shortcutxl 0.2.0

package/dist/config.js

@@ -0,0 +1,288 @@
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
+// =============================================================================
+// Package Detection
+// =============================================================================
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Detect if we're running as a Bun compiled binary.
+ * Bun binaries have import.meta.url containing "$bunfs", "~BUN", or "%7EBUN" (Bun's virtual filesystem path)
+ */
+export const isBunBinary = import.meta.url.includes('$bunfs') ||
+    import.meta.url.includes('~BUN') ||
+    import.meta.url.includes('%7EBUN');
+/** Detect if Bun is the runtime (compiled binary or bun run) */
+const isBunRuntime = !!process.versions.bun;
+function detectInstallMethod() {
+    if (isBunBinary) {
+        return 'bun-binary';
+    }
+    const resolvedPath = `${__dirname}\0${process.execPath || ''}`.toLowerCase();
+    if (resolvedPath.includes('/pnpm/') ||
+        resolvedPath.includes('/.pnpm/') ||
+        resolvedPath.includes('\\pnpm\\')) {
+        return 'pnpm';
+    }
+    if (resolvedPath.includes('/yarn/') ||
+        resolvedPath.includes('/.yarn/') ||
+        resolvedPath.includes('\\yarn\\')) {
+        return 'yarn';
+    }
+    if (isBunRuntime) {
+        return 'bun';
+    }
+    if (resolvedPath.includes('/npm/') ||
+        resolvedPath.includes('/node_modules/') ||
+        resolvedPath.includes('\\npm\\')) {
+        return 'npm';
+    }
+    return 'unknown';
+}
+export function getUpdateInstruction(packageName) {
+    const method = detectInstallMethod();
+    switch (method) {
+        case 'bun-binary':
+            return `Download from: ${RELEASES_URL}`;
+        case 'pnpm':
+            return `Run: pnpm install -g ${packageName}`;
+        case 'yarn':
+            return `Run: yarn global add ${packageName}`;
+        case 'bun':
+            return `Run: bun install -g ${packageName}`;
+        case 'npm':
+            return `Run: npm install -g ${packageName}`;
+        default:
+            return `Run: npm install -g ${packageName}`;
+    }
+}
+/**
+ * Get the shell command to auto-update the agent package.
+ * Returns undefined for bun-binary (requires manual download).
+ */
+export function getUpdateCommand(packageName) {
+    const method = detectInstallMethod();
+    switch (method) {
+        case 'bun-binary':
+            return undefined;
+        case 'pnpm':
+            return `pnpm install -g ${packageName}`;
+        case 'yarn':
+            return `yarn global add ${packageName}`;
+        case 'bun':
+            return `bun install -g ${packageName}`;
+        case 'npm':
+        default:
+            return `npm install -g ${packageName}`;
+    }
+}
+// =============================================================================
+// Package Asset Paths (shipped with executable)
+// =============================================================================
+/**
+ * Get the base directory for resolving package assets (themes, package.json, README.md, CHANGELOG.md).
+ * - For Bun binary: returns the directory containing the executable
+ * - For Node.js (dist/): returns __dirname (the dist/ directory)
+ * - For tsx (src/): returns parent directory (the package root)
+ */
+export function getPackageDir() {
+    // Allow override via environment variable (useful for Nix/Guix where store paths tokenize poorly)
+    // SHORTCUT PATCH: renamed from PI_PACKAGE_DIR
+    const envDir = process.env.SHORTCUT_PACKAGE_DIR;
+    if (envDir) {
+        if (envDir === '~')
+            return homedir();
+        if (envDir.startsWith('~/'))
+            return homedir() + envDir.slice(1);
+        return envDir;
+    }
+    if (isBunBinary) {
+        // Bun binary: process.execPath points to the compiled executable
+        return dirname(process.execPath);
+    }
+    // Node.js: walk up from __dirname until we find package.json
+    let dir = __dirname;
+    while (dir !== dirname(dir)) {
+        if (existsSync(join(dir, 'package.json'))) {
+            return dir;
+        }
+        dir = dirname(dir);
+    }
+    // Fallback (shouldn't happen)
+    return __dirname;
+}
+/**
+ * Get path to built-in default skills directory (shipped with package).
+ * Located at skills/ in the package root.
+ */
+export function getBundledSkillsDir() {
+    return join(getPackageDir(), 'skills');
+}
+/**
+ * Get path to built-in themes directory (shipped with package)
+ * - For Bun binary: theme/ next to executable
+ * - For Node.js (dist/): dist/modes/interactive/theme/
+ * - For tsx (src/): src/modes/interactive/theme/
+ */
+export function getThemesDir() {
+    if (isBunBinary) {
+        return join(dirname(process.execPath), 'theme');
+    }
+    // Theme is in modes/interactive/theme/ relative to src/ or dist/
+    const packageDir = getPackageDir();
+    const srcOrDist = existsSync(join(packageDir, 'src')) ? 'src' : 'dist';
+    return join(packageDir, srcOrDist, 'modes', 'interactive', 'theme');
+}
+/**
+ * Get path to HTML export template directory (shipped with package)
+ * - For Bun binary: export-html/ next to executable
+ * - For Node.js (dist/): dist/core/export-html/
+ * - For tsx (src/): src/core/export-html/
+ */
+export function getExportTemplateDir() {
+    if (isBunBinary) {
+        return join(dirname(process.execPath), 'export-html');
+    }
+    const packageDir = getPackageDir();
+    const srcOrDist = existsSync(join(packageDir, 'src')) ? 'src' : 'dist';
+    return join(packageDir, srcOrDist, 'core', 'export-html');
+}
+/** Get path to package.json */
+function getPackageJsonPath() {
+    return join(getPackageDir(), 'package.json');
+}
+/** Get path to README.md */
+export function getReadmePath() {
+    return resolve(join(getPackageDir(), 'README.md'));
+}
+/** Get path to docs directory */
+export function getDocsPath() {
+    return resolve(join(getPackageDir(), 'docs'));
+}
+/** Get path to examples directory */
+export function getExamplesPath() {
+    return resolve(join(getPackageDir(), 'examples'));
+}
+/** Get path to CHANGELOG.md */
+export function getChangelogPath() {
+    return resolve(join(getPackageDir(), 'CHANGELOG.md'));
+}
+// =============================================================================
+// App Config (from package.json shortcutConfig)
+// =============================================================================
+const pkg = JSON.parse(readFileSync(getPackageJsonPath(), 'utf-8'));
+export const APP_NAME = pkg.shortcutConfig?.name || 'shortcut';
+export const CONFIG_DIR_NAME = pkg.shortcutConfig?.configDir || '.shortcut';
+export const VERSION = pkg.version;
+export const NPM_PACKAGE_NAME = pkg.name || 'shortcutxl';
+// e.g., SHORTCUT_CODING_AGENT_DIR
+export const ENV_AGENT_DIR = `${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`;
+// -- Package & update URLs -------------------------------------------------
+/** npm registry URL for version checks. */
+export const NPM_REGISTRY_URL = `https://registry.npmjs.org/${NPM_PACKAGE_NAME}/latest`;
+/** GitHub repo base URL (for changelog, releases). */
+const GITHUB_REPO_URL = 'https://github.com/lyfegame/shortcut';
+/** Releases URL shown for bun-binary update instructions. */
+const RELEASES_URL = `${GITHUB_REPO_URL}/releases/latest`;
+// =============================================================================
+// Own Binary Resolution (for spawning subagent child processes)
+// =============================================================================
+/**
+ * Resolve how to spawn another instance of this agent as a child process.
+ *
+ * Returns [command, ...prefixArgs] such that:
+ *   spawn(command, [...prefixArgs, '--mode', 'json', ...])
+ * produces a child running the same agent binary with all custom tools.
+ *
+ * Resolution order:
+ * 1. Bun binary → [process.execPath]
+ * 2. Global install (bin in PATH) → ['shortcut']
+ * 3. Dev mode (tsx) → ['tsx', '/abs/path/to/src/cli.ts']
+ * 4. Built (node) → ['node', '/abs/path/to/dist/cli.js']
+ */
+export function resolveOwnBinary() {
+    if (isBunBinary) {
+        return [process.execPath];
+    }
+    // process.argv[1] is the script being executed (cli.ts or cli.js)
+    const script = process.argv[1];
+    if (script) {
+        const resolvedScript = resolve(script);
+        // Dev mode: running via tsx (e.g. `tsx src/cli.ts`)
+        if (resolvedScript.endsWith('.ts')) {
+            return ['tsx', resolvedScript];
+        }
+        // Built mode: running via node (e.g. `node dist/cli.js`)
+        // Also covers global install where the bin shim runs `node dist/cli.js`
+        if (resolvedScript.endsWith('.js')) {
+            return ['node', resolvedScript];
+        }
+    }
+    // Fallback: assume the bin name is in PATH (global npm/pnpm install)
+    return [APP_NAME];
+}
+// =============================================================================
+// User Config Paths (~/.shortcut/agent/*)
+// =============================================================================
+/** Get the agent config directory (e.g., ~/.shortcut/agent/) */
+export function getAgentDir() {
+    const envDir = process.env[ENV_AGENT_DIR];
+    if (envDir) {
+        // Expand tilde to home directory
+        if (envDir === '~')
+            return homedir();
+        if (envDir.startsWith('~/'))
+            return homedir() + envDir.slice(1);
+        return envDir;
+    }
+    return join(homedir(), CONFIG_DIR_NAME, 'agent');
+}
+/** Get path to user's custom themes directory */
+export function getCustomThemesDir() {
+    return join(getAgentDir(), 'themes');
+}
+/** Get path to models.json */
+export function getModelsPath() {
+    return join(getAgentDir(), 'models.json');
+}
+/** Get path to auth.json */
+export function getAuthPath() {
+    return join(getAgentDir(), 'auth.json');
+}
+/** Get path to settings.json */
+export function getSettingsPath() {
+    return join(getAgentDir(), 'settings.json');
+}
+/** Get path to managed binaries directory (fd, rg) */
+export function getBinDir() {
+    return join(getAgentDir(), 'bin');
+}
+/** Get path to prompt templates directory */
+export function getPromptsDir() {
+    return join(getAgentDir(), 'prompts');
+}
+/** Get path to sessions directory */
+export function getSessionsDir() {
+    return join(getAgentDir(), 'sessions');
+}
+/** Get path to debug log file */
+export function getDebugLogPath() {
+    return join(getAgentDir(), `${APP_NAME}-debug.log`);
+}
+/** Get path to installed marker file */
+export function getInstalledMarkerPath() {
+    return join(getAgentDir(), '.installed');
+}
+/** Check if ShortcutXL installation has been completed (marker file exists). */
+export function isInstalled() {
+    return existsSync(getInstalledMarkerPath());
+}
+/** Enable dev-only features (e.g. /export, verbose tool-download messages). */
+export const DEV_MODE = process.env.SHORTCUT_DEV_MODE === '1';
+/** Get path to ShortcutXL.xll (stable user-local copy at ~/.shortcut/agent/xll/). */
+export function getXllPath() {
+    return join(getAgentDir(), "xll", "ShortcutXL.xll");
+}
+//# sourceMappingURL=config.js.map

package/dist/core/abort.js

@@ -0,0 +1,15 @@
+/**
+ * Standardized abort/cancellation messages.
+ *
+ * Two audiences:
+ * - The **agent** (LLM) sees ABORT_AGENT_MESSAGE in tool results so it
+ *   understands the user interrupted and can adjust.
+ * - The **user** sees ABORT_UI_MESSAGE rendered in the TUI.
+ */
+/** Sent back to the LLM as the tool result text when a tool is interrupted. */
+export const ABORT_AGENT_MESSAGE = 'User interrupted the operation.';
+/** Shown to the user in the interactive UI when an operation is cancelled. */
+export const ABORT_UI_LABEL = 'Interrupted \u00b7 What should Shortcut do instead?';
+/** Short form for inline status indicators, e.g. "(interrupted)". */
+export const ABORT_UI_LABEL_INLINE = '(interrupted)';
+//# sourceMappingURL=abort.js.map

package/dist/core/agent-loop.js

@@ -0,0 +1,352 @@
+/**
+ * Vendored agent loop from @mariozechner/pi-agent-core.
+ *
+ * SHORTCUT PATCH: executeToolCalls uses Promise.all for parallel execution
+ * instead of upstream's sequential for-loop. Steering is checked once after
+ * all tools complete, not between each tool.
+ */
+import { EventStream, streamSimple, validateToolArguments } from '@mariozechner/pi-ai';
+import { ABORT_AGENT_MESSAGE } from './abort.js';
+import { DEFAULT_MAX_CHARS, ERROR_MAX_CHARS_LLM, truncateOutput } from './tools/truncate.js';
+/** Yield to the event loop every N stream events to prevent microtask starvation. */
+const STREAM_YIELD_INTERVAL = 5;
+/**
+ * Start an agent loop with a new prompt message.
+ * The prompt is added to the context and events are emitted for it.
+ */
+export function agentLoop(prompts, context, config, signal, streamFn) {
+    const stream = createAgentStream();
+    (async () => {
+        const newMessages = [...prompts];
+        const currentContext = {
+            ...context,
+            messages: [...context.messages, ...prompts]
+        };
+        stream.push({ type: 'agent_start' });
+        stream.push({ type: 'turn_start' });
+        for (const prompt of prompts) {
+            stream.push({ type: 'message_start', message: prompt });
+            stream.push({ type: 'message_end', message: prompt });
+        }
+        await runLoop(currentContext, newMessages, config, signal, stream, streamFn);
+    })();
+    return stream;
+}
+/**
+ * Continue an agent loop from the current context without adding a new message.
+ * Used for retries - context already has user message or tool results.
+ *
+ * **Important:** The last message in context must convert to a `user` or `toolResult` message
+ * via `convertToLlm`. If it doesn't, the LLM provider will reject the request.
+ * This cannot be validated here since `convertToLlm` is only called once per turn.
+ */
+export function agentLoopContinue(context, config, signal, streamFn) {
+    if (context.messages.length === 0) {
+        throw new Error('Cannot continue: no messages in context');
+    }
+    if (context.messages[context.messages.length - 1].role === 'assistant') {
+        throw new Error('Cannot continue from message role: assistant');
+    }
+    const stream = createAgentStream();
+    (async () => {
+        const newMessages = [];
+        const currentContext = { ...context };
+        stream.push({ type: 'agent_start' });
+        stream.push({ type: 'turn_start' });
+        await runLoop(currentContext, newMessages, config, signal, stream, streamFn);
+    })();
+    return stream;
+}
+function createAgentStream() {
+    return new EventStream((event) => event.type === 'agent_end', (event) => (event.type === 'agent_end' ? event.messages : []));
+}
+/**
+ * Main loop logic shared by agentLoop and agentLoopContinue.
+ */
+async function runLoop(currentContext, newMessages, config, signal, stream, streamFn) {
+    let firstTurn = true;
+    // Check for steering messages at start (user may have typed while waiting)
+    let pendingMessages = (await config.getSteeringMessages?.()) || [];
+    // Outer loop: continues when queued follow-up messages arrive after agent would stop
+    while (true) {
+        let hasMoreToolCalls = true;
+        let steeringAfterTools = null;
+        // Inner loop: process tool calls and steering messages
+        while (hasMoreToolCalls || pendingMessages.length > 0) {
+            if (!firstTurn) {
+                stream.push({ type: 'turn_start' });
+            }
+            else {
+                firstTurn = false;
+            }
+            // Process pending messages (inject before next assistant response)
+            if (pendingMessages.length > 0) {
+                for (const message of pendingMessages) {
+                    stream.push({ type: 'message_start', message });
+                    stream.push({ type: 'message_end', message });
+                    currentContext.messages.push(message);
+                    newMessages.push(message);
+                }
+                pendingMessages = [];
+            }
+            // SHORTCUT PATCH: switch to invokeAssistantResponse for non-streaming.
+            const message = await streamAssistantResponse(currentContext, config, signal, stream, streamFn);
+            newMessages.push(message);
+            if (message.stopReason === 'error' || message.stopReason === 'aborted') {
+                // Ensure the assistant message is never blank — inject error text so
+                // retries give the LLM useful context instead of an empty message.
+                // Skip for aborts: user-initiated cancellations are handled by the UI
+                // abort label and don't need "[Request failed: ...]" injected.
+                if (message.stopReason !== 'aborted' && message.content.length === 0 && message.errorMessage) {
+                    message.content.push({
+                        type: 'text',
+                        text: `[Request failed: ${message.errorMessage.slice(0, ERROR_MAX_CHARS_LLM)}]`
+                    });
+                }
+                // If the errored/aborted response contains tool calls, synthesize
+                // error tool_results so the tool_use→tool_result contract is never
+                // violated. Without this, the orphaned tool_use blocks make every
+                // subsequent API call fail with a 400.
+                const orphanedToolCalls = message.content.filter((c) => c.type === 'toolCall');
+                const errorToolResults = orphanedToolCalls.map((tc) => ({
+                    role: 'toolResult',
+                    toolCallId: tc.id,
+                    toolName: tc.name,
+                    content: [
+                        {
+                            type: 'text',
+                            text: message.stopReason === 'aborted'
+                                ? ABORT_AGENT_MESSAGE
+                                : `Tool call failed: ${message.errorMessage || 'unknown error'}`
+                        }
+                    ],
+                    isError: true,
+                    timestamp: Date.now()
+                }));
+                for (const result of errorToolResults) {
+                    stream.push({ type: 'message_start', message: result });
+                    stream.push({ type: 'message_end', message: result });
+                    newMessages.push(result);
+                }
+                stream.push({ type: 'turn_end', message, toolResults: errorToolResults });
+                stream.push({ type: 'agent_end', messages: newMessages });
+                stream.end(newMessages);
+                return;
+            }
+            // Check for tool calls
+            const toolCalls = message.content.filter((c) => c.type === 'toolCall');
+            hasMoreToolCalls = toolCalls.length > 0;
+            const toolResults = [];
+            if (hasMoreToolCalls) {
+                const toolExecution = await executeToolCalls(currentContext.tools, message, signal, stream, config.getSteeringMessages);
+                toolResults.push(...toolExecution.toolResults);
+                steeringAfterTools = toolExecution.steeringMessages ?? null;
+                for (const result of toolResults) {
+                    currentContext.messages.push(result);
+                    newMessages.push(result);
+                }
+            }
+            stream.push({ type: 'turn_end', message, toolResults });
+            // Get steering messages after turn completes
+            if (steeringAfterTools && steeringAfterTools.length > 0) {
+                pendingMessages = steeringAfterTools;
+                steeringAfterTools = null;
+            }
+            else {
+                pendingMessages = (await config.getSteeringMessages?.()) || [];
+            }
+        }
+        // Agent would stop here. Check for follow-up messages.
+        const followUpMessages = (await config.getFollowUpMessages?.()) || [];
+        if (followUpMessages.length > 0) {
+            // Set as pending so inner loop processes them
+            pendingMessages = followUpMessages;
+            continue;
+        }
+        // No more messages, exit
+        break;
+    }
+    stream.push({ type: 'agent_end', messages: newMessages });
+    stream.end(newMessages);
+}
+/**
+ * Build the LLM context and resolve the API key.
+ * Shared setup for both streaming and invoke paths.
+ */
+async function prepareLlmCall(context, config, signal, streamFn) {
+    // Apply context transform if configured (AgentMessage[] → AgentMessage[])
+    let messages = context.messages;
+    if (config.transformContext) {
+        messages = await config.transformContext(messages, signal);
+    }
+    // Convert to LLM-compatible messages (AgentMessage[] → Message[])
+    const llmMessages = await config.convertToLlm(messages);
+    const llmContext = {
+        systemPrompt: context.systemPrompt,
+        messages: llmMessages,
+        tools: context.tools
+    };
+    const streamFunction = streamFn || streamSimple;
+    const resolvedApiKey = (config.getApiKey ? await config.getApiKey(config.model.provider) : undefined) || config.apiKey;
+    return { llmContext, streamFunction, resolvedApiKey };
+}
+/**
+ * Get an assistant response via invoke (non-streaming).
+ * Waits for the complete response, then emits message_start/message_end.
+ * Currently unused — swap with streamAssistantResponse in runLoop to enable.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+async function invokeAssistantResponse(context, config, signal, stream, streamFn) {
+    const { llmContext, streamFunction, resolvedApiKey } = await prepareLlmCall(context, config, signal, streamFn);
+    const response = await streamFunction(config.model, llmContext, {
+        ...config,
+        apiKey: resolvedApiKey,
+        signal
+    });
+    const finalMessage = await response.result();
+    context.messages.push(finalMessage);
+    stream.push({ type: 'message_start', message: { ...finalMessage } });
+    stream.push({ type: 'message_end', message: finalMessage });
+    return finalMessage;
+}
+/**
+ * Get an assistant response via streaming.
+ * Emits message_start, message_update deltas, then message_end.
+ */
+async function streamAssistantResponse(context, config, signal, stream, streamFn) {
+    const { llmContext, streamFunction, resolvedApiKey } = await prepareLlmCall(context, config, signal, streamFn);
+    const response = await streamFunction(config.model, llmContext, {
+        ...config,
+        apiKey: resolvedApiKey,
+        signal
+    });
+    let partialMessage = null;
+    let addedPartial = false;
+    // SHORTCUT PATCH: yield to the event loop every N events to prevent
+    // microtask starvation that blocks TUI rendering on slower machines.
+    let eventCount = 0;
+    for await (const event of response) {
+        if (++eventCount % STREAM_YIELD_INTERVAL === 0) {
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        switch (event.type) {
+            case 'start':
+                partialMessage = event.partial;
+                context.messages.push(partialMessage);
+                addedPartial = true;
+                stream.push({ type: 'message_start', message: { ...partialMessage } });
+                break;
+            case 'text_start':
+            case 'text_delta':
+            case 'text_end':
+            case 'thinking_start':
+            case 'thinking_delta':
+            case 'thinking_end':
+            case 'toolcall_start':
+            case 'toolcall_delta':
+            case 'toolcall_end':
+                if (partialMessage) {
+                    partialMessage = event.partial;
+                    context.messages[context.messages.length - 1] = partialMessage;
+                    stream.push({
+                        type: 'message_update',
+                        assistantMessageEvent: event,
+                        message: { ...partialMessage }
+                    });
+                }
+                break;
+            case 'done':
+            case 'error': {
+                const finalMessage = await response.result();
+                if (addedPartial) {
+                    context.messages[context.messages.length - 1] = finalMessage;
+                }
+                else {
+                    context.messages.push(finalMessage);
+                }
+                if (!addedPartial) {
+                    stream.push({ type: 'message_start', message: { ...finalMessage } });
+                }
+                stream.push({ type: 'message_end', message: finalMessage });
+                return finalMessage;
+            }
+        }
+    }
+    return await response.result();
+}
+// SHORTCUT PATCH: parallel tool execution via Promise.all (upstream uses sequential for-loop).
+// All tool calls run concurrently. Steering is checked once after all tools complete.
+async function executeToolCalls(tools, assistantMessage, signal, stream, getSteeringMessages) {
+    const toolCalls = assistantMessage.content.filter((c) => c.type === 'toolCall');
+    const results = await Promise.all(toolCalls.map(async (toolCall) => {
+        const tool = tools?.find((t) => t.name === toolCall.name);
+        stream.push({
+            type: 'tool_execution_start',
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            args: toolCall.arguments
+        });
+        let result;
+        let isError = false;
+        try {
+            if (!tool)
+                throw new Error(`Tool ${toolCall.name} not found`);
+            const validatedArgs = validateToolArguments(tool, toolCall);
+            result = await tool.execute(toolCall.id, validatedArgs, signal, (partialResult) => {
+                stream.push({
+                    type: 'tool_execution_update',
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.name,
+                    args: toolCall.arguments,
+                    partialResult
+                });
+            });
+        }
+        catch (e) {
+            result = {
+                content: [{ type: 'text', text: e instanceof Error ? e.message : String(e) }],
+                details: {}
+            };
+            isError = true;
+        }
+        // SHORTCUT PATCH: central truncation safety net — ensures no oversized tool
+        // result reaches the LLM or trace logs, even if a tool forgets to truncate.
+        // Errors get a tighter limit (500 chars) since error bodies are rarely useful.
+        const maxChars = isError ? ERROR_MAX_CHARS_LLM : DEFAULT_MAX_CHARS;
+        result = {
+            ...result,
+            content: result.content.map((block) => {
+                if (block.type === 'text' && block.text.length > maxChars) {
+                    return { ...block, text: truncateOutput(block.text, maxChars) };
+                }
+                return block;
+            })
+        };
+        stream.push({
+            type: 'tool_execution_end',
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            result,
+            isError
+        });
+        const toolResultMessage = {
+            role: 'toolResult',
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            content: result.content,
+            details: result.details,
+            isError,
+            timestamp: Date.now()
+        };
+        stream.push({ type: 'message_start', message: toolResultMessage });
+        stream.push({ type: 'message_end', message: toolResultMessage });
+        return toolResultMessage;
+    }));
+    // Check steering once after all tools complete
+    const steeringMessages = getSteeringMessages ? await getSteeringMessages() : undefined;
+    return {
+        toolResults: results,
+        steeringMessages: steeringMessages?.length ? steeringMessages : undefined
+    };
+}
+//# sourceMappingURL=agent-loop.js.map