@townco/agent 0.1.84 → 0.1.85

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

@@ -2,6 +2,7 @@ import Anthropic from "@anthropic-ai/sdk";
 import { createLogger } from "../../../logger.js";
 import { telemetry } from "../../../telemetry/index.js";
 import { countToolResultTokens } from "../../../utils/token-counter.js";
+import { extractDocumentContext } from "./document-context-extractor/index.js";
 const logger = createLogger("tool-response-compactor");
 // Create Anthropic client directly (not using LangChain)
 // This ensures compaction LLM calls don't get captured by LangGraph's streaming
@@ -32,7 +33,6 @@ export const toolResponseCompactor = async (ctx) => {
     // Get settings from hook configuration
     const settings = ctx.session.requestParams.hookSettings;
     const maxTokensSize = settings?.maxTokensSize ?? 20000; // Default: 20000 tokens
-    const responseTruncationThreshold = settings?.responseTruncationThreshold ?? 30;
     // Use maxTokensSize directly as it's now in tokens
     const maxAllowedResponseSize = maxTokensSize;
     // Calculate available space in context
@@ -41,7 +41,9 @@ export const toolResponseCompactor = async (ctx) => {
     const effectiveMaxResponseSize = availableSpace < maxAllowedResponseSize
         ? Math.floor(availableSpace * 0.9)
         : maxAllowedResponseSize;
-    const compactionLimit = COMPACTION_MODEL_CONTEXT * (responseTruncationThreshold / 100);
+    // Calculate compaction limit: max response size that can fit in a single LLM compaction call
+    const COMPACTION_OVERHEAD = 10000;
+    const compactionLimit = Math.floor((COMPACTION_MODEL_CONTEXT - COMPACTION_OVERHEAD) * 0.9); // ~175K tokens
     logger.info("Tool response compaction hook triggered", {
         toolCallId,
         toolName,
@@ -66,14 +68,12 @@ export const toolResponseCompactor = async (ctx) => {
             },
         };
     }
-    // Response would exceed threshold, need to compact or truncate
-    // Determine target size: use effectiveMaxResponseSize, but cap at compactionLimit for truncation
+    // Response would exceed threshold, need to compact or extract
+    // Target size is the effectiveMaxResponseSize (what we want the final output to be)
     // 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 = effectiveMaxResponseSize > 0
-        ? Math.min(effectiveMaxResponseSize, compactionLimit)
-        : minTargetSize;
+    const targetSize = effectiveMaxResponseSize > 0 ? effectiveMaxResponseSize : minTargetSize;
     logger.info("Calculated target size for compaction", {
         availableSpace,
         effectiveMaxResponseSize,
@@ -82,73 +82,79 @@ export const toolResponseCompactor = async (ctx) => {
         targetSize,
         contextAlreadyOverThreshold: availableSpace <= maxAllowedResponseSize,
     });
-    // Case 2: Huge response, must truncate (too large for LLM compaction)
+    // Case 2: Huge response - use document context extractor (with truncation fallback)
     if (outputTokens >= compactionLimit) {
-        logger.warn("Tool response exceeds compaction capacity, truncating", {
+        logger.info("Tool response exceeds compaction capacity, using document context extractor", {
             outputTokens,
             compactionLimit,
             targetSize,
             availableSpace,
         });
-        const truncated = truncateToolResponse(rawOutput, targetSize);
-        const finalTokens = countToolResultTokens(truncated);
-        // Verify truncation stayed within boundaries
-        if (finalTokens > targetSize) {
-            logger.error("Truncation exceeded target size - this should not happen!", {
-                finalTokens,
-                targetSize,
-                excess: finalTokens - targetSize,
-            });
-            // Try more aggressive truncation (70% of target as emergency measure)
-            const emergencySize = Math.floor(targetSize * 0.7);
-            const emergencyTruncated = truncateToolResponse(rawOutput, emergencySize);
-            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", {
-                    emergencyTokens,
-                    targetSize,
-                    emergencySize,
+        // Build conversation context for extraction
+        const recentMessages = ctx.session.messages.slice(-5);
+        const conversationContext = recentMessages
+            .map((msg) => {
+            const text = msg.content
+                .filter((b) => b.type === "text")
+                .map((b) => (b.type === "text" ? b.text : ""))
+                .join("\n");
+            return `${msg.role}: ${text}`;
+        })
+            .join("\n\n");
+        // Try document context extraction
+        try {
+            const extractionResult = await extractDocumentContext(rawOutput, toolName, toolCallId, toolInput, conversationContext, targetSize, ctx.sessionId ?? "unknown", ctx.storage);
+            if (extractionResult.success && extractionResult.extractedData) {
+                logger.info("Document context extraction succeeded", {
+                    originalTokens: outputTokens,
+                    finalTokens: extractionResult.extractedTokens,
+                    chunksProcessed: extractionResult.metadata.chunksProcessed,
+                    chunksExtractedFrom: extractionResult.metadata.chunksExtractedFrom,
                 });
-                // Ultra-conservative: just return a simple error structure with the raw data sliced to 50% of target
-                const ultraConservativeSize = Math.floor(targetSize * 0.5);
                 return {
                     newContextEntry: null,
                     metadata: {
-                        action: "truncated",
+                        action: "compacted",
                         originalTokens: outputTokens,
-                        finalTokens: ultraConservativeSize, // Conservative estimate
-                        modifiedOutput: {
-                            _truncation_error: "Tool response was too large and could not be reliably truncated",
-                            _original_token_count: outputTokens,
-                            _target_token_count: targetSize,
-                            _partial_data: JSON.stringify(rawOutput).slice(0, ultraConservativeSize * 3),
-                        },
-                        truncationWarning: `Tool response was severely truncated from ${outputTokens.toLocaleString()} to ~${ultraConservativeSize.toLocaleString()} tokens (emergency truncation failed - data may be incomplete)`,
+                        finalTokens: extractionResult.extractedTokens,
+                        tokensSaved: outputTokens - (extractionResult.extractedTokens ?? 0),
+                        modifiedOutput: extractionResult.extractedData,
+                        compactionMethod: "document_context_extraction",
+                        extractionMetadata: extractionResult.metadata,
                     },
                 };
             }
-            return {
-                newContextEntry: null,
-                metadata: {
-                    action: "truncated",
-                    originalTokens: outputTokens,
-                    finalTokens: emergencyTokens,
-                    modifiedOutput: emergencyTruncated,
-                    truncationWarning: `Tool response was aggressively truncated from ${outputTokens.toLocaleString()} to ${emergencyTokens.toLocaleString()} tokens to fit within context limit (emergency truncation)`,
-                },
-            };
+            // Extraction failed - throw error to terminate agent loop
+            logger.error("Document context extraction failed", {
+                error: extractionResult.error,
+                phase: extractionResult.metadata.phase,
+                toolName,
+                toolCallId,
+                outputTokens,
+            });
+            throw new Error(`Document context extraction failed for tool "${toolName}": ${extractionResult.error}. ` +
+                `Original response was ${outputTokens.toLocaleString()} tokens. ` +
+                `Full response saved to artifacts.`);
+        }
+        catch (extractionError) {
+            // Re-throw if it's already our error
+            if (extractionError instanceof Error &&
+                extractionError.message.includes("Document context extraction failed")) {
+                throw extractionError;
+            }
+            // Extraction threw an unexpected error - terminate agent loop
+            logger.error("Document context extraction threw an error", {
+                error: extractionError instanceof Error
+                    ? extractionError.message
+                    : String(extractionError),
+                toolName,
+                toolCallId,
+                outputTokens,
+            });
+            throw new Error(`Document context extraction failed for tool "${toolName}": ${extractionError instanceof Error
+                ? extractionError.message
+                : String(extractionError)}. Original response was ${outputTokens.toLocaleString()} tokens.`);
         }
-        return {
-            newContextEntry: null,
-            metadata: {
-                action: "truncated",
-                originalTokens: outputTokens,
-                finalTokens,
-                modifiedOutput: truncated,
-                truncationWarning: `Tool response was truncated from ${outputTokens.toLocaleString()} to ${finalTokens.toLocaleString()} tokens to fit within max response size limit (max allowed: ${effectiveMaxResponseSize.toLocaleString()} tokens)`,
-            },
-        };
     }
     // Case 1: Medium response, intelligent compaction
     logger.info("Tool response requires intelligent compaction", {
@@ -171,28 +177,19 @@ export const toolResponseCompactor = async (ctx) => {
         })
             .join("\n\n");
         const compacted = await compactWithLLM(rawOutput, toolName, toolInput, conversationContext, targetSize);
-        let finalTokens = countToolResultTokens(compacted);
+        const finalTokens = countToolResultTokens(compacted);
         // Verify compaction stayed within boundaries
         if (finalTokens > targetSize) {
-            logger.warn("LLM compaction exceeded target, falling back to truncation", {
+            logger.error("LLM compaction exceeded target", {
                 finalTokens,
                 targetSize,
                 excess: finalTokens - targetSize,
+                toolName,
+                toolCallId,
             });
-            // Fallback to truncation
-            const truncated = truncateToolResponse(compacted, targetSize);
-            finalTokens = countToolResultTokens(truncated);
-            return {
-                newContextEntry: null,
-                metadata: {
-                    action: "compacted_then_truncated",
-                    originalTokens: outputTokens,
-                    finalTokens,
-                    tokensSaved: outputTokens - finalTokens,
-                    modifiedOutput: truncated,
-                    truncationWarning: `Tool response was compacted then truncated from ${outputTokens.toLocaleString()} to ${finalTokens.toLocaleString()} tokens to fit within context limit`,
-                },
-            };
+            throw new Error(`LLM compaction for tool "${toolName}" exceeded target size. ` +
+                `Compacted to ${finalTokens.toLocaleString()} tokens but target was ${targetSize.toLocaleString()}. ` +
+                `Original response was ${outputTokens.toLocaleString()} tokens.`);
         }
         logger.info("Successfully compacted tool response", {
             originalTokens: outputTokens,
@@ -212,62 +209,13 @@ export const toolResponseCompactor = async (ctx) => {
         };
     }
     catch (error) {
-        logger.error("Compaction failed, falling back to truncation", {
+        logger.error("Compaction failed", {
             error: error instanceof Error ? error.message : String(error),
+            toolName,
+            toolCallId,
+            outputTokens,
         });
-        // Fallback to truncation with the same target size
-        const truncated = truncateToolResponse(rawOutput, targetSize);
-        let finalTokens = countToolResultTokens(truncated);
-        // Verify truncation stayed within boundaries
-        if (finalTokens > targetSize) {
-            logger.error("Fallback truncation exceeded target, using emergency truncation", {
-                finalTokens,
-                targetSize,
-            });
-            const emergencySize = Math.floor(targetSize * 0.7);
-            const emergencyTruncated = truncateToolResponse(rawOutput, emergencySize);
-            finalTokens = countToolResultTokens(emergencyTruncated);
-            // Final safety check
-            if (finalTokens > targetSize) {
-                logger.error("Emergency truncation STILL exceeded target - using ultra-conservative fallback");
-                const ultraConservativeSize = Math.floor(targetSize * 0.5);
-                return {
-                    newContextEntry: null,
-                    metadata: {
-                        action: "truncated",
-                        originalTokens: outputTokens,
-                        finalTokens: ultraConservativeSize,
-                        modifiedOutput: {
-                            _truncation_error: "Tool response was too large and could not be reliably truncated (compaction failed)",
-                            _original_token_count: outputTokens,
-                            _target_token_count: targetSize,
-                            _partial_data: JSON.stringify(rawOutput).slice(0, ultraConservativeSize * 3),
-                        },
-                        truncationWarning: `Tool response was severely truncated from ${outputTokens.toLocaleString()} to ~${ultraConservativeSize.toLocaleString()} tokens (compaction+emergency truncation failed)`,
-                    },
-                };
-            }
-            return {
-                newContextEntry: null,
-                metadata: {
-                    action: "truncated",
-                    originalTokens: outputTokens,
-                    finalTokens,
-                    modifiedOutput: emergencyTruncated,
-                    truncationWarning: `Tool response was truncated from ${outputTokens.toLocaleString()} to ${finalTokens.toLocaleString()} tokens (compaction failed, emergency truncation applied)`,
-                },
-            };
-        }
-        return {
-            newContextEntry: null,
-            metadata: {
-                action: "truncated",
-                originalTokens: outputTokens,
-                finalTokens,
-                modifiedOutput: truncated,
-                truncationWarning: `Tool response was truncated from ${outputTokens.toLocaleString()} to ${finalTokens.toLocaleString()} tokens (compaction failed)`,
-            },
-        };
+        throw new Error(`LLM compaction failed for tool "${toolName}": ${error instanceof Error ? error.message : String(error)}. Original response was ${outputTokens.toLocaleString()} tokens.`);
     }
 };
 /**
@@ -456,86 +404,3 @@ Return ONLY valid JSON (no explanation text).`;
     });
     return currentData;
 }
-/**
- * Truncate tool response to target token count
- * Uses iterative approach to ensure we stay under the target
- */
-function truncateToolResponse(rawOutput, targetTokens) {
-    const currentTokens = countToolResultTokens(rawOutput);
-    if (currentTokens <= targetTokens) {
-        return rawOutput; // Already within limit
-    }
-    const outputString = JSON.stringify(rawOutput);
-    // Start with 70% of target to leave significant room for closing braces and metadata
-    let ratio = 0.7;
-    let lastResult = null;
-    // Iteratively truncate until we meet the target
-    for (let attempt = 0; attempt < 15; attempt++) {
-        // Calculate character limit based on ratio
-        const targetChars = Math.floor((targetTokens * ratio * outputString.length) / currentTokens);
-        // Truncate the JSON string
-        let truncated = outputString.slice(0, targetChars);
-        // Try to close any open JSON structures
-        const openBraces = (truncated.match(/{/g) || []).length;
-        const closeBraces = (truncated.match(/}/g) || []).length;
-        const openBrackets = (truncated.match(/\[/g) || []).length;
-        const closeBrackets = (truncated.match(/\]/g) || []).length;
-        truncated += "}".repeat(Math.max(0, openBraces - closeBraces));
-        truncated += "]".repeat(Math.max(0, openBrackets - closeBrackets));
-        try {
-            // Try to parse as valid JSON
-            const parsed = JSON.parse(truncated);
-            const parsedTokens = countToolResultTokens(parsed);
-            // Store the result
-            lastResult = { parsed, tokens: parsedTokens };
-            if (parsedTokens <= targetTokens) {
-                // Success! Add truncation notice
-                return {
-                    ...parsed,
-                    _truncation_notice: "... [TRUNCATED - response exceeded size limit]",
-                    _original_token_count: currentTokens,
-                    _truncated_token_count: parsedTokens,
-                };
-            }
-            // Still too large - calculate how much we need to reduce
-            // If we overshot, reduce ratio proportionally to how much we exceeded
-            const overshootRatio = parsedTokens / targetTokens; // e.g., 1.03 if we're 3% over
-            ratio = (ratio / overshootRatio) * 0.95; // Reduce by overshoot amount plus 5% safety margin
-            logger.debug("Truncation attempt resulted in overshoot, retrying", {
-                attempt,
-                targetTokens,
-                parsedTokens,
-                overshootRatio,
-                newRatio: ratio,
-            });
-        }
-        catch {
-            // JSON parse failed, try more aggressive truncation
-            ratio *= 0.85;
-        }
-    }
-    // If we exhausted all attempts, return the last successful parse (if any)
-    // or a very conservative fallback
-    if (lastResult && lastResult.tokens <= targetTokens * 1.1) {
-        // Within 10% of target - good enough
-        logger.warn("Truncation reached attempt limit but result is close enough", {
-            targetTokens,
-            actualTokens: lastResult.tokens,
-        });
-        return {
-            ...lastResult.parsed,
-            _truncation_notice: "... [TRUNCATED - response exceeded size limit]",
-            _original_token_count: currentTokens,
-            _truncated_token_count: lastResult.tokens,
-        };
-    }
-    // If all attempts failed, return a simple truncated structure
-    const safeChars = Math.floor(targetTokens * 3); // Very conservative
-    return {
-        truncated: true,
-        originalSize: currentTokens,
-        targetSize: targetTokens,
-        content: outputString.slice(0, safeChars),
-        warning: "Response was truncated due to size constraints (JSON parsing failed)",
-    };
-}

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

@@ -1,5 +1,11 @@
 import type { ContextEntry } from "../../acp-server/session-storage";
 import type { SessionMessage } from "../agent-runner";
+/**
+ * Storage interface for hooks that need to persist data
+ */
+export interface HookStorageInterface {
+    getArtifactsDir(sessionId: string): string;
+}
 /**
  * Hook types supported by the agent system
  */
@@ -19,17 +25,10 @@ export interface ContextSizeSettings {
 export interface ToolResponseSettings {
     /**
      * Maximum size of a tool response in tokens.
-     * Tool responses larger than this will trigger compaction.
+     * Tool responses larger than this will trigger compaction/extraction.
      * Default: 20000
      */
     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.
-     * The truncation limit is also this percentage.
-     * Default: 30
-     */
-    responseTruncationThreshold?: number | undefined;
 }
 /**
  * Hook configuration in agent definition
@@ -90,6 +89,14 @@ export interface HookContext {
      * The model being used
      */
     model: string;
+    /**
+     * Session ID for the current session
+     */
+    sessionId?: string | undefined;
+    /**
+     * Storage interface for hooks that need to persist data
+     */
+    storage?: HookStorageInterface | undefined;
     /**
      * Tool response data (only for tool_response hooks)
      */

package/dist/runner/langchain/index.js

@@ -14,6 +14,7 @@ import { createModelFromString, detectProvider } from "./model-factory.js";
 import { makeOtelCallbacks } from "./otel-callbacks.js";
 import { makeArtifactsTools } from "./tools/artifacts";
 import { makeBrowserTools } from "./tools/browser";
+import { makeDocumentExtractTool } from "./tools/document_extract";
 import { makeFilesystemTools } from "./tools/filesystem";
 import { makeGenerateImageTool, makeTownGenerateImageTool, } from "./tools/generate_image";
 import { SUBAGENT_TOOL_NAME } from "./tools/subagent";
@@ -42,6 +43,7 @@ export const TOOL_REGISTRY = {
     generate_image: () => makeGenerateImageTool(),
     town_generate_image: () => makeTownGenerateImageTool(),
     browser: () => makeBrowserTools(),
+    document_extract: () => makeDocumentExtractTool(),
 };
 // ============================================================================
 // Custom tool loading

package/dist/runner/langchain/tools/document_extract.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Document extraction tool for extracting relevant information from large files
+ *
+ * Uses the document context extractor to intelligently extract relevant
+ * information from large documents based on a query/requirements description.
+ */
+import { z } from "zod";
+/**
+ * Factory function to create the document extract tool
+ */
+export declare function makeDocumentExtractTool(): import("langchain").DynamicStructuredTool<z.ZodObject<{
+    session_id: z.ZodOptional<z.ZodString>;
+    file_path: z.ZodString;
+    query: z.ZodString;
+    target_tokens: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>, {
+    session_id: string;
+    file_path: string;
+    query: string;
+    target_tokens?: number;
+}, {
+    file_path: string;
+    query: string;
+    session_id?: string | undefined;
+    target_tokens?: number | undefined;
+}, string>;

package/dist/runner/langchain/tools/document_extract.js

@@ -0,0 +1,135 @@
+/**
+ * Document extraction tool for extracting relevant information from large files
+ *
+ * Uses the document context extractor to intelligently extract relevant
+ * information from large documents based on a query/requirements description.
+ */
+import * as fs from "node:fs/promises";
+import { tool } from "langchain";
+import { z } from "zod";
+import { createLogger } from "../../../logger.js";
+import { countTokens } from "../../../utils/token-counter.js";
+import { extractDocumentContext } from "../../hooks/predefined/document-context-extractor/index.js";
+const logger = createLogger("document-extract-tool");
+// Minimum document size (in tokens) to use extraction
+// Smaller documents are returned as-is
+const MIN_EXTRACTION_THRESHOLD = 10000;
+// Default target size for extraction output
+const DEFAULT_TARGET_TOKENS = 20000;
+/**
+ * Document extraction tool
+ *
+ * Reads a file and extracts relevant information based on the provided query.
+ * For large documents, uses intelligent chunking and relevance scoring.
+ * Small documents are returned as-is.
+ */
+const documentExtract = tool(async ({ session_id, file_path, query, target_tokens, }) => {
+    try {
+        // Read the file content
+        const content = await fs.readFile(file_path, "utf-8");
+        // Try to parse as JSON, otherwise treat as plain text
+        let parsedContent;
+        try {
+            parsedContent = JSON.parse(content);
+        }
+        catch {
+            // Not JSON, wrap as text object
+            parsedContent = { content };
+        }
+        // Count tokens in the document
+        const documentTokens = countTokens(content);
+        logger.info("Document extraction requested", {
+            filePath: file_path,
+            documentTokens,
+            query: query.substring(0, 100),
+            sessionId: session_id,
+        });
+        // If document is small enough, return as-is
+        if (documentTokens <= MIN_EXTRACTION_THRESHOLD) {
+            logger.info("Document below extraction threshold, returning as-is", {
+                documentTokens,
+                threshold: MIN_EXTRACTION_THRESHOLD,
+            });
+            return content;
+        }
+        // Use document context extractor for large documents
+        const targetSize = target_tokens ?? DEFAULT_TARGET_TOKENS;
+        const result = await extractDocumentContext(parsedContent, "document_extract", // toolName
+        `extract-${Date.now()}`, // toolCallId
+        { file_path, query }, // toolInput
+        query, // conversationContext (use query as context)
+        targetSize, session_id, undefined);
+        if (result.success && result.extractedData) {
+            logger.info("Document extraction successful", {
+                originalTokens: result.metadata.originalTokens,
+                extractedTokens: result.extractedTokens,
+                chunksProcessed: result.metadata.chunksProcessed,
+                chunksExtractedFrom: result.metadata.chunksExtractedFrom,
+            });
+            // Return extracted content as formatted string
+            return JSON.stringify(result.extractedData, null, 2);
+        }
+        // Extraction failed
+        logger.error("Document extraction failed", {
+            error: result.error,
+            phase: result.metadata.phase,
+        });
+        return `Error: Failed to extract from document: ${result.error}`;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logger.error("Document extract tool error", {
+            filePath: file_path,
+            error: errorMessage,
+        });
+        // Check for common errors
+        if (errorMessage.includes("ENOENT") ||
+            errorMessage.includes("no such file")) {
+            return `Error: File not found at path: ${file_path}`;
+        }
+        if (errorMessage.includes("EACCES")) {
+            return `Error: Permission denied reading file: ${file_path}`;
+        }
+        return `Error: ${errorMessage}`;
+    }
+}, {
+    name: "document_extract",
+    description: "Extract relevant information from a large document file based on a query. " +
+        "Use this tool when you need to find specific information in a large file " +
+        "(e.g., JSON data, logs, API responses) that would be too large to process directly. " +
+        "The tool intelligently identifies and extracts the most relevant portions of the document. " +
+        "For small files (under 10,000 tokens), returns the full content.",
+    schema: z.object({
+        session_id: z
+            .string()
+            .optional()
+            .describe("INTERNAL USE ONLY - Auto-injected by system"),
+        file_path: z
+            .string()
+            .describe("Absolute path to the file to extract from (e.g., '/tmp/data.json')"),
+        query: z
+            .string()
+            .describe("Description of what information to extract from the document. " +
+            "Be specific about what you're looking for."),
+        target_tokens: z
+            .number()
+            .optional()
+            .describe("Target size for extracted output in tokens (default: 20000). " +
+            "Use smaller values if you need a more concise summary."),
+    }),
+});
+// Add metadata for UI display
+documentExtract.prettyName =
+    "Extract from Document";
+documentExtract.icon = "FileSearch";
+documentExtract.verbiage = {
+    active: "Extracting relevant information from {file_path}",
+    past: "Extracted relevant information from {file_path}",
+    paramKey: "file_path",
+};
+/**
+ * Factory function to create the document extract tool
+ */
+export function makeDocumentExtractTool() {
+    return documentExtract;
+}

package/dist/runner/tools.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 /** Built-in tool types. */
-export declare const zBuiltInToolType: 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">]>;
+export declare const zBuiltInToolType: 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.ZodLiteral<"document_extract">]>;
 /** Subagent configuration schema for Task tools. */
 export declare const zSubagentConfig: z.ZodObject<{
     agentName: z.ZodString;
@@ -23,7 +23,7 @@ declare const zDirectTool: z.ZodObject<{
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 /** Tool type - can be a built-in tool string or custom tool object. */
-export declare const zToolType: 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<{
+export declare const zToolType: 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.ZodLiteral<"document_extract">]>, z.ZodObject<{
     type: z.ZodLiteral<"custom">;
     modulePath: z.ZodString;
 }, z.core.$strip>, z.ZodObject<{

package/dist/runner/tools.js

@@ -10,6 +10,7 @@ export const zBuiltInToolType = z.union([
     z.literal("generate_image"),
     z.literal("town_generate_image"),
     z.literal("browser"),
+    z.literal("document_extract"),
 ]);
 /** Custom tool schema (loaded from module path). */
 const zCustomTool = z.object({

package/dist/templates/index.d.ts

@@ -32,7 +32,6 @@ export interface TemplateVars {
         type: "tool_response";
         setting?: {
             maxTokensSize?: number | undefined;
-            responseTruncationThreshold?: number | undefined;
         } | undefined;
         callback: string;
     }> | undefined;