@mastra/cloudflare 0.11.1 → 0.11.2

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

@@ -1,28 +1,47 @@
+import type { default as Cloudflare_2 } from 'cloudflare';
 import type { EvalRow } from '@mastra/core/storage';
 import type { KVNamespace as KVNamespace_2 } from '@cloudflare/workers-types';
 import { KVNamespaceListKey as KVNamespaceListKey_2 } from '@cloudflare/workers-types';
+import { LegacyEvalsStorage } from '@mastra/core/storage';
 import type { MastraMessageContentV2 } from '@mastra/core/agent';
 import type { MastraMessageV1 } from '@mastra/core/memory';
+import type { MastraMessageV1 as MastraMessageV1_2 } from '@mastra/core';
 import type { MastraMessageV2 } from '@mastra/core/memory';
+import type { MastraMessageV2 as MastraMessageV2_2 } from '@mastra/core';
 import { MastraStorage } from '@mastra/core/storage';
+import { MemoryStorage } from '@mastra/core/storage';
+import type { PaginationArgs } from '@mastra/core/storage';
 import type { PaginationInfo } from '@mastra/core/storage';
+import type { PaginationInfo as PaginationInfo_2 } from '@mastra/core';
+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 { StorageGetMessagesArg as StorageGetMessagesArg_2 } from '@mastra/core';
 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 { StorageResourceType as StorageResourceType_2 } from '@mastra/core';
 import type { StorageThreadType } from '@mastra/core/memory';
+import type { StorageThreadType as StorageThreadType_2 } from '@mastra/core';
+import { StoreOperations } from '@mastra/core/storage';
 import type { TABLE_EVALS } from '@mastra/core/storage';
 import type { TABLE_MESSAGES } from '@mastra/core/storage';
 import type { TABLE_NAMES } from '@mastra/core/storage';
 import type { TABLE_RESOURCES } from '@mastra/core/storage';
+import type { TABLE_SCORERS } from '@mastra/core/storage';
 import type { TABLE_THREADS } from '@mastra/core/storage';
 import type { TABLE_TRACES } from '@mastra/core/storage';
 import type { TABLE_WORKFLOW_SNAPSHOT } from '@mastra/core/storage';
 import type { Trace } from '@mastra/core/telemetry';
+import { TracesStorage } from '@mastra/core/storage';
 import type { WorkflowRun } from '@mastra/core/storage';
 import type { WorkflowRuns } from '@mastra/core/storage';
 import type { WorkflowRunState } from '@mastra/core/workflows';
 import type { WorkflowRunState as WorkflowRunState_2 } from '@mastra/core';
+import { WorkflowsStorage } from '@mastra/core/storage';
 
 /**
  * Configuration for Cloudflare KV using REST API
@@ -41,6 +60,7 @@ export declare interface CloudflareRestConfig {
 }
 
 declare class CloudflareStore extends MastraStorage {
+    stores: StorageDomains;
     private client?;
     private accountId?;
     private namespacePrefix;
@@ -48,80 +68,10 @@ declare class CloudflareStore extends MastraStorage {
     private validateWorkersConfig;
     private validateRestConfig;
     constructor(config: CloudflareStoreConfig);
-    private getBinding;
-    private listNamespaces;
-    private getNamespaceValue;
-    private putNamespaceValue;
-    private deleteNamespaceValue;
-    listNamespaceKeys(tableName: TABLE_NAMES, options?: ListOptions): Promise<KVNamespaceListKey_2<unknown, string>[]>;
-    private createNamespaceById;
-    private getNamespaceIdByName;
-    private createNamespace;
-    private getOrCreateNamespaceId;
-    private getNamespaceId;
-    private LEGACY_NAMESPACE_MAP;
-    /**
-     * There were a few legacy mappings for tables such as
-     * - messages -> threads
-     * - workflow_snapshot -> mastra_workflows
-     * - traces -> evals
-     * This has been updated to use dedicated namespaces for each table.
-     * In the case of data for a table existing in the legacy namespace, warn the user to migrate to the new namespace.
-     *
-     * @param tableName The table name to check for legacy data
-     * @param prefix The namespace prefix
-     * @returns The legacy namespace ID if data exists; otherwise, null
-     */
-    private checkLegacyNamespace;
-    /**
-     * Helper to safely serialize data for KV storage
-     */
-    private safeSerialize;
-    /**
-     * Helper to safely parse data from KV storage
-     */
-    private safeParse;
-    private putKV;
-    private getKV;
-    private deleteKV;
-    private listKV;
-    private getSortedMessages;
-    private updateSorting;
-    private getIncludedMessagesWithContext;
-    private getRecentMessages;
-    private fetchAndParseMessages;
-    /**
-     * Queue for serializing sorted order updates.
-     * Updates the sorted order for a given key. This operation is eventually consistent.
-     */
-    private updateQueue;
-    /**
-     * Updates the sorted order for a given key. This operation is eventually consistent.
-     * Note: Operations on the same orderKey are serialized using a queue to prevent
-     * concurrent updates from conflicting with each other.
-     */
-    private updateSortedMessages;
-    private getRank;
-    private getRange;
-    private getLastN;
-    private getFullOrder;
-    private getKey;
-    private getSchemaKey;
-    private getTableSchema;
-    private validateColumnValue;
-    private validateAgainstSchema;
-    private validateRecord;
-    private ensureMetadata;
     createTable({ tableName, schema, }: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
     }): Promise<void>;
-    /**
-     * No-op: This backend is schemaless and does not require schema changes.
-     * @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(_args: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
@@ -130,6 +80,9 @@ declare class CloudflareStore extends MastraStorage {
     clearTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
     insert<T extends TABLE_NAMES>({ tableName, record, }: {
         tableName: T;
         record: Record<string, any>;
@@ -155,8 +108,6 @@ declare class CloudflareStore extends MastraStorage {
     deleteThread({ threadId }: {
         threadId: string;
     }): Promise<void>;
-    private getMessageKey;
-    private getThreadMessagesKey;
     saveMessages(args: {
         messages: MastraMessageV1[];
         format?: undefined | 'v1';
@@ -171,18 +122,12 @@ declare class CloudflareStore extends MastraStorage {
     getMessages(args: StorageGetMessagesArg & {
         format: 'v2';
     }): Promise<MastraMessageV2[]>;
-    private validateWorkflowParams;
-    private validateWorkflowState;
-    private normalizeSteps;
-    private normalizeWorkflowState;
     persistWorkflowSnapshot(params: {
-        namespace: string;
         workflowName: string;
         runId: string;
         snapshot: WorkflowRunState;
     }): Promise<void>;
     loadWorkflowSnapshot(params: {
-        namespace: string;
         workflowName: string;
         runId: string;
     }): Promise<WorkflowRunState | null>;
@@ -199,12 +144,18 @@ declare class CloudflareStore extends MastraStorage {
         fromDate?: Date;
         toDate?: Date;
     }): Promise<any[]>;
-    private parseJSON;
-    getEvalsByAgentName(_agentName: string, _type?: 'test' | 'live'): Promise<EvalRow[]>;
-    private parseWorkflowRun;
-    private buildWorkflowSnapshotPrefix;
-    getWorkflowRuns({ namespace, workflowName, limit, offset, resourceId, fromDate, toDate, }?: {
-        namespace?: string;
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    getEvals(options: {
+        agentName?: string;
+        type?: 'test' | 'live';
+        dateRange?: {
+            start?: Date;
+            end?: Date;
+        };
+    } & PaginationArgs): Promise<PaginationInfo & {
+        evals: EvalRow[];
+    }>;
+    getWorkflowRuns({ workflowName, limit, offset, resourceId, fromDate, toDate, }?: {
         workflowName?: string;
         limit?: number;
         offset?: number;
@@ -212,26 +163,24 @@ declare class CloudflareStore extends MastraStorage {
         fromDate?: Date;
         toDate?: Date;
     }): Promise<WorkflowRuns>;
-    getWorkflowRunById({ namespace, runId, workflowName, }: {
-        namespace: string;
+    getWorkflowRunById({ runId, workflowName, }: {
         runId: string;
         workflowName: string;
     }): Promise<WorkflowRun | null>;
-    getTracesPaginated(_args: StorageGetTracesArg): Promise<PaginationInfo & {
+    getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & {
         traces: Trace[];
     }>;
-    getThreadsByResourceIdPaginated(_args: {
+    getThreadsByResourceIdPaginated(args: {
         resourceId: string;
-        page?: number;
-        perPage?: number;
+        page: number;
+        perPage: number;
     }): Promise<PaginationInfo & {
         threads: StorageThreadType[];
     }>;
-    getMessagesPaginated(_args: StorageGetMessagesArg): Promise<PaginationInfo & {
+    getMessagesPaginated(args: StorageGetMessagesArg): Promise<PaginationInfo & {
         messages: MastraMessageV1[] | MastraMessageV2[];
     }>;
-    close(): Promise<void>;
-    updateMessages(_args: {
+    updateMessages(args: {
         messages: Partial<Omit<MastraMessageV2, 'createdAt'>> & {
             id: string;
             content?: {
@@ -240,6 +189,46 @@ declare class CloudflareStore extends MastraStorage {
             };
         }[];
     }): Promise<MastraMessageV2[]>;
+    getScoreById({ id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    saveScore(score: ScoreRowData): Promise<{
+        score: 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[];
+    }>;
+    getScoresByScorerId({ scorerId, pagination, }: {
+        scorerId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    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>;
+    close(): Promise<void>;
 }
 export { CloudflareStore }
 export { CloudflareStore as CloudflareStore_alias_1 }
@@ -303,16 +292,129 @@ export declare interface KVOperation {
     metadata?: any;
 }
 
+export declare class LegacyEvalsStorageCloudflare extends LegacyEvalsStorage {
+    operations: StoreOperationsCloudflare;
+    constructor({ operations }: {
+        operations: StoreOperationsCloudflare;
+    });
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    getEvals(options: {
+        agentName?: string;
+        type?: 'test' | 'live';
+        dateRange?: {
+            start?: Date;
+            end?: Date;
+        };
+    } & PaginationArgs): Promise<PaginationInfo & {
+        evals: EvalRow[];
+    }>;
+}
+
 export declare type ListOptions = {
     limit?: number;
     prefix?: string;
 };
 
+export declare class MemoryStorageCloudflare extends MemoryStorage {
+    operations: StoreOperationsCloudflare;
+    constructor({ operations }: {
+        operations: StoreOperationsCloudflare;
+    });
+    private ensureMetadata;
+    getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType_2 | null>;
+    getThreadsByResourceId({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageThreadType_2[]>;
+    getThreadsByResourceIdPaginated(args: {
+        resourceId: string;
+        page?: number;
+        perPage?: number;
+    }): Promise<PaginationInfo_2 & {
+        threads: StorageThreadType_2[];
+    }>;
+    saveThread({ thread }: {
+        thread: StorageThreadType_2;
+    }): Promise<StorageThreadType_2>;
+    updateThread({ id, title, metadata, }: {
+        id: string;
+        title: string;
+        metadata: Record<string, unknown>;
+    }): Promise<StorageThreadType_2>;
+    private getMessageKey;
+    private getThreadMessagesKey;
+    deleteThread({ threadId }: {
+        threadId: string;
+    }): Promise<void>;
+    private findMessageInAnyThread;
+    /**
+     * Queue for serializing sorted order updates.
+     * Updates the sorted order for a given key. This operation is eventually consistent.
+     */
+    private updateQueue;
+    private updateSorting;
+    /**
+     * Updates the sorted order for a given key. This operation is eventually consistent.
+     * Note: Operations on the same orderKey are serialized using a queue to prevent
+     * concurrent updates from conflicting with each other.
+     */
+    private updateSortedMessages;
+    private getSortedMessages;
+    private migrateMessage;
+    saveMessages(args: {
+        messages: MastraMessageV1_2[];
+        format?: undefined | 'v1';
+    }): Promise<MastraMessageV1_2[]>;
+    saveMessages(args: {
+        messages: MastraMessageV2_2[];
+        format: 'v2';
+    }): Promise<MastraMessageV2_2[]>;
+    private getRank;
+    private getRange;
+    private getLastN;
+    private getFullOrder;
+    private getIncludedMessagesWithContext;
+    private getRecentMessages;
+    private fetchAndParseMessagesFromMultipleThreads;
+    getMessages(args: StorageGetMessagesArg_2 & {
+        format?: 'v1';
+    }): Promise<MastraMessageV1_2[]>;
+    getMessages(args: StorageGetMessagesArg_2 & {
+        format: 'v2';
+    }): Promise<MastraMessageV2_2[]>;
+    getMessagesPaginated(args: StorageGetMessagesArg_2): Promise<PaginationInfo_2 & {
+        messages: MastraMessageV1_2[] | MastraMessageV2_2[];
+    }>;
+    updateMessages(args: {
+        messages: (Partial<Omit<MastraMessageV2_2, 'createdAt'>> & {
+            id: string;
+            threadId?: string;
+            content?: {
+                metadata?: MastraMessageContentV2['metadata'];
+                content?: MastraMessageContentV2['content'];
+            };
+        })[];
+    }): Promise<MastraMessageV2_2[]>;
+    getResourceById({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageResourceType_2 | null>;
+    saveResource({ resource }: {
+        resource: StorageResourceType_2;
+    }): Promise<StorageResourceType_2>;
+    updateResource({ resourceId, workingMemory, metadata, }: {
+        resourceId: string;
+        workingMemory?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<StorageResourceType_2>;
+}
+
 export declare type RecordTypes = {
     [TABLE_THREADS]: StorageThreadType;
     [TABLE_MESSAGES]: MastraMessageV2;
     [TABLE_WORKFLOW_SNAPSHOT]: WorkflowRunState;
     [TABLE_EVALS]: EvalRow;
+    [TABLE_SCORERS]: ScoreRowData;
     [TABLE_TRACES]: any;
     [TABLE_RESOURCES]: StorageResourceType;
 };
@@ -320,4 +422,162 @@ export declare type RecordTypes = {
 export declare const retryUntil: <T>(fn: () => Promise<T>, condition: (result: T) => boolean, timeout?: number, // REST API needs longer timeout due to higher latency
 interval?: number) => Promise<T>;
 
+export declare class ScoresStorageCloudflare extends ScoresStorage {
+    private operations;
+    constructor({ operations }: {
+        operations: StoreOperationsCloudflare;
+    });
+    getScoreById({ id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    saveScore(score: Omit<ScoreRowData, 'createdAt' | 'updatedAt'>): Promise<{
+        score: ScoreRowData;
+    }>;
+    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 StoreOperationsCloudflare extends StoreOperations {
+    private bindings?;
+    client?: Cloudflare_2;
+    accountId?: string;
+    namespacePrefix: string;
+    constructor({ namespacePrefix, bindings, client, accountId, }: {
+        bindings?: Record<TABLE_NAMES, KVNamespace_2>;
+        namespacePrefix: string;
+        client?: Cloudflare_2;
+        accountId?: string;
+    });
+    hasColumn(): Promise<boolean>;
+    alterTable(_args: {
+        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>;
+    private getBinding;
+    getKey<T extends TABLE_NAMES>(tableName: T, record: Record<string, string>): string;
+    private getSchemaKey;
+    /**
+     * Helper to safely parse data from KV storage
+     */
+    private safeParse;
+    private createNamespaceById;
+    private createNamespace;
+    private listNamespaces;
+    private getNamespaceIdByName;
+    private getOrCreateNamespaceId;
+    private getNamespaceId;
+    private getNamespaceValue;
+    getKV(tableName: TABLE_NAMES, key: string): Promise<any>;
+    private getTableSchema;
+    private validateColumnValue;
+    private validateAgainstSchema;
+    private validateRecord;
+    insert({ tableName, record }: {
+        tableName: TABLE_NAMES;
+        record: Record<string, any>;
+    }): Promise<void>;
+    private ensureMetadata;
+    load<R>({ tableName, keys }: {
+        tableName: TABLE_NAMES;
+        keys: Record<string, string>;
+    }): Promise<R | null>;
+    batchInsert<T extends TABLE_NAMES>(input: {
+        tableName: T;
+        records: Partial<RecordTypes[T]>[];
+    }): Promise<void>;
+    /**
+     * Helper to safely serialize data for KV storage
+     */
+    private safeSerialize;
+    private putNamespaceValue;
+    putKV({ tableName, key, value, metadata, }: {
+        tableName: TABLE_NAMES;
+        key: string;
+        value: any;
+        metadata?: any;
+    }): Promise<void>;
+    createTable({ tableName, schema, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+    }): Promise<void>;
+    listNamespaceKeys(tableName: TABLE_NAMES, options?: ListOptions): Promise<KVNamespaceListKey_2<unknown, string>[]>;
+    private deleteNamespaceValue;
+    deleteKV(tableName: TABLE_NAMES, key: string): Promise<void>;
+    listKV(tableName: TABLE_NAMES, options?: ListOptions): Promise<Array<{
+        name: string;
+    }>>;
+}
+
+export declare class TracesStorageCloudflare extends TracesStorage {
+    private operations;
+    constructor({ operations }: {
+        operations: StoreOperationsCloudflare;
+    });
+    getTraces(args: StorageGetTracesArg): Promise<Trace[]>;
+    getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
+    batchTraceInsert({ records }: {
+        records: Record<string, any>[];
+    }): Promise<void>;
+}
+
+export declare class WorkflowsStorageCloudflare extends WorkflowsStorage {
+    private operations;
+    constructor({ operations }: {
+        operations: StoreOperationsCloudflare;
+    });
+    private validateWorkflowParams;
+    persistWorkflowSnapshot(params: {
+        workflowName: string;
+        runId: string;
+        snapshot: WorkflowRunState;
+    }): Promise<void>;
+    loadWorkflowSnapshot(params: {
+        workflowName: string;
+        runId: string;
+    }): Promise<WorkflowRunState | null>;
+    private parseWorkflowRun;
+    private buildWorkflowSnapshotPrefix;
+    getWorkflowRuns({ workflowName, limit, offset, resourceId, fromDate, toDate, }?: {
+        workflowName?: string;
+        limit?: number;
+        offset?: number;
+        resourceId?: string;
+        fromDate?: Date;
+        toDate?: Date;
+    }): Promise<WorkflowRuns>;
+    getWorkflowRunById({ runId, workflowName, }: {
+        runId: string;
+        workflowName: string;
+    }): Promise<WorkflowRun | null>;
+}
+
 export { }