Bugtracker-Durchgang: 13 Bugs behoben, Build ohne Warnungen
Alle Behebungen auf der Linux-Test-VM gegengeprueft (Ubuntu, .NET 10.0.111): Build 0 Warnungen / 0 Fehler, 637 Tests gruen, 1 uebersprungen (WindowsFact). Sicherheit und Zielplattform #373 PathBoundary.Canonicalize fiel offen aus. File.ResolveLinkTarget wirft fuer einen fehlenden Abschnitt FileNotFoundException; der catch(IOException) verliess daraufhin die GANZE Aufloesung mit dem unaufgeloesten Pfad - und der besteht jede Praefixpruefung. Der Symlink-Schutz war damit bei jedem Schreibvorgang wirkungslos. Jetzt ueber FileSystemInfo.LinkTarget, und TryCanonicalize meldet "nicht bestimmbar", statt fail-open durchzureichen. #374 WorkspacePath weist den Backslash rundheraus ab, wie den Doppelpunkt. Eine Schreibweise statt einer Sonderregel je Windows-Form. #375 Log-Verzeichnis: leer heisst "Anwendungseinstellung"; ein relativer Wert zaehlt gegen das Instanzverzeichnis, nicht gegen das Arbeitsverzeichnis des Prozesses. Ein systemd-Dienst landet nicht mehr auf /Logs. Agentenkommunikation #206 Delegationskette gegen A->B->A (Test A13). Zyklusfrei per Bauart, dazu MaxDelegationDepth gegen die Staffel, die niemand beauftragt hat. #461 Zwei unabhaengige Ketten ueber Kreuz - beim Beheben von #206 gefunden und reproduziert. Ein delegierter Lauf wartet nur noch begrenzt auf ein fremdes Gate; ein Chat vom Menschen reiht sich weiter unbegrenzt ein. #234 Instanz-Id wird durchgereicht statt aus einem nur beilaeufig gesetzten Feld gelesen. Betrieb und Oberflaeche #376 Log-Ansicht chronologisch statt gruppiert je Moduldatei, mit Stacktraces an ihrer Meldung - auch ueber Taktgrenzen hinweg. #377 Info-Tabelle: feste Spaltenbreiten, damit ein langer Aenderungstext den anderen Spalten nicht den Platz nimmt. #378 Sicherung: Mindestabstand zwischen Ueberschrift und Schaltflaechenleiste. #379 Hellmodus: drei von vier gedaempften Textpinseln lagen unter 4,5:1. Die helle Palette ist als Ganzes verschoben, damit die Staffelung sichtbar bleibt statt auf einen Wert zusammenzufallen. Hygiene #233 stock_add: der Indexstand wird innerhalb der Sperre festgehalten. #235 Zeitumstellung: eine nicht existierende Ortszeit wird auf den ersten Zeitpunkt nach der Luecke verschoben statt uebersprungen (R4, R5). #236 45 Nullable-Warnungen und eine CA1416 - nicht unterdrueckt, sondern die Stellen so umgebaut, dass die Zusage nachvollziehbar wird. Mail meldet jetzt, WELCHER Zugangsschluessel fehlt, statt an einer KeyNotFoundException zu scheitern. #203 Kompaktiert wird vor dem API-Aufruf statt danach; die gemessenen Prompt-Groessen kalibrieren die Schaetzung je Modell. Neu: tests/ClawdDotNet.App.Tests - fuer #375 und #376 gab es keinen Ort fuer Tests. Dazu Regressionstests fuer jede Behebung; jeder wurde gegen den alten Stand geprueft, damit belegt ist, dass er den Fehler faengt. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Richard
@@ -16,8 +16,17 @@ public sealed class InstanceConfig
|
||||
[JsonPropertyName("workingDirectory")]
|
||||
public string WorkingDirectory { get; set; } = "./data/";
|
||||
|
||||
/// <summary>
|
||||
/// Wohin diese Instanz protokolliert. Leer heißt: das Log-Verzeichnis aus den
|
||||
/// Anwendungseinstellungen, also der absolute Pfad unter <c>AppPaths.DataDirectory</c>.
|
||||
///
|
||||
/// Die frühere Vorbelegung <c>"./Logs"</c> war nie leer und verdeckte damit die
|
||||
/// Anwendungseinstellung vollständig; aufgelöst wurde sie zudem gegen das
|
||||
/// Arbeitsverzeichnis des Prozesses. Ein relativer Wert zählt heute gegen das
|
||||
/// Instanzverzeichnis (siehe <c>AppHost.StartAsync</c>).
|
||||
/// </summary>
|
||||
[JsonPropertyName("logDirectory")]
|
||||
public string LogDirectory { get; set; } = "./Logs";
|
||||
public string LogDirectory { get; set; } = "";
|
||||
|
||||
[JsonPropertyName("webServerPort")]
|
||||
public int WebServerPort { get; set; } = 8080;
|
||||
@@ -33,6 +42,27 @@ public sealed class InstanceConfig
|
||||
[JsonPropertyName("budget")]
|
||||
public InstanceBudget Budget { get; set; } = new();
|
||||
|
||||
/// <summary>
|
||||
/// Wie viele Weitergaben eine Delegationskette höchstens haben darf (B8, #206).
|
||||
/// A→B ist die Tiefe 1. Zyklen fängt die Kette selbst ab; dieser Wert begrenzt die
|
||||
/// Staffel A→B→C→D, die niemand beauftragt hat und die jeden Schritt einen vollen
|
||||
/// Lauf kostet.
|
||||
///
|
||||
/// Instanzweit und nicht je Agent: Eine Kette gehört keinem der Beteiligten.
|
||||
/// </summary>
|
||||
[JsonPropertyName("maxDelegationDepth")]
|
||||
public int MaxDelegationDepth { get; set; } = 3;
|
||||
|
||||
/// <summary>
|
||||
/// Wie lange ein delegierter Aufruf höchstens auf einen belegten Zielagenten
|
||||
/// wartet, in Sekunden (#461). Danach kommt eine Absage statt weiterer Wartezeit.
|
||||
///
|
||||
/// Gilt nur für Delegationen. Ein vom Menschen angestoßener Chat reiht sich
|
||||
/// weiterhin ein und wartet, so lange es dauert.
|
||||
/// </summary>
|
||||
[JsonPropertyName("delegationGateTimeoutSeconds")]
|
||||
public int DelegationGateTimeoutSeconds { get; set; } = 120;
|
||||
|
||||
[JsonPropertyName("agents")]
|
||||
public List<AgentConfig> Agents { get; set; } = new();
|
||||
|
||||
|
||||
@@ -32,6 +32,36 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
|
||||
/// <summary>Tagesgrenzen der Instanz. Wird vom Host gesetzt.</summary>
|
||||
public InstanceBudget InstanceBudget { get; set; } = InstanceBudget.Unlimited;
|
||||
|
||||
/// <summary>
|
||||
/// Wie viele Weitergaben eine Delegationskette höchstens haben darf (B8).
|
||||
/// A→B ist die Tiefe 1, A→B→C die Tiefe 2.
|
||||
///
|
||||
/// Zyklen fängt schon die Kette selbst ab — dieser Wert begrenzt die Staffel, die
|
||||
/// keiner ist: A beauftragt B, B beauftragt C, C beauftragt D. Jeder Schritt hält
|
||||
/// das Gate seines Vorgängers und kostet einen vollen Lauf; drei Weitergaben sind
|
||||
/// mehr, als eine sinnvolle Arbeitsteilung braucht.
|
||||
///
|
||||
/// Instanzweit und nicht je Agent: Eine Kette gehört keinem der Beteiligten.
|
||||
/// </summary>
|
||||
public int MaxDelegationDepth { get; set; } = 3;
|
||||
|
||||
/// <summary>
|
||||
/// Wie lange ein <b>delegierter</b> Lauf höchstens auf das Gate seines Zielagenten
|
||||
/// wartet (#461). Danach kommt eine Absage statt weiterer Wartezeit.
|
||||
///
|
||||
/// <para>Die Delegationskette schließt Zyklen aus, aber nicht das Über-Kreuz: Lauf 1
|
||||
/// startet bei A und beauftragt B, Lauf 2 startet zeitgleich bei B und beauftragt A.
|
||||
/// Beide Ketten sind für sich zyklusfrei — trotzdem hält jeder das Gate, auf das der
|
||||
/// andere wartet. Eine Kette kann das grundsätzlich nicht sehen; nur eine Frist
|
||||
/// löst es auf.</para>
|
||||
///
|
||||
/// <para>Nur für delegierte Läufe. Ein vom Menschen angestoßener Chat reiht sich
|
||||
/// weiterhin ein und wartet, so lange es dauert — dort gibt es niemanden, der
|
||||
/// verklemmen könnte, und ein Abbruch wäre nur lästig.</para>
|
||||
/// </summary>
|
||||
public TimeSpan DelegationGateTimeout { get; set; } = TimeSpan.FromSeconds(120);
|
||||
|
||||
private readonly ContextCompactor _compactor;
|
||||
|
||||
private readonly Dictionary<string, List<ChatEntry>> _chatHistories = new();
|
||||
@@ -112,14 +142,16 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
string instanceId,
|
||||
CancellationToken externalCt,
|
||||
string? source = null,
|
||||
string? taskId = null)
|
||||
string? taskId = null,
|
||||
DelegationChain? delegation = null)
|
||||
{
|
||||
// Vor der ersten Anfrage prüfen — ein erschöpftes Budget soll gar nichts kosten.
|
||||
if (await CheckBudgetAsync(agentConfig, externalCt) is { } denied)
|
||||
return denied;
|
||||
|
||||
var runId = Guid.NewGuid().ToString("N");
|
||||
var result = await RunCoreAsync(agentConfig, userMessage, instanceId, externalCt, runId, source);
|
||||
var chain = delegation ?? DelegationChain.Root(agentConfig.AgentId);
|
||||
var result = await RunCoreAsync(agentConfig, userMessage, instanceId, externalCt, runId, source, chain);
|
||||
await RecordUsageAsync(agentConfig, result);
|
||||
await RecordReceiptAsync(runId, agentConfig, result, source ?? AuditSource.Direct, taskId);
|
||||
return result;
|
||||
@@ -131,7 +163,8 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
string instanceId,
|
||||
CancellationToken externalCt,
|
||||
string runId,
|
||||
string? source)
|
||||
string? source,
|
||||
DelegationChain chain)
|
||||
{
|
||||
var logger = _loggerFactory.CreateLogger($"ClawdDotNet.Core.Engine.{agentConfig.AgentId}");
|
||||
var loopGuard = new LoopGuard(agentConfig.LoopGuard);
|
||||
@@ -166,6 +199,14 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
ct.ThrowIfCancellationRequested();
|
||||
loopGuard.RecordStep();
|
||||
|
||||
// Kompaktieren vor dem Aufruf — dieselbe Reihenfolge wie in ChatCoreAsync.
|
||||
// Verhindert die Token-Explosion bei komplexen Analysen, und zwar bevor
|
||||
// sie bezahlt ist statt danach.
|
||||
if (await _compactor.CompactIfNeededAsync(messages, agentConfig.LoopGuard, agentConfig.Model, ct))
|
||||
{
|
||||
OnStepCompleted?.Invoke(agentConfig.AgentId, "Context kompaktiert (RunAsync)");
|
||||
}
|
||||
|
||||
if (cachingEnabled)
|
||||
PromptCache.ApplyBreakpoints(messages);
|
||||
|
||||
@@ -180,22 +221,15 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
: null
|
||||
};
|
||||
|
||||
var estimated = _compactor.EstimateFor(agentConfig.Model, messages);
|
||||
|
||||
var response = await _client.CompleteAsync(request, ct);
|
||||
|
||||
var promptTokens = 0;
|
||||
if (response.Usage is not null)
|
||||
{
|
||||
tally.Add(response.Usage);
|
||||
promptTokens = response.Usage.PromptTokens;
|
||||
loopGuard.RecordTokens(response.Usage.TotalTokens);
|
||||
}
|
||||
|
||||
// Context-Compaction auch in RunAsync – verhindert Token-Explosion bei komplexen Analysen
|
||||
var compacted = await _compactor.CompactIfNeededAsync(
|
||||
messages, promptTokens, agentConfig.LoopGuard, agentConfig.Model, ct);
|
||||
if (compacted)
|
||||
{
|
||||
OnStepCompleted?.Invoke(agentConfig.AgentId, "Context kompaktiert (RunAsync)");
|
||||
_compactor.Calibrate(agentConfig.Model, estimated, response.Usage.PromptTokens);
|
||||
}
|
||||
|
||||
var choice = response.Choices.FirstOrDefault();
|
||||
@@ -214,7 +248,7 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
foreach (var toolCall in assistantMessage.ToolCalls)
|
||||
{
|
||||
var toolResult = await ExecuteToolCallAsync(
|
||||
toolCall, agentConfig, instanceId, tools, logger, ct, runId, source);
|
||||
toolCall, agentConfig, instanceId, tools, logger, ct, runId, source, chain);
|
||||
|
||||
messages.Add(ChatMessage.ToolResponse(toolCall.Id, toolResult));
|
||||
}
|
||||
@@ -303,12 +337,14 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
string instanceId,
|
||||
CancellationToken externalCt,
|
||||
string? source = null,
|
||||
string? taskId = null)
|
||||
string? taskId = null,
|
||||
DelegationChain? delegation = null)
|
||||
{
|
||||
if (await CheckBudgetAsync(agentConfig, externalCt) is { } denied)
|
||||
return denied;
|
||||
|
||||
var runId = Guid.NewGuid().ToString("N");
|
||||
var chain = delegation ?? DelegationChain.Root(agentConfig.AgentId);
|
||||
|
||||
// Abbrechbar sein, schon bevor der Lauf an der Reihe ist — sonst hängt eine
|
||||
// wartende Nachricht auch dann noch, wenn der Benutzer längst abgebrochen hat.
|
||||
@@ -316,9 +352,24 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
RegisterRun(agentConfig.AgentId, runCts);
|
||||
|
||||
var gate = GetAgentGate(agentConfig.AgentId);
|
||||
|
||||
// Ein delegierter Lauf wartet nur begrenzt (#461): Zwei Ketten über Kreuz
|
||||
// halten jeweils das Gate, auf das die andere wartet, und keine der beiden
|
||||
// sieht die andere. Ein vom Menschen angestoßener Chat wartet dagegen weiter,
|
||||
// so lange es dauert — dort gibt es niemanden, der verklemmen könnte.
|
||||
var gateWait = chain.Depth > 0 ? DelegationGateTimeout : Timeout.InfiniteTimeSpan;
|
||||
|
||||
try
|
||||
{
|
||||
await gate.WaitAsync(runCts.Token);
|
||||
if (!await gate.WaitAsync(gateWait, runCts.Token))
|
||||
{
|
||||
UnregisterRun(agentConfig.AgentId, runCts);
|
||||
return new AgentRunResult(
|
||||
agentConfig.AgentId, AgentRunStatus.TargetBusy,
|
||||
$"[Agent belegt: '{agentConfig.AgentId}' hat innerhalb von " +
|
||||
$"{gateWait.TotalSeconds:0} Sekunden nicht frei gehabt]",
|
||||
0, 0, TimeSpan.Zero);
|
||||
}
|
||||
}
|
||||
catch (OperationCanceledException)
|
||||
{
|
||||
@@ -330,7 +381,7 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
|
||||
try
|
||||
{
|
||||
var result = await ChatCoreAsync(agentConfig, userMessage, instanceId, runCts.Token, source, runId);
|
||||
var result = await ChatCoreAsync(agentConfig, userMessage, instanceId, runCts.Token, source, runId, chain);
|
||||
await RecordUsageAsync(agentConfig, result);
|
||||
await RecordReceiptAsync(runId, agentConfig, result, source, taskId);
|
||||
return result;
|
||||
@@ -348,7 +399,8 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
string instanceId,
|
||||
CancellationToken runCt,
|
||||
string? source,
|
||||
string runId)
|
||||
string runId,
|
||||
DelegationChain chain)
|
||||
{
|
||||
var logger = _loggerFactory.CreateLogger($"ClawdDotNet.Core.Engine.Chat.{agentConfig.AgentId}");
|
||||
var loopGuard = new LoopGuard(agentConfig.LoopGuard);
|
||||
@@ -398,6 +450,16 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
ct.ThrowIfCancellationRequested();
|
||||
loopGuard.RecordStep();
|
||||
|
||||
// Kompaktieren VOR dem Aufruf. Vorher lief die Prüfung danach und mit
|
||||
// den promptTokens der gerade bezahlten Anfrage: Der überfüllte Prompt
|
||||
// war zu dem Zeitpunkt längst abgerechnet, gekürzt wurde erst für den
|
||||
// nächsten Schritt. Genau ein Schritt zu spät, und der teuerste.
|
||||
if (await _compactor.CompactIfNeededAsync(messages, agentConfig.LoopGuard, agentConfig.Model, ct))
|
||||
{
|
||||
PersistChatState(agentConfig.AgentId);
|
||||
OnStepCompleted?.Invoke(agentConfig.AgentId, "Context kompaktiert");
|
||||
}
|
||||
|
||||
if (cachingEnabled)
|
||||
PromptCache.ApplyBreakpoints(messages);
|
||||
|
||||
@@ -412,23 +474,18 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
: null
|
||||
};
|
||||
|
||||
// Was die Schätzung für genau diese Anfrage sagt — gleich neben dem, was
|
||||
// die API dafür wirklich berechnet. Der Vergleich der beiden ist die
|
||||
// einzige Rückmeldung, die die Schätzung je bekommt.
|
||||
var estimated = _compactor.EstimateFor(agentConfig.Model, messages);
|
||||
|
||||
var response = await _client.CompleteAsync(request, ct);
|
||||
|
||||
var promptTokens = 0;
|
||||
if (response.Usage is not null)
|
||||
{
|
||||
tally.Add(response.Usage);
|
||||
promptTokens = response.Usage.PromptTokens;
|
||||
loopGuard.RecordTokens(response.Usage.TotalTokens);
|
||||
}
|
||||
|
||||
// Context-Compaction nach API-Response prüfen
|
||||
var compacted = await _compactor.CompactIfNeededAsync(
|
||||
messages, promptTokens, agentConfig.LoopGuard, agentConfig.Model, ct);
|
||||
if (compacted)
|
||||
{
|
||||
PersistChatState(agentConfig.AgentId);
|
||||
OnStepCompleted?.Invoke(agentConfig.AgentId, "Context kompaktiert");
|
||||
_compactor.Calibrate(agentConfig.Model, estimated, response.Usage.PromptTokens);
|
||||
}
|
||||
|
||||
var choice = response.Choices.FirstOrDefault();
|
||||
@@ -447,7 +504,7 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
foreach (var toolCall in assistantMessage.ToolCalls)
|
||||
{
|
||||
var toolResult = await ExecuteToolCallAsync(
|
||||
toolCall, agentConfig, instanceId, tools, logger, ct, runId, source);
|
||||
toolCall, agentConfig, instanceId, tools, logger, ct, runId, source, chain);
|
||||
messages.Add(ChatMessage.ToolResponse(toolCall.Id, toolResult));
|
||||
}
|
||||
|
||||
@@ -700,6 +757,37 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
|
||||
// ─── IAgentMessageRouter ───
|
||||
|
||||
/// <summary>
|
||||
/// Darf dieser Aufruf weitergegeben werden (B8)? Gibt den Ablehnungsgrund zurück
|
||||
/// oder <c>null</c>, wenn nichts dagegen spricht.
|
||||
///
|
||||
/// <para>Der Grund geht als Ergebnis an den aufrufenden Agenten zurück, nicht als
|
||||
/// Ausnahme: Er soll lesen können, warum es nicht geht, und einen anderen Weg
|
||||
/// wählen. Deshalb steht die ganze Kette in der Meldung — „Zyklus" allein sagt
|
||||
/// niemandem, welcher.</para>
|
||||
/// </summary>
|
||||
private string? CheckDelegation(DelegationChain? chain, string fromAgentId, string toAgentId)
|
||||
{
|
||||
// Ohne Kette ist der Aufruf von aussen angestossen: Der Absender ist der erste
|
||||
// in der Kette, weitergegeben wurde noch nichts.
|
||||
var callerChain = chain ?? DelegationChain.Root(fromAgentId);
|
||||
|
||||
// Der eigentliche Deadlock. Der Zielagent hält sein Gate schon irgendwo weiter
|
||||
// oben in dieser Kette und gibt es erst frei, wenn dieser Aufruf zurückkommt —
|
||||
// was er nur könnte, wenn das Gate frei wäre.
|
||||
if (callerChain.Contains(toAgentId))
|
||||
return $"Zyklus in der Delegationskette: {callerChain} -> {toAgentId}. " +
|
||||
$"Agent '{toAgentId}' wartet in dieser Kette bereits auf eine Antwort und " +
|
||||
"kann keinen zweiten Auftrag annehmen, ohne sich selbst zu blockieren.";
|
||||
|
||||
if (callerChain.Depth >= MaxDelegationDepth)
|
||||
return $"Delegationstiefe erschöpft: {callerChain} hat die Grenze von " +
|
||||
$"{MaxDelegationDepth} Weitergaben erreicht. Erledige den Rest selbst " +
|
||||
"oder gib die Aufgabe an den Auftraggeber zurück.";
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
public IReadOnlyList<AgentInfo> ListAgents(string callerAgentId)
|
||||
{
|
||||
var configs = _agentConfigProvider?.Invoke() ?? [];
|
||||
@@ -709,8 +797,19 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
.ToList();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Die Instanz des Aufrufers, sonst die der Engine (B13).
|
||||
///
|
||||
/// <c>_instanceId</c> wird nur in <c>SetAgentConfigProvider</c> gesetzt und war
|
||||
/// vorher die einzige Quelle — ein Lauf, der mit einer anderen Instanz-Id
|
||||
/// angestoßen wurde, verlor sie beim Weiterreichen, und ohne den Aufruf war sie leer.
|
||||
/// </summary>
|
||||
private string ResolveInstanceId(string? fromCaller)
|
||||
=> string.IsNullOrWhiteSpace(fromCaller) ? _instanceId : fromCaller;
|
||||
|
||||
public async Task<AgentMessageResult> SendMessageAsync(
|
||||
string fromAgentId, string toAgentId, string message, CancellationToken ct)
|
||||
string fromAgentId, string toAgentId, string message,
|
||||
string? instanceId, DelegationChain? chain, CancellationToken ct)
|
||||
{
|
||||
var configs = _agentConfigProvider?.Invoke();
|
||||
if (configs is null)
|
||||
@@ -726,6 +825,11 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
if (targetConfig is null)
|
||||
return new AgentMessageResult(false, null, $"Agent '{toAgentId}' not found.");
|
||||
|
||||
if (CheckDelegation(chain, fromAgentId, toAgentId) is { } refused)
|
||||
return new AgentMessageResult(false, null, refused);
|
||||
|
||||
var callerChain = chain ?? DelegationChain.Root(fromAgentId);
|
||||
|
||||
var fromConfig = configs.FirstOrDefault(a => a.AgentId == fromAgentId);
|
||||
var fromName = fromConfig?.DisplayName ?? fromAgentId;
|
||||
|
||||
@@ -733,13 +837,23 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
|
||||
try
|
||||
{
|
||||
var result = await ChatAsync(targetConfig, wrappedMessage, _instanceId, ct, source: ChatSource.AgentComm);
|
||||
var result = await ChatAsync(targetConfig, wrappedMessage, ResolveInstanceId(instanceId), ct,
|
||||
source: ChatSource.AgentComm, delegation: callerChain.Append(toAgentId));
|
||||
|
||||
return result.Status switch
|
||||
{
|
||||
AgentRunStatus.Completed => new AgentMessageResult(true, result.FinalMessage),
|
||||
AgentRunStatus.LoopLimitExceeded => new AgentMessageResult(true, result.FinalMessage,
|
||||
"Agent hat das Step-Limit erreicht, die Nachricht wurde aber zugestellt."),
|
||||
|
||||
// #461: Das Ziel war die ganze Frist über belegt. Für den fragenden
|
||||
// Agenten ist das kein Fehler, sondern eine Auskunft — er kann es
|
||||
// später erneut versuchen oder ohne die Antwort weiterarbeiten.
|
||||
AgentRunStatus.TargetBusy => new AgentMessageResult(false, null,
|
||||
$"Agent '{targetConfig.DisplayName}' ({toAgentId}) ist belegt und hat innerhalb " +
|
||||
$"von {DelegationGateTimeout.TotalSeconds:0} Sekunden nicht frei gehabt. " +
|
||||
"Später erneut versuchen oder ohne diese Antwort weitermachen."),
|
||||
|
||||
_ => new AgentMessageResult(false, null, $"Agent run status: {result.Status}")
|
||||
};
|
||||
}
|
||||
@@ -750,7 +864,8 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
}
|
||||
|
||||
public async Task<AgentSpawnResult> SpawnAgentAsync(
|
||||
string fromAgentId, string targetAgentId, string taskMessage, CancellationToken ct)
|
||||
string fromAgentId, string targetAgentId, string taskMessage,
|
||||
string? instanceId, DelegationChain? chain, CancellationToken ct)
|
||||
{
|
||||
var configs = _agentConfigProvider?.Invoke();
|
||||
if (configs is null)
|
||||
@@ -760,6 +875,13 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
if (targetConfig is null)
|
||||
return new AgentSpawnResult(false, targetAgentId, null, $"Agent '{targetAgentId}' not found.");
|
||||
|
||||
// Auch der Spawn zählt: Er startet einen vollen Lauf und kann seinerseits
|
||||
// delegieren. Ohne diese Prüfung wäre die Kette über spawn zu umgehen.
|
||||
if (CheckDelegation(chain, fromAgentId, targetAgentId) is { } refused)
|
||||
return new AgentSpawnResult(false, targetAgentId, null, refused);
|
||||
|
||||
var callerChain = chain ?? DelegationChain.Root(fromAgentId);
|
||||
|
||||
if (IsRunning(targetAgentId))
|
||||
return new AgentSpawnResult(false, targetAgentId, null,
|
||||
$"Agent '{targetConfig.DisplayName}' läuft bereits. Verwende send_message statt spawn.");
|
||||
@@ -771,7 +893,8 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
|
||||
try
|
||||
{
|
||||
var result = await RunAsync(targetConfig, wrappedMessage, _instanceId, ct);
|
||||
var result = await RunAsync(targetConfig, wrappedMessage, ResolveInstanceId(instanceId), ct,
|
||||
delegation: callerChain.Append(targetAgentId));
|
||||
|
||||
return result.Status == AgentRunStatus.Completed
|
||||
? new AgentSpawnResult(true, targetAgentId, result.FinalMessage)
|
||||
@@ -842,7 +965,8 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
ILogger logger,
|
||||
CancellationToken ct,
|
||||
string runId,
|
||||
string? source)
|
||||
string? source,
|
||||
DelegationChain chain)
|
||||
{
|
||||
var toolName = toolCall.Function.Name;
|
||||
var arguments = toolCall.Function.Arguments ?? "";
|
||||
@@ -889,7 +1013,7 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
? default
|
||||
: JsonDocument.Parse(toolCall.Function.Arguments).RootElement;
|
||||
|
||||
var context = BuildToolContext(agentConfig, instanceId, toolName, ct);
|
||||
var context = BuildToolContext(agentConfig, instanceId, toolName, ct, chain);
|
||||
|
||||
logger.LogDebug("Executing tool {Tool} for agent {AgentId}", toolName, agentConfig.AgentId);
|
||||
|
||||
@@ -936,7 +1060,8 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
}
|
||||
|
||||
private AgentToolContext BuildToolContext(
|
||||
AgentConfig agentConfig, string instanceId, string toolName, CancellationToken ct)
|
||||
AgentConfig agentConfig, string instanceId, string toolName, CancellationToken ct,
|
||||
DelegationChain? chain = null)
|
||||
{
|
||||
var toolConfig = agentConfig.Tools.TryGetValue(toolName, out var cfg)
|
||||
? cfg.AsReadOnly()
|
||||
@@ -955,7 +1080,8 @@ public sealed class AgentEngine : IAgentMessageRouter, Staging.IFrozenCallExecut
|
||||
agentConfig.SharedWorkspacePath,
|
||||
this,
|
||||
_memoryRepository,
|
||||
_taskRepository);
|
||||
_taskRepository,
|
||||
chain ?? DelegationChain.Root(agentConfig.AgentId));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
|
||||
@@ -31,5 +31,12 @@ public enum AgentRunStatus
|
||||
LoopLimitExceeded,
|
||||
|
||||
/// <summary>Der Lauf fand nicht statt, weil das Tagesbudget erschöpft ist.</summary>
|
||||
BudgetExceeded
|
||||
BudgetExceeded,
|
||||
|
||||
/// <summary>
|
||||
/// Der Lauf fand nicht statt, weil der Agent belegt war und der Aufruf nicht
|
||||
/// unbegrenzt warten darf (#461). Trifft nur delegierte Läufe — ein vom Menschen
|
||||
/// angestoßener Chat reiht sich weiterhin ein und wartet, so lange es dauert.
|
||||
/// </summary>
|
||||
TargetBusy
|
||||
}
|
||||
|
||||
@@ -14,12 +14,32 @@ public sealed class ContextCompactor
|
||||
private const int MaxToolResultChars = 2000;
|
||||
private const string TruncatedMarker = "\n\n[... Ergebnis gekürzt ...]";
|
||||
|
||||
/// <summary>
|
||||
/// Wie stark ein einzelner Messwert den Faktor verschiebt. Klein genug, dass ein
|
||||
/// Ausreißer die Schwelle nicht kippt, groß genug, dass ein Modellwechsel nach
|
||||
/// wenigen Aufrufen ankommt.
|
||||
/// </summary>
|
||||
private const double CalibrationWeight = 0.25;
|
||||
|
||||
/// <summary>
|
||||
/// Je Modell: um welchen Faktor die rohe Schätzung danebenlag. 1,0 heißt „noch nichts
|
||||
/// gemessen". Modellweise, weil verschiedene Tokenizer denselben Text verschieden
|
||||
/// zerlegen — ein gemeinsamer Faktor wäre der Mittelwert von etwas, das nichts
|
||||
/// miteinander zu tun hat.
|
||||
/// </summary>
|
||||
private readonly System.Collections.Concurrent.ConcurrentDictionary<string, double> _calibration = new();
|
||||
|
||||
public ContextCompactor(IChatCompletionClient client, ILoggerFactory loggerFactory)
|
||||
{
|
||||
_client = client;
|
||||
_logger = loggerFactory.CreateLogger("ClawdDotNet.Core.Engine.ContextCompactor");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Die rohe Schätzung: vier Zeichen je Token. Grob, aber ohne Netzaufruf und ohne
|
||||
/// Kenntnis des Tokenizers — und darauf kommt es an, weil sie <b>vor</b> dem Senden
|
||||
/// gebraucht wird. <see cref="EstimateFor"/> zieht die gemessene Abweichung nach.
|
||||
/// </summary>
|
||||
public static int EstimateTokens(List<ChatMessage> messages)
|
||||
{
|
||||
var totalChars = 0;
|
||||
@@ -37,16 +57,51 @@ public sealed class ContextCompactor
|
||||
return totalChars / 4;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Die Schätzung für ein bestimmtes Modell — die rohe Rechnung, korrigiert um das,
|
||||
/// was bei diesem Modell bisher tatsächlich gemessen wurde.
|
||||
/// </summary>
|
||||
public int EstimateFor(string model, List<ChatMessage> messages)
|
||||
=> (int)(EstimateTokens(messages) * _calibration.GetValueOrDefault(model, 1.0));
|
||||
|
||||
/// <summary>
|
||||
/// Meldet, wie groß der Prompt wirklich war, den eine Schätzung vorhergesagt hat.
|
||||
///
|
||||
/// <para>Vier Zeichen je Token stimmt für englische Fließtexte ungefähr und liegt
|
||||
/// bei deutschem Text, JSON und Code daneben — je nach Modell in beide Richtungen.
|
||||
/// Der Faktor zieht die Schätzung dorthin, wo dieses Modell tatsächlich liegt.</para>
|
||||
///
|
||||
/// <para>Gleitender Mittelwert statt letztem Messwert: Ein einzelner Ausreißer soll
|
||||
/// die Schwelle nicht verschieben. Begrenzt auf das Halbe bis Vierfache — was
|
||||
/// darüber hinausginge, ist kein Kalibrierungsfall mehr, sondern ein Fehler
|
||||
/// woanders, und den soll die Schätzung nicht kaschieren.</para>
|
||||
/// </summary>
|
||||
public void Calibrate(string model, int estimatedTokens, int actualPromptTokens)
|
||||
{
|
||||
if (estimatedTokens <= 0 || actualPromptTokens <= 0) return;
|
||||
|
||||
var gemessen = Math.Clamp((double)actualPromptTokens / estimatedTokens, 0.5, 4.0);
|
||||
|
||||
// Auch der erste Messwert zählt nur mit seinem Gewicht — Ausgangspunkt ist die
|
||||
// rohe Schätzung (Faktor 1,0). Setzte der erste Wert den Faktor voll, könnte ein
|
||||
// einzelner Ausreißer die Schwelle sofort verschieben, und genau das soll der
|
||||
// gleitende Mittelwert verhindern.
|
||||
static double Naechster(double bisher, double gemessen)
|
||||
=> bisher * (1 - CalibrationWeight) + gemessen * CalibrationWeight;
|
||||
|
||||
_calibration.AddOrUpdate(
|
||||
model,
|
||||
Naechster(1.0, gemessen),
|
||||
(_, bisher) => Naechster(bisher, gemessen));
|
||||
}
|
||||
|
||||
public async Task<bool> CompactIfNeededAsync(
|
||||
List<ChatMessage> messages,
|
||||
int lastPromptTokens,
|
||||
LoopGuardConfig guard,
|
||||
string model,
|
||||
CancellationToken ct)
|
||||
{
|
||||
var contextTokens = lastPromptTokens > 0
|
||||
? lastPromptTokens
|
||||
: EstimateTokens(messages);
|
||||
var contextTokens = EstimateFor(model, messages);
|
||||
|
||||
var threshold = (int)(guard.MaxContextTokens * guard.CompactionThreshold);
|
||||
|
||||
|
||||
@@ -55,13 +55,18 @@ public static class PathBoundary
|
||||
/// den abschließenden Trenner gälte <c>…/Workspace-Backup</c> als Teil von
|
||||
/// <c>…/Workspace</c>.
|
||||
///
|
||||
/// Symbolische Verknüpfungen werden aufgelöst (<see cref="Canonicalize"/>) — ein
|
||||
/// Pfad, der nur über eine Verknüpfung hinauszeigt, gilt als außerhalb.
|
||||
/// Symbolische Verknüpfungen werden aufgelöst (<see cref="TryCanonicalize"/>) — ein
|
||||
/// Pfad, der nur über eine Verknüpfung hinauszeigt, gilt als außerhalb. Steht einer
|
||||
/// der beiden Pfade nicht fest, gilt der Kandidat als außerhalb: Ein unaufgelöster
|
||||
/// Pfad besteht die Präfixprüfung gerade deshalb, weil er unaufgelöst ist.
|
||||
/// </summary>
|
||||
public static bool IsInside(string candidate, string root)
|
||||
{
|
||||
var normalizedRoot = Canonicalize(NormalizeDirectory(root));
|
||||
var normalizedCandidate = Canonicalize(Path.GetFullPath(candidate));
|
||||
if (!TryCanonicalize(NormalizeDirectory(root), out var normalizedRoot) ||
|
||||
!TryCanonicalize(Path.GetFullPath(candidate), out var normalizedCandidate))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// Der Root selbst gilt als innerhalb.
|
||||
if (string.Equals(
|
||||
@@ -90,6 +95,17 @@ public static class PathBoundary
|
||||
: full;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Löst symbolische Verknüpfungen in jedem Abschnitt des Pfades auf.
|
||||
/// </summary>
|
||||
/// <exception cref="IOException">
|
||||
/// Der Pfad ist nicht bestimmbar. <see cref="TryCanonicalize"/> meldet das ohne Wurf.
|
||||
/// </exception>
|
||||
public static string Canonicalize(string path)
|
||||
=> TryCanonicalize(path, out var canonical)
|
||||
? canonical
|
||||
: throw new IOException($"Pfad nicht bestimmbar: {path}");
|
||||
|
||||
/// <summary>
|
||||
/// Löst symbolische Verknüpfungen in jedem Abschnitt des Pfades auf.
|
||||
///
|
||||
@@ -101,15 +117,21 @@ public static class PathBoundary
|
||||
///
|
||||
/// Noch nicht existierende Abschnitte bleiben unverändert — für einen Pfad, der erst
|
||||
/// angelegt werden soll, ist das der richtige Umgang: Was es nicht gibt, kann keine
|
||||
/// Verknüpfung sein, und der bereits vorhandene Teil davor wurde geprüft.
|
||||
/// Verknüpfung sein, und der bereits vorhandene Teil davor wurde geprüft. Unverändert
|
||||
/// bleibt dabei genau dieser eine Abschnitt; was davor aufgelöst wurde, zählt weiter.
|
||||
///
|
||||
/// Rückgabe <c>false</c> heißt: Der Pfad steht nicht fest (Zyklus, zu tiefe Kette,
|
||||
/// gesperrtes Verzeichnis). Dann darf niemand mit ihm weiterrechnen — die
|
||||
/// Einschließungsprüfung weist ab, statt den unaufgelösten Pfad durchzureichen.
|
||||
/// </summary>
|
||||
public static string Canonicalize(string path)
|
||||
public static bool TryCanonicalize(string path, out string canonical)
|
||||
{
|
||||
var full = Path.GetFullPath(path);
|
||||
canonical = full;
|
||||
|
||||
var root = Path.GetPathRoot(full);
|
||||
if (string.IsNullOrEmpty(root))
|
||||
return full;
|
||||
return true;
|
||||
|
||||
var rest = full[root.Length..]
|
||||
.Split([Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar],
|
||||
@@ -124,22 +146,36 @@ public static class PathBoundary
|
||||
string? target;
|
||||
try
|
||||
{
|
||||
// Gibt null zurück, wenn der Abschnitt keine Verknüpfung ist oder
|
||||
// nicht existiert. Wirft bei Zyklen und bei zu tiefen Ketten.
|
||||
target = Directory.Exists(current)
|
||||
? Directory.ResolveLinkTarget(current, returnFinalTarget: true)?.FullName
|
||||
: File.ResolveLinkTarget(current, returnFinalTarget: true)?.FullName;
|
||||
// LinkTarget fragt den Eintrag, ohne ihm zu folgen: null heißt „keine
|
||||
// Verknüpfung" und ebenso „gibt es noch nicht". Beides ist derselbe
|
||||
// Fall — der Abschnitt bleibt, wie er ist.
|
||||
//
|
||||
// Der frühere Weg über File.ResolveLinkTarget führte hier in die Irre:
|
||||
// Für einen fehlenden Abschnitt wirft der Aufruf FileNotFoundException,
|
||||
// also eine IOException, und der Fang darunter verließ die ganze
|
||||
// Auflösung mit dem unaufgelösten Pfad. Da der jede Präfixprüfung
|
||||
// besteht, war der Symlink-Schutz bei jedem Schreibvorgang wirkungslos.
|
||||
FileSystemInfo entry = Directory.Exists(current)
|
||||
? new DirectoryInfo(current)
|
||||
: new FileInfo(current);
|
||||
|
||||
if (entry.LinkTarget is null)
|
||||
continue;
|
||||
|
||||
// Folgt der ganzen Kette. Hängt sie ins Leere, bleibt das unmittelbare
|
||||
// Ziel — die Richtung stimmt, und darauf kommt es an.
|
||||
target = entry.ResolveLinkTarget(returnFinalTarget: true)?.FullName
|
||||
?? entry.LinkTarget;
|
||||
}
|
||||
catch (IOException)
|
||||
{
|
||||
// Zyklus oder unauflösbare Kette. Der Pfad ist damit nicht bestimmbar —
|
||||
// wir geben zurück, was wir haben. Die Einschließungsprüfung entscheidet
|
||||
// dann auf der bisherigen, unaufgelösten Fassung: Sie weist im Zweifel ab.
|
||||
return full;
|
||||
// Zyklus oder zu tiefe Kette: Wohin der Pfad zeigt, ist nicht zu
|
||||
// ermitteln. Fail closed — der Aufrufer bekommt kein Ergebnis.
|
||||
return false;
|
||||
}
|
||||
catch (UnauthorizedAccessException)
|
||||
{
|
||||
return full;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!string.IsNullOrEmpty(target))
|
||||
@@ -150,6 +186,7 @@ public static class PathBoundary
|
||||
}
|
||||
}
|
||||
|
||||
return Path.GetFullPath(current);
|
||||
canonical = Path.GetFullPath(current);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -108,11 +108,7 @@ public static class TaskSchedule
|
||||
|
||||
if (matchLocal is null) return null;
|
||||
|
||||
// Ungültige Ortszeit (Sprung bei der Zeitumstellung) darf nicht werfen.
|
||||
var unspecified = DateTime.SpecifyKind(matchLocal.Value, DateTimeKind.Unspecified);
|
||||
if (tz.IsInvalidTime(unspecified)) return null;
|
||||
|
||||
var occUtc = TimeZoneInfo.ConvertTimeToUtc(unspecified, tz);
|
||||
if (!TryToUtc(matchLocal.Value, tz, out var occUtc)) return null;
|
||||
var occ = Iso(occUtc);
|
||||
|
||||
// Nur fällig, wenn der Termin echt über dem Marker liegt.
|
||||
@@ -145,12 +141,57 @@ public static class TaskSchedule
|
||||
var tz = ResolveTimeZone(timeZone);
|
||||
if (tz is null) return false; // unbekannte Zone: der Termin ist nicht bestimmbar
|
||||
|
||||
var unspecified = DateTime.SpecifyKind(local, DateTimeKind.Unspecified);
|
||||
if (tz.IsInvalidTime(unspecified)) return false;
|
||||
return TryToUtc(local, tz, out utc);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Rechnet eine Wanduhrzeit in ihren UTC-Zeitpunkt um — auch dann, wenn es diese
|
||||
/// Uhrzeit an diesem Tag gar nicht gibt.
|
||||
///
|
||||
/// <para><b>Der Frühjahrssprung.</b> In der Nacht der Umstellung springt die Uhr von
|
||||
/// 02:00 auf 03:00; „02:30" existiert an diesem Tag nicht. Vorher fiel ein Termin
|
||||
/// darin schlicht aus — einmal im Jahr lief eine tägliche Aufgabe nicht, und weil
|
||||
/// nichts scheiterte, fiel es niemandem auf. Ein ausgefallener Lauf ist kein
|
||||
/// harmloseres Ergebnis als ein verschobener, nur ein leiseres.</para>
|
||||
///
|
||||
/// <para>Der Termin wandert deshalb auf den ersten Zeitpunkt, den es nach der Lücke
|
||||
/// gibt — aus 02:30 wird 03:00, nicht 03:30. So spät wie nötig, so früh wie möglich;
|
||||
/// die Reihenfolge mehrerer Termine in derselben Lücke bleibt dabei erhalten, weil
|
||||
/// sie alle auf denselben Zeitpunkt fallen und der Marker den zweiten abfängt.</para>
|
||||
///
|
||||
/// <para><b>Der Herbstsprung</b> braucht nichts Eigenes: Eine doppelt vorkommende
|
||||
/// Uhrzeit rechnet <c>ConvertTimeToUtc</c> auf die Normalzeit-Fassung um, also auf
|
||||
/// den zweiten Durchlauf. Beide Durchläufe ergeben denselben Occurrence-Key, und der
|
||||
/// Marker sorgt dafür, dass nur einer davon feuert.</para>
|
||||
/// </summary>
|
||||
private static bool TryToUtc(DateTime local, TimeZoneInfo tz, out DateTime utc)
|
||||
{
|
||||
var unspecified = DateTime.SpecifyKind(local, DateTimeKind.Unspecified);
|
||||
|
||||
if (!tz.IsInvalidTime(unspecified))
|
||||
{
|
||||
utc = TimeZoneInfo.ConvertTimeToUtc(unspecified, tz);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Minutenweise vorrücken, bis die Uhr wieder eine Zeit zeigt, die es gibt.
|
||||
// Die Obergrenze ist Vorsicht, kein Fachwissen: Die größte gebräuchliche Lücke
|
||||
// ist eine Stunde (Lord Howe Island: 30 Minuten). Bräuchte es je mehr als drei,
|
||||
// stimmt etwas anderes nicht, und dann ist „gar nicht" das ehrlichere Ergebnis.
|
||||
for (var probe = unspecified.AddMinutes(1);
|
||||
probe <= unspecified.AddHours(3);
|
||||
probe = probe.AddMinutes(1))
|
||||
{
|
||||
if (tz.IsInvalidTime(probe)) continue;
|
||||
|
||||
utc = TimeZoneInfo.ConvertTimeToUtc(probe, tz);
|
||||
return true;
|
||||
}
|
||||
|
||||
utc = default;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@@ -16,5 +16,12 @@ public sealed record AgentToolContext(
|
||||
string? SharedWorkspacePath = null,
|
||||
IAgentMessageRouter? MessageRouter = null,
|
||||
IMemoryRepository? Memory = null,
|
||||
ITaskRepository? Tasks = null
|
||||
ITaskRepository? Tasks = null,
|
||||
|
||||
/// <summary>
|
||||
/// Wer an diesem Aufruf schon beteiligt ist. Werkzeuge, die einen anderen Agenten
|
||||
/// beauftragen, reichen die Kette weiter — sonst kann die Engine einen Zyklus
|
||||
/// nicht von einer neuen Delegation unterscheiden. Siehe <see cref="DelegationChain"/>.
|
||||
/// </summary>
|
||||
DelegationChain? Delegation = null
|
||||
);
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
namespace ClawdDotNet.Core.Tools;
|
||||
|
||||
/// <summary>
|
||||
/// Wer an diesem Aufruf schon beteiligt ist — die Kette vom ersten Agenten bis zum
|
||||
/// gerade laufenden.
|
||||
///
|
||||
/// <para><b>Warum es die Kette gibt (B8).</b> <c>send_message</c> ist ein synchroner
|
||||
/// Aufruf: A hält sein Gate, während es auf B wartet. Ruft B nun A, wartet B auf ein
|
||||
/// Gate, das A hält und erst freigibt, wenn B geantwortet hat. Das löste nur der
|
||||
/// Timeout des äußeren Laufs auf — bis dahin standen beide Agenten.</para>
|
||||
///
|
||||
/// <para><b>Die Zusagen</b>, auf denen alles Weitere aufsetzt:</para>
|
||||
/// <list type="number">
|
||||
/// <item>Ein Agent kommt in einer Kette höchstens einmal vor. Damit wartet niemand
|
||||
/// auf ein Gate, das er in derselben Kette schon hält — der Verklemmung ist die
|
||||
/// Grundlage entzogen, nicht nur die Wahrscheinlichkeit genommen.</item>
|
||||
/// <item>Eine Kette ist höchstens <c>MaxDelegationDepth</c> Schritte lang. Zyklen
|
||||
/// sind damit ausgeschlossen, eine lange Staffel A→B→C→D→… aber nicht; die
|
||||
/// kostet Zeit und Tokens, ohne dass jemand sie beauftragt hätte.</item>
|
||||
/// <item>Die Kette gehört zum <b>Aufruf</b>, nicht zum Agenten. Zwei unabhängige
|
||||
/// Läufe desselben Agenten behindern einander nicht.</item>
|
||||
/// </list>
|
||||
///
|
||||
/// <para>Unveränderlich: <see cref="Append"/> gibt eine neue Kette zurück. Ein Aufruf
|
||||
/// kann die Kette seines Aufrufers deshalb nicht verändern, und die Kette lässt sich
|
||||
/// gefahrlos über Fadengrenzen reichen.</para>
|
||||
/// </summary>
|
||||
public sealed class DelegationChain
|
||||
{
|
||||
private readonly string[] _agents;
|
||||
|
||||
private DelegationChain(string[] agents) => _agents = agents;
|
||||
|
||||
/// <summary>Der Anfang: ein Lauf, den niemand delegiert hat.</summary>
|
||||
public static DelegationChain Root(string agentId) => new([agentId]);
|
||||
|
||||
/// <summary>Die Agenten in der Reihenfolge, in der sie beauftragt wurden.</summary>
|
||||
public IReadOnlyList<string> Agents => _agents;
|
||||
|
||||
/// <summary>
|
||||
/// Die Zahl der Weitergaben — nicht die der Agenten. Ein Lauf ohne Delegation hat
|
||||
/// die Tiefe 0, A→B die Tiefe 1.
|
||||
/// </summary>
|
||||
public int Depth => _agents.Length - 1;
|
||||
|
||||
/// <summary>Ist dieser Agent in der Kette schon vertreten?</summary>
|
||||
public bool Contains(string agentId)
|
||||
=> Array.IndexOf(_agents, agentId) >= 0;
|
||||
|
||||
/// <summary>Die Kette mit einem weiteren Agenten am Ende.</summary>
|
||||
public DelegationChain Append(string agentId)
|
||||
=> new([.. _agents, agentId]);
|
||||
|
||||
/// <summary>Für Meldungen und Protokoll: <c>A -> B -> C</c>.</summary>
|
||||
public override string ToString() => string.Join(" -> ", _agents);
|
||||
}
|
||||
@@ -10,15 +10,32 @@ public interface IAgentMessageRouter
|
||||
{
|
||||
IReadOnlyList<AgentInfo> ListAgents(string callerAgentId);
|
||||
|
||||
/// <param name="instanceId">
|
||||
/// Die Instanz des aufrufenden Laufs — aus <see cref="AgentToolContext.InstanceId"/>
|
||||
/// durchgereicht. Leer heißt „nimm die Instanz, mit der die Engine eingerichtet
|
||||
/// wurde". Vorher galt immer Letzteres, auch wenn der Lauf mit einer anderen
|
||||
/// Instanz-Id angestoßen worden war (B13).
|
||||
/// </param>
|
||||
/// <param name="chain">
|
||||
/// Die Delegationskette des aufrufenden Laufs — aus
|
||||
/// <see cref="AgentToolContext.Delegation"/> durchgereicht. <c>null</c> heißt
|
||||
/// „von aussen angestossen", die Kette beginnt dann beim Absender. Ohne sie kann
|
||||
/// die Engine A→B→A nicht von einer neuen Delegation unterscheiden (B8).
|
||||
/// </param>
|
||||
Task<AgentMessageResult> SendMessageAsync(
|
||||
string fromAgentId,
|
||||
string toAgentId,
|
||||
string message,
|
||||
string? instanceId,
|
||||
DelegationChain? chain,
|
||||
CancellationToken ct);
|
||||
|
||||
/// <inheritdoc cref="SendMessageAsync"/>
|
||||
Task<AgentSpawnResult> SpawnAgentAsync(
|
||||
string fromAgentId,
|
||||
string targetAgentId,
|
||||
string taskMessage,
|
||||
string? instanceId,
|
||||
DelegationChain? chain,
|
||||
CancellationToken ct);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user