@polka-codes/core 0.9.80 → 0.9.81

package/dist/_tsup-dts-rollup.d.ts

@@ -1,4 +1,3 @@
-import { $strip } from 'zod/v4/core';
 import type { FilePart } from 'ai';
 import type { ImagePart } from 'ai';
 import type { JSONValue } from '@ai-sdk/provider';
@@ -15,19 +14,6 @@ import type { ToolModelMessage } from '@ai-sdk/provider-utils';
 import type { ToolResultPart } from '@ai-sdk/provider-utils';
 import { ToolSet } from 'ai';
 import { z } from 'zod';
-import { ZodEnum } from 'zod';
-import { ZodNullable } from 'zod';
-import { ZodObject } from 'zod';
-import { ZodOptional } from 'zod';
-import { ZodString } from 'zod';
-
-declare type AgentToolInfo = {
-    name: string;
-    description: string;
-    parameters: z.ZodObject<any>;
-};
-export { AgentToolInfo }
-export { AgentToolInfo as AgentToolInfo_alias_1 }
 
 declare type AgentToolRegistry = {
     generateText: {
@@ -47,24 +33,20 @@ declare type AgentToolRegistry = {
             toolName: string;
             input: any;
         };
-        output: AgentToolResponse;
+        output: ToolResponse;
     };
 };
 export { AgentToolRegistry }
 export { AgentToolRegistry as AgentToolRegistry_alias_1 }
 export { AgentToolRegistry as AgentToolRegistry_alias_2 }
 
-declare type AgentToolResponse = ToolResponseReply | ToolResponseExit | ToolResponseError;
-export { AgentToolResponse }
-export { AgentToolResponse as AgentToolResponse_alias_1 }
-
 declare const agentWorkflow: WorkflowFn<AgentWorkflowInput, ExitReason, AgentToolRegistry>;
 export { agentWorkflow }
 export { agentWorkflow as agentWorkflow_alias_1 }
 export { agentWorkflow as agentWorkflow_alias_2 }
 
 declare type AgentWorkflowInput = {
-    tools: Readonly<FullAgentToolInfo[]>;
+    tools: Readonly<FullToolInfo[]>;
     maxToolRoundTrips?: number;
     userMessage: readonly JsonUserModelMessage[];
     outputSchema?: z.ZodSchema;
@@ -78,6 +60,13 @@ export { AgentWorkflowInput }
 export { AgentWorkflowInput as AgentWorkflowInput_alias_1 }
 export { AgentWorkflowInput as AgentWorkflowInput_alias_2 }
 
+/**
+ * Instructions about code field format constraints.
+ */
+declare const CODE_FIELD_CONSTRAINTS = "REMEMBER: The \"code\" field must be ONLY the function body statements.\n- DO NOT wrap code in arrow functions: `(ctx) => { ... }`\n- DO NOT wrap code in async functions: `async (ctx) => { ... }`\n- DO NOT include outer curly braces\n- DO include a return statement if the step should produce output\n- Each \"code\" field should be a string containing multiple statements separated by newlines";
+export { CODE_FIELD_CONSTRAINTS }
+export { CODE_FIELD_CONSTRAINTS as CODE_FIELD_CONSTRAINTS_alias_1 }
+
 declare type CommandProvider = {
     executeCommand?: (command: string, needApprove: boolean) => Promise<{
         stdout: string;
@@ -90,6 +79,20 @@ export { CommandProvider }
 export { CommandProvider as CommandProvider_alias_1 }
 export { CommandProvider as CommandProvider_alias_2 }
 
+/**
+ * Complete example demonstrating all quality guidelines in a single step.
+ */
+declare const COMPLETE_STEP_EXAMPLE = "## Complete Example: High-Quality Step Implementation\n\nThis example demonstrates all quality guidelines in a single step:\n\n```ts\n// Step: processUserData\n// Task: Read, validate, and process user data from a file\n\n// Input validation\nif (!ctx.input.dataFile) {\n  throw new Error('Missing required input: dataFile')\n}\n\nctx.logger.info(`Starting user data processing for: ${ctx.input.dataFile}`)\n\n// Read file with error handling\nlet rawData\ntry {\n  ctx.logger.debug(`Reading file: ${ctx.input.dataFile}`)\n  rawData = await ctx.agentTools.readFile({ path: ctx.input.dataFile })\n\n  if (!rawData) {\n    throw new Error(`File not found or empty: ${ctx.input.dataFile}`)\n  }\n} catch (error) {\n  const err = error instanceof Error ? error : new Error(String(error))\n  ctx.logger.error(`Failed to read file: ${err.message}`)\n  throw err  // Preserve original stack trace\n}\n\n// Parse and validate data\nlet users\ntry {\n  ctx.logger.debug('Parsing JSON data')\n  const parsed = JSON.parse(rawData)\n\n  if (!parsed?.users || !Array.isArray(parsed.users)) {\n    throw new Error('Invalid data format: expected {users: [...]}')\n  }\n\n  users = parsed.users\n  ctx.logger.info(`Found ${users.length} users to process`)\n} catch (error) {\n  const err = error instanceof Error ? error : new Error(String(error))\n  ctx.logger.error(`Data parsing failed: ${err.message}`)\n  throw err  // Preserve original stack trace\n}\n\n// Process each user with progress reporting\nconst results = []\nfor (let i = 0; i < users.length; i++) {\n  const user = users[i]\n\n  // Validate each user object\n  if (!user?.id || !user?.email) {\n    ctx.logger.warn(`Skipping invalid user at index ${i}: missing id or email`)\n    continue\n  }\n\n  // Process user\n  const processed = {\n    id: user.id,\n    email: user.email.toLowerCase().trim(),\n    name: user.name?.trim() || 'Unknown',\n    processedAt: new Date().toISOString(),\n    status: 'active'\n  }\n\n  results.push(processed)\n\n  // Progress feedback every 10 items\n  if ((i + 1) % 10 === 0) {\n    ctx.logger.info(`Processed ${i + 1}/${users.length} users`)\n  }\n}\n\nctx.logger.info(`Successfully processed ${results.length}/${users.length} users`)\n\n// Return structured result with metadata\nreturn {\n  users: results,\n  metadata: {\n    totalInput: users.length,\n    totalProcessed: results.length,\n    skipped: users.length - results.length,\n    processedAt: new Date().toISOString()\n  }\n}\n```\n\nKey features demonstrated:\n- Input validation at start\n- Comprehensive error handling with try-catch that preserves stack traces\n- Logging at info, debug, warn, and error levels\n- Progress reporting for long operations (every 10 items)\n- Data validation throughout (null checks, type checks, array validation)\n- Structured return value with metadata for observability\n- Descriptive error messages with context\n- Meaningful variable names (rawData, users, processed)\n- Clean async/await usage\n- Template literals for readable string interpolation\n- Proper error type guards (error instanceof Error)";
+export { COMPLETE_STEP_EXAMPLE }
+export { COMPLETE_STEP_EXAMPLE as COMPLETE_STEP_EXAMPLE_alias_1 }
+
+/**
+ * Compose the full implementation guidelines from individual components.
+ */
+declare function composeImplementationGuidelines(): string;
+export { composeImplementationGuidelines }
+export { composeImplementationGuidelines as composeImplementationGuidelines_alias_1 }
+
 /**
  * Utility to compute exponential backoff delays for rate-limit handling. generated by polka.codes
  *
@@ -140,6 +143,17 @@ declare const configSchema: z.ZodOptional<z.ZodNullable<z.ZodObject<{
         model: z.ZodOptional<z.ZodString>;
         parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
         budget: z.ZodOptional<z.ZodNumber>;
+        rules: z.ZodOptional<z.ZodUnion<[z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            url: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            repo: z.ZodString;
+            path: z.ZodString;
+            tag: z.ZodOptional<z.ZodString>;
+            commit: z.ZodOptional<z.ZodString>;
+            branch: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>>, z.ZodString]>>;
     }, z.core.$strip>>>;
     tools: z.ZodOptional<z.ZodObject<{
         search: z.ZodOptional<z.ZodUnion<[z.ZodObject<{
@@ -147,6 +161,17 @@ declare const configSchema: z.ZodOptional<z.ZodNullable<z.ZodObject<{
             model: z.ZodOptional<z.ZodString>;
             parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
             budget: z.ZodOptional<z.ZodNumber>;
+            rules: z.ZodOptional<z.ZodUnion<[z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                url: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                repo: z.ZodString;
+                path: z.ZodString;
+                tag: z.ZodOptional<z.ZodString>;
+                commit: z.ZodOptional<z.ZodString>;
+                branch: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>]>>>, z.ZodString]>>;
         }, z.core.$strip>, z.ZodBoolean]>>;
     }, z.core.$strip>>;
     rules: z.ZodOptional<z.ZodUnion<[z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
@@ -165,6 +190,13 @@ declare const configSchema: z.ZodOptional<z.ZodNullable<z.ZodObject<{
 export { configSchema }
 export { configSchema as configSchema_alias_1 }
 
+/**
+ * Guidelines for accessing context and returning values.
+ */
+declare const CONTEXT_USAGE_GUIDELINES = "## Guidelines\n- Use `await` for all async operations.\n- Return the output value for the step (this becomes the step output).\n- Access inputs via `ctx.input.<inputId>`.\n- Access previous step outputs via `ctx.state.<stepOutputKey>` (defaults to the step `output` or `id`).";
+export { CONTEXT_USAGE_GUIDELINES }
+export { CONTEXT_USAGE_GUIDELINES as CONTEXT_USAGE_GUIDELINES_alias_1 }
+
 declare function createContext<TTools extends ToolRegistry>(tools: WorkflowTools<TTools>, stepFn?: StepFn, logger?: Logger): WorkflowContext<TTools>;
 export { createContext }
 export { createContext as createContext_alias_1 }
@@ -173,6 +205,7 @@ export { createContext as createContext_alias_2 }
 declare function createDynamicWorkflow<TTools extends ToolRegistry = DynamicWorkflowRegistry>(definition: WorkflowFile | string, options?: DynamicWorkflowRunnerOptions): (workflowId: string, input: Record<string, any>, context: WorkflowContext<TTools>) => Promise<any>;
 export { createDynamicWorkflow }
 export { createDynamicWorkflow as createDynamicWorkflow_alias_1 }
+export { createDynamicWorkflow as createDynamicWorkflow_alias_2 }
 
 declare const _default: {
     handler: ToolHandler<{
@@ -199,82 +232,6 @@ export { _default as askFollowupQuestion_alias_1 }
 export { _default as default_alias }
 
 declare const _default_10: {
-    handler: ToolHandler<{
-        readonly name: "readMemory";
-        readonly description: "Reads content from a memory topic. Use this to retrieve information stored in previous steps. If no topic is specified, reads from the default topic.";
-        readonly parameters: z.ZodObject<{
-            topic: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strip>;
-    }, MemoryProvider>;
-    name: "readMemory";
-    description: "Reads content from a memory topic. Use this to retrieve information stored in previous steps. If no topic is specified, reads from the default topic.";
-    parameters: z.ZodObject<{
-        topic: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>;
-};
-export { _default_10 as default_alias_9 }
-export { _default_10 as readMemory }
-export { _default_10 as readMemory_alias_1 }
-
-declare const _default_11: {
-    handler: ToolHandler<{
-        readonly name: "removeFile";
-        readonly description: "Request to remove a file at the specified path.";
-        readonly parameters: z.ZodObject<{
-            path: z.ZodString;
-        }, z.core.$strip>;
-    }, FilesystemProvider>;
-    name: "removeFile";
-    description: "Request to remove a file at the specified path.";
-    parameters: z.ZodObject<{
-        path: z.ZodString;
-    }, z.core.$strip>;
-};
-export { _default_11 as default_alias_10 }
-export { _default_11 as removeFile }
-export { _default_11 as removeFile_alias_1 }
-
-declare const _default_12: {
-    handler: ToolHandler<{
-        readonly name: "renameFile";
-        readonly description: "Request to rename a file from source path to target path.";
-        readonly parameters: z.ZodObject<{
-            source_path: z.ZodString;
-            target_path: z.ZodString;
-        }, z.core.$strip>;
-    }, FilesystemProvider>;
-    name: "renameFile";
-    description: "Request to rename a file from source path to target path.";
-    parameters: z.ZodObject<{
-        source_path: z.ZodString;
-        target_path: z.ZodString;
-    }, z.core.$strip>;
-};
-export { _default_12 as default_alias_11 }
-export { _default_12 as renameFile }
-export { _default_12 as renameFile_alias_1 }
-
-declare const _default_13: {
-    handler: ToolHandler<{
-        readonly name: "replaceInFile";
-        readonly description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.";
-        readonly parameters: z.ZodObject<{
-            path: z.ZodString;
-            diff: z.ZodString;
-        }, z.core.$strip>;
-    }, FilesystemProvider>;
-    name: "replaceInFile";
-    description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.";
-    parameters: z.ZodObject<{
-        path: z.ZodString;
-        diff: z.ZodString;
-    }, z.core.$strip>;
-};
-export { _default_13 as default_alias_12 }
-export { _default_13 as replaceInFile }
-export { _default_13 as replaceInFile_alias_1 }
-
-declare const _default_14: {
     handler: ToolHandler<{
         readonly name: "search";
         readonly description: "Search the web for information using Google Search. Use this tool to find current information, facts, news, documentation, or research that is not available in your training data. Returns comprehensive search results with relevant content extracted from the web.";
@@ -288,11 +245,11 @@ declare const _default_14: {
         query: z.ZodString;
     }, z.core.$strip>;
 };
-export { _default_14 as default_alias_13 }
-export { _default_14 as search }
-export { _default_14 as search_alias_1 }
+export { _default_10 as default_alias_9 }
+export { _default_10 as search }
+export { _default_10 as search_alias_1 }
 
-declare const _default_15: {
+declare const _default_11: {
     handler: ToolHandler<{
         readonly name: "searchFiles";
         readonly description: "Request to perform a regex search across files in a specified directory, outputting context-rich results that include surrounding lines. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context.";
@@ -310,83 +267,11 @@ declare const _default_15: {
         filePattern: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 };
-export { _default_15 as default_alias_14 }
-export { _default_15 as searchFiles }
-export { _default_15 as searchFiles_alias_1 }
-
-declare const _default_16: {
-    handler: ToolHandler<{
-        readonly name: "updateMemory";
-        readonly description: "Appends, replaces, or removes content from a memory topic. Use \"append\" to add to existing content, \"replace\" to overwrite entirely, or \"remove\" to delete a topic. Memory persists across tool calls within a workflow.";
-        readonly parameters: z.ZodObject<{
-            operation: z.ZodEnum<{
-                append: "append";
-                replace: "replace";
-                remove: "remove";
-            }>;
-            topic: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        }, z.core.$strip>;
-    }, MemoryProvider>;
-    name: "updateMemory";
-    description: "Appends, replaces, or removes content from a memory topic. Use \"append\" to add to existing content, \"replace\" to overwrite entirely, or \"remove\" to delete a topic. Memory persists across tool calls within a workflow.";
-    parameters: z.ZodObject<{
-        operation: z.ZodEnum<{
-            append: "append";
-            replace: "replace";
-            remove: "remove";
-        }>;
-        topic: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>;
-};
-export { _default_16 as default_alias_15 }
-export { _default_16 as updateMemory }
-export { _default_16 as updateMemory_alias_1 }
-
-declare const _default_17: {
-    handler: ToolHandler<{
-        readonly name: "updateTodoItem";
-        readonly description: "Add or update a to-do item.";
-        readonly parameters: ZodObject<    {
-        operation: ZodEnum<    {
-        add: "add";
-        update: "update";
-        }>;
-        id: ZodOptional<ZodNullable<ZodString>>;
-        parentId: ZodOptional<ZodNullable<ZodString>>;
-        title: ZodOptional<ZodNullable<ZodString>>;
-        description: ZodOptional<ZodNullable<ZodString>>;
-        status: ZodOptional<ZodNullable<ZodEnum<    {
-        open: "open";
-        completed: "completed";
-        closed: "closed";
-        }>>>;
-        }, $strip>;
-    }, TodoProvider>;
-    name: "updateTodoItem";
-    description: "Add or update a to-do item.";
-    parameters: ZodObject<    {
-    operation: ZodEnum<    {
-    add: "add";
-    update: "update";
-    }>;
-    id: ZodOptional<ZodNullable<ZodString>>;
-    parentId: ZodOptional<ZodNullable<ZodString>>;
-    title: ZodOptional<ZodNullable<ZodString>>;
-    description: ZodOptional<ZodNullable<ZodString>>;
-    status: ZodOptional<ZodNullable<ZodEnum<    {
-    open: "open";
-    completed: "completed";
-    closed: "closed";
-    }>>>;
-    }, $strip>;
-};
-export { _default_17 as default_alias_16 }
-export { _default_17 as updateTodoItem }
-export { _default_17 as updateTodoItem_alias_1 }
+export { _default_11 as default_alias_10 }
+export { _default_11 as searchFiles }
+export { _default_11 as searchFiles_alias_1 }
 
-declare const _default_18: {
+declare const _default_12: {
     handler: ToolHandler<{
         readonly name: "writeToFile";
         readonly description: "Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file. Ensure that the output content does not include incorrect escaped character patterns such as `&lt;`, `&gt;`, or `&amp;`. Also ensure there is no unwanted CDATA tags in the content.";
@@ -402,9 +287,9 @@ declare const _default_18: {
         content: z.ZodString;
     }, z.core.$strip>;
 };
-export { _default_18 as default_alias_17 }
-export { _default_18 as writeToFile }
-export { _default_18 as writeToFile_alias_1 }
+export { _default_12 as default_alias_11 }
+export { _default_12 as writeToFile }
+export { _default_12 as writeToFile_alias_1 }
 
 declare const _default_2: {
     handler: ToolHandler<{
@@ -445,24 +330,6 @@ export { _default_3 as fetchUrl }
 export { _default_3 as fetchUrl_alias_1 }
 
 declare const _default_4: {
-    handler: ToolHandler<{
-        readonly name: "getTodoItem";
-        readonly description: "Get a to-do item by its ID.";
-        readonly parameters: z.ZodObject<{
-            id: z.ZodString;
-        }, z.core.$strip>;
-    }, TodoProvider>;
-    name: "getTodoItem";
-    description: "Get a to-do item by its ID.";
-    parameters: z.ZodObject<{
-        id: z.ZodString;
-    }, z.core.$strip>;
-};
-export { _default_4 as default_alias_3 }
-export { _default_4 as getTodoItem }
-export { _default_4 as getTodoItem_alias_1 }
-
-declare const _default_5: {
     handler: ToolHandler<{
         readonly name: "listFiles";
         readonly description: "Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.";
@@ -482,89 +349,105 @@ declare const _default_5: {
         includeIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
     }, z.core.$strip>;
 };
+export { _default_4 as default_alias_3 }
+export { _default_4 as listFiles }
+export { _default_4 as listFiles_alias_1 }
+
+declare const _default_5: {
+    handler: ToolHandler<{
+        readonly name: "readBinaryFile";
+        readonly description: "Read a binary file from a URL or local path. Use file:// prefix to access local files. This can be used to access non-text files such as PDFs or images.";
+        readonly parameters: z.ZodObject<{
+            url: z.ZodString;
+        }, z.core.$strip>;
+    }, FilesystemProvider>;
+    name: "readBinaryFile";
+    description: "Read a binary file from a URL or local path. Use file:// prefix to access local files. This can be used to access non-text files such as PDFs or images.";
+    parameters: z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strip>;
+};
 export { _default_5 as default_alias_4 }
-export { _default_5 as listFiles }
-export { _default_5 as listFiles_alias_1 }
+export { _default_5 as readBinaryFile }
+export { _default_5 as readBinaryFile_alias_1 }
 
 declare const _default_6: {
     handler: ToolHandler<{
-        readonly name: "listMemoryTopics";
-        readonly description: "Lists all topics in memory. Use this to see what information has been stored and which topics are available to read from.";
-        readonly parameters: z.ZodObject<{}, z.core.$strip>;
-    }, MemoryProvider>;
-    name: "listMemoryTopics";
-    description: "Lists all topics in memory. Use this to see what information has been stored and which topics are available to read from.";
-    parameters: z.ZodObject<{}, z.core.$strip>;
+        readonly name: "readFile";
+        readonly description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.";
+        readonly parameters: z.ZodObject<{
+            path: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+            includeIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>>>;
+        }, z.core.$strip>;
+    }, FilesystemProvider>;
+    name: "readFile";
+    description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.";
+    parameters: z.ZodObject<{
+        path: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+        includeIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>>>;
+    }, z.core.$strip>;
 };
 export { _default_6 as default_alias_5 }
-export { _default_6 as listMemoryTopics }
-export { _default_6 as listMemoryTopics_alias_1 }
+export { _default_6 as readFile }
+export { _default_6 as readFile_alias_1 }
 
 declare const _default_7: {
     handler: ToolHandler<{
-        readonly name: "listTodoItems";
-        readonly description: "List all to-do items, sorted by id. If an id is provided, it lists all sub-items for that id. Can be filtered by status.";
+        readonly name: "removeFile";
+        readonly description: "Request to remove a file at the specified path.";
         readonly parameters: z.ZodObject<{
-            id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-            status: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-                open: "open";
-                completed: "completed";
-                closed: "closed";
-            }>>>;
+            path: z.ZodString;
         }, z.core.$strip>;
-    }, TodoProvider>;
-    name: "listTodoItems";
-    description: "List all to-do items, sorted by id. If an id is provided, it lists all sub-items for that id. Can be filtered by status.";
+    }, FilesystemProvider>;
+    name: "removeFile";
+    description: "Request to remove a file at the specified path.";
     parameters: z.ZodObject<{
-        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        status: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            open: "open";
-            completed: "completed";
-            closed: "closed";
-        }>>>;
+        path: z.ZodString;
     }, z.core.$strip>;
 };
 export { _default_7 as default_alias_6 }
-export { _default_7 as listTodoItems }
-export { _default_7 as listTodoItems_alias_1 }
+export { _default_7 as removeFile }
+export { _default_7 as removeFile_alias_1 }
 
 declare const _default_8: {
     handler: ToolHandler<{
-        readonly name: "readBinaryFile";
-        readonly description: "Read a binary file from a URL or local path. Use file:// prefix to access local files. This can be used to access non-text files such as PDFs or images.";
+        readonly name: "renameFile";
+        readonly description: "Request to rename a file from source path to target path.";
         readonly parameters: z.ZodObject<{
-            url: z.ZodString;
+            source_path: z.ZodString;
+            target_path: z.ZodString;
         }, z.core.$strip>;
     }, FilesystemProvider>;
-    name: "readBinaryFile";
-    description: "Read a binary file from a URL or local path. Use file:// prefix to access local files. This can be used to access non-text files such as PDFs or images.";
+    name: "renameFile";
+    description: "Request to rename a file from source path to target path.";
     parameters: z.ZodObject<{
-        url: z.ZodString;
+        source_path: z.ZodString;
+        target_path: z.ZodString;
     }, z.core.$strip>;
 };
 export { _default_8 as default_alias_7 }
-export { _default_8 as readBinaryFile }
-export { _default_8 as readBinaryFile_alias_1 }
+export { _default_8 as renameFile }
+export { _default_8 as renameFile_alias_1 }
 
 declare const _default_9: {
     handler: ToolHandler<{
-        readonly name: "readFile";
-        readonly description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.";
+        readonly name: "replaceInFile";
+        readonly description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.";
         readonly parameters: z.ZodObject<{
-            path: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
-            includeIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>>>;
+            path: z.ZodString;
+            diff: z.ZodString;
         }, z.core.$strip>;
     }, FilesystemProvider>;
-    name: "readFile";
-    description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.";
+    name: "replaceInFile";
+    description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.";
     parameters: z.ZodObject<{
-        path: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
-        includeIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>>>;
+        path: z.ZodString;
+        diff: z.ZodString;
     }, z.core.$strip>;
 };
 export { _default_9 as default_alias_8 }
-export { _default_9 as readFile }
-export { _default_9 as readFile_alias_1 }
+export { _default_9 as replaceInFile }
+export { _default_9 as replaceInFile_alias_1 }
 
 /**
  * Returns the directory portion of a path string.
@@ -581,10 +464,12 @@ declare type DynamicStepRuntimeContext<TTools extends ToolRegistry> = {
     logger: Logger;
     step: StepFn;
     runWorkflow: (workflowId: string, input?: Record<string, any>) => Promise<any>;
-    toolInfo: Readonly<FullAgentToolInfo[]> | undefined;
+    toolInfo: Readonly<FullToolInfo[]> | undefined;
+    agentTools: Record<string, (input: any) => Promise<any>>;
 };
 export { DynamicStepRuntimeContext }
 export { DynamicStepRuntimeContext as DynamicStepRuntimeContext_alias_1 }
+export { DynamicStepRuntimeContext as DynamicStepRuntimeContext_alias_2 }
 
 declare type DynamicWorkflowParseResult = {
     success: true;
@@ -595,19 +480,21 @@ declare type DynamicWorkflowParseResult = {
 };
 export { DynamicWorkflowParseResult }
 export { DynamicWorkflowParseResult as DynamicWorkflowParseResult_alias_1 }
+export { DynamicWorkflowParseResult as DynamicWorkflowParseResult_alias_2 }
 
 declare type DynamicWorkflowRegistry = ToolRegistry & {
     runWorkflow: RunWorkflowTool;
 };
 export { DynamicWorkflowRegistry }
 export { DynamicWorkflowRegistry as DynamicWorkflowRegistry_alias_1 }
+export { DynamicWorkflowRegistry as DynamicWorkflowRegistry_alias_2 }
 
 declare type DynamicWorkflowRunnerOptions = {
     /**
      * Tool definitions used when a step does not have persisted `code`
      * and needs to be executed via `agentWorkflow`.
      */
-    toolInfo?: Readonly<FullAgentToolInfo[]>;
+    toolInfo?: Readonly<FullToolInfo[]>;
     /**
      * Model id forwarded to `agentWorkflow` for agent-executed steps.
      */
@@ -638,6 +525,7 @@ declare type DynamicWorkflowRunnerOptions = {
 };
 export { DynamicWorkflowRunnerOptions }
 export { DynamicWorkflowRunnerOptions as DynamicWorkflowRunnerOptions_alias_1 }
+export { DynamicWorkflowRunnerOptions as DynamicWorkflowRunnerOptions_alias_2 }
 
 declare type ExitReason = {
     type: 'UsageExceeded';
@@ -680,15 +568,16 @@ export { fromJsonModelMessage }
 export { fromJsonModelMessage as fromJsonModelMessage_alias_1 }
 export { fromJsonModelMessage as fromJsonModelMessage_alias_2 }
 
-declare type FullAgentToolInfo = AgentToolInfo & {
-    handler: ToolHandler<AgentToolInfo, any>;
+declare type FullToolInfo = ToolInfo & {
+    handler: ToolHandler<ToolInfo, any>;
 };
-export { FullAgentToolInfo }
-export { FullAgentToolInfo as FullAgentToolInfo_alias_1 }
+export { FullToolInfo }
+export { FullToolInfo as FullToolInfo_alias_1 }
 
 declare type GenerateWorkflowCodeInput = z.infer<typeof GenerateWorkflowCodeInputSchema>;
 export { GenerateWorkflowCodeInput }
 export { GenerateWorkflowCodeInput as GenerateWorkflowCodeInput_alias_1 }
+export { GenerateWorkflowCodeInput as GenerateWorkflowCodeInput_alias_2 }
 
 declare const GenerateWorkflowCodeInputSchema: z.ZodObject<{
     workflow: z.ZodObject<{
@@ -712,31 +601,37 @@ declare const GenerateWorkflowCodeInputSchema: z.ZodObject<{
             output: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         }, z.core.$strip>>;
     }, z.core.$strip>;
+    skipReview: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
 }, z.core.$strip>;
 export { GenerateWorkflowCodeInputSchema }
 export { GenerateWorkflowCodeInputSchema as GenerateWorkflowCodeInputSchema_alias_1 }
+export { GenerateWorkflowCodeInputSchema as GenerateWorkflowCodeInputSchema_alias_2 }
 
 declare const generateWorkflowCodeWorkflow: WorkflowFn<GenerateWorkflowCodeInput, WorkflowFile, AgentToolRegistry>;
 export { generateWorkflowCodeWorkflow }
 export { generateWorkflowCodeWorkflow as generateWorkflowCodeWorkflow_alias_1 }
+export { generateWorkflowCodeWorkflow as generateWorkflowCodeWorkflow_alias_2 }
 
 declare type GenerateWorkflowDefinitionInput = z.infer<typeof GenerateWorkflowDefinitionInputSchema>;
 export { GenerateWorkflowDefinitionInput }
 export { GenerateWorkflowDefinitionInput as GenerateWorkflowDefinitionInput_alias_1 }
+export { GenerateWorkflowDefinitionInput as GenerateWorkflowDefinitionInput_alias_2 }
 
 declare const GenerateWorkflowDefinitionInputSchema: z.ZodObject<{
     prompt: z.ZodString;
-    availableTools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    availableTools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         description: z.ZodString;
-    }, z.core.$strip>>>;
+    }, z.core.$strip>>>>;
 }, z.core.$strip>;
 export { GenerateWorkflowDefinitionInputSchema }
 export { GenerateWorkflowDefinitionInputSchema as GenerateWorkflowDefinitionInputSchema_alias_1 }
+export { GenerateWorkflowDefinitionInputSchema as GenerateWorkflowDefinitionInputSchema_alias_2 }
 
 declare const generateWorkflowDefinitionWorkflow: WorkflowFn<GenerateWorkflowDefinitionInput, WorkflowFile, AgentToolRegistry>;
 export { generateWorkflowDefinitionWorkflow }
 export { generateWorkflowDefinitionWorkflow as generateWorkflowDefinitionWorkflow_alias_1 }
+export { generateWorkflowDefinitionWorkflow as generateWorkflowDefinitionWorkflow_alias_2 }
 
 declare type GetTodoItemOutput = TodoItem & {
     subItems: {
@@ -756,33 +651,21 @@ export declare const handler_alias_10: ToolHandler<typeof toolInfo_alias_10, Fil
 
 export declare const handler_alias_11: ToolHandler<typeof toolInfo_alias_11, FilesystemProvider>;
 
-export declare const handler_alias_12: ToolHandler<typeof toolInfo_alias_12, FilesystemProvider>;
-
-export declare const handler_alias_13: ToolHandler<typeof toolInfo_alias_13, WebProvider>;
-
-export declare const handler_alias_14: ToolHandler<typeof toolInfo_alias_14, FilesystemProvider>;
-
-export declare const handler_alias_15: ToolHandler<typeof toolInfo_alias_15, MemoryProvider>;
-
-export declare const handler_alias_16: ToolHandler<typeof toolInfo_alias_16, TodoProvider>;
-
-export declare const handler_alias_17: ToolHandler<typeof toolInfo_alias_17, FilesystemProvider>;
-
 export declare const handler_alias_2: ToolHandler<typeof toolInfo_alias_2, WebProvider>;
 
-export declare const handler_alias_3: ToolHandler<typeof toolInfo_alias_3, TodoProvider>;
+export declare const handler_alias_3: ToolHandler<typeof toolInfo_alias_3, FilesystemProvider>;
 
 export declare const handler_alias_4: ToolHandler<typeof toolInfo_alias_4, FilesystemProvider>;
 
-export declare const handler_alias_5: ToolHandler<typeof toolInfo_alias_5, MemoryProvider>;
+export declare const handler_alias_5: ToolHandler<typeof toolInfo_alias_5, FilesystemProvider>;
 
-export declare const handler_alias_6: ToolHandler<typeof toolInfo_alias_6, TodoProvider>;
+export declare const handler_alias_6: ToolHandler<typeof toolInfo_alias_6, FilesystemProvider>;
 
 export declare const handler_alias_7: ToolHandler<typeof toolInfo_alias_7, FilesystemProvider>;
 
 export declare const handler_alias_8: ToolHandler<typeof toolInfo_alias_8, FilesystemProvider>;
 
-export declare const handler_alias_9: ToolHandler<typeof toolInfo_alias_9, MemoryProvider>;
+export declare const handler_alias_9: ToolHandler<typeof toolInfo_alias_9, WebProvider>;
 
 declare type InteractionProvider = {
     askFollowupQuestion?: (question: string, options: string[]) => Promise<string>;
@@ -1015,6 +898,7 @@ export { ModelInfo as ModelInfo_alias_1 }
 declare function parseDynamicWorkflowDefinition(source: string): DynamicWorkflowParseResult;
 export { parseDynamicWorkflowDefinition }
 export { parseDynamicWorkflowDefinition as parseDynamicWorkflowDefinition_alias_1 }
+export { parseDynamicWorkflowDefinition as parseDynamicWorkflowDefinition_alias_2 }
 
 declare const parseJsonFromMarkdown: (markdown: string) => ParseOutputResult<any>;
 export { parseJsonFromMarkdown }
@@ -1037,10 +921,28 @@ declare const providerModelSchema: z.ZodObject<{
     model: z.ZodOptional<z.ZodString>;
     parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     budget: z.ZodOptional<z.ZodNumber>;
+    rules: z.ZodOptional<z.ZodUnion<[z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        repo: z.ZodString;
+        path: z.ZodString;
+        tag: z.ZodOptional<z.ZodString>;
+        commit: z.ZodOptional<z.ZodString>;
+        branch: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>>, z.ZodString]>>;
 }, z.core.$strip>;
 export { providerModelSchema }
 export { providerModelSchema as providerModelSchema_alias_1 }
 
+/**
+ * Quality guidelines for error handling, logging, validation, and best practices.
+ */
+declare const QUALITY_GUIDELINES = "## Quality Guidelines for Code Implementation\n\n### Error Handling\n- ALWAYS validate inputs at the start of steps\n- Use try-catch for operations that might fail (file I/O, parsing, API calls)\n- Preserve stack traces: re-throw original errors rather than creating new ones\n- Use error type guards: `const err = error instanceof Error ? error : new Error(String(error))`\n- Check for null/undefined before using values\n- Handle edge cases (empty arrays, missing files, invalid data)\n\n### Logging\n- Use `ctx.logger.info()` for important progress updates\n- Use `ctx.logger.debug()` for detailed information\n- Use `ctx.logger.warn()` for recoverable issues\n- Use `ctx.logger.error()` before throwing errors\n- Log when starting and completing significant operations\n- Use template literals for readability: `ctx.logger.info(\\`Processing ${items.length} items...\\`)`\n\n### User Experience\n- Provide progress feedback for long operations\n- Return structured data (objects/arrays), not strings when possible\n- Include helpful metadata in results (counts, timestamps, status)\n- For batch operations, report progress: `Processed 5/10 items`\n\n### Data Validation\n- Validate required fields exist before accessing\n- Check data types match expectations\n- Validate array lengths before iteration\n- Example: `if (!data?.users || !Array.isArray(data.users)) throw new Error('Invalid data format')`\n\n### Best Practices\n- Use meaningful variable names\n- Avoid nested callbacks - use async/await\n- Clean up resources (close files, clear timeouts)\n- Return consistent data structures across similar steps\n- For iteration, consider batching or rate limiting\n\n### When to Simplify\n- Simple transformation steps (e.g., formatting strings) need only basic error handling\n- Internal sub-workflow steps with validated inputs from parent can skip redundant validation\n- Minimal logging is fine for fast steps (<100ms) that don't perform I/O or external calls\n- Use judgment: match error handling complexity to the step's failure risk and impact";
+export { QUALITY_GUIDELINES }
+export { QUALITY_GUIDELINES as QUALITY_GUIDELINES_alias_1 }
+
 declare const replaceInFile_2: (fileContent: string, diff: string) => ReplaceResult;
 export { replaceInFile_2 as replaceInFileHelper }
 export { replaceInFile_2 as replaceInFile_alias_2 }
@@ -1080,6 +982,13 @@ declare const ruleSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
 export { ruleSchema }
 export { ruleSchema as ruleSchema_alias_1 }
 
+/**
+ * TypeScript type definitions for the runtime context available in dynamic workflow steps.
+ */
+declare const RUNTIME_CONTEXT_TYPES = "## Runtime context (ctx)\n```ts\n// Runtime types (for reference)\ntype Logger = {\n  debug: (...args: any[]) => void\n  info: (...args: any[]) => void\n  warn: (...args: any[]) => void\n  error: (...args: any[]) => void\n}\n\ntype StepFn = {\n  <T>(name: string, fn: () => Promise<T>): Promise<T>\n  <T>(name: string, options: { retry?: number }, fn: () => Promise<T>): Promise<T>\n}\n\ntype JsonModelMessage = { role: 'system' | 'user' | 'assistant' | 'tool'; content: any }\ntype JsonResponseMessage = { role: 'assistant' | 'tool'; content: any }\ntype ToolSet = Record<string, any>\n\ntype ToolResponseResult =\n  | { type: 'text'; value: string }\n  | { type: 'json'; value: any }\n  | { type: 'error-text'; value: string }\n  | { type: 'error-json'; value: any }\n  | { type: 'content'; value: any[] }\n\ntype ToolResponse =\n  | { type: 'Reply'; message: ToolResponseResult }\n  | { type: 'Exit'; message: string; object?: any }\n  | { type: 'Error'; message: ToolResponseResult }\n\ntype ExitReason =\n  | { type: 'UsageExceeded' }\n  | { type: 'Exit'; message: string; object?: any }\n  | { type: 'Error'; error: { message: string; stack?: string } }\n\ntype FullToolInfo = { name: string; description: string; parameters: any; handler: any }\n\ntype AgentTools = {\n  readFile: (input: { path: string }) => Promise<string | null>\n  writeToFile: (input: { path: string; content: string }) => Promise<void>\n  executeCommand: (input: { command: string; pipe?: boolean; requiresApproval?: boolean } & ({ args: string[]; shell?: false } | { shell: true })) => Promise<{\n    exitCode: number\n    stdout: string\n    stderr: string\n  }>\n  searchFiles: (input: { path: string; regex: string; filePattern?: string }) => Promise<string>\n  listFiles: (input: { path: string; recursive?: boolean; maxCount?: number; includeIgnored?: boolean }) => Promise<string>\n  fetchUrl: (input: { url: string[] }) => Promise<string>\n  askFollowupQuestion: (input: { questions: { prompt: string; options?: string[] }[] }) => Promise<any>\n  // ... and other tools available in the environment\n}\n\n// Tools available on ctx.tools in dynamic steps\ntype DynamicWorkflowTools = {\n  // LLM + agent helpers\n  runAgent: (input: {\n    tools: Readonly<FullToolInfo[]>\n    maxToolRoundTrips?: number\n    userMessage: readonly JsonModelMessage[]\n  } & ({ messages: JsonModelMessage[] } | { systemPrompt: string })) => Promise<ExitReason>\n\n  // CLI UX helpers\n  confirm: (input: { message: string }) => Promise<boolean>\n  input: (input: { message: string; default?: string }) => Promise<string>\n  select: (input: { message: string; choices: { name: string; value: string }[] }) => Promise<string>\n}\n\ntype DynamicStepRuntimeContext = {\n  workflowId: string\n  stepId: string\n  input: Record<string, any>\n  state: Record<string, any>\n  tools: DynamicWorkflowTools\n  agentTools: AgentTools\n  logger: Logger\n  step: StepFn\n  runWorkflow: (workflowId: string, input?: Record<string, any>) => Promise<any>\n  toolInfo?: ReadonlyArray<FullToolInfo>\n}\n```\n\n- `ctx.input`: workflow inputs (read-only).\n- `ctx.state`: shared state between steps (previous step outputs are stored here).\n- `ctx.agentTools`: standard tools (readFile, executeCommand, etc.). Call as `await ctx.agentTools.someTool({ ... })`.\n- `ctx.tools`: workflow helpers (runAgent, confirm, input, select).\n- `ctx.runWorkflow`: run a sub-workflow by id.";
+export { RUNTIME_CONTEXT_TYPES }
+export { RUNTIME_CONTEXT_TYPES as RUNTIME_CONTEXT_TYPES_alias_1 }
+
 declare type RunWorkflowTool = {
     input: {
         workflowId: string;
@@ -1089,6 +998,7 @@ declare type RunWorkflowTool = {
 };
 export { RunWorkflowTool }
 export { RunWorkflowTool as RunWorkflowTool_alias_1 }
+export { RunWorkflowTool as RunWorkflowTool_alias_2 }
 
 declare interface StepFn {
     <T>(name: string, fn: () => Promise<T>): Promise<T>;
@@ -1205,7 +1115,7 @@ export { TaskEventText as TaskEventText_alias_2 }
 declare interface TaskEventToolError extends TaskEventBase {
     kind: TaskEventKind.ToolError;
     tool: string;
-    error: ToolResponseError | ToolResponseResult;
+    error: ToolResponseResult;
 }
 export { TaskEventToolError }
 export { TaskEventToolError as TaskEventToolError_alias_1 }
@@ -1284,10 +1194,34 @@ export { toJsonModelMessage }
 export { toJsonModelMessage as toJsonModelMessage_alias_1 }
 export { toJsonModelMessage as toJsonModelMessage_alias_2 }
 
-declare type ToolHandler<_T, P> = (provider: P, args: Partial<Record<string, ToolParameterValue>>) => Promise<AgentToolResponse>;
+declare const TOOL_CALLING_EXAMPLES = "## Tool calling examples\n\n### Standard tools (ctx.agentTools)\n```ts\n// readFile\nconst readme = await ctx.agentTools.readFile({ path: 'README.md' })\nif (readme == null) throw new Error('README.md not found')\n\n// writeToFile\nawait ctx.agentTools.writeToFile({ path: 'notes.txt', content: 'hello\\n' })\n\n// executeCommand (args form)\nconst rg = await ctx.agentTools.executeCommand({ command: 'rg', args: ['-n', 'TODO', '.'] })\nif (rg.exitCode !== 0) throw new Error(rg.stderr)\n\n// executeCommand (shell form)\nawait ctx.agentTools.executeCommand({ command: 'ls -la', shell: true, pipe: true })\n```\n\n### Workflow helpers (ctx.tools)\n```ts\n// runAgent (nested agent; use ctx.toolInfo as the tool list)\nconst agentRes = await ctx.tools.runAgent({\n  systemPrompt: 'You are a helpful assistant.',\n  userMessage: [{ role: 'user', content: 'Summarize README.md in 3 bullets.' }],\n  tools: (ctx.toolInfo ?? []) as any,\n})\nif (agentRes.type !== 'Exit') throw new Error('runAgent failed')\n\n// confirm / input / select (interactive)\nconst ok = await ctx.tools.confirm({ message: 'Proceed?' })\nconst name = await ctx.tools.input({ message: 'Name?', default: 'main' })\nconst flavor = await ctx.tools.select({\n  message: 'Pick one',\n  choices: [\n    { name: 'A', value: 'a' },\n    { name: 'B', value: 'b' },\n  ],\n})\n```\n\n### Sub-workflow example (ctx.runWorkflow)\n```ts\nconst results: any[] = []\nfor (const pr of ctx.state.prs ?? []) {\n  results.push(await ctx.runWorkflow('reviewPR', { prId: pr.id }))\n}\nreturn results\n```";
+export { TOOL_CALLING_EXAMPLES }
+export { TOOL_CALLING_EXAMPLES as TOOL_CALLING_EXAMPLES_alias_1 }
+
+/**
+ * Tool groups that can be used in step.tools arrays.
+ * - "readonly": File reading operations only
+ * - "readwrite": Full file system access
+ * - "internet": Network operations (fetch, search)
+ * - "all": All available tools (special keyword, not in this map)
+ */
+declare const TOOL_GROUPS: Record<string, string[]>;
+export { TOOL_GROUPS }
+export { TOOL_GROUPS as TOOL_GROUPS_alias_1 }
+export { TOOL_GROUPS as TOOL_GROUPS_alias_2 }
+
+declare type ToolHandler<_T, P> = (provider: P, args: Partial<Record<string, ToolParameterValue>>) => Promise<ToolResponse>;
 export { ToolHandler }
 export { ToolHandler as ToolHandler_alias_1 }
 
+declare type ToolInfo = {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<any>;
+};
+export { ToolInfo }
+export { ToolInfo as ToolInfo_alias_1 }
+
 export declare const toolInfo: {
     readonly name: "askFollowupQuestion";
     readonly description: "Call this when vital details are missing. Pose each follow-up as one direct, unambiguous question. If it speeds the reply, add up to five short, mutually-exclusive answer options. Group any related questions in the same call to avoid a back-and-forth chain.";
@@ -1309,40 +1243,6 @@ export declare const toolInfo_alias_1: {
 };
 
 export declare const toolInfo_alias_10: {
-    readonly name: "removeFile";
-    readonly description: "Request to remove a file at the specified path.";
-    readonly parameters: z.ZodObject<{
-        path: z.ZodString;
-    }, z.core.$strip>;
-};
-
-export declare const toolInfo_alias_11: {
-    readonly name: "renameFile";
-    readonly description: "Request to rename a file from source path to target path.";
-    readonly parameters: z.ZodObject<{
-        source_path: z.ZodString;
-        target_path: z.ZodString;
-    }, z.core.$strip>;
-};
-
-export declare const toolInfo_alias_12: {
-    readonly name: "replaceInFile";
-    readonly description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.";
-    readonly parameters: z.ZodObject<{
-        path: z.ZodString;
-        diff: z.ZodString;
-    }, z.core.$strip>;
-};
-
-export declare const toolInfo_alias_13: {
-    readonly name: "search";
-    readonly description: "Search the web for information using Google Search. Use this tool to find current information, facts, news, documentation, or research that is not available in your training data. Returns comprehensive search results with relevant content extracted from the web.";
-    readonly parameters: z.ZodObject<{
-        query: z.ZodString;
-    }, z.core.$strip>;
-};
-
-export declare const toolInfo_alias_14: {
     readonly name: "searchFiles";
     readonly description: "Request to perform a regex search across files in a specified directory, outputting context-rich results that include surrounding lines. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context.";
     readonly parameters: z.ZodObject<{
@@ -1352,41 +1252,7 @@ export declare const toolInfo_alias_14: {
     }, z.core.$strip>;
 };
 
-export declare const toolInfo_alias_15: {
-    readonly name: "updateMemory";
-    readonly description: "Appends, replaces, or removes content from a memory topic. Use \"append\" to add to existing content, \"replace\" to overwrite entirely, or \"remove\" to delete a topic. Memory persists across tool calls within a workflow.";
-    readonly parameters: z.ZodObject<{
-        operation: z.ZodEnum<{
-            append: "append";
-            replace: "replace";
-            remove: "remove";
-        }>;
-        topic: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        content: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, z.core.$strip>;
-};
-
-export declare const toolInfo_alias_16: {
-    readonly name: "updateTodoItem";
-    readonly description: "Add or update a to-do item.";
-    readonly parameters: ZodObject<    {
-    operation: ZodEnum<    {
-    add: "add";
-    update: "update";
-    }>;
-    id: ZodOptional<ZodNullable<ZodString>>;
-    parentId: ZodOptional<ZodNullable<ZodString>>;
-    title: ZodOptional<ZodNullable<ZodString>>;
-    description: ZodOptional<ZodNullable<ZodString>>;
-    status: ZodOptional<ZodNullable<ZodEnum<    {
-    open: "open";
-    completed: "completed";
-    closed: "closed";
-    }>>>;
-    }, $strip>;
-};
-
-export declare const toolInfo_alias_17: {
+export declare const toolInfo_alias_11: {
     readonly name: "writeToFile";
     readonly description: "Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file. Ensure that the output content does not include incorrect escaped character patterns such as `&lt;`, `&gt;`, or `&amp;`. Also ensure there is no unwanted CDATA tags in the content.";
     readonly parameters: z.ZodObject<{
@@ -1404,14 +1270,6 @@ export declare const toolInfo_alias_2: {
 };
 
 export declare const toolInfo_alias_3: {
-    readonly name: "getTodoItem";
-    readonly description: "Get a to-do item by its ID.";
-    readonly parameters: z.ZodObject<{
-        id: z.ZodString;
-    }, z.core.$strip>;
-};
-
-export declare const toolInfo_alias_4: {
     readonly name: "listFiles";
     readonly description: "Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.";
     readonly parameters: z.ZodObject<{
@@ -1422,47 +1280,54 @@ export declare const toolInfo_alias_4: {
     }, z.core.$strip>;
 };
 
+export declare const toolInfo_alias_4: {
+    readonly name: "readBinaryFile";
+    readonly description: "Read a binary file from a URL or local path. Use file:// prefix to access local files. This can be used to access non-text files such as PDFs or images.";
+    readonly parameters: z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strip>;
+};
+
 export declare const toolInfo_alias_5: {
-    readonly name: "listMemoryTopics";
-    readonly description: "Lists all topics in memory. Use this to see what information has been stored and which topics are available to read from.";
-    readonly parameters: z.ZodObject<{}, z.core.$strip>;
+    readonly name: "readFile";
+    readonly description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.";
+    readonly parameters: z.ZodObject<{
+        path: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+        includeIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>>>;
+    }, z.core.$strip>;
 };
 
 export declare const toolInfo_alias_6: {
-    readonly name: "listTodoItems";
-    readonly description: "List all to-do items, sorted by id. If an id is provided, it lists all sub-items for that id. Can be filtered by status.";
+    readonly name: "removeFile";
+    readonly description: "Request to remove a file at the specified path.";
     readonly parameters: z.ZodObject<{
-        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        status: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
-            open: "open";
-            completed: "completed";
-            closed: "closed";
-        }>>>;
+        path: z.ZodString;
     }, z.core.$strip>;
 };
 
 export declare const toolInfo_alias_7: {
-    readonly name: "readBinaryFile";
-    readonly description: "Read a binary file from a URL or local path. Use file:// prefix to access local files. This can be used to access non-text files such as PDFs or images.";
+    readonly name: "renameFile";
+    readonly description: "Request to rename a file from source path to target path.";
     readonly parameters: z.ZodObject<{
-        url: z.ZodString;
+        source_path: z.ZodString;
+        target_path: z.ZodString;
     }, z.core.$strip>;
 };
 
 export declare const toolInfo_alias_8: {
-    readonly name: "readFile";
-    readonly description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.";
+    readonly name: "replaceInFile";
+    readonly description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.";
     readonly parameters: z.ZodObject<{
-        path: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
-        includeIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodBoolean>>>>;
+        path: z.ZodString;
+        diff: z.ZodString;
     }, z.core.$strip>;
 };
 
 export declare const toolInfo_alias_9: {
-    readonly name: "readMemory";
-    readonly description: "Reads content from a memory topic. Use this to retrieve information stored in previous steps. If no topic is specified, reads from the default topic.";
+    readonly name: "search";
+    readonly description: "Search the web for information using Google Search. Use this tool to find current information, facts, news, documentation, or research that is not available in your training data. Returns comprehensive search results with relevant content extracted from the web.";
     readonly parameters: z.ZodObject<{
-        topic: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        query: z.ZodString;
     }, z.core.$strip>;
 };
 
@@ -1493,27 +1358,12 @@ export { ToolRegistry }
 export { ToolRegistry as ToolRegistry_alias_1 }
 export { ToolRegistry as ToolRegistry_alias_2 }
 
-declare type ToolResponseError = {
-    type: ToolResponseType.Error;
-    message: ToolResponseResult;
-};
-export { ToolResponseError }
-export { ToolResponseError as ToolResponseError_alias_1 }
-
-declare type ToolResponseExit = {
-    type: ToolResponseType.Exit;
-    message: string;
-    object?: any;
-};
-export { ToolResponseExit }
-export { ToolResponseExit as ToolResponseExit_alias_1 }
-
-declare type ToolResponseReply = {
-    type: ToolResponseType.Reply;
+declare type ToolResponse = {
+    success: boolean;
     message: ToolResponseResult;
 };
-export { ToolResponseReply }
-export { ToolResponseReply as ToolResponseReply_alias_1 }
+export { ToolResponse }
+export { ToolResponse as ToolResponse_alias_1 }
 
 declare type ToolResponseResult = {
     type: 'text';
@@ -1546,14 +1396,6 @@ declare type ToolResponseResultMedia = {
 export { ToolResponseResultMedia }
 export { ToolResponseResultMedia as ToolResponseResultMedia_alias_1 }
 
-declare enum ToolResponseType {
-    Reply = "Reply",
-    Exit = "Exit",
-    Error = "Error"
-}
-export { ToolResponseType }
-export { ToolResponseType as ToolResponseType_alias_1 }
-
 declare type ToolSignature<I, O> = {
     input: I;
     output: O;
@@ -1660,6 +1502,22 @@ declare class UsageMeter {
 export { UsageMeter }
 export { UsageMeter as UsageMeter_alias_1 }
 
+/**
+ * Validates the code syntax for all steps in a workflow.
+ */
+declare function validateWorkflowCodeSyntax(workflow: WorkflowFile): WorkflowValidationResult;
+export { validateWorkflowCodeSyntax }
+export { validateWorkflowCodeSyntax as validateWorkflowCodeSyntax_alias_1 }
+export { validateWorkflowCodeSyntax as validateWorkflowCodeSyntax_alias_2 }
+
+/**
+ * Validates a workflow definition for structural correctness.
+ */
+declare function validateWorkflowDefinition(workflow: WorkflowFile): WorkflowValidationResult;
+export { validateWorkflowDefinition }
+export { validateWorkflowDefinition as validateWorkflowDefinition_alias_1 }
+export { validateWorkflowDefinition as validateWorkflowDefinition_alias_2 }
+
 declare type WebProvider = {
     fetchUrl?: (url: string) => Promise<string>;
     search?: (query: string) => Promise<string>;
@@ -1680,6 +1538,7 @@ export { WorkflowContext as WorkflowContext_alias_2 }
 declare type WorkflowDefinition = z.infer<typeof WorkflowDefinitionSchema>;
 export { WorkflowDefinition }
 export { WorkflowDefinition as WorkflowDefinition_alias_1 }
+export { WorkflowDefinition as WorkflowDefinition_alias_2 }
 
 declare const WorkflowDefinitionSchema: z.ZodObject<{
     task: z.ZodString;
@@ -1702,10 +1561,12 @@ declare const WorkflowDefinitionSchema: z.ZodObject<{
 }, z.core.$strip>;
 export { WorkflowDefinitionSchema }
 export { WorkflowDefinitionSchema as WorkflowDefinitionSchema_alias_1 }
+export { WorkflowDefinitionSchema as WorkflowDefinitionSchema_alias_2 }
 
 declare type WorkflowFile = z.infer<typeof WorkflowFileSchema>;
 export { WorkflowFile }
 export { WorkflowFile as WorkflowFile_alias_1 }
+export { WorkflowFile as WorkflowFile_alias_2 }
 
 declare const WorkflowFileSchema: z.ZodObject<{
     workflows: z.ZodRecord<z.ZodString, z.ZodObject<{
@@ -1730,6 +1591,7 @@ declare const WorkflowFileSchema: z.ZodObject<{
 }, z.core.$strip>;
 export { WorkflowFileSchema }
 export { WorkflowFileSchema as WorkflowFileSchema_alias_1 }
+export { WorkflowFileSchema as WorkflowFileSchema_alias_2 }
 
 declare type WorkflowFn<TInput, TOutput, TTools extends ToolRegistry> = (input: TInput, context: WorkflowContext<TTools>) => Promise<TOutput>;
 export { WorkflowFn }
@@ -1739,6 +1601,7 @@ export { WorkflowFn as WorkflowFn_alias_2 }
 declare type WorkflowInputDefinition = z.infer<typeof WorkflowInputDefinitionSchema>;
 export { WorkflowInputDefinition }
 export { WorkflowInputDefinition as WorkflowInputDefinition_alias_1 }
+export { WorkflowInputDefinition as WorkflowInputDefinition_alias_2 }
 
 declare const WorkflowInputDefinitionSchema: z.ZodObject<{
     id: z.ZodString;
@@ -1747,10 +1610,12 @@ declare const WorkflowInputDefinitionSchema: z.ZodObject<{
 }, z.core.$strip>;
 export { WorkflowInputDefinitionSchema }
 export { WorkflowInputDefinitionSchema as WorkflowInputDefinitionSchema_alias_1 }
+export { WorkflowInputDefinitionSchema as WorkflowInputDefinitionSchema_alias_2 }
 
 declare type WorkflowStepDefinition = z.infer<typeof WorkflowStepDefinitionSchema>;
 export { WorkflowStepDefinition }
 export { WorkflowStepDefinition as WorkflowStepDefinition_alias_1 }
+export { WorkflowStepDefinition as WorkflowStepDefinition_alias_2 }
 
 declare const WorkflowStepDefinitionSchema: z.ZodObject<{
     id: z.ZodString;
@@ -1764,6 +1629,7 @@ declare const WorkflowStepDefinitionSchema: z.ZodObject<{
 }, z.core.$strip>;
 export { WorkflowStepDefinitionSchema }
 export { WorkflowStepDefinitionSchema as WorkflowStepDefinitionSchema_alias_1 }
+export { WorkflowStepDefinitionSchema as WorkflowStepDefinitionSchema_alias_2 }
 
 declare type WorkflowTools<TTools extends ToolRegistry> = {
     [K in keyof TTools]: (input: TTools[K]['input']) => Promise<TTools[K]['output']>;
@@ -1772,4 +1638,12 @@ export { WorkflowTools }
 export { WorkflowTools as WorkflowTools_alias_1 }
 export { WorkflowTools as WorkflowTools_alias_2 }
 
+declare type WorkflowValidationResult = {
+    valid: boolean;
+    errors: string[];
+};
+export { WorkflowValidationResult }
+export { WorkflowValidationResult as WorkflowValidationResult_alias_1 }
+export { WorkflowValidationResult as WorkflowValidationResult_alias_2 }
+
 export { }