@cryptiklemur/lattice 4.0.1 → 5.0.0

package/dist/server/project/sdk-bridge.js

@@ -0,0 +1,960 @@
+import { query } from "@anthropic-ai/claude-agent-sdk";
+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.js";
+import { syncSessionToPeers } from "../mesh/session-sync.js";
+import { resolveSkillContent } from "../handlers/skills.js";
+import { getPluginMcpServers } from "../handlers/plugins.js";
+import { guessContextWindow, getSessionTitle, renameSession, listSessions, invalidateSessionCache } from "./session.js";
+import { getLatticeHome, loadConfig } from "../config.js";
+import { log } from "../logger.js";
+import { getDailySpend, invalidateDailySpendCache } from "../analytics/engine.js";
+import { getWarmupModels, cacheRateLimitEntry } from "./warmup.js";
+import { execSync } from "node:child_process";
+import { sendPush } from "../push.js";
+var HIDDEN_TOOLS = new Set([
+    "TaskUpdate", "TaskCreate", "TaskGet", "TaskList", "TaskOutput", "TaskStop",
+    "TodoWrite", "TodoRead",
+    "EnterPlanMode", "ExitPlanMode",
+    "ToolSearch",
+]);
+var claudeExePath = null;
+function getClaudeExecutablePath() {
+    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;
+}
+var pendingPermissions = new Map();
+var pendingElicitations = new Map();
+var autoApprovedTools = new Map();
+var sessionPermissionOverrides = new Map();
+export function getAvailableModels() {
+    return getWarmupModels();
+}
+function createMessageQueue() {
+    var queue = [];
+    var waiting = null;
+    var ended = false;
+    return {
+        push: function (msg) {
+            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, done: true });
+            }
+        },
+        [Symbol.asyncIterator]: function () {
+            return {
+                next: function () {
+                    if (queue.length > 0) {
+                        return Promise.resolve({ value: queue.shift(), done: false });
+                    }
+                    if (ended) {
+                        return Promise.resolve({ value: undefined, done: true });
+                    }
+                    return new Promise(function (resolve) {
+                        waiting = resolve;
+                    });
+                },
+            };
+        },
+    };
+}
+var sessionStreams = new Map();
+var pendingStreams = new Set();
+var interruptedSessions = new Set();
+function getStreamStatePath() {
+    return join(getLatticeHome(), "active-streams.json");
+}
+function persistStreamState() {
+    var entries = {};
+    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)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(getStreamStatePath(), JSON.stringify(entries), "utf-8");
+}
+export function loadInterruptedSessions() {
+    var path = getStreamStatePath();
+    if (!existsSync(path))
+        return;
+    try {
+        var data = JSON.parse(readFileSync(path, "utf-8"));
+        for (var sessionId of Object.keys(data)) {
+            interruptedSessions.add(sessionId);
+        }
+    }
+    catch { }
+    writeFileSync(path, "{}", "utf-8");
+}
+export function wasSessionInterrupted(sessionId) {
+    return interruptedSessions.has(sessionId);
+}
+export function clearInterruptedFlag(sessionId) {
+    interruptedSessions.delete(sessionId);
+}
+export function getPendingPermission(requestId) {
+    return pendingPermissions.get(requestId);
+}
+export function deletePendingPermission(requestId) {
+    pendingPermissions.delete(requestId);
+}
+export function cleanupClientPermissions(clientId) {
+    var toRemove = [];
+    pendingPermissions.forEach(function (entry, requestId) {
+        if (entry.clientId === clientId) {
+            toRemove.push(requestId);
+            entry.resolve({ behavior: "deny", message: "Client disconnected.", toolUseID: entry.toolUseID });
+        }
+    });
+    for (var i = 0; i < toRemove.length; i++) {
+        pendingPermissions.delete(toRemove[i]);
+    }
+    if (toRemove.length > 0) {
+        log.chat("Cleaned up %d pending permission(s) for disconnected client %s", toRemove.length, clientId);
+    }
+}
+export function getPendingElicitation(requestId) {
+    return pendingElicitations.get(requestId);
+}
+export function resolveElicitation(requestId, result) {
+    var pending = pendingElicitations.get(requestId);
+    if (!pending)
+        return;
+    pendingElicitations.delete(requestId);
+    pending.resolve(result);
+}
+export function cleanupClientElicitations(clientId) {
+    var toRemove = [];
+    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, toolName) {
+    var tools = autoApprovedTools.get(sessionId);
+    if (!tools) {
+        tools = new Set();
+        autoApprovedTools.set(sessionId, tools);
+    }
+    tools.add(toolName);
+}
+export function setSessionPermissionOverride(sessionId, mode) {
+    sessionPermissionOverrides.set(sessionId, mode);
+}
+export function getActiveStream(sessionId) {
+    var session = sessionStreams.get(sessionId);
+    return session && !session.ended ? session.queryInstance : undefined;
+}
+export function getSessionStream(sessionId) {
+    var session = sessionStreams.get(sessionId);
+    return session && !session.ended ? session : undefined;
+}
+export function getActiveStreamCount() {
+    var count = 0;
+    sessionStreams.forEach(function (session) {
+        if (!session.ended)
+            count++;
+    });
+    return count;
+}
+export function getActiveStreamCountForProject(projectSlug) {
+    var count = 0;
+    sessionStreams.forEach(function (session) {
+        if (!session.ended && session.projectSlug === projectSlug)
+            count++;
+    });
+    return count;
+}
+export function getSessionStreamClientId(sessionId) {
+    var session = sessionStreams.get(sessionId);
+    return session && !session.ended ? session.clientId : undefined;
+}
+export function endSessionStream(sessionId) {
+    var session = sessionStreams.get(sessionId);
+    if (session && !session.ended) {
+        session.ended = true;
+        session.messageQueue.end();
+        session.abortController.abort();
+    }
+}
+export function matchesAllowRules(rules, toolName, currentRule) {
+    for (var i = 0; i < rules.length; i++) {
+        var rule = rules[i];
+        if (rule === toolName || rule === currentRule)
+            return true;
+        var ruleMatch = rule.match(/^(\w+)\((.+)\)$/);
+        if (!ruleMatch)
+            continue;
+        var ruleToolName = ruleMatch[1];
+        var rulePattern = ruleMatch[2];
+        if (ruleToolName !== toolName)
+            continue;
+        var currentMatch = currentRule.match(/^\w+\((.+)\)$/);
+        if (!currentMatch)
+            continue;
+        var currentContent = currentMatch[1];
+        if (rulePattern === "*")
+            return true;
+        if (rulePattern.endsWith(":*")) {
+            var rulePrefix = rulePattern.slice(0, -1);
+            if (currentContent.startsWith(rulePrefix) || currentContent === rulePattern.slice(0, -2))
+                return true;
+        }
+        if (rulePattern.endsWith("**")) {
+            var dirPrefix = rulePattern.slice(0, -2);
+            if (currentContent.startsWith(dirPrefix))
+                return true;
+        }
+    }
+    return false;
+}
+export function buildPermissionRule(toolName, input) {
+    if (toolName === "Bash") {
+        var command = input.command || input.cmd || "";
+        if (typeof command === "string" && command) {
+            var firstWord = command.split(/\s+/)[0];
+            if (firstWord === "curl" || firstWord === "wget") {
+                var urlMatch = command.match(/https?:\/\/[^\s"']+/);
+                if (urlMatch) {
+                    try {
+                        var parsed = new URL(urlMatch[0]);
+                        return toolName + "(" + firstWord + ":" + parsed.hostname + ")";
+                    }
+                    catch { }
+                }
+            }
+            return toolName + "(" + firstWord + ":*)";
+        }
+    }
+    if (toolName === "Read" || toolName === "Edit" || toolName === "Write") {
+        var filePath = input.file_path || input.path || "";
+        if (typeof filePath === "string" && filePath) {
+            var dirParts = filePath.split("/");
+            dirParts.pop();
+            var dir = dirParts.join("/");
+            if (dir) {
+                var prefix = dir.startsWith("/") ? "" : "/";
+                return toolName + "(" + prefix + dir + "/**)";
+            }
+        }
+    }
+    if (toolName === "WebFetch") {
+        var url = input.url || "";
+        if (typeof url === "string" && url) {
+            try {
+                var parsed = new URL(url);
+                return toolName + "(domain:" + parsed.hostname + ")";
+            }
+            catch { }
+        }
+    }
+    return toolName;
+}
+var STRIP_PREFIXES = [
+    /^please\s+/i,
+    /^can\s+you\s+/i,
+    /^could\s+you\s+/i,
+    /^help\s+me\s+/i,
+    /^i\s+need\s+you\s+to\s+/i,
+    /^i\s+want\s+you\s+to\s+/i,
+    /^i'd\s+like\s+you\s+to\s+/i,
+];
+function generateSessionTitle(userMessage) {
+    var title = userMessage
+        .replace(/[#*_`~>\[\]()!]/g, "")
+        .replace(/\n+/g, " ")
+        .trim();
+    for (var i = 0; i < STRIP_PREFIXES.length; i++) {
+        title = title.replace(STRIP_PREFIXES[i], "");
+    }
+    title = title.trim();
+    if (title.length > 50) {
+        title = title.slice(0, 50);
+        var lastSpace = title.lastIndexOf(" ");
+        if (lastSpace > 30) {
+            title = title.slice(0, lastSpace);
+        }
+    }
+    if (!title) {
+        return "";
+    }
+    return title.charAt(0).toUpperCase() + title.slice(1);
+}
+function isDefaultTitle(title) {
+    if (title === "Untitled")
+        return true;
+    if (/^Session\s+\d/.test(title))
+        return true;
+    return false;
+}
+function resolvePromptText(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) {
+            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, attachments, sessionId) {
+    if (attachments && attachments.length > 0) {
+        var contentBlocks = [];
+        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 },
+            parent_tool_use_id: null,
+            session_id: sessionId,
+        };
+    }
+    return {
+        type: "user",
+        message: { role: "user", content: [{ type: "text", text: prompt }] },
+        parent_tool_use_id: null,
+        session_id: sessionId,
+    };
+}
+function pushToExistingStream(session, options) {
+    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) {
+    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 (pendingStreams.has(sessionId)) {
+        sendTo(clientId, { type: "chat:error", message: "Session already has an active stream." });
+        return;
+    }
+    pendingStreams.add(sessionId);
+    var projectSettingsPath = join(cwd, ".claude", "settings.json");
+    var savedAdditionalDirs = [];
+    var latticeDefaults = {};
+    if (existsSync(projectSettingsPath)) {
+        try {
+            var projSettings = JSON.parse(readFileSync(projectSettingsPath, "utf-8"));
+            if (projSettings.permissions && Array.isArray(projSettings.permissions.additionalDirectories)) {
+                savedAdditionalDirs = projSettings.permissions.additionalDirectories;
+            }
+            if (projSettings.lattice && typeof projSettings.lattice === "object") {
+                latticeDefaults = projSettings.lattice;
+            }
+        }
+        catch { }
+    }
+    var effectiveMode = sessionPermissionOverrides.get(sessionId)
+        || latticeDefaults.defaultPermissionMode
+        || "acceptEdits";
+    sessionPermissionOverrides.delete(sessionId);
+    var mcpServers = {};
+    var claudeJsonPath = join(homedir(), ".claude.json");
+    if (existsSync(claudeJsonPath)) {
+        try {
+            var claudeJson = JSON.parse(readFileSync(claudeJsonPath, "utf-8"));
+            if (claudeJson.mcpServers && typeof claudeJson.mcpServers === "object") {
+                mcpServers = claudeJson.mcpServers;
+            }
+        }
+        catch { }
+    }
+    var pluginMcpServers = getPluginMcpServers();
+    if (Object.keys(pluginMcpServers).length > 0) {
+        mcpServers = { ...mcpServers, ...pluginMcpServers };
+    }
+    var projectMcpPath = join(cwd, ".mcp.json");
+    if (existsSync(projectMcpPath)) {
+        try {
+            var projectMcpJson = JSON.parse(readFileSync(projectMcpPath, "utf-8"));
+            if (projectMcpJson.mcpServers && typeof projectMcpJson.mcpServers === "object") {
+                mcpServers = { ...mcpServers, ...projectMcpJson.mcpServers };
+            }
+        }
+        catch { }
+    }
+    var abortController = new AbortController();
+    var currentClientId = clientId;
+    var queryOptions = {
+        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 : undefined,
+        stderr: function (data) {
+            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.toolConfig = {
+        askUserQuestion: { previewFormat: "html" },
+    };
+    queryOptions.onElicitation = function (request, opts) {
+        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 });
+            }
+        });
+    };
+    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 });
+        }
+        if (toolName === "AskUserQuestion") {
+            var promptRequestId = options.toolUseID;
+            var questions = input.questions;
+            sendTo(activeClientId, {
+                type: "chat:prompt_request",
+                requestId: promptRequestId,
+                questions: questions,
+            });
+            return new Promise(function (resolve) {
+                pendingPermissions.set(promptRequestId, {
+                    resolve: resolve,
+                    toolName: toolName,
+                    toolUseID: options.toolUseID,
+                    input: input,
+                    suggestions: undefined,
+                    clientId: activeClientId,
+                    sessionId: sessionId,
+                    promptType: "question",
+                });
+            });
+        }
+        if (toolName === "ExitPlanMode") {
+            sendTo(activeClientId, {
+                type: "chat:plan_mode",
+                active: false,
+            });
+        }
+        if (toolName === "Read") {
+            var readPath = (input.file_path || input.path || "");
+            if (readPath.startsWith("/tmp/") || readPath === "/tmp") {
+                return Promise.resolve({ behavior: "allow", updatedInput: input, toolUseID: options.toolUseID });
+            }
+        }
+        if (toolName === "Bash") {
+            var cmd = (input.command || "").trim();
+            if (cmd.startsWith("cd ")) {
+                var cdTarget = cmd.slice(3).trim().replace(/^["']|["']$/g, "");
+                if (cdTarget.startsWith("~")) {
+                    cdTarget = join(homedir(), cdTarget.slice(1));
+                }
+                var cdResolved = resolve(cwd, cdTarget);
+                var home = homedir();
+                if (cdResolved.startsWith(cwd) || cdResolved === cwd || cdResolved.startsWith(home) || cdResolved === home) {
+                    return Promise.resolve({ behavior: "allow", updatedInput: input, toolUseID: options.toolUseID });
+                }
+            }
+        }
+        var allowRules = [];
+        if (existsSync(projectSettingsPath)) {
+            try {
+                var projSettingsForRules = JSON.parse(readFileSync(projectSettingsPath, "utf-8"));
+                if (projSettingsForRules.permissions && Array.isArray(projSettingsForRules.permissions.allow)) {
+                    allowRules = projSettingsForRules.permissions.allow;
+                }
+            }
+            catch { }
+        }
+        if (allowRules.length > 0) {
+            var currentRule = buildPermissionRule(toolName, input);
+            if (matchesAllowRules(allowRules, toolName, currentRule)) {
+                return Promise.resolve({ behavior: "allow", updatedInput: input, toolUseID: options.toolUseID });
+            }
+        }
+        var requestId = options.toolUseID;
+        var rule = buildPermissionRule(toolName, input);
+        var title = options.title || rule;
+        sendTo(activeClientId, {
+            type: "chat:permission_request",
+            requestId: requestId,
+            tool: toolName,
+            args: JSON.stringify(input),
+            title: title,
+            decisionReason: options.decisionReason,
+            permissionRule: rule,
+        });
+        sendPush({ type: "permission_request", title: "Permission Required", body: toolName + ": " + title, sessionId });
+        return new Promise(function (resolve) {
+            pendingPermissions.set(requestId, {
+                resolve: resolve,
+                toolName: toolName,
+                toolUseID: options.toolUseID,
+                input: input,
+                suggestions: options.suggestions,
+                clientId: activeClientId,
+                sessionId: sessionId,
+            });
+            if (options.signal) {
+                options.signal.addEventListener("abort", function () {
+                    if (pendingPermissions.has(requestId)) {
+                        pendingPermissions.delete(requestId);
+                        resolve({ behavior: "deny", message: "Stream aborted.", toolUseID: options.toolUseID });
+                        sendTo(activeClientId, { type: "chat:permission_resolved", requestId: requestId, status: "denied" });
+                    }
+                }, { once: true });
+            }
+        });
+    };
+    var shouldResume = false;
+    if (isNewSession) {
+        shouldResume = false;
+    }
+    else {
+        var hash = cwd.replace(/\//g, "-");
+        var sessionFile = join(homedir(), ".claude", "projects", hash, sessionId + ".jsonl");
+        shouldResume = existsSync(sessionFile);
+    }
+    if (shouldResume) {
+        queryOptions.resume = sessionId;
+    }
+    else {
+        queryOptions.sessionId = sessionId;
+    }
+    if (model && model !== "default") {
+        queryOptions.model = model;
+    }
+    if (!model || model === "default") {
+        if (latticeDefaults.defaultModel && typeof latticeDefaults.defaultModel === "string") {
+            queryOptions.model = latticeDefaults.defaultModel;
+        }
+    }
+    if (effort) {
+        queryOptions.effort = effort;
+    }
+    if (!effort) {
+        if (latticeDefaults.defaultEffort && typeof latticeDefaults.defaultEffort === "string") {
+            queryOptions.effort = latticeDefaults.defaultEffort;
+        }
+    }
+    if (latticeDefaults.thinking) {
+        queryOptions.thinking = latticeDefaults.thinking;
+    }
+    if (env) {
+        queryOptions.env = env;
+    }
+    var prompt = resolvePromptText(text);
+    sendTo(clientId, {
+        type: "chat:user_message",
+        text,
+        uuid: crypto.randomUUID(),
+    });
+    var mq = createMessageQueue();
+    var firstMsg = buildSDKUserMessage(prompt, attachments, sessionId);
+    var stream = query({ prompt: mq, options: queryOptions });
+    pendingStreams.delete(sessionId);
+    var sessionStream = {
+        sessionId,
+        messageQueue: mq,
+        queryInstance: stream,
+        abortController,
+        projectSlug,
+        clientId,
+        cwd,
+        turnStartTime: startTime,
+        firstUserMessage: text,
+        currentModel: model,
+        activeToolBlocks: {},
+        hiddenToolIds: new Set(),
+        turnDoneSent: false,
+        messageUUIDs: [],
+        ended: false,
+    };
+    sessionStreams.set(sessionId, sessionStream);
+    persistStreamState();
+    broadcast({ type: "session:busy", sessionId, busy: true }, clientId);
+    void (async function () {
+        var retried = false;
+        try {
+            await stream.initializationResult();
+        }
+        catch (initErr) {
+            log.chat("Session %s SDK initialization warning: %O", sessionId, initErr);
+        }
+        mq.push(firstMsg);
+        try {
+            for await (var msg of stream) {
+                processMessage(sessionStream, msg);
+            }
+        }
+        catch (err) {
+            var errMsg = err instanceof Error ? err.message : String(err);
+            if (errMsg.includes("aborted") || errMsg.includes("AbortError")) {
+                log.chat("Session %s stream aborted", sessionId);
+            }
+            else if (errMsg.includes("Sent before connected") && !retried) {
+                retried = true;
+                log.chat("Session %s SDK WebSocket race condition, retrying after delay...", sessionId);
+                await new Promise(function (r) { setTimeout(r, 500); });
+                try {
+                    var retryMq = createMessageQueue();
+                    var retryStream = query({ prompt: retryMq, options: queryOptions });
+                    retryMq.push(firstMsg);
+                    sessionStream.queryInstance = retryStream;
+                    sessionStream.messageQueue = retryMq;
+                    for await (var retryMsg of retryStream) {
+                        processMessage(sessionStream, retryMsg);
+                    }
+                }
+                catch (retryErr) {
+                    var retryErrMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+                    if (!retryErrMsg.includes("aborted") && !retryErrMsg.includes("AbortError")) {
+                        console.error("[lattice] SDK stream retry error: " + retryErrMsg);
+                        sendTo(sessionStream.clientId, { type: "chat:error", message: retryErrMsg });
+                    }
+                }
+            }
+            else {
+                console.error("[lattice] SDK stream error: " + errMsg);
+                sendTo(sessionStream.clientId, { type: "chat:error", message: errMsg });
+            }
+        }
+        finally {
+            sessionStream.ended = true;
+            pendingStreams.delete(sessionId);
+            sessionStreams.delete(sessionId);
+            persistStreamState();
+            broadcast({ type: "session:busy", sessionId, busy: false }, sessionStream.clientId);
+            var toCleanup = [];
+            pendingPermissions.forEach(function (entry, reqId) {
+                if (entry.sessionId === sessionId) {
+                    toCleanup.push(reqId);
+                    entry.resolve({ behavior: "deny", message: "Session ended.", toolUseID: entry.toolUseID });
+                    sendTo(entry.clientId, { type: "chat:permission_resolved", requestId: reqId, status: "denied" });
+                }
+            });
+            toCleanup.forEach(function (reqId) { pendingPermissions.delete(reqId); });
+            var elicitToCleanup = [];
+            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 (!sessionStream.turnDoneSent) {
+                sessionStream.turnDoneSent = true;
+                sendTo(sessionStream.clientId, { type: "chat:done", cost: 0, duration: Date.now() - sessionStream.turnStartTime });
+            }
+        }
+    })();
+}
+function processMessage(ss, msg) {
+    var sessionId = ss.sessionId;
+    if (msg.type === "system") {
+        var sysMsg = msg;
+        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;
+        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;
+        var evt = partial.event;
+        if (evt.type === "content_block_start") {
+            var block = evt.content_block;
+            var idx = evt.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;
+        }
+        if (evt.type === "content_block_delta") {
+            var deltaEvt = evt;
+            var blockIdx = deltaEvt.index;
+            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.index;
+            var stoppedBlock = ss.activeToolBlocks[stopIdx];
+            if (stoppedBlock) {
+                if (!HIDDEN_TOOLS.has(stoppedBlock.name)) {
+                    sendTo(ss.clientId, {
+                        type: "chat:tool_start",
+                        toolId: stoppedBlock.id,
+                        name: stoppedBlock.name,
+                        args: stoppedBlock.inputJson,
+                    });
+                }
+                if (stoppedBlock.name === "TodoWrite" && stoppedBlock.inputJson) {
+                    try {
+                        var todoInput = JSON.parse(stoppedBlock.inputJson);
+                        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 });
+                }
+                delete ss.activeToolBlocks[stopIdx];
+            }
+            return;
+        }
+        return;
+    }
+    if (msg.type === "user") {
+        var userMsg = msg;
+        if (userMsg.uuid) {
+            ss.messageUUIDs.push({ uuid: userMsg.uuid, type: "user" });
+            sendTo(ss.clientId, { type: "chat:message_uuid", 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];
+                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;
+    }
+    if (msg.type === "rate_limit_event") {
+        var rlMsg = msg;
+        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,
+        });
+        return;
+    }
+    if (msg.type === "prompt_suggestion") {
+        var suggestion = msg.suggestion;
+        if (suggestion) {
+            sendTo(ss.clientId, { type: "chat:prompt_suggestion", suggestion: suggestion });
+        }
+        return;
+    }
+    if (msg.type === "result") {
+        var resultMsg = msg;
+        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(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,
+            });
+        }
+        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,
+            });
+        }
+        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;
+    }
+}