sparkecoder 0.1.72 → 0.1.74

package/dist/agent/index.d.ts

@@ -1,6 +1,6 @@
 import 'ai';
 import '../schema-XcP0dedO.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-Dm6wGcYv.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-DT1l57s0.js';
 import '../search-CCffrVJE.js';
 import 'drizzle-orm/sqlite-core';
 import 'zod';

package/dist/agent/index.js

@@ -1794,9 +1794,8 @@ function createRemoteModel(modelId, config) {
       });
       if (!res.ok) {
         const err = await res.json().catch(() => ({}));
-        throw new Error(
-          `Remote inference failed (${res.status}): ${err.error || res.statusText}`
-        );
+        const detail = formatRemoteError(res.status, modelId, err);
+        throw new Error(detail);
       }
       const result = await res.json();
       return deserializeValue(result);
@@ -1813,9 +1812,8 @@ function createRemoteModel(modelId, config) {
       });
       if (!res.ok) {
         const err = await res.json().catch(() => ({}));
-        throw new Error(
-          `Remote inference failed (${res.status}): ${err.error || res.statusText}`
-        );
+        const detail = formatRemoteError(res.status, modelId, err);
+        throw new Error(detail);
       }
       const reader = res.body.getReader();
       const decoder = new TextDecoder();
@@ -1873,6 +1871,18 @@ function createRemoteModel(modelId, config) {
     }
   };
 }
+function formatRemoteError(status, modelId, body) {
+  const parts = [`Remote inference failed (${status}) for ${modelId}`];
+  if (body.error) parts.push(body.error);
+  if (body.details) {
+    const d = body.details;
+    if (d.type) parts.push(`type=${d.type}`);
+    if (d.statusCode && d.statusCode !== status) parts.push(`upstream=${d.statusCode}`);
+    if (d.cause) parts.push(`cause: ${d.cause}`);
+    if (d.orderWarnings?.length) parts.push(`prompt issues: ${d.orderWarnings.join("; ")}`);
+  }
+  return parts.join(" \u2014 ");
+}
 
 // src/agent/model.ts
 init_config();
@@ -1912,6 +1922,19 @@ import { z as z2 } from "zod";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
 
+// src/utils/tokens.ts
+var CHARS_PER_TOKEN = 4;
+var MESSAGE_OVERHEAD_TOKENS = 4;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function estimateMessageTokens(messages) {
+  return messages.reduce((total, msg) => {
+    const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    return total + estimateTokens(content) + MESSAGE_OVERHEAD_TOKENS;
+  }, 0);
+}
+
 // src/utils/truncate.ts
 var MAX_OUTPUT_CHARS = 1e4;
 function truncateOutput(output, maxChars = MAX_OUTPUT_CHARS) {
@@ -5698,9 +5721,6 @@ ${conversationHistory}
 Summary:`;
 }
 
-// src/agent/context.ts
-init_config();
-
 // src/utils/sanitize-messages.ts
 import { modelMessageSchema } from "ai";
 function convertDatesToStrings(value) {
@@ -5837,79 +5857,256 @@ function sanitizeModelMessages(messages) {
   return result;
 }
 
+// src/agent/model-limits.ts
+var MODEL_LIMITS = {
+  "anthropic/claude-opus-4-6": { contextWindow: 2e5, rollingTarget: 15e4 },
+  "anthropic/claude-sonnet-4": { contextWindow: 2e5, rollingTarget: 15e4 },
+  "anthropic/claude-3.5-sonnet": { contextWindow: 2e5, rollingTarget: 15e4 },
+  "anthropic/claude-3-haiku": { contextWindow: 2e5, rollingTarget: 15e4 },
+  "google/gemini-3-flash-preview": { contextWindow: 1e6, rollingTarget: 15e4 },
+  "google/gemini-2.5-pro": { contextWindow: 1e6, rollingTarget: 15e4 },
+  "google/gemini-2.5-flash": { contextWindow: 1e6, rollingTarget: 15e4 },
+  "openai/gpt-4o": { contextWindow: 128e3, rollingTarget: 78e3 },
+  "openai/gpt-4.1": { contextWindow: 1e6, rollingTarget: 15e4 },
+  "openai/o3": { contextWindow: 2e5, rollingTarget: 15e4 },
+  "xai/grok-3": { contextWindow: 131072, rollingTarget: 8e4 }
+};
+var DEFAULT_LIMITS = { contextWindow: 2e5, rollingTarget: 15e4 };
+var PREFIX_DEFAULTS = {
+  "anthropic/": { contextWindow: 2e5, rollingTarget: 15e4 },
+  "google/": { contextWindow: 1e6, rollingTarget: 15e4 },
+  "openai/": { contextWindow: 128e3, rollingTarget: 78e3 },
+  "xai/": { contextWindow: 131072, rollingTarget: 8e4 }
+};
+function getModelLimits(modelId) {
+  const normalized = modelId.trim().toLowerCase();
+  const exact = MODEL_LIMITS[normalized];
+  if (exact) return exact;
+  for (const [prefix, limits] of Object.entries(PREFIX_DEFAULTS)) {
+    if (normalized.startsWith(prefix)) return limits;
+  }
+  return DEFAULT_LIMITS;
+}
+var SUMMARIZATION_MODEL = "google/gemini-3-flash-preview";
+var SUMMARY_CHUNK_TOKENS = 3e4;
+var SUMMARY_BUDGET_RATIO = 0.15;
+
 // src/agent/context.ts
+var TOOL_OUTPUT_TRIM_CHARS = 400;
+var COMPACTABLE_TOOLS = /* @__PURE__ */ new Set([
+  "read_file",
+  "bash",
+  "explore_agent",
+  "code_graph"
+]);
 var ContextManager = class {
   sessionId;
+  modelId;
   maxContextChars;
   keepRecentMessages;
   autoSummarize;
-  summary = null;
+  summaries = [];
   constructor(options) {
     this.sessionId = options.sessionId;
+    this.modelId = options.modelId;
     this.maxContextChars = options.maxContextChars;
     this.keepRecentMessages = options.keepRecentMessages;
     this.autoSummarize = options.autoSummarize;
   }
   /**
-   * Get messages for the current context
-   * Returns ModelMessage[] that can be passed directly to streamText/generateText
-   * 
-   * Includes self-repair: if messages from the database have been corrupted
-   * (e.g., Date objects in tool outputs from parseDates), they are automatically
-   * sanitized to conform to the AI SDK's ModelMessage schema.
+   * Get messages for the current context, applying the three-phase pipeline.
    */
   async getMessages() {
-    let modelMessages = await messageQueries.getModelMessages(this.sessionId);
-    modelMessages = sanitizeModelMessages(modelMessages);
-    const contextSize = calculateContextSize(modelMessages);
-    if (this.autoSummarize && contextSize > this.maxContextChars) {
-      modelMessages = await this.summarizeContext(modelMessages);
+    let messages = await messageQueries.getModelMessages(this.sessionId);
+    messages = sanitizeModelMessages(messages);
+    messages = this.compactOlderMessages(messages, this.keepRecentMessages);
+    if (this.autoSummarize) {
+      const { rollingTarget } = getModelLimits(this.modelId);
+      const summaryBudget = Math.floor(rollingTarget * SUMMARY_BUDGET_RATIO);
+      messages = await this.chunkSummarize(messages, rollingTarget);
+      await this.rollSummaries(summaryBudget);
     }
-    if (this.summary) {
-      modelMessages = [
+    if (this.summaries.length > 0) {
+      const summaryContent = this.summaries.join("\n\n---\n\n");
+      messages = [
         {
           role: "system",
           content: `[Previous conversation summary]
-${this.summary}`
+${summaryContent}`
         },
-        ...modelMessages
+        ...messages
       ];
     }
-    return modelMessages;
+    messages = repairToolPairing(messages);
+    return messages;
+  }
+  // ---------------------------------------------------------------------------
+  // Phase 1 – Compact
+  // ---------------------------------------------------------------------------
+  /**
+   * Strip non-essential content from messages older than the most recent
+   * `recentCount`. Operates in-memory only — does not touch the DB.
+   *
+   * Tracks removed tool-call IDs so matching tool-results are also removed,
+   * preventing orphaned tool_result blocks that providers reject.
+   */
+  compactOlderMessages(messages, recentCount) {
+    if (messages.length <= recentCount) return messages;
+    const boundary = messages.length - recentCount;
+    const olderMessages = messages.slice(0, boundary);
+    const recentMessages = messages.slice(boundary);
+    const removedToolCallIds = /* @__PURE__ */ new Set();
+    const compacted = [];
+    for (const msg of olderMessages) {
+      const processed = this.compactMessage(msg, removedToolCallIds);
+      if (processed) compacted.push(processed);
+    }
+    if (removedToolCallIds.size > 0) {
+      const cleaned = [];
+      for (const msg of compacted) {
+        const result = stripOrphanedToolResults(msg, removedToolCallIds);
+        if (result) cleaned.push(result);
+      }
+      return [...cleaned, ...recentMessages];
+    }
+    return [...compacted, ...recentMessages];
+  }
+  compactMessage(msg, removedToolCallIds) {
+    if (!Array.isArray(msg.content)) return msg;
+    const parts = [];
+    for (const part of msg.content) {
+      if (part.type === "tool-call" && part.toolName === "todo") {
+        if (part.toolCallId) removedToolCallIds.add(part.toolCallId);
+        continue;
+      }
+      if (part.type === "tool-result" && part.toolName === "todo") {
+        if (part.toolCallId) removedToolCallIds.add(part.toolCallId);
+        continue;
+      }
+      if (part.type === "reasoning" || part.type === "thinking") continue;
+      if (part.type === "tool-result" && COMPACTABLE_TOOLS.has(part.toolName)) {
+        parts.push(this.trimToolResult(part));
+        continue;
+      }
+      parts.push(part);
+    }
+    if (parts.length === 0) return null;
+    return { ...msg, content: parts };
+  }
+  trimToolResult(part) {
+    const results = Array.isArray(part.result) ? part.result : [part.result];
+    const trimmedResults = results.map((r) => {
+      if (typeof r === "string" && r.length > TOOL_OUTPUT_TRIM_CHARS) {
+        const half = Math.floor(TOOL_OUTPUT_TRIM_CHARS / 2);
+        return r.slice(0, half) + `
+...[trimmed ${r.length - TOOL_OUTPUT_TRIM_CHARS} chars]...
+` + r.slice(-half);
+      }
+      if (r && typeof r === "object" && typeof r.text === "string" && r.text.length > TOOL_OUTPUT_TRIM_CHARS) {
+        const half = Math.floor(TOOL_OUTPUT_TRIM_CHARS / 2);
+        return {
+          ...r,
+          text: r.text.slice(0, half) + `
+...[trimmed ${r.text.length - TOOL_OUTPUT_TRIM_CHARS} chars]...
+` + r.text.slice(-half)
+        };
+      }
+      return r;
+    });
+    return {
+      ...part,
+      result: Array.isArray(part.result) ? trimmedResults : trimmedResults[0]
+    };
   }
+  // ---------------------------------------------------------------------------
+  // Phase 2 – Chunk-summarize
+  // ---------------------------------------------------------------------------
   /**
-   * Summarize older messages to reduce context size
+   * While estimated tokens exceed `rollingTarget`, peel off the oldest
+   * ~SUMMARY_CHUNK_TOKENS worth of messages, summarize them via the cheap
+   * model, and prepend the summary.
    */
-  async summarizeContext(messages) {
-    if (messages.length <= this.keepRecentMessages) {
-      return messages;
+  async chunkSummarize(messages, rollingTarget) {
+    let totalTokens = estimateMessageTokens(messages);
+    while (totalTokens > rollingTarget && messages.length > this.keepRecentMessages) {
+      let chunkTokens = 0;
+      let chunkEnd = 0;
+      const maxChunkable = messages.length - this.keepRecentMessages;
+      for (let i = 0; i < maxChunkable; i++) {
+        const msgTokens = this.messageTokens(messages[i]);
+        chunkTokens += msgTokens;
+        chunkEnd = i + 1;
+        if (chunkTokens >= SUMMARY_CHUNK_TOKENS) break;
+      }
+      if (chunkEnd === 0) break;
+      const chunk = messages.slice(0, chunkEnd);
+      const remaining = messages.slice(chunkEnd);
+      const summary = await this.summarizeChunk(chunk);
+      if (summary) {
+        this.summaries.push(summary);
+        console.log(
+          `[Context] Summarized ${chunk.length} messages (~${chunkTokens} tokens) into ${estimateTokens(summary)} tokens`
+        );
+      }
+      messages = remaining;
+      totalTokens = estimateMessageTokens(messages);
     }
-    const splitIndex = messages.length - this.keepRecentMessages;
-    const oldMessages = messages.slice(0, splitIndex);
-    const recentMessages = messages.slice(splitIndex);
-    const historyText = oldMessages.map((msg) => {
+    return messages;
+  }
+  async summarizeChunk(chunk) {
+    const historyText = chunk.map((msg) => {
       const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
       return `[${msg.role}]: ${content}`;
     }).join("\n\n");
     try {
-      const config = getConfig();
-      const summaryPrompt = createSummaryPrompt(historyText);
       const result = await generateText2({
-        model: resolveModel(config.defaultModel),
-        prompt: summaryPrompt
+        model: resolveModel(SUMMARIZATION_MODEL),
+        prompt: createSummaryPrompt(historyText)
       });
-      this.summary = result.text;
-      console.log(`[Context] Summarized ${oldMessages.length} messages into ${this.summary.length} chars`);
-      return recentMessages;
+      return result.text;
     } catch (error) {
-      console.error("[Context] Failed to summarize:", error);
-      return recentMessages;
+      console.error("[Context] Chunk summarization failed:", error);
+      return null;
     }
   }
+  // ---------------------------------------------------------------------------
+  // Phase 3 – Roll summaries
+  // ---------------------------------------------------------------------------
   /**
-   * Add a user message to the context
-   * Content can be a string or an array of content parts (for messages with images/files)
+   * If accumulated summaries exceed `budget` tokens, re-summarize them
+   * into a single condensed summary.
    */
+  async rollSummaries(budget) {
+    if (this.summaries.length <= 1) return;
+    const totalSummaryTokens = this.summaries.reduce(
+      (t, s) => t + estimateTokens(s),
+      0
+    );
+    if (totalSummaryTokens <= budget) return;
+    const combined = this.summaries.join("\n\n---\n\n");
+    try {
+      const result = await generateText2({
+        model: resolveModel(SUMMARIZATION_MODEL),
+        prompt: createSummaryPrompt(combined)
+      });
+      console.log(
+        `[Context] Rolled ${this.summaries.length} summaries (${totalSummaryTokens} tokens) into ${estimateTokens(result.text)} tokens`
+      );
+      this.summaries = [result.text];
+    } catch (error) {
+      console.error("[Context] Summary rolling failed:", error);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+  messageTokens(msg) {
+    const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    return estimateTokens(content) + 4;
+  }
+  // ---------------------------------------------------------------------------
+  // Public API (unchanged)
+  // ---------------------------------------------------------------------------
   async addUserMessage(content) {
     const userMessage = {
       role: "user",
@@ -5917,32 +6114,69 @@ ${this.summary}`
     };
     await messageQueries.create(this.sessionId, userMessage);
   }
-  /**
-   * Add response messages from AI SDK directly
-   * This is the preferred method - use result.response.messages from streamText/generateText
-   */
   async addResponseMessages(messages) {
     await messageQueries.addMany(this.sessionId, messages);
   }
-  /**
-   * Get current context statistics
-   */
   async getStats() {
     const messages = await messageQueries.getModelMessages(this.sessionId);
     return {
       messageCount: messages.length,
       contextChars: calculateContextSize(messages),
-      hasSummary: this.summary !== null
+      estimatedTokens: estimateMessageTokens(messages),
+      hasSummary: this.summaries.length > 0,
+      summaryCount: this.summaries.length
     };
   }
-  /**
-   * Clear all messages in the context
-   */
   async clear() {
     await messageQueries.deleteBySession(this.sessionId);
-    this.summary = null;
+    this.summaries = [];
   }
 };
+function stripOrphanedToolResults(msg, removedIds) {
+  if (!Array.isArray(msg.content)) return msg;
+  const parts = msg.content.filter((part) => {
+    if (part.type === "tool-result" && removedIds.has(part.toolCallId)) return false;
+    if (part.type === "tool-call" && removedIds.has(part.toolCallId)) return false;
+    return true;
+  });
+  if (parts.length === 0) return null;
+  return { ...msg, content: parts };
+}
+function repairToolPairing(messages) {
+  const toolCallIds = /* @__PURE__ */ new Set();
+  const toolResultIds = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    if (!Array.isArray(msg.content)) continue;
+    for (const part of msg.content) {
+      if (part.type === "tool-call" && part.toolCallId) toolCallIds.add(part.toolCallId);
+      if (part.type === "tool-result" && part.toolCallId) toolResultIds.add(part.toolCallId);
+    }
+  }
+  const orphanedCalls = new Set([...toolCallIds].filter((id) => !toolResultIds.has(id)));
+  const orphanedResults = new Set([...toolResultIds].filter((id) => !toolCallIds.has(id)));
+  if (orphanedCalls.size === 0 && orphanedResults.size === 0) return messages;
+  if (orphanedCalls.size > 0) {
+    console.warn(`[tool-repair] Removing ${orphanedCalls.size} orphaned tool-call(s) with no matching result`);
+  }
+  if (orphanedResults.size > 0) {
+    console.warn(`[tool-repair] Removing ${orphanedResults.size} orphaned tool-result(s) with no matching call`);
+  }
+  const repaired = [];
+  for (const msg of messages) {
+    if (!Array.isArray(msg.content)) {
+      repaired.push(msg);
+      continue;
+    }
+    const parts = msg.content.filter((part) => {
+      if (part.type === "tool-call" && orphanedCalls.has(part.toolCallId)) return false;
+      if (part.type === "tool-result" && orphanedResults.has(part.toolCallId)) return false;
+      return true;
+    });
+    if (parts.length === 0) continue;
+    repaired.push({ ...msg, content: parts });
+  }
+  return repaired;
+}
 
 // src/utils/webhook.ts
 async function sendWebhook(url, event) {
@@ -6026,6 +6260,7 @@ var Agent = class _Agent {
     }
     const context = new ContextManager({
       sessionId: session.id,
+      modelId: session.model || config.defaultModel,
       maxContextChars: config.context?.maxChars || 2e5,
       keepRecentMessages: config.context?.keepRecentMessages || 10,
       autoSummarize: config.context?.autoSummarize ?? true