@mastra/dynamodb 0.13.0 → 0.13.1-alpha.0

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

@@ -1,22 +1,33 @@
 import type { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
 import { Entity } from 'electrodb';
 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 { Service } from 'electrodb';
 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 { TABLE_RESOURCES } 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 baseAttributes: {
     readonly createdAt: {
@@ -44,21 +55,17 @@ declare class DynamoDBStore extends MastraStorage {
     private client;
     private service;
     protected hasInitialized: Promise<boolean> | null;
+    stores: StorageDomains;
     constructor({ name, config }: {
         name: string;
         config: DynamoDBStoreConfig;
     });
-    /**
-     * This method is modified for DynamoDB with ElectroDB single-table design.
-     * It assumes the table is created and managed externally via CDK/CloudFormation.
-     *
-     * This implementation only validates that the required table exists and is accessible.
-     * No table creation is attempted - we simply check if we can access the table.
-     */
-    createTable({ tableName }: {
-        tableName: TABLE_NAMES;
-        schema: Record<string, any>;
-    }): Promise<void>;
+    get supports(): {
+        selectByIncludeResourceScope: boolean;
+        resourceWorkingMemory: boolean;
+        hasColumn: boolean;
+        createTable: boolean;
+    };
     /**
      * Validates that the required DynamoDB table exists and is accessible.
      * This does not check the table structure - it assumes the table
@@ -76,41 +83,31 @@ declare class DynamoDBStore extends MastraStorage {
      * Handles resetting the stored promise on failure to allow retries.
      */
     private _performInitializationAndStore;
-    /**
-     * Pre-processes a record to ensure Date objects are converted to ISO strings
-     * This is necessary because ElectroDB validation happens before setters are applied
-     */
-    private preprocessRecord;
+    createTable({ tableName, schema }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, any>;
+    }): Promise<void>;
     alterTable(_args: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
         ifNotExists: string[];
     }): Promise<void>;
-    /**
-     * Clear all items from a logical "table" (entity type)
-     */
     clearTable({ tableName }: {
-        tableName: SUPPORTED_TABLE_NAMES;
+        tableName: TABLE_NAMES;
     }): Promise<void>;
-    /**
-     * Insert a record into the specified "table" (entity)
-     */
-    insert({ tableName, record, }: {
-        tableName: SUPPORTED_TABLE_NAMES;
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    insert({ tableName, record }: {
+        tableName: TABLE_NAMES;
         record: Record<string, any>;
     }): Promise<void>;
-    /**
-     * Insert multiple records as a batch
-     */
-    batchInsert({ tableName, records, }: {
-        tableName: SUPPORTED_TABLE_NAMES;
+    batchInsert({ tableName, records }: {
+        tableName: TABLE_NAMES;
         records: Record<string, any>[];
     }): Promise<void>;
-    /**
-     * Load a record by its keys
-     */
-    load<R>({ tableName, keys, }: {
-        tableName: SUPPORTED_TABLE_NAMES;
+    load<R>({ tableName, keys }: {
+        tableName: TABLE_NAMES;
         keys: Record<string, string>;
     }): Promise<R | null>;
     getThreadById({ threadId }: {
@@ -144,7 +141,27 @@ declare class DynamoDBStore extends MastraStorage {
         messages: MastraMessageV2[];
         format: 'v2';
     }): Promise<MastraMessageV2[]>;
-    private parseMessageData;
+    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[]>;
     getTraces(args: {
         name?: string;
         scope?: string;
@@ -156,6 +173,9 @@ declare class DynamoDBStore extends MastraStorage {
     batchTraceInsert({ records }: {
         records: Record<string, any>[];
     }): Promise<void>;
+    getTracesPaginated(_args: StorageGetTracesArg): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
     persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
         workflowName: string;
         runId: string;
@@ -177,36 +197,60 @@ declare class DynamoDBStore extends MastraStorage {
         runId: string;
         workflowName?: string;
     }): Promise<WorkflowRun | null>;
-    private formatWorkflowRun;
-    private getEntityNameForTable;
-    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
-    getTracesPaginated(_args: StorageGetTracesArg): Promise<PaginationInfo & {
-        traces: Trace[];
-    }>;
-    getThreadsByResourceIdPaginated(_args: {
+    getResourceById({ resourceId }: {
         resourceId: string;
-        page?: number;
-        perPage?: number;
-    }): Promise<PaginationInfo & {
-        threads: StorageThreadType[];
-    }>;
-    getMessagesPaginated(_args: StorageGetMessagesArg): Promise<PaginationInfo & {
-        messages: MastraMessageV1[] | MastraMessageV2[];
+    }): Promise<StorageResourceType | null>;
+    saveResource({ resource }: {
+        resource: StorageResourceType;
+    }): Promise<StorageResourceType>;
+    updateResource({ resourceId, workingMemory, metadata, }: {
+        resourceId: string;
+        workingMemory?: string;
+        metadata?: Record<string, any>;
+    }): Promise<StorageResourceType>;
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    getEvals(options: {
+        agentName?: string;
+        type?: 'test' | 'live';
+    } & PaginationArgs): Promise<PaginationInfo & {
+        evals: EvalRow[];
     }>;
     /**
      * Closes the DynamoDB client connection and cleans up resources.
      * Should be called when the store is no longer needed, e.g., at the end of tests or application shutdown.
      */
     close(): Promise<void>;
-    updateMessages(_args: {
-        messages: Partial<Omit<MastraMessageV2, 'createdAt'>> & {
-            id: string;
-            content?: {
-                metadata?: MastraMessageContentV2['metadata'];
-                content?: MastraMessageContentV2['content'];
-            };
-        }[];
-    }): Promise<MastraMessageV2[]>;
+    /**
+     * SCORERS - Not implemented
+     */
+    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[];
+    }>;
 }
 export { DynamoDBStore }
 export { DynamoDBStore as DynamoDBStore_alias_1 }
@@ -715,7 +759,7 @@ export declare function getElectroDbService(client: DynamoDBDocumentClient, tabl
     };
     };
     }>;
-    workflowSnapshot: Entity<string, string, string, {
+    workflow_snapshot: Entity<string, string, string, {
     model: {
     entity: string;
     version: string;
@@ -787,136 +831,857 @@ export declare function getElectroDbService(client: DynamoDBDocumentClient, tabl
     };
     };
     }>;
-}>;
-
-export declare const messageEntity: Entity<string, string, string, {
+    resource: Entity<string, string, string, {
     model: {
-        entity: string;
-        version: string;
-        service: string;
+    entity: string;
+    version: string;
+    service: string;
     };
     attributes: {
-        id: {
-            type: "string";
-            required: true;
-        };
-        threadId: {
-            type: "string";
-            required: true;
-        };
-        content: {
-            type: "string";
-            required: true;
-            set: (value?: string | void | undefined) => string | void;
-            get: (value?: string) => any;
-        };
-        role: {
-            type: "string";
-            required: true;
-        };
-        type: {
-            type: "string";
-            default: string;
-        };
-        resourceId: {
-            type: "string";
-            required: false;
-        };
-        toolCallIds: {
-            type: "string";
-            required: false;
-            set: (value?: string[] | string) => string | undefined;
-            get: (value?: string) => any;
-        };
-        toolCallArgs: {
-            type: "string";
-            required: false;
-            set: (value?: Record<string, unknown>[] | string) => string | undefined;
-            get: (value?: string) => any;
-        };
-        toolNames: {
-            type: "string";
-            required: false;
-            set: (value?: string[] | string) => string | undefined;
-            get: (value?: string) => any;
-        };
-        createdAt: {
-            readonly type: "string";
-            readonly required: true;
-            readonly readOnly: true;
-            readonly set: (value?: Date | string) => string;
-            readonly default: () => string;
-        };
-        updatedAt: {
-            readonly type: "string";
-            readonly required: true;
-            readonly set: (value?: Date | string) => string;
-            readonly default: () => string;
-        };
-        metadata: {
-            readonly type: "string";
-            readonly set: (value?: Record<string, unknown> | string) => string | undefined;
-            readonly get: (value?: string) => any;
-        };
-        entity: {
-            type: "string";
-            required: true;
-        };
+    id: {
+    type: "string";
+    required: true;
+    };
+    workingMemory: {
+    type: "string";
+    required: false;
+    };
+    metadata: {
+    type: "string";
+    required: false;
+    set: (value?: string | void | undefined) => string | void;
+    get: (value?: string) => any;
+    };
+    createdAt: {
+    readonly type: "string";
+    readonly required: true;
+    readonly readOnly: true;
+    readonly set: (value?: Date | string) => string;
+    readonly default: () => string;
+    };
+    updatedAt: {
+    readonly type: "string";
+    readonly required: true;
+    readonly set: (value?: Date | string) => string;
+    readonly default: () => string;
+    };
+    entity: {
+    type: "string";
+    required: true;
+    };
     };
     indexes: {
-        primary: {
-            pk: {
-                field: string;
-                composite: ("entity" | "id")[];
-            };
-            sk: {
-                field: string;
-                composite: "entity"[];
-            };
-        };
-        byThread: {
-            index: string;
-            pk: {
-                field: string;
-                composite: ("entity" | "threadId")[];
-            };
-            sk: {
-                field: string;
-                composite: "createdAt"[];
-            };
-        };
+    primary: {
+    pk: {
+    field: string;
+    composite: ("entity" | "id")[];
     };
-}>;
-
-declare type SUPPORTED_TABLE_NAMES = Exclude<TABLE_NAMES, typeof TABLE_RESOURCES>;
-
-export declare const threadEntity: Entity<string, string, string, {
+    sk: {
+    field: string;
+    composite: "entity"[];
+    };
+    };
+    };
+    }>;
+    score: Entity<string, string, string, {
     model: {
-        entity: string;
-        version: string;
-        service: string;
+    entity: string;
+    version: string;
+    service: string;
     };
     attributes: {
-        id: {
-            type: "string";
-            required: true;
-        };
-        resourceId: {
-            type: "string";
-            required: true;
-        };
-        title: {
-            type: "string";
-            required: true;
-        };
-        metadata: {
-            type: "string";
-            required: false;
-            set: (value?: Record<string, unknown> | string) => string | undefined;
-            get: (value?: string) => any;
-        };
-        createdAt: {
-            readonly type: "string";
+    id: {
+    type: "string";
+    required: true;
+    };
+    scorerId: {
+    type: "string";
+    required: true;
+    };
+    traceId: {
+    type: "string";
+    required: false;
+    };
+    runId: {
+    type: "string";
+    required: true;
+    };
+    scorer: {
+    type: "string";
+    required: true;
+    set: (value?: Record<string, unknown> | string) => string | undefined;
+    get: (value?: string) => any;
+    };
+    extractStepResult: {
+    type: "string";
+    required: false;
+    set: (value?: Record<string, unknown> | string) => string | undefined;
+    get: (value?: string) => any;
+    };
+    analyzeStepResult: {
+    type: "string";
+    required: false;
+    set: (value?: Record<string, unknown> | string) => string | undefined;
+    get: (value?: string) => any;
+    };
+    score: {
+    type: "number";
+    required: true;
+    };
+    reason: {
+    type: "string";
+    required: false;
+    };
+    extractPrompt: {
+    type: "string";
+    required: false;
+    };
+    analyzePrompt: {
+    type: "string";
+    required: false;
+    };
+    reasonPrompt: {
+    type: "string";
+    required: false;
+    };
+    input: {
+    type: "string";
+    required: true;
+    set: (value?: Record<string, unknown> | string) => string | undefined;
+    get: (value?: string) => any;
+    };
+    output: {
+    type: "string";
+    required: true;
+    set: (value?: Record<string, unknown> | string) => string | undefined;
+    get: (value?: string) => any;
+    };
+    additionalContext: {
+    type: "string";
+    required: false;
+    set: (value?: Record<string, unknown> | string) => string | undefined;
+    get: (value?: string) => any;
+    };
+    runtimeContext: {
+    type: "string";
+    required: false;
+    set: (value?: Record<string, unknown> | string) => string | undefined;
+    get: (value?: string) => any;
+    };
+    entityType: {
+    type: "string";
+    required: false;
+    };
+    entityData: {
+    type: "string";
+    required: false;
+    set: (value?: Record<string, unknown> | string) => string | undefined;
+    get: (value?: string) => any;
+    };
+    entityId: {
+    type: "string";
+    required: false;
+    };
+    source: {
+    type: "string";
+    required: true;
+    };
+    resourceId: {
+    type: "string";
+    required: false;
+    };
+    threadId: {
+    type: "string";
+    required: false;
+    };
+    createdAt: {
+    readonly type: "string";
+    readonly required: true;
+    readonly readOnly: true;
+    readonly set: (value?: Date | string) => string;
+    readonly default: () => string;
+    };
+    updatedAt: {
+    readonly type: "string";
+    readonly required: true;
+    readonly set: (value?: Date | string) => string;
+    readonly default: () => string;
+    };
+    metadata: {
+    readonly type: "string";
+    readonly set: (value?: Record<string, unknown> | string) => string | undefined;
+    readonly get: (value?: string) => any;
+    };
+    entity: {
+    type: "string";
+    required: true;
+    };
+    };
+    indexes: {
+    primary: {
+    pk: {
+    field: string;
+    composite: ("entity" | "id")[];
+    };
+    sk: {
+    field: string;
+    composite: "entity"[];
+    };
+    };
+    byScorer: {
+    index: string;
+    pk: {
+    field: string;
+    composite: ("entity" | "scorerId")[];
+    };
+    sk: {
+    field: string;
+    composite: "createdAt"[];
+    };
+    };
+    byRun: {
+    index: string;
+    pk: {
+    field: string;
+    composite: ("entity" | "runId")[];
+    };
+    sk: {
+    field: string;
+    composite: "createdAt"[];
+    };
+    };
+    byTrace: {
+    index: string;
+    pk: {
+    field: string;
+    composite: ("entity" | "traceId")[];
+    };
+    sk: {
+    field: string;
+    composite: "createdAt"[];
+    };
+    };
+    byEntityData: {
+    index: string;
+    pk: {
+    field: string;
+    composite: ("entity" | "entityId")[];
+    };
+    sk: {
+    field: string;
+    composite: "createdAt"[];
+    };
+    };
+    byResource: {
+    index: string;
+    pk: {
+    field: string;
+    composite: ("entity" | "resourceId")[];
+    };
+    sk: {
+    field: string;
+    composite: "createdAt"[];
+    };
+    };
+    byThread: {
+    index: string;
+    pk: {
+    field: string;
+    composite: ("entity" | "threadId")[];
+    };
+    sk: {
+    field: string;
+    composite: "createdAt"[];
+    };
+    };
+    };
+    }>;
+}>;
+
+export declare class LegacyEvalsDynamoDB extends LegacyEvalsStorage {
+    service: Service<Record<string, any>>;
+    tableName: string;
+    constructor({ service, tableName }: {
+        service: Service<Record<string, any>>;
+        tableName: string;
+    });
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    getEvals(options?: {
+        agentName?: string;
+        type?: 'test' | 'live';
+    } & PaginationArgs): Promise<PaginationInfo & {
+        evals: EvalRow[];
+    }>;
+}
+
+export declare class MemoryStorageDynamoDB extends MemoryStorage {
+    private service;
+    constructor({ service }: {
+        service: Service<Record<string, any>>;
+    });
+    private parseMessageData;
+    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(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[];
+    }>;
+    getMessagesPaginated(args: StorageGetMessagesArg & {
+        format?: 'v1' | 'v2';
+    }): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2[];
+    }>;
+    private _getIncludedMessages;
+    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 const messageEntity: Entity<string, string, string, {
+    model: {
+        entity: string;
+        version: string;
+        service: string;
+    };
+    attributes: {
+        id: {
+            type: "string";
+            required: true;
+        };
+        threadId: {
+            type: "string";
+            required: true;
+        };
+        content: {
+            type: "string";
+            required: true;
+            set: (value?: string | void | undefined) => string | void;
+            get: (value?: string) => any;
+        };
+        role: {
+            type: "string";
+            required: true;
+        };
+        type: {
+            type: "string";
+            default: string;
+        };
+        resourceId: {
+            type: "string";
+            required: false;
+        };
+        toolCallIds: {
+            type: "string";
+            required: false;
+            set: (value?: string[] | string) => string | undefined;
+            get: (value?: string) => any;
+        };
+        toolCallArgs: {
+            type: "string";
+            required: false;
+            set: (value?: Record<string, unknown>[] | string) => string | undefined;
+            get: (value?: string) => any;
+        };
+        toolNames: {
+            type: "string";
+            required: false;
+            set: (value?: string[] | string) => string | undefined;
+            get: (value?: string) => any;
+        };
+        createdAt: {
+            readonly type: "string";
+            readonly required: true;
+            readonly readOnly: true;
+            readonly set: (value?: Date | string) => string;
+            readonly default: () => string;
+        };
+        updatedAt: {
+            readonly type: "string";
+            readonly required: true;
+            readonly set: (value?: Date | string) => string;
+            readonly default: () => string;
+        };
+        metadata: {
+            readonly type: "string";
+            readonly set: (value?: Record<string, unknown> | string) => string | undefined;
+            readonly get: (value?: string) => any;
+        };
+        entity: {
+            type: "string";
+            required: true;
+        };
+    };
+    indexes: {
+        primary: {
+            pk: {
+                field: string;
+                composite: ("entity" | "id")[];
+            };
+            sk: {
+                field: string;
+                composite: "entity"[];
+            };
+        };
+        byThread: {
+            index: string;
+            pk: {
+                field: string;
+                composite: ("entity" | "threadId")[];
+            };
+            sk: {
+                field: string;
+                composite: "createdAt"[];
+            };
+        };
+    };
+}>;
+
+export declare const resourceEntity: Entity<string, string, string, {
+    model: {
+        entity: string;
+        version: string;
+        service: string;
+    };
+    attributes: {
+        id: {
+            type: "string";
+            required: true;
+        };
+        workingMemory: {
+            type: "string";
+            required: false;
+        };
+        metadata: {
+            type: "string";
+            required: false;
+            set: (value?: string | void | undefined) => string | void;
+            get: (value?: string) => any;
+        };
+        createdAt: {
+            readonly type: "string";
+            readonly required: true;
+            readonly readOnly: true;
+            readonly set: (value?: Date | string) => string;
+            readonly default: () => string;
+        };
+        updatedAt: {
+            readonly type: "string";
+            readonly required: true;
+            readonly set: (value?: Date | string) => string;
+            readonly default: () => string;
+        };
+        entity: {
+            type: "string";
+            required: true;
+        };
+    };
+    indexes: {
+        primary: {
+            pk: {
+                field: string;
+                composite: ("entity" | "id")[];
+            };
+            sk: {
+                field: string;
+                composite: "entity"[];
+            };
+        };
+    };
+}>;
+
+export declare const scoreEntity: Entity<string, string, string, {
+    model: {
+        entity: string;
+        version: string;
+        service: string;
+    };
+    attributes: {
+        id: {
+            type: "string";
+            required: true;
+        };
+        scorerId: {
+            type: "string";
+            required: true;
+        };
+        traceId: {
+            type: "string";
+            required: false;
+        };
+        runId: {
+            type: "string";
+            required: true;
+        };
+        scorer: {
+            type: "string";
+            required: true;
+            set: (value?: Record<string, unknown> | string) => string | undefined;
+            get: (value?: string) => any;
+        };
+        extractStepResult: {
+            type: "string";
+            required: false;
+            set: (value?: Record<string, unknown> | string) => string | undefined;
+            get: (value?: string) => any;
+        };
+        analyzeStepResult: {
+            type: "string";
+            required: false;
+            set: (value?: Record<string, unknown> | string) => string | undefined;
+            get: (value?: string) => any;
+        };
+        score: {
+            type: "number";
+            required: true;
+        };
+        reason: {
+            type: "string";
+            required: false;
+        };
+        extractPrompt: {
+            type: "string";
+            required: false;
+        };
+        analyzePrompt: {
+            type: "string";
+            required: false;
+        };
+        reasonPrompt: {
+            type: "string";
+            required: false;
+        };
+        input: {
+            type: "string";
+            required: true;
+            set: (value?: Record<string, unknown> | string) => string | undefined;
+            get: (value?: string) => any;
+        };
+        output: {
+            type: "string";
+            required: true;
+            set: (value?: Record<string, unknown> | string) => string | undefined;
+            get: (value?: string) => any;
+        };
+        additionalContext: {
+            type: "string";
+            required: false;
+            set: (value?: Record<string, unknown> | string) => string | undefined;
+            get: (value?: string) => any;
+        };
+        runtimeContext: {
+            type: "string";
+            required: false;
+            set: (value?: Record<string, unknown> | string) => string | undefined;
+            get: (value?: string) => any;
+        };
+        entityType: {
+            type: "string";
+            required: false;
+        };
+        entityData: {
+            type: "string";
+            required: false;
+            set: (value?: Record<string, unknown> | string) => string | undefined;
+            get: (value?: string) => any;
+        };
+        entityId: {
+            type: "string";
+            required: false;
+        };
+        source: {
+            type: "string";
+            required: true;
+        };
+        resourceId: {
+            type: "string";
+            required: false;
+        };
+        threadId: {
+            type: "string";
+            required: false;
+        };
+        createdAt: {
+            readonly type: "string";
+            readonly required: true;
+            readonly readOnly: true;
+            readonly set: (value?: Date | string) => string;
+            readonly default: () => string;
+        };
+        updatedAt: {
+            readonly type: "string";
+            readonly required: true;
+            readonly set: (value?: Date | string) => string;
+            readonly default: () => string;
+        };
+        metadata: {
+            readonly type: "string";
+            readonly set: (value?: Record<string, unknown> | string) => string | undefined;
+            readonly get: (value?: string) => any;
+        };
+        entity: {
+            type: "string";
+            required: true;
+        };
+    };
+    indexes: {
+        primary: {
+            pk: {
+                field: string;
+                composite: ("entity" | "id")[];
+            };
+            sk: {
+                field: string;
+                composite: "entity"[];
+            };
+        };
+        byScorer: {
+            index: string;
+            pk: {
+                field: string;
+                composite: ("entity" | "scorerId")[];
+            };
+            sk: {
+                field: string;
+                composite: "createdAt"[];
+            };
+        };
+        byRun: {
+            index: string;
+            pk: {
+                field: string;
+                composite: ("entity" | "runId")[];
+            };
+            sk: {
+                field: string;
+                composite: "createdAt"[];
+            };
+        };
+        byTrace: {
+            index: string;
+            pk: {
+                field: string;
+                composite: ("entity" | "traceId")[];
+            };
+            sk: {
+                field: string;
+                composite: "createdAt"[];
+            };
+        };
+        byEntityData: {
+            index: string;
+            pk: {
+                field: string;
+                composite: ("entity" | "entityId")[];
+            };
+            sk: {
+                field: string;
+                composite: "createdAt"[];
+            };
+        };
+        byResource: {
+            index: string;
+            pk: {
+                field: string;
+                composite: ("entity" | "resourceId")[];
+            };
+            sk: {
+                field: string;
+                composite: "createdAt"[];
+            };
+        };
+        byThread: {
+            index: string;
+            pk: {
+                field: string;
+                composite: ("entity" | "threadId")[];
+            };
+            sk: {
+                field: string;
+                composite: "createdAt"[];
+            };
+        };
+    };
+}>;
+
+export declare class ScoresStorageDynamoDB extends ScoresStorage {
+    private service;
+    constructor({ service }: {
+        service: Service<Record<string, any>>;
+    });
+    private parseScoreData;
+    getScoreById({ id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    saveScore(score: Omit<ScoreRowData, 'id' | 'createdAt' | 'updatedAt'>): Promise<{
+        score: ScoreRowData;
+    }>;
+    getScoresByScorerId({ scorerId, pagination, entityId, entityType, }: {
+        scorerId: string;
+        pagination: StoragePagination;
+        entityId?: string;
+        entityType?: string;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByRunId({ runId, pagination, }: {
+        runId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByEntityId({ entityId, entityType, pagination, }: {
+        entityId: string;
+        entityType: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+}
+
+export declare class StoreOperationsDynamoDB extends StoreOperations {
+    client: DynamoDBDocumentClient;
+    tableName: string;
+    service: Service<Record<string, any>>;
+    constructor({ service, tableName, client, }: {
+        service: Service<Record<string, any>>;
+        tableName: string;
+        client: DynamoDBDocumentClient;
+    });
+    hasColumn(): Promise<boolean>;
+    dropTable(): Promise<void>;
+    private getEntityNameForTable;
+    /**
+     * Pre-processes a record to ensure Date objects are converted to ISO strings
+     * This is necessary because ElectroDB validation happens before setters are applied
+     */
+    private preprocessRecord;
+    /**
+     * Validates that the required DynamoDB table exists and is accessible.
+     * This does not check the table structure - it assumes the table
+     * was created with the correct structure via CDK/CloudFormation.
+     */
+    private validateTableExists;
+    /**
+     * This method is modified for DynamoDB with ElectroDB single-table design.
+     * It assumes the table is created and managed externally via CDK/CloudFormation.
+     *
+     * This implementation only validates that the required table exists and is accessible.
+     * No table creation is attempted - we simply check if we can access the table.
+     */
+    createTable({ tableName }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, any>;
+    }): Promise<void>;
+    insert({ tableName, record }: {
+        tableName: TABLE_NAMES;
+        record: Record<string, any>;
+    }): Promise<void>;
+    alterTable(_args: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
+    /**
+     * Clear all items from a logical "table" (entity type)
+     */
+    clearTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    /**
+     * Insert multiple records as a batch
+     */
+    batchInsert({ tableName, records }: {
+        tableName: TABLE_NAMES;
+        records: Record<string, any>[];
+    }): Promise<void>;
+    /**
+     * Load a record by its keys
+     */
+    load<R>({ tableName, keys }: {
+        tableName: TABLE_NAMES;
+        keys: Record<string, string>;
+    }): Promise<R | null>;
+}
+
+export declare const threadEntity: Entity<string, string, string, {
+    model: {
+        entity: string;
+        version: string;
+        service: string;
+    };
+    attributes: {
+        id: {
+            type: "string";
+            required: true;
+        };
+        resourceId: {
+            type: "string";
+            required: true;
+        };
+        title: {
+            type: "string";
+            required: true;
+        };
+        metadata: {
+            type: "string";
+            required: false;
+            set: (value?: Record<string, unknown> | string) => string | undefined;
+            get: (value?: string) => any;
+        };
+        createdAt: {
+            readonly type: "string";
             readonly required: true;
             readonly readOnly: true;
             readonly set: (value?: Date | string) => string;
@@ -1084,6 +1849,29 @@ export declare const traceEntity: Entity<string, string, string, {
     };
 }>;
 
+export declare class TracesStorageDynamoDB extends TracesStorage {
+    private service;
+    private operations;
+    constructor({ service, operations }: {
+        service: Service<Record<string, any>>;
+        operations: StoreOperationsDynamoDB;
+    });
+    getTraces(args: {
+        name?: string;
+        scope?: string;
+        page: number;
+        perPage: number;
+        attributes?: Record<string, string>;
+        filters?: Record<string, any>;
+    }): Promise<any[]>;
+    batchTraceInsert({ records }: {
+        records: Record<string, any>[];
+    }): Promise<void>;
+    getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
+}
+
 export declare const workflowSnapshotEntity: Entity<string, string, string, {
     model: {
         entity: string;
@@ -1157,4 +1945,32 @@ export declare const workflowSnapshotEntity: Entity<string, string, string, {
     };
 }>;
 
+export declare class WorkflowStorageDynamoDB extends WorkflowsStorage {
+    private service;
+    constructor({ service }: {
+        service: Service<Record<string, any>>;
+    });
+    persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
+        workflowName: string;
+        runId: string;
+        snapshot: WorkflowRunState;
+    }): Promise<void>;
+    loadWorkflowSnapshot({ workflowName, runId, }: {
+        workflowName: string;
+        runId: string;
+    }): Promise<WorkflowRunState | null>;
+    getWorkflowRuns(args?: {
+        workflowName?: string;
+        fromDate?: Date;
+        toDate?: Date;
+        limit?: number;
+        offset?: number;
+        resourceId?: string;
+    }): Promise<WorkflowRuns>;
+    getWorkflowRunById(args: {
+        runId: string;
+        workflowName?: string;
+    }): Promise<WorkflowRun | null>;
+}
+
 export { }