import { AFS, type AFSExecOptions, type AFSExecResult, type AFSListOptions, type AFSListResult, type AFSModule, type AFSOptions, type AFSReadResult, type AFSSearchOptions } from "@aigne/afs";
import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
import type * as prompts from "@inquirer/prompts";
import { type ZodObject, type ZodType, z } from "zod";
import type { AgentEvent, Context, UserContext } from "../aigne/context.js";
import type { MessagePayload } from "../aigne/message-queue.js";
import type { ContextUsage } from "../aigne/usage.js";
import type { Memory, MemoryAgent } from "../memory/memory.js";
import type { MemoryRecorderInput } from "../memory/recorder.js";
import type { MemoryRetrieverInput } from "../memory/retriever.js";
import { type Nullish, type PromiseOrValue, type XOr } from "../utils/type-utils.js";
import type { ChatModel, ChatModelInputMessage } from "./chat-model.js";
import type { GuideRailAgent, GuideRailAgentOutput } from "./guide-rail-agent.js";
import type { ImageModel } from "./image-model.js";
import { type GetterSchema, type TransferAgentOutput } from "./types.js";
export * from "./types.js";
export declare const DEFAULT_INPUT_ACTION_GET = "$get";
/**
 * Basic message type that can contain any key-value pairs
 */
export interface Message extends Record<string, unknown> {
    $meta?: {
        usage?: ContextUsage;
        [key: string]: unknown;
    };
}
/**
 * Topics the agent subscribes to, can be a single topic string or an array of topic strings
 */
export type SubscribeTopic = string | string[];
/**
 * Topics the agent publishes to, can be:
 * - A single topic string
 * - An array of topic strings
 * - A function that receives the output and returns topic(s)
 *
 * @template O The agent output message type
 */
export type PublishTopic<O extends Message> = string | string[] | ((output: O) => PromiseOrValue<Nullish<string | string[]>>);
export type TaskRenderMode = "hide" | "collapse";
/**
 * Configuration options for an agent
 *
 * @template I The agent input message type
 * @template O The agent output message type
 */
export interface AgentOptions<I extends Message = Message, O extends Message = Message> extends Partial<Pick<Agent, "guideRails">> {
    /**
     * Topics the agent should subscribe to
     *
     * These topics determine which messages the agent will receive
     * from the system
     */
    subscribeTopic?: SubscribeTopic;
    /**
     * Topics the agent should publish to
     *
     * These topics determine where the agent's output messages
     * will be sent in the system
     */
    publishTopic?: PublishTopic<O>;
    /**
     * Name of the agent
     *
     * Used for identification and logging. Defaults to the constructor name
     * if not specified
     */
    name?: string;
    /**
     * Alias for the agent, can be used to refer to the agent by multiple names, especially in AIGNE CLI
     */
    alias?: string[];
    /**
     * Description of the agent
     *
     * A human-readable description of what the agent does, useful
     * for documentation and debugging
     */
    description?: string;
    model?: ChatModel;
    imageModel?: ImageModel;
    taskTitle?: string | ((input: I) => PromiseOrValue<string | undefined>);
    taskRenderMode?: TaskRenderMode;
    /**
     * Zod schema defining the input message structure
     *
     * Used to validate that input messages conform to the expected format
     */
    inputSchema?: AgentInputOutputSchema<I>;
    /**
     * Default input message for the agent, it can be used to provide partial input
     * or default values for the agent's input schema.
     */
    defaultInput?: Agent<I, O>["defaultInput"];
    /**
     * Zod schema defining the output message structure
     *
     * Used to validate that output messages conform to the expected format
     */
    outputSchema?: AgentInputOutputSchema<O>;
    /**
     * Whether to include input in the output
     *
     * When true, the agent will merge input fields into the output object
     */
    includeInputInOutput?: boolean;
    /**
     * List of skills (other agents or functions) this agent has
     *
     * These skills can be used by the agent to delegate tasks or
     * extend its capabilities
     */
    skills?: (Agent | FunctionAgentFn)[];
    /**
     * Whether to disable emitting events for agent actions
     *
     * When true, the agent won't emit events like agentStarted,
     * agentSucceed, or agentFailed
     */
    disableEvents?: boolean;
    /**
     * One or more memory agents this agent can use
     */
    memory?: MemoryAgent | MemoryAgent[];
    afs?: true | AFSOptions | AFS | ((afs: AFS) => AFS);
    asyncMemoryRecord?: boolean;
    /**
     * Maximum number of memory items to retrieve
     */
    maxRetrieveMemoryCount?: number;
    hooks?: AgentHooks<I, O> | AgentHooks<I, O>[];
    retryOnError?: Agent<I, O>["retryOnError"] | boolean;
}
export declare const agentOptionsSchema: ZodObject<{
    [key in keyof AgentOptions]: ZodType<AgentOptions[key]>;
}>;
export interface AgentInvokeOptions<U extends UserContext = UserContext> {
    /**
     * The execution context for the agent
     *
     * The context provides the runtime environment for agent execution, including:
     * - Event emission and subscription management
     * - Inter-agent communication and message passing
     * - Resource usage tracking and limits enforcement
     * - Timeout and status management
     * - Memory and state management across agent invocations
     *
     * Each agent invocation requires a context to coordinate with the broader
     * agent system and maintain proper isolation and resource control.
     */
    context: Context<U>;
    model?: ChatModel;
    imageModel?: ImageModel;
    /**
     * Whether to enable streaming response
     *
     * When true, the invoke method returns a ReadableStream that emits
     * chunks of the response as they become available, allowing for
     * real-time display of results
     *
     * When false or undefined, the invoke method waits for full completion
     * and returns the final JSON result
     */
    streaming?: boolean;
    /**
     * Optional hooks for agent invocation
     */
    hooks?: AgentHooks<any, any> | AgentHooks<any, any>[];
    /**
     * @inquirer/prompts used for collecting user input during agent execution
     *
     * This property only exists in the CLI context by command `aigne run`
     */
    prompts?: typeof prompts;
    /**
     * The caller agent that invoked this agent
     */
    caller?: Agent;
}
/**
 * Agent is the base class for all agents.
 * It provides a mechanism for defining input/output schemas and implementing processing logic,
 * serving as the foundation of the entire agent system.
 *
 * By extending the Agent class and implementing the process method, you can create custom agents
 * with various capabilities:
 * - Process structured input and output data
 * - Validate data formats using schemas
 * - Communicate between agents through contexts
 * - Support streaming or non-streaming responses
 * - Maintain memory of past interactions
 * - Output in multiple formats (JSON/text)
 * - Forward tasks to other agents
 *
 * @template I The input message type the agent accepts
 * @template O The output message type the agent returns
 *
 * @example
 * Here's an example of how to create a custom agent:
 * {@includeCode ../../test/agents/agent.test.ts#example-custom-agent}
 */
export declare abstract class Agent<I extends Message = any, O extends Message = any> implements AFSModule {
    /**
     * Custom object inspection behavior
     *
     * When using Node.js's util.inspect function to inspect an agent,
     * only the agent's name will be shown, making output more concise
     *
     * @returns Agent name
     */
    [nodejs.customInspect]: () => string;
    static load<I extends Message = any, O extends Message = any>(_options: {
        filepath: string;
        parsed: object;
    }): Promise<Agent<I, O>>;
    constructor(options?: AgentOptions<I, O>);
    afs?: AFS;
    tag?: string;
    /**
     * List of memories this agent can use
     *
     * @deprecated use afs instead
     */
    readonly memories: MemoryAgent[];
    asyncMemoryRecord?: boolean;
    /**
     * Maximum number of memory items to retrieve
     */
    maxRetrieveMemoryCount?: number;
    /**
     * Lifecycle hooks for agent processing.
     *
     * Hooks enable tracing, logging, monitoring, and custom behavior
     * without modifying the core agent implementation
     *
     * @example
     * Here's an example of using hooks:
     * {@includeCode ../../test/agents/agent.test.ts#example-agent-hooks}
     */
    readonly hooks: AgentHooks<I, O>[];
    retryOnError?: {
        retries?: number;
        minTimeout?: number;
        factor?: number;
        randomize?: boolean;
        shouldRetry?: (error: Error) => boolean | Promise<boolean>;
    };
    /**
     * List of GuideRail agents applied to this agent
     *
     * GuideRail agents validate, transform, or control the message flow by:
     * - Enforcing rules and safety policies
     * - Validating inputs/outputs against specific criteria
     * - Implementing business logic validations
     * - Monitoring and auditing agent behavior
     *
     * Each GuideRail agent can examine both input and expected output,
     * and has the ability to abort the process with an explanation
     *
     * @example
     * Here's an example of using GuideRail agents:
     *
     * {@includeCode ../../test/agents/agent.test.ts#example-agent-guide-rails}
     */
    readonly guideRails?: GuideRailAgent[];
    /**
     * Name of the agent, used for identification and logging
     *
     * Defaults to the class constructor name if not specified in options
     */
    readonly name: string;
    /**
     * Alias for the agent, can be used to refer to the agent by multiple names, especially in AIGNE CLI
     */
    readonly alias?: string[];
    /**
     * Default topic this agent subscribes to
     *
     * Each agent has a default topic in the format "$agent_[agent name]"
     * The agent automatically subscribes to this topic to receive messages
     *
     * @returns The default topic string
     */
    get topic(): string;
    /**
     * Description of the agent's purpose and capabilities
     *
     * Useful for documentation and when agents need to understand
     * each other's roles in a multi-agent system
     */
    readonly description?: string;
    model?: ChatModel;
    imageModel?: ImageModel;
    taskTitle?: string | ((input: Message) => PromiseOrValue<string | undefined>);
    renderTaskTitle(input: I): Promise<string | undefined>;
    taskRenderMode?: TaskRenderMode;
    private readonly _inputSchema?;
    defaultInput?: GetterSchema<I>;
    private readonly _outputSchema?;
    /**
     * Get the input data schema for this agent
     *
     * Used to validate that input messages conform to required format
     * If no input schema is set, returns an empty object schema by default
     *
     * @returns The Zod type definition for input data
     */
    get inputSchema(): ZodType<I>;
    get inputKeys(): string[];
    /**
     * Get the output data schema for this agent
     *
     * Used to validate that output messages conform to required format
     * If no output schema is set, returns an empty object schema by default
     *
     * @returns The Zod type definition for output data
     */
    get outputSchema(): ZodType<O>;
    get outputKeys(): string[];
    /**
     * Whether to include the original input in the output
     *
     * When true, the agent will merge input fields into the output object
     */
    readonly includeInputInOutput?: boolean;
    /**
     * Topics the agent subscribes to for receiving messages
     *
     * Can be a single topic string or an array of topic strings
     */
    readonly subscribeTopic?: SubscribeTopic;
    /**
     * Topics the agent publishes to for sending messages
     *
     * Can be a string, array of strings, or a function that determines
     * topics based on the output
     */
    readonly publishTopic?: PublishTopic<Message>;
    /**
     * Collection of skills (other agents) this agent can use
     *
     * Skills can be accessed by name or by array index, allowing
     * the agent to delegate tasks to specialized sub-agents
     */
    readonly skills: Agent<any, any>[] & {
        [key: string]: Agent<any, any>;
    };
    /**
     * Whether to disable emitting events for agent actions
     *
     * When true, the agent won't emit events like agentStarted,
     * agentSucceed, or agentFailed
     */
    private disableEvents?;
    private subscriptions;
    /**
     * Attach agent to context:
     * - Subscribe to topics and invoke process method when messages are received
     * - Subscribe to memory topics if memory is enabled
     *
     * Agents can receive messages and respond through the topic subscription system,
     * enabling inter-agent communication.
     *
     * @param context Context to attach to
     */
    attach(context: Pick<Context, "subscribe">): void;
    protected subscribeToTopics(context: Pick<Context, "subscribe">): void;
    onMessage({ message, context }: MessagePayload): Promise<void>;
    /**
     * Add skills (other agents or functions) to this agent
     *
     * Skills allow agents to reuse functionality from other agents,
     * building more complex behaviors.
     *
     * @param skills List of skills to add, can be Agent instances or functions
     */
    addSkill(...skills: (Agent | FunctionAgentFn)[]): void;
    /**
     * Check if the agent is invokable
     *
     * An agent is invokable if it has implemented the process method
     */
    get isInvokable(): boolean;
    /**
     * Check context status to ensure it hasn't timed out
     *
     * @param options Invocation options containing context
     * @throws Error if the context has timed out
     */
    private checkContextStatus;
    private newDefaultContext;
    retrieveMemories(input: Pick<MemoryRetrieverInput, "limit"> & {
        search?: Message | string;
    }, options: Pick<AgentInvokeOptions, "context">): Promise<Pick<Memory, "content">[]>;
    recordMemories(input: MemoryRecorderInput, options: Pick<AgentInvokeOptions, "context">): Promise<void>;
    /**
     * Invoke the agent with regular (non-streaming) response
     *
     * Regular mode waits for the agent to complete processing and return the final result,
     * suitable for scenarios where a complete result is needed at once.
     *
     * @param input Input message to the agent
     * @param options Invocation options, must set streaming to false or leave unset
     * @returns Final JSON response
     *
     * @example
     * Here's an example of invoking an agent with regular mode:
     * {@includeCode ../../test/agents/agent.test.ts#example-invoke}
     */
    invoke(input: I & Message, options?: Partial<AgentInvokeOptions> & {
        streaming?: false;
    }): Promise<O>;
    /**
     * Invoke the agent with streaming response
     *
     * Streaming responses allow the agent to return results incrementally,
     * suitable for scenarios requiring real-time progress updates, such as
     * chat bot typing effects.
     *
     * @param input Input message to the agent
     * @param options Invocation options, must set streaming to true for this overload
     * @returns Streaming response object
     *
     * @example
     * Here's an example of invoking an agent with streaming response:
     * {@includeCode ../../test/agents/agent.test.ts#example-invoke-streaming}
     */
    invoke(input: I & Message, options: Partial<AgentInvokeOptions> & {
        streaming: true;
    }): Promise<AgentResponseStream<O>>;
    /**
     * General signature for invoking the agent
     *
     * Returns either streaming or regular response based on the streaming parameter in options
     *
     * @param input Input message to the agent
     * @param options Invocation options
     * @returns Agent response (streaming or regular)
     */
    invoke(input: I & Message, options?: Partial<AgentInvokeOptions>): Promise<AgentResponse<O>>;
    private processStreamingAndRetry;
    private callHooks;
    private mergeDefaultInput;
    protected invokeSkill<I extends Message, O extends Message>(skill: Agent<I, O>, input: I & Message, options: AgentInvokeOptions): Promise<O>;
    protected invokeChildAgent: Context["invoke"];
    /**
     * Process agent output
     *
     * Validates output format, applies post-processing operations, and triggers success events
     *
     * @param input Original input message
     * @param output Raw output produced by the agent
     * @param options Invocation options
     * @returns Final processed output
     */
    protected processAgentOutput(input: I, output: Exclude<AgentResponse<O>, AgentResponseStream<O>>, { messages, ...options }: AgentInvokeOptions & {
        messages?: ChatModelInputMessage[];
    }): Promise<O>;
    /**
     * Process errors that occur during agent execution
     *
     * Logs error information, triggers failure events, and re-throws the error
     *
     * @param error Caught error
     * @param options Invocation options
     */
    private processAgentError;
    /**
     * Check agent invocation usage to prevent exceeding limits
     *
     * If the context has a maximum invocation limit set, checks if the limit
     * has been exceeded and increments the invocation counter
     *
     * @param options Invocation options containing context and limits
     * @throws Error if maximum invocation limit is exceeded
     */
    protected checkAgentInvokesUsage(options: AgentInvokeOptions): void;
    /**
     * Pre-processing operations before handling input
     *
     * Preparatory work done before executing the agent's main processing logic, including:
     * - Checking context status
     * - Verifying invocation limits
     *
     * @param _ Input message (unused)
     * @param options Options for agent invocation
     */
    protected preprocess(_: I, options: AgentInvokeOptions): Promise<void>;
    private checkResponseByGuideRails;
    private runGuideRails;
    /**
     * Handle errors detected by GuideRail agents
     *
     * This method is called when a GuideRail agent aborts the process, providing
     * a way for agents to customize error handling behavior. By default, it simply
     * returns the original error, but subclasses can override this method to:
     * - Transform the error into a more specific response
     * - Apply recovery strategies
     * - Log or report the error in a custom format
     * - Return a fallback output instead of an error
     *
     * @param error The GuideRail agent output containing abort=true and a reason
     * @returns Either the original/modified error or a substitute output object
     *          which will be tagged with $status: "GuideRailError"
     */
    protected onGuideRailError(error: GuideRailAgentOutput): Promise<O | GuideRailAgentOutput>;
    /**
     * Post-processing operations after handling output
     *
     * Operations performed after the agent produces output, including:
     * - Checking context status
     * - Adding interaction records to memory
     *
     * @param input Input message
     * @param output Output message
     * @param options Options for agent invocation
     */
    protected postprocess(input: I, output: O, options: AgentInvokeOptions): Promise<void>;
    protected publishToTopics(output: Message, options: AgentInvokeOptions): Promise<void>;
    formatOutput(output: O): PromiseOrValue<string>;
    /**
     * Core processing method of the agent, must be implemented in subclasses
     *
     * This is the main functionality implementation of the agent, processing input and
     * generating output. Can return various types of results:
     * - Regular object response
     * - Streaming response
     * - Async generator
     * - Another agent instance (transfer agent)
     *
     * @param input Input message
     * @param options Options for agent invocation
     * @returns Processing result
     *
     * @example
     * Example of returning a direct object:
     * {@includeCode ../../test/agents/agent.test.ts#example-process-direct-response}
     *
     * @example
     * Example of returning a streaming response:
     * {@includeCode ../../test/agents/agent.test.ts#example-process-streaming-response}
     *
     * @example
     * Example of using an async generator:
     * {@includeCode ../../test/agents/agent.test.ts#example-process-async-generator}
     *
     * @example
     * Example of transfer to another agent:
     * {@includeCode ../../test/agents/agent.test.ts#example-process-transfer}
     */
    abstract process(input: I, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
    /**
     * Shut down the agent and clean up resources
     *
     * Primarily used to clean up memory and other resources to prevent memory leaks
     *
     * @example
     * Here's an example of shutting down an agent:
     * {@includeCode ../../test/agents/agent.test.ts#example-agent-shutdown}
     *
     * @example
     * Here's an example of shutting down an agent by using statement:
     * {@includeCode ../../test/agents/agent.test.ts#example-agent-shutdown-by-using}
     */
    shutdown(): Promise<void>;
    /**
     * Async dispose method for shutdown the agent
     *
     * @example
     * Here's an example of shutting down an agent by using statement:
     * {@includeCode ../../test/agents/agent.test.ts#example-agent-shutdown-by-using}
     */
    [Symbol.asyncDispose](): Promise<void>;
    /** For AFSModule interface **/
    private agentToAFSEntry;
    private findAgentByAFSPath;
    list(_path: string, _options?: AFSListOptions): Promise<AFSListResult>;
    read(path: string): Promise<AFSReadResult>;
    search(path: string, _query: string, options?: AFSSearchOptions): Promise<AFSListResult>;
    exec(path: string, args: Record<string, any>, options: AFSExecOptions): Promise<AFSExecResult>;
}
export type AgentInput<T extends Agent> = T extends Agent<infer I, any> ? I : never;
export type AgentOutput<T extends Agent> = T extends Agent<any, infer O> ? O : never;
/**
 * Lifecycle hooks for agent execution
 *
 * Hooks provide a way to intercept and extend agent behavior at key points during
 * the agent's lifecycle, enabling custom functionality like logging, monitoring,
 * tracing, error handling, and more.
 */
export interface AgentHooks<I extends Message = Message, O extends Message = Message> {
    priority?: "low" | "medium" | "high";
    /**
     * Called when agent processing begins
     *
     * This hook runs before the agent processes input, allowing for
     * setup operations, logging, or input transformations.
     *
     * @param event Object containing the input message
     */
    onStart?: ((event: {
        context: Context;
        agent: Agent;
        input: I;
    }) => PromiseOrValue<void | {
        input?: I;
        options?: any;
    }>) | Agent<{
        input: I;
    }, {
        input?: I;
        options?: any;
    }>;
    /**
     * Called when agent processing completes or fails
     *
     * This hook runs after processing finishes, receiving either the output
     * or an error if processing failed. Useful for cleanup operations,
     * logging results, or error handling.
     *
     * @param event Object containing the input message and either output or error
     */
    onEnd?: ((event: XOr<{
        context: Context;
        agent: Agent;
        input: I;
        output: O;
        error: Error;
    }, "output", "error">) => PromiseOrValue<void | {
        output?: O;
        retry?: boolean;
    }>) | Agent<XOr<{
        input: I;
        output: O;
        error: Error;
    }, "output", "error">, {
        output?: O;
        retry?: boolean;
    }>;
    onSuccess?: ((event: {
        context: Context;
        agent: Agent;
        input: I;
        output: O;
    }) => PromiseOrValue<void | {
        output?: O;
    }>) | Agent<{
        input: I;
        output: O;
    }, {
        output?: O;
    }>;
    onError?: ((event: {
        context: Context;
        agent: Agent;
        input: I;
        error: Error;
    }) => PromiseOrValue<void | {
        retry?: boolean;
    }>) | Agent<{
        input: I;
        error: Error;
    }, {
        retry?: boolean;
    }>;
    /**
     * Called before a skill (sub-agent) is invoked
     *
     * This hook runs when the agent delegates work to a skill,
     * allowing for tracking skill usage or transforming input to the skill.
     *
     * @param event Object containing the skill being used and input message
     */
    onSkillStart?: ((event: {
        context: Context;
        agent: Agent;
        skill: Agent;
        input: Message;
    }) => PromiseOrValue<void>) | Agent<{
        skill: Agent;
        input: Message;
    }>;
    /**
     * Called after a skill (sub-agent) completes or fails
     *
     * This hook runs when a skill finishes execution, receiving either the output
     * or an error if the skill failed. Useful for monitoring skill performance
     * or handling skill-specific errors.
     *
     * @param event Object containing the skill used, input message, and either output or error
     */
    onSkillEnd?: ((event: XOr<{
        context: Context;
        agent: Agent;
        skill: Agent;
        input: Message;
        output: Message;
        error: Error;
    }, "output", "error">) => PromiseOrValue<void>) | Agent<XOr<{
        skill: Agent;
        input: Message;
        output: Message;
        error: Error;
    }, "output", "error">>;
    /**
     * Called when an agent hands off processing to another agent
     *
     * This hook runs when a source agent transfers control to a target agent,
     * allowing for tracking of handoffs between agents and monitoring the flow
     * of processing in multi-agent systems.
     *
     * @param event Object containing the source agent, target agent, and input message
     */
    onHandoff?: ((event: {
        context: Context;
        source: Agent;
        target: Agent;
        input: I;
    }) => PromiseOrValue<void>) | Agent<{
        source: Agent;
        target: Agent;
        input: I;
    }>;
}
export type AgentHookInput<H extends keyof AgentHooks, Hook extends AgentHooks[H] = AgentHooks[H]> = Hook extends (input: infer I) => any ? Omit<I, "context" | "agent"> : never;
export type AgentHookOutput<H extends keyof AgentHooks, Hook extends AgentHooks[H] = AgentHooks[H]> = Hook extends (...args: any[]) => any ? Exclude<Awaited<ReturnType<Hook>>, void> | undefined : never;
/**
 * Response type for an agent, can be:
 * - Direct response object
 * - Output transferred to another agent
 * - Streaming response
 *
 * @template T Response data type
 */
export type AgentResponse<T> = T | AgentResponseStream<T> | TransferAgentOutput | GuideRailAgentOutput;
/**
 * Streaming response type for an agent
 *
 * @template T Response data type
 */
export type AgentResponseStream<T> = ReadableStream<AgentResponseChunk<T>>;
/**
 * Data chunk type for streaming responses
 *
 * @template T Response data type
 */
export type AgentResponseChunk<T> = AgentResponseDelta<T> | AgentResponseProgress;
/**
 * Check if a response chunk is empty
 *
 * @template T Response data type
 * @param chunk The response chunk to check
 * @returns True if the chunk is empty
 */
export declare function isEmptyChunk<T>(chunk: AgentResponseChunk<T>): boolean;
/**
 * Incremental data structure for agent responses
 *
 * Used to represent a single incremental update in a streaming response
 *
 * @template T Response data type
 * @property delta.text - Text format incremental update
 * @property delta.json - JSON format incremental update
 */
export interface AgentResponseDelta<T> {
    delta: {
        text?: Partial<{
            [key in keyof T as Extract<T[key], string> extends string ? key : never]: string;
        }> | Partial<{
            [key: string]: string;
        }>;
        json?: Partial<T> | TransferAgentOutput;
    };
}
export declare function isAgentResponseDelta<T>(chunk: AgentResponseChunk<T>): chunk is AgentResponseDelta<T>;
export interface AgentResponseProgress {
    progress: ({
        event: "agentStarted";
        input: Message;
        taskTitle?: string;
    } | {
        event: "agentSucceed";
        output: Message;
    } | {
        event: "agentFailed";
        error: Error;
    } | {
        event: "message";
        message: ChatModelInputMessage;
    }) & Omit<AgentEvent, "agent"> & {
        agent: {
            name: string;
        };
    };
}
export type AgentResponseProgressMessageItem = {
    type: "text";
    content: string;
} | {
    type: "thinking";
    thoughts: string;
} | {
    type: "tool_use";
    toolUseId: string;
    name: string;
    input: unknown;
} | {
    type: "tool_result";
    toolUseId: string;
    content: unknown;
};
export declare function isAgentResponseProgress<T>(chunk: AgentResponseChunk<T>): chunk is AgentResponseProgress;
/**
 * Creates a text delta for streaming responses
 *
 * This utility function creates an AgentResponseDelta object with only the text part,
 * useful for incrementally building streaming text responses in agents.
 *
 * @template T Agent message type extending Message
 * @param textDelta The text content to include in the delta update
 * @returns An AgentResponseDelta with the text delta wrapped in the expected structure
 */
export declare function textDelta<T extends Message>(textDelta: NonNullable<AgentResponseDelta<T>["delta"]["text"]>): AgentResponseDelta<T>;
/**
 * Creates a JSON delta for streaming responses
 *
 * This utility function creates an AgentResponseDelta object with only the JSON part,
 * useful for incrementally building structured data responses in streaming mode.
 *
 * @template T Agent message type extending Message
 * @param jsonDelta The JSON data to include in the delta update
 * @returns An AgentResponseDelta with the JSON delta wrapped in the expected structure
 */
export declare function jsonDelta<T extends Message>(jsonDelta: NonNullable<AgentResponseDelta<T>["delta"]["json"]>): AgentResponseDelta<T>;
/**
 * Async generator type for agent processing
 *
 * Used to generate streaming response data
 *
 * @template O Agent output message type
 */
export type AgentProcessAsyncGenerator<O extends Message> = AsyncGenerator<AgentResponseChunk<O>, Partial<O> | TransferAgentOutput | undefined | void>;
/**
 * Result type for agent processing method, can be:
 * - Direct or streaming response
 * - Async generator
 * - Another agent instance (for task forwarding)
 *
 * @template O Agent output message type
 */
export type AgentProcessResult<O extends Message> = AgentResponse<O> | AgentProcessAsyncGenerator<O> | Agent;
export declare function agentProcessResultToObject<O extends Message>(response: AgentProcessResult<O>): Promise<O>;
/**
 * Schema definition type for agent input/output
 *
 * Can be a Zod type definition or a function that returns a Zod type
 *
 * @template I Agent input/output message type
 */
export type AgentInputOutputSchema<I extends Message = Message> = ZodType<I> | ((agent: Agent) => ZodType<I>);
/**
 * Configuration options for a function agent
 *
 * Extends the base agent options and adds function implementation
 *
 * @template I Agent input message type
 * @template O Agent output message type
 */
export interface FunctionAgentOptions<I extends Message = Message, O extends Message = Message> extends AgentOptions<I, O> {
    /**
     * Function implementing the agent's processing logic
     *
     * This function is called by the process method to handle input
     * and generate output
     */
    process: FunctionAgentFn<I, O>;
}
/**
 * Function agent class, implements agent logic through a function
 *
 * Provides a convenient way to create agents using functions without
 * needing to extend the Agent class
 *
 * @template I Agent input message type
 * @template O Agent output message type
 *
 * @example
 * Here's an example of creating a function agent:
 * {@includeCode ../../test/agents/agent.test.ts#example-function-agent}
 */
export declare class FunctionAgent<I extends Message = Message, O extends Message = Message> extends Agent<I, O> {
    tag: string;
    static schema(): ZodObject<{
        process: ZodType<FunctionAgentFn>;
    }, "strip", z.ZodTypeAny, {
        process: FunctionAgentFn<any, any, FunctionAgent<any, any>>;
    }, {
        process: FunctionAgentFn<any, any, FunctionAgent<any, any>>;
    }>;
    static load<I extends Message = any, O extends Message = any>(options: {
        filepath: string;
        parsed: object;
    }): Promise<Agent<I, O>>;
    /**
     * Create a function agent from a function or options
     *
     * Provides a convenient factory method to create an agent directly from a function
     *
     * @param options Function agent options or function
     * @returns New function agent instance
     *
     * @example
     * Here's an example of creating a function agent from a function:
     * {@includeCode ../../test/agents/agent.test.ts#example-function-agent-from-function}
     *
     * @example
     * Here's an example of creating a function agent without basic agent options:
     * {@includeCode ../../test/agents/agent.test.ts#example-function-agent}
     *
     * @example
     * Here's an example of creating a function agent from a function returning a stream:
     * {@includeCode ../../test/agents/agent.test.ts#example-function-agent-stream}
     *
     * @example
     * Here's an example of creating a function agent from a function returning an async generator:
     * {@includeCode ../../test/agents/agent.test.ts#example-function-agent-async-generator}
     */
    static from<I extends Message, O extends Message>(options: FunctionAgentOptions<I, O> | FunctionAgentFn<I, O>): FunctionAgent<I, O>;
    /**
     * Create a function agent instance
     *
     * @param options Function agent configuration options
     */
    constructor(options: FunctionAgentOptions<I, O>);
    /**
     * Stores the function used to process agent input and generate output
     *
     * @private
     */
    _process: FunctionAgentFn<I, O>;
    /**
     * Process input implementation, calls the configured processing function
     *
     * @param input Input message
     * @param options Invocation options
     * @returns Processing result
     */
    process(input: I, options: AgentInvokeOptions): PromiseOrValue<AgentProcessResult<O>>;
}
/**
 * Function type for function agents
 *
 * Defines the function signature for processing messages in a function agent
 *
 * @template I Agent input message type
 * @template O Agent output message type
 * @param input Input message
 * @param context Execution context
 * @returns Processing result, can be synchronous or asynchronous
 */
export type FunctionAgentFn<I extends Message = any, O extends Message = any, A extends FunctionAgent<I, O> = FunctionAgent<I, O>> = (this: A, input: I, options: AgentInvokeOptions) => PromiseOrValue<AgentProcessResult<O>>;