open-agent-sdk 0.1.0-alpha.0

package/dist/agent/react-loop.js

@@ -0,0 +1,674 @@
+/**
+ * ReAct (Reasoning + Acting) loop implementation
+ * Core agent logic for tool use and reasoning
+ */
+import { logger } from '../utils/logger';
+import { generateUUID } from '../utils/uuid';
+import { createUserMessage, createSystemMessage, createAssistantMessage, createToolResultMessage, createCompactBoundaryMessage, } from '../types/messages';
+import { HookManager } from '../hooks/manager';
+import { createPreToolUseInput, createPostToolUseInput, createSessionStartInput, createSessionEndInput, createPermissionRequestInput, createPostToolUseFailureInput, createUserPromptSubmitInput, createStopInput, createPreCompactInput, } from '../hooks/inputs';
+import { PermissionManager } from '../permissions/manager';
+export class ReActLoop {
+    provider;
+    toolRegistry;
+    config;
+    sessionId;
+    hookManager;
+    permissionManager;
+    constructor(provider, toolRegistry, config, sessionId) {
+        this.provider = provider;
+        this.toolRegistry = toolRegistry;
+        this.config = {
+            maxTurns: config.maxTurns,
+            systemPrompt: config.systemPrompt,
+            allowedTools: config.allowedTools,
+            cwd: config.cwd ?? process.cwd(),
+            env: config.env ?? {},
+            abortController: config.abortController,
+            permissionMode: config.permissionMode,
+            allowDangerouslySkipPermissions: config.allowDangerouslySkipPermissions,
+            canUseTool: config.canUseTool,
+            mcpServers: config.mcpServers,
+            hooks: config.hooks,
+        };
+        this.sessionId = sessionId ?? generateUUID();
+        // Initialize HookManager
+        if (config.hooks instanceof HookManager) {
+            this.hookManager = config.hooks;
+        }
+        else if (config.hooks) {
+            this.hookManager = new HookManager(config.hooks);
+        }
+        else {
+            this.hookManager = new HookManager();
+        }
+        // Initialize PermissionManager
+        this.permissionManager = new PermissionManager({
+            mode: config.permissionMode ?? 'default',
+            allowDangerouslySkipPermissions: config.allowDangerouslySkipPermissions ?? false,
+            canUseTool: config.canUseTool,
+        });
+    }
+    /**
+     * Get the permission manager instance
+     * Used for testing and inspection
+     */
+    getPermissionManager() {
+        return this.permissionManager;
+    }
+    async run(userPrompt) {
+        const messages = [];
+        // Add system message metadata if system prompt is configured
+        // The actual system prompt content is passed via ChatOptions to the provider
+        if (this.config.systemPrompt) {
+            messages.push(createSystemMessage(this.provider.getModel(), this.provider.constructor.name.toLowerCase().replace('provider', ''), this.config.allowedTools ?? this.toolRegistry.getAll().map((t) => t.name), this.config.cwd ?? process.cwd(), this.sessionId, generateUUID(), {
+                permissionMode: this.config.permissionMode,
+            }));
+        }
+        // Add user message
+        messages.push(createUserMessage(userPrompt, this.sessionId, generateUUID()));
+        // Trigger UserPromptSubmit hook
+        const userPromptSubmitInput = createUserPromptSubmitInput(this.sessionId, this.config.cwd ?? process.cwd(), userPrompt);
+        await this.hookManager.emit('UserPromptSubmit', userPromptSubmitInput, undefined);
+        let turnCount = 0;
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        // Get allowed tools
+        const availableTools = this.config.allowedTools
+            ? this.toolRegistry.getAllowedTools(this.config.allowedTools)
+            : this.toolRegistry.getAll();
+        const toolDefinitions = availableTools.map((tool) => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters,
+            },
+        }));
+        const toolContext = {
+            cwd: this.config.cwd,
+            env: this.config.env,
+            abortController: this.config.abortController,
+            provider: this.provider,
+        };
+        while (turnCount < this.config.maxTurns) {
+            // Check for abort
+            if (this.config.abortController?.signal.aborted) {
+                return {
+                    result: 'Operation aborted',
+                    messages,
+                    turnCount,
+                    usage: {
+                        input_tokens: totalInputTokens,
+                        output_tokens: totalOutputTokens,
+                    },
+                    isError: true,
+                };
+            }
+            turnCount++;
+            // Check for abort again after incrementing turn count
+            // This prevents race conditions where abort was triggered between the start of the loop and turnCount++
+            if (this.config.abortController?.signal.aborted) {
+                return {
+                    result: 'Operation aborted',
+                    messages,
+                    turnCount,
+                    usage: {
+                        input_tokens: totalInputTokens,
+                        output_tokens: totalOutputTokens,
+                    },
+                    isError: true,
+                };
+            }
+            // Call LLM
+            let assistantMessage;
+            try {
+                assistantMessage = await this.callLLM(messages, toolDefinitions, (tokens) => {
+                    totalInputTokens += tokens.input;
+                    totalOutputTokens += tokens.output;
+                });
+            }
+            catch (error) {
+                // Handle abort error from provider
+                if (error instanceof Error && error.message === 'Operation aborted') {
+                    return {
+                        result: 'Operation aborted',
+                        messages,
+                        turnCount,
+                        usage: {
+                            input_tokens: totalInputTokens,
+                            output_tokens: totalOutputTokens,
+                        },
+                        isError: true,
+                    };
+                }
+                throw error;
+            }
+            messages.push(assistantMessage);
+            // Check for auto-compaction after each LLM call
+            if (this.config.autoCompactThreshold !== undefined &&
+                totalInputTokens > this.config.autoCompactThreshold) {
+                logger.debug('[ReActLoop] Auto-compaction triggered:', {
+                    threshold: this.config.autoCompactThreshold,
+                    currentTokens: totalInputTokens,
+                });
+                const compactResult = await this.compact(messages, 'auto', totalInputTokens);
+                if (compactResult.summaryGenerated) {
+                    // Replace messages with compacted version
+                    messages.length = 0;
+                    messages.push(...compactResult.messages);
+                    logger.debug('[ReActLoop] Auto-compaction completed:', {
+                        preservedRounds: compactResult.preservedRounds,
+                        newMessageCount: messages.length,
+                    });
+                }
+            }
+            // Check if assistant wants to use tools
+            const assistantToolCalls = assistantMessage.message.tool_calls;
+            if (assistantToolCalls && assistantToolCalls.length > 0) {
+                // Execute tools and add results
+                for (const toolCall of assistantToolCalls) {
+                    const result = await this.executeTool(toolCall, availableTools, toolContext);
+                    messages.push(createToolResultMessage(toolCall.id, toolCall.function.name, result.content, result.isError, this.sessionId, generateUUID()));
+                }
+            }
+            else {
+                // No tool calls - agent produced final answer
+                // Trigger Stop hook — allows hooks to request continuation via { continue: true }
+                const shouldContinue = await this.emitStopHook();
+                if (shouldContinue) {
+                    // Hook requested continuation — keep looping
+                    continue;
+                }
+                const textContent = assistantMessage.message.content.find((c) => c.type === 'text');
+                return {
+                    result: textContent?.text ?? '',
+                    messages,
+                    turnCount,
+                    usage: {
+                        input_tokens: totalInputTokens,
+                        output_tokens: totalOutputTokens,
+                    },
+                };
+            }
+        }
+        // Max turns reached
+        return {
+            result: 'Maximum turns reached without completion',
+            messages,
+            turnCount,
+            usage: {
+                input_tokens: totalInputTokens,
+                output_tokens: totalOutputTokens,
+            },
+            isError: true,
+        };
+    }
+    /**
+     * Run the ReAct loop with streaming output
+     * Yields events for assistant messages, tool results, usage stats, and completion
+     * @param userPrompt - The current user message content
+     * @param history - Previous conversation messages (optional)
+     */
+    async *runStream(userPrompt, history = []) {
+        // Trigger SessionStart hook
+        const sessionStartInput = createSessionStartInput(this.sessionId, this.config.cwd ?? process.cwd(), history.length > 0 ? 'resume' : 'startup');
+        await this.hookManager.emit('SessionStart', sessionStartInput, undefined);
+        // Trigger UserPromptSubmit hook
+        const userPromptSubmitInput = createUserPromptSubmitInput(this.sessionId, this.config.cwd ?? process.cwd(), userPrompt);
+        await this.hookManager.emit('UserPromptSubmit', userPromptSubmitInput, undefined);
+        // Check if history already has a system message (metadata)
+        const hasSystemInHistory = history.some((msg) => msg.type === 'system');
+        const messages = [
+            // Add system message metadata if system prompt is configured and not already in history
+            // The actual system prompt content is passed via ChatOptions to the provider
+            ...(this.config.systemPrompt && !hasSystemInHistory
+                ? [
+                    createSystemMessage(this.provider.getModel(), this.provider.constructor.name.toLowerCase().replace('provider', ''), this.config.allowedTools ?? this.toolRegistry.getAll().map((t) => t.name), this.config.cwd ?? process.cwd(), this.sessionId, generateUUID(), {
+                        permissionMode: this.config.permissionMode,
+                    }),
+                ]
+                : []),
+            // Add history messages
+            ...history,
+            // Add current user message
+            createUserMessage(userPrompt, this.sessionId, generateUUID()),
+        ];
+        logger.debug('[ReActLoop] Total messages:', messages.length);
+        logger.debug('[ReActLoop] Messages:', JSON.stringify(messages, null, 2));
+        let turnCount = 0;
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        // Get allowed tools
+        const availableTools = this.config.allowedTools
+            ? this.toolRegistry.getAllowedTools(this.config.allowedTools)
+            : this.toolRegistry.getAll();
+        const toolDefinitions = availableTools.map((tool) => ({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.parameters,
+            },
+        }));
+        const toolContext = {
+            cwd: this.config.cwd,
+            env: this.config.env,
+            abortController: this.config.abortController,
+            provider: this.provider,
+        };
+        while (turnCount < this.config.maxTurns) {
+            // Check for abort
+            if (this.config.abortController?.signal.aborted) {
+                yield {
+                    type: 'done',
+                    result: 'Operation aborted',
+                };
+                // Trigger SessionEnd hook on abort
+                const sessionEndInput = createSessionEndInput(this.sessionId, this.config.cwd ?? process.cwd(), 'abort');
+                await this.hookManager.emit('SessionEnd', sessionEndInput, undefined);
+                return;
+            }
+            turnCount++;
+            // Call LLM
+            let assistantMessage;
+            try {
+                assistantMessage = await this.callLLM(messages, toolDefinitions, (tokens) => {
+                    totalInputTokens += tokens.input;
+                    totalOutputTokens += tokens.output;
+                });
+            }
+            catch (error) {
+                // Handle abort error from provider
+                if (error instanceof Error && error.message === 'Operation aborted') {
+                    yield { type: 'done', result: 'Operation aborted' };
+                    // Trigger SessionEnd hook on abort
+                    const sessionEndInput = createSessionEndInput(this.sessionId, this.config.cwd ?? process.cwd(), 'abort');
+                    await this.hookManager.emit('SessionEnd', sessionEndInput, undefined);
+                    return;
+                }
+                throw error;
+            }
+            messages.push(assistantMessage);
+            yield { type: 'assistant', message: assistantMessage };
+            // Check for auto-compaction after each LLM call
+            if (this.config.autoCompactThreshold !== undefined &&
+                totalInputTokens > this.config.autoCompactThreshold) {
+                logger.debug('[ReActLoop] Auto-compaction triggered in stream:', {
+                    threshold: this.config.autoCompactThreshold,
+                    currentTokens: totalInputTokens,
+                });
+                const compactResult = await this.compact(messages, 'auto', totalInputTokens);
+                if (compactResult.summaryGenerated) {
+                    // Replace messages with compacted version
+                    messages.length = 0;
+                    messages.push(...compactResult.messages);
+                    logger.debug('[ReActLoop] Auto-compaction completed in stream:', {
+                        preservedRounds: compactResult.preservedRounds,
+                        newMessageCount: messages.length,
+                    });
+                }
+            }
+            // Check if assistant wants to use tools
+            const assistantToolCalls = assistantMessage.message.tool_calls;
+            if (assistantToolCalls && assistantToolCalls.length > 0) {
+                // Execute tools and add results
+                for (const toolCall of assistantToolCalls) {
+                    const result = await this.executeTool(toolCall, availableTools, toolContext);
+                    const toolResultMessage = createToolResultMessage(toolCall.id, toolCall.function.name, result.content, result.isError, this.sessionId, generateUUID());
+                    messages.push(toolResultMessage);
+                    yield { type: 'tool_result', message: toolResultMessage };
+                }
+            }
+            else {
+                // No tool calls - agent produced final answer
+                // Trigger Stop hook — allows hooks to request continuation via { continue: true }
+                const shouldContinue = await this.emitStopHook();
+                if (shouldContinue) {
+                    // Hook requested continuation — keep looping
+                    continue;
+                }
+                const textContent = assistantMessage.message.content.find((c) => c.type === 'text');
+                const result = textContent?.text ?? '';
+                yield { type: 'usage', usage: { input_tokens: totalInputTokens, output_tokens: totalOutputTokens } };
+                yield { type: 'done', result };
+                // Trigger SessionEnd hook on successful completion
+                const sessionEndInput = createSessionEndInput(this.sessionId, this.config.cwd ?? process.cwd(), 'completed');
+                await this.hookManager.emit('SessionEnd', sessionEndInput, undefined);
+                return;
+            }
+        }
+        // Max turns reached
+        yield { type: 'usage', usage: { input_tokens: totalInputTokens, output_tokens: totalOutputTokens } };
+        yield { type: 'done', result: 'Maximum turns reached without completion' };
+        // Trigger SessionEnd hook
+        const sessionEndInput = createSessionEndInput(this.sessionId, this.config.cwd ?? process.cwd(), 'max_turns_reached');
+        await this.hookManager.emit('SessionEnd', sessionEndInput, undefined);
+    }
+    /**
+     * Get the hook manager instance
+     * Used for testing and inspection
+     */
+    getHookManager() {
+        return this.hookManager;
+    }
+    /**
+     * Compact conversation history to reduce token usage.
+     * Generates a summary of older messages and preserves recent rounds.
+     *
+     * @param messages - Current conversation messages
+     * @param trigger - What triggered the compaction ('manual' or 'auto')
+     * @param preTokens - Token count before compaction
+     * @returns Compacted messages and metadata
+     */
+    async compact(messages, trigger, preTokens) {
+        const preserveRecentRounds = this.config.preserveRecentRounds ?? 2;
+        // Separate system messages from conversation messages
+        const systemInitMsg = messages.find((m) => m.type === 'system' && 'subtype' in m && m.subtype === 'init');
+        // Get conversation messages (non-system)
+        const conversationMessages = messages.filter((m) => m.type !== 'system' || ('subtype' in m && m.subtype !== 'init'));
+        // Group messages into rounds (user -> assistant -> optional tool results)
+        const rounds = [];
+        let currentRound = [];
+        for (const msg of conversationMessages) {
+            if (msg.type === 'user') {
+                // Start a new round
+                if (currentRound.length > 0) {
+                    rounds.push(currentRound);
+                }
+                currentRound = [msg];
+            }
+            else {
+                // Add to current round (assistant or tool_result)
+                currentRound.push(msg);
+            }
+        }
+        // Don't forget the last round
+        if (currentRound.length > 0) {
+            rounds.push(currentRound);
+        }
+        // Determine which rounds to preserve and which to summarize
+        const totalRounds = rounds.length;
+        const roundsToPreserve = Math.min(preserveRecentRounds, totalRounds);
+        const roundsToSummarize = totalRounds - roundsToPreserve;
+        if (roundsToSummarize <= 0) {
+            // Nothing to compact
+            return {
+                messages,
+                preTokens,
+                trigger,
+                preservedRounds: totalRounds,
+                summaryGenerated: false,
+            };
+        }
+        // Trigger PreCompact hook
+        const preCompactInput = createPreCompactInput(this.sessionId, this.config.cwd ?? process.cwd(), trigger, null // custom_instructions - can be modified by hooks in future
+        );
+        const preCompactResults = await this.hookManager.emit('PreCompact', preCompactInput, undefined);
+        // Check if any hook blocked the compaction
+        for (const result of preCompactResults) {
+            if (result && typeof result === 'object' && 'stopReason' in result) {
+                const syncResult = result;
+                if (syncResult.stopReason) {
+                    logger.debug('[ReActLoop] PreCompact hook blocked compaction:', syncResult.stopReason);
+                    return {
+                        messages,
+                        preTokens,
+                        trigger,
+                        preservedRounds: totalRounds,
+                        summaryGenerated: false,
+                    };
+                }
+            }
+        }
+        // Messages to summarize (older rounds)
+        const messagesToSummarize = rounds.slice(0, roundsToSummarize).flat();
+        // Generate summary
+        const summary = await this.generateSummary(messagesToSummarize);
+        // Create compact boundary message
+        const boundaryMessage = createCompactBoundaryMessage(this.sessionId, generateUUID(), trigger, preTokens);
+        // Create summary message as an assistant message
+        const summaryMessage = createAssistantMessage([{ type: 'text', text: `Summary of previous conversation:\n${summary}` }], this.sessionId, generateUUID());
+        // Messages to preserve (recent rounds)
+        const preservedMessages = rounds.slice(roundsToSummarize).flat();
+        // Build compacted message list
+        const compactedMessages = [
+            ...(systemInitMsg ? [systemInitMsg] : []),
+            boundaryMessage,
+            summaryMessage,
+            ...preservedMessages,
+        ];
+        return {
+            messages: compactedMessages,
+            preTokens,
+            trigger,
+            preservedRounds: roundsToPreserve,
+            summaryGenerated: true,
+        };
+    }
+    /**
+     * Generate a summary of conversation messages using the LLM.
+     */
+    async generateSummary(messages) {
+        const summaryPrompt = `Please summarize the following conversation history, keeping key information:
+1. The user's original request/goal
+2. Major steps completed so far
+3. Important file modifications or code changes
+4. Current pending tasks or unfinished work
+5. Any significant errors and their solutions
+
+Conversation history:
+${JSON.stringify(messages, null, 2)}
+
+Generate a concise but comprehensive summary.`;
+        try {
+            // Use the provider to generate summary
+            const chatOptions = {
+                systemInstruction: 'You are a helpful assistant that summarizes conversations concisely.',
+            };
+            // Create a minimal message list for summary generation
+            const summaryMessages = [
+                createUserMessage(summaryPrompt, this.sessionId, generateUUID()),
+            ];
+            const stream = this.provider.chat(summaryMessages, [], this.config.abortController?.signal, chatOptions);
+            let summary = '';
+            for await (const chunk of stream) {
+                if (chunk.type === 'content' && chunk.delta) {
+                    summary += chunk.delta;
+                }
+            }
+            return summary.trim() || 'No summary available.';
+        }
+        catch (error) {
+            logger.warn('[ReActLoop] Failed to generate summary:', error);
+            return 'Summary generation failed. Continuing with preserved context.';
+        }
+    }
+    /**
+     * Emit the Stop hook and check if any handler requests continuation.
+     * Returns true if the loop should continue (hook returned { continue: true }).
+     */
+    async emitStopHook() {
+        const stopInput = createStopInput(this.sessionId, this.config.cwd ?? process.cwd(), true // stop_hook_active
+        );
+        const results = await this.hookManager.emit('Stop', stopInput, undefined);
+        // Check if any hook result requests continuation
+        for (const result of results) {
+            if (result && typeof result === 'object' && 'continue' in result) {
+                const syncResult = result;
+                if (syncResult.continue === true) {
+                    logger.debug('[ReActLoop] Stop hook requested continuation');
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    async callLLM(messages, tools, onUsage) {
+        // Pass system prompt via ChatOptions, not in messages
+        const chatOptions = {
+            systemInstruction: this.config.systemPrompt,
+        };
+        const stream = this.provider.chat(messages, tools, this.config.abortController?.signal, chatOptions);
+        let content = '';
+        const toolCalls = new Map();
+        let inputTokens = 0;
+        let outputTokens = 0;
+        for await (const chunk of stream) {
+            switch (chunk.type) {
+                case 'content':
+                    if (chunk.delta) {
+                        content += chunk.delta;
+                    }
+                    break;
+                case 'tool_call':
+                    if (chunk.tool_call) {
+                        const existing = toolCalls.get(chunk.tool_call.id);
+                        if (existing) {
+                            existing.function.arguments += chunk.tool_call.arguments;
+                        }
+                        else {
+                            toolCalls.set(chunk.tool_call.id, {
+                                id: chunk.tool_call.id,
+                                type: 'function',
+                                function: {
+                                    name: chunk.tool_call.name,
+                                    arguments: chunk.tool_call.arguments,
+                                },
+                            });
+                        }
+                    }
+                    break;
+                case 'usage':
+                    if (chunk.usage) {
+                        inputTokens = chunk.usage.input_tokens;
+                        outputTokens = chunk.usage.output_tokens;
+                    }
+                    break;
+                case 'error':
+                    if (chunk.error) {
+                        throw new Error(chunk.error);
+                    }
+                    break;
+            }
+        }
+        onUsage({ input: inputTokens, output: outputTokens });
+        const contentBlocks = content
+            ? [{ type: 'text', text: content }]
+            : [];
+        return createAssistantMessage(contentBlocks, this.sessionId, generateUUID(), null, toolCalls.size > 0 ? Array.from(toolCalls.values()) : undefined);
+    }
+    async executeTool(toolCall, availableTools, context) {
+        const tool = availableTools.find((t) => t.name === toolCall.function.name);
+        if (!tool) {
+            return {
+                content: `Error: Tool "${toolCall.function.name}" not found`,
+                isError: true,
+            };
+        }
+        let args;
+        try {
+            args = JSON.parse(toolCall.function.arguments);
+        }
+        catch (error) {
+            return {
+                content: `Error: Invalid JSON arguments - ${error instanceof Error ? error.message : String(error)}`,
+                isError: true,
+            };
+        }
+        const cwd = this.config.cwd ?? process.cwd();
+        // Special handling for AskUserQuestion tool
+        if (toolCall.function.name === 'AskUserQuestion') {
+            // AskUserQuestion requires canUseTool callback
+            if (!this.config.canUseTool) {
+                return {
+                    content: 'Error: AskUserQuestion requires a canUseTool callback to be configured. The tool cannot function without user interaction capability.',
+                    isError: true,
+                };
+            }
+            // If canUseTool exists, it will be handled by the normal permission flow
+            // The canUseTool callback will fill in the answers via updatedInput
+        }
+        // Trigger PreToolUse hook
+        const preToolInput = createPreToolUseInput(this.sessionId, cwd, toolCall.function.name, args);
+        const preToolResults = await this.hookManager.emitForTool('PreToolUse', preToolInput, toolCall.function.name, toolCall.id);
+        // Check if any PreToolUse hook denied the tool
+        const hookDenial = preToolResults.find((r) => r !== null && r !== undefined && typeof r === 'object' && 'hookSpecificOutput' in r &&
+            r.hookSpecificOutput !== undefined &&
+            r.hookSpecificOutput?.hookEventName === 'PreToolUse' &&
+            r.hookSpecificOutput?.permissionDecision === 'deny');
+        if (hookDenial) {
+            const errorMsg = hookDenial.hookSpecificOutput?.permissionDecisionReason || 'Tool denied by PreToolUse hook';
+            // Trigger PermissionRequest hook
+            const permissionRequestInput = createPermissionRequestInput(this.sessionId, cwd, toolCall.function.name, args);
+            await this.hookManager.emit('PermissionRequest', permissionRequestInput, toolCall.id);
+            return {
+                content: `Error: ${errorMsg}`,
+                isError: true,
+            };
+        }
+        // Apply any input modifications from PreToolUse hooks
+        let modifiedInput = args;
+        const inputModification = preToolResults.find((r) => r !== null && r !== undefined && typeof r === 'object' && 'hookSpecificOutput' in r &&
+            r.hookSpecificOutput !== undefined &&
+            r.hookSpecificOutput?.hookEventName === 'PreToolUse' &&
+            r.hookSpecificOutput?.updatedInput !== undefined);
+        if (inputModification?.hookSpecificOutput?.updatedInput) {
+            modifiedInput = inputModification.hookSpecificOutput.updatedInput;
+        }
+        // Check permissions using PermissionManager
+        // For AskUserQuestion, add 60-second timeout
+        let permissionResult;
+        if (toolCall.function.name === 'AskUserQuestion') {
+            const timeoutMs = 60_000;
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('AskUserQuestion timed out after 60 seconds')), timeoutMs));
+            try {
+                permissionResult = await Promise.race([
+                    this.permissionManager.checkPermission(toolCall.function.name, modifiedInput, { signal: this.config.abortController?.signal ?? new AbortController().signal }),
+                    timeoutPromise,
+                ]);
+            }
+            catch (error) {
+                return {
+                    content: `Error: ${error instanceof Error ? error.message : 'AskUserQuestion timed out'}`,
+                    isError: true,
+                };
+            }
+        }
+        else {
+            permissionResult = await this.permissionManager.checkPermission(toolCall.function.name, modifiedInput, { signal: this.config.abortController?.signal ?? new AbortController().signal });
+        }
+        if (!permissionResult.approved) {
+            // Trigger PermissionRequest hook on denial
+            const permissionRequestInput = createPermissionRequestInput(this.sessionId, cwd, toolCall.function.name, modifiedInput);
+            await this.hookManager.emit('PermissionRequest', permissionRequestInput, toolCall.id);
+            return {
+                content: `Error: ${permissionResult.error || 'Permission denied'}`,
+                isError: true,
+            };
+        }
+        // Use modified input from permission check (if any)
+        const finalInput = permissionResult.updatedInput ?? modifiedInput;
+        try {
+            const result = await tool.handler(finalInput, context);
+            // Trigger PostToolUse hook
+            const postToolInput = createPostToolUseInput(this.sessionId, cwd, toolCall.function.name, finalInput, result);
+            await this.hookManager.emitForTool('PostToolUse', postToolInput, toolCall.function.name, toolCall.id);
+            return {
+                content: JSON.stringify(result),
+                isError: false,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            // Trigger PostToolUseFailure hook
+            const postToolFailureInput = createPostToolUseFailureInput(this.sessionId, cwd, toolCall.function.name, finalInput, errorMessage);
+            await this.hookManager.emit('PostToolUseFailure', postToolFailureInput, toolCall.id);
+            return {
+                content: `Error: ${errorMessage}`,
+                isError: true,
+            };
+        }
+    }
+}
+//# sourceMappingURL=react-loop.js.map