@polpo-ai/server 0.15.75 → 0.15.77

package/dist/routes/completions/chat-handler.js

@@ -37,494 +37,494 @@ function clientSideToolNames(exec) {
 }
 /** Streaming chat mode — SSE stream of OpenAI-format chunks. */
 export function streamChatCompletion(c, exec) {
-    const { deps, body, completionId, agentMode, fullSystemPrompt, m: primaryModel, providerOpts: primaryProviderOpts, modelToolChoice, effectiveTools, effectiveToolExecutor, extraAiTools, isInteractiveFn, aiMessages, sessionStore, sessionId, onResponseFinished, } = exec;
-    const aiTools = mergeAiTools(exec);
-    let m = primaryModel;
-    let providerOpts = primaryProviderOpts;
-    const modelSelection = exec.modelSelection ?? modelSelectionForResolvedModel(primaryModel);
-    const reasoning = exec.agentConfig?.reasoning ?? deps.getConfig()?.settings?.reasoning;
-    const outputMode = streamingOutputPolicyMode(deps.runOutputPolicy);
-    const structuredResponse = isStructuredResponseFormat(body.response_format);
     return streamSSE(c, async (stream) => {
-        // Abort controller: cancelled when the client disconnects (closes SSE)
         const abortController = new AbortController();
         stream.onAbort(() => { abortController.abort(); });
-        // SSE heartbeat: write a comment (`: ping`) every 20s to prevent
-        // proxy idle timeouts (nginx 60s, Cloudflare 100s) during long tool
-        // execution pauses. SSE comments are invisible to compliant clients.
-        // WritableStream serializes writes, so heartbeats cannot interleave
-        // mid-payload with writeSSE calls.
         const heartbeatInterval = setInterval(() => {
             if (abortController.signal.aborted) {
                 clearInterval(heartbeatInterval);
                 return;
             }
-            stream.write(": ping\n\n").catch(() => {
-                clearInterval(heartbeatInterval);
-            });
+            stream.write(": ping\n\n").catch(() => clearInterval(heartbeatInterval));
         }, 20_000);
-        await stream.writeSSE({ data: sseChunk(completionId, { role: "assistant" }) });
-        // Reserve a placeholder message in the store BEFORE streaming.
-        // This guarantees the assistant message exists even if the client disconnects.
-        let assistantMsgId = null;
-        if (sessionStore && sessionId) {
-            const placeholder = await sessionStore.addMessage(sessionId, "assistant", "");
-            assistantMsgId = placeholder.id;
+        try {
+            await executeStreamingChatCompletion(stream, exec, abortController.signal);
         }
-        const messages = [...aiMessages];
-        let finalText = "";
-        let totalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
-        const toolCallsAccum = [];
-        let lastProviderMetadata;
-        let outputPolicyApplied = false;
-        let suggestions = [];
-        const finalizeOutput = async (validateStructured = true) => {
-            if (outputPolicyApplied)
-                return;
-            finalText = await applyCompletionOutputPolicy({
-                outputPolicy: deps.runOutputPolicy,
-                text: finalText,
-                mode: outputMode === "buffer" ? "enforce" : "audit",
-                runtimePlan: exec.runtimePlan,
-                agent: body.agent,
-                sessionId,
-                signal: abortController.signal,
+        finally {
+            clearInterval(heartbeatInterval);
+        }
+    });
+}
+/** Transport-independent producer used by attached and durable followers. */
+export async function executeStreamingChatCompletion(stream, exec, signal) {
+    const { deps, body, completionId, agentMode, fullSystemPrompt, m: primaryModel, providerOpts: primaryProviderOpts, modelToolChoice, effectiveTools, effectiveToolExecutor, extraAiTools, isInteractiveFn, aiMessages, sessionStore, sessionId, onResponseFinished, } = exec;
+    const aiTools = mergeAiTools(exec);
+    let m = primaryModel;
+    let providerOpts = primaryProviderOpts;
+    const modelSelection = exec.modelSelection ?? modelSelectionForResolvedModel(primaryModel);
+    const reasoning = exec.agentConfig?.reasoning ?? deps.getConfig()?.settings?.reasoning;
+    const outputMode = streamingOutputPolicyMode(deps.runOutputPolicy);
+    const structuredResponse = isStructuredResponseFormat(body.response_format);
+    await stream.writeSSE({ data: sseChunk(completionId, { role: "assistant" }) });
+    // Reserve a placeholder message in the store BEFORE streaming.
+    // This guarantees the assistant message exists even if the client disconnects.
+    let assistantMsgId = null;
+    if (sessionStore && sessionId) {
+        const placeholder = await sessionStore.addMessage(sessionId, "assistant", "");
+        assistantMsgId = placeholder.id;
+    }
+    const messages = [...aiMessages];
+    let finalText = "";
+    let totalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    const toolCallsAccum = [];
+    let lastProviderMetadata;
+    let outputPolicyApplied = false;
+    let suggestions = [];
+    const finalizeOutput = async (validateStructured = true) => {
+        if (outputPolicyApplied)
+            return;
+        finalText = await applyCompletionOutputPolicy({
+            outputPolicy: deps.runOutputPolicy,
+            text: finalText,
+            mode: outputMode === "buffer" ? "enforce" : "audit",
+            runtimePlan: exec.runtimePlan,
+            agent: body.agent,
+            sessionId,
+            signal,
+        });
+        if (validateStructured) {
+            finalText = await finalizeResponseFormatText(body.response_format, finalText);
+        }
+        outputPolicyApplied = true;
+        if ((outputMode === "buffer" || structuredResponse) && finalText) {
+            await stream.writeSSE({ data: sseChunk(completionId, { content: finalText }) });
+        }
+    };
+    try {
+        for (let turn = 0; turn < MAX_TURNS; turn++) {
+            // Bail out early if the client already disconnected
+            if (signal.aborted)
+                break;
+            // Compact context if approaching the model's context window limit.
+            // Under threshold this is just a cheap token estimation — zero LLM calls.
+            const compactionResult = await compactIfNeeded({
+                systemPrompt: fullSystemPrompt,
+                messages,
+                tools: exec.activeCompactionTools?.() ?? effectiveTools,
+                config: {
+                    contextWindow: m.contextWindow ?? 200_000,
+                    maxOutputTokens: m.maxTokens ?? 8192,
+                },
+                summarize: buildSummarizeFn(m, providerOpts),
+                mode: "chat",
+                onCompaction: async (event) => {
+                    await stream.writeSSE({
+                        data: sseChunk(completionId, {}, null, {
+                            compaction: {
+                                phase: event.phase,
+                                tokensBefore: event.tokensBefore,
+                                tokensAfter: event.tokensAfter,
+                                tokensReclaimed: event.tokensReclaimed,
+                                messagesBefore: event.messagesBefore,
+                                messagesAfter: event.messagesAfter,
+                            },
+                        }),
+                    });
+                },
             });
-            if (validateStructured) {
-                finalText = await finalizeResponseFormatText(body.response_format, finalText);
-            }
-            outputPolicyApplied = true;
-            if ((outputMode === "buffer" || structuredResponse) && finalText) {
-                await stream.writeSSE({ data: sseChunk(completionId, { content: finalText }) });
+            if (compactionResult.compacted) {
+                messages.splice(0, messages.length, ...compactionResult.messages);
             }
-        };
-        try {
-            for (let turn = 0; turn < MAX_TURNS; turn++) {
-                // Bail out early if the client already disconnected
-                if (abortController.signal.aborted)
-                    break;
-                // Compact context if approaching the model's context window limit.
-                // Under threshold this is just a cheap token estimation — zero LLM calls.
-                const compactionResult = await compactIfNeeded({
-                    systemPrompt: fullSystemPrompt,
-                    messages,
-                    tools: exec.activeCompactionTools?.() ?? effectiveTools,
-                    config: {
-                        contextWindow: m.contextWindow ?? 200_000,
-                        maxOutputTokens: m.maxTokens ?? 8192,
-                    },
-                    summarize: buildSummarizeFn(m, providerOpts),
-                    mode: "chat",
-                    onCompaction: async (event) => {
-                        await stream.writeSSE({
-                            data: sseChunk(completionId, {}, null, {
-                                compaction: {
-                                    phase: event.phase,
-                                    tokensBefore: event.tokensBefore,
-                                    tokensAfter: event.tokensAfter,
-                                    tokensReclaimed: event.tokensReclaimed,
-                                    messagesBefore: event.messagesBefore,
-                                    messagesAfter: event.messagesAfter,
-                                },
-                            }),
-                        });
-                    },
-                });
-                if (compactionResult.compacted) {
-                    messages.splice(0, messages.length, ...compactionResult.messages);
-                }
-                let turnText = "";
-                let streamError;
-                // Per-tool-call streaming state for this turn: the tool name (learned
-                // at tool-input-start) and the raw args JSON accumulated from the
-                // token-by-token input deltas, so the UI can render the call as it
-                // builds up instead of waiting for the whole turn to finish.
-                const toolCallNames = new Map();
-                const toolCallArgsText = new Map();
-                const resolvedAttempts = new Map();
-                const result = await runModelPolicyTurn({
-                    selection: modelSelection,
-                    resolveAttempt: async (attempt) => {
-                        const resolvedAttempt = attempt.index === 0 || !agentMode || !exec.agentConfig
-                            ? { model: primaryModel, providerOptions: primaryProviderOpts }
-                            : await deps.resolveAgentModel(agentConfigForModelAttempt(exec.agentConfig, attempt.model), reasoning);
-                        resolvedAttempts.set(attempt.index, resolvedAttempt);
-                        return {
-                            model: resolvedAttempt.model.aiModel,
-                            maxOutputTokens: resolvedAttempt.model.maxTokens,
-                            providerOptions: resolvedAttempt.providerOptions,
-                        };
-                    },
-                    preserveSingleAttemptError: true,
-                    system: fullSystemPrompt,
-                    messages,
-                    tools: aiTools,
-                    ...(exec.activeToolNames ? { activeTools: exec.activeToolNames() } : {}),
-                    ...(modelToolChoice ? { toolChoice: modelToolChoice } : {}),
-                    ...(exec.modelOutput ? { output: exec.modelOutput } : {}),
-                    abortSignal: abortController.signal,
-                }, async (event) => {
-                    if (abortController.signal.aborted)
-                        return;
-                    if (event.type === "reasoning-delta") {
-                        await stream.writeSSE({ data: sseChunk(completionId, {}, null, { thinking: event.text }) });
-                    }
-                    else if (event.type === "text-delta") {
-                        turnText += event.text;
-                        if (!structuredResponse)
-                            finalText += event.text;
-                        if (outputMode !== "buffer" && !structuredResponse) {
-                            await stream.writeSSE({ data: sseChunk(completionId, { content: event.text }) });
-                        }
-                    }
-                    else if (event.type === "tool-input-start") {
-                        // Emit early "preparing" signal — the LLM has started generating a tool call
-                        // but arguments are not yet complete. Lets the UI show immediate feedback.
-                        toolCallNames.set(event.id, event.name);
-                        await stream.writeSSE({
-                            data: sseChunk(completionId, {}, null, {
-                                tool_call: { id: event.id, name: event.name, state: "preparing" },
-                            }),
-                        });
-                    }
-                    else if (event.type === "tool-input-delta") {
-                        // Stream the argument tokens as they arrive. Accumulate the raw
-                        // JSON and forward it so the client can show the tool input
-                        // building up live. Still "preparing": args aren't final yet.
-                        const acc = (toolCallArgsText.get(event.id) ?? "") + event.delta;
-                        toolCallArgsText.set(event.id, acc);
-                        await stream.writeSSE({
-                            data: sseChunk(completionId, {}, null, {
-                                tool_call: {
-                                    id: event.id,
-                                    name: toolCallNames.get(event.id) ?? "",
-                                    state: "preparing",
-                                    argumentsText: acc,
-                                },
-                            }),
-                        });
-                    }
-                    else if (event.type === "finish") {
-                        // Capture error from finish reason if applicable
-                        if (event.finishReason === "error") {
-                            streamError = "Model returned an error";
-                        }
-                    }
-                });
-                // If aborted, stop the loop — skip error/tool processing
-                if (abortController.signal.aborted) {
-                    break;
+            let turnText = "";
+            let streamError;
+            // Per-tool-call streaming state for this turn: the tool name (learned
+            // at tool-input-start) and the raw args JSON accumulated from the
+            // token-by-token input deltas, so the UI can render the call as it
+            // builds up instead of waiting for the whole turn to finish.
+            const toolCallNames = new Map();
+            const toolCallArgsText = new Map();
+            const resolvedAttempts = new Map();
+            const result = await runModelPolicyTurn({
+                selection: modelSelection,
+                resolveAttempt: async (attempt) => {
+                    const resolvedAttempt = attempt.index === 0 || !agentMode || !exec.agentConfig
+                        ? { model: primaryModel, providerOptions: primaryProviderOpts }
+                        : await deps.resolveAgentModel(agentConfigForModelAttempt(exec.agentConfig, attempt.model), reasoning);
+                    resolvedAttempts.set(attempt.index, resolvedAttempt);
+                    return {
+                        model: resolvedAttempt.model.aiModel,
+                        maxOutputTokens: resolvedAttempt.model.maxTokens,
+                        providerOptions: resolvedAttempt.providerOptions,
+                    };
+                },
+                preserveSingleAttemptError: true,
+                system: fullSystemPrompt,
+                messages,
+                tools: aiTools,
+                ...(exec.activeToolNames ? { activeTools: exec.activeToolNames() } : {}),
+                ...(modelToolChoice ? { toolChoice: modelToolChoice } : {}),
+                ...(exec.modelOutput ? { output: exec.modelOutput } : {}),
+                abortSignal: signal,
+            }, async (event) => {
+                if (signal.aborted)
+                    return;
+                if (event.type === "reasoning-delta") {
+                    await stream.writeSSE({ data: sseChunk(completionId, {}, null, { thinking: event.text }) });
                 }
-                if (streamError) {
-                    finalText += `\n\nError: ${streamError}`;
+                else if (event.type === "text-delta") {
+                    turnText += event.text;
+                    if (!structuredResponse)
+                        finalText += event.text;
                     if (outputMode !== "buffer" && !structuredResponse) {
-                        await stream.writeSSE({ data: sseChunk(completionId, { content: `\n\nError: ${streamError}` }) });
+                        await stream.writeSSE({ data: sseChunk(completionId, { content: event.text }) });
                     }
-                    break;
                 }
-                const toolCalls = result.toolCalls;
-                if (structuredResponse && toolCalls.length === 0) {
-                    turnText = await serializeModelOutput(body.response_format, result.output, turnText);
-                    finalText += turnText;
-                }
-                const usage = result.usage;
-                const selectedResolved = resolvedAttempts.get(result.selectedAttempt.index);
-                if (selectedResolved) {
-                    m = selectedResolved.model;
-                    providerOpts = selectedResolved.providerOptions;
-                }
-                totalUsage = {
-                    inputTokens: (totalUsage.inputTokens ?? 0) + (usage.inputTokens ?? 0),
-                    outputTokens: (totalUsage.outputTokens ?? 0) + (usage.outputTokens ?? 0),
-                    totalTokens: (totalUsage.totalTokens ?? 0) + (usage.totalTokens ?? 0),
-                };
-                lastProviderMetadata = result.providerMetadata;
-                await appendModelResponseMessages(messages, result, turnText, toolCalls, exec.contextTrust ?? "off");
-                if (toolCalls.length === 0)
-                    break;
-                const dispatchableToolCalls = toolCalls.filter((call) => !isInvalidModelToolCall(call));
-                for (const call of toolCalls.filter(isInvalidModelToolCall)) {
-                    const event = invalidModelToolCallEvent(call);
-                    toolCallsAccum.push(event);
+                else if (event.type === "tool-input-start") {
+                    // Emit early "preparing" signal — the LLM has started generating a tool call
+                    // but arguments are not yet complete. Lets the UI show immediate feedback.
+                    toolCallNames.set(event.id, event.name);
                     await stream.writeSSE({
                         data: sseChunk(completionId, {}, null, {
-                            tool_call: event,
+                            tool_call: { id: event.id, name: event.name, state: "preparing" },
                         }),
                     });
                 }
-                if (dispatchableToolCalls.length === 0)
-                    continue;
-                // ── Client-side tools — return to client as standard tool_calls ──
-                const clientSideCall = dispatchableToolCalls.find((tc) => clientSideToolNames(exec).has(tc.toolName));
-                if (clientSideCall) {
-                    // Persist for session history
-                    toolCallsAccum.push({
-                        id: clientSideCall.toolCallId,
-                        name: clientSideCall.toolName,
-                        arguments: clientSideCall.input,
-                        state: "interrupted",
-                    });
-                    await finalizeOutput(false);
-                    // Send as standard OpenAI tool_calls finish reason
+                else if (event.type === "tool-input-delta") {
+                    // Stream the argument tokens as they arrive. Accumulate the raw
+                    // JSON and forward it so the client can show the tool input
+                    // building up live. Still "preparing": args aren't final yet.
+                    const acc = (toolCallArgsText.get(event.id) ?? "") + event.delta;
+                    toolCallArgsText.set(event.id, acc);
                     await stream.writeSSE({
-                        data: JSON.stringify({
-                            id: completionId,
-                            object: "chat.completion.chunk",
-                            choices: [{
-                                    index: 0,
-                                    delta: {
-                                        role: "assistant",
-                                        tool_calls: [{
-                                                index: 0,
-                                                id: clientSideCall.toolCallId,
-                                                type: "function",
-                                                function: {
-                                                    name: clientSideCall.toolName,
-                                                    arguments: JSON.stringify(clientSideCall.input),
-                                                },
-                                            }],
-                                    },
-                                    finish_reason: "tool_calls",
-                                }],
+                        data: sseChunk(completionId, {}, null, {
+                            tool_call: {
+                                id: event.id,
+                                name: toolCallNames.get(event.id) ?? "",
+                                state: "preparing",
+                                argumentsText: acc,
+                            },
                         }),
                     });
-                    await stream.writeSSE({ data: "[DONE]" });
-                    return;
                 }
-                // Check for interactive tools — only in orchestrator mode (agents don't have interactive tools)
-                const interactiveCall = agentMode ? undefined : dispatchableToolCalls.find((tc) => isInteractiveFn?.(tc.toolName));
-                if (interactiveCall) {
-                    // Persist the interactive tool call so it survives session reload
-                    toolCallsAccum.push({
-                        id: interactiveCall.toolCallId,
-                        name: interactiveCall.toolName,
-                        arguments: interactiveCall.input,
-                        state: "interrupted",
-                    });
-                    await finalizeOutput(false);
-                    if (interactiveCall.toolName === "ask_user") {
-                        const questions = interactiveCall.input?.questions ?? [];
-                        await stream.writeSSE({
-                            data: sseChunk(completionId, {}, "ask_user", { ask_user: { questions } }),
-                        });
+                else if (event.type === "finish") {
+                    // Capture error from finish reason if applicable
+                    if (event.finishReason === "error") {
+                        streamError = "Model returned an error";
                     }
-                    else if (interactiveCall.toolName === "create_mission") {
-                        const args = interactiveCall.input;
-                        let missionData;
-                        try {
-                            missionData = JSON.parse(args.data);
-                        }
-                        catch {
-                            missionData = args.data;
-                        }
-                        await stream.writeSSE({
-                            data: sseChunk(completionId, {}, "mission_preview", {
-                                mission_preview: {
-                                    name: args.name,
-                                    data: missionData,
-                                    prompt: args.prompt,
-                                },
-                            }),
-                        });
-                    }
-                    else if (interactiveCall.toolName === "set_vault_entry") {
-                        const args = interactiveCall.input;
-                        await stream.writeSSE({
-                            data: sseChunk(completionId, {}, "vault_preview", {
-                                vault_preview: {
-                                    agent: args.agent,
-                                    service: args.service,
-                                    type: args.type,
-                                    label: args.label,
-                                    credentials: args.credentials,
-                                },
-                            }),
-                        });
-                    }
-                    else if (interactiveCall.toolName === "open_file") {
-                        const args = interactiveCall.input;
-                        await stream.writeSSE({
-                            data: sseChunk(completionId, {}, "open_file", {
-                                open_file: {
-                                    path: args.path,
-                                },
-                            }),
-                        });
-                    }
-                    else if (interactiveCall.toolName === "navigate_to") {
-                        const args = interactiveCall.input;
-                        await stream.writeSSE({
-                            data: sseChunk(completionId, {}, "navigate_to", {
-                                navigate_to: {
-                                    target: args.target,
-                                    id: args.id,
-                                    name: args.name,
-                                    path: args.path,
-                                    highlight: args.highlight,
-                                },
-                            }),
-                        });
-                    }
-                    else if (interactiveCall.toolName === "open_tab") {
-                        const args = interactiveCall.input;
-                        await stream.writeSSE({
-                            data: sseChunk(completionId, {}, "open_tab", {
-                                open_tab: {
-                                    url: args.url,
-                                    label: args.label,
+                }
+            });
+            // If aborted, stop the loop — skip error/tool processing
+            if (signal.aborted) {
+                break;
+            }
+            if (streamError) {
+                finalText += `\n\nError: ${streamError}`;
+                if (outputMode !== "buffer" && !structuredResponse) {
+                    await stream.writeSSE({ data: sseChunk(completionId, { content: `\n\nError: ${streamError}` }) });
+                }
+                break;
+            }
+            const toolCalls = result.toolCalls;
+            if (structuredResponse && toolCalls.length === 0) {
+                turnText = await serializeModelOutput(body.response_format, result.output, turnText);
+                finalText += turnText;
+            }
+            const usage = result.usage;
+            const selectedResolved = resolvedAttempts.get(result.selectedAttempt.index);
+            if (selectedResolved) {
+                m = selectedResolved.model;
+                providerOpts = selectedResolved.providerOptions;
+            }
+            totalUsage = {
+                inputTokens: (totalUsage.inputTokens ?? 0) + (usage.inputTokens ?? 0),
+                outputTokens: (totalUsage.outputTokens ?? 0) + (usage.outputTokens ?? 0),
+                totalTokens: (totalUsage.totalTokens ?? 0) + (usage.totalTokens ?? 0),
+            };
+            lastProviderMetadata = result.providerMetadata;
+            await appendModelResponseMessages(messages, result, turnText, toolCalls, exec.contextTrust ?? "off");
+            if (toolCalls.length === 0)
+                break;
+            const dispatchableToolCalls = toolCalls.filter((call) => !isInvalidModelToolCall(call));
+            for (const call of toolCalls.filter(isInvalidModelToolCall)) {
+                const event = invalidModelToolCallEvent(call);
+                toolCallsAccum.push(event);
+                await stream.writeSSE({
+                    data: sseChunk(completionId, {}, null, {
+                        tool_call: event,
+                    }),
+                });
+            }
+            if (dispatchableToolCalls.length === 0)
+                continue;
+            // ── Client-side tools — return to client as standard tool_calls ──
+            const clientSideCall = dispatchableToolCalls.find((tc) => clientSideToolNames(exec).has(tc.toolName));
+            if (clientSideCall) {
+                // Persist for session history
+                toolCallsAccum.push({
+                    id: clientSideCall.toolCallId,
+                    name: clientSideCall.toolName,
+                    arguments: clientSideCall.input,
+                    state: "interrupted",
+                });
+                await finalizeOutput(false);
+                // Send as standard OpenAI tool_calls finish reason
+                await stream.writeSSE({
+                    data: JSON.stringify({
+                        id: completionId,
+                        object: "chat.completion.chunk",
+                        choices: [{
+                                index: 0,
+                                delta: {
+                                    role: "assistant",
+                                    tool_calls: [{
+                                            index: 0,
+                                            id: clientSideCall.toolCallId,
+                                            type: "function",
+                                            function: {
+                                                name: clientSideCall.toolName,
+                                                arguments: JSON.stringify(clientSideCall.input),
+                                            },
+                                        }],
                                 },
-                            }),
-                        });
-                    }
-                    await stream.writeSSE({ data: "[DONE]" });
-                    return; // finally block will persist whatever finalText we have
+                                finish_reason: "tool_calls",
+                            }],
+                    }),
+                });
+                await stream.writeSSE({ data: "[DONE]" });
+                return;
+            }
+            // Check for interactive tools — only in orchestrator mode (agents don't have interactive tools)
+            const interactiveCall = agentMode ? undefined : dispatchableToolCalls.find((tc) => isInteractiveFn?.(tc.toolName));
+            if (interactiveCall) {
+                // Persist the interactive tool call so it survives session reload
+                toolCallsAccum.push({
+                    id: interactiveCall.toolCallId,
+                    name: interactiveCall.toolName,
+                    arguments: interactiveCall.input,
+                    state: "interrupted",
+                });
+                await finalizeOutput(false);
+                if (interactiveCall.toolName === "ask_user") {
+                    const questions = interactiveCall.input?.questions ?? [];
+                    await stream.writeSSE({
+                        data: sseChunk(completionId, {}, "ask_user", { ask_user: { questions } }),
+                    });
                 }
-                // Provider tools (extraAiTools) are executed by the SDK / gateway.
-                // Their tool results are already preserved in responseMessages,
-                // so only record them for observability and skip local dispatch.
-                const providerToolNames = new Set(Object.keys(extraAiTools ?? {}));
-                const providerToolResults = indexToolResultsByCallId(result.toolResults);
-                for (const call of dispatchableToolCalls) {
-                    // Stop executing tools if client disconnected
-                    if (abortController.signal.aborted)
-                        break;
-                    const callArgs = call.input;
-                    if (providerToolNames.has(call.toolName)) {
-                        recordProviderToolCall(toolCallsAccum, call, providerToolResults);
-                        continue;
+                else if (interactiveCall.toolName === "create_mission") {
+                    const args = interactiveCall.input;
+                    let missionData;
+                    try {
+                        missionData = JSON.parse(args.data);
+                    }
+                    catch {
+                        missionData = args.data;
                     }
-                    // Notify client that a tool is being called
                     await stream.writeSSE({
-                        data: sseChunk(completionId, {}, null, {
-                            tool_call: { id: call.toolCallId, name: call.toolName, arguments: callArgs, state: "calling" },
+                        data: sseChunk(completionId, {}, "mission_preview", {
+                            mission_preview: {
+                                name: args.name,
+                                data: missionData,
+                                prompt: args.prompt,
+                            },
                         }),
                     });
-                    const result = await effectiveToolExecutor(call.toolName, callArgs, {
-                        callId: call.toolCallId,
-                        signal: abortController.signal,
-                    });
-                    const isError = result.startsWith("Error:");
-                    emitFileChanged(call.toolName, callArgs, result, deps.emit);
-                    // Accumulate for persistence
-                    toolCallsAccum.push({
-                        id: call.toolCallId,
-                        name: call.toolName,
-                        arguments: callArgs,
-                        result,
-                        state: isError ? "error" : "completed",
-                    });
-                    // Notify client with tool result (skip if aborted mid-tool)
-                    if (!abortController.signal.aborted) {
-                        await stream.writeSSE({
-                            data: sseChunk(completionId, {}, null, {
-                                tool_call: { id: call.toolCallId, name: call.toolName, result, state: isError ? "error" : "completed" },
-                            }),
-                        });
-                    }
-                    // Push tool result message in AI SDK format
-                    messages.push({
-                        role: "tool",
-                        content: [{
-                                type: "tool-result",
-                                toolCallId: call.toolCallId,
-                                toolName: call.toolName,
-                                output: isError
-                                    ? {
-                                        type: "error-text",
-                                        value: exec.contextTrust === "enforce"
-                                            ? renderRuntimeToolResult(call.toolName, call.toolCallId, result)
-                                            : result,
-                                    }
-                                    : {
-                                        type: "text",
-                                        value: exec.contextTrust === "enforce"
-                                            ? renderRuntimeToolResult(call.toolName, call.toolCallId, result)
-                                            : result,
-                                    },
-                            }],
-                    });
                 }
-            }
-            if (!abortController.signal.aborted) {
-                await finalizeOutput();
-                suggestions = await suggestionsForCompletion(exec, finalText, abortController.signal);
-                if (suggestions.length > 0) {
+                else if (interactiveCall.toolName === "set_vault_entry") {
+                    const args = interactiveCall.input;
                     await stream.writeSSE({
-                        data: ssePolpoChunk(completionId, { suggestions }),
+                        data: sseChunk(completionId, {}, "vault_preview", {
+                            vault_preview: {
+                                agent: args.agent,
+                                service: args.service,
+                                type: args.type,
+                                label: args.label,
+                                credentials: args.credentials,
+                            },
+                        }),
                     });
                 }
-                await stream.writeSSE({ data: sseChunk(completionId, {}, "stop") });
-                await stream.writeSSE({ data: "[DONE]" });
-            }
-        }
-        catch (err) {
-            // Suppress AbortError — expected when client disconnects
-            if ((err instanceof DOMException && err.name === "AbortError") || abortController.signal.aborted) {
-                // fall through to finally — no SSE error event needed
-            }
-            else {
-                // Friendly model_not_found surface — gateway returns 404 for
-                // renamed/deprecated SKUs (e.g. xai/grok-4-fast after the 4.1
-                // rename). Without this catch the error propagates as a 500.
-                const structuredOutputError = structuredOutputErrorEnvelope(err, structuredResponse);
-                const guardrailError = guardrailErrorEnvelope(err);
-                const notFound = modelNotFoundEnvelope(err, m?.id, body.agent);
-                if (structuredOutputError) {
+                else if (interactiveCall.toolName === "open_file") {
+                    const args = interactiveCall.input;
                     await stream.writeSSE({
-                        data: sseChunk(completionId, {}, "stop", { error: structuredOutputError }),
+                        data: sseChunk(completionId, {}, "open_file", {
+                            open_file: {
+                                path: args.path,
+                            },
+                        }),
                     });
-                    await stream.writeSSE({ data: "[DONE]" });
                 }
-                else if (guardrailError) {
-                    finalText = guardrailError.message;
-                    outputPolicyApplied = true;
+                else if (interactiveCall.toolName === "navigate_to") {
+                    const args = interactiveCall.input;
                     await stream.writeSSE({
-                        data: sseChunk(completionId, {}, "stop", { error: guardrailError }),
+                        data: sseChunk(completionId, {}, "navigate_to", {
+                            navigate_to: {
+                                target: args.target,
+                                id: args.id,
+                                name: args.name,
+                                path: args.path,
+                                highlight: args.highlight,
+                            },
+                        }),
                     });
-                    await stream.writeSSE({ data: "[DONE]" });
                 }
-                else if (notFound) {
+                else if (interactiveCall.toolName === "open_tab") {
+                    const args = interactiveCall.input;
                     await stream.writeSSE({
-                        data: sseChunk(completionId, {}, "stop", { error: notFound }),
+                        data: sseChunk(completionId, {}, "open_tab", {
+                            open_tab: {
+                                url: args.url,
+                                label: args.label,
+                            },
+                        }),
                     });
-                    await stream.writeSSE({ data: "[DONE]" });
                 }
-                else {
-                    const error = modelErrorEnvelope(err);
-                    const text = `Model request failed: ${error.message}`;
-                    finalText = outputMode === "buffer" ? text : finalText + text;
-                    await stream.writeSSE({ data: sseChunk(completionId, { content: text }) });
-                    await stream.writeSSE({ data: sseChunk(completionId, {}, "stop", { error }) });
-                    await stream.writeSSE({ data: "[DONE]" });
+                await stream.writeSSE({ data: "[DONE]" });
+                return; // finally block will persist whatever finalText we have
+            }
+            // Provider tools (extraAiTools) are executed by the SDK / gateway.
+            // Their tool results are already preserved in responseMessages,
+            // so only record them for observability and skip local dispatch.
+            const providerToolNames = new Set(Object.keys(extraAiTools ?? {}));
+            const providerToolResults = indexToolResultsByCallId(result.toolResults);
+            for (const call of dispatchableToolCalls) {
+                // Stop executing tools if client disconnected
+                if (signal.aborted)
+                    break;
+                const callArgs = call.input;
+                if (providerToolNames.has(call.toolName)) {
+                    recordProviderToolCall(toolCallsAccum, call, providerToolResults);
+                    continue;
+                }
+                // Notify client that a tool is being called
+                await stream.writeSSE({
+                    data: sseChunk(completionId, {}, null, {
+                        tool_call: { id: call.toolCallId, name: call.toolName, arguments: callArgs, state: "calling" },
+                    }),
+                });
+                const result = await effectiveToolExecutor(call.toolName, callArgs, {
+                    callId: call.toolCallId,
+                    signal,
+                });
+                const isError = result.startsWith("Error:");
+                emitFileChanged(call.toolName, callArgs, result, deps.emit);
+                // Accumulate for persistence
+                toolCallsAccum.push({
+                    id: call.toolCallId,
+                    name: call.toolName,
+                    arguments: callArgs,
+                    result,
+                    state: isError ? "error" : "completed",
+                });
+                // Notify client with tool result (skip if aborted mid-tool)
+                if (!signal.aborted) {
+                    await stream.writeSSE({
+                        data: sseChunk(completionId, {}, null, {
+                            tool_call: { id: call.toolCallId, name: call.toolName, result, state: isError ? "error" : "completed" },
+                        }),
+                    });
                 }
+                // Push tool result message in AI SDK format
+                messages.push({
+                    role: "tool",
+                    content: [{
+                            type: "tool-result",
+                            toolCallId: call.toolCallId,
+                            toolName: call.toolName,
+                            output: isError
+                                ? {
+                                    type: "error-text",
+                                    value: exec.contextTrust === "enforce"
+                                        ? renderRuntimeToolResult(call.toolName, call.toolCallId, result)
+                                        : result,
+                                }
+                                : {
+                                    type: "text",
+                                    value: exec.contextTrust === "enforce"
+                                        ? renderRuntimeToolResult(call.toolName, call.toolCallId, result)
+                                        : result,
+                                },
+                        }],
+                });
             }
         }
-        finally {
-            clearInterval(heartbeatInterval);
-            // Always persist the assistant response — even on disconnect.
-            // (Vault credentials are redacted inside persistAssistantMessage.)
-            await persistAssistantMessage(sessionStore, sessionId, assistantMsgId, finalText, toolCallsAccum, suggestions.length > 0 ? { suggestions } : undefined);
-            // Notify consumer (e.g. metering) — fire-and-forget
-            try {
-                deps.onCompletionFinished?.({
-                    usage: totalUsage,
-                    model: m.id ?? m.provider,
-                    resolvedModel: completionResolvedModelInfo(m),
-                    agent: body.agent,
-                    sessionId: sessionId ?? undefined,
-                    user: body.user,
-                    providerMetadata: lastProviderMetadata,
+        if (!signal.aborted) {
+            await finalizeOutput();
+            suggestions = await suggestionsForCompletion(exec, finalText, signal);
+            if (suggestions.length > 0) {
+                await stream.writeSSE({
+                    data: ssePolpoChunk(completionId, { suggestions }),
                 });
             }
-            catch { /* never fail on callback */ }
-            // Close per-request resources (MCP transports, etc.). Errors
-            // are intentionally swallowed — a stuck cleanup must not block
-            // the response from finishing.
-            if (onResponseFinished) {
-                onResponseFinished().catch(() => { });
+            await stream.writeSSE({ data: sseChunk(completionId, {}, "stop") });
+            await stream.writeSSE({ data: "[DONE]" });
+        }
+    }
+    catch (err) {
+        // Suppress AbortError — expected when client disconnects
+        if ((err instanceof DOMException && err.name === "AbortError") || signal.aborted) {
+            // fall through to finally — no SSE error event needed
+        }
+        else {
+            // Friendly model_not_found surface — gateway returns 404 for
+            // renamed/deprecated SKUs (e.g. xai/grok-4-fast after the 4.1
+            // rename). Without this catch the error propagates as a 500.
+            const structuredOutputError = structuredOutputErrorEnvelope(err, structuredResponse);
+            const guardrailError = guardrailErrorEnvelope(err);
+            const notFound = modelNotFoundEnvelope(err, m?.id, body.agent);
+            if (structuredOutputError) {
+                await stream.writeSSE({
+                    data: sseChunk(completionId, {}, "stop", { error: structuredOutputError }),
+                });
+                await stream.writeSSE({ data: "[DONE]" });
+            }
+            else if (guardrailError) {
+                finalText = guardrailError.message;
+                outputPolicyApplied = true;
+                await stream.writeSSE({
+                    data: sseChunk(completionId, {}, "stop", { error: guardrailError }),
+                });
+                await stream.writeSSE({ data: "[DONE]" });
+            }
+            else if (notFound) {
+                await stream.writeSSE({
+                    data: sseChunk(completionId, {}, "stop", { error: notFound }),
+                });
+                await stream.writeSSE({ data: "[DONE]" });
+            }
+            else {
+                const error = modelErrorEnvelope(err);
+                const text = `Model request failed: ${error.message}`;
+                finalText = outputMode === "buffer" ? text : finalText + text;
+                await stream.writeSSE({ data: sseChunk(completionId, { content: text }) });
+                await stream.writeSSE({ data: sseChunk(completionId, {}, "stop", { error }) });
+                await stream.writeSSE({ data: "[DONE]" });
             }
         }
-    });
+    }
+    finally {
+        // Always persist the assistant response — even on disconnect.
+        // (Vault credentials are redacted inside persistAssistantMessage.)
+        await persistAssistantMessage(sessionStore, sessionId, assistantMsgId, finalText, toolCallsAccum, suggestions.length > 0 ? { suggestions } : undefined);
+        // Notify consumer (e.g. metering) — fire-and-forget
+        try {
+            deps.onCompletionFinished?.({
+                usage: totalUsage,
+                model: m.id ?? m.provider,
+                resolvedModel: completionResolvedModelInfo(m),
+                agent: body.agent,
+                sessionId: sessionId ?? undefined,
+                user: body.user,
+                providerMetadata: lastProviderMetadata,
+            });
+        }
+        catch { /* never fail on callback */ }
+        // Close per-request resources (MCP transports, etc.). Errors
+        // are intentionally swallowed — a stuck cleanup must not block
+        // the response from finishing.
+        if (onResponseFinished) {
+            onResponseFinished().catch(() => { });
+        }
+    }
 }
 /** Non-streaming chat mode — single OpenAI-format JSON response. */
 export async function runNonStreamingChatCompletion(c, exec) {