@voltagent/core 0.1.71 → 0.1.72

package/dist/index.d.ts

@@ -344,10 +344,13 @@ type InternalAnyWorkflowStep<INPUT, DATA = DangerouslyAllowAny, RESULT = Dangero
  * Infer the result type from a list of steps
  * @private - INTERNAL USE ONLY
  */
-type InternalInferWorkflowStepsResult<STEPS extends ReadonlyArray<InternalAnyWorkflowStep<DangerouslyAllowAny, DangerouslyAllowAny, DangerouslyAllowAny>>> = {
-    [K in keyof STEPS]: Awaited<ReturnType<STEPS[K]["execute"]>>;
+type InternalInferWorkflowStepsResult<STEPS extends ReadonlyArray<InternalAnyWorkflowStep<any, any, any, any, any>>> = {
+    [K in keyof STEPS]: ExtractExecuteResult<STEPS[K]>;
 };
 type InternalExtractWorkflowInputData<T> = TF.IsUnknown<T> extends true ? BaseMessage | BaseMessage[] | string : TF.IsAny<T> extends true ? BaseMessage | BaseMessage[] | string : T extends z.ZodType ? z.infer<T> : T;
+type ExtractExecuteResult<T> = T extends {
+    execute: (...args: any[]) => infer R;
+} ? R extends Promise<infer U> ? U : R : never;
 
 type WorkflowStateStatus = "pending" | "running" | "completed" | "failed" | "suspended";
 type WorkflowState<INPUT, RESULT> = {
@@ -3545,6 +3548,17 @@ interface LibSQLStorageOptions extends MemoryOptions {
      * @default 100
      */
     storageLimit?: number;
+    /**
+     * Number of retry attempts for database operations when encountering busy/locked errors
+     * @default 3
+     */
+    retryAttempts?: number;
+    /**
+     * Base delay in milliseconds before retrying a failed operation
+     * Uses a jittered exponential backoff strategy for better load distribution
+     * @default 50
+     */
+    baseDelayMs?: number;
 }
 /**
  * A LibSQL storage implementation of the Memory and WorkflowMemory interfaces
@@ -3560,6 +3574,8 @@ declare class LibSQLStorage implements Memory {
     private initialized;
     private workflowExtension;
     private logger;
+    private retryAttempts;
+    private baseDelayMs;
     /**
      * Create a new LibSQL storage
      * @param options Configuration options
@@ -3577,6 +3593,20 @@ declare class LibSQLStorage implements Memory {
      * @param data Additional data to log
      */
     private debug;
+    /**
+     * Calculate delay with jitter for better load distribution
+     * @param attempt Current retry attempt number
+     * @returns Delay in milliseconds
+     */
+    private calculateRetryDelay;
+    /**
+     * Execute a database operation with retry strategy
+     * Implements jittered exponential backoff
+     * @param operationFn The operation function to execute
+     * @param operationName Operation name for logging
+     * @returns The result of the operation
+     */
+    private executeWithRetryStrategy;
     /**
      * Initialize workflow tables
      */
@@ -3619,7 +3649,7 @@ declare class LibSQLStorage implements Memory {
     /**
      * Close the database connection
      */
-    close(): void;
+    close(): Promise<void>;
     /**
      * Add or update a history entry
      * @param key Entry ID
@@ -4989,10 +5019,10 @@ declare function andWhen<INPUT, DATA, RESULT>({ condition, step, inputSchema, ou
  * @param config - Configuration object with steps array and metadata
  * @returns A workflow step that executes all steps simultaneously and returns their results as an array
  */
-declare function andAll<INPUT, DATA, RESULT, STEPS extends ReadonlyArray<InternalAnyWorkflowStep<INPUT, DATA, RESULT>>, INFERRED_RESULT = InternalInferWorkflowStepsResult<STEPS>>({ steps, ...config }: WorkflowStepParallelAllConfig<STEPS>): {
+declare function andAll<INPUT, DATA, RESULT, STEPS extends ReadonlyArray<InternalAnyWorkflowStep<INPUT, DATA, RESULT>>>({ steps, ...config }: WorkflowStepParallelAllConfig<STEPS>): {
     type: "parallel-all";
-    steps: InternalAnyWorkflowStep<INPUT, DATA, INFERRED_RESULT>[];
-    execute: (context: WorkflowExecuteContext<INPUT, DATA, any, any>) => Promise<INFERRED_RESULT>;
+    steps: InternalAnyWorkflowStep<INPUT, DATA, InternalInferWorkflowStepsResult<STEPS>>[];
+    execute: (context: WorkflowExecuteContext<INPUT, DATA, any, any>) => Promise<InternalInferWorkflowStepsResult<STEPS>>;
     id: string;
     name: string;
     purpose: string;
@@ -5043,12 +5073,12 @@ declare function andAll<INPUT, DATA, RESULT, STEPS extends ReadonlyArray<Interna
  * @param config - Configuration object with steps array and metadata
  * @returns A workflow step that executes all steps simultaneously and returns the result from the first step to complete
  */
-declare function andRace<INPUT, DATA, RESULT, STEPS extends ReadonlyArray<InternalAnyWorkflowStep<INPUT, DATA, RESULT>>, INFERRED_RESULT = InternalInferWorkflowStepsResult<STEPS>[number]>({ steps, ...config }: InternalWorkflowStepConfig<{
+declare function andRace<INPUT, DATA, RESULT, STEPS extends ReadonlyArray<InternalAnyWorkflowStep<INPUT, DATA, RESULT>>>({ steps, ...config }: InternalWorkflowStepConfig<{
     steps: STEPS;
 }>): {
     type: "parallel-race";
-    steps: InternalAnyWorkflowStep<INPUT, DATA, INFERRED_RESULT>[];
-    execute: (context: WorkflowExecuteContext<INPUT, DATA, any, any>) => Promise<INFERRED_RESULT>;
+    steps: InternalAnyWorkflowStep<INPUT, DATA, InternalInferWorkflowStepsResult<STEPS>[number]>[];
+    execute: (context: WorkflowExecuteContext<INPUT, DATA, any, any>) => Promise<InternalInferWorkflowStepsResult<STEPS>[number]>;
     id: string;
     name: string;
     purpose: string;

package/dist/index.js

@@ -4669,18 +4669,24 @@ var LibSQLStorage = class {
   initialized;
   workflowExtension;
   logger;
+  retryAttempts;
+  baseDelayMs;
   /**
    * Create a new LibSQL storage
    * @param options Configuration options
    */
   constructor(options) {
     this.logger = new LoggerProxy({ component: "libsql-storage" });
+    this.retryAttempts = options.retryAttempts ?? 3;
+    this.baseDelayMs = options.baseDelayMs ?? 50;
     this.options = {
       storageLimit: options.storageLimit || 100,
       tablePrefix: options.tablePrefix || "voltagent_memory",
       debug: options.debug || false,
       url: this.normalizeUrl(options.url),
-      authToken: options.authToken
+      authToken: options.authToken,
+      retryAttempts: this.retryAttempts,
+      baseDelayMs: this.baseDelayMs
     };
     this.client = (0, import_client.createClient)({
       url: this.options.url,
@@ -4726,6 +4732,50 @@ var LibSQLStorage = class {
       this.logger.debug(`${message}`, data || "");
     }
   }
+  /**
+   * Calculate delay with jitter for better load distribution
+   * @param attempt Current retry attempt number
+   * @returns Delay in milliseconds
+   */
+  calculateRetryDelay(attempt) {
+    const exponentialDelay = this.baseDelayMs * 2 ** (attempt - 1);
+    const jitterFactor = 0.2 + Math.random() * 0.2;
+    const delayWithJitter = exponentialDelay * (1 + jitterFactor);
+    return Math.min(delayWithJitter, 2e3);
+  }
+  /**
+   * Execute a database operation with retry strategy
+   * Implements jittered exponential backoff
+   * @param operationFn The operation function to execute
+   * @param operationName Operation name for logging
+   * @returns The result of the operation
+   */
+  async executeWithRetryStrategy(operationFn, operationName) {
+    let attempt = 0;
+    while (attempt < this.retryAttempts) {
+      attempt++;
+      try {
+        return await operationFn();
+      } catch (error) {
+        const isBusyError = error.message && (error.message.includes("SQLITE_BUSY") || error.message.includes("database is locked") || error.code === "SQLITE_BUSY");
+        if (!isBusyError || attempt >= this.retryAttempts) {
+          this.debug(`Operation failed: ${operationName}`, {
+            attempt,
+            error: error.message
+          });
+          throw error;
+        }
+        const delay = this.calculateRetryDelay(attempt);
+        this.debug(`Retrying ${operationName}`, {
+          attempt,
+          remainingAttempts: this.retryAttempts - attempt,
+          delay
+        });
+        await new Promise((resolve) => setTimeout(resolve, delay));
+      }
+    }
+    throw new Error(`Max retry attempts (${this.retryAttempts}) exceeded for ${operationName}`);
+  }
   /**
    * Initialize workflow tables
    */
@@ -4744,6 +4794,20 @@ var LibSQLStorage = class {
    * @returns Promise that resolves when initialization is complete
    */
   async initializeDatabase() {
+    if (this.options.url.startsWith("file:") || this.options.url.includes(":memory:")) {
+      try {
+        await this.client.execute("PRAGMA journal_mode=WAL;");
+        this.debug("PRAGMA journal_mode=WAL set.");
+      } catch (err) {
+        this.debug("Failed to set PRAGMA journal_mode=WAL.", err);
+      }
+      try {
+        await this.client.execute("PRAGMA busy_timeout = 5000;");
+        this.debug("PRAGMA busy_timeout=5000 set.");
+      } catch (err) {
+        this.debug("Failed to set PRAGMA busy_timeout.", err);
+      }
+    }
     const conversationsTableName = `${this.options.tablePrefix}_conversations`;
     await this.client.execute(`
         CREATE TABLE IF NOT EXISTS ${conversationsTableName} (
@@ -5015,7 +5079,7 @@ var LibSQLStorage = class {
     await debugDelay();
     const tableName = `${this.options.tablePrefix}_messages`;
     const contentString = JSON.stringify(message.content);
-    try {
+    await this.executeWithRetryStrategy(async () => {
       await this.client.execute({
         sql: `INSERT INTO ${tableName} (conversation_id, message_id, role, content, type, created_at)
               VALUES (?, ?, ?, ?, ?, ?)`,
@@ -5034,10 +5098,7 @@ var LibSQLStorage = class {
       } catch (pruneError) {
         this.debug("Error pruning old messages:", pruneError);
       }
-    } catch (error) {
-      this.debug("Error adding message:", error);
-      throw new Error("Failed to add message to LibSQL database");
-    }
+    }, `addMessage[${message.id}]`);
   }
   /**
    * Prune old messages to respect storage limit
@@ -5110,7 +5171,11 @@ var LibSQLStorage = class {
   /**
    * Close the database connection
    */
-  close() {
+  async close() {
+    try {
+      await this.initialized;
+    } catch {
+    }
     this.client.close();
   }
   /**
@@ -5370,7 +5435,7 @@ var LibSQLStorage = class {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const metadataString = JSON.stringify(conversation.metadata);
     const tableName = `${this.options.tablePrefix}_conversations`;
-    try {
+    return await this.executeWithRetryStrategy(async () => {
       await this.client.execute({
         sql: `INSERT INTO ${tableName} (id, resource_id, user_id, title, metadata, created_at, updated_at)
               VALUES (?, ?, ?, ?, ?, ?, ?)`,
@@ -5393,10 +5458,7 @@ var LibSQLStorage = class {
         createdAt: now,
         updatedAt: now
       };
-    } catch (error) {
-      this.debug("Error creating conversation:", error);
-      throw new Error("Failed to create conversation in LibSQL database");
-    }
+    }, `createConversation[${conversation.id}]`);
   }
   async getConversation(id) {
     await this.initialized;