@townco/agent 0.1.84 → 0.1.87

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

@@ -11,19 +11,11 @@
  */
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { createSecretKeyClient } from "@townco/supabase/server";
+import { createClient } from "@townco/apiclient";
+import { getShedAuth } from "@townco/core/auth";
 import { tool } from "langchain";
 import { z } from "zod";
 // ============================================================================
-// Supabase Client and Bucket Configuration
-// ============================================================================
-function getSupabaseClient() {
-    return createSecretKeyClient();
-}
-function getBucketName() {
-    return "town-builder-artifacts";
-}
-// ============================================================================
 // Storage Key Prefix Logic
 // ============================================================================
 /**
@@ -99,21 +91,26 @@ function validateStoragePath(path) {
         throw new Error("Storage path cannot be empty");
     }
 }
-function validateExpiration(expiresIn) {
-    // Supabase supports up to 365 days (31536000 seconds)
-    if (expiresIn < 1 || expiresIn > 31536000) {
-        throw new Error(`URL expiration must be between 1 and 31536000 seconds (365 days). Got: ${expiresIn}`);
-    }
-}
 // ============================================================================
 // Supabase Storage Operation Helpers
 // ============================================================================
 /**
- * Upload a file to Supabase Storage
+ * Upload a file to Supabase Storage using signed URL
  */
 async function uploadToSupabase(storageKey, localPath) {
-    const supabase = getSupabaseClient();
-    const bucket = getBucketName();
+    const auth = getShedAuth();
+    if (auth === null)
+        throw new Error(`agent/artifacts: could not fetch shed auth`);
+    const { shedUrl, accessToken } = auth;
+    // Get signed upload URL from server
+    const signedUrl = await createClient({
+        shedUrl,
+        accessToken,
+    }).getArtifactUrl.query({
+        kind: "user",
+        key: storageKey,
+        upload: true,
+    });
     // Read file content
     const fileContent = await fs.readFile(localPath);
     // Determine content type based on file extension
@@ -133,91 +130,92 @@ async function uploadToSupabase(storageKey, localPath) {
         ".zip": "application/zip",
     };
     const contentType = contentTypeMap[ext] || "application/octet-stream";
-    const { error } = await supabase.storage
-        .from(bucket)
-        .upload(storageKey, fileContent, {
-        contentType,
-        upsert: true, // Allow overwriting
+    // Upload using signed URL
+    const response = await fetch(signedUrl, {
+        method: "PUT",
+        body: fileContent,
+        headers: {
+            "Content-Type": contentType,
+        },
     });
-    if (error) {
-        throw new Error(`Failed to upload to Supabase Storage: ${error.message}`);
+    if (!response.ok) {
+        throw new Error(`Failed to upload to Supabase Storage: ${response.status} ${response.statusText}`);
     }
 }
 /**
- * Download a file from Supabase Storage
+ * Download a file from Supabase Storage using signed URL
  */
 async function downloadFromSupabase(storageKey, localPath) {
-    const supabase = getSupabaseClient();
-    const bucket = getBucketName();
-    const { data, error } = await supabase.storage
-        .from(bucket)
-        .download(storageKey);
-    if (error) {
-        throw new Error(`Failed to download from Supabase Storage: ${error.message}`);
+    const auth = getShedAuth();
+    if (auth === null)
+        throw new Error(`agent/artifacts: could not fetch shed auth`);
+    const { shedUrl, accessToken } = auth;
+    // Get signed download URL from server
+    const signedUrl = await createClient({
+        shedUrl,
+        accessToken,
+    }).getArtifactUrl.query({
+        kind: "user",
+        key: storageKey,
+        upload: false,
+    });
+    // Download file using signed URL
+    const response = await fetch(signedUrl);
+    if (!response.ok) {
+        throw new Error(`Failed to download from Supabase Storage: ${response.status} ${response.statusText}`);
     }
+    const data = await response.arrayBuffer();
     if (!data) {
         throw new Error("Supabase Storage response body is empty");
     }
     // Ensure parent directory exists
     const dir = path.dirname(localPath);
     await fs.mkdir(dir, { recursive: true });
-    // Convert Blob to Buffer and write
-    const arrayBuffer = await data.arrayBuffer();
-    const buffer = Buffer.from(arrayBuffer);
+    // Convert ArrayBuffer to Buffer and write
+    const buffer = Buffer.from(data);
     await fs.writeFile(localPath, buffer);
 }
 /**
  * Delete a file from Supabase Storage
  */
 async function deleteFromSupabase(storageKey) {
-    const supabase = getSupabaseClient();
-    const bucket = getBucketName();
-    const { error } = await supabase.storage.from(bucket).remove([storageKey]);
-    if (error) {
-        throw new Error(`Failed to delete from Supabase Storage: ${error.message}`);
-    }
+    const auth = getShedAuth();
+    if (auth === null)
+        throw new Error(`agent/artifacts: could not fetch shed auth`);
+    const { shedUrl, accessToken } = auth;
+    // Call the delete API endpoint
+    await createClient({ shedUrl, accessToken }).deleteArtifact.mutate({
+        kind: "user",
+        key: storageKey,
+    });
 }
+/**
+ * List files in Supabase Storage with optional prefix and recursion
+ */
 async function listFilesInSupabase(sessionId, relativePath, recursive = false) {
-    const supabase = getSupabaseClient();
-    const bucket = getBucketName();
-    // Build the prefix for listing
-    const basePath = relativePath
-        ? buildStorageKey(sessionId, relativePath)
-        : buildStorageKey(sessionId, "");
-    // For Supabase, we list at the base path
-    // If recursive, we'll need to handle it differently
-    const options = recursive
-        ? undefined
-        : {
-            limit: 100,
-            offset: 0,
-            sortBy: { column: "name", order: "asc" },
-        };
-    const { data, error } = await supabase.storage
-        .from(bucket)
-        .list(basePath, options);
-    if (error) {
-        throw new Error(`Failed to list files in Supabase Storage: ${error.message}`);
-    }
-    return data || [];
+    const auth = getShedAuth();
+    if (auth === null)
+        throw new Error(`agent/artifacts: could not fetch shed auth`);
+    const { shedUrl, accessToken } = auth;
+    return await createClient({ shedUrl, accessToken }).listArtifacts.query({
+        kind: "user",
+        key: buildStorageKey(sessionId, relativePath ?? ""),
+        recursive,
+    });
 }
 /**
  * Generate a signed URL for a Supabase Storage object
  */
-async function generateSignedUrl(storageKey, expiresIn) {
-    const supabase = getSupabaseClient();
-    const bucket = getBucketName();
-    const { data, error } = await supabase.storage
-        .from(bucket)
-        .createSignedUrl(storageKey, expiresIn);
-    if (error) {
-        throw new Error(`Failed to generate signed URL: ${error.message}`);
-    }
-    if (!data?.signedUrl) {
-        throw new Error("Signed URL not returned from Supabase Storage");
-    }
-    return data.signedUrl;
-}
+const generateSignedUrl = async (storageKey) => {
+    const shedAuth = getShedAuth();
+    if (shedAuth === null)
+        throw new Error("agent/artifacts: could not fetch shed auth");
+    const { accessToken, shedUrl } = shedAuth;
+    return await createClient({ shedUrl, accessToken }).getArtifactUrl.query({
+        kind: "user",
+        key: storageKey,
+    });
+};
 // ============================================================================
 // Error Handling Helpers
 // ============================================================================
@@ -391,17 +389,12 @@ const artifactsLs = tool(async ({ session_id, path, recursive = false, }) => {
 /**
  * Tool 4: artifacts_url - Generate signed URL
  */
-const artifactsUrl = tool(async ({ session_id, path, expires_in = 3600, }) => {
+const artifactsUrl = tool(async ({ session_id, path, }) => {
     try {
         validateStoragePath(path);
-        validateExpiration(expires_in);
         const storageKey = buildStorageKey(session_id, path);
-        const url = await generateSignedUrl(storageKey, expires_in);
-        const expiryHours = expires_in / 3600;
-        const expiryStr = expiryHours >= 1
-            ? `${expiryHours.toFixed(1)} hour(s)`
-            : `${expires_in} second(s)`;
-        return `Signed URL for ${path} (expires in ${expiryStr}):\n${url}`;
+        const _url = await generateSignedUrl(storageKey);
+        return `Signed URL for ${path}`;
     }
     catch (error) {
         return handleStorageError(error, `Failed to generate URL for ${path}`);
@@ -423,32 +416,44 @@ 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
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic metadata assignment to tool objects
 artifactsCp.prettyName = "Copy Artifact";
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic metadata assignment to tool objects
 artifactsCp.icon = "Upload";
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic metadata assignment to tool objects
 artifactsCp.verbiage = {
     active: "Copying artifact to {destination}",
     past: "Copied artifact to {destination}",
     paramKey: "destination",
 };
-artifactsDel.prettyName =
-    "Delete Artifact";
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic metadata assignment to tool objects
+artifactsDel.prettyName = "Delete Artifact";
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic metadata assignment to tool objects
 artifactsDel.icon = "Trash";
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic metadata assignment to tool objects
 artifactsDel.verbiage = {
     active: "Deleting artifact {path}",
     past: "Deleted artifact {path}",
     paramKey: "path",
 };
-artifactsLs.prettyName =
-    "List Artifacts";
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic metadata assignment to tool objects
+artifactsLs.prettyName = "List Artifacts";
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic metadata assignment to tool objects
 artifactsLs.icon = "List";
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic metadata assignment to tool objects
 artifactsLs.verbiage = {
     active: "Listing artifacts",
     past: "Listed artifacts",
 };
-artifactsUrl.prettyName =
-    "Generate Artifact URL";
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic metadata assignment to tool objects
+artifactsUrl.prettyName = "Generate Artifact URL";
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic metadata assignment to tool objects
 artifactsUrl.icon = "Link";
+// biome-ignore lint/suspicious/noExplicitAny: Dynamic metadata assignment to tool objects
 artifactsUrl.verbiage = {
     active: "Generating URL for {path}",
     past: "Generated URL for {path}",

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

@@ -40,16 +40,16 @@ interface BrowserCloseResult {
 export declare function makeBrowserTools(): readonly [import("langchain").DynamicStructuredTool<z.ZodObject<{
     url: z.ZodString;
     waitUntil: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        load: "load";
         domcontentloaded: "domcontentloaded";
+        load: "load";
         networkidle: "networkidle";
     }>>>;
 }, z.core.$strip>, {
     url: string;
-    waitUntil: "load" | "domcontentloaded" | "networkidle";
+    waitUntil: "domcontentloaded" | "load" | "networkidle";
 }, {
     url: string;
-    waitUntil?: "load" | "domcontentloaded" | "networkidle" | undefined;
+    waitUntil?: "domcontentloaded" | "load" | "networkidle" | undefined;
 }, BrowserNavigateResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{
     fullPage: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     selector: z.ZodOptional<z.ZodString>;
@@ -62,28 +62,28 @@ export declare function makeBrowserTools(): readonly [import("langchain").Dynami
 }, BrowserScreenshotResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{
     selector: z.ZodOptional<z.ZodString>;
     extractType: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        text: "text";
         html: "html";
+        text: "text";
     }>>>;
 }, z.core.$strip>, {
-    extractType: "text" | "html";
     selector?: string | undefined;
+    extractType: "html" | "text";
 }, {
     selector?: string | undefined;
-    extractType?: "text" | "html" | undefined;
+    extractType?: "html" | "text" | undefined;
 }, BrowserExtractResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{
     selector: z.ZodString;
     button: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         left: "left";
-        right: "right";
         middle: "middle";
+        right: "right";
     }>>>;
 }, z.core.$strip>, {
     selector: string;
-    button: "left" | "right" | "middle";
+    button: "left" | "middle" | "right";
 }, {
     selector: string;
-    button?: "left" | "right" | "middle" | undefined;
+    button?: "left" | "middle" | "right" | undefined;
 }, BrowserClickResult>, import("langchain").DynamicStructuredTool<z.ZodObject<{
     selector: z.ZodString;
     text: z.ZodString;

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;
+}, {
+    session_id?: string | undefined;
+    file_path: string;
+    query: string;
+    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/langchain/tools/filesystem.d.ts

@@ -9,8 +9,8 @@ export declare function makeFilesystemTools(): readonly [import("langchain").Dyn
     glob: z.ZodOptional<z.ZodString>;
     output_mode: z.ZodOptional<z.ZodEnum<{
         content: "content";
-        files_with_matches: "files_with_matches";
         count: "count";
+        files_with_matches: "files_with_matches";
     }>>;
     "-B": z.ZodOptional<z.ZodNumber>;
     "-A": z.ZodOptional<z.ZodNumber>;
@@ -24,7 +24,7 @@ export declare function makeFilesystemTools(): readonly [import("langchain").Dyn
     pattern: string;
     path?: string | undefined;
     glob?: string | undefined;
-    output_mode?: "content" | "files_with_matches" | "count" | undefined;
+    output_mode?: "content" | "count" | "files_with_matches" | undefined;
     "-B"?: number | undefined;
     "-A"?: number | undefined;
     "-C"?: number | undefined;
@@ -37,7 +37,7 @@ export declare function makeFilesystemTools(): readonly [import("langchain").Dyn
     pattern: string;
     path?: string | undefined;
     glob?: string | undefined;
-    output_mode?: "content" | "files_with_matches" | "count" | undefined;
+    output_mode?: "content" | "count" | "files_with_matches" | undefined;
     "-B"?: number | undefined;
     "-A"?: number | undefined;
     "-C"?: number | undefined;

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

@@ -12,36 +12,36 @@ interface GenerateImageResult {
 export declare function makeGenerateImageTool(): import("langchain").DynamicStructuredTool<z.ZodObject<{
     prompt: z.ZodString;
     aspectRatio: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        "16:9": "16:9";
         "1:1": "1:1";
         "3:4": "3:4";
         "4:3": "4:3";
-        "9:16": "9:16";
-        "16:9": "16:9";
         "5:4": "5:4";
+        "9:16": "9:16";
     }>>>;
 }, z.core.$strip>, {
     prompt: string;
-    aspectRatio: "1:1" | "3:4" | "4:3" | "9:16" | "16:9" | "5:4";
+    aspectRatio: "16:9" | "1:1" | "3:4" | "4:3" | "5:4" | "9:16";
 }, {
     prompt: string;
-    aspectRatio?: "1:1" | "3:4" | "4:3" | "9:16" | "16:9" | "5:4" | undefined;
+    aspectRatio?: "16:9" | "1:1" | "3:4" | "4:3" | "5:4" | "9:16" | undefined;
 }, GenerateImageResult>;
 /** Create generate image tool using Town proxy */
 export declare function makeTownGenerateImageTool(): import("langchain").DynamicStructuredTool<z.ZodObject<{
     prompt: z.ZodString;
     aspectRatio: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        "16:9": "16:9";
         "1:1": "1:1";
         "3:4": "3:4";
         "4:3": "4:3";
-        "9:16": "9:16";
-        "16:9": "16:9";
         "5:4": "5:4";
+        "9:16": "9:16";
     }>>>;
 }, z.core.$strip>, {
     prompt: string;
-    aspectRatio: "1:1" | "3:4" | "4:3" | "9:16" | "16:9" | "5:4";
+    aspectRatio: "16:9" | "1:1" | "3:4" | "4:3" | "5:4" | "9:16";
 }, {
     prompt: string;
-    aspectRatio?: "1:1" | "3:4" | "4:3" | "9:16" | "16:9" | "5:4" | undefined;
+    aspectRatio?: "16:9" | "1:1" | "3:4" | "4:3" | "5:4" | "9:16" | undefined;
 }, GenerateImageResult>;
 export {};

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

@@ -3,9 +3,9 @@ export declare const TODO_WRITE_TOOL_NAME = "todo_write";
 export declare const todoItemSchema: z.ZodObject<{
     content: z.ZodString;
     status: z.ZodEnum<{
-        pending: "pending";
-        in_progress: "in_progress";
         completed: "completed";
+        in_progress: "in_progress";
+        pending: "pending";
     }>;
     activeForm: z.ZodString;
 }, z.core.$strip>;
@@ -13,22 +13,22 @@ export declare function makeTodoWriteTool(): import("langchain").DynamicStructur
     todos: z.ZodArray<z.ZodObject<{
         content: z.ZodString;
         status: z.ZodEnum<{
-            pending: "pending";
-            in_progress: "in_progress";
             completed: "completed";
+            in_progress: "in_progress";
+            pending: "pending";
         }>;
         activeForm: z.ZodString;
     }, z.core.$strip>>;
 }, z.core.$strip>, {
     todos: {
         content: string;
-        status: "pending" | "in_progress" | "completed";
+        status: "completed" | "in_progress" | "pending";
         activeForm: string;
     }[];
 }, {
     todos: {
         content: string;
-        status: "pending" | "in_progress" | "completed";
+        status: "completed" | "in_progress" | "pending";
         activeForm: string;
     }[];
 }, string>;
@@ -36,22 +36,22 @@ export declare const todoWrite: import("langchain").DynamicStructuredTool<z.ZodO
     todos: z.ZodArray<z.ZodObject<{
         content: z.ZodString;
         status: z.ZodEnum<{
-            pending: "pending";
-            in_progress: "in_progress";
             completed: "completed";
+            in_progress: "in_progress";
+            pending: "pending";
         }>;
         activeForm: z.ZodString;
     }, z.core.$strip>>;
 }, z.core.$strip>, {
     todos: {
         content: string;
-        status: "pending" | "in_progress" | "completed";
+        status: "completed" | "in_progress" | "pending";
         activeForm: string;
     }[];
 }, {
     todos: {
         content: string;
-        status: "pending" | "in_progress" | "completed";
+        status: "completed" | "in_progress" | "pending";
         activeForm: string;
     }[];
 }, string>;

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<{