opencandle 0.7.0 → 0.9.0

package/gui/server/invoke-tool.ts

@@ -8,6 +8,12 @@ import { wrapWithDefaults } from "../../src/runtime/tool-defaults-wrapper.js";
 import { getAllTools } from "../../src/tools/index.js";
 import type { AskUserHandler } from "../../src/types/index.js";
 import { buildToolInvokeAckMessage } from "./tool-invoke-ack.js";
+import {
+  acquireWriterLock,
+  refreshWriterLock,
+  releaseWriterLock,
+  writerLockScopeForSession,
+} from "./writer-lock.js";
 
 export interface InvokeToolResult {
   toolCallId: string;
@@ -20,7 +26,11 @@ interface ToolInvokeClient {
 }
 
 export interface ToolInvokeController {
-  handleToolInvoke(toolName: string, args: Record<string, unknown>): Promise<InvokeToolResult>;
+  handleToolInvoke(
+    toolName: string,
+    args: Record<string, unknown>,
+    sessionId?: string,
+  ): Promise<InvokeToolResult>;
   handleToolInvokeMessage(client: ToolInvokeClient, data: Record<string, unknown>): Promise<void>;
 }
 
@@ -32,6 +42,10 @@ export interface ToolInvokeControllerOptions {
   getTools?: typeof getAllTools;
   invokeTool?: typeof invokeToolFromUi;
   askUserHandler?: AskUserHandler;
+  askUserHandlerForSessionId?: (sessionId: string) => AskUserHandler;
+  resolveSessionManager?: (sessionId: string) => Promise<SessionManager | null>;
+  broadcastSessionSnapshot?: (sessionManager: SessionManager) => void;
+  broadcastSessions?: () => void;
 }
 
 export function createToolInvokeController({
@@ -42,20 +56,63 @@ export function createToolInvokeController({
   getTools = getAllTools,
   invokeTool = invokeToolFromUi,
   askUserHandler,
+  askUserHandlerForSessionId,
+  resolveSessionManager,
+  broadcastSessionSnapshot,
+  broadcastSessions,
 }: ToolInvokeControllerOptions): ToolInvokeController {
   async function handleToolInvoke(
     toolName: string,
     args: Record<string, unknown>,
+    sessionId = "",
   ): Promise<InvokeToolResult> {
     if (role !== "writer") throw new Error("Read-only follower mode");
     const tool = getTools().find((candidate) => candidate.name === toolName);
     if (!tool) throw new Error(`Unknown tool: ${toolName}`);
-    const result = await invokeTool(getSessionManager(), tool, args, "ui", { askUserHandler });
-    if (!result.isError && marketStateToolMapping(toolName) != null) {
-      onMarketStateChanged?.();
+
+    const currentSessionManager = getSessionManager();
+    const runSessionManager = await resolveToolInvokeSessionManager(
+      currentSessionManager,
+      sessionId,
+      resolveSessionManager,
+    );
+    const useCurrentSession = sameSessionStorage(currentSessionManager, runSessionManager);
+    let acquiredLockScope = "";
+    let lockHeartbeat: ReturnType<typeof setInterval> | undefined;
+    if (!useCurrentSession) {
+      const lockScope = writerLockScopeForSession(runSessionManager);
+      const lockResult = await acquireWriterLock(lockScope, "gui");
+      if (lockResult.role !== "writer") {
+        throw new Error(
+          `Session is currently being written by ${lockResult.lock.processKind} (pid ${lockResult.lock.pid}).`,
+        );
+      }
+      acquiredLockScope = lockScope;
+      lockHeartbeat = setInterval(() => refreshWriterLock(lockScope), 5000);
+    }
+
+    try {
+      const runSessionId = safeSessionId(runSessionManager);
+      const result = await invokeTool(runSessionManager, tool, args, "ui", {
+        askUserHandler:
+          runSessionId && askUserHandlerForSessionId
+            ? askUserHandlerForSessionId(runSessionId)
+            : askUserHandler,
+      });
+      if (!result.isError && marketStateToolMapping(toolName) != null) {
+        onMarketStateChanged?.();
+      }
+      if (useCurrentSession) {
+        broadcastState();
+      } else {
+        broadcastSessionSnapshot?.(runSessionManager);
+        broadcastSessions?.();
+      }
+      return result;
+    } finally {
+      if (lockHeartbeat) clearInterval(lockHeartbeat);
+      if (acquiredLockScope) releaseWriterLock(acquiredLockScope);
     }
-    broadcastState();
-    return result;
   }
 
   async function handleToolInvokeMessage(
@@ -64,8 +121,9 @@ export function createToolInvokeController({
   ): Promise<void> {
     const requestId = typeof data.requestId === "string" ? data.requestId : "";
     const toolName = String(data.toolName ?? "");
+    const sessionId = typeof data.sessionId === "string" ? data.sessionId : "";
     try {
-      const result = await handleToolInvoke(toolName, requestArgs(data.args));
+      const result = await handleToolInvoke(toolName, requestArgs(data.args), sessionId);
       if (requestId) {
         client.send(buildToolInvokeAckMessage(requestId, toolName, result));
       }
@@ -88,6 +146,43 @@ export function createToolInvokeController({
   return { handleToolInvoke, handleToolInvokeMessage };
 }
 
+function sameSessionStorage(current: SessionManager, target: SessionManager): boolean {
+  if (current === target) return true;
+  const currentFile = safeSessionFile(current);
+  const targetFile = safeSessionFile(target);
+  return Boolean(currentFile && targetFile && currentFile === targetFile);
+}
+
+function safeSessionFile(sessionManager: SessionManager): string {
+  try {
+    return sessionManager.getSessionFile() ?? "";
+  } catch {
+    return "";
+  }
+}
+
+function safeSessionId(sessionManager: SessionManager): string {
+  try {
+    return sessionManager.getSessionId();
+  } catch {
+    return "";
+  }
+}
+
+async function resolveToolInvokeSessionManager(
+  currentSessionManager: SessionManager,
+  sessionId: string,
+  resolveSessionManager: ((sessionId: string) => Promise<SessionManager | null>) | undefined,
+): Promise<SessionManager> {
+  const targetSessionId = sessionId.trim();
+  if (!targetSessionId || targetSessionId === safeSessionId(currentSessionManager)) {
+    return currentSessionManager;
+  }
+  const resolved = await resolveSessionManager?.(targetSessionId);
+  if (!resolved) throw new Error("Unknown saved session");
+  return resolved;
+}
+
 function requestArgs(value: unknown): Record<string, unknown> {
   return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : {};
 }

package/gui/server/live-chat-event-adapter.ts

@@ -29,15 +29,20 @@ export function createLiveChatEventAdapter(
   let lastAssistantMessageId: string | undefined;
   const completedMessageIds = new Set<string>();
 
-  const emit = (event: Omit<ChatEvent, "seq">) => {
-    options.emit({ ...event, seq: seq++ } as ChatEvent);
+  const emit = (event: Omit<ChatEvent, "seq" | "sessionId">) => {
+    options.emit({ ...event, sessionId: options.sessionId, seq: seq++ } as ChatEvent);
   };
 
   const ensureAssistantMessage = (): string => {
     if (currentAssistantMessageId) return currentAssistantMessageId;
     currentAssistantMessageId = `${options.runId}-assistant-${++assistantCount}`;
     lastAssistantMessageId = currentAssistantMessageId;
-    emit({ type: "message.created", messageId: currentAssistantMessageId, role: "assistant" });
+    emit({
+      type: "message.created",
+      runId: options.runId,
+      messageId: currentAssistantMessageId,
+      role: "assistant",
+    });
     return currentAssistantMessageId;
   };
 
@@ -49,6 +54,7 @@ export function createLiveChatEventAdapter(
     completedMessageIds.add(messageId);
     emit({
       type: "message.completed",
+      runId: options.runId,
       messageId,
       content: contentToChatContent(message.content),
     });
@@ -66,9 +72,10 @@ export function createLiveChatEventAdapter(
               userCount === 1 && options.originalPrompt
                 ? options.originalPrompt
                 : messageText(message.content);
-            emit({ type: "message.created", messageId, role: "user" });
+            emit({ type: "message.created", runId: options.runId, messageId, role: "user" });
             emit({
               type: "message.completed",
+              runId: options.runId,
               messageId,
               content: [{ type: "text", text }],
             });
@@ -85,6 +92,7 @@ export function createLiveChatEventAdapter(
           if (update.type === "text_delta") {
             emit({
               type: "message.delta",
+              runId: options.runId,
               messageId: ensureAssistantMessage(),
               text: update.delta,
             });
@@ -116,6 +124,7 @@ export function createLiveChatEventAdapter(
           const messageId = messageIdForTool();
           emit({
             type: "tool.started",
+            runId: options.runId,
             toolCallId: event.toolCallId,
             messageId,
             name: event.toolName,
@@ -127,6 +136,7 @@ export function createLiveChatEventAdapter(
         case "tool_execution_update":
           emit({
             type: "tool.delta",
+            runId: options.runId,
             toolCallId: event.toolCallId,
             chunk: event.partialResult,
           });
@@ -137,6 +147,7 @@ export function createLiveChatEventAdapter(
           if (event.isError) {
             emit({
               type: "tool.failed",
+              runId: options.runId,
               toolCallId: event.toolCallId,
               error: {
                 message: messageText(output.content),
@@ -146,6 +157,7 @@ export function createLiveChatEventAdapter(
           } else {
             emit({
               type: "tool.completed",
+              runId: options.runId,
               toolCallId: event.toolCallId,
               output,
             });

package/gui/server/server.ts

@@ -1,7 +1,6 @@
 import { randomBytes } from "node:crypto";
-import { createReadStream, existsSync } from "node:fs";
-import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
-import { extname, join, resolve } from "node:path";
+import { createServer } from "node:http";
+import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
   AuthStorage,
@@ -9,12 +8,10 @@ import {
   createAgentSessionServices,
   getAgentDir,
   ModelRegistry,
-  SessionManager,
   SettingsManager,
 } from "@earendil-works/pi-coding-agent";
 import { createOpenCandleSession } from "../../src/index.js";
-import { probeProviderStatus } from "../../src/onboarding/provider-status.js";
-import type { ChatEvent } from "../shared/chat-events.js";
+import { assertSupportedNodeVersion } from "../../src/infra/node-version.js";
 import { createAskUserBridge } from "./ask-user-bridge.js";
 import {
   createLocalAutomationHeartbeat,
@@ -25,26 +22,25 @@ import {
   BackgroundQuoteRefreshes,
   createBackgroundQuotePoller,
 } from "./background-quotes.js";
-import { sessionEntriesToChatEvents } from "./chat-event-adapter.js";
-import { chatRunSessionConflict } from "./chat-run-session.js";
 import { createInitialGuiSessionManager } from "./gui-session-manager.js";
+import { createHttpRequestHandler, resolveSessionManagerById } from "./http-routes.js";
 import { createToolInvokeController } from "./invoke-tool.js";
-import { createLiveChatEventAdapter } from "./live-chat-event-adapter.js";
-import {
-  buildMarketStateQuoteSnapshot,
-  buildMarketStateSnapshot,
-  searchInstrumentCandidates,
-} from "./market-state-api.js";
-import { buildModelSetupState, createModelSetupController } from "./model-setup.js";
-import { isTrustedPrivateApiRequest, privateApiCookieHeader } from "./private-api-access.js";
-import { createPromptObservation, observePromptEvent } from "./prompt-observation.js";
+import { buildMarketStateQuoteSnapshot } from "./market-state-api.js";
+import { createModelSetupController } from "./model-setup.js";
+import { isTrustedPrivateApiRequest } from "./private-api-access.js";
 import { QuoteSnapshotStore } from "./quote-snapshot-store.js";
-import { createSessionActionsController, promptAndSettle } from "./session-actions.js";
-import { waitForNewEntryId } from "./session-entry-wait.js";
+import { createSessionActionsController } from "./session-actions.js";
 import { createGracefulShutdown } from "./shutdown.js";
-import { acquireWriterLock, refreshWriterLock, releaseWriterLock } from "./writer-lock.js";
+import {
+  acquireWriterLock,
+  refreshWriterLock,
+  releaseWriterLock,
+  writerLockScopeForSession,
+} from "./writer-lock.js";
 import { createWsHub, type WsHub } from "./ws-hub.js";
 
+assertSupportedNodeVersion();
+
 const cwd = process.cwd();
 const host = process.env.OPENCANDLE_GUI_HOST ?? "127.0.0.1";
 const port = Number(process.env.OPENCANDLE_GUI_PORT ?? 14567);
@@ -63,7 +59,9 @@ const settingsManager = SettingsManager.create(cwd, agentDir);
 const initialSessionManager = createInitialGuiSessionManager(cwd);
 let sessionManager = initialSessionManager;
 const sessionDir = sessionManager.getSessionDir();
-const lockResult = await acquireWriterLock(sessionDir, "gui");
+const initialWriterLockScope = writerLockScopeForSession(sessionManager);
+const lockResult = await acquireWriterLock(initialWriterLockScope, "gui");
+let activeWriterLockScope = initialWriterLockScope;
 let wsHub: WsHub;
 let quotePoller: BackgroundQuotePoller;
 const askUserBridge = createAskUserBridge({
@@ -93,7 +91,7 @@ const runtime = await createAgentSessionRuntime(
   { cwd, agentDir, sessionManager },
 );
 let session = runtime.session;
-const heartbeat = setInterval(() => refreshWriterLock(sessionDir), 5000);
+const heartbeat = setInterval(() => refreshWriterLock(activeWriterLockScope), 5000);
 const backgroundQuoteRefreshes = new BackgroundQuoteRefreshes();
 const quoteSnapshotStore = new QuoteSnapshotStore(() => buildMarketStateQuoteSnapshot());
 quotePoller = createBackgroundQuotePoller({
@@ -117,8 +115,17 @@ const toolInvokeController = createToolInvokeController({
   role: lockResult.role,
   getSessionManager: () => sessionManager,
   broadcastState: () => wsHub.broadcastState(),
+  broadcastSessionSnapshot: (targetSessionManager) =>
+    wsHub.broadcastSessionSnapshot(targetSessionManager),
+  broadcastSessions: () => wsHub.broadcastSessions(),
   onMarketStateChanged: () => quoteSnapshotStore.invalidate(),
   askUserHandler: askUserBridge.ask,
+  askUserHandlerForSessionId: (sessionId) => askUserBridge.askForSession(sessionId),
+  resolveSessionManager: (sessionId) =>
+    resolveSessionManagerById(
+      { cwd, sessionDir, getSessionManager: () => sessionManager },
+      sessionId,
+    ),
 });
 const sessionActionsController = createSessionActionsController({
   role: lockResult.role,
@@ -154,119 +161,54 @@ wsHub = createWsHub({
 
 let unsubscribeSession = wsHub.subscribeToSessionEvents();
 runtime.setRebindSession(async (nextSession) => {
+  const nextWriterLockScope = writerLockScopeForSession(nextSession.sessionManager);
+  if (lockResult.role === "writer" && nextWriterLockScope !== activeWriterLockScope) {
+    const nextLockResult = await acquireWriterLock(nextWriterLockScope, "gui");
+    if (nextLockResult.role !== "writer") {
+      throw new Error(
+        `Session is currently being written by ${nextLockResult.lock.processKind} (pid ${nextLockResult.lock.pid}).`,
+      );
+    }
+    releaseWriterLock(activeWriterLockScope);
+    activeWriterLockScope = nextWriterLockScope;
+  }
   unsubscribeSession();
   session = nextSession;
   sessionManager = nextSession.sessionManager;
   unsubscribeSession = wsHub.subscribeToSessionEvents();
 });
 
-const server = createServer((req, res) => {
-  void handleHttpRequest(req, res);
+const httpRequestHandler = createHttpRequestHandler({
+  host,
+  port,
+  webDist,
+  role: lockResult.role,
+  cwd,
+  agentDir,
+  sessionDir,
+  privateApiSessionToken,
+  allowRemotePrivateApi,
+  getSession: () => session,
+  getSessionManager: () => sessionManager,
+  createSessionForManager: async (targetSessionManager) =>
+    createOpenCandleSession({
+      cwd,
+      agentDir,
+      authStorage,
+      modelRegistry,
+      settingsManager,
+      sessionManager: targetSessionManager,
+      askUserHandler: askUserBridge.askForSession(targetSessionManager.getSessionId()),
+    }),
+  wsHub,
+  modelSetupController,
+  sessionActionsController,
+  quoteSnapshotStore,
 });
 
-async function handleHttpRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
-  const url = new URL(req.url ?? "/", `http://${host}:${port}`);
-  if (url.pathname === "/health") {
-    writeJson(res, { ok: true, role: lockResult.role });
-    return;
-  }
-
-  if (url.pathname === "/api/bootstrap" && req.method === "GET") {
-    if (!allowTrustedGuiRequest(req, res, "Bootstrap API")) return;
-    writeJson(res, await wsHub.buildBootstrapPayload());
-    return;
-  }
-
-  if (url.pathname === "/api/session/new" && req.method === "POST") {
-    if (!allowTrustedGuiRequest(req, res, "Session API")) return;
-    if (lockResult.role !== "writer") {
-      writeJson(res, { error: "Read-only follower mode" }, 409);
-      return;
-    }
-    await sessionActionsController.handleNewSession();
-    wsHub.broadcastState();
-    wsHub.broadcastSessions();
-    writeJson(res, await wsHub.buildBootstrapPayload());
-    return;
-  }
-
-  if (url.pathname === "/api/sessions" && req.method === "GET") {
-    if (!allowTrustedGuiRequest(req, res, "Session API")) return;
-    writeJson(res, {
-      currentSessionId: sessionManager.getSessionId(),
-      role: lockResult.role,
-      sessions: await SessionManager.list(cwd, sessionDir),
-    });
-    return;
-  }
-
-  if (url.pathname === "/api/session/events" && req.method === "GET") {
-    if (!allowTrustedGuiRequest(req, res, "Session API")) return;
-    writeJson(res, {
-      sessionId: sessionManager.getSessionId(),
-      role: lockResult.role,
-      events: wsHub.currentChatEvents(),
-    });
-    return;
-  }
-
-  if (url.pathname === "/api/market-state" && req.method === "GET") {
-    if (!allowTrustedGuiRequest(req, res, "Market-state API")) return;
-    writeJson(res, buildMarketStateSnapshot());
-    return;
-  }
-
-  if (url.pathname === "/api/market-state/quotes" && req.method === "GET") {
-    if (!allowTrustedGuiRequest(req, res, "Market-state API")) return;
-    writeJson(res, await quoteSnapshotStore.get());
-    return;
-  }
-
-  if (url.pathname === "/api/instruments/search" && req.method === "GET") {
-    if (!allowTrustedGuiRequest(req, res, "Market-state API")) return;
-    writeJson(res, await searchInstrumentCandidates(url.searchParams.get("q") ?? ""));
-    return;
-  }
-
-  if (url.pathname === "/api/diagnostics/twitter-cli" && req.method === "GET") {
-    if (!allowTrustedGuiRequest(req, res, "Diagnostics API")) return;
-    const mode = url.searchParams.get("mode") === "session" ? "session" : "install";
-    const force = url.searchParams.get("force") === "1";
-    writeJson(res, await probeProviderStatus("twitter", { mode, force }));
-    return;
-  }
-
-  if (url.pathname === "/api/diagnostics/reddit-cli" && req.method === "GET") {
-    if (!allowTrustedGuiRequest(req, res, "Diagnostics API")) return;
-    const mode = url.searchParams.get("mode") === "session" ? "session" : "install";
-    const force = url.searchParams.get("force") === "1";
-    writeJson(res, await probeProviderStatus("reddit", { mode, force }));
-    return;
-  }
-
-  if (url.pathname === "/api/chat/run" && req.method === "POST") {
-    if (!allowTrustedGuiRequest(req, res, "Chat run API")) return;
-    await handleSseChatRun(req, res);
-    return;
-  }
-
-  const requested = url.pathname === "/" ? "/index.html" : url.pathname;
-  const path = resolve(join(webDist, requested));
-  if (!path.startsWith(webDist) || !existsSync(path)) {
-    const fallback = resolve(join(webDist, "index.html"));
-    if (!extname(requested) && fallback.startsWith(webDist) && existsSync(fallback)) {
-      res.writeHead(200, privateGuiHeaders("text/html; charset=utf-8"));
-      createReadStream(fallback).pipe(res);
-      return;
-    }
-    res.writeHead(404).end("Not found");
-    return;
-  }
-
-  const type = contentType(path);
-  res.writeHead(200, privateGuiHeaders(type));
-  createReadStream(path).pipe(res);
-}
+const server = createServer((req, res) => {
+  void httpRequestHandler(req, res);
+});
 
 server.on("upgrade", (req, socket) => wsHub.handleUpgrade(req, socket));
 
@@ -292,7 +234,7 @@ const shutdown = createGracefulShutdown({
     localAutomationHeartbeat.stop();
     wsHub.closeClients();
     unsubscribeSession();
-    releaseWriterLock(sessionDir);
+    releaseWriterLock(activeWriterLockScope);
     await runtime.dispose();
   },
   exit: (code) => process.exit(code),
@@ -300,171 +242,3 @@ const shutdown = createGracefulShutdown({
 
 process.once("SIGINT", shutdown);
 process.once("SIGTERM", shutdown);
-
-async function handleSseChatRun(req: IncomingMessage, res: ServerResponse): Promise<void> {
-  if (lockResult.role !== "writer") {
-    writeJson(res, { error: "Read-only follower mode" }, 409);
-    return;
-  }
-
-  const body = await readJsonBody(req);
-  const prompt = String(asRecord(body).prompt ?? "").trim();
-  if (!prompt) {
-    writeJson(res, { error: "prompt is required" }, 400);
-    return;
-  }
-
-  const sessionConflict = chatRunSessionConflict(
-    asRecord(body).sessionId,
-    sessionManager.getSessionId(),
-  );
-  if (sessionConflict) {
-    writeJson(res, sessionConflict, 409);
-    return;
-  }
-
-  res.writeHead(200, {
-    "content-type": "text/event-stream; charset=utf-8",
-    "cache-control": "no-cache, no-transform",
-    connection: "keep-alive",
-  });
-
-  let seq = 1;
-  const runId = `gui-run-${Date.now()}`;
-  const runSession = session;
-  const runSessionManager = sessionManager;
-  const sessionId = runSessionManager.getSessionId();
-  // Name new sessions by the user's words before any workflow transform
-  // replaces the turn text, so the sidebar shows what the user actually asked.
-  if (!prompt.startsWith("/") && !runSessionManager.getSessionName()) {
-    runSessionManager.appendSessionInfo(prompt.length > 80 ? `${prompt.slice(0, 77)}...` : prompt);
-  }
-  const beforeEntries = runSessionManager.getEntries();
-  const beforeCount = beforeEntries.length;
-  const beforeIds = new Set(beforeEntries.map((entry) => entry.id));
-  writeSse(res, { type: "run.started", runId, sessionId, seq: seq++ });
-  res.flushHeaders?.();
-  const liveStartSeq = seq;
-  const liveAdapter = createLiveChatEventAdapter({
-    runId,
-    sessionId,
-    startSeq: seq,
-    emit: (event) => writeSse(res, event),
-    originalPrompt: prompt,
-  });
-  const observation = createPromptObservation();
-  const unsubscribeLive = runSession.subscribe((event) => {
-    liveAdapter.handle(event);
-    observePromptEvent(observation, event);
-  });
-
-  try {
-    const modelSetup = buildModelSetupState(runSession.modelRegistry, runSession.model);
-    if (!prompt.startsWith("/") && modelSetup.requirement !== "ready") {
-      runSessionManager.appendMessage({ role: "user", content: prompt, timestamp: Date.now() });
-      const message =
-        modelSetup.requirement === "select_model"
-          ? "Choose an available model before chat can run. OpenCandle found configured credentials but no active model."
-          : "Connect an AI model before chat can run. Paste a Google Gemini, OpenAI, or Anthropic API key in the setup panel.";
-      runSessionManager.appendCustomMessageEntry("opencandle-model-setup", message, true, {
-        source: "gui",
-        requirement: modelSetup.requirement,
-      });
-      wsHub.broadcastState();
-    } else {
-      await promptAndSettle(runSession, prompt, beforeIds, observation);
-      wsHub.broadcastState();
-    }
-    seq = liveAdapter.nextSeq();
-    if (seq === liveStartSeq) {
-      await waitForNewEntryId(
-        () => runSessionManager.getEntries().map((entry) => entry.id),
-        beforeIds,
-      );
-      const newEntries = runSessionManager
-        .getEntries()
-        .slice(beforeCount)
-        .filter((entry) => !beforeIds.has(entry.id));
-      const events = sessionEntriesToChatEvents(newEntries, {
-        sessionId,
-        updatedAt: new Date().toISOString(),
-        startSeq: seq,
-      });
-      for (const event of events) {
-        writeSse(res, event);
-        seq = event.seq + 1;
-      }
-    }
-    writeSse(res, { type: "run.completed", runId, seq });
-  } catch (error) {
-    seq = liveAdapter.nextSeq();
-    const message = error instanceof Error ? error.message : String(error);
-    writeSse(res, { type: "run.failed", runId, error: { message }, seq });
-  } finally {
-    unsubscribeLive();
-    res.end();
-  }
-}
-
-function writeJson(res: ServerResponse, value: unknown, status = 200): void {
-  res.writeHead(status, { "content-type": "application/json" });
-  res.end(JSON.stringify(value));
-}
-
-function allowTrustedGuiRequest(req: IncomingMessage, res: ServerResponse, label: string): boolean {
-  if (
-    isTrustedPrivateApiRequest(req.headers, privateApiSessionToken, req.socket.remoteAddress, {
-      allowRemote: allowRemotePrivateApi,
-    })
-  )
-    return true;
-  res.writeHead(403, { "content-type": "application/json" });
-  res.end(
-    JSON.stringify({
-      error: `${label} is only available to trusted GUI browser sessions.`,
-    }),
-  );
-  return false;
-}
-
-function privateGuiHeaders(contentTypeValue: string): Record<string, string> {
-  const headers: Record<string, string> = { "content-type": contentTypeValue };
-  if (contentTypeValue.startsWith("text/html")) {
-    headers["set-cookie"] = privateApiCookieHeader(privateApiSessionToken);
-  }
-  return headers;
-}
-
-function writeSse(res: ServerResponse, event: ChatEvent): void {
-  res.write(`data: ${JSON.stringify(event)}\n\n`);
-}
-
-async function readJsonBody(req: IncomingMessage): Promise<unknown> {
-  const chunks: Buffer[] = [];
-  for await (const chunk of req) {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-  }
-  if (chunks.length === 0) return {};
-  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
-}
-
-function contentType(path: string): string {
-  switch (extname(path)) {
-    case ".html":
-      return "text/html; charset=utf-8";
-    case ".css":
-      return "text/css; charset=utf-8";
-    case ".js":
-      return "text/javascript; charset=utf-8";
-    case ".svg":
-      return "image/svg+xml";
-    default:
-      return "application/octet-stream";
-  }
-}
-
-function asRecord(value: unknown): Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value)
-    ? (value as Record<string, unknown>)
-    : {};
-}