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>
This commit is contained in:
Richard
2026-07-27 18:32:17 +02:00
co-authored by Claude Opus 4.8
parent 6bbe9f9a80
commit 69b5704add
17 changed files with 971 additions and 28 deletions
+149 -7
View File
@@ -1,24 +1,33 @@
using System.Text.Json;
using System.Text.Json.Serialization;
namespace ClawdDotNet.Core.Api.Models;
[JsonConverter(typeof(ChatMessageConverter))]
public sealed class ChatMessage
{
[JsonPropertyName("role")]
public string Role { get; set; } = "";
[JsonPropertyName("content")]
[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
public string? Content { get; set; }
[JsonPropertyName("tool_calls")]
[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
public List<ToolCall>? ToolCalls { get; set; }
[JsonPropertyName("tool_call_id")]
[JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
public string? ToolCallId { get; set; }
/// <summary>
/// Setzt einen Prompt-Caching-Breakpoint auf diese Nachricht.
///
/// Alles, was im Prompt VOR dem Breakpoint steht (Tool-Definitionen, System-Prompt,
/// vorherige Nachrichten), wird beim nächsten Aufruf aus dem Cache gelesen und
/// kostet nur einen Bruchteil. Der Inhalt wird dann als Block-Array statt als
/// einfacher String serialisiert.
///
/// Wichtig: Der Prompt-Abschnitt vor dem Breakpoint muss zwischen zwei Aufrufen
/// zeichengenau identisch sein, sonst greift der Cache nicht.
/// </summary>
[JsonIgnore]
public bool CacheBreakpoint { get; set; }
public static ChatMessage System(string content) => new() { Role = "system", Content = content };
public static ChatMessage User(string content) => new() { Role = "user", Content = content };
public static ChatMessage Assistant(string content) => new() { Role = "assistant", Content = content };
@@ -36,3 +45,136 @@ public sealed class ChatMessage
Content = content
};
}
/// <summary>
/// Serialisiert <see cref="ChatMessage"/>. Der Inhalt geht normalerweise als einfacher
/// String raus; ist ein <see cref="ChatMessage.CacheBreakpoint"/> gesetzt, stattdessen
/// als Block-Array mit cache_control — das Format, das Anbieter für Prompt-Caching
/// erwarten.
///
/// Beim Lesen werden beide Formate akzeptiert: Antworten liefern den Inhalt als String,
/// gespeicherte Kontexte können ihn als Array enthalten.
/// </summary>
public sealed class ChatMessageConverter : JsonConverter<ChatMessage>
{
public override ChatMessage Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
if (reader.TokenType != JsonTokenType.StartObject)
throw new JsonException("ChatMessage: Objekt erwartet.");
var message = new ChatMessage();
while (reader.Read())
{
if (reader.TokenType == JsonTokenType.EndObject)
return message;
if (reader.TokenType != JsonTokenType.PropertyName)
continue;
var propertyName = reader.GetString();
reader.Read();
switch (propertyName)
{
case "role":
message.Role = reader.GetString() ?? "";
break;
case "content":
message.Content = ReadContent(ref reader);
break;
case "tool_calls":
message.ToolCalls = reader.TokenType == JsonTokenType.Null
? null
: JsonSerializer.Deserialize<List<ToolCall>>(ref reader, options);
break;
case "tool_call_id":
message.ToolCallId = reader.GetString();
break;
default:
reader.Skip();
break;
}
}
throw new JsonException("ChatMessage: unerwartetes Ende.");
}
/// <summary>Nimmt den Inhalt als String oder als Block-Array entgegen.</summary>
private static string? ReadContent(ref Utf8JsonReader reader)
{
if (reader.TokenType == JsonTokenType.Null)
return null;
if (reader.TokenType == JsonTokenType.String)
return reader.GetString();
if (reader.TokenType != JsonTokenType.StartArray)
{
reader.Skip();
return null;
}
// Block-Array: die text-Anteile zusammenführen.
var parts = new List<string>();
while (reader.Read() && reader.TokenType != JsonTokenType.EndArray)
{
if (reader.TokenType != JsonTokenType.StartObject)
{
reader.Skip();
continue;
}
using var block = JsonDocument.ParseValue(ref reader);
if (block.RootElement.TryGetProperty("text", out var text) &&
text.GetString() is { } value)
{
parts.Add(value);
}
}
return parts.Count > 0 ? string.Join("", parts) : null;
}
public override void Write(Utf8JsonWriter writer, ChatMessage value, JsonSerializerOptions options)
{
writer.WriteStartObject();
writer.WriteString("role", value.Role);
if (value.Content is not null)
{
if (value.CacheBreakpoint)
{
// [{ "type": "text", "text": "…", "cache_control": { "type": "ephemeral" } }]
writer.WriteStartArray("content");
writer.WriteStartObject();
writer.WriteString("type", "text");
writer.WriteString("text", value.Content);
writer.WriteStartObject("cache_control");
writer.WriteString("type", "ephemeral");
writer.WriteEndObject();
writer.WriteEndObject();
writer.WriteEndArray();
}
else
{
writer.WriteString("content", value.Content);
}
}
if (value.ToolCalls is { Count: > 0 })
{
writer.WritePropertyName("tool_calls");
JsonSerializer.Serialize(writer, value.ToolCalls, options);
}
if (value.ToolCallId is not null)
writer.WriteString("tool_call_id", value.ToolCallId);
writer.WriteEndObject();
}
}