ai-app: suggestapi verdrahtet (CLS-06 bis CLS-09) #437
No files matched your search
@@ -18,8 +18,10 @@ import (
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/decisionaudit"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/docchat"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/docchatapi"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/doclang"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/extract"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/extractapi"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/extractconfirmapi"
|
||||
@@ -29,6 +31,7 @@ import (
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/metadatapushclient"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/moduletype"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/moduletypeapi"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/originmark"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider/ollama"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/queue"
|
||||
@@ -39,10 +42,12 @@ import (
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/routingsuggestapi"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/semanticsearch"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/semanticsearchapi"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/suggestapi"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/summarize"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/summaryapi"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/threadsummarize"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/vectorindex"
|
||||
"gitea.perlbach24.de/scripte/nexarch/common/auditclient"
|
||||
"gitea.perlbach24.de/scripte/nexarch/common/policyclient"
|
||||
"gitea.perlbach24.de/scripte/nexarch/common/tenantregistryclient"
|
||||
)
|
||||
@@ -63,6 +68,7 @@ type config struct {
|
||||
policyURL string
|
||||
policyServiceToken string
|
||||
policyDisabled bool
|
||||
languages *doclang.Registry
|
||||
}
|
||||
|
||||
// policyClient liefert nil nur mit NEXARCH_AI_APP_POLICY_DISABLED=1.
|
||||
@@ -119,6 +125,11 @@ func loadConfig(getenv func(string) string) (config, error) {
|
||||
if cfg.policyURL == "" && !cfg.policyDisabled {
|
||||
return config{}, errors.New("ai-app: NEXARCH_AI_APP_POLICY_URL ist erforderlich (oder NEXARCH_AI_APP_POLICY_DISABLED=1 als Uebergang)")
|
||||
}
|
||||
languages, err := doclang.LoadRegistryFile(getenv(doclang.EnvLanguagesFile))
|
||||
if err != nil {
|
||||
return config{}, err
|
||||
}
|
||||
cfg.languages = languages
|
||||
if cfg.addr == "" {
|
||||
cfg.addr = defaultListenAddr
|
||||
}
|
||||
@@ -193,6 +204,31 @@ func build(pool *pgxpool.Pool, cfg config, prov provider.Provider, workerID stri
|
||||
log.Print("ai-app: NEXARCH_AI_APP_CORE_BASE_URL nicht gesetzt, Objekttyp-Registrierung (GOV-01) deaktiviert")
|
||||
}
|
||||
|
||||
registry := cfg.languages
|
||||
if registry == nil {
|
||||
registry = doclang.DefaultRegistry()
|
||||
}
|
||||
langStore := &doclang.Store{Pool: pool}
|
||||
markerStore := &originmark.Store{Pool: pool}
|
||||
suggest := &suggestapi.Server{
|
||||
Provider: prov,
|
||||
Model: cfg.model,
|
||||
Resolver: &doclang.Resolver{Registry: registry, Tenants: langStore},
|
||||
Languages: langStore,
|
||||
Markers: markerStore,
|
||||
ServiceToken: cfg.serviceToken,
|
||||
}
|
||||
// CLS-09: ohne Core-Audit gibt es keine Uebernahme-Protokollierung.
|
||||
if cfg.coreBaseURL != "" {
|
||||
suggest.Adopt = &originmark.Service{
|
||||
Markers: markerStore,
|
||||
Audit: decisionaudit.NewRecorder(auditclient.New(cfg.coreBaseURL, cfg.coreServiceToken)),
|
||||
}
|
||||
} else {
|
||||
log.Print("ai-app: NEXARCH_AI_APP_CORE_BASE_URL nicht gesetzt, Uebernahme-Protokollierung (/suggest/adopt) deaktiviert")
|
||||
}
|
||||
suggest.RegisterRoutes(mux)
|
||||
|
||||
quotaStore := quota.NewStore(pool, nil)
|
||||
q := queue.NewQueue(pool, 5*time.Minute)
|
||||
q.SetQuotaEnforcer(quotaStore)
|
||||
|
||||
@@ -165,6 +165,20 @@ func TestBuild_AllPackagesRegistered(t *testing.T) {
|
||||
if resp := get("POST", "/invoices/extract", `{"text":""}`); resp.StatusCode == http.StatusNotFound {
|
||||
t.Errorf("extractapi route nicht registriert (404)")
|
||||
}
|
||||
|
||||
// suggestapi (CLS-06..09): Mandantenkonfiguration laeuft gegen die echten Tabellen.
|
||||
if resp := get("PUT", "/tenants/acme/language", `{"language":"en"}`); resp.StatusCode != http.StatusOK {
|
||||
t.Errorf("suggestapi language status = %d, want 200", resp.StatusCode)
|
||||
}
|
||||
if resp := get("PUT", "/tenants/acme/origin-marker", `{"marker":"ki"}`); resp.StatusCode != http.StatusOK {
|
||||
t.Errorf("suggestapi origin-marker status = %d, want 200", resp.StatusCode)
|
||||
}
|
||||
if resp := get("POST", "/suggest/title", `{"tenant_slug":"acme","text":""}`); resp.StatusCode != http.StatusBadRequest {
|
||||
t.Errorf("suggestapi title status = %d, want 400", resp.StatusCode)
|
||||
}
|
||||
if resp := get("POST", "/suggest/adopt", `{}`); resp.StatusCode != http.StatusServiceUnavailable {
|
||||
t.Errorf("suggestapi adopt ohne Core-URL status = %d, want 503", resp.StatusCode)
|
||||
}
|
||||
}
|
||||
|
||||
// AK2 + Pruefung 2: ein echter Inferenz-Auftrag durchlaeuft die Warteschlange
|
||||
@@ -225,3 +239,20 @@ func TestLoadConfig_PolicyRequiredUnlessDisabled(t *testing.T) {
|
||||
t.Fatalf("mit POLICY_DISABLED=1 darf der Start nicht scheitern: %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadConfig_LanguagesFile(t *testing.T) {
|
||||
env := map[string]string{
|
||||
"NEXARCH_AI_APP_TENANT_DSN": "postgres://x",
|
||||
"NEXARCH_AI_APP_SERVICE_TOKEN": "tok",
|
||||
"NEXARCH_AI_APP_POLICY_DISABLED": "1",
|
||||
}
|
||||
get := func(k string) string { return env[k] }
|
||||
cfg, err := loadConfig(get)
|
||||
if err != nil || cfg.languages == nil {
|
||||
t.Fatalf("standardsprachen erwartet: %v", err)
|
||||
}
|
||||
env["NEXARCH_AI_LANGUAGES_FILE"] = filepath.Join(t.TempDir(), "fehlt.json")
|
||||
if _, err := loadConfig(get); err == nil || !strings.Contains(err.Error(), "NEXARCH_AI_LANGUAGES_FILE") {
|
||||
t.Fatalf("klarer fehler bei fehlender sprachdatei erwartet, bekam %v", err)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
# CLS-06 – Automatischer Titelvorschlag – Prüfprotokoll
|
||||
|
||||
Datum: 2026-11-06. Host: Entwicklungshost 192.168.1.204. Externer Ollama-Server `office.sysops.de:11435` (Text), Modell `gemma4:26b` (`gpt-oss:20b` aus CLS-03 ist dort nicht mehr verfügbar). Ausschließlich synthetische Dokumente.
|
||||
|
||||
## Umsetzung
|
||||
|
||||
Neues Paket `ai/internal/titlesuggest`: `Suggester.Suggest(ctx, moduleContext, language, documentText)` liefert bis zu 3 `Suggestion{Title, Confidence}`. Baut auf `provider.Provider` (ENG-01) auf, ohne Schreibpfad. Titel werden von Leerraum bereinigt, auf 120 Zeichen gekürzt und case-unabhängig dedupliziert. Kaputte Modellantwort ergibt eine leere Liste.
|
||||
|
||||
## Akzeptanzkriterien
|
||||
|
||||
| # | Kriterium | Ergebnis |
|
||||
|---|---|---|
|
||||
| 1 | Bis zu drei Titelvorschläge mit Konfidenz | **Erfüllt.** `TestSuggest_ReturnsConfidencePerTitle`, Konfidenz auf [0,1] geklammert. |
|
||||
| 2 | Titel bereinigt, gekürzt, ohne Dopplung | **Erfüllt.** `TestSuggest_DedupTrimAndLimit`. |
|
||||
| 3 | Vorschlag ohne automatische Übernahme | **Erfüllt.** Strukturell: kein Pool, kein Client außer `provider.Provider`. |
|
||||
| 4 | Fehlerhafte Modellantwort ergibt leere Liste statt Fehler | **Erfüllt.** `TestSuggest_GarbageYieldsEmpty`; Providerfehler und fehlender Provider werden als Fehler gemeldet (`TestSuggest_ProviderErrorAndNil`). |
|
||||
|
||||
## Prüfungen vor der Abnahme
|
||||
|
||||
| # | Prüfung | Zielwert | Ergebnis |
|
||||
|---|---|---|---|
|
||||
| 1 | Akzeptanzkriterien mit Mock-Provider belegt | alle 4 | **Bestanden.** 4/4 Unit-Tests grün. |
|
||||
| 2 | Trefferquote an synthetischem Testset gegen echtes Modell | dokumentiert | **Bestanden, 5/5.** `TestSuggest_RealInference_Accuracy`: Rechnung, Vertrag, Lieferschein, Zahlungserinnerung, englische Rechnung; jeweils enthielt mindestens ein Titel den erwarteten Begriff. Laufzeit 54 s. |
|
||||
| 3 | Keine automatische Übernahme geprüft | strukturell | **Bestanden.** Siehe AK3. |
|
||||
|
||||
## Einschränkungen
|
||||
|
||||
- Testset mit 5 Fällen; "Treffer" heißt: ein erwarteter Begriff kommt im Titel vor, nicht, dass der Titel sprachlich optimal ist.
|
||||
- Keine HTTP-API und keine Verdrahtung in `cmd/ai-app` (nicht Teil der Kriterien).
|
||||
- Der Parameter `language` ist ein reiner Prompt-Hinweis; die Spracherkennung liefert CLS-08.
|
||||
@@ -0,0 +1,33 @@
|
||||
# CLS-07 – Automatischer Korrespondenten-Vorschlag – Prüfprotokoll
|
||||
|
||||
Datum: 2026-11-06. Host: Entwicklungshost 192.168.1.204. Externer Ollama-Server `office.sysops.de:11435` (Text), Modell `gemma4:26b`. Ausschließlich synthetische Dokumente, keine echten Kunden- oder Mandantendaten.
|
||||
|
||||
## Umsetzung
|
||||
|
||||
Neues Paket `ai/internal/correspondentsuggest`: `Suggester.Suggest(ctx, existing, moduleContext, documentText)` liefert `(Suggestion{Name, Confidence, Existing}, ok, error)`. Ein Treffer auf einen bekannten Korrespondenten (case- und leerraumunabhängig) übernimmt dessen exakte Schreibweise und setzt `Existing=true`. Ohne erkennbaren Korrespondenten ist `ok=false`. Kein Schreibpfad.
|
||||
|
||||
## Akzeptanzkriterien
|
||||
|
||||
| # | Kriterium | Ergebnis |
|
||||
|---|---|---|
|
||||
| 1 | Korrespondent mit Konfidenz | **Erfüllt.** `TestSuggest_NormalizesToExisting`, Konfidenz geklammert (`TestSuggest_NewCorrespondentNotMarkedExisting`). |
|
||||
| 2 | Bekannter Korrespondent übernimmt exakte Schreibweise, als bestehend markiert | **Erfüllt.** `TestSuggest_NormalizesToExisting`. |
|
||||
| 3 | Kein erkennbarer Korrespondent ergibt keinen Vorschlag | **Erfüllt.** `TestSuggest_NoneOrGarbage` (leerer Name, Müll, abgeschnittenes JSON). |
|
||||
| 4 | Vorschlag ohne automatische Übernahme | **Erfüllt.** Strukturell, kein Schreibpfad. |
|
||||
|
||||
## Prüfungen vor der Abnahme
|
||||
|
||||
| # | Prüfung | Zielwert | Ergebnis |
|
||||
|---|---|---|---|
|
||||
| 1 | Akzeptanzkriterien mit Mock-Provider belegt | alle 4 | **Bestanden.** 4/4 Unit-Tests grün. |
|
||||
| 2 | Trefferquote an synthetischem Testset gegen echtes Modell | dokumentiert | **Bestanden, 4/4** im zweiten Lauf (Fälle: 3 bekannte Korrespondenten, 1 neuer). Laufzeit 66 s. |
|
||||
| 3 | Keine echten Kunden-/Mandantendaten im Testset | keine | **Bestanden.** Nur Muster-/Beispiel-Namen. |
|
||||
|
||||
## Befund und Korrektur
|
||||
|
||||
Erster Realtest-Lauf: 3/4. Bei unbekanntem Absender ("Neuer Absender KG") lieferte das Modell keinen Namen, weil der Prompt "bevorzugt exakt einen davon wählen" zu stark auf die Liste festlegte. Prompt geändert auf "wähle exakt einen davon, wenn er der Absender ist; ist der Absender keiner davon, nenne ihn so, wie er im Dokument steht". Zweiter Lauf: 4/4. Unit-Tests blieben grün.
|
||||
|
||||
## Einschränkungen
|
||||
|
||||
- Testset mit 4 Fällen, ein Fall für den Pfad "neuer Korrespondent".
|
||||
- Anlage neuer Korrespondenten im DMS, API und Verdrahtung in `cmd/ai-app` sind nicht Teil der Kachel.
|
||||
@@ -0,0 +1,34 @@
|
||||
# CLS-08 – Mehrsprachige Dokumentanalyse – Prüfprotokoll
|
||||
|
||||
Datum: 2026-11-06. Host: Entwicklungshost 192.168.1.204 (Wegwerf-Rolle/DB `cls08_test`, nach Abschluss entfernt).
|
||||
|
||||
## Umsetzung
|
||||
|
||||
- Neues Paket `ai/internal/doclang`: `Registry` mit Stoppwortlisten je Sprache (Deutsch, Englisch eingebaut), `Detect(text)` und `Resolver.Resolve(ctx, tenant, explicitDocLang, text)`.
|
||||
- Weitere Sprachen ohne Codeänderung: JSON-Datei über `NEXARCH_AI_LANGUAGES_FILE` (`[{"code","name","stopwords"}]`).
|
||||
- Ausgabesprache je Mandant in Tabelle `ai_tenant_languages` (Migration `0013`), bei jedem Aufruf live gelesen.
|
||||
- `tagsuggest.Suggester.Language` nimmt die Ausgabesprache in den Prompt auf; bestehende Tags anderer Sprache behalten Vorrang vor neuen. `titlesuggest` übernahm die Sprache bereits als Parameter (CLS-06).
|
||||
|
||||
## Akzeptanzkriterien
|
||||
|
||||
| # | Kriterium | Ergebnis |
|
||||
|---|---|---|
|
||||
| 1 | Dokumentsprache erkannt oder per Parameter vorgegeben | **Erfüllt.** `TestDetect_GermanAndEnglish`, `TestResolve_ExplicitOverridesDetectionAndUnknownFails` (unbekannter Code ergibt `ErrUnknownLanguage`). Unklare Texte ergeben keine Sprache statt einer Fehlzuordnung (`TestDetect_UnclearYieldsNothing`). |
|
||||
| 2 | Ausgabesprache je Mandant konfigurierbar | **Erfüllt.** `TestStore_PerTenantAndLive` (echte DB, Mandantentrennung), `TestResolve_OutputFollowsTenantOtherwiseDocument`. |
|
||||
| 3 | Bestehende Tag-Taxonomie wird bei abweichender Dokumentsprache respektiert | **Teilweise belegt.** `TestSuggest_LanguageInPromptAndTaxonomyKept`: Prompt enthält Sprachvorgabe und Vorrang bestehender Tags; englisches Dokument gegen deutschen Tag ergibt die bestehende Schreibweise. Mit Stub-Provider, nicht mit echtem Modell. |
|
||||
| 4 | Deutsch und Englisch belegt, weitere Sprachen per Konfiguration | **Erfüllt.** `TestRegistry_ExtensibleByJSONWithoutCodeChange` (Französisch per JSON), `TestRegistryFromEnv`, `TestLoadJSON_RejectsBadCode`. |
|
||||
|
||||
## Prüfungen vor der Abnahme
|
||||
|
||||
| # | Prüfung | Ergebnis |
|
||||
|---|---|---|
|
||||
| 1 | Testset deutsch/englisch gemessen | **Bestanden, 20/20** (10 de, 10 en), Zielwert 90 %. `TestDetect_SyntheticTestsetAccuracy`. |
|
||||
| 2 | Wechsel der Ausgabesprache wirkt ohne Neustart | **Bestanden.** In `TestStore_PerTenantAndLive` wird die Sprache gewechselt und sofort neu gelesen. |
|
||||
| 3 | Regressionstest bestehender CLS-Funktionen | **Bestanden.** Alle bestehenden `tagsuggest`-Tests grün (Unit; die zwei Realtests wurden ohne `TEST_OLLAMA_*` übersprungen). Neues Feld `Language` ist optional, leer ergibt unveränderten Prompt (`TestSuggest_NoLanguageNoInstruction`). |
|
||||
|
||||
## Einschränkungen
|
||||
|
||||
- Das Testset hat derselbe Autor wie die Stoppwortlisten geschrieben; 20/20 ist daher optimistisch. Kurze Texte, Texte mit vielen Zahlen/Namen und gemischtsprachige Dokumente sind nicht gemessen und liefern bei zu wenigen Treffern keine Sprache.
|
||||
- AK3 ist nur mit Stub-Provider belegt, nicht gegen ein echtes Modell.
|
||||
- `classify`, `extract` und `correspondentsuggest` nutzen die Sprache noch nicht; keine Verdrahtung in `cmd/ai-app` und kein API-Endpunkt zum Setzen der Mandantensprache.
|
||||
- Keine Übersetzung von Dokumentinhalten (ausdrücklich nicht Teil der Kachel).
|
||||
@@ -0,0 +1,32 @@
|
||||
# CLS-09 – Kennzeichnung KI-gesetzter Zuordnungen – Prüfprotokoll
|
||||
|
||||
Datum: 2026-11-06. Host: Entwicklungshost 192.168.1.204 (Wegwerf-Rolle/DB `cls09_test`, nach Abschluss entfernt).
|
||||
|
||||
## Umsetzung
|
||||
|
||||
- Migration `0012_ai_origin_marker`: Tabelle `ai_origin_markers` (eine Markierung je Mandant, nicht leer).
|
||||
- Paket `ai/internal/originmark`: `Store` (Set/Get/Clear, Validierung 1 bis 64 Zeichen ohne Steuerzeichen) und `Service.Apply(ctx, Adoption)`.
|
||||
- `Apply` liefert die Markierung, die der Aufrufer an die übernommene Zuordnung hängt. Nur bei `Source=ai`; manuelle Zuordnungen bleiben unmarkiert und unprotokolliert. KI-Übernahmen gehen über `decisionaudit.Recorder` ins zentrale Audit, mit `origin_marker` im Ergebnis.
|
||||
|
||||
## Akzeptanzkriterien
|
||||
|
||||
| # | Kriterium | Ergebnis |
|
||||
|---|---|---|
|
||||
| 1 | Übernommene KI-Vorschläge tragen eine mandantenweit konfigurierbare Markierung | **Erfüllt auf Paketebene.** `TestApply_AIAdoptionGetsMarkerAndAudit`, `TestStore_PerTenantSetGetClear` (echte DB). Der Aufrufer (DMS/Mail) hängt die Markierung an; diese Anbindung existiert noch nicht. |
|
||||
| 2 | Manuelle Zuordnungen werden nicht markiert | **Erfüllt.** `TestApply_ManualNeverMarkedNorAudited`. |
|
||||
| 3 | Markierung im Audit der KI-Entscheidung nachvollziehbar | **Teilweise belegt.** Mit Fake-Recorder: `origin_marker`, `kind` und `value` stehen im Ergebnis. Echter Core-Audit (`auditclient`) nicht getestet. |
|
||||
| 4 | Ohne Konfiguration keine Markierung | **Erfüllt.** `TestApply_NoConfigNoMarkerButAudited`; die KI-Übernahme wird trotzdem protokolliert. |
|
||||
|
||||
## Prüfungen vor der Abnahme
|
||||
|
||||
| # | Prüfung | Ergebnis |
|
||||
|---|---|---|
|
||||
| 1 | Übernahme setzt die Markierung nachweislich, manuelle Zuordnung nicht | **Bestanden** (Unit). Ende-zu-Ende mit DMS: **offen**. |
|
||||
| 2 | Markierung erscheint im Entscheidungs-Audit | **Teilweise.** Siehe AK3. |
|
||||
| 3 | Mandantentrennung | **Bestanden.** `TestApply_TenantIsolation` und DB-Test (`acme`/`other`, Clear berührt `other` nicht). |
|
||||
|
||||
## Einschränkungen
|
||||
|
||||
- Kein API-Endpunkt zum Setzen der Markierung, keine Verdrahtung in `cmd/ai-app`, keine Anbindung an DMS/Mail.
|
||||
- Schlägt das Audit fehl, liefert `Apply` einen Fehler und keine Markierung; ob die Fachaktion dann trotzdem Bestand hat, entscheidet der Aufrufer.
|
||||
- Oberfläche zur Filterung nach Markierung ist nicht Teil der Kachel.
|
||||
@@ -0,0 +1,32 @@
|
||||
# ENG-09 – Weitere Provider (OpenAI-kompatible Presets, Gemini) – Prüfprotokoll
|
||||
|
||||
Datum: 2026-11-06. Host: Entwicklungshost 192.168.1.204.
|
||||
|
||||
## Umsetzung
|
||||
|
||||
- Neues Paket `ai/internal/provider/gemini`: Chat, Completion (über Chat) und Embedding gegen die Gemini-REST-API (`generateContent`, `embedContent`). Schlüssel aus `NEXARCH_AI_GEMINI_API_KEY`, optionale Basis-URL `NEXARCH_AI_GEMINI_BASE_URL`; Schlüssel nur im Header `x-goog-api-key`. Ohne Schlüssel liefert `NewFromEnv` `ErrDisabled`.
|
||||
- OpenAI-kompatible Dienste: der vorhandene `openai`-Adapter nimmt bereits eine Basis-URL (`NEXARCH_AI_OPENAI_BASE_URL`); es war keine Codeänderung nötig.
|
||||
- Opt-in je Mandant: `openai.GuardedProvider` mit `TenantGate` umschließt jeden `provider.Provider`, auch den Gemini-Adapter.
|
||||
|
||||
## Akzeptanzkriterien
|
||||
|
||||
| # | Kriterium | Ergebnis |
|
||||
|---|---|---|
|
||||
| 1 | OpenAI-kompatible Dienste ohne Codeänderung über Basis-URL und Schlüssel aus Umgebungsvariablen | **Teilweise belegt.** Mechanismus vorhanden und durch bestehende `openai`-Tests (Fake-Server mit abweichender Basis-URL) abgedeckt. Gegen OpenRouter, vLLM, LiteLLM oder DeepSeek nicht getestet (keine Zugänge). |
|
||||
| 2 | Gemini-Adapter erfüllt den Provider-Vertragstest | **Erfüllt gegen Fake-Server.** `TestContract_Gemini` (Chat, Complete, Embed über `runContract`), `TestUniformErrors` (404, 429, 500 auf die einheitlichen Codes), Timeout/Nicht-Erreichbar (`TestUnreachableAndCancelled`). Nicht gegen die echte Gemini-API. |
|
||||
| 3 | Externe Anbieter nur nach Opt-in und Residenz-Prüfung | **Teilweise belegt.** Opt-in per `GuardedProvider` belegt (`TestOptIn_GuardedProviderBlocksWithoutCallingServer`: kein Aufruf ohne Freigabe oder ohne Mandant). Datenresidenz-Prüfung (`residency`) ist nicht an den Adapter gekoppelt. |
|
||||
| 4 | Zugangsdaten ausschließlich über Umgebungsvariablen | **Erfüllt.** `TestDisabledWithoutKey`; `TestKeyNotInErrors`; Schlüssel nie in der URL (`fakeServer` prüft den Query-Parameter `key`). |
|
||||
|
||||
## Prüfungen vor der Abnahme
|
||||
|
||||
| # | Prüfung | Ergebnis |
|
||||
|---|---|---|
|
||||
| 1 | Vertragstest gegen jeden neuen Adapter | **Bestanden** (Fake-Server). Echte Gemini-API: **offen**, kein API-Schlüssel vorhanden. |
|
||||
| 2 | Opt-in-Verweigerung blockiert den Aufruf nachweislich | **Bestanden.** Server-Zähler bleibt unberührt. |
|
||||
| 3 | Keine echten Kundendaten in Tests gegen externe Dienste | **Bestanden.** Es gibt keine Tests gegen externe Dienste. |
|
||||
|
||||
## Einschränkungen
|
||||
|
||||
- Kein Lauf gegen eine echte Gemini-API; Request-/Response-Format nach der öffentlichen REST-Dokumentation nachgebaut, nicht gegen den echten Dienst verifiziert.
|
||||
- `ai-app` bindet den Adapter nicht ein; die Fehlermeldung von `GuardedProvider` nennt den Anbieter `openai`, auch wenn Gemini umschlossen ist.
|
||||
- Kopplung an `residency` und Streaming sind nicht Teil dieser Kachel.
|
||||
@@ -0,0 +1,90 @@
|
||||
package correspondentsuggest
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider"
|
||||
)
|
||||
|
||||
type Suggestion struct {
|
||||
Name string `json:"name"`
|
||||
Confidence float64 `json:"confidence"`
|
||||
Existing bool `json:"existing"`
|
||||
}
|
||||
|
||||
type Suggester struct {
|
||||
Provider provider.Provider
|
||||
Model string
|
||||
}
|
||||
|
||||
func (s *Suggester) Suggest(ctx context.Context, existing []string, moduleContext, documentText string) (Suggestion, bool, error) {
|
||||
if s.Provider == nil {
|
||||
return Suggestion{}, false, errors.New("correspondentsuggest: kein provider konfiguriert")
|
||||
}
|
||||
resp, err := s.Provider.Chat(ctx, provider.ChatRequest{
|
||||
Model: s.Model,
|
||||
Messages: []provider.Message{
|
||||
{Role: provider.RoleSystem, Content: "Du bist ein Assistent zur Absender-Erkennung. Antworte ausschließlich mit einem JSON-Objekt, ohne Erklärtext."},
|
||||
{Role: provider.RoleUser, Content: buildPrompt(existing, moduleContext, documentText)},
|
||||
},
|
||||
Temperature: 0,
|
||||
})
|
||||
if err != nil {
|
||||
return Suggestion{}, false, fmt.Errorf("correspondentsuggest: modellaufruf: %w", err)
|
||||
}
|
||||
sug, ok := parse(existing, resp.Message.Content)
|
||||
return sug, ok, nil
|
||||
}
|
||||
|
||||
func buildPrompt(existing []string, moduleContext, documentText string) string {
|
||||
var b strings.Builder
|
||||
b.WriteString("Nenne den Korrespondenten (Absender bzw. Gegenpartei) des folgenden Dokuments.\n")
|
||||
if moduleContext != "" {
|
||||
fmt.Fprintf(&b, "Kontext: das Dokument stammt aus dem Modul %q.\n", moduleContext)
|
||||
}
|
||||
if len(existing) > 0 {
|
||||
b.WriteString("Bekannte Korrespondenten (wähle exakt einen davon, wenn er der Absender ist; ist der Absender keiner davon, nenne ihn so, wie er im Dokument steht): ")
|
||||
b.WriteString(strings.Join(existing, ", "))
|
||||
b.WriteString("\n")
|
||||
}
|
||||
b.WriteString(`Antworte NUR mit einem JSON-Objekt: {"name": string, "confidence": number zwischen 0 und 1}. Ist kein Korrespondent erkennbar, setze name auf "".` + "\n\nDokument:\n")
|
||||
b.WriteString(documentText)
|
||||
return b.String()
|
||||
}
|
||||
|
||||
func parse(existing []string, raw string) (Suggestion, bool) {
|
||||
start, end := strings.IndexByte(raw, '{'), strings.LastIndexByte(raw, '}')
|
||||
if start < 0 || end < start {
|
||||
return Suggestion{}, false
|
||||
}
|
||||
var in Suggestion
|
||||
if err := json.Unmarshal([]byte(raw[start:end+1]), &in); err != nil {
|
||||
return Suggestion{}, false
|
||||
}
|
||||
name := strings.Join(strings.Fields(in.Name), " ")
|
||||
if name == "" {
|
||||
return Suggestion{}, false
|
||||
}
|
||||
out := Suggestion{Name: name, Confidence: clamp(in.Confidence)}
|
||||
for _, e := range existing {
|
||||
if strings.EqualFold(strings.Join(strings.Fields(e), " "), name) {
|
||||
out.Name, out.Existing = e, true
|
||||
break
|
||||
}
|
||||
}
|
||||
return out, true
|
||||
}
|
||||
|
||||
func clamp(v float64) float64 {
|
||||
if v < 0 {
|
||||
return 0
|
||||
}
|
||||
if v > 1 {
|
||||
return 1
|
||||
}
|
||||
return v
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
package correspondentsuggest
|
||||
|
||||
import (
|
||||
"context"
|
||||
"os"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider/ollama"
|
||||
)
|
||||
|
||||
func TestSuggest_RealInference_Accuracy(t *testing.T) {
|
||||
base, model := os.Getenv("TEST_OLLAMA_BASE_URL"), os.Getenv("TEST_OLLAMA_MODEL")
|
||||
if base == "" || model == "" {
|
||||
t.Skip("TEST_OLLAMA_BASE_URL/TEST_OLLAMA_MODEL nicht gesetzt, Realtest uebersprungen")
|
||||
}
|
||||
s := &Suggester{Provider: ollama.New(base), Model: model}
|
||||
existing := []string{"Musterfirma GmbH", "Beispiel AG", "Stadtwerke Beispielstadt"}
|
||||
|
||||
cases := []struct {
|
||||
name, text, want string
|
||||
wantExisting bool
|
||||
}{
|
||||
{"rechnung", "Musterfirma GmbH\nMusterstrasse 1, 12345 Musterstadt\n\nRechnung Nr. 2024-0451 an Beispiel Consulting\nBetrag 1.297,00 EUR", "Musterfirma GmbH", true},
|
||||
{"vertrag", "Kuendigung des Dienstleistungsvertrags\nBeispiel AG, Vorstand\nBeispielweg 5, 54321 Beispieldorf\n\nSehr geehrte Damen und Herren, hiermit kuendigen wir den Vertrag zum Quartalsende.", "Beispiel AG", true},
|
||||
{"neu", "Neuer Absender KG\nTeststrasse 9\n\nAngebot Nr. 17 fuer Buerobedarf, gueltig bis 31.12.2026.", "Neuer Absender KG", false},
|
||||
{"strom", "Stadtwerke Beispielstadt\nJahresabrechnung Strom 2026\nVerbrauch 2.431 kWh, Nachzahlung 84,12 EUR", "Stadtwerke Beispielstadt", true},
|
||||
}
|
||||
|
||||
hits := 0
|
||||
for _, c := range cases {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 90*time.Second)
|
||||
got, ok, err := s.Suggest(ctx, existing, "dms", c.text)
|
||||
cancel()
|
||||
if err != nil {
|
||||
t.Fatalf("%s: %v", c.name, err)
|
||||
}
|
||||
t.Logf("%s: ok=%v %+v", c.name, ok, got)
|
||||
if ok && got.Name == c.want && got.Existing == c.wantExisting && got.Confidence >= 0 && got.Confidence <= 1 {
|
||||
hits++
|
||||
}
|
||||
}
|
||||
t.Logf("Trefferquote: %d/%d", hits, len(cases))
|
||||
if hits < 3 {
|
||||
t.Errorf("trefferquote %d/%d unter 3/4", hits, len(cases))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
package correspondentsuggest
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"testing"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider/mock"
|
||||
)
|
||||
|
||||
func newSuggester(resp string) *Suggester {
|
||||
return &Suggester{
|
||||
Provider: &mock.Provider{ChatResponse: provider.ChatResponse{Message: provider.Message{Role: provider.RoleAssistant, Content: resp}}},
|
||||
}
|
||||
}
|
||||
|
||||
func TestSuggest_NormalizesToExisting(t *testing.T) {
|
||||
got, ok, err := newSuggester(`{"name":" muster gmbh ","confidence":0.8}`).
|
||||
Suggest(context.Background(), []string{"Beispiel AG", "Muster GmbH"}, "dms", "Brief")
|
||||
if err != nil || !ok {
|
||||
t.Fatalf("ok=%v err=%v", ok, err)
|
||||
}
|
||||
if got.Name != "Muster GmbH" || !got.Existing || got.Confidence != 0.8 {
|
||||
t.Fatalf("unerwartet: %+v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSuggest_NewCorrespondentNotMarkedExisting(t *testing.T) {
|
||||
got, ok, _ := newSuggester(`{"name":"Neu KG","confidence":7}`).Suggest(context.Background(), []string{"Alt AG"}, "", "x")
|
||||
if !ok || got.Existing || got.Confidence != 1 {
|
||||
t.Fatalf("unerwartet: %+v ok=%v", got, ok)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSuggest_NoneOrGarbage(t *testing.T) {
|
||||
for _, raw := range []string{`{"name":"","confidence":0.9}`, "nix", `{"name":`} {
|
||||
if _, ok, err := newSuggester(raw).Suggest(context.Background(), nil, "", "x"); ok || err != nil {
|
||||
t.Fatalf("raw=%q ok=%v err=%v", raw, ok, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSuggest_Errors(t *testing.T) {
|
||||
s := &Suggester{Provider: &mock.Provider{Err: errors.New("down")}}
|
||||
if _, _, err := s.Suggest(context.Background(), nil, "", "x"); err == nil {
|
||||
t.Fatal("fehler erwartet")
|
||||
}
|
||||
if _, _, err := (&Suggester{}).Suggest(context.Background(), nil, "", "x"); err == nil {
|
||||
t.Fatal("fehler erwartet")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,210 @@
|
||||
package doclang
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"os"
|
||||
"regexp"
|
||||
"strings"
|
||||
"unicode"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
const EnvLanguagesFile = "NEXARCH_AI_LANGUAGES_FILE"
|
||||
|
||||
const (
|
||||
minTokens = 5
|
||||
minBestHits = 2
|
||||
codePatternRe = `^[a-z]{2,3}$`
|
||||
)
|
||||
|
||||
var (
|
||||
ErrUnknownLanguage = errors.New("doclang: sprache nicht registriert")
|
||||
ErrInvalidCode = errors.New("doclang: sprachcode muss 2 bis 3 kleinbuchstaben haben")
|
||||
codePattern = regexp.MustCompile(codePatternRe)
|
||||
)
|
||||
|
||||
type Language struct {
|
||||
Code string `json:"code"`
|
||||
Name string `json:"name"`
|
||||
Stopwords []string `json:"stopwords"`
|
||||
}
|
||||
|
||||
type Registry struct {
|
||||
langs map[string]Language
|
||||
words map[string]map[string]bool
|
||||
}
|
||||
|
||||
func DefaultRegistry() *Registry {
|
||||
r := &Registry{langs: map[string]Language{}, words: map[string]map[string]bool{}}
|
||||
_ = r.Register(Language{Code: "de", Name: "Deutsch", Stopwords: strings.Fields(
|
||||
"der die das und ist nicht ein eine mit von zu den für auf dem des auch sich wir sie ich bei nach wird sind oder aus werden wurde über sehr nur noch")})
|
||||
_ = r.Register(Language{Code: "en", Name: "English", Stopwords: strings.Fields(
|
||||
"the and is of to that for with on are this by or from at it not have was were will would which their been you your has had")})
|
||||
return r
|
||||
}
|
||||
|
||||
func (r *Registry) Register(l Language) error {
|
||||
l.Code = strings.ToLower(strings.TrimSpace(l.Code))
|
||||
if !codePattern.MatchString(l.Code) {
|
||||
return ErrInvalidCode
|
||||
}
|
||||
if strings.TrimSpace(l.Name) == "" {
|
||||
l.Name = l.Code
|
||||
}
|
||||
set := make(map[string]bool, len(l.Stopwords))
|
||||
for _, w := range l.Stopwords {
|
||||
if w = strings.ToLower(strings.TrimSpace(w)); w != "" {
|
||||
set[w] = true
|
||||
}
|
||||
}
|
||||
r.langs[l.Code] = l
|
||||
r.words[l.Code] = set
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *Registry) Lookup(code string) (Language, bool) {
|
||||
l, ok := r.langs[strings.ToLower(strings.TrimSpace(code))]
|
||||
return l, ok
|
||||
}
|
||||
|
||||
func (r *Registry) LoadJSON(src io.Reader) error {
|
||||
var langs []Language
|
||||
if err := json.NewDecoder(src).Decode(&langs); err != nil {
|
||||
return fmt.Errorf("doclang: sprachdatei lesen: %w", err)
|
||||
}
|
||||
for _, l := range langs {
|
||||
if err := r.Register(l); err != nil {
|
||||
return fmt.Errorf("doclang: sprache %q: %w", l.Code, err)
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func RegistryFromEnv() (*Registry, error) {
|
||||
return LoadRegistryFile(os.Getenv(EnvLanguagesFile))
|
||||
}
|
||||
|
||||
// LoadRegistryFile ergaenzt die Standardsprachen um die Sprachen aus path; leerer Pfad = nur Standard.
|
||||
func LoadRegistryFile(path string) (*Registry, error) {
|
||||
r := DefaultRegistry()
|
||||
if path == "" {
|
||||
return r, nil
|
||||
}
|
||||
f, err := os.Open(path)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("doclang: %s: %w", EnvLanguagesFile, err)
|
||||
}
|
||||
defer func() { _ = f.Close() }()
|
||||
if err := r.LoadJSON(f); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return r, nil
|
||||
}
|
||||
|
||||
// Detect liefert die wahrscheinlichste registrierte Sprache oder "" bei unklarem Text.
|
||||
func (r *Registry) Detect(text string) (Language, bool) {
|
||||
tokens := strings.FieldsFunc(strings.ToLower(text), func(c rune) bool { return !unicode.IsLetter(c) })
|
||||
if len(tokens) < minTokens {
|
||||
return Language{}, false
|
||||
}
|
||||
best, second, bestCode := 0, 0, ""
|
||||
for code, words := range r.words {
|
||||
hits := 0
|
||||
for _, t := range tokens {
|
||||
if words[t] {
|
||||
hits++
|
||||
}
|
||||
}
|
||||
switch {
|
||||
case hits > best || (hits == best && code < bestCode):
|
||||
second, best, bestCode = best, hits, code
|
||||
case hits > second:
|
||||
second = hits
|
||||
}
|
||||
}
|
||||
if best < minBestHits || best == second {
|
||||
return Language{}, false
|
||||
}
|
||||
return r.langs[bestCode], true
|
||||
}
|
||||
|
||||
type TenantLanguages interface {
|
||||
Get(ctx context.Context, tenantSlug string) (string, error)
|
||||
}
|
||||
|
||||
type Resolved struct {
|
||||
Document Language
|
||||
Output Language
|
||||
}
|
||||
|
||||
type Resolver struct {
|
||||
Registry *Registry
|
||||
Tenants TenantLanguages
|
||||
}
|
||||
|
||||
// Resolve ermittelt Dokument- und Ausgabesprache. Dokumentsprache: explizit, sonst erkannt.
|
||||
// Ausgabesprache: Mandantenkonfiguration, sonst Dokumentsprache. Leer, wenn beides unbekannt.
|
||||
func (r *Resolver) Resolve(ctx context.Context, tenantSlug, explicitDocLang, text string) (Resolved, error) {
|
||||
var out Resolved
|
||||
if explicitDocLang != "" {
|
||||
l, ok := r.Registry.Lookup(explicitDocLang)
|
||||
if !ok {
|
||||
return Resolved{}, fmt.Errorf("%w: %q", ErrUnknownLanguage, explicitDocLang)
|
||||
}
|
||||
out.Document = l
|
||||
} else if l, ok := r.Registry.Detect(text); ok {
|
||||
out.Document = l
|
||||
}
|
||||
out.Output = out.Document
|
||||
code, err := r.Tenants.Get(ctx, tenantSlug)
|
||||
if err != nil {
|
||||
return Resolved{}, err
|
||||
}
|
||||
if l, ok := r.Registry.Lookup(code); ok {
|
||||
out.Output = l
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
type Store struct {
|
||||
Pool *pgxpool.Pool
|
||||
}
|
||||
|
||||
func (s *Store) Set(ctx context.Context, tenantSlug, code string) error {
|
||||
tenantSlug = strings.TrimSpace(tenantSlug)
|
||||
code = strings.ToLower(strings.TrimSpace(code))
|
||||
if tenantSlug == "" {
|
||||
return fmt.Errorf("doclang: tenantSlug darf nicht leer sein")
|
||||
}
|
||||
if !codePattern.MatchString(code) {
|
||||
return ErrInvalidCode
|
||||
}
|
||||
_, err := s.Pool.Exec(ctx, `
|
||||
INSERT INTO ai_tenant_languages (tenant_slug, language, updated_at)
|
||||
VALUES ($1, $2, now())
|
||||
ON CONFLICT (tenant_slug) DO UPDATE SET language = EXCLUDED.language, updated_at = now()
|
||||
`, tenantSlug, code)
|
||||
if err != nil {
|
||||
return fmt.Errorf("doclang: speichern: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Get liefert "" ohne Konfiguration; liest live, Aenderungen wirken ohne Neustart.
|
||||
func (s *Store) Get(ctx context.Context, tenantSlug string) (string, error) {
|
||||
var code string
|
||||
err := s.Pool.QueryRow(ctx, `SELECT language FROM ai_tenant_languages WHERE tenant_slug = $1`, tenantSlug).Scan(&code)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return "", nil
|
||||
}
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("doclang: lesen: %w", err)
|
||||
}
|
||||
return code, nil
|
||||
}
|
||||
@@ -0,0 +1,202 @@
|
||||
package doclang
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/migrate"
|
||||
"gitea.perlbach24.de/scripte/nexarch/common/testdb"
|
||||
)
|
||||
|
||||
const (
|
||||
deText = "Sehr geehrte Damen und Herren, die Rechnung ist nicht bezahlt und wird von uns mit der Mahnung an Sie gesendet."
|
||||
enText = "Dear Sirs, the invoice is not paid and will be sent to you by the reminder that we have prepared for your account."
|
||||
frJSON = `[{"code":"fr","name":"Français","stopwords":["le","la","les","et","est","des","une","pour","dans","avec"]}]`
|
||||
)
|
||||
|
||||
type fakeTenants map[string]string
|
||||
|
||||
func (f fakeTenants) Get(_ context.Context, tenant string) (string, error) { return f[tenant], nil }
|
||||
|
||||
func TestDetect_GermanAndEnglish(t *testing.T) {
|
||||
r := DefaultRegistry()
|
||||
if l, ok := r.Detect(deText); !ok || l.Code != "de" {
|
||||
t.Fatalf("de: %+v %v", l, ok)
|
||||
}
|
||||
if l, ok := r.Detect(enText); !ok || l.Code != "en" {
|
||||
t.Fatalf("en: %+v %v", l, ok)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDetect_UnclearYieldsNothing(t *testing.T) {
|
||||
r := DefaultRegistry()
|
||||
for _, txt := range []string{"", "Rechnung 2026", "xyz abc qwe rty uio pas dfg hjk"} {
|
||||
if l, ok := r.Detect(txt); ok {
|
||||
t.Errorf("%q: unerwartet %+v", txt, l)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegistry_ExtensibleByJSONWithoutCodeChange(t *testing.T) {
|
||||
r := DefaultRegistry()
|
||||
if err := r.LoadJSON(strings.NewReader(frJSON)); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
l, ok := r.Detect("Le contrat est signé et les parties des deux côtés sont dans une situation pour avec")
|
||||
if !ok || l.Code != "fr" || l.Name != "Français" {
|
||||
t.Fatalf("fr: %+v %v", l, ok)
|
||||
}
|
||||
if l, ok := r.Detect(deText); !ok || l.Code != "de" {
|
||||
t.Fatalf("de nach erweiterung: %+v %v", l, ok)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRegistryFromEnv(t *testing.T) {
|
||||
path := filepath.Join(t.TempDir(), "langs.json")
|
||||
if err := os.WriteFile(path, []byte(frJSON), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Setenv(EnvLanguagesFile, path)
|
||||
r, err := RegistryFromEnv()
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, ok := r.Lookup("fr"); !ok {
|
||||
t.Fatal("fr fehlt")
|
||||
}
|
||||
t.Setenv(EnvLanguagesFile, filepath.Join(t.TempDir(), "fehlt.json"))
|
||||
if _, err := RegistryFromEnv(); err == nil {
|
||||
t.Fatal("fehler erwartet")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadJSON_RejectsBadCode(t *testing.T) {
|
||||
r := DefaultRegistry()
|
||||
if err := r.LoadJSON(strings.NewReader(`[{"code":"Deutsch","stopwords":[]}]`)); !errors.Is(err, ErrInvalidCode) {
|
||||
t.Fatalf("err=%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolve_OutputFollowsTenantOtherwiseDocument(t *testing.T) {
|
||||
r := &Resolver{Registry: DefaultRegistry(), Tenants: fakeTenants{"acme": "de"}}
|
||||
got, err := r.Resolve(context.Background(), "acme", "", enText)
|
||||
if err != nil || got.Document.Code != "en" || got.Output.Code != "de" {
|
||||
t.Fatalf("%+v %v", got, err)
|
||||
}
|
||||
got, _ = r.Resolve(context.Background(), "other", "", enText)
|
||||
if got.Output.Code != "en" {
|
||||
t.Fatalf("ohne konfiguration: %+v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolve_ExplicitOverridesDetectionAndUnknownFails(t *testing.T) {
|
||||
r := &Resolver{Registry: DefaultRegistry(), Tenants: fakeTenants{}}
|
||||
got, err := r.Resolve(context.Background(), "acme", "de", enText)
|
||||
if err != nil || got.Document.Code != "de" {
|
||||
t.Fatalf("%+v %v", got, err)
|
||||
}
|
||||
if _, err := r.Resolve(context.Background(), "acme", "xx", enText); !errors.Is(err, ErrUnknownLanguage) {
|
||||
t.Fatalf("err=%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestResolve_UnknownTenantCodeFallsBackToDocument(t *testing.T) {
|
||||
r := &Resolver{Registry: DefaultRegistry(), Tenants: fakeTenants{"acme": "fr"}}
|
||||
got, _ := r.Resolve(context.Background(), "acme", "", enText)
|
||||
if got.Output.Code != "en" {
|
||||
t.Fatalf("%+v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func newStore(t *testing.T) *Store {
|
||||
t.Helper()
|
||||
dsn := os.Getenv("TEST_TENANT_DSN")
|
||||
if dsn == "" {
|
||||
t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
|
||||
}
|
||||
pool := testdb.Pool(t, dsn)
|
||||
dir, err := filepath.Abs("../../migrations")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
migrations, err := migrate.Load(dir)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := migrate.Up(context.Background(), pool, migrations); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return &Store{Pool: pool}
|
||||
}
|
||||
|
||||
func TestStore_PerTenantAndLive(t *testing.T) {
|
||||
s := newStore(t)
|
||||
ctx := context.Background()
|
||||
if got, err := s.Get(ctx, "acme"); err != nil || got != "" {
|
||||
t.Fatalf("%q %v", got, err)
|
||||
}
|
||||
if err := s.Set(ctx, "acme", " DE "); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := s.Set(ctx, "other", "en"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got, _ := s.Get(ctx, "acme"); got != "de" {
|
||||
t.Fatalf("acme: %q", got)
|
||||
}
|
||||
if err := s.Set(ctx, "acme", "en"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got, _ := s.Get(ctx, "acme"); got != "en" {
|
||||
t.Fatalf("wechsel ohne neustart: %q", got)
|
||||
}
|
||||
if got, _ := s.Get(ctx, "other"); got != "en" {
|
||||
t.Fatalf("other: %q", got)
|
||||
}
|
||||
if err := s.Set(ctx, "acme", "Deutsch"); !errors.Is(err, ErrInvalidCode) {
|
||||
t.Fatalf("err=%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
var testset = []struct{ code, text string }{
|
||||
{"de", "Hiermit kündigen wir den Vertrag zum Ende des Quartals und bitten um eine schriftliche Bestätigung."},
|
||||
{"de", "Die Rechnung wurde am 15. November versendet und ist innerhalb von 14 Tagen zu bezahlen."},
|
||||
{"de", "Wir bedanken uns für Ihre Bestellung und senden Ihnen die Ware in den nächsten Tagen zu."},
|
||||
{"de", "Der Mieter ist verpflichtet, die Wohnung bei Auszug in einem sauberen Zustand zu übergeben."},
|
||||
{"de", "Sehr geehrte Frau Muster, anbei erhalten Sie die Unterlagen, die Sie angefordert haben."},
|
||||
{"de", "Das Angebot gilt nur für Kunden, die sich bis zum Jahresende für den Vertrag entscheiden."},
|
||||
{"de", "Aus technischen Gründen wird die Lieferung erst nach dem Feiertag bei Ihnen eintreffen."},
|
||||
{"de", "Ich bitte Sie, mir den Termin für die Besichtigung der Räume noch heute mitzuteilen."},
|
||||
{"de", "Die Gesellschafter haben in der Versammlung beschlossen, den Gewinn auf neue Rechnung vorzutragen."},
|
||||
{"de", "Eine Kopie des Bescheids ist diesem Schreiben beigefügt und wird auch an Ihren Steuerberater gesendet."},
|
||||
{"en", "We hereby terminate the contract at the end of the quarter and ask for a written confirmation."},
|
||||
{"en", "The invoice has been sent on the fifteenth of November and is payable within fourteen days."},
|
||||
{"en", "Thank you for your order, the goods will be shipped to you within the next few days."},
|
||||
{"en", "The tenant is obliged to hand over the apartment in a clean condition when moving out."},
|
||||
{"en", "Dear Ms Sample, please find attached the documents that you have requested from us."},
|
||||
{"en", "This offer is only valid for customers who decide on the contract before the end of the year."},
|
||||
{"en", "Due to technical reasons the delivery will not arrive before the public holiday."},
|
||||
{"en", "I would like to ask you to let me know the date for the inspection of the premises today."},
|
||||
{"en", "The shareholders have resolved at the meeting that the profit will be carried forward to the next year."},
|
||||
{"en", "A copy of the decision is attached to this letter and will also be sent to your tax advisor."},
|
||||
}
|
||||
|
||||
func TestDetect_SyntheticTestsetAccuracy(t *testing.T) {
|
||||
r := DefaultRegistry()
|
||||
hits := 0
|
||||
for _, c := range testset {
|
||||
if l, ok := r.Detect(c.text); ok && l.Code == c.code {
|
||||
hits++
|
||||
} else {
|
||||
t.Logf("fehlklassifiziert/unklar (%s): %q -> %+v ok=%v", c.code, c.text, l, ok)
|
||||
}
|
||||
}
|
||||
t.Logf("Erkennungsquote: %d/%d", hits, len(testset))
|
||||
if hits < len(testset)*9/10 {
|
||||
t.Errorf("erkennungsquote %d/%d unter 90%%", hits, len(testset))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,133 @@
|
||||
package originmark
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"unicode"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/decisionaudit"
|
||||
)
|
||||
|
||||
const MaxMarkerLen = 64
|
||||
|
||||
var ErrInvalidMarker = errors.New("originmark: markierung muss 1 bis 64 druckbare zeichen ohne steuerzeichen haben")
|
||||
|
||||
type Store struct {
|
||||
Pool *pgxpool.Pool
|
||||
}
|
||||
|
||||
func validate(marker string) (string, error) {
|
||||
marker = strings.TrimSpace(marker)
|
||||
if marker == "" || len([]rune(marker)) > MaxMarkerLen {
|
||||
return "", ErrInvalidMarker
|
||||
}
|
||||
for _, r := range marker {
|
||||
if unicode.IsControl(r) {
|
||||
return "", ErrInvalidMarker
|
||||
}
|
||||
}
|
||||
return marker, nil
|
||||
}
|
||||
|
||||
func (s *Store) Set(ctx context.Context, tenantSlug, marker string) error {
|
||||
tenantSlug = strings.TrimSpace(tenantSlug)
|
||||
if tenantSlug == "" {
|
||||
return fmt.Errorf("originmark: tenantSlug darf nicht leer sein")
|
||||
}
|
||||
marker, err := validate(marker)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
_, err = s.Pool.Exec(ctx, `
|
||||
INSERT INTO ai_origin_markers (tenant_slug, marker, updated_at)
|
||||
VALUES ($1, $2, now())
|
||||
ON CONFLICT (tenant_slug) DO UPDATE SET marker = EXCLUDED.marker, updated_at = now()
|
||||
`, tenantSlug, marker)
|
||||
if err != nil {
|
||||
return fmt.Errorf("originmark: speichern: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Store) Clear(ctx context.Context, tenantSlug string) error {
|
||||
if _, err := s.Pool.Exec(ctx, `DELETE FROM ai_origin_markers WHERE tenant_slug = $1`, tenantSlug); err != nil {
|
||||
return fmt.Errorf("originmark: loeschen: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Get liefert "" ohne Konfiguration.
|
||||
func (s *Store) Get(ctx context.Context, tenantSlug string) (string, error) {
|
||||
var marker string
|
||||
err := s.Pool.QueryRow(ctx, `SELECT marker FROM ai_origin_markers WHERE tenant_slug = $1`, tenantSlug).Scan(&marker)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return "", nil
|
||||
}
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("originmark: lesen: %w", err)
|
||||
}
|
||||
return marker, nil
|
||||
}
|
||||
|
||||
type Source string
|
||||
|
||||
const (
|
||||
SourceAI Source = "ai"
|
||||
SourceManual Source = "manual"
|
||||
)
|
||||
|
||||
type Adoption struct {
|
||||
Source Source
|
||||
TenantSlug string
|
||||
Actor string
|
||||
Function string
|
||||
Model string
|
||||
PromptVersion int
|
||||
InputRef string
|
||||
Kind string
|
||||
Value string
|
||||
}
|
||||
|
||||
type MarkerReader interface {
|
||||
Get(ctx context.Context, tenantSlug string) (string, error)
|
||||
}
|
||||
|
||||
type AuditRecorder interface {
|
||||
Record(ctx context.Context, d decisionaudit.Decision) error
|
||||
}
|
||||
|
||||
type Service struct {
|
||||
Markers MarkerReader
|
||||
Audit AuditRecorder
|
||||
}
|
||||
|
||||
// Apply liefert die Herkunftsmarkierung, die der Aufrufer an die uebernommene
|
||||
// Zuordnung haengen soll; "" fuer manuelle Zuordnungen oder ohne Konfiguration.
|
||||
// Eine KI-Uebernahme wird immer im Audit festgehalten, mit Markierung falls gesetzt.
|
||||
func (s *Service) Apply(ctx context.Context, a Adoption) (string, error) {
|
||||
if a.Source != SourceAI {
|
||||
return "", nil
|
||||
}
|
||||
marker, err := s.Markers.Get(ctx, a.TenantSlug)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
result := map[string]any{"kind": a.Kind, "value": a.Value, "origin_marker": marker}
|
||||
if err := s.Audit.Record(ctx, decisionaudit.Decision{
|
||||
TenantSlug: a.TenantSlug,
|
||||
Actor: a.Actor,
|
||||
Function: a.Function,
|
||||
Model: a.Model,
|
||||
PromptVersion: a.PromptVersion,
|
||||
InputRef: a.InputRef,
|
||||
Result: result,
|
||||
}); err != nil {
|
||||
return "", fmt.Errorf("originmark: audit: %w", err)
|
||||
}
|
||||
return marker, nil
|
||||
}
|
||||
@@ -0,0 +1,141 @@
|
||||
package originmark
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/decisionaudit"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/migrate"
|
||||
"gitea.perlbach24.de/scripte/nexarch/common/testdb"
|
||||
)
|
||||
|
||||
type fakeMarkers map[string]string
|
||||
|
||||
func (f fakeMarkers) Get(_ context.Context, tenant string) (string, error) { return f[tenant], nil }
|
||||
|
||||
type fakeAudit struct {
|
||||
got []decisionaudit.Decision
|
||||
err error
|
||||
}
|
||||
|
||||
func (f *fakeAudit) Record(_ context.Context, d decisionaudit.Decision) error {
|
||||
f.got = append(f.got, d)
|
||||
return f.err
|
||||
}
|
||||
|
||||
func adoption(src Source, tenant string) Adoption {
|
||||
return Adoption{Source: src, TenantSlug: tenant, Actor: "u1", Function: "tagsuggest", Model: "m", PromptVersion: 1, InputRef: "doc-1", Kind: "tag", Value: "rechnung"}
|
||||
}
|
||||
|
||||
func TestApply_AIAdoptionGetsMarkerAndAudit(t *testing.T) {
|
||||
audit := &fakeAudit{}
|
||||
s := &Service{Markers: fakeMarkers{"acme": "ai-processed"}, Audit: audit}
|
||||
got, err := s.Apply(context.Background(), adoption(SourceAI, "acme"))
|
||||
if err != nil || got != "ai-processed" {
|
||||
t.Fatalf("got=%q err=%v", got, err)
|
||||
}
|
||||
if len(audit.got) != 1 || audit.got[0].Result["origin_marker"] != "ai-processed" || audit.got[0].Result["value"] != "rechnung" {
|
||||
t.Fatalf("audit: %+v", audit.got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestApply_ManualNeverMarkedNorAudited(t *testing.T) {
|
||||
audit := &fakeAudit{}
|
||||
s := &Service{Markers: fakeMarkers{"acme": "ai-processed"}, Audit: audit}
|
||||
got, err := s.Apply(context.Background(), adoption(SourceManual, "acme"))
|
||||
if err != nil || got != "" || len(audit.got) != 0 {
|
||||
t.Fatalf("got=%q err=%v audit=%d", got, err, len(audit.got))
|
||||
}
|
||||
}
|
||||
|
||||
func TestApply_NoConfigNoMarkerButAudited(t *testing.T) {
|
||||
audit := &fakeAudit{}
|
||||
s := &Service{Markers: fakeMarkers{}, Audit: audit}
|
||||
got, err := s.Apply(context.Background(), adoption(SourceAI, "acme"))
|
||||
if err != nil || got != "" || len(audit.got) != 1 || audit.got[0].Result["origin_marker"] != "" {
|
||||
t.Fatalf("got=%q err=%v audit=%+v", got, err, audit.got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestApply_TenantIsolation(t *testing.T) {
|
||||
s := &Service{Markers: fakeMarkers{"acme": "ai-processed"}, Audit: &fakeAudit{}}
|
||||
got, _ := s.Apply(context.Background(), adoption(SourceAI, "other"))
|
||||
if got != "" {
|
||||
t.Fatalf("marker eines anderen mandanten: %q", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestApply_AuditFailureReturnsError(t *testing.T) {
|
||||
s := &Service{Markers: fakeMarkers{"acme": "x"}, Audit: &fakeAudit{err: errors.New("down")}}
|
||||
if got, err := s.Apply(context.Background(), adoption(SourceAI, "acme")); err == nil || got != "" {
|
||||
t.Fatalf("got=%q err=%v", got, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidate(t *testing.T) {
|
||||
for _, bad := range []string{"", " ", "a\nb", strings.Repeat("x", MaxMarkerLen+1)} {
|
||||
if _, err := validate(bad); !errors.Is(err, ErrInvalidMarker) {
|
||||
t.Errorf("%q: err=%v", bad, err)
|
||||
}
|
||||
}
|
||||
if got, err := validate(" ai-processed "); err != nil || got != "ai-processed" {
|
||||
t.Errorf("got=%q err=%v", got, err)
|
||||
}
|
||||
}
|
||||
|
||||
func newStore(t *testing.T) *Store {
|
||||
t.Helper()
|
||||
dsn := os.Getenv("TEST_TENANT_DSN")
|
||||
if dsn == "" {
|
||||
t.Skip("TEST_TENANT_DSN nicht gesetzt, Integrationstest übersprungen")
|
||||
}
|
||||
pool := testdb.Pool(t, dsn)
|
||||
dir, err := filepath.Abs("../../migrations")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
migrations, err := migrate.Load(dir)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := migrate.Up(context.Background(), pool, migrations); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return &Store{Pool: pool}
|
||||
}
|
||||
|
||||
func TestStore_PerTenantSetGetClear(t *testing.T) {
|
||||
s := newStore(t)
|
||||
ctx := context.Background()
|
||||
if got, err := s.Get(ctx, "acme"); err != nil || got != "" {
|
||||
t.Fatalf("ohne konfiguration: %q %v", got, err)
|
||||
}
|
||||
if err := s.Set(ctx, "acme", " ai-processed "); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := s.Set(ctx, "other", "ki"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got, _ := s.Get(ctx, "acme"); got != "ai-processed" {
|
||||
t.Fatalf("acme: %q", got)
|
||||
}
|
||||
if got, _ := s.Get(ctx, "other"); got != "ki" {
|
||||
t.Fatalf("other: %q", got)
|
||||
}
|
||||
if err := s.Clear(ctx, "acme"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if got, _ := s.Get(ctx, "acme"); got != "" {
|
||||
t.Fatalf("nach clear: %q", got)
|
||||
}
|
||||
if got, _ := s.Get(ctx, "other"); got != "ki" {
|
||||
t.Fatalf("other beruehrt: %q", got)
|
||||
}
|
||||
if err := s.Set(ctx, "acme", "\t"); !errors.Is(err, ErrInvalidMarker) {
|
||||
t.Fatalf("err=%v", err)
|
||||
}
|
||||
}
|
||||
@@ -2,12 +2,17 @@ package provider_test
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider/gemini"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider/mock"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider/ollama"
|
||||
)
|
||||
@@ -84,6 +89,22 @@ func TestContract_Ollama(t *testing.T) {
|
||||
runContract(t, p, model)
|
||||
}
|
||||
|
||||
func TestContract_Gemini(t *testing.T) {
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if strings.HasSuffix(r.URL.Path, ":embedContent") {
|
||||
_ = json.NewEncoder(w).Encode(map[string]any{"embedding": map[string]any{"values": []float64{0.1, 0.2}}})
|
||||
return
|
||||
}
|
||||
_ = json.NewEncoder(w).Encode(map[string]any{"candidates": []map[string]any{{"content": map[string]any{"parts": []map[string]string{{"text": "OK"}}}}}})
|
||||
}))
|
||||
defer srv.Close()
|
||||
p, err := gemini.New(srv.URL, "k")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
runContract(t, p, "gemini-test")
|
||||
}
|
||||
|
||||
// TestInterchangeable_SameCallerCode belegt AK2: ein Aufrufer, der gegen das
|
||||
// Interface programmiert, funktioniert unveraendert mit jeder Implementierung.
|
||||
func TestInterchangeable_SameCallerCode(t *testing.T) {
|
||||
|
||||
@@ -0,0 +1,203 @@
|
||||
package gemini
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"io"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"os"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider"
|
||||
)
|
||||
|
||||
const (
|
||||
DefaultBaseURL = "https://generativelanguage.googleapis.com/v1beta"
|
||||
EnvAPIKey = "NEXARCH_AI_GEMINI_API_KEY"
|
||||
EnvBaseURL = "NEXARCH_AI_GEMINI_BASE_URL"
|
||||
)
|
||||
|
||||
var ErrDisabled = fmt.Errorf("gemini-adapter: %s nicht gesetzt, adapter bleibt deaktiviert", EnvAPIKey)
|
||||
|
||||
type Provider struct {
|
||||
BaseURL string
|
||||
APIKey string
|
||||
Client *http.Client
|
||||
}
|
||||
|
||||
var _ provider.Provider = (*Provider)(nil)
|
||||
|
||||
func New(baseURL, apiKey string) (*Provider, error) {
|
||||
if apiKey == "" {
|
||||
return nil, ErrDisabled
|
||||
}
|
||||
if baseURL == "" {
|
||||
baseURL = DefaultBaseURL
|
||||
}
|
||||
return &Provider{
|
||||
BaseURL: strings.TrimRight(baseURL, "/"),
|
||||
APIKey: apiKey,
|
||||
Client: &http.Client{Timeout: 120 * time.Second},
|
||||
}, nil
|
||||
}
|
||||
|
||||
func NewFromEnv() (*Provider, error) {
|
||||
return New(os.Getenv(EnvBaseURL), os.Getenv(EnvAPIKey))
|
||||
}
|
||||
|
||||
func newErr(code provider.Code, msg string, err error) error {
|
||||
return &provider.Error{Provider: "gemini", Code: code, Message: msg, Err: err}
|
||||
}
|
||||
|
||||
func (p *Provider) do(ctx context.Context, model, method string, body, out any) error {
|
||||
buf, err := json.Marshal(body)
|
||||
if err != nil {
|
||||
return newErr(provider.CodeInvalidRequest, "anfrage kodieren", err)
|
||||
}
|
||||
endpoint := fmt.Sprintf("%s/models/%s:%s", p.BaseURL, url.PathEscape(strings.TrimPrefix(model, "models/")), method)
|
||||
req, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(buf))
|
||||
if err != nil {
|
||||
return newErr(provider.CodeInvalidRequest, "anfrage aufbauen", err)
|
||||
}
|
||||
req.Header.Set("x-goog-api-key", p.APIKey)
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
|
||||
resp, err := p.Client.Do(req)
|
||||
if err != nil {
|
||||
if ctx.Err() != nil {
|
||||
return newErr(provider.CodeTimeout, "anfrage abgebrochen", err)
|
||||
}
|
||||
return newErr(provider.CodeUnavailable, "dienst nicht erreichbar", err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
|
||||
data, err := io.ReadAll(resp.Body)
|
||||
if err != nil {
|
||||
return newErr(provider.CodeUpstream, "antwort lesen", err)
|
||||
}
|
||||
switch {
|
||||
case resp.StatusCode == http.StatusNotFound:
|
||||
return newErr(provider.CodeModelNotFound, "modell nicht gefunden", fmt.Errorf("http %d", resp.StatusCode))
|
||||
case resp.StatusCode == http.StatusTooManyRequests:
|
||||
return newErr(provider.CodeRateLimited, "rate limit", fmt.Errorf("http %d", resp.StatusCode))
|
||||
case resp.StatusCode >= 400:
|
||||
return newErr(provider.CodeUpstream, "fehlerhafte antwort", fmt.Errorf("http %d: %s", resp.StatusCode, string(data)))
|
||||
}
|
||||
if err := json.Unmarshal(data, out); err != nil {
|
||||
return newErr(provider.CodeUpstream, "antwort dekodieren", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
type part struct {
|
||||
Text string `json:"text"`
|
||||
}
|
||||
|
||||
type content struct {
|
||||
Role string `json:"role,omitempty"`
|
||||
Parts []part `json:"parts"`
|
||||
}
|
||||
|
||||
type generationConfig struct {
|
||||
MaxOutputTokens int `json:"maxOutputTokens,omitempty"`
|
||||
Temperature float64 `json:"temperature"`
|
||||
}
|
||||
|
||||
type generateRequest struct {
|
||||
SystemInstruction *content `json:"systemInstruction,omitempty"`
|
||||
Contents []content `json:"contents"`
|
||||
GenerationConfig generationConfig `json:"generationConfig"`
|
||||
}
|
||||
|
||||
type generateResponse struct {
|
||||
Candidates []struct {
|
||||
Content content `json:"content"`
|
||||
FinishReason string `json:"finishReason"`
|
||||
} `json:"candidates"`
|
||||
UsageMetadata struct {
|
||||
PromptTokenCount int `json:"promptTokenCount"`
|
||||
CandidatesTokenCount int `json:"candidatesTokenCount"`
|
||||
TotalTokenCount int `json:"totalTokenCount"`
|
||||
} `json:"usageMetadata"`
|
||||
ModelVersion string `json:"modelVersion"`
|
||||
}
|
||||
|
||||
func (p *Provider) Chat(ctx context.Context, req provider.ChatRequest) (provider.ChatResponse, error) {
|
||||
body := generateRequest{GenerationConfig: generationConfig{MaxOutputTokens: req.MaxTokens, Temperature: req.Temperature}}
|
||||
var system []part
|
||||
for _, m := range req.Messages {
|
||||
switch m.Role {
|
||||
case provider.RoleSystem:
|
||||
system = append(system, part{Text: m.Content})
|
||||
case provider.RoleAssistant:
|
||||
body.Contents = append(body.Contents, content{Role: "model", Parts: []part{{Text: m.Content}}})
|
||||
default:
|
||||
body.Contents = append(body.Contents, content{Role: "user", Parts: []part{{Text: m.Content}}})
|
||||
}
|
||||
}
|
||||
if len(system) > 0 {
|
||||
body.SystemInstruction = &content{Parts: system}
|
||||
}
|
||||
|
||||
var out generateResponse
|
||||
if err := p.do(ctx, req.Model, "generateContent", body, &out); err != nil {
|
||||
return provider.ChatResponse{}, err
|
||||
}
|
||||
if len(out.Candidates) == 0 {
|
||||
return provider.ChatResponse{}, newErr(provider.CodeUpstream, "keine antwort in candidates", nil)
|
||||
}
|
||||
c := out.Candidates[0]
|
||||
var text strings.Builder
|
||||
for _, pt := range c.Content.Parts {
|
||||
text.WriteString(pt.Text)
|
||||
}
|
||||
return provider.ChatResponse{
|
||||
Model: out.ModelVersion,
|
||||
Message: provider.Message{Role: provider.RoleAssistant, Content: text.String()},
|
||||
FinishReason: c.FinishReason,
|
||||
Usage: provider.Usage{
|
||||
PromptTokens: out.UsageMetadata.PromptTokenCount,
|
||||
CompletionTokens: out.UsageMetadata.CandidatesTokenCount,
|
||||
TotalTokens: out.UsageMetadata.TotalTokenCount,
|
||||
},
|
||||
}, nil
|
||||
}
|
||||
|
||||
func (p *Provider) Complete(ctx context.Context, req provider.CompletionRequest) (provider.CompletionResponse, error) {
|
||||
resp, err := p.Chat(ctx, provider.ChatRequest{
|
||||
Model: req.Model,
|
||||
Messages: []provider.Message{{Role: provider.RoleUser, Content: req.Prompt}},
|
||||
MaxTokens: req.MaxTokens,
|
||||
Temperature: req.Temperature,
|
||||
})
|
||||
if err != nil {
|
||||
return provider.CompletionResponse{}, err
|
||||
}
|
||||
return provider.CompletionResponse{Model: resp.Model, Text: resp.Message.Content, FinishReason: resp.FinishReason, Usage: resp.Usage}, nil
|
||||
}
|
||||
|
||||
type embedRequest struct {
|
||||
Content content `json:"content"`
|
||||
}
|
||||
|
||||
type embedResponse struct {
|
||||
Embedding struct {
|
||||
Values []float64 `json:"values"`
|
||||
} `json:"embedding"`
|
||||
}
|
||||
|
||||
func (p *Provider) Embed(ctx context.Context, req provider.EmbeddingRequest) (provider.EmbeddingResponse, error) {
|
||||
var out embedResponse
|
||||
body := embedRequest{Content: content{Parts: []part{{Text: req.Input}}}}
|
||||
if err := p.do(ctx, req.Model, "embedContent", body, &out); err != nil {
|
||||
return provider.EmbeddingResponse{}, err
|
||||
}
|
||||
if len(out.Embedding.Values) == 0 {
|
||||
return provider.EmbeddingResponse{}, newErr(provider.CodeUpstream, "keine einbettung in der antwort", nil)
|
||||
}
|
||||
return provider.EmbeddingResponse{Model: req.Model, Embedding: out.Embedding.Values}, nil
|
||||
}
|
||||
@@ -0,0 +1,148 @@
|
||||
package gemini
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider/openai"
|
||||
)
|
||||
|
||||
func fakeServer(t *testing.T, status int) (*httptest.Server, *map[string]any) {
|
||||
t.Helper()
|
||||
var last map[string]any
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if got := r.Header.Get("x-goog-api-key"); got != "key-1" {
|
||||
t.Errorf("x-goog-api-key = %q", got)
|
||||
}
|
||||
if r.URL.Query().Get("key") != "" {
|
||||
t.Error("schluessel darf nicht in der url stehen")
|
||||
}
|
||||
_ = json.NewDecoder(r.Body).Decode(&last)
|
||||
if status != http.StatusOK {
|
||||
w.WriteHeader(status)
|
||||
_, _ = w.Write([]byte(`{"error":{"message":"x"}}`))
|
||||
return
|
||||
}
|
||||
switch {
|
||||
case strings.HasSuffix(r.URL.Path, ":generateContent"):
|
||||
_ = json.NewEncoder(w).Encode(map[string]any{
|
||||
"candidates": []map[string]any{{
|
||||
"content": map[string]any{"role": "model", "parts": []map[string]string{{"text": "ha"}, {"text": "llo"}}},
|
||||
"finishReason": "STOP",
|
||||
}},
|
||||
"usageMetadata": map[string]int{"promptTokenCount": 3, "candidatesTokenCount": 2, "totalTokenCount": 5},
|
||||
"modelVersion": "gemini-test",
|
||||
})
|
||||
case strings.HasSuffix(r.URL.Path, ":embedContent"):
|
||||
_ = json.NewEncoder(w).Encode(map[string]any{"embedding": map[string]any{"values": []float64{0.1, 0.2}}})
|
||||
default:
|
||||
t.Errorf("unerwarteter pfad %s", r.URL.Path)
|
||||
}
|
||||
}))
|
||||
t.Cleanup(srv.Close)
|
||||
return srv, &last
|
||||
}
|
||||
|
||||
func TestChat_MapsRolesUsageAndParts(t *testing.T) {
|
||||
srv, last := fakeServer(t, http.StatusOK)
|
||||
p, _ := New(srv.URL, "key-1")
|
||||
resp, err := p.Chat(context.Background(), provider.ChatRequest{
|
||||
Model: "models/gemini-test",
|
||||
Messages: []provider.Message{
|
||||
{Role: provider.RoleSystem, Content: "sys"},
|
||||
{Role: provider.RoleUser, Content: "u"},
|
||||
{Role: provider.RoleAssistant, Content: "a"},
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if resp.Message.Content != "hallo" || resp.Usage.TotalTokens != 5 || resp.FinishReason != "STOP" {
|
||||
t.Fatalf("unerwartet: %+v", resp)
|
||||
}
|
||||
if (*last)["systemInstruction"] == nil {
|
||||
t.Fatal("systemInstruction fehlt")
|
||||
}
|
||||
contents := (*last)["contents"].([]any)
|
||||
if len(contents) != 2 || contents[1].(map[string]any)["role"] != "model" {
|
||||
t.Fatalf("rollen falsch: %v", contents)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCompleteAndEmbed(t *testing.T) {
|
||||
srv, _ := fakeServer(t, http.StatusOK)
|
||||
p, _ := New(srv.URL, "key-1")
|
||||
c, err := p.Complete(context.Background(), provider.CompletionRequest{Model: "m", Prompt: "x"})
|
||||
if err != nil || c.Text != "hallo" {
|
||||
t.Fatalf("complete: %+v %v", c, err)
|
||||
}
|
||||
e, err := p.Embed(context.Background(), provider.EmbeddingRequest{Model: "m", Input: "x"})
|
||||
if err != nil || len(e.Embedding) != 2 {
|
||||
t.Fatalf("embed: %+v %v", e, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestUniformErrors(t *testing.T) {
|
||||
for status, code := range map[int]provider.Code{404: provider.CodeModelNotFound, 429: provider.CodeRateLimited, 500: provider.CodeUpstream} {
|
||||
srv, _ := fakeServer(t, status)
|
||||
p, _ := New(srv.URL, "key-1")
|
||||
_, err := p.Chat(context.Background(), provider.ChatRequest{Model: "m", Messages: []provider.Message{{Role: provider.RoleUser, Content: "x"}}})
|
||||
if !provider.IsCode(err, code) {
|
||||
t.Errorf("status %d: err=%v, want %s", status, err, code)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestUnreachableAndCancelled(t *testing.T) {
|
||||
p, _ := New("http://127.0.0.1:1", "key-1")
|
||||
_, err := p.Embed(context.Background(), provider.EmbeddingRequest{Model: "m", Input: "x"})
|
||||
if !provider.IsCode(err, provider.CodeUnavailable) {
|
||||
t.Fatalf("err=%v", err)
|
||||
}
|
||||
ctx, cancel := context.WithCancel(context.Background())
|
||||
cancel()
|
||||
_, err = p.Embed(ctx, provider.EmbeddingRequest{Model: "m", Input: "x"})
|
||||
if !provider.IsCode(err, provider.CodeTimeout) {
|
||||
t.Fatalf("err=%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestDisabledWithoutKey(t *testing.T) {
|
||||
t.Setenv(EnvAPIKey, "")
|
||||
if _, err := NewFromEnv(); err != ErrDisabled {
|
||||
t.Fatalf("err=%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestKeyNotInErrors(t *testing.T) {
|
||||
srv, _ := fakeServer(t, http.StatusInternalServerError)
|
||||
p, _ := New(srv.URL, "key-1")
|
||||
_, err := p.Chat(context.Background(), provider.ChatRequest{Model: "m", Messages: []provider.Message{{Role: provider.RoleUser, Content: "x"}}})
|
||||
if err == nil || strings.Contains(err.Error(), "key-1") {
|
||||
t.Fatalf("err=%v", err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOptIn_GuardedProviderBlocksWithoutCallingServer(t *testing.T) {
|
||||
called := false
|
||||
srv := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) { called = true }))
|
||||
defer srv.Close()
|
||||
inner, _ := New(srv.URL, "key-1")
|
||||
g := &openai.GuardedProvider{Inner: inner, Gate: openai.NewEnvTenantGate("acme")}
|
||||
req := provider.ChatRequest{Model: "m", Messages: []provider.Message{{Role: provider.RoleUser, Content: "x"}}}
|
||||
|
||||
if _, err := g.Chat(openai.WithTenant(context.Background(), "other"), req); err == nil {
|
||||
t.Fatal("freigabe fehlt, fehler erwartet")
|
||||
}
|
||||
if _, err := g.Chat(context.Background(), req); err == nil {
|
||||
t.Fatal("ohne mandant, fehler erwartet")
|
||||
}
|
||||
if called {
|
||||
t.Fatal("server wurde trotz fehlender freigabe aufgerufen")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,293 @@
|
||||
package suggestapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"net/http"
|
||||
"strings"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/correspondentsuggest"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/doclang"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/originmark"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/tagsuggest"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/titlesuggest"
|
||||
"gitea.perlbach24.de/scripte/nexarch/common/svcauth"
|
||||
)
|
||||
|
||||
const maxBodyBytes = 1 << 20
|
||||
|
||||
type MarkerStore interface {
|
||||
Set(ctx context.Context, tenantSlug, marker string) error
|
||||
Get(ctx context.Context, tenantSlug string) (string, error)
|
||||
Clear(ctx context.Context, tenantSlug string) error
|
||||
}
|
||||
|
||||
type LanguageStore interface {
|
||||
Set(ctx context.Context, tenantSlug, code string) error
|
||||
Get(ctx context.Context, tenantSlug string) (string, error)
|
||||
}
|
||||
|
||||
type Server struct {
|
||||
Provider provider.Provider
|
||||
Model string
|
||||
Resolver *doclang.Resolver
|
||||
Languages LanguageStore
|
||||
Markers MarkerStore
|
||||
Adopt *originmark.Service
|
||||
ServiceToken string
|
||||
}
|
||||
|
||||
func (s *Server) RegisterRoutes(mux *http.ServeMux) {
|
||||
mux.HandleFunc("POST /suggest/title", s.auth(s.handleTitle))
|
||||
mux.HandleFunc("POST /suggest/correspondent", s.auth(s.handleCorrespondent))
|
||||
mux.HandleFunc("POST /suggest/tags", s.auth(s.handleTags))
|
||||
mux.HandleFunc("POST /suggest/adopt", s.auth(s.handleAdopt))
|
||||
mux.HandleFunc("GET /tenants/{tenant}/origin-marker", s.auth(s.handleMarkerGet))
|
||||
mux.HandleFunc("PUT /tenants/{tenant}/origin-marker", s.auth(s.handleMarkerPut))
|
||||
mux.HandleFunc("DELETE /tenants/{tenant}/origin-marker", s.auth(s.handleMarkerDelete))
|
||||
mux.HandleFunc("GET /tenants/{tenant}/language", s.auth(s.handleLanguageGet))
|
||||
mux.HandleFunc("PUT /tenants/{tenant}/language", s.auth(s.handleLanguagePut))
|
||||
}
|
||||
|
||||
func (s *Server) auth(next http.HandlerFunc) http.HandlerFunc {
|
||||
return func(w http.ResponseWriter, r *http.Request) {
|
||||
if !svcauth.Equal(r.Header.Get("X-Service-Token"), s.ServiceToken) {
|
||||
writeError(w, http.StatusUnauthorized, "service-token fehlt oder ist ungueltig")
|
||||
return
|
||||
}
|
||||
next(w, r)
|
||||
}
|
||||
}
|
||||
|
||||
type suggestRequest struct {
|
||||
TenantSlug string `json:"tenant_slug"`
|
||||
Module string `json:"module"`
|
||||
Text string `json:"text"`
|
||||
DocumentLanguage string `json:"document_language"`
|
||||
Existing []string `json:"existing"`
|
||||
}
|
||||
|
||||
type languages struct {
|
||||
Document string `json:"document_language,omitempty"`
|
||||
Output string `json:"output_language,omitempty"`
|
||||
}
|
||||
|
||||
// prepare dekodiert und prueft die Anfrage und loest die Sprachen auf; bei Fehler ist die Antwort geschrieben.
|
||||
func (s *Server) prepare(w http.ResponseWriter, r *http.Request) (suggestRequest, doclang.Resolved, bool) {
|
||||
var req suggestRequest
|
||||
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, maxBodyBytes)).Decode(&req); err != nil {
|
||||
writeError(w, http.StatusBadRequest, "ungueltiger anfrage-koerper")
|
||||
return req, doclang.Resolved{}, false
|
||||
}
|
||||
if strings.TrimSpace(req.TenantSlug) == "" || strings.TrimSpace(req.Text) == "" {
|
||||
writeError(w, http.StatusBadRequest, "tenant_slug und text sind erforderlich")
|
||||
return req, doclang.Resolved{}, false
|
||||
}
|
||||
res, err := s.Resolver.Resolve(r.Context(), req.TenantSlug, req.DocumentLanguage, req.Text)
|
||||
if errors.Is(err, doclang.ErrUnknownLanguage) {
|
||||
writeError(w, http.StatusBadRequest, "document_language ist nicht registriert")
|
||||
return req, res, false
|
||||
}
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "sprache ermitteln fehlgeschlagen")
|
||||
return req, res, false
|
||||
}
|
||||
return req, res, true
|
||||
}
|
||||
|
||||
func langsOf(res doclang.Resolved) languages {
|
||||
return languages{Document: res.Document.Code, Output: res.Output.Code}
|
||||
}
|
||||
|
||||
type titleResponse struct {
|
||||
languages
|
||||
Titles []titlesuggest.Suggestion `json:"titles"`
|
||||
}
|
||||
|
||||
func (s *Server) handleTitle(w http.ResponseWriter, r *http.Request) {
|
||||
req, res, ok := s.prepare(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
sug := &titlesuggest.Suggester{Provider: s.Provider, Model: s.Model}
|
||||
titles, err := sug.Suggest(r.Context(), req.Module, res.Output.Name, req.Text)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusBadGateway, "titelvorschlag fehlgeschlagen")
|
||||
return
|
||||
}
|
||||
if titles == nil {
|
||||
titles = []titlesuggest.Suggestion{}
|
||||
}
|
||||
writeJSON(w, http.StatusOK, titleResponse{languages: langsOf(res), Titles: titles})
|
||||
}
|
||||
|
||||
type correspondentResponse struct {
|
||||
languages
|
||||
Suggestion *correspondentsuggest.Suggestion `json:"suggestion"`
|
||||
}
|
||||
|
||||
func (s *Server) handleCorrespondent(w http.ResponseWriter, r *http.Request) {
|
||||
req, res, ok := s.prepare(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
sug := &correspondentsuggest.Suggester{Provider: s.Provider, Model: s.Model}
|
||||
got, found, err := sug.Suggest(r.Context(), req.Existing, req.Module, req.Text)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusBadGateway, "korrespondentenvorschlag fehlgeschlagen")
|
||||
return
|
||||
}
|
||||
resp := correspondentResponse{languages: langsOf(res)}
|
||||
if found {
|
||||
resp.Suggestion = &got
|
||||
}
|
||||
writeJSON(w, http.StatusOK, resp)
|
||||
}
|
||||
|
||||
type tagsResponse struct {
|
||||
languages
|
||||
Tags []tagsuggest.Suggestion `json:"tags"`
|
||||
}
|
||||
|
||||
func (s *Server) handleTags(w http.ResponseWriter, r *http.Request) {
|
||||
req, res, ok := s.prepare(w, r)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
sug := &tagsuggest.Suggester{Provider: s.Provider, Model: s.Model, Language: res.Output.Name}
|
||||
tags, err := sug.Suggest(r.Context(), req.Existing, req.Module, req.Text)
|
||||
if err != nil {
|
||||
writeError(w, http.StatusBadGateway, "tagvorschlag fehlgeschlagen")
|
||||
return
|
||||
}
|
||||
if tags == nil {
|
||||
tags = []tagsuggest.Suggestion{}
|
||||
}
|
||||
writeJSON(w, http.StatusOK, tagsResponse{languages: langsOf(res), Tags: tags})
|
||||
}
|
||||
|
||||
type adoptRequest struct {
|
||||
Source string `json:"source"`
|
||||
TenantSlug string `json:"tenant_slug"`
|
||||
Actor string `json:"actor"`
|
||||
Function string `json:"function"`
|
||||
Model string `json:"model"`
|
||||
PromptVersion int `json:"prompt_version"`
|
||||
InputRef string `json:"input_ref"`
|
||||
Kind string `json:"kind"`
|
||||
Value string `json:"value"`
|
||||
}
|
||||
|
||||
func (s *Server) handleAdopt(w http.ResponseWriter, r *http.Request) {
|
||||
if s.Adopt == nil {
|
||||
writeError(w, http.StatusServiceUnavailable, "uebernahme-protokollierung nicht konfiguriert")
|
||||
return
|
||||
}
|
||||
var req adoptRequest
|
||||
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, maxBodyBytes)).Decode(&req); err != nil {
|
||||
writeError(w, http.StatusBadRequest, "ungueltiger anfrage-koerper")
|
||||
return
|
||||
}
|
||||
src := originmark.Source(req.Source)
|
||||
if src != originmark.SourceAI && src != originmark.SourceManual {
|
||||
writeError(w, http.StatusBadRequest, "source muss ai oder manual sein")
|
||||
return
|
||||
}
|
||||
if strings.TrimSpace(req.TenantSlug) == "" || strings.TrimSpace(req.Kind) == "" || strings.TrimSpace(req.Value) == "" {
|
||||
writeError(w, http.StatusBadRequest, "tenant_slug, kind und value sind erforderlich")
|
||||
return
|
||||
}
|
||||
if src == originmark.SourceAI && (req.Function == "" || req.Model == "" || req.InputRef == "") {
|
||||
writeError(w, http.StatusBadRequest, "function, model und input_ref sind bei source=ai erforderlich")
|
||||
return
|
||||
}
|
||||
marker, err := s.Adopt.Apply(r.Context(), originmark.Adoption{
|
||||
Source: src, TenantSlug: req.TenantSlug, Actor: req.Actor, Function: req.Function, Model: req.Model,
|
||||
PromptVersion: req.PromptVersion, InputRef: req.InputRef, Kind: req.Kind, Value: req.Value,
|
||||
})
|
||||
if err != nil {
|
||||
writeError(w, http.StatusBadGateway, "uebernahme protokollieren fehlgeschlagen")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, map[string]string{"origin_marker": marker})
|
||||
}
|
||||
|
||||
func (s *Server) handleMarkerGet(w http.ResponseWriter, r *http.Request) {
|
||||
marker, err := s.Markers.Get(r.Context(), r.PathValue("tenant"))
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "markierung lesen fehlgeschlagen")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, map[string]string{"marker": marker})
|
||||
}
|
||||
|
||||
func (s *Server) handleMarkerPut(w http.ResponseWriter, r *http.Request) {
|
||||
var req struct {
|
||||
Marker string `json:"marker"`
|
||||
}
|
||||
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, maxBodyBytes)).Decode(&req); err != nil {
|
||||
writeError(w, http.StatusBadRequest, "ungueltiger anfrage-koerper")
|
||||
return
|
||||
}
|
||||
if err := s.Markers.Set(r.Context(), r.PathValue("tenant"), req.Marker); err != nil {
|
||||
if errors.Is(err, originmark.ErrInvalidMarker) {
|
||||
writeError(w, http.StatusBadRequest, err.Error())
|
||||
return
|
||||
}
|
||||
writeError(w, http.StatusInternalServerError, "markierung speichern fehlgeschlagen")
|
||||
return
|
||||
}
|
||||
s.handleMarkerGet(w, r)
|
||||
}
|
||||
|
||||
func (s *Server) handleMarkerDelete(w http.ResponseWriter, r *http.Request) {
|
||||
if err := s.Markers.Clear(r.Context(), r.PathValue("tenant")); err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "markierung loeschen fehlgeschlagen")
|
||||
return
|
||||
}
|
||||
s.handleMarkerGet(w, r)
|
||||
}
|
||||
|
||||
func (s *Server) handleLanguageGet(w http.ResponseWriter, r *http.Request) {
|
||||
code, err := s.Languages.Get(r.Context(), r.PathValue("tenant"))
|
||||
if err != nil {
|
||||
writeError(w, http.StatusInternalServerError, "sprache lesen fehlgeschlagen")
|
||||
return
|
||||
}
|
||||
writeJSON(w, http.StatusOK, map[string]string{"language": code})
|
||||
}
|
||||
|
||||
func (s *Server) handleLanguagePut(w http.ResponseWriter, r *http.Request) {
|
||||
var req struct {
|
||||
Language string `json:"language"`
|
||||
}
|
||||
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, maxBodyBytes)).Decode(&req); err != nil {
|
||||
writeError(w, http.StatusBadRequest, "ungueltiger anfrage-koerper")
|
||||
return
|
||||
}
|
||||
if _, ok := s.Resolver.Registry.Lookup(req.Language); !ok {
|
||||
writeError(w, http.StatusBadRequest, "sprache nicht registriert")
|
||||
return
|
||||
}
|
||||
if err := s.Languages.Set(r.Context(), r.PathValue("tenant"), req.Language); err != nil {
|
||||
if errors.Is(err, doclang.ErrInvalidCode) {
|
||||
writeError(w, http.StatusBadRequest, err.Error())
|
||||
return
|
||||
}
|
||||
writeError(w, http.StatusInternalServerError, "sprache speichern fehlgeschlagen")
|
||||
return
|
||||
}
|
||||
s.handleLanguageGet(w, r)
|
||||
}
|
||||
|
||||
func writeJSON(w http.ResponseWriter, status int, v any) {
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
w.WriteHeader(status)
|
||||
_ = json.NewEncoder(w).Encode(v)
|
||||
}
|
||||
|
||||
func writeError(w http.ResponseWriter, status int, message string) {
|
||||
writeJSON(w, status, map[string]string{"error": message})
|
||||
}
|
||||
@@ -0,0 +1,241 @@
|
||||
package suggestapi
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/decisionaudit"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/doclang"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/originmark"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider/mock"
|
||||
)
|
||||
|
||||
type memStore struct{ m map[string]string }
|
||||
|
||||
func newMem() *memStore { return &memStore{m: map[string]string{}} }
|
||||
|
||||
func (s *memStore) Set(_ context.Context, tenant, v string) error {
|
||||
if strings.TrimSpace(v) == "" {
|
||||
return originmark.ErrInvalidMarker
|
||||
}
|
||||
s.m[tenant] = v
|
||||
return nil
|
||||
}
|
||||
func (s *memStore) Get(_ context.Context, tenant string) (string, error) { return s.m[tenant], nil }
|
||||
func (s *memStore) Clear(_ context.Context, tenant string) error { delete(s.m, tenant); return nil }
|
||||
|
||||
type recAudit struct{ got []decisionaudit.Decision }
|
||||
|
||||
func (r *recAudit) Record(_ context.Context, d decisionaudit.Decision) error {
|
||||
r.got = append(r.got, d)
|
||||
return nil
|
||||
}
|
||||
|
||||
type fixture struct {
|
||||
srv *httptest.Server
|
||||
markers *memStore
|
||||
langs *memStore
|
||||
audit *recAudit
|
||||
prov *mock.Provider
|
||||
}
|
||||
|
||||
func newFixture(t *testing.T, withAdopt bool) *fixture {
|
||||
t.Helper()
|
||||
f := &fixture{markers: newMem(), langs: newMem(), audit: &recAudit{}, prov: &mock.Provider{}}
|
||||
s := &Server{
|
||||
Provider: f.prov,
|
||||
Model: "m",
|
||||
Resolver: &doclang.Resolver{Registry: doclang.DefaultRegistry(), Tenants: tenantLang{f.langs}},
|
||||
Languages: f.langs,
|
||||
Markers: f.markers,
|
||||
ServiceToken: "tok",
|
||||
}
|
||||
if withAdopt {
|
||||
s.Adopt = &originmark.Service{Markers: f.markers, Audit: f.audit}
|
||||
}
|
||||
mux := http.NewServeMux()
|
||||
s.RegisterRoutes(mux)
|
||||
f.srv = httptest.NewServer(mux)
|
||||
t.Cleanup(f.srv.Close)
|
||||
return f
|
||||
}
|
||||
|
||||
type tenantLang struct{ s *memStore }
|
||||
|
||||
func (t tenantLang) Get(ctx context.Context, tenant string) (string, error) {
|
||||
return t.s.Get(ctx, tenant)
|
||||
}
|
||||
|
||||
func (f *fixture) reply(content string) {
|
||||
f.prov.ChatResponse = provider.ChatResponse{Message: provider.Message{Role: provider.RoleAssistant, Content: content}}
|
||||
}
|
||||
|
||||
func (f *fixture) do(t *testing.T, method, path, body string, token bool) (int, map[string]any) {
|
||||
t.Helper()
|
||||
req, _ := http.NewRequest(method, f.srv.URL+path, strings.NewReader(body))
|
||||
if token {
|
||||
req.Header.Set("X-Service-Token", "tok")
|
||||
}
|
||||
resp, err := http.DefaultClient.Do(req)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
defer resp.Body.Close()
|
||||
var out map[string]any
|
||||
_ = json.NewDecoder(resp.Body).Decode(&out)
|
||||
return resp.StatusCode, out
|
||||
}
|
||||
|
||||
const enDoc = "Dear Sirs, the invoice is not paid and will be sent to you by the reminder that we have prepared for your account."
|
||||
|
||||
func TestAllRoutesRequireServiceToken(t *testing.T) {
|
||||
f := newFixture(t, true)
|
||||
for _, r := range [][2]string{
|
||||
{"POST", "/suggest/title"}, {"POST", "/suggest/correspondent"}, {"POST", "/suggest/tags"}, {"POST", "/suggest/adopt"},
|
||||
{"GET", "/tenants/acme/origin-marker"}, {"PUT", "/tenants/acme/origin-marker"}, {"DELETE", "/tenants/acme/origin-marker"},
|
||||
{"GET", "/tenants/acme/language"}, {"PUT", "/tenants/acme/language"},
|
||||
} {
|
||||
if code, _ := f.do(t, r[0], r[1], `{}`, false); code != http.StatusUnauthorized {
|
||||
t.Errorf("%s %s: status %d, want 401", r[0], r[1], code)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestTitle_ReturnsTitlesAndResolvedLanguages(t *testing.T) {
|
||||
f := newFixture(t, false)
|
||||
f.langs.m["acme"] = "de"
|
||||
f.reply(`[{"title":"Zahlungserinnerung","confidence":0.9}]`)
|
||||
code, out := f.do(t, "POST", "/suggest/title", `{"tenant_slug":"acme","module":"dms","text":"`+enDoc+`"}`, true)
|
||||
if code != 200 || out["document_language"] != "en" || out["output_language"] != "de" {
|
||||
t.Fatalf("%d %v", code, out)
|
||||
}
|
||||
titles := out["titles"].([]any)
|
||||
if len(titles) != 1 || titles[0].(map[string]any)["title"] != "Zahlungserinnerung" {
|
||||
t.Fatalf("%v", out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTitle_EmptyListNotNull(t *testing.T) {
|
||||
f := newFixture(t, false)
|
||||
f.reply("kein json")
|
||||
_, out := f.do(t, "POST", "/suggest/title", `{"tenant_slug":"acme","text":"x"}`, true)
|
||||
if titles, ok := out["titles"].([]any); !ok || len(titles) != 0 {
|
||||
t.Fatalf("%v", out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCorrespondent_FoundAndNone(t *testing.T) {
|
||||
f := newFixture(t, false)
|
||||
f.reply(`{"name":"muster gmbh","confidence":0.8}`)
|
||||
_, out := f.do(t, "POST", "/suggest/correspondent", `{"tenant_slug":"acme","text":"Brief","existing":["Muster GmbH"]}`, true)
|
||||
s := out["suggestion"].(map[string]any)
|
||||
if s["name"] != "Muster GmbH" || s["existing"] != true {
|
||||
t.Fatalf("%v", out)
|
||||
}
|
||||
f.reply(`{"name":"","confidence":0}`)
|
||||
_, out = f.do(t, "POST", "/suggest/correspondent", `{"tenant_slug":"acme","text":"Brief"}`, true)
|
||||
if out["suggestion"] != nil {
|
||||
t.Fatalf("%v", out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestTags_NormalizesToExisting(t *testing.T) {
|
||||
f := newFixture(t, false)
|
||||
f.reply(`[{"tag":"rechnung","confidence":0.9}]`)
|
||||
_, out := f.do(t, "POST", "/suggest/tags", `{"tenant_slug":"acme","text":"x","existing":["Rechnung"]}`, true)
|
||||
tags := out["tags"].([]any)
|
||||
if len(tags) != 1 || tags[0].(map[string]any)["tag"] != "Rechnung" {
|
||||
t.Fatalf("%v", out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSuggest_BadRequests(t *testing.T) {
|
||||
f := newFixture(t, false)
|
||||
for name, body := range map[string]string{
|
||||
"kein json": `{`,
|
||||
"ohne tenant": `{"text":"x"}`,
|
||||
"ohne text": `{"tenant_slug":"acme","text":" "}`,
|
||||
"unbekannt lang": `{"tenant_slug":"acme","text":"x","document_language":"xx"}`,
|
||||
} {
|
||||
if code, _ := f.do(t, "POST", "/suggest/title", body, true); code != http.StatusBadRequest {
|
||||
t.Errorf("%s: status %d, want 400", name, code)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestSuggest_ProviderErrorIs502(t *testing.T) {
|
||||
f := newFixture(t, false)
|
||||
f.prov.Err = &provider.Error{Provider: "mock", Code: provider.CodeUnavailable, Message: "down"}
|
||||
for _, p := range []string{"title", "correspondent", "tags"} {
|
||||
if code, _ := f.do(t, "POST", "/suggest/"+p, `{"tenant_slug":"acme","text":"x"}`, true); code != http.StatusBadGateway {
|
||||
t.Errorf("%s: status %d, want 502", p, code)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdopt_AIGetsMarkerManualDoesNot(t *testing.T) {
|
||||
f := newFixture(t, true)
|
||||
f.markers.m["acme"] = "ai-processed"
|
||||
ai := `{"source":"ai","tenant_slug":"acme","actor":"u1","function":"tagsuggest","model":"m","prompt_version":1,"input_ref":"doc-1","kind":"tag","value":"rechnung"}`
|
||||
code, out := f.do(t, "POST", "/suggest/adopt", ai, true)
|
||||
if code != 200 || out["origin_marker"] != "ai-processed" || len(f.audit.got) != 1 {
|
||||
t.Fatalf("%d %v audit=%d", code, out, len(f.audit.got))
|
||||
}
|
||||
manual := `{"source":"manual","tenant_slug":"acme","kind":"tag","value":"rechnung"}`
|
||||
code, out = f.do(t, "POST", "/suggest/adopt", manual, true)
|
||||
if code != 200 || out["origin_marker"] != "" || len(f.audit.got) != 1 {
|
||||
t.Fatalf("%d %v audit=%d", code, out, len(f.audit.got))
|
||||
}
|
||||
}
|
||||
|
||||
func TestAdopt_ValidationAndUnconfigured(t *testing.T) {
|
||||
f := newFixture(t, true)
|
||||
for name, body := range map[string]string{
|
||||
"source falsch": `{"source":"x","tenant_slug":"a","kind":"tag","value":"v"}`,
|
||||
"ai ohne input": `{"source":"ai","tenant_slug":"a","kind":"tag","value":"v","function":"f","model":"m"}`,
|
||||
"ohne value": `{"source":"manual","tenant_slug":"a","kind":"tag"}`,
|
||||
"kein json": `{`,
|
||||
} {
|
||||
if code, _ := f.do(t, "POST", "/suggest/adopt", body, true); code != http.StatusBadRequest {
|
||||
t.Errorf("%s: status %d, want 400", name, code)
|
||||
}
|
||||
}
|
||||
g := newFixture(t, false)
|
||||
if code, _ := g.do(t, "POST", "/suggest/adopt", `{"source":"manual","tenant_slug":"a","kind":"tag","value":"v"}`, true); code != http.StatusServiceUnavailable {
|
||||
t.Errorf("status %d, want 503", code)
|
||||
}
|
||||
}
|
||||
|
||||
func TestOriginMarkerConfig(t *testing.T) {
|
||||
f := newFixture(t, false)
|
||||
if code, out := f.do(t, "PUT", "/tenants/acme/origin-marker", `{"marker":"ki"}`, true); code != 200 || out["marker"] != "ki" {
|
||||
t.Fatalf("%d %v", code, out)
|
||||
}
|
||||
if _, out := f.do(t, "GET", "/tenants/other/origin-marker", "", true); out["marker"] != "" {
|
||||
t.Fatalf("mandantentrennung: %v", out)
|
||||
}
|
||||
if code, _ := f.do(t, "PUT", "/tenants/acme/origin-marker", `{"marker":" "}`, true); code != http.StatusBadRequest {
|
||||
t.Fatalf("status %d, want 400", code)
|
||||
}
|
||||
if code, out := f.do(t, "DELETE", "/tenants/acme/origin-marker", "", true); code != 200 || out["marker"] != "" {
|
||||
t.Fatalf("%d %v", code, out)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLanguageConfig(t *testing.T) {
|
||||
f := newFixture(t, false)
|
||||
if code, _ := f.do(t, "PUT", "/tenants/acme/language", `{"language":"fr"}`, true); code != http.StatusBadRequest {
|
||||
t.Fatalf("unregistrierte sprache: status %d, want 400", code)
|
||||
}
|
||||
if code, out := f.do(t, "PUT", "/tenants/acme/language", `{"language":"en"}`, true); code != 200 || out["language"] != "en" {
|
||||
t.Fatalf("%d %v", code, out)
|
||||
}
|
||||
if _, out := f.do(t, "GET", "/tenants/acme/language", "", true); out["language"] != "en" {
|
||||
t.Fatalf("%v", out)
|
||||
}
|
||||
}
|
||||
@@ -26,6 +26,8 @@ type Suggestion struct {
|
||||
type Suggester struct {
|
||||
Provider provider.Provider
|
||||
Model string
|
||||
// Language ist der Anzeigename der Ausgabesprache; leer = keine Vorgabe.
|
||||
Language string
|
||||
}
|
||||
|
||||
type modelSuggestion struct {
|
||||
@@ -47,7 +49,7 @@ func (s *Suggester) Suggest(ctx context.Context, existingTags []string, moduleCo
|
||||
return nil, errors.New("tagsuggest: kein provider konfiguriert")
|
||||
}
|
||||
|
||||
prompt := buildPrompt(existingTags, moduleContext, documentText)
|
||||
prompt := buildPrompt(existingTags, moduleContext, s.Language, documentText)
|
||||
resp, err := s.Provider.Chat(ctx, provider.ChatRequest{
|
||||
Model: s.Model,
|
||||
Messages: []provider.Message{
|
||||
@@ -63,7 +65,7 @@ func (s *Suggester) Suggest(ctx context.Context, existingTags []string, moduleCo
|
||||
return parseAndDedup(existingTags, resp.Message.Content), nil
|
||||
}
|
||||
|
||||
func buildPrompt(existingTags []string, moduleContext, documentText string) string {
|
||||
func buildPrompt(existingTags []string, moduleContext, language, documentText string) string {
|
||||
var b strings.Builder
|
||||
b.WriteString("Schlage passende Schlagworte (Tags) für das folgende Dokument vor.\n")
|
||||
if moduleContext != "" {
|
||||
@@ -74,6 +76,9 @@ func buildPrompt(existingTags []string, moduleContext, documentText string) stri
|
||||
b.WriteString(strings.Join(existingTags, ", "))
|
||||
b.WriteString("\n")
|
||||
}
|
||||
if language != "" {
|
||||
b.WriteString(fmt.Sprintf("Neue Tags schreibst du in der Sprache %q. Bestehende Tags dürfen auch in einer anderen Sprache vorliegen als das Dokument; ein bedeutungsgleicher bestehender Tag hat immer Vorrang vor einem neuen Tag.\n", language))
|
||||
}
|
||||
b.WriteString("Antworte NUR mit einem JSON-Array in diesem Format: ")
|
||||
b.WriteString(`[{"tag": string, "confidence": number zwischen 0 und 1, "reasoning": string}, ...].`)
|
||||
b.WriteString(" Schlage höchstens 8 Tags vor, keine Dopplungen.\n\n")
|
||||
|
||||
@@ -2,6 +2,7 @@ package tagsuggest
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider"
|
||||
@@ -125,3 +126,40 @@ func TestSuggest_NoProvider_ReturnsError(t *testing.T) {
|
||||
t.Fatal("erwartet Fehler ohne konfigurierten Provider")
|
||||
}
|
||||
}
|
||||
|
||||
type capturingProvider struct {
|
||||
stubProvider
|
||||
prompt string
|
||||
}
|
||||
|
||||
func (c *capturingProvider) Chat(ctx context.Context, req provider.ChatRequest) (provider.ChatResponse, error) {
|
||||
c.prompt = req.Messages[len(req.Messages)-1].Content
|
||||
return c.stubProvider.Chat(ctx, req)
|
||||
}
|
||||
|
||||
// CLS-08: Ausgabesprache wird in den Prompt aufgenommen, bestehende Tags in anderer Sprache behalten Vorrang.
|
||||
func TestSuggest_LanguageInPromptAndTaxonomyKept(t *testing.T) {
|
||||
p := &capturingProvider{stubProvider: stubProvider{response: `[{"tag":"rechnung","confidence":0.9}]`}}
|
||||
s := &Suggester{Provider: p, Model: "test", Language: "Deutsch"}
|
||||
|
||||
got, err := s.Suggest(context.Background(), []string{"Rechnung"}, "dms", "Invoice for consulting services")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(got) != 1 || got[0].Tag != "Rechnung" {
|
||||
t.Fatalf("taxonomie nicht respektiert: %+v", got)
|
||||
}
|
||||
if !strings.Contains(p.prompt, `"Deutsch"`) || !strings.Contains(p.prompt, "Vorrang") {
|
||||
t.Fatalf("sprachvorgabe fehlt im prompt: %s", p.prompt)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSuggest_NoLanguageNoInstruction(t *testing.T) {
|
||||
p := &capturingProvider{stubProvider: stubProvider{response: `[]`}}
|
||||
if _, err := (&Suggester{Provider: p}).Suggest(context.Background(), nil, "", "x"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if strings.Contains(p.prompt, "Sprache") {
|
||||
t.Fatalf("unerwartete sprachvorgabe: %s", p.prompt)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,97 @@
|
||||
package titlesuggest
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider"
|
||||
)
|
||||
|
||||
const (
|
||||
maxTitleRunes = 120
|
||||
maxSuggestions = 3
|
||||
)
|
||||
|
||||
type Suggestion struct {
|
||||
Title string `json:"title"`
|
||||
Confidence float64 `json:"confidence"`
|
||||
}
|
||||
|
||||
type Suggester struct {
|
||||
Provider provider.Provider
|
||||
Model string
|
||||
}
|
||||
|
||||
func (s *Suggester) Suggest(ctx context.Context, moduleContext, language, documentText string) ([]Suggestion, error) {
|
||||
if s.Provider == nil {
|
||||
return nil, errors.New("titlesuggest: kein provider konfiguriert")
|
||||
}
|
||||
resp, err := s.Provider.Chat(ctx, provider.ChatRequest{
|
||||
Model: s.Model,
|
||||
Messages: []provider.Message{
|
||||
{Role: provider.RoleSystem, Content: "Du bist ein Assistent für Dokumenttitel. Antworte ausschließlich mit einem JSON-Array von Objekten, ohne Erklärtext."},
|
||||
{Role: provider.RoleUser, Content: buildPrompt(moduleContext, language, documentText)},
|
||||
},
|
||||
Temperature: 0,
|
||||
})
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("titlesuggest: modellaufruf: %w", err)
|
||||
}
|
||||
return parse(resp.Message.Content), nil
|
||||
}
|
||||
|
||||
func buildPrompt(moduleContext, language, documentText string) string {
|
||||
var b strings.Builder
|
||||
b.WriteString("Schlage prägnante Titel für das folgende Dokument vor.\n")
|
||||
if moduleContext != "" {
|
||||
fmt.Fprintf(&b, "Kontext: das Dokument stammt aus dem Modul %q.\n", moduleContext)
|
||||
}
|
||||
if language != "" {
|
||||
fmt.Fprintf(&b, "Schreibe die Titel in der Sprache %q.\n", language)
|
||||
}
|
||||
fmt.Fprintf(&b, "Antworte NUR mit einem JSON-Array: [{\"title\": string, \"confidence\": number zwischen 0 und 1}, ...]. Höchstens %d Titel, je höchstens %d Zeichen.\n\nDokument:\n", maxSuggestions, maxTitleRunes)
|
||||
b.WriteString(documentText)
|
||||
return b.String()
|
||||
}
|
||||
|
||||
func parse(raw string) []Suggestion {
|
||||
start, end := strings.IndexByte(raw, '['), strings.LastIndexByte(raw, ']')
|
||||
if start < 0 || end < start {
|
||||
return nil
|
||||
}
|
||||
var in []Suggestion
|
||||
if err := json.Unmarshal([]byte(raw[start:end+1]), &in); err != nil {
|
||||
return nil
|
||||
}
|
||||
seen := make(map[string]bool)
|
||||
var out []Suggestion
|
||||
for _, s := range in {
|
||||
title := strings.Join(strings.Fields(s.Title), " ")
|
||||
if r := []rune(title); len(r) > maxTitleRunes {
|
||||
title = strings.TrimSpace(string(r[:maxTitleRunes]))
|
||||
}
|
||||
key := strings.ToLower(title)
|
||||
if title == "" || seen[key] {
|
||||
continue
|
||||
}
|
||||
seen[key] = true
|
||||
out = append(out, Suggestion{Title: title, Confidence: clamp(s.Confidence)})
|
||||
if len(out) == maxSuggestions {
|
||||
break
|
||||
}
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
func clamp(v float64) float64 {
|
||||
if v < 0 {
|
||||
return 0
|
||||
}
|
||||
if v > 1 {
|
||||
return 1
|
||||
}
|
||||
return v
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
package titlesuggest
|
||||
|
||||
import (
|
||||
"context"
|
||||
"os"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider/ollama"
|
||||
)
|
||||
|
||||
func TestSuggest_RealInference_Accuracy(t *testing.T) {
|
||||
base, model := os.Getenv("TEST_OLLAMA_BASE_URL"), os.Getenv("TEST_OLLAMA_MODEL")
|
||||
if base == "" || model == "" {
|
||||
t.Skip("TEST_OLLAMA_BASE_URL/TEST_OLLAMA_MODEL nicht gesetzt, Realtest uebersprungen")
|
||||
}
|
||||
s := &Suggester{Provider: ollama.New(base), Model: model}
|
||||
|
||||
cases := []struct {
|
||||
name, text string
|
||||
want []string
|
||||
}{
|
||||
{"rechnung", "Rechnung Nr. 2024-0451\nMusterfirma GmbH\nBetrag: 1.297,00 EUR zzgl. 19% USt\nLeistung: Beratung September 2026", []string{"rechnung", "2024-0451"}},
|
||||
{"vertrag", "Dienstleistungsvertrag zwischen Musterfirma GmbH und Beispiel AG. Laufzeit 24 Monate, Kuendigungsfrist 3 Monate zum Quartalsende.", []string{"vertrag"}},
|
||||
{"lieferschein", "Lieferschein Nr. 88213\n20x Aktenordner, 5x Tonerkartuschen\nLieferung am 03.10.2026 an Musterstrasse 1", []string{"lieferschein", "88213"}},
|
||||
{"mahnung", "Zahlungserinnerung: Die Rechnung 2024-0451 vom 15.11.2026 ist noch offen. Bitte zahlen Sie bis zum 30.11.2026.", []string{"mahnung", "erinnerung", "zahlung"}},
|
||||
{"invoice-en", "Invoice No. 7731, Sample Corp. Amount due: 540.00 EUR. Payment terms: 14 days net.", []string{"invoice", "7731", "rechnung"}},
|
||||
}
|
||||
|
||||
hits := 0
|
||||
for _, c := range cases {
|
||||
ctx, cancel := context.WithTimeout(context.Background(), 90*time.Second)
|
||||
got, err := s.Suggest(ctx, "dms", "Deutsch", c.text)
|
||||
cancel()
|
||||
if err != nil {
|
||||
t.Fatalf("%s: %v", c.name, err)
|
||||
}
|
||||
hit := false
|
||||
for _, g := range got {
|
||||
if g.Confidence < 0 || g.Confidence > 1 {
|
||||
t.Errorf("%s: konfidenz ausserhalb [0,1]: %v", c.name, g.Confidence)
|
||||
}
|
||||
for _, w := range c.want {
|
||||
if strings.Contains(strings.ToLower(g.Title), w) {
|
||||
hit = true
|
||||
}
|
||||
}
|
||||
}
|
||||
t.Logf("%s: hit=%v vorschlaege=%+v", c.name, hit, got)
|
||||
if hit {
|
||||
hits++
|
||||
}
|
||||
}
|
||||
t.Logf("Trefferquote: %d/%d", hits, len(cases))
|
||||
if hits < 3 {
|
||||
t.Errorf("trefferquote %d/%d unter 3/5", hits, len(cases))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
package titlesuggest
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider"
|
||||
"gitea.perlbach24.de/scripte/nexarch/ai/internal/provider/mock"
|
||||
)
|
||||
|
||||
func newSuggester(resp string) *Suggester {
|
||||
return &Suggester{
|
||||
Provider: &mock.Provider{ChatResponse: provider.ChatResponse{Message: provider.Message{Role: provider.RoleAssistant, Content: resp}}},
|
||||
Model: "test",
|
||||
}
|
||||
}
|
||||
|
||||
func TestSuggest_ReturnsConfidencePerTitle(t *testing.T) {
|
||||
got, err := newSuggester(`[{"title":"Rechnung 2026-001","confidence":0.9},{"title":"Rechnung Muster GmbH","confidence":2}]`).
|
||||
Suggest(context.Background(), "dms", "de", "Rechnung")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(got) != 2 || got[0].Confidence != 0.9 || got[1].Confidence != 1 {
|
||||
t.Fatalf("unerwartet: %+v", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSuggest_DedupTrimAndLimit(t *testing.T) {
|
||||
long := strings.Repeat("a", 300)
|
||||
got, err := newSuggester(`[{"title":" Vertrag A ","confidence":0.5},{"title":"vertrag a","confidence":0.4},{"title":"","confidence":1},{"title":"`+long+`","confidence":0.3},{"title":"B","confidence":0.2},{"title":"C","confidence":0.1}]`).
|
||||
Suggest(context.Background(), "", "", "x")
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(got) != 3 || got[0].Title != "Vertrag A" {
|
||||
t.Fatalf("unerwartet: %+v", got)
|
||||
}
|
||||
if n := len([]rune(got[1].Title)); n != maxTitleRunes {
|
||||
t.Fatalf("titel nicht gekuerzt: %d", n)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSuggest_GarbageYieldsEmpty(t *testing.T) {
|
||||
got, err := newSuggester("kein json").Suggest(context.Background(), "", "", "x")
|
||||
if err != nil || len(got) != 0 {
|
||||
t.Fatalf("got=%v err=%v", got, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSuggest_ProviderErrorAndNil(t *testing.T) {
|
||||
s := &Suggester{Provider: &mock.Provider{Err: errors.New("down")}}
|
||||
if _, err := s.Suggest(context.Background(), "", "", "x"); err == nil {
|
||||
t.Fatal("fehler erwartet")
|
||||
}
|
||||
if _, err := (&Suggester{}).Suggest(context.Background(), "", "", "x"); err == nil {
|
||||
t.Fatal("fehler erwartet")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1 @@
|
||||
DROP TABLE ai_origin_markers;
|
||||
@@ -0,0 +1,5 @@
|
||||
CREATE TABLE ai_origin_markers (
|
||||
tenant_slug TEXT PRIMARY KEY,
|
||||
marker TEXT NOT NULL CHECK (marker <> ''),
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
@@ -0,0 +1 @@
|
||||
DROP TABLE ai_tenant_languages;
|
||||
@@ -0,0 +1,5 @@
|
||||
CREATE TABLE ai_tenant_languages (
|
||||
tenant_slug TEXT PRIMARY KEY,
|
||||
language TEXT NOT NULL CHECK (language ~ '^[a-z]{2,3}$'),
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
Reference in new issue
Block a user