@jxsuite/server 0.32.0 → 0.33.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jxsuite/server",
-  "version": "0.32.0",
+  "version": "0.33.0",
   "description": "Jx development server with live reload, server-side proxy, and studio integration",
   "license": "MIT",
   "repository": {
@@ -14,7 +14,7 @@
   "type": "module",
   "exports": {
     ".": "./src/server.ts",
-    "./claude-session": "./src/claude-session.ts",
+    "./ai-api": "./src/ai-api.ts",
     "./packages": "./src/packages.ts",
     "./refactor": "./src/refactor/index.ts",
     "./resolve": "./src/resolve.ts",
@@ -29,14 +29,11 @@
     "test:coverage": "bun test --isolate --coverage"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.190",
-    "@anthropic-ai/sdk": "^0.105.0",
-    "@jxsuite/compiler": "^0.32.0",
-    "@jxsuite/create": "^0.32.0",
-    "@jxsuite/parser": "^0.32.0",
-    "@jxsuite/runtime": "^0.32.0",
-    "@jxsuite/schema": "^0.32.0",
-    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@jxsuite/compiler": "^0.33.0",
+    "@jxsuite/create": "^0.33.0",
+    "@jxsuite/parser": "^0.33.0",
+    "@jxsuite/runtime": "^0.33.0",
+    "@jxsuite/schema": "^0.33.0",
     "chokidar": "^5.0.0",
     "zod": "^4.4.3"
   }

package/src/ai-api.ts

@@ -0,0 +1,465 @@
+/**
+ * Ai-api.js — AI proxy endpoints for Jx Studio
+ *
+ * Handles /__studio/ai/chat (SSE streaming proxy to OpenAI) and /__studio/ai/models.
+ * The server acts as a thin proxy: validates the request shape, forwards to OpenAI,
+ * normalizes the SSE stream into StreamEvent-compatible format, and pipes back.
+ *
+ * API key flow:
+ *   1. Request header X-Api-Key or Authorization: Bearer <key>
+ *   2. Fallback: OPENAI_API_KEY env var
+ *   3. If neither → 401 with error message
+ *
+ * Base URL flow:
+ *   1. Request header X-Api-Base-URL
+ *   2. Fallback: OPENAI_BASE_URL env var
+ *   3. Default: https://api.openai.com/v1
+ *
+ * @license MIT
+ */
+
+// ─── Configuration ───────────────────────────────────────────────────────────
+
+const DEFAULT_BASE_URL = "https://api.openai.com/v1";
+
+/** A tool-call fragment inside an OpenAI streaming `delta`. */
+interface ToolCallDelta {
+  index: number;
+  id?: string;
+  type?: string;
+  function?: { name?: string; arguments?: string };
+}
+
+/** A single OpenAI chat-completions streaming chunk (the JSON after `data: `). */
+interface OpenAIStreamChunk {
+  choices?: {
+    index?: number;
+    delta?: { content?: string; tool_calls?: ToolCallDelta[] };
+    finish_reason?: string | null;
+  }[];
+}
+
+/** A model entry from the upstream `/models` listing. */
+interface ModelEntry {
+  id: string;
+  context_window?: number;
+  owned_by?: string;
+}
+
+function getConfig(req: Request): { apiKey: string | null; baseUrl: string; missingKey: boolean } {
+  const authHeader = req.headers.get("Authorization") || "";
+  const apiKeyHeader = req.headers.get("X-Api-Key") || "";
+  const baseUrlHeader = req.headers.get("X-Api-Base-URL") || "";
+
+  let apiKey = null;
+
+  // Check Authorization: Bearer <key>
+  if (authHeader.startsWith("Bearer ")) {
+    apiKey = authHeader.slice(7).trim();
+  }
+
+  // Check X-Api-Key header (overrides Bearer)
+  if (apiKeyHeader) {
+    apiKey = apiKeyHeader.trim();
+  }
+
+  // Check env var (fallback)
+  if (!apiKey && process.env.OPENAI_API_KEY) {
+    apiKey = process.env.OPENAI_API_KEY;
+  }
+
+  // Check base URL
+  const baseUrl = baseUrlHeader || process.env.OPENAI_BASE_URL || DEFAULT_BASE_URL;
+
+  return { apiKey, baseUrl, missingKey: !apiKey };
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/** Write an SSE event to the response stream. */
+function writeSSE(controller: ReadableStreamDefaultController, event: unknown): void {
+  const data = JSON.stringify(event);
+  controller.enqueue(new TextEncoder().encode(`data: ${data}\n\n`));
+}
+
+/** Write a JSON error response (for non-streaming endpoints and error cases). */
+function jsonError(status: number, message: string): Response {
+  return Response.json(
+    { error: message },
+    {
+      status,
+      headers: { "Content-Type": "application/json" },
+    },
+  );
+}
+
+// ─── /__studio/ai/chat — SSE streaming proxy ───────────────────────────────
+
+/** Handle POST /__studio/ai/chat — proxy chat completions to OpenAI via SSE. */
+export async function handleChat(req: Request): Promise<Response> {
+  const { apiKey, baseUrl, missingKey } = getConfig(req);
+  if (missingKey) {
+    return jsonError(
+      401,
+      "No API key configured. Set OPENAI_API_KEY env var or send X-Api-Key header.",
+    );
+  }
+
+  // Parse request body
+  let body: {
+    messages?: unknown[];
+    tools?: unknown[];
+    systemPrompt?: string;
+    model?: string;
+  };
+  try {
+    body = (await req.json()) as {
+      messages?: unknown[];
+      tools?: unknown[];
+      systemPrompt?: string;
+      model?: string;
+    };
+  } catch {
+    return jsonError(400, "Invalid JSON body");
+  }
+
+  const { messages = [], tools = [], systemPrompt = "", model = "gpt-4o" } = body;
+
+  if (!Array.isArray(messages)) {
+    return jsonError(400, "messages must be an array");
+  }
+
+  // Build OpenAI request
+  const openaiBody: {
+    model: string;
+    messages: unknown[];
+    stream: boolean;
+    stream_options: { include_usage: boolean };
+    tools?: unknown[];
+    tool_choice?: string;
+    parallel_tool_calls?: boolean;
+  } = {
+    model,
+    messages: [{ role: "system", content: systemPrompt }, ...messages],
+    stream: true,
+    stream_options: { include_usage: true },
+  };
+
+  if (tools && tools.length > 0) {
+    openaiBody.tools = tools;
+    openaiBody.tool_choice = "auto";
+    openaiBody.parallel_tool_calls = true;
+  }
+
+  const upstreamUrl = `${baseUrl}/chat/completions`;
+
+  // Create the SSE stream
+  const stream = new ReadableStream({
+    async start(controller) {
+      let response;
+      try {
+        response = await fetch(upstreamUrl, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${apiKey}`,
+          },
+          body: JSON.stringify(openaiBody),
+          signal: req.signal,
+        });
+      } catch (error) {
+        if ((error as Error).name === "AbortError") {
+          writeSSE(controller, { type: "done", stopReason: "cancelled" });
+        } else {
+          writeSSE(controller, {
+            type: "error",
+            message: `Network error: ${(error as Error).message}`,
+          });
+        }
+        controller.close();
+        return;
+      }
+
+      if (!response.ok) {
+        let errorBody = "";
+        try {
+          errorBody = await response.text();
+        } catch {
+          /* Ignore */
+        }
+        // Parse the upstream JSON error body (OpenAI returns { error: { message: "..." } },
+        // While some compatible providers return { error: "..." }). Extract a clean message
+        // Instead of embedding the raw JSON in the error text.
+        let cleanMessage = errorBody || response.statusText;
+        try {
+          const parsed = JSON.parse(errorBody) as { error?: string | { message?: string } };
+          if (typeof parsed.error === "string") {
+            cleanMessage = parsed.error;
+          } else if (parsed.error?.message) {
+            cleanMessage = parsed.error.message;
+          }
+        } catch {
+          /* Not JSON — use the raw body. */
+        }
+        writeSSE(controller, {
+          type: "error",
+          message: cleanMessage,
+          code: String(response.status),
+        });
+        controller.close();
+        return;
+      }
+
+      const reader = response.body?.getReader();
+      if (!reader) {
+        writeSSE(controller, { type: "error", message: "No response body from upstream" });
+        controller.close();
+        return;
+      }
+
+      const decoder = new TextDecoder();
+      let buffer = "";
+
+      const pendingToolCalls = new Map<number, { id: string; name: string; args: string }>();
+
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            break;
+          }
+
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.startsWith("data: ")) {
+              continue;
+            }
+
+            const dataStr = trimmed.slice(6);
+            if (dataStr === "[DONE]") {
+              // Emit pending tool call ends
+              for (const [, tc] of pendingToolCalls) {
+                writeSSE(controller, { type: "tool_call_end", id: tc.id });
+              }
+              pendingToolCalls.clear();
+              writeSSE(controller, { type: "done", stopReason: "stop" });
+              controller.close();
+              return;
+            }
+
+            let parsed: OpenAIStreamChunk;
+            try {
+              parsed = JSON.parse(dataStr) as OpenAIStreamChunk;
+            } catch {
+              continue;
+            }
+
+            const choice = parsed.choices?.[0];
+            if (!choice) {
+              continue;
+            }
+
+            const { delta } = choice;
+            if (!delta) {
+              continue;
+            }
+
+            // Text content
+            if (delta.content) {
+              writeSSE(controller, { type: "delta", content: delta.content });
+            }
+
+            // Tool calls
+            if (delta.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                if (tc.id) {
+                  // First appearance
+                  const entry = {
+                    id: tc.id,
+                    name: tc.function?.name || "",
+                    args: tc.function?.arguments || "",
+                  };
+                  pendingToolCalls.set(tc.index, entry);
+
+                  writeSSE(controller, { type: "tool_call_start", id: tc.id, name: entry.name });
+
+                  if (entry.args) {
+                    writeSSE(controller, { type: "tool_call_delta", id: tc.id, args: entry.args });
+                  }
+                } else if (tc.function?.arguments) {
+                  // Subsequent fragment
+                  const existing = pendingToolCalls.get(tc.index);
+                  if (existing) {
+                    existing.args += tc.function.arguments;
+                    writeSSE(controller, {
+                      type: "tool_call_delta",
+                      id: existing.id,
+                      args: tc.function.arguments,
+                    });
+                  }
+                }
+              }
+            }
+
+            // Finish reason
+            if (choice.finish_reason === "tool_calls") {
+              for (const [, tc] of pendingToolCalls) {
+                writeSSE(controller, { type: "tool_call_end", id: tc.id });
+              }
+              pendingToolCalls.clear();
+              writeSSE(controller, { type: "done", stopReason: "tool_calls" });
+              controller.close();
+              return;
+            }
+
+            if (choice.finish_reason === "stop" || choice.finish_reason === "length") {
+              for (const [, tc] of pendingToolCalls) {
+                writeSSE(controller, { type: "tool_call_end", id: tc.id });
+              }
+              pendingToolCalls.clear();
+              writeSSE(controller, {
+                type: "done",
+                stopReason: choice.finish_reason === "length" ? "length" : "stop",
+              });
+              controller.close();
+              return;
+            }
+          }
+        }
+
+        // Stream ended without explicit finish_reason
+        for (const [, tc] of pendingToolCalls) {
+          writeSSE(controller, { type: "tool_call_end", id: tc.id });
+        }
+        pendingToolCalls.clear();
+        writeSSE(controller, { type: "done", stopReason: "stop" });
+        controller.close();
+      } catch (error) {
+        void reader.cancel();
+        if ((error as Error).name === "AbortError") {
+          writeSSE(controller, { type: "done", stopReason: "cancelled" });
+          controller.close();
+          return;
+        }
+        writeSSE(controller, {
+          type: "error",
+          message: `Stream error: ${(error as Error).message}`,
+        });
+        controller.close();
+      }
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive",
+    },
+  });
+}
+
+// ─── /__studio/ai/models — model listing ────────────────────────────────────
+
+/**
+ * Handle GET /__studio/ai/models — return available models.
+ *
+ * When the caller has configured an API key (header or env), the request is proxied to the upstream
+ * provider's /models endpoint so any OpenAI-compatible endpoint (OpenRouter, local LLM, OpenCode
+ * Zen, Azure, etc.) returns its actual model list. Falls back to a hardcoded default list when no
+ * key is available.
+ */
+export async function handleModels(req: Request): Promise<Response> {
+  const { apiKey, baseUrl, missingKey } = getConfig(req);
+
+  // No key available → return hardcoded defaults so the UI can at least render.
+  if (missingKey) {
+    const defaults = [
+      { id: "gpt-4o", name: "GPT-4o", contextWindow: 128_000 },
+      { id: "gpt-4.1", name: "GPT-4.1", contextWindow: 1_000_000 },
+      { id: "gpt-4.1-mini", name: "GPT-4.1 Mini", contextWindow: 1_000_000 },
+      { id: "gpt-4o-mini", name: "GPT-4o Mini", contextWindow: 128_000 },
+    ];
+    return Response.json(
+      { models: defaults, configured: false },
+      {
+        headers: { "Content-Type": "application/json" },
+      },
+    );
+  }
+
+  // Key is available — proxy to the upstream /models endpoint.
+  try {
+    const upstreamUrl = `${baseUrl}/models`;
+    const upstreamResp = await fetch(upstreamUrl, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+    });
+
+    if (!upstreamResp.ok) {
+      // Upstream failed — return defaults with configured flag so user can still try.
+      const defaults = [{ id: "gpt-4o", name: "GPT-4o", contextWindow: 128_000 }];
+      return Response.json(
+        { models: defaults, configured: true, upstreamError: upstreamResp.status },
+        {
+          headers: { "Content-Type": "application/json" },
+        },
+      );
+    }
+
+    const data = (await upstreamResp.json()) as { data?: ModelEntry[] } | ModelEntry[];
+    // OpenAI /models returns { object: "list", data: [{ id, ... }] }
+    // Map to our simpler format.
+    const rawModels: ModelEntry[] = Array.isArray(data)
+      ? data
+      : Array.isArray(data.data)
+        ? data.data
+        : [];
+    const models = rawModels.map(({ id, context_window, owned_by }) => ({
+      id,
+      name: id,
+      contextWindow: context_window || 0,
+      ownedBy: owned_by,
+    }));
+
+    return Response.json(
+      { models, configured: true },
+      {
+        headers: { "Content-Type": "application/json" },
+      },
+    );
+  } catch {
+    // Network error → return defaults.
+    const defaults = [{ id: "gpt-4o", name: "GPT-4o", contextWindow: 128_000 }];
+    return Response.json(
+      { models: defaults, configured: true, upstreamError: "network" },
+      {
+        headers: { "Content-Type": "application/json" },
+      },
+    );
+  }
+}
+
+// ─── Route handler ───────────────────────────────────────────────────────────
+
+/**
+ * Main handler for /__studio/ai/* requests.
+ *
+ * @returns Response if handled, null if route doesn't match
+ */
+export async function handleAiApi(req: Request, url: URL): Promise<Response | null> {
+  const { pathname } = url;
+
+  if (pathname === "/__studio/ai/chat" && req.method === "POST") {
+    return handleChat(req);
+  }
+
+  if (pathname === "/__studio/ai/models" && req.method === "GET") {
+    return handleModels(req);
+  }
+
+  return null;
+}

package/src/server.ts

@@ -19,6 +19,7 @@ import { createWatcher, injectSSE } from "./watch.ts";
 import { handleResolve, handleServerFunction } from "./resolve.ts";
 import { handleStudioApi } from "./studio-api.ts";
 import { handleCodeApi } from "./code-api.ts";
+import { handleAiApi } from "./ai-api.ts";
 import { existsSync, readFileSync } from "node:fs";
 
 /**
@@ -252,6 +253,12 @@ export async function createDevServer(options: {
           return Response.json({ ok: true, root: activeProjectRoot });
         }
 
+        // AI proxy endpoints (/__studio/ai/chat, /__studio/ai/models)
+        const aiRes = await handleAiApi(req, url);
+        if (aiRes) {
+          return aiRes;
+        }
+
         const codeRes = await handleCodeApi(req, url);
         if (codeRes) {
           return codeRes;
@@ -332,7 +339,11 @@ export async function createDevServer(options: {
         return new Response("Not found", { status: 404 });
       }
 
-      if (handleSSE && path.endsWith(".html")) {
+      // Inject the live-reload script into served HTML — but NOT into the Studio editor.
+      // Studio manages its own state (open tabs, undo history, chat) and refreshes edited
+      // Files in-place; a blanket location.reload() would destroy that, e.g. when the AI
+      // Assistant writes a file matching a build glob inside the watched root.
+      if (handleSSE && path.endsWith(".html") && !path.startsWith("/packages/studio/")) {
         const html = await file.text();
         return new Response(injectSSE(html), {
           headers: { "Content-Type": "text/html; charset=utf-8" },
@@ -343,6 +354,9 @@ export async function createDevServer(options: {
     },
 
     port,
+    // Keep SSE connections alive — heartbeats are every 15 s, and AI streaming can take
+    // 30+ s. The default 10 s idleTimeout kills them prematurely.
+    idleTimeout: 120,
   });
 
   console.log(`\n@jxsuite/server listening on http://localhost:${server.port}`);

package/src/studio-api.ts

@@ -21,7 +21,6 @@ import {
   setPackageVersions,
 } from "./packages.ts";
 import type { FormatRegistry } from "@jxsuite/schema/format-registry";
-import * as claude from "./claude-session.ts";
 import type { ClassJsonDef } from "./types.ts";
 import type { ProjectConfig } from "@jxsuite/schema/types";
 
@@ -1438,79 +1437,6 @@ export async function handleStudioApi(
     }
   }
 
-  // ─── AI Assistant ─────────────────────────────────────────────────────────
-
-  if (path === "/__studio/ai/auth-status" && req.method === "GET") {
-    const status = await claude.getAuthStatus();
-    return Response.json(status);
-  }
-
-  if (path === "/__studio/ai/session" && req.method === "POST") {
-    try {
-      const body = (await req.json()) as { message?: string; systemPrompt?: string };
-      const projectDir = activeProjectRoot || root;
-      const opts: { systemPrompt?: string } = {};
-      if (body.systemPrompt !== undefined) {
-        opts.systemPrompt = body.systemPrompt;
-      }
-      const result = claude.createSession(projectDir, body.message!, opts);
-      return Response.json(result);
-    } catch (error) {
-      return Response.json(
-        { error: error instanceof Error ? error.message : String(error) },
-        { status: 500 },
-      );
-    }
-  }
-
-  if (
-    path.startsWith("/__studio/ai/session/") &&
-    path.endsWith("/stream") &&
-    req.method === "GET"
-  ) {
-    const id = path.split("/").slice(4)[0]!;
-    return claude.streamSession(id);
-  }
-
-  if (
-    path.startsWith("/__studio/ai/session/") &&
-    path.endsWith("/message") &&
-    req.method === "POST"
-  ) {
-    try {
-      const id = path.split("/").slice(4)[0]!;
-      const body = (await req.json()) as { message?: string };
-      claude.sendMessage(id, body.message!);
-      return Response.json({ ok: true });
-    } catch (error) {
-      return Response.json(
-        { error: error instanceof Error ? error.message : String(error) },
-        { status: 500 },
-      );
-    }
-  }
-
-  if (path.startsWith("/__studio/ai/session/") && path.endsWith("/stop") && req.method === "POST") {
-    const id = path.split("/").slice(4)[0]!;
-    claude.stopSession(id);
-    return Response.json({ ok: true });
-  }
-
-  if (path.startsWith("/__studio/ai/session/") && req.method === "DELETE") {
-    const id = path.split("/").slice(4)[0]!;
-    claude.deleteSession(id);
-    return Response.json({ ok: true });
-  }
-
-  if (path.startsWith("/__studio/ai/session/") && req.method === "GET") {
-    const id = path.split("/").slice(4)[0]!;
-    const info = claude.getSession(id);
-    if (!info) {
-      return Response.json({ error: "Not found" }, { status: 404 });
-    }
-    return Response.json(info);
-  }
-
   return null;
 }
 

package/src/watch.ts

@@ -16,6 +16,9 @@ const DEFAULT_IGNORE = [
   "**/.direnv/**",
   "**/bun.lockb",
   "**/bun.lock",
+  // Bun test temporary directories — created/deleted transiently, cause EINVAL on
+  // Fs.watch when cleaned up mid-scan.
+  "**/__test-*/**",
 ];
 
 /** @param {string} value */
@@ -186,5 +189,14 @@ export function createWatcher(
     }, debounceMs);
   });
 
+  // Gracefully handle watch errors (e.g. EINVAL on transient Bun test dirs).
+  watcher.on("error", (err) => {
+    const error = err as Error;
+    if (error.message?.includes("EINVAL")) {
+      return;
+    }
+    console.error("[watch] chokidar error:", error.message ?? error);
+  });
+
   return { broadcast, broadcastEvent, handleSSE, watcher };
 }

package/src/claude-session.ts

@@ -1,338 +0,0 @@
-/**
- * Claude-session.js — Claude Agent SDK session manager
- *
- * Manages Claude Code sessions via @anthropic-ai/claude-agent-sdk, providing: - Session creation
- * with streaming output - Follow-up messages via session resume - SSE broadcasting to connected
- * frontend clients - Session interruption and cleanup
- */
-
-import { query } from "@anthropic-ai/claude-agent-sdk";
-
-import type { Options as AgentOptions, SDKMessage } from "@anthropic-ai/claude-agent-sdk";
-
-interface Session {
-  id: string;
-  sessionId: string | null;
-  projectRoot: string;
-  messages: SDKMessage[];
-  sseClients: Set<(event: string, data: unknown) => void>;
-  status: "active" | "idle" | "stopped";
-  abortController: AbortController | null;
-  query: AsyncGenerator | null;
-}
-
-/**
- * Build a clean env for SDK child processes. Strips session-specific vars from a parent Claude Code
- * instance that would override the SDK's own credential resolution (OAuth from ~/.claude/).
- */
-function buildSdkEnv() {
-  const env = { ...process.env };
-  delete env.ANTHROPIC_AUTH_TOKEN;
-  delete env.ANTHROPIC_BASE_URL;
-  delete env.CLAUDE_CODE_ENTRYPOINT;
-  delete env.CLAUDE_CODE_EXECPATH;
-  delete env.CLAUDE_AGENT_SDK_VERSION;
-  delete env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC;
-  delete env.CLAUDECODE;
-  env.CLAUDE_AGENT_SDK_CLIENT_APP = "jx-studio/0.17.0";
-  return env;
-}
-
-const sessions = new Map<string, Session>();
-
-let idCounter = 0;
-
-function genId() {
-  return `ai_${Date.now().toString(36)}_${(idCounter += 1).toString(36)}`;
-}
-
-/**
- * Broadcast an SSE event to all connected clients for a session.
- *
- * @param {Session} session
- * @param {string} event
- * @param {unknown} data
- */
-function broadcast(session: Session, event: string, data: unknown) {
-  session.messages.push(data as SDKMessage);
-  for (const send of session.sseClients) {
-    send(event, data);
-  }
-}
-
-/**
- * Process the async message stream from a query.
- *
- * @param {Session} session
- * @param {AsyncGenerator<SDKMessage>} stream
- */
-async function processStream(session: Session, stream: AsyncGenerator<SDKMessage>) {
-  session.status = "active";
-  try {
-    for await (const message of stream) {
-      if ((session.status as string) === "stopped") {
-        break;
-      }
-      if (message.session_id && !session.sessionId) {
-        session.sessionId = message.session_id;
-      }
-      broadcast(session, message.type, message);
-    }
-  } catch (error) {
-    if (error instanceof Error && error.name !== "AbortError") {
-      broadcast(session, "error", { error: String(error), type: "error" });
-    }
-  } finally {
-    session.status = "idle";
-    session.query = null;
-    session.abortController = null;
-    broadcast(session, "done", { type: "done" });
-  }
-}
-
-/**
- * Create a new AI session and begin streaming.
- *
- * @param {string} projectRoot
- * @param {string} message
- * @param {{ systemPrompt?: string }} [opts]
- * @returns {{ id: string }}
- */
-export function createSession(
-  projectRoot: string,
-  message: string,
-  opts: { systemPrompt?: string } = {},
-) {
-  const id = genId();
-  const abortController = new AbortController();
-
-  const session: Session = {
-    abortController,
-    id,
-    messages: [],
-    projectRoot,
-    query: null,
-    sessionId: null,
-    sseClients: new Set(),
-    status: "active",
-  };
-
-  sessions.set(id, session);
-
-  const queryOpts: AgentOptions = {
-    abortController,
-    allowedTools: ["Read", "Edit", "Write", "Bash", "Glob", "Grep"],
-    cwd: projectRoot,
-    env: buildSdkEnv(),
-    includePartialMessages: true,
-    maxTurns: 30,
-    permissionMode: "acceptEdits",
-    persistSession: true,
-  };
-
-  if (opts.systemPrompt) {
-    queryOpts.systemPrompt = opts.systemPrompt;
-  }
-
-  const stream = query({ options: queryOpts, prompt: message });
-  session.query = stream;
-  void processStream(session, stream);
-
-  return { id };
-}
-
-/**
- * Send a follow-up message to an existing session.
- *
- * @param {string} id
- * @param {string} message
- */
-export function sendMessage(id: string, message: string) {
-  const session = sessions.get(id);
-  if (!session) {
-    throw new Error(`Session not found: ${id}`);
-  }
-  if (session.status === "active") {
-    throw new Error("Session is still processing");
-  }
-
-  const abortController = new AbortController();
-  session.abortController = abortController;
-
-  const queryOpts: AgentOptions = {
-    abortController,
-    allowedTools: ["Read", "Edit", "Write", "Bash", "Glob", "Grep"],
-    continue: true,
-    cwd: session.projectRoot,
-    env: buildSdkEnv(),
-    includePartialMessages: true,
-    maxTurns: 30,
-    permissionMode: "acceptEdits",
-  };
-
-  if (session.sessionId) {
-    queryOpts.resume = session.sessionId;
-    delete queryOpts.continue;
-  }
-
-  const stream = query({ options: queryOpts, prompt: message });
-  session.query = stream;
-  void processStream(session, stream);
-}
-
-/**
- * Stop a running session (interrupt the current query).
- *
- * @param {string} id
- */
-export function stopSession(id: string) {
-  const session = sessions.get(id);
-  if (!session) {
-    return;
-  }
-  session.status = "stopped";
-  if (session.abortController) {
-    session.abortController.abort();
-  }
-}
-
-/**
- * Remove a session entirely.
- *
- * @param {string} id
- */
-export function deleteSession(id: string) {
-  stopSession(id);
-  sessions.delete(id);
-}
-
-/**
- * Get an SSE Response stream for a session.
- *
- * @param {string} id
- * @returns {Response}
- */
-export function streamSession(id: string) {
-  const session = sessions.get(id);
-  if (!session) {
-    return new Response("Session not found", { status: 404 });
-  }
-
-  const encoder = new TextEncoder();
-  let sendRef: (event: string, data: unknown) => void = () => {};
-  const stream = new ReadableStream({
-    cancel() {
-      session.sseClients.delete(sendRef);
-    },
-    start(controller) {
-      /** @param {string} event @param {unknown} data */
-      sendRef = (event: string, data: unknown) => {
-        try {
-          controller.enqueue(encoder.encode(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`));
-        } catch {
-          // Stream closed
-        }
-      };
-
-      session.sseClients.add(sendRef);
-
-      for (const msg of session.messages) {
-        sendRef(((msg as Record<string, unknown>).type as string) || "message", msg);
-      }
-
-      const heartbeat = setInterval(() => {
-        try {
-          controller.enqueue(encoder.encode(": heartbeat\n\n"));
-        } catch {
-          clearInterval(heartbeat);
-          session.sseClients.delete(sendRef);
-        }
-      }, 15_000);
-    },
-  });
-
-  return new Response(stream, {
-    headers: {
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-      "Content-Type": "text/event-stream",
-    },
-  });
-}
-
-/**
- * Check if the claude agent SDK can authenticate.
- *
- * @returns {Promise<{ authenticated: boolean; error?: string }>}
- */
-export async function getAuthStatus() {
-  try {
-    const ctrl = new AbortController();
-    const timeout = setTimeout(() => ctrl.abort(), 15_000);
-    const testStream = query({
-      options: {
-        abortController: ctrl,
-        env: buildSdkEnv(),
-        includePartialMessages: true,
-        maxTurns: 1,
-        persistSession: false,
-      },
-      prompt: "Say OK",
-    });
-
-    for await (const msg of testStream) {
-      if (msg.type === "assistant") {
-        const content = (msg as Record<string, unknown>).message as
-          | { content?: unknown[] }
-          | undefined;
-        if (Array.isArray(content?.content)) {
-          const text = content.content.find(
-            (b: unknown) => (b as { type?: string }).type === "text",
-          ) as { text?: string } | undefined;
-          if (text?.text?.toLowerCase().includes("error")) {
-            clearTimeout(timeout);
-            ctrl.abort();
-            return { authenticated: false, error: text.text };
-          }
-        }
-        clearTimeout(timeout);
-        ctrl.abort();
-        return { authenticated: true };
-      }
-      if (msg.type === "result") {
-        const result = msg as Record<string, unknown>;
-        clearTimeout(timeout);
-        ctrl.abort();
-        if (result.is_error) {
-          return {
-            authenticated: false,
-            error: (result.result as string) || "API error",
-          };
-        }
-        return { authenticated: true };
-      }
-    }
-
-    clearTimeout(timeout);
-    return { authenticated: true };
-  } catch (error) {
-    return { authenticated: false, error: String(error) };
-  }
-}
-
-/**
- * Get session info.
- *
- * @param {string} id
- */
-export function getSession(id: string) {
-  const session = sessions.get(id);
-  if (!session) {
-    return null;
-  }
-  return {
-    id: session.id,
-    messageCount: session.messages.length,
-    status: session.status,
-  };
-}