@strands-agents/sdk 1.10.0 → 1.11.1

package/dist/src/agent/agent.js

@@ -22,9 +22,12 @@ import { ConversationManager } from '../conversation-manager/conversation-manage
 import { ContextOffloader } from '../vended-plugins/context-offloader/plugin.js';
 import { InMemoryStorage } from '../storage/in-memory-storage.js';
 import { HookRegistryImplementation } from '../hooks/registry.js';
-import { MiddlewareRegistry, InvokeModelStage, ExecuteToolStage, AgentStreamStage } from '../middleware/index.js';
-import { InitializedEvent, AfterInvocationEvent, AfterModelCallEvent, AfterToolCallEvent, AfterToolsEvent, BeforeInvocationEvent, BeforeModelCallEvent, BeforeToolCallEvent, BeforeToolsEvent, HookableEvent, MessageAddedEvent, ModelStreamUpdateEvent, ContentBlockEvent, ModelMessageEvent, ToolResultEvent, AgentResultEvent, ToolStreamUpdateEvent, InterruptEvent, } from '../hooks/events.js';
+import { createMiddlewareInterrupt } from '../middleware/interrupt.js';
+import { MiddlewareRegistry, InvokeModelStage, AgentStreamStage } from '../middleware/index.js';
+import { InitializedEvent, AfterInvocationEvent, AfterModelCallEvent, AfterToolsEvent, BeforeInvocationEvent, BeforeModelCallEvent, BeforeToolsEvent, HookableEvent, MessageAddedEvent, ModelStreamUpdateEvent, ContentBlockEvent, ModelMessageEvent, ToolResultEvent, AgentResultEvent, InterruptEvent, } from '../hooks/events.js';
 import { StructuredOutputTool, STRUCTURED_OUTPUT_TOOL_NAME } from '../tools/structured-output-tool.js';
+import { ConcurrentToolExecutor } from '../tools/executors/concurrent.js';
+import { SequentialToolExecutor } from '../tools/executors/sequential.js';
 import { AgentAsTool } from './agent-as-tool.js';
 import { ToolCaller } from './tool-caller.js';
 import { MemoryManager } from '../memory/memory-manager.js';
@@ -35,7 +38,7 @@ import { logger } from '../logging/logger.js';
 import { CancelledError, CheckpointError } from '../errors.js';
 import { DefaultModelRetryStrategy } from '../retry/default-model-retry-strategy.js';
 import { warnOnDuplicateRetryStrategyTypes } from '../retry/retry-strategy.js';
-import { Interrupt, InterruptError, InterruptState, interruptFromAgent } from '../interrupt.js';
+import { InterruptError, InterruptState } from '../interrupt.js';
 import { Checkpoint } from '../experimental/checkpoint.js';
 import { isInterruptResponseContent } from '../types/interrupt.js';
 import { takeSnapshot as takeSnapshotInternal, loadSnapshot as loadSnapshotInternal } from './snapshot.js';
@@ -82,37 +85,27 @@ function resolveConversationManager(contextManager, conversationManager) {
     }
     return conversationManager ?? new SlidingWindowConversationManager({ windowSize: 40 });
 }
+/**
+ * Resolves a tool executor instance from an executor or string shorthand.
+ */
+function resolveToolExecutor(toolExecutor) {
+    switch (toolExecutor) {
+        case 'sequential':
+            return new SequentialToolExecutor();
+        case 'concurrent':
+        case undefined:
+            return new ConcurrentToolExecutor();
+        default:
+            if (typeof toolExecutor === 'string') {
+                throw new Error(`Unknown toolExecutor: ${toolExecutor}`);
+            }
+            return toolExecutor;
+    }
+}
 /** Default name assigned to agents when none is provided. */
 const DEFAULT_AGENT_NAME = 'Strands Agent';
 /** Default identifier assigned to agents when none is provided. */
 const DEFAULT_AGENT_ID = 'agent';
-/**
- * Creates a non-mutating interrupt function for middleware contexts.
- * Reads existing responses from state (resume case) but never writes to it.
- * On first run (no response), throws InterruptError with a locally-created Interrupt.
- *
- * @param interruptState - The agent's interrupt state (read-only access)
- * @param idPrefix - Prefix for the interrupt ID (e.g., 'middleware:agentStream')
- */
-function createMiddlewareInterrupt(interruptState, idPrefix) {
-    return (params) => {
-        const interruptId = `${idPrefix}:${params.name}`;
-        const existing = interruptState.interrupts[interruptId];
-        if (existing?.response !== undefined) {
-            return { response: existing.response };
-        }
-        if (params.response !== undefined) {
-            return { response: params.response };
-        }
-        const interrupt = new Interrupt({
-            id: interruptId,
-            name: params.name,
-            ...(params.reason !== undefined && { reason: params.reason }),
-            source: 'middleware',
-        });
-        throw new InterruptError(interrupt);
-    };
-}
 /**
  * Orchestrates the interaction between a model, a set of tools, and MCP clients.
  * The Agent is responsible for managing the lifecycle of tools and clients
@@ -191,7 +184,7 @@ export class Agent {
     _meter;
     /** Interrupt state for human-in-the-loop workflows. */
     _interruptState;
-    /** Strategy for executing tool calls from a single assistant turn. */
+    /** Executor for tool calls from a single assistant turn. */
     _toolExecutor;
     /** When true, the agent loop pauses at cycle boundaries for durable execution. */
     _checkpointing;
@@ -301,7 +294,7 @@ export class Agent {
         this._meter = new Meter();
         // Initialize interrupt state for human-in-the-loop workflows
         this._interruptState = new InterruptState();
-        this._toolExecutor = config?.toolExecutor ?? 'concurrent';
+        this._toolExecutor = resolveToolExecutor(config?.toolExecutor);
         this._checkpointing = config?.checkpointing ?? false;
         // Pass a private helper into ToolCaller so message append + hook firing
         // remains an internal concern of Agent (not exposed as a public method).
@@ -481,6 +474,21 @@ export class Agent {
     get toolRegistry() {
         return this._toolRegistry;
     }
+    /**
+     * Executor for tool calls from a single assistant turn.
+     *
+     * Reading always yields the resolved executor instance. Assigning accepts an
+     * executor instance or a {@link ToolExecutorStrategy} string shorthand, which is
+     * resolved to the matching instance on write.
+     *
+     * @throws Error if assigned an unrecognized string shorthand.
+     */
+    get toolExecutor() {
+        return this._toolExecutor;
+    }
+    set toolExecutor(toolExecutor) {
+        this._toolExecutor = resolveToolExecutor(toolExecutor);
+    }
     /**
      * Read-only snapshot of accumulated agent metrics (cycles, token usage, tool stats).
      */
@@ -1084,7 +1092,7 @@ export class Agent {
                         assistantMessage = modelResult.message;
                     }
                     // Execute tools
-                    const toolsResult = yield* this.executeTools(assistantMessage, this._toolRegistry, invocationState, completedToolResults);
+                    const toolsResult = yield* this.executeTools(assistantMessage, invocationState, completedToolResults);
                     // When the consumer breaks the stream (e.g. agent.cancel() + break),
                     // yield* returns undefined because the inner generator was closed.
                     if (!toolsResult) {
@@ -1591,15 +1599,14 @@ export class Agent {
     }
     /**
      * Emits `BeforeToolsEvent`, handles the pre-launch cancel paths, then
-     * delegates per-tool execution to the configured {@link ToolExecutorStrategy}.
+     * delegates per-tool execution to the configured executor.
      * Always pairs `BeforeToolsEvent` with a terminal `AfterToolsEvent`, even on
      * the invariant-violation throw path.
      *
      * @param assistantMessage - The assistant message containing tool use blocks
-     * @param toolRegistry - Registry containing available tools
      * @returns Tool-result message and the dispatched AfterToolsEvent
      */
-    async *executeTools(assistantMessage, toolRegistry, invocationState, completedToolResults) {
+    async *executeTools(assistantMessage, invocationState, completedToolResults) {
         const beforeToolsEvent = new BeforeToolsEvent({ agent: this, message: assistantMessage, invocationState });
         try {
             yield beforeToolsEvent;
@@ -1616,105 +1623,41 @@ export class Agent {
             throw error;
         }
         const toolUseBlocks = assistantMessage.content.filter((block) => block.type === 'toolUseBlock');
-        if (toolUseBlocks.length === 0) {
-            // Preserve BeforeToolsEvent/AfterToolsEvent bracket symmetry even on
-            // this invariant-violation branch.
-            yield new AfterToolsEvent({
-                agent: this,
-                message: new Message({ role: 'user', content: [] }),
-                invocationState,
-            });
-            throw new Error('Model indicated toolUse but no tool use blocks found in message');
-        }
-        // Pre-launch cancel paths are strategy-independent.
-        if (beforeToolsEvent.cancel) {
-            const message = typeof beforeToolsEvent.cancel === 'string' ? beforeToolsEvent.cancel : 'Tool cancelled by hook';
-            return yield* this._yieldCancelledToolResults(toolUseBlocks, message, invocationState);
-        }
-        if (this.isCancelled) {
-            return yield* this._yieldCancelledToolResults(toolUseBlocks, 'Tool execution cancelled', invocationState);
-        }
-        switch (this._toolExecutor) {
-            case 'sequential':
-                return yield* this._executeToolsSequential(toolUseBlocks, toolRegistry, invocationState, completedToolResults, assistantMessage);
-            case 'concurrent':
-                return yield* this._executeToolsConcurrent(toolUseBlocks, toolRegistry, invocationState, completedToolResults, assistantMessage);
-            default: {
-                const _exhaustive = this._toolExecutor;
-                throw new Error(`Unknown toolExecutor: ${_exhaustive}`);
-            }
-        }
-    }
-    /**
-     * Emits a `ToolResultEvent` for every block plus an `AfterToolsEvent`, and
-     * returns the resulting tool-result message and dispatched event. Used by the pre-launch cancel
-     * paths shared across executors.
-     */
-    async *_yieldCancelledToolResults(toolUseBlocks, message, invocationState) {
-        const cancelBlocks = this._cancelAllAsResults(toolUseBlocks, message);
-        for (const result of cancelBlocks) {
-            yield new ToolResultEvent({ agent: this, result, invocationState });
-        }
-        const toolResultMessage = new Message({ role: 'user', content: cancelBlocks });
-        const afterToolsEvent = new AfterToolsEvent({ agent: this, message: toolResultMessage, invocationState });
-        yield afterToolsEvent;
-        return { message: toolResultMessage, afterToolsEvent };
-    }
-    /**
-     * Executes tools one at a time, honoring `agent.cancelSignal` between
-     * iterations to short-circuit not-yet-started tools.
-     */
-    async *_executeToolsSequential(toolUseBlocks, toolRegistry, invocationState, completedToolResults, assistantMessage) {
         const toolResultBlocks = [];
         let toolResultMessage;
         let afterToolsEvent;
         try {
-            for (const toolUseBlock of toolUseBlocks) {
-                // Skip tools that were already completed before the interrupt
-                if (completedToolResults?.has(toolUseBlock.toolUseId)) {
-                    const completedResult = completedToolResults.get(toolUseBlock.toolUseId);
-                    // No events emitted for already-completed tools.
-                    // The result is included in the final tool result message.
-                    toolResultBlocks.push(completedResult);
-                    continue;
-                }
-                if (this.isCancelled) {
-                    const cancelBlock = new ToolResultBlock({
-                        toolUseId: toolUseBlock.toolUseId,
-                        status: 'error',
-                        content: [new TextBlock('Tool execution cancelled')],
-                    });
-                    toolResultBlocks.push(cancelBlock);
-                    yield new ToolResultEvent({ agent: this, result: cancelBlock, invocationState });
-                    continue;
-                }
-                try {
-                    const toolResultBlock = yield* this.executeTool(toolUseBlock, toolRegistry, invocationState);
-                    toolResultBlocks.push(toolResultBlock);
-                    yield new ToolResultEvent({ agent: this, result: toolResultBlock, invocationState });
-                }
-                catch (error) {
-                    if (error instanceof InterruptError) {
-                        // Store pending state with completed results so far
-                        const completedSoFar = {};
-                        for (const block of toolResultBlocks) {
-                            completedSoFar[block.toolUseId] = block.toJSON();
-                        }
-                        // Also include any previously completed results
-                        if (completedToolResults) {
-                            for (const [id, block] of completedToolResults) {
-                                completedSoFar[id] = block.toJSON();
-                            }
-                        }
-                        this._interruptState.setPendingToolExecution({
-                            assistantMessageData: assistantMessage.toJSON(),
-                            completedToolResults: completedSoFar,
-                        });
-                        throw error;
-                    }
-                    throw error;
+            if (toolUseBlocks.length === 0) {
+                throw new Error('Model indicated toolUse but no tool use blocks found in message');
+            }
+            // Pre-launch cancellation is executor-independent.
+            const cancelMessage = beforeToolsEvent.cancel
+                ? typeof beforeToolsEvent.cancel === 'string'
+                    ? beforeToolsEvent.cancel
+                    : 'Tool cancelled by hook'
+                : this.isCancelled
+                    ? 'Tool execution cancelled'
+                    : undefined;
+            if (cancelMessage) {
+                toolResultBlocks.push(...this._cancelAllAsResults(toolUseBlocks, cancelMessage));
+                for (const result of toolResultBlocks) {
+                    yield new ToolResultEvent({ agent: this, result, invocationState });
                 }
             }
+            else {
+                yield* this._toolExecutor.execute({
+                    agent: this,
+                    middlewareRegistry: this._middlewareRegistry,
+                    tracer: this._tracer,
+                    meter: this._meter,
+                }, {
+                    toolUseBlocks,
+                    toolResultBlocks,
+                    invocationState,
+                    assistantMessage,
+                    ...(completedToolResults && { completedToolResults }),
+                });
+            }
         }
         finally {
             toolResultMessage = new Message({ role: 'user', content: toolResultBlocks });
@@ -1734,302 +1677,6 @@ export class Agent {
             content: [new TextBlock(message)],
         }));
     }
-    /**
-     * Executes tools concurrently by merging N per-tool {@link executeTool}
-     * async generators via `Promise.race`. Per-tool event order is preserved
-     * (because each generator is iterated serially); cross-tool events may
-     * interleave at race resolution boundaries.
-     *
-     * Per-tool retry (`AfterToolCallEvent.retry`) is isolated — it lives inside
-     * `executeTool`'s own `while(true)` loop, so one tool retrying does not
-     * disturb its siblings.
-     */
-    async *_executeToolsConcurrent(toolUseBlocks, toolRegistry, invocationState, completedToolResults, assistantMessage) {
-        let toolResultMessage;
-        let afterToolsEvent;
-        const gens = toolUseBlocks.map((block) => ({
-            block,
-            gen: completedToolResults?.has(block.toolUseId)
-                ? undefined // Skip already-completed tools
-                : this.executeTool(block, toolRegistry, invocationState),
-        }));
-        const step = (idx) => gens[idx].gen.next().then((res) => ({ idx, kind: 'next', res }), (error) => ({ idx, kind: 'throw', error }));
-        // Seed completed results from resume state
-        const resultsByToolUseId = new Map();
-        if (completedToolResults) {
-            for (const [id, result] of completedToolResults) {
-                resultsByToolUseId.set(id, result);
-            }
-        }
-        // Only race tools that need execution
-        const pendingNext = new Map();
-        for (let idx = 0; idx < gens.length; idx++) {
-            if (gens[idx].gen) {
-                pendingNext.set(idx, step(idx));
-            }
-        }
-        // Track interrupts — let all other tools finish before propagating
-        let interruptError;
-        try {
-            while (pendingNext.size > 0) {
-                const winner = await Promise.race(pendingNext.values());
-                const { idx } = winner;
-                const block = gens[idx].block;
-                if (winner.kind === 'throw') {
-                    pendingNext.delete(idx);
-                    // Detect InterruptError — don't convert to error result, track it
-                    if (winner.error instanceof InterruptError) {
-                        interruptError = winner.error;
-                        continue;
-                    }
-                    const err = normalizeError(winner.error);
-                    const result = new ToolResultBlock({
-                        toolUseId: block.toolUseId,
-                        status: 'error',
-                        content: [new TextBlock(err.message)],
-                        error: err,
-                    });
-                    resultsByToolUseId.set(block.toolUseId, result);
-                    yield new ToolResultEvent({ agent: this, result, invocationState });
-                    continue;
-                }
-                if (winner.res.done) {
-                    pendingNext.delete(idx);
-                    resultsByToolUseId.set(block.toolUseId, winner.res.value);
-                    yield new ToolResultEvent({ agent: this, result: winner.res.value, invocationState });
-                }
-                else {
-                    try {
-                        yield winner.res.value;
-                    }
-                    catch (e) {
-                        // InterruptError thrown back into generator from stream() error injection
-                        if (e instanceof InterruptError) {
-                            interruptError = e;
-                            pendingNext.delete(idx);
-                            continue;
-                        }
-                        throw e;
-                    }
-                    pendingNext.set(idx, step(idx));
-                }
-            }
-            // After all tools finish, propagate interrupt if one was raised
-            if (interruptError) {
-                const completedSoFar = {};
-                for (const [id, result] of resultsByToolUseId) {
-                    completedSoFar[id] = result.toJSON();
-                }
-                this._interruptState.setPendingToolExecution({
-                    assistantMessageData: assistantMessage.toJSON(),
-                    completedToolResults: completedSoFar,
-                });
-                throw interruptError;
-            }
-        }
-        finally {
-            // Close any generators still in-flight (e.g. consumer broke out of stream).
-            await Promise.allSettled(Array.from(pendingNext.keys(), (idx) => gens[idx].gen.return(undefined)));
-            // Build the result message from whatever completed, in source order.
-            // Missing entries get a fallback error block so the message always
-            // accounts for every toolUseBlock the model emitted.
-            const toolResultBlocks = [];
-            for (const block of toolUseBlocks) {
-                const result = resultsByToolUseId.get(block.toolUseId);
-                if (result) {
-                    toolResultBlocks.push(result);
-                }
-                else {
-                    toolResultBlocks.push(new ToolResultBlock({
-                        toolUseId: block.toolUseId,
-                        status: 'error',
-                        content: [new TextBlock('Tool execution interrupted')],
-                    }));
-                }
-            }
-            toolResultMessage = new Message({ role: 'user', content: toolResultBlocks });
-            afterToolsEvent = new AfterToolsEvent({ agent: this, message: toolResultMessage, invocationState });
-            yield afterToolsEvent;
-        }
-        return { message: toolResultMessage, afterToolsEvent };
-    }
-    /**
-     * Executes a single tool and returns the result.
-     * If the tool is not found or fails to return a result, returns an error ToolResult
-     * instead of throwing an exception. This allows the agent loop to continue and
-     * let the model handle the error gracefully.
-     *
-     * @param toolUseBlock - Tool use block to execute
-     * @param toolRegistry - Registry containing available tools
-     * @returns Tool result block
-     */
-    async *executeTool(toolUseBlock, toolRegistry, invocationState) {
-        const registryTool = toolRegistry.get(toolUseBlock.name);
-        // Create toolUse object for hook events and telemetry. Callbacks may mutate
-        // this object's fields (input/name/toolUseId) inside BeforeToolCallEvent.
-        const toolUse = {
-            name: toolUseBlock.name,
-            toolUseId: toolUseBlock.toolUseId,
-            input: toolUseBlock.input,
-        };
-        // Retry loop for tool execution
-        while (true) {
-            const beforeToolCallEvent = new BeforeToolCallEvent({
-                agent: this,
-                toolUse,
-                tool: registryTool,
-                invocationState,
-            });
-            yield beforeToolCallEvent;
-            // Resolve the tool that would actually execute. selectedTool wins;
-            // otherwise if the hook renamed toolUse.name, re-resolve from the
-            // registry under the new name; otherwise use the original registry
-            // lookup. Resolved before the cancel check so AfterToolCallEvent.tool
-            // is consistent whether the cancel or execution branch runs.
-            const effectiveTool = beforeToolCallEvent.selectedTool ??
-                (toolUse.name !== toolUseBlock.name ? toolRegistry.get(toolUse.name) : registryTool);
-            // Cancel individual tool if hook requested it
-            if (beforeToolCallEvent.cancel) {
-                const cancelMessage = typeof beforeToolCallEvent.cancel === 'string' ? beforeToolCallEvent.cancel : 'Tool cancelled by hook';
-                const cancelResult = new ToolResultBlock({
-                    toolUseId: toolUse.toolUseId,
-                    status: 'error',
-                    content: [new TextBlock(cancelMessage)],
-                });
-                const afterToolCallEvent = new AfterToolCallEvent({
-                    agent: this,
-                    toolUse,
-                    tool: effectiveTool,
-                    result: cancelResult,
-                    invocationState,
-                });
-                yield afterToolCallEvent;
-                if (afterToolCallEvent.retry) {
-                    continue;
-                }
-                return afterToolCallEvent.result;
-            }
-            // Execute tool core logic through middleware chain
-            const toolResult = yield* this._executeToolWithMiddleware(effectiveTool, toolUse, invocationState);
-            const error = toolResult.error;
-            // Single point for AfterToolCallEvent
-            const afterToolCallEvent = new AfterToolCallEvent({
-                agent: this,
-                toolUse,
-                tool: effectiveTool,
-                result: toolResult,
-                invocationState,
-                ...(error !== undefined && { error }),
-            });
-            yield afterToolCallEvent;
-            if (afterToolCallEvent.retry) {
-                continue;
-            }
-            // Return the (possibly mutated) result so hook transformations propagate
-            // to ToolResultEvent and the conversation message the model will see.
-            return afterToolCallEvent.result;
-        }
-    }
-    async *_executeToolWithMiddleware(tool, toolUse, invocationState) {
-        const context = {
-            agent: this,
-            tool,
-            toolUse: deepCopy(toolUse),
-            invocationState,
-            interrupt: createMiddlewareInterrupt(this._interruptState, `middleware:executeTool:${toolUse.toolUseId}`),
-        };
-        // async function* doesn't bind lexical `this`; capture for the terminal callback.
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const self = this;
-        const middlewareResult = yield* this._middlewareRegistry.invoke(ExecuteToolStage, context, async function* (ctx) {
-            const result = yield* self._executeToolCore(ctx.tool, ctx.toolUse, ctx.invocationState);
-            return { result };
-        });
-        return middlewareResult.result;
-    }
-    async *_executeToolCore(effectiveTool, toolUse, invocationState) {
-        // Start tool span within loop span context
-        const toolSpan = this._tracer.startToolCallSpan({
-            tool: toolUse,
-        });
-        // Track tool execution time for metrics
-        const toolStartTime = Date.now();
-        let toolResult;
-        let error;
-        if (!effectiveTool) {
-            // Tool not found
-            toolResult = new ToolResultBlock({
-                toolUseId: toolUse.toolUseId,
-                status: 'error',
-                content: [new TextBlock(`Tool '${toolUse.name}' not found in registry`)],
-            });
-        }
-        else {
-            // Execute tool within the tool span context
-            const toolContext = {
-                toolUse: {
-                    name: toolUse.name,
-                    toolUseId: toolUse.toolUseId,
-                    input: toolUse.input,
-                },
-                agent: this,
-                invocationState,
-                interrupt: (params) => {
-                    return interruptFromAgent(this, `tool:${toolUse.toolUseId}:${params.name}`, params, 'tool');
-                },
-            };
-            try {
-                // Manually iterate tool stream to wrap each ToolStreamEvent in ToolStreamUpdateEvent.
-                // This keeps the tool authoring interface unchanged — tools construct ToolStreamEvent
-                // without knowledge of agents or hooks, and we wrap at the boundary.
-                // Tool execution is ran within the tool span's context so that
-                // downstream calls (e.g., MCP clients) can propagate trace context
-                const toolGenerator = this._tracer.withSpanContext(toolSpan, () => effectiveTool.stream(toolContext));
-                let toolNext = await this._tracer.withSpanContext(toolSpan, () => toolGenerator.next());
-                while (!toolNext.done) {
-                    yield new ToolStreamUpdateEvent({ agent: this, event: toolNext.value, invocationState });
-                    toolNext = await this._tracer.withSpanContext(toolSpan, () => toolGenerator.next());
-                }
-                const result = toolNext.value;
-                if (!result) {
-                    // Tool didn't return a result
-                    toolResult = new ToolResultBlock({
-                        toolUseId: toolUse.toolUseId,
-                        status: 'error',
-                        content: [new TextBlock(`Tool '${toolUse.name}' did not return a result`)],
-                    });
-                }
-                else {
-                    toolResult = result;
-                    error = result.error;
-                }
-            }
-            catch (e) {
-                // Re-throw InterruptError to allow interrupt handling
-                if (e instanceof InterruptError) {
-                    throw e;
-                }
-                // Tool execution failed with error
-                error = normalizeError(e);
-                toolResult = new ToolResultBlock({
-                    toolUseId: toolUse.toolUseId,
-                    status: 'error',
-                    content: [new TextBlock(error.message)],
-                    error,
-                });
-            }
-        }
-        // End tool span with the raw tool result — telemetry reflects what the
-        // tool actually returned, independent of AfterToolCallEvent mutations.
-        this._tracer.endToolCallSpan(toolSpan, { toolResult, ...(error && { error }) });
-        // End tool metrics tracking
-        this._meter.endToolCall({
-            tool: toolUse,
-            duration: Date.now() - toolStartTime,
-            success: toolResult.status === 'success',
-        });
-        return toolResult;
-    }
     /**
      * Redacts the last message in the conversation history.
      * Called when guardrails block user input and redaction is enabled.