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>

tests/ClawdDotNet.Core.Tests/Infrastructure/FakeTool.cs

@@ -22,12 +22,47 @@ internal sealed class FakeTool : IAgentTool
     /// <summary>Jeder Aufruf wird mitgeschrieben — inklusive der aufrufenden Agent-Id.</summary>
     public ConcurrentBag<string> Invocations { get; } = new();
 
+    /// <summary>Ob das Werkzeug sich für gleichzeitige Ausführung freigibt (#551).</summary>
+    public bool IsParallelSafe { get; private init; }
+
+    /// <summary>
+    /// Höchste Zahl gleichzeitig laufender Aufrufe, die dieses Werkzeug gesehen hat.
+    ///
+    /// Das ist der einzige Nachweis, der zählt: Eine kürzere Gesamtlaufzeit könnte auch
+    /// von einer schnellen Maschine kommen, aber ein Höchststand von 2 kann nur
+    /// entstehen, wenn zwei Aufrufe einander tatsächlich überlappt haben.
+    /// </summary>
+    public int MaxConcurrent => _maxConcurrent;
+
+    private int _current;
+    private int _maxConcurrent;
+
     private FakeTool(string name, Func<JsonElement, AgentToolContext, CancellationToken, Task<ToolResult>> handler)
     {
         Name = name;
         _handler = handler;
     }
 
+    /// <summary>
+    /// Ein langsames Werkzeug, das sich für Nebenläufigkeit freigibt und mitzählt,
+    /// wie viele Aufrufe sich überlappt haben.
+    /// </summary>
+    public static FakeTool SlowParallelSafe(TimeSpan delay, string result = "ok", string name = "ParallelTool")
+        => new(name, async (_, _, ct) =>
+        {
+            await Task.Delay(delay, ct);
+            return ToolResult.Ok(result);
+        })
+        { IsParallelSafe = true };
+
+    /// <summary>Dasselbe, aber ohne Freigabe — muss seriell bleiben.</summary>
+    public static FakeTool SlowSerial(TimeSpan delay, string result = "ok", string name = "SerialTool")
+        => new(name, async (_, _, ct) =>
+        {
+            await Task.Delay(delay, ct);
+            return ToolResult.Ok(result);
+        });
+
     public static FakeTool Returning(string result, string name = "TestTool")
         => new(name, (_, _, _) => Task.FromResult(ToolResult.Ok(result)));
 
@@ -42,10 +77,26 @@ internal sealed class FakeTool : IAgentTool
     public static FakeTool Throwing(Exception ex, string name = "TestTool")
         => new(name, (_, _, _) => throw ex);
 
-    public Task<ToolResult> ExecuteAsync(JsonElement input, AgentToolContext context, CancellationToken ct)
+    public async Task<ToolResult> ExecuteAsync(JsonElement input, AgentToolContext context, CancellationToken ct)
     {
         Invocations.Add(context.AgentId);
-        return _handler(input, context, ct);
+
+        var now = Interlocked.Increment(ref _current);
+
+        // Höchststand fortschreiben, ohne ihn je zu senken: Vergleichen und Tauschen,
+        // bis der gespeicherte Wert nicht mehr kleiner ist.
+        int seen;
+        while (now > (seen = Volatile.Read(ref _maxConcurrent)))
+            Interlocked.CompareExchange(ref _maxConcurrent, now, seen);
+
+        try
+        {
+            return await _handler(input, context, ct);
+        }
+        finally
+        {
+            Interlocked.Decrement(ref _current);
+        }
     }
 }