openfox 2.0.76 → 2.0.77

package/dist/{chunk-EZK7CGJ7.js → chunk-RMXPVQP4.js}

@@ -19,6 +19,7 @@ var OUTPUT_LIMITS = {
     maxImageBytes: 2097152,
     // 2MB for images
     maxPdfPages: 50,
+    maxPdfImages: 20,
     maxFileBytes: 20971520
     // 20MB general file safety limit
   },
@@ -38,7 +39,8 @@ var OUTPUT_LIMITS = {
 };
 
 // src/server/tools/pdf-utils.ts
-import { getDocument } from "pdfjs-dist/legacy/build/pdf.mjs";
+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);
@@ -63,47 +65,278 @@ function processPdfContent(text, maxBytes) {
   const isScanned = output.replace(/\[Page \d+\/\d+\]\n/g, "").trim().length === 0;
   return { output, truncated, isScanned };
 }
-async function extractPdfText(buffer) {
+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 rawMeta = await doc.getMetadata();
-  const info = rawMeta.info;
-  const title = info?.["Title"] || null;
-  const author = info?.["Author"] || null;
-  const pages = [];
+  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 content = await page.getTextContent();
-        const pageText = content.items.map((item) => "str" in item ? item.str : "").join(" ");
-        pages.push(`[Page ${i}/${pageCount}]
-${pageText}`);
+        const blocks = await extractPageBlocks(page, i, pageCount, imageCounter, maxImages);
+        allBlocks.push(...blocks);
       } finally {
         page.cleanup();
       }
     }
+  } catch {
   } finally {
     doc.cleanup();
   }
-  let text = pages.join("\n\n");
   if (pageCount > limitedPageCount) {
-    text += `
+    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 };
+}
 
-[PDF has ${pageCount} pages, showing first ${limitedPageCount}. Use a shell command to process more.]`;
+// 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);
   }
-  return { text, pageCount, title, author };
+  cache.set(key, value);
 }
 
-// src/server/llm/resolve-attachments.ts
-function decodeDataUrlToText(data) {
+// src/server/utils/data-url.ts
+function decodeDataUrl(data) {
   const match = data.match(/^data:.*?;base64,(.+)$/);
-  if (match?.[1]) {
-    return Buffer.from(match[1], "base64").toString("utf8");
+  if (!match?.[1]) return null;
+  try {
+    return Buffer.from(match[1], "base64");
+  } catch {
+    return null;
   }
-  return data;
 }
+
+// src/server/llm/resolve-attachments.ts
+var pdfBlockCache = /* @__PURE__ */ new Map();
 async function extractPdfFromDataUrl(data, filename) {
   const base64Match = data.match(/^data:.*?;base64,(.+)$/);
   if (base64Match?.[1]) {
@@ -118,14 +351,50 @@ ${result.text}`;
   }
   return `[PDF: ${filename}] (could not extract text)`;
 }
+async function extractPdfBlocksFromDataUrl(data, filename) {
+  const cacheKey = contentHash(data);
+  const cached = pdfBlockCache.get(cacheKey);
+  if (cached) {
+    const result = [{ type: "text", text: `[PDF: ${filename}]` }];
+    result.push(...cached);
+    return result;
+  }
+  const base64Match = data.match(/^data:.*?;base64,(.+)$/);
+  if (!base64Match?.[1]) {
+    cacheSet(pdfBlockCache, cacheKey, []);
+    return [{ type: "text", text: `[PDF: ${filename}] (could not extract content)` }];
+  }
+  try {
+    const buffer = Buffer.from(base64Match[1], "base64");
+    const result = await extractPdfContent(buffer);
+    const body = [];
+    for (const block of result.blocks) {
+      if (block.type === "text" && block.content) {
+        body.push({ type: "text", text: block.content });
+      } else if (block.type === "image" && block.dataUrl) {
+        body.push({ type: "image_url", image_url: { url: block.dataUrl } });
+      }
+    }
+    cacheSet(pdfBlockCache, cacheKey, body);
+    const parts = [{ type: "text", text: `[PDF: ${filename}]` }];
+    parts.push(...body);
+    return parts;
+  } catch {
+    cacheSet(pdfBlockCache, cacheKey, []);
+    return [{ type: "text", text: `[PDF: ${filename}] (could not extract content)` }];
+  }
+}
 async function resolveAttachmentToText(attachment, supportsVision) {
   const mimeType = attachment.mimeType;
   if (TEXT_MIME_EXACT.includes(mimeType) || TEXT_MIME_PREFIXES.some((p) => mimeType.startsWith(p))) {
-    const text = decodeDataUrlToText(attachment.data);
+    const text = decodeDataUrl(attachment.data)?.toString("utf8") ?? attachment.data;
     return `[File: ${attachment.filename || "file"}]
 ${text}`;
   }
   if (mimeType === "application/pdf") {
+    if (attachment.pdfContent) {
+      return attachment.pdfContent;
+    }
     return extractPdfFromDataUrl(attachment.data, attachment.filename || "document.pdf");
   }
   if (supportsVision) {
@@ -136,6 +405,7 @@ ${text}`;
   }
   return `[Image: ${attachment.filename || "image"}] (vision not supported, cannot describe)`;
 }
+var isVisionAttachment = (attachment) => attachment.mimeType.startsWith("image/") || attachment.mimeType === "application/pdf";
 async function resolveAttachmentsInMessages(messages, supportsVision) {
   const result = [];
   for (const msg of messages) {
@@ -143,7 +413,7 @@ async function resolveAttachmentsInMessages(messages, supportsVision) {
       result.push(msg);
       continue;
     }
-    if (supportsVision && msg.attachments.every((a) => a.mimeType.startsWith("image/"))) {
+    if (supportsVision && msg.attachments.every(isVisionAttachment)) {
       result.push(msg);
       continue;
     }
@@ -151,7 +421,7 @@ async function resolveAttachmentsInMessages(messages, supportsVision) {
     if (msg.content?.trim()) parts.push(msg.content);
     const remainingImageAttachments = [];
     for (const attachment of msg.attachments) {
-      if (supportsVision && attachment.mimeType.startsWith("image/")) {
+      if (supportsVision && isVisionAttachment(attachment)) {
         remainingImageAttachments.push(attachment);
         continue;
       }
@@ -197,8 +467,8 @@ async function buildAttachmentContent(msgContent, attachments, modelSupportsVisi
     content.push({ type: "text", text: msgContent });
   }
   for (const attachment of attachments) {
-    const converted = await convertAttachment(attachment, modelSupportsVision);
-    content.push(converted);
+    const parts = await convertAttachment(attachment, modelSupportsVision);
+    content.push(...parts);
   }
   return content;
 }
@@ -222,7 +492,7 @@ function getThinking(msg, override) {
 function buildAssistantMessage(msg, thinkingField) {
   const result = {
     role: "assistant",
-    content: msg.content || null
+    content: msg.toolCalls?.length ? msg.content || "" : msg.content || null
   };
   if (msg.toolCalls?.length) {
     result["tool_calls"] = convertToolCalls(msg.toolCalls);
@@ -235,32 +505,28 @@ function buildAssistantMessage(msg, thinkingField) {
 async function convertAttachment(attachment, modelSupportsVision) {
   const mimeType = attachment.mimeType;
   if (TEXT_MIME_EXACT.includes(mimeType) || TEXT_MIME_PREFIXES.some((p) => mimeType.startsWith(p))) {
-    return {
-      type: "text",
-      text: `[File: ${attachment.filename || "file"}]
-${attachment.data}`
-    };
+    return [{ type: "text", text: `[File: ${attachment.filename || "file"}]
+${attachment.data}` }];
   }
   if (mimeType === "application/pdf") {
+    if (modelSupportsVision) {
+      return extractPdfBlocksFromDataUrl(attachment.data, attachment.filename || "document.pdf");
+    }
+    if (attachment.pdfContent) {
+      return [{ type: "text", text: attachment.pdfContent }];
+    }
     const text = await extractPdfFromDataUrl(attachment.data, attachment.filename || "document.pdf");
-    return { type: "text", text };
+    return [{ type: "text", text }];
   }
   if (modelSupportsVision) {
-    return {
-      type: "image_url",
-      image_url: { url: attachment.data }
-    };
+    return [{ type: "image_url", image_url: { url: attachment.data } }];
   }
   if (attachment.description) {
-    return {
-      type: "text",
-      text: `[Image: ${attachment.filename || "image"} - description: ${attachment.description}]`
-    };
+    return [
+      { type: "text", text: `[Image: ${attachment.filename || "image"} - description: ${attachment.description}]` }
+    ];
   }
-  return {
-    type: "text",
-    text: `[Image: ${attachment.filename || "image"}] (vision not supported, cannot describe)`
-  };
+  return [{ type: "text", text: `[Image: ${attachment.filename || "image"}] (vision not supported, cannot describe)` }];
 }
 async function convertMessages(messages, modelSupportsVision, thinkingField) {
   const filtered = messages.filter((msg) => {
@@ -398,7 +664,11 @@ export {
   isPdfBuffer,
   formatPdfErrorMessage,
   processPdfContent,
+  extractPdfContent,
   extractPdfText,
+  contentHash,
+  cacheSet,
+  decodeDataUrl,
   resolveAttachmentsInMessages,
   parseToolArguments,
   buildModelParams,
@@ -409,4 +679,4 @@ export {
   buildStreamingCreateParams,
   mapFinishReason
 };
-//# sourceMappingURL=chunk-EZK7CGJ7.js.map
+//# sourceMappingURL=chunk-RMXPVQP4.js.map

package/dist/{chunk-HLHGNHMV.js → chunk-VMYDUZWI.js}

@@ -9,7 +9,7 @@ import {
   loadAllAgentsDefault,
   processEventsForConversation,
   runTopLevelAgentLoop
-} from "./chunk-D6CI2B7B.js";
+} from "./chunk-YDV7RIQ6.js";
 import {
   TurnMetrics,
   buildAgentReminder,
@@ -17,7 +17,7 @@ import {
   buildTopLevelSystemPrompt,
   createChatDoneEvent,
   createMessageStartEvent
-} from "./chunk-7772ENZN.js";
+} from "./chunk-XNCHOD2X.js";
 import {
   PathAccessDeniedError
 } from "./chunk-46RORSKU.js";
@@ -66,7 +66,7 @@ function resolveAgentDef(sessionManager, sessionId) {
 }
 async function buildCachedPrompt(sessionManager, sessionId, agentDef) {
   const { instructionContent, skills } = await loadSessionContext(sessionManager, sessionId);
-  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-JRCUWPJO.js");
+  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-T7S45DOQ.js");
   const tools = getToolRegistryForAgent2(agentDef).definitions;
   const toolFingerprint = getToolFingerprint(tools);
   const allAgents = await loadAllAgentsDefault();
@@ -79,7 +79,7 @@ async function buildCachedPrompt(sessionManager, sessionId, agentDef) {
 async function computeSessionHash(sessionManager, sessionId) {
   const { instructionContent, skills } = await loadSessionContext(sessionManager, sessionId);
   const agentDef = await resolveAgentDef(sessionManager, sessionId);
-  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-JRCUWPJO.js");
+  const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-T7S45DOQ.js");
   const tools = getToolRegistryForAgent2(agentDef).definitions;
   const toolFingerprint = getToolFingerprint(tools);
   return computeDynamicContextHash(instructionContent, skills, toolFingerprint);
@@ -359,4 +359,4 @@ export {
   runChatTurn,
   runAgentTurn
 };
-//# sourceMappingURL=chunk-HLHGNHMV.js.map
+//# sourceMappingURL=chunk-VMYDUZWI.js.map

package/dist/{chunk-KVRSAC4Z.js → chunk-VPFUXGMM.js}

@@ -8,6 +8,10 @@ function buildUpdatedServerConfig(patch, existing, persistedCfg) {
   const mergedEnv = patch.env !== void 0 ? patch.env : transportChanged ? void 0 : existing.config.env;
   const mergedUrl = patch.url !== void 0 ? patch.url : transportChanged ? void 0 : existing.config.url;
   const mergedHeaders = patch.headers !== void 0 ? patch.headers : transportChanged ? void 0 : existing.config.headers;
+  const mergedTimeout = patch.timeout !== void 0 ? patch.timeout : existing.config.timeout;
+  if (patch.timeout !== void 0 && (typeof patch.timeout !== "number" || patch.timeout <= 0)) {
+    return { serverCfg: {}, error: "timeout must be a positive number" };
+  }
   if (resolvedTransport === "http" && !mergedUrl) {
     return { serverCfg: {}, error: "url is required for http transport" };
   }
@@ -21,6 +25,7 @@ function buildUpdatedServerConfig(patch, existing, persistedCfg) {
     ...mergedEnv && Object.keys(mergedEnv).length > 0 ? { env: mergedEnv } : {},
     ...mergedUrl ? { url: mergedUrl } : {},
     ...mergedHeaders && Object.keys(mergedHeaders).length > 0 ? { headers: mergedHeaders } : {},
+    ...mergedTimeout !== void 0 ? { timeout: mergedTimeout } : {},
     ...persistedCfg?.disabledTools && persistedCfg.disabledTools.length > 0 ? { disabledTools: persistedCfg.disabledTools } : {},
     ...persistedCfg?.cachedTools && persistedCfg.cachedTools.length > 0 ? { cachedTools: persistedCfg.cachedTools } : {}
   };
@@ -51,4 +56,4 @@ export {
   buildUpdatedServerConfig,
   applyMcpServerUpdate
 };
-//# sourceMappingURL=chunk-KVRSAC4Z.js.map
+//# sourceMappingURL=chunk-VPFUXGMM.js.map

package/dist/{chunk-W4ZEG3LX.js → chunk-WL2WEJAK.js}

@@ -13,7 +13,7 @@ import {
   getThinking,
   mapFinishReason,
   parseToolArguments
-} from "./chunk-EZK7CGJ7.js";
+} from "./chunk-RMXPVQP4.js";
 import {
   LLMError,
   OpenAIHttpClient
@@ -268,4 +268,4 @@ function createLLMClient(config, initialBackend = "unknown") {
 export {
   createLLMClient
 };
-//# sourceMappingURL=chunk-W4ZEG3LX.js.map
+//# sourceMappingURL=chunk-WL2WEJAK.js.map

package/dist/{chunk-7772ENZN.js → chunk-XNCHOD2X.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-YHEQTVFV.js";
 import {
   buildModelParams
-} from "./chunk-EZK7CGJ7.js";
+} from "./chunk-RMXPVQP4.js";
 import {
   logger
 } from "./chunk-K44MW7JJ.js";
@@ -679,4 +679,4 @@ export {
   createChatDoneEvent,
   consumeStreamGenerator
 };
-//# sourceMappingURL=chunk-7772ENZN.js.map
+//# sourceMappingURL=chunk-XNCHOD2X.js.map