188 lines
6.2 KiB
Go
188 lines
6.2 KiB
Go
package services
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"log/slog"
|
|
"net/http"
|
|
"strings"
|
|
"time"
|
|
|
|
"speech-learning-api/internal/config"
|
|
"speech-learning-api/internal/domain"
|
|
)
|
|
|
|
type TeacherAgent interface {
|
|
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)
|
|
}
|
|
|
|
type FlowiseTeacher struct {
|
|
cfg config.Config
|
|
client *http.Client
|
|
logger *slog.Logger
|
|
}
|
|
|
|
func NewFlowiseTeacher(cfg config.Config, logger *slog.Logger) *FlowiseTeacher {
|
|
return &FlowiseTeacher{
|
|
cfg: cfg,
|
|
client: &http.Client{
|
|
Timeout: 30 * time.Second,
|
|
},
|
|
logger: logger,
|
|
}
|
|
}
|
|
|
|
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.",
|
|
}
|
|
return f.ask(ctx, prompt, mockFeedback(targetText, result))
|
|
}
|
|
|
|
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{
|
|
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 ...",
|
|
})
|
|
}
|
|
|
|
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{
|
|
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 ...",
|
|
})
|
|
}
|
|
|
|
func (f *FlowiseTeacher) ask(ctx context.Context, payload any, fallback domain.TeacherResponse) (domain.TeacherResponse, 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,
|
|
})
|
|
endpoint := strings.TrimRight(f.cfg.FlowiseBaseURL, "/") + "/api/v1/prediction/" + f.cfg.FlowiseChatflow
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(reqBody))
|
|
if err != nil {
|
|
return fallback, err
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
if f.cfg.FlowiseAPIKey != "" {
|
|
req.Header.Set("Authorization", "Bearer "+f.cfg.FlowiseAPIKey)
|
|
}
|
|
|
|
resp, err := f.client.Do(req)
|
|
if err != nil {
|
|
f.logger.Warn("flowise unavailable, using fallback", "error", err)
|
|
return fallback, nil
|
|
}
|
|
defer resp.Body.Close()
|
|
respBody, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return fallback, err
|
|
}
|
|
if resp.StatusCode >= 300 {
|
|
f.logger.Warn("flowise returned error, using fallback", "status", resp.StatusCode, "body", string(respBody))
|
|
return fallback, nil
|
|
}
|
|
|
|
var envelope struct {
|
|
Text string `json:"text"`
|
|
JSON json.RawMessage `json:"json"`
|
|
}
|
|
if err := json.Unmarshal(respBody, &envelope); err == nil {
|
|
if envelope.Text != "" {
|
|
if parsed, ok := parseTeacherResponse(envelope.Text); ok {
|
|
return parsed, nil
|
|
}
|
|
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 := parseTeacherResponse(string(respBody)); ok {
|
|
return parsed, nil
|
|
}
|
|
f.logger.Warn("flowise response not parseable, using fallback", "body", string(respBody))
|
|
return fallback, nil
|
|
}
|
|
|
|
func parseTeacherResponse(value string) (domain.TeacherResponse, bool) {
|
|
value = strings.TrimSpace(value)
|
|
value = strings.TrimPrefix(value, "```json")
|
|
value = strings.TrimPrefix(value, "```")
|
|
value = strings.TrimSuffix(value, "```")
|
|
var out domain.TeacherResponse
|
|
if err := json.Unmarshal([]byte(strings.TrimSpace(value)), &out); err != nil {
|
|
return domain.TeacherResponse{}, false
|
|
}
|
|
return out, out.TeacherFeedback != "" || out.TargetText != "" || out.TTSText != ""
|
|
}
|
|
|
|
func parseTeacherResponseJSON(value json.RawMessage) (domain.TeacherResponse, bool) {
|
|
if parsed, ok := parseTeacherResponse(string(value)); ok {
|
|
return parsed, true
|
|
}
|
|
var text string
|
|
if err := json.Unmarshal(value, &text); err != nil {
|
|
return domain.TeacherResponse{}, false
|
|
}
|
|
return parseTeacherResponse(text)
|
|
}
|
|
|
|
func mockFeedback(targetText string, result domain.PronunciationResult) domain.TeacherResponse {
|
|
weak := "den roten Woertern"
|
|
for _, word := range result.WordScores {
|
|
if word.Highlight == "weak" {
|
|
weak = fmt.Sprintf("'%s'", word.Word)
|
|
break
|
|
}
|
|
}
|
|
feedback := fmt.Sprintf("Guter Versuch. Uebe jetzt besonders %s. Sprich langsam und halte die Endlaute klar.", weak)
|
|
if result.OverallScore >= 85 {
|
|
feedback = "Sehr solide. Wiederhole den Satz einmal etwas natuerlicher und mit ruhigem Rhythmus."
|
|
}
|
|
return domain.TeacherResponse{
|
|
ExerciseType: "repeat_sentence",
|
|
TargetText: targetText,
|
|
TeacherFeedback: feedback,
|
|
TTSText: targetText,
|
|
NextRecommendation: "Noch einmal sprechen und auf die markierten Woerter achten.",
|
|
}
|
|
}
|