openfox 2.0.135 → 2.0.137

package/dist/{chunk-NFEZATSN.js → chunk-FIQPKLDY.js}

@@ -1,27 +1,27 @@
 import {
   getPendingQuestionsForSession
-} from "./chunk-JURM3RPZ.js";
+} from "./chunk-V5AC2TV7.js";
 import {
   combineEventsWithSnapshot,
   getEventStore
-} from "./chunk-QZOV4OVN.js";
+} from "./chunk-2OO46UAW.js";
 import {
   buildMessagesFromStoredEvents,
   foldPendingConfirmations
-} from "./chunk-MEEUXRFL.js";
+} from "./chunk-MMGHIPBU.js";
 import {
   updateSessionMetadata
-} from "./chunk-F2MOHHXB.js";
+} from "./chunk-X4PVR6AW.js";
 import {
   getRuntimeConfig
-} from "./chunk-ORCQ3EXQ.js";
+} from "./chunk-BHVR2YS5.js";
 import {
   createContextStateMessage,
   createSessionStateMessage
 } from "./chunk-AATMPL7S.js";
 import {
   getMaxVisibleItems
-} from "./chunk-CTWZPN7G.js";
+} from "./chunk-QUAEH3MP.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -162,7 +162,7 @@ async function generateSessionNameForSession(sessionId, userMessage, deps, signa
       client = deps.getLLMClient();
       client.setModel(providerConfig.model);
     } else if (providerConfig) {
-      const { createLLMClient } = await import("./client-VVYOWXRR.js");
+      const { createLLMClient } = await import("./client-MVI3J7SN.js");
       client = createLLMClient(
         {
           llm: {
@@ -216,4 +216,4 @@ export {
   needsNameGeneration,
   generateSessionNameForSession
 };
-//# sourceMappingURL=chunk-NFEZATSN.js.map
+//# sourceMappingURL=chunk-FIQPKLDY.js.map

package/dist/chunk-FSSUPWYO.js

@@ -0,0 +1,336 @@
+// src/server/tools/types.ts
+var OUTPUT_LIMITS = {
+  read_file: {
+    maxLines: 2e3,
+    maxBytes: 1e5,
+    maxImageBytes: 2097152,
+    // 2MB for images
+    maxPdfPages: 50,
+    maxPdfImages: 20,
+    maxFileBytes: 20971520
+    // 20MB general file safety limit
+  },
+  run_command: {
+    maxLines: 2e3,
+    maxBytes: 5e4
+  },
+  glob: {
+    maxResults: 500
+  },
+  grep: {
+    maxMatches: 200
+  },
+  web_fetch: {
+    maxBytes: 1e5
+  }
+};
+
+// src/server/tools/pdf-utils.ts
+import { getDocument, OPS } from "pdfjs-dist/legacy/build/pdf.mjs";
+import { PNG } from "pngjs";
+var PDF_HEADER = Buffer.from("%PDF");
+function isPdfBuffer(buffer) {
+  return buffer.length > 4 && buffer.subarray(0, 4).equals(PDF_HEADER);
+}
+function isPasswordError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return message.toLowerCase().includes("password") || message.toLowerCase().includes("encrypt");
+}
+function formatPdfErrorMessage(err) {
+  if (isPasswordError(err)) {
+    return "This PDF is password-protected. Unlock it with an external tool first.";
+  }
+  return `Failed to read PDF: ${err instanceof Error ? err.message : String(err)}`;
+}
+function processPdfContent(text, maxBytes) {
+  let output = text;
+  let truncated = false;
+  if (output.length > maxBytes) {
+    output = output.slice(0, maxBytes) + "\n\n[Output truncated due to size limit]";
+    truncated = true;
+  }
+  const isScanned = output.replace(/\[Page \d+\/\d+\]\n/g, "").trim().length === 0;
+  return { output, truncated, isScanned };
+}
+var IMAGE_KIND_GRAYSCALE_1BPP = 1;
+var IMAGE_KIND_RGB_24BPP = 2;
+var IMAGE_KIND_RGBA_32BPP = 3;
+function getRgbaPixel(data, width, x, y, kind) {
+  if (kind === IMAGE_KIND_RGBA_32BPP) {
+    const i = (y * width + x) * 4;
+    return [data[i] ?? 0, data[i + 1] ?? 0, data[i + 2] ?? 0, data[i + 3] ?? 255];
+  }
+  if (kind === IMAGE_KIND_RGB_24BPP) {
+    const i = (y * width + x) * 3;
+    return [data[i] ?? 0, data[i + 1] ?? 0, data[i + 2] ?? 0, 255];
+  }
+  if (kind === IMAGE_KIND_GRAYSCALE_1BPP) {
+    const bytesPerRow = Math.ceil(width / 8);
+    const byteIdx = y * bytesPerRow + Math.floor(x / 8);
+    const bitIdx = 7 - x % 8;
+    const val = (data[byteIdx] ?? 0) >> bitIdx & 1 ? 255 : 0;
+    return [val, val, val, 255];
+  }
+  return [0, 0, 0, 255];
+}
+function toRgbaBuffer(data, width, height, kind) {
+  const rgba = new Uint8Array(width * height * 4);
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      const [r, g, b, a] = getRgbaPixel(data, width, x, y, kind);
+      const i = (y * width + x) * 4;
+      rgba[i] = r;
+      rgba[i + 1] = g;
+      rgba[i + 2] = b;
+      rgba[i + 3] = a;
+    }
+  }
+  return rgba;
+}
+function extractBitmapToRawImageData(bitmap) {
+  const canvas = new globalThis.OffscreenCanvas(bitmap.width, bitmap.height);
+  const ctx = canvas.getContext("2d");
+  ctx.drawImage(bitmap, 0, 0);
+  const imageData = ctx.getImageData(0, 0, bitmap.width, bitmap.height);
+  return {
+    width: bitmap.width,
+    height: bitmap.height,
+    data: new Uint8Array(imageData.data.buffer),
+    kind: IMAGE_KIND_RGBA_32BPP
+  };
+}
+function encodeImageToDataUrl(imgData, maxDimension = 1024) {
+  try {
+    let { width, height } = imgData;
+    let { data, kind } = imgData;
+    if (imgData.bitmap && !data) {
+      const converted = extractBitmapToRawImageData(imgData.bitmap);
+      data = converted.data;
+      kind = converted.kind;
+    }
+    if (!data) return null;
+    if (width * height * 4 > 20971520) return null;
+    if (maxDimension > 0 && (width > maxDimension || height > maxDimension)) {
+      const scale = maxDimension / Math.max(width, height);
+      const newWidth = Math.round(width * scale);
+      const newHeight = Math.round(height * scale);
+      const scaled = new Uint8Array(newWidth * newHeight * 4);
+      for (let y = 0; y < newHeight; y++) {
+        for (let x = 0; x < newWidth; x++) {
+          const srcX = Math.floor(x / scale);
+          const srcY = Math.floor(y / scale);
+          const dstI = (y * newWidth + x) * 4;
+          const [r, g, b, a] = getRgbaPixel(data, width, srcX, srcY, kind);
+          scaled[dstI] = r;
+          scaled[dstI + 1] = g;
+          scaled[dstI + 2] = b;
+          scaled[dstI + 3] = a;
+        }
+      }
+      width = newWidth;
+      height = newHeight;
+      const png2 = new PNG({ width, height });
+      Buffer.from(scaled.buffer, scaled.byteOffset, scaled.byteLength).copy(png2.data);
+      const pngBuffer2 = PNG.sync.write(png2);
+      return `data:image/png;base64,${pngBuffer2.toString("base64")}`;
+    }
+    let rgba;
+    if (kind === IMAGE_KIND_RGBA_32BPP) {
+      rgba = Uint8Array.from(
+        data instanceof Uint8ClampedArray ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : data
+      );
+    } else {
+      rgba = toRgbaBuffer(data, width, height, kind);
+    }
+    const png = new PNG({ width, height });
+    Buffer.from(rgba.buffer, rgba.byteOffset, rgba.byteLength).copy(png.data);
+    const pngBuffer = PNG.sync.write(png);
+    return `data:image/png;base64,${pngBuffer.toString("base64")}`;
+  } catch {
+    return null;
+  }
+}
+async function extractPageBlocks(page, pageIndex, pageCount, imageCounter, maxImages) {
+  const [textContent, opList] = await Promise.all([page.getTextContent(), page.getOperatorList()]);
+  const textItems = textContent.items.filter(
+    (item) => "str" in item
+  );
+  const textStr = textItems.map((t) => t.str).join(" ").trim();
+  const imageOpIndices = [];
+  for (let i = 0; i < opList.fnArray.length; i++) {
+    const op = opList.fnArray[i];
+    if (op === OPS.paintImageXObject || op === OPS.paintInlineImageXObject || op === OPS.paintImageMaskXObject || op === OPS.paintImageMaskXObjectGroup || op === OPS.paintImageXObjectRepeat || op === OPS.paintImageMaskXObjectRepeat || op === OPS.paintInlineImageXObjectGroup || op === OPS.paintSolidColorImageMask) {
+      imageOpIndices.push(i);
+    }
+  }
+  const blocks = [];
+  if (textStr) {
+    blocks.push({ type: "text", content: `[Page ${pageIndex}/${pageCount}]
+${textStr}` });
+  }
+  for (let imageOpIdx = 0; imageOpIdx < imageOpIndices.length; imageOpIdx++) {
+    if (imageCounter.count >= maxImages) {
+      imageCounter.limitReached = true;
+      break;
+    }
+    const opIdx = imageOpIndices[imageOpIdx];
+    if (opIdx === void 0) break;
+    const imgBlock = await extractImageBlock(page, opList, opIdx);
+    if (imgBlock) {
+      blocks.push(imgBlock);
+      imageCounter.count++;
+    }
+  }
+  return blocks;
+}
+function isValidPixelData(data) {
+  return data instanceof Uint8Array || data instanceof Uint8ClampedArray;
+}
+var IMAGE_RESOLVE_TIMEOUT_MS = 5e3;
+async function getObjectWithFallback(objs, objId) {
+  try {
+    return objs.get(objId);
+  } catch {
+  }
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => reject(new Error("timeout")), IMAGE_RESOLVE_TIMEOUT_MS);
+    try {
+      ;
+      objs.get(objId, (data) => {
+        clearTimeout(timeoutId);
+        resolve(data);
+      });
+    } catch (e) {
+      clearTimeout(timeoutId);
+      reject(e);
+    }
+  });
+}
+async function extractImageBlock(page, opList, opIdx) {
+  const args = opList.argsArray[opIdx];
+  const objId = Array.isArray(args) ? args[0] : void 0;
+  let imgData = null;
+  if (objId && typeof objId === "string") {
+    try {
+      const store = objId.startsWith("g_") ? page.commonObjs : page.objs;
+      const raw = await getObjectWithFallback(store, objId);
+      if (raw && typeof raw === "object" && "width" in raw && "height" in raw) {
+        const r = raw;
+        if (isValidPixelData(r["data"])) {
+          imgData = raw;
+        } else if (r["bitmap"] && !r["data"]) {
+          imgData = raw;
+        }
+      }
+    } catch {
+    }
+  } else if (Array.isArray(args) && args[0] && typeof args[0] === "object" && "width" in args[0]) {
+    const inline = args[0];
+    if (isValidPixelData(inline["data"])) {
+      imgData = args[0];
+    } else if (inline["bitmap"] && !inline["data"]) {
+      imgData = args[0];
+    }
+  }
+  if (imgData) {
+    const dataUrl = encodeImageToDataUrl(imgData);
+    if (dataUrl) {
+      return { type: "image", dataUrl };
+    }
+  }
+  return null;
+}
+async function extractPdfContent(buffer) {
+  const doc = await getDocument({ data: Uint8Array.from(buffer) }).promise;
+  const pageCount = doc.numPages;
+  const allBlocks = [];
+  const limitedPageCount = Math.min(pageCount, OUTPUT_LIMITS.read_file.maxPdfPages);
+  const maxImages = OUTPUT_LIMITS.read_file.maxPdfImages;
+  const imageCounter = { count: 0, limitReached: false };
+  let title = null;
+  let author = null;
+  try {
+    const rawMeta = await doc.getMetadata();
+    const info = rawMeta.info;
+    title = info?.["Title"] || null;
+    author = info?.["Author"] || null;
+  } catch {
+  }
+  try {
+    for (let i = 1; i <= limitedPageCount; i++) {
+      const page = await doc.getPage(i);
+      try {
+        const blocks = await extractPageBlocks(page, i, pageCount, imageCounter, maxImages);
+        allBlocks.push(...blocks);
+      } finally {
+        page.cleanup();
+      }
+    }
+  } catch {
+  } finally {
+    doc.cleanup();
+  }
+  if (pageCount > limitedPageCount) {
+    allBlocks.push({
+      type: "text",
+      content: `[PDF has ${pageCount} pages, showing first ${limitedPageCount}. Use a shell command to process more.]`
+    });
+  }
+  if (imageCounter.limitReached) {
+    allBlocks.push({
+      type: "text",
+      content: `[Image limit reached: showing first ${maxImages} images out of more in this document.]`
+    });
+  }
+  return {
+    blocks: allBlocks,
+    pageCount,
+    title,
+    author,
+    imageCount: imageCounter.count,
+    imageLimitReached: imageCounter.limitReached
+  };
+}
+async function extractPdfText(buffer) {
+  const result = await extractPdfContent(buffer);
+  const text = result.blocks.filter((b) => b.type === "text").map((b) => b.content ?? "").join("\n\n");
+  return { text, pageCount: result.pageCount, title: result.title, author: result.author };
+}
+
+// src/server/utils/cache.ts
+import { createHash } from "crypto";
+function contentHash(data) {
+  return createHash("sha256").update(data).digest("hex").slice(0, 16);
+}
+function cacheSet(cache, key, value) {
+  const max = 50;
+  if (cache.size >= max) {
+    const first = cache.keys().next().value;
+    if (first !== void 0) cache.delete(first);
+  }
+  cache.set(key, value);
+}
+
+// src/server/utils/data-url.ts
+function decodeDataUrl(data) {
+  const match = data.match(/^data:.*?;base64,(.+)$/);
+  if (!match?.[1]) return null;
+  try {
+    return Buffer.from(match[1], "base64");
+  } catch {
+    return null;
+  }
+}
+
+export {
+  OUTPUT_LIMITS,
+  isPdfBuffer,
+  formatPdfErrorMessage,
+  processPdfContent,
+  extractPdfContent,
+  extractPdfText,
+  contentHash,
+  cacheSet,
+  decodeDataUrl
+};
+//# sourceMappingURL=chunk-FSSUPWYO.js.map

package/dist/{chunk-5UQ4CKOA.js → chunk-G5GUQKLS.js}

@@ -4,14 +4,15 @@ import {
 } from "./chunk-OA2FURC3.js";
 import {
   createLLMClient
-} from "./chunk-ZMK4VX7V.js";
+} from "./chunk-64YDOCQR.js";
 import {
   getModelProfile
 } from "./chunk-TS5WKTFB.js";
 import {
   detectBackendFromUrl,
+  detectProviderDefaultsFromUrl,
   getBackendCapabilities
-} from "./chunk-UV6IH6HK.js";
+} from "./chunk-AKWJMMEJ.js";
 import {
   buildModelsUrl,
   ensureVersionPrefix,
@@ -19,12 +20,15 @@ import {
 } from "./chunk-HNCM3D7Y.js";
 import {
   resolveAttachmentsInMessages
-} from "./chunk-EUOWCVU6.js";
+} from "./chunk-QMU3ZY2C.js";
+import {
+  sanitizeToolSchema
+} from "./chunk-XG3AUMPI.js";
 import {
   getCatalogEntry,
   resolveEffortForModel,
   resolveModeModelId
-} from "./chunk-2AI7VYPN.js";
+} from "./chunk-VKMPR25F.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -79,6 +83,15 @@ function createTransportLLMClient(provider, modelId, transport, reasoningEffort)
       request: {
         ...request,
         messages: await resolveAttachmentsInMessages(request.messages, supportsVision),
+        ...request.tools ? {
+          tools: request.tools.map((t) => ({
+            ...t,
+            function: {
+              ...t.function,
+              parameters: sanitizeToolSchema(t.function.parameters)
+            }
+          }))
+        } : {},
         ...resolvedEffort && !send.suppressEffort ? { reasoningEffort: resolvedEffort } : {}
       },
       effort: resolvedEffort
@@ -265,6 +278,7 @@ function mergeModelsWithUserOverrides(backendModels, userModels, preserveMissing
   const claimedByMergedModes = /* @__PURE__ */ new Set();
   for (const userModel of userModels) {
     if (!userModel.modes?.length) continue;
+    claimedByMergedModes.add(normalizeModelId(userModel.id));
     for (const mode of userModel.modes) {
       if (mode.apiModelId) claimedByMergedModes.add(normalizeModelId(mode.apiModelId));
     }
@@ -449,6 +463,10 @@ function createProviderManager(config, options = {}) {
     });
     return effort ? { reasoningEffort: effort } : {};
   }
+  function resolveThinkingField(provider) {
+    if (provider.thinkingField) return provider.thinkingField;
+    return detectProviderDefaultsFromUrl(provider.url)?.thinkingField;
+  }
   function createConfigForProvider(provider, model, reasoningEffort) {
     const modelThinking = resolveModelThinkingConfig(provider, model, reasoningEffort);
     const configureModel = provider.models.find((m) => m.id === model);
@@ -458,6 +476,7 @@ function createProviderManager(config, options = {}) {
       configureModel?.apiModelId,
       model
     );
+    const thinkingField = resolveThinkingField(provider);
     return {
       ...config,
       llm: {
@@ -466,7 +485,7 @@ function createProviderManager(config, options = {}) {
         model: send.modelId,
         backend: resolveBackend(provider),
         ...provider.apiKey && { apiKey: provider.apiKey },
-        ...provider.thinkingField && { thinkingField: provider.thinkingField },
+        ...thinkingField ? { thinkingField } : {},
         ...provider.sendReasoningInMessages !== void 0 ? { sendReasoningInMessages: provider.sendReasoningInMessages } : {},
         ...modelThinking.reasoningEffort && !send.suppressEffort && { reasoningEffort: modelThinking.reasoningEffort }
       }
@@ -767,7 +786,9 @@ function createProviderManager(config, options = {}) {
         source: "user",
         ...existingModel?.name !== void 0 && { name: existingModel.name },
         ...existingModel?.apiModelId !== void 0 && { apiModelId: existingModel.apiModelId },
+        ...existingModel?.requestBody !== void 0 && { requestBody: existingModel.requestBody },
         ...existingModel?.modes !== void 0 && { modes: existingModel.modes },
+        ...existingModel?.selected !== void 0 && { selected: existingModel.selected },
         ...finalTemp !== void 0 && { temperature: finalTemp },
         ...finalTopP !== void 0 && { topP: finalTopP },
         ...finalTopK !== void 0 && { topK: finalTopK },
@@ -895,4 +916,4 @@ export {
   parseDefaultModelSelection,
   createProviderManager
 };
-//# sourceMappingURL=chunk-5UQ4CKOA.js.map
+//# sourceMappingURL=chunk-G5GUQKLS.js.map

package/dist/{chunk-7ET46SNE.js → chunk-HEYU7FAY.js}

@@ -6,10 +6,10 @@ import {
 } from "./chunk-TS5WKTFB.js";
 import {
   getBackendCapabilities
-} from "./chunk-UV6IH6HK.js";
+} from "./chunk-AKWJMMEJ.js";
 import {
   buildModelParams
-} from "./chunk-EUOWCVU6.js";
+} from "./chunk-QMU3ZY2C.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -518,4 +518,4 @@ export {
   createChatDoneEvent,
   consumeStreamGenerator
 };
-//# sourceMappingURL=chunk-7ET46SNE.js.map
+//# sourceMappingURL=chunk-HEYU7FAY.js.map

package/dist/{chunk-4R5GV7RW.js → chunk-JIS6C6PA.js}

@@ -1,51 +1,51 @@
+import {
+  buildCachedPrompt,
+  checkToolChangesAndInject,
+  computeDynamicContextHash,
+  getToolFingerprint
+} from "./chunk-6TQNTFJW.js";
 import {
   createAssemblyResult,
   getConversationMessages,
   getToolRegistryForAgent,
   processEventsForConversation,
   runTopLevelAgentLoop
-} from "./chunk-ESZQTFQP.js";
+} from "./chunk-ZQENKB7X.js";
+import {
+  getAllInstructions,
+  getEnabledSkillMetadata
+} from "./chunk-Q33DL67W.js";
 import {
   serverT
-} from "./chunk-OZWHRBDY.js";
+} from "./chunk-4SBVW4UH.js";
 import {
   TurnMetrics,
   createChatDoneEvent,
   createMessageStartEvent
-} from "./chunk-7ET46SNE.js";
-import {
-  buildCachedPrompt,
-  checkToolChangesAndInject,
-  computeDynamicContextHash,
-  getToolFingerprint
-} from "./chunk-VHLD6PCZ.js";
-import {
-  getAllInstructions,
-  getEnabledSkillMetadata
-} from "./chunk-DWA4IE65.js";
+} from "./chunk-HEYU7FAY.js";
 import {
   buildAgentReminder,
   buildAgentSmallReminder,
   buildTopLevelSystemPrompt
-} from "./chunk-7QMWYNVF.js";
+} from "./chunk-4LLGI372.js";
 import {
   PathAccessDeniedError
-} from "./chunk-I5ODJKYM.js";
+} from "./chunk-XWWRZSK7.js";
 import {
   getCurrentContextWindowId,
   getCurrentWindowMessageOptions,
   getEventStore
-} from "./chunk-QZOV4OVN.js";
+} from "./chunk-2OO46UAW.js";
 import {
   buildSnapshotFromSessionState
-} from "./chunk-MEEUXRFL.js";
+} from "./chunk-MMGHIPBU.js";
 import {
   findAgentById,
   getRuntimeConfig,
   getSubAgents,
   loadAllAgentsDefault,
   resolveDefaultAgentId
-} from "./chunk-ORCQ3EXQ.js";
+} from "./chunk-BHVR2YS5.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -55,7 +55,7 @@ import {
 
 // src/server/chat/orchestrator.ts
 async function buildRetryPatterns() {
-  const { getSetting, SETTINGS_KEYS } = await import("./settings-ZJPM6PQV.js");
+  const { getSetting, SETTINGS_KEYS } = await import("./settings-WH6BVQCP.js");
   const raw = getSetting(SETTINGS_KEYS.RETRY_PATTERNS);
   if (!raw) {
     const oldXmlProtection = getSetting("llm.disableXmlProtection");
@@ -355,7 +355,7 @@ async function runAgentTurn(options, turnMetrics, agentId, append, callbacks) {
       getConversationMessages: buildGetConversationMessages(options.sessionId, resolveAgentClient, append),
       injectAgentReminder: () => injectAgentReminder(options.sessionId, agentDef),
       rebuildCachedContext: async () => {
-        const { applyDynamicContext } = await import("./dynamic-context-LKC6JYLQ.js");
+        const { applyDynamicContext } = await import("./dynamic-context-HL4RGNHK.js");
         await applyDynamicContext(options.sessionManager, options.sessionId, agentLlmClient.getModel());
       },
       ...options.initialCompacting ? { initialCompacting: true } : {},
@@ -385,4 +385,4 @@ export {
   runChatTurn,
   runAgentTurn
 };
-//# sourceMappingURL=chunk-4R5GV7RW.js.map
+//# sourceMappingURL=chunk-JIS6C6PA.js.map

package/dist/{chunk-5H5NRWHA.js → chunk-LQPAM55V.js}

@@ -1,10 +1,10 @@
 import {
   runAgentTurn
-} from "./chunk-4R5GV7RW.js";
+} from "./chunk-JIS6C6PA.js";
 import {
   executeSubAgent,
   getToolRegistryForAgent
-} from "./chunk-ESZQTFQP.js";
+} from "./chunk-ZQENKB7X.js";
 import {
   gitSpawnEnv
 } from "./chunk-J7GAZGZT.js";
@@ -14,38 +14,40 @@ import {
   loadDefaultWorkflows,
   loadProjectWorkflows,
   loadUserWorkflows,
-  normalizeWorkflowScope,
+  normalizeWorkflowScope
+} from "./chunk-QBWJCO5K.js";
+import {
   serverT
-} from "./chunk-OZWHRBDY.js";
+} from "./chunk-4SBVW4UH.js";
 import {
   TurnMetrics,
   createMessageStartEvent
-} from "./chunk-7ET46SNE.js";
+} from "./chunk-HEYU7FAY.js";
 import {
   checkAborted,
   decodeUtf8,
   spawnShellProcess
-} from "./chunk-5UMXFLET.js";
+} from "./chunk-SAGDTQXD.js";
 import {
   terminateProcessTree
 } from "./chunk-I72ACQ6R.js";
 import {
   getCurrentContextWindowId,
   getEventStore
-} from "./chunk-QZOV4OVN.js";
+} from "./chunk-2OO46UAW.js";
 import {
   findAgentById,
   getRuntimeConfig,
   loadAllAgentsDefault,
   resolveDefaultAgentId
-} from "./chunk-ORCQ3EXQ.js";
+} from "./chunk-BHVR2YS5.js";
 import {
   createChatMessageMessage,
   createSessionRunningMessage
 } from "./chunk-AATMPL7S.js";
 import {
   LLMError
-} from "./chunk-J3NMNYGM.js";
+} from "./chunk-N5JKVNLH.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -1021,4 +1023,4 @@ export {
   abortRunnerRun,
   launchWorkflowRun
 };
-//# sourceMappingURL=chunk-5H5NRWHA.js.map
+//# sourceMappingURL=chunk-LQPAM55V.js.map