Prompt-Caching, Tool-Ergebnis-Kappung und Kostenerfassung

T1 — Prompt-Caching. Bisher wurde bei jedem Schritt eines Runs der komplette
Prompt neu berechnet, inklusive Tool-Definitionen und System-Prompt, die sich nie
aendern. Bei zehn Schritten und einem 15k-Praefix sind das 150.000 statt 15.000
Eingabe-Tokens.

ChatMessage bekommt dafuer einen eigenen JsonConverter: Der Inhalt geht weiterhin
als String raus, bei gesetztem CacheBreakpoint jedoch als Blockarray mit
cache_control. Beim Lesen werden beide Formate akzeptiert, damit bestehende
ChatContext.json weiter geladen werden koennen.

PromptCache setzt zwei Breakpoints: einen auf den System-Prompt (deckt
Tool-Definitionen und System-Prompt ab) und einen rollierenden auf die letzte
Nachricht mit Inhalt. Vorherige Markierungen werden vorher entfernt, damit sie
sich nicht ansammeln. Aktivierung ueber promptCaching: auto (Default, aktiv fuer
Modelle mit Unterstuetzung), on oder off.

Der wichtigste Test dazu prueft die Praefix-Stabilitaet: Der System-Prompt muss
ueber alle Schritte zeichengleich serialisiert werden. Ein einziger Zeitstempel
darin wuerde den Cache still verwerfen — die Kosten blieben unveraendert, ohne
dass es irgendwo auffiele.

T9 — Usage liest prompt_tokens_details.cached_tokens; die Zahl wird bis in
AgentRunResult durchgereicht. Ohne sie liesse sich die Wirkung nicht belegen.

T2 — Tool-Ergebnisse werden jetzt zentral in ExecuteToolCallAsync gekappt
(maxToolResultChars, Default 16.000). Bisher konnte ein einzelner WebFetch mit
dem 512-KB-Standardlimit rund 130.000 Tokens in EINER Antwort erzeugen; die
Compaction griff erst danach, bezahlt war der Request laengst.

T3 — Die Zusammenfassung beim Kompaktieren laeuft ueber ein konfigurierbares
summaryModel (Default gemini-2.5-flash) statt ueber das teure Agentenmodell.

B4 — AgentRunResult fuehrt Prompt- und Completion-Tokens getrennt; die
Kostenanzeige schaetzte bisher 50/50, real liegt das Verhaeltnis eher bei 95:5.
Die veraltete Preistabelle bleibt offen.

Neue Einstellungen sind im PropertyGrid sichtbar und werden vom AgentEditor bei
neuen Agenten mitgeschrieben.

Alle 91 Tests gruen.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

src/ClawdDotNet.Core/Engine/PromptCache.cs

@@ -0,0 +1,67 @@
+using ClawdDotNet.Core.Api.Models;
+
+namespace ClawdDotNet.Core.Engine;
+
+/// <summary>
+/// Setzt Prompt-Caching-Breakpoints in die Nachrichtenliste.
+///
+/// Hintergrund: In einem Agenten-Run wird bei JEDEM Schritt der komplette Prompt erneut
+/// gesendet und voll berechnet — inklusive Tool-Definitionen und System-Prompt, die sich
+/// nie ändern. Bei zehn Schritten und einem 15k-Präfix sind das 150.000 Eingabe-Tokens
+/// statt 15.000.
+///
+/// Ein Breakpoint markiert das Ende eines stabilen Prompt-Abschnitts. Alles davor wird
+/// beim nächsten Aufruf aus dem Cache gelesen und kostet nur einen Bruchteil.
+///
+/// Zwei Breakpoints werden gesetzt:
+/// 1. auf den System-Prompt — deckt Tool-Definitionen und System-Prompt ab,
+/// 2. rollierend auf die letzte Nachricht — deckt den bereits gelaufenen Gesprächsverlauf ab.
+/// </summary>
+public static class PromptCache
+{
+    /// <summary>
+    /// Modelle, bei denen "auto" das Caching einschaltet. Andere Anbieter ignorieren
+    /// cache_control entweder oder cachen ohnehin automatisch.
+    /// </summary>
+    private static readonly string[] AutoEnabledPrefixes = ["anthropic/"];
+
+    public static bool IsEnabledFor(string setting, string model) => setting?.ToLowerInvariant() switch
+    {
+        "on" => true,
+        "off" => false,
+        _ => AutoEnabledPrefixes.Any(p => model.StartsWith(p, StringComparison.OrdinalIgnoreCase))
+    };
+
+    /// <summary>
+    /// Setzt die Breakpoints neu. Vorherige werden entfernt, damit sich pro Schritt
+    /// nie mehr als die beabsichtigten Markierungen ansammeln.
+    /// </summary>
+    public static void ApplyBreakpoints(List<ChatMessage> messages)
+    {
+        foreach (var msg in messages)
+            msg.CacheBreakpoint = false;
+
+        if (messages.Count == 0)
+            return;
+
+        // 1. System-Prompt — der stabilste Teil überhaupt.
+        var system = messages[0].Role == "system" ? messages[0] : null;
+        if (system?.Content is not null)
+            system.CacheBreakpoint = true;
+
+        // 2. Letzte Nachricht mit Inhalt. Beim nächsten Schritt ist alles bis hierher
+        //    unverändert und wird aus dem Cache gelesen.
+        //    Eine assistant-Nachricht mit tool_calls hat keinen Textinhalt und kann
+        //    deshalb keinen Block tragen — in dem Fall bleibt es beim System-Breakpoint.
+        for (var i = messages.Count - 1; i >= 1; i--)
+        {
+            if (messages[i].Content is null)
+                continue;
+
+            if (!ReferenceEquals(messages[i], system))
+                messages[i].CacheBreakpoint = true;
+
+            break;
+        }
+    }
+}