@jait/gateway 0.1.227 → 0.1.229

package/dist/routes/chat.js

@@ -687,7 +687,7 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
                 ? body["session_id"]
                 : randomUUID();
         const chatMode = isValidChatMode(body["mode"]) ? body["mode"] : "agent";
-        const requestProvider = typeof body["provider"] === "string"
+        let requestProvider = typeof body["provider"] === "string"
             ? body["provider"]
             : undefined;
         const requestRuntimeMode = parseRuntimeMode(body["runtimeMode"]);
@@ -717,12 +717,21 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
             }
         }
         const userApiKeys = userService?.getSettings(authUser.id).apiKeys ?? {};
-        const effectiveModel = userApiKeys["OPENAI_MODEL"]?.trim() || config.openaiModel;
+        const requestBodyModel = typeof body["model"] === "string" ? body["model"].trim() : "";
+        const effectiveModel = requestBodyModel || userApiKeys["OPENAI_MODEL"]?.trim() || config.openaiModel;
+        // When the selected model looks like an OpenRouter model (contains "/"),
+        // route through OpenRouter using the user's OpenRouter API key.
+        const isOpenRouterModel = effectiveModel.includes("/");
+        const openRouterKey = userApiKeys["OPENROUTER_API_KEY"]?.trim();
         const llmRuntime = {
-            openaiApiKey: userApiKeys["OPENAI_API_KEY"]?.trim() || config.openaiApiKey,
-            openaiBaseUrl: userApiKeys["OPENAI_BASE_URL"]?.trim() || config.openaiBaseUrl,
+            openaiApiKey: isOpenRouterModel && openRouterKey
+                ? openRouterKey
+                : (userApiKeys["OPENAI_API_KEY"]?.trim() || config.openaiApiKey),
+            openaiBaseUrl: isOpenRouterModel && openRouterKey
+                ? "https://openrouter.ai/api/v1"
+                : (userApiKeys["OPENAI_BASE_URL"]?.trim() || config.openaiBaseUrl),
             openaiModel: effectiveModel,
-            contextWindow: userApiKeys["OPENAI_MODEL"]?.trim()
+            contextWindow: (requestBodyModel || userApiKeys["OPENAI_MODEL"]?.trim())
                 ? inferContextWindow(effectiveModel)
                 : config.contextWindow,
         };
@@ -828,6 +837,7 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
         const steering = new SteeringController();
         sessionSteeringControllers.set(sessionId, steering);
         try {
+            let usedCliProvider = false;
             // ══ CLI Provider path (codex / claude-code via MCP) ══════════
             if (requestProvider && requestProvider !== "jait" && providerRegistry) {
                 const cliWsRoot = surfaceRegistry
@@ -869,317 +879,321 @@ export function registerChatRoutes(app, config, depsOrDb, sessionServiceArg) {
                 const runtimeMode = resolveProviderRuntimeMode(cliProvider, requestRuntimeMode);
                 const available = await cliProvider.checkAvailability();
                 if (!available) {
-                    safeWrite(`data: ${JSON.stringify({ type: "error", message: `Provider ${requestProvider} is not available${isRemote ? " on the remote node" : ""}: ${cliProvider.info.unavailableReason ?? "CLI not found"}` })}\n\n`);
-                    reply.raw.end();
-                    return;
-                }
-                console.log(`[chat/cli] session=${sessionId} wsRoot="${cliWsRoot}" session.workspacePath="${sessionRecord?.workspacePath}" surfaces=${surfaceRegistry?.getBySession(sessionId)?.length ?? 0}`);
-                // Ensure a FileSystemSurface exists for this session so we can
-                // back up files before CLI providers (Codex/Claude) write them,
-                // enabling the keep/discard (undo) flow.
-                // Use _skipBroadcast so the UI doesn't open the workspace panel.
-                let cliFsSurface = null;
-                if (surfaceRegistry) {
-                    const fsId = `fs-${sessionId}`;
-                    const existing = surfaceRegistry.getSurface(fsId);
-                    if (existing instanceof FileSystemSurface && existing.state === "running") {
-                        cliFsSurface = existing;
-                    }
-                    else {
-                        try {
-                            const prevHandler = surfaceRegistry.onSurfaceStarted;
-                            surfaceRegistry.onSurfaceStarted = null;
-                            const started = await surfaceRegistry.startSurface("filesystem", fsId, {
-                                sessionId,
-                                workspaceRoot: cliWsRoot,
-                            });
-                            surfaceRegistry.onSurfaceStarted = prevHandler;
-                            cliFsSurface = started;
-                        }
-                        catch { /* best effort */ }
-                    }
-                }
-                const mcpServers = [providerRegistry.buildJaitMcpServerRef(config, getRequestBaseUrl(request), {
-                        sessionId,
-                        workspaceRoot: cliWsRoot,
-                    })];
-                // ── Reuse an existing CLI session if one is alive for this Jait session ──
-                const cachedCliSession = activeCliSessions.get(sessionId);
-                let providerSessionId;
-                if (cachedCliSession && cachedCliSession.providerId === requestProvider && cachedCliSession.runtimeMode === runtimeMode) {
-                    // Existing session with the same provider — try to reuse it
-                    providerSessionId = cachedCliSession.providerSessionId;
-                    cliProvider = cachedCliSession.provider;
-                    console.log(`[chat/cli] Reusing ${requestProvider}/${runtimeMode} session ${providerSessionId} for ${sessionId}`);
+                    // Provider is offline or not installed — fall back to Jait
+                    const reason = cliProvider.info.unavailableReason ?? "CLI not found";
+                    console.log(`[chat/cli] Provider ${requestProvider} unavailable (${reason}), falling back to jait`);
+                    safeWrite(`data: ${JSON.stringify({ type: "provider_fallback", from: requestProvider, to: "jait", reason })}\n\n`);
                 }
                 else {
-                    // If the user switched providers, stop the old session first
-                    if (cachedCliSession) {
-                        try {
-                            await cachedCliSession.provider.stopSession(cachedCliSession.providerSessionId);
+                    console.log(`[chat/cli] session=${sessionId} wsRoot="${cliWsRoot}" session.workspacePath="${sessionRecord?.workspacePath}" surfaces=${surfaceRegistry?.getBySession(sessionId)?.length ?? 0}`);
+                    // Ensure a FileSystemSurface exists for this session so we can
+                    // back up files before CLI providers (Codex/Claude) write them,
+                    // enabling the keep/discard (undo) flow.
+                    // Use _skipBroadcast so the UI doesn't open the workspace panel.
+                    let cliFsSurface = null;
+                    if (surfaceRegistry) {
+                        const fsId = `fs-${sessionId}`;
+                        const existing = surfaceRegistry.getSurface(fsId);
+                        if (existing instanceof FileSystemSurface && existing.state === "running") {
+                            cliFsSurface = existing;
+                        }
+                        else {
+                            try {
+                                const prevHandler = surfaceRegistry.onSurfaceStarted;
+                                surfaceRegistry.onSurfaceStarted = null;
+                                const started = await surfaceRegistry.startSurface("filesystem", fsId, {
+                                    sessionId,
+                                    workspaceRoot: cliWsRoot,
+                                });
+                                surfaceRegistry.onSurfaceStarted = prevHandler;
+                                cliFsSurface = started;
+                            }
+                            catch { /* best effort */ }
                         }
-                        catch { /* best effort */ }
-                        activeCliSessions.delete(sessionId);
-                    }
-                    const session = await cliProvider.startSession({
-                        threadId: sessionId,
-                        workingDirectory: cliWsRoot,
-                        mode: runtimeMode,
-                        model: typeof body["model"] === "string" ? body["model"] : undefined,
-                        mcpServers,
-                    });
-                    providerSessionId = session.id;
-                    activeCliSessions.set(sessionId, { providerId: requestProvider, runtimeMode, providerSessionId, provider: cliProvider });
-                    console.log(`[chat/cli] Started new ${requestProvider}/${runtimeMode}${isRemote ? " (remote)" : ""} session ${providerSessionId} for ${sessionId}`);
-                }
-                // Tell the frontend about the execution context (node, workspace)
-                safeWrite(`data: ${JSON.stringify({
-                    type: "session_info",
-                    provider: requestProvider,
-                    workspacePath: cliWsRoot,
-                    isRemote,
-                    ...(remoteNodeInfo ? { remoteNode: remoteNodeInfo } : {}),
-                })}\n\n`);
-                // Collect full content from CLI provider events
-                const contentChunks = [];
-                /** Bytes received via streaming `token` events for the current message block.
-                 *  Reset when a tool starts so we can correctly detect the next message block. */
-                let tokenBytesThisBlock = 0;
-                // ── Accumulate tool calls + segments for persistence ──
-                const cliToolCalls = [];
-                const cliSegments = [];
-                /** Track the current pending tool-group callIds (batched between text tokens) */
-                let pendingToolGroup = [];
-                let lastSegmentWasText = false;
-                /** Flush any buffered text into a text segment */
-                const flushTextSegment = () => {
-                    if (lastSegmentWasText)
-                        return; // already flushed
-                    const text = contentChunks.join("");
-                    // Only create a segment if there's new text since the last tool group
-                    const prevTextLen = cliSegments
-                        .filter((s) => s.type === "text")
-                        .reduce((n, s) => n + s.content.length, 0);
-                    const newText = text.slice(prevTextLen);
-                    if (newText) {
-                        cliSegments.push({ type: "text", content: newText });
                     }
-                    lastSegmentWasText = true;
-                };
-                /** Flush any pending tool group into a segment */
-                const flushToolGroup = () => {
-                    if (pendingToolGroup.length > 0) {
-                        // Before adding a tool group, flush any preceding text
-                        flushTextSegment();
-                        cliSegments.push({ type: "toolGroup", callIds: [...pendingToolGroup] });
-                        pendingToolGroup = [];
-                        lastSegmentWasText = false;
+                    const mcpServers = [providerRegistry.buildJaitMcpServerRef(config, getRequestBaseUrl(request), {
+                            sessionId,
+                            workspaceRoot: cliWsRoot,
+                        })];
+                    // ── Reuse an existing CLI session if one is alive for this Jait session ──
+                    const cachedCliSession = activeCliSessions.get(sessionId);
+                    let providerSessionId;
+                    if (cachedCliSession && cachedCliSession.providerId === requestProvider && cachedCliSession.runtimeMode === runtimeMode) {
+                        // Existing session with the same provider — try to reuse it
+                        providerSessionId = cachedCliSession.providerSessionId;
+                        cliProvider = cachedCliSession.provider;
+                        console.log(`[chat/cli] Reusing ${requestProvider}/${runtimeMode} session ${providerSessionId} for ${sessionId}`);
                     }
-                };
-                const unsubscribe = cliProvider.onEvent((event) => {
-                    if (event.sessionId !== providerSessionId) {
-                        return;
-                    }
-                    // Map provider events to SSE events the frontend understands
-                    switch (event.type) {
-                        case "token":
-                            // If there's a pending tool group, flush it first
-                            flushToolGroup();
-                            contentChunks.push(event.content);
-                            tokenBytesThisBlock += event.content.length;
-                            lastSegmentWasText = false; // new text arrived
-                            accumulateToken(sessionId, event.content);
-                            safeWrite(`data: ${JSON.stringify({ type: "token", content: event.content })}\n\n`);
-                            emitToSubscribers(sessionId, { type: "token", content: event.content });
-                            break;
-                        case "tool.start": {
-                            // Reset token counter — any subsequent message event for a NEW
-                            // agent response (after tools run) should be emitted if no
-                            // tokens were streamed for it.
-                            tokenBytesThisBlock = 0;
-                            const callId = event.callId ?? `cli-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-                            // Accumulate for persistence
-                            cliToolCalls.push({
-                                callId,
-                                tool: event.tool,
-                                args: event.args ?? {},
-                                ok: true,
-                                message: "",
-                                startedAt: Date.now(),
-                            });
-                            pendingToolGroup.push(callId);
-                            // Save backup of the original file before external providers mutate it.
-                            const mutationPath = getExternalFileMutationPath(event.tool, event.args);
-                            if (mutationPath && cliFsSurface) {
-                                cliFsSurface.saveExternalBackup(mutationPath).catch(() => { });
+                    else {
+                        // If the user switched providers, stop the old session first
+                        if (cachedCliSession) {
+                            try {
+                                await cachedCliSession.provider.stopSession(cachedCliSession.providerSessionId);
                             }
-                            safeWrite(`data: ${JSON.stringify({ type: "tool_start", call_id: callId, tool: event.tool, args: event.args })}\n\n`);
-                            emitToSubscribers(sessionId, { type: "tool_start", call_id: callId, tool: event.tool, args: event.args });
-                            accumulateToolStart(sessionId, callId, event.tool, event.args ?? {});
-                            break;
+                            catch { /* best effort */ }
+                            activeCliSessions.delete(sessionId);
                         }
-                        case "tool.output": {
-                            // Accumulate streaming output on the matching tool call
-                            const tc = cliToolCalls.find(t => t.callId === event.callId);
-                            if (tc) {
-                                tc.message = (tc.message || "") + event.content;
-                            }
-                            accumulateToolOutput(sessionId, event.callId ?? "", event.content);
-                            safeWrite(`data: ${JSON.stringify({ type: "tool_output", call_id: event.callId, content: event.content })}\n\n`);
-                            break;
+                        const session = await cliProvider.startSession({
+                            threadId: sessionId,
+                            workingDirectory: cliWsRoot,
+                            mode: runtimeMode,
+                            model: typeof body["model"] === "string" ? body["model"] : undefined,
+                            mcpServers,
+                        });
+                        providerSessionId = session.id;
+                        activeCliSessions.set(sessionId, { providerId: requestProvider, runtimeMode, providerSessionId, provider: cliProvider });
+                        console.log(`[chat/cli] Started new ${requestProvider}/${runtimeMode}${isRemote ? " (remote)" : ""} session ${providerSessionId} for ${sessionId}`);
+                    }
+                    // Tell the frontend about the execution context (node, workspace)
+                    safeWrite(`data: ${JSON.stringify({
+                        type: "session_info",
+                        provider: requestProvider,
+                        workspacePath: cliWsRoot,
+                        isRemote,
+                        ...(remoteNodeInfo ? { remoteNode: remoteNodeInfo } : {}),
+                    })}\n\n`);
+                    // Collect full content from CLI provider events
+                    const contentChunks = [];
+                    /** Bytes received via streaming `token` events for the current message block.
+                     *  Reset when a tool starts so we can correctly detect the next message block. */
+                    let tokenBytesThisBlock = 0;
+                    // ── Accumulate tool calls + segments for persistence ──
+                    const cliToolCalls = [];
+                    const cliSegments = [];
+                    /** Track the current pending tool-group callIds (batched between text tokens) */
+                    let pendingToolGroup = [];
+                    let lastSegmentWasText = false;
+                    /** Flush any buffered text into a text segment */
+                    const flushTextSegment = () => {
+                        if (lastSegmentWasText)
+                            return; // already flushed
+                        const text = contentChunks.join("");
+                        // Only create a segment if there's new text since the last tool group
+                        const prevTextLen = cliSegments
+                            .filter((s) => s.type === "text")
+                            .reduce((n, s) => n + s.content.length, 0);
+                        const newText = text.slice(prevTextLen);
+                        if (newText) {
+                            cliSegments.push({ type: "text", content: newText });
                         }
-                        case "tool.result": {
-                            const resultCallId = event.callId ?? `cli-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-                            // Update the matching tool call record
-                            const tc = cliToolCalls.find(t => t.callId === resultCallId);
-                            if (tc) {
-                                tc.ok = event.ok;
-                                tc.message = event.message || tc.message;
-                                tc.data = event.data;
-                                tc.completedAt = Date.now();
+                        lastSegmentWasText = true;
+                    };
+                    /** Flush any pending tool group into a segment */
+                    const flushToolGroup = () => {
+                        if (pendingToolGroup.length > 0) {
+                            // Before adding a tool group, flush any preceding text
+                            flushTextSegment();
+                            cliSegments.push({ type: "toolGroup", callIds: [...pendingToolGroup] });
+                            pendingToolGroup = [];
+                            lastSegmentWasText = false;
+                        }
+                    };
+                    const unsubscribe = cliProvider.onEvent((event) => {
+                        if (event.sessionId !== providerSessionId) {
+                            return;
+                        }
+                        // Map provider events to SSE events the frontend understands
+                        switch (event.type) {
+                            case "token":
+                                // If there's a pending tool group, flush it first
+                                flushToolGroup();
+                                contentChunks.push(event.content);
+                                tokenBytesThisBlock += event.content.length;
+                                lastSegmentWasText = false; // new text arrived
+                                accumulateToken(sessionId, event.content);
+                                safeWrite(`data: ${JSON.stringify({ type: "token", content: event.content })}\n\n`);
+                                emitToSubscribers(sessionId, { type: "token", content: event.content });
+                                break;
+                            case "tool.start": {
+                                // Reset token counter — any subsequent message event for a NEW
+                                // agent response (after tools run) should be emitted if no
+                                // tokens were streamed for it.
+                                tokenBytesThisBlock = 0;
+                                const callId = event.callId ?? `cli-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                                // Accumulate for persistence
+                                cliToolCalls.push({
+                                    callId,
+                                    tool: event.tool,
+                                    args: event.args ?? {},
+                                    ok: true,
+                                    message: "",
+                                    startedAt: Date.now(),
+                                });
+                                pendingToolGroup.push(callId);
+                                // Save backup of the original file before external providers mutate it.
+                                const mutationPath = getExternalFileMutationPath(event.tool, event.args);
+                                if (mutationPath && cliFsSurface) {
+                                    cliFsSurface.saveExternalBackup(mutationPath).catch(() => { });
+                                }
+                                safeWrite(`data: ${JSON.stringify({ type: "tool_start", call_id: callId, tool: event.tool, args: event.args })}\n\n`);
+                                emitToSubscribers(sessionId, { type: "tool_start", call_id: callId, tool: event.tool, args: event.args });
+                                accumulateToolStart(sessionId, callId, event.tool, event.args ?? {});
+                                break;
                             }
-                            safeWrite(`data: ${JSON.stringify({ type: "tool_result", call_id: resultCallId, tool: event.tool, ok: event.ok, message: event.message, data: event.data })}\n\n`);
-                            emitToSubscribers(sessionId, { type: "tool_result", call_id: resultCallId, tool: event.tool, ok: event.ok, message: event.message, data: event.data });
-                            accumulateToolResult(sessionId, resultCallId, event.ok, event.message || "", event.data);
-                            // Emit todo_list event for TodoWrite (normalized to "todo") tool calls
-                            if (event.ok && (tc?.tool === "todo" || event.tool === "todo")) {
-                                const rawTodos = tc?.args?.["todos"];
-                                if (Array.isArray(rawTodos)) {
-                                    const items = rawTodos.map((t, i) => ({
-                                        id: typeof t["id"] === "number" ? t["id"] : i,
-                                        title: String(t["content"] ?? t["title"] ?? ""),
-                                        status: t["status"] === "in_progress" ? "in-progress" : t["status"] === "completed" ? "completed" : "not-started",
-                                    }));
-                                    const todoListEvent = { type: "todo_list", items };
-                                    safeWrite(`data: ${JSON.stringify(todoListEvent)}\n\n`);
-                                    emitToSubscribers(sessionId, todoListEvent);
-                                    if (sessionStateService) {
-                                        try {
-                                            sessionStateService.set(sessionId, { "todo_list": items });
+                            case "tool.output": {
+                                // Accumulate streaming output on the matching tool call
+                                const tc = cliToolCalls.find(t => t.callId === event.callId);
+                                if (tc) {
+                                    tc.message = (tc.message || "") + event.content;
+                                }
+                                accumulateToolOutput(sessionId, event.callId ?? "", event.content);
+                                safeWrite(`data: ${JSON.stringify({ type: "tool_output", call_id: event.callId, content: event.content })}\n\n`);
+                                break;
+                            }
+                            case "tool.result": {
+                                const resultCallId = event.callId ?? `cli-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                                // Update the matching tool call record
+                                const tc = cliToolCalls.find(t => t.callId === resultCallId);
+                                if (tc) {
+                                    tc.ok = event.ok;
+                                    tc.message = event.message || tc.message;
+                                    tc.data = event.data;
+                                    tc.completedAt = Date.now();
+                                }
+                                safeWrite(`data: ${JSON.stringify({ type: "tool_result", call_id: resultCallId, tool: event.tool, ok: event.ok, message: event.message, data: event.data })}\n\n`);
+                                emitToSubscribers(sessionId, { type: "tool_result", call_id: resultCallId, tool: event.tool, ok: event.ok, message: event.message, data: event.data });
+                                accumulateToolResult(sessionId, resultCallId, event.ok, event.message || "", event.data);
+                                // Emit todo_list event for TodoWrite (normalized to "todo") tool calls
+                                if (event.ok && (tc?.tool === "todo" || event.tool === "todo")) {
+                                    const rawTodos = tc?.args?.["todos"];
+                                    if (Array.isArray(rawTodos)) {
+                                        const items = rawTodos.map((t, i) => ({
+                                            id: typeof t["id"] === "number" ? t["id"] : i,
+                                            title: String(t["content"] ?? t["title"] ?? ""),
+                                            status: t["status"] === "in_progress" ? "in-progress" : t["status"] === "completed" ? "completed" : "not-started",
+                                        }));
+                                        const todoListEvent = { type: "todo_list", items };
+                                        safeWrite(`data: ${JSON.stringify(todoListEvent)}\n\n`);
+                                        emitToSubscribers(sessionId, todoListEvent);
+                                        if (sessionStateService) {
+                                            try {
+                                                sessionStateService.set(sessionId, { "todo_list": items });
+                                            }
+                                            catch { /* ignore */ }
+                                        }
+                                        if (ws) {
+                                            ws.broadcast(sessionId, {
+                                                type: "ui.state-sync",
+                                                sessionId,
+                                                timestamp: new Date().toISOString(),
+                                                payload: { key: "todo_list", value: items },
+                                            });
                                         }
-                                        catch { /* ignore */ }
                                     }
+                                }
+                                // Emit file_changed for successful external file mutations.
+                                const mutationPath = getExternalFileMutationPath(tc?.tool ?? event.tool, tc?.args ?? {});
+                                if (event.ok && mutationPath) {
+                                    const editName = mutationPath.split(/[\/\\]/).pop() ?? mutationPath;
+                                    safeWrite(`data: ${JSON.stringify({ type: "file_changed", path: mutationPath, name: editName })}\n\n`);
+                                    // Broadcast to other session clients
                                     if (ws) {
                                         ws.broadcast(sessionId, {
                                             type: "ui.state-sync",
                                             sessionId,
                                             timestamp: new Date().toISOString(),
-                                            payload: { key: "todo_list", value: items },
+                                            payload: { key: "file_changed", value: { path: mutationPath, name: editName } },
                                         });
                                     }
-                                }
-                            }
-                            // Emit file_changed for successful external file mutations.
-                            const mutationPath = getExternalFileMutationPath(tc?.tool ?? event.tool, tc?.args ?? {});
-                            if (event.ok && mutationPath) {
-                                const editName = mutationPath.split(/[\/\\]/).pop() ?? mutationPath;
-                                safeWrite(`data: ${JSON.stringify({ type: "file_changed", path: mutationPath, name: editName })}\n\n`);
-                                // Broadcast to other session clients
-                                if (ws) {
-                                    ws.broadcast(sessionId, {
-                                        type: "ui.state-sync",
-                                        sessionId,
-                                        timestamp: new Date().toISOString(),
-                                        payload: { key: "file_changed", value: { path: mutationPath, name: editName } },
-                                    });
-                                }
-                                // Persist cumulative changed files list
-                                if (sessionStateService) {
-                                    try {
-                                        const existing = sessionStateService.get(sessionId, ["changed_files"]);
-                                        const files = Array.isArray(existing["changed_files"]) ? existing["changed_files"] : [];
-                                        if (!files.some((f) => f.path === mutationPath)) {
-                                            files.push({ path: mutationPath, name: editName });
-                                            sessionStateService.set(sessionId, { changed_files: files });
+                                    // Persist cumulative changed files list
+                                    if (sessionStateService) {
+                                        try {
+                                            const existing = sessionStateService.get(sessionId, ["changed_files"]);
+                                            const files = Array.isArray(existing["changed_files"]) ? existing["changed_files"] : [];
+                                            if (!files.some((f) => f.path === mutationPath)) {
+                                                files.push({ path: mutationPath, name: editName });
+                                                sessionStateService.set(sessionId, { changed_files: files });
+                                            }
                                         }
+                                        catch { /* ignore */ }
                                     }
-                                    catch { /* ignore */ }
                                 }
+                                break;
                             }
-                            break;
-                        }
-                        case "tool.approval-required":
-                            safeWrite(`data: ${JSON.stringify({ type: "approval_required", tool: event.tool, args: event.args, requestId: event.requestId })}\n\n`);
-                            break;
-                        case "message":
-                            if (event.role === "assistant" && event.content) {
-                                flushToolGroup();
-                                // `message` events carry the *complete* text of an agent message.
-                                // If token deltas already streamed this content, skip to avoid
-                                // doubling the persisted text. Only use as fallback when Codex
-                                // sends a complete message without preceding token deltas.
-                                if (tokenBytesThisBlock === 0) {
-                                    contentChunks.push(event.content);
-                                    safeWrite(`data: ${JSON.stringify({ type: "token", content: event.content })}\n\n`);
-                                    emitToSubscribers(sessionId, { type: "token", content: event.content });
+                            case "tool.approval-required":
+                                safeWrite(`data: ${JSON.stringify({ type: "approval_required", tool: event.tool, args: event.args, requestId: event.requestId })}\n\n`);
+                                break;
+                            case "message":
+                                if (event.role === "assistant" && event.content) {
+                                    flushToolGroup();
+                                    // `message` events carry the *complete* text of an agent message.
+                                    // If token deltas already streamed this content, skip to avoid
+                                    // doubling the persisted text. Only use as fallback when Codex
+                                    // sends a complete message without preceding token deltas.
+                                    if (tokenBytesThisBlock === 0) {
+                                        contentChunks.push(event.content);
+                                        safeWrite(`data: ${JSON.stringify({ type: "token", content: event.content })}\n\n`);
+                                        emitToSubscribers(sessionId, { type: "token", content: event.content });
+                                    }
+                                    lastSegmentWasText = false;
                                 }
-                                lastSegmentWasText = false;
-                            }
-                            break;
-                        case "session.error":
-                            safeWrite(`data: ${JSON.stringify({ type: "error", message: event.error })}\n\n`);
-                            break;
-                    }
-                });
-                // Send the turn — with recovery if the cached session died between messages
-                try {
-                    await cliProvider.sendTurn(providerSessionId, content);
-                }
-                catch (sendErr) {
-                    // Session likely died (process exited) — start a fresh one
-                    console.warn(`[chat/cli] sendTurn failed on cached session, recovering:`, sendErr);
-                    activeCliSessions.delete(sessionId);
-                    const freshSession = await cliProvider.startSession({
-                        threadId: sessionId,
-                        workingDirectory: cliWsRoot,
-                        mode: runtimeMode,
-                        model: typeof body["model"] === "string" ? body["model"] : undefined,
-                        mcpServers,
-                    });
-                    providerSessionId = freshSession.id;
-                    activeCliSessions.set(sessionId, { providerId: requestProvider, runtimeMode, providerSessionId, provider: cliProvider });
-                    console.log(`[chat/cli] Recovered with new ${requestProvider}/${runtimeMode} session ${providerSessionId}`);
-                    await cliProvider.sendTurn(providerSessionId, content);
-                }
-                // Wait for turn completion or error
-                await new Promise((resolve) => {
-                    const checkDone = cliProvider.onEvent((event) => {
-                        if (event.sessionId !== providerSessionId) {
-                            return;
+                                break;
+                            case "session.error":
+                                safeWrite(`data: ${JSON.stringify({ type: "error", message: event.error })}\n\n`);
+                                break;
                         }
-                        if (event.type === "session.completed" || event.type === "session.error" || event.type === "turn.completed") {
-                            // If the session errored, invalidate the cache so the next message creates a fresh one
-                            if (event.type === "session.error") {
-                                activeCliSessions.delete(sessionId);
+                    });
+                    // Send the turn — with recovery if the cached session died between messages
+                    try {
+                        await cliProvider.sendTurn(providerSessionId, content);
+                    }
+                    catch (sendErr) {
+                        // Session likely died (process exited) — start a fresh one
+                        console.warn(`[chat/cli] sendTurn failed on cached session, recovering:`, sendErr);
+                        activeCliSessions.delete(sessionId);
+                        const freshSession = await cliProvider.startSession({
+                            threadId: sessionId,
+                            workingDirectory: cliWsRoot,
+                            mode: runtimeMode,
+                            model: typeof body["model"] === "string" ? body["model"] : undefined,
+                            mcpServers,
+                        });
+                        providerSessionId = freshSession.id;
+                        activeCliSessions.set(sessionId, { providerId: requestProvider, runtimeMode, providerSessionId, provider: cliProvider });
+                        console.log(`[chat/cli] Recovered with new ${requestProvider}/${runtimeMode} session ${providerSessionId}`);
+                        await cliProvider.sendTurn(providerSessionId, content);
+                    }
+                    // Wait for turn completion or error
+                    await new Promise((resolve) => {
+                        const checkDone = cliProvider.onEvent((event) => {
+                            if (event.sessionId !== providerSessionId) {
+                                return;
                             }
-                            checkDone();
+                            if (event.type === "session.completed" || event.type === "session.error" || event.type === "turn.completed") {
+                                // If the session errored, invalidate the cache so the next message creates a fresh one
+                                if (event.type === "session.error") {
+                                    activeCliSessions.delete(sessionId);
+                                }
+                                checkDone();
+                                resolve();
+                            }
+                        });
+                        // Also abort if client disconnects
+                        streamAbort.signal.addEventListener("abort", () => {
+                            cliProvider.interruptTurn(providerSessionId).catch(() => { });
                             resolve();
-                        }
+                        });
                     });
-                    // Also abort if client disconnects
-                    streamAbort.signal.addEventListener("abort", () => {
-                        cliProvider.interruptTurn(providerSessionId).catch(() => { });
-                        resolve();
-                    });
-                });
-                unsubscribe();
-                fullContent = contentChunks.join("");
-                // Flush any remaining tool group / trailing text into segments
-                flushToolGroup();
-                flushTextSegment();
-                // Build persistence JSON
-                const cliTcJson = cliToolCalls.length > 0 ? JSON.stringify(cliToolCalls) : undefined;
-                const cliSegJson = cliSegments.length > 0 ? JSON.stringify(cliSegments) : undefined;
-                // Also stash on the outer scope so the done handler can emit them
-                partialToolCalls = cliToolCalls;
-                resultSegmentsJson = cliSegJson;
-                // Persist assistant message with tool calls and segments
-                history.push({ role: "assistant", content: fullContent, uiToolCalls: cliToolCalls.length > 0 ? cliToolCalls : undefined });
-                persistMessage(sessionId, "assistant", fullContent, cliTcJson, cliSegJson);
-                // Session stays alive for the next turn — do NOT stop it.
-                // It will be cleaned up on session error, provider switch, or server shutdown.
+                    unsubscribe();
+                    fullContent = contentChunks.join("");
+                    // Flush any remaining tool group / trailing text into segments
+                    flushToolGroup();
+                    flushTextSegment();
+                    // Build persistence JSON
+                    const cliTcJson = cliToolCalls.length > 0 ? JSON.stringify(cliToolCalls) : undefined;
+                    const cliSegJson = cliSegments.length > 0 ? JSON.stringify(cliSegments) : undefined;
+                    // Also stash on the outer scope so the done handler can emit them
+                    partialToolCalls = cliToolCalls;
+                    resultSegmentsJson = cliSegJson;
+                    // Persist assistant message with tool calls and segments
+                    history.push({ role: "assistant", content: fullContent, uiToolCalls: cliToolCalls.length > 0 ? cliToolCalls : undefined });
+                    persistMessage(sessionId, "assistant", fullContent, cliTcJson, cliSegJson);
+                    // Session stays alive for the next turn — do NOT stop it.
+                    // It will be cleaned up on session error, provider switch, or server shutdown.
+                    usedCliProvider = true;
+                } // end availability else
             }
-            else if (config.llmProvider === "openai") {
+            if (!usedCliProvider && config.llmProvider === "openai") {
                 // ══ OpenAI agentic loop (using extracted runAgentLoop) ═════
                 // Build tiered schemas per request — respects user-disabled tools
                 const userSettings = userService?.getSettings(authUser.id);