protoagent 0.1.13 → 0.1.15

package/dist/components/ApprovalPrompt.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { Select } from '@inkjs/ui';
+import { LeftBar } from './LeftBar.js';
+/**
+ * Interactive approval prompt rendered inline.
+ */
+export const ApprovalPrompt = ({ request, onRespond }) => {
+    const sessionApprovalLabel = request.sessionScopeKey
+        ? 'Approve this operation for session'
+        : `Approve all "${request.type}" for session`;
+    const items = [
+        { label: 'Approve once', value: 'approve_once' },
+        { label: sessionApprovalLabel, value: 'approve_session' },
+        { label: 'Reject', value: 'reject' },
+    ];
+    return (_jsxs(LeftBar, { color: "green", marginTop: 1, marginBottom: 1, children: [_jsx(Text, { color: "green", bold: true, children: "Approval Required" }), _jsx(Text, { children: request.description }), request.detail && (_jsx(Text, { dimColor: true, children: request.detail.length > 200 ? request.detail.slice(0, 200) + '...' : request.detail })), _jsx(Box, { marginTop: 1, children: _jsx(Select, { options: items.map((item) => ({ value: item.value, label: item.label })), onChange: (value) => onRespond(value) }) })] }));
+};

package/dist/components/CommandFilter.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+// ─── Available slash commands ───
+export const SLASH_COMMANDS = [
+    { name: '/help', description: 'Show all available commands' },
+    { name: '/quit', description: 'Exit ProtoAgent' },
+    { name: '/exit', description: 'Alias for /quit' },
+];
+/**
+ * Shows filtered slash commands when user types /.
+ */
+export const CommandFilter = ({ inputText }) => {
+    if (!inputText.startsWith('/'))
+        return null;
+    const filtered = SLASH_COMMANDS.filter((cmd) => cmd.name.toLowerCase().startsWith(inputText.toLowerCase()));
+    if (filtered.length === 0)
+        return null;
+    return (_jsx(Box, { flexDirection: "column", marginBottom: 1, children: filtered.map((cmd) => (_jsxs(Text, { dimColor: true, children: [_jsx(Text, { color: "green", children: cmd.name }), " \u2014 ", cmd.description] }, cmd.name))) }));
+};

package/dist/components/InlineSetup.js

@@ -0,0 +1,33 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box } from 'ink';
+import { writeConfig, writeInitConfig, TargetSelection, ModelSelection, ApiKeyInput, } from '../config.js';
+/**
+ * Inline setup wizard — shown when no config exists.
+ */
+export const InlineSetup = ({ onComplete }) => {
+    const [setupStep, setSetupStep] = useState('target');
+    const [target, setTarget] = useState('project');
+    const [selectedProviderId, setSelectedProviderId] = useState('');
+    const [selectedModelId, setSelectedModelId] = useState('');
+    const handleModelSelect = (providerId, modelId) => {
+        setSelectedProviderId(providerId);
+        setSelectedModelId(modelId);
+        setSetupStep('api_key');
+    };
+    const handleConfigComplete = (config) => {
+        writeInitConfig(target);
+        writeConfig(config, target);
+        onComplete(config);
+    };
+    if (setupStep === 'target') {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(TargetSelection, { title: "First-time setup", subtitle: "Create a ProtoAgent runtime config:", onSelect: (value) => {
+                    setTarget(value);
+                    setSetupStep('provider');
+                } }) }));
+    }
+    if (setupStep === 'provider') {
+        return (_jsx(Box, { marginTop: 1, children: _jsx(ModelSelection, { setSelectedProviderId: setSelectedProviderId, setSelectedModelId: setSelectedModelId, onSelect: handleModelSelect, title: "First-time setup" }) }));
+    }
+    return (_jsx(Box, { marginTop: 1, children: _jsx(ApiKeyInput, { selectedProviderId: selectedProviderId, selectedModelId: selectedModelId, target: target, title: "First-time setup", showProviderHeaders: false, onComplete: handleConfigComplete }) }));
+};

package/dist/components/UsageDisplay.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+/**
+ * Cost/usage display in the status bar.
+ */
+export const UsageDisplay = ({ usage, totalCost }) => {
+    if (!usage && totalCost === 0)
+        return null;
+    return (_jsxs(Box, { marginTop: 1, children: [usage && (_jsxs(Box, { children: [_jsxs(Box, { backgroundColor: "#064e3b", paddingX: 1, children: [_jsx(Text, { color: "white", children: "tokens: " }), _jsxs(Text, { color: "white", bold: true, children: [usage.inputTokens, "\u2193 ", usage.outputTokens, "\u2191"] })] }), _jsxs(Box, { backgroundColor: "#065f46", paddingX: 1, children: [_jsx(Text, { color: "white", children: "ctx: " }), _jsxs(Text, { color: "white", bold: true, children: [usage.contextPercent.toFixed(0), "%"] })] })] })), totalCost > 0 && (_jsxs(Box, { backgroundColor: "#064e3b", paddingX: 1, children: [_jsx(Text, { color: "black", children: "cost: " }), _jsxs(Text, { color: "black", bold: true, children: ["$", totalCost.toFixed(4)] })] }))] }));
+};

package/dist/config.js

@@ -6,7 +6,7 @@ import { useState } from 'react';
 import { Box, Text } from 'ink';
 import { Select, TextInput, PasswordInput } from '@inkjs/ui';
 import { parse } from 'jsonc-parser';
-import { getActiveRuntimeConfigPath } from './runtime-config.js';
+import { getActiveRuntimeConfigPath, RuntimeConfigFileSchema } from './runtime-config.js';
 import { getAllProviders, getProvider } from './providers.js';
 const CONFIG_DIR_MODE = 0o700;
 const CONFIG_FILE_MODE = 0o600;
@@ -76,10 +76,10 @@ export const getProjectRuntimeConfigDirectory = (cwd = process.cwd()) => {
 export const getProjectRuntimeConfigPath = (cwd = process.cwd()) => {
     return path.join(getProjectRuntimeConfigDirectory(cwd), 'protoagent.jsonc');
 };
-export const getInitConfigPath = (target, cwd = process.cwd()) => {
+export const getRuntimeConfigPath = (target, cwd = process.cwd()) => {
     return target === 'project' ? getProjectRuntimeConfigPath(cwd) : getUserRuntimeConfigPath();
 };
-const RUNTIME_CONFIG_TEMPLATE = `{
+export const RUNTIME_CONFIG_TEMPLATE = `{
   // Add project or user-wide ProtoAgent runtime config here.
   // Example uses:
   // - choose the active provider/model by making it the first provider
@@ -151,13 +151,22 @@ function readRuntimeConfigFileSync(configPath) {
         if (errors.length > 0 || !isPlainObject(parsed)) {
             return null;
         }
-        return parsed;
+        // Validate against zod schema
+        const result = RuntimeConfigFileSchema.safeParse(parsed);
+        if (!result.success) {
+            console.error('Invalid runtime config format:', result.error.issues.map(i => `${i.path.join('.')}: ${i.message}`).join(', '));
+            return null;
+        }
+        return result.data;
     }
     catch (error) {
         console.error('Error reading runtime config file:', error);
         return null;
     }
 }
+// Returns the first provider with a valid model from the runtime config.
+// The active provider/model is determined by order: first provider in the
+// config with at least one model, and the first model under that provider.
 function getConfiguredProviderAndModel(runtimeConfig) {
     for (const [providerId, providerConfig] of Object.entries(runtimeConfig.providers || {})) {
         const modelId = Object.keys(providerConfig.models || {})[0];
@@ -179,32 +188,36 @@ function writeRuntimeConfigFile(configPath, runtimeConfig) {
     writeFileSync(configPath, `${JSON.stringify(runtimeConfig, null, 2)}\n`, { encoding: 'utf8', mode: CONFIG_FILE_MODE });
     hardenPermissions(configPath, CONFIG_FILE_MODE);
 }
-function upsertSelectedConfig(runtimeConfig, config) {
-    const existingProviders = runtimeConfig.providers || {};
-    const currentProvider = existingProviders[config.provider] || {};
+// Merges a new provider/model configuration into the existing runtime config.
+// Used by writeConfig() to add/update a provider without losing existing data.
+// - newConfig: the provider/model to add (from user running 'configure' command)
+// - existingRuntimeConfig: the current runtime config file content (may be empty)
+function upsertSelectedConfig(existingRuntimeConfig, newConfig) {
+    const existingProviders = existingRuntimeConfig.providers || {};
+    const currentProvider = existingProviders[newConfig.provider] || {};
     const currentModels = currentProvider.models || {};
-    const selectedModelConfig = currentModels[config.model] || {};
+    const selectedModelConfig = currentModels[newConfig.model] || {};
     const nextProvider = {
         ...currentProvider,
-        ...(config.apiKey?.trim() ? { apiKey: config.apiKey.trim() } : {}),
+        ...(newConfig.apiKey?.trim() ? { apiKey: newConfig.apiKey.trim() } : {}),
         models: Object.fromEntries([
-            [config.model, selectedModelConfig],
-            ...Object.entries(currentModels).filter(([modelId]) => modelId !== config.model),
+            [newConfig.model, selectedModelConfig],
+            ...Object.entries(currentModels).filter(([modelId]) => modelId !== newConfig.model),
         ]),
     };
-    if (!config.apiKey?.trim()) {
+    if (!newConfig.apiKey?.trim()) {
         delete nextProvider.apiKey;
     }
     return {
-        ...runtimeConfig,
+        ...existingRuntimeConfig,
         providers: Object.fromEntries([
-            [config.provider, nextProvider],
-            ...Object.entries(existingProviders).filter(([providerId]) => providerId !== config.provider),
+            [newConfig.provider, nextProvider],
+            ...Object.entries(existingProviders).filter(([providerId]) => providerId !== newConfig.provider),
         ]),
     };
 }
 export function writeInitConfig(target, cwd = process.cwd(), options = {}) {
-    const configPath = getInitConfigPath(target, cwd);
+    const configPath = getRuntimeConfigPath(target, cwd);
     const alreadyExists = existsSync(configPath);
     if (alreadyExists) {
         if (!options.overwrite) {
@@ -218,8 +231,13 @@ export function writeInitConfig(target, cwd = process.cwd(), options = {}) {
     hardenPermissions(configPath, CONFIG_FILE_MODE);
     return { path: configPath, status: alreadyExists ? 'overwritten' : 'created' };
 }
+// Reads the provider/model config from a runtime config file.
+// - 'project': read from <cwd>/.protoagent/protoagent.jsonc
+// - 'user': read from ~/.config/protoagent/protoagent.jsonc
+// - 'active' (default): check project config first, fall back to user config
+//   This is what the agent uses at runtime to determine which provider/model to use.
 export const readConfig = (target = 'active', cwd = process.cwd()) => {
-    const configPath = target === 'active' ? getActiveRuntimeConfigPath() : getInitConfigPath(target, cwd);
+    const configPath = target === 'active' ? getActiveRuntimeConfigPath() : getRuntimeConfigPath(target, cwd);
     if (!configPath) {
         return null;
     }
@@ -229,22 +247,14 @@ export const readConfig = (target = 'active', cwd = process.cwd()) => {
     }
     return getConfiguredProviderAndModel(runtimeConfig);
 };
-export function getDefaultConfigTarget(cwd = process.cwd()) {
-    const activeConfigPath = getActiveRuntimeConfigPath();
-    if (activeConfigPath === getProjectRuntimeConfigPath(cwd)) {
-        return 'project';
-    }
-    return 'user';
-}
 export const writeConfig = (config, target = 'user', cwd = process.cwd()) => {
-    const configPath = getInitConfigPath(target, cwd);
+    const configPath = getRuntimeConfigPath(target, cwd);
     const runtimeConfig = readRuntimeConfigFileSync(configPath) || { providers: {}, mcp: { servers: {} } };
     const nextRuntimeConfig = upsertSelectedConfig(runtimeConfig, config);
     writeRuntimeConfigFile(configPath, nextRuntimeConfig);
     return configPath;
 };
 export const ResetPrompt = ({ existingConfig, setStep, setConfigWritten }) => {
-    const [resetInput, setResetInput] = useState('');
     const provider = getProvider(existingConfig.provider);
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Existing configuration found:" }), _jsxs(Text, { children: ["  Provider: ", provider?.name || existingConfig.provider] }), _jsxs(Text, { children: ["  Model: ", existingConfig.model] }), _jsxs(Text, { children: ["  API Key: ", '*'.repeat(8)] }), _jsx(Text, { children: " " }), _jsx(Text, { children: "Do you want to reset and configure a new one? (y/n)" }), _jsx(TextInput, { onSubmit: (answer) => {
                     if (answer.toLowerCase() === 'y') {
@@ -310,7 +320,7 @@ export const ConfigResult = ({ configWritten }) => {
 };
 export const ConfigureComponent = () => {
     const [step, setStep] = useState(0);
-    const [target, setTarget] = useState(getDefaultConfigTarget());
+    const [target, setTarget] = useState('user');
     const [existingConfig, setExistingConfig] = useState(null);
     const [selectedProviderId, setSelectedProviderId] = useState('');
     const [selectedModelId, setSelectedModelId] = useState('');
@@ -339,22 +349,20 @@ export const ConfigureComponent = () => {
 export const InitComponent = () => {
     const [selectedTarget, setSelectedTarget] = useState(null);
     const [result, setResult] = useState(null);
-    const options = [
-        {
-            label: 'Project config',
-            value: 'project',
-            description: getProjectRuntimeConfigPath(),
-        },
-        {
-            label: 'Shared user config',
-            value: 'user',
-            description: getUserRuntimeConfigPath(),
-        },
-    ];
-    const activeTarget = selectedTarget ?? 'project';
-    const activeOption = options.find((option) => option.value === activeTarget) ?? options[0];
+    // Step 1: Show target selection
+    if (!selectedTarget && !result) {
+        return (_jsx(TargetSelection, { title: "Create a ProtoAgent runtime config", subtitle: "Select where to write `protoagent.jsonc`", onSelect: (target) => {
+                const configPath = getRuntimeConfigPath(target);
+                if (existsSync(configPath)) {
+                    setSelectedTarget(target);
+                    return;
+                }
+                setResult(writeInitConfig(target));
+            } }));
+    }
+    // Step 2: Target selected but file exists - confirm overwrite
     if (selectedTarget && !result) {
-        const selectedPath = getInitConfigPath(selectedTarget);
+        const selectedPath = getRuntimeConfigPath(selectedTarget);
         return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Config already exists:" }), _jsx(Text, { children: selectedPath }), _jsx(Text, { children: "Overwrite it? (y/n)" }), _jsx(TextInput, { onSubmit: (answer) => {
                         if (answer.trim().toLowerCase() === 'y') {
                             setResult(writeInitConfig(selectedTarget, process.cwd(), { overwrite: true }));
@@ -364,6 +372,7 @@ export const InitComponent = () => {
                         }
                     } })] }));
     }
+    // Step 3: Show result
     if (result) {
         const color = result.status === 'exists' ? 'yellow' : 'green';
         const message = result.status === 'created'
@@ -373,13 +382,5 @@ export const InitComponent = () => {
                 : 'ProtoAgent config already exists:';
         return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: color, children: message }), _jsx(Text, { children: result.path })] }));
     }
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "Create a ProtoAgent runtime config:" }), _jsx(Text, { dimColor: true, children: "Select where to write `protoagent.jsonc`." }), _jsx(Text, { dimColor: true, children: activeOption.description }), _jsx(Box, { marginTop: 1, children: _jsx(Select, { options: options.map((option) => ({ label: option.label, value: option.value })), onChange: (value) => {
-                        const target = value;
-                        const configPath = getInitConfigPath(target);
-                        if (existsSync(configPath)) {
-                            setSelectedTarget(target);
-                            return;
-                        }
-                        setResult(writeInitConfig(target));
-                    } }) })] }));
+    return null;
 };

package/dist/hooks/useAgentEventHandler.js

@@ -0,0 +1,356 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback } from 'react';
+import { Text } from 'ink';
+import { renderFormattedText, normalizeTranscriptText } from '../utils/format-message.js';
+import { formatSubAgentActivity, formatToolActivity } from '../utils/tool-display.js';
+export function useAgentEventHandler(options) {
+    const { addStatic, setCompletionMessages, setIsStreaming, setStreamingText, setActiveTool, setLastUsage, setTotalCost, setThreadErrors, setError, assistantMessageRef, streamingBufferRef, } = options;
+    return useCallback((event) => {
+        switch (event.type) {
+            case 'text_delta': {
+                handleTextDelta(event, {
+                    addStatic,
+                    setCompletionMessages,
+                    setIsStreaming,
+                    setStreamingText,
+                    assistantMessageRef,
+                    streamingBufferRef,
+                });
+                break;
+            }
+            case 'sub_agent_iteration': {
+                handleSubAgentIteration(event, {
+                    setActiveTool,
+                    setTotalCost,
+                });
+                break;
+            }
+            case 'tool_call': {
+                handleToolCall(event, {
+                    addStatic,
+                    setCompletionMessages,
+                    setActiveTool,
+                    assistantMessageRef,
+                    streamingBufferRef,
+                    setIsStreaming,
+                    setStreamingText,
+                });
+                break;
+            }
+            case 'tool_result': {
+                handleToolResult(event, {
+                    addStatic,
+                    setCompletionMessages,
+                    setActiveTool,
+                    assistantMessageRef,
+                });
+                break;
+            }
+            case 'usage': {
+                handleUsage(event, { setLastUsage, setTotalCost });
+                break;
+            }
+            case 'error': {
+                handleError(event, { setThreadErrors, setError });
+                break;
+            }
+            case 'iteration_done': {
+                handleIterationDone({ assistantMessageRef });
+                break;
+            }
+            case 'done': {
+                handleDone(event, {
+                    addStatic,
+                    setCompletionMessages,
+                    setIsStreaming,
+                    setStreamingText,
+                    setActiveTool,
+                    setThreadErrors,
+                    assistantMessageRef,
+                    streamingBufferRef,
+                });
+                break;
+            }
+        }
+    }, [
+        addStatic,
+        setCompletionMessages,
+        setIsStreaming,
+        setStreamingText,
+        setActiveTool,
+        setLastUsage,
+        setTotalCost,
+        setThreadErrors,
+        setError,
+        assistantMessageRef,
+        streamingBufferRef,
+    ]);
+}
+// Helper to flush streaming buffer to static and reset state
+function flushStreamingBuffer(ctx) {
+    const { addStatic, setIsStreaming, setStreamingText, streamingBufferRef } = ctx;
+    const buffer = streamingBufferRef.current;
+    if (buffer.unflushedContent) {
+        addStatic(renderFormattedText(buffer.unflushedContent));
+    }
+    streamingBufferRef.current = { unflushedContent: '', hasFlushedAnyLine: false };
+    setIsStreaming(false);
+    setStreamingText('');
+}
+function handleTextDelta(event, ctx) {
+    const deltaText = event.content || '';
+    const { assistantMessageRef, streamingBufferRef, addStatic, setCompletionMessages, setIsStreaming, setStreamingText } = ctx;
+    // First text delta of this turn: initialize ref, show streaming indicator.
+    if (!assistantMessageRef.current || assistantMessageRef.current.kind !== 'streaming_text') {
+        // Trim leading whitespace from first delta - LLMs often output leading \n or spaces
+        const trimmedDelta = deltaText.replace(/^\s+/, '');
+        const assistantMsg = { role: 'assistant', content: trimmedDelta, tool_calls: [] };
+        // Use functional update to get correct index
+        setCompletionMessages((prev) => {
+            const idx = prev.length;
+            assistantMessageRef.current = { message: assistantMsg, index: idx, kind: 'streaming_text' };
+            return [...prev, assistantMsg];
+        });
+        setIsStreaming(true);
+        // Initialize the streaming buffer and process the first chunk
+        const buffer = { unflushedContent: trimmedDelta, hasFlushedAnyLine: false };
+        streamingBufferRef.current = buffer;
+        // Process the first chunk: split on newlines and flush complete lines
+        const lines = buffer.unflushedContent.split('\n');
+        if (lines.length > 1) {
+            const completeLines = lines.slice(0, -1);
+            const textToFlush = completeLines.join('\n');
+            if (textToFlush) {
+                addStatic(renderFormattedText(textToFlush));
+                buffer.hasFlushedAnyLine = true;
+            }
+            buffer.unflushedContent = lines[lines.length - 1];
+        }
+        setStreamingText(buffer.unflushedContent);
+    }
+    else {
+        // Subsequent deltas — append to ref and buffer, then flush complete lines
+        assistantMessageRef.current.message.content += deltaText;
+        // Accumulate in buffer and flush complete lines to static
+        const buffer = streamingBufferRef.current;
+        buffer.unflushedContent += deltaText;
+        // Split on newlines to find complete lines
+        const lines = buffer.unflushedContent.split('\n');
+        // If we have more than 1 element, there were newlines
+        if (lines.length > 1) {
+            // All lines except the last one are complete (ended with \n)
+            const completeLines = lines.slice(0, -1);
+            // Build the text to flush - each complete line gets a newline added back
+            const textToFlush = completeLines.join('\n');
+            if (textToFlush) {
+                addStatic(renderFormattedText(textToFlush));
+                buffer.hasFlushedAnyLine = true;
+            }
+            // Keep only the last (incomplete) line in the buffer
+            buffer.unflushedContent = lines[lines.length - 1];
+        }
+        // Show the incomplete line (if any) in the dynamic frame
+        setStreamingText(buffer.unflushedContent);
+    }
+}
+function handleSubAgentIteration(event, ctx) {
+    const { setActiveTool, setTotalCost } = ctx;
+    if (event.subAgentTool) {
+        const { tool, status, args } = event.subAgentTool;
+        if (status === 'running') {
+            setActiveTool(formatSubAgentActivity(tool, args));
+        }
+        else {
+            setActiveTool(null);
+        }
+    }
+    // Handle sub-agent usage update
+    if (event.subAgentUsage) {
+        setTotalCost((prev) => prev + event.subAgentUsage.estimatedCost);
+    }
+}
+function handleToolCall(event, ctx) {
+    const { setCompletionMessages, setActiveTool, assistantMessageRef } = ctx;
+    if (!event.toolCall)
+        return;
+    const toolCall = event.toolCall;
+    setActiveTool(toolCall.name);
+    // If the model streamed some text before invoking this tool,
+    // flush any remaining unflushed content to <Static> now.
+    if (assistantMessageRef.current?.kind === 'streaming_text') {
+        // Flush buffer and add spacing before the tool call
+        flushStreamingBuffer(ctx);
+        ctx.addStatic(renderFormattedText('\n'));
+        assistantMessageRef.current = null;
+    }
+    // Track the tool call in the ref WITHOUT triggering a render.
+    // The render will happen when tool_result arrives.
+    const existingRef = assistantMessageRef.current;
+    const assistantMsg = existingRef?.message
+        ? {
+            ...existingRef.message,
+            tool_calls: [...(existingRef.message.tool_calls || [])],
+        }
+        : { role: 'assistant', content: '', tool_calls: [] };
+    const nextToolCall = {
+        id: toolCall.id,
+        type: 'function',
+        function: { name: toolCall.name, arguments: toolCall.args },
+    };
+    const idx = assistantMsg.tool_calls.findIndex((tc) => tc.id === toolCall.id);
+    if (idx === -1) {
+        assistantMsg.tool_calls.push(nextToolCall);
+    }
+    else {
+        assistantMsg.tool_calls[idx] = nextToolCall;
+    }
+    if (!existingRef) {
+        // First tool call — we need to add the assistant message to state
+        setCompletionMessages((prev) => {
+            assistantMessageRef.current = {
+                message: assistantMsg,
+                index: prev.length,
+                kind: 'tool_call_assistant',
+            };
+            return [...prev, assistantMsg];
+        });
+    }
+    else {
+        // Subsequent tool calls — just update the ref, no render
+        assistantMessageRef.current = {
+            ...existingRef,
+            message: assistantMsg,
+            kind: 'tool_call_assistant',
+        };
+    }
+}
+function handleToolResult(event, ctx) {
+    const { addStatic, setCompletionMessages, setActiveTool, assistantMessageRef } = ctx;
+    if (!event.toolCall)
+        return;
+    const toolCall = event.toolCall;
+    setActiveTool(null);
+    // Write the tool summary immediately — at this point loading is
+    // still true but the frame height is stable (spinner + input box).
+    // The next state change (setActiveTool(null)) doesn't affect
+    // frame height so write() restores the correct frame.
+    const compactResult = (toolCall.result || '')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, 180);
+    // Parse tool args to show relevant parameter
+    let toolDisplay = toolCall.name;
+    try {
+        const args = JSON.parse(toolCall.args || '{}');
+        toolDisplay = formatToolActivity(toolCall.name, args);
+    }
+    catch {
+        // If parsing fails, just use the tool name
+    }
+    addStatic(_jsxs(Text, { dimColor: true, children: ['▶ ', toolDisplay, ': ', compactResult, '\n'] }));
+    // Flush the assistant message + tool result into completionMessages
+    // for session saving.
+    setCompletionMessages((prev) => {
+        const updated = [...prev];
+        // Sync assistant message
+        if (assistantMessageRef.current) {
+            updated[assistantMessageRef.current.index] = {
+                ...assistantMessageRef.current.message,
+            };
+        }
+        // Append tool result with args for replay
+        updated.push({
+            role: 'tool',
+            tool_call_id: toolCall.id,
+            content: toolCall.result || '',
+            name: toolCall.name,
+            args: toolCall.args,
+        });
+        return updated;
+    });
+}
+function handleUsage(event, ctx) {
+    const { setLastUsage, setTotalCost } = ctx;
+    if (event.usage) {
+        setLastUsage(event.usage);
+        setTotalCost((prev) => prev + event.usage.cost);
+    }
+}
+function handleError(event, ctx) {
+    const { setThreadErrors, setError } = ctx;
+    if (event.error) {
+        const errorMessage = event.error;
+        setThreadErrors((prev) => {
+            if (event.transient) {
+                return [
+                    ...prev.filter((threadError) => !threadError.transient),
+                    {
+                        id: `${Date.now()}-${prev.length}`,
+                        message: errorMessage,
+                        transient: true,
+                    },
+                ];
+            }
+            if (prev[prev.length - 1]?.message === errorMessage) {
+                return prev;
+            }
+            return [
+                ...prev,
+                {
+                    id: `${Date.now()}-${prev.length}`,
+                    message: errorMessage,
+                    transient: false,
+                },
+            ];
+        });
+    }
+    else {
+        setError('Unknown error');
+    }
+}
+function handleIterationDone(ctx) {
+    const { assistantMessageRef } = ctx;
+    if (assistantMessageRef.current?.kind === 'tool_call_assistant') {
+        assistantMessageRef.current = null;
+    }
+}
+function handleDone(_event, ctx) {
+    const { setCompletionMessages, setActiveTool, setThreadErrors, assistantMessageRef, streamingBufferRef } = ctx;
+    if (assistantMessageRef.current?.kind === 'streaming_text') {
+        const finalRef = assistantMessageRef.current;
+        const buffer = streamingBufferRef.current;
+        // Flush any remaining unflushed content from the buffer
+        // This is the final incomplete line that was being displayed live
+        if (buffer.unflushedContent) {
+            // If we've already flushed some lines, just append the remainder
+            // Otherwise, normalize and flush the full content
+            if (buffer.hasFlushedAnyLine) {
+                ctx.addStatic(renderFormattedText(buffer.unflushedContent));
+            }
+            else {
+                // Nothing was flushed yet, normalize the full content
+                const normalized = normalizeTranscriptText(finalRef.message.content || '');
+                if (normalized) {
+                    ctx.addStatic(renderFormattedText(normalized));
+                }
+            }
+        }
+        // Add final spacing after the streamed text
+        // Always add one newline - the user message adds another for blank line separation
+        if (buffer.unflushedContent) {
+            ctx.addStatic(renderFormattedText('\n'));
+        }
+        // Clear streaming state and buffer
+        ctx.setIsStreaming(false);
+        ctx.setStreamingText('');
+        streamingBufferRef.current = { unflushedContent: '', hasFlushedAnyLine: false };
+        setCompletionMessages((prev) => {
+            const updated = [...prev];
+            updated[finalRef.index] = { ...finalRef.message };
+            return updated;
+        });
+        assistantMessageRef.current = null;
+    }
+    setActiveTool(null);
+    setThreadErrors((prev) => prev.filter((threadError) => !threadError.transient));
+}

package/dist/mcp.js

@@ -104,6 +104,9 @@ async function registerMcpTools(conn) {
                 },
             });
             registerDynamicHandler(toolName, async (args) => {
+                // Note: Errors from this handler are caught and formatted by
+                // handleToolCall() in tools/index.ts, which wraps all tool calls
+                // in a try/catch and returns `Error executing ${toolName}: ${msg}`
                 const result = await conn.client.callTool({
                     name: tool.name,
                     arguments: (args && typeof args === 'object' ? args : {}),