@townco/agent 0.1.82 → 0.1.84

package/dist/acp-server/session-storage.js

@@ -78,6 +78,16 @@ const toolCallBlockSchema = z.object({
     subagentPort: z.number().optional(),
     subagentSessionId: z.string().optional(),
     subagentMessages: z.array(subagentMessageSchema).optional(),
+    _meta: z
+        .object({
+        truncationWarning: z.string().optional(),
+        compactionAction: z.enum(["compacted", "truncated"]).optional(),
+        originalTokens: z.number().optional(),
+        finalTokens: z.number().optional(),
+        originalContentPreview: z.string().optional(),
+        originalContentPath: z.string().optional(),
+    })
+        .optional(),
 });
 const contentBlockSchema = z.discriminatedUnion("type", [
     textBlockSchema,
@@ -114,7 +124,6 @@ const contextEntrySchema = z.object({
         toolInputTokens: z.number(),
         toolResultsTokens: z.number(),
         totalEstimated: z.number(),
-        llmReportedInputTokens: z.number().optional(),
         modelContextWindow: z.number().optional(),
     }),
 });
@@ -131,7 +140,8 @@ const storedSessionSchema = z.object({
 });
 /**
  * File-based session storage
- * Stores sessions in agents/<agent-name>/.sessions/<session_id>.json
+ * Stores sessions in agents/<agent-name>/.sessions/<session_id>/session.json
+ * (Legacy: agents/<agent-name>/.sessions/<session_id>.json)
  */
 export class SessionStorage {
     sessionsDir;
@@ -146,17 +156,25 @@ export class SessionStorage {
         this.agentName = agentName;
     }
     /**
-     * Ensure the .sessions directory exists
+     * Ensure the session directory exists
      */
-    ensureSessionsDir() {
-        if (!existsSync(this.sessionsDir)) {
-            mkdirSync(this.sessionsDir, { recursive: true });
+    ensureSessionDir(sessionId) {
+        const sessionDir = join(this.sessionsDir, sessionId);
+        if (!existsSync(sessionDir)) {
+            mkdirSync(sessionDir, { recursive: true });
         }
     }
     /**
      * Get the file path for a session
      */
     getSessionPath(sessionId) {
+        return join(this.sessionsDir, sessionId, "session.json");
+    }
+    /**
+     * Get the legacy file path for a session (for backwards compatibility)
+     * Legacy format: .sessions/<session_id>.json (flat file, not directory)
+     */
+    getLegacySessionPath(sessionId) {
         return join(this.sessionsDir, `${sessionId}.json`);
     }
     /**
@@ -164,7 +182,7 @@ export class SessionStorage {
      * Uses atomic write (write to temp file, then rename)
      */
     async saveSession(sessionId, messages, context) {
-        this.ensureSessionsDir();
+        this.ensureSessionDir(sessionId);
         const sessionPath = this.getSessionPath(sessionId);
         const tempPath = `${sessionPath}.tmp`;
         const now = new Date().toISOString();
@@ -207,14 +225,24 @@ export class SessionStorage {
     }
     /**
      * Synchronous session loading (for internal use)
+     * Checks new location first, falls back to legacy location
      */
     loadSessionSync(sessionId) {
         const sessionPath = this.getSessionPath(sessionId);
+        const legacyPath = this.getLegacySessionPath(sessionId);
+        // Check new location first
+        let actualPath = sessionPath;
         if (!existsSync(sessionPath)) {
-            return null;
+            // Fall back to legacy location
+            if (existsSync(legacyPath)) {
+                actualPath = legacyPath;
+            }
+            else {
+                return null;
+            }
         }
         try {
-            const content = readFileSync(sessionPath, "utf-8");
+            const content = readFileSync(actualPath, "utf-8");
             const parsed = JSON.parse(content);
             // Validate with zod
             const validated = storedSessionSchema.parse(parsed);
@@ -225,39 +253,64 @@ export class SessionStorage {
         }
     }
     /**
-     * Check if a session exists
+     * Check if a session exists (checks both new and legacy locations)
      */
     sessionExists(sessionId) {
-        return existsSync(this.getSessionPath(sessionId));
+        return (existsSync(this.getSessionPath(sessionId)) ||
+            existsSync(this.getLegacySessionPath(sessionId)));
     }
     /**
-     * Delete a session
+     * Delete a session (deletes entire session directory or legacy file)
      */
     async deleteSession(sessionId) {
-        const sessionPath = this.getSessionPath(sessionId);
-        if (!existsSync(sessionPath)) {
-            return false;
-        }
+        const sessionDir = join(this.sessionsDir, sessionId);
+        const legacyPath = this.getLegacySessionPath(sessionId);
+        let deleted = false;
         try {
-            unlinkSync(sessionPath);
-            return true;
+            // Delete session directory (.sessions/<sessionId>/)
+            if (existsSync(sessionDir)) {
+                // Recursively delete the session directory
+                const { rmSync } = await import("node:fs");
+                rmSync(sessionDir, { recursive: true, force: true });
+                deleted = true;
+            }
+            // Also delete legacy location if it exists (.sessions/<sessionId>.json)
+            if (existsSync(legacyPath)) {
+                unlinkSync(legacyPath);
+                deleted = true;
+            }
+            return deleted;
         }
         catch (error) {
             throw new Error(`Failed to delete session ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     /**
-     * List all session IDs
+     * List all session IDs (checks both new and legacy locations)
      */
     async listSessions() {
-        if (!existsSync(this.sessionsDir)) {
-            return [];
-        }
+        const sessionIds = new Set();
         try {
-            const files = readdirSync(this.sessionsDir);
-            return files
-                .filter((file) => file.endsWith(".json") && !file.endsWith(".tmp"))
-                .map((file) => file.replace(".json", ""));
+            // Check .sessions/ directory
+            if (existsSync(this.sessionsDir)) {
+                const entries = readdirSync(this.sessionsDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        // New format: .sessions/<sessionId>/session.json
+                        const sessionJsonPath = join(this.sessionsDir, entry.name, "session.json");
+                        if (existsSync(sessionJsonPath)) {
+                            sessionIds.add(entry.name);
+                        }
+                    }
+                    else if (entry.isFile() &&
+                        entry.name.endsWith(".json") &&
+                        !entry.name.endsWith(".tmp")) {
+                        // Legacy format: .sessions/<sessionId>.json
+                        sessionIds.add(entry.name.replace(".json", ""));
+                    }
+                }
+            }
+            return Array.from(sessionIds);
         }
         catch (error) {
             throw new Error(`Failed to list sessions: ${error instanceof Error ? error.message : String(error)}`);
@@ -271,43 +324,84 @@ export class SessionStorage {
      * Returns sessions sorted by updatedAt (most recent first)
      */
     async listSessionsWithMetadata() {
-        if (!existsSync(this.sessionsDir)) {
-            return [];
-        }
-        try {
-            const files = readdirSync(this.sessionsDir);
-            const sessionFiles = files.filter((file) => file.endsWith(".json") && !file.endsWith(".tmp"));
-            const sessions = [];
-            for (const file of sessionFiles) {
-                const sessionId = file.replace(".json", "");
-                try {
-                    const session = this.loadSessionSync(sessionId);
-                    if (session) {
-                        // Find the first user message for preview
-                        const firstUserMsg = session.messages.find((m) => m.role === "user");
-                        const firstUserText = firstUserMsg?.content.find((c) => c.type === "text");
-                        const entry = {
-                            sessionId: session.sessionId,
-                            createdAt: session.metadata.createdAt,
-                            updatedAt: session.metadata.updatedAt,
-                            messageCount: session.messages.length,
-                        };
-                        if (firstUserText && "text" in firstUserText) {
-                            entry.firstUserMessage = firstUserText.text.slice(0, 100);
-                        }
-                        sessions.push(entry);
+        // Get all session IDs from both locations
+        const sessionIds = await this.listSessions();
+        const sessions = [];
+        for (const sessionId of sessionIds) {
+            try {
+                const session = this.loadSessionSync(sessionId);
+                if (session) {
+                    // Find the first user message for preview
+                    const firstUserMsg = session.messages.find((m) => m.role === "user");
+                    const firstUserText = firstUserMsg?.content.find((c) => c.type === "text");
+                    const entry = {
+                        sessionId: session.sessionId,
+                        createdAt: session.metadata.createdAt,
+                        updatedAt: session.metadata.updatedAt,
+                        messageCount: session.messages.length,
+                    };
+                    if (firstUserText && "text" in firstUserText) {
+                        entry.firstUserMessage = firstUserText.text.slice(0, 100);
                     }
-                }
-                catch {
-                    // Skip invalid sessions
+                    sessions.push(entry);
                 }
             }
-            // Sort by updatedAt, most recent first
-            sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
-            return sessions;
+            catch {
+                // Skip invalid sessions
+            }
         }
-        catch (error) {
-            throw new Error(`Failed to list sessions: ${error instanceof Error ? error.message : String(error)}`);
+        // Sort by updatedAt, most recent first
+        sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+        return sessions;
+    }
+    /**
+     * Get the directory for storing large content files for a session (artifacts folder)
+     */
+    getArtifactsDir(sessionId) {
+        return join(this.sessionsDir, sessionId, "artifacts");
+    }
+    /**
+     * Get the file path for a tool's original content
+     * Follows the pattern: artifacts/tool-<ToolName>/<toolCallId>.original.txt
+     */
+    getToolOriginalPath(sessionId, toolName, toolCallId) {
+        return join(this.getArtifactsDir(sessionId), `tool-${toolName}`, `${toolCallId}.original.txt`);
+    }
+    /**
+     * Save original tool response to a separate file
+     * Follows the pattern: artifacts/tool-<ToolName>/<toolCallId>.original.txt
+     * @param toolName - The name of the tool (e.g., "Read", "Grep")
+     * @returns Relative file path (for storage in _meta.originalContentPath)
+     */
+    saveToolOriginal(sessionId, toolName, toolCallId, content) {
+        const toolDir = join(this.getArtifactsDir(sessionId), `tool-${toolName}`);
+        if (!existsSync(toolDir)) {
+            mkdirSync(toolDir, { recursive: true });
         }
+        const filePath = this.getToolOriginalPath(sessionId, toolName, toolCallId);
+        writeFileSync(filePath, content, "utf-8");
+        // Return relative path for storage in metadata
+        return `${sessionId}/artifacts/tool-${toolName}/${toolCallId}.original.txt`;
+    }
+    /**
+     * Load original tool response from separate file
+     */
+    loadToolOriginal(sessionId, toolName, toolCallId) {
+        const filePath = this.getToolOriginalPath(sessionId, toolName, toolCallId);
+        if (!existsSync(filePath)) {
+            return null;
+        }
+        try {
+            return readFileSync(filePath, "utf-8");
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Check if original content exists for a tool call
+     */
+    hasToolOriginal(sessionId, toolName, toolCallId) {
+        return existsSync(this.getToolOriginalPath(sessionId, toolName, toolCallId));
     }
 }

package/dist/definition/index.d.ts

@@ -21,7 +21,7 @@ export declare const HookConfigSchema: z.ZodObject<{
     setting: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
         threshold: z.ZodNumber;
     }, z.core.$strip>, z.ZodObject<{
-        maxContextThreshold: z.ZodOptional<z.ZodNumber>;
+        maxTokensSize: z.ZodOptional<z.ZodNumber>;
         responseTruncationThreshold: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>]>>;
     callback: z.ZodString;
@@ -78,7 +78,7 @@ export declare const AgentDefinitionSchema: z.ZodObject<{
         setting: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
             threshold: z.ZodNumber;
         }, z.core.$strip>, z.ZodObject<{
-            maxContextThreshold: z.ZodOptional<z.ZodNumber>;
+            maxTokensSize: z.ZodOptional<z.ZodNumber>;
             responseTruncationThreshold: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>]>>;
         callback: z.ZodString;

package/dist/definition/index.js

@@ -64,7 +64,7 @@ export const HookConfigSchema = z.object({
         }),
         // For tool_response hooks
         z.object({
-            maxContextThreshold: z.number().min(0).max(100).optional(),
+            maxTokensSize: z.number().min(0).optional(),
             responseTruncationThreshold: z.number().min(0).max(100).optional(),
         }),
     ])

package/dist/runner/agent-runner.d.ts

@@ -9,7 +9,7 @@ export declare const zAgentRunnerParams: z.ZodObject<{
     suggestedPrompts: z.ZodOptional<z.ZodArray<z.ZodString>>;
     systemPrompt: z.ZodNullable<z.ZodString>;
     model: z.ZodString;
-    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"town_web_search">, z.ZodLiteral<"filesystem">, z.ZodLiteral<"generate_image">, z.ZodLiteral<"browser">]>, z.ZodObject<{
+    tools: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodLiteral<"artifacts">, z.ZodLiteral<"todo_write">, z.ZodLiteral<"get_weather">, z.ZodLiteral<"web_search">, z.ZodLiteral<"town_web_search">, z.ZodLiteral<"filesystem">, z.ZodLiteral<"generate_image">, z.ZodLiteral<"town_generate_image">, z.ZodLiteral<"browser">]>, z.ZodObject<{
         type: z.ZodLiteral<"custom">;
         modulePath: z.ZodString;
     }, z.core.$strip>, z.ZodObject<{
@@ -48,7 +48,7 @@ export declare const zAgentRunnerParams: z.ZodObject<{
         setting: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
             threshold: z.ZodNumber;
         }, z.core.$strip>, z.ZodObject<{
-            maxContextThreshold: z.ZodOptional<z.ZodNumber>;
+            maxTokensSize: z.ZodOptional<z.ZodNumber>;
             responseTruncationThreshold: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>]>>;
         callback: z.ZodString;
@@ -74,6 +74,8 @@ export interface ConfigOverrides {
 }
 export type InvokeRequest = Omit<PromptRequest, "_meta"> & {
     messageId: string;
+    /** Agent directory path for session-scoped file storage */
+    agentDir?: string;
     sessionMeta?: Record<string, unknown>;
     contextMessages?: SessionMessage[];
     configOverrides?: ConfigOverrides;

package/dist/runner/hooks/executor.d.ts

@@ -41,6 +41,7 @@ export declare class HookExecutor {
     }): Promise<{
         modifiedOutput?: Record<string, unknown>;
         truncationWarning?: string;
+        metadata?: Record<string, unknown>;
         notifications: HookNotification[];
     }>;
     /**

package/dist/runner/hooks/executor.js

@@ -137,6 +137,9 @@ export class HookExecutor {
                     if (result.truncationWarning !== undefined) {
                         response.truncationWarning = result.truncationWarning;
                     }
+                    if (result.metadata !== undefined) {
+                        response.metadata = result.metadata;
+                    }
                     return response;
                 }
             }
@@ -152,7 +155,11 @@ export class HookExecutor {
         const notifications = [];
         // Get threshold from settings
         const settings = hook.setting;
-        const threshold = settings?.maxContextThreshold ?? 80;
+        // For notifications, calculate a percentage based on maxTokensSize relative to maxTokens
+        // Default to 20000 tokens, which we'll convert to a percentage for display
+        const maxTokensSize = settings?.maxTokensSize ?? 20000;
+        // Calculate approximate percentage: maxTokensSize / maxTokens * 100
+        const threshold = Math.min(100, Math.round((maxTokensSize / maxTokens) * 100));
         // Capture start time and emit hook_triggered BEFORE callback runs
         // This allows the UI to show the loading state immediately
         const triggeredAt = Date.now();
@@ -185,8 +192,15 @@ export class HookExecutor {
                 toolResponse,
             };
             const result = await callback(hookContext);
+            logger.info("Hook callback result", {
+                hasMetadata: !!result.metadata,
+                metadataAction: result.metadata?.action,
+                hasModifiedOutput: !!result.metadata?.modifiedOutput,
+                modifiedOutputType: typeof result.metadata?.modifiedOutput,
+                toolCallId: toolResponse.toolCallId,
+            });
             // Extract modified output and warnings from metadata
-            if (result.metadata && result.metadata.modifiedOutput) {
+            if (result.metadata?.modifiedOutput) {
                 // Hook took action - emit completed notification
                 const response = { notifications };
                 response.modifiedOutput = result.metadata.modifiedOutput;
@@ -194,6 +208,8 @@ export class HookExecutor {
                     response.truncationWarning = result.metadata
                         .truncationWarning;
                 }
+                // Include full metadata for persistence
+                response.metadata = result.metadata;
                 // Notify completion
                 this.emitNotification({
                     type: "hook_completed",

package/dist/runner/hooks/predefined/compaction-tool.js

@@ -11,7 +11,7 @@ export const compactionTool = async (ctx) => {
     logger.info("Compaction tool triggered", {
         currentTokens: ctx.currentTokens,
         maxTokens: ctx.maxTokens,
-        percentage: ctx.percentage.toFixed(2) + "%",
+        percentage: `${ctx.percentage.toFixed(2)}%`,
         contextEntries: ctx.session.context.length,
         totalMessages: ctx.session.messages.length,
         model: ctx.model,
@@ -107,7 +107,8 @@ Please provide your summary based on the conversation above, following this stru
                     .join("\n")
                 : "Failed to extract summary";
         // Extract token usage from LLM response
-        const responseUsage = response.usage_metadata;
+        const responseUsage = response
+            .usage_metadata;
         const summaryTokens = responseUsage?.output_tokens ?? 0;
         const inputTokensUsed = responseUsage?.input_tokens ?? ctx.currentTokens;
         logger.info("Generated compaction summary", {

package/dist/runner/hooks/predefined/tool-response-compactor.d.ts

@@ -1,6 +1,2 @@
 import type { HookCallback } from "../types.js";
-/**
- * Tool response compaction hook - compacts or truncates large tool responses
- * to prevent context overflow
- */
 export declare const toolResponseCompactor: HookCallback;

package/dist/runner/hooks/predefined/tool-response-compactor.js

@@ -15,6 +15,8 @@ const COMPACTION_MODEL_CONTEXT = 200000; // Haiku context size for calculating t
  * Tool response compaction hook - compacts or truncates large tool responses
  * to prevent context overflow
  */
+// Tools that should never be compacted (internal/small response tools)
+const SKIP_COMPACTION_TOOLS = new Set(["todo_write", "TodoWrite"]);
 export const toolResponseCompactor = async (ctx) => {
     // Only process if we have tool response data
     if (!ctx.toolResponse) {
@@ -22,28 +24,38 @@ export const toolResponseCompactor = async (ctx) => {
         return { newContextEntry: null };
     }
     const { toolCallId, toolName, toolInput, rawOutput, outputTokens } = ctx.toolResponse;
+    // Skip compaction for certain internal tools
+    if (SKIP_COMPACTION_TOOLS.has(toolName)) {
+        logger.debug("Skipping compaction for internal tool", { toolName });
+        return { newContextEntry: null };
+    }
     // Get settings from hook configuration
     const settings = ctx.session.requestParams.hookSettings;
-    const maxContextThreshold = settings?.maxContextThreshold ?? 80;
+    const maxTokensSize = settings?.maxTokensSize ?? 20000; // Default: 20000 tokens
     const responseTruncationThreshold = settings?.responseTruncationThreshold ?? 30;
-    // Calculate actual token limits from percentages
-    const maxAllowedTotal = ctx.maxTokens * (maxContextThreshold / 100);
-    const availableSpace = maxAllowedTotal - ctx.currentTokens;
-    const projectedTotal = ctx.currentTokens + outputTokens;
+    // Use maxTokensSize directly as it's now in tokens
+    const maxAllowedResponseSize = maxTokensSize;
+    // Calculate available space in context
+    const availableSpace = ctx.maxTokens - ctx.currentTokens;
+    // Failsafe: if available space is less than maxTokensSize, use availableSpace - 10%
+    const effectiveMaxResponseSize = availableSpace < maxAllowedResponseSize
+        ? Math.floor(availableSpace * 0.9)
+        : maxAllowedResponseSize;
     const compactionLimit = COMPACTION_MODEL_CONTEXT * (responseTruncationThreshold / 100);
     logger.info("Tool response compaction hook triggered", {
         toolCallId,
         toolName,
         outputTokens,
         currentContext: ctx.currentTokens,
-        maxAllowedTotal,
+        maxTokens: ctx.maxTokens,
+        maxAllowedResponseSize,
         availableSpace,
-        projectedTotal,
+        effectiveMaxResponseSize,
         compactionLimit,
         settings,
     });
     // Case 0: Small response, no action needed
-    if (projectedTotal < maxAllowedTotal) {
+    if (outputTokens <= effectiveMaxResponseSize) {
         logger.info("Tool response fits within threshold, no compaction needed");
         return {
             newContextEntry: null,
@@ -55,19 +67,20 @@ export const toolResponseCompactor = async (ctx) => {
         };
     }
     // Response would exceed threshold, need to compact or truncate
-    // Determine target size: fit within available space, but cap at compactionLimit for truncation
-    // IMPORTANT: If context is already over threshold, availableSpace will be negative
+    // Determine target size: use effectiveMaxResponseSize, but cap at compactionLimit for truncation
+    // IMPORTANT: If context is already very full, availableSpace might be very small
     // In that case, use a minimum reasonable target size (e.g., 10% of the output or 1000 tokens)
     const minTargetSize = Math.max(Math.floor(outputTokens * 0.1), 1000);
-    const targetSize = availableSpace > 0
-        ? Math.min(availableSpace, compactionLimit)
+    const targetSize = effectiveMaxResponseSize > 0
+        ? Math.min(effectiveMaxResponseSize, compactionLimit)
         : minTargetSize;
     logger.info("Calculated target size for compaction", {
         availableSpace,
+        effectiveMaxResponseSize,
         compactionLimit,
         minTargetSize,
         targetSize,
-        contextAlreadyOverThreshold: availableSpace <= 0,
+        contextAlreadyOverThreshold: availableSpace <= maxAllowedResponseSize,
     });
     // Case 2: Huge response, must truncate (too large for LLM compaction)
     if (outputTokens >= compactionLimit) {
@@ -89,7 +102,7 @@ export const toolResponseCompactor = async (ctx) => {
             // Try more aggressive truncation (70% of target as emergency measure)
             const emergencySize = Math.floor(targetSize * 0.7);
             const emergencyTruncated = truncateToolResponse(rawOutput, emergencySize);
-            let emergencyTokens = countToolResultTokens(emergencyTruncated);
+            const emergencyTokens = countToolResultTokens(emergencyTruncated);
             // Final safety check - if emergency truncation STILL exceeded target, use ultra-conservative fallback
             if (emergencyTokens > targetSize) {
                 logger.error("Emergency truncation STILL exceeded target - using ultra-conservative fallback", {
@@ -133,7 +146,7 @@ export const toolResponseCompactor = async (ctx) => {
                 originalTokens: outputTokens,
                 finalTokens,
                 modifiedOutput: truncated,
-                truncationWarning: `Tool response was truncated from ${outputTokens.toLocaleString()} to ${finalTokens.toLocaleString()} tokens to fit within context limit (available space: ${availableSpace.toLocaleString()} tokens)`,
+                truncationWarning: `Tool response was truncated from ${outputTokens.toLocaleString()} to ${finalTokens.toLocaleString()} tokens to fit within max response size limit (max allowed: ${effectiveMaxResponseSize.toLocaleString()} tokens)`,
             },
         };
     }
@@ -141,6 +154,7 @@ export const toolResponseCompactor = async (ctx) => {
     logger.info("Tool response requires intelligent compaction", {
         outputTokens,
         targetSize,
+        effectiveMaxResponseSize,
         availableSpace,
         compactionLimit,
     });
@@ -151,7 +165,7 @@ export const toolResponseCompactor = async (ctx) => {
             .map((msg) => {
             const text = msg.content
                 .filter((b) => b.type === "text")
-                .map((b) => b.text)
+                .map((b) => (b.type === "text" ? b.text : ""))
                 .join("\n");
             return `${msg.role}: ${text}`;
         })

package/dist/runner/hooks/types.d.ts

@@ -18,11 +18,11 @@ export interface ContextSizeSettings {
  */
 export interface ToolResponseSettings {
     /**
-     * Maximum % of main model context that tool response + current context can reach
-     * If adding the tool response would exceed this, compaction is triggered
-     * Default: 80
+     * Maximum size of a tool response in tokens.
+     * Tool responses larger than this will trigger compaction.
+     * Default: 20000
      */
-    maxContextThreshold?: number | undefined;
+    maxTokensSize?: number | undefined;
     /**
      * Maximum % of compaction model context (Haiku: 200k) that a tool response can be
      * to attempt LLM-based compaction. Larger responses are truncated instead.
@@ -141,7 +141,6 @@ export declare function createContextEntry(messages: Array<{
     toolInputTokens: number;
     toolResultsTokens: number;
     totalEstimated: number;
-    llmReportedInputTokens?: number | undefined;
 }): ContextEntry;
 /**
  * Helper function to create a full message entry for context

package/dist/runner/langchain/index.d.ts

@@ -13,5 +13,6 @@ export declare class LangchainAgent implements AgentRunner {
     constructor(params: CreateAgentRunnerParams);
     invoke(req: InvokeRequest): AsyncGenerator<ExtendedSessionUpdate, PromptResponse, undefined>;
     private invokeInternal;
+    private invokeWithContext;
 }
 export { makeSubagentsTool } from "./tools/subagent.js";