openfox 2.0.134 → 2.0.136

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-M4J2L4VH.js → chunk-GP5BYQMF.js}

@@ -2,55 +2,55 @@ import {
   generateSessionNameForSession,
   getSessionMessageCount,
   needsNameGeneration
-} from "./chunk-FAQDLL2X.js";
+} from "./chunk-5YPHN5NC.js";
 import {
   launchWorkflowRun
-} from "./chunk-7HGBJFIJ.js";
+} from "./chunk-CPVEONNS.js";
 import {
   runChatTurn
-} from "./chunk-YOPXAI2W.js";
+} from "./chunk-UL7776XB.js";
+import {
+  applyDynamicContext,
+  computeSessionHash,
+  computeUnifiedDiff
+} from "./chunk-YDPC4FLR.js";
 import {
   devServerManager
-} from "./chunk-J5HOUEPE.js";
+} from "./chunk-EXLCFEML.js";
 import {
   gitSpawnEnv
 } from "./chunk-J7GAZGZT.js";
 import {
   serverT
-} from "./chunk-OZWHRBDY.js";
+} from "./chunk-4SBVW4UH.js";
 import {
   appendCompactionPrompt
-} from "./chunk-BZND27IB.js";
+} from "./chunk-VA2TYWQR.js";
 import {
   hasRecentLLMFailure,
   interruptLLMRetryWait
-} from "./chunk-7ET46SNE.js";
+} from "./chunk-HEYU7FAY.js";
 import {
   onProcessEvent
-} from "./chunk-5UMXFLET.js";
+} from "./chunk-SAGDTQXD.js";
 import {
   killProcessTree
 } from "./chunk-I72ACQ6R.js";
-import {
-  applyDynamicContext,
-  computeSessionHash,
-  computeUnifiedDiff
-} from "./chunk-QICVOQNX.js";
 import {
   getPendingQuestionsForSession,
   provideAnswer
-} from "./chunk-JURM3RPZ.js";
+} from "./chunk-V5AC2TV7.js";
 import {
   combineEventsWithSnapshot,
   getEventStore
-} from "./chunk-CSYOWFPU.js";
+} from "./chunk-342BKOTE.js";
 import {
   buildMessagesFromStoredEvents,
   foldPendingConfirmations
-} from "./chunk-MEEUXRFL.js";
+} from "./chunk-XGG4XCKP.js";
 import {
   getRuntimeConfig
-} from "./chunk-ORCQ3EXQ.js";
+} from "./chunk-BHVR2YS5.js";
 import {
   createChatErrorMessage,
   createChatMessageMessage,
@@ -68,10 +68,10 @@ import {
 } from "./chunk-AATMPL7S.js";
 import {
   getPlatformShell
-} from "./chunk-O3RCSKUH.js";
+} from "./chunk-MOYWDP73.js";
 import {
   getMaxVisibleItems
-} from "./chunk-CTWZPN7G.js";
+} from "./chunk-QUAEH3MP.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -1344,8 +1344,8 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
       }
       const session = sessionManager.requireSession(sessionId);
       try {
-        const { buildCachedPrompt, computePreviewToolDiff } = await import("./dynamic-context-WKEXQCTK.js");
-        const allAgents = await import("./registry-BEIR7Y5G.js");
+        const { buildCachedPrompt, computePreviewToolDiff } = await import("./dynamic-context-RDBNQPPA.js");
+        const allAgents = await import("./registry-FMDMGIUB.js");
         const agentDef = allAgents.findAgentById(session.mode, await allAgents.loadAllAgentsDefault()) ?? allAgents.findAgentById("planner", await allAgents.loadAllAgentsDefault());
         const modelName = session.providerModel ?? _providerManager?.getCurrentModel();
         const {
@@ -1356,7 +1356,7 @@ async function handleClientMessage(ws, client, message, _getLLMClient, _getActiv
         const oldCached = sessionManager.getCachedPrompt(sessionId);
         const oldPrompt = oldCached?.systemPrompt;
         const diff = oldPrompt ? computeUnifiedDiff(oldPrompt, newPrompt) : [];
-        const { getToolRegistryForAgent } = await import("./tools-WWIWD3O7.js");
+        const { getToolRegistryForAgent } = await import("./tools-EJOABHVO.js");
         const unfilteredTools = getToolRegistryForAgent(agentDef).definitions;
         const toolDiff = computePreviewToolDiff(oldCached?.tools, unfilteredTools, newTools);
         send({
@@ -1729,4 +1729,4 @@ export {
   signalMcpReady,
   createWebSocketServer
 };
-//# sourceMappingURL=chunk-M4J2L4VH.js.map
+//# sourceMappingURL=chunk-GP5BYQMF.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-MRE4OYKI.js → chunk-MILEZY2J.js}

@@ -207,7 +207,7 @@ async function runCli(options) {
       break;
     }
     case "provider": {
-      const { runProviderCommand } = await import("./provider-JWUNG2TD.js");
+      const { runProviderCommand } = await import("./provider-SOC6Z25R.js");
       const [, subcommand] = positionals;
       await runProviderCommand(mode, subcommand);
       break;
@@ -252,7 +252,7 @@ async function runCli(options) {
       break;
     }
     case "update": {
-      const { runUpdate } = await import("./update-Q6SH7UP2.js");
+      const { runUpdate } = await import("./update-IPHJMRQZ.js");
       const code = await runUpdate();
       if (code !== 0) {
         process.exit(code);
@@ -265,7 +265,7 @@ async function runCli(options) {
       if (!configExists) {
         await runNetworkSetup(mode);
       }
-      const { runServe } = await import("./serve-HSDVY37K.js");
+      const { runServe } = await import("./serve-EWA5HXC7.js");
       const serveOptions = { mode };
       if (values.port) serveOptions.port = parseInt(values.port);
       if (values["no-browser"] === true) serveOptions.openBrowser = false;
@@ -277,4 +277,4 @@ async function runCli(options) {
 export {
   runCli
 };
-//# sourceMappingURL=chunk-MRE4OYKI.js.map
+//# sourceMappingURL=chunk-MILEZY2J.js.map

package/dist/{chunk-O3RCSKUH.js → chunk-MOYWDP73.js}

@@ -1,7 +1,7 @@
 import {
   SETTINGS_KEYS,
   getSetting
-} from "./chunk-CTWZPN7G.js";
+} from "./chunk-QUAEH3MP.js";
 
 // src/server/utils/platform.ts
 import os from "os";
@@ -63,4 +63,4 @@ export {
   isWindowsPath,
   isAbsolutePath
 };
-//# sourceMappingURL=chunk-O3RCSKUH.js.map
+//# sourceMappingURL=chunk-MOYWDP73.js.map

package/dist/{chunk-J3NMNYGM.js → chunk-N5JKVNLH.js}

@@ -1,7 +1,7 @@
 import {
   SETTINGS_KEYS,
   getSetting
-} from "./chunk-CTWZPN7G.js";
+} from "./chunk-QUAEH3MP.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -194,4 +194,4 @@ export {
   ChatHttpClient,
   OpenAIHttpClient
 };
-//# sourceMappingURL=chunk-J3NMNYGM.js.map
+//# sourceMappingURL=chunk-N5JKVNLH.js.map