Strukturlaşdırılmış və axın şəklində cavablar

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

package academy.study;

public record StudyAnswer(String explanation, String example) {
    public StudyAnswer {
        if (explanation == null || explanation.isBlank() || explanation.length() > 2000
                || example == null || example.isBlank() || example.length() > 1500) {
            throw new IllegalArgumentException("Invalid study answer fields");
        }
    }
}

package academy.study;

import java.util.ArrayList;
import java.util.concurrent.atomic.AtomicInteger;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.SystemMessage;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.converter.BeanOutputConverter;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Flux;

@Service
public class PromptResponseService {
    private final ChatClient chatClient;

    public PromptResponseService(ChatModel model) {
        this.chatClient = ChatClient.builder(model).build();
    }

    public StudyAnswer structured(String question, StudyPromptFactory.Language language) {
        var converter = new BeanOutputConverter<>(StudyAnswer.class);
        var base = StudyPromptFactory.create(question, language);
        var messages = new ArrayList<Message>(base.getInstructions());
        messages.add(1, new SystemMessage(converter.getFormat()));
        String raw = chatClient.prompt(new Prompt(messages)).call().content();
        if (AnswerChecks.check(raw) != AnswerChecks.Result.PASS) {
            throw new IllegalStateException("Invalid structured response length");
        }
        StudyAnswer answer = converter.convert(raw);
        if (answer == null) {
            throw new IllegalStateException("Missing structured answer");
        }
        return answer;
    }

    public Flux<String> stream(String question, StudyPromptFactory.Language language) {
        Prompt prompt = StudyPromptFactory.create(question, language);
        return Flux.defer(() -> {
            var used = new AtomicInteger();
            return chatClient.prompt(prompt).stream().content().<String>handle((chunk, sink) -> {
                int remaining = AnswerChecks.MAX_LENGTH - used.get();
                if (chunk.length() > remaining) {
                    sink.error(new IllegalStateException("Stream exceeded display limit"));
                } else {
                    used.addAndGet(chunk.length());
                    sink.next(chunk);
                }
            });
        });
    }
}

package academy.study;

import java.time.Duration;
import java.util.List;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.ai.chat.messages.AssistantMessage;
import org.springframework.ai.chat.model.ChatModel;
import org.springframework.ai.chat.model.ChatResponse;
import org.springframework.ai.chat.model.Generation;
import org.springframework.ai.chat.prompt.Prompt;
import reactor.core.publisher.Flux;

import static academy.study.StudyPromptFactory.Language.ENGLISH;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;

class PromptResponseServiceTest {
    private ChatModel model;
    private PromptResponseService service;
    private static final Duration WAIT = Duration.ofSeconds(3);

    @BeforeEach
    void setUp() {
        model = mock(ChatModel.class);
        service = new PromptResponseService(model);
    }

    private ChatResponse response(String text) {
        return new ChatResponse(List.of(new Generation(new AssistantMessage(text))));
    }

    @Test
    void convertsStructuredAnswerAndSendsFormatInstructions() {
        when(model.call(any(Prompt.class))).thenReturn(response("""
                {"explanation":"A class defines a type.","example":"class Sample {}"}
                """));
        var answer = service.structured("Explain classes", ENGLISH);
        assertEquals("class Sample {}", answer.example());
        var prompt = ArgumentCaptor.forClass(Prompt.class);
        verify(model).call(prompt.capture());
        String text = prompt.getValue().getContents();
        assertTrue(text.contains("explanation"));
        assertTrue(text.contains("example"));
    }

    @Test
    void rejectsMalformedAndIncompleteStructuredAnswers() {
        for (String raw : List.of("not JSON", "{}",
                "{\"explanation\":\"Valid text\",\"example\":\"\"}")) {
            when(model.call(any(Prompt.class))).thenReturn(response(raw));
            assertThrows(RuntimeException.class,
                    () -> service.structured("Explain classes", ENGLISH));
        }
    }

    @Test
    void rejectsOversizedStructuredTextBeforeConversion() {
        when(model.call(any(Prompt.class))).thenReturn(response("x".repeat(4001)));
        assertThrows(IllegalStateException.class,
                () -> service.structured("Explain classes", ENGLISH));
    }

    @Test
    void streamsFragmentsInOrder() {
        when(model.stream(any(Prompt.class))).thenReturn(
                Flux.just(response("class "), response("Sample {}")));
        var chunks = service.stream("Explain classes", ENGLISH).collectList().block(WAIT);
        assertEquals(List.of("class ", "Sample {}"), chunks);
        verify(model).stream(any(Prompt.class));
    }

    @Test
    void resetsDisplayBudgetForEachSubscription() {
        when(model.stream(any(Prompt.class))).thenReturn(
                Flux.just(response("x".repeat(2000)), response("y".repeat(2000))));
        var stream = service.stream("Explain classes", ENGLISH);
        for (int i = 0; i < 2; i++) {
            var chunks = stream.collectList().block(WAIT);
            assertNotNull(chunks);
            assertEquals(4000, String.join("", chunks).length());
        }
        verify(model, times(2)).stream(any(Prompt.class));
    }

    @Test
    void reportsOverflowInsteadOfCompletingSuccessfully() {
        when(model.stream(any(Prompt.class))).thenReturn(
                Flux.just(response("x".repeat(4000)), response("y")));
        assertThrows(IllegalStateException.class,
                () -> service.stream("Explain classes", ENGLISH).collectList().block(WAIT));
    }
}

env -u RUN_LIVE_EVALUATION mvn clean verify