sparkecoder 0.1.138 → 0.1.140

package/dist/index.js

@@ -7669,6 +7669,105 @@ var init_cap_image_count = __esm({
   }
 });
 
+// src/utils/sanitize-images.ts
+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;
+}
+var SUPPORTED_IMAGE_TYPES, INVALID_IMAGE_PLACEHOLDER;
+var init_sanitize_images = __esm({
+  "src/utils/sanitize-images.ts"() {
+    "use strict";
+    SUPPORTED_IMAGE_TYPES = ["image/jpeg", "image/png", "image/gif", "image/webp"];
+    INVALID_IMAGE_PLACEHOLDER = "[invalid image omitted \u2014 the data was not a valid jpeg/png/gif/webp]";
+  }
+});
+
 // src/agent/model-limits.ts
 function getModelLimits(modelId) {
   const normalized = modelId.trim().toLowerCase();
@@ -7686,7 +7785,11 @@ var init_model_limits = __esm({
     MODEL_LIMITS = {
       "claude-opus-4-8": { contextWindow: 2e5, rollingTarget: 15e4 },
       "gpt-5.5": { contextWindow: 35e4, rollingTarget: 15e4 },
-      "claude-fable-5": { contextWindow: 2e5, rollingTarget: 15e4 }
+      "claude-fable-5": { contextWindow: 2e5, rollingTarget: 15e4 },
+      // Claude Opus 4.7 advertises a 1M-token context. Keyed WITH the provider
+      // prefix because getModelLimits() matches the full id (e.g.
+      // "anthropic/claude-opus-4.7") before falling back to the prefix table.
+      "anthropic/claude-opus-4.7": { contextWindow: 1e6, rollingTarget: 15e4 }
     };
     DEFAULT_LIMITS = { contextWindow: 2e5, rollingTarget: 15e4 };
     PREFIX_DEFAULTS = {
@@ -7760,6 +7863,39 @@ var init_conversation_archive = __esm({
 
 // src/agent/context.ts
 import { generateText as generateText2 } from "ai";
+function truncateMiddle(s, cap) {
+  if (s.length <= cap) return s;
+  const half = Math.floor(cap / 2);
+  return s.slice(0, half) + `
+...[truncated ${s.length - cap} chars to fit context]...
+` + s.slice(-half);
+}
+function truncateToolResultText(part) {
+  const trunc = (r) => {
+    if (typeof r === "string") return truncateMiddle(r, HARD_TRUNCATE_CHARS);
+    if (r && typeof r === "object" && typeof r.text === "string") {
+      return { ...r, text: truncateMiddle(r.text, HARD_TRUNCATE_CHARS) };
+    }
+    return r;
+  };
+  if (Array.isArray(part.result)) return { ...part, result: part.result.map(trunc) };
+  if ("result" in part) return { ...part, result: trunc(part.result) };
+  return part;
+}
+function hardTruncateMessageText(msg) {
+  if (typeof msg.content === "string") {
+    return { ...msg, content: truncateMiddle(msg.content, HARD_TRUNCATE_CHARS) };
+  }
+  if (!Array.isArray(msg.content)) return msg;
+  const parts = msg.content.map((part) => {
+    if (part?.type === "text" && typeof part.text === "string") {
+      return { ...part, text: truncateMiddle(part.text, HARD_TRUNCATE_CHARS) };
+    }
+    if (part?.type === "tool-result") return truncateToolResultText(part);
+    return part;
+  });
+  return { ...msg, content: parts };
+}
 function stripBinaryContentForSummary(value) {
   if (Array.isArray(value)) return value.map(stripBinaryContentForSummary);
   if (!value || typeof value !== "object") return value;
@@ -7936,7 +8072,7 @@ function ensureEndsWithUserOrTool(messages) {
     { role: "user", content: [{ type: "text", text: "Please continue." }] }
   ];
 }
-var TOOL_OUTPUT_TRIM_CHARS, COMPACTABLE_TOOLS, ContextManager;
+var TOOL_OUTPUT_TRIM_CHARS, COMPACTABLE_TOOLS, ContextManager, HARD_TRUNCATE_CHARS;
 var init_context = __esm({
   "src/agent/context.ts"() {
     "use strict";
@@ -7947,6 +8083,7 @@ var init_context = __esm({
     init_prompts();
     init_sanitize_messages();
     init_cap_image_count();
+    init_sanitize_images();
     init_model_limits();
     TOOL_OUTPUT_TRIM_CHARS = 400;
     COMPACTABLE_TOOLS = /* @__PURE__ */ new Set([
@@ -7996,9 +8133,50 @@ ${summaryContent}`
         messages = repairToolPairing(messages);
         messages = ensureToolResultsFollowCalls(messages);
         messages = ensureEndsWithUserOrTool(messages);
+        messages = sanitizeInvalidImages(messages);
         messages = capImageCount(messages);
+        messages = this.enforceHardCap(messages);
         return messages;
       }
+      /**
+       * Drop oldest messages (and, as a last resort, hard-truncate text) until
+       * the prompt fits the model's context window. Preserves any leading
+       * summary system message and always keeps the most recent message, then
+       * repairs tool pairing so dropping can't orphan a tool result.
+       */
+      enforceHardCap(messages) {
+        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);
+        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;
+        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 > 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 ${tokenCeiling} est-tokens / ${MAX_MESSAGES} msgs).`
+        );
+        return out;
+      }
       // ---------------------------------------------------------------------------
       // Phase 1 – Compact
       // ---------------------------------------------------------------------------
@@ -8225,6 +8403,7 @@ ${summaryContent}`
         this.summaries = [];
       }
     };
+    HARD_TRUNCATE_CHARS = 6e3;
   }
 });
 
@@ -9086,7 +9265,29 @@ function markRespondedForThread(slackChannel2, threadTs) {
   }
 }
 function resolveBatchOnTurnEnd(events, ok) {
-  if (!ok) return;
+  if (!ok) {
+    for (const ev of events) {
+      const key2 = eventKey(ev);
+      const entry2 = ledger.get(key2);
+      if (!entry2 || TERMINAL.has(entry2.state)) continue;
+      entry2.state = "failed";
+      entry2.updatedAt = Date.now();
+      if (entry2.channel === "slack" && entry2.slackChannel) {
+        if (entry2.messageTs) fireResultReaction(entry2.slackChannel, entry2.messageTs, "failed");
+        if (entry2.threadTs) maybePostFallback(entry2.slackChannel, entry2.threadTs);
+      }
+      recordEvent({
+        source: "daemon",
+        status: "failed",
+        channel: entry2.channel,
+        sessionId: entry2.sessionId,
+        error: "turn failed; not replayed (avoids context-overflow spiral)",
+        textSnippet: entry2.event.content.slice(0, 200),
+        meta: { ackKey: entry2.key, ackState: "failed" }
+      });
+    }
+    return;
+  }
   for (const ev of events) {
     const key2 = eventKey(ev);
     const entry2 = ledger.get(key2);
@@ -9138,11 +9339,7 @@ function failEntry(entry2) {
   if (entry2.channel === "slack" && entry2.slackChannel && entry2.messageTs) {
     fireResultReaction(entry2.slackChannel, entry2.messageTs, "failed");
     if (entry2.threadTs) {
-      fireFallback(
-        entry2.slackChannel,
-        entry2.threadTs,
-        `:warning: I wasn't able to handle this after ${entry2.attempts} attempt(s). It may need a human \u2014 flagging it here so it isn't lost.`
-      );
+      maybePostFallback(entry2.slackChannel, entry2.threadTs);
     }
   }
   recordEvent({
@@ -9185,6 +9382,17 @@ function fireFallback(channel, threadTs, text) {
   } catch {
   }
 }
+function maybePostFallback(channel, threadTs) {
+  const now = Date.now();
+  const last = lastFallbackAt.get(channel) ?? 0;
+  if (now - last < FALLBACK_COOLDOWN_MS) return;
+  lastFallbackAt.set(channel, now);
+  fireFallback(
+    channel,
+    threadTs,
+    "\u26A0\uFE0F I'm having trouble processing messages right now (likely an overloaded context or a backend error). A human may need to check on me \u2014 I'll pick back up once it's resolved."
+  );
+}
 function startReconciler() {
   if (reconcileTimer) return;
   reconcileTimer = setInterval(() => {
@@ -9206,8 +9414,9 @@ function __listAcks() {
 }
 function __resetAcks() {
   ledger.clear();
+  lastFallbackAt.clear();
 }
-var REPLAY_AFTER_MS, RECONCILE_EVERY_MS, MAX_ATTEMPTS, PRUNE_AFTER_MS, MAX_ENTRIES, TERMINAL, SEP, ledger, reconcileTimer;
+var REPLAY_AFTER_MS, RECONCILE_EVERY_MS, MAX_ATTEMPTS, PRUNE_AFTER_MS, FALLBACK_COOLDOWN_MS, lastFallbackAt, MAX_ENTRIES, TERMINAL, SEP, ledger, reconcileTimer;
 var init_inbox_acks = __esm({
   "src/orchestrator/inbox-acks.ts"() {
     "use strict";
@@ -9218,6 +9427,8 @@ var init_inbox_acks = __esm({
     RECONCILE_EVERY_MS = 6e4;
     MAX_ATTEMPTS = 2;
     PRUNE_AFTER_MS = 60 * 6e4;
+    FALLBACK_COOLDOWN_MS = 15 * 6e4;
+    lastFallbackAt = /* @__PURE__ */ new Map();
     MAX_ENTRIES = 5e3;
     TERMINAL = /* @__PURE__ */ new Set(["responded", "skipped", "handed_off", "failed"]);
     SEP = "\u241F";