@voltagent/core 0.1.47 → 0.1.49

package/README.md

@@ -128,7 +128,7 @@ VOLTAGENT SERVER STARTED SUCCESSFULLY
 ══════════════════════════════════════════════════
 ✓ HTTP Server: http://localhost:3141
 
-VoltOps Platform: https://console.voltagent.dev
+Test your agents with VoltOps Console: https://console.voltagent.dev
 ══════════════════════════════════════════════════
 ```
 

package/dist/index.d.ts

@@ -808,16 +808,245 @@ declare function streamEventForwarder(event: StreamEvent, options: StreamEventFo
 declare function createStreamEventForwarder(options: StreamEventForwarderOptions): (event: StreamEvent) => Promise<void>;
 
 /**
- * Options object for dynamic value resolution
+ * VoltOps Client Type Definitions
+ *
+ * All types related to VoltOps client functionality including
+ * prompt management, telemetry, and API interactions.
+ */
+
+/**
+ * Reference to a prompt in the VoltOps system
+ */
+type PromptReference = {
+    /** Name of the prompt */
+    promptName: string;
+    /** Specific version number (takes precedence over label) */
+    version?: number;
+    /** Label to fetch (e.g., 'latest', 'production', 'staging') */
+    label?: string;
+    /** Variables to substitute in the template */
+    variables?: Record<string, any>;
+    /** Per-prompt cache configuration (overrides global settings) */
+    promptCache?: {
+        enabled?: boolean;
+        ttl?: number;
+        maxSize?: number;
+    };
+};
+/**
+ * Helper interface for prompt operations in agent instructions
  */
-type DynamicValueOptions = {
-    /** User-defined context that can be used for dynamic value resolution */
+type PromptHelper = {
+    /** Get prompt content by reference */
+    getPrompt: (reference: PromptReference) => Promise<PromptContent>;
+};
+/**
+ * Enhanced dynamic value options with prompts support
+ */
+interface DynamicValueOptions {
+    /** User context map */
     userContext: Map<string | symbol, unknown>;
+    /** Prompt helper (available when VoltOpsClient is configured) */
+    prompts: PromptHelper;
+}
+/**
+ * Dynamic value type for agent configuration
+ */
+type DynamicValue<T> = (options: DynamicValueOptions) => Promise<T> | T;
+/**
+ * VoltOps client configuration options
+ */
+type VoltOpsClientOptions = {
+    /** Base URL of the VoltOps API (default: https://api.voltagent.dev) */
+    baseUrl?: string;
+    /**
+     * Public API key for VoltOps authentication
+     *
+     * @description Your VoltOps public key used for API authentication and prompt management.
+     * This key is safe to use in client-side applications as it only provides read access.
+     *
+     * @format Should start with `pk_` prefix (e.g., `pk_1234567890abcdef`)
+     *
+     * @example
+     * ```typescript
+     * publicKey: process.env.VOLTOPS_PUBLIC_KEY
+     * ```
+     *
+     *
+     * @obtain Get your API keys from: https://console.voltagent.dev/settings/projects
+     */
+    publicKey?: string;
+    /**
+     * Secret API key for VoltOps authentication
+     *
+     * @description Your VoltOps secret key used for secure API operations and analytics.
+     * This key provides full access to your VoltOps project and should be kept secure.
+     *
+     * @format Should start with `sk_` prefix (e.g., `sk_abcdef1234567890`)
+     *
+     * @example
+     * ```typescript
+     * secretKey: process.env.VOLTOPS_SECRET_KEY
+     * ```
+     *
+     *
+     * @obtain Get your API keys from: https://console.voltagent.dev/settings/projects
+     */
+    secretKey?: string;
+    /** Custom fetch implementation (optional) */
+    fetch?: typeof fetch;
+    /** Enable observability export (default: true) */
+    observability?: boolean;
+    /** Enable prompt management (default: true) */
+    prompts?: boolean;
+    /** Optional configuration for prompt caching */
+    promptCache?: {
+        enabled?: boolean;
+        ttl?: number;
+        maxSize?: number;
+    };
 };
 /**
- * A value that can be either static or dynamically computed based on context
+ * Cached prompt data for performance optimization
  */
-type DynamicValue<T> = T | ((options: DynamicValueOptions) => T | Promise<T>);
+type CachedPrompt = {
+    /** Prompt content */
+    content: string;
+    /** When the prompt was fetched */
+    fetchedAt: number;
+    /** Time to live in milliseconds */
+    ttl: number;
+};
+/**
+ * API response for prompt fetch operations
+ * Simplified format matching the desired response structure
+ */
+type PromptApiResponse = {
+    /** Prompt name */
+    name: string;
+    /** Prompt type */
+    type: "text" | "chat";
+    /** Prompt content object */
+    prompt: PromptContent;
+    /** LLM configuration */
+    config: {
+        model?: string;
+        temperature?: number;
+        max_tokens?: number;
+        top_p?: number;
+        frequency_penalty?: number;
+        presence_penalty?: number;
+        supported_languages?: string[];
+        [key: string]: any;
+    };
+    /** Prompt version number */
+    version: number;
+    /** Labels array */
+    labels: string[];
+    /** Tags array */
+    tags: string[];
+    /** Base prompt ID for tracking */
+    prompt_id: string;
+    /** PromptVersion ID (the actual entity ID) */
+    prompt_version_id: string;
+};
+/**
+ * API client interface for prompt operations
+ */
+interface PromptApiClient {
+    /** Fetch a prompt by reference */
+    fetchPrompt(reference: PromptReference): Promise<PromptApiResponse>;
+}
+/**
+ * VoltOps prompt manager interface
+ */
+interface VoltOpsPromptManager {
+    /** Get prompt content by reference */
+    getPrompt(reference: PromptReference): Promise<PromptContent>;
+    /** Preload prompts for better performance */
+    preload(references: PromptReference[]): Promise<void>;
+    /** Clear cache */
+    clearCache(): void;
+    /** Get cache statistics */
+    getCacheStats(): {
+        size: number;
+        entries: string[];
+    };
+}
+/**
+ * Main VoltOps client interface
+ */
+interface VoltOpsClient$1 {
+    /** Prompt management functionality */
+    prompts?: VoltOpsPromptManager;
+    /** Observability exporter (for backward compatibility) */
+    observability?: VoltAgentExporter;
+    /** Configuration options */
+    options: VoltOpsClientOptions & {
+        baseUrl: string;
+    };
+    /** Create a prompt helper for agent instructions */
+    createPromptHelper(agentId: string, historyEntryId?: string): PromptHelper;
+    /** Backward compatibility methods */
+    exportHistoryEntry?: VoltAgentExporter["exportHistoryEntry"];
+    exportHistoryEntryAsync?: VoltAgentExporter["exportHistoryEntryAsync"];
+    exportTimelineEvent?: VoltAgentExporter["exportTimelineEvent"];
+    exportTimelineEventAsync?: VoltAgentExporter["exportTimelineEventAsync"];
+}
+/**
+ * Chat message structure compatible with BaseMessage
+ */
+type ChatMessage = BaseMessage;
+/**
+ * Content of a prompt - either text or chat messages
+ */
+interface PromptContent {
+    type: "text" | "chat";
+    text?: string;
+    messages?: ChatMessage[];
+    /**
+     * Metadata about the prompt from VoltOps API
+     * Available when prompt is fetched from VoltOps
+     */
+    metadata?: {
+        /** Base prompt ID for tracking */
+        prompt_id?: string;
+        /** Specific PromptVersion ID (critical for analytics) */
+        prompt_version_id?: string;
+        /** Prompt name */
+        name?: string;
+        /** Prompt version number */
+        version?: number;
+        /** Labels array (e.g., 'production', 'staging', 'latest') */
+        labels?: string[];
+        /** Tags array for categorization */
+        tags?: string[];
+        /** LLM configuration from prompt */
+        config?: {
+            model?: string;
+            temperature?: number;
+            max_tokens?: number;
+            top_p?: number;
+            frequency_penalty?: number;
+            presence_penalty?: number;
+            supported_languages?: string[];
+            [key: string]: any;
+        };
+    };
+}
+
+/**
+ * Enhanced dynamic value for instructions that supports prompt management
+ */
+type InstructionsDynamicValue = string | DynamicValue<string | PromptContent>;
+/**
+ * Enhanced dynamic value for models that supports static or dynamic values
+ */
+type ModelDynamicValue<T> = T | DynamicValue<T>;
+/**
+ * Enhanced dynamic value for tools that supports static or dynamic values
+ */
+type ToolsDynamicValue = (Tool<any> | Toolkit)[] | DynamicValue<(Tool<any> | Toolkit)[]>;
 /**
  * Provider options type for LLM configurations
  */
@@ -868,7 +1097,7 @@ type AgentOptions = {
      * Tools and/or Toolkits that the agent can use
      * Can be static or dynamic based on user context
      */
-    tools?: DynamicValue<(Tool<any> | Toolkit)[]>;
+    tools?: ToolsDynamicValue;
     /**
      * Sub-agents that this agent can delegate tasks to
      */
@@ -878,8 +1107,17 @@ type AgentOptions = {
      */
     userContext?: Map<string | symbol, unknown>;
     /**
-     * Telemetry exporter for the agent
-     * Used to send telemetry data to an external service
+     * @deprecated Use `voltOpsClient` instead. Will be removed in a future version.
+     *
+     * Telemetry exporter for the agent - DEPRECATED
+     *
+     * 🔄 MIGRATION REQUIRED:
+     * ❌ OLD: telemetryExporter: new VoltAgentExporter({ ... })
+     * ✅ NEW: voltOpsClient: new VoltOpsClient({ publicKey: "...", secretKey: "..." })
+     *
+     * 📖 Migration guide: https://voltagent.dev/docs/observability/developer-console/#migration-guide-from-telemetryexporter-to-voltopsclient
+     *
+     * ✨ Benefits: Observability + prompt management + dynamic prompts from console
      */
     telemetryExporter?: VoltAgentExporter;
 } & ({
@@ -890,9 +1128,10 @@ type AgentOptions = {
     description: string;
     /**
      * Agent instructions. This is the preferred field.
-     * Can be static or dynamic based on user context
+     * Can be static or dynamic based on user context.
+     * Enhanced to support prompt management via helper functions.
      */
-    instructions?: DynamicValue<string>;
+    instructions?: InstructionsDynamicValue;
 } | {
     /**
      * @deprecated Use `instructions` instead.
@@ -902,10 +1141,33 @@ type AgentOptions = {
     /**
      * Agent instructions. This is the preferred field.
      * Required if description is not provided.
-     * Can be static or dynamic based on user context
+     * Can be static or dynamic based on user context.
+     * Enhanced to support prompt management via helper functions.
      */
-    instructions: DynamicValue<string>;
+    instructions: InstructionsDynamicValue;
 });
+/**
+ * System message response with optional prompt metadata
+ */
+interface SystemMessageResponse {
+    systemMessages: BaseMessage | BaseMessage[];
+    promptMetadata?: {
+        /** Base prompt ID for tracking */
+        prompt_id?: string;
+        /** PromptVersion ID (the actual entity ID) */
+        prompt_version_id?: string;
+        name?: string;
+        version?: number;
+        labels?: string[];
+        tags?: string[];
+        config?: {
+            model?: string;
+            temperature?: number;
+            [key: string]: any;
+        };
+    };
+    isDynamicInstructions?: boolean;
+}
 /**
  * Provider instance type helper
  */
@@ -1261,6 +1523,26 @@ type InferResponseFromProvider<TProvider extends {
 type InferOriginalResponseFromProvider<TProvider extends {
     llm: LLMProvider<any>;
 }, TMethod extends "generateText" | "streamText" | "generateObject" | "streamObject"> = InferResponseFromProvider<TProvider, TMethod>["provider"];
+type GenerateTextResponse<TProvider extends {
+    llm: LLMProvider<any>;
+}> = InferGenerateTextResponseFromProvider<TProvider> & {
+    userContext: Map<string | symbol, unknown>;
+};
+type StreamTextResponse<TProvider extends {
+    llm: LLMProvider<any>;
+}> = InferStreamTextResponseFromProvider<TProvider> & {
+    userContext?: Map<string | symbol, unknown>;
+};
+type GenerateObjectResponse<TProvider extends {
+    llm: LLMProvider<any>;
+}, TSchema extends z.ZodType> = InferGenerateObjectResponseFromProvider<TProvider, TSchema> & {
+    userContext: Map<string | symbol, unknown>;
+};
+type StreamObjectResponse<TProvider extends {
+    llm: LLMProvider<any>;
+}, TSchema extends z.ZodType> = InferStreamObjectResponseFromProvider<TProvider, TSchema> & {
+    userContext?: Map<string | symbol, unknown>;
+};
 
 /**
  * Token usage information
@@ -2650,6 +2932,65 @@ declare abstract class BaseRetriever {
     abstract retrieve(input: string | BaseMessage[], options: RetrieveOptions): Promise<string>;
 }
 
+/**
+ * Main VoltOps client class that provides unified access to both
+ * telemetry export and prompt management functionality.
+ */
+declare class VoltOpsClient implements VoltOpsClient$1 {
+    readonly options: VoltOpsClientOptions & {
+        baseUrl: string;
+    };
+    readonly observability?: VoltAgentExporter;
+    readonly prompts?: VoltOpsPromptManager;
+    constructor(options: VoltOpsClientOptions);
+    /**
+     * Create a prompt helper for agent instructions
+     */
+    createPromptHelper(_agentId: string): PromptHelper;
+    get exportHistoryEntry(): ((historyEntryData: ExportAgentHistoryPayload) => Promise<{
+        historyEntryId: string;
+    }>) | undefined;
+    get exportHistoryEntryAsync(): ((historyEntryData: ExportAgentHistoryPayload) => void) | undefined;
+    get exportTimelineEvent(): ((timelineEventData: ExportTimelineEventPayload) => Promise<{
+        timelineEventId: string;
+    }>) | undefined;
+    get exportTimelineEventAsync(): ((timelineEventData: ExportTimelineEventPayload) => void) | undefined;
+    /**
+     * Check if observability is enabled and configured
+     */
+    isObservabilityEnabled(): boolean;
+    /**
+     * Check if prompt management is enabled and configured
+     */
+    isPromptManagementEnabled(): boolean;
+    /**
+     * Get observability exporter for backward compatibility
+     * @deprecated Use observability property directly
+     */
+    getObservabilityExporter(): VoltAgentExporter | undefined;
+    /**
+     * Get prompt manager for direct access
+     */
+    getPromptManager(): VoltOpsPromptManager | undefined;
+    /**
+     * Static method to create prompt helper with priority-based fallback
+     * Priority: Agent VoltOpsClient > Global VoltOpsClient > Fallback instructions
+     */
+    static createPromptHelperWithFallback(agentId: string, agentName: string, fallbackInstructions: string, agentVoltOpsClient?: VoltOpsClient): PromptHelper;
+    /**
+     * Validate API keys and provide helpful error messages
+     */
+    private validateApiKeys;
+    /**
+     * Cleanup resources when client is no longer needed
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Factory function to create VoltOps client
+ */
+declare const createVoltOpsClient: (options: VoltOpsClientOptions) => VoltOpsClient;
+
 /**
  * ReadableStream type for voice responses
  */
@@ -2972,18 +3313,23 @@ declare class Agent<TProvider extends {
      * Retriever for automatic RAG
      */
     private retriever?;
+    /**
+     * VoltOps client for this specific agent (optional)
+     * Takes priority over global VoltOpsClient for prompt management
+     */
+    private readonly voltOpsClient?;
     /**
      * Create a new agent
      */
     constructor(options: AgentOptions & TProvider & {
-        model: DynamicValue<ModelType<TProvider>>;
+        model: ModelDynamicValue<ModelType<TProvider>>;
         subAgents?: Agent<any>[];
         maxHistoryEntries?: number;
         hooks?: AgentHooks;
         retriever?: BaseRetriever;
         voice?: Voice;
         markdown?: boolean;
-        telemetryExporter?: VoltAgentExporter;
+        voltOpsClient?: VoltOpsClient;
     });
     /**
      * Resolve dynamic instructions based on user context
@@ -3005,7 +3351,7 @@ declare class Agent<TProvider extends {
         historyEntryId: string;
         contextMessages: BaseMessage[];
         operationContext?: OperationContext;
-    }): Promise<BaseMessage>;
+    }): Promise<SystemMessageResponse>;
     /**
      * Prepare agents memory for the supervisor system message
      * This fetches and formats recent interactions with sub-agents
@@ -3095,19 +3441,19 @@ declare class Agent<TProvider extends {
     /**
      * Generate a text response without streaming
      */
-    generateText(input: string | BaseMessage[], options?: PublicGenerateOptions): Promise<InferGenerateTextResponseFromProvider<TProvider>>;
+    generateText(input: string | BaseMessage[], options?: PublicGenerateOptions): Promise<GenerateTextResponse<TProvider>>;
     /**
      * Stream a text response
      */
-    streamText(input: string | BaseMessage[], options?: PublicGenerateOptions): Promise<InferStreamTextResponseFromProvider<TProvider>>;
+    streamText(input: string | BaseMessage[], options?: PublicGenerateOptions): Promise<StreamTextResponse<TProvider>>;
     /**
      * Generate a structured object response
      */
-    generateObject<TSchema extends z.ZodType>(input: string | BaseMessage[], schema: TSchema, options?: PublicGenerateOptions): Promise<InferGenerateObjectResponseFromProvider<TProvider, TSchema>>;
+    generateObject<TSchema extends z.ZodType>(input: string | BaseMessage[], schema: TSchema, options?: PublicGenerateOptions): Promise<GenerateObjectResponse<TProvider, TSchema>>;
     /**
      * Stream a structured object response
      */
-    streamObject<TSchema extends z.ZodType>(input: string | BaseMessage[], schema: TSchema, options?: PublicGenerateOptions): Promise<InferStreamObjectResponseFromProvider<TProvider, TSchema>>;
+    streamObject<TSchema extends z.ZodType>(input: string | BaseMessage[], schema: TSchema, options?: PublicGenerateOptions): Promise<StreamObjectResponse<TProvider, TSchema>>;
     /**
      * Add a sub-agent that this agent can delegate tasks to
      */
@@ -3165,6 +3511,10 @@ declare class Agent<TProvider extends {
      * This is typically called by the main VoltAgent instance after it has initialized its exporter.
      */
     _INTERNAL_setVoltAgentExporter(exporter: VoltAgentExporter): void;
+    /**
+     * Helper method to get retriever context with event handling
+     */
+    private getRetrieverContext;
 }
 
 /**
@@ -3243,6 +3593,20 @@ type VoltAgentOptions = {
      * Server configuration options
      */
     server?: ServerOptions;
+    /**
+     * Unified VoltOps client for telemetry and prompt management
+     * Replaces the old telemetryExporter approach with a comprehensive solution.
+     */
+    voltOpsClient?: VoltOpsClient$1;
+    /**
+     * @deprecated Use `voltOpsClient` instead. Will be removed in a future version.
+     * Optional OpenTelemetry SpanExporter instance or array of instances.
+     * or a VoltAgentExporter instance or array of instances.
+     * If provided, VoltAgent will attempt to initialize and register
+     * a NodeTracerProvider with a BatchSpanProcessor for the given exporter(s).
+     * It's recommended to only provide this in one VoltAgent instance per application process.
+     */
+    telemetryExporter?: (SpanExporter | VoltAgentExporter) | (SpanExporter | VoltAgentExporter)[];
     /**
      * @deprecated Use `server.port` instead
      */
@@ -3260,14 +3624,6 @@ type VoltAgentOptions = {
      * @deprecated Use `server.enableSwaggerUI` instead
      */
     enableSwaggerUI?: boolean;
-    /**
-     * Optional OpenTelemetry SpanExporter instance or array of instances.
-     * or a VoltAgentExporter instance or array of instances.
-     * If provided, VoltAgent will attempt to initialize and register
-     * a NodeTracerProvider with a BatchSpanProcessor for the given exporter(s).
-     * It's recommended to only provide this in one VoltAgent instance per application process.
-     */
-    telemetryExporter?: (SpanExporter | VoltAgentExporter) | (SpanExporter | VoltAgentExporter)[];
 };
 
 /**
@@ -3931,6 +4287,7 @@ declare class AgentRegistry {
     private agents;
     private isInitialized;
     private globalVoltAgentExporter?;
+    private globalVoltOpsClient?;
     /**
      * Track parent-child relationships between agents (child -> parents)
      */
@@ -4000,6 +4357,15 @@ declare class AgentRegistry {
      * Get the global VoltAgentExporter instance.
      */
     getGlobalVoltAgentExporter(): VoltAgentExporter | undefined;
+    /**
+     * Set the global VoltOpsClient instance.
+     * This replaces the old telemetryExporter approach with a unified solution.
+     */
+    setGlobalVoltOpsClient(client: VoltOpsClient$1 | undefined): void;
+    /**
+     * Get the global VoltOpsClient instance.
+     */
+    getGlobalVoltOpsClient(): VoltOpsClient$1 | undefined;
 }
 
 /**
@@ -4015,6 +4381,117 @@ declare function registerCustomEndpoint(endpoint: CustomEndpointDefinition): voi
  */
 declare function registerCustomEndpoints(endpoints: CustomEndpointDefinition[]): void;
 
+/**
+ * Prompt manager with caching and Liquid template processing
+ */
+
+/**
+ * Implementation of VoltOpsPromptManager with caching and Liquid templates
+ */
+declare class VoltOpsPromptManagerImpl implements VoltOpsPromptManager {
+    private readonly cache;
+    private readonly apiClient;
+    private readonly templateEngine;
+    private readonly cacheConfig;
+    constructor(options: VoltOpsClientOptions);
+    /**
+     * Get prompt content by reference with caching and template processing
+     */
+    getPrompt(reference: PromptReference): Promise<PromptContent>;
+    /**
+     * Preload prompts for better performance
+     */
+    preload(references: PromptReference[]): Promise<void>;
+    /**
+     * Clear cache
+     */
+    clearCache(): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        size: number;
+        entries: string[];
+    };
+    /**
+     * Convert API response to PromptContent with metadata
+     */
+    private convertApiResponseToPromptContent;
+    /**
+     * Generate cache key for prompt reference
+     */
+    private getCacheKey;
+    /**
+     * Get cached prompt if valid
+     */
+    private getCachedPrompt;
+    /**
+     * Set cached prompt with TTL and size limit enforcement
+     */
+    private setCachedPrompt;
+    /**
+     * Evict oldest cache entry to make room for new one
+     */
+    private evictOldestEntry;
+    /**
+     * Process template variables using configured template engine
+     */
+    private processTemplate;
+    /**
+     * Process PromptContent with template processing
+     */
+    private processPromptContent;
+    /**
+     * Process MessageContent (can be string or array of parts)
+     */
+    private processMessageContent;
+}
+
+/**
+ * API client for prompt operations
+ */
+
+/**
+ * Implementation of PromptApiClient for VoltOps API communication
+ */
+declare class VoltOpsPromptApiClient implements PromptApiClient {
+    private readonly baseUrl;
+    private readonly publicKey;
+    private readonly secretKey;
+    private readonly fetchFn;
+    constructor(options: VoltOpsClientOptions);
+    /**
+     * Fetch prompt content from VoltOps API
+     */
+    fetchPrompt(reference: PromptReference): Promise<PromptApiResponse>;
+    /**
+     * Build URL for prompt API endpoint
+     */
+    private buildPromptUrl;
+    /**
+     * Build authentication headers
+     */
+    private buildHeaders;
+}
+
+/**
+ * Simple template engine for basic variable substitution
+ */
+/**
+ * Template engine interface
+ */
+type TemplateEngine = {
+    /** Process template with variables */
+    process: (content: string, variables: Record<string, any>) => string;
+    /** Engine name for debugging */
+    name: string;
+};
+/**
+ * Simple mustache-style template engine (built-in, no dependencies)
+ * Supports {{variable}} syntax for basic variable substitution
+ */
+declare const createSimpleTemplateEngine: () => TemplateEngine;
+
 /**
  * Main VoltAgent class for managing agents and server
  */
@@ -4069,4 +4546,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, AsyncIterableStream, BaseEventMetadata, BaseLLMOptions, BaseMessage, BaseRetriever, BaseTimelineEvent, BaseTool, BaseToolCall, ClientInfo, Conversation, ConversationQueryOptions, CreateConversationInput, CreateReasoningToolsOptions, CustomEndpointDefinition, CustomEndpointError, CustomEndpointHandler, DEFAULT_INSTRUCTIONS, DataContent, DynamicValueOptions, ErrorStreamPart, EventStatus, ExtractVariableNames, FEW_SHOT_EXAMPLES, FilePart, FinishStreamPart, 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, ReasoningStreamPart, ReasoningToolExecuteOptions, RetrieveOptions, Retriever, RetrieverErrorEvent, RetrieverOptions, RetrieverStartEvent, RetrieverSuccessEvent, SSEServerConfig, ServerOptions, SourceStreamPart, StandardEventData, StandardTimelineEvent, StdioServerConfig, StepChunkCallback, StepFinishCallback, StepWithContent, StreamEventForwarderOptions, StreamObjectFinishResult, StreamObjectOnFinishCallback, StreamObjectOptions, StreamPart, StreamTextFinishResult, StreamTextOnFinishCallback, StreamTextOptions, StreamableHTTPServerConfig, TemplateVariables, TextDeltaStreamPart, TextPart, TimelineEventCoreLevel, TimelineEventCoreStatus, TimelineEventCoreType, Tool, ToolCall, ToolCallStreamPart, ToolErrorEvent, ToolErrorInfo, ToolExecuteOptions, ToolExecutionContext, ToolManager, ToolOptions, ToolResultStreamPart, ToolSchema, ToolStartEvent, ToolStatus, ToolStatusInfo, ToolSuccessEvent, Toolkit, ToolsetMap, ToolsetWithTools, TransportError, Usage, UsageInfo, Voice, VoiceEventData, VoiceEventType, VoiceMetadata, VoiceOptions, VoltAgent, VoltAgentError, VoltAgentExporter, VoltAgentExporterOptions, VoltAgentOptions, checkForUpdates, createAsyncIterableStream, createHooks, createNodeId, createPrompt, createReasoningTools, createRetrieverTool, createStreamEventForwarder, createTool, createToolkit, VoltAgent as default, getNodeTypeFromNodeId, registerCustomEndpoint, registerCustomEndpoints, safeJsonParse, serializeValueForDebug, streamEventForwarder, 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, CachedPrompt, ClientInfo, Conversation, ConversationQueryOptions, CreateConversationInput, CreateReasoningToolsOptions, CustomEndpointDefinition, CustomEndpointError, CustomEndpointHandler, DEFAULT_INSTRUCTIONS, DataContent, DynamicValue, DynamicValueOptions, ErrorStreamPart, EventStatus, ExtractVariableNames, FEW_SHOT_EXAMPLES, FilePart, FinishStreamPart, GenerateObjectOptions, GenerateTextOptions, HTTPServerConfig, HistoryStatus, HttpMethod, VoltOpsClient$1 as IVoltOpsClient, 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, PromptApiClient, PromptApiResponse, PromptCreator, PromptHelper, PromptReference, PromptTemplate, ProviderObjectResponse, ProviderObjectStreamResponse, ProviderParams, ProviderResponse, ProviderTextResponse, ProviderTextStreamResponse, ReadableStreamType, ReasoningStep, ReasoningStepSchema, ReasoningStreamPart, ReasoningToolExecuteOptions, RetrieveOptions, Retriever, RetrieverErrorEvent, RetrieverOptions, RetrieverStartEvent, RetrieverSuccessEvent, SSEServerConfig, ServerOptions, SourceStreamPart, StandardEventData, StandardTimelineEvent, StdioServerConfig, StepChunkCallback, StepFinishCallback, StepWithContent, StreamEventForwarderOptions, StreamObjectFinishResult, StreamObjectOnFinishCallback, StreamObjectOptions, StreamPart, StreamTextFinishResult, StreamTextOnFinishCallback, StreamTextOptions, StreamableHTTPServerConfig, TemplateVariables, TextDeltaStreamPart, TextPart, TimelineEventCoreLevel, TimelineEventCoreStatus, TimelineEventCoreType, Tool, ToolCall, ToolCallStreamPart, ToolErrorEvent, ToolErrorInfo, ToolExecuteOptions, ToolExecutionContext, ToolManager, ToolOptions, ToolResultStreamPart, ToolSchema, ToolStartEvent, ToolStatus, ToolStatusInfo, ToolSuccessEvent, Toolkit, ToolsetMap, ToolsetWithTools, TransportError, Usage, UsageInfo, Voice, VoiceEventData, VoiceEventType, VoiceMetadata, VoiceOptions, VoltAgent, VoltAgentError, VoltAgentExporter, VoltAgentExporterOptions, VoltAgentOptions, VoltOpsClient, VoltOpsClientOptions, VoltOpsPromptApiClient, VoltOpsPromptManager, VoltOpsPromptManagerImpl, checkForUpdates, createAsyncIterableStream, createHooks, createNodeId, createPrompt, createReasoningTools, createRetrieverTool, createSimpleTemplateEngine, createStreamEventForwarder, createTool, createToolkit, createVoltOpsClient, VoltAgent as default, getNodeTypeFromNodeId, registerCustomEndpoint, registerCustomEndpoints, safeJsonParse, serializeValueForDebug, streamEventForwarder, tool, updateAllPackages, updateSinglePackage, zodSchemaToJsonUI };