@mastra/mongodb 0.0.0-vnext-inngest-20250508131921 → 0.0.0-vnextAgentNetwork-20250527102918

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

@@ -1,16 +1,25 @@
 import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 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 { IndexStats } from '@mastra/core/vector';
+import { MastraStorage } from '@mastra/core/storage';
 import { MastraVector } from '@mastra/core/vector';
+import type { MessageType } from '@mastra/core/memory';
 import type { MongoClientOptions } from 'mongodb';
 import type { OperatorSupport } from '@mastra/core/vector/filter';
-import type { ParamsToArgs } from '@mastra/core/vector';
 import type { QueryResult } from '@mastra/core/vector';
-import type { QueryVectorArgs } from '@mastra/core/vector';
 import type { QueryVectorParams } from '@mastra/core/vector';
-import type { UpsertVectorArgs } from '@mastra/core/vector';
+import type { StorageGetMessagesArg } from '@mastra/core/storage';
+import type { StorageThreadType } from '@mastra/core/memory';
+import type { TABLE_NAMES } from '@mastra/core/storage';
+import type { UpdateVectorParams } from '@mastra/core/vector';
 import type { UpsertVectorParams } from '@mastra/core/vector';
 import type { VectorFilter } from '@mastra/core/vector/filter';
+import type { WorkflowRun } from '@mastra/core/storage';
+import type { WorkflowRunState } from '@mastra/core/workflows';
 
 /**
  * Vector store specific prompt that details supported operators and examples.
@@ -20,6 +29,14 @@ declare const MONGODB_PROMPT = "When querying MongoDB Vector, you can ONLY use t
 export { MONGODB_PROMPT }
 export { MONGODB_PROMPT as MONGODB_PROMPT_alias_1 }
 
+declare interface MongoDBConfig {
+    url: string;
+    dbName: string;
+    options?: MongoClientOptions;
+}
+export { MongoDBConfig }
+export { MongoDBConfig as MongoDBConfig_alias_1 }
+
 /**
  * Translator for MongoDB filter queries.
  * Maintains MongoDB-compatible syntax while ensuring proper validation
@@ -33,9 +50,13 @@ export declare class MongoDBFilterTranslator extends BaseFilterTranslator {
     isEmpty(filter: any): boolean;
 }
 
-declare type MongoDBQueryArgs = [...QueryVectorArgs, string?];
-export { MongoDBQueryArgs }
-export { MongoDBQueryArgs as MongoDBQueryArgs_alias_1 }
+declare interface MongoDBIndexReadyParams {
+    indexName: string;
+    timeoutMs?: number;
+    checkIntervalMs?: number;
+}
+export { MongoDBIndexReadyParams }
+export { MongoDBIndexReadyParams as MongoDBIndexReadyParams_alias_1 }
 
 declare interface MongoDBQueryVectorParams extends QueryVectorParams {
     documentFilter?: VectorFilter;
@@ -43,13 +64,93 @@ declare interface MongoDBQueryVectorParams extends QueryVectorParams {
 export { MongoDBQueryVectorParams }
 export { MongoDBQueryVectorParams as MongoDBQueryVectorParams_alias_1 }
 
-declare type MongoDBUpsertArgs = [...UpsertVectorArgs, string[]?];
-export { MongoDBUpsertArgs }
-export { MongoDBUpsertArgs as MongoDBUpsertArgs_alias_1 }
-
-declare type MongoDBUpsertParams = ParamsToArgs<MongoDBUpsertArgs>;
-export { MongoDBUpsertParams }
-export { MongoDBUpsertParams as MongoDBUpsertParams_alias_1 }
+declare class MongoDBStore extends MastraStorage {
+    #private;
+    constructor(config: MongoDBConfig);
+    private getConnection;
+    private getCollection;
+    createTable(): Promise<void>;
+    clearTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    insert({ tableName, record }: {
+        tableName: TABLE_NAMES;
+        record: Record<string, any>;
+    }): Promise<void>;
+    batchInsert({ tableName, records }: {
+        tableName: TABLE_NAMES;
+        records: Record<string, any>[];
+    }): Promise<void>;
+    load<R>({ tableName, keys }: {
+        tableName: TABLE_NAMES;
+        keys: Record<string, string>;
+    }): Promise<R | null>;
+    getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType | null>;
+    getThreadsByResourceId({ resourceId }: {
+        resourceId: string;
+    }): Promise<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>;
+    getMessages<T = unknown>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T[]>;
+    saveMessages({ messages }: {
+        messages: MessageType[];
+    }): Promise<MessageType[]>;
+    getTraces({ name, scope, page, perPage, attributes, filters, }?: {
+        name?: string;
+        scope?: string;
+        page: number;
+        perPage: number;
+        attributes?: Record<string, string>;
+        filters?: Record<string, any>;
+    }): Promise<any[]>;
+    getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, }?: {
+        workflowName?: string;
+        fromDate?: Date;
+        toDate?: Date;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        runs: Array<{
+            workflowName: string;
+            runId: string;
+            snapshot: WorkflowRunState | string;
+            createdAt: Date;
+            updatedAt: Date;
+        }>;
+        total: number;
+    }>;
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
+        workflowName: string;
+        runId: string;
+        snapshot: WorkflowRunState;
+    }): Promise<void>;
+    loadWorkflowSnapshot({ workflowName, runId, }: {
+        workflowName: string;
+        runId: string;
+    }): Promise<WorkflowRunState | null>;
+    getWorkflowRunById({ runId, workflowName, }: {
+        runId: string;
+        workflowName?: string;
+    }): Promise<WorkflowRun | null>;
+    private parseWorkflowRun;
+    private parseRow;
+    private transformEvalRow;
+    close(): Promise<void>;
+}
+export { MongoDBStore }
+export { MongoDBStore as MongoDBStore_alias_1 }
 
 declare interface MongoDBUpsertVectorParams extends UpsertVectorParams {
     documents?: string[];
@@ -73,18 +174,46 @@ declare class MongoDBVector extends MastraVector {
     });
     connect(): Promise<void>;
     disconnect(): Promise<void>;
-    createIndex(params: CreateIndexParams): Promise<void>;
-    waitForIndexReady(indexName: string, timeoutMs?: number, checkIntervalMs?: number): Promise<void>;
-    upsert(params: MongoDBUpsertVectorParams): Promise<string[]>;
-    query(params: MongoDBQueryVectorParams): Promise<QueryResult[]>;
+    createIndex({ indexName, dimension, metric }: CreateIndexParams): Promise<void>;
+    /**
+     * Waits for the index to be ready.
+     *
+     * @param {string} indexName - The name of the index to wait for
+     * @param {number} timeoutMs - The maximum time in milliseconds to wait for the index to be ready (default: 60000)
+     * @param {number} checkIntervalMs - The interval in milliseconds at which to check if the index is ready (default: 2000)
+     * @returns A promise that resolves when the index is ready
+     */
+    waitForIndexReady({ indexName, timeoutMs, checkIntervalMs, }: MongoDBIndexReadyParams): Promise<void>;
+    upsert({ indexName, vectors, metadata, ids, documents }: MongoDBUpsertVectorParams): Promise<string[]>;
+    query({ indexName, queryVector, topK, filter, includeVector, documentFilter, }: MongoDBQueryVectorParams): Promise<QueryResult[]>;
     listIndexes(): Promise<string[]>;
-    describeIndex(indexName: string): Promise<IndexStats>;
-    deleteIndex(indexName: string): Promise<void>;
-    updateIndexById(indexName: string, id: string, update: {
-        vector?: number[];
-        metadata?: Record<string, any>;
-    }): Promise<void>;
-    deleteIndexById(indexName: string, id: string): Promise<void>;
+    /**
+     * Retrieves statistics about a vector index.
+     *
+     * @param {string} indexName - The name of the index to describe
+     * @returns A promise that resolves to the index statistics including dimension, count and metric
+     */
+    describeIndex({ indexName }: DescribeIndexParams): Promise<IndexStats>;
+    deleteIndex({ indexName }: DeleteIndexParams): Promise<void>;
+    /**
+     * Updates a vector by its ID with the provided vector and/or metadata.
+     * @param indexName - The name of the index containing the vector.
+     * @param id - The ID of the vector to update.
+     * @param update - An object containing the vector and/or metadata to update.
+     * @param update.vector - An optional array of numbers representing the new vector.
+     * @param update.metadata - An optional record containing the new metadata.
+     * @returns A promise that resolves when the update is complete.
+     * @throws Will throw an error if no updates are provided or if the update operation fails.
+     */
+    updateVector({ indexName, id, update }: UpdateVectorParams): Promise<void>;
+    /**
+     * Deletes a vector by its ID.
+     * @param indexName - The name of the index containing the vector.
+     * @param id - The ID of the vector to delete.
+     * @returns A promise that resolves when the deletion is complete.
+     * @throws Will throw an error if the deletion operation fails.
+     */
+    deleteVector({ indexName, id }: DeleteVectorParams): Promise<void>;
     private getCollection;
     private validateVectorDimensions;
     private setIndexDimension;