openfox 2.0.38 → 2.0.40

package/dist/{chunk-DL6ZILAF.js → chunk-LBGHZLLH.js}

@@ -1,3 +1,6 @@
+import {
+  getProjectByWorkdir
+} from "./chunk-YQ3SOPBI.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -65,25 +68,24 @@ ${headerLines}\r
   return Buffer.concat([head, body]);
 }
 function dechunk(buf) {
-  const str = buf.toString("utf8");
   const parts = [];
   let pos = 0;
-  while (pos < str.length) {
-    const nlIdx = str.indexOf("\r\n", pos);
+  while (pos < buf.length) {
+    const nlIdx = buf.indexOf("\r\n", pos);
     if (nlIdx < 0) break;
-    const sizeStr = str.slice(pos, nlIdx);
+    const sizeStr = buf.subarray(pos, nlIdx).toString("ascii");
     const size = parseInt(sizeStr, 16);
     if (isNaN(size) || size < 0) break;
     if (size === 0) break;
     const chunkStart = nlIdx + 2;
     const chunkEnd = chunkStart + size;
-    if (chunkEnd > str.length) break;
-    parts.push(str.slice(chunkStart, chunkEnd));
+    if (chunkEnd > buf.length) break;
+    parts.push(buf.subarray(chunkStart, chunkEnd));
     pos = chunkEnd + 2;
   }
-  return Buffer.from(parts.join(""), "utf8");
+  return Buffer.concat(parts);
 }
-function startInspectProxy(target, sessionManager) {
+function startInspectProxy(target, sessionManager, workdir) {
   const port = getAvailablePort();
   const server = net.createServer((client) => {
     let clientHead = "";
@@ -100,6 +102,26 @@ function startInspectProxy(target, sessionManager) {
       const { method, url, headers } = parseReqHeaders(clientHead);
       const isWS = headers["upgrade"] === "websocket";
       clientParsed = true;
+      if (url === "/__openfox_sessions" && method === "GET") {
+        let sessions = sessionManager.listSessions();
+        if (workdir) {
+          const project = getProjectByWorkdir(workdir);
+          if (project) {
+            sessions = sessions.filter((s) => s.projectId === project.id);
+          }
+        }
+        sessions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+        const mapped = sessions.map((s) => ({
+          id: s.id,
+          title: s.title ?? s.id,
+          createdAt: s.createdAt
+        }));
+        client.write(
+          buildResponse(200, { "Content-Type": "application/json" }, Buffer.from(JSON.stringify({ sessions: mapped })))
+        );
+        client.end();
+        return;
+      }
       if (url === "/__openfox_feedback" && method === "POST") {
         const contentLength = parseInt(headers["content-length"] || "0", 10);
         let bodyData = chunk.slice(he + 4);
@@ -158,8 +180,10 @@ ${annotation || "(none)"}`;
         return;
       }
       targetSocket = net.connect(targetPort, targetHost);
-      targetSocket.on("error", () => client.destroy());
-      client.on("error", () => targetSocket.destroy());
+      targetSocket.on("error", () => {
+        respondWithError(502, "Bad Gateway");
+      });
+      client.on("error", () => targetSocket?.destroy());
       client.on("end", () => targetSocket.end());
       const connClose = "\r\nConnection: close";
       const reqEnd = clientHead.indexOf("\r\n\r\n");
@@ -176,7 +200,15 @@ ${annotation || "(none)"}`;
       let resHeaders = {};
       const bodyBuf = [];
       let headEnd = -1;
+      let responded = false;
+      function respondWithError(status2, message) {
+        if (responded) return;
+        responded = true;
+        client.write(buildResponse(status2, { "Content-Type": "text/plain" }, Buffer.from(message)));
+        client.end();
+      }
       targetSocket.on("data", (sChunk) => {
+        if (responded) return;
         if (!serverParsed) {
           serverHeadBuf += sChunk.toString("utf8");
           const sHe = serverHeadBuf.indexOf("\r\n\r\n");
@@ -215,17 +247,20 @@ ${annotation || "(none)"}`;
         client.write(sChunk);
       });
       targetSocket.on("end", () => {
+        if (responded) return;
         if (!serverParsed) {
-          client.end();
+          respondWithError(502, "Upstream connection closed prematurely");
           return;
         }
         if (isHtml && enc) {
           const fullBody = Buffer.concat(bodyBuf);
+          const isChunked = (resHeaders["transfer-encoding"] || "").toLowerCase() === "chunked";
+          const decoded = isChunked ? dechunk(fullBody) : fullBody;
           let text;
           try {
-            if (enc === "gzip") text = zlib.gunzipSync(fullBody).toString("utf8");
-            else if (enc === "deflate") text = zlib.inflateSync(fullBody).toString("utf8");
-            else text = fullBody.toString("utf8");
+            if (enc === "gzip") text = zlib.gunzipSync(decoded).toString("utf8");
+            else if (enc === "deflate") text = zlib.inflateSync(decoded).toString("utf8");
+            else text = decoded.toString("utf8");
           } catch {
             client.end();
             return;
@@ -236,6 +271,9 @@ ${annotation || "(none)"}`;
           if (bi >= 0) modified = text.slice(0, bi) + INJECT_SCRIPT + text.slice(bi);
           else if (hi >= 0) modified = text.slice(0, hi) + INJECT_SCRIPT + text.slice(hi);
           else {
+            const headStr2 = buildHttpHeaders(resHeaders, status);
+            client.write(Buffer.from(headStr2, "utf8"));
+            client.write(fullBody);
             client.end();
             return;
           }
@@ -246,6 +284,7 @@ ${annotation || "(none)"}`;
           const headStr = buildHttpHeaders(resHeaders, status);
           client.write(Buffer.from(headStr, "utf8"));
           client.write(compressed);
+          client.end();
         } else if (isHtml && bodyBuf.length > 0) {
           const fullBody = Buffer.concat(bodyBuf);
           const isChunked = (resHeaders["transfer-encoding"] || "").toLowerCase() === "chunked";
@@ -258,14 +297,22 @@ ${annotation || "(none)"}`;
           else if (hi >= 0)
             modified = Buffer.concat([dechunks.slice(0, hi), Buffer.from(INJECT_SCRIPT, "utf8"), dechunks.slice(hi)]);
           else {
+            const headStr2 = buildHttpHeaders(
+              resHeaders,
+              status,
+              Buffer.byteLength(dechunks),
+              "text/html; charset=utf-8"
+            );
+            client.write(Buffer.from(headStr2, "utf8"));
+            client.write(dechunks);
             client.end();
             return;
           }
           const headStr = buildHttpHeaders(resHeaders, status, Buffer.byteLength(modified), "text/html; charset=utf-8");
           client.write(Buffer.from(headStr, "utf8"));
           client.write(modified);
+          client.end();
         }
-        client.end();
       });
     });
     client.on("error", () => {
@@ -293,4 +340,4 @@ export {
   startInspectProxy,
   stopAllInspectProxies
 };
-//# sourceMappingURL=chunk-DL6ZILAF.js.map
+//# sourceMappingURL=chunk-LBGHZLLH.js.map

package/dist/{chunk-HJ7KRYWX.js → chunk-LH5J7V4F.js}

@@ -1,6 +1,6 @@
 import {
   startInspectProxy
-} from "./chunk-DL6ZILAF.js";
+} from "./chunk-LBGHZLLH.js";
 import {
   createProcess,
   getPlatformShell,
@@ -3452,7 +3452,7 @@ var callSubAgentTool = {
       };
     }
     try {
-      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-ATO5MSWX.js");
+      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-Q32G4RCJ.js");
       const toolRegistry = getToolRegistryForAgent2(agentDef);
       const turnMetrics = new TurnMetrics();
       const result = await executeSubAgent({
@@ -3806,7 +3806,7 @@ var DevServerManager = class {
     instance.exited = false;
     if (!config.disableInspect && config.url && this._sessionManager) {
       try {
-        const { port, cleanup } = startInspectProxy(config.url, this._sessionManager);
+        const { port, cleanup } = startInspectProxy(config.url, this._sessionManager, workdir);
         instance.inspectProxyPort = port;
         instance.proxyCleanup = cleanup;
         logger.debug("Inspect proxy started", { workdir, port, target: config.url });
@@ -4268,7 +4268,7 @@ function resolveAgentDef2(sessionManager, sessionId) {
 }
 async function buildCachedPrompt(sessionManager, sessionId, agentDef) {
   const { instructionContent, skills } = await loadSessionContext(sessionManager, sessionId);
-  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-ATO5MSWX.js");
+  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-Q32G4RCJ.js");
   const tools = getToolRegistryForAgent2(agentDef).definitions;
   const toolFingerprint = getToolFingerprint(tools);
   const allAgents = await loadAllAgentsDefault();
@@ -4281,7 +4281,7 @@ async function buildCachedPrompt(sessionManager, sessionId, agentDef) {
 async function computeSessionHash(sessionManager, sessionId) {
   const { instructionContent, skills } = await loadSessionContext(sessionManager, sessionId);
   const agentDef = await resolveAgentDef2(sessionManager, sessionId);
-  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-ATO5MSWX.js");
+  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-Q32G4RCJ.js");
   const tools = getToolRegistryForAgent2(agentDef).definitions;
   const toolFingerprint = getToolFingerprint(tools);
   return computeDynamicContextHash(instructionContent, skills, toolFingerprint);
@@ -4388,7 +4388,7 @@ var mcpConfigTool = createTool(
       await saveGlobalConfig(mcpConfigMode, { ...globalConfig, mcpServers: updated });
     }
     async function rebuildTools() {
-      const { setMcpTools: setMcpTools2 } = await import("./tools-ATO5MSWX.js");
+      const { setMcpTools: setMcpTools2 } = await import("./tools-Q32G4RCJ.js");
       const mcpTools = createMcpTools(mcpManagerForTools);
       setMcpTools2(mcpTools);
     }
@@ -4489,6 +4489,270 @@ var mcpConfigTool = createTool(
   }
 );
 
+// src/server/tools/trace-code.ts
+import { stat as stat2, readFile as readFile8 } from "fs/promises";
+function graphNode(location, depth, relation, symbolName, symbolKind) {
+  const node = { location, depth, relation, symbolName };
+  if (symbolKind) node.symbolKind = symbolKind;
+  return node;
+}
+var MAX_DEPTH = 5;
+var VALID_DIRECTIONS = ["up", "down", "both"];
+var SNIPPET_RADIUS = 2;
+var CACHE_MAX_SIZE = 50;
+function locationKey(loc) {
+  return `${loc.path}:${loc.line}:${loc.character}`;
+}
+function formatLocation(loc, workdir) {
+  const relPath = loc.path.startsWith(workdir) ? loc.path.slice(workdir.length + 1) : loc.path;
+  return `${relPath}:${loc.line + 1}:${loc.character}`;
+}
+var fileCache = /* @__PURE__ */ new Map();
+async function getCachedLines(path, approvedPaths) {
+  if (!approvedPaths.has(path)) return [];
+  const cached = fileCache.get(path);
+  if (cached) {
+    try {
+      const stats = await stat2(path);
+      if (stats.mtimeMs === cached.mtimeMs) {
+        return cached.lines;
+      }
+    } catch {
+    }
+  }
+  try {
+    const stats = await stat2(path);
+    const content = await readFile8(path, "utf-8");
+    const lines = content.split("\n");
+    fileCache.set(path, { mtimeMs: stats.mtimeMs, lines });
+    if (fileCache.size > CACHE_MAX_SIZE) {
+      const oldest = fileCache.keys().next();
+      if (!oldest.done && oldest.value !== void 0) {
+        fileCache.delete(oldest.value);
+      }
+    }
+    return lines;
+  } catch {
+    return [];
+  }
+}
+async function getSnippet(path, line, approvedPaths, radius = SNIPPET_RADIUS) {
+  const lines = await getCachedLines(path, approvedPaths);
+  if (lines.length === 0) return "";
+  const start = Math.max(0, line - radius);
+  const end = Math.min(lines.length - 1, line + radius);
+  const lineNumWidth = String(end + 1).length;
+  const result = [];
+  for (let i = start; i <= end; i++) {
+    const gutter = i === line ? ">" : " ";
+    const lineNum = String(i + 1).padStart(lineNumWidth);
+    result.push(`${gutter} ${lineNum}\u2502 ${lines[i] ?? ""}`);
+  }
+  return result.join("\n");
+}
+function formatEdgeLabel(relation) {
+  switch (relation) {
+    case "definition":
+      return "definition";
+    case "references":
+      return "reference";
+    case "type-definition":
+      return "type definition";
+    default:
+      return relation;
+  }
+}
+async function collectNodes(lsp, startLocations, symbolName, symbolKind, maxDepth, direction) {
+  const visited = /* @__PURE__ */ new Set();
+  const nodes = [];
+  const edges = [];
+  const queue = startLocations.map((loc) => ({ location: loc, depth: 0, relation: "match" }));
+  let idx = 0;
+  while (idx < queue.length) {
+    const item = queue[idx];
+    idx++;
+    const key = locationKey(item.location);
+    if (visited.has(key)) continue;
+    visited.add(key);
+    nodes.push(graphNode(item.location, item.depth, item.relation, symbolName, symbolKind));
+    if (item.parentKey) {
+      const relation = item.relation === "definition" ? "definition" : item.relation === "type-definition" ? "type-definition" : "references";
+      edges.push({ from: item.parentKey, to: key, relation });
+    }
+    if (item.depth >= maxDepth) continue;
+    const { path, line, character } = item.location;
+    if (direction === "down" || direction === "both") {
+      const defs = await lsp.getDefinition(path, line, character);
+      for (const def of defs) {
+        const defKey = locationKey(def);
+        if (!visited.has(defKey)) {
+          queue.push({ location: def, depth: item.depth + 1, relation: "definition", parentKey: key });
+        }
+      }
+      const typeDefs = await lsp.getTypeDefinition(path, line, character);
+      for (const td of typeDefs) {
+        const tdKey = locationKey(td);
+        if (!visited.has(tdKey)) {
+          queue.push({ location: td, depth: item.depth + 1, relation: "type-definition", parentKey: key });
+        }
+      }
+    }
+    if (direction === "up" || direction === "both") {
+      const refs = await lsp.getReferences(path, line, character);
+      for (const ref of refs) {
+        const refKey = locationKey(ref);
+        if (!visited.has(refKey)) {
+          queue.push({ location: ref, depth: item.depth + 1, relation: "reference", parentKey: key });
+        }
+      }
+    }
+  }
+  return { nodes, edges };
+}
+async function formatOutput(symbolName, direction, depth, nodes, edges, workdir, approvedPaths) {
+  const lines = [];
+  lines.push(`Symbol: ${symbolName}`);
+  lines.push(`Direction: ${direction} | Depth: ${depth}`);
+  lines.push(`Nodes: ${nodes.length} | Edges: ${edges.length}`);
+  lines.push("");
+  if (nodes.length === 0) {
+    lines.push("No results found.");
+    return lines.join("\n");
+  }
+  const byDepth = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const group = byDepth.get(node.depth) ?? [];
+    group.push(node);
+    byDepth.set(node.depth, group);
+  }
+  for (const [depth2, group] of [...byDepth.entries()].sort(([a], [b]) => a - b)) {
+    lines.push(`\u2500\u2500 Depth ${depth2} \u2500\u2500`);
+    const fileGroups = /* @__PURE__ */ new Map();
+    for (const node of group) {
+      const fileKey = node.location.path;
+      const fileGroup = fileGroups.get(fileKey) ?? [];
+      fileGroup.push(node);
+      fileGroups.set(fileKey, fileGroup);
+    }
+    for (const [filePath, fileNodes] of fileGroups) {
+      const relPath = filePath.startsWith(workdir) ? filePath.slice(workdir.length + 1) : filePath;
+      if (fileNodes.length > 5) {
+        const kinds = [...new Set(fileNodes.map((n) => formatEdgeLabel(n.relation)))];
+        lines.push(`  ${kinds.join(", ")} \xD7 ${fileNodes.length} in ${relPath}`);
+      } else {
+        for (const node of fileNodes) {
+          const label = formatEdgeLabel(node.relation);
+          const kind = node.symbolKind ? ` (${node.symbolKind})` : "";
+          const loc = formatLocation(node.location, workdir);
+          lines.push(`  ${label}: ${loc}${kind}`);
+          const snippet = await getSnippet(node.location.path, node.location.line, approvedPaths);
+          if (snippet) {
+            for (const snipLine of snippet.split("\n")) {
+              lines.push(`    ${snipLine}`);
+            }
+          }
+        }
+      }
+    }
+    lines.push("");
+  }
+  if (edges.length > 0 && edges.length <= 20) {
+    lines.push("Edges:");
+    for (const edge of edges) {
+      lines.push(`  ${edge.from} \u2500\u2500${edge.relation}\u2500\u2500\u25B6 ${edge.to}`);
+    }
+    lines.push("");
+  } else if (edges.length > 20) {
+    lines.push(`Edges: ${edges.length} total (suppressed, too many to display individually)`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var traceCodeTool = createTool(
+  "trace_code",
+  {
+    type: "function",
+    function: {
+      name: "trace_code",
+      description: "Trace a symbol through the codebase using LSP-powered static analysis. Finds definitions, references, and type definitions up to a configurable depth. Returns a graph of locations with inline code snippets for each node.",
+      parameters: {
+        type: "object",
+        properties: {
+          symbol: {
+            type: "string",
+            description: 'Symbol name to trace (e.g., "rebuildTools", "handleSubmit", "UserProfile")'
+          },
+          file: {
+            type: "string",
+            description: "File path containing the symbol. Used to seed the LSP server and detect the language. Relative to the working directory."
+          },
+          depth: {
+            type: "number",
+            description: "Graph traversal depth (default: 1, max: 5). How many hops to follow. Start with 1 for immediate defs+refs.",
+            default: 1
+          },
+          direction: {
+            type: "string",
+            enum: ["up", "down", "both"],
+            description: '"down" follows definitions, "up" finds references, "both" does both (default).',
+            default: "both"
+          }
+        },
+        required: ["symbol", "file"]
+      }
+    }
+  },
+  async (args, context, helpers) => {
+    const symbol = args.symbol?.trim();
+    if (!symbol) {
+      return helpers.error("symbol is required");
+    }
+    const file = args.file?.trim();
+    if (!file) {
+      return helpers.error("file is required");
+    }
+    const depth = args.depth ?? 1;
+    if (depth > MAX_DEPTH) {
+      return helpers.error(`depth cannot exceed ${MAX_DEPTH}`);
+    }
+    const direction = args.direction ?? "both";
+    if (!VALID_DIRECTIONS.includes(direction)) {
+      return helpers.error(`direction must be one of: ${VALID_DIRECTIONS.join(", ")}`);
+    }
+    const lsp = context.lspManager;
+    if (!lsp) {
+      return helpers.error("LSP is not available. The trace_code tool requires a running LSP server.");
+    }
+    const fullPath = helpers.resolvePath(file);
+    try {
+      await stat2(fullPath);
+    } catch {
+      return helpers.error(`File not found: "${file}". Check that the path exists.`);
+    }
+    let symbols;
+    try {
+      symbols = await lsp.seedAndFindWorkspaceSymbol(symbol, fullPath);
+    } catch {
+      return helpers.error(`Failed to search for symbol "${symbol}". LSP may not be responding.`);
+    }
+    if (symbols.length === 0) {
+      const installHint = lsp.getInstallHint(fullPath);
+      const hint = installHint ? ` ${installHint}` : "";
+      return helpers.error(
+        `Symbol "${symbol}" not found in "${file}". Check that the symbol name is correct and that the LSP server has indexed the project.${hint}`
+      );
+    }
+    const startLocations = symbols.map((s) => s.location);
+    const symbolKind = symbols[0].kind;
+    const { nodes, edges } = await collectNodes(lsp, startLocations, symbol, symbolKind, depth, direction);
+    const allPaths = [...new Set(nodes.map((n) => n.location.path))];
+    await helpers.checkPathAccess(allPaths);
+    const approvedPaths = new Set(allPaths);
+    const output = await formatOutput(symbol, direction, depth, nodes, edges, context.workdir, approvedPaths);
+    return helpers.success(output);
+  }
+);
+
 // src/server/tools/index.ts
 var _builtInTools;
 function getBuiltInTools() {
@@ -4507,7 +4771,8 @@ function getBuiltInTools() {
       devServerTool,
       stepDoneTool,
       backgroundProcessTool,
-      mcpConfigTool
+      mcpConfigTool,
+      traceCodeTool
     ];
   }
   return _builtInTools;
@@ -4793,4 +5058,4 @@ export {
   getToolRegistryForAgent,
   createToolRegistry
 };
-//# sourceMappingURL=chunk-HJ7KRYWX.js.map
+//# sourceMappingURL=chunk-LH5J7V4F.js.map

package/dist/{chunk-FFQCZ2MI.js → chunk-WUG3TOAL.js}

@@ -12,7 +12,7 @@ import {
   loadAllAgentsDefault,
   processEventsForConversation,
   runTopLevelAgentLoop
-} from "./chunk-HJ7KRYWX.js";
+} from "./chunk-LH5J7V4F.js";
 import {
   TurnMetrics,
   WORKFLOW_KICKOFF_PROMPT,
@@ -310,4 +310,4 @@ export {
   runAgentTurn,
   injectWorkflowKickoffIfNeeded
 };
-//# sourceMappingURL=chunk-FFQCZ2MI.js.map
+//# sourceMappingURL=chunk-WUG3TOAL.js.map

package/dist/cli/dev.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runCli
-} from "../chunk-7W2WATAO.js";
+} from "../chunk-34CRQ76B.js";
 import {
   logger
 } from "../chunk-K44MW7JJ.js";

package/dist/cli/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   runCli
-} from "../chunk-7W2WATAO.js";
+} from "../chunk-34CRQ76B.js";
 import {
   logger
 } from "../chunk-K44MW7JJ.js";

package/dist/{inspect-proxy-42ZXL2R5.js → inspect-proxy-UT2LFGJ5.js}

@@ -1,10 +1,12 @@
 import {
   startInspectProxy,
   stopAllInspectProxies
-} from "./chunk-DL6ZILAF.js";
+} from "./chunk-LBGHZLLH.js";
+import "./chunk-YQ3SOPBI.js";
+import "./chunk-ZPIZLTWU.js";
 import "./chunk-K44MW7JJ.js";
 export {
   startInspectProxy,
   stopAllInspectProxies
 };
-//# sourceMappingURL=inspect-proxy-42ZXL2R5.js.map
+//# sourceMappingURL=inspect-proxy-UT2LFGJ5.js.map

package/dist/{orchestrator-ZFBVVQBO.js → orchestrator-O4FZ3UVV.js}

@@ -2,9 +2,9 @@ import {
   injectWorkflowKickoffIfNeeded,
   runAgentTurn,
   runChatTurn
-} from "./chunk-FFQCZ2MI.js";
-import "./chunk-HJ7KRYWX.js";
-import "./chunk-DL6ZILAF.js";
+} from "./chunk-WUG3TOAL.js";
+import "./chunk-LH5J7V4F.js";
+import "./chunk-LBGHZLLH.js";
 import "./chunk-PBGOZMVY.js";
 import "./chunk-VRGRAQDG.js";
 import "./chunk-NWO6GRYE.js";
@@ -42,4 +42,4 @@ export {
   runAgentTurn,
   runChatTurn
 };
-//# sourceMappingURL=orchestrator-ZFBVVQBO.js.map
+//# sourceMappingURL=orchestrator-O4FZ3UVV.js.map

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openfox",
-  "version": "2.0.38",
+  "version": "2.0.40",
   "description": "Local-LLM-first agentic coding assistant",
   "type": "module",
   "bin": {

package/dist/{processor-NG4NH2SS.js → processor-PQ5IQ24D.js}

@@ -3,8 +3,8 @@ import {
   finalizeTurnCompletion,
   generateSessionNameForSession
 } from "./chunk-JGNAYJJZ.js";
-import "./chunk-HJ7KRYWX.js";
-import "./chunk-DL6ZILAF.js";
+import "./chunk-LH5J7V4F.js";
+import "./chunk-LBGHZLLH.js";
 import "./chunk-PBGOZMVY.js";
 import "./chunk-VRGRAQDG.js";
 import "./chunk-NWO6GRYE.js";
@@ -171,7 +171,7 @@ var QueueProcessor = class {
       backend: provider?.backend ?? llmClient.getBackend(),
       model: llmClient.getModel()
     };
-    const { runChatTurn } = await import("./orchestrator-ZFBVVQBO.js");
+    const { runChatTurn } = await import("./orchestrator-O4FZ3UVV.js");
     const runChatTurnParams = buildRunChatTurnParams({
       sessionManager,
       sessionId,
@@ -216,4 +216,4 @@ var QueueProcessor = class {
 export {
   QueueProcessor
 };
-//# sourceMappingURL=processor-NG4NH2SS.js.map
+//# sourceMappingURL=processor-PQ5IQ24D.js.map

package/dist/{serve-VIWHYE6X.js → serve-NC3U2VTG.js}

@@ -1,11 +1,11 @@
 import {
   VERSION,
   createServer
-} from "./chunk-ATBNY4CL.js";
-import "./chunk-GZZW4XSI.js";
-import "./chunk-FFQCZ2MI.js";
-import "./chunk-HJ7KRYWX.js";
-import "./chunk-DL6ZILAF.js";
+} from "./chunk-J7QZK6WE.js";
+import "./chunk-EZJFNX7D.js";
+import "./chunk-WUG3TOAL.js";
+import "./chunk-LH5J7V4F.js";
+import "./chunk-LBGHZLLH.js";
 import "./chunk-PBGOZMVY.js";
 import "./chunk-VRGRAQDG.js";
 import "./chunk-NWO6GRYE.js";
@@ -199,4 +199,4 @@ async function runServe(options) {
 export {
   runServe
 };
-//# sourceMappingURL=serve-VIWHYE6X.js.map
+//# sourceMappingURL=serve-NC3U2VTG.js.map