änderungen von vorherigen Codexnutzung: sollte den Agent lassen die Aufgaben zu erzeugen

This commit is contained in:
Eugenius Naumenko
2026-09-22 16:14:41 +00:00
parent a7d8f72129
commit 74a4caa1c6
12 changed files with 457 additions and 239 deletions
+78 -51
View File
@@ -16,6 +16,7 @@ import (
)
type TeacherAgent interface {
NextExercise(ctx context.Context, input domain.GeneratedExerciseRequest) (domain.GeneratedExercise, error)
FeedbackForAttempt(ctx context.Context, targetText string, result domain.PronunciationResult, weakWords []domain.WordScore) (domain.TeacherResponse, error)
StartConversation(ctx context.Context, targetLanguage, cefrLevel string) (domain.TeacherResponse, error)
ContinueConversation(ctx context.Context, targetLanguage, cefrLevel, userText string) (domain.TeacherResponse, error)
@@ -37,59 +38,78 @@ func NewFlowiseTeacher(cfg config.Config, logger *slog.Logger) *FlowiseTeacher {
}
}
func (f *FlowiseTeacher) FeedbackForAttempt(ctx context.Context, targetText string, result domain.PronunciationResult, weakWords []domain.WordScore) (domain.TeacherResponse, error) {
prompt := map[string]any{
"task": "practice_feedback",
"target_text": targetText,
"recognized_text": result.RecognizedText,
"scores": result,
"weak_words": weakWords,
"rules": "Answer in German. A1 learner. Max two corrections. Return valid JSON only.",
func (f *FlowiseTeacher) NextExercise(ctx context.Context, input domain.GeneratedExerciseRequest) (domain.GeneratedExercise, error) {
fallback := domain.GeneratedExercise{
ID: "",
ExerciseType: "repeat_sentence",
TargetLanguage: valueOr(input.TargetLanguage, "en-US"),
CEFRLevel: valueOr(input.CEFRLevel, "A1"),
ReferenceText: "Hello, my name is Anna.",
DisplayPrompt: "Sprich den Satz klar nach.",
TTSText: "Hello, my name is Anna.",
FocusPoints: []string{"clear rhythm", "final sounds"},
SuccessCriteria: []string{"accuracy above 80"},
ReasonForChoice: "Fallback exercise because Flowise did not return a valid exercise.",
Source: "fallback",
}
return f.ask(ctx, prompt, mockFeedback(targetText, result))
payload := map[string]any{
"task": "next_exercise",
"user_id": input.UserID,
"target_language": input.TargetLanguage,
"cefr_level": input.CEFRLevel,
"ui_language": input.UILanguage,
"profile": input.Profile,
"progress": input.Progress,
"recent_weak_words": input.RecentWeakWords,
"preferred_type": valueOr(input.PreferredType, "repeat_sentence"),
"rules": "Generate one A1 English pronunciation exercise. Return valid JSON only with fields: exercise_type, target_language, cefr_level, reference_text, display_prompt, tts_text, focus_points, success_criteria, reason_for_choice.",
}
return f.askExercise(ctx, payload, input.SessionID, fallback)
}
func (f *FlowiseTeacher) FeedbackForAttempt(ctx context.Context, targetText string, result domain.PronunciationResult, weakWords []domain.WordScore) (domain.TeacherResponse, error) {
_ = ctx
_ = weakWords
return mockFeedback(targetText, result), nil
}
func (f *FlowiseTeacher) StartConversation(ctx context.Context, targetLanguage, cefrLevel string) (domain.TeacherResponse, error) {
prompt := map[string]any{
"task": "start_conversation",
"target_language": targetLanguage,
"cefr_level": cefrLevel,
"rules": "Create a simple A1 roleplay. Return valid JSON only.",
}
return f.ask(ctx, prompt, domain.TeacherResponse{
_ = ctx
_ = targetLanguage
_ = cefrLevel
return domain.TeacherResponse{
ExerciseType: "conversation",
TargetText: "Hello. What is your name?",
TeacherFeedback: "Wir starten sehr einfach. Antworte mit: My name is ...",
TTSText: "Hello. What is your name?",
NextRecommendation: "Antworten: My name is ...",
})
}, nil
}
func (f *FlowiseTeacher) ContinueConversation(ctx context.Context, targetLanguage, cefrLevel, userText string) (domain.TeacherResponse, error) {
prompt := map[string]any{
"task": "continue_conversation",
"target_language": targetLanguage,
"cefr_level": cefrLevel,
"user_text": userText,
"rules": "Continue a simple A1 conversation. Return valid JSON only.",
}
return f.ask(ctx, prompt, domain.TeacherResponse{
_ = ctx
_ = targetLanguage
_ = cefrLevel
_ = userText
return domain.TeacherResponse{
ExerciseType: "conversation",
TargetText: "Nice to meet you. Where are you from?",
TeacherFeedback: "Gut. Jetzt uebe einen kurzen Satz mit Herkunft.",
TTSText: "Nice to meet you. Where are you from?",
NextRecommendation: "Antworten: I am from ...",
})
}, nil
}
func (f *FlowiseTeacher) ask(ctx context.Context, payload any, fallback domain.TeacherResponse) (domain.TeacherResponse, error) {
func (f *FlowiseTeacher) askExercise(ctx context.Context, payload any, sessionID string, fallback domain.GeneratedExercise) (domain.GeneratedExercise, error) {
if f.cfg.FlowiseChatflow == "" || f.cfg.FlowiseBaseURL == "" {
return fallback, nil
}
body, _ := json.Marshal(payload)
question := string(body)
reqBody, _ := json.Marshal(map[string]any{
"question": question,
"question": string(body),
"overrideConfig": map[string]any{
"sessionId": sessionID,
},
})
endpoint := strings.TrimRight(f.cfg.FlowiseBaseURL, "/") + "/api/v1/prediction/" + f.cfg.FlowiseChatflow
@@ -104,7 +124,7 @@ func (f *FlowiseTeacher) ask(ctx context.Context, payload any, fallback domain.T
resp, err := f.client.Do(req)
if err != nil {
f.logger.Warn("flowise unavailable, using fallback", "error", err)
f.logger.Warn("flowise exercise generation unavailable, using fallback", "error", err)
return fallback, nil
}
defer resp.Body.Close()
@@ -113,56 +133,63 @@ func (f *FlowiseTeacher) ask(ctx context.Context, payload any, fallback domain.T
return fallback, err
}
if resp.StatusCode >= 300 {
f.logger.Warn("flowise returned error, using fallback", "status", resp.StatusCode, "body", string(respBody))
f.logger.Warn("flowise exercise generation returned error, using fallback", "status", resp.StatusCode, "body", string(respBody))
return fallback, nil
}
if exercise, ok := parseGeneratedExerciseEnvelope(respBody); ok {
exercise.TargetLanguage = valueOr(exercise.TargetLanguage, fallback.TargetLanguage)
exercise.CEFRLevel = valueOr(exercise.CEFRLevel, fallback.CEFRLevel)
exercise.ExerciseType = valueOr(exercise.ExerciseType, fallback.ExerciseType)
exercise.DisplayPrompt = valueOr(exercise.DisplayPrompt, fallback.DisplayPrompt)
exercise.TTSText = valueOr(exercise.TTSText, exercise.ReferenceText)
exercise.Source = "flowise"
return exercise, nil
}
f.logger.Warn("flowise exercise response not parseable, using fallback", "body", string(respBody))
return fallback, nil
}
func parseGeneratedExerciseEnvelope(body []byte) (domain.GeneratedExercise, bool) {
var envelope struct {
Text string `json:"text"`
JSON json.RawMessage `json:"json"`
}
if err := json.Unmarshal(respBody, &envelope); err == nil {
if err := json.Unmarshal(body, &envelope); err == nil {
if envelope.Text != "" {
if parsed, ok := parseTeacherResponse(envelope.Text); ok {
return parsed, nil
if parsed, ok := parseGeneratedExercise(envelope.Text); ok {
return parsed, true
}
fallback.TeacherFeedback = envelope.Text
return fallback, nil
}
if len(envelope.JSON) > 0 && string(envelope.JSON) != "null" {
if parsed, ok := parseTeacherResponseJSON(envelope.JSON); ok {
return parsed, nil
if parsed, ok := parseGeneratedExerciseJSON(envelope.JSON); ok {
return parsed, true
}
}
}
if parsed, ok := parseTeacherResponse(string(respBody)); ok {
return parsed, nil
}
f.logger.Warn("flowise response not parseable, using fallback", "body", string(respBody))
return fallback, nil
return parseGeneratedExercise(string(body))
}
func parseTeacherResponse(value string) (domain.TeacherResponse, bool) {
func parseGeneratedExercise(value string) (domain.GeneratedExercise, bool) {
value = strings.TrimSpace(value)
value = strings.TrimPrefix(value, "```json")
value = strings.TrimPrefix(value, "```")
value = strings.TrimSuffix(value, "```")
var out domain.TeacherResponse
var out domain.GeneratedExercise
if err := json.Unmarshal([]byte(strings.TrimSpace(value)), &out); err != nil {
return domain.TeacherResponse{}, false
return domain.GeneratedExercise{}, false
}
return out, out.TeacherFeedback != "" || out.TargetText != "" || out.TTSText != ""
return out, strings.TrimSpace(out.ReferenceText) != ""
}
func parseTeacherResponseJSON(value json.RawMessage) (domain.TeacherResponse, bool) {
if parsed, ok := parseTeacherResponse(string(value)); ok {
func parseGeneratedExerciseJSON(value json.RawMessage) (domain.GeneratedExercise, bool) {
if parsed, ok := parseGeneratedExercise(string(value)); ok {
return parsed, true
}
var text string
if err := json.Unmarshal(value, &text); err != nil {
return domain.TeacherResponse{}, false
return domain.GeneratedExercise{}, false
}
return parseTeacherResponse(text)
return parseGeneratedExercise(text)
}
func mockFeedback(targetText string, result domain.PronunciationResult) domain.TeacherResponse {
+60 -67
View File
@@ -13,73 +13,27 @@ import (
"speech-learning-api/internal/domain"
)
func TestParseTeacherResponse(t *testing.T) {
response, ok := parseTeacherResponse(`{
"exercise_type": "repeat_sentence",
"target_text": "Hello.",
"teacher_feedback": "Gut.",
"tts_text": "Hello.",
"ssml": "",
"next_recommendation": "Noch einmal."
}`)
if !ok {
t.Fatal("expected response to parse")
}
if response.TargetText != "Hello." {
t.Fatalf("unexpected target text %q", response.TargetText)
}
}
func TestParseTeacherResponseJSONFromObject(t *testing.T) {
response, ok := parseTeacherResponseJSON(json.RawMessage(`{
"exercise_type": "repeat_sentence",
"target_text": "Hello.",
"teacher_feedback": "Gut.",
"tts_text": "Hello.",
"ssml": "",
"next_recommendation": "Noch einmal."
}`))
if !ok {
t.Fatal("expected response to parse")
}
if response.TeacherFeedback != "Gut." {
t.Fatalf("unexpected feedback %q", response.TeacherFeedback)
}
}
func TestParseTeacherResponseJSONFromString(t *testing.T) {
response, ok := parseTeacherResponseJSON(json.RawMessage(`"{\"exercise_type\":\"repeat_sentence\",\"target_text\":\"Hello.\",\"teacher_feedback\":\"Gut.\",\"tts_text\":\"Hello.\",\"ssml\":\"\",\"next_recommendation\":\"Noch einmal.\"}"`))
if !ok {
t.Fatal("expected response to parse")
}
if response.NextRecommendation != "Noch einmal." {
t.Fatalf("unexpected recommendation %q", response.NextRecommendation)
}
}
func TestFlowiseAskSendsQuestionOnly(t *testing.T) {
func TestFlowiseNextExerciseSendsSessionAndParsesResponse(t *testing.T) {
var requestBody map[string]json.RawMessage
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/api/v1/prediction/chatflow-id" {
t.Fatalf("unexpected path %q", r.URL.Path)
}
if r.Header.Get("Authorization") != "Bearer api-key" {
t.Fatalf("unexpected authorization header %q", r.Header.Get("Authorization"))
}
if err := json.NewDecoder(r.Body).Decode(&requestBody); err != nil {
t.Fatalf("decode request body: %v", err)
}
response := domain.TeacherResponse{
ExerciseType: "conversation",
TargetText: "Hello.",
TeacherFeedback: "Gut.",
TTSText: "Hello.",
NextRecommendation: "Noch einmal.",
response := domain.GeneratedExercise{
ExerciseType: "repeat_sentence",
TargetLanguage: "en-US",
CEFRLevel: "A1",
ReferenceText: "I live in Berlin.",
DisplayPrompt: "Sprich den Satz klar nach.",
TTSText: "I live in Berlin.",
FocusPoints: []string{"live"},
SuccessCriteria: []string{"accuracy above 80"},
ReasonForChoice: "Uebt einen kurzen A1-Satz.",
}
responseText, err := json.Marshal(response)
if err != nil {
@@ -94,22 +48,61 @@ func TestFlowiseAskSendsQuestionOnly(t *testing.T) {
teacher := NewFlowiseTeacher(config.Config{
FlowiseBaseURL: server.URL,
FlowiseChatflow: "chatflow-id",
FlowiseAPIKey: "api-key",
}, slog.New(slog.NewTextHandler(io.Discard, nil)))
response, err := teacher.ask(context.Background(), map[string]any{"task": "start_conversation"}, domain.TeacherResponse{
TeacherFeedback: "fallback",
exercise, err := teacher.NextExercise(context.Background(), domain.GeneratedExerciseRequest{
UserID: "usr_1",
TargetLanguage: "en-US",
CEFRLevel: "A1",
SessionID: "usr_1:en-US:practice",
})
if err != nil {
t.Fatalf("ask: %v", err)
t.Fatalf("NextExercise: %v", err)
}
if response.TeacherFeedback != "Gut." {
t.Fatalf("unexpected feedback %q", response.TeacherFeedback)
if exercise.ReferenceText != "I live in Berlin." {
t.Fatalf("unexpected reference text %q", exercise.ReferenceText)
}
if _, ok := requestBody["question"]; !ok {
t.Fatal("expected question in request body")
if exercise.Source != "flowise" {
t.Fatalf("unexpected source %q", exercise.Source)
}
if _, ok := requestBody["form"]; ok {
t.Fatal("did not expect form in request body")
var override struct {
SessionID string `json:"sessionId"`
}
if err := json.Unmarshal(requestBody["overrideConfig"], &override); err != nil {
t.Fatalf("decode overrideConfig: %v", err)
}
if override.SessionID != "usr_1:en-US:practice" {
t.Fatalf("unexpected sessionId %q", override.SessionID)
}
var question map[string]any
if err := json.Unmarshal(requestBody["question"], &question); err == nil {
t.Fatalf("expected question to be a JSON string, got object %#v", question)
}
var questionText string
if err := json.Unmarshal(requestBody["question"], &questionText); err != nil {
t.Fatalf("decode question text: %v", err)
}
if err := json.Unmarshal([]byte(questionText), &question); err != nil {
t.Fatalf("decode question payload: %v", err)
}
if question["task"] != "next_exercise" {
t.Fatalf("unexpected task %#v", question["task"])
}
}
func TestParseGeneratedExerciseEnvelope(t *testing.T) {
body := []byte(`{"text":"{\"exercise_type\":\"repeat_sentence\",\"target_language\":\"en-US\",\"cefr_level\":\"A1\",\"reference_text\":\"I live in Berlin.\",\"display_prompt\":\"Sprich den Satz klar nach.\",\"tts_text\":\"I live in Berlin.\",\"focus_points\":[\"live\"],\"success_criteria\":[\"accuracy above 80\"],\"reason_for_choice\":\"Practise /l/.\"}"}`)
exercise, ok := parseGeneratedExerciseEnvelope(body)
if !ok {
t.Fatal("expected generated exercise to parse")
}
if exercise.ReferenceText != "I live in Berlin." {
t.Fatalf("unexpected reference text %q", exercise.ReferenceText)
}
if len(exercise.FocusPoints) != 1 || exercise.FocusPoints[0] != "live" {
t.Fatalf("unexpected focus points %#v", exercise.FocusPoints)
}
}