@mastra/mssql 0.0.0-fix-tool-call-history-3-20250806004225 → 0.0.0-interpolate-reporter-url-20250910180021

package/dist/index.js

@@ -461,6 +461,7 @@ var MemoryMSSQL = class extends MemoryStorage {
     selectBy,
     orderByStatement
   }) {
+    if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
     const include = selectBy?.include;
     if (!include) return null;
     const unionQueries = [];
@@ -532,11 +533,12 @@ var MemoryMSSQL = class extends MemoryStorage {
     return dedupedRows;
   }
   async getMessages(args) {
-    const { threadId, format, selectBy } = args;
+    const { threadId, resourceId, format, selectBy } = args;
     const selectStatement = `SELECT seq_id, id, content, role, type, [createdAt], thread_id AS threadId, resourceId`;
     const orderByStatement = `ORDER BY [seq_id] DESC`;
     const limit = resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
     try {
+      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
       let rows = [];
       const include = selectBy?.include || [];
       if (include?.length) {
@@ -574,7 +576,8 @@ var MemoryMSSQL = class extends MemoryStorage {
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
-            threadId
+            threadId,
+            resourceId: resourceId ?? ""
           }
         },
         error
@@ -584,30 +587,65 @@ var MemoryMSSQL = class extends MemoryStorage {
       return [];
     }
   }
-  async getMessagesPaginated(args) {
-    const { threadId, selectBy } = args;
-    const { page = 0, perPage: perPageInput } = selectBy?.pagination || {};
+  async getMessagesById({
+    messageIds,
+    format
+  }) {
+    if (messageIds.length === 0) return [];
+    const selectStatement = `SELECT seq_id, id, content, role, type, [createdAt], thread_id AS threadId, resourceId`;
     const orderByStatement = `ORDER BY [seq_id] DESC`;
-    if (selectBy?.include?.length) {
-      await this._getIncludedMessages({ threadId, selectBy, orderByStatement });
+    try {
+      let rows = [];
+      let query = `${selectStatement} FROM ${getTableName({ indexName: TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })} WHERE [id] IN (${messageIds.map((_, i) => `@id${i}`).join(", ")})`;
+      const request = this.pool.request();
+      messageIds.forEach((id, i) => request.input(`id${i}`, id));
+      query += ` ${orderByStatement}`;
+      const result = await request.query(query);
+      const remainingRows = result.recordset || [];
+      rows.push(...remainingRows);
+      rows.sort((a, b) => {
+        const timeDiff = a.seq_id - b.seq_id;
+        return timeDiff;
+      });
+      rows = rows.map(({ seq_id, ...rest }) => rest);
+      if (format === `v1`) return this._parseAndFormatMessages(rows, format);
+      return this._parseAndFormatMessages(rows, `v2`);
+    } catch (error) {
+      const mastraError = new MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_GET_MESSAGES_BY_ID_FAILED",
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: {
+            messageIds: JSON.stringify(messageIds)
+          }
+        },
+        error
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return [];
     }
+  }
+  async getMessagesPaginated(args) {
+    const { threadId, resourceId, format, selectBy } = args;
+    const { page = 0, perPage: perPageInput, dateRange } = selectBy?.pagination || {};
     try {
-      const { threadId: threadId2, format, selectBy: selectBy2 } = args;
-      const { page: page2 = 0, perPage: perPageInput2, dateRange } = selectBy2?.pagination || {};
+      if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
       const fromDate = dateRange?.start;
       const toDate = dateRange?.end;
       const selectStatement = `SELECT seq_id, id, content, role, type, [createdAt], thread_id AS threadId, resourceId`;
-      const orderByStatement2 = `ORDER BY [seq_id] DESC`;
-      let messages2 = [];
-      if (selectBy2?.include?.length) {
-        const includeMessages = await this._getIncludedMessages({ threadId: threadId2, selectBy: selectBy2, orderByStatement: orderByStatement2 });
-        if (includeMessages) messages2.push(...includeMessages);
+      const orderByStatement = `ORDER BY [seq_id] DESC`;
+      let messages = [];
+      if (selectBy?.include?.length) {
+        const includeMessages = await this._getIncludedMessages({ threadId, selectBy, orderByStatement });
+        if (includeMessages) messages.push(...includeMessages);
       }
-      const perPage = perPageInput2 !== void 0 ? perPageInput2 : resolveMessageLimit({ last: selectBy2?.last, defaultLimit: 40 });
-      const currentOffset = page2 * perPage;
+      const perPage = perPageInput !== void 0 ? perPageInput : resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
+      const currentOffset = page * perPage;
       const conditions = ["[thread_id] = @threadId"];
       const request = this.pool.request();
-      request.input("threadId", threadId2);
+      request.input("threadId", threadId);
       if (fromDate instanceof Date && !isNaN(fromDate.getTime())) {
         conditions.push("[createdAt] >= @fromDate");
         request.input("fromDate", fromDate.toISOString());
@@ -620,35 +658,35 @@ var MemoryMSSQL = class extends MemoryStorage {
       const countQuery = `SELECT COUNT(*) as total FROM ${getTableName({ indexName: TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })} ${whereClause}`;
       const countResult = await request.query(countQuery);
       const total = parseInt(countResult.recordset[0]?.total, 10) || 0;
-      if (total === 0 && messages2.length > 0) {
-        const parsedIncluded = this._parseAndFormatMessages(messages2, format);
+      if (total === 0 && messages.length > 0) {
+        const parsedIncluded = this._parseAndFormatMessages(messages, format);
         return {
           messages: parsedIncluded,
           total: parsedIncluded.length,
-          page: page2,
+          page,
           perPage,
           hasMore: false
         };
       }
-      const excludeIds = messages2.map((m) => m.id);
+      const excludeIds = messages.map((m) => m.id);
       if (excludeIds.length > 0) {
         const excludeParams = excludeIds.map((_, idx) => `@id${idx}`);
         conditions.push(`id NOT IN (${excludeParams.join(", ")})`);
         excludeIds.forEach((id, idx) => request.input(`id${idx}`, id));
       }
       const finalWhereClause = `WHERE ${conditions.join(" AND ")}`;
-      const dataQuery = `${selectStatement} FROM ${getTableName({ indexName: TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })} ${finalWhereClause} ${orderByStatement2} OFFSET @offset ROWS FETCH NEXT @limit ROWS ONLY`;
+      const dataQuery = `${selectStatement} FROM ${getTableName({ indexName: TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })} ${finalWhereClause} ${orderByStatement} OFFSET @offset ROWS FETCH NEXT @limit ROWS ONLY`;
       request.input("offset", currentOffset);
       request.input("limit", perPage);
       const rowsResult = await request.query(dataQuery);
       const rows = rowsResult.recordset || [];
       rows.sort((a, b) => a.seq_id - b.seq_id);
-      messages2.push(...rows);
-      const parsed = this._parseAndFormatMessages(messages2, format);
+      messages.push(...rows);
+      const parsed = this._parseAndFormatMessages(messages, format);
       return {
         messages: parsed,
         total: total + excludeIds.length,
-        page: page2,
+        page,
         perPage,
         hasMore: currentOffset + rows.length < total
       };
@@ -660,6 +698,7 @@ var MemoryMSSQL = class extends MemoryStorage {
           category: ErrorCategory.THIRD_PARTY,
           details: {
             threadId,
+            resourceId: resourceId ?? "",
             page
           }
         },
@@ -1832,6 +1871,22 @@ var WorkflowsMSSQL = class extends WorkflowsStorage {
     this.operations = operations;
     this.schema = schema;
   }
+  updateWorkflowResults({
+    // workflowName,
+    // runId,
+    // stepId,
+    // result,
+    // runtimeContext,
+  }) {
+    throw new Error("Method not implemented.");
+  }
+  updateWorkflowState({
+    // workflowName,
+    // runId,
+    // opts,
+  }) {
+    throw new Error("Method not implemented.");
+  }
   async persistWorkflowSnapshot({
     workflowName,
     runId,
@@ -2183,6 +2238,12 @@ var MSSQLStore = class extends MastraStorage {
   async getMessages(args) {
     return this.stores.memory.getMessages(args);
   }
+  async getMessagesById({
+    messageIds,
+    format
+  }) {
+    return this.stores.memory.getMessagesById({ messageIds, format });
+  }
   async getMessagesPaginated(args) {
     return this.stores.memory.getMessagesPaginated(args);
   }
@@ -2213,6 +2274,22 @@ var MSSQLStore = class extends MastraStorage {
   /**
    * Workflows
    */
+  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,