@polka-codes/core 0.9.46 → 0.9.47

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

@@ -1,238 +1,12 @@
 import type { FilePart } from 'ai';
 import type { ImagePart } from 'ai';
 import type { JSONValue } from '@ai-sdk/provider';
-import { LanguageModelUsage } from 'ai';
 import type { LanguageModelV2 } from '@ai-sdk/provider';
 import type { LanguageModelV2ToolResultOutput } from '@ai-sdk/provider';
 import type { LanguageModelV2Usage } from '@ai-sdk/provider';
-import type { ModelMessage } from '@ai-sdk/provider-utils';
-import type { 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(message: (UserModelMessage | ToolModelMessage)[]): 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(): {
-        input: number;
-        output: number;
-        cachedRead: number;
-        cost: number;
-        messageCount: 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;
-    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;
-    requireToolUse: boolean;
-};
-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 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 }
-
-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 }
-
-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;
@@ -260,7 +34,6 @@ 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>;
@@ -278,10 +51,6 @@ declare const configSchema: z.ZodObject<{
     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>;
@@ -291,95 +60,52 @@ declare const configSchema: 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 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 name: "appendMemory";
+        readonly description: "Appends content to a memory topic.";
         readonly parameters: z.ZodObject<{
-            questions: z.ZodArray<z.ZodObject<{
-                prompt: z.ZodString;
-                options: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            }, z.core.$strip>>;
+            topic: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            content: z.ZodString;
         }, z.core.$strip>;
-    }, 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.";
+    }, MemoryProvider>;
+    name: "appendMemory";
+    description: "Appends content to a memory topic.";
     parameters: z.ZodObject<{
-        questions: z.ZodArray<z.ZodObject<{
-            prompt: z.ZodString;
-            options: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
+        topic: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        content: z.ZodString;
     }, z.core.$strip>;
 };
-export { _default as askFollowupQuestion }
-export { _default as askFollowupQuestion_alias_1 }
+export { _default as appendMemory }
+export { _default as appendMemory_alias_1 }
 export { _default as default_alias }
 
 declare const _default_10: {
     handler: ToolHandler<{
-        readonly name: "remove_file";
+        readonly name: "removeFile";
         readonly description: "Request to remove a file at the specified path.";
         readonly parameters: z.ZodObject<{
             path: z.ZodString;
         }, z.core.$strip>;
     }, FilesystemProvider>;
-    isAvailable: (provider: FilesystemProvider) => boolean;
-    name: "remove_file";
+    name: "removeFile";
     description: "Request to remove a file at the specified path.";
     parameters: z.ZodObject<{
         path: z.ZodString;
@@ -391,49 +117,85 @@ export { _default_10 as removeFile_alias_1 }
 
 declare const _default_11: {
     handler: ToolHandler<{
-        readonly name: "rename_file";
+        readonly name: "removeMemory";
+        readonly description: "Removes a topic from memory.";
+        readonly parameters: z.ZodObject<{
+            topic: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, MemoryProvider>;
+    name: "removeMemory";
+    description: "Removes a topic from memory.";
+    parameters: z.ZodObject<{
+        topic: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+};
+export { _default_11 as default_alias_10 }
+export { _default_11 as removeMemory }
+export { _default_11 as removeMemory_alias_1 }
+
+declare const _default_12: {
+    handler: ToolHandler<{
+        readonly name: "renameFile";
         readonly description: "Request to rename a file from source path to target path.";
         readonly parameters: z.ZodObject<{
             source_path: z.ZodString;
             target_path: z.ZodString;
         }, z.core.$strip>;
     }, FilesystemProvider>;
-    isAvailable: (provider: FilesystemProvider) => boolean;
-    name: "rename_file";
+    name: "renameFile";
     description: "Request to rename a file from source path to target path.";
     parameters: z.ZodObject<{
         source_path: z.ZodString;
         target_path: z.ZodString;
     }, z.core.$strip>;
 };
-export { _default_11 as default_alias_10 }
-export { _default_11 as renameFile }
-export { _default_11 as renameFile_alias_1 }
+export { _default_12 as default_alias_11 }
+export { _default_12 as renameFile }
+export { _default_12 as renameFile_alias_1 }
 
-declare const _default_12: {
+declare const _default_13: {
     handler: ToolHandler<{
-        readonly name: "replace_in_file";
+        readonly name: "replaceInFile";
         readonly description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.";
         readonly parameters: z.ZodObject<{
             path: z.ZodString;
             diff: z.ZodString;
         }, z.core.$strip>;
     }, FilesystemProvider>;
-    isAvailable: (provider: FilesystemProvider) => boolean;
-    name: "replace_in_file";
+    name: "replaceInFile";
     description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.";
     parameters: z.ZodObject<{
         path: z.ZodString;
         diff: z.ZodString;
     }, z.core.$strip>;
 };
-export { _default_12 as default_alias_11 }
-export { _default_12 as replaceInFile }
-export { _default_12 as replaceInFile_alias_1 }
+export { _default_13 as default_alias_12 }
+export { _default_13 as replaceInFile }
+export { _default_13 as replaceInFile_alias_1 }
 
-declare const _default_13: {
+declare const _default_14: {
     handler: ToolHandler<{
-        readonly name: "search_files";
+        readonly name: "replaceMemory";
+        readonly description: "Replaces content of a memory topic.";
+        readonly parameters: z.ZodObject<{
+            topic: z.ZodOptional<z.ZodString>;
+            content: z.ZodString;
+        }, z.core.$strip>;
+    }, MemoryProvider>;
+    name: "replaceMemory";
+    description: "Replaces content of a memory topic.";
+    parameters: z.ZodObject<{
+        topic: z.ZodOptional<z.ZodString>;
+        content: z.ZodString;
+    }, z.core.$strip>;
+};
+export { _default_14 as default_alias_13 }
+export { _default_14 as replaceMemory }
+export { _default_14 as replaceMemory_alias_1 }
+
+declare const _default_15: {
+    handler: ToolHandler<{
+        readonly name: "searchFiles";
         readonly description: "Request to perform a regex search across files in a specified directory, outputting context-rich results that include surrounding lines. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context.";
         readonly parameters: z.ZodObject<{
             path: z.ZodString;
@@ -441,8 +203,7 @@ declare const _default_13: {
             filePattern: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
     }, FilesystemProvider>;
-    isAvailable: (provider: FilesystemProvider) => boolean;
-    name: "search_files";
+    name: "searchFiles";
     description: "Request to perform a regex search across files in a specified directory, outputting context-rich results that include surrounding lines. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context.";
     parameters: z.ZodObject<{
         path: z.ZodString;
@@ -450,143 +211,95 @@ declare const _default_13: {
         filePattern: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 };
-export { _default_13 as default_alias_12 }
-export { _default_13 as searchFiles }
-export { _default_13 as searchFiles_alias_1 }
+export { _default_15 as default_alias_14 }
+export { _default_15 as searchFiles }
+export { _default_15 as searchFiles_alias_1 }
 
-declare const _default_14: {
+declare const _default_16: {
     handler: ToolHandler<{
-        readonly name: "write_to_file";
+        readonly name: "writeToFile";
         readonly description: "Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file. Ensure that the output content does not include incorrect escaped character patterns such as `&lt;`, `&gt;`, or `&amp;`. Also ensure there is no unwanted CDATA tags in the content.";
         readonly parameters: z.ZodObject<{
             path: z.ZodString;
             content: z.ZodString;
         }, z.core.$strip>;
     }, FilesystemProvider>;
-    isAvailable: (provider: FilesystemProvider) => boolean;
-    name: "write_to_file";
+    name: "writeToFile";
     description: "Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file. Ensure that the output content does not include incorrect escaped character patterns such as `&lt;`, `&gt;`, or `&amp;`. Also ensure there is no unwanted CDATA tags in the content.";
     parameters: z.ZodObject<{
         path: z.ZodString;
         content: z.ZodString;
     }, z.core.$strip>;
 };
-export { _default_14 as default_alias_13 }
-export { _default_14 as writeToFile }
-export { _default_14 as writeToFile_alias_1 }
+export { _default_16 as default_alias_15 }
+export { _default_16 as writeToFile }
+export { _default_16 as writeToFile_alias_1 }
 
 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 name: "askFollowupQuestion";
+        readonly description: "Call this when vital details are missing. Pose each follow-up as one direct, unambiguous question. If it speeds the reply, add up to five short, mutually-exclusive answer options. Group any related questions in the same call to avoid a back-and-forth chain.";
         readonly parameters: z.ZodObject<{
-            result: z.ZodString;
+            questions: z.ZodArray<z.ZodObject<{
+                prompt: z.ZodString;
+                options: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>;
     }, 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.";
+    name: "askFollowupQuestion";
+    description: "Call this when vital details are missing. Pose each follow-up as one direct, unambiguous question. If it speeds the reply, add up to five short, mutually-exclusive answer options. Group any related questions in the same call to avoid a back-and-forth chain.";
     parameters: z.ZodObject<{
-        result: z.ZodString;
+        questions: z.ZodArray<z.ZodObject<{
+            prompt: z.ZodString;
+            options: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
 };
-export { _default_2 as attemptCompletion }
-export { _default_2 as attemptCompletion_alias_1 }
+export { _default_2 as askFollowupQuestion }
+export { _default_2 as askFollowupQuestion_alias_1 }
 export { _default_2 as default_alias_1 }
 
 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>;
-    }, 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>;
-};
-export { _default_3 as default_alias_2 }
-export { _default_3 as delegate }
-export { _default_3 as delegate_alias_1 }
-
-declare const _default_4: {
-    handler: ToolHandler<{
-        readonly name: "execute_command";
+        readonly name: "executeCommand";
         readonly description: "Run a single CLI command. The command is always executed in the project-root working directory (regardless of earlier commands). Prefer one-off shell commands over wrapper scripts for flexibility. **IMPORTANT**: After an `execute_command` call, you MUST stop and NOT allowed to make further tool calls in the same message.";
         readonly parameters: z.ZodObject<{
             command: z.ZodString;
             requiresApproval: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
         }, z.core.$strip>;
     }, CommandProvider>;
-    isAvailable: (provider: CommandProvider) => boolean;
-    name: "execute_command";
+    name: "executeCommand";
     description: "Run a single CLI command. The command is always executed in the project-root working directory (regardless of earlier commands). Prefer one-off shell commands over wrapper scripts for flexibility. **IMPORTANT**: After an `execute_command` call, you MUST stop and NOT allowed to make further tool calls in the same message.";
     parameters: z.ZodObject<{
         command: z.ZodString;
         requiresApproval: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
     }, z.core.$strip>;
 };
-export { _default_4 as default_alias_3 }
-export { _default_4 as executeCommand }
-export { _default_4 as executeCommand_alias_1 }
+export { _default_3 as default_alias_2 }
+export { _default_3 as executeCommand }
+export { _default_3 as executeCommand_alias_1 }
 
-declare const _default_5: {
+declare const _default_4: {
     handler: ToolHandler<{
-        readonly name: "fetch_url";
+        readonly name: "fetchUrl";
         readonly description: "Fetch the content located at one or more HTTP(S) URLs and return it in Markdown format. This works for standard web pages as well as raw files (e.g. README.md, source code) hosted on platforms like GitHub.";
         readonly parameters: z.ZodObject<{
             url: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
         }, z.core.$strip>;
     }, WebProvider>;
-    isAvailable: (provider: WebProvider) => boolean;
-    name: "fetch_url";
+    name: "fetchUrl";
     description: "Fetch the content located at one or more HTTP(S) URLs and return it in Markdown format. This works for standard web pages as well as raw files (e.g. README.md, source code) hosted on platforms like GitHub.";
     parameters: z.ZodObject<{
         url: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
 };
-export { _default_5 as default_alias_4 }
-export { _default_5 as fetchUrl }
-export { _default_5 as fetchUrl_alias_1 }
-
-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>;
-    }, 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>;
-};
-export { _default_6 as default_alias_5 }
-export { _default_6 as handOver }
-export { _default_6 as handOver_alias_1 }
+export { _default_4 as default_alias_3 }
+export { _default_4 as fetchUrl }
+export { _default_4 as fetchUrl_alias_1 }
 
-declare const _default_7: {
+declare const _default_5: {
     handler: ToolHandler<{
-        readonly name: "list_files";
+        readonly name: "listFiles";
         readonly description: "Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.";
         readonly parameters: z.ZodObject<{
             path: z.ZodString;
@@ -595,8 +308,7 @@ declare const _default_7: {
             includeIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
         }, z.core.$strip>;
     }, FilesystemProvider>;
-    isAvailable: (provider: FilesystemProvider) => boolean;
-    name: "list_files";
+    name: "listFiles";
     description: "Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.";
     parameters: z.ZodObject<{
         path: z.ZodString;
@@ -605,49 +317,79 @@ declare const _default_7: {
         includeIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
     }, z.core.$strip>;
 };
-export { _default_7 as default_alias_6 }
-export { _default_7 as listFiles }
-export { _default_7 as listFiles_alias_1 }
+export { _default_5 as default_alias_4 }
+export { _default_5 as listFiles }
+export { _default_5 as listFiles_alias_1 }
 
-declare const _default_8: {
+declare const _default_6: {
+    handler: ToolHandler<{
+        readonly name: "listMemoryTopics";
+        readonly description: "Lists all topics in memory.";
+        readonly parameters: z.ZodObject<{}, z.core.$strip>;
+    }, MemoryProvider>;
+    name: "listMemoryTopics";
+    description: "Lists all topics in memory.";
+    parameters: z.ZodObject<{}, z.core.$strip>;
+};
+export { _default_6 as default_alias_5 }
+export { _default_6 as listMemoryTopics }
+export { _default_6 as listMemoryTopics_alias_1 }
+
+declare const _default_7: {
     handler: ToolHandler<{
-        readonly name: "read_binary_file";
+        readonly name: "readBinaryFile";
         readonly description: "Read a binary file from a URL or local path. Use file:// prefix to access local files. This can be used to access non-text files such as PDFs or images.";
         readonly parameters: z.ZodObject<{
             url: z.ZodString;
         }, z.core.$strip>;
     }, FilesystemProvider>;
-    isAvailable: (provider: FilesystemProvider) => boolean;
-    name: "read_binary_file";
+    name: "readBinaryFile";
     description: "Read a binary file from a URL or local path. Use file:// prefix to access local files. This can be used to access non-text files such as PDFs or images.";
     parameters: z.ZodObject<{
         url: z.ZodString;
     }, z.core.$strip>;
 };
-export { _default_8 as default_alias_7 }
-export { _default_8 as readBinaryFile }
-export { _default_8 as readBinaryFile_alias_1 }
+export { _default_7 as default_alias_6 }
+export { _default_7 as readBinaryFile }
+export { _default_7 as readBinaryFile_alias_1 }
 
-declare const _default_9: {
+declare const _default_8: {
     handler: ToolHandler<{
-        readonly name: "read_file";
+        readonly name: "readFile";
         readonly description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.";
         readonly parameters: z.ZodObject<{
             path: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
             includeIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
         }, z.core.$strip>;
     }, FilesystemProvider>;
-    isAvailable: (provider: FilesystemProvider) => boolean;
-    name: "read_file";
+    name: "readFile";
     description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.";
     parameters: z.ZodObject<{
         path: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
         includeIgnored: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodDefault<z.ZodOptional<z.ZodBoolean>>>;
     }, z.core.$strip>;
 };
+export { _default_8 as default_alias_7 }
+export { _default_8 as readFile }
+export { _default_8 as readFile_alias_1 }
+
+declare const _default_9: {
+    handler: ToolHandler<{
+        readonly name: "readMemory";
+        readonly description: "Reads content from a memory topic.";
+        readonly parameters: z.ZodObject<{
+            topic: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, MemoryProvider>;
+    name: "readMemory";
+    description: "Reads content from a memory topic.";
+    parameters: z.ZodObject<{
+        topic: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+};
 export { _default_9 as default_alias_8 }
-export { _default_9 as readFile }
-export { _default_9 as readFile_alias_1 }
+export { _default_9 as readMemory }
+export { _default_9 as readMemory_alias_1 }
 
 /**
  * Returns the directory portion of a path string.
@@ -655,28 +397,6 @@ export { _default_9 as readFile_alias_1 }
  */
 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 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 }
-
 declare type FilesystemProvider = {
     readFile?: (path: string, includeIgnored: boolean) => Promise<string | undefined>;
     writeFile?: (path: string, content: string) => Promise<void>;
@@ -693,142 +413,67 @@ 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;
-}>, 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 }
-
-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.
- * @returns The available tools
- */
-declare const getAvailableTools: <T extends FullToolInfoV2 | FullToolInfo>({ provider, allTools, hasAgent, }: {
-    provider: any;
-    allTools: T[];
-    hasAgent: 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;
-
-export declare const getInt: <T extends string>(args: Partial<Record<T, ToolParameterValue>>, name: T, defaultValue?: number) => number;
-
-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, InteractionProvider>;
+export declare const handler: ToolHandler<typeof toolInfo, MemoryProvider>;
 
 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_10: ToolHandler<typeof toolInfo_alias_10, MemoryProvider>;
 
 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_13: ToolHandler<typeof toolInfo_alias_13, MemoryProvider>;
+
+export declare const handler_alias_14: ToolHandler<typeof toolInfo_alias_14, FilesystemProvider>;
 
-export declare const handler_alias_2: ToolHandler<typeof toolInfo_alias_2, any>;
+export declare const handler_alias_15: ToolHandler<typeof toolInfo_alias_15, FilesystemProvider>;
 
-export declare const handler_alias_3: ToolHandler<typeof toolInfo_alias_3, CommandProvider>;
+export declare const handler_alias_2: ToolHandler<typeof toolInfo_alias_2, CommandProvider>;
 
-export declare const handler_alias_4: ToolHandler<typeof toolInfo_alias_4, WebProvider>;
+export declare const handler_alias_3: ToolHandler<typeof toolInfo_alias_3, WebProvider>;
 
-export declare const handler_alias_5: ToolHandler<typeof toolInfo_alias_5, any>;
+export declare const handler_alias_4: ToolHandler<typeof toolInfo_alias_4, FilesystemProvider>;
+
+export declare const handler_alias_5: ToolHandler<typeof toolInfo_alias_5, MemoryProvider>;
 
 export declare const handler_alias_6: ToolHandler<typeof toolInfo_alias_6, FilesystemProvider>;
 
 export declare const handler_alias_7: ToolHandler<typeof toolInfo_alias_7, FilesystemProvider>;
 
-export declare const handler_alias_8: ToolHandler<typeof toolInfo_alias_8, FilesystemProvider>;
+export declare const handler_alias_8: ToolHandler<typeof toolInfo_alias_8, MemoryProvider>;
 
 export declare const handler_alias_9: ToolHandler<typeof toolInfo_alias_9, FilesystemProvider>;
 
 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: InteractionProvider) => 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: any) => boolean;
-
-export declare const isAvailable_alias_3: (provider: CommandProvider) => boolean;
-
-export declare const isAvailable_alias_4: (provider: WebProvider) => boolean;
-
-export declare const isAvailable_alias_5: (_provider: any) => boolean;
-
-export declare const isAvailable_alias_6: (provider: FilesystemProvider) => 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 interface MemoryProvider {
+    listMemoryTopics: () => Promise<string[]>;
+    readMemory: (topic?: string) => Promise<string | undefined>;
+    appendMemory: (topic: string | undefined, content: string) => Promise<void>;
+    replaceMemory: (topic: string | undefined, content: string) => Promise<void>;
+    removeMemory: (topic: string | undefined) => Promise<void>;
+}
+export { MemoryProvider }
+export { MemoryProvider as MemoryProvider_alias_1 }
+export { MemoryProvider as MemoryProvider_alias_2 }
+
 declare class MockProvider implements ToolProvider {
     readFile(_path: string, _includeIgnored?: boolean): Promise<string>;
     writeFile(_path: string, _content: string): Promise<void>;
@@ -843,7 +488,6 @@ declare class MockProvider implements ToolProvider {
         summary?: string;
     }>;
     askFollowupQuestion(_question: string, _options?: string[]): Promise<string>;
-    attemptCompletion(_result: string): Promise<string | undefined>;
 }
 export { MockProvider }
 export { MockProvider as MockProvider_alias_1 }
@@ -858,99 +502,6 @@ declare type ModelInfo = {
 export { ModelInfo }
 export { ModelInfo as ModelInfo_alias_1 }
 
-declare class MultiAgent {
-    #private;
-    constructor(config: MultiAgentConfig);
-    startTask(options: {
-        agentName: string;
-        task: string;
-        context: string;
-        files?: (ImagePart | FilePart)[];
-    }): Promise<ExitReason>;
-    continueTask(userMessage: UserContent_2): 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;
-
-/**
- * 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 }
-
 declare const parseJsonFromMarkdown: (markdown: string) => ParseOutputResult<any>;
 export { parseJsonFromMarkdown }
 export { parseJsonFromMarkdown as parseJsonFromMarkdown_alias_1 }
@@ -967,13 +518,6 @@ export { ParseOutputResult }
 export { ParseOutputResult as ParseOutputResult_alias_1 }
 export { ParseOutputResult as ParseOutputResult_alias_2 }
 
-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_2 }
@@ -999,238 +543,6 @@ 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";
-
-export declare const rules: (toolNamePrefix: string) => string;
-
-declare type SharedAgentOptions = {
-    ai: LanguageModelV2;
-    os: string;
-    provider: ToolProvider;
-    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;
-    requireToolUse?: boolean;
-};
-export { SharedAgentOptions }
-export { SharedAgentOptions as SharedAgentOptions_alias_1 }
-export { SharedAgentOptions as SharedAgentOptions_alias_2 }
-
-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 | TaskEventToolUse | TaskEventToolResult | TaskEventToolError | 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;
-}
-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 }
-
-declare interface TaskEventToolError extends TaskEventBase {
-    kind: TaskEventKind.ToolError;
-    tool: string;
-    error: ToolResponseError | ToolResponseResult;
-}
-export { TaskEventToolError }
-export { TaskEventToolError as TaskEventToolError_alias_1 }
-export { TaskEventToolError as TaskEventToolError_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 }
-
-declare interface TaskEventToolResult extends TaskEventBase {
-    kind: TaskEventKind.ToolReply | TaskEventKind.ToolInvalid | TaskEventKind.ToolInterrupted;
-    tool: string;
-    content: ToolResponseResult;
-}
-export { TaskEventToolResult }
-export { TaskEventToolResult as TaskEventToolResult_alias_1 }
-export { TaskEventToolResult as TaskEventToolResult_alias_2 }
-
-/**
- * Event for tool-related updates
- */
-declare interface TaskEventToolUse extends TaskEventBase {
-    kind: TaskEventKind.ToolUse;
-    tool: string;
-    params: Record<string, any>;
-}
-export { TaskEventToolUse }
-export { TaskEventToolUse as TaskEventToolUse_alias_1 }
-export { TaskEventToolUse as TaskEventToolUse_alias_2 }
-
-/**
- * Event for API usage updates
- */
-declare interface TaskEventUsage extends TaskEventBase {
-    kind: TaskEventKind.Usage;
-    usage: LanguageModelUsage;
-}
-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 }
@@ -1238,14 +550,22 @@ export { ToolHandler as ToolHandler_alias_1 }
 declare type ToolInfo = {
     name: string;
     description: string;
-    parameters: ToolParameter[];
-    examples?: ToolExample[];
+    parameters: z.ZodObject<any>;
 };
 export { ToolInfo }
 export { ToolInfo as ToolInfo_alias_1 }
 
 export declare const toolInfo: {
-    readonly name: "ask_followup_question";
+    readonly name: "appendMemory";
+    readonly description: "Appends content to a memory topic.";
+    readonly parameters: z.ZodObject<{
+        topic: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        content: z.ZodString;
+    }, z.core.$strip>;
+};
+
+export declare const toolInfo_alias_1: {
+    readonly name: "askFollowupQuestion";
     readonly description: "Call this when vital details are missing. Pose each follow-up as one direct, unambiguous question. If it speeds the reply, add up to five short, mutually-exclusive answer options. Group any related questions in the same call to avoid a back-and-forth chain.";
     readonly parameters: z.ZodObject<{
         questions: z.ZodArray<z.ZodObject<{
@@ -1255,16 +575,16 @@ export declare const toolInfo: {
     }, z.core.$strip>;
 };
 
-export declare const toolInfo_alias_1: {
-    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.";
+export declare const toolInfo_alias_10: {
+    readonly name: "removeMemory";
+    readonly description: "Removes a topic from memory.";
     readonly parameters: z.ZodObject<{
-        result: z.ZodString;
+        topic: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 };
 
-export declare const toolInfo_alias_10: {
-    readonly name: "rename_file";
+export declare const toolInfo_alias_11: {
+    readonly name: "renameFile";
     readonly description: "Request to rename a file from source path to target path.";
     readonly parameters: z.ZodObject<{
         source_path: z.ZodString;
@@ -1272,8 +592,8 @@ export declare const toolInfo_alias_10: {
     }, z.core.$strip>;
 };
 
-export declare const toolInfo_alias_11: {
-    readonly name: "replace_in_file";
+export declare const toolInfo_alias_12: {
+    readonly name: "replaceInFile";
     readonly description: "Request to replace sections of content in an existing file using SEARCH/REPLACE blocks that define exact changes to specific parts of the file. This tool should be used when you need to make targeted changes to specific parts of a file.";
     readonly parameters: z.ZodObject<{
         path: z.ZodString;
@@ -1281,8 +601,17 @@ export declare const toolInfo_alias_11: {
     }, z.core.$strip>;
 };
 
-export declare const toolInfo_alias_12: {
-    readonly name: "search_files";
+export declare const toolInfo_alias_13: {
+    readonly name: "replaceMemory";
+    readonly description: "Replaces content of a memory topic.";
+    readonly parameters: z.ZodObject<{
+        topic: z.ZodOptional<z.ZodString>;
+        content: z.ZodString;
+    }, z.core.$strip>;
+};
+
+export declare const toolInfo_alias_14: {
+    readonly name: "searchFiles";
     readonly description: "Request to perform a regex search across files in a specified directory, outputting context-rich results that include surrounding lines. This tool searches for patterns or specific content across multiple files, displaying each match with encapsulating context.";
     readonly parameters: z.ZodObject<{
         path: z.ZodString;
@@ -1291,8 +620,8 @@ export declare const toolInfo_alias_12: {
     }, z.core.$strip>;
 };
 
-export declare const toolInfo_alias_13: {
-    readonly name: "write_to_file";
+export declare const toolInfo_alias_15: {
+    readonly name: "writeToFile";
     readonly description: "Request to write content to a file at the specified path. If the file exists, it will be overwritten with the provided content. If the file doesn't exist, it will be created. This tool will automatically create any directories needed to write the file. Ensure that the output content does not include incorrect escaped character patterns such as `&lt;`, `&gt;`, or `&amp;`. Also ensure there is no unwanted CDATA tags in the content.";
     readonly parameters: z.ZodObject<{
         path: z.ZodString;
@@ -1301,18 +630,7 @@ export declare const toolInfo_alias_13: {
 };
 
 export declare const toolInfo_alias_2: {
-    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>;
-};
-
-export declare const toolInfo_alias_3: {
-    readonly name: "execute_command";
+    readonly name: "executeCommand";
     readonly description: "Run a single CLI command. The command is always executed in the project-root working directory (regardless of earlier commands). Prefer one-off shell commands over wrapper scripts for flexibility. **IMPORTANT**: After an `execute_command` call, you MUST stop and NOT allowed to make further tool calls in the same message.";
     readonly parameters: z.ZodObject<{
         command: z.ZodString;
@@ -1320,27 +638,16 @@ export declare const toolInfo_alias_3: {
     }, z.core.$strip>;
 };
 
-export declare const toolInfo_alias_4: {
-    readonly name: "fetch_url";
+export declare const toolInfo_alias_3: {
+    readonly name: "fetchUrl";
     readonly description: "Fetch the content located at one or more HTTP(S) URLs and return it in Markdown format. This works for standard web pages as well as raw files (e.g. README.md, source code) hosted on platforms like GitHub.";
     readonly parameters: z.ZodObject<{
         url: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
 };
 
-export declare const toolInfo_alias_5: {
-    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>;
-};
-
-export declare const toolInfo_alias_6: {
-    readonly name: "list_files";
+export declare const toolInfo_alias_4: {
+    readonly name: "listFiles";
     readonly description: "Request to list files and directories within the specified directory. If recursive is true, it will list all files and directories recursively. If recursive is false or not provided, it will only list the top-level contents. Do not use this tool to confirm the existence of files you may have created, as the user will let you know if the files were created successfully or not.";
     readonly parameters: z.ZodObject<{
         path: z.ZodString;
@@ -1350,16 +657,22 @@ export declare const toolInfo_alias_6: {
     }, z.core.$strip>;
 };
 
-export declare const toolInfo_alias_7: {
-    readonly name: "read_binary_file";
+export declare const toolInfo_alias_5: {
+    readonly name: "listMemoryTopics";
+    readonly description: "Lists all topics in memory.";
+    readonly parameters: z.ZodObject<{}, z.core.$strip>;
+};
+
+export declare const toolInfo_alias_6: {
+    readonly name: "readBinaryFile";
     readonly description: "Read a binary file from a URL or local path. Use file:// prefix to access local files. This can be used to access non-text files such as PDFs or images.";
     readonly parameters: z.ZodObject<{
         url: z.ZodString;
     }, z.core.$strip>;
 };
 
-export declare const toolInfo_alias_8: {
-    readonly name: "read_file";
+export declare const toolInfo_alias_7: {
+    readonly name: "readFile";
     readonly description: "Request to read the contents of one or multiple files at the specified paths. Use comma separated paths to read multiple files. Use this when you need to examine the contents of an existing file you do not know the contents of, for example to analyze code, review text files, or extract information from configuration files. May not be suitable for other types of binary files, as it returns the raw content as a string. Try to list all the potential files are relevent to the task, and then use this tool to read all the relevant files.";
     readonly parameters: z.ZodObject<{
         path: z.ZodPipe<z.ZodTransform<string[], unknown>, z.ZodArray<z.ZodString>>;
@@ -1367,22 +680,22 @@ export declare const toolInfo_alias_8: {
     }, z.core.$strip>;
 };
 
+export declare const toolInfo_alias_8: {
+    readonly name: "readMemory";
+    readonly description: "Reads content from a memory topic.";
+    readonly parameters: z.ZodObject<{
+        topic: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+};
+
 export declare const toolInfo_alias_9: {
-    readonly name: "remove_file";
+    readonly name: "removeFile";
     readonly description: "Request to remove a file at the specified path.";
     readonly parameters: z.ZodObject<{
         path: z.ZodString;
     }, z.core.$strip>;
 };
 
-declare type ToolInfoV2 = {
-    name: string;
-    description: string;
-    parameters: z.ZodObject<any>;
-};
-export { ToolInfoV2 }
-export { ToolInfoV2 as ToolInfoV2_alias_1 }
-
 declare type ToolParameter = {
     name: string;
     description: string;
@@ -1400,29 +713,18 @@ declare type ToolParameterValue = string | {
 export { ToolParameterValue }
 export { ToolParameterValue as ToolParameterValue_alias_1 }
 
-declare type ToolProvider = FilesystemProvider & CommandProvider & InteractionProvider & WebProvider;
+declare type ToolProvider = FilesystemProvider & CommandProvider & InteractionProvider & WebProvider & Partial<MemoryProvider>;
 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;
+declare type ToolResponse = ToolResponseReply | ToolResponseExit | ToolResponseError;
 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: ToolResponseResult;
-    canRetry?: boolean;
 };
 export { ToolResponseError }
 export { ToolResponseError as ToolResponseError_alias_1 }
@@ -1435,52 +737,6 @@ declare type ToolResponseExit = {
 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: ToolResponseResult;
-};
-export { ToolResponseInvalid }
-export { ToolResponseInvalid as ToolResponseInvalid_alias_1 }
-
-declare type ToolResponseOrToolPause = {
-    type: 'response';
-    tool: string;
-    response: LanguageModelV2ToolResultOutput;
-    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: ToolResponseResult;
@@ -1522,31 +778,11 @@ export { ToolResponseResultMedia as ToolResponseResultMedia_alias_1 }
 declare enum ToolResponseType {
     Reply = "Reply",
     Exit = "Exit",
-    Invalid = "Invalid",
-    Error = "Error",
-    Interrupted = "Interrupted",
-    HandOver = "HandOver",
-    Delegate = "Delegate",
-    Pause = "Pause"
+    Error = "Error"
 }
 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;
@@ -1555,17 +791,6 @@ declare type Totals = {
     messageCount: 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.