@mastra/lance 0.2.0 → 0.2.1-alpha.0

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

@@ -2,6 +2,7 @@ import { ArrayOperator } from '@mastra/core/vector/filter';
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 import { BasicOperator } from '@mastra/core/vector/filter';
 import type { BlacklistedRootOperators } from '@mastra/core/vector/filter';
+import type { Connection } from '@lancedb/lancedb';
 import type { ConnectionOptions } from '@lancedb/lancedb';
 import type { CreateIndexParams } from '@mastra/core';
 import type { CreateTableOptions } from '@lancedb/lancedb';
@@ -10,6 +11,7 @@ import type { DeleteVectorParams } from '@mastra/core';
 import type { DescribeIndexParams } from '@mastra/core';
 import type { EvalRow } from '@mastra/core/storage';
 import type { IndexStats } from '@mastra/core';
+import { LegacyEvalsStorage } from '@mastra/core/storage';
 import { LogicalOperator } from '@mastra/core/vector/filter';
 import type { LogicalOperatorValueMap } from '@mastra/core/vector/filter';
 import type { MastraMessageContentV2 } from '@mastra/core/agent';
@@ -17,6 +19,7 @@ import type { MastraMessageV1 } from '@mastra/core/memory';
 import type { MastraMessageV2 } from '@mastra/core/memory';
 import { MastraStorage } from '@mastra/core/storage';
 import { MastraVector } from '@mastra/core/vector';
+import { MemoryStorage } from '@mastra/core/storage';
 import { NumericOperator } from '@mastra/core/vector/filter';
 import type { OperatorValueMap } from '@mastra/core/vector/filter';
 import type { PaginationInfo } from '@mastra/core/storage';
@@ -24,20 +27,37 @@ import type { QueryResult } from '@mastra/core';
 import type { QueryVectorParams } from '@mastra/core';
 import { RegexOperator } from '@mastra/core/vector/filter';
 import type { SchemaLike } from '@lancedb/lancedb';
+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 } from '@lancedb/lancedb';
 import type { TABLE_NAMES } from '@mastra/core/storage';
 import type { TableLike } from '@lancedb/lancedb';
 import type { Trace } from '@mastra/core/telemetry';
+import { TracesStorage } from '@mastra/core/storage';
 import type { TraceType } from '@mastra/core/memory';
 import type { UpdateVectorParams } from '@mastra/core';
 import type { UpsertVectorParams } from '@mastra/core';
 import type { VectorFilter } from '@mastra/core/vector/filter';
 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 getPrimaryKeys(tableName: TABLE_NAMES): string[];
+
+export declare function getTableSchema({ tableName, client, }: {
+    tableName: TABLE_NAMES;
+    client: Connection;
+}): Promise<SchemaLike>;
 
 declare interface HNSWConfig {
     m?: number;
@@ -112,6 +132,7 @@ declare interface LanceQueryVectorParams extends QueryVectorParams<LanceVectorFi
 }
 
 declare class LanceStorage extends MastraStorage {
+    stores: StorageDomains;
     private lanceClient;
     /**
      * Creates a new instance of LanceStorage
@@ -136,7 +157,6 @@ declare class LanceStorage extends MastraStorage {
      * ```
      */
     static create(name: string, uri: string, options?: ConnectionOptions): Promise<LanceStorage>;
-    private getPrimaryKeys;
     /**
      * @internal
      * Private constructor to enforce using the create factory method
@@ -146,76 +166,29 @@ declare class LanceStorage extends MastraStorage {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
     }): Promise<void>;
-    private translateSchema;
-    /**
-     * Drop a table if it exists
-     * @param tableName Name of the table to drop
-     */
-    dropTable(tableName: TABLE_NAMES): Promise<void>;
-    /**
-     * Get table schema
-     * @param tableName Name of the table
-     * @returns Table schema
-     */
-    getTableSchema(tableName: TABLE_NAMES): Promise<SchemaLike>;
-    protected getDefaultValue(type: StorageColumn['type']): string;
-    /**
-     * 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
-     */
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
     alterTable({ tableName, schema, ifNotExists, }: {
-        tableName: string;
+        tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
         ifNotExists: string[];
     }): Promise<void>;
     clearTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;
-    /**
-     * Insert a single record into a table. This function overwrites the existing record if it exists. Use this function for inserting records into tables with custom schemas.
-     * @param tableName The name of the table to insert into.
-     * @param record The record to insert.
-     */
     insert({ tableName, record }: {
-        tableName: string;
+        tableName: TABLE_NAMES;
         record: Record<string, any>;
     }): Promise<void>;
-    /**
-     * Insert multiple records into a table. This function overwrites the existing records if they exist. Use this function for inserting records into tables with custom schemas.
-     * @param tableName The name of the table to insert into.
-     * @param records The records to insert.
-     */
     batchInsert({ tableName, records }: {
-        tableName: string;
+        tableName: TABLE_NAMES;
         records: Record<string, any>[];
     }): Promise<void>;
-    /**
-     * Load a record from the database by its key(s)
-     * @param tableName The name of the table to query
-     * @param keys Record of key-value pairs to use for lookup
-     * @throws Error if invalid types are provided for keys
-     * @returns The loaded record with proper type conversions, or null if not found
-     */
     load({ tableName, keys }: {
         tableName: TABLE_NAMES;
         keys: Record<string, any>;
     }): Promise<any>;
-    /**
-     * Validates that key types match the schema definition
-     * @param keys The keys to validate
-     * @param tableSchema The table schema to validate against
-     * @throws Error if a key has an incompatible type
-     */
-    private validateKeyTypes;
-    /**
-     * Process a database result with appropriate type conversions based on the table schema
-     * @param rawResult The raw result object from the database
-     * @param tableSchema The schema of the table containing type information
-     * @returns Processed result with correct data types
-     */
-    private processResultWithTypeConversion;
     getThreadById({ threadId }: {
         threadId: string;
     }): Promise<StorageThreadType | null>;
@@ -238,6 +211,23 @@ declare class LanceStorage extends MastraStorage {
     deleteThread({ threadId }: {
         threadId: string;
     }): Promise<void>;
+    get supports(): {
+        selectByIncludeResourceScope: boolean;
+        resourceWorkingMemory: boolean;
+        hasColumn: boolean;
+        createTable: boolean;
+    };
+    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>;
     /**
      * Processes messages to include context messages based on withPreviousMessages and withNextMessages
      * @param records - The sorted array of records to process
@@ -259,24 +249,55 @@ declare class LanceStorage extends MastraStorage {
         messages: MastraMessageV2[];
         format: 'v2';
     }): Promise<MastraMessageV2[]>;
-    saveTrace({ trace }: {
-        trace: TraceType;
-    }): Promise<TraceType>;
-    getTraceById({ traceId }: {
+    getThreadsByResourceIdPaginated(args: {
+        resourceId: string;
+        page: number;
+        perPage: number;
+    }): Promise<PaginationInfo & {
+        threads: StorageThreadType[];
+    }>;
+    getMessagesPaginated(args: StorageGetMessagesArg & {
+        format?: 'v1' | 'v2';
+    }): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2[];
+    }>;
+    updateMessages(_args: {
+        messages: Partial<Omit<MastraMessageV2, 'createdAt'>> & {
+            id: string;
+            content?: {
+                metadata?: MastraMessageContentV2['metadata'];
+                content?: MastraMessageContentV2['content'];
+            };
+        }[];
+    }): Promise<MastraMessageV2[]>;
+    getTraceById(args: {
         traceId: string;
     }): Promise<TraceType>;
-    getTraces({ name, scope, page, perPage, attributes, }: {
+    getTraces(args: {
         name?: string;
         scope?: string;
         page: number;
         perPage: number;
         attributes?: Record<string, string>;
-    }): Promise<TraceType[]>;
-    saveEvals({ evals }: {
-        evals: EvalRow[];
-    }): Promise<EvalRow[]>;
+    }): Promise<Trace[]>;
+    getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
-    private parseWorkflowRun;
+    getEvals(options: {
+        agentName?: string;
+        type?: 'test' | 'live';
+        page?: number;
+        perPage?: number;
+        fromDate?: Date;
+        toDate?: Date;
+        dateRange?: {
+            start?: Date;
+            end?: Date;
+        };
+    }): Promise<PaginationInfo & {
+        evals: EvalRow[];
+    }>;
     getWorkflowRuns(args?: {
         namespace?: string;
         workflowName?: string;
@@ -285,11 +306,6 @@ declare class LanceStorage extends MastraStorage {
         limit?: number;
         offset?: number;
     }): Promise<WorkflowRuns>;
-    /**
-     * Retrieve a single workflow run by its runId.
-     * @param args The ID of the workflow run to retrieve
-     * @returns The workflow run object or null if not found
-     */
     getWorkflowRunById(args: {
         runId: string;
         workflowName?: string;
@@ -309,28 +325,34 @@ declare class LanceStorage extends MastraStorage {
         workflowName: string;
         runId: string;
     }): Promise<WorkflowRunState | null>;
-    getTracesPaginated(_args: StorageGetTracesArg): Promise<PaginationInfo & {
-        traces: Trace[];
+    getScoreById({ id: _id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    getScoresByScorerId({ scorerId, pagination, }: {
+        scorerId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
     }>;
-    getThreadsByResourceIdPaginated(_args: {
-        resourceId: string;
-        page?: number;
-        perPage?: number;
-    }): Promise<PaginationInfo & {
-        threads: StorageThreadType[];
+    saveScore(_score: ScoreRowData): Promise<{
+        score: ScoreRowData;
     }>;
-    getMessagesPaginated(_args: StorageGetMessagesArg): Promise<PaginationInfo & {
-        messages: MastraMessageV1[] | MastraMessageV2[];
+    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[];
     }>;
-    updateMessages(_args: {
-        messages: Partial<Omit<MastraMessageV2, 'createdAt'>> & {
-            id: string;
-            content?: {
-                metadata?: MastraMessageContentV2['metadata'];
-                content?: MastraMessageContentV2['content'];
-            };
-        }[];
-    }): Promise<MastraMessageV2[]>;
 }
 export { LanceStorage }
 export { LanceStorage as LanceStorage_alias_1 }
@@ -406,4 +428,253 @@ declare class LanceVectorStore extends MastraVector<LanceVectorFilter> {
 export { LanceVectorStore }
 export { LanceVectorStore as LanceVectorStore_alias_1 }
 
+export declare function processResultWithTypeConversion(rawResult: Record<string, any> | Record<string, any>[], tableSchema: SchemaLike): Record<string, any> | Record<string, any>[];
+
+export declare class StoreLegacyEvalsLance extends LegacyEvalsStorage {
+    private client;
+    constructor({ client }: {
+        client: Connection;
+    });
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    getEvals(options: {
+        agentName?: string;
+        type?: 'test' | 'live';
+        page?: number;
+        perPage?: number;
+        fromDate?: Date;
+        toDate?: Date;
+        dateRange?: {
+            start?: Date;
+            end?: Date;
+        };
+    }): Promise<PaginationInfo & {
+        evals: EvalRow[];
+    }>;
+}
+
+export declare class StoreMemoryLance extends MemoryStorage {
+    private client;
+    private operations;
+    constructor({ client, operations }: {
+        client: Connection;
+        operations: StoreOperationsLance;
+    });
+    getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType | null>;
+    getThreadsByResourceId({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageThreadType[]>;
+    /**
+     * Saves a thread to the database. This function doesn't overwrite existing threads.
+     * @param thread - The thread to save
+     * @returns The saved thread
+     */
+    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>;
+    getMessages(args: StorageGetMessagesArg & {
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    saveMessages(args: {
+        messages: MastraMessageV1[];
+        format?: undefined | 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: MastraMessageV2[];
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    getThreadsByResourceIdPaginated(args: {
+        resourceId: string;
+        page?: number;
+        perPage?: number;
+    }): Promise<PaginationInfo & {
+        threads: StorageThreadType[];
+    }>;
+    /**
+     * Processes messages to include context messages based on withPreviousMessages and withNextMessages
+     * @param records - The sorted array of records to process
+     * @param include - The array of include specifications with context parameters
+     * @returns The processed array with context messages included
+     */
+    private processMessagesWithContext;
+    getMessagesPaginated(args: StorageGetMessagesArg & {
+        format?: 'v1' | 'v2';
+    }): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2[];
+    }>;
+    /**
+     * Parse message data from LanceDB record format to MastraMessageV2 format
+     */
+    private parseMessageData;
+    updateMessages(args: {
+        messages: Partial<Omit<MastraMessageV2, 'createdAt'>> & {
+            id: string;
+            content?: {
+                metadata?: MastraMessageContentV2['metadata'];
+                content?: MastraMessageContentV2['content'];
+            };
+        }[];
+    }): Promise<MastraMessageV2[]>;
+    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>;
+}
+
+export declare class StoreOperationsLance extends StoreOperations {
+    client: Connection;
+    constructor({ client }: {
+        client: Connection;
+    });
+    protected getDefaultValue(type: StorageColumn['type']): string;
+    hasColumn(tableName: TABLE_NAMES, columnName: string): Promise<boolean>;
+    private translateSchema;
+    createTable({ tableName, schema, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+    }): Promise<void>;
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    alterTable({ tableName, schema, ifNotExists, }: {
+        tableName: string;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
+    clearTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    insert({ tableName, record }: {
+        tableName: string;
+        record: Record<string, any>;
+    }): Promise<void>;
+    batchInsert({ tableName, records }: {
+        tableName: string;
+        records: Record<string, any>[];
+    }): Promise<void>;
+    load({ tableName, keys }: {
+        tableName: TABLE_NAMES;
+        keys: Record<string, any>;
+    }): Promise<any>;
+}
+
+export declare class StoreScoresLance extends ScoresStorage {
+    private client;
+    constructor({ client }: {
+        client: Connection;
+    });
+    saveScore(score: ScoreRowData): Promise<{
+        score: ScoreRowData;
+    }>;
+    getScoreById({ id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    getScoresByScorerId({ scorerId, pagination, }: {
+        scorerId: 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[];
+    }>;
+}
+
+export declare class StoreTracesLance extends TracesStorage {
+    private client;
+    private operations;
+    constructor({ client, operations }: {
+        client: Connection;
+        operations: StoreOperationsLance;
+    });
+    saveTrace({ trace }: {
+        trace: TraceType;
+    }): Promise<TraceType>;
+    getTraceById({ traceId }: {
+        traceId: string;
+    }): Promise<TraceType>;
+    getTraces({ name, scope, page, perPage, attributes, }: {
+        name?: string;
+        scope?: string;
+        page: number;
+        perPage: number;
+        attributes?: Record<string, string>;
+    }): Promise<Trace[]>;
+    getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
+    batchTraceInsert({ records }: {
+        records: Record<string, any>[];
+    }): Promise<void>;
+}
+
+export declare class StoreWorkflowsLance extends WorkflowsStorage {
+    client: Connection;
+    constructor({ client }: {
+        client: Connection;
+    });
+    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(args: {
+        runId: string;
+        workflowName?: string;
+    }): Promise<{
+        workflowName: string;
+        runId: string;
+        snapshot: any;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    getWorkflowRuns(args?: {
+        namespace?: string;
+        resourceId?: string;
+        workflowName?: string;
+        fromDate?: Date;
+        toDate?: Date;
+        limit?: number;
+        offset?: number;
+    }): Promise<WorkflowRuns_2>;
+}
+
+export declare function validateKeyTypes(keys: Record<string, any>, tableSchema: SchemaLike): void;
+
 export { }