Adaptiven A1-Kurs und statistisches Aussprachetraining integrieren

Direkte DeepSeek- und Mistral-Anbindung mit versionierten Aktionsprofilen,
Budgetreservierung, Tokenabrechnung und administrativen Qualitätsprüfungen
ersetzen die Flowise-Abhängigkeit im regulären Betrieb.

840 geprüfte A1-Aufgaben mit geschützter Testauswertung und konkreten offenen
Arbeitsaufträgen ergänzen den Kurs. Inhalts- und Sprachbewertung bleiben von
Azure-Aussprachewerten getrennt; historische Aufgaben und Antworten bleiben erhalten.

Echte Wort- und Phonemmessungen werden mit Herkunft, Aktualität und Nachweisdichte
gebündelt. Go bestimmt Trainingsziele und Wiederholungen, das Modell formuliert
dazu passende Nachsprechübungen. Profilansicht und Auswahlgründe werden angezeigt.

Validierung: Go-Race-Tests mit lokaler PostgreSQL-Integration, go vet,
Web-Build, Audit aller 840 Aufgaben und drei Browser-Smokes mit lokalen
Modell-/Speech-Fixtures bestanden. Keine Produktionsänderungen oder Live-Aufrufe.
This commit is contained in:
Eugenius Naumenko
2026-11-01 23:23:20 +00:00
parent 83944f791e
commit e274eaab2b
186 changed files with 46676 additions and 257 deletions
+668
View File
@@ -0,0 +1,668 @@
package httpapi
import (
"context"
"encoding/binary"
"encoding/json"
"errors"
"io"
"net/http"
"strconv"
"strings"
"time"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/services"
"speech-learning-api/internal/store"
)
func (s *Server) SetCourseEngine(engine *services.CourseEngine) { s.course = engine }
func (s *Server) adaptiveProfile(w http.ResponseWriter, r *http.Request) (domain.LearnerProfile, bool) {
if s.course == nil {
writeError(w, http.StatusServiceUnavailable, errors.New("course engine unavailable"))
return domain.LearnerProfile{}, false
}
p, err := s.courseProfile(r)
if err != nil {
writeError(w, http.StatusNotFound, err)
return p, false
}
if p.CEFRLevel != "A1" {
writeError(w, http.StatusBadRequest, errors.New("the adaptive course is available at A1"))
return p, false
}
return p, true
}
func adaptiveError(w http.ResponseWriter, err error) {
status := http.StatusInternalServerError
if errors.Is(err, store.ErrNotFound) {
status = http.StatusNotFound
}
if errors.Is(err, store.ErrCourseConflict) {
status = http.StatusConflict
}
if status == 500 {
writeError(w, status, errors.New("Der Kursvorgang konnte nicht gespeichert oder geladen werden."))
} else {
writeError(w, status, err)
}
}
func adaptiveJSON(w http.ResponseWriter, r *http.Request, out any) bool {
r.Body = http.MaxBytesReader(w, r.Body, 32768)
defer r.Body.Close()
decoder := json.NewDecoder(r.Body)
decoder.DisallowUnknownFields()
if err := decoder.Decode(out); err != nil {
writeError(w, 400, errors.New("invalid course request"))
return false
}
if decoder.Decode(new(any)) != io.EOF {
writeError(w, 400, errors.New("trailing request content"))
return false
}
return true
}
func (s *Server) adaptiveCatalog(w http.ResponseWriter, r *http.Request) {
p, ok := s.adaptiveProfile(w, r)
if !ok {
return
}
user, err := s.store.GetUser(r.Context(), currentUserID(r))
if err != nil {
adaptiveError(w, err)
return
}
snap, err := s.course.Repo.Snapshot(r.Context(), user.ID, p.TargetLanguage, user.UILanguage)
if err != nil {
adaptiveError(w, err)
return
}
languages, err := s.store.ListLanguages(r.Context())
if err != nil {
adaptiveError(w, err)
return
}
available := []string{}
for _, l := range languages {
modules, err := s.course.Repo.Modules(r.Context(), l.Code)
if err != nil {
adaptiveError(w, err)
return
}
if len(modules) == 7 {
available = append(available, l.Code)
}
}
exams, err := s.course.Repo.Exams(r.Context(), user.ID, p.TargetLanguage)
if err != nil {
adaptiveError(w, err)
return
}
analysisJob, err := s.course.Repo.LatestAnalysisJob(r.Context(), user.ID, p.TargetLanguage)
if err != nil {
adaptiveError(w, err)
return
}
if s.course.Mode == "bank" {
snap.PreviousAnalysis = nil
analysisJob = nil
}
inventory, err := s.course.Repo.BankInventory(r.Context(), user.ID, p.TargetLanguage)
if err != nil {
adaptiveError(w, err)
return
}
writeJSON(w, 200, map[string]any{"task_mode": s.course.Mode, "grading_available": s.course.EvaluationAvailable(r.Context()), "bank": inventory, "analysis_job": analysisJob, "profile": p, "modules": snap.Modules, "progress": snap.Progress, "analysis": snap.PreviousAnalysis, "facts_version": snap.FactsVersion, "enabled_languages": available, "languages": languages, "exams": exams})
}
func (s *Server) adaptiveNext(w http.ResponseWriter, r *http.Request) {
p, ok := s.adaptiveProfile(w, r)
if !ok {
return
}
var input struct {
RequestID string `json:"request_id"`
Skill string `json:"skill"`
}
if !adaptiveJSON(w, r, &input) {
return
}
if !courseRequestIDPattern.MatchString(input.RequestID) || !validCourseSkill(input.Skill) {
writeError(w, 400, errors.New("invalid request ID or skill"))
return
}
if _, err := s.course.Repo.Module(r.Context(), p.TargetLanguage, r.PathValue("id")); err != nil {
adaptiveError(w, err)
return
}
j, err := s.course.Repo.Enqueue(r.Context(), currentUserID(r), p.TargetLanguage, "next", r.PathValue("id"), input.Skill, "", input.RequestID)
if err != nil {
adaptiveError(w, err)
return
}
writeJSON(w, 202, j)
}
func validCourseSkill(skill string) bool {
if skill == "" {
return true
}
for _, s := range domain.CourseSkills {
if s == skill {
return true
}
}
return false
}
func (s *Server) adaptiveHistory(w http.ResponseWriter, r *http.Request) {
p, ok := s.adaptiveProfile(w, r)
if !ok {
return
}
if _, err := s.course.Repo.Module(r.Context(), p.TargetLanguage, r.PathValue("id")); err != nil {
adaptiveError(w, err)
return
}
offset := 0
if value := r.URL.Query().Get("offset"); value != "" {
n, err := strconv.Atoi(value)
if err != nil || n < 0 {
writeError(w, 400, errors.New("invalid history offset"))
return
}
offset = n
}
tasks, err := s.course.Repo.History(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"), offset)
if err != nil {
adaptiveError(w, err)
return
}
writeJSON(w, 200, map[string]any{"tasks": tasks, "offset": offset, "has_more": len(tasks) == 25})
}
func (s *Server) adaptiveJob(w http.ResponseWriter, r *http.Request) {
p, ok := s.adaptiveProfile(w, r)
if !ok {
return
}
j, err := s.course.Repo.Job(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
if err != nil {
adaptiveError(w, err)
return
}
writeJSON(w, 200, j)
}
func (s *Server) adaptiveRetryJob(w http.ResponseWriter, r *http.Request) {
p, ok := s.adaptiveProfile(w, r)
if !ok {
return
}
if s.course.Mode == "bank" {
existing, err := s.course.Repo.Job(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
if err != nil {
adaptiveError(w, err)
return
}
if existing.Kind == "evaluate" && !s.course.EvaluationAvailable(r.Context()) {
writeError(w, 409, errors.New("KI-Bewertung derzeit nicht verfügbar. Die Antwort bleibt gespeichert."))
return
}
}
j, err := s.course.Repo.RetryJob(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
if err != nil {
adaptiveError(w, err)
return
}
writeJSON(w, 202, j)
}
func (s *Server) adaptiveTask(w http.ResponseWriter, r *http.Request) {
p, ok := s.adaptiveProfile(w, r)
if !ok {
return
}
user := currentUserID(r)
task, err := s.course.Repo.Task(r.Context(), user, p.TargetLanguage, r.PathValue("id"))
if err != nil {
adaptiveError(w, err)
return
}
latest, err := s.course.Repo.LatestTaskAttempt(r.Context(), user, p.TargetLanguage, task.ID)
if err != nil {
adaptiveError(w, err)
return
}
reveal := latest != nil && (latest.Status == "graded" || latest.Status == "ungraded")
if task.ExamID != "" {
exam, err := s.course.Repo.Exam(r.Context(), user, p.TargetLanguage, task.ExamID)
if err != nil {
adaptiveError(w, err)
return
}
reveal = exam.Status == "completed"
}
if latest != nil {
value, err := s.course.PublicAttempt(r.Context(), user, p.TargetLanguage, *latest)
if err != nil {
adaptiveError(w, err)
return
}
latest = &value
}
writeJSON(w, 200, map[string]any{"task": task.Public(reveal), "attempt": latest})
}
func (s *Server) adaptiveAttempt(w http.ResponseWriter, r *http.Request) {
p, ok := s.adaptiveProfile(w, r)
if !ok {
return
}
var input struct {
RequestID string `json:"request_id"`
Answer string `json:"answer"`
}
if !adaptiveJSON(w, r, &input) {
return
}
legacyResponse := input.RequestID == ""
answer := strings.TrimSpace(input.Answer)
if input.RequestID == "" {
input.RequestID = newRequestID()
}
if !courseRequestIDPattern.MatchString(input.RequestID) || answer == "" || len([]rune(answer)) > 10000 {
writeError(w, 400, errors.New("answer and request ID are required; maximum 10000 characters"))
return
}
task, err := s.course.Repo.Task(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
if err != nil {
adaptiveError(w, err)
return
}
if task.Kind == "repeat_sentence" || task.Kind == "free_speech" {
writeError(w, 400, errors.New("this task requires an audio recording"))
return
}
if task.Kind == "choice" {
valid := false
for _, option := range task.Options {
if answer == option.ID || answer == option.Label {
valid = true
break
}
}
if !valid {
writeError(w, 400, errors.New("Bitte eine der angebotenen Antworten wählen."))
return
}
}
attempt, job, err := s.course.Submit(r.Context(), currentUserID(r), p.TargetLanguage, task.ID, input.RequestID, answer, nil)
if err != nil {
adaptiveError(w, err)
return
}
public, err := s.course.PublicAttempt(r.Context(), currentUserID(r), p.TargetLanguage, attempt)
if err != nil {
adaptiveError(w, err)
return
}
status := 201
if job != nil {
status = 202
}
if legacyResponse && task.ExamID == "" && public.Evaluation != nil {
solution := task.AnswerKey.ReferenceAnswer
for _, option := range task.Options {
if option.ID == task.AnswerKey.CorrectOptionID {
solution = option.Label
}
}
writeJSON(w, 201, domain.CourseAttemptResult{ID: public.ID, TaskID: task.ID, Correct: public.Evaluation.Verdict == "correct", Solution: solution, Explanation: public.Evaluation.Feedback, Transcript: task.AudioText})
return
}
writeJSON(w, status, map[string]any{"attempt": public, "job": job})
}
func (s *Server) adaptiveGetAttempt(w http.ResponseWriter, r *http.Request) {
p, ok := s.adaptiveProfile(w, r)
if !ok {
return
}
a, err := s.course.Repo.Attempt(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
if err != nil {
adaptiveError(w, err)
return
}
a, err = s.course.PublicAttempt(r.Context(), currentUserID(r), p.TargetLanguage, a)
if err != nil {
adaptiveError(w, err)
return
}
writeJSON(w, 200, a)
}
func (s *Server) adaptiveRetryAttempt(w http.ResponseWriter, r *http.Request) {
p, ok := s.adaptiveProfile(w, r)
if !ok {
return
}
if s.course.Mode == "bank" && !s.course.EvaluationAvailable(r.Context()) {
writeError(w, 409, errors.New("KI-Bewertung derzeit nicht verfügbar. Die Antwort bleibt gespeichert."))
return
}
j, err := s.course.Repo.RetryEvaluation(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
if err != nil {
adaptiveError(w, err)
return
}
writeJSON(w, 202, j)
}
func (s *Server) adaptiveAudio(w http.ResponseWriter, r *http.Request) {
p, ok := s.adaptiveProfile(w, r)
if !ok {
return
}
t, err := s.course.Repo.Task(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
if err != nil {
adaptiveError(w, err)
return
}
text := t.AudioText
if t.Kind == "repeat_sentence" {
text = t.ReferenceText
}
if text == "" {
writeError(w, 404, store.ErrNotFound)
return
}
lang, err := s.store.GetLanguage(r.Context(), p.TargetLanguage)
if err != nil {
adaptiveError(w, err)
return
}
if lang.AzureLocale == "" || lang.DefaultTTSVoice == "" {
writeError(w, 503, errors.New("speech is not configured for this language"))
return
}
audio, mime, err := s.speech.Synthesize(r.Context(), lang.AzureLocale, lang.DefaultTTSVoice, text)
if err != nil || len(audio) == 0 {
writeError(w, 503, errors.New("Audio ist momentan nicht verfügbar."))
return
}
w.Header().Set("Content-Type", mime)
w.Header().Set("Cache-Control", "private, no-store")
w.WriteHeader(200)
_, _ = w.Write(audio)
}
// Parse the actual PCM header and frame count. A file extension or claimed
// MIME type alone cannot establish the sample rate or the 30-second limit.
func validCourseWAV(audio []byte) bool {
if len(audio) < 44 || string(audio[:4]) != "RIFF" || string(audio[8:12]) != "WAVE" {
return false
}
validFormat := false
dataSize := 0
for pos := 12; pos+8 <= len(audio); {
size := int(binary.LittleEndian.Uint32(audio[pos+4 : pos+8]))
start := pos + 8
if size < 0 || size > len(audio)-start {
return false
}
switch string(audio[pos : pos+4]) {
case "fmt ":
if size < 16 {
return false
}
validFormat = binary.LittleEndian.Uint16(audio[start:start+2]) == 1 && binary.LittleEndian.Uint16(audio[start+2:start+4]) == 1 && binary.LittleEndian.Uint32(audio[start+4:start+8]) == 16000 && binary.LittleEndian.Uint16(audio[start+14:start+16]) == 16 && binary.LittleEndian.Uint32(audio[start+8:start+12]) == 32000 && binary.LittleEndian.Uint16(audio[start+12:start+14]) == 2
case "data":
dataSize += size
}
pos = start + size + size%2
}
return validFormat && dataSize > 0 && dataSize <= 16000*2*30 && dataSize%2 == 0
}
func (s *Server) adaptiveAudioAttempt(w http.ResponseWriter, r *http.Request) {
p, ok := s.adaptiveProfile(w, r)
if !ok {
return
}
t, err := s.course.Repo.Task(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
if err != nil {
adaptiveError(w, err)
return
}
if t.Kind != "repeat_sentence" && t.Kind != "free_speech" {
writeError(w, 400, errors.New("this task does not accept audio"))
return
}
r.Body = http.MaxBytesReader(w, r.Body, 2<<20)
if err = r.ParseMultipartForm(2 << 20); err != nil {
writeError(w, 400, errors.New("invalid audio upload"))
return
}
if r.MultipartForm != nil {
defer r.MultipartForm.RemoveAll()
}
requestID := r.FormValue("request_id")
if !courseRequestIDPattern.MatchString(requestID) {
writeError(w, 400, errors.New("request_id is required"))
return
}
if old, err := s.course.Repo.AttemptByRequest(r.Context(), currentUserID(r), p.TargetLanguage, requestID); err == nil {
if old.TaskID != t.ID {
writeError(w, 400, errors.New("request belongs to another task"))
return
}
a, err := s.course.PublicAttempt(r.Context(), currentUserID(r), p.TargetLanguage, old)
if err != nil {
adaptiveError(w, err)
return
}
writeJSON(w, 200, map[string]any{"attempt": a})
return
} else if !errors.Is(err, store.ErrNotFound) {
adaptiveError(w, err)
return
}
file, _, err := r.FormFile("audio")
if err != nil {
writeError(w, 400, errors.New("audio is required"))
return
}
defer file.Close()
audio, err := io.ReadAll(io.LimitReader(file, (1<<20)+1))
if err != nil || !validCourseWAV(audio) {
writeError(w, 400, errors.New("Bitte eine WAV-Aufnahme mit 16 kHz, mono, maximal 30 Sekunden senden."))
return
}
lang, err := s.store.GetLanguage(r.Context(), p.TargetLanguage)
if err != nil {
adaptiveError(w, err)
return
}
if lang.AzureLocale == "" {
writeError(w, 503, errors.New("speech locale unavailable"))
return
}
ctx, cancel := context.WithTimeout(r.Context(), 50*time.Second)
defer cancel()
transcript := t.ReferenceText
if t.Kind == "free_speech" {
transcriber, ok := s.speech.(interface {
Transcribe(context.Context, []byte, string, string) (string, error)
})
if !ok {
writeError(w, 503, errors.New("free speech is unavailable"))
return
}
transcript, err = transcriber.Transcribe(ctx, audio, "audio/wav", lang.AzureLocale)
if err != nil {
writeError(w, 503, errors.New("Die Aufnahme konnte nicht transkribiert werden. Bitte erneut senden."))
return
}
}
var speech *domain.PronunciationResult
if lang.SupportsPronunciationAssessment {
result, err := s.speech.AssessPronunciation(ctx, services.PronunciationInput{Audio: audio, ContentType: "audio/wav", TargetText: transcript, Locale: lang.AzureLocale})
if err != nil {
writeError(w, 503, errors.New("Die Sprachmessung ist fehlgeschlagen. Die Aufnahme kann erneut gesendet werden."))
return
}
if t.Kind == "free_speech" {
result.Method = "unscripted"
result.CompletenessScore = 0
result.RecognizedText = transcript
}
if result.Provider != "azure" {
writeError(w, 503, errors.New("Für Kursaufnahmen ist eine echte Azure-Sprachmessung erforderlich."))
return
}
speech = &result
} else if t.Kind == "repeat_sentence" {
transcriber, ok := s.speech.(interface {
Transcribe(context.Context, []byte, string, string) (string, error)
})
if !ok {
writeError(w, 503, errors.New("speech is unavailable"))
return
}
transcript, err = transcriber.Transcribe(ctx, audio, "audio/wav", lang.AzureLocale)
if err != nil {
writeError(w, 503, errors.New("Die Aufnahme konnte nicht transkribiert werden."))
return
}
}
answer := transcript
if speech != nil && t.Kind == "repeat_sentence" {
answer = speech.RecognizedText
}
if strings.TrimSpace(answer) == "" {
writeError(w, 400, errors.New("no speech recognized"))
return
}
a, job, err := s.course.Submit(r.Context(), currentUserID(r), p.TargetLanguage, t.ID, requestID, answer, speech)
if err != nil {
adaptiveError(w, err)
return
}
a, err = s.course.PublicAttempt(r.Context(), currentUserID(r), p.TargetLanguage, a)
if err != nil {
adaptiveError(w, err)
return
}
writeJSON(w, 202, map[string]any{"attempt": a, "job": job})
}
func (s *Server) adaptiveNewExam(w http.ResponseWriter, r *http.Request) {
p, ok := s.adaptiveProfile(w, r)
if !ok {
return
}
var input struct {
RequestID string `json:"request_id"`
}
if !adaptiveJSON(w, r, &input) {
return
}
if !courseRequestIDPattern.MatchString(input.RequestID) {
writeError(w, 400, errors.New("request_id is required"))
return
}
mods, err := s.course.Repo.Modules(r.Context(), p.TargetLanguage)
if err != nil {
adaptiveError(w, err)
return
}
if len(mods) != 7 {
writeError(w, 404, store.ErrNotFound)
return
}
exam, err := s.course.Repo.NewExam(r.Context(), currentUserID(r), p.TargetLanguage, input.RequestID)
if err != nil {
adaptiveError(w, err)
return
}
job, err := s.course.Repo.Enqueue(r.Context(), currentUserID(r), p.TargetLanguage, "exam", mods[6].ID, "", exam.ID, "exam:"+exam.ID)
if err != nil {
adaptiveError(w, err)
return
}
writeJSON(w, 202, map[string]any{"exam": exam, "job": job})
}
func (s *Server) adaptiveExam(w http.ResponseWriter, r *http.Request) {
p, ok := s.adaptiveProfile(w, r)
if !ok {
return
}
exam, err := s.course.Repo.Exam(r.Context(), currentUserID(r), p.TargetLanguage, r.PathValue("id"))
if err != nil {
adaptiveError(w, err)
return
}
writeJSON(w, 200, exam)
}
// The compatibility endpoint retains its synchronous choice response. New
// clients use jobs; old clients can still submit the displayed option label.
func (s *Server) adaptiveLegacyNext(w http.ResponseWriter, r *http.Request) {
p, ok := s.adaptiveProfile(w, r)
if !ok {
return
}
var input struct {
RequestID string `json:"request_id"`
}
if !adaptiveJSON(w, r, &input) {
return
}
if !courseRequestIDPattern.MatchString(input.RequestID) {
writeError(w, 400, errors.New("invalid request_id"))
return
}
module := r.PathValue("id")
if _, err := s.course.Repo.Module(r.Context(), p.TargetLanguage, module); err != nil {
adaptiveError(w, err)
return
}
j, err := s.course.Repo.Enqueue(r.Context(), currentUserID(r), p.TargetLanguage, "legacy_next", module, "vocabulary", "", input.RequestID)
if err != nil {
adaptiveError(w, err)
return
}
timer := time.NewTimer(25 * time.Second)
defer timer.Stop()
ticker := time.NewTicker(250 * time.Millisecond)
defer ticker.Stop()
for j.Status == "queued" || j.Status == "running" {
select {
case <-r.Context().Done():
return
case <-timer.C:
goto fallback
case <-ticker.C:
j, err = s.course.Repo.Job(r.Context(), currentUserID(r), p.TargetLanguage, j.ID)
if err != nil {
adaptiveError(w, err)
return
}
}
}
if j.Status == "succeeded" && j.TaskID != "" {
t, err := s.course.Repo.Task(r.Context(), currentUserID(r), p.TargetLanguage, j.TaskID)
if err != nil {
adaptiveError(w, err)
return
}
writeLegacyAdaptiveTask(w, t)
return
}
fallback:
t, err := s.course.Repo.Reserve(r.Context(), currentUserID(r), p.TargetLanguage, module, "vocabulary")
if err != nil {
adaptiveError(w, err)
return
}
writeLegacyAdaptiveTask(w, t)
}
func legacyAdaptiveTask(t domain.AdaptiveTask) domain.CourseTask {
task := domain.CourseTask{ID: t.ID, ModuleID: t.ModuleID, Skill: t.Skill, Kind: t.Kind, Prompt: t.Prompt, Passage: t.Passage, Source: t.Source, Options: []string{}}
for _, o := range t.Options {
task.Options = append(task.Options, o.Label)
}
return task
}
func writeLegacyAdaptiveTask(w http.ResponseWriter, t domain.AdaptiveTask) {
writeJSON(w, 200, domain.CoursePracticeResult{Task: legacyAdaptiveTask(t), Source: t.Source})
}
@@ -0,0 +1,44 @@
package httpapi
import (
"encoding/binary"
"testing"
)
func TestCourseWAVUsesActualFormatAndDuration(t *testing.T) {
wav := func(seconds int) []byte {
b := make([]byte, 44+seconds*32000)
copy(b, "RIFF")
binary.LittleEndian.PutUint32(b[4:8], uint32(len(b)-8))
copy(b[8:12], "WAVE")
copy(b[12:16], "fmt ")
binary.LittleEndian.PutUint32(b[16:20], 16)
binary.LittleEndian.PutUint16(b[20:22], 1)
binary.LittleEndian.PutUint16(b[22:24], 1)
binary.LittleEndian.PutUint32(b[24:28], 16000)
binary.LittleEndian.PutUint32(b[28:32], 32000)
binary.LittleEndian.PutUint16(b[32:34], 2)
binary.LittleEndian.PutUint16(b[34:36], 16)
copy(b[36:40], "data")
binary.LittleEndian.PutUint32(b[40:44], uint32(len(b)-44))
return b
}
if !validCourseWAV(wav(30)) {
t.Fatal("valid recording rejected")
}
if validCourseWAV(wav(31)) || validCourseWAV(wav(0)) {
t.Fatal("duration not enforced")
}
for _, offset := range []int{20, 22, 24, 28, 32, 34} {
b := wav(1)
b[offset] ^= 0xff
if validCourseWAV(b) {
t.Fatalf("invalid format accepted at %d", offset)
}
}
b := wav(1)
binary.LittleEndian.PutUint32(b[40:44], 9999999)
if validCourseWAV(b) || validCourseWAV([]byte("not a WAV")) {
t.Fatal("malformed payload accepted")
}
}
+290
View File
@@ -0,0 +1,290 @@
package httpapi
import (
"context"
"encoding/json"
"errors"
"io"
"net/http"
"strconv"
"time"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/services"
"speech-learning-api/internal/store"
)
func (s *Server) SetAIService(a *services.AIService) { s.ai = a }
func (s *Server) aiAvailable(w http.ResponseWriter) bool {
if s.ai == nil {
writeError(w, 503, errors.New("Direkte KI-Anbindung nicht eingerichtet"))
return false
}
return true
}
func aiHTTPError(w http.ResponseWriter, err error) {
status := 500
if errors.Is(err, store.ErrAIBudget) || errors.Is(err, store.ErrAIDisabled) || errors.Is(err, store.ErrAIAttempts) {
status = 409
}
if errors.Is(err, store.ErrAIConflict) {
status = 409
}
if errors.Is(err, store.ErrNotFound) {
status = 404
}
if status == 500 {
writeError(w, status, errors.New("KI-Verwaltung momentan nicht verfügbar"))
return
}
writeError(w, status, err)
}
func (s *Server) aiSettings(w http.ResponseWriter, r *http.Request) {
if !s.aiAvailable(w) {
return
}
profiles, err := s.ai.Repo.Profiles(r.Context())
if err != nil {
aiHTTPError(w, err)
return
}
budget, err := s.ai.Repo.Budget(r.Context())
if err != nil {
aiHTTPError(w, err)
return
}
writeJSON(w, 200, map[string]any{"profiles": profiles, "budget": budget, "providers": map[string]bool{"deepseek": s.ai.Configured("deepseek"), "mistral": s.ai.Configured("mistral")}, "prompt_version": s.ai.PromptVersion, "prompts": s.ai.Prompts, "schemas": s.ai.Schemas})
}
func (s *Server) aiSaveProfile(w http.ResponseWriter, r *http.Request) {
if !s.aiAvailable(w) {
return
}
var p domain.AIProfile
if !adaptiveJSON(w, r, &p) {
return
}
if p.Action != r.PathValue("action") {
writeError(w, 400, errors.New("Arbeitsschritt stimmt nicht überein"))
return
}
if err := services.ValidAIProfile(p); err != nil {
writeError(w, 400, err)
return
}
saved, err := s.ai.Repo.SaveProfile(r.Context(), currentUserID(r), p)
if err != nil {
aiHTTPError(w, err)
return
}
writeJSON(w, 200, saved)
}
func (s *Server) aiSaveBudget(w http.ResponseWriter, r *http.Request) {
if !s.aiAvailable(w) {
return
}
var b struct {
Month int64 `json:"monthly_limit_microusd"`
Day int64 `json:"daily_limit_microusd"`
}
if !adaptiveJSON(w, r, &b) {
return
}
if b.Month < 0 || b.Day < 0 || b.Month > 1000000000000 || b.Day > 1000000000000 {
writeError(w, 400, errors.New("Ungültiges Budget"))
return
}
if err := s.ai.Repo.SaveBudget(r.Context(), currentUserID(r), b.Month, b.Day); err != nil {
aiHTTPError(w, err)
return
}
value, err := s.ai.Repo.Budget(r.Context())
if err != nil {
aiHTTPError(w, err)
return
}
writeJSON(w, 200, value)
}
func (s *Server) aiModels(w http.ResponseWriter, r *http.Request) {
if !s.aiAvailable(w) {
return
}
p := r.PathValue("provider")
if p != "deepseek" && p != "mistral" {
writeError(w, 400, errors.New("Unbekannter Anbieter"))
return
}
models, err := s.ai.Models(r.Context(), p)
if err != nil {
writeError(w, 502, errors.New("Modellliste nicht verfügbar; API-Key und Anbieterzugang prüfen"))
return
}
writeJSON(w, 200, models)
}
func (s *Server) aiUsage(w http.ResponseWriter, r *http.Request) {
if !s.aiAvailable(w) {
return
}
q := r.URL.Query()
offset := 0
if q.Get("offset") != "" {
n, err := strconv.Atoi(q.Get("offset"))
if err != nil || n < 0 || n > 1000000 {
writeError(w, 400, errors.New("Ungültige Seite"))
return
}
offset = n
}
for _, key := range []string{"from", "to"} {
if q.Get(key) != "" {
if _, err := time.Parse(time.RFC3339, q.Get(key)); err != nil {
writeError(w, 400, errors.New("Zeitraum muss RFC3339 sein"))
return
}
}
}
result, err := s.ai.Repo.Usage(r.Context(), domain.AIUsageFilter{From: q.Get("from"), To: q.Get("to"), Provider: q.Get("provider"), Model: q.Get("model"), User: q.Get("user"), Action: q.Get("action"), Offset: offset})
if err != nil {
aiHTTPError(w, err)
return
}
writeJSON(w, 200, result)
}
func (s *Server) aiCallDetail(w http.ResponseWriter, r *http.Request) {
if !s.aiAvailable(w) {
return
}
c, err := s.ai.Repo.Call(r.Context(), r.PathValue("id"))
if err != nil {
aiHTTPError(w, err)
return
}
writeJSON(w, 200, c)
}
func (s *Server) aiResolve(w http.ResponseWriter, r *http.Request) {
if !s.aiAvailable(w) {
return
}
var b struct {
Cost int64 `json:"cost_microusd"`
Reason string `json:"reason"`
}
if !adaptiveJSON(w, r, &b) {
return
}
if b.Cost < 0 || b.Cost > 1000000000000 || len(b.Reason) < 5 || len(b.Reason) > 1000 {
writeError(w, 400, errors.New("Kosten und Begründung erforderlich"))
return
}
if err := s.ai.Repo.Resolve(r.Context(), currentUserID(r), r.PathValue("id"), b.Cost, b.Reason); err != nil {
aiHTTPError(w, err)
return
}
writeJSON(w, 200, map[string]bool{"ok": true})
}
func (s *Server) aiTest(w http.ResponseWriter, r *http.Request) {
if !s.aiAvailable(w) {
return
}
var b struct {
RequestID string `json:"request_id"`
Action string `json:"action"`
Input json.RawMessage `json:"input"`
}
if !aiTestJSON(w, r, &b) {
return
}
if !courseRequestIDPattern.MatchString(b.RequestID) {
writeError(w, 400, errors.New("request_id erforderlich"))
return
}
if _, ok := s.ai.Prompts[b.Action]; !ok {
writeError(w, 400, errors.New("Unbekannter Arbeitsschritt"))
return
}
if len(b.Input) == 0 {
writeError(w, 400, errors.New("Testeingabe fehlt"))
return
}
ctx, cancel := context.WithTimeout(r.Context(), 75*time.Second)
defer cancel()
ctx, operation, err := s.ai.Begin(ctx, currentUserID(r), "test_"+currentUserID(r)+"_"+b.RequestID, true)
if err != nil {
aiHTTPError(w, err)
return
}
var result json.RawMessage
// Typed contracts prevent a test from showing malformed JSON as successful.
output := services.AIOutputForAction(b.Action)
err = s.ai.Call(ctx, b.Action, b.Input, output)
if err != nil {
writeJSON(w, 200, map[string]any{"ok": false, "operation_id": operation.ID, "error": s.ai.AdminError(err), "profile": operation.Profiles[b.Action], "prompt_version": operation.PromptVersion})
return
}
result, err = json.Marshal(output)
if err != nil {
aiHTTPError(w, err)
return
}
writeJSON(w, 200, map[string]any{"ok": true, "operation_id": operation.ID, "output": result, "profile": operation.Profiles[b.Action], "prompt_version": operation.PromptVersion})
}
func (s *Server) aiQuality(w http.ResponseWriter, r *http.Request) {
if !s.aiAvailable(w) {
return
}
var b struct {
RequestID string `json:"request_id"`
Suite string `json:"suite"`
}
if !adaptiveJSON(w, r, &b) {
return
}
if !courseRequestIDPattern.MatchString(b.RequestID) {
writeError(w, 400, errors.New("request_id erforderlich"))
return
}
if b.Suite == "" {
b.Suite = "grammar"
}
if b.Suite != "grammar" && b.Suite != "writing" {
writeError(w, 400, errors.New("Unbekannte Qualitätsprüfung"))
return
}
operationID := "quality_" + currentUserID(r) + "_" + b.RequestID
if b.Suite != "grammar" {
operationID = "quality_" + b.Suite + "_" + currentUserID(r) + "_" + b.RequestID
}
ctx, cancel := context.WithTimeout(r.Context(), 80*time.Second)
defer cancel()
ctx, o, err := s.ai.Begin(ctx, currentUserID(r), operationID, true)
if err != nil {
aiHTTPError(w, err)
return
}
results, err := s.ai.QualitySuite(ctx, b.Suite)
if err != nil {
aiHTTPError(w, err)
return
}
passed := true
for _, result := range results {
passed = passed && result.Passed
}
writeJSON(w, 200, map[string]any{"suite": b.Suite, "passed": passed, "results": results, "operation_id": o.ID, "profile": o.Profiles["evaluate_course_attempt"]})
}
func aiTestJSON(w http.ResponseWriter, r *http.Request, out any) bool {
r.Body = http.MaxBytesReader(w, r.Body, 1<<20)
defer r.Body.Close()
decoder := json.NewDecoder(r.Body)
decoder.DisallowUnknownFields()
if err := decoder.Decode(out); err != nil {
writeError(w, 400, errors.New("Ungültige Testeingabe; maximal 1 MiB"))
return false
}
if decoder.Decode(new(any)) != io.EOF {
writeError(w, 400, errors.New("Zusätzliche Daten hinter der Testeingabe"))
return false
}
return true
}
@@ -0,0 +1,468 @@
package httpapi
import (
"bytes"
"context"
"database/sql"
"encoding/json"
"fmt"
"io"
"log/slog"
"net/http"
"net/http/httptest"
"net/url"
"os"
"os/exec"
"path/filepath"
"runtime"
"sync"
"sync/atomic"
"syscall"
"testing"
"time"
_ "github.com/jackc/pgx/v5/stdlib"
"speech-learning-api/internal/config"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/services"
"speech-learning-api/internal/store"
)
func aiHTTPFixture(t *testing.T, bankMode ...bool) (*httptest.Server, string, *store.AIStore) {
t.Helper()
dsn := os.Getenv("COURSE_TEST_DATABASE_URL")
if dsn == "" {
t.Skip("COURSE_TEST_DATABASE_URL not set")
}
admin, err := sql.Open("pgx", dsn)
if err != nil {
t.Fatal(err)
}
schema := store.NewID("ai_http")
if _, err = admin.Exec(`CREATE SCHEMA ` + schema); err != nil {
t.Fatal(err)
}
parsed, _ := url.Parse(dsn)
q := parsed.Query()
q.Set("search_path", schema)
parsed.RawQuery = q.Encode()
db, err := sql.Open("pgx", parsed.String())
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { db.Close(); admin.Exec(`DROP SCHEMA ` + schema + ` CASCADE`); admin.Close() })
ctx, cancel := context.WithCancel(context.Background())
t.Cleanup(cancel)
profiles := store.NewPostgresStore(db)
if err = profiles.Init(ctx); err != nil {
t.Fatal(err)
}
user, err := profiles.CreateUser(ctx, "ai-http@example.test", "hash", "de-DE")
if err != nil {
t.Fatal(err)
}
profiles.CreateLearnerProfile(ctx, user.ID, "en-US", "A1", 10)
db.Exec(`UPDATE users SET role='admin' WHERE id=$1`, user.ID)
cfg := config.Config{JWTSecret: "ai-http-test-only", MistralAPIKey: "fixture-key", DeepSeekAPIKey: "fixture-key", AzureMock: true, CORSOrigins: []string{"http://localhost:15175"}}
if len(bankMode) > 1 && bankMode[1] {
cfg.PronunciationStrategy = "statistical"
}
var exerciseNumber atomic.Int32
a := services.NewAIService(store.NewAIStore(db), cfg)
provider := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path == "/models" {
json.NewEncoder(w).Encode(map[string]any{"data": []any{map[string]any{"id": "fixture-model", "context_window": 131072, "max_output_tokens": 16384}}})
return
}
var body struct {
Messages []struct {
Content string `json:"content"`
} `json:"messages"`
}
if err := json.NewDecoder(r.Body).Decode(&body); err != nil || len(body.Messages) != 2 {
t.Error("missing model messages")
http.Error(w, "bad", 400)
return
}
var request struct {
Task string `json:"task"`
Input json.RawMessage `json:"input"`
}
json.Unmarshal([]byte(body.Messages[1].Content), &request)
var result any
switch request.Task {
case "next_exercise":
var in struct {
Mode string `json:"training_mode"`
Required []string `json:"required_practice_words"`
Plan *domain.PronunciationPlan `json:"training_plan"`
}
json.Unmarshal(request.Input, &in)
word := "cat"
candidate := ""
if len(in.Required) > 0 {
word = in.Required[0]
}
if in.Mode == "transfer" {
word = "cup"
if in.Plan != nil {
for _, known := range in.Plan.KnownWords {
if known == word {
word = "school"
}
}
}
candidate = word
}
n := exerciseNumber.Add(1)
ref := fmt.Sprintf("I see a %s near %s.", word, []string{"home", "the lake", "the pond", "the shop", "the house", "the garden"}[int(n-1)%6])
result = domain.GeneratedExercise{ExerciseType: "repeat_sentence", TargetLanguage: "en-US", CEFRLevel: "A1", ReferenceText: ref, TTSText: ref, DisplayPrompt: "Sprich den Satz nach.", ReasonForChoice: "Kurze Übung anhand des gespeicherten Trainingsziels.", FocusPoints: []string{word}, SuccessCriteria: []string{"Sprich mit natürlichem Rhythmus."}, CandidateWord: candidate}
case "evaluate_course_attempt":
var in struct {
Answer string `json:"answer"`
}
json.Unmarshal(request.Input, &in)
score, verdict, issues := 100, "correct", []string{}
if in.Answer == "He have got a sister." {
score, verdict, issues = 60, "partial", []string{"has nach he verwenden"}
}
feedback := "Bewertung aus Testanbieter"
if in.Answer == "my name is Jack Hill. I live in city. My hobby is shwiming." {
score, verdict, issues = 80, "partial", []string{"Am Satzanfang My schreiben.", "in city muss in a city heißen.", "shwiming muss swimming heißen."}
feedback = "Inhalt erfüllt; My am Satzanfang, a city und swimming korrigieren."
}
result = map[string]any{"score": score, "verdict": verdict, "feedback": feedback, "issues": issues}
case "analyze_course_progress":
var in domain.CourseSnapshot
json.Unmarshal(request.Input, &in)
modules := []domain.ModuleAnalysis{}
for _, m := range in.Modules {
modules = append(modules, domain.ModuleAnalysis{ModuleID: m.ID, Strengths: []string{}, Weaknesses: []string{}, Recommendation: "Weiterlernen", Reason: "Aus gespeicherten Antworten", EvidenceIDs: []string{}})
}
result = domain.CourseAnalysis{SchemaVersion: 2, TargetLanguage: "en-US", CourseVersion: domain.CourseVersion, FactsVersion: in.FactsVersion, Summary: "Lernstand aus Testanbieter", RecommendedModuleID: "a1_family_v1", Modules: modules}
case "plan_course_task":
var in struct {
Module string `json:"module_id"`
Skill string `json:"requested_skill"`
}
json.Unmarshal(request.Input, &in)
if in.Skill == "" {
in.Skill = "grammar"
}
kind := "choice"
if in.Skill == "writing" {
kind = "free_text"
}
if in.Skill == "speaking" {
kind = "free_speech"
}
if in.Skill == "reading" {
kind = "short_text"
}
result = domain.CourseBrief{SchemaVersion: 2, ModuleID: in.Module, TargetLanguage: "en-US", CourseVersion: domain.CourseVersion, Skill: in.Skill, Kind: kind, Objective: "A1-Aufgabe", Difficulty: "A1", Reason: "Lernstand"}
case "author_course_task":
var in struct {
Brief domain.CourseBrief `json:"brief"`
}
json.Unmarshal(request.Input, &in)
task := domain.AdaptiveTask{SchemaVersion: 2, ModuleID: in.Brief.ModuleID, TargetLanguage: "en-US", CourseVersion: domain.CourseVersion, CEFRLevel: "A1", Skill: in.Brief.Skill, Kind: in.Brief.Kind, Prompt: "Aufgabe vom direkten Testanbieter", AnswerKey: &domain.TaskKey{Rubric: []string{"Verständliche A1-Antwort"}, Explanation: "Private Testlösung", ReferenceAnswer: "He has got a sister."}}
if task.Kind == "choice" {
task.Options = []domain.TaskOption{{ID: "o1", Label: "Anna"}, {ID: "o2", Label: "Bob"}, {ID: "o3", Label: "Tom"}}
task.AnswerKey.CorrectOptionID = "o1"
}
if task.Skill == "reading" {
task.Passage = "My name is Anna."
}
if task.Skill == "listening" {
task.AudioText = "My name is Anna."
}
result = map[string]any{"schema_version": 2, "tasks": []domain.AdaptiveTask{task}}
case "review_course_task":
var in struct {
Candidate struct {
Tasks []domain.AdaptiveTask `json:"tasks"`
} `json:"candidate"`
}
json.Unmarshal(request.Input, &in)
checks := []services.AIChoiceCheck{}
for i, task := range in.Candidate.Tasks {
if task.Kind == "choice" {
if task.AnswerKey != nil {
t.Error("authored key leaked to reviewer")
}
check := services.AIChoiceCheck{TaskIndex: i}
for n, option := range task.Options {
check.Options = append(check.Options, services.AIOptionCheck{OptionID: option.ID, IsCorrect: n == 0, Reason: "Fixture solution"})
}
checks = append(checks, check)
}
}
result = services.AIReview{SchemaVersion: 2, Approved: true, ChoiceChecks: checks, ReviewNotes: "Unabhängig gelöst"}
case "author_course_exam":
tasks, err := store.NewAdaptiveStore(db).ReserveExam(ctx, user.ID, "en-US", "a1_review_test_v1")
if err != nil {
t.Error(err)
}
for i := range tasks {
tasks[i].Source = ""
}
result = map[string]any{"schema_version": 2, "tasks": tasks}
case "review_course_exam":
var in struct {
Candidate struct {
Tasks []domain.AdaptiveTask `json:"tasks"`
} `json:"candidate"`
}
json.Unmarshal(request.Input, &in)
checks := []services.AIChoiceCheck{}
for i, task := range in.Candidate.Tasks {
if task.Kind == "choice" {
if task.AnswerKey != nil {
t.Error("authored key leaked to reviewer")
}
check := services.AIChoiceCheck{TaskIndex: i}
for n, option := range task.Options {
check.Options = append(check.Options, services.AIOptionCheck{OptionID: option.ID, IsCorrect: n == 0, Reason: "Fixture solution"})
}
checks = append(checks, check)
}
}
result = services.AIReview{SchemaVersion: 2, Approved: true, ChoiceChecks: checks, ReviewNotes: "Unabhängig gelöst"}
default:
t.Error("unexpected task", request.Task)
http.Error(w, "unsupported", 400)
return
}
output, _ := json.Marshal(result)
json.NewEncoder(w).Encode(map[string]any{"choices": []any{map[string]any{"finish_reason": "stop", "message": map[string]any{"content": string(output)}}}, "usage": map[string]any{"prompt_tokens": 100, "completion_tokens": 30}})
}))
t.Cleanup(provider.Close)
a.URLs["mistral"] = provider.URL
a.URLs["deepseek"] = provider.URL
auth := services.NewAuthService(profiles, cfg.JWTSecret)
logger := slog.New(slog.NewTextHandler(io.Discard, nil))
server := NewServer(cfg, logger, profiles, auth, services.NewAzureSpeechService(cfg, logger), a)
server.SetAIService(a)
engine := services.NewCourseEngine(store.NewAdaptiveStore(db), profiles, a, logger)
if len(bankMode) > 0 && bankMode[0] {
engine.Mode = "bank"
server.speech = bankFixtureSpeech{}
}
if len(bankMode) > 1 && bankMode[1] {
server.speech = statisticalFixtureSpeech{}
}
server.SetCourseEngine(engine)
go engine.Run(ctx)
api := httptest.NewServer(server.Routes())
t.Cleanup(api.Close)
token, _ := auth.IssueToken(user.ID)
return api, token, a.Repo
}
func aiHTTP(t *testing.T, api *httptest.Server, token, method, path string, body any) map[string]json.RawMessage {
t.Helper()
data, _ := json.Marshal(body)
req, _ := http.NewRequest(method, api.URL+path, bytes.NewReader(data))
req.Header.Set("Authorization", "Bearer "+token)
req.Header.Set("Content-Type", "application/json")
resp, err := api.Client().Do(req)
if err != nil {
t.Fatal(err)
}
defer resp.Body.Close()
var result map[string]json.RawMessage
json.NewDecoder(resp.Body).Decode(&result)
if resp.StatusCode >= 300 {
t.Fatalf("%s %s: %d: %s", method, path, resp.StatusCode, result["error"])
}
return result
}
func TestAIAdminPostgresAPI(t *testing.T) {
api, token, repo := aiHTTPFixture(t)
settings := aiHTTP(t, api, token, "GET", "/admin/ai/settings", nil)
var profiles map[string]domain.AIProfile
json.Unmarshal(settings["profiles"], &profiles)
p := profiles["evaluate_course_attempt"]
p.Model = "fixture-model"
p.PricingSet = true
p.InputPrice = 1000000
p.OutputPrice = 2000000
p.ContextTokens = 131072
aiHTTP(t, api, token, "PUT", "/admin/ai/profiles/"+p.Action, p)
aiHTTP(t, api, token, "PUT", "/admin/ai/budget", map[string]int64{"monthly_limit_microusd": 1000000})
aiHTTP(t, api, token, "GET", "/admin/ai/providers/mistral/models", nil)
result := aiHTTP(t, api, token, "POST", "/admin/ai/quality", map[string]string{"request_id": "quality-request"})
var passed bool
json.Unmarshal(result["passed"], &passed)
if !passed {
t.Fatal("quality fixture failed", result)
}
// Same request must reuse both paid completions.
aiHTTP(t, api, token, "POST", "/admin/ai/quality", map[string]string{"request_id": "quality-request"})
report, err := repo.Usage(context.Background(), domain.AIUsageFilter{})
if err != nil || report.Total != 2 {
t.Fatal("duplicate API test billing", report, err)
}
c := aiHTTP(t, api, token, "GET", "/admin/ai/calls/"+report.Calls[0].ID, nil)
if bytes.Contains(c["input"], []byte("fixture-key")) {
t.Fatal("key leaked")
}
}
func TestAIBrowserSmoke(t *testing.T) {
if os.Getenv("AI_BROWSER_SMOKE") != "1" {
t.Skip("AI_BROWSER_SMOKE=1 enables Playwright against a disposable API")
}
api, token, _ := aiHTTPFixture(t)
_, file, _, _ := runtime.Caller(0)
web := filepath.Clean(filepath.Join(filepath.Dir(file), "../../../web"))
dev := exec.Command("npm", "run", "dev", "--", "--host", "127.0.0.1", "--port", "15175", "--strictPort")
dev.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
dev.Dir = web
dev.Env = append(os.Environ(), "VITE_API_BASE_URL="+api.URL)
var devOutput bytes.Buffer
dev.Stdout = &devOutput
dev.Stderr = &devOutput
if err := dev.Start(); err != nil {
t.Fatal(err)
}
var stopOnce sync.Once
stopDev := func() {
stopOnce.Do(func() {
if dev.Process != nil {
syscall.Kill(-dev.Process.Pid, syscall.SIGTERM)
dev.Wait()
}
})
}
t.Cleanup(stopDev)
ready := false
for i := 0; i < 40; i++ {
resp, err := http.Get("http://localhost:15175")
if err == nil {
resp.Body.Close()
ready = true
break
}
time.Sleep(100 * time.Millisecond)
}
if !ready {
stopDev()
t.Fatal("Vite did not start", devOutput.String())
}
node := exec.Command("node", "tests/ai-admin.e2e.cjs")
node.Dir = web
node.Env = append(os.Environ(), "AI_E2E_API="+api.URL, "AI_E2E_TOKEN="+token, "AI_E2E_URL=http://localhost:15175")
output, err := node.CombinedOutput()
stopDev()
t.Log(string(output))
t.Log("Vite:", devOutput.String())
if err != nil {
t.Fatal(err)
}
}
func TestBankBrowserSmoke(t *testing.T) {
if os.Getenv("BANK_BROWSER_SMOKE") != "1" {
t.Skip("BANK_BROWSER_SMOKE=1 enables Playwright against a disposable API")
}
api, token, _ := aiHTTPFixture(t, true)
_, file, _, _ := runtime.Caller(0)
web := filepath.Clean(filepath.Join(filepath.Dir(file), "../../../web"))
dev := exec.Command("npm", "run", "dev", "--", "--host", "127.0.0.1", "--port", "15175", "--strictPort")
dev.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
dev.Dir = web
dev.Env = append(os.Environ(), "VITE_API_BASE_URL="+api.URL)
var devOutput bytes.Buffer
dev.Stdout = &devOutput
dev.Stderr = &devOutput
if err := dev.Start(); err != nil {
t.Fatal(err)
}
var stopOnce sync.Once
stopDev := func() {
stopOnce.Do(func() {
if dev.Process != nil {
syscall.Kill(-dev.Process.Pid, syscall.SIGTERM)
dev.Wait()
}
})
}
t.Cleanup(stopDev)
ready := false
for i := 0; i < 40; i++ {
resp, err := http.Get("http://localhost:15175")
if err == nil {
resp.Body.Close()
ready = true
break
}
time.Sleep(100 * time.Millisecond)
}
if !ready {
stopDev()
t.Fatal("Vite did not start", devOutput.String())
}
node := exec.Command("node", "tests/course-bank.e2e.cjs")
node.Dir = web
node.Env = append(os.Environ(), "AI_E2E_API="+api.URL, "AI_E2E_TOKEN="+token, "AI_E2E_URL=http://localhost:15175")
output, err := node.CombinedOutput()
stopDev()
t.Log(string(output))
t.Log("Vite:", devOutput.String())
if err != nil {
t.Fatal(err)
}
}
func TestPronunciationBrowserSmoke(t *testing.T) {
if os.Getenv("PRONUNCIATION_BROWSER_SMOKE") != "1" {
t.Skip("PRONUNCIATION_BROWSER_SMOKE=1 enables Playwright against a disposable API")
}
api, token, _ := aiHTTPFixture(t, true, true)
_, file, _, _ := runtime.Caller(0)
web := filepath.Clean(filepath.Join(filepath.Dir(file), "../../../web"))
dev := exec.Command("npm", "run", "dev", "--", "--host", "127.0.0.1", "--port", "15175", "--strictPort")
dev.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
dev.Dir = web
dev.Env = append(os.Environ(), "VITE_API_BASE_URL="+api.URL)
var devOutput bytes.Buffer
dev.Stdout = &devOutput
dev.Stderr = &devOutput
if err := dev.Start(); err != nil {
t.Fatal(err)
}
var stopOnce sync.Once
stopDev := func() {
stopOnce.Do(func() {
if dev.Process != nil {
syscall.Kill(-dev.Process.Pid, syscall.SIGTERM)
dev.Wait()
}
})
}
t.Cleanup(stopDev)
ready := false
for i := 0; i < 40; i++ {
resp, err := http.Get("http://localhost:15175")
if err == nil {
resp.Body.Close()
ready = true
break
}
time.Sleep(100 * time.Millisecond)
}
if !ready {
stopDev()
t.Fatal("Vite did not start", devOutput.String())
}
node := exec.Command("node", "tests/pronunciation-profile.e2e.cjs")
node.Dir = web
node.Env = append(os.Environ(), "AI_E2E_API="+api.URL, "AI_E2E_TOKEN="+token, "AI_E2E_URL=http://localhost:15175")
output, err := node.CombinedOutput()
stopDev()
t.Log(string(output))
t.Log("Vite:", devOutput.String())
if err != nil {
t.Fatal(err)
}
}
+54
View File
@@ -0,0 +1,54 @@
package httpapi
import (
"io"
"log/slog"
"net/http"
"net/http/httptest"
"strings"
"testing"
"speech-learning-api/internal/config"
"speech-learning-api/internal/services"
)
func TestAIAdminRoutesAreProtected(t *testing.T) {
data := &adminTestStore{role: "learner"}
auth := services.NewAuthService(nil, "ai-route-secret")
token, _ := auth.IssueToken("admin-test")
s := &Server{store: data, auth: auth, logger: slog.New(slog.NewTextHandler(io.Discard, nil))}
handler := s.Routes()
for _, route := range []struct{ method, path string }{{"GET", "settings"}, {"PUT", "profiles/evaluate_course_attempt"}, {"PUT", "budget"}, {"GET", "providers/mistral/models"}, {"GET", "usage"}, {"GET", "calls/test"}, {"POST", "calls/test/resolve"}, {"POST", "test"}, {"POST", "quality"}} {
for _, role := range []string{"anonymous", "learner", "admin"} {
data.role = role
req := httptest.NewRequest(route.method, "/admin/ai/"+route.path, strings.NewReader("{}"))
if role != "anonymous" {
req.Header.Set("Authorization", "Bearer "+token)
}
w := httptest.NewRecorder()
handler.ServeHTTP(w, req)
want := http.StatusForbidden
if role == "anonymous" {
want = 401
}
if role == "admin" {
want = 503
}
if w.Code != want {
t.Fatalf("%s %s %s: %d, expected %d", role, route.method, route.path, w.Code, want)
}
}
}
}
func TestAISettingsCORSAllowsPUT(t *testing.T) {
s := &Server{cfg: config.Config{CORSOrigins: []string{"http://localhost:15175"}}}
req := httptest.NewRequest("OPTIONS", "/admin/ai/budget", nil)
req.Header.Set("Origin", "http://localhost:15175")
req.Header.Set("Access-Control-Request-Method", "PUT")
w := httptest.NewRecorder()
s.cors(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { t.Fatal("preflight should terminate in middleware") })).ServeHTTP(w, req)
if !strings.Contains(w.Header().Get("Access-Control-Allow-Methods"), "PUT") {
t.Fatal("PUT settings blocked by CORS")
}
}
+167
View File
@@ -0,0 +1,167 @@
package httpapi
import (
"errors"
"net/http"
"strings"
"unicode"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/store"
)
func (s *Server) courseProfile(r *http.Request) (domain.LearnerProfile, error) {
return s.store.GetPrimaryProfile(r.Context(), currentUserID(r))
}
func (s *Server) courseModules(w http.ResponseWriter, r *http.Request) {
profile, err := s.courseProfile(r)
if err != nil {
writeError(w, http.StatusNotFound, err)
return
}
modules, err := s.store.CourseModules(r.Context(), currentUserID(r), profile.TargetLanguage, profile.CEFRLevel)
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
writeJSON(w, http.StatusOK, map[string]any{"modules": modules})
}
func (s *Server) courseModule(w http.ResponseWriter, r *http.Request) {
profile, err := s.courseProfile(r)
if err != nil {
writeError(w, http.StatusNotFound, err)
return
}
detail, err := s.store.CourseModule(r.Context(), currentUserID(r), profile.TargetLanguage, profile.CEFRLevel, r.PathValue("id"))
if errors.Is(err, store.ErrNotFound) {
writeError(w, http.StatusNotFound, err)
return
}
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
writeJSON(w, http.StatusOK, detail)
}
func (s *Server) courseTask(r *http.Request) (domain.CourseTaskKey, error) {
profile, err := s.courseProfile(r)
if err != nil {
return domain.CourseTaskKey{}, err
}
return s.store.CourseTaskKey(r.Context(), r.PathValue("id"), currentUserID(r), profile.TargetLanguage, profile.CEFRLevel)
}
func (s *Server) courseAttempt(w http.ResponseWriter, r *http.Request) {
if strings.HasPrefix(r.PathValue("id"), "a2_") {
s.adaptiveAttempt(w, r)
return
}
key, err := s.courseTask(r)
if errors.Is(err, store.ErrNotFound) {
writeError(w, http.StatusNotFound, err)
return
}
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
if key.Kind != "choice" && key.Kind != "short_text" {
writeError(w, http.StatusBadRequest, errors.New("this task uses pronunciation assessment"))
return
}
var input struct {
Answer string `json:"answer"`
}
if err := decodeJSON(r, &input); err != nil {
writeError(w, http.StatusBadRequest, err)
return
}
answer := strings.TrimSpace(input.Answer)
if answer == "" || len([]rune(answer)) > 200 {
writeError(w, http.StatusBadRequest, errors.New("answer must contain 1 to 200 characters"))
return
}
correct := answerMatches(answer, key.AcceptedAnswers)
id, err := s.store.SaveCourseAttempt(r.Context(), currentUserID(r), key.ID, answer, correct)
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
transcript := ""
if key.Skill == "listening" {
transcript = key.AudioText
}
if s.course != nil {
if syncErr := s.course.Repo.SyncLegacy(r.Context()); syncErr != nil {
s.logger.Warn("legacy course evidence sync failed", "error", syncErr)
}
}
writeJSON(w, http.StatusCreated, domain.CourseAttemptResult{ID: id, TaskID: key.ID, Correct: correct, Solution: key.Solution, Explanation: key.Explanation, Transcript: transcript})
}
func answerMatches(answer string, accepted []string) bool {
normalized := normalizeCourseAnswer(answer)
for _, candidate := range accepted {
if normalized == normalizeCourseAnswer(candidate) {
return true
}
}
return false
}
func normalizeCourseAnswer(answer string) string {
answer = strings.Map(func(r rune) rune {
if r == '’' {
return '\''
}
return r
}, answer)
answer = strings.Join(strings.Fields(strings.ToLower(strings.TrimSpace(answer))), " ")
return strings.TrimSpace(strings.TrimRightFunc(answer, func(r rune) bool { return unicode.IsPunct(r) && r != '\'' }))
}
func (s *Server) courseAudio(w http.ResponseWriter, r *http.Request) {
if strings.HasPrefix(r.PathValue("id"), "a2_") {
s.adaptiveAudio(w, r)
return
}
key, err := s.courseTask(r)
if errors.Is(err, store.ErrNotFound) {
writeError(w, http.StatusNotFound, err)
return
}
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
if key.Skill != "listening" || key.AudioText == "" {
writeError(w, http.StatusNotFound, store.ErrNotFound)
return
}
profile, err := s.courseProfile(r)
if err != nil {
writeError(w, http.StatusNotFound, err)
return
}
language, err := s.store.GetLanguage(r.Context(), profile.TargetLanguage)
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
audio, mime, err := s.speech.Synthesize(r.Context(), language.AzureLocale, language.DefaultTTSVoice, key.AudioText)
if err != nil {
writeError(w, http.StatusBadGateway, err)
return
}
if len(audio) == 0 {
writeError(w, http.StatusServiceUnavailable, errors.New("audio is unavailable"))
return
}
w.Header().Set("Content-Type", mime)
w.Header().Set("Cache-Control", "private, no-store")
w.WriteHeader(http.StatusOK)
_, _ = w.Write(audio)
}
@@ -0,0 +1,42 @@
package httpapi
import (
"context"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/services"
"strings"
)
// Explicit local fixture, not a claim of a real Azure measurement.
type bankFixtureSpeech struct{}
func (bankFixtureSpeech) AssessPronunciation(_ context.Context, in services.PronunciationInput) (domain.PronunciationResult, error) {
return domain.PronunciationResult{Provider: "azure", RecognizedText: in.TargetText, OverallScore: 90, AccuracyScore: 90}, nil
}
func (bankFixtureSpeech) Transcribe(context.Context, []byte, string, string) (string, error) {
return "I have got a brother.", nil
}
func (bankFixtureSpeech) Synthesize(context.Context, string, string, string) ([]byte, string, error) {
return []byte("fixture mp3"), "audio/mpeg", nil
}
func (bankFixtureSpeech) SynthesizeExercise(context.Context, string, string, string, string, string) ([]byte, string, error) {
return []byte("fixture mp3"), "audio/mpeg", nil
}
// Named fixtures intentionally simulate known measurements; they never call Azure.
type statisticalFixtureSpeech struct{ bankFixtureSpeech }
func (statisticalFixtureSpeech) AssessPronunciation(_ context.Context, in services.PronunciationInput) (domain.PronunciationResult, error) {
result := domain.PronunciationResult{Provider: "azure", Locale: in.Locale, Alphabet: "IPA", Method: "scripted", MeasurementVersion: "test-fixture", RecognizedText: in.TargetText, OverallScore: 80, AccuracyScore: 80}
for _, token := range strings.Fields(in.TargetText) {
word := strings.ToLower(strings.Trim(token, ".,!?"))
w := domain.WordScore{Word: word, Accuracy: 90, Highlight: "good"}
if word == "cat" || word == "cup" || word == "school" {
w.Accuracy = 40
w.Highlight = "weak"
w.PhonemeScores = []domain.PhonemeScore{{Phoneme: "k", Accuracy: 30, Highlight: "weak"}}
}
result.WordScores = append(result.WordScores, w)
}
return result, nil
}
@@ -0,0 +1,166 @@
package httpapi
import (
"context"
"encoding/json"
"errors"
"io"
"net/http"
"regexp"
"strings"
"time"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/services"
"speech-learning-api/internal/store"
)
func (s *Server) practiceModule(w http.ResponseWriter, r *http.Request) (domain.CourseModuleDetail, bool) {
profile, err := s.courseProfile(r)
if err != nil {
writeError(w, http.StatusNotFound, err)
return domain.CourseModuleDetail{}, false
}
detail, err := s.store.CourseModule(r.Context(), currentUserID(r), profile.TargetLanguage, profile.CEFRLevel, r.PathValue("id"))
if errors.Is(err, store.ErrNotFound) {
writeError(w, http.StatusNotFound, err)
return detail, false
}
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return detail, false
}
if detail.Module.ID != "a1_introductions_v1" || profile.TargetLanguage != "en-US" || profile.CEFRLevel != "A1" {
writeError(w, http.StatusBadRequest, errors.New("additional practice is not available for this module"))
return detail, false
}
return detail, true
}
func (s *Server) coursePractice(w http.ResponseWriter, r *http.Request) {
detail, ok := s.practiceModule(w, r)
if !ok {
return
}
tasks, err := s.store.CoursePractice(r.Context(), currentUserID(r), detail.Module.ID)
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
if s.course != nil {
profile, err := s.courseProfile(r)
if err != nil {
adaptiveError(w, err)
return
}
newer, err := s.course.Repo.History(r.Context(), currentUserID(r), profile.TargetLanguage, detail.Module.ID, 0)
if err != nil {
adaptiveError(w, err)
return
}
for _, item := range newer {
if item.Kind != "choice" || strings.HasPrefix(item.ID, "a2_legacy_") {
continue
}
converted := legacyAdaptiveTask(item)
latest, err := s.course.Repo.LatestTaskAttempt(r.Context(), currentUserID(r), profile.TargetLanguage, item.ID)
if err != nil {
adaptiveError(w, err)
return
}
if latest != nil {
converted.Attempted = true
converted.Correct = latest.Evaluation != nil && latest.Evaluation.Verdict == "correct"
}
tasks = append(tasks, converted)
}
}
writeJSON(w, http.StatusOK, map[string]any{"tasks": tasks})
}
var courseRequestIDPattern = regexp.MustCompile(`^[A-Za-z0-9_-]{8,80}$`)
func (s *Server) nextCoursePractice(w http.ResponseWriter, r *http.Request) {
if s.course != nil {
s.adaptiveLegacyNext(w, r)
return
}
var input struct {
RequestID string `json:"request_id"`
}
r.Body = http.MaxBytesReader(w, r.Body, 1024)
defer r.Body.Close()
decoder := json.NewDecoder(r.Body)
decoder.DisallowUnknownFields()
if err := decoder.Decode(&input); err != nil {
writeError(w, http.StatusBadRequest, errors.New("invalid practice request"))
return
}
if decoder.Decode(new(any)) != io.EOF || !courseRequestIDPattern.MatchString(input.RequestID) {
writeError(w, http.StatusBadRequest, errors.New("invalid request_id"))
return
}
detail, ok := s.practiceModule(w, r)
if !ok {
return
}
userID := currentUserID(r)
existing, err := s.store.CoursePracticeByRequest(r.Context(), userID, detail.Module.ID, input.RequestID)
if err == nil {
writeJSON(w, http.StatusOK, existing)
return
}
if !errors.Is(err, store.ErrNotFound) {
writeError(w, http.StatusInternalServerError, err)
return
}
selection, err := s.store.SelectCoursePractice(r.Context(), userID, detail.Module.ID)
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
user, err := s.store.GetUser(r.Context(), userID)
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
request := domain.GenerateCourseTaskRequest{
Task: "generate_course_task", SchemaVersion: 1, TargetLanguage: detail.Module.TargetLanguage,
CEFRLevel: detail.Module.CEFRLevel, UILanguage: user.UILanguage, ModuleID: detail.Module.ID,
Skill: selection.Goal.Skill, Kind: "choice", LearningGoal: selection.Goal,
LearningState: selection.State, AvoidPrompts: selection.AvoidPrompts,
}
reason := "course generator unavailable"
if s.courseGenerator != nil {
ctx, cancel := context.WithTimeout(r.Context(), 25*time.Second)
generated, generateErr := s.courseGenerator.GenerateCourseTask(ctx, request)
cancel()
// Validate here as well so another generator implementation cannot bypass it.
if generateErr == nil {
generateErr = services.ValidateGeneratedCourseTask(generated, request)
}
if generateErr == nil {
result, saveErr := s.store.SaveGeneratedCourseTask(r.Context(), userID, input.RequestID, generated)
if saveErr == nil {
s.logger.Info("course practice selected", "source", result.Source, "task_id", result.Task.ID, "learning_goal_id", selection.Goal.ID)
writeJSON(w, http.StatusOK, result)
return
}
reason = "saving generated course task failed"
s.logger.Warn(reason, "error", saveErr)
} else {
reason = generateErr.Error()
}
}
if r.Context().Err() != nil {
return
}
s.logger.Warn("course generation fallback", "reason", reason, "learning_goal_id", selection.Goal.ID)
result, err := s.store.CoursePracticeFallback(r.Context(), userID, selection.Goal.SeedTaskID)
if err != nil {
writeError(w, http.StatusInternalServerError, err)
return
}
s.logger.Info("course practice selected", "source", result.Source, "task_id", result.Task.ID, "learning_goal_id", selection.Goal.ID)
writeJSON(w, http.StatusOK, result)
}
@@ -0,0 +1,135 @@
package httpapi
import (
"context"
"encoding/json"
"errors"
"io"
"log/slog"
"net/http"
"net/http/httptest"
"strings"
"testing"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/store"
)
type practiceTestStore struct {
*courseTestStore
saved int
fallback int
existing bool
saveError bool
selectionError bool
}
func (s *practiceTestStore) GetUser(context.Context, string) (domain.User, error) {
return domain.User{UILanguage: "de-DE"}, nil
}
func (s *practiceTestStore) CourseModule(context.Context, string, string, string, string) (domain.CourseModuleDetail, error) {
return domain.CourseModuleDetail{Module: domain.CourseModule{ID: "a1_introductions_v1", TargetLanguage: "en-US", CEFRLevel: "A1"}}, nil
}
func (s *practiceTestStore) CoursePracticeByRequest(context.Context, string, string, string) (domain.CoursePracticeResult, error) {
if s.existing {
return domain.CoursePracticeResult{Task: domain.CourseTask{ID: "existing"}, Source: "flowise"}, nil
}
return domain.CoursePracticeResult{}, store.ErrNotFound
}
func (s *practiceTestStore) SelectCoursePractice(context.Context, string, string) (domain.CoursePracticeSelection, error) {
if s.selectionError {
return domain.CoursePracticeSelection{}, errors.New("database unavailable")
}
return domain.CoursePracticeSelection{Goal: domain.IntroductionGoals()[2], State: domain.CourseLearningState{RecentResults: []bool{}}, AvoidPrompts: []string{}}, nil
}
func (s *practiceTestStore) SaveGeneratedCourseTask(_ context.Context, user, request string, out domain.GeneratedCourseTask) (domain.CoursePracticeResult, error) {
if user != "usr_1" || request != "request_123" {
return domain.CoursePracticeResult{}, errors.New("incorrect ownership")
}
s.saved++
if s.saveError {
return domain.CoursePracticeResult{}, errors.New("save failed")
}
return domain.CoursePracticeResult{Task: domain.CourseTask{ID: "generated", Prompt: out.Prompt, Options: out.Options, Kind: out.Kind, Skill: out.Skill}, Source: "flowise"}, nil
}
func (s *practiceTestStore) CoursePracticeFallback(_ context.Context, user, seed string) (domain.CoursePracticeResult, error) {
s.fallback++
if user != "usr_1" || seed != "a1i_v1_grammar_1" {
return domain.CoursePracticeResult{}, errors.New("wrong fallback")
}
return domain.CoursePracticeResult{Task: domain.CourseTask{ID: seed}, Source: "seed"}, nil
}
type practiceGenerator struct {
err error
invalid bool
calls int
}
func (g *practiceGenerator) GenerateCourseTask(_ context.Context, in domain.GenerateCourseTaskRequest) (domain.GeneratedCourseTask, error) {
g.calls++
out := domain.GeneratedCourseTask{SchemaVersion: 1, TargetLanguage: in.TargetLanguage, CEFRLevel: in.CEFRLevel, ModuleID: in.ModuleID, LearningGoalID: in.LearningGoal.ID, Skill: in.Skill, Kind: "choice", Prompt: "Ergänze: I ___ from Germany.", Options: []string{"am", "is", "are"}, Solution: "am", Explanation: "Nach I steht am."}
if g.invalid {
out.Solution = "unknown"
}
return out, g.err
}
func TestNextCoursePracticeGenerationAndFallback(t *testing.T) {
for _, test := range []struct {
name string
generator *practiceGenerator
saveError, existing, dbError bool
status int
source string
}{
{name: "generated", generator: &practiceGenerator{}, status: 200, source: "flowise"},
{name: "disabled", status: 200, source: "seed"},
{name: "timeout", generator: &practiceGenerator{err: context.DeadlineExceeded}, status: 200, source: "seed"},
{name: "invalid", generator: &practiceGenerator{invalid: true}, status: 200, source: "seed"},
{name: "save failure", generator: &practiceGenerator{}, saveError: true, status: 200, source: "seed"},
{name: "idempotent retry", generator: &practiceGenerator{}, existing: true, status: 200, source: "flowise"},
{name: "database unavailable", generator: &practiceGenerator{}, dbError: true, status: 500},
} {
t.Run(test.name, func(t *testing.T) {
data := &practiceTestStore{courseTestStore: &courseTestStore{}, saveError: test.saveError, existing: test.existing, selectionError: test.dbError}
server := &Server{store: data, logger: slog.New(slog.NewTextHandler(io.Discard, nil))}
if test.generator != nil {
server.courseGenerator = test.generator
}
w := httptest.NewRecorder()
server.nextCoursePractice(w, courseRequest("POST", "/", `{"request_id":"request_123"}`))
if w.Code != test.status {
t.Fatalf("status %d: %s", w.Code, w.Body.String())
}
if test.status != 200 {
return
}
var result domain.CoursePracticeResult
if err := json.Unmarshal(w.Body.Bytes(), &result); err != nil {
t.Fatal(err)
}
if result.Source != test.source {
t.Fatalf("source %s", result.Source)
}
if strings.Contains(w.Body.String(), "solution") || strings.Contains(w.Body.String(), "explanation") {
t.Fatal("leaked key")
}
if test.existing && test.generator.calls != 0 {
t.Fatal("regenerated idempotent request")
}
if test.generator != nil && test.generator.invalid && data.saved != 0 {
t.Fatal("stored invalid task")
}
})
}
}
func TestCoursePracticeRejectsClientSelectedGoals(t *testing.T) {
server := &Server{}
for _, body := range []string{`{}`, `{"request_id":"short"}`, `{"request_id":"request_123","skill":"grammar"}`, `{"request_id":"request_123"} {}`, strings.Repeat(" ", 1100)} {
w := httptest.NewRecorder()
server.nextCoursePractice(w, courseRequest(http.MethodPost, "/", body))
if w.Code != 400 {
t.Fatalf("status %d", w.Code)
}
}
}
+128
View File
@@ -0,0 +1,128 @@
package httpapi
import (
"bytes"
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/services"
)
type courseTestStore struct {
DataStore
savedAnswer string
savedUser string
savedOK bool
key domain.CourseTaskKey
}
func (s *courseTestStore) GetPrimaryProfile(context.Context, string) (domain.LearnerProfile, error) {
return domain.LearnerProfile{TargetLanguage: "en-US", CEFRLevel: "A1"}, nil
}
func (s *courseTestStore) CourseTaskKey(_ context.Context, _, _, _, _ string) (domain.CourseTaskKey, error) {
return s.key, nil
}
func (s *courseTestStore) SaveCourseAttempt(_ context.Context, userID, _, answer string, correct bool) (string, error) {
s.savedUser, s.savedAnswer, s.savedOK = userID, answer, correct
return "cat_1", nil
}
func (s *courseTestStore) CourseModule(context.Context, string, string, string, string) (domain.CourseModuleDetail, error) {
return domain.CourseModuleDetail{Module: domain.CourseModule{ID: "a1_introductions_v1"}, Tasks: []domain.CourseTask{{ID: "task_1", Kind: "choice", Prompt: "Who?", Options: []string{"Anna", "Ben"}}}}, nil
}
func (s *courseTestStore) GetLanguage(context.Context, string) (domain.LanguageProfile, error) {
return domain.LanguageProfile{AzureLocale: "en-US", DefaultTTSVoice: "en-US-JennyNeural"}, nil
}
type courseTestSpeech struct {
services.SpeechService
text string
}
func (s *courseTestSpeech) Synthesize(_ context.Context, _, _, text string) ([]byte, string, error) {
s.text = text
return []byte("mp3"), "audio/mpeg", nil
}
func courseRequest(method, path, body string) *http.Request {
req := httptest.NewRequest(method, path, strings.NewReader(body))
req.SetPathValue("id", "task_1")
return req.WithContext(context.WithValue(req.Context(), userIDKey, "usr_1"))
}
func TestCourseModuleDoesNotExposeAnswerOrListeningTranscript(t *testing.T) {
s := &Server{store: &courseTestStore{}}
w := httptest.NewRecorder()
s.courseModule(w, courseRequest(http.MethodGet, "/course/modules/a1_introductions_v1", ""))
if w.Code != http.StatusOK {
t.Fatalf("status %d: %s", w.Code, w.Body.String())
}
if bytes.Contains(w.Body.Bytes(), []byte("accepted_answers")) || bytes.Contains(w.Body.Bytes(), []byte("solution")) || bytes.Contains(w.Body.Bytes(), []byte("audio_text")) {
t.Fatalf("course detail leaked hidden answers: %s", w.Body.String())
}
}
func TestCourseAttemptStoresBothWrongAndNormalizedCorrectAnswer(t *testing.T) {
data := &courseTestStore{key: domain.CourseTaskKey{ID: "task_1", Kind: "short_text", AcceptedAnswers: []string{"My name is Anna"}, Solution: "My name is Anna.", Explanation: "A1 sentence"}}
s := &Server{store: data}
for _, test := range []struct {
answer string
correct bool
}{{"Wrong", false}, {" MY NAME IS ANNA. ", true}} {
w := httptest.NewRecorder()
s.courseAttempt(w, courseRequest(http.MethodPost, "/course/tasks/task_1/attempts", `{"answer":`+jsonString(test.answer)+`}`))
if w.Code != http.StatusCreated {
t.Fatalf("status %d: %s", w.Code, w.Body.String())
}
if data.savedUser != "usr_1" || data.savedOK != test.correct {
t.Fatalf("saved wrong result: %#v", data)
}
var result domain.CourseAttemptResult
if err := json.Unmarshal(w.Body.Bytes(), &result); err != nil {
t.Fatal(err)
}
if result.Correct != test.correct || result.Solution == "" {
t.Fatalf("wrong response: %#v", result)
}
}
}
func jsonString(value string) string { encoded, _ := json.Marshal(value); return string(encoded) }
func TestCourseAudioOnlyUsesListeningText(t *testing.T) {
data := &courseTestStore{key: domain.CourseTaskKey{ID: "task_1", Kind: "choice", Skill: "listening", AudioText: "My name is Anna."}}
speech := &courseTestSpeech{}
s := &Server{store: data, speech: speech}
w := httptest.NewRecorder()
s.courseAudio(w, courseRequest(http.MethodGet, "/course/tasks/task_1/audio", ""))
if w.Code != http.StatusOK || speech.text != "My name is Anna." || w.Header().Get("Content-Type") != "audio/mpeg" {
t.Fatalf("unexpected audio result: %d %q", w.Code, speech.text)
}
data.key.Skill = "reading"
w = httptest.NewRecorder()
s.courseAudio(w, courseRequest(http.MethodGet, "/course/tasks/task_1/audio", ""))
if w.Code != http.StatusNotFound {
t.Fatalf("non-listening audio status %d", w.Code)
}
}
func TestListeningTranscriptIsReturnedAfterSubmission(t *testing.T) {
data := &courseTestStore{key: domain.CourseTaskKey{ID: "task_1", Kind: "choice", Skill: "listening", AudioText: "My name is Anna.", AcceptedAnswers: []string{"Anna"}, Solution: "Anna"}}
s := &Server{store: data}
w := httptest.NewRecorder()
s.courseAttempt(w, courseRequest(http.MethodPost, "/course/tasks/task_1/attempts", `{"answer":"Ben"}`))
if w.Code != http.StatusCreated {
t.Fatalf("status %d: %s", w.Code, w.Body.String())
}
var result domain.CourseAttemptResult
if err := json.Unmarshal(w.Body.Bytes(), &result); err != nil {
t.Fatal(err)
}
if result.Transcript != "My name is Anna." || result.Correct {
t.Fatalf("unexpected feedback: %#v", result)
}
}
+27 -34
View File
@@ -5,7 +5,6 @@ import (
"net/http"
"os"
"runtime"
"strings"
"time"
)
@@ -30,7 +29,8 @@ func (s *Server) debugStatus(w http.ResponseWriter, r *http.Request) {
"checks": map[string]any{
"db": s.store.DebugStatus(r.Context()),
"azure": s.azureStatus(),
"flowise": s.flowiseStatus(r.Context()),
"ai": s.aiStatus(r.Context()),
"flowise": s.aiStatus(r.Context()),
},
})
}
@@ -79,9 +79,9 @@ func (s *Server) debugConfig() map[string]any {
"azure_mock": s.cfg.AzureMock,
"azure_region": valueOr(s.cfg.AzureRegion, "not-set"),
"azure_speech_key_set": s.cfg.AzureSpeechKey != "",
"flowise_base_url": valueOr(s.cfg.FlowiseBaseURL, "not-set"),
"flowise_chatflow_set": s.cfg.FlowiseChatflow != "",
"flowise_api_key_set": s.cfg.FlowiseAPIKey != "",
"ai_provider": "direct",
"deepseek_api_key_set": s.cfg.DeepSeekAPIKey != "",
"mistral_api_key_set": s.cfg.MistralAPIKey != "",
"jwt_secret_configured": s.cfg.JWTSecret != "" && s.cfg.JWTSecret != "dev-secret-change-me",
}
}
@@ -104,40 +104,33 @@ func (s *Server) azureStatus() debugCheck {
}
func (s *Server) flowiseStatus(ctx context.Context) debugCheck {
baseURL := strings.TrimRight(s.cfg.FlowiseBaseURL, "/")
details := map[string]any{
"base_url": valueOr(baseURL, "not-set"),
"chatflow_set": s.cfg.FlowiseChatflow != "",
"api_key_set": s.cfg.FlowiseAPIKey != "",
return s.aiStatus(ctx)
}
func (s *Server) aiStatus(ctx context.Context) debugCheck {
if s.ai == nil {
return debugCheck{Status: "not_configured"}
}
if baseURL == "" {
return debugCheck{OK: false, Status: "not_configured", Details: details}
}
start := time.Now()
checkCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
req, err := http.NewRequestWithContext(checkCtx, http.MethodGet, baseURL, nil)
b, err := s.ai.Repo.Budget(ctx)
if err != nil {
return debugCheck{OK: false, Status: "invalid_url", Error: err.Error(), Details: details}
return debugCheck{Status: "database_unavailable"}
}
resp, err := http.DefaultClient.Do(req)
profiles, err := s.ai.Repo.Profiles(ctx)
if err != nil {
return debugCheck{OK: false, Status: "unreachable", Error: err.Error(), DurationMS: time.Since(start).Milliseconds(), Details: details}
return debugCheck{Status: "database_unavailable"}
}
defer resp.Body.Close()
ok := resp.StatusCode < 500
status := "reachable"
if !ok {
status = "server_error"
active := 0
for _, p := range profiles {
if p.Enabled && s.ai.Configured(p.Provider) {
active++
}
}
return debugCheck{
OK: ok,
Status: status,
HTTPStatus: resp.StatusCode,
DurationMS: time.Since(start).Milliseconds(),
Details: details,
ok := active > 0 && b.MonthlyLimit > 0 && b.MonthCommitted < b.MonthlyLimit && (b.DailyLimit == 0 || b.DayCommitted < b.DailyLimit)
status := "setup_required"
if ok {
status = "configured"
}
return debugCheck{OK: ok, Status: status, Details: map[string]any{"active_profiles": active, "deepseek_configured": s.ai.Configured("deepseek"), "mistral_configured": s.ai.Configured("mistral"), "budget": b}}
}
func (s *Server) debugAI(w http.ResponseWriter, r *http.Request) {
writeJSON(w, 200, map[string]any{"request_id": requestID(r), "ai": s.aiStatus(r.Context())})
}
+1 -1
View File
@@ -84,7 +84,7 @@ func (s *Server) cors(next http.Handler) http.Handler {
w.Header().Set("Vary", "Origin")
w.Header().Set("Access-Control-Allow-Credentials", "true")
w.Header().Set("Access-Control-Allow-Headers", "Authorization, Content-Type")
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PATCH, DELETE, OPTIONS")
w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE, OPTIONS")
w.Header().Set("Access-Control-Expose-Headers", "X-Request-ID")
}
if r.Method == http.MethodOptions {
@@ -0,0 +1,35 @@
package httpapi
import (
"context"
"errors"
"net/http"
"speech-learning-api/internal/domain"
"time"
)
type pronunciationStore interface {
PronunciationProfile(context.Context, string, string, time.Time) (domain.PronunciationProfile, error)
PlanPronunciation(context.Context, string, string, time.Time) (domain.PronunciationPlan, error)
FailPronunciationPlan(context.Context, string, string) error
}
func (s *Server) pronunciationProfile(w http.ResponseWriter, r *http.Request) {
repo, ok := s.store.(pronunciationStore)
if !ok {
writeError(w, 503, errors.New("Ausspracheprofil nicht verfügbar"))
return
}
user := currentUserID(r)
profile, err := s.store.GetPrimaryProfile(r.Context(), user)
if err != nil {
writeError(w, 404, err)
return
}
result, err := repo.PronunciationProfile(r.Context(), user, profile.TargetLanguage, time.Now().UTC())
if err != nil {
writeError(w, 500, err)
return
}
writeJSON(w, 200, result)
}
@@ -0,0 +1,56 @@
package httpapi
import (
"context"
"io"
"log/slog"
"testing"
"speech-learning-api/internal/domain"
"speech-learning-api/internal/services"
)
type pronunciationHistoryStore struct {
DataStore
user, language, level string
fallbackAvoid []string
}
func (s *pronunciationHistoryStore) RecentPronunciationTexts(_ context.Context, user, language, level string) ([]string, error) {
s.user, s.language, s.level = user, language, level
return []string{"Saved after reload."}, nil
}
func (s *pronunciationHistoryStore) NextLessonAndExercise(_ context.Context, _ domain.LearnerProfile, avoid ...string) (domain.Lesson, domain.Exercise, error) {
s.fallbackAvoid = avoid
return domain.Lesson{}, domain.Exercise{Source: "seed"}, nil
}
type pronunciationHistoryTeacher struct {
services.TeacherAgent
request domain.GeneratedExerciseRequest
}
func (t *pronunciationHistoryTeacher) NextExercise(_ context.Context, request domain.GeneratedExerciseRequest) (domain.GeneratedExercise, error) {
t.request = request
return domain.GeneratedExercise{}, nil
}
func TestPronunciationLoadsHistoryWithoutClientIDs(t *testing.T) {
for _, client := range [][]string{nil, {"From browser."}} {
repo, teacher := &pronunciationHistoryStore{}, &pronunciationHistoryTeacher{}
s := &Server{store: repo, teacher: teacher, logger: slog.New(slog.NewTextHandler(io.Discard, nil))}
_, _, err := s.nextAgentExercise(context.Background(), domain.User{ID: "learner"}, domain.LearnerProfile{TargetLanguage: "en-US", CEFRLevel: "A1"}, domain.ProgressSummary{}, client)
if err != nil {
t.Fatal(err)
}
if repo.user != "learner" || repo.language != "en-US" || repo.level != "A1" {
t.Fatal("wrong history scope")
}
avoid := teacher.request.AvoidReferenceTexts
if len(avoid) != len(client)+1 || avoid[len(avoid)-1] != "Saved after reload." {
t.Fatalf("history not passed to generator: %v", avoid)
}
if len(repo.fallbackAvoid) != len(client) {
t.Fatal("history exhausted fixed fallback")
}
}
}
+92 -12
View File
@@ -25,6 +25,7 @@ type DataStore interface {
NextLessonAndExercise(ctx context.Context, profile domain.LearnerProfile, avoidReferenceText ...string) (domain.Lesson, domain.Exercise, error)
SaveGeneratedExercise(ctx context.Context, userID string, generated domain.GeneratedExercise) (domain.Lesson, domain.Exercise, error)
GetExercise(ctx context.Context, id, userID string) (domain.Exercise, error)
RecentPronunciationTexts(ctx context.Context, userID, language, level string) ([]string, error)
SaveAttempt(ctx context.Context, attempt domain.Attempt) (domain.Attempt, error)
Progress(ctx context.Context, userID string, limit int) (domain.ProgressSummary, error)
AdminOverview(ctx context.Context) (domain.AdminOverview, error)
@@ -32,20 +33,33 @@ type DataStore interface {
CreateConversationSession(ctx context.Context, userID, targetLanguage, cefrLevel string) (domain.ConversationSession, error)
SaveConversationTurn(ctx context.Context, turn domain.ConversationTurn) (domain.ConversationTurn, error)
DebugStatus(ctx context.Context) domain.DebugDBStatus
CourseModules(ctx context.Context, userID, language, level string) ([]domain.CourseModule, error)
CourseModule(ctx context.Context, userID, language, level, id string) (domain.CourseModuleDetail, error)
CourseTaskKey(ctx context.Context, taskID, userID, language, level string) (domain.CourseTaskKey, error)
SaveCourseAttempt(ctx context.Context, userID, taskID, answer string, correct bool) (string, error)
SelectCoursePractice(ctx context.Context, userID, moduleID string) (domain.CoursePracticeSelection, error)
CoursePractice(ctx context.Context, userID, moduleID string) ([]domain.CourseTask, error)
CoursePracticeByRequest(ctx context.Context, userID, moduleID, requestID string) (domain.CoursePracticeResult, error)
CoursePracticeFallback(ctx context.Context, userID, seedID string) (domain.CoursePracticeResult, error)
SaveGeneratedCourseTask(ctx context.Context, userID, requestID string, out domain.GeneratedCourseTask) (domain.CoursePracticeResult, error)
}
type Server struct {
cfg config.Config
logger *slog.Logger
store DataStore
auth *services.AuthService
speech services.SpeechService
teacher services.TeacherAgent
started time.Time
ai *services.AIService
course *services.CourseEngine
cfg config.Config
logger *slog.Logger
store DataStore
auth *services.AuthService
speech services.SpeechService
teacher services.TeacherAgent
courseGenerator services.CourseTaskGenerator
started time.Time
}
func NewServer(cfg config.Config, logger *slog.Logger, store DataStore, auth *services.AuthService, speech services.SpeechService, teacher services.TeacherAgent) *Server {
return &Server{cfg: cfg, logger: logger, store: store, auth: auth, speech: speech, teacher: teacher, started: time.Now()}
generator, _ := teacher.(services.CourseTaskGenerator)
return &Server{courseGenerator: generator, cfg: cfg, logger: logger, store: store, auth: auth, speech: speech, teacher: teacher, started: time.Now()}
}
func (s *Server) Routes() http.Handler {
@@ -60,17 +74,45 @@ func (s *Server) Routes() http.Handler {
mux.Handle("GET /languages", s.requireAuth(http.HandlerFunc(s.languages)))
mux.Handle("GET /languages/{code}/voices", s.requireAuth(http.HandlerFunc(s.languageVoices)))
mux.Handle("GET /dashboard", s.requireAuth(http.HandlerFunc(s.dashboard)))
mux.Handle("GET /pronunciation/profile", s.requireAuth(http.HandlerFunc(s.pronunciationProfile)))
mux.Handle("GET /progress", s.requireAuth(http.HandlerFunc(s.progress)))
mux.Handle("POST /lessons/next", s.requireAuth(http.HandlerFunc(s.nextLesson)))
mux.Handle("GET /practice/exercises/{id}/audio", s.requireAuth(http.HandlerFunc(s.exerciseAudio)))
mux.Handle("POST /practice/attempts", s.requireAuth(http.HandlerFunc(s.createAttempt)))
mux.Handle("GET /course/catalog", s.requireAuth(http.HandlerFunc(s.adaptiveCatalog)))
mux.Handle("POST /course/modules/{id}/tasks/next", s.requireAuth(http.HandlerFunc(s.adaptiveNext)))
mux.Handle("GET /course/modules/{id}/tasks", s.requireAuth(http.HandlerFunc(s.adaptiveHistory)))
mux.Handle("GET /course/jobs/{id}", s.requireAuth(http.HandlerFunc(s.adaptiveJob)))
mux.Handle("POST /course/jobs/{id}/retry", s.requireAuth(http.HandlerFunc(s.adaptiveRetryJob)))
mux.Handle("GET /course/tasks/{id}", s.requireAuth(http.HandlerFunc(s.adaptiveTask)))
mux.Handle("POST /course/tasks/{id}/audio-attempts", s.requireAuth(http.HandlerFunc(s.adaptiveAudioAttempt)))
mux.Handle("GET /course/attempts/{id}", s.requireAuth(http.HandlerFunc(s.adaptiveGetAttempt)))
mux.Handle("POST /course/attempts/{id}/retry", s.requireAuth(http.HandlerFunc(s.adaptiveRetryAttempt)))
mux.Handle("POST /course/exams", s.requireAuth(http.HandlerFunc(s.adaptiveNewExam)))
mux.Handle("GET /course/exams/{id}", s.requireAuth(http.HandlerFunc(s.adaptiveExam)))
mux.Handle("GET /course/modules", s.requireAuth(http.HandlerFunc(s.courseModules)))
mux.Handle("POST /course/modules/{id}/practice/next", s.requireAuth(http.HandlerFunc(s.nextCoursePractice)))
mux.Handle("GET /course/modules/{id}/practice", s.requireAuth(http.HandlerFunc(s.coursePractice)))
mux.Handle("GET /course/modules/{id}", s.requireAuth(http.HandlerFunc(s.courseModule)))
mux.Handle("POST /course/tasks/{id}/attempts", s.requireAuth(http.HandlerFunc(s.courseAttempt)))
mux.Handle("GET /course/tasks/{id}/audio", s.requireAuth(http.HandlerFunc(s.courseAudio)))
mux.Handle("POST /conversation/start", s.requireAuth(http.HandlerFunc(s.startConversation)))
mux.Handle("POST /conversation/{id}/turn", s.requireAuth(http.HandlerFunc(s.conversationTurn)))
mux.Handle("GET /admin/overview", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.adminOverview))))
mux.Handle("GET /admin/users", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.adminUsers))))
mux.Handle("GET /admin/ai/settings", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiSettings))))
mux.Handle("PUT /admin/ai/profiles/{action}", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiSaveProfile))))
mux.Handle("PUT /admin/ai/budget", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiSaveBudget))))
mux.Handle("GET /admin/ai/providers/{provider}/models", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiModels))))
mux.Handle("GET /admin/ai/usage", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiUsage))))
mux.Handle("GET /admin/ai/calls/{id}", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiCallDetail))))
mux.Handle("POST /admin/ai/calls/{id}/resolve", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiResolve))))
mux.Handle("POST /admin/ai/quality", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiQuality))))
mux.Handle("POST /admin/ai/test", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.aiTest))))
if s.cfg.DebugEnabled {
mux.Handle("GET /debug/status", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugStatus))))
mux.Handle("GET /debug/db", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugDB))))
mux.Handle("GET /debug/ai", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugAI))))
mux.Handle("GET /debug/flowise", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugFlowise))))
mux.Handle("GET /debug/azure", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugAzure))))
mux.Handle("GET /debug/runtime", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.debugRuntime))))
@@ -266,11 +308,32 @@ func (s *Server) nextLesson(w http.ResponseWriter, r *http.Request) {
}
func (s *Server) nextAgentExercise(ctx context.Context, user domain.User, profile domain.LearnerProfile, progress domain.ProgressSummary, avoidReferenceTexts []string) (domain.Lesson, domain.Exercise, error) {
// Keep fallback exercises available even when the learner has already used
// every seed. The broader persisted history constrains generated sentences.
fallbackAvoid := append([]string{}, avoidReferenceTexts...)
recent, err := s.store.RecentPronunciationTexts(ctx, user.ID, profile.TargetLanguage, profile.CEFRLevel)
if err != nil {
return domain.Lesson{}, domain.Exercise{}, err
}
avoidReferenceTexts = append(append([]string{}, avoidReferenceTexts...), recent...)
avoidReferenceText := ""
if len(avoidReferenceTexts) > 0 {
avoidReferenceText = avoidReferenceTexts[len(avoidReferenceTexts)-1]
}
var plan *domain.PronunciationPlan
if s.cfg.PronunciationStrategy == "statistical" {
repo, ok := s.store.(pronunciationStore)
if !ok {
return domain.Lesson{}, domain.Exercise{}, errors.New("pronunciation statistics unavailable")
}
selected, err := repo.PlanPronunciation(ctx, user.ID, profile.TargetLanguage, time.Now().UTC())
if err != nil {
return domain.Lesson{}, domain.Exercise{}, err
}
plan = &selected
}
generated, err := s.teacher.NextExercise(ctx, domain.GeneratedExerciseRequest{
TrainingPlan: plan,
UserID: user.ID,
Profile: profile,
Progress: progress,
@@ -283,7 +346,11 @@ func (s *Server) nextAgentExercise(ctx context.Context, user domain.User, profil
AvoidReferenceText: avoidReferenceText,
AvoidReferenceTexts: avoidReferenceTexts,
})
if err == nil && generated.Source == "flowise" && strings.TrimSpace(generated.ReferenceText) != "" {
if err == nil && (generated.Source == "flowise" || generated.Source == "ai") && strings.TrimSpace(generated.ReferenceText) != "" {
generated.TrainingPlan = plan
if plan != nil && plan.Mode == "transfer" {
plan.CandidateWord = generated.CandidateWord
}
lesson, exercise, saveErr := s.store.SaveGeneratedExercise(ctx, user.ID, generated)
if saveErr == nil {
s.logger.Info("next exercise selected", "request_id", ctx.Value(requestIDKey), "source", exercise.Source, "exercise_id", exercise.ID)
@@ -292,9 +359,16 @@ func (s *Server) nextAgentExercise(ctx context.Context, user domain.User, profil
s.logger.Warn("saving generated exercise failed, using seed fallback", "error", saveErr)
}
if err != nil {
s.logger.Warn("flowise next exercise failed, using seed fallback", "error", err)
s.logger.Warn("AI next exercise failed, using seed fallback", "error", err)
}
lesson, exercise, err := s.store.NextLessonAndExercise(ctx, profile, avoidReferenceTexts...)
if plan != nil {
if repo, ok := s.store.(pronunciationStore); ok {
if planErr := repo.FailPronunciationPlan(ctx, user.ID, plan.ID); planErr != nil {
s.logger.Warn("pronunciation plan cleanup failed", "error", planErr)
}
}
}
lesson, exercise, err := s.store.NextLessonAndExercise(ctx, profile, fallbackAvoid...)
if err == nil {
s.logger.Info("next exercise selected", "request_id", ctx.Value(requestIDKey), "source", exercise.Source, "exercise_id", exercise.ID)
}
@@ -400,7 +474,8 @@ func (s *Server) createAttempt(w http.ResponseWriter, r *http.Request) {
return
}
attempt, err := s.store.SaveAttempt(r.Context(), domain.Attempt{
UserID: currentUserID(r),
UserID: currentUserID(r),
Provider: result.Provider, Measurement: &result,
ExerciseID: exercise.ID,
TargetLanguage: exercise.TargetLanguage,
RecognizedText: result.RecognizedText,
@@ -416,6 +491,11 @@ func (s *Server) createAttempt(w http.ResponseWriter, r *http.Request) {
writeError(w, http.StatusInternalServerError, err)
return
}
if s.course != nil {
if err := s.course.Repo.SyncLegacyForExercise(r.Context(), exercise.ID); err != nil {
s.logger.Warn("legacy speech evidence sync failed", "error", err)
}
}
writeJSON(w, http.StatusCreated, map[string]any{"attempt": attempt, "teacher": teacher, "provider": result.Provider})
}