@mastra/dynamodb 0.0.0-update-stores-peerDeps-20250723031338 → 0.0.0-vector-query-tool-provider-options-20250828222356

package/dist/entities/workflow-snapshot.d.ts

@@ -0,0 +1,74 @@
+import { Entity } from 'electrodb';
+export declare const workflowSnapshotEntity: Entity<string, string, string, {
+    model: {
+        entity: string;
+        version: string;
+        service: string;
+    };
+    attributes: {
+        workflow_name: {
+            type: "string";
+            required: true;
+        };
+        run_id: {
+            type: "string";
+            required: true;
+        };
+        snapshot: {
+            type: "string";
+            required: true;
+            set: (value?: any) => any;
+            get: (value?: string) => any;
+        };
+        resourceId: {
+            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" | "workflow_name")[];
+            };
+            sk: {
+                field: string;
+                composite: "run_id"[];
+            };
+        };
+        gsi2: {
+            index: string;
+            pk: {
+                field: string;
+                composite: ("entity" | "run_id")[];
+            };
+            sk: {
+                field: string;
+                composite: "workflow_name"[];
+            };
+        };
+    };
+}>;
+//# sourceMappingURL=workflow-snapshot.d.ts.map

package/dist/entities/workflow-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-snapshot.d.ts","sourceRoot":"","sources":["../../src/entities/workflow-snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGnC,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;0BAwBf,GAAG;0BAOH,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBxB,CAAC"}

package/dist/index.cjs

@@ -420,6 +420,28 @@ var scoreEntity = new electrodb.Entity({
         return value;
       }
     },
+    preprocessStepResult: {
+      type: "string",
+      required: false,
+      set: (value) => {
+        if (value && typeof value !== "string") {
+          return JSON.stringify(value);
+        }
+        return value;
+      },
+      get: (value) => {
+        if (value && typeof value === "string") {
+          try {
+            if (value.startsWith("{") || value.startsWith("[")) {
+              return JSON.parse(value);
+            }
+          } catch {
+            return value;
+          }
+        }
+        return value;
+      }
+    },
     analyzeStepResult: {
       type: "string",
       required: false,
@@ -458,10 +480,19 @@ var scoreEntity = new electrodb.Entity({
       type: "string",
       required: false
     },
+    // Deprecated in favor of generateReasonPrompt
     reasonPrompt: {
       type: "string",
       required: false
     },
+    generateScorePrompt: {
+      type: "string",
+      required: false
+    },
+    generateReasonPrompt: {
+      type: "string",
+      required: false
+    },
     input: {
       type: "string",
       required: true,
@@ -1092,6 +1123,20 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
       // transformed by the ElectroDB entity getters.
     };
   }
+  // Helper function to transform and sort threads
+  transformAndSortThreads(rawThreads, orderBy, sortDirection) {
+    return rawThreads.map((data) => ({
+      ...data,
+      // Convert date strings back to Date objects for consistency
+      createdAt: typeof data.createdAt === "string" ? new Date(data.createdAt) : data.createdAt,
+      updatedAt: typeof data.updatedAt === "string" ? new Date(data.updatedAt) : data.updatedAt
+    })).sort((a, b) => {
+      const fieldA = orderBy === "createdAt" ? a.createdAt : a.updatedAt;
+      const fieldB = orderBy === "createdAt" ? b.createdAt : b.updatedAt;
+      const comparison = fieldA.getTime() - fieldB.getTime();
+      return sortDirection === "DESC" ? -comparison : comparison;
+    });
+  }
   async getThreadById({ threadId }) {
     this.logger.debug("Getting thread by ID", { threadId });
     try {
@@ -1120,21 +1165,20 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
       );
     }
   }
-  async getThreadsByResourceId({ resourceId }) {
-    this.logger.debug("Getting threads by resource ID", { resourceId });
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead for paginated results.
+   */
+  async getThreadsByResourceId(args) {
+    const resourceId = args.resourceId;
+    const orderBy = this.castThreadOrderBy(args.orderBy);
+    const sortDirection = this.castThreadSortDirection(args.sortDirection);
+    this.logger.debug("Getting threads by resource ID", { resourceId, orderBy, sortDirection });
     try {
       const result = await this.service.entities.thread.query.byResource({ entity: "thread", resourceId }).go();
       if (!result.data.length) {
         return [];
       }
-      return result.data.map((data) => ({
-        ...data,
-        // Convert date strings back to Date objects for consistency
-        createdAt: typeof data.createdAt === "string" ? new Date(data.createdAt) : data.createdAt,
-        updatedAt: typeof data.updatedAt === "string" ? new Date(data.updatedAt) : data.updatedAt
-        // metadata: data.metadata ? JSON.parse(data.metadata) : undefined, // REMOVED by AI
-        // metadata is already transformed by the entity's getter
-      }));
+      return this.transformAndSortThreads(result.data, orderBy, sortDirection);
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -1156,7 +1200,7 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
       resourceId: thread.resourceId,
       title: thread.title || `Thread ${thread.id}`,
       createdAt: thread.createdAt?.toISOString() || now.toISOString(),
-      updatedAt: now.toISOString(),
+      updatedAt: thread.updatedAt?.toISOString() || now.toISOString(),
       metadata: thread.metadata ? JSON.stringify(thread.metadata) : void 0
     };
     try {
@@ -1317,6 +1361,36 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
       );
     }
   }
+  async getMessagesById({
+    messageIds,
+    format
+  }) {
+    this.logger.debug("Getting messages by ID", { messageIds });
+    if (messageIds.length === 0) return [];
+    try {
+      const results = await Promise.all(
+        messageIds.map((id) => this.service.entities.message.query.primary({ entity: "message", id }).go())
+      );
+      const data = results.map((result) => result.data).flat(1);
+      let parsedMessages = data.map((data2) => this.parseMessageData(data2)).filter((msg) => "content" in msg);
+      const uniqueMessages = parsedMessages.filter(
+        (message, index, self) => index === self.findIndex((m) => m.id === message.id)
+      );
+      const list = new agent.MessageList().add(uniqueMessages, "memory");
+      if (format === `v1`) return list.get.all.v1();
+      return list.get.all.v2();
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "STORAGE_DYNAMODB_STORE_GET_MESSAGES_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { messageIds: JSON.stringify(messageIds) }
+        },
+        error$1
+      );
+    }
+  }
   async saveMessages(args) {
     const { messages, format = "v1" } = args;
     this.logger.debug("Saving messages", { count: messages.length });
@@ -1391,11 +1465,19 @@ var MemoryStorageDynamoDB = class extends storage.MemoryStorage {
   }
   async getThreadsByResourceIdPaginated(args) {
     const { resourceId, page = 0, perPage = 100 } = args;
-    this.logger.debug("Getting threads by resource ID with pagination", { resourceId, page, perPage });
+    const orderBy = this.castThreadOrderBy(args.orderBy);
+    const sortDirection = this.castThreadSortDirection(args.sortDirection);
+    this.logger.debug("Getting threads by resource ID with pagination", {
+      resourceId,
+      page,
+      perPage,
+      orderBy,
+      sortDirection
+    });
     try {
       const query = this.service.entities.thread.query.byResource({ entity: "thread", resourceId });
       const results = await query.go();
-      const allThreads = results.data;
+      const allThreads = this.transformAndSortThreads(results.data, orderBy, sortDirection);
       const startIndex = page * perPage;
       const endIndex = startIndex + perPage;
       const paginatedThreads = allThreads.slice(startIndex, endIndex);
@@ -1762,7 +1844,8 @@ var StoreOperationsDynamoDB = class extends storage.StoreOperations {
       [storage.TABLE_EVALS]: "eval",
       [storage.TABLE_SCORERS]: "score",
       [storage.TABLE_TRACES]: "trace",
-      [storage.TABLE_RESOURCES]: "resource"
+      [storage.TABLE_RESOURCES]: "resource",
+      [storage.TABLE_AI_SPANS]: "ai_span"
     };
     return mapping[tableName] || null;
   }
@@ -2099,11 +2182,12 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
       traceId: score.traceId || "",
       runId: score.runId,
       scorer: typeof score.scorer === "string" ? score.scorer : JSON.stringify(score.scorer),
-      extractStepResult: typeof score.extractStepResult === "string" ? score.extractStepResult : JSON.stringify(score.extractStepResult),
+      preprocessStepResult: typeof score.preprocessStepResult === "string" ? score.preprocessStepResult : JSON.stringify(score.preprocessStepResult),
       analyzeStepResult: typeof score.analyzeStepResult === "string" ? score.analyzeStepResult : JSON.stringify(score.analyzeStepResult),
       score: score.score,
       reason: score.reason,
-      extractPrompt: score.extractPrompt,
+      preprocessPrompt: score.preprocessPrompt,
+      generateScorePrompt: score.generateScorePrompt,
       analyzePrompt: score.analyzePrompt,
       reasonPrompt: score.reasonPrompt,
       input: typeof score.input === "string" ? score.input : JSON.stringify(score.input),
@@ -2144,9 +2228,9 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
     scorerId,
     pagination,
     entityId,
-    entityType
+    entityType,
+    source
   }) {
-    this.logger.debug("Getting scores by scorer ID", { scorerId, pagination, entityId, entityType });
     try {
       const query = this.service.entities.score.query.byScorer({ entity: "score", scorerId });
       const results = await query.go();
@@ -2157,6 +2241,9 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
       if (entityType) {
         allScores = allScores.filter((score) => score.entityType === entityType);
       }
+      if (source) {
+        allScores = allScores.filter((score) => score.source === source);
+      }
       allScores.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
       const startIndex = pagination.page * pagination.perPage;
       const endIndex = startIndex + pagination.perPage;
@@ -2182,6 +2269,7 @@ var ScoresStorageDynamoDB = class extends storage.ScoresStorage {
             scorerId: scorerId || "",
             entityId: entityId || "",
             entityType: entityType || "",
+            source: source || "",
             page: pagination.page,
             perPage: pagination.perPage
           }
@@ -2514,6 +2602,22 @@ var WorkflowStorageDynamoDB = class extends storage.WorkflowsStorage {
     super();
     this.service = service;
   }
+  updateWorkflowResults({
+    // workflowName,
+    // runId,
+    // stepId,
+    // result,
+    // runtimeContext,
+  }) {
+    throw new Error("Method not implemented.");
+  }
+  updateWorkflowState({
+    // workflowName,
+    // runId,
+    // opts,
+  }) {
+    throw new Error("Method not implemented.");
+  }
   // Workflow operations
   async persistWorkflowSnapshot({
     workflowName,
@@ -2763,7 +2867,8 @@ var DynamoDBStore = class extends storage.MastraStorage {
       selectByIncludeResourceScope: true,
       resourceWorkingMemory: true,
       hasColumn: false,
-      createTable: false
+      createTable: false,
+      deleteMessages: false
     };
   }
   /**
@@ -2858,8 +2963,8 @@ var DynamoDBStore = class extends storage.MastraStorage {
   async getThreadById({ threadId }) {
     return this.stores.memory.getThreadById({ threadId });
   }
-  async getThreadsByResourceId({ resourceId }) {
-    return this.stores.memory.getThreadsByResourceId({ resourceId });
+  async getThreadsByResourceId(args) {
+    return this.stores.memory.getThreadsByResourceId(args);
   }
   async saveThread({ thread }) {
     return this.stores.memory.saveThread({ thread });
@@ -2882,6 +2987,12 @@ var DynamoDBStore = class extends storage.MastraStorage {
   }) {
     return this.stores.memory.getMessages({ threadId, resourceId, selectBy, format });
   }
+  async getMessagesById({
+    messageIds,
+    format
+  }) {
+    return this.stores.memory.getMessagesById({ messageIds, format });
+  }
   async saveMessages(args) {
     return this.stores.memory.saveMessages(args);
   }
@@ -2905,6 +3016,22 @@ var DynamoDBStore = class extends storage.MastraStorage {
     return this.stores.traces.getTracesPaginated(_args);
   }
   // Workflow operations
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    runtimeContext
+  }) {
+    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, runtimeContext });
+  }
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
+  }) {
+    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
+  }
   async persistWorkflowSnapshot({
     workflowName,
     runId,
@@ -2991,11 +3118,16 @@ var DynamoDBStore = class extends storage.MastraStorage {
     });
   }
   async getScoresByScorerId({
-    scorerId: _scorerId,
-    pagination: _pagination
+    scorerId,
+    source,
+    entityId,
+    entityType,
+    pagination
   }) {
-    return this.stores.scores.getScoresByScorerId({ scorerId: _scorerId, pagination: _pagination });
+    return this.stores.scores.getScoresByScorerId({ scorerId, source, entityId, entityType, pagination });
   }
 };
 
 exports.DynamoDBStore = DynamoDBStore;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map