nexarch/ai/internal/summaryapi/summaryapi.go

// Package summaryapi ist die HTTP-Bindung fuer Dokument- (SUM-01) und
// Thread-Zusammenfassungen (SUM-02), damit eine Oberflaeche (SUM-03) sie
// 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 (SEM-03), fail closed.
package summaryapi

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

	"gitea.perlbach24.de/scripte/nexarch/ai/internal/summarize"
	"gitea.perlbach24.de/scripte/nexarch/ai/internal/threadsummarize"
	"gitea.perlbach24.de/scripte/nexarch/common/svcauth"
)

type Server struct {
	docSummarizer    *summarize.Summarizer
	threadSummarizer *threadsummarize.Summarizer
	serviceToken     string
}

func NewServer(docSummarizer *summarize.Summarizer, threadSummarizer *threadsummarize.Summarizer, serviceToken string) *Server {
	return &Server{docSummarizer: docSummarizer, threadSummarizer: threadSummarizer, serviceToken: serviceToken}
}

func (s *Server) RegisterRoutes(mux *http.ServeMux) {
	mux.HandleFunc("POST /documents/summarize", s.requireAuth(s.handleDocumentSummarize))
	mux.HandleFunc("POST /threads/summarize", s.requireAuth(s.handleThreadSummarize))
}

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 documentSummarizeRequest struct {
	Text     string `json:"text"`
	MaxWords int    `json:"max_words"`
	Language string `json:"language"`
}

type documentSummarizeResponse struct {
	Summary   string `json:"summary"`
	Truncated bool   `json:"truncated"`
}

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

	result, err := s.docSummarizer.Summarize(r.Context(), req.Text, summarize.Options{MaxWords: req.MaxWords, Language: req.Language})
	if err != nil {
		writeError(w, http.StatusInternalServerError, "zusammenfassung fehlgeschlagen")
		return
	}
	writeJSON(w, http.StatusOK, documentSummarizeResponse{Summary: result.Summary, Truncated: result.Truncated})
}

type threadMessageRequest struct {
	ID   string `json:"id"`
	From string `json:"from"`
	Body string `json:"body"`
}

type threadSummarizeRequest struct {
	Messages []threadMessageRequest `json:"messages"`
	MaxWords int                    `json:"max_words"`
	Language string                 `json:"language"`
}

type threadSummarizeResponse struct {
	Summary       string `json:"summary"`
	MessageCount  int    `json:"message_count"`
	LastMessageID string `json:"last_message_id"`
}

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

	messages := make([]threadsummarize.Message, 0, len(req.Messages))
	for _, m := range req.Messages {
		messages = append(messages, threadsummarize.Message{ID: m.ID, From: m.From, Body: m.Body})
	}

	result, err := s.threadSummarizer.Summarize(r.Context(), threadsummarize.Thread{Messages: messages}, threadsummarize.Options{MaxWords: req.MaxWords, Language: req.Language})
	if err != nil {
		writeError(w, http.StatusInternalServerError, "zusammenfassung fehlgeschlagen")
		return
	}
	writeJSON(w, http.StatusOK, threadSummarizeResponse{Summary: result.Summary, MessageCount: result.MessageCount, LastMessageID: result.LastMessageID})
}

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