gott/Endpoints/ChatEndpoint.cs

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
using Gott.Extensions;
using Gott.Models;
using Gott.Services;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Routing;
using Microsoft.Extensions.Configuration;

namespace Gott.Endpoints;

public static class ChatEndpoint
{
    public static void MapChatEndpoint(this IEndpointRouteBuilder app)
    {
        app.MapPost("/api/chat", HandleChat);
        app.MapPost("/api/chat/stop", HandleStop);
    }

    private static async Task HandleChat(HttpRequest req, HttpResponse res, IConfiguration config, ChatService chatService, DatabaseService db, StreamingTracker streamingTracker, AnthropicService anthropic, CancellationToken cancellationToken)
    {
        var body = await JsonSerializer.DeserializeAsync<ChatRequest>(req.Body);
        if (body == null || body.Content.ValueKind == JsonValueKind.Undefined)
        {
            res.StatusCode = 400;
            await res.WriteAsJsonAsync(new { error = "content required" });
            return;
        }

        var sessionId = body.SessionId;
        if (string.IsNullOrEmpty(sessionId))
        {
            res.StatusCode = 400;
            await res.WriteAsJsonAsync(new { error = "sessionId required" });
            return;
        }

        var userId = req.HttpContext.GetUserId();
        var maxIterations = config.GetValue<int>("MaxIterations", 100);

        var ctx = await chatService.PrepareContext(sessionId, userId, maxIterations);
        if (ctx == null)
        {
            res.StatusCode = 400;
            await res.WriteAsJsonAsync(new { error = "Session/Agent nicht gefunden oder kein Agent ausgewählt" });
            return;
        }

        // Neue User-Message aus Request-Content aufbereiten und speichern
        var userMessage = new ChatMessage { Role = "user", Content = body.Content };
        var textContent = userMessage.GetTextContent();
        var attachmentBlocks = userMessage.GetAttachmentBlocks();

        var attachmentRecords = attachmentBlocks.Select(b => new AttachmentRecord
        {
            Type = b.Type,
            MediaType = b.MediaType,
            FileName = b.FileName,
            Data = b.Data
        }).ToList();

        await db.SaveMessageWithAttachments(new MessageRecord
        {
            ChainId = ctx.ChainId,
            Iteration = 0,
            Role = "user",
            Type = "text",
            Content = textContent
        }, attachmentRecords);

        // History komplett aus DB aufbauen (inkl. gerade gespeicherter Message)
        var messages = await chatService.BuildHistoryFromDb(sessionId);

        res.Headers["Content-Type"] = "text/event-stream";
        res.Headers["Cache-Control"] = "no-cache";
        res.Headers["Connection"] = "keep-alive";

        // CancellationToken: Verknüpft Stop-Button (über StreamingTracker) + Client-Disconnect
        var stopCts = streamingTracker.Start(sessionId, ctx.ChainId);
        using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, stopCts.Token);

        try
        {
            await anthropic.StreamChat(res, ctx.ModelId, ctx.SystemPrompt, messages, ctx.ChainId, ctx.Workspace, sessionId, agentId: ctx.AgentId, useMemory: ctx.UseMemory, webSearchVersion: ctx.WebSearchVersion, maxIterations: ctx.MaxIterations, toolChoice: ctx.ToolChoice, review: ctx.Review, cancellationToken: linkedCts.Token);
        }
        finally
        {
            streamingTracker.Stop(sessionId);
        }
    }

    private static async Task HandleStop(HttpRequest req, HttpResponse res, StreamingTracker streamingTracker)
    {
        var body = await JsonSerializer.DeserializeAsync<JsonElement>(req.Body);
        var sessionId = body.TryGetProperty("sessionId", out var sid) ? sid.GetString() : null;

        if (string.IsNullOrEmpty(sessionId))
        {
            res.StatusCode = 400;
            await res.WriteAsJsonAsync(new { error = "sessionId required" });
            return;
        }

        var cancelled = streamingTracker.Cancel(sessionId);
        await res.WriteAsJsonAsync(new { stopped = cancelled });
    }
}