sparkecoder 0.1.139 → 0.1.140

package/dist/agent/index.d.ts

@@ -1,6 +1,6 @@
 import 'ai';
-import '../schema-Dz-wABVY.js';
-export { A as Agent, a as AgentOptions, b as AgentRunOptions, c as AgentStreamResult, C as ContextManager, M as MessageAttachment, d as buildSystemPrompt, e as buildTaskPromptAddendum } from '../index-BAsQWqZj.js';
-import '../search-CVVfuBPZ.js';
+import '../schema-BSz4MzhJ.js';
+export { A as Agent, a as AgentOptions, b as AgentRunOptions, c as AgentStreamResult, C as ContextManager, M as MessageAttachment, d as buildSystemPrompt, e as buildTaskPromptAddendum } from '../index-Cl_eUatM.js';
+import '../search-DOzC4ojH.js';
 import 'drizzle-orm/sqlite-core';
 import 'zod';

package/dist/agent/index.js

@@ -7734,6 +7734,99 @@ function capImageCount(messages, max = MAX_IMAGES_IN_CONTEXT) {
   return mutated ? out : messages;
 }
 
+// src/utils/sanitize-images.ts
+var SUPPORTED_IMAGE_TYPES = ["image/jpeg", "image/png", "image/gif", "image/webp"];
+var INVALID_IMAGE_PLACEHOLDER = "[invalid image omitted \u2014 the data was not a valid jpeg/png/gif/webp]";
+function hasImageMagic(bytes) {
+  if (bytes.length < 12) return false;
+  if (bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71) return true;
+  if (bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) return true;
+  if (bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 56) return true;
+  if (bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80) return true;
+  return false;
+}
+function extractBase64(part) {
+  const raw = typeof part?.data === "string" ? part.data : typeof part?.image === "string" ? part.image : null;
+  if (typeof raw !== "string" || raw.length === 0) return null;
+  if (/^https?:\/\//i.test(raw)) return null;
+  const dataUrl = raw.match(/^data:[^;,]+;base64,([\s\S]*)$/);
+  return dataUrl ? dataUrl[1] : raw;
+}
+function isInvalidImagePart(part) {
+  if (!part || typeof part !== "object") return false;
+  const t = part.type;
+  if (t !== "image" && t !== "image-data" && t !== "media") return false;
+  const mt = part.mediaType;
+  const b64 = extractBase64(part);
+  if (b64 === null) {
+    return typeof mt === "string" && mt.startsWith("image/") && !SUPPORTED_IMAGE_TYPES.includes(mt);
+  }
+  let bytes;
+  try {
+    bytes = Buffer.from(b64, "base64");
+  } catch {
+    return true;
+  }
+  if (bytes.length === 0) return true;
+  return !hasImageMagic(bytes);
+}
+function placeholder() {
+  return { type: "text", text: INVALID_IMAGE_PLACEHOLDER };
+}
+function sanitizeInvalidImages(messages) {
+  if (!Array.isArray(messages) || messages.length === 0) return messages;
+  let mutated = false;
+  let dropped = 0;
+  const out = messages.slice();
+  for (let i = 0; i < out.length; i++) {
+    const msg = out[i];
+    if (!Array.isArray(msg.content)) continue;
+    let contentCloned = false;
+    const ensureCloned = () => {
+      if (contentCloned) return;
+      out[i] = { ...msg, content: [...msg.content] };
+      contentCloned = true;
+    };
+    const content = () => out[i].content;
+    for (let j = 0; j < content().length; j++) {
+      const part = content()[j];
+      if (isInvalidImagePart(part)) {
+        ensureCloned();
+        out[i].content[j] = placeholder();
+        mutated = true;
+        dropped++;
+        continue;
+      }
+      if (part && typeof part === "object" && part.type === "tool-result" && part.output && part.output.type === "content" && Array.isArray(part.output.value)) {
+        const innerValue = part.output.value;
+        let innerMutated = false;
+        const newValue = innerValue.slice();
+        for (let k = 0; k < newValue.length; k++) {
+          if (isInvalidImagePart(newValue[k])) {
+            newValue[k] = placeholder();
+            innerMutated = true;
+            dropped++;
+          }
+        }
+        if (innerMutated) {
+          ensureCloned();
+          out[i].content[j] = {
+            ...part,
+            output: { ...part.output, value: newValue }
+          };
+          mutated = true;
+        }
+      }
+    }
+  }
+  if (mutated) {
+    console.warn(
+      `[sanitize-images] Replaced ${dropped} invalid image part(s) with a text placeholder (non-image bytes / unsupported type) to avoid provider 400 "invalid image" errors.`
+    );
+  }
+  return mutated ? out : messages;
+}
+
 // src/agent/model-limits.ts
 var MODEL_LIMITS = {
   "claude-opus-4-8": { contextWindow: 2e5, rollingTarget: 15e4 },
@@ -7813,6 +7906,7 @@ ${summaryContent}`
     messages = repairToolPairing(messages);
     messages = ensureToolResultsFollowCalls(messages);
     messages = ensureEndsWithUserOrTool(messages);
+    messages = sanitizeInvalidImages(messages);
     messages = capImageCount(messages);
     messages = this.enforceHardCap(messages);
     return messages;
@@ -7824,28 +7918,35 @@ ${summaryContent}`
    * repairs tool pairing so dropping can't orphan a tool result.
    */
   enforceHardCap(messages) {
-    const { contextWindow } = getModelLimits(this.modelId);
-    const ceiling = Math.max(2e4, Math.floor(contextWindow * 0.9));
+    const { rollingTarget } = getModelLimits(this.modelId);
+    const MAX_MESSAGES = 120;
+    const tokenCeiling = Math.max(2e4, Math.floor(rollingTarget * 1.5));
     const tokens = messages.map((m) => this.messageTokens(m));
     let total = tokens.reduce((a, b) => a + b, 0);
-    if (total <= ceiling) return messages;
     const hasLeadingSummary = messages.length > 0 && messages[0].role === "system";
     const firstBody = hasLeadingSummary ? 1 : 0;
     const lastIndex = messages.length - 1;
+    const bodyCount = messages.length - firstBody;
+    if (bodyCount <= MAX_MESSAGES && total <= tokenCeiling) return messages;
     let start = firstBody;
-    while (start < lastIndex && total > ceiling) {
+    const countDropTarget = messages.length - MAX_MESSAGES;
+    while (start < countDropTarget && start < lastIndex) {
+      total -= tokens[start];
+      start += 1;
+    }
+    while (start < lastIndex && total > tokenCeiling) {
       total -= tokens[start];
       start += 1;
     }
     let out = hasLeadingSummary ? [messages[0], ...messages.slice(start)] : messages.slice(start);
-    if (total > ceiling) {
+    if (total > tokenCeiling) {
       out = out.map((m) => hardTruncateMessageText(m));
     }
     out = repairToolPairing(out);
     out = ensureToolResultsFollowCalls(out);
     out = ensureEndsWithUserOrTool(out);
     console.warn(
-      `[Context] hard cap engaged for ${this.modelId}: trimmed ${messages.length}\u2192${out.length} msgs (ceiling ${ceiling} tokens).`
+      `[Context] hard cap engaged for ${this.modelId}: trimmed ${messages.length}\u2192${out.length} msgs (ceiling ${tokenCeiling} est-tokens / ${MAX_MESSAGES} msgs).`
     );
     return out;
   }