nexarch/ai/internal/docchatapi/docchatapi.go

// Package docchatapi ist die HTTP-Bindung des Dokumenten-Chats (SEM-04/SEM-05),
// damit eine Oberflaeche (SEM-06) ihn abrufen kann. Aufrufer ist das anfragende
// Modul (DMS/Mail) bzw. dessen eigene Backend-for-Frontend-Route, nicht der
// Endnutzer direkt — Service-Token-Pflicht wie semanticsearchapi/summaryapi,
// fail closed.
package docchatapi

import (
	"encoding/json"
	"errors"
	"net/http"

	"gitea.perlbach24.de/scripte/nexarch/ai/internal/docchat"
	"gitea.perlbach24.de/scripte/nexarch/ai/internal/semanticsearch"
	"gitea.perlbach24.de/scripte/nexarch/ai/internal/vectorindex"
	"gitea.perlbach24.de/scripte/nexarch/common/svcauth"
)

type Server struct {
	svc          *docchat.Service
	serviceToken string
}

func NewServer(svc *docchat.Service, serviceToken string) *Server {
	return &Server{svc: svc, serviceToken: serviceToken}
}

func (s *Server) RegisterRoutes(mux *http.ServeMux) {
	mux.HandleFunc("POST /chat", s.requireAuth(s.handleAsk))
	mux.HandleFunc("POST /chat/citation", s.requireAuth(s.handleResolveCitation))
}

func (s *Server) requireAuth(next http.HandlerFunc) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		got := r.Header.Get("X-Service-Token")
		if !svcauth.Equal(got, s.serviceToken) {
			writeError(w, http.StatusUnauthorized, "service-token fehlt oder ist ungueltig")
			return
		}
		next(w, r)
	}
}

type refRequest struct {
	SourceType string `json:"source_type"`
	SourceID   string `json:"source_id"`
}

type askRequest struct {
	TenantSlug  string       `json:"tenant_slug"`
	Question    string       `json:"question"`
	TopK        int          `json:"top_k"`
	AllowedRefs []refRequest `json:"allowed_refs"`
}

func (s *Server) handleAsk(w http.ResponseWriter, r *http.Request) {
	var req askRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "ungueltiger anfrage-koerper")
		return
	}

	refs := make([]semanticsearch.Ref, 0, len(req.AllowedRefs))
	for _, ref := range req.AllowedRefs {
		refs = append(refs, semanticsearch.Ref{SourceType: ref.SourceType, SourceID: ref.SourceID})
	}

	answer, err := s.svc.Ask(r.Context(), req.TenantSlug, req.Question, req.TopK, refs)
	switch {
	case err == nil:
		writeJSON(w, http.StatusOK, answer)
	case errors.Is(err, semanticsearch.ErrNoAllowedRefs):
		writeError(w, http.StatusBadRequest, "keine freigegebenen referenzen")
	default:
		writeError(w, http.StatusInternalServerError, "chat-antwort fehlgeschlagen")
	}
}

type citationRequest struct {
	TenantSlug string `json:"tenant_slug"`
	Index      int    `json:"index"`
	SourceType string `json:"source_type"`
	SourceID   string `json:"source_id"`
	ChunkIndex int    `json:"chunk_index"`
}

type citationResponse struct {
	Text string `json:"text"`
}

func (s *Server) handleResolveCitation(w http.ResponseWriter, r *http.Request) {
	var req citationRequest
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
		writeError(w, http.StatusBadRequest, "ungueltiger anfrage-koerper")
		return
	}

	text, err := s.svc.ResolveCitation(r.Context(), req.TenantSlug, docchat.Citation{
		Index:      req.Index,
		SourceType: req.SourceType,
		SourceID:   req.SourceID,
		ChunkIndex: req.ChunkIndex,
	})
	switch {
	case err == nil:
		writeJSON(w, http.StatusOK, citationResponse{Text: text})
	case errors.Is(err, vectorindex.ErrChunkNotFound):
		writeError(w, http.StatusNotFound, "abschnitt nicht gefunden")
	default:
		writeError(w, http.StatusInternalServerError, "zitat konnte nicht aufgeloest werden")
	}
}

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})
}