@mastra/cloudflare-d1 0.0.0-tool-call-parts-20250630193309 → 0.0.0-transpile-packages-20250730132657

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

@@ -1,18 +1,32 @@
+import { default as Cloudflare_2 } from 'cloudflare';
 import type { D1Database as D1Database_2 } from '@cloudflare/workers-types';
 import type { EvalRow } from '@mastra/core/storage';
+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/memory';
 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 { 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 { WorkflowRun } from '@mastra/core/storage';
 import type { WorkflowRuns } from '@mastra/core/storage';
 import type { WorkflowRunState } from '@mastra/core/workflows';
+import { WorkflowsStorage } from '@mastra/core/storage';
 
 export declare const createSampleTrace: (name: string, scope?: string, attributes?: Record<string, string>) => {
     id: string;
@@ -33,6 +47,44 @@ export declare const createSampleTrace: (name: string, scope?: string, attribute
 
 export declare function createSqlBuilder(): SqlBuilder;
 
+declare interface D1Client {
+    query(args: {
+        sql: string;
+        params: string[];
+    }): Promise<{
+        result: D1QueryResult;
+    }>;
+}
+export { D1Client }
+export { D1Client as D1Client_alias_1 }
+
+export declare interface D1Client_alias_2 {
+    query(args: {
+        sql: string;
+        params: string[];
+    }): Promise<{
+        result: D1QueryResult_alias_2;
+    }>;
+}
+
+export declare interface D1Client_alias_3 {
+    query(args: {
+        sql: string;
+        params: string[];
+    }): Promise<{
+        result: D1QueryResult_alias_3;
+    }>;
+}
+
+declare interface D1ClientConfig {
+    /** Optional prefix for table names */
+    tablePrefix?: string;
+    /** D1 Client */
+    client: D1Client;
+}
+export { D1ClientConfig }
+export { D1ClientConfig as D1ClientConfig_alias_1 }
+
 /**
  * Configuration for D1 using the REST API
  */
@@ -49,31 +101,30 @@ declare interface D1Config {
 export { D1Config }
 export { D1Config as D1Config_alias_1 }
 
+declare type D1QueryResult = Awaited<ReturnType<Cloudflare_2['d1']['database']['query']>>['result'];
+export { D1QueryResult }
+export { D1QueryResult as D1QueryResult_alias_1 }
+
+export declare type D1QueryResult_alias_2 = Awaited<ReturnType<Cloudflare_2['d1']['database']['query']>>['result'];
+
+export declare type D1QueryResult_alias_3 = Awaited<ReturnType<Cloudflare_2['d1']['database']['query']>>['result'];
+
 declare class D1Store extends MastraStorage {
     private client?;
-    private accountId?;
-    private databaseId?;
     private binding?;
     private tablePrefix;
+    stores: StorageDomains;
     /**
      * Creates a new D1Store instance
      * @param config Configuration for D1 access (either REST API or Workers Binding API)
      */
     constructor(config: D1StoreConfig);
-    private getTableName;
-    private formatSqlParams;
-    private executeWorkersBindingQuery;
-    private executeRestQuery;
-    /**
-     * Execute a SQL query against the D1 database
-     * @param options Query options including SQL, parameters, and whether to return only the first result
-     * @returns Query results as an array or a single object if first=true
-     */
-    private executeQuery;
-    private getTableColumns;
-    private serializeValue;
-    private deserializeValue;
-    protected getSqlType(type: StorageColumn['type']): string;
+    get supports(): {
+        selectByIncludeResourceScope: boolean;
+        resourceWorkingMemory: boolean;
+        hasColumn: boolean;
+        createTable: boolean;
+    };
     createTable({ tableName, schema, }: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
@@ -92,7 +143,10 @@ declare class D1Store extends MastraStorage {
     clearTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;
-    private processRecord;
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    hasColumn(table: string, column: string): Promise<boolean>;
     insert({ tableName, record }: {
         tableName: TABLE_NAMES;
         record: Record<string, any>;
@@ -136,7 +190,6 @@ declare class D1Store extends MastraStorage {
         messages: MastraMessageV2[];
         format: 'v2';
     }): Promise<MastraMessageV2[]>;
-    private _getIncludedMessages;
     /**
      * @deprecated use getMessagesPaginated instead
      */
@@ -160,6 +213,18 @@ declare class D1Store extends MastraStorage {
         workflowName: string;
         runId: string;
     }): Promise<WorkflowRunState | null>;
+    getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
+        workflowName?: string;
+        fromDate?: Date;
+        toDate?: Date;
+        limit?: number;
+        offset?: number;
+        resourceId?: string;
+    }): Promise<WorkflowRuns>;
+    getWorkflowRunById({ runId, workflowName, }: {
+        runId: string;
+        workflowName?: string;
+    }): Promise<WorkflowRun | null>;
     /**
      * Insert multiple records in a batch operation
      * @param tableName The table to insert into
@@ -169,16 +234,10 @@ declare class D1Store extends MastraStorage {
         tableName: TABLE_NAMES;
         records: Record<string, any>[];
     }): Promise<void>;
-    /**
-     * Upsert multiple records in a batch operation
-     * @param tableName The table to insert into
-     * @param records The records to insert
-     */
-    private batchUpsert;
     /**
      * @deprecated use getTracesPaginated instead
      */
-    getTraces({ name, scope, page, perPage, attributes, fromDate, toDate, }: {
+    getTraces(args: {
         name?: string;
         scope?: string;
         page: number;
@@ -187,50 +246,19 @@ declare class D1Store extends MastraStorage {
         fromDate?: Date;
         toDate?: Date;
     }): Promise<Trace[]>;
-    getTracesPaginated(args: {
-        name?: string;
-        scope?: string;
-        attributes?: Record<string, string>;
-        page: number;
-        perPage: number;
-        fromDate?: Date;
-        toDate?: Date;
-    }): Promise<PaginationInfo & {
+    getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & {
         traces: Trace[];
     }>;
     /**
      * @deprecated use getEvals instead
      */
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
-    getEvals(options?: {
+    getEvals(options: {
         agentName?: string;
         type?: 'test' | 'live';
-        page?: number;
-        perPage?: number;
-        fromDate?: Date;
-        toDate?: Date;
-    }): Promise<PaginationInfo & {
+    } & PaginationArgs): Promise<PaginationInfo & {
         evals: EvalRow[];
     }>;
-    private parseWorkflowRun;
-    private hasColumn;
-    getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
-        workflowName?: string;
-        fromDate?: Date;
-        toDate?: Date;
-        limit?: number;
-        offset?: number;
-        resourceId?: string;
-    }): Promise<WorkflowRuns>;
-    getWorkflowRunById({ runId, workflowName, }: {
-        runId: string;
-        workflowName?: string;
-    }): Promise<WorkflowRun | null>;
-    /**
-     * Close the database connection
-     * No explicit cleanup needed for D1 in either REST or Workers Binding mode
-     */
-    close(): Promise<void>;
     updateMessages(_args: {
         messages: Partial<Omit<MastraMessageV2, 'createdAt'>> & {
             id: string;
@@ -240,6 +268,50 @@ declare class D1Store extends MastraStorage {
             };
         }[];
     }): 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>;
+    getScoreById({ id: _id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    saveScore(_score: ScoreRowData): Promise<{
+        score: ScoreRowData;
+    }>;
+    getScoresByRunId({ runId: _runId, pagination: _pagination, }: {
+        runId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByEntityId({ entityId: _entityId, entityType: _entityType, pagination: _pagination, }: {
+        pagination: StoragePagination;
+        entityId: string;
+        entityType: string;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByScorerId({ scorerId: _scorerId, pagination: _pagination, }: {
+        scorerId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    /**
+     * Close the database connection
+     * No explicit cleanup needed for D1 in either REST or Workers Binding mode
+     */
+    close(): Promise<void>;
 }
 export { D1Store }
 export { D1Store as D1Store_alias_1 }
@@ -247,7 +319,7 @@ export { D1Store as D1Store_alias_1 }
 /**
  * Combined configuration type supporting both REST API and Workers Binding API
  */
-declare type D1StoreConfig = D1Config | D1WorkersConfig;
+declare type D1StoreConfig = D1Config | D1WorkersConfig | D1ClientConfig;
 export { D1StoreConfig }
 export { D1StoreConfig as D1StoreConfig_alias_1 }
 
@@ -263,6 +335,104 @@ declare interface D1WorkersConfig {
 export { D1WorkersConfig }
 export { D1WorkersConfig as D1WorkersConfig_alias_1 }
 
+export declare function deserializeValue(value: any, type?: string): any;
+
+export declare function isArrayOfRecords(value: any): value is Record<string, any>[];
+
+export declare class LegacyEvalsStorageD1 extends LegacyEvalsStorage {
+    private operations;
+    constructor({ operations }: {
+        operations: StoreOperationsD1;
+    });
+    getEvals(options: {
+        agentName?: string;
+        type?: 'test' | 'live';
+    } & PaginationArgs): Promise<PaginationInfo & {
+        evals: EvalRow[];
+    }>;
+    /**
+     * @deprecated use getEvals instead
+     */
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+}
+
+export declare class MemoryStorageD1 extends MemoryStorage {
+    private operations;
+    constructor({ operations }: {
+        operations: StoreOperationsD1;
+    });
+    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
+     */
+    getThreadsByResourceId({ resourceId }: {
+        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>;
+    saveMessages(args: {
+        messages: MastraMessageV1[];
+        format?: undefined | 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: MastraMessageV2[];
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    private _getIncludedMessages;
+    /**
+     * @deprecated use getMessagesPaginated instead
+     */
+    getMessages(args: StorageGetMessagesArg & {
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    getMessagesPaginated({ threadId, selectBy, format, }: 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[]>;
+}
+
 /**
  * Parses and returns a valid SQL SELECT column identifier.
  * Allows a single identifier (letters, numbers, underscores), or '*', optionally with 'AS alias'.
@@ -282,6 +452,41 @@ export declare function parseSelectIdentifier(column: string): SelectIdentifier;
 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 ScoresStorageD1 extends ScoresStorage {
+    private operations;
+    constructor({ operations }: {
+        operations: StoreOperationsD1;
+    });
+    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[];
+    }>;
+}
+
 /** Represents a validated SQL SELECT column identifier (or '*', optionally with 'AS alias'). */
 declare type SelectIdentifier = string & {
     __brand: 'SelectIdentifier';
@@ -396,4 +601,106 @@ export declare interface SqlQueryOptions {
     first?: boolean;
 }
 
+export declare class StoreOperationsD1 extends StoreOperations {
+    private client?;
+    private binding?;
+    private tablePrefix;
+    constructor(config: StoreOperationsD1Config);
+    hasColumn(table: string, column: string): Promise<boolean>;
+    getTableName(tableName: TABLE_NAMES): string;
+    private formatSqlParams;
+    private executeWorkersBindingQuery;
+    private executeRestQuery;
+    executeQuery(options: SqlQueryOptions): Promise<Record<string, any>[] | Record<string, any> | null>;
+    private getTableColumns;
+    private serializeValue;
+    protected getSqlType(type: StorageColumn['type']): string;
+    createTable({ tableName, schema, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+    }): Promise<void>;
+    clearTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    alterTable(args: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): 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>;
+    processRecord(record: Record<string, any>): Promise<Record<string, any>>;
+    /**
+     * Upsert multiple records in a batch operation
+     * @param tableName The table to insert into
+     * @param records The records to insert
+     */
+    batchUpsert({ tableName, records }: {
+        tableName: TABLE_NAMES;
+        records: Record<string, any>[];
+    }): Promise<void>;
+}
+
+export declare interface StoreOperationsD1Config {
+    client?: D1Client_alias_2;
+    binding?: D1Database_2;
+    tablePrefix?: string;
+}
+
+export declare class TracesStorageD1 extends TracesStorage {
+    private operations;
+    constructor({ operations }: {
+        operations: StoreOperationsD1;
+    });
+    getTraces(args: StorageGetTracesArg): Promise<Trace[]>;
+    getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
+    batchTraceInsert({ records }: {
+        records: Record<string, any>[];
+    }): Promise<void>;
+}
+
+export declare class WorkflowsStorageD1 extends WorkflowsStorage {
+    private operations;
+    constructor({ operations }: {
+        operations: StoreOperationsD1;
+    });
+    persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
+        workflowName: string;
+        runId: string;
+        snapshot: WorkflowRunState;
+    }): Promise<void>;
+    loadWorkflowSnapshot(params: {
+        workflowName: string;
+        runId: string;
+    }): Promise<WorkflowRunState | null>;
+    private parseWorkflowRun;
+    getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
+        workflowName?: string;
+        fromDate?: Date;
+        toDate?: Date;
+        limit?: number;
+        offset?: number;
+        resourceId?: string;
+    }): Promise<WorkflowRuns>;
+    getWorkflowRunById({ runId, workflowName, }: {
+        runId: string;
+        workflowName?: string;
+    }): Promise<WorkflowRun | null>;
+}
+
 export { }