Harness gegen stillen Verlust gehaertet (#547-#551)

Fuenf Befunde mit einem gemeinsamen Fehlermodus: Keiner erzeugt eine
Fehlermeldung. Der Lauf wird fertig, das Ergebnis sieht plausibel aus,
und nur die Qualitaet ist schlechter.

#547 Der Begleittext zum Werkzeugaufruf ging verloren. AssistantWithToolCalls
baute eine neue Nachricht aus nur den Aufrufen; der Text, den das Modell
daneben geschrieben hatte, fiel weg. Damit verlor das Modell zwischen zwei
Schritten seinen eigenen Plan, und im Audit stand, dass ein Werkzeug lief,
nicht warum.

#548 finish_reason wurde nirgends gelesen. Eine an der Ausgabegrenze
abgeschnittene Antwort galt als fertiges Ergebnis. Das trifft besonders
Laeufe im Hintergrund, wo niemand zusieht. Neuer Status Truncated: Das
Teilergebnis geht weiter, aber gekennzeichnet.

#549 reasoning_details wurde verworfen. Bei Werkzeugnutzung muss der
Denkverlauf unveraendert zurueck, sonst beginnt ein Thinking-Modell jedes
Mal von vorn. Wird jetzt als rohes JSON durchgereicht - ohne Auslegung,
weil Reihenfolge und Signatur daran haengen.

#550 Die Anfrage verlangt jetzt einen Anbieter, der alle mitgeschickten
Parameter beherrscht. Ohne das durfte ein Anbieter cache_control, reasoning
oder sogar tools stillschweigend uebergehen - der Lauf lieferte dann eine
gewoehnliche Textantwort, wo ein Werkzeugaufruf hingehoert haette. Dazu
usage.include: der abgerechnete Betrag schlaegt die Eigenrechnung, die als
Rueckfallebene bleibt. Denktiefe je Agent einstellbar, Vorgabe off.

#551 Werkzeuge eines Zuges laufen gleichzeitig, sofern sie sich dafuer
freigeben. Die Vorgabe von IsParallelSafe ist false, weil die falsche
Antwort hier nicht auffaellt: Zwei schreibende Aufrufe auf derselben Datei
scheitern nicht zuverlaessig, sondern gelegentlich. Freigegeben ist bisher
nur WebFetch - es liest ausschliesslich. Die Reihenfolge der Ergebnisse
folgt den Aufrufen, nicht der Fertigstellung; daran haengen die
tool_call_id-Zuordnung und der Cache-Praefix.

27 neue Tests, 887 gesamt, keine Regression. Build ohne Warnungen.

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

src/ClawdDotNet.Core/Api/Models/ChatMessage.cs

@@ -28,14 +28,45 @@ public sealed class ChatMessage
     [JsonIgnore]
     public bool CacheBreakpoint { get; set; }
 
+    /// <summary>
+    /// Der Denkverlauf als Klartext, so wie der Anbieter ihn geliefert hat.
+    /// </summary>
+    public string? Reasoning { get; set; }
+
+    /// <summary>
+    /// Der strukturierte Denkverlauf, unverändert.
+    ///
+    /// Wird bei Werkzeugnutzung in der folgenden Anfrage zurückgeschickt: Das Modell
+    /// setzt seine begonnene Antwort fort, statt eine neue zu beginnen. Die Abfolge
+    /// muss dabei genau der gelieferten entsprechen — umstellen oder verändern macht
+    /// sie unbrauchbar, und bei signierten Formaten kann der Anbieter sie dann nicht
+    /// mehr zuordnen. Deshalb wird hier rohes JSON gehalten und nichts ausgelegt.
+    /// </summary>
+    public JsonElement? ReasoningDetails { 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 };
 
-    public static ChatMessage AssistantWithToolCalls(List<ToolCall> toolCalls) => new()
+    /// <summary>
+    /// Baut die assistant-Nachricht für einen Zug mit Werkzeugaufrufen.
+    ///
+    /// <paramref name="content"/> ist der Text, den das Modell neben die Aufrufe
+    /// geschrieben hat („Ich sehe zuerst in der Konfiguration nach"). Er gehört in den
+    /// Verlauf: Ohne ihn verliert das Modell im nächsten Schritt seinen eigenen Plan,
+    /// und im Audit steht, <i>dass</i> ein Werkzeug lief, nicht <i>warum</i>.
+    /// </summary>
+    public static ChatMessage AssistantWithToolCalls(
+        List<ToolCall> toolCalls,
+        string? content = null,
+        string? reasoning = null,
+        JsonElement? reasoningDetails = null) => new()
     {
         Role = "assistant",
-        ToolCalls = toolCalls
+        Content = string.IsNullOrEmpty(content) ? null : content,
+        ToolCalls = toolCalls,
+        Reasoning = reasoning,
+        ReasoningDetails = reasoningDetails
     };
 
     public static ChatMessage ToolResponse(string toolCallId, string content) => new()
@@ -95,6 +126,24 @@ public sealed class ChatMessageConverter : JsonConverter<ChatMessage>
                     message.ToolCallId = reader.GetString();
                     break;
 
+                // Der Denkverlauf wird durchgereicht, nicht ausgelegt. "reasoning_content"
+                // ist derselbe Inhalt unter anderem Namen; wer zuerst kommt, gewinnt.
+                case "reasoning":
+                case "reasoning_content":
+                    message.Reasoning ??= reader.TokenType == JsonTokenType.String
+                        ? reader.GetString()
+                        : null;
+                    if (reader.TokenType is not JsonTokenType.String and not JsonTokenType.Null)
+                        reader.Skip();
+                    break;
+
+                case "reasoning_details":
+                    // Clone(), weil der Reader nach dieser Schleife nicht mehr gilt.
+                    message.ReasoningDetails = reader.TokenType == JsonTokenType.Null
+                        ? null
+                        : JsonDocument.ParseValue(ref reader).RootElement.Clone();
+                    break;
+
                 default:
                     reader.Skip();
                     break;
@@ -175,6 +224,18 @@ public sealed class ChatMessageConverter : JsonConverter<ChatMessage>
         if (value.ToolCallId is not null)
             writer.WriteString("tool_call_id", value.ToolCallId);
 
+        // Unverändert zurück. Das strukturierte Feld hat Vorrang, weil nur es Signatur
+        // und Reihenfolge trägt; der Klartext geht mit, wenn es keines gibt.
+        if (value.ReasoningDetails is { } details)
+        {
+            writer.WritePropertyName("reasoning_details");
+            details.WriteTo(writer);
+        }
+        else if (value.Reasoning is not null)
+        {
+            writer.WriteString("reasoning", value.Reasoning);
+        }
+
         writer.WriteEndObject();
     }
 }