@voltagent/core 0.1.42 → 0.1.43

package/dist/index.d.ts

@@ -555,6 +555,11 @@ declare class HistoryManager {
      * Optional VoltAgentExporter for sending telemetry data.
      */
     private voltAgentExporter?;
+    /**
+     * Background queue for non-blocking history operations
+     * Uses lower concurrency to preserve operation order when telemetryExporter is enabled
+     */
+    private historyQueue;
     /**
      * Create a new history manager
      *
@@ -573,11 +578,22 @@ declare class HistoryManager {
      * This allows the exporter to be set after the HistoryManager is created.
      */
     setExporter(exporter: VoltAgentExporter): void;
+    /**
+     * Get the VoltAgentExporter instance
+     * @returns The VoltAgentExporter instance or undefined if not configured
+     */
+    getExporter(): VoltAgentExporter | undefined;
     /**
      * Checks if a VoltAgentExporter is configured for this history manager.
      * @returns True if an exporter is configured, false otherwise.
      */
     isExporterConfigured(): boolean;
+    /**
+     * Queue a history operation for background processing
+     * @param operationId Unique identifier for the operation
+     * @param operation The async operation to execute
+     */
+    private queueHistoryOperation;
     /**
      * Add a new history entry
      *
@@ -592,7 +608,7 @@ declare class HistoryManager {
      * @param steps - Steps to add
      * @returns The updated entry or undefined if not found
      */
-    addStepsToEntry(entryId: string, steps: StepWithContent[]): Promise<AgentHistoryEntry | undefined>;
+    addStepsToEntry(entryId: string, steps: StepWithContent[]): void;
     /**
      * Get history entry by ID
      *
@@ -619,11 +635,12 @@ declare class HistoryManager {
      */
     updateEntry(id: string, updates: Partial<Omit<AgentHistoryEntry, "id" | "timestamp"> & {
         metadata?: Record<string, unknown>;
-    }>): Promise<AgentHistoryEntry | undefined>;
+    }>): void;
     /**
      * 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
@@ -692,44 +709,66 @@ interface VoltAgentExporterOptions {
 declare class VoltAgentExporter {
     private apiClient;
     readonly publicKey: string;
+    /**
+     * Internal queue for all telemetry export operations
+     * Ensures non-blocking exports that don't interfere with event ordering
+     */
+    private telemetryQueue;
     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.
+     * @returns A promise that resolves with the response from the telemetry service.
      */
     exportHistoryEntry(historyEntryData: ExportAgentHistoryPayload): Promise<{
         historyEntryId: string;
     }>;
+    /**
+     * Exports a single agent history entry asynchronously (non-blocking).
+     * Queues the export operation to avoid blocking the calling thread.
+     * @param historyEntryData - The agent history data to export.
+     */
+    exportHistoryEntryAsync(historyEntryData: ExportAgentHistoryPayload): void;
     /**
      * 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 a single timeline event asynchronously (non-blocking).
+     * Queues the export operation to avoid blocking the calling thread.
+     * @param timelineEventData - The timeline event data to export.
+     */
+    exportTimelineEventAsync(timelineEventData: ExportTimelineEventPayload): void;
     /**
      * 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.
+     * @returns A promise that resolves when the export is complete.
      */
     exportHistorySteps(history_id: string, steps: HistoryStep[]): Promise<void>;
+    /**
+     * Exports history steps for a specific agent history entry asynchronously (non-blocking).
+     * @param history_id - The ID of the history entry to export steps for.
+     * @param steps - The steps data to export.
+     */
+    exportHistoryStepsAsync(history_id: string, steps: HistoryStep[]): 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.
+     * @returns A promise that resolves when the update is complete.
      */
     updateHistoryEntry(history_id: string, updates: Partial<AgentHistoryUpdatableFields>): Promise<void>;
+    /**
+     * Updates specific fields of an agent history entry asynchronously (non-blocking).
+     * @param history_id - The ID of the history entry to update.
+     * @param updates - An object containing the fields to update.
+     */
+    updateHistoryEntryAsync(history_id: string, updates: Partial<AgentHistoryUpdatableFields>): void;
 }
 
 type StreamEventType = StreamEvent["type"];
@@ -2401,16 +2440,19 @@ declare class MemoryManager {
      * The ID of the resource (agent) that owns this memory manager
      */
     private resourceId;
+    /**
+     * Background queue for memory operations
+     */
+    private backgroundQueue;
     /**
      * Creates a new MemoryManager
      */
     constructor(resourceId: string, memory?: Memory | false, options?: MemoryOptions);
     /**
-     * Create and publish a timeline event for memory operations
+     * Create and publish a timeline event for memory operations using the queue
      *
      * @param context - Operation context with history entry info
      * @param event - Timeline event to publish
-     * @returns A promise that resolves when the event is published
      */
     private publishTimelineEvent;
     /**
@@ -2422,12 +2464,26 @@ declare class MemoryManager {
      */
     createStepFinishHandler(context: OperationContext, userId?: string, conversationId?: string): (() => void) | ((step: StepWithContent) => Promise<void>);
     /**
-     * Prepare conversation context for message generation
+     * Prepare conversation context for message generation (CONTEXT-FIRST OPTIMIZED)
+     * Ensures context is always loaded, optimizes non-critical operations in background
      */
     prepareConversationContext(context: OperationContext, input: string | BaseMessage[], userId?: string, conversationIdParam?: string, contextLimit?: number): Promise<{
         messages: BaseMessage[];
         conversationId: string;
     }>;
+    /**
+     * Handle sequential background operations using the queue
+     * Setup conversation and save input in a single atomic operation
+     */
+    private handleSequentialBackgroundOperations;
+    /**
+     * Ensure conversation exists (background task)
+     */
+    private ensureConversationExists;
+    /**
+     * Save current input (background task)
+     */
+    private saveCurrentInput;
     /**
      * Get the memory instance
      */
@@ -3024,6 +3080,7 @@ declare class Agent<TProvider extends {
      * Helper method to enrich and end an OpenTelemetry span associated with a tool call.
      */
     private _endOtelToolSpan;
+    private publishTimelineEvent;
     /**
      * Create an enhanced fullStream with real-time SubAgent event injection
      */