@polka-codes/core 0.9.18 → 0.9.19

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

@@ -0,0 +1,1861 @@
+import type { FilePart } from 'ai';
+import type { ImagePart } from 'ai';
+import type { LanguageModelV2 } from '@ai-sdk/provider';
+import type { LanguageModelV2Usage } from '@ai-sdk/provider';
+import type { ModelMessage } from '@ai-sdk/provider-utils';
+import type { ModelMessage as ModelMessage_2 } from 'ai';
+import type { TextPart } from 'ai';
+import type { ToolModelMessage } from '@ai-sdk/provider-utils';
+import type { UserContent } from '@ai-sdk/provider-utils';
+import type { UserContent as UserContent_2 } from 'ai';
+import type { UserModelMessage } from '@ai-sdk/provider-utils';
+import { z } from 'zod';
+
+declare abstract class AgentBase {
+    #private;
+    readonly ai: LanguageModelV2;
+    protected readonly config: Readonly<AgentBaseConfig>;
+    protected readonly handlers: Record<string, FullToolInfoV2>;
+    constructor(name: string, ai: LanguageModelV2, config: AgentBaseConfig);
+    abort(): void;
+    get parameters(): Readonly<Record<string, any>>;
+    get messages(): Readonly<ModelMessage[]>;
+    setMessages(messages: Readonly<ModelMessage[]>): void;
+    start(prompt: UserContent): Promise<ExitReason>;
+    step(prompt: UserContent): Promise<AssistantMessageContent[]>;
+    handleStepResponse(response: AssistantMessageContent[]): Promise<{
+        type: "reply";
+        message: UserModelMessage | ToolModelMessage;
+    } | {
+        type: "exit";
+        reason: ExitReason;
+    }>;
+    continueTask(userMessage: UserContent): Promise<ExitReason>;
+    protected abstract onBeforeInvokeTool(name: string, args: Record<string, string>): Promise<ToolResponse | undefined>;
+    get model(): string;
+    get usage(): {
+        messageCount: number;
+        input: number;
+        output: number;
+        cachedRead: number;
+        cost: number;
+    };
+}
+export { AgentBase }
+export { AgentBase as AgentBase_alias_1 }
+export { AgentBase as AgentBase_alias_2 }
+
+declare type AgentBaseConfig = {
+    systemPrompt: string;
+    tools: FullToolInfoV2[];
+    toolNamePrefix: string;
+    provider: ToolProvider;
+    interactive: boolean;
+    agents?: Readonly<AgentInfo[]>;
+    scripts?: Record<string, string | {
+        command: string;
+        description: string;
+    }>;
+    callback?: TaskEventCallback;
+    policies: AgentPolicy[];
+    retryCount?: number;
+    requestTimeoutSeconds?: number;
+    toolFormat: ToolFormat;
+    parameters: Record<string, any>;
+    usageMeter: UsageMeter;
+};
+export { AgentBaseConfig }
+export { AgentBaseConfig as AgentBaseConfig_alias_1 }
+export { AgentBaseConfig as AgentBaseConfig_alias_2 }
+
+declare type AgentInfo = {
+    name: string;
+    responsibilities: string[];
+};
+export { AgentInfo }
+export { AgentInfo as AgentInfo_alias_1 }
+export { AgentInfo as AgentInfo_alias_2 }
+
+declare type AgentNameType = (typeof allAgents)[number]['name'];
+export { AgentNameType }
+export { AgentNameType as AgentNameType_alias_1 }
+
+declare type AgentPolicy = (tools: Record<string, FullToolInfoV2>, parameters: Record<string, any>) => AgentPolicyInstance | undefined;
+export { AgentPolicy }
+export { AgentPolicy as AgentPolicy_alias_1 }
+export { AgentPolicy as AgentPolicy_alias_2 }
+
+declare type AgentPolicyInstance = {
+    name: string;
+    tools?: FullToolInfoV2[];
+    prompt?: string;
+    onBeforeInvokeTool?: (name: string, args: Record<string, string>) => Promise<ToolResponse | undefined>;
+    onBeforeRequest?: (agent: AgentBase) => Promise<void>;
+    prepareMessages?: (agent: AgentBase, messages: ModelMessage_2[]) => Promise<ModelMessage_2[]>;
+};
+export { AgentPolicyInstance }
+export { AgentPolicyInstance as AgentPolicyInstance_alias_1 }
+export { AgentPolicyInstance as AgentPolicyInstance_alias_2 }
+
+declare const agentsPrompt: (agents: Readonly<AgentInfo[]>, name: string) => string;
+export { agentsPrompt }
+export { agentsPrompt as agentsPrompt_alias_1 }
+export { agentsPrompt as agentsPrompt_alias_2 }
+
+declare type AiToolDefinition<Input, Output = string> = {
+    name: string;
+    description: string;
+    prompt: string;
+    formatInput: (params: Input) => string;
+    parseOutput: (output: string) => Output;
+};
+export { AiToolDefinition }
+export { AiToolDefinition as AiToolDefinition_alias_1 }
+export { AiToolDefinition as AiToolDefinition_alias_2 }
+
+export declare type AiToolDefinitionWithAgent<Input, Output = string> = AiToolDefinition<Input, Output> & {
+    agent: (options: SharedAgentOptions) => AgentBase;
+};
+
+export declare type AiToolDefinitionWithMultiAgent<Input, Output = string> = AiToolDefinition<Input, Output> & {
+    agent: AgentNameType;
+};
+
+declare const allAgents: readonly [{
+    readonly name: "architect";
+    readonly responsibilities: ["Analyzing the user’s overall task and requirements.", "Creating plans and making higher-level decisions about system structure and design.", "Reviewing and analyzing existing code or components for maintainability and scalability.", "Laying out the roadmap for implementation."];
+}, {
+    readonly name: "coder";
+    readonly responsibilities: ["Editing and refactoring existing code.", "Creating new features or modules.", "Running tests and analyzing test results.", "Maintaining coding standards, lint rules, and general code quality."];
+}, {
+    readonly name: "analyzer";
+    readonly responsibilities: ["Analyzing project structure and organization", "Identifying key source code files and their relationships", "Understanding common coding patterns and conventions", "Examining development workflow and tooling", "Analyzing dependencies and their usage patterns"];
+}, {
+    readonly name: "codefixer";
+    readonly responsibilities: ["Fixing type errors and type-related issues", "Resolving failing tests", "Addressing code quality issues", "Tracking and reporting unfixed issues"];
+}];
+export { allAgents }
+export { allAgents as allAgents_alias_1 }
+
+export declare namespace allTools {
+    export {
+        _default as askFollowupQuestion,
+        _default_2 as attemptCompletion,
+        _default_3 as delegate,
+        _default_4 as executeCommand,
+        _default_5 as fetchUrl,
+        _default_6 as handOver,
+        _default_7 as listFiles,
+        _default_8 as readFile,
+        _default_9 as removeFile,
+        _default_10 as renameFile,
+        _default_11 as replaceInFile,
+        _default_12 as searchFiles,
+        _default_13 as writeToFile
+    }
+}
+
+declare class AnalyzerAgent extends AgentBase {
+    constructor(options: AnalyzerAgentOptions);
+    onBeforeInvokeTool(): Promise<undefined>;
+}
+export { AnalyzerAgent }
+export { AnalyzerAgent as AnalyzerAgent_alias_1 }
+export { AnalyzerAgent as AnalyzerAgent_alias_2 }
+
+declare const analyzerAgentInfo: {
+    readonly name: "analyzer";
+    readonly responsibilities: ["Analyzing project structure and organization", "Identifying key source code files and their relationships", "Understanding common coding patterns and conventions", "Examining development workflow and tooling", "Analyzing dependencies and their usage patterns"];
+};
+export { analyzerAgentInfo }
+export { analyzerAgentInfo as analyzerAgentInfo_alias_1 }
+export { analyzerAgentInfo as analyzerAgentInfo_alias_2 }
+
+declare type AnalyzerAgentOptions = SharedAgentOptions;
+export { AnalyzerAgentOptions }
+export { AnalyzerAgentOptions as AnalyzerAgentOptions_alias_1 }
+export { AnalyzerAgentOptions as AnalyzerAgentOptions_alias_2 }
+
+/**
+ * Annotate a diff with line numbers for additions and deletions
+ * Adds [Line N] for additions and [Line N removed] for deletions
+ */
+export declare function annotateDiffWithLineNumbers(diff: string): string;
+
+declare class ArchitectAgent extends AgentBase {
+    constructor(options: ArchitectAgentOptions);
+    onBeforeInvokeTool(): Promise<undefined>;
+}
+export { ArchitectAgent }
+export { ArchitectAgent as ArchitectAgent_alias_1 }
+export { ArchitectAgent as ArchitectAgent_alias_2 }
+
+declare const architectAgentInfo: {
+    readonly name: "architect";
+    readonly responsibilities: ["Analyzing the user’s overall task and requirements.", "Creating plans and making higher-level decisions about system structure and design.", "Reviewing and analyzing existing code or components for maintainability and scalability.", "Laying out the roadmap for implementation."];
+};
+export { architectAgentInfo }
+export { architectAgentInfo as architectAgentInfo_alias_1 }
+export { architectAgentInfo as architectAgentInfo_alias_2 }
+
+declare type ArchitectAgentOptions = SharedAgentOptions;
+export { ArchitectAgentOptions }
+export { ArchitectAgentOptions as ArchitectAgentOptions_alias_1 }
+export { ArchitectAgentOptions as ArchitectAgentOptions_alias_2 }
+
+declare type AssistantMessageContent = TextContent | ToolUse;
+export { AssistantMessageContent }
+export { AssistantMessageContent as AssistantMessageContent_alias_1 }
+export { AssistantMessageContent as AssistantMessageContent_alias_2 }
+
+export declare const basePrompt = "You are a highly skilled software engineer specializing in debugging and fixing code issues. You have extensive experience with:\n- Type systems and type checking\n- Test frameworks and debugging test failures\n- Code quality tools and best practices\n- Systematic debugging approaches";
+
+export declare const basePrompt_alias_1 = "You are a highly skilled software engineer with extensive knowledge in many programming languages, frameworks, design patterns, and best practices.";
+
+declare const capabilities: (_toolNamePrefix: string) => string;
+export { capabilities }
+export { capabilities as capabilities_alias_1 }
+export { capabilities as capabilities_alias_2 }
+
+/**
+ * CodeFixer agent for fixing code issues like type errors and failing tests.
+ * Using Scripts: format, check, test
+ */
+declare class CodeFixerAgent extends AgentBase {
+    #private;
+    constructor(options: CodeFixerAgentOptions);
+    protected onBeforeInvokeTool(name: string, _args: Record<string, string>): Promise<ToolResponse | undefined>;
+}
+export { CodeFixerAgent }
+export { CodeFixerAgent as CodeFixerAgent_alias_1 }
+export { CodeFixerAgent as CodeFixerAgent_alias_2 }
+
+declare const codeFixerAgentInfo: {
+    readonly name: "codefixer";
+    readonly responsibilities: ["Fixing type errors and type-related issues", "Resolving failing tests", "Addressing code quality issues", "Tracking and reporting unfixed issues"];
+};
+export { codeFixerAgentInfo }
+export { codeFixerAgentInfo as codeFixerAgentInfo_alias_1 }
+export { codeFixerAgentInfo as codeFixerAgentInfo_alias_2 }
+
+declare type CodeFixerAgentOptions = SharedAgentOptions & {
+    maxRetries?: number;
+};
+export { CodeFixerAgentOptions }
+export { CodeFixerAgentOptions as CodeFixerAgentOptions_alias_1 }
+export { CodeFixerAgentOptions as CodeFixerAgentOptions_alias_2 }
+
+export declare const codeFixingStrategies = "\n====\n\nCODE FIXING STRATEGIES\n\n1. Type Errors\n   - Analyze type error messages carefully\n   - Check type definitions and imports\n   - Consider type assertions only as a last resort\n   - Verify type compatibility across function boundaries\n   - Look for null/undefined handling issues\n\n2. Test Failures\n   - Examine test output and error messages\n   - Check test setup and fixtures\n   - Verify assertions and expectations\n   - Look for async/timing issues\n   - Consider edge cases and input validation\n\n3. Code Quality Issues\n   - Follow project's coding standards\n   - Address linter warnings systematically\n   - Improve code readability\n   - Fix potential runtime issues\n   - Consider performance implications\n\n4. General Approach\n   - Start with the most critical issues\n   - Make minimal necessary changes\n   - Verify fixes don't introduce new issues\n   - Document complex fixes with comments\n   - Track attempted solutions for each issue";
+
+/**
+ * Coder agent for writing code.
+ * Using Scripts: format, check, test
+ */
+declare class CoderAgent extends AgentBase {
+    #private;
+    constructor(options: CoderAgentOptions);
+    protected onBeforeInvokeTool(name: string, _args: Record<string, string>): Promise<ToolResponse | undefined>;
+}
+export { CoderAgent }
+export { CoderAgent as CoderAgent_alias_1 }
+export { CoderAgent as CoderAgent_alias_2 }
+
+declare const coderAgentInfo: {
+    readonly name: "coder";
+    readonly responsibilities: ["Editing and refactoring existing code.", "Creating new features or modules.", "Running tests and analyzing test results.", "Maintaining coding standards, lint rules, and general code quality."];
+};
+export { coderAgentInfo }
+export { coderAgentInfo as coderAgentInfo_alias_1 }
+export { coderAgentInfo as coderAgentInfo_alias_2 }
+
+declare type CoderAgentOptions = SharedAgentOptions;
+export { CoderAgentOptions }
+export { CoderAgentOptions as CoderAgentOptions_alias_1 }
+export { CoderAgentOptions as CoderAgentOptions_alias_2 }
+
+declare type CommandProvider = {
+    executeCommand?: (command: string, needApprove: boolean) => Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
+};
+export { CommandProvider }
+export { CommandProvider as CommandProvider_alias_1 }
+export { CommandProvider as CommandProvider_alias_2 }
+
+declare type Config = z.infer<typeof configSchema>;
+export { Config }
+export { Config as Config_alias_1 }
+
+declare const configSchema: z.ZodObject<{
+    agent: z.ZodOptional<z.ZodString>;
+    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>;
+    }, z.core.$strip>>>;
+    defaultProvider: z.ZodOptional<z.ZodString>;
+    defaultModel: z.ZodOptional<z.ZodString>;
+    defaultParameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    toolFormat: z.ZodOptional<z.ZodEnum<{
+        native: "native";
+        "polka-codes": "polka-codes";
+    }>>;
+    maxMessageCount: z.ZodOptional<z.ZodNumber>;
+    budget: z.ZodOptional<z.ZodNumber>;
+    retryCount: z.ZodOptional<z.ZodNumber>;
+    requestTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    scripts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>]>>>;
+    agents: 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>>;
+        toolFormat: z.ZodOptional<z.ZodEnum<{
+            native: "native";
+            "polka-codes": "polka-codes";
+        }>>;
+        initialContext: z.ZodOptional<z.ZodObject<{
+            maxFileCount: z.ZodOptional<z.ZodNumber>;
+            excludes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        retryCount: z.ZodOptional<z.ZodNumber>;
+        requestTimeoutSeconds: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    commands: z.ZodOptional<z.ZodObject<{
+        default: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodOptional<z.ZodString>;
+            model: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            toolFormat: z.ZodOptional<z.ZodEnum<{
+                native: "native";
+                "polka-codes": "polka-codes";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$catchall<z.ZodObject<{
+        provider: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        toolFormat: z.ZodOptional<z.ZodEnum<{
+            native: "native";
+            "polka-codes": "polka-codes";
+        }>>;
+    }, z.core.$strip>>>>;
+    rules: z.ZodOptional<z.ZodUnion<[z.ZodOptional<z.ZodArray<z.ZodString>>, z.ZodString]>>;
+    excludeFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    policies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export { configSchema }
+export { configSchema as configSchema_alias_1 }
+
+declare const createNewProject: (agent: MultiAgent, params: string) => Promise<string>;
+export { createNewProject }
+export { createNewProject as createNewProject_alias_1 }
+
+declare const customInstructions: (customInstructions: string[]) => string;
+export { customInstructions }
+export { customInstructions as customInstructions_alias_1 }
+export { customInstructions as customInstructions_alias_2 }
+
+declare const customScripts: (commands: Record<string, string | {
+    command: string;
+    description: string;
+}>) => string;
+export { customScripts }
+export { customScripts as customScripts_alias_1 }
+export { customScripts as customScripts_alias_2 }
+
+declare const _default: {
+    handler: ToolHandler<{
+        readonly name: "ask_followup_question";
+        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>;
+        readonly permissionLevel: PermissionLevel.None;
+    }, InteractionProvider>;
+    isAvailable: (provider: InteractionProvider) => boolean;
+    name: "ask_followup_question";
+    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>;
+    permissionLevel: PermissionLevel.None;
+};
+export { _default as askFollowupQuestion }
+export { _default as askFollowupQuestion_alias_1 }
+export { _default as askFollowupQuestion_alias_2 }
+export { _default as default_alias_6 }
+
+declare const _default_10: {
+    handler: ToolHandler<{
+        readonly name: "rename_file";
+        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>;
+        readonly permissionLevel: PermissionLevel.Write;
+    }, FilesystemProvider>;
+    isAvailable: (provider: FilesystemProvider) => boolean;
+    name: "rename_file";
+    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>;
+    permissionLevel: PermissionLevel.Write;
+};
+export { _default_10 as default_alias_15 }
+export { _default_10 as renameFile }
+export { _default_10 as renameFile_alias_1 }
+export { _default_10 as renameFile_alias_2 }
+
+declare const _default_11: {
+    handler: ToolHandler<{
+        readonly name: "replace_in_file";
+        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>;
+        readonly permissionLevel: PermissionLevel.Write;
+    }, FilesystemProvider>;
+    isAvailable: (provider: FilesystemProvider) => boolean;
+    name: "replace_in_file";
+    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>;
+    permissionLevel: PermissionLevel.Write;
+};
+export { _default_11 as default_alias_16 }
+export { _default_11 as replaceInFile }
+export { _default_11 as replaceInFile_alias_1 }
+export { _default_11 as replaceInFile_alias_2 }
+
+declare const _default_12: {
+    handler: ToolHandler<{
+        readonly name: "search_files";
+        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>;
+        readonly permissionLevel: PermissionLevel.Read;
+    }, FilesystemProvider>;
+    isAvailable: (provider: FilesystemProvider) => boolean;
+    name: "search_files";
+    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>;
+    permissionLevel: PermissionLevel.Read;
+};
+export { _default_12 as default_alias_17 }
+export { _default_12 as searchFiles }
+export { _default_12 as searchFiles_alias_1 }
+export { _default_12 as searchFiles_alias_2 }
+
+declare const _default_13: {
+    handler: ToolHandler<{
+        readonly name: "write_to_file";
+        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>;
+        readonly permissionLevel: PermissionLevel.Write;
+    }, FilesystemProvider>;
+    isAvailable: (provider: FilesystemProvider) => boolean;
+    name: "write_to_file";
+    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>;
+    permissionLevel: PermissionLevel.Write;
+};
+export { _default_13 as default_alias_18 }
+export { _default_13 as writeToFile }
+export { _default_13 as writeToFile_alias_1 }
+export { _default_13 as writeToFile_alias_2 }
+
+declare const _default_2: {
+    handler: ToolHandler<{
+        readonly name: "attempt_completion";
+        readonly description: "Use this tool when you believe the user’s requested task is complete. Indicate that your work is finished, but acknowledge the user may still provide additional instructions or questions if they want to continue. This tool MUST NOT to be used with any other tool.";
+        readonly parameters: z.ZodObject<{
+            result: z.ZodString;
+        }, z.core.$strip>;
+        readonly permissionLevel: PermissionLevel.None;
+    }, InteractionProvider>;
+    isAvailable: (_provider: InteractionProvider) => boolean;
+    name: "attempt_completion";
+    description: "Use this tool when you believe the user’s requested task is complete. Indicate that your work is finished, but acknowledge the user may still provide additional instructions or questions if they want to continue. This tool MUST NOT to be used with any other tool.";
+    parameters: z.ZodObject<{
+        result: z.ZodString;
+    }, z.core.$strip>;
+    permissionLevel: PermissionLevel.None;
+};
+export { _default_2 as attemptCompletion }
+export { _default_2 as attemptCompletion_alias_1 }
+export { _default_2 as attemptCompletion_alias_2 }
+export { _default_2 as default_alias_7 }
+
+declare const _default_3: {
+    handler: ToolHandler<{
+        readonly name: "delegate";
+        readonly description: "Temporarily delegate a task to another agent and receive the result back. This tool MUST NOT to be used with any other tool.";
+        readonly parameters: z.ZodObject<{
+            agentName: z.ZodString;
+            task: z.ZodString;
+            context: z.ZodString;
+            files: z.ZodOptional<z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>;
+        readonly permissionLevel: PermissionLevel.None;
+    }, any>;
+    isAvailable: (_provider: any) => boolean;
+    name: "delegate";
+    description: "Temporarily delegate a task to another agent and receive the result back. This tool MUST NOT to be used with any other tool.";
+    parameters: z.ZodObject<{
+        agentName: z.ZodString;
+        task: z.ZodString;
+        context: z.ZodString;
+        files: z.ZodOptional<z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    permissionLevel: PermissionLevel.None;
+};
+export { _default_3 as default_alias_8 }
+export { _default_3 as delegate }
+export { _default_3 as delegate_alias_1 }
+export { _default_3 as delegate_alias_2 }
+
+declare const _default_4: {
+    handler: ToolHandler<{
+        readonly name: "execute_command";
+        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>;
+        readonly permissionLevel: PermissionLevel.Arbitrary;
+    }, CommandProvider>;
+    isAvailable: (provider: CommandProvider) => boolean;
+    name: "execute_command";
+    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>;
+    permissionLevel: PermissionLevel.Arbitrary;
+};
+export { _default_4 as default_alias_9 }
+export { _default_4 as executeCommand }
+export { _default_4 as executeCommand_alias_1 }
+export { _default_4 as executeCommand_alias_2 }
+
+declare const _default_5: {
+    handler: ToolHandler<{
+        readonly name: "fetch_url";
+        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>;
+        readonly permissionLevel: PermissionLevel.Read;
+    }, WebProvider>;
+    isAvailable: (provider: WebProvider) => boolean;
+    name: "fetch_url";
+    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>;
+    permissionLevel: PermissionLevel.Read;
+};
+export { _default_5 as default_alias_10 }
+export { _default_5 as fetchUrl }
+export { _default_5 as fetchUrl_alias_1 }
+export { _default_5 as fetchUrl_alias_2 }
+
+declare const _default_6: {
+    handler: ToolHandler<{
+        readonly name: "hand_over";
+        readonly description: "Hand over the current task to another agent to complete. This tool MUST NOT to be used with any other tool.";
+        readonly parameters: z.ZodObject<{
+            agentName: z.ZodString;
+            task: z.ZodString;
+            context: z.ZodString;
+            files: z.ZodOptional<z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>;
+        readonly permissionLevel: PermissionLevel.None;
+    }, any>;
+    isAvailable: (_provider: any) => boolean;
+    name: "hand_over";
+    description: "Hand over the current task to another agent to complete. This tool MUST NOT to be used with any other tool.";
+    parameters: z.ZodObject<{
+        agentName: z.ZodString;
+        task: z.ZodString;
+        context: z.ZodString;
+        files: z.ZodOptional<z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    permissionLevel: PermissionLevel.None;
+};
+export { _default_6 as default_alias_11 }
+export { _default_6 as handOver }
+export { _default_6 as handOver_alias_1 }
+export { _default_6 as handOver_alias_2 }
+
+declare const _default_7: {
+    handler: ToolHandler<{
+        readonly name: "list_files";
+        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>;
+        readonly permissionLevel: PermissionLevel.Read;
+    }, FilesystemProvider>;
+    isAvailable: (provider: FilesystemProvider) => boolean;
+    name: "list_files";
+    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>;
+    permissionLevel: PermissionLevel.Read;
+};
+export { _default_7 as default_alias_12 }
+export { _default_7 as listFiles }
+export { _default_7 as listFiles_alias_1 }
+export { _default_7 as listFiles_alias_2 }
+
+declare const _default_8: {
+    handler: ToolHandler<{
+        readonly name: "read_file";
+        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.ZodBoolean>>>;
+        }, z.core.$strip>;
+        readonly permissionLevel: PermissionLevel.Read;
+    }, FilesystemProvider>;
+    isAvailable: (provider: FilesystemProvider) => boolean;
+    name: "read_file";
+    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.ZodBoolean>>>;
+    }, z.core.$strip>;
+    permissionLevel: PermissionLevel.Read;
+};
+export { _default_8 as default_alias_13 }
+export { _default_8 as readFile }
+export { _default_8 as readFile_alias_1 }
+export { _default_8 as readFile_alias_2 }
+
+declare const _default_9: {
+    handler: ToolHandler<{
+        readonly name: "remove_file";
+        readonly description: "Request to remove a file at the specified path.";
+        readonly parameters: z.ZodObject<{
+            path: z.ZodString;
+        }, z.core.$strip>;
+        readonly permissionLevel: PermissionLevel.Write;
+    }, FilesystemProvider>;
+    isAvailable: (provider: FilesystemProvider) => boolean;
+    name: "remove_file";
+    description: "Request to remove a file at the specified path.";
+    parameters: z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strip>;
+    permissionLevel: PermissionLevel.Write;
+};
+export { _default_9 as default_alias_14 }
+export { _default_9 as removeFile }
+export { _default_9 as removeFile_alias_1 }
+export { _default_9 as removeFile_alias_2 }
+
+/**
+ * AI tool for creating new projects based on user specifications.
+ * Generated by polka.codes
+ */
+export declare const default_alias: {
+    readonly name: "createNewProject";
+    readonly description: "Creates a new project";
+    readonly prompt: "You are an AiTool designed to assist users in creating new projects. Follow these guidelines:\n\n1. **Gather Information:**\n   - Begin by asking the user for essential project details, including:\n     - Project type (e.g., web, mobile, desktop, etc.)\n     - Desired programming languages\n     - Preferred frameworks or libraries\n     - Build tools and package manager preferences\n     - Testing frameworks and patterns\n     - Code style and linting preferences\n     - Any additional specifications or requirements\n\n2. **Clarification & Confirmation:**\n   - Do not make any decisions or assumptions on behalf of the user.\n   - Ask clarifying questions if any detail is ambiguous.\n   - Confirm each piece of information with the user before proceeding to the next step.\n\n3. **Avoid Redundancy:**\n   - Do not repeat questions or details that have already been confirmed.\n   - Keep interactions concise and focused on gathering complete and accurate details.\n\n4. **Generate Configuration:**\n   - Based on the collected information, generate a .polkacodes.yml configuration file that includes:\n     - scripts section with common development commands (test, format, check, etc.)\n     - rules section reflecting project conventions and tools\n     - excludeFiles section for sensitive files only\n   - Example structure:\n     ```yaml\n     scripts:\n       test:\n         command: \"[test-command]\"\n         description: \"Run tests\"\n       format:\n         command: \"[format-command]\"\n         description: \"Format code\"\n       check:\n         command: \"[check-command]\"\n         description: \"Check code\"\n\n     rules:\n       - \"[package-manager-rule]\"\n       - \"[testing-framework-rule]\"\n       - \"[code-style-rule]\"\n       - \"[other-rule]\"\n\n     excludeFiles:\n       - \".env\"\n       - \".env.*\"\n     ```\n\n5. **Generate Essential Project Files:**\n   - Create a .gitattributes file with appropriate configurations:\n     - Mark lock files as generated and exclude them from diffs\n     - Example for different package managers:\n\n       # For Bun\n       bun.lock linguist-generated=true\n       bun.lock -diff\n\n       # For npm\n       package-lock.json linguist-generated=true\n       package-lock.json -diff\n\n       # For Yarn\n       yarn.lock linguist-generated=true\n       yarn.lock -diff\n\n       # For pnpm\n       pnpm-lock.yaml linguist-generated=true\n       pnpm-lock.yaml -diff\n\n     - Include other common configurations as needed based on project type\n\n6. **Handover to Coder Agent:**\n   - Once all required information is collected and validated by the user, compile:\n     1. The final project specifications\n     2. The .polkacodes.yml configuration content\n   - Clearly hand over these details to the coder agent, instructing them to:\n     1. Create the new project based on the confirmed specifications\n     2. Include the .polkacodes.yml file in the project root\n     3. Include the .gitattributes file with appropriate configurations\n     4. Ensure all specified tools and configurations are properly set up";
+    readonly formatInput: (params: string) => string;
+    readonly parseOutput: (output: string) => string;
+    readonly agent: "architect";
+};
+
+export declare const default_alias_1: {
+    readonly name: "generateGitCommitMessage";
+    readonly description: "Generates git commit messages from git diff output";
+    readonly prompt: "\nYou are an advanced assistant specialized in creating concise and accurate Git commit messages. When you receive:\n- A Git diff inside the <tool_input> tag.\n- Additional user-supplied context inside the <tool_input_context> tag (if any).\n\nYou will produce a single commit message enclosed within <tool_output> tags. The commit message must accurately reflect the changes shown in the diff and should be clear, descriptive, and devoid of unnecessary or repeated information. If a context is provided, it MUST be incorporated into the commit message.\n\nHere’s an example of the input and the expected output format:\n\n<tool_input>\n--- a/example_file.py\n+++ b/example_file.py\n@@ -10,7 +10,7 @@ def example_function():\n-    print(\"Old behavior\")\n+    print(\"New behavior\")\n</tool_input>\n<tool_input_context>\nChanging print statement to update the user-facing message.\n</tool_input_context>\n\nExample Output:\n\n<tool_output>\nUpdate print statement for revised user-facing message\n</tool_output>\n\nFollow the same structure for any new input. Never repeat questions; focus on generating a concise commit message that captures the essence of the changes.\n";
+    readonly formatInput: (params: {
+        diff: string;
+        context?: string;
+    }) => string;
+    readonly parseOutput: (output: string) => string;
+};
+
+export declare const default_alias_2: {
+    readonly name: "generateGithubPullRequestDetails";
+    readonly description: "Generates a GitHub pull request title and description from git commits";
+    readonly prompt: "\n# Generate Github Pull Request Details\n\nYou are given:\n- A branch name in <tool_input_branch_name>.\n- An optional context message in <tool_input_context> (which may or may not be present).\n- All commit messages combined in <tool_input_commit_messages>.\n- All diffs combined in <tool_input_commit_diff>.\n\nYour task:\n1. Consider the optional context (if provided).\n   - If an issue number is found, add \"Closes #xxx\" at the beginning of the PR description\n   - IMPORTANT: Use ONLY the exact format \"Closes #xxx\" at the beginning of the description\n   - DO NOT use variations like \"Closes issue #xxx\" or other formats\n2. Analyze the combined commit messages and diffs.\n3. Produce a single GitHub Pull Request title.\n4. Produce a Pull Request description that explains the changes.\n\nUse the following template for the Pull Request description:\n\n---\n**Context (if provided)**:\n- Acknowledge any guiding concerns or instructions.\n\n**Summary of Changes**:\n- Provide a concise list or overview of what changed.\n\n**Highlights of Changed Code**:\n- Mention only the specific sections or functionalities updated, without showing full surrounding context.\n\n**Additional Information (if needed)**:\n- Testing steps (if applicable).\n- Any notes or caveats.\n\n---\n\nOutput format:\n<tool_output>\n  <tool_output_pr_title>YOUR PR TITLE HERE</tool_output_pr_title>\n  <tool_output_pr_description>\n    YOUR PR DESCRIPTION HERE\n  </tool_output_pr_description>\n</tool_output>\n\nBelow is an **example** of the input and output:\n\nExample Input:\n<tool_input>\n<tool_input_branch_name>feature/refactor-logging</tool_input_branch_name>\n<tool_input_context>Implementing changes for issue #123 - Focus on clean code and maintainability</tool_input_context>\n<tool_input_commit_messages>\nRemove debug logs\nRefactor order validation logic\n</tool_input_commit_messages>\n<tool_input_commit_diff>\ndiff --git a/user_service.py b/user_service.py\n- print(\"Debug info\")\n+ # Removed debug print statements\n\ndiff --git a/order_service.py b/order_service.py\n- if is_valid_order(order):\n-     process_order(order)\n+ validate_and_process(order)\n</tool_input_commit_diff>\n</tool_input>\n\nExample Output:\n<tool_output>\n<tool_output_pr_title>Refactor Order Validation and Remove Debug Logs</tool_output_pr_title>\n<tool_output_pr_description>\nCloses #123\n\n**Context**:\n- Implementing changes for issue #123 - Focus on clean code and maintainability\n\n**Summary of Changes**:\n- Refactored order validation logic to use a new `validate_and_process` method.\n- Removed debug print statements from `user_service.py`.\n\n**Highlights of Changed Code**:\n- `order_service.py`: Replaced direct call to `process_order` with `validate_and_process`.\n- `user_service.py`: Removed `print(\"Debug info\")`.\n</tool_output_pr_description>\n</tool_output>\n\n---\n\nUse the above format whenever you receive <tool_input> that may include a branch name, an optional context, aggregated commit messages in a single tag, and a combined diff in a single tag. Provide your final output strictly in <tool_output> with <tool_output_pr_title> and <tool_output_pr_description>. Only highlight the changed code and avoid including the context around the changes in the description.\n";
+    readonly formatInput: (params: Input) => string;
+    readonly parseOutput: (output: string) => Output;
+};
+
+/**
+ * AI tool for analyzing project files and generating polkacodes config sections.
+ * Generated by polka.codes
+ */
+export declare const default_alias_3: {
+    readonly name: "generateProjectConfig";
+    readonly description: "Analyzes project files to generate polkacodes config sections";
+    readonly prompt: "\nRole: Analyzer agent\nGoal: Produce a valid polkacodes YAML configuration for the project.\n\nWorkflow\n1. Scan project files with tool_read_file and identify:\n   - Package/build tool (npm, bun, pnpm, etc.)\n   - Test framework and patterns (snapshot tests, coverage, etc.)\n   - Formatter / linter and their rules\n   - Folder structure and naming conventions\n   - CI / development workflows\n\n2. Build a YAML config with three root keys:\n\n```yaml\nscripts:          # derive from package.json and CI\n  format:        # code formatter\n    command: \"<formatter cmd>\"\n    description: \"Format code\"\n  check:         # linter / type checker\n    command: \"<linter cmd>\"\n    description: \"Static checks\"\n  test:          # test runner\n    command: \"<test cmd>\"\n    description: \"Run tests\"\n  # add any other meaningful project scripts\n\nrules:            # bullet list of key conventions/tools\n\nexcludeFiles:     # only files likely to hold secrets\n  - \".env\"\n  - \".env.*\"\n  - \".npmrc\"\n  # do NOT list build artifacts, lockfiles, or paths already in .gitignore\n```\n\n3. Return the YAML exactly once, wrapped like:\n\n<tool_attempt_completion>\n<tool_parameter_result>\n# YAML (2-space indents, double-quoted commands)\n</tool_parameter_result>\n</tool_attempt_completion>\n";
+    readonly formatInput: () => string;
+    readonly parseOutput: (output: string) => string;
+    readonly agent: "analyzer";
+};
+
+export declare const default_alias_4: {
+    readonly name: "reviewDiff";
+    readonly description: "Reviews a git diff";
+    readonly prompt: "\n# Code Review Prompt\n\nYou are a senior software engineer reviewing code changes.\n\n## Critical Instructions\n**ONLY review the actual changes shown in the diff.** Do not comment on existing code that wasn't modified.\n\n## Viewing Changes\n- **Use git_diff** to inspect the actual code changes for each relevant file.\n  - **Pull request**: use the provided commit range for the git_diff tool with contextLines: 5 and includeLineNumbers: true\n  - **Local changes**: diff staged or unstaged files using the git_diff tool with contextLines: 5 and includeLineNumbers: true\n- The diff will include line number annotations: [Line N] for additions and [Line N removed] for deletions\n- If a pull request is present you may receive:\n  - <pr_title>\n  - <pr_description>\n  - <commit_messages>\n- A <review_instructions> tag tells you the focus of the review.\n- File status information is provided in <file_status> - use this to understand which files were modified, added, deleted, or renamed.\n\n## Line Number Reporting\n- **IMPORTANT**: Use the line numbers from the annotations in the diff output\n- For additions: Look for [Line N] annotations after the + lines\n- For deletions: Look for [Line N removed] annotations after the - lines\n- For modifications: Report the line number of the new/current code (from [Line N] annotations)\n- Report single lines as \"N\" and ranges as \"N-M\"\n\n## Review Guidelines\nFocus exclusively on the changed lines (+ additions, - deletions, modified lines):\n- **Specific issues**: Point to exact problems in the changed code with accurate line references from the annotations\n- **Actionable fixes**: Provide concrete solutions, not vague suggestions\n- **Clear reasoning**: Explain why each issue matters and how to fix it\n- **Avoid generic advice**: No generic suggestions like \"add more tests\", \"improve documentation\", or \"follow best practices\" unless directly related to a specific problem in the diff\n\n## What NOT to review\n- Existing unchanged code\n- Overall project structure or architecture (unless directly impacted by changes)\n- Generic best practices unrelated to the specific changes\n- Missing features or functionality not part of this diff\n\n## Output Format\nDo **not** include praise or positive feedback. Ignore generated files such as lock files.\nOnly include reviews for actual issues found in the changed code.\n\nReturn your review as a JSON object inside a ```json block, wrapped like:\n<tool_attempt_completion>\n<tool_parameter_result>\n```json\n{\n  \"overview\": \"Summary of specific issues found in the diff changes, or 'No issues found' if the changes look good.\",\n  \"specificReviews\": [\n    {\n      \"file\": \"path/filename.ext\",\n      \"lines\": \"N or N-M\",\n      \"review\": \"Specific issue with the changed code and exact actionable fix.\"\n    }\n  ]\n}\n```\n</tool_parameter_result>\n</tool_attempt_completion>\n";
+    readonly formatInput: (params: Input_2) => string;
+    readonly parseOutput: (output: string) => Output_2;
+    readonly agent: (options: SharedAgentOptions) => AnalyzerAgent;
+};
+
+export declare const default_alias_5: {
+    handler: ToolHandler<{
+        readonly name: "git_diff";
+        readonly description: "Get the git diff for the current repository. Can be used to get staged changes, unstaged changes, or changes between commits. By default, it returns unstaged changes.";
+        readonly parameters: z.ZodObject<{
+            staged: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
+            commitRange: z.ZodOptional<z.ZodString>;
+            file: z.ZodOptional<z.ZodString>;
+            contextLines: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+            includeLineNumbers: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
+        }, z.core.$strip>;
+        readonly permissionLevel: PermissionLevel.Read;
+    }, CommandProvider>;
+    isAvailable: (provider: CommandProvider) => boolean;
+    name: "git_diff";
+    description: "Get the git diff for the current repository. Can be used to get staged changes, unstaged changes, or changes between commits. By default, it returns unstaged changes.";
+    parameters: z.ZodObject<{
+        staged: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
+        commitRange: z.ZodOptional<z.ZodString>;
+        file: z.ZodOptional<z.ZodString>;
+        contextLines: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+        includeLineNumbers: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
+    }, z.core.$strip>;
+    permissionLevel: PermissionLevel.Read;
+};
+
+export declare interface DiffHunk {
+    oldStart: number;
+    oldCount: number;
+    newStart: number;
+    newCount: number;
+    header: string;
+}
+
+/**
+ * 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;
+
+export declare const editingFilesPrompt: (toolNamePrefix: string) => string;
+
+declare const EnableCachePolicy: AgentPolicy;
+export { EnableCachePolicy }
+export { EnableCachePolicy as EnableCachePolicy_alias_1 }
+export { EnableCachePolicy as EnableCachePolicy_alias_2 }
+export { EnableCachePolicy as EnableCachePolicy_alias_3 }
+
+declare const executeAgentTool: <T extends AiToolDefinitionWithAgent<any, any>>(definition: T, options: SharedAgentOptions, params: GetInput<T>) => Promise<GetOutput<T>>;
+export { executeAgentTool }
+export { executeAgentTool as executeAgentTool_alias_1 }
+
+declare const executeMultiAgentTool: <T extends AiToolDefinitionWithMultiAgent<any, any>>(definition: T, agent: MultiAgent, params: GetInput<T>) => Promise<GetOutput<T>>;
+export { executeMultiAgentTool }
+export { executeMultiAgentTool as executeMultiAgentTool_alias_1 }
+
+declare const executeTool: <T extends AiToolDefinition<any, any>>(definition: T, ai: LanguageModelV2, params: GetInput<T>, usageMeter: UsageMeter) => Promise<GetOutput<T>>;
+export { executeTool }
+export { executeTool as executeTool_alias_1 }
+
+declare type ExitReason = {
+    type: 'UsageExceeded';
+} | {
+    type: 'WaitForUserInput';
+} | {
+    type: 'Aborted';
+} | ToolResponseExit | ToolResponseInterrupted | ToolResponseHandOver | ToolResponseDelegate | {
+    type: 'Pause';
+    responses: ToolResponseOrToolPause[];
+};
+export { ExitReason }
+export { ExitReason as ExitReason_alias_1 }
+export { ExitReason as ExitReason_alias_2 }
+
+/**
+ * Extract line ranges from a diff for a specific file
+ * Returns an array of line ranges that were modified
+ */
+export declare function extractModifiedLineRanges(diff: string, filePath?: string): Array<{
+    start: number;
+    end: number;
+    type: 'added' | 'removed' | 'modified';
+}>;
+
+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[]>;
+};
+export { FilesystemProvider }
+export { FilesystemProvider as FilesystemProvider_alias_1 }
+export { FilesystemProvider as FilesystemProvider_alias_2 }
+
+export declare const fullSystemPrompt: (info: {
+    os: string;
+}, tools: FullToolInfoV2[], toolNamePrefix: string, instructions: string[], scripts: Record<string, string | {
+    command: string;
+    description: string;
+}>, useNativeTool: boolean) => string;
+
+export declare const fullSystemPrompt_alias_1: (info: {
+    os: string;
+}, tools: FullToolInfoV2[], toolNamePrefix: string, instructions: string[], scripts: Record<string, string | {
+    command: string;
+    description: string;
+}>, useNativeTool: boolean) => string;
+
+export declare const fullSystemPrompt_alias_2: (info: {
+    os: string;
+}, tools: FullToolInfoV2[], toolNamePrefix: string, instructions: string[], scripts: Record<string, string | {
+    command: string;
+    description: string;
+}>, _interactive: boolean, useNativeTool: boolean) => string;
+
+export declare const fullSystemPrompt_alias_3: (info: {
+    os: string;
+}, tools: FullToolInfoV2[], toolNamePrefix: string, instructions: string[], scripts: Record<string, string | {
+    command: string;
+    description: string;
+}>, useNativeTool: boolean) => string;
+
+declare type FullToolInfo = ToolInfo & {
+    handler: ToolHandler<ToolInfo, any>;
+    isAvailable: (provider: any) => boolean;
+};
+export { FullToolInfo }
+export { FullToolInfo as FullToolInfo_alias_1 }
+
+declare type FullToolInfoV2 = ToolInfoV2 & {
+    handler: ToolHandler<ToolInfoV2, any>;
+    isAvailable: (provider: any) => boolean;
+};
+export { FullToolInfoV2 }
+export { FullToolInfoV2 as FullToolInfoV2_alias_1 }
+
+declare const generateGitCommitMessage: (ai: LanguageModelV2, params: {
+    diff: string;
+    context?: string;
+}, usageMeter: UsageMeter) => Promise<string>;
+export { generateGitCommitMessage }
+export { generateGitCommitMessage as generateGitCommitMessage_alias_1 }
+
+declare const generateGithubPullRequestDetails: (ai: LanguageModelV2, params: {
+    commitMessages: string;
+    commitDiff: string;
+    context?: string;
+    branchName: string;
+}, usageMeter: UsageMeter) => Promise<{
+    title: string;
+    description: string;
+}>;
+export { generateGithubPullRequestDetails }
+export { generateGithubPullRequestDetails as generateGithubPullRequestDetails_alias_1 }
+
+declare const generateProjectConfig: (agent: MultiAgent, params: unknown) => Promise<string>;
+export { generateProjectConfig }
+export { generateProjectConfig as generateProjectConfig_alias_1 }
+
+export declare const getArray: <T extends string>(args: Partial<Record<T, ToolParameterValue>> | ToolParameterValue, name: T, defaultValue?: ToolParameterValue[]) => ToolParameterValue[];
+
+/**
+ * Get the available tools based on the provider and agent availability
+ * @param provider The provider to use.
+ * @param allTools All possible tools.
+ * @param hasAgent Whether the agent has agents.
+ * @param permissionLevel Determines which tools are available based on the agent's assigned level.
+ * @param interactive Determines whether the `askFollowupQuestion` tool is available.
+ * @returns The available tools
+ */
+declare const getAvailableTools: <T extends FullToolInfoV2 | FullToolInfo>({ provider, allTools, hasAgent, permissionLevel, interactive, }: {
+    provider: any;
+    allTools: T[];
+    hasAgent: boolean;
+    permissionLevel: PermissionLevel;
+    interactive: boolean;
+}) => T[];
+export { getAvailableTools }
+export { getAvailableTools as getAvailableTools_alias_1 }
+
+export declare const getBoolean: <T extends string>(args: Partial<Record<T, ToolParameterValue>>, name: T, defaultValue?: boolean) => boolean;
+
+declare type GetInput<T> = T extends AiToolDefinition<infer Input, any> ? Input : never;
+export { GetInput }
+export { GetInput as GetInput_alias_1 }
+export { GetInput as GetInput_alias_2 }
+
+export declare const getInt: <T extends string>(args: Partial<Record<T, ToolParameterValue>>, name: T, defaultValue?: number) => number;
+
+declare type GetOutput<T> = T extends AiToolDefinition<any, infer Output> ? Output : never;
+export { GetOutput }
+export { GetOutput as GetOutput_alias_1 }
+export { GetOutput as GetOutput_alias_2 }
+
+export declare const getString: <T extends string>(args: Partial<Record<T, string>> | ToolParameterValue, name: T, defaultValue?: string) => string;
+
+export declare const getStringArray: <T extends string>(args: Partial<Record<T, ToolParameterValue>>, name: T, defaultValue?: string[]) => string[];
+
+export declare const handler: ToolHandler<typeof toolInfo, CommandProvider>;
+
+export declare const handler_alias_1: ToolHandler<typeof toolInfo_alias_1, InteractionProvider>;
+
+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_12: ToolHandler<typeof toolInfo_alias_12, FilesystemProvider>;
+
+export declare const handler_alias_13: ToolHandler<typeof toolInfo_alias_13, FilesystemProvider>;
+
+export declare const handler_alias_2: ToolHandler<typeof toolInfo_alias_2, InteractionProvider>;
+
+export declare const handler_alias_3: ToolHandler<typeof toolInfo_alias_3, any>;
+
+export declare const handler_alias_4: ToolHandler<typeof toolInfo_alias_4, CommandProvider>;
+
+export declare const handler_alias_5: ToolHandler<typeof toolInfo_alias_5, WebProvider>;
+
+export declare const handler_alias_6: ToolHandler<typeof toolInfo_alias_6, any>;
+
+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, FilesystemProvider>;
+
+declare type Input = {
+    commitMessages: string;
+    commitDiff: string;
+    context?: string;
+    branchName: string;
+};
+
+declare type Input_2 = {
+    pullRequestTitle?: string;
+    pullRequestDescription?: string;
+    commitMessages?: string;
+    commitRange?: string;
+    staged?: boolean;
+    changedFiles?: Array<{
+        path: string;
+        status: string;
+    }>;
+};
+
+declare type InteractionProvider = {
+    askFollowupQuestion?: (question: string, options: string[]) => Promise<string>;
+    attemptCompletion?: (result: string) => Promise<string | undefined>;
+};
+export { InteractionProvider }
+export { InteractionProvider as InteractionProvider_alias_1 }
+export { InteractionProvider as InteractionProvider_alias_2 }
+
+export declare const isAvailable: (provider: CommandProvider) => boolean;
+
+export declare const isAvailable_alias_1: (provider: InteractionProvider) => boolean;
+
+export declare const isAvailable_alias_10: (provider: FilesystemProvider) => boolean;
+
+export declare const isAvailable_alias_11: (provider: FilesystemProvider) => boolean;
+
+export declare const isAvailable_alias_12: (provider: FilesystemProvider) => boolean;
+
+export declare const isAvailable_alias_13: (provider: FilesystemProvider) => boolean;
+
+export declare const isAvailable_alias_2: (_provider: InteractionProvider) => boolean;
+
+export declare const isAvailable_alias_3: (_provider: any) => boolean;
+
+export declare const isAvailable_alias_4: (provider: CommandProvider) => boolean;
+
+export declare const isAvailable_alias_5: (provider: WebProvider) => boolean;
+
+export declare const isAvailable_alias_6: (_provider: any) => boolean;
+
+export declare const isAvailable_alias_7: (provider: FilesystemProvider) => boolean;
+
+export declare const isAvailable_alias_8: (provider: FilesystemProvider) => boolean;
+
+export declare const isAvailable_alias_9: (provider: FilesystemProvider) => boolean;
+
+/**
+ * Joins all given path segments, then normalizes the result.
+ */
+export declare function join(...parts: string[]): string;
+
+declare const makeAgentTool: <T extends AiToolDefinitionWithAgent<any, any>>(definition: T) => (options: SharedAgentOptions, params: GetInput<T>) => Promise<GetOutput<T>>;
+export { makeAgentTool }
+export { makeAgentTool as makeAgentTool_alias_1 }
+
+declare const makeMultiAgentTool: <T extends AiToolDefinitionWithMultiAgent<any, any>>(definition: T) => (agent: MultiAgent, params: GetInput<T>) => Promise<GetOutput<T>>;
+export { makeMultiAgentTool }
+export { makeMultiAgentTool as makeMultiAgentTool_alias_1 }
+
+declare const makeTool: <T extends AiToolDefinition<any, any>>(definition: T) => (ai: LanguageModelV2, params: GetInput<T>, usageMeter: UsageMeter) => Promise<GetOutput<T>>;
+export { makeTool }
+export { makeTool as makeTool_alias_1 }
+
+declare class MockProvider implements ToolProvider {
+    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;
+    }>;
+    askFollowupQuestion(_question: string, _options?: string[]): Promise<string>;
+    attemptCompletion(_result: string): Promise<string | undefined>;
+}
+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 }
+
+declare class MultiAgent {
+    #private;
+    constructor(config: MultiAgentConfig);
+    startTask(options: {
+        agentName: string;
+        task: string;
+        context: string;
+    }): Promise<ExitReason>;
+    continueTask(userMessage: string): Promise<ExitReason>;
+    get hasActiveAgent(): boolean;
+    abort(): void;
+}
+export { MultiAgent }
+export { MultiAgent as MultiAgent_alias_1 }
+export { MultiAgent as MultiAgent_alias_2 }
+
+declare type MultiAgentConfig = {
+    createAgent: (name: string) => Promise<AgentBase>;
+    getPrompt?: (name: string, task: string, context: string | undefined, files: string[] | undefined, originalTask: string | undefined) => Promise<string>;
+};
+export { MultiAgentConfig }
+export { MultiAgentConfig as MultiAgentConfig_alias_1 }
+export { MultiAgentConfig as MultiAgentConfig_alias_2 }
+
+export declare const objectives: (toolNamePrefix: string) => string;
+
+declare type Output = {
+    title: string;
+    description: string;
+};
+
+declare type Output_2 = {
+    overview: string;
+    specificReviews: SpecificReview[];
+};
+
+/**
+ * Parse an assistant's message into an array of text content and tool use content.
+ *
+ * @example
+ * const tools = [
+ *   {
+ *     name: "search",
+ *     parameters: [
+ *       {name: "query", type: "string"}
+ *     ]
+ *   }
+ * ]
+ *
+ * // Text only
+ * parseAssistantMessage("Hello world", tools, "tool_")
+ * // Returns: [{type: "text", content: "Hello world"}]
+ *
+ * // Tool use with parameters
+ * parseAssistantMessage(
+ *   `Let me search that for you
+ *   <tool_search>
+ *     <tool_parameter_query>cats</tool_parameter_query>
+ *   </tool_search>
+ *   Here are the results`,
+ *   tools,
+ *   "tool_"
+ * )
+ * // Returns: [
+ * //   {type: "text", content: "Let me search that for you"},
+ * //   {type: "tool_use", name: "search", params: {query: "cats"}},
+ * //   {type: "text", content: "Here are the results"}
+ * // ]
+ *
+ * // Array mode (multiple occurrences of the same parameter)
+ * parseAssistantMessage(
+ *   `<tool_read_file>
+ *     <tool_parameter_path>test.ts</tool_parameter_path>
+ *     <tool_parameter_path>main.ts</tool_parameter_path>
+ *   </tool_read_file>`,
+ *   tools,
+ *   "tool_"
+ * )
+ * // Returns: [
+ * //   {type: "tool_use", name: "read_file", params: {path: ["test.ts", "main.ts"]}}
+ * // ]
+ *
+ * // Nested objects
+ * parseAssistantMessage(
+ *   `<tool_example>
+ *     <tool_parameter_key>
+ *       <tool_parameter_key2>value</tool_parameter_key2>
+ *       <tool_parameter_key3>value2</tool_parameter_key3>
+ *     </tool_parameter_key>
+ *   </tool_example>`,
+ *   tools,
+ *   "tool_"
+ * )
+ * // Returns: [
+ * //   {type: "tool_use", name: "example", params: {key: {key2: "value", key3: "value2"}}}
+ * // ]
+ */
+declare function parseAssistantMessage(assistantMessage: string, tools: ToolInfo[], toolNamePrefix: string): AssistantMessageContent[];
+export { parseAssistantMessage }
+export { parseAssistantMessage as parseAssistantMessage_alias_1 }
+export { parseAssistantMessage as parseAssistantMessage_alias_2 }
+
+/**
+ * Parse a unified diff hunk header
+ * Format: @@ -oldStart,oldCount +newStart,newCount @@ optional context
+ */
+export declare function parseHunkHeader(header: string): DiffHunk | null;
+
+declare enum PermissionLevel {
+    None = 0,
+    Read = 1,
+    Write = 2,
+    Arbitrary = 3
+}
+export { PermissionLevel }
+export { PermissionLevel as PermissionLevel_alias_1 }
+
+declare enum Policies {
+    TruncateContext = "truncatecontext",
+    EnableCache = "enablecache"
+}
+export { Policies }
+export { Policies as Policies_alias_1 }
+
+declare const replaceInFile_2: (fileContent: string, diff: string) => ReplaceResult;
+export { replaceInFile_2 as replaceInFileHelper }
+export { replaceInFile_2 as replaceInFile_alias_3 }
+export { replaceInFile_2 as replaceInFile_alias_4 }
+
+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: UserContent_2) => 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 }
+
+export declare const retryGuidelines = "\n====\n\nRETRY GUIDELINES\n\n1. Before Retrying\n   - Analyze previous attempt's failure\n   - Consider alternative approaches\n   - Check if similar issues were fixed\n   - Verify no new issues were introduced\n\n2. When to Retry\n   - Error message changed but issue persists\n   - New information available about the root cause\n   - Different fixing strategy available\n   - Previous attempt partially successful\n\n3. When to Stop\n   - Maximum retry limit reached\n   - Same error occurs repeatedly\n   - Fix would require major refactoring\n   - Issue requires human intervention\n\n4. After Maximum Retries\n   - Document attempted solutions\n   - Explain why the issue remains\n   - Suggest manual intervention steps\n   - Report any partial improvements";
+
+declare const reviewDiff: (options: SharedAgentOptions, params: {
+    pullRequestTitle?: string;
+    pullRequestDescription?: string;
+    commitMessages?: string;
+    commitRange?: string;
+    staged?: boolean;
+    changedFiles?: Array<{
+        path: string;
+        status: string;
+    }>;
+}) => Promise<{
+    overview: string;
+    specificReviews: {
+        file: string;
+        lines: string;
+        review: string;
+    }[];
+}>;
+export { reviewDiff }
+export { reviewDiff as reviewDiff_alias_1 }
+
+export declare const rules: (toolNamePrefix: string) => string;
+
+declare type SharedAgentOptions = {
+    ai: LanguageModelV2;
+    os: string;
+    provider: ToolProvider;
+    interactive: boolean;
+    additionalTools?: FullToolInfoV2[];
+    customInstructions?: string[];
+    scripts?: Record<string, string | {
+        command: string;
+        description: string;
+    }>;
+    agents?: Readonly<AgentInfo[]>;
+    callback?: TaskEventCallback;
+    policies: AgentPolicy[];
+    retryCount?: number;
+    requestTimeoutSeconds?: number;
+    toolFormat: ToolFormat;
+    parameters?: Record<string, any>;
+    usageMeter?: UsageMeter;
+};
+export { SharedAgentOptions }
+export { SharedAgentOptions as SharedAgentOptions_alias_1 }
+export { SharedAgentOptions as SharedAgentOptions_alias_2 }
+
+declare type SpecificReview = {
+    file: string;
+    lines: string;
+    review: string;
+};
+
+declare const systemInformation: (info: {
+    os: string;
+}) => string;
+export { systemInformation }
+export { systemInformation as systemInformation_alias_1 }
+export { systemInformation as systemInformation_alias_2 }
+
+/**
+ * Union type of all possible task events
+ */
+declare type TaskEvent = TaskEventStartTask | TaskEventStartRequest | TaskEventEndRequest | TaskEventUsage | TaskEventText | TaskEventTool | TaskEventToolPause | TaskEventToolHandOverDelegate | 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;
+    agent: AgentBase;
+}
+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",
+    Usage = "Usage",
+    Text = "Text",
+    Reasoning = "Reasoning",
+    ToolUse = "ToolUse",
+    ToolReply = "ToolReply",
+    ToolInvalid = "ToolInvalid",
+    ToolError = "ToolError",
+    ToolInterrupted = "ToolInterrupted",
+    ToolHandOver = "ToolHandOver",
+    ToolDelegate = "ToolDelegate",
+    ToolPause = "ToolPause",
+    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: ModelMessage;
+}
+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 }
+
+/**
+ * Event for tool-related updates
+ */
+declare interface TaskEventTool extends TaskEventBase {
+    kind: TaskEventKind.ToolUse | TaskEventKind.ToolReply | TaskEventKind.ToolInvalid | TaskEventKind.ToolError | TaskEventKind.ToolInterrupted;
+    tool: string;
+    content: any;
+}
+export { TaskEventTool }
+export { TaskEventTool as TaskEventTool_alias_1 }
+export { TaskEventTool as TaskEventTool_alias_2 }
+
+/**
+ * Event for tool handover
+ */
+declare interface TaskEventToolHandOverDelegate extends TaskEventBase {
+    kind: TaskEventKind.ToolHandOver | TaskEventKind.ToolDelegate;
+    tool: string;
+    agentName: string;
+    task: string;
+    context?: string;
+    files?: string[];
+}
+export { TaskEventToolHandOverDelegate }
+export { TaskEventToolHandOverDelegate as TaskEventToolHandOverDelegate_alias_1 }
+export { TaskEventToolHandOverDelegate as TaskEventToolHandOverDelegate_alias_2 }
+
+declare interface TaskEventToolPause extends TaskEventBase {
+    kind: TaskEventKind.ToolPause;
+    tool: string;
+    object: any;
+}
+export { TaskEventToolPause }
+export { TaskEventToolPause as TaskEventToolPause_alias_1 }
+export { TaskEventToolPause as TaskEventToolPause_alias_2 }
+
+/**
+ * Event for API usage updates
+ */
+declare interface TaskEventUsage extends TaskEventBase {
+    kind: TaskEventKind.Usage;
+}
+export { TaskEventUsage }
+export { TaskEventUsage as TaskEventUsage_alias_1 }
+export { TaskEventUsage as TaskEventUsage_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 interface TextContent {
+    type: 'text';
+    content: string;
+}
+export { TextContent }
+export { TextContent as TextContent_alias_1 }
+export { TextContent as TextContent_alias_2 }
+
+declare type ToolExample = {
+    description: string;
+    input: Record<string, ToolParameterValue>;
+};
+export { ToolExample }
+export { ToolExample as ToolExample_alias_1 }
+
+declare type ToolFormat = 'native' | 'polka-codes';
+export { ToolFormat }
+export { ToolFormat as ToolFormat_alias_1 }
+
+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: ToolParameter[];
+    examples?: ToolExample[];
+    permissionLevel: PermissionLevel;
+};
+export { ToolInfo }
+export { ToolInfo as ToolInfo_alias_1 }
+
+export declare const toolInfo: {
+    readonly name: "git_diff";
+    readonly description: "Get the git diff for the current repository. Can be used to get staged changes, unstaged changes, or changes between commits. By default, it returns unstaged changes.";
+    readonly parameters: z.ZodObject<{
+        staged: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
+        commitRange: z.ZodOptional<z.ZodString>;
+        file: z.ZodOptional<z.ZodString>;
+        contextLines: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+        includeLineNumbers: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
+    }, z.core.$strip>;
+    readonly permissionLevel: PermissionLevel.Read;
+};
+
+export declare const toolInfo_alias_1: {
+    readonly name: "ask_followup_question";
+    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>;
+    readonly permissionLevel: PermissionLevel.None;
+};
+
+export declare const toolInfo_alias_10: {
+    readonly name: "rename_file";
+    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>;
+    readonly permissionLevel: PermissionLevel.Write;
+};
+
+export declare const toolInfo_alias_11: {
+    readonly name: "replace_in_file";
+    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>;
+    readonly permissionLevel: PermissionLevel.Write;
+};
+
+export declare const toolInfo_alias_12: {
+    readonly name: "search_files";
+    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>;
+    readonly permissionLevel: PermissionLevel.Read;
+};
+
+export declare const toolInfo_alias_13: {
+    readonly name: "write_to_file";
+    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>;
+    readonly permissionLevel: PermissionLevel.Write;
+};
+
+export declare const toolInfo_alias_2: {
+    readonly name: "attempt_completion";
+    readonly description: "Use this tool when you believe the user’s requested task is complete. Indicate that your work is finished, but acknowledge the user may still provide additional instructions or questions if they want to continue. This tool MUST NOT to be used with any other tool.";
+    readonly parameters: z.ZodObject<{
+        result: z.ZodString;
+    }, z.core.$strip>;
+    readonly permissionLevel: PermissionLevel.None;
+};
+
+export declare const toolInfo_alias_3: {
+    readonly name: "delegate";
+    readonly description: "Temporarily delegate a task to another agent and receive the result back. This tool MUST NOT to be used with any other tool.";
+    readonly parameters: z.ZodObject<{
+        agentName: z.ZodString;
+        task: z.ZodString;
+        context: z.ZodString;
+        files: z.ZodOptional<z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    readonly permissionLevel: PermissionLevel.None;
+};
+
+export declare const toolInfo_alias_4: {
+    readonly name: "execute_command";
+    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>;
+    readonly permissionLevel: PermissionLevel.Arbitrary;
+};
+
+export declare const toolInfo_alias_5: {
+    readonly name: "fetch_url";
+    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>;
+    readonly permissionLevel: PermissionLevel.Read;
+};
+
+export declare const toolInfo_alias_6: {
+    readonly name: "hand_over";
+    readonly description: "Hand over the current task to another agent to complete. This tool MUST NOT to be used with any other tool.";
+    readonly parameters: z.ZodObject<{
+        agentName: z.ZodString;
+        task: z.ZodString;
+        context: z.ZodString;
+        files: z.ZodOptional<z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>;
+    readonly permissionLevel: PermissionLevel.None;
+};
+
+export declare const toolInfo_alias_7: {
+    readonly name: "list_files";
+    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>;
+    readonly permissionLevel: PermissionLevel.Read;
+};
+
+export declare const toolInfo_alias_8: {
+    readonly name: "read_file";
+    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.ZodBoolean>>>;
+    }, z.core.$strip>;
+    readonly permissionLevel: PermissionLevel.Read;
+};
+
+export declare const toolInfo_alias_9: {
+    readonly name: "remove_file";
+    readonly description: "Request to remove a file at the specified path.";
+    readonly parameters: z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strip>;
+    readonly permissionLevel: PermissionLevel.Write;
+};
+
+declare type ToolInfoV2 = {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<any>;
+    permissionLevel: PermissionLevel;
+};
+export { ToolInfoV2 }
+export { ToolInfoV2 as ToolInfoV2_alias_1 }
+
+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;
+export { ToolProvider }
+export { ToolProvider as ToolProvider_alias_1 }
+export { ToolProvider as ToolProvider_alias_2 }
+
+declare type ToolResponse = ToolResponseReply | ToolResponseExit | ToolResponseInvalid | ToolResponseError | ToolResponseInterrupted | ToolResponseHandOver | ToolResponseDelegate | ToolResponsePause;
+export { ToolResponse }
+export { ToolResponse as ToolResponse_alias_1 }
+
+declare type ToolResponseDelegate = {
+    type: ToolResponseType.Delegate;
+    agentName: string;
+    task: string;
+    context?: string;
+    files?: string[];
+};
+export { ToolResponseDelegate }
+export { ToolResponseDelegate as ToolResponseDelegate_alias_1 }
+
+declare type ToolResponseError = {
+    type: ToolResponseType.Error;
+    message: string;
+    canRetry?: boolean;
+};
+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 ToolResponseHandOver = {
+    type: ToolResponseType.HandOver;
+    agentName: string;
+    task: string;
+    context?: string;
+    files?: string[];
+};
+export { ToolResponseHandOver }
+export { ToolResponseHandOver as ToolResponseHandOver_alias_1 }
+
+declare type ToolResponseInterrupted = {
+    type: ToolResponseType.Interrupted;
+    message: string;
+};
+export { ToolResponseInterrupted }
+export { ToolResponseInterrupted as ToolResponseInterrupted_alias_1 }
+
+declare type ToolResponseInvalid = {
+    type: ToolResponseType.Invalid;
+    message: string;
+};
+export { ToolResponseInvalid }
+export { ToolResponseInvalid as ToolResponseInvalid_alias_1 }
+
+declare type ToolResponseOrToolPause = {
+    type: 'response';
+    tool: string;
+    response: UserContent;
+    id?: string;
+} | {
+    type: 'pause';
+    tool: string;
+    object: any;
+    id?: string;
+};
+export { ToolResponseOrToolPause }
+export { ToolResponseOrToolPause as ToolResponseOrToolPause_alias_1 }
+export { ToolResponseOrToolPause as ToolResponseOrToolPause_alias_2 }
+
+declare type ToolResponsePause = {
+    type: ToolResponseType.Pause;
+    object: any;
+};
+export { ToolResponsePause }
+export { ToolResponsePause as ToolResponsePause_alias_1 }
+
+declare type ToolResponseReply = {
+    type: ToolResponseType.Reply;
+    message: UserContent;
+};
+export { ToolResponseReply }
+export { ToolResponseReply as ToolResponseReply_alias_1 }
+
+declare enum ToolResponseType {
+    Reply = "Reply",
+    Exit = "Exit",
+    Invalid = "Invalid",
+    Error = "Error",
+    Interrupted = "Interrupted",
+    HandOver = "HandOver",
+    Delegate = "Delegate",
+    Pause = "Pause"
+}
+export { ToolResponseType }
+export { ToolResponseType as ToolResponseType_alias_1 }
+
+declare interface ToolUse {
+    id?: string;
+    type: 'tool_use';
+    name: string;
+    params: Record<string, any>;
+}
+export { ToolUse }
+export { ToolUse as ToolUse_alias_1 }
+export { ToolUse as ToolUse_alias_2 }
+
+declare const toolUsePrompt: (useNativeTool: boolean, tools: FullToolInfoV2[], toolNamePrefix: string) => string;
+export { toolUsePrompt }
+export { toolUsePrompt as toolUsePrompt_alias_1 }
+export { toolUsePrompt as toolUsePrompt_alias_2 }
+
+declare type Totals = {
+    input: number;
+    output: number;
+    cachedRead: number;
+    cost: number;
+};
+
+export declare function toToolInfoV1(tool: FullToolInfoV2): FullToolInfo;
+
+declare const TruncateContextPolicy: () => {
+    name: Policies;
+    onBeforeRequest(agent: AgentBase): Promise<void>;
+};
+export { TruncateContextPolicy }
+export { TruncateContextPolicy as TruncateContextPolicy_alias_1 }
+export { TruncateContextPolicy as TruncateContextPolicy_alias_2 }
+export { TruncateContextPolicy as TruncateContextPolicy_alias_3 }
+
+/**
+ * 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 & {
+        calls: number;
+    }>): void;
+    /** Manually bump the message count (useful if you record some calls 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(): {
+        messageCount: number;
+        input: number;
+        output: number;
+        cachedRead: number;
+        cost: number;
+    };
+    /** Print a concise usage summary to console. */
+    printUsage(customConsole?: Console): void;
+    onFinishHandler(llm: LanguageModelV2): (evt: {
+        totalUsage: LanguageModelV2Usage;
+        providerMetadata: any;
+    }) => void;
+}
+export { UsageMeter }
+export { UsageMeter as UsageMeter_alias_1 }
+
+declare type WebProvider = {
+    fetchUrl?: (url: string) => Promise<string>;
+};
+export { WebProvider }
+export { WebProvider as WebProvider_alias_1 }
+export { WebProvider as WebProvider_alias_2 }
+
+export { }