sparkecoder 0.1.71 → 0.1.73

package/dist/db/index.d.ts

@@ -1,5 +1,5 @@
-import { C as Checkpoint, F as FileBackup, M as ModelMessage, a as Message, S as Session, L as LoadedSkill, T as TodoItem, b as ToolExecution, A as ActiveStream, I as IndexStatusRecord, c as IndexedChunk, d as SubagentExecution, e as SubagentStep, f as Terminal } from '../schema-C7Mm4Ykn.js';
-export { N as NewActiveStream, g as NewCheckpoint, h as NewFileBackup, i as NewIndexStatusRecord, j as NewIndexedChunk, k as NewMessage, l as NewSession, m as NewSubagentExecution, n as NewTerminal, o as NewTodoItem, p as NewToolExecution, q as SessionConfig, r as TaskConfig, U as UserContentPart, s as UserFilePart, t as UserImagePart, u as UserModelMessage, v as UserTextPart } from '../schema-C7Mm4Ykn.js';
+import { C as Checkpoint, F as FileBackup, M as ModelMessage, a as Message, S as Session, L as LoadedSkill, T as TodoItem, b as ToolExecution, A as ActiveStream, I as IndexStatusRecord, c as IndexedChunk, d as SubagentExecution, e as SubagentStep, f as Terminal } from '../schema-XcP0dedO.js';
+export { N as NewActiveStream, g as NewCheckpoint, h as NewFileBackup, i as NewIndexStatusRecord, j as NewIndexedChunk, k as NewMessage, l as NewSession, m as NewSubagentExecution, n as NewTerminal, o as NewTodoItem, p as NewToolExecution, q as SessionConfig, r as TaskConfig, U as UserContentPart, s as UserFilePart, t as UserImagePart, u as UserModelMessage, v as UserTextPart } from '../schema-XcP0dedO.js';
 import 'drizzle-orm/sqlite-core';
 
 /**

package/dist/{index-CYNqPa6Z.d.ts → index-dbWF1hyW.d.ts}

@@ -1,7 +1,7 @@
 import { ModelMessage, streamText } from 'ai';
-import { S as Session, b as ToolExecution, r as TaskConfig } from './schema-C7Mm4Ykn.js';
+import { S as Session, b as ToolExecution, r as TaskConfig } from './schema-XcP0dedO.js';
 import { z } from 'zod';
-import { B as BashToolProgress, W as WriteFileProgress, S as SearchToolProgress } from './search-CVVfuBPZ.js';
+import { B as BashToolProgress, W as WriteFileProgress, S as SearchToolProgress } from './search-CCffrVJE.js';
 
 declare const ToolApprovalConfigSchema: z.ZodObject<{
     bash: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
@@ -37,54 +37,54 @@ declare const SessionConfigSchema: z.ZodObject<{
         error: z.ZodOptional<z.ZodString>;
         iterations: z.ZodOptional<z.ZodNumber>;
     }, "strip", z.ZodTypeAny, {
-        status: "running" | "completed" | "failed";
-        enabled: boolean;
+        status: "completed" | "failed" | "running";
         outputSchema: Record<string, unknown>;
-        webhookUrl?: string | undefined;
+        enabled: boolean;
+        error?: string | undefined;
         maxIterations?: number | undefined;
+        webhookUrl?: string | undefined;
         result?: unknown;
-        error?: string | undefined;
         iterations?: number | undefined;
     }, {
-        status: "running" | "completed" | "failed";
-        enabled: boolean;
+        status: "completed" | "failed" | "running";
         outputSchema: Record<string, unknown>;
-        webhookUrl?: string | undefined;
+        enabled: boolean;
+        error?: string | undefined;
         maxIterations?: number | undefined;
+        webhookUrl?: string | undefined;
         result?: unknown;
-        error?: string | undefined;
         iterations?: number | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     maxContextChars: number;
     toolApprovals?: Record<string, boolean> | undefined;
     approvalWebhook?: string | undefined;
-    skillsDirectory?: string | undefined;
     task?: {
-        status: "running" | "completed" | "failed";
-        enabled: boolean;
+        status: "completed" | "failed" | "running";
         outputSchema: Record<string, unknown>;
-        webhookUrl?: string | undefined;
+        enabled: boolean;
+        error?: string | undefined;
         maxIterations?: number | undefined;
+        webhookUrl?: string | undefined;
         result?: unknown;
-        error?: string | undefined;
         iterations?: number | undefined;
     } | undefined;
+    skillsDirectory?: string | undefined;
 }, {
     toolApprovals?: Record<string, boolean> | undefined;
     approvalWebhook?: string | undefined;
-    skillsDirectory?: string | undefined;
-    maxContextChars?: number | undefined;
     task?: {
-        status: "running" | "completed" | "failed";
-        enabled: boolean;
+        status: "completed" | "failed" | "running";
         outputSchema: Record<string, unknown>;
-        webhookUrl?: string | undefined;
+        enabled: boolean;
+        error?: string | undefined;
         maxIterations?: number | undefined;
+        webhookUrl?: string | undefined;
         result?: unknown;
-        error?: string | undefined;
         iterations?: number | undefined;
     } | undefined;
+    skillsDirectory?: string | undefined;
+    maxContextChars?: number | undefined;
 }>;
 declare const SparkcoderConfigSchema: z.ZodObject<{
     defaultModel: z.ZodDefault<z.ZodString>;
@@ -179,6 +179,7 @@ declare const SparkcoderConfigSchema: z.ZodObject<{
         exclude?: string[] | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
+    defaultModel: string;
     toolApprovals: {
         bash: boolean;
         write_file: boolean;
@@ -186,7 +187,6 @@ declare const SparkcoderConfigSchema: z.ZodObject<{
         load_skill: boolean;
         todo: boolean;
     };
-    defaultModel: string;
     skills: {
         directory: string;
         additionalDirectories: string[];
@@ -202,8 +202,8 @@ declare const SparkcoderConfigSchema: z.ZodObject<{
         publicUrl?: string | undefined;
     };
     databasePath: string;
-    approvalWebhook?: string | undefined;
     workingDirectory?: string | undefined;
+    approvalWebhook?: string | undefined;
     remoteServer?: {
         url?: string | undefined;
         authKey?: string | undefined;
@@ -217,6 +217,8 @@ declare const SparkcoderConfigSchema: z.ZodObject<{
         namespace?: string | undefined;
     } | undefined;
 }, {
+    defaultModel?: string | undefined;
+    workingDirectory?: string | undefined;
     toolApprovals?: {
         bash?: boolean | undefined;
         write_file?: boolean | undefined;
@@ -225,8 +227,6 @@ declare const SparkcoderConfigSchema: z.ZodObject<{
         todo?: boolean | undefined;
     } | undefined;
     approvalWebhook?: string | undefined;
-    workingDirectory?: string | undefined;
-    defaultModel?: string | undefined;
     skills?: {
         directory?: string | undefined;
         additionalDirectories?: string[] | undefined;
@@ -299,40 +299,54 @@ interface ResolvedConfig extends Omit<SparkcoderConfig, 'server'> {
 
 interface ContextManagerOptions {
     sessionId: string;
+    modelId: string;
     maxContextChars: number;
     keepRecentMessages: number;
     autoSummarize: boolean;
 }
 /**
- * Manages conversation context including history and summarization
+ * Manages conversation context with a three-phase rolling window:
  *
- * Uses AI SDK's ModelMessage format directly for accurate message passing.
- * Messages are stored in the exact format returned by response.messages.
+ *   Phase 1 – Compact: strip todo tool calls, trim large tool outputs,
+ *             and remove thinking blocks from older messages (no LLM cost).
+ *   Phase 2 – Chunk-summarize: when compacted context still exceeds the
+ *             model's rolling target, summarize the oldest ~30 K-token chunk
+ *             via a cheap/fast model (gemini-3-flash-preview).
+ *   Phase 3 – Roll summaries: when accumulated summaries exceed their budget
+ *             (~15 % of rolling target), re-summarize them into one.
  */
 declare class ContextManager {
     private sessionId;
+    private modelId;
     private maxContextChars;
     private keepRecentMessages;
     private autoSummarize;
-    private summary;
+    private summaries;
     constructor(options: ContextManagerOptions);
     /**
-     * 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.
      */
     getMessages(): Promise<ModelMessage[]>;
     /**
-     * Summarize older messages to reduce context size
+     * Strip non-essential content from messages older than the most recent
+     * `recentCount`. Operates in-memory only — does not touch the DB.
      */
-    private summarizeContext;
+    compactOlderMessages(messages: ModelMessage[], recentCount: number): ModelMessage[];
+    private compactMessage;
+    private trimToolResult;
     /**
-     * Add a user message to the context
-     * Content can be a string or an array of content parts (for messages with images/files)
+     * 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.
      */
+    private chunkSummarize;
+    private summarizeChunk;
+    /**
+     * If accumulated summaries exceed `budget` tokens, re-summarize them
+     * into a single condensed summary.
+     */
+    private rollSummaries;
+    private messageTokens;
     addUserMessage(content: string | Array<{
         type: string;
         text?: string;
@@ -340,22 +354,14 @@ declare class ContextManager {
         data?: string;
         mediaType?: string;
     }>): Promise<void>;
-    /**
-     * Add response messages from AI SDK directly
-     * This is the preferred method - use result.response.messages from streamText/generateText
-     */
     addResponseMessages(messages: ModelMessage[]): Promise<void>;
-    /**
-     * Get current context statistics
-     */
     getStats(): Promise<{
         messageCount: number;
         contextChars: number;
+        estimatedTokens: number;
         hasSummary: boolean;
+        summaryCount: number;
     }>;
-    /**
-     * Clear all messages in the context
-     */
     clear(): Promise<void>;
 }
 
@@ -540,7 +546,9 @@ declare class Agent {
     getContextStats(): Promise<{
         messageCount: number;
         contextChars: number;
+        estimatedTokens: number;
         hasSummary: boolean;
+        summaryCount: number;
     }>;
     /**
      * Clear conversation context (start fresh)

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { R as ResolvedConfig } from './index-CYNqPa6Z.js';
-export { A as Agent, a as AgentOptions, b as AgentRunOptions, c as AgentStreamResult, S as SparkcoderConfig, T as ToolApprovalConfig } from './index-CYNqPa6Z.js';
+import { R as ResolvedConfig } from './index-dbWF1hyW.js';
+export { A as Agent, a as AgentOptions, b as AgentRunOptions, c as AgentStreamResult, S as SparkcoderConfig, T as ToolApprovalConfig } from './index-dbWF1hyW.js';
 export { ServerOptions, createApp, startServer, stopServer } from './server/index.js';
 export { checkpointQueries, closeDatabase, fileBackupQueries, getDb, initDatabase, messageQueries, sessionQueries, skillQueries, todoQueries, toolExecutionQueries } from './db/index.js';
-import { F as FileBackup, C as Checkpoint } from './schema-C7Mm4Ykn.js';
-export { a as Message, M as ModelMessage, S as Session, q as SessionConfig, f as Terminal, T as TodoItem, b as ToolExecution } from './schema-C7Mm4Ykn.js';
+import { F as FileBackup, C as Checkpoint } from './schema-XcP0dedO.js';
+export { a as Message, M as ModelMessage, S as Session, q as SessionConfig, f as Terminal, T as TodoItem, b as ToolExecution } from './schema-XcP0dedO.js';
 export { createLoadSkillTool, createReadFileTool, createTodoTool, createTools } from './tools/index.js';
-export { c as createBashTool, a as createWriteFileTool } from './search-CVVfuBPZ.js';
+export { c as createBashTool, a as createWriteFileTool } from './search-CCffrVJE.js';
 import 'ai';
 import 'zod';
 import 'hono/types';

package/dist/index.js

@@ -2280,6 +2280,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) {
@@ -6267,9 +6280,6 @@ ${conversationHistory}
 Summary:`;
 }
 
-// src/agent/context.ts
-init_config();
-
 // src/utils/sanitize-messages.ts
 import { modelMessageSchema } from "ai";
 function convertDatesToStrings(value) {
@@ -6406,79 +6416,237 @@ 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);
-    }
-    if (this.summary) {
-      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.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;
+    return messages;
   }
+  // ---------------------------------------------------------------------------
+  // Phase 1 – Compact
+  // ---------------------------------------------------------------------------
   /**
-   * Summarize older messages to reduce context size
+   * Strip non-essential content from messages older than the most recent
+   * `recentCount`. Operates in-memory only — does not touch the DB.
    */
-  async summarizeContext(messages) {
-    if (messages.length <= this.keepRecentMessages) {
-      return messages;
-    }
-    const splitIndex = messages.length - this.keepRecentMessages;
-    const oldMessages = messages.slice(0, splitIndex);
-    const recentMessages = messages.slice(splitIndex);
-    const historyText = oldMessages.map((msg) => {
+  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 compacted = [];
+    for (const msg of olderMessages) {
+      const processed = this.compactMessage(msg);
+      if (processed) compacted.push(processed);
+    }
+    return [...compacted, ...recentMessages];
+  }
+  compactMessage(msg) {
+    if (!Array.isArray(msg.content)) return msg;
+    const parts = [];
+    for (const part of msg.content) {
+      if (part.type === "tool-call" && part.toolName === "todo") continue;
+      if (part.type === "tool-result" && part.toolName === "todo") 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
+  // ---------------------------------------------------------------------------
+  /**
+   * 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 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);
+    }
+    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",
@@ -6486,30 +6654,22 @@ ${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 = [];
   }
 };
 
@@ -6577,6 +6737,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