@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/services/tools/toolExecution.js

@@ -0,0 +1,1218 @@
+import { feature } from '../../recovery/bunBundleShim.js';
+import { logEvent, } from '../analytics/index.js';
+import { extractMcpToolDetails, extractSkillName, extractToolInputForTelemetry, getFileExtensionForAnalytics, getFileExtensionsFromBashCommand, isToolDetailsLoggingEnabled, mcpToolDetailsForAnalytics, sanitizeToolNameForAnalytics, } from '../analytics/metadata.js';
+import { addToToolDuration, getCodeEditToolDecisionCounter, getStatsStore, } from '../../bootstrap/state.js';
+import { buildCodeEditToolAttributes, isCodeEditingTool, } from '../../hooks/toolPermission/permissionLogging.js';
+import { findToolByName, } from '../../Tool.js';
+import { startSpeculativeClassifierCheck } from '../../tools/BashTool/bashPermissions.js';
+import { BASH_TOOL_NAME } from '../../tools/BashTool/toolName.js';
+import { FILE_EDIT_TOOL_NAME } from '../../tools/FileEditTool/constants.js';
+import { FILE_READ_TOOL_NAME } from '../../tools/FileReadTool/prompt.js';
+import { FILE_WRITE_TOOL_NAME } from '../../tools/FileWriteTool/prompt.js';
+import { NOTEBOOK_EDIT_TOOL_NAME } from '../../tools/NotebookEditTool/constants.js';
+import { POWERSHELL_TOOL_NAME } from '../../tools/PowerShellTool/toolName.js';
+import { parseGitCommitId } from '../../tools/shared/gitOperationTracking.js';
+import { isDeferredTool, TOOL_SEARCH_TOOL_NAME, } from '../../tools/ToolSearchTool/prompt.js';
+import { getAllBaseTools } from '../../tools.js';
+import { count } from '../../utils/array.js';
+import { createAttachmentMessage } from '../../utils/attachments.js';
+import { logForDebugging } from '../../utils/debug.js';
+import { AbortError, errorMessage, getErrnoCode, ShellError, TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, } from '../../utils/errors.js';
+import { executePermissionDeniedHooks } from '../../utils/hooks.js';
+import { logError } from '../../utils/log.js';
+import { CANCEL_MESSAGE, createProgressMessage, createStopHookSummaryMessage, createToolResultStopMessage, createUserMessage, withMemoryCorrectionHint, } from '../../utils/messages.js';
+import { startSessionActivity, stopSessionActivity, } from '../../utils/sessionActivity.js';
+import { jsonStringify } from '../../utils/slowOperations.js';
+import { Stream } from '../../utils/stream.js';
+import { logOTelEvent } from '../../utils/telemetry/events.js';
+import { addToolContentEvent, endToolBlockedOnUserSpan, endToolExecutionSpan, endToolSpan, isBetaTracingEnabled, startToolBlockedOnUserSpan, startToolExecutionSpan, startToolSpan, } from '../../utils/telemetry/sessionTracing.js';
+import { formatError, formatZodValidationError, } from '../../utils/toolErrors.js';
+import { processPreMappedToolResultBlock, processToolResultBlock, } from '../../utils/toolResultStorage.js';
+import { extractDiscoveredToolNames, isToolSearchEnabledOptimistic, isToolSearchToolAvailable, } from '../../utils/toolSearch.js';
+import { McpAuthError, McpToolCallError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, } from '../mcp/client.js';
+import { mcpInfoFromString } from '../mcp/mcpStringUtils.js';
+import { normalizeNameForMCP } from '../mcp/normalization.js';
+import { getLoggingSafeMcpBaseUrl, getMcpServerScopeFromToolName, isMcpTool, } from '../mcp/utils.js';
+import { resolveHookPermissionDecision, runPostToolUseFailureHooks, runPostToolUseHooks, runPreToolUseHooks, } from './toolHooks.js';
+/** Minimum total hook duration (ms) to show inline timing summary */
+export const HOOK_TIMING_DISPLAY_THRESHOLD_MS = 500;
+/** Log a debug warning when hooks/permission-decision block for this long. Matches
+ * BashTool's PROGRESS_THRESHOLD_MS — the collapsed view feels stuck past this. */
+const SLOW_PHASE_LOG_THRESHOLD_MS = 2000;
+/**
+ * Classify a tool execution error into a telemetry-safe string.
+ *
+ * In minified/external builds, `error.constructor.name` is mangled into
+ * short identifiers like "nJT" or "Chq" — useless for diagnostics.
+ * This function extracts structured, telemetry-safe information instead:
+ * - TelemetrySafeError: use its telemetryMessage (already vetted)
+ * - Node.js fs errors: log the error code (ENOENT, EACCES, etc.)
+ * - Known error types: use their unminified name
+ * - Fallback: "Error" (better than a mangled 3-char identifier)
+ */
+export function classifyToolError(error) {
+    if (error instanceof TelemetrySafeError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS) {
+        return error.telemetryMessage.slice(0, 200);
+    }
+    if (error instanceof Error) {
+        // Node.js filesystem errors have a `code` property (ENOENT, EACCES, etc.)
+        // These are safe to log and much more useful than the constructor name.
+        const errnoCode = getErrnoCode(error);
+        if (typeof errnoCode === 'string') {
+            return `Error:${errnoCode}`;
+        }
+        // ShellError, ImageSizeError, etc. have stable `.name` properties
+        // that survive minification (they're set in the constructor).
+        if (error.name && error.name !== 'Error' && error.name.length > 3) {
+            return error.name.slice(0, 60);
+        }
+        return 'Error';
+    }
+    return 'UnknownError';
+}
+/**
+ * Map a rule's origin to the documented OTel `source` vocabulary, matching
+ * the interactive path's semantics (permissionLogging.ts:81): session-scoped
+ * grants are temporary, on-disk grants are permanent, and user-authored
+ * denies are user_reject regardless of persistence. Everything the user
+ * didn't write (cliArg, policySettings, projectSettings, flagSettings) is
+ * config.
+ */
+function ruleSourceToOTelSource(ruleSource, behavior) {
+    switch (ruleSource) {
+        case 'session':
+            return behavior === 'allow' ? 'user_temporary' : 'user_reject';
+        case 'localSettings':
+        case 'userSettings':
+            return behavior === 'allow' ? 'user_permanent' : 'user_reject';
+        default:
+            return 'config';
+    }
+}
+/**
+ * Map a PermissionDecisionReason to the OTel `source` label for the
+ * non-interactive tool_decision path, staying within the documented
+ * vocabulary (config, hook, user_permanent, user_temporary, user_reject).
+ *
+ * For permissionPromptTool, the SDK host may set decisionClassification on
+ * the PermissionResult to tell us exactly what happened (once vs always vs
+ * cache hit — the host knows, we can't tell from {behavior:'allow'} alone).
+ * Without it, we fall back conservatively: allow → user_temporary,
+ * deny → user_reject.
+ */
+function decisionReasonToOTelSource(reason, behavior) {
+    if (!reason) {
+        return 'config';
+    }
+    switch (reason.type) {
+        case 'permissionPromptTool': {
+            // toolResult is typed `unknown` on PermissionDecisionReason but carries
+            // the parsed Output from PermissionPromptToolResultSchema. Narrow at
+            // runtime rather than widen the cross-file type.
+            const toolResult = reason.toolResult;
+            const classified = toolResult?.decisionClassification;
+            if (classified === 'user_temporary' ||
+                classified === 'user_permanent' ||
+                classified === 'user_reject') {
+                return classified;
+            }
+            return behavior === 'allow' ? 'user_temporary' : 'user_reject';
+        }
+        case 'rule':
+            return ruleSourceToOTelSource(reason.rule.source, behavior);
+        case 'hook':
+            return 'hook';
+        case 'mode':
+        case 'classifier':
+        case 'subcommandResults':
+        case 'asyncAgent':
+        case 'sandboxOverride':
+        case 'workingDir':
+        case 'safetyCheck':
+        case 'other':
+            return 'config';
+        default: {
+            const _exhaustive = reason;
+            return 'config';
+        }
+    }
+}
+function getNextImagePasteId(messages) {
+    let maxId = 0;
+    for (const message of messages) {
+        if (message.type === 'user' && message.imagePasteIds) {
+            for (const id of message.imagePasteIds) {
+                if (id > maxId)
+                    maxId = id;
+            }
+        }
+    }
+    return maxId + 1;
+}
+function findMcpServerConnection(toolName, mcpClients) {
+    if (!toolName.startsWith('mcp__')) {
+        return undefined;
+    }
+    const mcpInfo = mcpInfoFromString(toolName);
+    if (!mcpInfo) {
+        return undefined;
+    }
+    // mcpInfo.serverName is normalized (e.g., "claude_ai_Slack"), but client.name
+    // is the original name (e.g., "claude.ai Slack"). Normalize both for comparison.
+    return mcpClients.find(client => normalizeNameForMCP(client.name) === mcpInfo.serverName);
+}
+/**
+ * Extracts the MCP server transport type from a tool name.
+ * Returns the server type (stdio, sse, http, ws, sdk, etc.) for MCP tools,
+ * or undefined for built-in tools.
+ */
+function getMcpServerType(toolName, mcpClients) {
+    const serverConnection = findMcpServerConnection(toolName, mcpClients);
+    if (serverConnection?.type === 'connected') {
+        // Handle stdio configs where type field is optional (defaults to 'stdio')
+        return serverConnection.config.type ?? 'stdio';
+    }
+    return undefined;
+}
+/**
+ * Extracts the MCP server base URL for a tool by looking up its server connection.
+ * Returns undefined for stdio servers, built-in tools, or if the server is not connected.
+ */
+function getMcpServerBaseUrlFromToolName(toolName, mcpClients) {
+    const serverConnection = findMcpServerConnection(toolName, mcpClients);
+    if (serverConnection?.type !== 'connected') {
+        return undefined;
+    }
+    return getLoggingSafeMcpBaseUrl(serverConnection.config);
+}
+export async function* runToolUse(toolUse, assistantMessage, canUseTool, toolUseContext) {
+    const toolName = toolUse.name;
+    // First try to find in the available tools (what the model sees)
+    let tool = findToolByName(toolUseContext.options.tools, toolName);
+    // If not found, check if it's a deprecated tool being called by alias
+    // (e.g., old transcripts calling "KillShell" which is now an alias for "TaskStop")
+    // Only fall back for tools where the name matches an alias, not the primary name
+    if (!tool) {
+        const fallbackTool = findToolByName(getAllBaseTools(), toolName);
+        // Only use fallback if the tool was found via alias (deprecated name)
+        if (fallbackTool && fallbackTool.aliases?.includes(toolName)) {
+            tool = fallbackTool;
+        }
+    }
+    const messageId = assistantMessage.message.id;
+    const requestId = assistantMessage.requestId;
+    const mcpServerType = getMcpServerType(toolName, toolUseContext.options.mcpClients);
+    const mcpServerBaseUrl = getMcpServerBaseUrlFromToolName(toolName, toolUseContext.options.mcpClients);
+    // Check if the tool exists
+    if (!tool) {
+        const sanitizedToolName = sanitizeToolNameForAnalytics(toolName);
+        logForDebugging(`Unknown tool ${toolName}: ${toolUse.id}`);
+        logEvent('tengu_tool_use_error', {
+            error: `No such tool available: ${sanitizedToolName}`,
+            toolName: sanitizedToolName,
+            toolUseID: toolUse.id,
+            isMcp: toolName.startsWith('mcp__'),
+            queryChainId: toolUseContext.queryTracking
+                ?.chainId,
+            queryDepth: toolUseContext.queryTracking?.depth,
+            ...(mcpServerType && {
+                mcpServerType: mcpServerType,
+            }),
+            ...(mcpServerBaseUrl && {
+                mcpServerBaseUrl: mcpServerBaseUrl,
+            }),
+            ...(requestId && {
+                requestId: requestId,
+            }),
+            ...mcpToolDetailsForAnalytics(toolName, mcpServerType, mcpServerBaseUrl),
+        });
+        yield {
+            message: createUserMessage({
+                content: [
+                    {
+                        type: 'tool_result',
+                        content: `<tool_use_error>Error: No such tool available: ${toolName}</tool_use_error>`,
+                        is_error: true,
+                        tool_use_id: toolUse.id,
+                    },
+                ],
+                toolUseResult: `Error: No such tool available: ${toolName}`,
+                sourceToolAssistantUUID: assistantMessage.uuid,
+            }),
+        };
+        return;
+    }
+    const toolInput = toolUse.input;
+    try {
+        if (toolUseContext.abortController.signal.aborted) {
+            logEvent('tengu_tool_use_cancelled', {
+                toolName: sanitizeToolNameForAnalytics(tool.name),
+                toolUseID: toolUse.id,
+                isMcp: tool.isMcp ?? false,
+                queryChainId: toolUseContext.queryTracking
+                    ?.chainId,
+                queryDepth: toolUseContext.queryTracking?.depth,
+                ...(mcpServerType && {
+                    mcpServerType: mcpServerType,
+                }),
+                ...(mcpServerBaseUrl && {
+                    mcpServerBaseUrl: mcpServerBaseUrl,
+                }),
+                ...(requestId && {
+                    requestId: requestId,
+                }),
+                ...mcpToolDetailsForAnalytics(tool.name, mcpServerType, mcpServerBaseUrl),
+            });
+            const content = createToolResultStopMessage(toolUse.id);
+            content.content = withMemoryCorrectionHint(CANCEL_MESSAGE);
+            yield {
+                message: createUserMessage({
+                    content: [content],
+                    toolUseResult: CANCEL_MESSAGE,
+                    sourceToolAssistantUUID: assistantMessage.uuid,
+                }),
+            };
+            return;
+        }
+        for await (const update of streamedCheckPermissionsAndCallTool(tool, toolUse.id, toolInput, toolUseContext, canUseTool, assistantMessage, messageId, requestId, mcpServerType, mcpServerBaseUrl)) {
+            yield update;
+        }
+    }
+    catch (error) {
+        logError(error);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const toolInfo = tool ? ` (${tool.name})` : '';
+        const detailedError = `Error calling tool${toolInfo}: ${errorMessage}`;
+        yield {
+            message: createUserMessage({
+                content: [
+                    {
+                        type: 'tool_result',
+                        content: `<tool_use_error>${detailedError}</tool_use_error>`,
+                        is_error: true,
+                        tool_use_id: toolUse.id,
+                    },
+                ],
+                toolUseResult: detailedError,
+                sourceToolAssistantUUID: assistantMessage.uuid,
+            }),
+        };
+    }
+}
+function streamedCheckPermissionsAndCallTool(tool, toolUseID, input, toolUseContext, canUseTool, assistantMessage, messageId, requestId, mcpServerType, mcpServerBaseUrl) {
+    // This is a bit of a hack to get progress events and final results
+    // into a single async iterable.
+    //
+    // Ideally the progress reporting and tool call reporting would
+    // be via separate mechanisms.
+    const stream = new Stream();
+    checkPermissionsAndCallTool(tool, toolUseID, input, toolUseContext, canUseTool, assistantMessage, messageId, requestId, mcpServerType, mcpServerBaseUrl, progress => {
+        logEvent('tengu_tool_use_progress', {
+            messageID: messageId,
+            toolName: sanitizeToolNameForAnalytics(tool.name),
+            isMcp: tool.isMcp ?? false,
+            queryChainId: toolUseContext.queryTracking
+                ?.chainId,
+            queryDepth: toolUseContext.queryTracking?.depth,
+            ...(mcpServerType && {
+                mcpServerType: mcpServerType,
+            }),
+            ...(mcpServerBaseUrl && {
+                mcpServerBaseUrl: mcpServerBaseUrl,
+            }),
+            ...(requestId && {
+                requestId: requestId,
+            }),
+            ...mcpToolDetailsForAnalytics(tool.name, mcpServerType, mcpServerBaseUrl),
+        });
+        stream.enqueue({
+            message: createProgressMessage({
+                toolUseID: progress.toolUseID,
+                parentToolUseID: toolUseID,
+                data: progress.data,
+            }),
+        });
+    })
+        .then(results => {
+        for (const result of results) {
+            stream.enqueue(result);
+        }
+    })
+        .catch(error => {
+        stream.error(error);
+    })
+        .finally(() => {
+        stream.done();
+    });
+    return stream;
+}
+/**
+ * Appended to Zod errors when a deferred tool wasn't in the discovered-tool
+ * set — re-runs the claude.ts schema-filter scan dispatch-time to detect the
+ * mismatch. The raw Zod error ("expected array, got string") doesn't tell the
+ * model to re-load the tool; this hint does. Null if the schema was sent.
+ */
+export function buildSchemaNotSentHint(tool, messages, tools) {
+    // Optimistic gating — reconstructing claude.ts's full useToolSearch
+    // computation is fragile. These two gates prevent pointing at a ToolSearch
+    // that isn't callable; occasional misfires (Haiku, tst-auto below threshold)
+    // cost one extra round-trip on an already-failing path.
+    if (!isToolSearchEnabledOptimistic())
+        return null;
+    if (!isToolSearchToolAvailable(tools))
+        return null;
+    if (!isDeferredTool(tool))
+        return null;
+    const discovered = extractDiscoveredToolNames(messages);
+    if (discovered.has(tool.name))
+        return null;
+    return (`\n\nThis tool's schema was not sent to the API — it was not in the discovered-tool set derived from message history. ` +
+        `Without the schema in your prompt, typed parameters (arrays, numbers, booleans) get emitted as strings and the client-side parser rejects them. ` +
+        `Load the tool first: call ${TOOL_SEARCH_TOOL_NAME} with query "select:${tool.name}", then retry this call.`);
+}
+async function checkPermissionsAndCallTool(tool, toolUseID, input, toolUseContext, canUseTool, assistantMessage, messageId, requestId, mcpServerType, mcpServerBaseUrl, onToolProgress) {
+    // Validate input types with zod (surprisingly, the model is not great at generating valid input)
+    const parsedInput = tool.inputSchema.safeParse(input);
+    if (!parsedInput.success) {
+        let errorContent = formatZodValidationError(tool.name, parsedInput.error);
+        const schemaHint = buildSchemaNotSentHint(tool, toolUseContext.messages, toolUseContext.options.tools);
+        if (schemaHint) {
+            logEvent('tengu_deferred_tool_schema_not_sent', {
+                toolName: sanitizeToolNameForAnalytics(tool.name),
+                isMcp: tool.isMcp ?? false,
+            });
+            errorContent += schemaHint;
+        }
+        logForDebugging(`${tool.name} tool input error: ${errorContent.slice(0, 200)}`);
+        logEvent('tengu_tool_use_error', {
+            error: 'InputValidationError',
+            errorDetails: errorContent.slice(0, 2000),
+            messageID: messageId,
+            toolName: sanitizeToolNameForAnalytics(tool.name),
+            isMcp: tool.isMcp ?? false,
+            queryChainId: toolUseContext.queryTracking
+                ?.chainId,
+            queryDepth: toolUseContext.queryTracking?.depth,
+            ...(mcpServerType && {
+                mcpServerType: mcpServerType,
+            }),
+            ...(mcpServerBaseUrl && {
+                mcpServerBaseUrl: mcpServerBaseUrl,
+            }),
+            ...(requestId && {
+                requestId: requestId,
+            }),
+            ...mcpToolDetailsForAnalytics(tool.name, mcpServerType, mcpServerBaseUrl),
+        });
+        return [
+            {
+                message: createUserMessage({
+                    content: [
+                        {
+                            type: 'tool_result',
+                            content: `<tool_use_error>InputValidationError: ${errorContent}</tool_use_error>`,
+                            is_error: true,
+                            tool_use_id: toolUseID,
+                        },
+                    ],
+                    toolUseResult: `InputValidationError: ${parsedInput.error.message}`,
+                    sourceToolAssistantUUID: assistantMessage.uuid,
+                }),
+            },
+        ];
+    }
+    // Validate input values. Each tool has its own validation logic
+    const isValidCall = await tool.validateInput?.(parsedInput.data, toolUseContext);
+    if (isValidCall?.result === false) {
+        logForDebugging(`${tool.name} tool validation error: ${isValidCall.message?.slice(0, 200)}`);
+        logEvent('tengu_tool_use_error', {
+            messageID: messageId,
+            toolName: sanitizeToolNameForAnalytics(tool.name),
+            error: isValidCall.message,
+            errorCode: isValidCall.errorCode,
+            isMcp: tool.isMcp ?? false,
+            queryChainId: toolUseContext.queryTracking
+                ?.chainId,
+            queryDepth: toolUseContext.queryTracking?.depth,
+            ...(mcpServerType && {
+                mcpServerType: mcpServerType,
+            }),
+            ...(mcpServerBaseUrl && {
+                mcpServerBaseUrl: mcpServerBaseUrl,
+            }),
+            ...(requestId && {
+                requestId: requestId,
+            }),
+            ...mcpToolDetailsForAnalytics(tool.name, mcpServerType, mcpServerBaseUrl),
+        });
+        return [
+            {
+                message: createUserMessage({
+                    content: [
+                        {
+                            type: 'tool_result',
+                            content: `<tool_use_error>${isValidCall.message}</tool_use_error>`,
+                            is_error: true,
+                            tool_use_id: toolUseID,
+                        },
+                    ],
+                    toolUseResult: `Error: ${isValidCall.message}`,
+                    sourceToolAssistantUUID: assistantMessage.uuid,
+                }),
+            },
+        ];
+    }
+    // Speculatively start the bash allow classifier check early so it runs in
+    // parallel with pre-tool hooks, deny/ask classifiers, and permission dialog
+    // setup. The UI indicator (setClassifierChecking) is NOT set here — it's
+    // set in interactiveHandler.ts only when the permission check returns `ask`
+    // with a pendingClassifierCheck. This avoids flashing "classifier running"
+    // for commands that auto-allow via prefix rules.
+    if (tool.name === BASH_TOOL_NAME &&
+        parsedInput.data &&
+        'command' in parsedInput.data) {
+        const appState = toolUseContext.getAppState();
+        startSpeculativeClassifierCheck(parsedInput.data.command, appState.toolPermissionContext, toolUseContext.abortController.signal, toolUseContext.options.isNonInteractiveSession);
+    }
+    const resultingMessages = [];
+    // Defense-in-depth: strip _simulatedSedEdit from model-provided Bash input.
+    // This field is internal-only — it must only be injected by the permission
+    // system (SedEditPermissionRequest) after user approval. If the model supplies
+    // it, the schema's strictObject should already reject it, but we strip here
+    // as a safeguard against future regressions.
+    let processedInput = parsedInput.data;
+    if (tool.name === BASH_TOOL_NAME &&
+        processedInput &&
+        typeof processedInput === 'object' &&
+        '_simulatedSedEdit' in processedInput) {
+        const { _simulatedSedEdit: _, ...rest } = processedInput;
+        processedInput = rest;
+    }
+    // Backfill legacy/derived fields on a shallow clone so hooks/canUseTool see
+    // them without affecting tool.call(). SendMessageTool adds fields; file
+    // tools overwrite file_path with expandPath — that mutation must not reach
+    // call() because tool results embed the input path verbatim (e.g. "File
+    // created successfully at: {path}"), and changing it alters the serialized
+    // transcript and VCR fixture hashes. If a hook/permission later returns a
+    // fresh updatedInput, callInput converges on it below — that replacement
+    // is intentional and should reach call().
+    let callInput = processedInput;
+    const backfilledClone = tool.backfillObservableInput &&
+        typeof processedInput === 'object' &&
+        processedInput !== null
+        ? { ...processedInput }
+        : null;
+    if (backfilledClone) {
+        tool.backfillObservableInput(backfilledClone);
+        processedInput = backfilledClone;
+    }
+    let shouldPreventContinuation = false;
+    let stopReason;
+    let hookPermissionResult;
+    const preToolHookInfos = [];
+    const preToolHookStart = Date.now();
+    for await (const result of runPreToolUseHooks(toolUseContext, tool, processedInput, toolUseID, assistantMessage.message.id, requestId, mcpServerType, mcpServerBaseUrl)) {
+        switch (result.type) {
+            case 'message':
+                if (result.message.message.type === 'progress') {
+                    onToolProgress(result.message.message);
+                }
+                else {
+                    resultingMessages.push(result.message);
+                    const att = result.message.message.attachment;
+                    if (att &&
+                        'command' in att &&
+                        att.command !== undefined &&
+                        'durationMs' in att &&
+                        att.durationMs !== undefined) {
+                        preToolHookInfos.push({
+                            command: att.command,
+                            durationMs: att.durationMs,
+                        });
+                    }
+                }
+                break;
+            case 'hookPermissionResult':
+                hookPermissionResult = result.hookPermissionResult;
+                break;
+            case 'hookUpdatedInput':
+                // Hook provided updatedInput without making a permission decision (passthrough)
+                // Update processedInput so it's used in the normal permission flow
+                processedInput = result.updatedInput;
+                break;
+            case 'preventContinuation':
+                shouldPreventContinuation = result.shouldPreventContinuation;
+                break;
+            case 'stopReason':
+                stopReason = result.stopReason;
+                break;
+            case 'additionalContext':
+                resultingMessages.push(result.message);
+                break;
+            case 'stop':
+                getStatsStore()?.observe('pre_tool_hook_duration_ms', Date.now() - preToolHookStart);
+                resultingMessages.push({
+                    message: createUserMessage({
+                        content: [createToolResultStopMessage(toolUseID)],
+                        toolUseResult: `Error: ${stopReason}`,
+                        sourceToolAssistantUUID: assistantMessage.uuid,
+                    }),
+                });
+                return resultingMessages;
+        }
+    }
+    const preToolHookDurationMs = Date.now() - preToolHookStart;
+    getStatsStore()?.observe('pre_tool_hook_duration_ms', preToolHookDurationMs);
+    if (preToolHookDurationMs >= SLOW_PHASE_LOG_THRESHOLD_MS) {
+        logForDebugging(`Slow PreToolUse hooks: ${preToolHookDurationMs}ms for ${tool.name} (${preToolHookInfos.length} hooks)`, { level: 'info' });
+    }
+    // Emit PreToolUse summary immediately so it's visible while the tool executes.
+    // Use wall-clock time (not sum of individual durations) since hooks run in parallel.
+    if (process.env.USER_TYPE === 'ant' && preToolHookInfos.length > 0) {
+        if (preToolHookDurationMs > HOOK_TIMING_DISPLAY_THRESHOLD_MS) {
+            resultingMessages.push({
+                message: createStopHookSummaryMessage(preToolHookInfos.length, preToolHookInfos, [], false, undefined, false, 'suggestion', undefined, 'PreToolUse', preToolHookDurationMs),
+            });
+        }
+    }
+    const toolAttributes = {};
+    if (processedInput && typeof processedInput === 'object') {
+        if (tool.name === FILE_READ_TOOL_NAME && 'file_path' in processedInput) {
+            toolAttributes.file_path = String(processedInput.file_path);
+        }
+        else if ((tool.name === FILE_EDIT_TOOL_NAME ||
+            tool.name === FILE_WRITE_TOOL_NAME) &&
+            'file_path' in processedInput) {
+            toolAttributes.file_path = String(processedInput.file_path);
+        }
+        else if (tool.name === BASH_TOOL_NAME && 'command' in processedInput) {
+            const bashInput = processedInput;
+            toolAttributes.full_command = bashInput.command;
+        }
+    }
+    startToolSpan(tool.name, toolAttributes, isBetaTracingEnabled() ? jsonStringify(processedInput) : undefined);
+    startToolBlockedOnUserSpan();
+    // Check whether we have permission to use the tool,
+    // and ask the user for permission if we don't
+    const permissionMode = toolUseContext.getAppState().toolPermissionContext.mode;
+    const permissionStart = Date.now();
+    const resolved = await resolveHookPermissionDecision(hookPermissionResult, tool, processedInput, toolUseContext, canUseTool, assistantMessage, toolUseID);
+    const permissionDecision = resolved.decision;
+    processedInput = resolved.input;
+    const permissionDurationMs = Date.now() - permissionStart;
+    // In auto mode, canUseTool awaits the classifier (side_query) — if that's
+    // slow the collapsed view shows "Running…" with no (Ns) tick since
+    // bash_progress hasn't started yet. Auto-only: in default mode this timer
+    // includes interactive-dialog wait (user think time), which is just noise.
+    if (permissionDurationMs >= SLOW_PHASE_LOG_THRESHOLD_MS &&
+        permissionMode === 'auto') {
+        logForDebugging(`Slow permission decision: ${permissionDurationMs}ms for ${tool.name} ` +
+            `(mode=${permissionMode}, behavior=${permissionDecision.behavior})`, { level: 'info' });
+    }
+    // Emit tool_decision OTel event and code-edit counter if the interactive
+    // permission path didn't already log it (headless mode bypasses permission
+    // logging, so we need to emit both the generic event and the code-edit
+    // counter here)
+    if (permissionDecision.behavior !== 'ask' &&
+        !toolUseContext.toolDecisions?.has(toolUseID)) {
+        const decision = permissionDecision.behavior === 'allow' ? 'accept' : 'reject';
+        const source = decisionReasonToOTelSource(permissionDecision.decisionReason, permissionDecision.behavior);
+        void logOTelEvent('tool_decision', {
+            decision,
+            source,
+            tool_name: sanitizeToolNameForAnalytics(tool.name),
+        });
+        // Increment code-edit tool decision counter for headless mode
+        if (isCodeEditingTool(tool.name)) {
+            void buildCodeEditToolAttributes(tool, processedInput, decision, source).then(attributes => getCodeEditToolDecisionCounter()?.add(1, attributes));
+        }
+    }
+    // Add message if permission was granted/denied by PermissionRequest hook
+    if (permissionDecision.decisionReason?.type === 'hook' &&
+        permissionDecision.decisionReason.hookName === 'PermissionRequest' &&
+        permissionDecision.behavior !== 'ask') {
+        resultingMessages.push({
+            message: createAttachmentMessage({
+                type: 'hook_permission_decision',
+                decision: permissionDecision.behavior,
+                toolUseID,
+                hookEvent: 'PermissionRequest',
+            }),
+        });
+    }
+    if (permissionDecision.behavior !== 'allow') {
+        logForDebugging(`${tool.name} tool permission denied`);
+        const decisionInfo = toolUseContext.toolDecisions?.get(toolUseID);
+        endToolBlockedOnUserSpan('reject', decisionInfo?.source || 'unknown');
+        endToolSpan();
+        logEvent('tengu_tool_use_can_use_tool_rejected', {
+            messageID: messageId,
+            toolName: sanitizeToolNameForAnalytics(tool.name),
+            queryChainId: toolUseContext.queryTracking
+                ?.chainId,
+            queryDepth: toolUseContext.queryTracking?.depth,
+            ...(mcpServerType && {
+                mcpServerType: mcpServerType,
+            }),
+            ...(mcpServerBaseUrl && {
+                mcpServerBaseUrl: mcpServerBaseUrl,
+            }),
+            ...(requestId && {
+                requestId: requestId,
+            }),
+            ...mcpToolDetailsForAnalytics(tool.name, mcpServerType, mcpServerBaseUrl),
+        });
+        let errorMessage = permissionDecision.message;
+        // Only use generic "Execution stopped" message if we don't have a detailed hook message
+        if (shouldPreventContinuation && !errorMessage) {
+            errorMessage = `Execution stopped by PreToolUse hook${stopReason ? `: ${stopReason}` : ''}`;
+        }
+        // Build top-level content: tool_result (text-only for is_error compatibility) + images alongside
+        const messageContent = [
+            {
+                type: 'tool_result',
+                content: errorMessage,
+                is_error: true,
+                tool_use_id: toolUseID,
+            },
+        ];
+        // Add image blocks at top level (not inside tool_result, which rejects non-text with is_error)
+        const rejectContentBlocks = permissionDecision.behavior === 'ask'
+            ? permissionDecision.contentBlocks
+            : undefined;
+        if (rejectContentBlocks?.length) {
+            messageContent.push(...rejectContentBlocks);
+        }
+        // Generate sequential imagePasteIds so each image renders with a distinct label
+        let rejectImageIds;
+        if (rejectContentBlocks?.length) {
+            const imageCount = count(rejectContentBlocks, (b) => b.type === 'image');
+            if (imageCount > 0) {
+                const startId = getNextImagePasteId(toolUseContext.messages);
+                rejectImageIds = Array.from({ length: imageCount }, (_, i) => startId + i);
+            }
+        }
+        resultingMessages.push({
+            message: createUserMessage({
+                content: messageContent,
+                imagePasteIds: rejectImageIds,
+                toolUseResult: `Error: ${errorMessage}`,
+                sourceToolAssistantUUID: assistantMessage.uuid,
+            }),
+        });
+        // Run PermissionDenied hooks for auto mode classifier denials.
+        // If a hook returns {retry: true}, tell the model it may retry.
+        if (feature('TRANSCRIPT_CLASSIFIER') &&
+            permissionDecision.decisionReason?.type === 'classifier' &&
+            permissionDecision.decisionReason.classifier === 'auto-mode') {
+            let hookSaysRetry = false;
+            for await (const result of executePermissionDeniedHooks(tool.name, toolUseID, processedInput, permissionDecision.decisionReason.reason ?? 'Permission denied', toolUseContext, permissionMode, toolUseContext.abortController.signal)) {
+                if (result.retry)
+                    hookSaysRetry = true;
+            }
+            if (hookSaysRetry) {
+                resultingMessages.push({
+                    message: createUserMessage({
+                        content: 'The PermissionDenied hook indicated this command is now approved. You may retry it if you would like.',
+                        isMeta: true,
+                    }),
+                });
+            }
+        }
+        return resultingMessages;
+    }
+    logEvent('tengu_tool_use_can_use_tool_allowed', {
+        messageID: messageId,
+        toolName: sanitizeToolNameForAnalytics(tool.name),
+        queryChainId: toolUseContext.queryTracking
+            ?.chainId,
+        queryDepth: toolUseContext.queryTracking?.depth,
+        ...(mcpServerType && {
+            mcpServerType: mcpServerType,
+        }),
+        ...(mcpServerBaseUrl && {
+            mcpServerBaseUrl: mcpServerBaseUrl,
+        }),
+        ...(requestId && {
+            requestId: requestId,
+        }),
+        ...mcpToolDetailsForAnalytics(tool.name, mcpServerType, mcpServerBaseUrl),
+    });
+    // Use the updated input from permissions if provided
+    // (Don't overwrite if undefined - processedInput may have been modified by passthrough hooks)
+    if (permissionDecision.updatedInput !== undefined) {
+        processedInput = permissionDecision.updatedInput;
+    }
+    // Prepare tool parameters for logging in tool_result event.
+    // Gated by OTEL_LOG_TOOL_DETAILS — tool parameters can contain sensitive
+    // content (bash commands, MCP server names, etc.) so they're opt-in only.
+    const telemetryToolInput = extractToolInputForTelemetry(processedInput);
+    let toolParameters = {};
+    if (isToolDetailsLoggingEnabled()) {
+        if (tool.name === BASH_TOOL_NAME && 'command' in processedInput) {
+            const bashInput = processedInput;
+            const commandParts = bashInput.command.trim().split(/\s+/);
+            const bashCommand = commandParts[0] || '';
+            toolParameters = {
+                bash_command: bashCommand,
+                full_command: bashInput.command,
+                ...(bashInput.timeout !== undefined && {
+                    timeout: bashInput.timeout,
+                }),
+                ...(bashInput.description !== undefined && {
+                    description: bashInput.description,
+                }),
+                ...('dangerouslyDisableSandbox' in bashInput && {
+                    dangerouslyDisableSandbox: bashInput.dangerouslyDisableSandbox,
+                }),
+            };
+        }
+        const mcpDetails = extractMcpToolDetails(tool.name);
+        if (mcpDetails) {
+            toolParameters.mcp_server_name = mcpDetails.serverName;
+            toolParameters.mcp_tool_name = mcpDetails.mcpToolName;
+        }
+        const skillName = extractSkillName(tool.name, processedInput);
+        if (skillName) {
+            toolParameters.skill_name = skillName;
+        }
+    }
+    const decisionInfo = toolUseContext.toolDecisions?.get(toolUseID);
+    endToolBlockedOnUserSpan(decisionInfo?.decision || 'unknown', decisionInfo?.source || 'unknown');
+    startToolExecutionSpan();
+    const startTime = Date.now();
+    startSessionActivity('tool_exec');
+    // If processedInput still points at the backfill clone, no hook/permission
+    // replaced it — pass the pre-backfill callInput so call() sees the model's
+    // original field values. Otherwise converge on the hook-supplied input.
+    // Permission/hook flows may return a fresh object derived from the
+    // backfilled clone (e.g. via inputSchema.parse). If its file_path matches
+    // the backfill-expanded value, restore the model's original so the tool
+    // result string embeds the path the model emitted — keeps transcript/VCR
+    // hashes stable. Other hook modifications flow through unchanged.
+    if (backfilledClone &&
+        processedInput !== callInput &&
+        typeof processedInput === 'object' &&
+        processedInput !== null &&
+        'file_path' in processedInput &&
+        'file_path' in callInput &&
+        processedInput.file_path ===
+            backfilledClone.file_path) {
+        callInput = {
+            ...processedInput,
+            file_path: callInput.file_path,
+        };
+    }
+    else if (processedInput !== backfilledClone) {
+        callInput = processedInput;
+    }
+    try {
+        const result = await tool.call(callInput, {
+            ...toolUseContext,
+            toolUseId: toolUseID,
+            userModified: permissionDecision.userModified ?? false,
+        }, canUseTool, assistantMessage, progress => {
+            onToolProgress({
+                toolUseID: progress.toolUseID,
+                data: progress.data,
+            });
+        });
+        const durationMs = Date.now() - startTime;
+        addToToolDuration(durationMs);
+        // Log tool content/output as span event if enabled
+        if (result.data && typeof result.data === 'object') {
+            const contentAttributes = {};
+            // Read tool: capture file_path and content
+            if (tool.name === FILE_READ_TOOL_NAME && 'content' in result.data) {
+                if ('file_path' in processedInput) {
+                    contentAttributes.file_path = String(processedInput.file_path);
+                }
+                contentAttributes.content = String(result.data.content);
+            }
+            // Edit/Write tools: capture file_path and diff
+            if ((tool.name === FILE_EDIT_TOOL_NAME ||
+                tool.name === FILE_WRITE_TOOL_NAME) &&
+                'file_path' in processedInput) {
+                contentAttributes.file_path = String(processedInput.file_path);
+                // For Edit, capture the actual changes made
+                if (tool.name === FILE_EDIT_TOOL_NAME && 'diff' in result.data) {
+                    contentAttributes.diff = String(result.data.diff);
+                }
+                // For Write, capture the written content
+                if (tool.name === FILE_WRITE_TOOL_NAME && 'content' in processedInput) {
+                    contentAttributes.content = String(processedInput.content);
+                }
+            }
+            // Bash tool: capture command
+            if (tool.name === BASH_TOOL_NAME && 'command' in processedInput) {
+                const bashInput = processedInput;
+                contentAttributes.bash_command = bashInput.command;
+                // Also capture output if available
+                if ('output' in result.data) {
+                    contentAttributes.output = String(result.data.output);
+                }
+            }
+            if (Object.keys(contentAttributes).length > 0) {
+                addToolContentEvent('tool.output', contentAttributes);
+            }
+        }
+        // Capture structured output from tool result if present
+        if (typeof result === 'object' && 'structured_output' in result) {
+            // Store the structured output in an attachment message
+            resultingMessages.push({
+                message: createAttachmentMessage({
+                    type: 'structured_output',
+                    data: result.structured_output,
+                }),
+            });
+        }
+        endToolExecutionSpan({ success: true });
+        // Pass tool result for new_context logging
+        const toolResultStr = result.data && typeof result.data === 'object'
+            ? jsonStringify(result.data)
+            : String(result.data ?? '');
+        endToolSpan(toolResultStr);
+        // Map the tool result to API format once and cache it. This block is reused
+        // by addToolResult (skipping the remap) and measured here for analytics.
+        const mappedToolResultBlock = tool.mapToolResultToToolResultBlockParam(result.data, toolUseID);
+        const mappedContent = mappedToolResultBlock.content;
+        const toolResultSizeBytes = !mappedContent
+            ? 0
+            : typeof mappedContent === 'string'
+                ? mappedContent.length
+                : jsonStringify(mappedContent).length;
+        // Extract file extension for file-related tools
+        let fileExtension;
+        if (processedInput && typeof processedInput === 'object') {
+            if ((tool.name === FILE_READ_TOOL_NAME ||
+                tool.name === FILE_EDIT_TOOL_NAME ||
+                tool.name === FILE_WRITE_TOOL_NAME) &&
+                'file_path' in processedInput) {
+                fileExtension = getFileExtensionForAnalytics(String(processedInput.file_path));
+            }
+            else if (tool.name === NOTEBOOK_EDIT_TOOL_NAME &&
+                'notebook_path' in processedInput) {
+                fileExtension = getFileExtensionForAnalytics(String(processedInput.notebook_path));
+            }
+            else if (tool.name === BASH_TOOL_NAME && 'command' in processedInput) {
+                const bashInput = processedInput;
+                fileExtension = getFileExtensionsFromBashCommand(bashInput.command, bashInput._simulatedSedEdit?.filePath);
+            }
+        }
+        logEvent('tengu_tool_use_success', {
+            messageID: messageId,
+            toolName: sanitizeToolNameForAnalytics(tool.name),
+            isMcp: tool.isMcp ?? false,
+            durationMs,
+            preToolHookDurationMs,
+            toolResultSizeBytes,
+            ...(fileExtension !== undefined && { fileExtension }),
+            queryChainId: toolUseContext.queryTracking
+                ?.chainId,
+            queryDepth: toolUseContext.queryTracking?.depth,
+            ...(mcpServerType && {
+                mcpServerType: mcpServerType,
+            }),
+            ...(mcpServerBaseUrl && {
+                mcpServerBaseUrl: mcpServerBaseUrl,
+            }),
+            ...(requestId && {
+                requestId: requestId,
+            }),
+            ...mcpToolDetailsForAnalytics(tool.name, mcpServerType, mcpServerBaseUrl),
+        });
+        // Enrich tool parameters with git commit ID from successful git commit output
+        if (isToolDetailsLoggingEnabled() &&
+            (tool.name === BASH_TOOL_NAME || tool.name === POWERSHELL_TOOL_NAME) &&
+            'command' in processedInput &&
+            typeof processedInput.command === 'string' &&
+            processedInput.command.match(/\bgit\s+commit\b/) &&
+            result.data &&
+            typeof result.data === 'object' &&
+            'stdout' in result.data) {
+            const gitCommitId = parseGitCommitId(String(result.data.stdout));
+            if (gitCommitId) {
+                toolParameters.git_commit_id = gitCommitId;
+            }
+        }
+        // Log tool result event for OTLP with tool parameters and decision context
+        const mcpServerScope = isMcpTool(tool)
+            ? getMcpServerScopeFromToolName(tool.name)
+            : null;
+        void logOTelEvent('tool_result', {
+            tool_name: sanitizeToolNameForAnalytics(tool.name),
+            success: 'true',
+            duration_ms: String(durationMs),
+            ...(Object.keys(toolParameters).length > 0 && {
+                tool_parameters: jsonStringify(toolParameters),
+            }),
+            ...(telemetryToolInput && { tool_input: telemetryToolInput }),
+            tool_result_size_bytes: String(toolResultSizeBytes),
+            ...(decisionInfo && {
+                decision_source: decisionInfo.source,
+                decision_type: decisionInfo.decision,
+            }),
+            ...(mcpServerScope && { mcp_server_scope: mcpServerScope }),
+        });
+        // Run PostToolUse hooks
+        let toolOutput = result.data;
+        const hookResults = [];
+        const toolContextModifier = result.contextModifier;
+        const mcpMeta = result.mcpMeta;
+        async function addToolResult(toolUseResult, preMappedBlock) {
+            // Use the pre-mapped block when available (non-MCP tools where hooks
+            // don't modify the output), otherwise map from scratch.
+            const toolResultBlock = preMappedBlock
+                ? await processPreMappedToolResultBlock(preMappedBlock, tool.name, tool.maxResultSizeChars)
+                : await processToolResultBlock(tool, toolUseResult, toolUseID);
+            // Build content blocks - tool result first, then optional feedback
+            const contentBlocks = [toolResultBlock];
+            // Add accept feedback if user provided feedback when approving
+            // (acceptFeedback only exists on PermissionAllowDecision, which is guaranteed here)
+            if ('acceptFeedback' in permissionDecision &&
+                permissionDecision.acceptFeedback) {
+                contentBlocks.push({
+                    type: 'text',
+                    text: permissionDecision.acceptFeedback,
+                });
+            }
+            // Add content blocks (e.g., pasted images) from the permission decision
+            const allowContentBlocks = 'contentBlocks' in permissionDecision
+                ? permissionDecision.contentBlocks
+                : undefined;
+            if (allowContentBlocks?.length) {
+                contentBlocks.push(...allowContentBlocks);
+            }
+            // Generate sequential imagePasteIds so each image renders with a distinct label
+            let allowImageIds;
+            if (allowContentBlocks?.length) {
+                const imageCount = count(allowContentBlocks, (b) => b.type === 'image');
+                if (imageCount > 0) {
+                    const startId = getNextImagePasteId(toolUseContext.messages);
+                    allowImageIds = Array.from({ length: imageCount }, (_, i) => startId + i);
+                }
+            }
+            resultingMessages.push({
+                message: createUserMessage({
+                    content: contentBlocks,
+                    imagePasteIds: allowImageIds,
+                    toolUseResult: toolUseContext.agentId && !toolUseContext.preserveToolUseResults
+                        ? undefined
+                        : toolUseResult,
+                    mcpMeta: toolUseContext.agentId ? undefined : mcpMeta,
+                    sourceToolAssistantUUID: assistantMessage.uuid,
+                }),
+                contextModifier: toolContextModifier
+                    ? {
+                        toolUseID: toolUseID,
+                        modifyContext: toolContextModifier,
+                    }
+                    : undefined,
+            });
+        }
+        // TOOD(hackyon): refactor so we don't have different experiences for MCP tools
+        if (!isMcpTool(tool)) {
+            await addToolResult(toolOutput, mappedToolResultBlock);
+        }
+        const postToolHookInfos = [];
+        const postToolHookStart = Date.now();
+        for await (const hookResult of runPostToolUseHooks(toolUseContext, tool, toolUseID, assistantMessage.message.id, processedInput, toolOutput, requestId, mcpServerType, mcpServerBaseUrl)) {
+            if ('updatedMCPToolOutput' in hookResult) {
+                if (isMcpTool(tool)) {
+                    toolOutput = hookResult.updatedMCPToolOutput;
+                }
+            }
+            else if (isMcpTool(tool)) {
+                hookResults.push(hookResult);
+                if (hookResult.message.type === 'attachment') {
+                    const att = hookResult.message.attachment;
+                    if ('command' in att &&
+                        att.command !== undefined &&
+                        'durationMs' in att &&
+                        att.durationMs !== undefined) {
+                        postToolHookInfos.push({
+                            command: att.command,
+                            durationMs: att.durationMs,
+                        });
+                    }
+                }
+            }
+            else {
+                resultingMessages.push(hookResult);
+                if (hookResult.message.type === 'attachment') {
+                    const att = hookResult.message.attachment;
+                    if ('command' in att &&
+                        att.command !== undefined &&
+                        'durationMs' in att &&
+                        att.durationMs !== undefined) {
+                        postToolHookInfos.push({
+                            command: att.command,
+                            durationMs: att.durationMs,
+                        });
+                    }
+                }
+            }
+        }
+        const postToolHookDurationMs = Date.now() - postToolHookStart;
+        if (postToolHookDurationMs >= SLOW_PHASE_LOG_THRESHOLD_MS) {
+            logForDebugging(`Slow PostToolUse hooks: ${postToolHookDurationMs}ms for ${tool.name} (${postToolHookInfos.length} hooks)`, { level: 'info' });
+        }
+        if (isMcpTool(tool)) {
+            await addToolResult(toolOutput);
+        }
+        // Show PostToolUse hook timing inline below tool result when > 500ms.
+        // Use wall-clock time (not sum of individual durations) since hooks run in parallel.
+        if (process.env.USER_TYPE === 'ant' && postToolHookInfos.length > 0) {
+            if (postToolHookDurationMs > HOOK_TIMING_DISPLAY_THRESHOLD_MS) {
+                resultingMessages.push({
+                    message: createStopHookSummaryMessage(postToolHookInfos.length, postToolHookInfos, [], false, undefined, false, 'suggestion', undefined, 'PostToolUse', postToolHookDurationMs),
+                });
+            }
+        }
+        // If the tool provided new messages, add them to the list to return.
+        if (result.newMessages && result.newMessages.length > 0) {
+            for (const message of result.newMessages) {
+                resultingMessages.push({ message });
+            }
+        }
+        // If hook indicated to prevent continuation after successful execution, yield a stop reason message
+        if (shouldPreventContinuation) {
+            resultingMessages.push({
+                message: createAttachmentMessage({
+                    type: 'hook_stopped_continuation',
+                    message: stopReason || 'Execution stopped by hook',
+                    hookName: `PreToolUse:${tool.name}`,
+                    toolUseID: toolUseID,
+                    hookEvent: 'PreToolUse',
+                }),
+            });
+        }
+        // Yield the remaining hook results after the other messages are sent
+        for (const hookResult of hookResults) {
+            resultingMessages.push(hookResult);
+        }
+        return resultingMessages;
+    }
+    catch (error) {
+        const durationMs = Date.now() - startTime;
+        addToToolDuration(durationMs);
+        endToolExecutionSpan({
+            success: false,
+            error: errorMessage(error),
+        });
+        endToolSpan();
+        // Handle MCP auth errors by updating the client status to 'needs-auth'
+        // This updates the /mcp display to show the server needs re-authorization
+        if (error instanceof McpAuthError) {
+            toolUseContext.setAppState(prevState => {
+                const serverName = error.serverName;
+                const existingClientIndex = prevState.mcp.clients.findIndex(c => c.name === serverName);
+                if (existingClientIndex === -1) {
+                    return prevState;
+                }
+                const existingClient = prevState.mcp.clients[existingClientIndex];
+                // Only update if client was connected (don't overwrite other states)
+                if (!existingClient || existingClient.type !== 'connected') {
+                    return prevState;
+                }
+                const updatedClients = [...prevState.mcp.clients];
+                updatedClients[existingClientIndex] = {
+                    name: serverName,
+                    type: 'needs-auth',
+                    config: existingClient.config,
+                };
+                return {
+                    ...prevState,
+                    mcp: {
+                        ...prevState.mcp,
+                        clients: updatedClients,
+                    },
+                };
+            });
+        }
+        if (!(error instanceof AbortError)) {
+            const errorMsg = errorMessage(error);
+            logForDebugging(`${tool.name} tool error (${durationMs}ms): ${errorMsg.slice(0, 200)}`);
+            if (!(error instanceof ShellError)) {
+                logError(error);
+            }
+            logEvent('tengu_tool_use_error', {
+                messageID: messageId,
+                toolName: sanitizeToolNameForAnalytics(tool.name),
+                error: classifyToolError(error),
+                isMcp: tool.isMcp ?? false,
+                queryChainId: toolUseContext.queryTracking
+                    ?.chainId,
+                queryDepth: toolUseContext.queryTracking?.depth,
+                ...(mcpServerType && {
+                    mcpServerType: mcpServerType,
+                }),
+                ...(mcpServerBaseUrl && {
+                    mcpServerBaseUrl: mcpServerBaseUrl,
+                }),
+                ...(requestId && {
+                    requestId: requestId,
+                }),
+                ...mcpToolDetailsForAnalytics(tool.name, mcpServerType, mcpServerBaseUrl),
+            });
+            // Log tool result error event for OTLP with tool parameters and decision context
+            const mcpServerScope = isMcpTool(tool)
+                ? getMcpServerScopeFromToolName(tool.name)
+                : null;
+            void logOTelEvent('tool_result', {
+                tool_name: sanitizeToolNameForAnalytics(tool.name),
+                use_id: toolUseID,
+                success: 'false',
+                duration_ms: String(durationMs),
+                error: errorMessage(error),
+                ...(Object.keys(toolParameters).length > 0 && {
+                    tool_parameters: jsonStringify(toolParameters),
+                }),
+                ...(telemetryToolInput && { tool_input: telemetryToolInput }),
+                ...(decisionInfo && {
+                    decision_source: decisionInfo.source,
+                    decision_type: decisionInfo.decision,
+                }),
+                ...(mcpServerScope && { mcp_server_scope: mcpServerScope }),
+            });
+        }
+        const content = formatError(error);
+        // Determine if this was a user interrupt
+        const isInterrupt = error instanceof AbortError;
+        // Run PostToolUseFailure hooks
+        const hookMessages = [];
+        for await (const hookResult of runPostToolUseFailureHooks(toolUseContext, tool, toolUseID, messageId, processedInput, content, isInterrupt, requestId, mcpServerType, mcpServerBaseUrl)) {
+            hookMessages.push(hookResult);
+        }
+        return [
+            {
+                message: createUserMessage({
+                    content: [
+                        {
+                            type: 'tool_result',
+                            content,
+                            is_error: true,
+                            tool_use_id: toolUseID,
+                        },
+                    ],
+                    toolUseResult: `Error: ${content}`,
+                    mcpMeta: toolUseContext.agentId
+                        ? undefined
+                        : error instanceof
+                            McpToolCallError_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS
+                            ? error.mcpMeta
+                            : undefined,
+                    sourceToolAssistantUUID: assistantMessage.uuid,
+                }),
+            },
+            ...hookMessages,
+        ];
+    }
+    finally {
+        stopSessionActivity('tool_exec');
+        // Clean up decision info after logging
+        if (decisionInfo) {
+            toolUseContext.toolDecisions?.delete(toolUseID);
+        }
+    }
+}