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

using System.Collections.Concurrent;
using System.Text.Json;
using ClawdDotNet.Core.Tools;

namespace ClawdDotNet.Core.Tests.Infrastructure;

/// <summary>
/// Ein Tool, das einen anderen Agenten beauftragt — der Nachbau dessen, was
/// <c>AgentComm.send_message</c> und <c>AgentSpawn.spawn_agent</c> tun.
///
/// <para>Der Nachbau ist nötig, weil beide Werkzeuge in eigenen Projekten liegen, die
/// <c>ClawdDotNet.Core.Tests</c> nicht referenziert. Entscheidend ist ohnehin nur die
/// eine Zeile, in der sie sich hier gleichen: Die Delegationskette des eigenen Laufs
/// wird weitergereicht. Ein Tool, das sie unterschlägt, macht aus einem Zyklus eine
/// neue Beauftragung — genau der Fall, den B8 beschreibt.</para>
///
/// <para>Wen ein Agent beauftragt, steht in <paramref name="routes"/>: agentId → Ziel.
/// Wer dort nicht vorkommt, delegiert nicht und antwortet schlicht.</para>
/// </summary>
internal sealed class DelegatingTool : IAgentTool
{
    private readonly IReadOnlyDictionary<string, string> _routes;
    private readonly bool _spawn;
    private readonly TimeSpan _delayBeforeHandoff;

    public string Name => "TestTool";
    public string Description => "Beauftragt einen anderen Agenten.";

    public JsonElement InputSchema { get; } = JsonDocument.Parse("""
        { "type": "object", "properties": { "message": { "type": "string" } } }
        """).RootElement.Clone();

    /// <summary>Was zurückkam — Aufrufer, Ziel und das Ergebnis der Weitergabe.</summary>
    public ConcurrentBag<(string From, string To, bool Delivered, string? Error)> Handoffs { get; } = new();

    /// <param name="delayBeforeHandoff">
    /// Wartezeit, bevor weitergegeben wird. Der Fake-Client antwortet synchron; ohne
    /// diese Pause läuft ein Chat vollständig durch, bevor der nächste überhaupt
    /// beginnt, und zwei Ketten können sich nicht überschneiden.
    /// </param>
    public DelegatingTool(
        IReadOnlyDictionary<string, string> routes,
        bool spawn = false,
        TimeSpan delayBeforeHandoff = default)
    {
        _routes = routes;
        _spawn = spawn;
        _delayBeforeHandoff = delayBeforeHandoff;
    }

    public async Task<ToolResult> ExecuteAsync(
        JsonElement input, AgentToolContext context, CancellationToken ct)
    {
        if (!_routes.TryGetValue(context.AgentId, out var target))
            return ToolResult.Ok("nichts zu delegieren");

        if (_delayBeforeHandoff > TimeSpan.Zero)
            await Task.Delay(_delayBeforeHandoff, ct);

        if (_spawn)
        {
            var spawned = await context.MessageRouter!.SpawnAgentAsync(
                context.AgentId, target, "Auftrag", context.InstanceId, context.Delegation, ct);

            Handoffs.Add((context.AgentId, target, spawned.Started, spawned.Error));

            return spawned.Started
                ? ToolResult.Ok(spawned.FinalMessage ?? "")
                : ToolResult.Ok(JsonSerializer.Serialize(new { spawned = false, error = spawned.Error }));
        }

        var result = await context.MessageRouter!.SendMessageAsync(
            context.AgentId, target, "Frage", context.InstanceId, context.Delegation, ct);

        Handoffs.Add((context.AgentId, target, result.Delivered, result.Error));

        // Wie das echte Tool: Eine Ablehnung ist kein Wurf, sondern ein Ergebnis, das
        // der Agent lesen und auf das er anders reagieren kann.
        return result.Delivered
            ? ToolResult.Ok(result.Response ?? "")
            : ToolResult.Ok(JsonSerializer.Serialize(new { delivered = false, error = result.Error }));
    }
}