@polka-codes/core 0.9.83 → 0.9.84

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

@@ -0,0 +1,2303 @@
+import type { FilePart } from 'ai';
+import type { ImagePart } from 'ai';
+import type { JSONValue } from '@ai-sdk/provider';
+import type { LanguageModelV2 } from '@ai-sdk/provider';
+import type { LanguageModelV2ToolResultOutput } from '@ai-sdk/provider';
+import type { LanguageModelV2Usage } from '@ai-sdk/provider';
+import type { ModelMessage } from '@ai-sdk/provider-utils';
+import type { ProviderOptions } from '@ai-sdk/provider-utils';
+import type { ReasoningPart } from '@ai-sdk/provider-utils';
+import type { SystemModelMessage } from '@ai-sdk/provider-utils';
+import type { TextPart } from 'ai';
+import type { TextPart as TextPart_2 } from '@ai-sdk/provider-utils';
+import type { ToolModelMessage } from '@ai-sdk/provider-utils';
+import type { ToolResultPart } from '@ai-sdk/provider-utils';
+import { ToolSet } from 'ai';
+import { z } from 'zod';
+
+declare type AgentToolRegistry = {
+    generateText: {
+        input: {
+            messages: JsonModelMessage[];
+            tools: ToolSet;
+            model?: string;
+        };
+        output: JsonResponseMessage[];
+    };
+    taskEvent: {
+        input: TaskEvent;
+        output: void;
+    };
+    invokeTool: {
+        input: {
+            toolName: string;
+            input: any;
+        };
+        output: ToolResponse;
+    };
+};
+export { AgentToolRegistry }
+export { AgentToolRegistry as AgentToolRegistry_alias_1 }
+export { AgentToolRegistry as AgentToolRegistry_alias_2 }
+
+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<FullToolInfo[]>;
+    maxToolRoundTrips?: number;
+    userMessage: readonly JsonUserModelMessage[];
+    outputSchema?: z.ZodSchema;
+    model?: string;
+} & ({
+    messages: JsonModelMessage[];
+} | {
+    systemPrompt: string;
+});
+export { AgentWorkflowInput }
+export { AgentWorkflowInput as AgentWorkflowInput_alias_1 }
+export { AgentWorkflowInput as AgentWorkflowInput_alias_2 }
+
+declare type BreakStep = z.infer<typeof BreakStepSchema>;
+export { BreakStep }
+export { BreakStep as BreakStep_alias_1 }
+export { BreakStep as BreakStep_alias_2 }
+
+/**
+ * Break statement - exits the nearest enclosing loop
+ */
+declare const BreakStepSchema: z.ZodObject<{
+    break: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export { BreakStepSchema }
+export { BreakStepSchema as BreakStepSchema_alias_1 }
+export { BreakStepSchema as BreakStepSchema_alias_2 }
+
+declare type CommandProvider = {
+    executeCommand?: (command: string, needApprove: boolean) => Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+        summary?: string;
+    }>;
+};
+export { CommandProvider }
+export { CommandProvider as CommandProvider_alias_1 }
+export { CommandProvider as CommandProvider_alias_2 }
+
+/**
+ * Utility to compute exponential backoff delays for rate-limit handling. generated by polka.codes
+ *
+ * The backoff starts at baseSeconds and doubles each time, capped at capSeconds.
+ * Example with base=2, cap=60: 2, 4, 8, 16, 32, 60, 60, ...
+ */
+declare function computeRateLimitBackoffSeconds(count: number, baseSeconds?: number, capSeconds?: number): number;
+export { computeRateLimitBackoffSeconds }
+export { computeRateLimitBackoffSeconds as computeRateLimitBackoffSeconds_alias_1 }
+
+declare type Config = NonNullable<z.infer<typeof configSchema>>;
+export { Config }
+export { Config as Config_alias_1 }
+
+declare type ConfigRule = z.infer<typeof ruleSchema>;
+export { ConfigRule }
+export { ConfigRule as ConfigRule_alias_1 }
+
+declare const configSchema: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    prices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+        inputPrice: z.ZodOptional<z.ZodNumber>;
+        outputPrice: z.ZodOptional<z.ZodNumber>;
+        cacheWritesPrice: z.ZodOptional<z.ZodNumber>;
+        cacheReadsPrice: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>>;
+    providers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        apiKey: z.ZodOptional<z.ZodString>;
+        defaultModel: z.ZodOptional<z.ZodString>;
+        defaultParameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        location: z.ZodOptional<z.ZodString>;
+        project: z.ZodOptional<z.ZodString>;
+        keyFile: z.ZodOptional<z.ZodString>;
+        baseUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    defaultProvider: z.ZodOptional<z.ZodString>;
+    defaultModel: z.ZodOptional<z.ZodString>;
+    defaultParameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    maxMessageCount: z.ZodOptional<z.ZodNumber>;
+    budget: z.ZodOptional<z.ZodNumber>;
+    retryCount: z.ZodOptional<z.ZodNumber>;
+    requestTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    summaryThreshold: z.ZodOptional<z.ZodNumber>;
+    scripts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        workflow: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strict>, z.ZodObject<{
+        script: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        permissions: z.ZodOptional<z.ZodObject<{
+            fs: z.ZodOptional<z.ZodEnum<{
+                read: "read";
+                write: "write";
+                none: "none";
+            }>>;
+            network: z.ZodOptional<z.ZodBoolean>;
+            subprocess: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>;
+        timeout: z.ZodOptional<z.ZodNumber>;
+        memory: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>]>>>;
+    commands: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        provider: z.ZodOptional<z.ZodString>;
+        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<{
+            provider: z.ZodOptional<z.ZodString>;
+            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>>;
+    mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+            provider: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strict>]>>>;
+    }, z.core.$strict>>>;
+    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]>>;
+    excludeFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>>>;
+export { configSchema }
+export { configSchema as configSchema_alias_1 }
+
+declare type ContinueStep = z.infer<typeof ContinueStepSchema>;
+export { ContinueStep }
+export { ContinueStep as ContinueStep_alias_1 }
+export { ContinueStep as ContinueStep_alias_2 }
+
+/**
+ * Continue statement - skips to next iteration of nearest enclosing loop
+ */
+declare const ContinueStepSchema: z.ZodObject<{
+    continue: z.ZodLiteral<true>;
+}, z.core.$strip>;
+export { ContinueStepSchema }
+export { ContinueStepSchema as ContinueStepSchema_alias_1 }
+export { ContinueStepSchema as ContinueStepSchema_alias_2 }
+
+declare function createContext<TTools extends ToolRegistry>(tools: WorkflowTools<TTools>, stepFn?: StepFn, logger?: Logger): WorkflowContext<TTools>;
+export { createContext }
+export { createContext as createContext_alias_1 }
+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 }
+
+/**
+ * Create a file content XML element
+ */
+export declare function createFileElement(tagName: string, path: string, content?: string, attrs?: Record<string, string>): string;
+
+/**
+ * Create a standardized error response for provider method not available
+ */
+export declare function createProviderError(action: string): ToolResponse;
+
+declare const _default: {
+    handler: ToolHandler<{
+        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.";
+        readonly parameters: z.ZodObject<{
+            questions: z.ZodArray<z.ZodObject<{
+                prompt: z.ZodString;
+                options: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, InteractionProvider>;
+    name: "askFollowupQuestion";
+    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.";
+    parameters: z.ZodObject<{
+        questions: z.ZodArray<z.ZodObject<{
+            prompt: z.ZodString;
+            options: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+};
+export { _default as askFollowupQuestion }
+export { _default as askFollowupQuestion_alias_1 }
+export { _default as default_alias }
+
+declare const _default_10: {
+    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.";
+        readonly parameters: z.ZodObject<{
+            query: z.ZodString;
+        }, z.core.$strip>;
+    }, WebProvider>;
+    name: "search";
+    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.";
+    parameters: z.ZodObject<{
+        query: z.ZodString;
+    }, z.core.$strip>;
+};
+export { _default_10 as default_alias_9 }
+export { _default_10 as search }
+export { _default_10 as search_alias_1 }
+
+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.";
+        readonly parameters: z.ZodObject<{
+            path: z.ZodString;
+            regex: z.ZodString;
+            filePattern: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, FilesystemProvider>;
+    name: "searchFiles";
+    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.";
+    parameters: z.ZodObject<{
+        path: z.ZodString;
+        regex: z.ZodString;
+        filePattern: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+};
+export { _default_11 as default_alias_10 }
+export { _default_11 as searchFiles }
+export { _default_11 as searchFiles_alias_1 }
+
+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.";
+        readonly parameters: z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+        }, z.core.$strip>;
+    }, FilesystemProvider>;
+    name: "writeToFile";
+    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.";
+    parameters: z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>;
+};
+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<{
+        readonly name: "executeCommand";
+        readonly description: "Run a single CLI command. The command is always executed in the project-root working directory (regardless of earlier commands). Prefer one-off shell commands over wrapper scripts for flexibility. **IMPORTANT**: After an `execute_command` call, you MUST stop and NOT allowed to make further tool calls in the same message.";
+        readonly parameters: z.ZodObject<{
+            command: z.ZodString;
+            requiresApproval: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
+        }, z.core.$strip>;
+    }, CommandProvider>;
+    name: "executeCommand";
+    description: "Run a single CLI command. The command is always executed in the project-root working directory (regardless of earlier commands). Prefer one-off shell commands over wrapper scripts for flexibility. **IMPORTANT**: After an `execute_command` call, you MUST stop and NOT allowed to make further tool calls in the same message.";
+    parameters: z.ZodObject<{
+        command: z.ZodString;
+        requiresApproval: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
+    }, z.core.$strip>;
+};
+export { _default_2 as default_alias_1 }
+export { _default_2 as executeCommand }
+export { _default_2 as executeCommand_alias_1 }
+
+declare const _default_3: {
+    handler: ToolHandler<{
+        readonly name: "fetchUrl";
+        readonly description: "Fetch the content located at one or more HTTP(S) URLs and return it in Markdown format. This works for standard web pages as well as raw files (e.g. README.md, source code) hosted on platforms like GitHub.";
+        readonly parameters: z.ZodObject<{
+            url: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    }, WebProvider>;
+    name: "fetchUrl";
+    description: "Fetch the content located at one or more HTTP(S) URLs and return it in Markdown format. This works for standard web pages as well as raw files (e.g. README.md, source code) hosted on platforms like GitHub.";
+    parameters: z.ZodObject<{
+        url: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+};
+export { _default_3 as default_alias_2 }
+export { _default_3 as fetchUrl }
+export { _default_3 as fetchUrl_alias_1 }
+
+declare const _default_4: {
+    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.";
+        readonly parameters: z.ZodObject<{
+            path: z.ZodString;
+            maxCount: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+            recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
+            includeIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
+        }, z.core.$strip>;
+    }, FilesystemProvider>;
+    name: "listFiles";
+    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.";
+    parameters: z.ZodObject<{
+        path: z.ZodString;
+        maxCount: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+        recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
+        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 readBinaryFile }
+export { _default_5 as readBinaryFile_alias_1 }
+
+declare const _default_6: {
+    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 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 readFile }
+export { _default_6 as readFile_alias_1 }
+
+declare const _default_7: {
+    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_7 as default_alias_6 }
+export { _default_7 as removeFile }
+export { _default_7 as removeFile_alias_1 }
+
+declare const _default_8: {
+    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_8 as default_alias_7 }
+export { _default_8 as renameFile }
+export { _default_8 as renameFile_alias_1 }
+
+declare const _default_9: {
+    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_9 as default_alias_8 }
+export { _default_9 as replaceInFile }
+export { _default_9 as replaceInFile_alias_1 }
+
+/**
+ * Represents a directory entry
+ */
+declare interface DirectoryEntry {
+    name: string;
+    isDirectory: boolean;
+    isFile: boolean;
+}
+export { DirectoryEntry }
+export { DirectoryEntry as DirectoryEntry_alias_1 }
+export { DirectoryEntry as DirectoryEntry_alias_2 }
+
+/**
+ * Returns the directory portion of a path string.
+ * Strips trailing slashes, then takes everything up to the last slash.
+ */
+export declare function dirname(path: string): string;
+
+declare type DynamicStepRuntimeContext<TTools extends ToolRegistry> = {
+    workflowId: string;
+    stepId: string;
+    input: Record<string, any>;
+    state: Record<string, any>;
+    tools: WorkflowTools<TTools>;
+    logger: Logger;
+    step: StepFn;
+    runWorkflow: (workflowId: string, input?: Record<string, any>) => Promise<any>;
+    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;
+    definition: WorkflowFile;
+} | {
+    success: false;
+    error: string;
+};
+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<FullToolInfo[]>;
+    /**
+     * Model id forwarded to `agentWorkflow` for agent-executed steps.
+     */
+    model?: string;
+    /**
+     * Maximum round trips for agent-executed steps.
+     */
+    maxToolRoundTrips?: number;
+    /**
+     * Customize per-step system prompt for agent-executed steps.
+     */
+    stepSystemPrompt?: (args: {
+        workflowId: string;
+        step: WorkflowStepDefinition;
+        input: any;
+        state: any;
+    }) => string;
+    /**
+     * Whether to wrap plain text agent responses in an object { result: ... }.
+     * Defaults to false.
+     */
+    wrapAgentResultInObject?: boolean;
+    /**
+     * Built-in workflows that can be called by name if not found in the definition.
+     */
+    builtInWorkflows?: Record<string, WorkflowFn<any, any, any>>;
+    /**
+     * Allow unsafe code execution in condition expressions.
+     * When false (default), only simple comparisons and property access are allowed.
+     * When true, arbitrary JavaScript code can be executed in conditions.
+     * WARNING: Setting to true with untrusted workflow definitions is a security risk.
+     * @default false
+     */
+    allowUnsafeCodeExecution?: boolean;
+};
+export { DynamicWorkflowRunnerOptions }
+export { DynamicWorkflowRunnerOptions as DynamicWorkflowRunnerOptions_alias_1 }
+export { DynamicWorkflowRunnerOptions as DynamicWorkflowRunnerOptions_alias_2 }
+
+declare type ExitReason = {
+    type: 'UsageExceeded';
+    messages: JsonModelMessage[];
+} | {
+    type: 'Exit';
+    message: string;
+    object?: any;
+    messages: JsonModelMessage[];
+} | {
+    type: 'Error';
+    error: {
+        message: string;
+        stack?: string;
+    };
+    messages: JsonModelMessage[];
+};
+export { ExitReason }
+export { ExitReason as ExitReason_alias_1 }
+export { ExitReason as ExitReason_alias_2 }
+
+/**
+ * File statistics
+ */
+declare interface FileStats {
+    size: number;
+    isDirectory: boolean;
+    isFile: boolean;
+}
+export { FileStats }
+export { FileStats as FileStats_alias_1 }
+export { FileStats as FileStats_alias_2 }
+
+/**
+ * File system provider interface for abstracting file operations.
+ * This allows the core package to run in different environments:
+ * - Node.js (local filesystem)
+ * - Cloudflare edge runtime (remote storage, KV, R2, etc.)
+ */
+declare interface FileSystemProvider {
+    /**
+     * Check if a path exists
+     */
+    exists(path: string): Promise<boolean> | boolean;
+    /**
+     * Read a directory and return entries
+     */
+    readdir(path: string): Promise<DirectoryEntry[]>;
+    /**
+     * Read file content as text
+     */
+    readFile(path: string): Promise<string>;
+    /**
+     * Read file content as a buffer
+     */
+    readFileAsBuffer(path: string): Promise<Uint8Array>;
+    /**
+     * Get file statistics
+     */
+    stat(path: string): Promise<FileStats>;
+    /**
+     * Join path segments
+     */
+    join(...paths: string[]): string;
+    /**
+     * Normalize a path
+     */
+    normalize(path: string): string;
+}
+export { FileSystemProvider }
+export { FileSystemProvider as FileSystemProvider_alias_1 }
+export { FileSystemProvider as FileSystemProvider_alias_2 }
+
+declare type FilesystemProvider = {
+    readFile?: (path: string, includeIgnored: boolean) => Promise<string | undefined>;
+    writeFile?: (path: string, content: string) => Promise<void>;
+    removeFile?: (path: string) => Promise<void>;
+    renameFile?: (sourcePath: string, targetPath: string) => Promise<void>;
+    listFiles?: (path: string, recursive: boolean, maxCount: number, includeIgnored: boolean) => Promise<[string[], boolean]>;
+    searchFiles?: (path: string, regex: string, filePattern: string) => Promise<string[]>;
+    readBinaryFile?: (url: string) => Promise<{
+        base64Data: string;
+        mediaType: string;
+    }>;
+};
+export { FilesystemProvider }
+export { FilesystemProvider as FilesystemProvider_alias_1 }
+export { FilesystemProvider as FilesystemProvider_alias_2 }
+
+/**
+ * Options for configuring the file system provider
+ */
+declare interface FileSystemProviderOptions {
+    /**
+     * Base directory for relative paths
+     */
+    baseDir?: string;
+}
+export { FileSystemProviderOptions }
+export { FileSystemProviderOptions as FileSystemProviderOptions_alias_1 }
+export { FileSystemProviderOptions as FileSystemProviderOptions_alias_2 }
+
+declare const fromJsonModelMessage: (msg: JsonModelMessage) => ModelMessage;
+export { fromJsonModelMessage }
+export { fromJsonModelMessage as fromJsonModelMessage_alias_1 }
+export { fromJsonModelMessage as fromJsonModelMessage_alias_2 }
+
+declare type FullToolInfo = ToolInfo & {
+    handler: ToolHandler<ToolInfo, any>;
+};
+export { FullToolInfo }
+export { FullToolInfo as FullToolInfo_alias_1 }
+
+/**
+ * Get file statistics for a skill
+ */
+declare function getSkillStats(skill: Skill): {
+    totalSize: number;
+    fileCount: number;
+    largestFile: {
+        name: string;
+        size: number;
+    };
+};
+export { getSkillStats }
+export { getSkillStats as getSkillStats_alias_1 }
+export { getSkillStats as getSkillStats_alias_2 }
+
+declare type GetTodoItemOutput = TodoItem & {
+    subItems: {
+        id: string;
+        title: string;
+    }[];
+};
+export { GetTodoItemOutput }
+export { GetTodoItemOutput as GetTodoItemOutput_alias_1 }
+export { GetTodoItemOutput as GetTodoItemOutput_alias_2 }
+
+export declare const handler: ToolHandler<typeof toolInfo, InteractionProvider>;
+
+export declare const handler_alias_1: ToolHandler<typeof toolInfo_alias_1, CommandProvider>;
+
+export declare const handler_alias_10: ToolHandler<typeof toolInfo_alias_10, FilesystemProvider>;
+
+export declare const handler_alias_11: ToolHandler<typeof toolInfo_alias_11, FilesystemProvider>;
+
+export declare const handler_alias_2: ToolHandler<typeof toolInfo_alias_2, WebProvider>;
+
+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, FilesystemProvider>;
+
+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, WebProvider>;
+
+declare type IfElseStep = z.infer<typeof IfElseStepSchema>;
+export { IfElseStep }
+export { IfElseStep as IfElseStep_alias_1 }
+export { IfElseStep as IfElseStep_alias_2 }
+
+/**
+ * If/else branch - conditionally executes steps
+ */
+declare const IfElseStepSchema: any;
+export { IfElseStepSchema }
+export { IfElseStepSchema as IfElseStepSchema_alias_1 }
+export { IfElseStepSchema as IfElseStepSchema_alias_2 }
+
+declare const IGNORED_DIRECTORIES: readonly [".git", "node_modules", ".next", ".turbo", "dist", "build", "coverage", ".cache", ".vscode", ".idea", "tmp", "temp", ".DS_Store"];
+export { IGNORED_DIRECTORIES }
+export { IGNORED_DIRECTORIES as IGNORED_DIRECTORIES_alias_1 }
+export { IGNORED_DIRECTORIES as IGNORED_DIRECTORIES_alias_2 }
+
+declare type InteractionProvider = {
+    askFollowupQuestion?: (question: string, options: string[]) => Promise<string>;
+};
+export { InteractionProvider }
+export { InteractionProvider as InteractionProvider_alias_1 }
+export { InteractionProvider as InteractionProvider_alias_2 }
+
+/**
+ * Joins all given path segments, then normalizes the result.
+ */
+export declare function join(...parts: string[]): string;
+
+/**
+ Content of an assistant message.
+ It can be a string or an array of text, image, reasoning, redacted reasoning, and tool call parts.
+ */
+declare type JsonAssistantContent = string | Array<TextPart_2 | JsonFilePart | ReasoningPart | JsonToolCallPart | ToolResultPart>;
+
+/**
+ An assistant message. It can contain text, tool calls, or a combination of text and tool calls.
+ */
+declare type JsonAssistantModelMessage = {
+    role: 'assistant';
+    content: JsonAssistantContent;
+    /**
+     Additional provider-specific metadata. They are passed through
+     to the provider from the AI SDK and enable provider-specific
+     functionality that can be fully encapsulated in the provider.
+     */
+    providerOptions?: ProviderOptions;
+};
+
+declare type JsonDataContent = {
+    type: 'base64' | 'url';
+    value: string;
+};
+
+/**
+ File content part of a prompt. It contains a file.
+ */
+declare interface JsonFilePart {
+    type: 'file';
+    /**
+     File data. Can either be:
+
+     - data: a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer
+     - URL: a URL that points to the image
+     */
+    data: JsonDataContent;
+    /**
+     Optional filename of the file.
+     */
+    filename?: string;
+    /**
+     IANA media type of the file.
+
+     @see https://www.iana.org/assignments/media-types/media-types.xhtml
+     */
+    mediaType: string;
+    /**
+     Additional provider-specific metadata. They are passed through
+     to the provider from the AI SDK and enable provider-specific
+     functionality that can be fully encapsulated in the provider.
+     */
+    providerOptions?: ProviderOptions;
+}
+export { JsonFilePart }
+export { JsonFilePart as JsonFilePart_alias_1 }
+export { JsonFilePart as JsonFilePart_alias_2 }
+
+declare interface JsonImagePart {
+    type: 'image';
+    /**
+     Image data. Can either be:
+
+     - data: a base64-encoded string, a Uint8Array, an ArrayBuffer, or a Buffer
+     - URL: a URL that points to the image
+     */
+    image: JsonDataContent;
+    /**
+     Optional IANA media type of the image.
+
+     @see https://www.iana.org/assignments/media-types/media-types.xhtml
+     */
+    mediaType?: string;
+    /**
+     Additional provider-specific metadata. They are passed through
+     to the provider from the AI SDK and enable provider-specific
+     functionality that can be fully encapsulated in the provider.
+     */
+    providerOptions?: ProviderOptions;
+}
+export { JsonImagePart }
+export { JsonImagePart as JsonImagePart_alias_1 }
+export { JsonImagePart as JsonImagePart_alias_2 }
+
+declare type JsonModelMessage = SystemModelMessage | JsonUserModelMessage | JsonAssistantModelMessage | ToolModelMessage;
+export { JsonModelMessage }
+export { JsonModelMessage as JsonModelMessage_alias_1 }
+export { JsonModelMessage as JsonModelMessage_alias_2 }
+
+declare type JsonResponseMessage = JsonAssistantModelMessage | ToolModelMessage;
+export { JsonResponseMessage }
+export { JsonResponseMessage as JsonResponseMessage_alias_1 }
+export { JsonResponseMessage as JsonResponseMessage_alias_2 }
+
+declare interface JsonToolCallPart {
+    type: 'tool-call';
+    /**
+     ID of the tool call. This ID is used to match the tool call with the tool result.
+     */
+    toolCallId: string;
+    /**
+     Name of the tool that is being called.
+     */
+    toolName: string;
+    /**
+     Arguments of the tool call. This is a JSON-serializable object that matches the tool's input schema.
+     */
+    input: JSONValue;
+    /**
+     Additional provider-specific metadata. They are passed through
+     to the provider from the AI SDK and enable provider-specific
+     functionality that can be fully encapsulated in the provider.
+     */
+    providerOptions?: ProviderOptions;
+    /**
+     Whether the tool call was executed by the provider.
+     */
+    providerExecuted?: boolean;
+}
+
+/**
+ Content of a user message. It can be a string or an array of text and image parts.
+ */
+declare type JsonUserContent = string | Array<TextPart_2 | JsonImagePart | JsonFilePart>;
+export { JsonUserContent }
+export { JsonUserContent as JsonUserContent_alias_1 }
+export { JsonUserContent as JsonUserContent_alias_2 }
+
+/**
+ A user message. It can contain text or a combination of text and images.
+ */
+declare type JsonUserModelMessage = {
+    role: 'user';
+    content: JsonUserContent;
+    /**
+     Additional provider-specific metadata. They are passed through
+     to the provider from the AI SDK and enable provider-specific
+     functionality that can be fully encapsulated in the provider.
+     */
+    providerOptions?: ProviderOptions;
+};
+export { JsonUserModelMessage }
+export { JsonUserModelMessage as JsonUserModelMessage_alias_1 }
+export { JsonUserModelMessage as JsonUserModelMessage_alias_2 }
+
+/**
+ * List all available skills with their descriptions
+ *
+ * This tool enables agents to discover what specialized capabilities
+ * are available based on task context.
+ */
+declare function listSkills(input: ListSkillsInput, context: SkillContext): Promise<ListSkillsOutput>;
+export { listSkills }
+export { listSkills as listSkills_alias_1 }
+export { listSkills as listSkills_alias_2 }
+
+declare type ListSkillsInput = z.infer<typeof ListSkillsInputSchema>;
+export { ListSkillsInput }
+export { ListSkillsInput as ListSkillsInput_alias_1 }
+export { ListSkillsInput as ListSkillsInput_alias_2 }
+
+/**
+ * Tool input parameters for listing skills
+ */
+declare const ListSkillsInputSchema: z.ZodObject<{
+    filter: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export { ListSkillsInputSchema }
+export { ListSkillsInputSchema as ListSkillsInputSchema_alias_1 }
+export { ListSkillsInputSchema as ListSkillsInputSchema_alias_2 }
+
+declare type ListSkillsOutput = z.infer<typeof ListSkillsOutputSchema>;
+export { ListSkillsOutput }
+export { ListSkillsOutput as ListSkillsOutput_alias_1 }
+export { ListSkillsOutput as ListSkillsOutput_alias_2 }
+
+/**
+ * Tool output for listing skills
+ */
+declare const ListSkillsOutputSchema: z.ZodObject<{
+    skills: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        source: z.ZodEnum<{
+            project: "project";
+            personal: "personal";
+            plugin: "plugin";
+        }>;
+    }, z.core.$strip>>;
+    total: z.ZodNumber;
+}, z.core.$strip>;
+export { ListSkillsOutputSchema }
+export { ListSkillsOutputSchema as ListSkillsOutputSchema_alias_1 }
+export { ListSkillsOutputSchema as ListSkillsOutputSchema_alias_2 }
+
+/**
+ * Tool info for listSkills (used in agent workflow)
+ */
+declare const listSkillsToolInfo: {
+    readonly name: "listSkills";
+    readonly description: "List all available skills with their descriptions. Use this to discover what specialized capabilities are available.";
+    readonly parameters: z.ZodObject<{
+        filter: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    readonly returns: z.ZodObject<{
+        skills: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            source: z.ZodEnum<{
+                project: "project";
+                personal: "personal";
+                plugin: "plugin";
+            }>;
+        }, z.core.$strip>>;
+        total: z.ZodNumber;
+    }, z.core.$strip>;
+};
+export { listSkillsToolInfo }
+export { listSkillsToolInfo as listSkillsToolInfo_alias_1 }
+export { listSkillsToolInfo as listSkillsToolInfo_alias_2 }
+
+declare type ListTodoItemsOutput = TodoItem[];
+export { ListTodoItemsOutput }
+export { ListTodoItemsOutput as ListTodoItemsOutput_alias_1 }
+export { ListTodoItemsOutput as ListTodoItemsOutput_alias_2 }
+
+/**
+ * Load a skill by name to access its instructions and resources
+ *
+ * This tool enables agents to autonomously load specialized knowledge
+ * and capabilities based on task context.
+ */
+declare function loadSkill(input: LoadSkillInput, context: SkillContext): Promise<LoadSkillOutput>;
+export { loadSkill }
+export { loadSkill as loadSkill_alias_1 }
+export { loadSkill as loadSkill_alias_2 }
+
+declare type LoadSkillInput = z.infer<typeof LoadSkillInputSchema>;
+export { LoadSkillInput }
+export { LoadSkillInput as LoadSkillInput_alias_1 }
+export { LoadSkillInput as LoadSkillInput_alias_2 }
+
+/**
+ * Tool input parameters for loading a skill
+ */
+declare const LoadSkillInputSchema: z.ZodObject<{
+    skillName: z.ZodString;
+}, z.core.$strip>;
+export { LoadSkillInputSchema }
+export { LoadSkillInputSchema as LoadSkillInputSchema_alias_1 }
+export { LoadSkillInputSchema as LoadSkillInputSchema_alias_2 }
+
+declare type LoadSkillOutput = z.infer<typeof LoadSkillOutputSchema>;
+export { LoadSkillOutput }
+export { LoadSkillOutput as LoadSkillOutput_alias_1 }
+export { LoadSkillOutput as LoadSkillOutput_alias_2 }
+
+/**
+ * Tool output for loading a skill
+ */
+declare const LoadSkillOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    skill: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        content: z.ZodString;
+        availableFiles: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+    warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export { LoadSkillOutputSchema }
+export { LoadSkillOutputSchema as LoadSkillOutputSchema_alias_1 }
+export { LoadSkillOutputSchema as LoadSkillOutputSchema_alias_2 }
+
+/**
+ * Tool info for loadSkill (used in agent workflow)
+ */
+declare const loadSkillToolInfo: {
+    readonly name: "loadSkill";
+    readonly description: "Load a skill by name to access its instructions and resources. Use this when you need specialized knowledge or capabilities for a specific task.";
+    readonly parameters: z.ZodObject<{
+        skillName: z.ZodString;
+    }, z.core.$strip>;
+    readonly returns: z.ZodObject<{
+        success: z.ZodBoolean;
+        skill: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            content: z.ZodString;
+            availableFiles: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+        error: z.ZodOptional<z.ZodString>;
+        warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+};
+export { loadSkillToolInfo }
+export { loadSkillToolInfo as loadSkillToolInfo_alias_1 }
+export { loadSkillToolInfo as loadSkillToolInfo_alias_2 }
+
+declare interface Logger {
+    debug: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+}
+export { Logger }
+export { Logger as Logger_alias_1 }
+export { Logger as Logger_alias_2 }
+
+declare const makeStepFn: () => StepFn;
+export { makeStepFn }
+export { makeStepFn as makeStepFn_alias_1 }
+export { makeStepFn as makeStepFn_alias_2 }
+
+declare type McpServerConfig = z.infer<typeof mcpServerConfigSchema>;
+export { McpServerConfig }
+export { McpServerConfig as McpServerConfig_alias_1 }
+
+declare const mcpServerConfigSchema: z.ZodObject<{
+    command: z.ZodString;
+    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    tools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+        provider: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>]>>>;
+}, z.core.$strict>;
+export { mcpServerConfigSchema }
+export { mcpServerConfigSchema as mcpServerConfigSchema_alias_1 }
+
+declare interface MemoryProvider {
+    listMemoryTopics: () => Promise<string[]>;
+    readMemory: (topic?: string) => Promise<string | undefined>;
+    updateMemory: (operation: 'append' | 'replace' | 'remove', topic: string | undefined, content: string | undefined) => Promise<void>;
+}
+export { MemoryProvider }
+export { MemoryProvider as MemoryProvider_alias_1 }
+export { MemoryProvider as MemoryProvider_alias_2 }
+
+declare class MockProvider implements ToolProvider {
+    listTodoItems(id?: string | null, _status?: string | null): Promise<{
+        id: string;
+        title: string;
+        status: "open";
+        description: string;
+    }[]>;
+    getTodoItem(id: string): Promise<GetTodoItemOutput | undefined>;
+    updateTodoItem(input: UpdateTodoItemInput): Promise<{
+        id: string;
+    }>;
+    readFile(_path: string, _includeIgnored?: boolean): Promise<string>;
+    writeFile(_path: string, _content: string): Promise<void>;
+    removeFile(_path: string): Promise<void>;
+    renameFile(_sourcePath: string, _targetPath: string): Promise<void>;
+    listFiles(_path: string, _recursive: boolean, _maxCount: number, _includeIgnored?: boolean): Promise<[string[], boolean]>;
+    searchFiles(_path: string, _regex: string, _filePattern: string): Promise<string[]>;
+    executeCommand(_command: string, _needApprove: boolean): Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+        summary?: string;
+    }>;
+    askFollowupQuestion(_question: string, _options?: string[]): Promise<string>;
+    search(_query: string): Promise<string>;
+    listMemoryTopics(): Promise<string[]>;
+    readMemory(_topic?: string): Promise<string | undefined>;
+    updateMemory(_operation: 'append' | 'replace' | 'remove', _topic?: string, _content?: string): Promise<void>;
+}
+export { MockProvider }
+export { MockProvider as MockProvider_alias_1 }
+export { MockProvider as MockProvider_alias_2 }
+
+declare type ModelInfo = {
+    inputPrice: number;
+    outputPrice: number;
+    cacheWritesPrice: number;
+    cacheReadsPrice: number;
+};
+export { ModelInfo }
+export { ModelInfo as ModelInfo_alias_1 }
+
+/**
+ * Node.js file system provider implementation
+ * Uses the node:fs module for file operations
+ */
+declare class NodeFileSystemProvider implements FileSystemProvider {
+    readonly _options: FileSystemProviderOptions;
+    constructor(_options?: FileSystemProviderOptions);
+    exists(path: string): boolean;
+    readdir(path: string): Promise<DirectoryEntry[]>;
+    readFile(path: string): Promise<string>;
+    readFileAsBuffer(path: string): Promise<Uint8Array>;
+    stat(path: string): Promise<FileStats>;
+    join(...paths: string[]): string;
+    normalize(path: string): string;
+}
+export { NodeFileSystemProvider }
+export { NodeFileSystemProvider as NodeFileSystemProvider_alias_1 }
+export { NodeFileSystemProvider as NodeFileSystemProvider_alias_2 }
+
+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 }
+export { parseJsonFromMarkdown as parseJsonFromMarkdown_alias_1 }
+export { parseJsonFromMarkdown as parseJsonFromMarkdown_alias_2 }
+
+declare type ParseOutputResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error?: string;
+};
+export { ParseOutputResult }
+export { ParseOutputResult as ParseOutputResult_alias_1 }
+export { ParseOutputResult as ParseOutputResult_alias_2 }
+
+/**
+ * Simplify boolean string preprocessing
+ * Converts 'true'/'false' strings to actual booleans
+ */
+export declare function preprocessBoolean(val: unknown): unknown;
+
+declare type ProviderConfig = z.infer<typeof providerConfigSchema>;
+export { ProviderConfig }
+export { ProviderConfig as ProviderConfig_alias_1 }
+
+declare const providerConfigSchema: z.ZodObject<{
+    apiKey: z.ZodOptional<z.ZodString>;
+    defaultModel: z.ZodOptional<z.ZodString>;
+    defaultParameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    location: z.ZodOptional<z.ZodString>;
+    project: z.ZodOptional<z.ZodString>;
+    keyFile: z.ZodOptional<z.ZodString>;
+    baseUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export { providerConfigSchema }
+export { providerConfigSchema as providerConfigSchema_alias_1 }
+
+declare const providerModelSchema: z.ZodObject<{
+    provider: z.ZodOptional<z.ZodString>;
+    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 }
+
+/**
+ * Read a supporting file from a loaded skill
+ *
+ * This tool enables agents to access supporting files bundled with skills,
+ * such as reference documentation, examples, scripts, or templates.
+ * Files are returned as plain text content.
+ */
+declare function readSkillFile(input: ReadSkillFileInput, context: SkillContext): Promise<ReadSkillFileOutput>;
+export { readSkillFile }
+export { readSkillFile as readSkillFile_alias_1 }
+export { readSkillFile as readSkillFile_alias_2 }
+
+declare type ReadSkillFileInput = z.infer<typeof ReadSkillFileInputSchema>;
+export { ReadSkillFileInput }
+export { ReadSkillFileInput as ReadSkillFileInput_alias_1 }
+export { ReadSkillFileInput as ReadSkillFileInput_alias_2 }
+
+/**
+ * Tool input parameters for reading a skill file
+ */
+declare const ReadSkillFileInputSchema: z.ZodObject<{
+    skillName: z.ZodString;
+    filename: z.ZodString;
+}, z.core.$strip>;
+export { ReadSkillFileInputSchema }
+export { ReadSkillFileInputSchema as ReadSkillFileInputSchema_alias_1 }
+export { ReadSkillFileInputSchema as ReadSkillFileInputSchema_alias_2 }
+
+declare type ReadSkillFileOutput = z.infer<typeof ReadSkillFileOutputSchema>;
+export { ReadSkillFileOutput }
+export { ReadSkillFileOutput as ReadSkillFileOutput_alias_1 }
+export { ReadSkillFileOutput as ReadSkillFileOutput_alias_2 }
+
+/**
+ * Tool output for reading a skill file
+ */
+declare const ReadSkillFileOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    content: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export { ReadSkillFileOutputSchema }
+export { ReadSkillFileOutputSchema as ReadSkillFileOutputSchema_alias_1 }
+export { ReadSkillFileOutputSchema as ReadSkillFileOutputSchema_alias_2 }
+
+/**
+ * Tool info for readSkillFile (used in agent workflow)
+ */
+declare const readSkillFileToolInfo: {
+    readonly name: "readSkillFile";
+    readonly description: "Read a supporting file from a skill. Use this to access reference documentation, examples, scripts, or templates bundled with a skill. First use loadSkill to see available files, then use this tool to read specific files.";
+    readonly parameters: z.ZodObject<{
+        skillName: z.ZodString;
+        filename: z.ZodString;
+    }, z.core.$strip>;
+    readonly returns: z.ZodObject<{
+        success: z.ZodBoolean;
+        content: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+};
+export { readSkillFileToolInfo }
+export { readSkillFileToolInfo as readSkillFileToolInfo_alias_1 }
+export { readSkillFileToolInfo as readSkillFileToolInfo_alias_2 }
+
+declare const replaceInFile_2: (fileContent: string, diff: string) => ReplaceResult;
+export { replaceInFile_2 as replaceInFileHelper }
+export { replaceInFile_2 as replaceInFile_alias_2 }
+export { replaceInFile_2 as replaceInFile_alias_3 }
+
+declare type ReplaceResult = {
+    content: string;
+    status: 'no_diff_applied' | 'some_diff_applied' | 'all_diff_applied';
+    appliedCount: number;
+    totalCount: number;
+};
+export { ReplaceResult }
+export { ReplaceResult as ReplaceResult_alias_1 }
+
+declare const responsePrompts: {
+    readonly errorInvokeTool: (tool: string, error: unknown) => string;
+    readonly requireUseTool: "Error: No tool use detected. You MUST use a tool before proceeding.\ne.g. <tool_tool_name>tool_name</tool_tool_name>\n\nEnsure the opening and closing tags are correctly nested and closed, and that you are using the correct tool name.\nAvoid unnecessary text or symbols before or after the tool use.\nAvoid unnecessary escape characters or special characters.\n";
+    readonly requireUseToolNative: "Error: No tool use detected. You MUST use a tool before proceeding.\n";
+    readonly toolResults: (tool: string, result: LanguageModelV2ToolResultOutput) => Array<TextPart | ImagePart | FilePart>;
+    readonly commandResult: (command: string, exitCode: number, stdout: string, stderr: string) => string;
+};
+export { responsePrompts }
+export { responsePrompts as responsePrompts_alias_1 }
+export { responsePrompts as responsePrompts_alias_2 }
+
+declare const ruleSchema: 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>]>;
+export { ruleSchema }
+export { ruleSchema as ruleSchema_alias_1 }
+
+declare type RunWorkflowTool = {
+    input: {
+        workflowId: string;
+        input?: any;
+    };
+    output: any;
+};
+export { RunWorkflowTool }
+export { RunWorkflowTool as RunWorkflowTool_alias_1 }
+export { RunWorkflowTool as RunWorkflowTool_alias_2 }
+
+declare type ScriptConfig = z.infer<typeof scriptSchema>;
+export { ScriptConfig }
+export { ScriptConfig as ScriptConfig_alias_1 }
+
+declare const scriptSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    command: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    workflow: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    input: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strict>, z.ZodObject<{
+    script: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    permissions: z.ZodOptional<z.ZodObject<{
+        fs: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            write: "write";
+            none: "none";
+        }>>;
+        network: z.ZodOptional<z.ZodBoolean>;
+        subprocess: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    memory: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>]>;
+export { scriptSchema }
+export { scriptSchema as scriptSchema_alias_1 }
+
+/**
+ * Represents a loaded Agent Skill with all its content
+ */
+declare interface Skill extends SkillReference {
+    /**
+     * Main instructions content (SKILL.md without frontmatter)
+     */
+    content: string;
+    /**
+     * Additional files bundled with the skill
+     * Key is relative path from skill directory (e.g., "reference.md", "scripts/helper.py")
+     * Value is file content
+     */
+    files: Map<string, string>;
+}
+export { Skill }
+export { Skill as Skill_alias_1 }
+export { Skill as Skill_alias_2 }
+
+declare const SKILL_ERROR_MESSAGES: {
+    readonly MISSING_FRONTMATTER: "SKILL.md must begin with YAML frontmatter enclosed in ---";
+    readonly FRONTMATTER_INVALID: "Invalid frontmatter: {message}";
+    readonly SKILL_NOT_FOUND: "Skill not found";
+    readonly CONTEXT_NOT_INITIALIZED: "Skill context not initialized";
+};
+export { SKILL_ERROR_MESSAGES }
+export { SKILL_ERROR_MESSAGES as SKILL_ERROR_MESSAGES_alias_1 }
+export { SKILL_ERROR_MESSAGES as SKILL_ERROR_MESSAGES_alias_2 }
+
+/**
+ * Constants for Agent Skills system
+ */
+declare const SKILL_LIMITS: {
+    readonly MAX_FILE_SIZE: number;
+    readonly MAX_SKILL_SIZE: number;
+    readonly MAX_DEPTH: 10;
+    readonly MAX_FILES: 500;
+    readonly MIN_DESCRIPTION_LENGTH: 20;
+    readonly MAX_DESCRIPTION_LENGTH: 1024;
+    readonly MAX_NAME_LENGTH: 64;
+};
+export { SKILL_LIMITS }
+export { SKILL_LIMITS as SKILL_LIMITS_alias_1 }
+export { SKILL_LIMITS as SKILL_LIMITS_alias_2 }
+
+/**
+ * Context object passed to agents and tools for skill operations
+ */
+declare interface SkillContext {
+    /**
+     * Currently active/loaded skill (if any)
+     */
+    activeSkill: Skill | null;
+    /**
+     * All available skills discovered from all sources (metadata only)
+     */
+    availableSkills: SkillReference[];
+    /**
+     * History of skills loaded during the session (for debugging/telemetry)
+     */
+    skillLoadingHistory: string[];
+    /**
+     * Load a skill by name
+     */
+    loadSkill: (name: string) => Promise<Skill | null>;
+}
+export { SkillContext }
+export { SkillContext as SkillContext_alias_1 }
+export { SkillContext as SkillContext_alias_2 }
+
+/**
+ * Error thrown when skill discovery fails
+ */
+declare class SkillDiscoveryError extends Error {
+    path: string;
+    constructor(message: string, path: string);
+}
+export { SkillDiscoveryError }
+export { SkillDiscoveryError as SkillDiscoveryError_alias_1 }
+export { SkillDiscoveryError as SkillDiscoveryError_alias_2 }
+
+/**
+ * Service for discovering and loading Agent Skills from filesystem
+ *
+ * Skills are discovered from three sources with priority:
+ * 1. Project skills at .claude/skills/ (highest priority)
+ * 2. Personal skills at ~/.claude/skills/
+ * 3. Plugin skills at node_modules (lowest priority)
+ */
+declare class SkillDiscoveryService {
+    private fs;
+    private personalSkillsDir;
+    private projectSkillsDir;
+    private pluginSkillsDirs;
+    constructor(options: {
+        cwd: string;
+        personalSkillsDir?: string;
+        pluginSkillsDirs?: string[];
+        fs?: FileSystemProvider;
+    });
+    /**
+     * Discover all available skills from all sources
+     * Removes duplicates (project skills take priority over personal/plugin)
+     */
+    discoverAll(): Promise<SkillReference[]>;
+    /**
+     * Discover skills in a specific directory
+     */
+    discoverInDirectory(dir: string, source: 'personal' | 'project' | 'plugin'): Promise<SkillReference[]>;
+    /**
+     * Discover skills from plugin directories (node_modules)
+     */
+    discoverPlugins(): Promise<SkillReference[]>;
+    /**
+     * Load a single skill from its directory
+     */
+    loadSkill(skillPath: string, source: 'personal' | 'project' | 'plugin'): Promise<Skill>;
+    /**
+     * Parse SKILL.md content and extract frontmatter
+     */
+    private parseSkillMd;
+    /**
+     * Parse and validate YAML frontmatter
+     */
+    private parseMetadata;
+    /**
+     * Recursively load files from a directory into the files map
+     * @returns The total size of all files loaded (in bytes)
+     */
+    private loadDirectoryFiles;
+    /**
+     * Create an initial skill context object
+     */
+    createContext(): Promise<SkillContext>;
+}
+export { SkillDiscoveryService }
+export { SkillDiscoveryService as SkillDiscoveryService_alias_1 }
+export { SkillDiscoveryService as SkillDiscoveryService_alias_2 }
+
+declare type SkillMetadata = z.infer<typeof skillMetadataSchema>;
+export { SkillMetadata }
+export { SkillMetadata as SkillMetadata_alias_1 }
+export { SkillMetadata as SkillMetadata_alias_2 }
+
+/**
+ * Zod schema for skill metadata (YAML frontmatter in SKILL.md)
+ */
+declare const skillMetadataSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export { skillMetadataSchema }
+export { skillMetadataSchema as skillMetadataSchema_alias_1 }
+export { skillMetadataSchema as skillMetadataSchema_alias_2 }
+
+/**
+ * Represents a reference to a discovered skill (metadata only)
+ */
+declare interface SkillReference {
+    /**
+     * Parsed metadata from SKILL.md frontmatter
+     */
+    metadata: SkillMetadata;
+    /**
+     * Absolute path to the skill directory on disk
+     */
+    path: string;
+    /**
+     * Where the skill was loaded from
+     */
+    source: 'personal' | 'project' | 'plugin';
+}
+export { SkillReference }
+export { SkillReference as SkillReference_alias_1 }
+export { SkillReference as SkillReference_alias_2 }
+
+declare type SkillSource = keyof typeof SOURCE_ICONS;
+export { SkillSource }
+export { SkillSource as SkillSource_alias_1 }
+export { SkillSource as SkillSource_alias_2 }
+
+/**
+ * Error thrown when skill validation fails
+ */
+declare class SkillValidationError extends Error {
+    path: string;
+    constructor(message: string, path: string);
+}
+export { SkillValidationError }
+export { SkillValidationError as SkillValidationError_alias_1 }
+export { SkillValidationError as SkillValidationError_alias_2 }
+
+declare const SOURCE_ICONS: {
+    readonly project: "📁";
+    readonly personal: "🏠";
+    readonly plugin: "🔌";
+};
+export { SOURCE_ICONS }
+export { SOURCE_ICONS as SOURCE_ICONS_alias_1 }
+export { SOURCE_ICONS as SOURCE_ICONS_alias_2 }
+
+declare interface StepFn {
+    <T>(name: string, fn: () => Promise<T>): Promise<T>;
+    <T>(name: string, options: StepOptions, fn: () => Promise<T>): Promise<T>;
+}
+export { StepFn }
+export { StepFn as StepFn_alias_1 }
+export { StepFn as StepFn_alias_2 }
+
+declare type StepOptions = {
+    retry?: number;
+};
+export { StepOptions }
+export { StepOptions as StepOptions_alias_1 }
+export { StepOptions as StepOptions_alias_2 }
+
+/**
+ * Security validation patterns to detect suspicious content
+ *
+ * Note: Patterns use case-insensitive flag (/i) but NOT global (/g) to avoid
+ * stateful lastIndex issues when RegExp.test() is called multiple times.
+ */
+declare const SUSPICIOUS_PATTERNS: readonly [RegExp, RegExp, RegExp];
+export { SUSPICIOUS_PATTERNS }
+export { SUSPICIOUS_PATTERNS as SUSPICIOUS_PATTERNS_alias_1 }
+export { SUSPICIOUS_PATTERNS as SUSPICIOUS_PATTERNS_alias_2 }
+
+/**
+ * Union type of all possible task events
+ */
+declare type TaskEvent = TaskEventStartTask | TaskEventStartRequest | TaskEventEndRequest | TaskEventText | TaskEventToolUse | TaskEventToolResult | TaskEventToolError | TaskEventUsageExceeded | TaskEventEndTask;
+export { TaskEvent }
+export { TaskEvent as TaskEvent_alias_1 }
+export { TaskEvent as TaskEvent_alias_2 }
+
+/**
+ * Base interface for all task events
+ */
+declare interface TaskEventBase {
+    kind: TaskEventKind;
+}
+export { TaskEventBase }
+export { TaskEventBase as TaskEventBase_alias_1 }
+export { TaskEventBase as TaskEventBase_alias_2 }
+
+declare type TaskEventCallback = (event: TaskEvent) => void | Promise<void>;
+export { TaskEventCallback }
+export { TaskEventCallback as TaskEventCallback_alias_1 }
+export { TaskEventCallback as TaskEventCallback_alias_2 }
+
+/**
+ * Event for request end
+ */
+declare interface TaskEventEndRequest extends TaskEventBase {
+    kind: TaskEventKind.EndRequest;
+    message: string;
+}
+export { TaskEventEndRequest }
+export { TaskEventEndRequest as TaskEventEndRequest_alias_1 }
+export { TaskEventEndRequest as TaskEventEndRequest_alias_2 }
+
+/**
+ * Event for task end
+ */
+declare interface TaskEventEndTask extends TaskEventBase {
+    kind: TaskEventKind.EndTask;
+    exitReason: ExitReason;
+}
+export { TaskEventEndTask }
+export { TaskEventEndTask as TaskEventEndTask_alias_1 }
+export { TaskEventEndTask as TaskEventEndTask_alias_2 }
+
+/**
+ * Enum representing different kinds of task events
+ */
+declare enum TaskEventKind {
+    StartTask = "StartTask",
+    StartRequest = "StartRequest",
+    EndRequest = "EndRequest",
+    Text = "Text",
+    Reasoning = "Reasoning",
+    ToolUse = "ToolUse",
+    ToolReply = "ToolReply",
+    ToolError = "ToolError",
+    UsageExceeded = "UsageExceeded",
+    EndTask = "EndTask"
+}
+export { TaskEventKind }
+export { TaskEventKind as TaskEventKind_alias_1 }
+export { TaskEventKind as TaskEventKind_alias_2 }
+
+/**
+ * Event for request start
+ */
+declare interface TaskEventStartRequest extends TaskEventBase {
+    kind: TaskEventKind.StartRequest;
+    userMessage: readonly JsonModelMessage[];
+}
+export { TaskEventStartRequest }
+export { TaskEventStartRequest as TaskEventStartRequest_alias_1 }
+export { TaskEventStartRequest as TaskEventStartRequest_alias_2 }
+
+/**
+ * Event for task start
+ */
+declare interface TaskEventStartTask extends TaskEventBase {
+    kind: TaskEventKind.StartTask;
+    systemPrompt: string;
+}
+export { TaskEventStartTask }
+export { TaskEventStartTask as TaskEventStartTask_alias_1 }
+export { TaskEventStartTask as TaskEventStartTask_alias_2 }
+
+/**
+ * Event for text/reasoning updates
+ */
+declare interface TaskEventText extends TaskEventBase {
+    kind: TaskEventKind.Text | TaskEventKind.Reasoning;
+    newText: string;
+}
+export { TaskEventText }
+export { TaskEventText as TaskEventText_alias_1 }
+export { TaskEventText as TaskEventText_alias_2 }
+
+declare interface TaskEventToolError extends TaskEventBase {
+    kind: TaskEventKind.ToolError;
+    tool: string;
+    error: ToolResponseResult;
+}
+export { TaskEventToolError }
+export { TaskEventToolError as TaskEventToolError_alias_1 }
+export { TaskEventToolError as TaskEventToolError_alias_2 }
+
+declare interface TaskEventToolResult extends TaskEventBase {
+    kind: TaskEventKind.ToolReply;
+    tool: string;
+    content: ToolResponseResult;
+}
+export { TaskEventToolResult }
+export { TaskEventToolResult as TaskEventToolResult_alias_1 }
+export { TaskEventToolResult as TaskEventToolResult_alias_2 }
+
+/**
+ * Event for tool-related updates
+ */
+declare interface TaskEventToolUse extends TaskEventBase {
+    kind: TaskEventKind.ToolUse;
+    tool: string;
+    params: Record<string, any>;
+}
+export { TaskEventToolUse }
+export { TaskEventToolUse as TaskEventToolUse_alias_1 }
+export { TaskEventToolUse as TaskEventToolUse_alias_2 }
+
+/**
+ * Event for task usage exceeded
+ */
+declare interface TaskEventUsageExceeded extends TaskEventBase {
+    kind: TaskEventKind.UsageExceeded;
+}
+export { TaskEventUsageExceeded }
+export { TaskEventUsageExceeded as TaskEventUsageExceeded_alias_1 }
+export { TaskEventUsageExceeded as TaskEventUsageExceeded_alias_2 }
+
+declare type TodoItem = z.infer<typeof TodoItemSchema>;
+export { TodoItem }
+export { TodoItem as TodoItem_alias_1 }
+export { TodoItem as TodoItem_alias_2 }
+
+declare const TodoItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    status: z.ZodEnum<{
+        open: "open";
+        completed: "completed";
+        closed: "closed";
+    }>;
+}, z.core.$strip>;
+export { TodoItemSchema }
+export { TodoItemSchema as TodoItemSchema_alias_1 }
+export { TodoItemSchema as TodoItemSchema_alias_2 }
+
+declare type TodoProvider = {
+    listTodoItems: (id?: string | null, status?: string | null) => Promise<ListTodoItemsOutput>;
+    getTodoItem: (id: string) => Promise<GetTodoItemOutput | undefined>;
+    updateTodoItem: (input: UpdateTodoItemInput) => Promise<UpdateTodoItemOutput>;
+};
+export { TodoProvider }
+export { TodoProvider as TodoProvider_alias_1 }
+export { TodoProvider as TodoProvider_alias_2 }
+
+declare const TodoStatus: z.ZodEnum<{
+    open: "open";
+    completed: "completed";
+    closed: "closed";
+}>;
+export { TodoStatus }
+export { TodoStatus as TodoStatus_alias_1 }
+export { TodoStatus as TodoStatus_alias_2 }
+
+declare const toJsonModelMessage: (msg: ModelMessage) => JsonModelMessage;
+export { toJsonModelMessage }
+export { toJsonModelMessage as toJsonModelMessage_alias_1 }
+export { toJsonModelMessage as toJsonModelMessage_alias_2 }
+
+/**
+ * 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.";
+    readonly parameters: z.ZodObject<{
+        questions: z.ZodArray<z.ZodObject<{
+            prompt: z.ZodString;
+            options: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+};
+
+export declare const toolInfo_alias_1: {
+    readonly name: "executeCommand";
+    readonly description: "Run a single CLI command. The command is always executed in the project-root working directory (regardless of earlier commands). Prefer one-off shell commands over wrapper scripts for flexibility. **IMPORTANT**: After an `execute_command` call, you MUST stop and NOT allowed to make further tool calls in the same message.";
+    readonly parameters: z.ZodObject<{
+        command: z.ZodString;
+        requiresApproval: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
+    }, z.core.$strip>;
+};
+
+export declare const toolInfo_alias_10: {
+    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<{
+        path: z.ZodString;
+        regex: z.ZodString;
+        filePattern: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+};
+
+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<{
+        path: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strip>;
+};
+
+export declare const toolInfo_alias_2: {
+    readonly name: "fetchUrl";
+    readonly description: "Fetch the content located at one or more HTTP(S) URLs and return it in Markdown format. This works for standard web pages as well as raw files (e.g. README.md, source code) hosted on platforms like GitHub.";
+    readonly parameters: z.ZodObject<{
+        url: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+};
+
+export declare const toolInfo_alias_3: {
+    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<{
+        path: z.ZodString;
+        maxCount: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+        recursive: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
+        includeIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
+    }, 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: "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: "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_7: {
+    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_8: {
+    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_9: {
+    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>;
+};
+
+declare type ToolParameter = {
+    name: string;
+    description: string;
+    required: boolean;
+    usageValue?: string;
+    allowMultiple?: boolean;
+    children?: ToolParameter[];
+};
+export { ToolParameter }
+export { ToolParameter as ToolParameter_alias_1 }
+
+declare type ToolParameterValue = string | {
+    [key: string]: ToolParameterValue;
+} | ToolParameterValue[];
+export { ToolParameterValue }
+export { ToolParameterValue as ToolParameterValue_alias_1 }
+
+declare type ToolProvider = FilesystemProvider & CommandProvider & InteractionProvider & WebProvider & Partial<MemoryProvider> & Partial<TodoProvider>;
+export { ToolProvider }
+export { ToolProvider as ToolProvider_alias_1 }
+export { ToolProvider as ToolProvider_alias_2 }
+
+declare type ToolRegistry = Record<string, ToolSignature<any, any>>;
+export { ToolRegistry }
+export { ToolRegistry as ToolRegistry_alias_1 }
+export { ToolRegistry as ToolRegistry_alias_2 }
+
+declare type ToolResponse = {
+    success: boolean;
+    message: ToolResponseResult;
+};
+export { ToolResponse }
+export { ToolResponse as ToolResponse_alias_1 }
+
+declare type ToolResponseResult = {
+    type: 'text';
+    value: string;
+} | {
+    type: 'json';
+    value: JSONValue;
+} | {
+    type: 'error-text';
+    value: string;
+} | {
+    type: 'error-json';
+    value: JSONValue;
+} | {
+    type: 'content';
+    value: Array<{
+        type: 'text';
+        text: string;
+    } | ToolResponseResultMedia>;
+};
+export { ToolResponseResult }
+export { ToolResponseResult as ToolResponseResult_alias_1 }
+
+declare type ToolResponseResultMedia = {
+    type: 'media';
+    data: string;
+    mediaType: string;
+    url: string;
+};
+export { ToolResponseResultMedia }
+export { ToolResponseResultMedia as ToolResponseResultMedia_alias_1 }
+
+declare type ToolSignature<I, O> = {
+    input: I;
+    output: O;
+};
+export { ToolSignature }
+export { ToolSignature as ToolSignature_alias_1 }
+export { ToolSignature as ToolSignature_alias_2 }
+
+declare type Totals = {
+    input: number;
+    output: number;
+    cachedRead: number;
+    cost: number;
+    messageCount: number;
+};
+
+declare type TryCatchStep = z.infer<typeof TryCatchStepSchema>;
+export { TryCatchStep }
+export { TryCatchStep as TryCatchStep_alias_1 }
+export { TryCatchStep as TryCatchStep_alias_2 }
+
+/**
+ * Try/catch block - error handling
+ */
+declare const TryCatchStepSchema: z.ZodObject<{
+    id: z.ZodString;
+    try: z.ZodObject<{
+        trySteps: z.ZodArray<z.ZodLazy<any>>;
+        catchSteps: z.ZodArray<z.ZodLazy<any>>;
+    }, z.core.$strip>;
+    output: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export { TryCatchStepSchema }
+export { TryCatchStepSchema as TryCatchStepSchema_alias_1 }
+export { TryCatchStepSchema as TryCatchStepSchema_alias_2 }
+
+declare type UpdateTodoItemInput = z.infer<typeof UpdateTodoItemInputSchema>;
+export { UpdateTodoItemInput }
+export { UpdateTodoItemInput as UpdateTodoItemInput_alias_1 }
+export { UpdateTodoItemInput as UpdateTodoItemInput_alias_2 }
+
+declare const UpdateTodoItemInputSchema: z.ZodObject<{
+    operation: z.ZodEnum<{
+        add: "add";
+        update: "update";
+    }>;
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    parentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        open: "open";
+        completed: "completed";
+        closed: "closed";
+    }>>>;
+}, z.core.$strip>;
+export { UpdateTodoItemInputSchema }
+export { UpdateTodoItemInputSchema as UpdateTodoItemInputSchema_alias_1 }
+export { UpdateTodoItemInputSchema as UpdateTodoItemInputSchema_alias_2 }
+
+declare type UpdateTodoItemOutput = z.infer<typeof UpdateTodoItemOutputSchema>;
+export { UpdateTodoItemOutput }
+export { UpdateTodoItemOutput as UpdateTodoItemOutput_alias_1 }
+export { UpdateTodoItemOutput as UpdateTodoItemOutput_alias_2 }
+
+declare const UpdateTodoItemOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+}, z.core.$strip>;
+export { UpdateTodoItemOutputSchema }
+export { UpdateTodoItemOutputSchema as UpdateTodoItemOutputSchema_alias_1 }
+export { UpdateTodoItemOutputSchema as UpdateTodoItemOutputSchema_alias_2 }
+
+/**
+ * Tracks token / cost usage across any mix of LLM models.
+ * Supports optional caps on total messages and total cost.
+ */
+declare class UsageMeter {
+    #private;
+    constructor(modelInfos?: Record<string, Record<string, Partial<ModelInfo>>>, opts?: {
+        maxMessages?: number;
+        maxCost?: number;
+    });
+    addUsage(llm: LanguageModelV2, resp: {
+        usage: LanguageModelV2Usage;
+        providerMetadata?: any;
+    } | {
+        totalUsage: LanguageModelV2Usage;
+        providerMetadata?: any;
+    }, options?: {
+        modelInfo?: ModelInfo;
+    }): void;
+    /** Override the running totals (e.g., restore from saved state). */
+    setUsage(newUsage: Partial<Totals>): void;
+    /** Manually bump the message count (useful if you record some messages without token info). */
+    incrementMessageCount(n?: number): void;
+    /** Reset the running totals. */
+    resetUsage(): void;
+    /** Return true once either messages or cost exceed the configured caps. */
+    isLimitExceeded(): {
+        messageCount: boolean;
+        maxMessages: number;
+        cost: boolean;
+        maxCost: number;
+        result: boolean;
+    };
+    /** Same as isLimitExceeded but throws an error if a limit is hit. */
+    checkLimit(): void;
+    /** Getter for the aggregated totals (immutable copy). */
+    get usage(): {
+        input: number;
+        output: number;
+        cachedRead: number;
+        cost: number;
+        messageCount: number;
+    };
+    /** Merge another UsageMeter's totals into this one. */
+    merge(other: UsageMeter): void;
+    getUsageText(): string;
+    onFinishHandler(llm: LanguageModelV2): (evt: {
+        totalUsage: LanguageModelV2Usage;
+        providerMetadata: any;
+    }) => void;
+}
+export { UsageMeter }
+export { UsageMeter as UsageMeter_alias_1 }
+
+/**
+ * Validate a skill's metadata
+ * Note: Zod already validates name format, max length, and description max length
+ * This function only validates requirements not covered by Zod
+ */
+declare function validateSkillMetadata(skill: Skill): string[];
+export { validateSkillMetadata }
+export { validateSkillMetadata as validateSkillMetadata_alias_1 }
+export { validateSkillMetadata as validateSkillMetadata_alias_2 }
+
+/**
+ * Validate file references in skill content
+ *
+ * Warns about external references and absolute paths
+ */
+declare function validateSkillReferences(skill: Skill): string[];
+export { validateSkillReferences }
+export { validateSkillReferences as validateSkillReferences_alias_1 }
+export { validateSkillReferences as validateSkillReferences_alias_2 }
+
+/**
+ * Validate a skill's security constraints
+ *
+ * @throws {SkillValidationError} if validation fails
+ */
+declare function validateSkillSecurity(skill: Skill): void;
+export { validateSkillSecurity }
+export { validateSkillSecurity as validateSkillSecurity_alias_1 }
+export { validateSkillSecurity as validateSkillSecurity_alias_2 }
+
+/**
+ * Validate a workflow file for common issues
+ */
+declare function validateWorkflowFile(definition: WorkflowFile): ValidationResult;
+export { validateWorkflowFile }
+export { validateWorkflowFile as validateWorkflowFile_alias_1 }
+export { validateWorkflowFile as validateWorkflowFile_alias_2 }
+
+declare type ValidationResult = {
+    success: true;
+} | {
+    success: false;
+    errors: string[];
+};
+export { ValidationResult }
+export { ValidationResult as ValidationResult_alias_1 }
+export { ValidationResult as ValidationResult_alias_2 }
+
+declare type WebProvider = {
+    fetchUrl?: (url: string) => Promise<string>;
+    search?: (query: string) => Promise<string>;
+};
+export { WebProvider }
+export { WebProvider as WebProvider_alias_1 }
+export { WebProvider as WebProvider_alias_2 }
+
+declare type WhileLoopStep = z.infer<typeof WhileLoopStepSchema>;
+export { WhileLoopStep }
+export { WhileLoopStep as WhileLoopStep_alias_1 }
+export { WhileLoopStep as WhileLoopStep_alias_2 }
+
+/**
+ * While loop - repeats steps while condition is true
+ */
+declare const WhileLoopStepSchema: any;
+export { WhileLoopStepSchema }
+export { WhileLoopStepSchema as WhileLoopStepSchema_alias_1 }
+export { WhileLoopStepSchema as WhileLoopStepSchema_alias_2 }
+
+declare type WorkflowContext<TTools extends ToolRegistry> = {
+    step: StepFn;
+    logger: Logger;
+    tools: WorkflowTools<TTools>;
+};
+export { WorkflowContext }
+export { WorkflowContext as WorkflowContext_alias_1 }
+export { WorkflowContext as WorkflowContext_alias_2 }
+
+declare type WorkflowControlFlowStep = z.infer<typeof WorkflowControlFlowStepSchema>;
+export { WorkflowControlFlowStep }
+export { WorkflowControlFlowStep as WorkflowControlFlowStep_alias_1 }
+export { WorkflowControlFlowStep as WorkflowControlFlowStep_alias_2 }
+
+/**
+ * Any step that can appear in a workflow's steps array
+ * Can be a basic step, control flow, or jump statement
+ */
+declare const WorkflowControlFlowStepSchema: any;
+export { WorkflowControlFlowStepSchema }
+export { WorkflowControlFlowStepSchema as WorkflowControlFlowStepSchema_alias_1 }
+export { WorkflowControlFlowStepSchema as WorkflowControlFlowStepSchema_alias_2 }
+
+declare type WorkflowDefinition = z.infer<typeof WorkflowDefinitionSchema>;
+export { WorkflowDefinition }
+export { WorkflowDefinition as WorkflowDefinition_alias_1 }
+export { WorkflowDefinition as WorkflowDefinition_alias_2 }
+
+/**
+ * Workflow definition - now supports control flow in steps
+ */
+declare const WorkflowDefinitionSchema: z.ZodObject<{
+    task: z.ZodString;
+    inputs: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        default: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+    }, z.core.$strip>>>>;
+    steps: z.ZodArray<any>;
+    output: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, 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<{
+        task: z.ZodString;
+        inputs: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            default: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+        }, z.core.$strip>>>>;
+        steps: z.ZodArray<any>;
+        output: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>>;
+}, 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 }
+export { WorkflowFn as WorkflowFn_alias_1 }
+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;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    default: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+}, 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 }
+
+/**
+ * Basic workflow step - executes a task
+ */
+declare const WorkflowStepDefinitionSchema: z.ZodObject<{
+    id: z.ZodString;
+    tools: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    task: z.ZodString;
+    output: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    expected_outcome: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    outputSchema: z.ZodOptional<z.ZodNullable<z.ZodAny>>;
+    timeout: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, 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']>;
+};
+export { WorkflowTools }
+export { WorkflowTools as WorkflowTools_alias_1 }
+export { WorkflowTools as WorkflowTools_alias_2 }
+
+export { }