@voltagent/core 0.1.30 → 0.1.32

package/dist/index.d.ts

@@ -5,6 +5,246 @@ import { SpanExporter } from '@opentelemetry/sdk-trace-base';
 import { ClientCapabilities } from '@modelcontextprotocol/sdk/types.js';
 import { EventEmitter } from 'node:events';
 
+/**
+ * Represents a collection of related tools with optional shared instructions.
+ */
+type Toolkit = {
+    /**
+     * Unique identifier name for the toolkit. Used for management and potentially logging.
+     */
+    name: string;
+    /**
+     * A brief description of what the toolkit does or what tools it contains.
+     * Optional.
+     */
+    description?: string;
+    /**
+     * Shared instructions for the LLM on how to use the tools within this toolkit.
+     * These instructions are intended to be added to the system prompt if `addInstructions` is true.
+     * Optional.
+     */
+    instructions?: string;
+    /**
+     * Whether to automatically add the toolkit's `instructions` to the agent's system prompt.
+     * If true, the instructions from individual tools within this toolkit might be ignored
+     * by the Agent's system message generation logic to avoid redundancy.
+     * Defaults to false.
+     */
+    addInstructions?: boolean;
+    /**
+     * An array of Tool instances that belong to this toolkit.
+     */
+    tools: Tool<ToolSchema>[];
+};
+/**
+ * Helper function for creating a new toolkit.
+ * Provides default values and ensures the basic structure is met.
+ *
+ * @param options - The configuration options for the toolkit.
+ * @returns A Toolkit object.
+ */
+declare const createToolkit: (options: Toolkit) => Toolkit;
+
+/**
+ * Status of a tool at any given time
+ */
+type ToolStatus = "idle" | "working" | "error" | "completed";
+/**
+ * Tool status information
+ */
+type ToolStatusInfo = {
+    name: string;
+    status: ToolStatus;
+    result?: any;
+    error?: any;
+    input?: any;
+    output?: any;
+    timestamp: Date;
+    parameters?: any;
+};
+/**
+ * Manager class to handle all tool-related operations, including Toolkits.
+ */
+declare class ToolManager {
+    /**
+     * Standalone tools managed by this manager.
+     */
+    private tools;
+    /**
+     * Toolkits managed by this manager.
+     */
+    private toolkits;
+    /**
+     * Creates a new ToolManager.
+     * Accepts both individual tools and toolkits.
+     */
+    constructor(items?: (AgentTool | Toolkit)[]);
+    /**
+     * Get all individual tools and tools within toolkits as a flattened list.
+     */
+    getTools(): BaseTool[];
+    /**
+     * Get all toolkits managed by this manager.
+     */
+    getToolkits(): Toolkit[];
+    /**
+     * Add an individual tool to the manager.
+     * If a standalone tool with the same name already exists, it will be replaced.
+     * A warning is issued if the name conflicts with a tool inside a toolkit, but the standalone tool is still added/replaced.
+     * @returns true if the tool was successfully added or replaced.
+     */
+    addTool(tool: AgentTool): boolean;
+    /**
+     * Add a toolkit to the manager.
+     * If a toolkit with the same name already exists, it will be replaced.
+     * Also checks if any tool within the toolkit conflicts with existing standalone tools or tools in other toolkits.
+     * @returns true if the toolkit was successfully added or replaced.
+     */
+    addToolkit(toolkit: Toolkit): boolean;
+    /**
+     * Add multiple tools or toolkits to the manager.
+     */
+    addItems(items: (AgentTool | Toolkit)[]): void;
+    /**
+     * Remove a standalone tool by name. Does not remove tools from toolkits.
+     * @returns true if the tool was removed, false if it wasn't found.
+     */
+    removeTool(toolName: string): boolean;
+    /**
+     * Remove a toolkit by name.
+     * @returns true if the toolkit was removed, false if it wasn't found.
+     */
+    removeToolkit(toolkitName: string): boolean;
+    /**
+     * Prepare tools for text generation (includes tools from toolkits).
+     */
+    prepareToolsForGeneration(dynamicTools?: BaseTool[]): BaseTool[];
+    /**
+     * Get agent's tools (including those in toolkits) for API exposure.
+     */
+    getToolsForApi(): {
+        name: string;
+        description: string;
+        parameters: any;
+    }[];
+    /**
+     * Check if a tool with the given name exists (either standalone or in a toolkit).
+     */
+    hasTool(toolName: string): boolean;
+    /**
+     * Get a tool by name (searches standalone tools and tools within toolkits).
+     * @param toolName The name of the tool to get
+     * @returns The tool (as BaseTool) or undefined if not found
+     */
+    getToolByName(toolName: string): BaseTool | undefined;
+    /**
+     * Execute a tool by name
+     * @param toolName The name of the tool to execute
+     * @param args The arguments to pass to the tool
+     * @param options Optional execution options like signal
+     * @returns The result of the tool execution
+     * @throws Error if the tool doesn't exist or fails to execute
+     */
+    executeTool(toolName: string, args: any, options?: ToolExecuteOptions): Promise<any>;
+}
+
+/**
+ * Tool definition compatible with Vercel AI SDK
+ */
+type AgentTool = BaseTool;
+/**
+ * Tool options for creating a new tool
+ */
+type ToolOptions<T extends ToolSchema = ToolSchema> = {
+    /**
+     * Unique identifier for the tool
+     */
+    id?: string;
+    /**
+     * Name of the tool
+     */
+    name: string;
+    /**
+     * Description of the tool
+     */
+    description: string;
+    /**
+     * Tool parameter schema
+     */
+    parameters: T;
+    /**
+     * Function to execute when the tool is called
+     */
+    execute: (args: z.infer<T>, options?: ToolExecuteOptions) => Promise<unknown>;
+};
+/**
+ * Tool class for defining tools that agents can use
+ */
+declare class Tool<T extends ToolSchema = ToolSchema> {
+    /**
+     * Unique identifier for the tool
+     */
+    readonly id: string;
+    /**
+     * Name of the tool
+     */
+    readonly name: string;
+    /**
+     * Description of the tool
+     */
+    readonly description: string;
+    /**
+     * Tool parameter schema
+     */
+    readonly parameters: T;
+    /**
+     * Function to execute when the tool is called
+     */
+    readonly execute: (args: z.infer<T>, options?: ToolExecuteOptions) => Promise<unknown>;
+    /**
+     * Create a new tool
+     */
+    constructor(options: ToolOptions<T>);
+}
+/**
+ * Helper function for creating a new tool
+ */
+declare const createTool: <T extends ToolSchema>(options: ToolOptions<T>) => Tool<T>;
+/**
+ * Alias for createTool function
+ */
+declare const tool: <T extends ToolSchema>(options: ToolOptions<T>) => Tool<T>;
+
+/**
+ * An async iterable stream that can be read from.
+ * @example
+ * ```typescript
+ * const stream: AsyncIterableStream<string> = getStream();
+ * for await (const chunk of stream) {
+ *   console.log(chunk);
+ * }
+ * ```
+ */
+type AsyncIterableStream<T> = AsyncIterable<T> & ReadableStream<T>;
+/**
+ * Create an async iterable stream from a readable stream.
+ *
+ * This is useful for creating an async iterable stream from a readable stream.
+ *
+ * @example
+ * ```typescript
+ * const stream: AsyncIterableStream<string> = createAsyncIterableStream(new ReadableStream({
+ *   start(controller) {
+ *     controller.enqueue("Hello");
+ *     controller.close();
+ *   },
+ * }));
+ * ```
+ * @param source The readable stream to create an async iterable stream from.
+ * @returns The async iterable stream.
+ */
+declare function createAsyncIterableStream<T>(source: ReadableStream<T>): AsyncIterableStream<T>;
+
 /**
  * Memory options
  */
@@ -50,6 +290,7 @@ type MessageFilterOptions = {
 type Conversation = {
     id: string;
     resourceId: string;
+    userId: string;
     title: string;
     metadata: Record<string, unknown>;
     createdAt: string;
@@ -61,9 +302,21 @@ type Conversation = {
 type CreateConversationInput = {
     id: string;
     resourceId: string;
+    userId: string;
     title: string;
     metadata: Record<string, unknown>;
 };
+/**
+ * Query builder options for conversations
+ */
+type ConversationQueryOptions = {
+    userId?: string;
+    resourceId?: string;
+    limit?: number;
+    offset?: number;
+    orderBy?: "created_at" | "updated_at" | "title";
+    orderDirection?: "ASC" | "DESC";
+};
 /**
  * Memory interface for storing and retrieving messages
  */
@@ -95,6 +348,21 @@ type Memory = {
      * Get conversations for a resource
      */
     getConversations(resourceId: string): Promise<Conversation[]>;
+    /**
+     * Get conversations by user ID with query options
+     */
+    getConversationsByUserId(userId: string, options?: Omit<ConversationQueryOptions, "userId">): Promise<Conversation[]>;
+    /**
+     * Get conversations with advanced query options
+     */
+    queryConversations(options: ConversationQueryOptions): Promise<Conversation[]>;
+    /**
+     * Get all messages for a specific conversation
+     */
+    getConversationMessages(conversationId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<MemoryMessage[]>;
     /**
      * Update a conversation
      */
@@ -312,358 +580,148 @@ declare class HistoryManager {
      * Add steps to an existing history entry
      *
      * @param entryId - ID of the entry to update
-     * @param steps - Steps to add
-     * @returns The updated entry or undefined if not found
-     */
-    addStepsToEntry(entryId: string, steps: StepWithContent[]): Promise<AgentHistoryEntry | undefined>;
-    /**
-     * Get history entry by ID
-     *
-     * @param id - ID of the entry to find
-     * @returns The history entry or undefined if not found
-     */
-    getEntryById(id: string): Promise<AgentHistoryEntry | undefined>;
-    /**
-     * Get all history entries
-     *
-     * @returns Array of history entries
-     */
-    getEntries(): Promise<AgentHistoryEntry[]>;
-    /**
-     * Clear all history entries
-     */
-    clear(): Promise<void>;
-    /**
-     * Update an existing history entry
-     *
-     * @param id - ID of the entry to update
-     * @param updates - Partial entry with fields to update
-     * @returns The updated entry or undefined if not found
-     */
-    updateEntry(id: string, updates: Partial<Omit<AgentHistoryEntry, "id" | "timestamp"> & {
-        metadata?: Record<string, unknown>;
-    }>): Promise<AgentHistoryEntry | undefined>;
-    /**
-     * Persists a timeline event for a history entry.
-     * This is used by the new immutable event system.
-     *
-     * @param historyId - ID of the history entry
-     * @param event - The NewTimelineEvent object to persist
-     * @returns A promise that resolves to the updated entry or undefined if an error occurs
-     */
-    persistTimelineEvent(historyId: string, event: NewTimelineEvent): Promise<AgentHistoryEntry | undefined>;
-}
-
-interface ExportAgentHistoryPayload {
-    agent_id: string;
-    project_id: string;
-    history_id: string;
-    startTime: string;
-    endTime?: string;
-    status: string;
-    input: Record<string, unknown>;
-    output?: Record<string, unknown>;
-    error?: Record<string, unknown>;
-    usage?: Record<string, unknown>;
-    metadata?: Record<string, unknown>;
-    steps?: HistoryStep[];
-    userId?: string;
-    conversationId?: string;
-    model?: string;
-}
-interface ExportTimelineEventPayload {
-    history_id: string;
-    event_id: string;
-    agent_id: string;
-    event: NewTimelineEvent;
-}
-interface AgentHistoryUpdatableFields {
-    input?: AgentHistoryEntry["input"];
-    output?: string;
-    status?: AgentStatus;
-    usage?: UsageInfo;
-    metadata?: Record<string, unknown>;
-    endTime?: string;
-}
-
-/**
- * Options for configuring the VoltAgentExporter.
- */
-interface VoltAgentExporterOptions {
-    /**
-     * The base URL for the VoltAgent Edge Functions.
-     */
-    baseUrl: string;
-    /**
-     * The public API key for the project, used to identify the project
-     * when sending telemetry data.
-     */
-    publicKey: string;
-    /**
-     * The client's secret key (obtained once during project creation)
-     * used for authenticating requests to the telemetry Edge Functions.
-     * This will be sent as 'clientSecretKey' in the request body.
-     */
-    secretKey: string;
-    /**
-     * Optional fetch implementation. Defaults to global fetch.
-     * Useful for environments where global fetch might not be available or needs to be polyfilled (e.g., some Node.js versions).
-     */
-    fetch?: typeof fetch;
-}
-
-declare class VoltAgentExporter {
-    private apiClient;
-    readonly publicKey: string;
-    constructor(options: VoltAgentExporterOptions);
-    /**
-     * Exports a single agent history entry.
-     * @param historyEntryData - The agent history data to export.
-     *                           This should conform to ExportAgentHistoryPayload.
-     * @returns A promise that resolves with the response from the telemetry service,
-     *          typically including the ID of the created history entry.
-     */
-    exportHistoryEntry(historyEntryData: ExportAgentHistoryPayload): Promise<{
-        historyEntryId: string;
-    }>;
-    /**
-     * Exports a single timeline event.
-     * (Placeholder for when the 'export-timeline-event' Edge Function is ready)
-     * @param timelineEventData - The timeline event data to export.
-     *                            This should conform to ExportTimelineEventPayload.
-     * @returns A promise that resolves with the response from the telemetry service.
-     */
-    exportTimelineEvent(timelineEventData: ExportTimelineEventPayload): Promise<{
-        timelineEventId: string;
-    }>;
-    /**
-     * Exports history steps for a specific agent history entry.
-     * @param project_id - The project ID associated with the history entry.
-     * @param history_id - The ID of the history entry to export steps for.
-     * @param steps - The steps data to export.
-     * @returns A promise that resolves with the response from the telemetry service.
-     */
-    exportHistorySteps(history_id: string, steps: HistoryStep[]): Promise<void>;
-    /**
-     * Updates specific fields of an agent history entry.
-     * @param project_id - The project ID associated with the history entry.
-     * @param history_id - The ID of the history entry to update.
-     * @param updates - An object containing the fields to update.
-     *                  Should conform to Partial<AgentHistoryUpdatableFields>.
-     * @returns A promise that resolves with the response from the telemetry service.
-     */
-    updateHistoryEntry(history_id: string, updates: Partial<AgentHistoryUpdatableFields>): Promise<void>;
-}
-
-/**
- * Represents a collection of related tools with optional shared instructions.
- */
-type Toolkit = {
-    /**
-     * Unique identifier name for the toolkit. Used for management and potentially logging.
-     */
-    name: string;
-    /**
-     * A brief description of what the toolkit does or what tools it contains.
-     * Optional.
-     */
-    description?: string;
-    /**
-     * Shared instructions for the LLM on how to use the tools within this toolkit.
-     * These instructions are intended to be added to the system prompt if `addInstructions` is true.
-     * Optional.
-     */
-    instructions?: string;
-    /**
-     * Whether to automatically add the toolkit's `instructions` to the agent's system prompt.
-     * If true, the instructions from individual tools within this toolkit might be ignored
-     * by the Agent's system message generation logic to avoid redundancy.
-     * Defaults to false.
-     */
-    addInstructions?: boolean;
-    /**
-     * An array of Tool instances that belong to this toolkit.
-     */
-    tools: Tool<ToolSchema>[];
-};
-/**
- * Helper function for creating a new toolkit.
- * Provides default values and ensures the basic structure is met.
- *
- * @param options - The configuration options for the toolkit.
- * @returns A Toolkit object.
- */
-declare const createToolkit: (options: Toolkit) => Toolkit;
-
-/**
- * Status of a tool at any given time
- */
-type ToolStatus = "idle" | "working" | "error" | "completed";
-/**
- * Tool status information
- */
-type ToolStatusInfo = {
-    name: string;
-    status: ToolStatus;
-    result?: any;
-    error?: any;
-    input?: any;
-    output?: any;
-    timestamp: Date;
-    parameters?: any;
-};
-/**
- * Manager class to handle all tool-related operations, including Toolkits.
- */
-declare class ToolManager {
-    /**
-     * Standalone tools managed by this manager.
-     */
-    private tools;
-    /**
-     * Toolkits managed by this manager.
-     */
-    private toolkits;
-    /**
-     * Creates a new ToolManager.
-     * Accepts both individual tools and toolkits.
-     */
-    constructor(items?: (AgentTool | Toolkit)[]);
-    /**
-     * Get all individual tools and tools within toolkits as a flattened list.
-     */
-    getTools(): BaseTool[];
-    /**
-     * Get all toolkits managed by this manager.
-     */
-    getToolkits(): Toolkit[];
-    /**
-     * Add an individual tool to the manager.
-     * If a standalone tool with the same name already exists, it will be replaced.
-     * A warning is issued if the name conflicts with a tool inside a toolkit, but the standalone tool is still added/replaced.
-     * @returns true if the tool was successfully added or replaced.
-     */
-    addTool(tool: AgentTool): boolean;
-    /**
-     * Add a toolkit to the manager.
-     * If a toolkit with the same name already exists, it will be replaced.
-     * Also checks if any tool within the toolkit conflicts with existing standalone tools or tools in other toolkits.
-     * @returns true if the toolkit was successfully added or replaced.
-     */
-    addToolkit(toolkit: Toolkit): boolean;
-    /**
-     * Add multiple tools or toolkits to the manager.
-     */
-    addItems(items: (AgentTool | Toolkit)[]): void;
-    /**
-     * Remove a standalone tool by name. Does not remove tools from toolkits.
-     * @returns true if the tool was removed, false if it wasn't found.
-     */
-    removeTool(toolName: string): boolean;
-    /**
-     * Remove a toolkit by name.
-     * @returns true if the toolkit was removed, false if it wasn't found.
-     */
-    removeToolkit(toolkitName: string): boolean;
-    /**
-     * Prepare tools for text generation (includes tools from toolkits).
-     */
-    prepareToolsForGeneration(dynamicTools?: BaseTool[]): BaseTool[];
-    /**
-     * Get agent's tools (including those in toolkits) for API exposure.
-     */
-    getToolsForApi(): {
-        name: string;
-        description: string;
-        parameters: any;
-    }[];
-    /**
-     * Check if a tool with the given name exists (either standalone or in a toolkit).
-     */
-    hasTool(toolName: string): boolean;
-    /**
-     * Get a tool by name (searches standalone tools and tools within toolkits).
-     * @param toolName The name of the tool to get
-     * @returns The tool (as BaseTool) or undefined if not found
-     */
-    getToolByName(toolName: string): BaseTool | undefined;
-    /**
-     * Execute a tool by name
-     * @param toolName The name of the tool to execute
-     * @param args The arguments to pass to the tool
-     * @param options Optional execution options like signal
-     * @returns The result of the tool execution
-     * @throws Error if the tool doesn't exist or fails to execute
-     */
-    executeTool(toolName: string, args: any, options?: ToolExecuteOptions): Promise<any>;
-}
-
-/**
- * Tool definition compatible with Vercel AI SDK
- */
-type AgentTool = BaseTool;
-/**
- * Tool options for creating a new tool
- */
-type ToolOptions<T extends ToolSchema = ToolSchema> = {
+     * @param steps - Steps to add
+     * @returns The updated entry or undefined if not found
+     */
+    addStepsToEntry(entryId: string, steps: StepWithContent[]): Promise<AgentHistoryEntry | undefined>;
     /**
-     * Unique identifier for the tool
+     * Get history entry by ID
+     *
+     * @param id - ID of the entry to find
+     * @returns The history entry or undefined if not found
      */
-    id?: string;
+    getEntryById(id: string): Promise<AgentHistoryEntry | undefined>;
     /**
-     * Name of the tool
+     * Get all history entries
+     *
+     * @returns Array of history entries
      */
-    name: string;
+    getEntries(): Promise<AgentHistoryEntry[]>;
     /**
-     * Description of the tool
+     * Clear all history entries
      */
-    description: string;
+    clear(): Promise<void>;
     /**
-     * Tool parameter schema
+     * Update an existing history entry
+     *
+     * @param id - ID of the entry to update
+     * @param updates - Partial entry with fields to update
+     * @returns The updated entry or undefined if not found
      */
-    parameters: T;
+    updateEntry(id: string, updates: Partial<Omit<AgentHistoryEntry, "id" | "timestamp"> & {
+        metadata?: Record<string, unknown>;
+    }>): Promise<AgentHistoryEntry | undefined>;
     /**
-     * Function to execute when the tool is called
+     * Persists a timeline event for a history entry.
+     * This is used by the new immutable event system.
+     *
+     * @param historyId - ID of the history entry
+     * @param event - The NewTimelineEvent object to persist
+     * @returns A promise that resolves to the updated entry or undefined if an error occurs
      */
-    execute: (args: z.infer<T>, options?: ToolExecuteOptions) => Promise<unknown>;
-};
+    persistTimelineEvent(historyId: string, event: NewTimelineEvent): Promise<AgentHistoryEntry | undefined>;
+}
+
+interface ExportAgentHistoryPayload {
+    agent_id: string;
+    project_id: string;
+    history_id: string;
+    startTime: string;
+    endTime?: string;
+    status: string;
+    input: Record<string, unknown>;
+    output?: Record<string, unknown>;
+    error?: Record<string, unknown>;
+    usage?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    steps?: HistoryStep[];
+    userId?: string;
+    conversationId?: string;
+    model?: string;
+}
+interface ExportTimelineEventPayload {
+    history_id: string;
+    event_id: string;
+    agent_id: string;
+    event: NewTimelineEvent;
+}
+interface AgentHistoryUpdatableFields {
+    input?: AgentHistoryEntry["input"];
+    output?: string;
+    status?: AgentStatus;
+    usage?: UsageInfo;
+    metadata?: Record<string, unknown>;
+    endTime?: string;
+}
+
 /**
- * Tool class for defining tools that agents can use
+ * Options for configuring the VoltAgentExporter.
  */
-declare class Tool<T extends ToolSchema = ToolSchema> {
+interface VoltAgentExporterOptions {
     /**
-     * Unique identifier for the tool
+     * The base URL for the VoltAgent Edge Functions.
      */
-    readonly id: string;
+    baseUrl: string;
     /**
-     * Name of the tool
+     * The public API key for the project, used to identify the project
+     * when sending telemetry data.
      */
-    readonly name: string;
+    publicKey: string;
     /**
-     * Description of the tool
+     * The client's secret key (obtained once during project creation)
+     * used for authenticating requests to the telemetry Edge Functions.
+     * This will be sent as 'clientSecretKey' in the request body.
      */
-    readonly description: string;
+    secretKey: string;
     /**
-     * Tool parameter schema
+     * Optional fetch implementation. Defaults to global fetch.
+     * Useful for environments where global fetch might not be available or needs to be polyfilled (e.g., some Node.js versions).
      */
-    readonly parameters: T;
+    fetch?: typeof fetch;
+}
+
+declare class VoltAgentExporter {
+    private apiClient;
+    readonly publicKey: string;
+    constructor(options: VoltAgentExporterOptions);
     /**
-     * Function to execute when the tool is called
+     * Exports a single agent history entry.
+     * @param historyEntryData - The agent history data to export.
+     *                           This should conform to ExportAgentHistoryPayload.
+     * @returns A promise that resolves with the response from the telemetry service,
+     *          typically including the ID of the created history entry.
      */
-    readonly execute: (args: z.infer<T>, options?: ToolExecuteOptions) => Promise<unknown>;
+    exportHistoryEntry(historyEntryData: ExportAgentHistoryPayload): Promise<{
+        historyEntryId: string;
+    }>;
     /**
-     * Create a new tool
+     * Exports a single timeline event.
+     * (Placeholder for when the 'export-timeline-event' Edge Function is ready)
+     * @param timelineEventData - The timeline event data to export.
+     *                            This should conform to ExportTimelineEventPayload.
+     * @returns A promise that resolves with the response from the telemetry service.
      */
-    constructor(options: ToolOptions<T>);
+    exportTimelineEvent(timelineEventData: ExportTimelineEventPayload): Promise<{
+        timelineEventId: string;
+    }>;
+    /**
+     * Exports history steps for a specific agent history entry.
+     * @param project_id - The project ID associated with the history entry.
+     * @param history_id - The ID of the history entry to export steps for.
+     * @param steps - The steps data to export.
+     * @returns A promise that resolves with the response from the telemetry service.
+     */
+    exportHistorySteps(history_id: string, steps: HistoryStep[]): Promise<void>;
+    /**
+     * Updates specific fields of an agent history entry.
+     * @param project_id - The project ID associated with the history entry.
+     * @param history_id - The ID of the history entry to update.
+     * @param updates - An object containing the fields to update.
+     *                  Should conform to Partial<AgentHistoryUpdatableFields>.
+     * @returns A promise that resolves with the response from the telemetry service.
+     */
+    updateHistoryEntry(history_id: string, updates: Partial<AgentHistoryUpdatableFields>): Promise<void>;
 }
-/**
- * Helper function for creating a new tool
- */
-declare const createTool: <T extends ToolSchema>(options: ToolOptions<T>) => Tool<T>;
-/**
- * Alias for createTool function
- */
-declare const tool: <T extends ToolSchema>(options: ToolOptions<T>) => Tool<T>;
 
 /**
  * Provider options type for LLM configurations
@@ -765,27 +823,27 @@ type ModelType<T> = T extends {
 /**
  * Infer generate text response type
  */
-type InferGenerateTextResponse$1<T extends {
+type InferGenerateTextResponseFromProvider<TProvider extends {
     llm: LLMProvider<any>;
-}> = Awaited<ReturnType<T["llm"]["generateText"]>>;
+}> = ProviderTextResponse<InferOriginalResponseFromProvider<TProvider, "generateText">>;
 /**
  * Infer stream text response type
  */
-type InferStreamTextResponse<T extends {
+type InferStreamTextResponseFromProvider<TProvider extends {
     llm: LLMProvider<any>;
-}> = Awaited<ReturnType<T["llm"]["streamText"]>>;
+}> = ProviderTextStreamResponse<InferOriginalResponseFromProvider<TProvider, "streamText">>;
 /**
  * Infer generate object response type
  */
-type InferGenerateObjectResponse$1<T extends {
+type InferGenerateObjectResponseFromProvider<TProvider extends {
     llm: LLMProvider<any>;
-}> = Awaited<ReturnType<T["llm"]["generateObject"]>>;
+}, TSchema extends z.ZodType> = ProviderObjectResponse<InferOriginalResponseFromProvider<TProvider, "generateObject">, z.infer<TSchema>>;
 /**
  * Infer stream object response type
  */
-type InferStreamObjectResponse<T extends {
+type InferStreamObjectResponseFromProvider<TProvider extends {
     llm: LLMProvider<any>;
-}> = Awaited<ReturnType<T["llm"]["streamObject"]>>;
+}, TSchema extends z.ZodType> = ProviderObjectStreamResponse<InferOriginalResponseFromProvider<TProvider, "streamObject">, z.infer<TSchema>>;
 /**
  * Common generate options - internal version that includes historyEntryId
  * Not exposed directly to users
@@ -945,6 +1003,8 @@ type OperationContext = {
     otelSpan?: Span;
     /** Map to store active OpenTelemetry spans for tool calls within this operation */
     toolSpans?: Map<string, Span>;
+    /** Conversation steps for building full message history including tool calls/results */
+    conversationSteps?: StepWithContent[];
 };
 /**
  * Tool execution context passed to tool.execute method
@@ -1009,6 +1069,8 @@ interface StreamTextFinishResult {
     providerResponse?: unknown;
     /** Any warnings generated during the completion (if available). */
     warnings?: unknown[];
+    /** User context containing any custom metadata from the operation. */
+    userContext?: Map<string | symbol, unknown>;
 }
 /**
  * Type for the onFinish callback function for streamText.
@@ -1030,6 +1092,8 @@ interface StreamObjectFinishResult<TObject> {
     warnings?: unknown[];
     /** The reason the stream finished (if available). Although less common for object streams. */
     finishReason?: string;
+    /** User context containing any custom metadata from the operation. */
+    userContext?: Map<string | symbol, unknown>;
 }
 /**
  * Type for the onFinish callback function for streamObject.
@@ -1050,6 +1114,8 @@ interface StandardizedTextResult {
     finishReason?: string;
     /** Warnings (if available from provider). */
     warnings?: unknown[];
+    /** User context containing any custom metadata from the operation. */
+    userContext?: Map<string | symbol, unknown>;
 }
 /**
  * Standardized success result structure for generateObject.
@@ -1066,6 +1132,8 @@ interface StandardizedObjectResult<TObject> {
     finishReason?: string;
     /** Warnings (if available from provider). */
     warnings?: unknown[];
+    /** User context containing any custom metadata from the operation. */
+    userContext?: Map<string | symbol, unknown>;
 }
 /**
  * Unified output type for the onEnd hook, representing the successful result
@@ -1074,6 +1142,12 @@ interface StandardizedObjectResult<TObject> {
  * Object types are generalized to 'unknown' here for the union.
  */
 type AgentOperationOutput = StandardizedTextResult | StreamTextFinishResult | StandardizedObjectResult<unknown> | StreamObjectFinishResult<unknown>;
+type InferResponseFromProvider<TProvider extends {
+    llm: LLMProvider<any>;
+}, TMethod extends "generateText" | "streamText" | "generateObject" | "streamObject"> = Awaited<ReturnType<TProvider["llm"][TMethod]>>;
+type InferOriginalResponseFromProvider<TProvider extends {
+    llm: LLMProvider<any>;
+}, TMethod extends "generateText" | "streamText" | "generateObject" | "streamObject"> = InferResponseFromProvider<TProvider, TMethod>["provider"];
 
 /**
  * Token usage information
@@ -1132,7 +1206,7 @@ type ProviderTextStreamResponse<TOriginalResponse> = {
     /**
      * Text stream for consuming the response
      */
-    textStream: ReadableStream<string>;
+    textStream: AsyncIterableStream<string>;
 };
 /**
  * Response type for object generation operations
@@ -1166,7 +1240,7 @@ type ProviderObjectStreamResponse<TOriginalResponse, TObject> = {
     /**
      * Object stream for consuming partial objects
      */
-    objectStream: ReadableStream<Partial<TObject>>;
+    objectStream: AsyncIterableStream<Partial<TObject>>;
 };
 /**
  * Data content type for binary data
@@ -1354,6 +1428,11 @@ type LLMProvider<TProvider> = {
      * @throws {VoltAgentError} If an error occurs during generation.
      */
     generateText(options: GenerateTextOptions<InferModel<TProvider>>): Promise<ProviderTextResponse<InferGenerateTextResponse<TProvider>>>;
+    /**
+     * Streams a text response based on the provided options.
+     * Implementers should catch underlying SDK/API errors and throw a VoltAgentError.
+     * @throws {VoltAgentError} If an error occurs during streaming.
+     */
     streamText(options: StreamTextOptions<InferModel<TProvider>>): Promise<ProviderTextStreamResponse<InferStreamResponse<TProvider>>>;
     /**
      * Generates a structured object response based on the provided options and schema.
@@ -1361,8 +1440,21 @@ type LLMProvider<TProvider> = {
      * @throws {VoltAgentError} If an error occurs during generation.
      */
     generateObject<TSchema extends z.ZodType>(options: GenerateObjectOptions<InferModel<TProvider>, TSchema>): Promise<ProviderObjectResponse<InferGenerateObjectResponse<TProvider>, z.infer<TSchema>>>;
+    /**
+     * Streams a structured object response based on the provided options and schema.
+     * Implementers should catch underlying SDK/API errors and throw a VoltAgentError.
+     * @throws {VoltAgentError} If an error occurs during streaming.
+     */
     streamObject<TSchema extends z.ZodType>(options: StreamObjectOptions<InferModel<TProvider>, TSchema>): Promise<ProviderObjectStreamResponse<InferStreamResponse<TProvider>, z.infer<TSchema>>>;
+    /**
+     * Converts a base message to a provider-specific message.
+     * @param message The base message to convert.
+     * @returns The provider-specific message.
+     */
     toMessage(message: BaseMessage): InferMessage<TProvider>;
+    /**
+     * Optional tool conversion method.
+     */
     toTool?: (tool: BaseTool) => InferTool<TProvider>;
     /**
      * Returns a string representation of the model identifier.
@@ -1685,6 +1777,110 @@ declare class InMemoryStorage implements Memory {
      * @returns Array of conversations
      */
     getConversations(resourceId: string): Promise<Conversation[]>;
+    /**
+     * Get conversations by user ID with query options
+     * @param userId User ID
+     * @param options Query options
+     * @returns Array of conversations
+     */
+    getConversationsByUserId(userId: string, options?: Omit<ConversationQueryOptions, "userId">): Promise<Conversation[]>;
+    /**
+     * Query conversations with flexible filtering and pagination options
+     *
+     * This method provides a powerful way to search and filter conversations
+     * with support for user-based filtering, resource filtering, pagination,
+     * and custom sorting.
+     *
+     * @param options Query options for filtering and pagination
+     * @param options.userId Optional user ID to filter conversations by specific user
+     * @param options.resourceId Optional resource ID to filter conversations by specific resource
+     * @param options.limit Maximum number of conversations to return (default: 50)
+     * @param options.offset Number of conversations to skip for pagination (default: 0)
+     * @param options.orderBy Field to sort by: 'created_at', 'updated_at', or 'title' (default: 'updated_at')
+     * @param options.orderDirection Sort direction: 'ASC' or 'DESC' (default: 'DESC')
+     *
+     * @returns Promise that resolves to an array of conversations matching the criteria
+     *
+     * @example
+     * ```typescript
+     * // Get all conversations for a specific user
+     * const userConversations = await storage.queryConversations({
+     *   userId: 'user123',
+     *   limit: 20
+     * });
+     *
+     * // Get conversations for a resource with pagination
+     * const resourceConversations = await storage.queryConversations({
+     *   resourceId: 'chatbot-v1',
+     *   limit: 10,
+     *   offset: 20,
+     *   orderBy: 'created_at',
+     *   orderDirection: 'ASC'
+     * });
+     *
+     * // Get all conversations (admin view)
+     * const allConversations = await storage.queryConversations({
+     *   limit: 100,
+     *   orderBy: 'updated_at'
+     * });
+     * ```
+     */
+    queryConversations(options: ConversationQueryOptions): Promise<Conversation[]>;
+    /**
+     * Get messages for a specific conversation with pagination support
+     *
+     * This method retrieves all messages within a conversation, ordered chronologically
+     * from oldest to newest. It supports pagination to handle large conversations
+     * efficiently and avoid memory issues.
+     *
+     * @param conversationId The unique identifier of the conversation to retrieve messages from
+     * @param options Optional pagination and filtering options
+     * @param options.limit Maximum number of messages to return (default: 100)
+     * @param options.offset Number of messages to skip for pagination (default: 0)
+     *
+     * @returns Promise that resolves to an array of messages in chronological order (oldest first)
+     *
+     * @example
+     * ```typescript
+     * // Get the first 50 messages in a conversation
+     * const messages = await storage.getConversationMessages('conv-123', {
+     *   limit: 50
+     * });
+     *
+     * // Get messages with pagination (skip first 20, get next 30)
+     * const olderMessages = await storage.getConversationMessages('conv-123', {
+     *   limit: 30,
+     *   offset: 20
+     * });
+     *
+     * // Get all messages (use with caution for large conversations)
+     * const allMessages = await storage.getConversationMessages('conv-123');
+     *
+     * // Process messages in batches
+     * const batchSize = 100;
+     * let offset = 0;
+     * let hasMore = true;
+     *
+     * while (hasMore) {
+     *   const batch = await storage.getConversationMessages('conv-123', {
+     *     limit: batchSize,
+     *     offset: offset
+     *   });
+     *
+     *   // Process batch
+     *   processBatch(batch);
+     *
+     *   hasMore = batch.length === batchSize;
+     *   offset += batchSize;
+     * }
+     * ```
+     *
+     * @throws {Error} If the conversation ID is invalid or operation fails
+     */
+    getConversationMessages(conversationId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<MemoryMessage[]>;
     /**
      * Update a conversation
      * @param id Conversation ID
@@ -1784,6 +1980,11 @@ declare class LibSQLStorage implements Memory {
      * @param conversationId Conversation identifier (optional, defaults to "default")
      */
     addMessage(message: MemoryMessage, userId?: string, conversationId?: string): Promise<void>;
+    /**
+     * Prune old messages to respect storage limit
+     * @param conversationId Conversation ID to prune messages for
+     */
+    private pruneOldMessages;
     /**
      * Clear messages from memory
      */
@@ -1848,6 +2049,27 @@ declare class LibSQLStorage implements Memory {
     createConversation(conversation: CreateConversationInput): Promise<Conversation>;
     getConversation(id: string): Promise<Conversation | null>;
     getConversations(resourceId: string): Promise<Conversation[]>;
+    getConversationsByUserId(userId: string, options?: Omit<ConversationQueryOptions, "userId">): Promise<Conversation[]>;
+    /**
+     * Query conversations with filtering and pagination options
+     *
+     * @param options Query options for filtering and pagination
+     * @returns Promise that resolves to an array of conversations matching the criteria
+     * @see {@link https://voltagent.ai/docs/agents/memory/libsql#querying-conversations | Querying Conversations}
+     */
+    queryConversations(options: ConversationQueryOptions): Promise<Conversation[]>;
+    /**
+     * Get messages for a specific conversation with pagination support
+     *
+     * @param conversationId The unique identifier of the conversation to retrieve messages from
+     * @param options Optional pagination and filtering options
+     * @returns Promise that resolves to an array of messages in chronological order (oldest first)
+     * @see {@link https://voltagent.ai/docs/agents/memory/libsql#conversation-messages | Getting Conversation Messages}
+     */
+    getConversationMessages(conversationId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<MemoryMessage[]>;
     updateConversation(id: string, updates: Partial<Omit<Conversation, "id" | "createdAt" | "updatedAt">>): Promise<Conversation>;
     deleteConversation(id: string): Promise<void>;
     /**
@@ -1877,6 +2099,159 @@ declare class LibSQLStorage implements Memory {
         error?: Error;
         backupCreated?: boolean;
     }>;
+    /**
+     * Migrate conversation schema to add user_id and update messages table
+     *
+     * ⚠️  **CRITICAL WARNING: DESTRUCTIVE OPERATION** ⚠️
+     *
+     * This method performs a DESTRUCTIVE schema migration that:
+     * - DROPS and recreates existing tables
+     * - Creates temporary tables during migration
+     * - Modifies the primary key structure of the messages table
+     * - Can cause DATA LOSS if interrupted or if errors occur
+     *
+     * **IMPORTANT SAFETY REQUIREMENTS:**
+     * - 🛑 STOP all application instances before running this migration
+     * - 🛑 Ensure NO concurrent database operations are running
+     * - 🛑 Take a full database backup before running (independent of built-in backup)
+     * - 🛑 Test the migration on a copy of production data first
+     * - 🛑 Plan for downtime during migration execution
+     *
+     * **What this migration does:**
+     * 1. Creates backup tables (if createBackup=true)
+     * 2. Creates temporary tables with new schema
+     * 3. Migrates data from old tables to new schema
+     * 4. DROPS original tables
+     * 5. Renames temporary tables to original names
+     * 6. All operations are wrapped in a transaction for atomicity
+     *
+     * @param options Migration configuration options
+     * @param options.createBackup Whether to create backup tables before migration (default: true, HIGHLY RECOMMENDED)
+     * @param options.restoreFromBackup Whether to restore from existing backup instead of migrating (default: false)
+     * @param options.deleteBackupAfterSuccess Whether to delete backup tables after successful migration (default: false)
+     *
+     * @returns Promise resolving to migration result with success status, migrated count, and backup info
+     *
+     * @example
+     * ```typescript
+     * // RECOMMENDED: Run with backup creation (default)
+     * const result = await storage.migrateConversationSchema({
+     *   createBackup: true,
+     *   deleteBackupAfterSuccess: false // Keep backup for safety
+     * });
+     *
+     * if (result.success) {
+     *   console.log(`Migrated ${result.migratedCount} conversations successfully`);
+     * } else {
+     *   console.error('Migration failed:', result.error);
+     *   // Consider restoring from backup
+     * }
+     *
+     * // If migration fails, restore from backup:
+     * const restoreResult = await storage.migrateConversationSchema({
+     *   restoreFromBackup: true
+     * });
+     * ```
+     *
+     * @throws {Error} If migration fails and transaction is rolled back
+     *
+     * @since This migration is typically only needed when upgrading from older schema versions
+     */
+    private migrateConversationSchema;
+    /**
+     * Get conversations for a user with a fluent query builder interface
+     * @param userId User ID to filter by
+     * @returns Query builder object
+     */
+    getUserConversations(userId: string): {
+        /**
+         * Limit the number of results
+         * @param count Number of conversations to return
+         * @returns Query builder
+         */
+        limit: (count: number) => {
+            /**
+             * Order results by a specific field
+             * @param field Field to order by
+             * @param direction Sort direction
+             * @returns Query builder
+             */
+            orderBy: (field?: "created_at" | "updated_at" | "title", direction?: "ASC" | "DESC") => {
+                /**
+                 * Execute the query and return results
+                 * @returns Promise of conversations
+                 */
+                execute: () => Promise<Conversation[]>;
+            };
+            /**
+             * Execute the query with default ordering
+             * @returns Promise of conversations
+             */
+            execute: () => Promise<Conversation[]>;
+        };
+        /**
+         * Order results by a specific field
+         * @param field Field to order by
+         * @param direction Sort direction
+         * @returns Query builder
+         */
+        orderBy: (field?: "created_at" | "updated_at" | "title", direction?: "ASC" | "DESC") => {
+            /**
+             * Limit the number of results
+             * @param count Number of conversations to return
+             * @returns Query builder
+             */
+            limit: (count: number) => {
+                /**
+                 * Execute the query and return results
+                 * @returns Promise of conversations
+                 */
+                execute: () => Promise<Conversation[]>;
+            };
+            /**
+             * Execute the query without limit
+             * @returns Promise of conversations
+             */
+            execute: () => Promise<Conversation[]>;
+        };
+        /**
+         * Execute the query with default options
+         * @returns Promise of conversations
+         */
+        execute: () => Promise<Conversation[]>;
+    };
+    /**
+     * Get conversation by ID and ensure it belongs to the specified user
+     * @param conversationId Conversation ID
+     * @param userId User ID to validate ownership
+     * @returns Conversation or null
+     */
+    getUserConversation(conversationId: string, userId: string): Promise<Conversation | null>;
+    /**
+     * Get paginated conversations for a user
+     * @param userId User ID
+     * @param page Page number (1-based)
+     * @param pageSize Number of items per page
+     * @returns Object with conversations and pagination info
+     */
+    getPaginatedUserConversations(userId: string, page?: number, pageSize?: number): Promise<{
+        conversations: Conversation[];
+        page: number;
+        pageSize: number;
+        hasMore: boolean;
+    }>;
+    /**
+     * Check and create migration flag table, return if migration already completed
+     * @param migrationType Type of migration to check
+     * @returns Object with completion status and details
+     */
+    private checkMigrationFlag;
+    /**
+     * Set migration flag after successful completion
+     * @param migrationType Type of migration completed
+     * @param migratedCount Number of records migrated
+     */
+    private setMigrationFlag;
 }
 
 /**
@@ -2009,6 +2384,16 @@ type RetrieverOptions = {
      */
     [key: string]: any;
 };
+/**
+ * Options passed to retrieve method
+ */
+interface RetrieveOptions {
+    /**
+     * User-managed context map for this specific retrieval operation
+     * Can be used to store metadata, results, or any custom data
+     */
+    userContext?: Map<string | symbol, unknown>;
+}
 /**
  * Retriever interface for retrieving relevant information
  */
@@ -2016,9 +2401,10 @@ type Retriever = {
     /**
      * Retrieve relevant documents based on input text
      * @param text The text to use for retrieval
-     * @returns Promise resolving to an array of retrieval results
+     * @param options Configuration and context for the retrieval
+     * @returns Promise resolving to a string with the retrieved content
      */
-    retrieve(text: string): Promise<string>;
+    retrieve(text: string, options: RetrieveOptions): Promise<string>;
     /**
      * Configuration options for the retriever
      * This is optional and may not be present in all implementations
@@ -2065,13 +2451,14 @@ declare abstract class BaseRetriever {
      */
     constructor(options?: RetrieverOptions);
     /**
-     * Retrieve information based on input.
-     * This method must be implemented by all concrete subclasses.
+     * Abstract method that must be implemented by concrete retriever classes.
+     * Retrieves relevant information based on the input text or messages.
      *
-     * @param input - The input to base the retrieval on, can be string or BaseMessage array
-     * @returns A Promise that resolves to a formatted context string
+     * @param input - The input to use for retrieval (string or BaseMessage array)
+     * @param options - Configuration and context for the retrieval
+     * @returns Promise resolving to a string with the retrieved content
      */
-    abstract retrieve(input: string | BaseMessage[]): Promise<string>;
+    abstract retrieve(input: string | BaseMessage[], options: RetrieveOptions): Promise<string>;
 }
 
 /**
@@ -2187,11 +2574,19 @@ interface OnStartHookArgs {
     context: OperationContext;
 }
 interface OnEndHookArgs {
+    /**
+     * The conversation ID.
+     */
+    conversationId: string;
+    /**
+     * The agent that generated the output.
+     */
     agent: Agent<any>;
     /** The standardized successful output object. Undefined on error. */
     output: AgentOperationOutput | undefined;
     /** The VoltAgentError object if the operation failed. Undefined on success. */
     error: VoltAgentError | undefined;
+    /** The complete conversation messages including user input and assistant responses (Vercel AI SDK compatible) */
     context: OperationContext;
 }
 interface OnHandoffHookArgs {
@@ -2387,10 +2782,11 @@ declare class Agent<TProvider extends {
     /**
      * Get the system message for the agent
      */
-    protected getSystemMessage({ input, historyEntryId, contextMessages, }: {
+    protected getSystemMessage({ input, historyEntryId, contextMessages, operationContext, }: {
         input?: string | BaseMessage[];
         historyEntryId: string;
         contextMessages: BaseMessage[];
+        operationContext?: OperationContext;
     }): Promise<BaseMessage>;
     /**
      * Prepare agents memory for the supervisor system message
@@ -2454,7 +2850,7 @@ declare class Agent<TProvider extends {
      */
     getHistory(): Promise<AgentHistoryEntry[]>;
     /**
-     * Add step to history immediately
+     * Add step to history immediately and to conversation steps
      */
     private addStepToHistory;
     /**
@@ -2476,19 +2872,19 @@ declare class Agent<TProvider extends {
     /**
      * Generate a text response without streaming
      */
-    generateText(input: string | BaseMessage[], options?: PublicGenerateOptions): Promise<InferGenerateTextResponse$1<TProvider>>;
+    generateText(input: string | BaseMessage[], options?: PublicGenerateOptions): Promise<InferGenerateTextResponseFromProvider<TProvider>>;
     /**
      * Stream a text response
      */
-    streamText(input: string | BaseMessage[], options?: PublicGenerateOptions): Promise<InferStreamTextResponse<TProvider>>;
+    streamText(input: string | BaseMessage[], options?: PublicGenerateOptions): Promise<InferStreamTextResponseFromProvider<TProvider>>;
     /**
      * Generate a structured object response
      */
-    generateObject<T extends z.ZodType>(input: string | BaseMessage[], schema: T, options?: PublicGenerateOptions): Promise<InferGenerateObjectResponse$1<TProvider>>;
+    generateObject<TSchema extends z.ZodType>(input: string | BaseMessage[], schema: TSchema, options?: PublicGenerateOptions): Promise<InferGenerateObjectResponseFromProvider<TProvider, TSchema>>;
     /**
      * Stream a structured object response
      */
-    streamObject<T extends z.ZodType>(input: string | BaseMessage[], schema: T, options?: PublicGenerateOptions): Promise<InferStreamObjectResponse<TProvider>>;
+    streamObject<TSchema extends z.ZodType>(input: string | BaseMessage[], schema: TSchema, options?: PublicGenerateOptions): Promise<InferStreamObjectResponseFromProvider<TProvider, TSchema>>;
     /**
      * Add a sub-agent that this agent can delegate tasks to
      */
@@ -2609,10 +3005,10 @@ declare const ReasoningStepSchema: z.ZodObject<{
     historyEntryId: z.ZodString;
     agentId: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    id: string;
+    type: "thought" | "analysis";
     title: string;
+    id: string;
     historyEntryId: string;
-    type: "thought" | "analysis";
     agentId: string;
     timestamp: string;
     reasoning: string;
@@ -2621,10 +3017,10 @@ declare const ReasoningStepSchema: z.ZodObject<{
     result?: string | undefined;
     next_action?: NextAction | undefined;
 }, {
-    id: string;
+    type: "thought" | "analysis";
     title: string;
+    id: string;
     historyEntryId: string;
-    type: "thought" | "analysis";
     agentId: string;
     timestamp: string;
     reasoning: string;
@@ -3366,4 +3762,4 @@ declare class VoltAgent {
     shutdownTelemetry(): Promise<void>;
 }
 
-export { Agent, AgentErrorEvent, AgentHistoryEntry, AgentHookOnEnd, AgentHookOnHandoff, AgentHookOnStart, AgentHookOnToolEnd, AgentHookOnToolStart, AgentHooks, AgentOptions, AgentRegistry, AgentResponse, AgentStartEvent, AgentStartEventMetadata, AgentSuccessEvent, AgentSuccessEventMetadata, AgentTool, AllowedVariableValue, AnyToolConfig, BaseEventMetadata, BaseLLMOptions, BaseMessage, BaseRetriever, BaseTimelineEvent, BaseTool, BaseToolCall, ClientInfo, Conversation, CreateConversationInput, CreateReasoningToolsOptions, CustomEndpointDefinition, CustomEndpointError, CustomEndpointHandler, DEFAULT_INSTRUCTIONS, DataContent, EventStatus, ExtractVariableNames, FEW_SHOT_EXAMPLES, FilePart, GenerateObjectOptions, GenerateTextOptions, HTTPServerConfig, HistoryStatus, HttpMethod, ImagePart, InMemoryStorage, InferGenerateObjectResponse, InferGenerateTextResponse, InferMessage, InferModel, InferProviderParams, InferStreamResponse, InferTool, LLMProvider, LibSQLStorage, MCPClient, MCPClientConfig, MCPClientEvents, MCPConfiguration, MCPOptions, MCPServerConfig, MCPToolCall, MCPToolResult, Memory, MemoryEventMetadata, MemoryManager, MemoryMessage, MemoryOptions, MemoryReadErrorEvent, MemoryReadStartEvent, MemoryReadSuccessEvent, MemoryWriteErrorEvent, MemoryWriteStartEvent, MemoryWriteSuccessEvent, MessageContent, MessageFilterOptions, MessageRole, ModelToolCall, NewTimelineEvent, NextAction, NodeType, OnEndHookArgs, OnHandoffHookArgs, OnStartHookArgs, OnToolEndHookArgs, OnToolStartHookArgs, OperationContext, PackageUpdateInfo, PromptCreator, PromptTemplate, ProviderObjectResponse, ProviderObjectStreamResponse, ProviderParams, ProviderResponse, ProviderTextResponse, ProviderTextStreamResponse, ReadableStreamType, ReasoningStep, ReasoningStepSchema, ReasoningToolExecuteOptions, Retriever, RetrieverErrorEvent, RetrieverOptions, RetrieverStartEvent, RetrieverSuccessEvent, RetryConfig, StandardEventData, StandardTimelineEvent, StdioServerConfig, StepChunkCallback, StepFinishCallback, StepWithContent, StreamObjectFinishResult, StreamObjectOnFinishCallback, StreamObjectOptions, StreamTextFinishResult, StreamTextOnFinishCallback, StreamTextOptions, TemplateVariables, TextPart, TimelineEventCoreLevel, TimelineEventCoreStatus, TimelineEventCoreType, Tool, ToolCall, ToolErrorEvent, ToolErrorInfo, ToolExecuteOptions, ToolExecutionContext, ToolManager, ToolOptions, ToolSchema, ToolStartEvent, ToolStatus, ToolStatusInfo, ToolSuccessEvent, Toolkit, ToolsetMap, ToolsetWithTools, TransportError, Usage, UsageInfo, Voice, VoiceEventData, VoiceEventType, VoiceMetadata, VoiceOptions, VoltAgent, VoltAgentError, VoltAgentExporter, VoltAgentExporterOptions, checkForUpdates, createHooks, createNodeId, createPrompt, createReasoningTools, createRetrieverTool, createTool, createToolkit, VoltAgent as default, getNodeTypeFromNodeId, registerCustomEndpoint, registerCustomEndpoints, safeJsonParse, serializeValueForDebug, tool, updateAllPackages, updateSinglePackage, zodSchemaToJsonUI };
+export { Agent, AgentErrorEvent, AgentHistoryEntry, AgentHookOnEnd, AgentHookOnHandoff, AgentHookOnStart, AgentHookOnToolEnd, AgentHookOnToolStart, AgentHooks, AgentOptions, AgentRegistry, AgentResponse, AgentStartEvent, AgentStartEventMetadata, AgentSuccessEvent, AgentSuccessEventMetadata, AgentTool, AllowedVariableValue, AnyToolConfig, AsyncIterableStream, BaseEventMetadata, BaseLLMOptions, BaseMessage, BaseRetriever, BaseTimelineEvent, BaseTool, BaseToolCall, ClientInfo, Conversation, ConversationQueryOptions, CreateConversationInput, CreateReasoningToolsOptions, CustomEndpointDefinition, CustomEndpointError, CustomEndpointHandler, DEFAULT_INSTRUCTIONS, DataContent, EventStatus, ExtractVariableNames, FEW_SHOT_EXAMPLES, FilePart, GenerateObjectOptions, GenerateTextOptions, HTTPServerConfig, HistoryStatus, HttpMethod, ImagePart, InMemoryStorage, InferGenerateObjectResponse, InferGenerateTextResponse, InferMessage, InferModel, InferProviderParams, InferStreamResponse, InferTool, LLMProvider, LibSQLStorage, MCPClient, MCPClientConfig, MCPClientEvents, MCPConfiguration, MCPOptions, MCPServerConfig, MCPToolCall, MCPToolResult, Memory, MemoryEventMetadata, MemoryManager, MemoryMessage, MemoryOptions, MemoryReadErrorEvent, MemoryReadStartEvent, MemoryReadSuccessEvent, MemoryWriteErrorEvent, MemoryWriteStartEvent, MemoryWriteSuccessEvent, MessageContent, MessageFilterOptions, MessageRole, ModelToolCall, NewTimelineEvent, NextAction, NodeType, OnEndHookArgs, OnHandoffHookArgs, OnStartHookArgs, OnToolEndHookArgs, OnToolStartHookArgs, OperationContext, PackageUpdateInfo, PromptCreator, PromptTemplate, ProviderObjectResponse, ProviderObjectStreamResponse, ProviderParams, ProviderResponse, ProviderTextResponse, ProviderTextStreamResponse, ReadableStreamType, ReasoningStep, ReasoningStepSchema, ReasoningToolExecuteOptions, RetrieveOptions, Retriever, RetrieverErrorEvent, RetrieverOptions, RetrieverStartEvent, RetrieverSuccessEvent, RetryConfig, StandardEventData, StandardTimelineEvent, StdioServerConfig, StepChunkCallback, StepFinishCallback, StepWithContent, StreamObjectFinishResult, StreamObjectOnFinishCallback, StreamObjectOptions, StreamTextFinishResult, StreamTextOnFinishCallback, StreamTextOptions, TemplateVariables, TextPart, TimelineEventCoreLevel, TimelineEventCoreStatus, TimelineEventCoreType, Tool, ToolCall, ToolErrorEvent, ToolErrorInfo, ToolExecuteOptions, ToolExecutionContext, ToolManager, ToolOptions, ToolSchema, ToolStartEvent, ToolStatus, ToolStatusInfo, ToolSuccessEvent, Toolkit, ToolsetMap, ToolsetWithTools, TransportError, Usage, UsageInfo, Voice, VoiceEventData, VoiceEventType, VoiceMetadata, VoiceOptions, VoltAgent, VoltAgentError, VoltAgentExporter, VoltAgentExporterOptions, checkForUpdates, createAsyncIterableStream, createHooks, createNodeId, createPrompt, createReasoningTools, createRetrieverTool, createTool, createToolkit, VoltAgent as default, getNodeTypeFromNodeId, registerCustomEndpoint, registerCustomEndpoints, safeJsonParse, serializeValueForDebug, tool, updateAllPackages, updateSinglePackage, zodSchemaToJsonUI };