@mastra/libsql 0.11.0 → 0.11.1-alpha.0

package/dist/_tsup-dts-rollup.d.ts

@@ -1,42 +1,81 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
+import type { Client } from '@libsql/client';
 import type { CreateIndexParams } from '@mastra/core/vector';
 import type { DeleteIndexParams } from '@mastra/core/vector';
 import type { DeleteVectorParams } from '@mastra/core/vector';
 import type { DescribeIndexParams } from '@mastra/core/vector';
 import type { EvalRow } from '@mastra/core/storage';
+import type { IMastraLogger } from '@mastra/core/logger';
 import type { IndexStats } from '@mastra/core/vector';
 import type { InValue } from '@libsql/client';
+import { LegacyEvalsStorage } from '@mastra/core/storage';
 import type { MastraMessageContentV2 } from '@mastra/core/agent';
 import type { MastraMessageV1 } from '@mastra/core/memory';
 import type { MastraMessageV2 } from '@mastra/core/agent';
+import type { MastraMessageV2 as MastraMessageV2_2 } from '@mastra/core/memory';
 import { MastraStorage } from '@mastra/core/storage';
 import { MastraVector } from '@mastra/core/vector';
+import { MemoryStorage } from '@mastra/core/storage';
 import type { OperatorSupport } from '@mastra/core/vector/filter';
 import type { OperatorValueMap } from '@mastra/core/vector/filter';
 import type { PaginationArgs } from '@mastra/core/storage';
 import type { PaginationInfo } from '@mastra/core/storage';
 import type { QueryResult } from '@mastra/core/vector';
 import type { QueryVectorParams } from '@mastra/core/vector';
+import type { ScoreRowData } from '@mastra/core/scores';
+import { ScoresStorage } from '@mastra/core/storage';
 import type { StorageColumn } from '@mastra/core/storage';
+import type { StorageDomains } from '@mastra/core/storage';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
+import type { StorageGetTracesArg } from '@mastra/core/storage';
+import type { StorageGetTracesPaginatedArg } from '@mastra/core/storage';
+import type { StoragePagination } from '@mastra/core/storage';
 import type { StorageResourceType } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
+import { StoreOperations } from '@mastra/core/storage';
 import type { TABLE_NAMES } from '@mastra/core/storage';
 import type { Trace } from '@mastra/core/telemetry';
+import { TracesStorage } from '@mastra/core/storage';
 import type { UpdateVectorParams } from '@mastra/core/vector';
 import type { UpsertVectorParams } from '@mastra/core/vector';
 import type { VectorFieldValue } from '@mastra/core/vector/filter';
 import type { VectorFilter } from '@mastra/core/vector/filter';
 import type { WorkflowRun } from '@mastra/core/storage';
+import type { WorkflowRun as WorkflowRun_2 } from '@mastra/core';
 import type { WorkflowRuns } from '@mastra/core/storage';
+import type { WorkflowRuns as WorkflowRuns_2 } from '@mastra/core';
+import type { WorkflowRunState } from '@mastra/core/workflows';
+import type { WorkflowRunState as WorkflowRunState_2 } from '@mastra/core';
+import { WorkflowsStorage } from '@mastra/core/storage';
 
 export declare function buildFilterQuery(filter: LibSQLVectorFilter): FilterResult;
 
+export declare function createExecuteWriteOperationWithRetry({ logger, maxRetries, initialBackoffMs, }: {
+    logger: IMastraLogger;
+    maxRetries: number;
+    initialBackoffMs: number;
+}): <T>(operationFn: () => Promise<T>, operationDescription: string) => Promise<T>;
+
 declare interface FilterResult {
     sql: string;
     values: InValue[];
 }
 
+export declare class LegacyEvalsLibSQL extends LegacyEvalsStorage {
+    private client;
+    constructor({ client }: {
+        client: Client;
+    });
+    /** @deprecated use getEvals instead */
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    getEvals(options?: {
+        agentName?: string;
+        type?: 'test' | 'live';
+    } & PaginationArgs): Promise<PaginationInfo & {
+        evals: EvalRow[];
+    }>;
+}
+
 /**
  * Vector store specific prompt that details supported operators and examples.
  * This prompt helps users construct valid filters for LibSQL Vector.
@@ -45,7 +84,7 @@ declare const LIBSQL_PROMPT = "When querying LibSQL Vector, you can ONLY use the
 export { LIBSQL_PROMPT }
 export { LIBSQL_PROMPT as LIBSQL_PROMPT_alias_1 }
 
-declare interface LibSQLConfig {
+declare type LibSQLConfig = {
     url: string;
     authToken?: string;
     /**
@@ -59,7 +98,11 @@ declare interface LibSQLConfig {
      * @default 100
      */
     initialBackoffMs?: number;
-}
+} | {
+    client: Client;
+    maxRetries?: number;
+    initialBackoffMs?: number;
+};
 export { LibSQLConfig }
 export { LibSQLConfig as LibSQLConfig_alias_1 }
 
@@ -97,17 +140,18 @@ declare class LibSQLStore extends MastraStorage {
     private client;
     private readonly maxRetries;
     private readonly initialBackoffMs;
+    stores: StorageDomains;
     constructor(config: LibSQLConfig);
     get supports(): {
         selectByIncludeResourceScope: boolean;
         resourceWorkingMemory: boolean;
+        hasColumn: boolean;
+        createTable: boolean;
     };
-    private getCreateTableSQL;
     createTable({ tableName, schema, }: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
     }): Promise<void>;
-    protected getSqlType(type: StorageColumn['type']): string;
     /**
      * Alters table schema to add columns if they don't exist
      * @param tableName Name of the table
@@ -122,18 +166,17 @@ declare class LibSQLStore extends MastraStorage {
     clearTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;
-    private prepareStatement;
-    private executeWriteOperationWithRetry;
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
     insert(args: {
         tableName: TABLE_NAMES;
         record: Record<string, any>;
     }): Promise<void>;
-    private doInsert;
     batchInsert(args: {
         tableName: TABLE_NAMES;
         records: Record<string, any>[];
     }): Promise<void>;
-    private doBatchInsert;
     load<R>({ tableName, keys }: {
         tableName: TABLE_NAMES;
         keys: Record<string, string>;
@@ -149,7 +192,9 @@ declare class LibSQLStore extends MastraStorage {
     }): Promise<StorageThreadType[]>;
     getThreadsByResourceIdPaginated(args: {
         resourceId: string;
-    } & PaginationArgs): Promise<PaginationInfo & {
+        page: number;
+        perPage: number;
+    }): Promise<PaginationInfo & {
         threads: StorageThreadType[];
     }>;
     saveThread({ thread }: {
@@ -163,8 +208,6 @@ declare class LibSQLStore extends MastraStorage {
     deleteThread({ threadId }: {
         threadId: string;
     }): Promise<void>;
-    private parseRow;
-    private _getIncludedMessages;
     /**
      * @deprecated use getMessagesPaginated instead for paginated results.
      */
@@ -196,7 +239,6 @@ declare class LibSQLStore extends MastraStorage {
             };
         })[];
     }): Promise<MastraMessageV2[]>;
-    private transformEvalRow;
     /** @deprecated use getEvals instead */
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
     getEvals(options?: {
@@ -205,27 +247,61 @@ declare class LibSQLStore extends MastraStorage {
     } & PaginationArgs): Promise<PaginationInfo & {
         evals: EvalRow[];
     }>;
+    getScoreById({ id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    saveScore(score: Omit<ScoreRowData, 'id' | 'createdAt' | 'updatedAt'>): Promise<{
+        score: ScoreRowData;
+    }>;
+    getScoresByScorerId({ scorerId, entityId, entityType, pagination, }: {
+        scorerId: string;
+        entityId?: string;
+        entityType?: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByRunId({ runId, pagination, }: {
+        runId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByEntityId({ entityId, entityType, pagination, }: {
+        pagination: StoragePagination;
+        entityId: string;
+        entityType: string;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    /**
+     * TRACES
+     */
     /**
      * @deprecated use getTracesPaginated instead.
      */
-    getTraces(args: {
-        name?: string;
-        scope?: string;
-        page: number;
-        perPage: number;
-        attributes?: Record<string, string>;
-        filters?: Record<string, any>;
-        fromDate?: Date;
-        toDate?: Date;
-    }): Promise<Trace[]>;
-    getTracesPaginated(args: {
-        name?: string;
-        scope?: string;
-        attributes?: Record<string, string>;
-        filters?: Record<string, any>;
-    } & PaginationArgs): Promise<PaginationInfo & {
+    getTraces(args: StorageGetTracesArg): Promise<Trace[]>;
+    getTracesPaginated(args: StorageGetTracesArg): Promise<PaginationInfo & {
         traces: Trace[];
     }>;
+    batchTraceInsert(args: {
+        records: Record<string, any>[];
+    }): Promise<void>;
+    /**
+     * WORKFLOWS
+     */
+    persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
+        workflowName: string;
+        runId: string;
+        snapshot: WorkflowRunState;
+    }): Promise<void>;
+    loadWorkflowSnapshot({ workflowName, runId, }: {
+        workflowName: string;
+        runId: string;
+    }): Promise<WorkflowRunState | null>;
     getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
         workflowName?: string;
         fromDate?: Date;
@@ -249,8 +325,6 @@ declare class LibSQLStore extends MastraStorage {
         workingMemory?: string;
         metadata?: Record<string, unknown>;
     }): Promise<StorageResourceType>;
-    private hasColumn;
-    private parseWorkflowRun;
 }
 export { LibSQLStore as DefaultStorage }
 export { LibSQLStore as DefaultStorage_alias_1 }
@@ -329,4 +403,236 @@ export { LibSQLVectorConfig as LibSQLVectorConfig_alias_1 }
 
 export declare type LibSQLVectorFilter = VectorFilter<keyof LibSQLOperatorValueMap, LibSQLOperatorValueMap>;
 
+export declare class MemoryLibSQL extends MemoryStorage {
+    private client;
+    private operations;
+    constructor({ client, operations }: {
+        client: Client;
+        operations: StoreOperationsLibSQL;
+    });
+    private parseRow;
+    private _getIncludedMessages;
+    /**
+     * @deprecated use getMessagesPaginated instead for paginated results.
+     */
+    getMessages(args: StorageGetMessagesArg & {
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format: 'v2';
+    }): Promise<MastraMessageV2_2[]>;
+    getMessagesPaginated(args: StorageGetMessagesArg & {
+        format?: 'v1' | 'v2';
+    }): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2_2[];
+    }>;
+    saveMessages(args: {
+        messages: MastraMessageV1[];
+        format?: undefined | 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: MastraMessageV2_2[];
+        format: 'v2';
+    }): Promise<MastraMessageV2_2[]>;
+    updateMessages({ messages, }: {
+        messages: (Partial<Omit<MastraMessageV2_2, 'createdAt'>> & {
+            id: string;
+            content?: {
+                metadata?: MastraMessageContentV2['metadata'];
+                content?: MastraMessageContentV2['content'];
+            };
+        })[];
+    }): Promise<MastraMessageV2_2[]>;
+    getResourceById({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageResourceType | null>;
+    saveResource({ resource }: {
+        resource: StorageResourceType;
+    }): Promise<StorageResourceType>;
+    updateResource({ resourceId, workingMemory, metadata, }: {
+        resourceId: string;
+        workingMemory?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<StorageResourceType>;
+    getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType | null>;
+    /**
+     * @deprecated use getThreadsByResourceIdPaginated instead for paginated results.
+     */
+    getThreadsByResourceId(args: {
+        resourceId: string;
+    }): Promise<StorageThreadType[]>;
+    getThreadsByResourceIdPaginated(args: {
+        resourceId: string;
+        page: number;
+        perPage: number;
+    }): Promise<PaginationInfo & {
+        threads: StorageThreadType[];
+    }>;
+    saveThread({ thread }: {
+        thread: StorageThreadType;
+    }): Promise<StorageThreadType>;
+    updateThread({ id, title, metadata, }: {
+        id: string;
+        title: string;
+        metadata: Record<string, unknown>;
+    }): Promise<StorageThreadType>;
+    deleteThread({ threadId }: {
+        threadId: string;
+    }): Promise<void>;
+}
+
+export declare function prepareStatement({ tableName, record }: {
+    tableName: TABLE_NAMES;
+    record: Record<string, any>;
+}): {
+    sql: string;
+    args: InValue[];
+};
+
+export declare class ScoresLibSQL extends ScoresStorage {
+    private operations;
+    private client;
+    constructor({ client, operations }: {
+        client: Client;
+        operations: StoreOperationsLibSQL;
+    });
+    getScoresByRunId({ runId, pagination, }: {
+        runId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByScorerId({ scorerId, entityId, entityType, pagination, }: {
+        scorerId: string;
+        entityId?: string;
+        entityType?: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    private transformScoreRow;
+    getScoreById({ id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    saveScore(score: Omit<ScoreRowData, 'id' | 'createdAt' | 'updatedAt'>): Promise<{
+        score: ScoreRowData;
+    }>;
+    getScoresByEntityId({ entityId, entityType, pagination, }: {
+        pagination: StoragePagination;
+        entityId: string;
+        entityType: string;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+}
+
+export declare class StoreOperationsLibSQL extends StoreOperations {
+    private client;
+    /**
+     * Maximum number of retries for write operations if an SQLITE_BUSY error occurs.
+     * @default 5
+     */
+    maxRetries: number;
+    /**
+     * Initial backoff time in milliseconds for retrying write operations on SQLITE_BUSY.
+     * The backoff time will double with each retry (exponential backoff).
+     * @default 100
+     */
+    initialBackoffMs: number;
+    constructor({ client, maxRetries, initialBackoffMs, }: {
+        client: Client;
+        maxRetries?: number;
+        initialBackoffMs?: number;
+    });
+    hasColumn(table: string, column: string): Promise<boolean>;
+    private getCreateTableSQL;
+    createTable({ tableName, schema, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+    }): Promise<void>;
+    protected getSqlType(type: StorageColumn['type']): string;
+    private doInsert;
+    insert(args: {
+        tableName: TABLE_NAMES;
+        record: Record<string, any>;
+    }): Promise<void>;
+    load<R>({ tableName, keys }: {
+        tableName: TABLE_NAMES;
+        keys: Record<string, string>;
+    }): Promise<R | null>;
+    private doBatchInsert;
+    batchInsert(args: {
+        tableName: TABLE_NAMES;
+        records: Record<string, any>[];
+    }): Promise<void>;
+    /**
+     * Alters table schema to add columns if they don't exist
+     * @param tableName Name of the table
+     * @param schema Schema of the table
+     * @param ifNotExists Array of column names to add if they don't exist
+     */
+    alterTable({ tableName, schema, ifNotExists, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
+    clearTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+}
+
+export declare class TracesLibSQL extends TracesStorage {
+    private client;
+    private operations;
+    constructor({ client, operations }: {
+        client: Client;
+        operations: StoreOperationsLibSQL;
+    });
+    getTraces(args: StorageGetTracesArg): Promise<Trace[]>;
+    getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
+    batchTraceInsert({ records }: {
+        records: Record<string, any>[];
+    }): Promise<void>;
+}
+
+export declare class WorkflowsLibSQL extends WorkflowsStorage {
+    operations: StoreOperationsLibSQL;
+    client: Client;
+    constructor({ operations, client }: {
+        operations: StoreOperationsLibSQL;
+        client: Client;
+    });
+    persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
+        workflowName: string;
+        runId: string;
+        snapshot: WorkflowRunState_2;
+    }): Promise<void>;
+    loadWorkflowSnapshot({ workflowName, runId, }: {
+        workflowName: string;
+        runId: string;
+    }): Promise<WorkflowRunState_2 | null>;
+    getWorkflowRunById({ runId, workflowName, }: {
+        runId: string;
+        workflowName?: string;
+    }): Promise<WorkflowRun_2 | null>;
+    getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
+        workflowName?: string;
+        fromDate?: Date;
+        toDate?: Date;
+        limit?: number;
+        offset?: number;
+        resourceId?: string;
+    }): Promise<WorkflowRuns_2>;
+}
+
 export { }