@draht/agent-core 2026.9.5-1 → 2026.10.4-3

package/dist/agent-loop.d.ts

@@ -2,8 +2,8 @@
  * Agent loop that works with AgentMessage throughout.
  * Transforms to Message[] only at the LLM call boundary.
  */
-import { EventStream } from "@draht/ai";
-import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, StreamFn } from "./types.ts";
+import { type AssistantMessage, EventStream } from "@draht/ai";
+import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, AgentTool, AgentToolCall, AgentToolCallOutcome, AgentToolResult, StreamFn } from "./types.ts";
 export type AgentEventSink = (event: AgentEvent) => Promise<void> | void;
 /**
  * Start an agent loop with a new prompt message.
@@ -21,4 +21,29 @@ export declare function agentLoop(prompts: AgentMessage[], context: AgentContext
 export declare function agentLoopContinue(context: AgentContext, config: AgentLoopConfig, signal: AbortSignal | undefined, streamFn: StreamFn): EventStream<AgentEvent, AgentMessage[]>;
 export declare function runAgentLoop(prompts: AgentMessage[], context: AgentContext, config: AgentLoopConfig, emit: AgentEventSink, signal: AbortSignal | undefined, streamFn: StreamFn): Promise<AgentMessage[]>;
 export declare function runAgentLoopContinue(context: AgentContext, config: AgentLoopConfig, emit: AgentEventSink, signal: AbortSignal | undefined, streamFn: StreamFn): Promise<AgentMessage[]>;
+/** The `beforeToolCall` and `afterToolCall` hooks of {@link AgentLoopConfig}. */
+export type ToolCallHooks = Pick<AgentLoopConfig, "beforeToolCall" | "afterToolCall">;
+type ToolUpdateSink = (partialResult: AgentToolResult<any>) => Promise<void> | void;
+/** Options for {@link runToolCall}. */
+export interface RunToolCallOptions extends ToolCallHooks {
+    /** Tools the call resolves against. */
+    tools: readonly AgentTool<any>[];
+    /** Passed to the hooks as the message that issued the call. */
+    assistantMessage: AssistantMessage;
+    /** Passed to the hooks as the current agent context. */
+    context: AgentContext;
+    signal?: AbortSignal;
+    onUpdate?: ToolUpdateSink;
+}
+/**
+ * Run one tool call through the same steps as a model-issued call: argument preparation, schema
+ * validation, `beforeToolCall`, execution, and `afterToolCall`. Emits no events and adds no
+ * messages. Tools that call other tools use this so the hooks (for example permission checks)
+ * apply to those calls too.
+ *
+ * Never rejects for tool failures: unknown tools, validation errors, blocked calls, and thrown
+ * errors come back as `isError: true`.
+ */
+export declare function runToolCall(toolCall: AgentToolCall, options: RunToolCallOptions): Promise<AgentToolCallOutcome>;
+export {};
 //# sourceMappingURL=agent-loop.d.ts.map

package/dist/agent-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAGN,WAAW,EAGX,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EACf,YAAY,EAIZ,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzE;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAiBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAwBzC;AAED,wBAAsB,YAAY,CACjC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAgBzB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzB"}
+{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../src/agent-loop.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACN,KAAK,gBAAgB,EACrB,WAAW,EASX,MAAM,WAAW,CAAC;AAEnB,OAAO,KAAK,EACX,YAAY,EACZ,UAAU,EACV,eAAe,EACf,YAAY,EACZ,SAAS,EACT,aAAa,EACb,oBAAoB,EACpB,eAAe,EAEf,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAEzE;;;GAGG;AACH,wBAAgB,SAAS,CACxB,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAiBzC;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAChC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,WAAW,CAAC,UAAU,EAAE,YAAY,EAAE,CAAC,CAwBzC;AAED,wBAAsB,YAAY,CACjC,OAAO,EAAE,YAAY,EAAE,EACvB,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzB;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,cAAc,EACpB,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,QAAQ,EAAE,QAAQ,GAChB,OAAO,CAAC,YAAY,EAAE,CAAC,CAiBzB;AAmhBD,iFAAiF;AACjF,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,eAAe,EAAE,gBAAgB,GAAG,eAAe,CAAC,CAAC;AAEtF,KAAK,cAAc,GAAG,CAAC,aAAa,EAAE,eAAe,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;AAwGpF,uCAAuC;AACvC,MAAM,WAAW,kBAAmB,SAAQ,aAAa;IACxD,uCAAuC;IACvC,KAAK,EAAE,SAAS,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC;IACjC,+DAA+D;IAC/D,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,wDAAwD;IACxD,OAAO,EAAE,YAAY,CAAC;IACtB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC1B;AAED;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAQrH"}

package/dist/agent-loop.js

@@ -2,7 +2,7 @@
  * Agent loop that works with AgentMessage throughout.
  * Transforms to Message[] only at the LLM call boundary.
  */
-import { EventStream, validateToolArguments, } from "@draht/ai";
+import { EventStream, getCurrentTools, getToolStateChanges, normalizeContext, toToolDeclaration, validateToolArguments, } from "@draht/ai";
 import { getDefaultStreamFn } from "./stream-fn.js";
 /**
  * Start an agent loop with a new prompt message.
@@ -41,16 +41,17 @@ export function agentLoopContinue(context, config, signal, streamFn) {
     return stream;
 }
 export async function runAgentLoop(prompts, context, config, emit, signal, streamFn) {
-    const newMessages = [...prompts];
+    const initialMessages = declareToolChanges(context, prompts);
+    const newMessages = [...initialMessages];
     const currentContext = {
         ...context,
-        messages: [...context.messages, ...prompts],
+        messages: [...context.messages, ...initialMessages],
     };
     await emit({ type: "agent_start" });
     await emit({ type: "turn_start" });
-    for (const prompt of prompts) {
-        await emit({ type: "message_start", message: prompt });
-        await emit({ type: "message_end", message: prompt });
+    for (const message of initialMessages) {
+        await emit({ type: "message_start", message });
+        await emit({ type: "message_end", message });
     }
     await runLoop(currentContext, newMessages, config, signal, emit, streamFn ?? getDefaultStreamFn());
     return newMessages;
@@ -78,7 +79,8 @@ function createAgentStream() {
 async function runLoop(initialContext, newMessages, initialConfig, signal, emit, streamFunction) {
     let currentContext = initialContext;
     let config = initialConfig;
-    let firstTurn = true;
+    let lastCompletedTurn;
+    let explicitContinuation = false;
     // Check for steering messages at start (user may have typed while waiting)
     let pendingMessages = (await config.getSteeringMessages?.()) || [];
     // Outer loop: continues when queued follow-up messages arrive after agent would stop
@@ -86,26 +88,66 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
         let hasMoreToolCalls = true;
         // Inner loop: process tool calls and steering messages
         while (hasMoreToolCalls || pendingMessages.length > 0) {
-            if (!firstTurn) {
+            let preparedMessages = [];
+            if (lastCompletedTurn) {
+                const nextTurnSnapshot = await config.prepareNextTurn?.(lastCompletedTurn);
+                if (nextTurnSnapshot) {
+                    currentContext = nextTurnSnapshot.context ?? currentContext;
+                    preparedMessages = nextTurnSnapshot.messages ?? [];
+                    config = {
+                        ...config,
+                        model: nextTurnSnapshot.model ?? config.model,
+                        reasoning: nextTurnSnapshot.thinkingLevel === undefined
+                            ? config.reasoning
+                            : nextTurnSnapshot.thinkingLevel === "off"
+                                ? undefined
+                                : nextTurnSnapshot.thinkingLevel,
+                    };
+                }
+                // Preparation can be long-running (for example, compaction). Pick up steering
+                // queued while it ran. Only poll again if the earlier poll returned nothing;
+                // otherwise one-at-a-time mode would deliver two messages in this turn.
+                if (pendingMessages.length === 0) {
+                    pendingMessages = (await config.getSteeringMessages?.()) || [];
+                }
                 await emit({ type: "turn_start" });
             }
-            else {
-                firstTurn = false;
+            // Process prepared and queued messages before the next assistant response.
+            for (const message of declareToolChanges(currentContext, [...preparedMessages, ...pendingMessages])) {
+                await emit({ type: "message_start", message });
+                await emit({ type: "message_end", message });
+                currentContext.messages.push(message);
+                newMessages.push(message);
             }
-            // Process pending messages (inject before next assistant response)
-            if (pendingMessages.length > 0) {
-                for (const message of pendingMessages) {
-                    await emit({ type: "message_start", message });
-                    await emit({ type: "message_end", message });
-                    currentContext.messages.push(message);
-                    newMessages.push(message);
-                }
-                pendingMessages = [];
+            pendingMessages = [];
+            const requestUpdate = await config.prepareRequest?.({
+                context: currentContext,
+                model: config.model,
+                thinkingLevel: config.reasoning ?? "off",
+            }, signal);
+            if (requestUpdate) {
+                currentContext = requestUpdate.context ?? currentContext;
+                config = {
+                    ...config,
+                    model: requestUpdate.model ?? config.model,
+                    reasoning: requestUpdate.thinkingLevel === undefined
+                        ? config.reasoning
+                        : requestUpdate.thinkingLevel === "off"
+                            ? undefined
+                            : requestUpdate.thinkingLevel,
+                };
             }
             // Stream assistant response
             const message = await streamAssistantResponse(currentContext, config, signal, emit, streamFunction);
             newMessages.push(message);
             if (message.stopReason === "error" || message.stopReason === "aborted") {
+                lastCompletedTurn = {
+                    message,
+                    toolResults: [],
+                    context: currentContext,
+                    newMessages,
+                };
+                await config.finishTurn?.(lastCompletedTurn, signal);
                 await emit({ type: "turn_end", message, toolResults: [] });
                 await emit({ type: "agent_end", messages: newMessages });
                 return;
@@ -128,49 +170,89 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
                     newMessages.push(result);
                 }
             }
-            await emit({ type: "turn_end", message, toolResults });
-            const nextTurnContext = {
+            lastCompletedTurn = {
                 message,
                 toolResults,
                 context: currentContext,
                 newMessages,
             };
-            const nextTurnSnapshot = await config.prepareNextTurn?.(nextTurnContext);
-            if (nextTurnSnapshot) {
-                currentContext = nextTurnSnapshot.context ?? currentContext;
-                config = {
-                    ...config,
-                    model: nextTurnSnapshot.model ?? config.model,
-                    reasoning: nextTurnSnapshot.thinkingLevel === undefined
-                        ? config.reasoning
-                        : nextTurnSnapshot.thinkingLevel === "off"
-                            ? undefined
-                            : nextTurnSnapshot.thinkingLevel,
-                };
-            }
-            if (await config.shouldStopAfterTurn?.({
-                message,
-                toolResults,
-                context: currentContext,
-                newMessages,
-            })) {
+            const decision = await config.finishTurn?.(lastCompletedTurn, signal);
+            await emit({ type: "turn_end", message, toolResults });
+            if (decision?.action === "end") {
                 await emit({ type: "agent_end", messages: newMessages });
                 return;
             }
+            explicitContinuation = decision?.action === "continue";
             pendingMessages = (await config.getSteeringMessages?.()) || [];
+            if (hasMoreToolCalls || pendingMessages.length > 0) {
+                explicitContinuation = false;
+            }
         }
         // Agent would stop here. Check for follow-up messages.
         const followUpMessages = (await config.getFollowUpMessages?.()) || [];
         if (followUpMessages.length > 0) {
             // Set as pending so inner loop processes them
+            explicitContinuation = false;
             pendingMessages = followUpMessages;
             continue;
         }
+        // No natural request was selected, so fulfill the continuation decision with one context-only turn.
+        if (explicitContinuation) {
+            explicitContinuation = false;
+            continue;
+        }
         // No more messages, exit
         break;
     }
     await emit({ type: "agent_end", messages: newMessages });
 }
+/**
+ * Declare tool loadout changes to the model.
+ *
+ * `context.tools` is what the runtime can execute; the transcript's system messages declare
+ * what the model may call. Before each request the difference becomes `toolsAdded` and
+ * `toolsRemoved` on a system message. When a pending system message exists, its tool fields
+ * are treated as intent and replaced with the delta between the committed transcript and
+ * the executable set, so replay always yields exactly `context.tools`. Otherwise a new
+ * system message is inserted before the first non-system pending message.
+ */
+function declareToolChanges(context, pendingMessages) {
+    let systemIndex = -1;
+    for (let i = pendingMessages.length - 1; i >= 0; i--) {
+        if (pendingMessages[i].role === "system") {
+            systemIndex = i;
+            break;
+        }
+    }
+    const pending = pendingMessages[systemIndex];
+    const baseline = pending
+        ? pendingMessages.map((message, index) => index === systemIndex ? withToolChanges(pending, NO_CHANGES) : message)
+        : pendingMessages;
+    const changes = getToolStateChanges(getCurrentTools([...context.messages, ...baseline]), (context.tools ?? []).map(toToolDeclaration));
+    const unchanged = changes.toolsAdded.length === 0 && changes.toolsRemoved.length === 0;
+    if (pending) {
+        // Keep the caller's message object when it already declares no tool changes.
+        if (unchanged && !pending.toolsAdded?.length && !pending.toolsRemoved?.length)
+            return pendingMessages;
+        return baseline.map((message, index) => (index === systemIndex ? withToolChanges(pending, changes) : message));
+    }
+    if (unchanged)
+        return pendingMessages;
+    const update = withToolChanges({ role: "system", content: "", timestamp: Date.now() }, changes);
+    const insertIndex = pendingMessages.findIndex((message) => message.role !== "system");
+    const index = insertIndex === -1 ? pendingMessages.length : insertIndex;
+    return [...pendingMessages.slice(0, index), update, ...pendingMessages.slice(index)];
+}
+const NO_CHANGES = { toolsAdded: [], toolsRemoved: [] };
+/** Copy a system message with its tool fields replaced by `changes`; empty lists omit the field. */
+function withToolChanges(message, { toolsAdded, toolsRemoved }) {
+    const { toolsAdded: _added, toolsRemoved: _removed, ...rest } = message;
+    return {
+        ...rest,
+        ...(toolsAdded.length > 0 ? { toolsAdded } : {}),
+        ...(toolsRemoved.length > 0 ? { toolsRemoved } : {}),
+    };
+}
 /**
  * Stream an assistant response from the LLM.
  * This is where AgentMessage[] gets transformed to Message[] for the LLM.
@@ -183,12 +265,7 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
     }
     // Convert to LLM-compatible messages (AgentMessage[] → Message[])
     const llmMessages = await config.convertToLlm(messages);
-    // Build LLM context
-    const llmContext = {
-        systemPrompt: context.systemPrompt,
-        messages: llmMessages,
-        tools: context.tools,
-    };
+    const llmContext = normalizeContext({ messages: llmMessages });
     // Resolve API key (important for expiring tokens)
     const resolvedApiKey = (config.getApiKey ? await config.getApiKey(config.model.provider) : undefined) || config.apiKey;
     const response = await streamFunction(config.model, llmContext, {
@@ -196,6 +273,8 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
         apiKey: resolvedApiKey,
         signal,
     });
+    // Record the requested level, whichever stream function answered.
+    const result = async () => Object.assign(await response.result(), { thinkingLevel: config.reasoning ?? "off" });
     let partialMessage = null;
     let addedPartial = false;
     for await (const event of response) {
@@ -227,7 +306,7 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
                 break;
             case "done":
             case "error": {
-                const finalMessage = await response.result();
+                const finalMessage = await result();
                 if (addedPartial) {
                     context.messages[context.messages.length - 1] = finalMessage;
                 }
@@ -242,7 +321,7 @@ async function streamAssistantResponse(context, config, signal, emit, streamFunc
             }
         }
     }
-    const finalMessage = await response.result();
+    const finalMessage = await result();
     if (addedPartial) {
         context.messages[context.messages.length - 1] = finalMessage;
     }
@@ -312,7 +391,7 @@ async function executeToolCallsSequential(currentContext, assistantMessage, tool
             };
         }
         else {
-            const executed = await executePreparedToolCall(preparation, signal, emit);
+            const executed = await executePreparedToolCall(preparation, signal, emitToolExecutionUpdate(toolCall, emit));
             finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
         }
         await emitToolExecutionEnd(finalized, emit);
@@ -362,7 +441,7 @@ async function executeToolCallsParallel(currentContext, assistantMessage, toolCa
                 await emitToolExecutionEnd(finalized, emit);
                 return finalized;
             }
-            const executed = await executePreparedToolCall(preparation, signal, emit);
+            const executed = await executePreparedToolCall(preparation, signal, emitToolExecutionUpdate(toolCall, emit));
             const finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
             await emitToolExecutionEnd(finalized, emit);
             return finalized;
@@ -399,8 +478,8 @@ function prepareToolCallArguments(tool, toolCall) {
         arguments: preparedArguments,
     };
 }
-async function prepareToolCall(currentContext, assistantMessage, toolCall, config, signal) {
-    const tool = currentContext.tools?.find((t) => t.name === toolCall.name);
+async function prepareToolCall(currentContext, assistantMessage, toolCall, config, signal, tools = currentContext.tools ?? []) {
+    const tool = tools.find((t) => t.name === toolCall.name);
     if (!tool) {
         return {
             kind: "immediate",
@@ -459,24 +538,45 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
         };
     }
 }
-async function executePreparedToolCall(prepared, signal, emit) {
+function emitToolExecutionUpdate(toolCall, emit) {
+    return (partialResult) => emit({
+        type: "tool_execution_update",
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        args: toolCall.arguments,
+        partialResult,
+    });
+}
+/**
+ * Run one tool call through the same steps as a model-issued call: argument preparation, schema
+ * validation, `beforeToolCall`, execution, and `afterToolCall`. Emits no events and adds no
+ * messages. Tools that call other tools use this so the hooks (for example permission checks)
+ * apply to those calls too.
+ *
+ * Never rejects for tool failures: unknown tools, validation errors, blocked calls, and thrown
+ * errors come back as `isError: true`.
+ */
+export async function runToolCall(toolCall, options) {
+    const { assistantMessage, context, signal } = options;
+    const preparation = await prepareToolCall(context, assistantMessage, toolCall, options, signal, options.tools);
+    if (preparation.kind === "immediate") {
+        return { toolCall, result: preparation.result, isError: preparation.isError };
+    }
+    const executed = await executePreparedToolCall(preparation, signal, options.onUpdate ?? (() => { }));
+    return finalizeExecutedToolCall(context, assistantMessage, preparation, executed, options, signal);
+}
+async function executePreparedToolCall(prepared, signal, onUpdate) {
     const updateEvents = [];
     let acceptingUpdates = true;
     try {
         const result = await prepared.tool.execute(prepared.toolCall.id, prepared.args, signal, (partialResult) => {
             if (!acceptingUpdates)
                 return;
-            updateEvents.push(Promise.resolve(emit({
-                type: "tool_execution_update",
-                toolCallId: prepared.toolCall.id,
-                toolName: prepared.toolCall.name,
-                args: prepared.toolCall.arguments,
-                partialResult,
-            })));
+            updateEvents.push(Promise.resolve(onUpdate(partialResult)));
         });
         acceptingUpdates = false;
         await Promise.all(updateEvents);
-        return { result, isError: false };
+        return { result, isError: result.isError === true };
     }
     catch (error) {
         acceptingUpdates = false;
@@ -504,6 +604,8 @@ async function finalizeExecutedToolCall(currentContext, assistantMessage, prepar
                 context: currentContext,
             }, signal);
             if (afterResult) {
+                // Structured content not replaced along with the content may no longer match it.
+                const structuredContent = afterResult.structuredContent ?? (afterResult.content ? undefined : result.structuredContent);
                 result = {
                     ...result,
                     content: afterResult.content ?? result.content,
@@ -511,6 +613,10 @@ async function finalizeExecutedToolCall(currentContext, assistantMessage, prepar
                     usage: afterResult.usage ?? result.usage,
                     terminate: afterResult.terminate ?? result.terminate,
                 };
+                if (structuredContent === undefined)
+                    delete result.structuredContent;
+                else
+                    result.structuredContent = structuredContent;
                 isError = afterResult.isError ?? isError;
             }
         }
@@ -550,7 +656,6 @@ function createToolResultMessage(finalized) {
         content: finalized.result.content ?? [],
         details: finalized.result.details,
         usage: finalized.result.usage,
-        ...(finalized.result.addedToolNames?.length ? { addedToolNames: finalized.result.addedToolNames } : {}),
         isError: finalized.isError,
         timestamp: Date.now(),
     };