@cryptiklemur/lattice 1.46.7 → 2.0.0

package/{server/src → src/server}/project/sdk-bridge.ts

@@ -4,7 +4,7 @@ import type { SDKMessage, SDKPartialAssistantMessage, SDKResultMessage, SDKUserM
 import type { CanUseTool, PermissionMode, PermissionResult, PermissionUpdate } from "@anthropic-ai/claude-agent-sdk";
 type MessageParam = SDKUserMessage["message"];
 import type { Attachment } from "@lattice/shared";
-import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync, readdirSync, readlinkSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { sendTo, broadcast } from "../ws/broadcast";
@@ -15,6 +15,29 @@ import { guessContextWindow, getSessionTitle, renameSession, listSessions, inval
 import { getLatticeHome, loadConfig } from "../config";
 import { log } from "../logger";
 import { getDailySpend, invalidateDailySpendCache } from "../analytics/engine";
+import { getWarmupModels, cacheRateLimitEntry } from "./warmup";
+import { execSync } from "node:child_process";
+import { sendPush } from "../push";
+
+var HIDDEN_TOOLS = new Set([
+  "TaskUpdate", "TaskCreate", "TaskGet", "TaskList", "TaskOutput", "TaskStop",
+  "TodoWrite", "TodoRead",
+  "EnterPlanMode", "ExitPlanMode",
+  "ToolSearch",
+]);
+
+var claudeExePath: string | null = null;
+
+function getClaudeExecutablePath(): string {
+  if (claudeExePath) return claudeExePath;
+  try {
+    claudeExePath = execSync("which claude", { encoding: "utf-8" }).trim();
+    log.chat("Using system claude: %s", claudeExePath);
+  } catch {
+    claudeExePath = "claude";
+  }
+  return claudeExePath;
+}
 
 interface PendingPermission {
   resolve: (result: PermissionResult) => void;
@@ -28,6 +51,15 @@ interface PendingPermission {
 }
 
 var pendingPermissions = new Map<string, PendingPermission>();
+
+interface PendingElicitation {
+  resolve: (result: { action: "accept" | "decline"; content?: Record<string, unknown> }) => void;
+  clientId: string;
+  sessionId: string;
+}
+
+var pendingElicitations = new Map<string, PendingElicitation>();
+
 var autoApprovedTools = new Map<string, Set<string>>();
 var sessionPermissionOverrides = new Map<string, PermissionMode>();
 
@@ -49,87 +81,79 @@ export interface ModelEntry {
   displayName: string;
 }
 
-var KNOWN_MODELS: ModelEntry[] = [
-  { value: "default", displayName: "Default" },
-  { value: "opus", displayName: "Opus" },
-  { value: "sonnet", displayName: "Sonnet" },
-  { value: "haiku", displayName: "Haiku" },
-];
-
 export function getAvailableModels(): ModelEntry[] {
-  return KNOWN_MODELS.slice();
+  return getWarmupModels();
 }
 
-var activeStreams = new Map<string, Query>();
+interface MessageQueue {
+  push(msg: SDKUserMessage): void;
+  end(): void;
+  [Symbol.asyncIterator](): AsyncIterator<SDKUserMessage>;
+}
+
+function createMessageQueue(): MessageQueue {
+  var queue: SDKUserMessage[] = [];
+  var waiting: ((result: IteratorResult<SDKUserMessage>) => void) | null = null;
+  var ended = false;
+
+  return {
+    push: function (msg: SDKUserMessage) {
+      if (waiting) {
+        var resolve = waiting;
+        waiting = null;
+        resolve({ value: msg, done: false });
+      } else {
+        queue.push(msg);
+      }
+    },
+    end: function () {
+      ended = true;
+      if (waiting) {
+        var resolve = waiting;
+        waiting = null;
+        resolve({ value: undefined as any, done: true });
+      }
+    },
+    [Symbol.asyncIterator]: function () {
+      return {
+        next: function (): Promise<IteratorResult<SDKUserMessage>> {
+          if (queue.length > 0) {
+            return Promise.resolve({ value: queue.shift()!, done: false });
+          }
+          if (ended) {
+            return Promise.resolve({ value: undefined as any, done: true });
+          }
+          return new Promise(function (resolve) {
+            waiting = resolve;
+          });
+        },
+      };
+    },
+  };
+}
+
+interface SessionStream {
+  sessionId: string;
+  messageQueue: MessageQueue;
+  queryInstance: Query;
+  abortController: AbortController;
+  projectSlug: string;
+  clientId: string;
+  cwd: string;
+  turnStartTime: number;
+  firstUserMessage: string;
+  currentModel: string | undefined;
+  activeToolBlocks: Record<number, { id: string; name: string; inputJson: string }>;
+  hiddenToolIds: Set<string>;
+  turnDoneSent: boolean;
+  messageUUIDs: Array<{ uuid: string; type: string }>;
+  ended: boolean;
+}
+
+var sessionStreams = new Map<string, SessionStream>();
 var pendingStreams = new Set<string>();
-var streamMetadata = new Map<string, { projectSlug: string; clientId: string; startedAt: number }>();
 var interruptedSessions = new Set<string>();
 
-// Track external lock state so we only broadcast on changes
-var externalLockState = new Map<string, boolean>();
-var watchedSessions = new Set<string>();
-var remoteSessionWatchers = new Map<string, Set<string>>();
-
-/**
- * Start polling a session's lock file for external CLI usage.
- * Called when a client activates a session.
- */
-export function watchSessionLock(sessionId: string): void {
-  watchedSessions.add(sessionId);
-}
-
-/**
- * Stop polling a session's lock file.
- */
-export function unwatchSessionLock(sessionId: string): void {
-  watchedSessions.delete(sessionId);
-  externalLockState.delete(sessionId);
-}
-
-export function addRemoteSessionWatcher(sessionId: string, nodeId: string): void {
-  var watchers = remoteSessionWatchers.get(sessionId);
-  if (!watchers) {
-    watchers = new Set();
-    remoteSessionWatchers.set(sessionId, watchers);
-  }
-  watchers.add(nodeId);
-}
-
-export function getBusyOwner(sessionId: string): "cli" | "lattice" | undefined {
-  if (activeStreams.has(sessionId)) return "lattice";
-  if (isSessionLockedByExternal(sessionId)) return "cli";
-  return undefined;
-}
-
-// Poll every 3 seconds for external lock changes
-setInterval(function () {
-  for (var sessionId of watchedSessions) {
-    var busy = isSessionBusy(sessionId);
-    var prev = externalLockState.get(sessionId) ?? false;
-
-    if (busy !== prev) {
-      externalLockState.set(sessionId, busy);
-      var owner = busy ? getBusyOwner(sessionId) : undefined;
-      broadcast({ type: "session:busy", sessionId, busy: busy, busyOwner: owner });
-
-      var watchers = remoteSessionWatchers.get(sessionId);
-      if (watchers) {
-        var { getPeerConnection } = require("../mesh/connector") as typeof import("../mesh/connector");
-        for (var nodeId of watchers) {
-          var peerWs = getPeerConnection(nodeId);
-          if (peerWs) {
-            peerWs.send(JSON.stringify({
-              type: "mesh:proxy_response",
-              projectSlug: "",
-              requestId: "busy-" + sessionId,
-              payload: { type: "session:busy", sessionId, busy: busy, busyOwner: owner },
-            }));
-          }
-        }
-      }
-    }
-  }
-}, 3000);
 
 function getStreamStatePath(): string {
   return join(getLatticeHome(), "active-streams.json");
@@ -137,8 +161,10 @@ function getStreamStatePath(): string {
 
 function persistStreamState(): void {
   var entries: Record<string, { projectSlug: string; clientId: string; startedAt: number }> = {};
-  streamMetadata.forEach(function (meta, sessionId) {
-    entries[sessionId] = meta;
+  sessionStreams.forEach(function (session, sessionId) {
+    if (!session.ended) {
+      entries[sessionId] = { projectSlug: session.projectSlug, clientId: session.clientId, startedAt: session.turnStartTime };
+    }
   });
   var dir = getLatticeHome();
   if (!existsSync(dir)) {
@@ -191,6 +217,30 @@ export function cleanupClientPermissions(clientId: string): void {
   }
 }
 
+export function getPendingElicitation(requestId: string): PendingElicitation | undefined {
+  return pendingElicitations.get(requestId);
+}
+
+export function resolveElicitation(requestId: string, result: { action: "accept" | "decline"; content?: Record<string, unknown> }): void {
+  var pending = pendingElicitations.get(requestId);
+  if (!pending) return;
+  pendingElicitations.delete(requestId);
+  pending.resolve(result);
+}
+
+export function cleanupClientElicitations(clientId: string): void {
+  var toRemove: string[] = [];
+  pendingElicitations.forEach(function (entry, requestId) {
+    if (entry.clientId === clientId) {
+      toRemove.push(requestId);
+      entry.resolve({ action: "decline" });
+    }
+  });
+  for (var i = 0; i < toRemove.length; i++) {
+    pendingElicitations.delete(toRemove[i]);
+  }
+}
+
 export function addAutoApprovedTool(sessionId: string, toolName: string): void {
   var tools = autoApprovedTools.get(sessionId);
   if (!tools) {
@@ -205,110 +255,43 @@ export function setSessionPermissionOverride(sessionId: string, mode: Permission
 }
 
 export function getActiveStream(sessionId: string): Query | undefined {
-  return activeStreams.get(sessionId);
+  var session = sessionStreams.get(sessionId);
+  return session && !session.ended ? session.queryInstance : undefined;
 }
 
-export function getActiveStreamCount(): number {
-  return activeStreams.size;
+export function getSessionStream(sessionId: string): SessionStream | undefined {
+  var session = sessionStreams.get(sessionId);
+  return session && !session.ended ? session : undefined;
 }
 
-export function getActiveSessionCountForProject(projectPath: string): number {
+export function getActiveStreamCount(): number {
   var count = 0;
-  var hash = projectPath.replace(/\//g, "-");
-  var dir = join(homedir(), ".claude", "projects", hash);
-
-  for (var [sessionId] of activeStreams) {
-    if (existsSync(join(dir, sessionId + ".jsonl"))) count++;
-  }
-
-  if (cliActiveProjects.has(projectPath)) count++;
-
+  sessionStreams.forEach(function (session) {
+    if (!session.ended) count++;
+  });
   return count;
 }
 
-/**
- * Check if a session is controlled by an external process (not Lattice).
- * Lattice's own active streams are handled by isProcessing on the client,
- * so this ONLY returns true for external CLI instances.
- */
-export function isSessionBusy(sessionId: string): boolean {
-  if (activeStreams.has(sessionId)) return true;
-  return isSessionLockedByExternal(sessionId);
-}
-
-/**
- * Check if a PID is the Lattice daemon or one of its child processes.
- * The SDK spawns child processes (e.g. claude-agent-sdk/cli.js) that hold
- * lock files — those are NOT external.
- */
-var cliActiveProjects = new Set<string>();
-
-function refreshCliDetection(): void {
-  var newActive = new Set<string>();
-  var cliPids = getClaudeCliPidsAsync();
-  for (var i = 0; i < cliPids.length; i++) {
-    newActive.add(cliPids[i].cwd);
-  }
-  cliActiveProjects = newActive;
-}
-
-function getClaudeCliPidsAsync(): Array<{ pid: number; cwd: string; cmdline: string[] }> {
-  var results: Array<{ pid: number; cwd: string; cmdline: string[] }> = [];
-  try {
-    var procEntries = readdirSync("/proc").filter(function (e) { return /^\d+$/.test(e); });
-    for (var i = 0; i < procEntries.length; i++) {
-      var pid = parseInt(procEntries[i], 10);
-      if (pid === process.pid) continue;
-      try {
-        var cmdline = readFileSync("/proc/" + pid + "/cmdline", "utf-8").split("\0");
-        var exe = cmdline[0] || "";
-        if (!exe.endsWith("/claude") && exe !== "claude") continue;
-        var cwd = readlinkSync("/proc/" + pid + "/cwd");
-        results.push({ pid, cwd, cmdline });
-      } catch {}
-    }
-  } catch {}
-  return results;
-}
-
-setInterval(refreshCliDetection, 10000);
-
-function getProjectPathForSession(sessionId: string): string | null {
-  var config = loadConfig();
-  for (var i = 0; i < config.projects.length; i++) {
-    var hash = config.projects[i].path.replace(/\//g, "-");
-    var jsonlPath = join(homedir(), ".claude", "projects", hash, sessionId + ".jsonl");
-    if (existsSync(jsonlPath)) return config.projects[i].path;
-  }
-  return null;
+export function getActiveStreamCountForProject(projectSlug: string): number {
+  var count = 0;
+  sessionStreams.forEach(function (session) {
+    if (!session.ended && session.projectSlug === projectSlug) count++;
+  });
+  return count;
 }
 
-
-function isSessionLockedByExternal(sessionId: string): boolean {
-  if (activeStreams.has(sessionId)) return false;
-  var projectPath = getProjectPathForSession(sessionId);
-  if (!projectPath) return false;
-  return cliActiveProjects.has(projectPath);
+export function getSessionStreamClientId(sessionId: string): string | undefined {
+  var session = sessionStreams.get(sessionId);
+  return session && !session.ended ? session.clientId : undefined;
 }
 
-export function stopExternalSession(sessionId: string): boolean {
-  var projectPath = getProjectPathForSession(sessionId);
-  if (!projectPath) return false;
-  var pids = getClaudeCliPidsAsync();
-  for (var i = 0; i < pids.length; i++) {
-    if (pids[i].cwd === projectPath) {
-      try {
-        process.kill(pids[i].pid, "SIGINT");
-        return true;
-      } catch {}
-    }
+export function endSessionStream(sessionId: string): void {
+  var session = sessionStreams.get(sessionId);
+  if (session && !session.ended) {
+    session.ended = true;
+    session.messageQueue.end();
+    session.abortController.abort();
   }
-  return false;
-}
-
-export function getSessionStreamClientId(sessionId: string): string | undefined {
-  var meta = streamMetadata.get(sessionId);
-  return meta ? meta.clientId : undefined;
 }
 
 export function matchesAllowRules(rules: string[], toolName: string, currentRule: string): boolean {
@@ -423,12 +406,104 @@ function isDefaultTitle(title: string): boolean {
   return false;
 }
 
+function resolvePromptText(text: string): string {
+  if (text.startsWith("/")) {
+    var parts = text.split(/\s+/);
+    var skillName = parts[0].slice(1);
+    var skillArgs = parts.slice(1).join(" ");
+    var skillContent = resolveSkillContent(skillName);
+    if (skillContent) {
+      return "<skill-name>" + skillName + "</skill-name>\n" +
+        "<skill-content>\n" + skillContent + "\n</skill-content>\n" +
+        (skillArgs ? "<skill-args>" + skillArgs + "</skill-args>\n" : "") +
+        "Execute this skill. Follow its instructions exactly.";
+    }
+  }
+  return text;
+}
+
+function buildSDKUserMessage(prompt: string, attachments: Attachment[] | undefined, sessionId: string): SDKUserMessage {
+  if (attachments && attachments.length > 0) {
+    var contentBlocks: Array<{ type: "text"; text: string } | { type: "image"; source: { type: "base64"; media_type: string; data: string } }> = [];
+    contentBlocks.push({ type: "text", text: prompt });
+
+    for (var ai = 0; ai < attachments.length; ai++) {
+      var att = attachments[ai];
+      if (att.type === "image" && att.mimeType && !att.mimeType.includes("svg")) {
+        contentBlocks.push({
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: att.mimeType,
+            data: att.content,
+          },
+        });
+      } else {
+        var prefix = att.name ? "[Attached: " + att.name + "]\n" : "";
+        contentBlocks.push({
+          type: "text",
+          text: prefix + att.content,
+        });
+      }
+    }
+
+    return {
+      type: "user",
+      message: { role: "user", content: contentBlocks } as MessageParam,
+      parent_tool_use_id: null,
+      session_id: sessionId,
+    };
+  }
+
+  return {
+    type: "user",
+    message: { role: "user", content: [{ type: "text", text: prompt }] } as MessageParam,
+    parent_tool_use_id: null,
+    session_id: sessionId,
+  };
+}
+
+function pushToExistingStream(session: SessionStream, options: ChatStreamOptions): void {
+  var { text, attachments, clientId, sessionId, model } = options;
+
+  session.clientId = clientId;
+  session.turnStartTime = Date.now();
+  session.turnDoneSent = false;
+  session.activeToolBlocks = {};
+
+  var prompt = resolvePromptText(text);
+  var userMsg = buildSDKUserMessage(prompt, attachments, sessionId);
+
+  sendTo(clientId, {
+    type: "chat:user_message",
+    text,
+    uuid: crypto.randomUUID(),
+  });
+
+  if (model && model !== "default" && model !== session.currentModel) {
+    void session.queryInstance.setModel(model).catch(function (err) {
+      log.chat("Failed to switch model: %O", err);
+    });
+    session.currentModel = model;
+  }
+
+  broadcast({ type: "session:busy", sessionId, busy: true }, clientId);
+  session.messageQueue.push(userMsg);
+}
+
 export function startChatStream(options: ChatStreamOptions): void {
   var { projectSlug, sessionId, text, attachments, clientId, cwd, env, model, effort, isNewSession } = options;
+
+  var existing = sessionStreams.get(sessionId);
+  if (existing && !existing.ended) {
+    pushToExistingStream(existing, options);
+    return;
+  }
+
   var startTime = Date.now();
   var firstUserMessage = text;
 
-  if (activeStreams.has(sessionId) || pendingStreams.has(sessionId)) {
+  if (pendingStreams.has(sessionId)) {
     sendTo(clientId, { type: "chat:error", message: "Session already has an active stream." });
     return;
   }
@@ -481,19 +556,63 @@ export function startChatStream(options: ChatStreamOptions): void {
     } catch {}
   }
 
+  var abortController = new AbortController();
+  var currentClientId = clientId;
+
   var queryOptions: Parameters<typeof query>[0]["options"] = {
     cwd,
     permissionMode: effectiveMode,
     promptSuggestions: true,
+    settingSources: ["user", "project", "local"],
+    includePartialMessages: true,
+    enableFileCheckpointing: true,
+    agentProgressSummaries: true,
+    extraArgs: { "replay-user-messages": null },
+    abortController,
+    pathToClaudeCodeExecutable: getClaudeExecutablePath(),
     additionalDirectories: savedAdditionalDirs.length > 0 ? savedAdditionalDirs : undefined,
     mcpServers: Object.keys(mcpServers).length > 0 ? mcpServers as Record<string, any> : undefined,
+    stderr: function (data: string) {
+      if (data.includes("error") || data.includes("Error") || data.includes("credit") || data.includes("Credit") || data.includes("billing") || data.includes("auth")) {
+        log.chat("SDK stderr: %s", data.trim());
+      }
+    },
   };
 
   (queryOptions as any).toolConfig = {
     askUserQuestion: { previewFormat: "html" },
   };
 
+  queryOptions.onElicitation = function (request: any, opts: any) {
+    return new Promise(function (resolve) {
+      var requestId = crypto.randomUUID();
+      var activeClientId = (sessionStreams.get(sessionId) || { clientId: currentClientId }).clientId;
+      pendingElicitations.set(requestId, { resolve, clientId: activeClientId, sessionId });
+      sendTo(activeClientId, {
+        type: "chat:elicitation_request",
+        requestId,
+        serverName: request.serverName || "MCP Server",
+        message: request.message || "",
+        mode: request.mode || "form",
+        url: request.url || null,
+        requestedSchema: request.requestedSchema || null,
+      });
+      sendPush({ type: "elicitation", title: "Input Required", body: (request.serverName || "MCP Server") + " needs your input", sessionId });
+      if (opts && opts.signal) {
+        opts.signal.addEventListener("abort", function () {
+          if (pendingElicitations.has(requestId)) {
+            pendingElicitations.delete(requestId);
+            resolve({ action: "decline" });
+          }
+        }, { once: true });
+      }
+    });
+  } as any;
+
   queryOptions.canUseTool = function (toolName, input, options) {
+    var ss = sessionStreams.get(sessionId);
+    var activeClientId = ss ? ss.clientId : currentClientId;
+
     var approved = autoApprovedTools.get(sessionId);
     if (approved && approved.has(toolName)) {
       return Promise.resolve({ behavior: "allow", updatedInput: input, toolUseID: options.toolUseID } as PermissionResult);
@@ -502,7 +621,7 @@ export function startChatStream(options: ChatStreamOptions): void {
     if (toolName === "AskUserQuestion") {
       var promptRequestId = options.toolUseID;
       var questions = (input as { questions: Array<{ question: string; header: string; options: Array<{ label: string; description: string; preview?: string }>; multiSelect: boolean }> }).questions;
-      sendTo(clientId, {
+      sendTo(activeClientId, {
         type: "chat:prompt_request",
         requestId: promptRequestId,
         questions: questions,
@@ -514,7 +633,7 @@ export function startChatStream(options: ChatStreamOptions): void {
           toolUseID: options.toolUseID,
           input: input,
           suggestions: undefined,
-          clientId: clientId,
+          clientId: activeClientId,
           sessionId: sessionId,
           promptType: "question",
         });
@@ -522,7 +641,7 @@ export function startChatStream(options: ChatStreamOptions): void {
     }
 
     if (toolName === "ExitPlanMode") {
-      sendTo(clientId, {
+      sendTo(activeClientId, {
         type: "chat:plan_mode",
         active: false,
       });
@@ -571,7 +690,7 @@ export function startChatStream(options: ChatStreamOptions): void {
     var rule = buildPermissionRule(toolName, input);
     var title = options.title || rule;
 
-    sendTo(clientId, {
+    sendTo(activeClientId, {
       type: "chat:permission_request",
       requestId: requestId,
       tool: toolName,
@@ -580,6 +699,7 @@ export function startChatStream(options: ChatStreamOptions): void {
       decisionReason: options.decisionReason,
       permissionRule: rule,
     });
+    sendPush({ type: "permission_request", title: "Permission Required", body: toolName + ": " + title, sessionId });
 
     return new Promise<PermissionResult>(function (resolve) {
       pendingPermissions.set(requestId, {
@@ -588,7 +708,7 @@ export function startChatStream(options: ChatStreamOptions): void {
         toolUseID: options.toolUseID,
         input: input,
         suggestions: options.suggestions,
-        clientId: clientId,
+        clientId: activeClientId,
         sessionId: sessionId,
       });
 
@@ -597,7 +717,7 @@ export function startChatStream(options: ChatStreamOptions): void {
           if (pendingPermissions.has(requestId)) {
             pendingPermissions.delete(requestId);
             resolve({ behavior: "deny", message: "Stream aborted.", toolUseID: options.toolUseID });
-            sendTo(clientId, { type: "chat:permission_resolved", requestId: requestId, status: "denied" });
+            sendTo(activeClientId, { type: "chat:permission_resolved", requestId: requestId, status: "denied" });
           }
         }, { once: true });
       }
@@ -647,19 +767,7 @@ export function startChatStream(options: ChatStreamOptions): void {
     queryOptions.env = env;
   }
 
-  var prompt = text;
-  if (text.startsWith("/")) {
-    var parts = text.split(/\s+/);
-    var skillName = parts[0].slice(1);
-    var skillArgs = parts.slice(1).join(" ");
-    var skillContent = resolveSkillContent(skillName);
-    if (skillContent) {
-      prompt = "<skill-name>" + skillName + "</skill-name>\n" +
-        "<skill-content>\n" + skillContent + "\n</skill-content>\n" +
-        (skillArgs ? "<skill-args>" + skillArgs + "</skill-args>\n" : "") +
-        "Execute this skill. Follow its instructions exactly.";
-    }
-  }
+  var prompt = resolvePromptText(text);
 
   sendTo(clientId, {
     type: "chat:user_message",
@@ -667,71 +775,53 @@ export function startChatStream(options: ChatStreamOptions): void {
     uuid: crypto.randomUUID(),
   });
 
-  var activeToolBlocks: Record<number, { id: string; name: string; inputJson: string }> = {};
-  var doneSent = false;
-
-  var queryPrompt: string | AsyncIterable<SDKUserMessage>;
-
-  if (attachments && attachments.length > 0) {
-    var contentBlocks: Array<{ type: "text"; text: string } | { type: "image"; source: { type: "base64"; media_type: string; data: string } }> = [];
-    contentBlocks.push({ type: "text", text: prompt });
-
-    for (var ai = 0; ai < attachments.length; ai++) {
-      var att = attachments[ai];
-      if (att.type === "image" && att.mimeType && !att.mimeType.includes("svg")) {
-        contentBlocks.push({
-          type: "image",
-          source: {
-            type: "base64",
-            media_type: att.mimeType,
-            data: att.content,
-          },
-        });
-      } else {
-        var prefix = att.name ? "[Attached: " + att.name + "]\n" : "";
-        contentBlocks.push({
-          type: "text",
-          text: prefix + att.content,
-        });
-      }
-    }
-
-    var userMessage: SDKUserMessage = {
-      type: "user",
-      message: { role: "user", content: contentBlocks } as MessageParam,
-      parent_tool_use_id: null,
-      session_id: sessionId,
-    };
+  var mq = createMessageQueue();
+  var firstMsg = buildSDKUserMessage(prompt, attachments, sessionId);
+  mq.push(firstMsg);
 
-    queryPrompt = (async function* () {
-      yield userMessage;
-    })();
-  } else {
-    queryPrompt = prompt;
-  }
-
-  var stream = query({ prompt: queryPrompt, options: queryOptions });
+  var stream = query({ prompt: mq as any, options: queryOptions });
   pendingStreams.delete(sessionId);
-  activeStreams.set(sessionId, stream);
-  streamMetadata.set(sessionId, { projectSlug, clientId, startedAt: Date.now() });
+
+  var sessionStream: SessionStream = {
+    sessionId,
+    messageQueue: mq,
+    queryInstance: stream,
+    abortController,
+    projectSlug,
+    clientId,
+    cwd,
+    turnStartTime: startTime,
+    firstUserMessage: text,
+    currentModel: model,
+    activeToolBlocks: {},
+    hiddenToolIds: new Set<string>(),
+    turnDoneSent: false,
+    messageUUIDs: [],
+    ended: false,
+  };
+  sessionStreams.set(sessionId, sessionStream);
   persistStreamState();
   broadcast({ type: "session:busy", sessionId, busy: true }, clientId);
 
   void (async function () {
     try {
       for await (var msg of stream) {
-        processMessage(msg);
+        processMessage(sessionStream, msg);
       }
     } catch (err: unknown) {
       var errMsg = err instanceof Error ? err.message : String(err);
-      console.error("[lattice] SDK stream error: " + errMsg);
-      sendTo(clientId, { type: "chat:error", message: errMsg });
+      if (errMsg.includes("aborted") || errMsg.includes("AbortError")) {
+        log.chat("Session %s stream aborted", sessionId);
+      } else {
+        console.error("[lattice] SDK stream error: " + errMsg);
+        sendTo(sessionStream.clientId, { type: "chat:error", message: errMsg });
+      }
     } finally {
+      sessionStream.ended = true;
       pendingStreams.delete(sessionId);
-      activeStreams.delete(sessionId);
-      streamMetadata.delete(sessionId);
+      sessionStreams.delete(sessionId);
       persistStreamState();
-      broadcast({ type: "session:busy", sessionId, busy: false }, clientId);
+      broadcast({ type: "session:busy", sessionId, busy: false }, sessionStream.clientId);
 
       var toCleanup: string[] = [];
       pendingPermissions.forEach(function (entry, reqId) {
@@ -743,234 +833,242 @@ export function startChatStream(options: ChatStreamOptions): void {
       });
       toCleanup.forEach(function (reqId) { pendingPermissions.delete(reqId); });
 
+      var elicitToCleanup: string[] = [];
+      pendingElicitations.forEach(function (entry, reqId) {
+        if (entry.sessionId === sessionId) {
+          elicitToCleanup.push(reqId);
+          entry.resolve({ action: "decline" });
+        }
+      });
+      elicitToCleanup.forEach(function (reqId) { pendingElicitations.delete(reqId); });
+
       autoApprovedTools.delete(sessionId);
       sessionPermissionOverrides.delete(sessionId);
 
-      if (!doneSent) {
-        doneSent = true;
-        sendTo(clientId, { type: "chat:done", cost: 0, duration: Date.now() - startTime });
+      if (!sessionStream.turnDoneSent) {
+        sessionStream.turnDoneSent = true;
+        sendTo(sessionStream.clientId, { type: "chat:done", cost: 0, duration: Date.now() - sessionStream.turnStartTime });
       }
     }
   })();
+}
 
-  function processMessage(msg: SDKMessage): void {
+function processMessage(ss: SessionStream, msg: SDKMessage): void {
+  var sessionId = ss.sessionId;
 
-    if (msg.type === "system") {
-      var sysMsg = msg as { type: "system"; subtype?: string; mcp_servers?: { name: string; status: string }[]; tools?: string[] };
-      if (sysMsg.subtype === "init") {
-        var toolCount = (sysMsg.tools || []).length;
-        var mcpCount = (sysMsg.mcp_servers || []).filter(function (s) { return s.status === "connected"; }).length;
-        log.chat("Session ready: %d tools, %d MCP servers connected", toolCount, mcpCount);
-      }
-      return;
+  if (msg.type === "system") {
+    var sysMsg = msg as { type: "system"; subtype?: string; mcp_servers?: { name: string; status: string }[]; tools?: string[] };
+    if (sysMsg.subtype === "init") {
+      var toolCount = (sysMsg.tools || []).length;
+      var mcpCount = (sysMsg.mcp_servers || []).filter(function (s) { return s.status === "connected"; }).length;
+      log.chat("Session ready: %d tools, %d MCP servers connected", toolCount, mcpCount);
     }
+    return;
+  }
 
-    if (msg.type === "assistant") {
-      var assistantMsg = msg as { type: "assistant"; message: { content: unknown; model?: string; usage?: { input_tokens?: number; output_tokens?: number; cache_read_input_tokens?: number; cache_creation_input_tokens?: number } } };
-      var msgUsage = assistantMsg.message.usage;
-      if (msgUsage && msgUsage.input_tokens != null) {
-        sendTo(clientId, {
-          type: "chat:context_usage",
-          inputTokens: msgUsage.input_tokens || 0,
-          outputTokens: msgUsage.output_tokens || 0,
-          cacheReadTokens: msgUsage.cache_read_input_tokens || 0,
-          cacheCreationTokens: msgUsage.cache_creation_input_tokens || 0,
-          contextWindow: guessContextWindow(assistantMsg.message.model || ""),
-        });
-      }
-      var aContent = assistantMsg.message.content;
-      if (Array.isArray(aContent)) {
-        for (var ai = 0; ai < aContent.length; ai++) {
-          var aBlock = aContent[ai] as { type?: string; text?: string; id?: string; name?: string; input?: unknown };
-          if (aBlock.type === "text" && aBlock.text) {
-            sendTo(clientId, { type: "chat:delta", text: aBlock.text });
-          } else if (aBlock.type === "tool_use" && aBlock.id && aBlock.name) {
-            sendTo(clientId, {
-              type: "chat:tool_start",
-              toolId: aBlock.id,
-              name: aBlock.name,
-              args: JSON.stringify(aBlock.input ?? {}),
-            });
-            if (aBlock.name === "TodoWrite" && aBlock.input) {
-              var todoInput = aBlock.input as { todos?: Array<{ id?: string; content: string; status: string; activeForm?: string }> };
-              if (todoInput.todos) {
-                sendTo(clientId, {
-                  type: "chat:todo_update",
-                  todos: todoInput.todos.map(function (t, idx) {
-                    return { id: t.id || String(idx), content: t.content, status: t.status, priority: "medium" };
-                  }),
-                });
-              }
-            }
-            if (aBlock.name === "EnterPlanMode") {
-              sendTo(clientId, { type: "chat:plan_mode", active: true });
-            }
-            if (aBlock.name === "ExitPlanMode") {
-              sendTo(clientId, { type: "chat:plan_mode", active: false });
-            }
-          }
-        }
-      } else if (typeof aContent === "string" && aContent) {
-        sendTo(clientId, { type: "chat:delta", text: aContent });
-      }
-      return;
+  if (msg.type === "assistant") {
+    var assistantMsg = msg as { type: "assistant"; message: { content: unknown; model?: string; usage?: { input_tokens?: number; output_tokens?: number; cache_read_input_tokens?: number; cache_creation_input_tokens?: number } } };
+    var msgUsage = assistantMsg.message.usage;
+    if (msgUsage && msgUsage.input_tokens != null) {
+      sendTo(ss.clientId, {
+        type: "chat:context_usage",
+        inputTokens: msgUsage.input_tokens || 0,
+        outputTokens: msgUsage.output_tokens || 0,
+        cacheReadTokens: msgUsage.cache_read_input_tokens || 0,
+        cacheCreationTokens: msgUsage.cache_creation_input_tokens || 0,
+        contextWindow: guessContextWindow(assistantMsg.message.model || ""),
+      });
     }
+    return;
+  }
 
-    if (msg.type === "stream_event") {
-      var partial = msg as SDKPartialAssistantMessage;
-      var evt = partial.event;
-
-      if (evt.type === "content_block_start") {
-        var block = (evt as { content_block: { type: string; id?: string; name?: string }; index: number }).content_block;
-        var idx = (evt as { index: number }).index;
-        if (block.type === "tool_use" && block.id && block.name) {
-          activeToolBlocks[idx] = { id: block.id, name: block.name, inputJson: "" };
-          sendTo(clientId, {
+  if (msg.type === "stream_event") {
+    var partial = msg as SDKPartialAssistantMessage;
+    var evt = partial.event;
+
+    if (evt.type === "content_block_start") {
+      var block = (evt as { content_block: { type: string; id?: string; name?: string }; index: number }).content_block;
+      var idx = (evt as { index: number }).index;
+      if (block.type === "tool_use" && block.id && block.name) {
+        ss.activeToolBlocks[idx] = { id: block.id, name: block.name, inputJson: "" };
+        if (HIDDEN_TOOLS.has(block.name)) {
+          ss.hiddenToolIds.add(block.id);
+        } else {
+          sendTo(ss.clientId, {
             type: "chat:tool_start",
             toolId: block.id,
             name: block.name,
             args: "",
           });
         }
-        return;
       }
+      return;
+    }
 
-      if (evt.type === "content_block_delta") {
-        var deltaEvt = evt as { index: number; delta: { type: string; text?: string; partial_json?: string } };
-        var blockIdx = deltaEvt.index;
+    if (evt.type === "content_block_delta") {
+      var deltaEvt = evt as { index: number; delta: { type: string; text?: string; partial_json?: string } };
+      var blockIdx = deltaEvt.index;
 
-        if (deltaEvt.delta.type === "text_delta" && typeof deltaEvt.delta.text === "string") {
-          sendTo(clientId, { type: "chat:delta", text: deltaEvt.delta.text });
-        } else if (deltaEvt.delta.type === "input_json_delta" && activeToolBlocks[blockIdx]) {
-          activeToolBlocks[blockIdx].inputJson += deltaEvt.delta.partial_json || "";
-          var updatedTool = activeToolBlocks[blockIdx];
-          sendTo(clientId, {
+      if (deltaEvt.delta.type === "text_delta" && typeof deltaEvt.delta.text === "string") {
+        sendTo(ss.clientId, { type: "chat:delta", text: deltaEvt.delta.text });
+      } else if (deltaEvt.delta.type === "input_json_delta" && ss.activeToolBlocks[blockIdx]) {
+        ss.activeToolBlocks[blockIdx].inputJson += deltaEvt.delta.partial_json || "";
+      }
+      return;
+    }
+
+    if (evt.type === "content_block_stop") {
+      var stopIdx = (evt as { index: number }).index;
+      var stoppedBlock = ss.activeToolBlocks[stopIdx];
+      if (stoppedBlock) {
+        if (!HIDDEN_TOOLS.has(stoppedBlock.name)) {
+          sendTo(ss.clientId, {
             type: "chat:tool_start",
-            toolId: updatedTool.id,
-            name: updatedTool.name,
-            args: updatedTool.inputJson,
+            toolId: stoppedBlock.id,
+            name: stoppedBlock.name,
+            args: stoppedBlock.inputJson,
           });
         }
-        return;
-      }
-
-      if (evt.type === "content_block_stop") {
-        var stopIdx = (evt as { index: number }).index;
-        var stoppedBlock = activeToolBlocks[stopIdx];
-        if (stoppedBlock) {
-          if (stoppedBlock.name === "TodoWrite" && stoppedBlock.inputJson) {
-            try {
-              var todoInput = JSON.parse(stoppedBlock.inputJson) as { todos?: Array<{ id?: string; content: string; status: string; activeForm?: string }> };
-              if (todoInput.todos) {
-                sendTo(clientId, {
-                  type: "chat:todo_update",
-                  todos: todoInput.todos.map(function (t, idx) {
-                    return { id: t.id || String(idx), content: t.content, status: t.status, priority: "medium" };
-                  }),
-                });
-              }
-            } catch {}
-          }
-          if (stoppedBlock.name === "EnterPlanMode") {
-            sendTo(clientId, { type: "chat:plan_mode", active: true });
-          }
-          if (stoppedBlock.name === "ExitPlanMode") {
-            sendTo(clientId, { type: "chat:plan_mode", active: false });
-          }
-          delete activeToolBlocks[stopIdx];
+        if (stoppedBlock.name === "TodoWrite" && stoppedBlock.inputJson) {
+          try {
+            var todoInput = JSON.parse(stoppedBlock.inputJson) as { todos?: Array<{ id?: string; content: string; status: string; activeForm?: string }> };
+            if (todoInput.todos) {
+              sendTo(ss.clientId, {
+                type: "chat:todo_update",
+                todos: todoInput.todos.map(function (t, idx) {
+                  return { id: t.id || String(idx), content: t.content, status: t.status, priority: "medium" };
+                }),
+              });
+            }
+          } catch {}
+        }
+        if (stoppedBlock.name === "EnterPlanMode") {
+          sendTo(ss.clientId, { type: "chat:plan_mode", active: true });
+        }
+        if (stoppedBlock.name === "ExitPlanMode") {
+          sendTo(ss.clientId, { type: "chat:plan_mode", active: false });
         }
-        return;
+        delete ss.activeToolBlocks[stopIdx];
       }
-
       return;
     }
 
-    if (msg.type === "user") {
-      var userMsg = msg as { type: "user"; message: { content: unknown }; tool_use_result?: unknown };
-      var content = userMsg.message.content;
-      if (Array.isArray(content)) {
-        for (var i = 0; i < content.length; i++) {
-          var item = content[i] as { type?: string; tool_use_id?: string; content?: unknown };
-          if (item.type === "tool_result" && item.tool_use_id) {
-            var resultContent = typeof item.content === "string"
-              ? item.content
-              : JSON.stringify(item.content ?? "");
-            sendTo(clientId, {
-              type: "chat:tool_result",
-              toolId: item.tool_use_id,
-              content: resultContent,
-            });
-          }
+    return;
+  }
+
+  if (msg.type === "user") {
+    var userMsg = msg as { type: "user"; message: { content: unknown }; uuid?: string; tool_use_result?: unknown };
+    if (userMsg.uuid) {
+      ss.messageUUIDs.push({ uuid: userMsg.uuid, type: "user" });
+      sendTo(ss.clientId, { type: "chat:message_uuid" as any, uuid: userMsg.uuid, messageType: "user" });
+    }
+    var content = userMsg.message.content;
+    if (Array.isArray(content)) {
+      for (var i = 0; i < content.length; i++) {
+        var item = content[i] as { type?: string; tool_use_id?: string; content?: unknown };
+        if (item.type === "tool_result" && item.tool_use_id) {
+          if (ss.hiddenToolIds.has(item.tool_use_id)) continue;
+          var resultContent = typeof item.content === "string"
+            ? item.content
+            : JSON.stringify(item.content ?? "");
+          sendTo(ss.clientId, {
+            type: "chat:tool_result",
+            toolId: item.tool_use_id,
+            content: resultContent,
+          });
         }
       }
-      return;
     }
+    return;
+  }
 
-    if (msg.type === "prompt_suggestion") {
-      var suggestion = (msg as { type: string; suggestion: string }).suggestion;
-      if (suggestion) {
-        sendTo(clientId, { type: "chat:prompt_suggestion", suggestion: suggestion });
-      }
-      return;
-    }
+  if (msg.type === "rate_limit_event") {
+    var rlMsg = msg as { type: string; rate_limit_info: { status: string; utilization?: number; resetsAt?: number; rateLimitType?: string; overageStatus?: string; overageResetsAt?: number; isUsingOverage?: boolean } };
+    var rli = rlMsg.rate_limit_info;
+    cacheRateLimitEntry({
+      status: rli.status,
+      utilization: rli.utilization,
+      resetsAt: rli.resetsAt,
+      rateLimitType: rli.rateLimitType,
+      overageStatus: rli.overageStatus,
+      overageResetsAt: rli.overageResetsAt,
+      isUsingOverage: rli.isUsingOverage,
+    });
+    sendTo(ss.clientId, {
+      type: "chat:rate_limit",
+      status: rli.status,
+      utilization: rli.utilization,
+      resetsAt: rli.resetsAt,
+      rateLimitType: rli.rateLimitType,
+      overageStatus: rli.overageStatus,
+      overageResetsAt: rli.overageResetsAt,
+      isUsingOverage: rli.isUsingOverage,
+    } as any);
+    return;
+  }
 
-    if (msg.type === "result") {
-      var resultMsg = msg as SDKResultMessage;
-      var dur = Date.now() - startTime;
-      var cost = resultMsg.total_cost_usd || 0;
+  if (msg.type === "prompt_suggestion") {
+    var suggestion = (msg as { type: string; suggestion: string }).suggestion;
+    if (suggestion) {
+      sendTo(ss.clientId, { type: "chat:prompt_suggestion", suggestion: suggestion });
+    }
+    return;
+  }
 
-      if (resultMsg.usage && resultMsg.modelUsage) {
-        var contextWindow = 0;
-        var modelKeys = Object.keys(resultMsg.modelUsage);
-        for (var mk = 0; mk < modelKeys.length; mk++) {
-          var mu = resultMsg.modelUsage[modelKeys[mk]];
-          if (mu.contextWindow > contextWindow) {
-            contextWindow = mu.contextWindow;
-          }
+  if (msg.type === "result") {
+    var resultMsg = msg as SDKResultMessage;
+    var dur = Date.now() - ss.turnStartTime;
+    var cost = resultMsg.total_cost_usd || 0;
+
+    if (resultMsg.usage && resultMsg.modelUsage) {
+      var contextWindow = 0;
+      var modelKeys = Object.keys(resultMsg.modelUsage);
+      for (var mk = 0; mk < modelKeys.length; mk++) {
+        var mu = resultMsg.modelUsage[modelKeys[mk]];
+        if (mu.contextWindow > contextWindow) {
+          contextWindow = mu.contextWindow;
         }
-        sendTo(clientId, {
-          type: "chat:context_usage",
-          inputTokens: resultMsg.usage.input_tokens || 0,
-          outputTokens: resultMsg.usage.output_tokens || 0,
-          cacheReadTokens: resultMsg.usage.cache_read_input_tokens || 0,
-          cacheCreationTokens: resultMsg.usage.cache_creation_input_tokens || 0,
-          contextWindow: contextWindow,
-        });
       }
+      sendTo(ss.clientId, {
+        type: "chat:context_usage",
+        inputTokens: resultMsg.usage.input_tokens || 0,
+        outputTokens: resultMsg.usage.output_tokens || 0,
+        cacheReadTokens: resultMsg.usage.cache_read_input_tokens || 0,
+        cacheCreationTokens: resultMsg.usage.cache_creation_input_tokens || 0,
+        contextWindow: contextWindow,
+      });
+    }
 
-      doneSent = true;
-      activeStreams.delete(sessionId);
-      streamMetadata.delete(sessionId);
-      persistStreamState();
-      sendTo(clientId, { type: "chat:done", cost: cost, duration: dur });
-      invalidateDailySpendCache();
-      var budgetConfig = loadConfig().costBudget;
-      if (budgetConfig) {
-        sendTo(clientId, {
-          type: "budget:status",
-          dailySpend: getDailySpend(),
-          dailyLimit: budgetConfig.dailyLimit,
-          enforcement: budgetConfig.enforcement,
-        } as never);
-      }
-      broadcast({ type: "session:busy", sessionId, busy: false }, clientId);
-      syncSessionToPeers(cwd, projectSlug, sessionId);
-
-      void getSessionTitle(projectSlug, sessionId).then(function (currentTitle) {
-        if (!isDefaultTitle(currentTitle)) return;
-        var newTitle = generateSessionTitle(firstUserMessage);
-        if (!newTitle) return;
-        void renameSession(projectSlug, sessionId, newTitle).then(function (ok) {
-          if (!ok) return;
-          log.session("Auto-titled session %s: %s", sessionId, newTitle);
-          invalidateSessionCache(projectSlug);
-          void listSessions(projectSlug, { limit: 40 }).then(function (result) {
-            broadcast({ type: "session:list", projectSlug, sessions: result.sessions, totalCount: result.totalCount });
-          });
+    ss.turnDoneSent = true;
+    sendTo(ss.clientId, { type: "chat:done", cost: cost, duration: dur });
+    sendPush({ type: "done", title: "Task Complete", body: "Claude finished responding", sessionId, projectSlug: ss.projectSlug });
+    invalidateDailySpendCache();
+    var budgetConfig = loadConfig().costBudget;
+    if (budgetConfig) {
+      sendTo(ss.clientId, {
+        type: "budget:status",
+        dailySpend: getDailySpend(),
+        dailyLimit: budgetConfig.dailyLimit,
+        enforcement: budgetConfig.enforcement,
+      } as never);
+    }
+    broadcast({ type: "session:busy", sessionId, busy: false }, ss.clientId);
+    syncSessionToPeers(ss.cwd, ss.projectSlug, sessionId);
+
+    void getSessionTitle(ss.projectSlug, sessionId).then(function (currentTitle) {
+      if (!isDefaultTitle(currentTitle)) return;
+      var newTitle = generateSessionTitle(ss.firstUserMessage);
+      if (!newTitle) return;
+      void renameSession(ss.projectSlug, sessionId, newTitle).then(function (ok) {
+        if (!ok) return;
+        log.session("Auto-titled session %s: %s", sessionId, newTitle);
+        invalidateSessionCache(ss.projectSlug);
+        void listSessions(ss.projectSlug, { limit: 40 }).then(function (result) {
+          broadcast({ type: "session:list", projectSlug: ss.projectSlug, sessions: result.sessions, totalCount: result.totalCount });
         });
       });
+    });
 
-      return;
-    }
+    return;
   }
 }