@townco/agent 0.1.83 → 0.1.85

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

@@ -177,9 +177,6 @@ async function deleteFromSupabase(storageKey) {
         throw new Error(`Failed to delete from Supabase Storage: ${error.message}`);
     }
 }
-/**
- * List files in Supabase Storage with optional prefix and recursion
- */
 async function listFilesInSupabase(sessionId, relativePath, recursive = false) {
     const supabase = getSupabaseClient();
     const bucket = getBucketName();
@@ -426,9 +423,6 @@ const artifactsUrl = tool(async ({ session_id, path, expires_in = 3600, }) => {
             .describe("Expiration time in seconds (1-31536000). Default: 3600 (1 hour)"),
     }),
 });
-// ============================================================================
-// Tool Metadata
-// ============================================================================
 // Add metadata for UI display
 artifactsCp.prettyName = "Copy Artifact";
 artifactsCp.icon = "Upload";
@@ -437,20 +431,23 @@ artifactsCp.verbiage = {
     past: "Copied artifact to {destination}",
     paramKey: "destination",
 };
-artifactsDel.prettyName = "Delete Artifact";
+artifactsDel.prettyName =
+    "Delete Artifact";
 artifactsDel.icon = "Trash";
 artifactsDel.verbiage = {
     active: "Deleting artifact {path}",
     past: "Deleted artifact {path}",
     paramKey: "path",
 };
-artifactsLs.prettyName = "List Artifacts";
+artifactsLs.prettyName =
+    "List Artifacts";
 artifactsLs.icon = "List";
 artifactsLs.verbiage = {
     active: "Listing artifacts",
     past: "Listed artifacts",
 };
-artifactsUrl.prettyName = "Generate Artifact URL";
+artifactsUrl.prettyName =
+    "Generate Artifact URL";
 artifactsUrl.icon = "Link";
 artifactsUrl.verbiage = {
     active: "Generating URL for {path}",

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

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