@mastra/mssql 0.0.0-roamin-openaivoice-speak-options-passing-20250926163614 → 0.0.0-safe-stringify-telemetry-20251205024938

package/dist/index.cjs

@@ -2,13 +2,15 @@
 
 var error = require('@mastra/core/error');
 var storage = require('@mastra/core/storage');
-var sql2 = require('mssql');
+var sql3 = require('mssql');
 var utils = require('@mastra/core/utils');
 var agent = require('@mastra/core/agent');
+var crypto = require('crypto');
+var scores = require('@mastra/core/scores');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var sql2__default = /*#__PURE__*/_interopDefault(sql2);
+var sql3__default = /*#__PURE__*/_interopDefault(sql3);
 
 // src/storage/index.ts
 function getSchemaName(schema) {
@@ -20,6 +22,69 @@ function getTableName({ indexName, schemaName }) {
   const quotedSchemaName = schemaName;
   return quotedSchemaName ? `${quotedSchemaName}.${quotedIndexName}` : quotedIndexName;
 }
+function buildDateRangeFilter(dateRange, fieldName) {
+  const filters = {};
+  if (dateRange?.start) {
+    filters[`${fieldName}_gte`] = dateRange.start;
+  }
+  if (dateRange?.end) {
+    filters[`${fieldName}_lte`] = dateRange.end;
+  }
+  return filters;
+}
+function prepareWhereClause(filters, _schema) {
+  const conditions = [];
+  const params = {};
+  let paramIndex = 1;
+  Object.entries(filters).forEach(([key, value]) => {
+    if (value === void 0) return;
+    const paramName = `p${paramIndex++}`;
+    if (key.endsWith("_gte")) {
+      const fieldName = key.slice(0, -4);
+      conditions.push(`[${utils.parseSqlIdentifier(fieldName, "field name")}] >= @${paramName}`);
+      params[paramName] = value instanceof Date ? value.toISOString() : value;
+    } else if (key.endsWith("_lte")) {
+      const fieldName = key.slice(0, -4);
+      conditions.push(`[${utils.parseSqlIdentifier(fieldName, "field name")}] <= @${paramName}`);
+      params[paramName] = value instanceof Date ? value.toISOString() : value;
+    } else if (value === null) {
+      conditions.push(`[${utils.parseSqlIdentifier(key, "field name")}] IS NULL`);
+    } else {
+      conditions.push(`[${utils.parseSqlIdentifier(key, "field name")}] = @${paramName}`);
+      params[paramName] = value instanceof Date ? value.toISOString() : value;
+    }
+  });
+  return {
+    sql: conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "",
+    params
+  };
+}
+function transformFromSqlRow({
+  tableName,
+  sqlRow
+}) {
+  const schema = storage.TABLE_SCHEMAS[tableName];
+  const result = {};
+  Object.entries(sqlRow).forEach(([key, value]) => {
+    const columnSchema = schema?.[key];
+    if (columnSchema?.type === "jsonb" && typeof value === "string") {
+      try {
+        result[key] = JSON.parse(value);
+      } catch {
+        result[key] = value;
+      }
+    } else if (columnSchema?.type === "timestamp" && value && typeof value === "string") {
+      result[key] = new Date(value);
+    } else if (columnSchema?.type === "timestamp" && value instanceof Date) {
+      result[key] = value;
+    } else if (columnSchema?.type === "boolean") {
+      result[key] = Boolean(value);
+    } else {
+      result[key] = value;
+    }
+  });
+  return result;
+}
 
 // src/storage/domains/legacy-evals/index.ts
 function transformEvalRow(row) {
@@ -30,7 +95,7 @@ function transformEvalRow(row) {
     } catch {
     }
   }
-  if (row.test_info) {
+  if (row.result) {
     try {
       resultValue = typeof row.result === "string" ? JSON.parse(row.result) : row.result;
     } catch {
@@ -76,7 +141,7 @@ var LegacyEvalsMSSQL = class extends storage.LegacyEvalsStorage {
       if (error && error.number === 208 && error.message && error.message.includes("Invalid object name")) {
         return [];
       }
-      console.error("Failed to get evals for the specified agent: " + error?.message);
+      this.logger?.error?.("Failed to get evals for the specified agent:", error);
       throw error;
     }
   }
@@ -112,7 +177,7 @@ var LegacyEvalsMSSQL = class extends storage.LegacyEvalsStorage {
       const countReq = this.pool.request();
       Object.entries(params).forEach(([key, value]) => {
         if (value instanceof Date) {
-          countReq.input(key, sql2__default.default.DateTime, value);
+          countReq.input(key, sql3__default.default.DateTime, value);
         } else {
           countReq.input(key, value);
         }
@@ -131,7 +196,7 @@ var LegacyEvalsMSSQL = class extends storage.LegacyEvalsStorage {
       const req = this.pool.request();
       Object.entries(params).forEach(([key, value]) => {
         if (value instanceof Date) {
-          req.input(key, sql2__default.default.DateTime, value);
+          req.input(key, sql3__default.default.DateTime, value);
         } else {
           req.input(key, value);
         }
@@ -163,7 +228,7 @@ var LegacyEvalsMSSQL = class extends storage.LegacyEvalsStorage {
         error$1
       );
       this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
+      this.logger?.trackException?.(mastraError);
       throw mastraError;
     }
   }
@@ -256,7 +321,8 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
         };
       }
       const orderByField = orderBy === "createdAt" ? "[createdAt]" : "[updatedAt]";
-      const dataQuery = `SELECT id, [resourceId], title, metadata, [createdAt], [updatedAt] ${baseQuery} ORDER BY ${orderByField} ${sortDirection} OFFSET @offset ROWS FETCH NEXT @perPage ROWS ONLY`;
+      const dir = (sortDirection || "DESC").toUpperCase() === "ASC" ? "ASC" : "DESC";
+      const dataQuery = `SELECT id, [resourceId], title, metadata, [createdAt], [updatedAt] ${baseQuery} ORDER BY ${orderByField} ${dir} OFFSET @offset ROWS FETCH NEXT @perPage ROWS ONLY`;
       const dataRequest = this.pool.request();
       dataRequest.input("resourceId", resourceId);
       dataRequest.input("perPage", perPage);
@@ -313,9 +379,14 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
       req.input("id", thread.id);
       req.input("resourceId", thread.resourceId);
       req.input("title", thread.title);
-      req.input("metadata", thread.metadata ? JSON.stringify(thread.metadata) : null);
-      req.input("createdAt", sql2__default.default.DateTime2, thread.createdAt);
-      req.input("updatedAt", sql2__default.default.DateTime2, thread.updatedAt);
+      const metadata = thread.metadata ? JSON.stringify(thread.metadata) : null;
+      if (metadata === null) {
+        req.input("metadata", sql3__default.default.NVarChar, null);
+      } else {
+        req.input("metadata", metadata);
+      }
+      req.input("createdAt", sql3__default.default.DateTime2, thread.createdAt);
+      req.input("updatedAt", sql3__default.default.DateTime2, thread.updatedAt);
       await req.query(mergeSql);
       return thread;
     } catch (error$1) {
@@ -340,7 +411,8 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
     try {
       const baseQuery = `FROM ${getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) })} WHERE [resourceId] = @resourceId`;
       const orderByField = orderBy === "createdAt" ? "[createdAt]" : "[updatedAt]";
-      const dataQuery = `SELECT id, [resourceId], title, metadata, [createdAt], [updatedAt] ${baseQuery} ORDER BY ${orderByField} ${sortDirection}`;
+      const dir = (sortDirection || "DESC").toUpperCase() === "ASC" ? "ASC" : "DESC";
+      const dataQuery = `SELECT id, [resourceId], title, metadata, [createdAt], [updatedAt] ${baseQuery} ORDER BY ${orderByField} ${dir}`;
       const request = this.pool.request();
       request.input("resourceId", resourceId);
       const resultSet = await request.query(dataQuery);
@@ -589,7 +661,7 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
         error$1
       );
       this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
+      this.logger?.trackException?.(mastraError);
       return [];
     }
   }
@@ -629,7 +701,7 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
         error$1
       );
       this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
+      this.logger?.trackException?.(mastraError);
       return [];
     }
   }
@@ -688,10 +760,11 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
       const rows = rowsResult.recordset || [];
       rows.sort((a, b) => a.seq_id - b.seq_id);
       messages.push(...rows);
-      const parsed = this._parseAndFormatMessages(messages, format);
+      let parsed = this._parseAndFormatMessages(messages, format);
+      parsed = parsed.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
       return {
         messages: parsed,
-        total: total + excludeIds.length,
+        total,
         page,
         perPage,
         hasMore: currentOffset + rows.length < total
@@ -711,7 +784,7 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
         error$1
       );
       this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
+      this.logger?.trackException?.(mastraError);
       return { messages: [], total: 0, page, perPage: perPageInput || 40, hasMore: false };
     }
   }
@@ -763,7 +836,7 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
             "content",
             typeof message.content === "string" ? message.content : JSON.stringify(message.content)
           );
-          request.input("createdAt", sql2__default.default.DateTime2, message.createdAt);
+          request.input("createdAt", sql3__default.default.DateTime2, message.createdAt);
           request.input("role", message.role);
           request.input("type", message.type || "v2");
           request.input("resourceId", message.resourceId);
@@ -782,7 +855,7 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
           await request.query(mergeSql);
         }
         const threadReq = transaction.request();
-        threadReq.input("updatedAt", sql2__default.default.DateTime2, /* @__PURE__ */ new Date());
+        threadReq.input("updatedAt", sql3__default.default.DateTime2, /* @__PURE__ */ new Date());
         threadReq.input("id", threadId);
         await threadReq.query(`UPDATE ${tableThreads} SET [updatedAt] = @updatedAt WHERE id = @id`);
         await transaction.commit();
@@ -978,8 +1051,10 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
         return null;
       }
       return {
-        ...result,
-        workingMemory: typeof result.workingMemory === "object" ? JSON.stringify(result.workingMemory) : result.workingMemory,
+        id: result.id,
+        createdAt: result.createdAt,
+        updatedAt: result.updatedAt,
+        workingMemory: result.workingMemory,
         metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
       };
     } catch (error$1) {
@@ -993,7 +1068,7 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
         error$1
       );
       this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
+      this.logger?.trackException?.(mastraError);
       throw mastraError;
     }
   }
@@ -1002,7 +1077,7 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
       tableName: storage.TABLE_RESOURCES,
       record: {
         ...resource,
-        metadata: JSON.stringify(resource.metadata)
+        metadata: resource.metadata
       }
     });
     return resource;
@@ -1060,20 +1135,337 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
         error$1
       );
       this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
+      this.logger?.trackException?.(mastraError);
       throw mastraError;
     }
   }
 };
+var ObservabilityMSSQL = class extends storage.ObservabilityStorage {
+  pool;
+  operations;
+  schema;
+  constructor({
+    pool,
+    operations,
+    schema
+  }) {
+    super();
+    this.pool = pool;
+    this.operations = operations;
+    this.schema = schema;
+  }
+  get aiTracingStrategy() {
+    return {
+      preferred: "batch-with-updates",
+      supported: ["batch-with-updates", "insert-only"]
+    };
+  }
+  async createAISpan(span) {
+    try {
+      const startedAt = span.startedAt instanceof Date ? span.startedAt.toISOString() : span.startedAt;
+      const endedAt = span.endedAt instanceof Date ? span.endedAt.toISOString() : span.endedAt;
+      const record = {
+        ...span,
+        startedAt,
+        endedAt
+        // Note: createdAt/updatedAt will be set by default values
+      };
+      return this.operations.insert({ tableName: storage.TABLE_AI_SPANS, record });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MSSQL_STORE_CREATE_AI_SPAN_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            spanId: span.spanId,
+            traceId: span.traceId,
+            spanType: span.spanType,
+            spanName: span.name
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async getAITrace(traceId) {
+    try {
+      const tableName = getTableName({
+        indexName: storage.TABLE_AI_SPANS,
+        schemaName: getSchemaName(this.schema)
+      });
+      const request = this.pool.request();
+      request.input("traceId", traceId);
+      const result = await request.query(
+        `SELECT
+          [traceId], [spanId], [parentSpanId], [name], [scope], [spanType],
+          [attributes], [metadata], [links], [input], [output], [error], [isEvent],
+          [startedAt], [endedAt], [createdAt], [updatedAt]
+        FROM ${tableName}
+        WHERE [traceId] = @traceId
+        ORDER BY [startedAt] DESC`
+      );
+      if (!result.recordset || result.recordset.length === 0) {
+        return null;
+      }
+      return {
+        traceId,
+        spans: result.recordset.map(
+          (span) => transformFromSqlRow({
+            tableName: storage.TABLE_AI_SPANS,
+            sqlRow: span
+          })
+        )
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MSSQL_STORE_GET_AI_TRACE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            traceId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async updateAISpan({
+    spanId,
+    traceId,
+    updates
+  }) {
+    try {
+      const data = { ...updates };
+      if (data.endedAt instanceof Date) {
+        data.endedAt = data.endedAt.toISOString();
+      }
+      if (data.startedAt instanceof Date) {
+        data.startedAt = data.startedAt.toISOString();
+      }
+      await this.operations.update({
+        tableName: storage.TABLE_AI_SPANS,
+        keys: { spanId, traceId },
+        data
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MSSQL_STORE_UPDATE_AI_SPAN_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            spanId,
+            traceId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async getAITracesPaginated({
+    filters,
+    pagination
+  }) {
+    const page = pagination?.page ?? 0;
+    const perPage = pagination?.perPage ?? 10;
+    const { entityId, entityType, ...actualFilters } = filters || {};
+    const filtersWithDateRange = {
+      ...actualFilters,
+      ...buildDateRangeFilter(pagination?.dateRange, "startedAt"),
+      parentSpanId: null
+      // Only get root spans for traces
+    };
+    const whereClause = prepareWhereClause(filtersWithDateRange);
+    let actualWhereClause = whereClause.sql;
+    const params = { ...whereClause.params };
+    let currentParamIndex = Object.keys(params).length + 1;
+    if (entityId && entityType) {
+      let name = "";
+      if (entityType === "workflow") {
+        name = `workflow run: '${entityId}'`;
+      } else if (entityType === "agent") {
+        name = `agent run: '${entityId}'`;
+      } else {
+        const error$1 = new error.MastraError({
+          id: "MSSQL_STORE_GET_AI_TRACES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            entityType
+          },
+          text: `Cannot filter by entity type: ${entityType}`
+        });
+        throw error$1;
+      }
+      const entityParam = `p${currentParamIndex++}`;
+      if (actualWhereClause) {
+        actualWhereClause += ` AND [name] = @${entityParam}`;
+      } else {
+        actualWhereClause = ` WHERE [name] = @${entityParam}`;
+      }
+      params[entityParam] = name;
+    }
+    const tableName = getTableName({
+      indexName: storage.TABLE_AI_SPANS,
+      schemaName: getSchemaName(this.schema)
+    });
+    try {
+      const countRequest = this.pool.request();
+      Object.entries(params).forEach(([key, value]) => {
+        countRequest.input(key, value);
+      });
+      const countResult = await countRequest.query(
+        `SELECT COUNT(*) as count FROM ${tableName}${actualWhereClause}`
+      );
+      const total = countResult.recordset[0]?.count ?? 0;
+      if (total === 0) {
+        return {
+          pagination: {
+            total: 0,
+            page,
+            perPage,
+            hasMore: false
+          },
+          spans: []
+        };
+      }
+      const dataRequest = this.pool.request();
+      Object.entries(params).forEach(([key, value]) => {
+        dataRequest.input(key, value);
+      });
+      dataRequest.input("offset", page * perPage);
+      dataRequest.input("limit", perPage);
+      const dataResult = await dataRequest.query(
+        `SELECT * FROM ${tableName}${actualWhereClause} ORDER BY [startedAt] DESC OFFSET @offset ROWS FETCH NEXT @limit ROWS ONLY`
+      );
+      const spans = dataResult.recordset.map(
+        (row) => transformFromSqlRow({
+          tableName: storage.TABLE_AI_SPANS,
+          sqlRow: row
+        })
+      );
+      return {
+        pagination: {
+          total,
+          page,
+          perPage,
+          hasMore: (page + 1) * perPage < total
+        },
+        spans
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MSSQL_STORE_GET_AI_TRACES_PAGINATED_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        error$1
+      );
+    }
+  }
+  async batchCreateAISpans(args) {
+    if (!args.records || args.records.length === 0) {
+      return;
+    }
+    try {
+      await this.operations.batchInsert({
+        tableName: storage.TABLE_AI_SPANS,
+        records: args.records.map((span) => ({
+          ...span,
+          startedAt: span.startedAt instanceof Date ? span.startedAt.toISOString() : span.startedAt,
+          endedAt: span.endedAt instanceof Date ? span.endedAt.toISOString() : span.endedAt
+        }))
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MSSQL_STORE_BATCH_CREATE_AI_SPANS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            count: args.records.length
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async batchUpdateAISpans(args) {
+    if (!args.records || args.records.length === 0) {
+      return;
+    }
+    try {
+      const updates = args.records.map(({ traceId, spanId, updates: data }) => {
+        const processedData = { ...data };
+        if (processedData.endedAt instanceof Date) {
+          processedData.endedAt = processedData.endedAt.toISOString();
+        }
+        if (processedData.startedAt instanceof Date) {
+          processedData.startedAt = processedData.startedAt.toISOString();
+        }
+        return {
+          keys: { spanId, traceId },
+          data: processedData
+        };
+      });
+      await this.operations.batchUpdate({
+        tableName: storage.TABLE_AI_SPANS,
+        updates
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MSSQL_STORE_BATCH_UPDATE_AI_SPANS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            count: args.records.length
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async batchDeleteAITraces(args) {
+    if (!args.traceIds || args.traceIds.length === 0) {
+      return;
+    }
+    try {
+      const keys = args.traceIds.map((traceId) => ({ traceId }));
+      await this.operations.batchDelete({
+        tableName: storage.TABLE_AI_SPANS,
+        keys
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MSSQL_STORE_BATCH_DELETE_AI_TRACES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            count: args.traceIds.length
+          }
+        },
+        error$1
+      );
+    }
+  }
+};
 var StoreOperationsMSSQL = class extends storage.StoreOperations {
   pool;
   schemaName;
   setupSchemaPromise = null;
   schemaSetupComplete = void 0;
-  getSqlType(type, isPrimaryKey = false) {
+  getSqlType(type, isPrimaryKey = false, useLargeStorage = false) {
     switch (type) {
       case "text":
-        return isPrimaryKey ? "NVARCHAR(255)" : "NVARCHAR(MAX)";
+        if (useLargeStorage) {
+          return "NVARCHAR(MAX)";
+        }
+        return isPrimaryKey ? "NVARCHAR(255)" : "NVARCHAR(400)";
       case "timestamp":
         return "DATETIME2(7)";
       case "uuid":
@@ -1086,6 +1478,8 @@ var StoreOperationsMSSQL = class extends storage.StoreOperations {
         return "BIGINT";
       case "float":
         return "FLOAT";
+      case "boolean":
+        return "BIT";
       default:
         throw new error.MastraError({
           id: "MASTRA_STORAGE_MSSQL_STORE_TYPE_NOT_SUPPORTED",
@@ -1148,20 +1542,26 @@ var StoreOperationsMSSQL = class extends storage.StoreOperations {
     }
     await this.setupSchemaPromise;
   }
-  async insert({ tableName, record }) {
+  async insert({
+    tableName,
+    record,
+    transaction
+  }) {
     try {
-      const columns = Object.keys(record).map((col) => utils.parseSqlIdentifier(col, "column name"));
-      const values = Object.values(record);
-      const paramNames = values.map((_, i) => `@param${i}`);
-      const insertSql = `INSERT INTO ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} (${columns.map((c) => `[${c}]`).join(", ")}) VALUES (${paramNames.join(", ")})`;
-      const request = this.pool.request();
-      values.forEach((value, i) => {
-        if (value instanceof Date) {
-          request.input(`param${i}`, sql2__default.default.DateTime2, value);
-        } else if (typeof value === "object" && value !== null) {
-          request.input(`param${i}`, JSON.stringify(value));
+      const columns = Object.keys(record);
+      const parsedColumns = columns.map((col) => utils.parseSqlIdentifier(col, "column name"));
+      const paramNames = columns.map((_, i) => `@param${i}`);
+      const insertSql = `INSERT INTO ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} (${parsedColumns.map((c) => `[${c}]`).join(", ")}) VALUES (${paramNames.join(", ")})`;
+      const request = transaction ? transaction.request() : this.pool.request();
+      columns.forEach((col, i) => {
+        const value = record[col];
+        const preparedValue = this.prepareValue(value, col, tableName);
+        if (preparedValue instanceof Date) {
+          request.input(`param${i}`, sql3__default.default.DateTime2, preparedValue);
+        } else if (preparedValue === null || preparedValue === void 0) {
+          request.input(`param${i}`, this.getMssqlType(tableName, col), null);
         } else {
-          request.input(`param${i}`, value);
+          request.input(`param${i}`, preparedValue);
         }
       });
       await request.query(insertSql);
@@ -1185,7 +1585,7 @@ var StoreOperationsMSSQL = class extends storage.StoreOperations {
       try {
         await this.pool.request().query(`TRUNCATE TABLE ${fullTableName}`);
       } catch (truncateError) {
-        if (truncateError.message && truncateError.message.includes("foreign key")) {
+        if (truncateError?.number === 4712) {
           await this.pool.request().query(`DELETE FROM ${fullTableName}`);
         } else {
           throw truncateError;
@@ -1208,9 +1608,11 @@ var StoreOperationsMSSQL = class extends storage.StoreOperations {
   getDefaultValue(type) {
     switch (type) {
       case "timestamp":
-        return "DEFAULT SYSDATETIMEOFFSET()";
+        return "DEFAULT SYSUTCDATETIME()";
       case "jsonb":
         return "DEFAULT N'{}'";
+      case "boolean":
+        return "DEFAULT 0";
       default:
         return super.getDefaultValue(type);
     }
@@ -1221,13 +1623,29 @@ var StoreOperationsMSSQL = class extends storage.StoreOperations {
   }) {
     try {
       const uniqueConstraintColumns = tableName === storage.TABLE_WORKFLOW_SNAPSHOT ? ["workflow_name", "run_id"] : [];
+      const largeDataColumns = [
+        "workingMemory",
+        "snapshot",
+        "metadata",
+        "content",
+        // messages.content - can be very long conversation content
+        "input",
+        // evals.input - test input data
+        "output",
+        // evals.output - test output data
+        "instructions",
+        // evals.instructions - evaluation instructions
+        "other"
+        // traces.other - additional trace data
+      ];
       const columns = Object.entries(schema).map(([name, def]) => {
         const parsedName = utils.parseSqlIdentifier(name, "column name");
         const constraints = [];
         if (def.primaryKey) constraints.push("PRIMARY KEY");
         if (!def.nullable) constraints.push("NOT NULL");
         const isIndexed = !!def.primaryKey || uniqueConstraintColumns.includes(name);
-        return `[${parsedName}] ${this.getSqlType(def.type, isIndexed)} ${constraints.join(" ")}`.trim();
+        const useLargeStorage = largeDataColumns.includes(name);
+        return `[${parsedName}] ${this.getSqlType(def.type, isIndexed, useLargeStorage)} ${constraints.join(" ")}`.trim();
       }).join(",\n");
       if (this.schemaName) {
         await this.setupSchema();
@@ -1314,7 +1732,19 @@ ${columns}
           const columnExists = Array.isArray(checkResult.recordset) && checkResult.recordset.length > 0;
           if (!columnExists) {
             const columnDef = schema[columnName];
-            const sqlType = this.getSqlType(columnDef.type);
+            const largeDataColumns = [
+              "workingMemory",
+              "snapshot",
+              "metadata",
+              "content",
+              "input",
+              "output",
+              "instructions",
+              "other"
+            ];
+            const useLargeStorage = largeDataColumns.includes(columnName);
+            const isIndexed = !!columnDef.primaryKey;
+            const sqlType = this.getSqlType(columnDef.type, isIndexed, useLargeStorage);
             const nullable = columnDef.nullable === false ? "NOT NULL" : "";
             const defaultValue = columnDef.nullable === false ? this.getDefaultValue(columnDef.type) : "";
             const parsedColumnName = utils.parseSqlIdentifier(columnName, "column name");
@@ -1342,11 +1772,15 @@ ${columns}
     try {
       const keyEntries = Object.entries(keys).map(([key, value]) => [utils.parseSqlIdentifier(key, "column name"), value]);
       const conditions = keyEntries.map(([key], i) => `[${key}] = @param${i}`).join(" AND ");
-      const values = keyEntries.map(([_, value]) => value);
       const sql7 = `SELECT * FROM ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} WHERE ${conditions}`;
       const request = this.pool.request();
-      values.forEach((value, i) => {
-        request.input(`param${i}`, value);
+      keyEntries.forEach(([key, value], i) => {
+        const preparedValue = this.prepareValue(value, key, tableName);
+        if (preparedValue === null || preparedValue === void 0) {
+          request.input(`param${i}`, this.getMssqlType(tableName, key), null);
+        } else {
+          request.input(`param${i}`, preparedValue);
+        }
       });
       const resultSet = await request.query(sql7);
       const result = resultSet.recordset[0] || null;
@@ -1380,7 +1814,7 @@ ${columns}
     try {
       await transaction.begin();
       for (const record of records) {
-        await this.insert({ tableName, record });
+        await this.insert({ tableName, record, transaction });
       }
       await transaction.commit();
     } catch (error$1) {
@@ -1417,69 +1851,637 @@ ${columns}
       );
     }
   }
-};
-function parseJSON(jsonString) {
-  try {
-    return JSON.parse(jsonString);
-  } catch {
-    return jsonString;
-  }
-}
-function transformScoreRow(row) {
-  return {
-    ...row,
-    input: parseJSON(row.input),
-    scorer: parseJSON(row.scorer),
-    preprocessStepResult: parseJSON(row.preprocessStepResult),
-    analyzeStepResult: parseJSON(row.analyzeStepResult),
-    metadata: parseJSON(row.metadata),
-    output: parseJSON(row.output),
-    additionalContext: parseJSON(row.additionalContext),
-    runtimeContext: parseJSON(row.runtimeContext),
-    entity: parseJSON(row.entity),
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt
-  };
-}
-var ScoresMSSQL = class extends storage.ScoresStorage {
-  pool;
-  operations;
-  schema;
-  constructor({
-    pool,
-    operations,
-    schema
-  }) {
-    super();
-    this.pool = pool;
-    this.operations = operations;
-    this.schema = schema;
-  }
-  async getScoreById({ id }) {
-    try {
-      const request = this.pool.request();
-      request.input("p1", id);
-      const result = await request.query(
-        `SELECT * FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName(this.schema) })} WHERE id = @p1`
-      );
-      if (result.recordset.length === 0) {
-        return null;
+  /**
+   * Prepares a value for database operations, handling Date objects and JSON serialization
+   */
+  prepareValue(value, columnName, tableName) {
+    if (value === null || value === void 0) {
+      return value;
+    }
+    if (value instanceof Date) {
+      return value;
+    }
+    const schema = storage.TABLE_SCHEMAS[tableName];
+    const columnSchema = schema?.[columnName];
+    if (columnSchema?.type === "boolean") {
+      return value ? 1 : 0;
+    }
+    if (columnSchema?.type === "jsonb") {
+      if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed.length > 0) {
+          try {
+            JSON.parse(trimmed);
+            return trimmed;
+          } catch {
+          }
+        }
+        return JSON.stringify(value);
       }
-      return transformScoreRow(result.recordset[0]);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_MSSQL_STORE_GET_SCORE_BY_ID_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { id }
-        },
-        error$1
-      );
+      if (typeof value === "bigint") {
+        return value.toString();
+      }
+      return JSON.stringify(value);
+    }
+    if (typeof value === "object") {
+      return JSON.stringify(value);
     }
+    return value;
   }
-  async saveScore(score) {
-    try {
+  /**
+   * Maps TABLE_SCHEMAS types to mssql param types (used when value is null)
+   */
+  getMssqlType(tableName, columnName) {
+    const col = storage.TABLE_SCHEMAS[tableName]?.[columnName];
+    switch (col?.type) {
+      case "text":
+        return sql3__default.default.NVarChar;
+      case "timestamp":
+        return sql3__default.default.DateTime2;
+      case "uuid":
+        return sql3__default.default.UniqueIdentifier;
+      case "jsonb":
+        return sql3__default.default.NVarChar;
+      case "integer":
+        return sql3__default.default.Int;
+      case "bigint":
+        return sql3__default.default.BigInt;
+      case "float":
+        return sql3__default.default.Float;
+      case "boolean":
+        return sql3__default.default.Bit;
+      default:
+        return sql3__default.default.NVarChar;
+    }
+  }
+  /**
+   * Update a single record in the database
+   */
+  async update({
+    tableName,
+    keys,
+    data,
+    transaction
+  }) {
+    try {
+      if (!data || Object.keys(data).length === 0) {
+        throw new error.MastraError({
+          id: "MASTRA_STORAGE_MSSQL_UPDATE_EMPTY_DATA",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: "Cannot update with empty data payload"
+        });
+      }
+      if (!keys || Object.keys(keys).length === 0) {
+        throw new error.MastraError({
+          id: "MASTRA_STORAGE_MSSQL_UPDATE_EMPTY_KEYS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: "Cannot update without keys to identify records"
+        });
+      }
+      const setClauses = [];
+      const request = transaction ? transaction.request() : this.pool.request();
+      let paramIndex = 0;
+      Object.entries(data).forEach(([key, value]) => {
+        const parsedKey = utils.parseSqlIdentifier(key, "column name");
+        const paramName = `set${paramIndex++}`;
+        setClauses.push(`[${parsedKey}] = @${paramName}`);
+        const preparedValue = this.prepareValue(value, key, tableName);
+        if (preparedValue === null || preparedValue === void 0) {
+          request.input(paramName, this.getMssqlType(tableName, key), null);
+        } else {
+          request.input(paramName, preparedValue);
+        }
+      });
+      const whereConditions = [];
+      Object.entries(keys).forEach(([key, value]) => {
+        const parsedKey = utils.parseSqlIdentifier(key, "column name");
+        const paramName = `where${paramIndex++}`;
+        whereConditions.push(`[${parsedKey}] = @${paramName}`);
+        const preparedValue = this.prepareValue(value, key, tableName);
+        if (preparedValue === null || preparedValue === void 0) {
+          request.input(paramName, this.getMssqlType(tableName, key), null);
+        } else {
+          request.input(paramName, preparedValue);
+        }
+      });
+      const tableName_ = getTableName({
+        indexName: tableName,
+        schemaName: getSchemaName(this.schemaName)
+      });
+      const updateSql = `UPDATE ${tableName_} SET ${setClauses.join(", ")} WHERE ${whereConditions.join(" AND ")}`;
+      await request.query(updateSql);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_UPDATE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  /**
+   * Update multiple records in a single batch transaction
+   */
+  async batchUpdate({
+    tableName,
+    updates
+  }) {
+    const transaction = this.pool.transaction();
+    try {
+      await transaction.begin();
+      for (const { keys, data } of updates) {
+        await this.update({ tableName, keys, data, transaction });
+      }
+      await transaction.commit();
+    } catch (error$1) {
+      await transaction.rollback();
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_BATCH_UPDATE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName,
+            numberOfRecords: updates.length
+          }
+        },
+        error$1
+      );
+    }
+  }
+  /**
+   * Delete multiple records by keys
+   */
+  async batchDelete({ tableName, keys }) {
+    if (keys.length === 0) {
+      return;
+    }
+    const tableName_ = getTableName({
+      indexName: tableName,
+      schemaName: getSchemaName(this.schemaName)
+    });
+    const transaction = this.pool.transaction();
+    try {
+      await transaction.begin();
+      for (const keySet of keys) {
+        const conditions = [];
+        const request = transaction.request();
+        let paramIndex = 0;
+        Object.entries(keySet).forEach(([key, value]) => {
+          const parsedKey = utils.parseSqlIdentifier(key, "column name");
+          const paramName = `p${paramIndex++}`;
+          conditions.push(`[${parsedKey}] = @${paramName}`);
+          const preparedValue = this.prepareValue(value, key, tableName);
+          if (preparedValue === null || preparedValue === void 0) {
+            request.input(paramName, this.getMssqlType(tableName, key), null);
+          } else {
+            request.input(paramName, preparedValue);
+          }
+        });
+        const deleteSql = `DELETE FROM ${tableName_} WHERE ${conditions.join(" AND ")}`;
+        await request.query(deleteSql);
+      }
+      await transaction.commit();
+    } catch (error$1) {
+      await transaction.rollback();
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_BATCH_DELETE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName,
+            numberOfRecords: keys.length
+          }
+        },
+        error$1
+      );
+    }
+  }
+  /**
+   * Create a new index on a table
+   */
+  async createIndex(options) {
+    try {
+      const { name, table, columns, unique = false, where } = options;
+      const schemaName = this.schemaName || "dbo";
+      const fullTableName = getTableName({
+        indexName: table,
+        schemaName: getSchemaName(this.schemaName)
+      });
+      const indexNameSafe = utils.parseSqlIdentifier(name, "index name");
+      const checkRequest = this.pool.request();
+      checkRequest.input("indexName", indexNameSafe);
+      checkRequest.input("schemaName", schemaName);
+      checkRequest.input("tableName", table);
+      const indexExists = await checkRequest.query(`
+        SELECT 1 as found
+        FROM sys.indexes i
+        INNER JOIN sys.tables t ON i.object_id = t.object_id
+        INNER JOIN sys.schemas s ON t.schema_id = s.schema_id
+        WHERE i.name = @indexName
+          AND s.name = @schemaName
+          AND t.name = @tableName
+      `);
+      if (indexExists.recordset && indexExists.recordset.length > 0) {
+        return;
+      }
+      const uniqueStr = unique ? "UNIQUE " : "";
+      const columnsStr = columns.map((col) => {
+        if (col.includes(" DESC") || col.includes(" ASC")) {
+          const [colName, ...modifiers] = col.split(" ");
+          if (!colName) {
+            throw new Error(`Invalid column specification: ${col}`);
+          }
+          return `[${utils.parseSqlIdentifier(colName, "column name")}] ${modifiers.join(" ")}`;
+        }
+        return `[${utils.parseSqlIdentifier(col, "column name")}]`;
+      }).join(", ");
+      const whereStr = where ? ` WHERE ${where}` : "";
+      const createIndexSql = `CREATE ${uniqueStr}INDEX [${indexNameSafe}] ON ${fullTableName} (${columnsStr})${whereStr}`;
+      await this.pool.request().query(createIndexSql);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_INDEX_CREATE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName: options.name,
+            tableName: options.table
+          }
+        },
+        error$1
+      );
+    }
+  }
+  /**
+   * Drop an existing index
+   */
+  async dropIndex(indexName) {
+    try {
+      const schemaName = this.schemaName || "dbo";
+      const indexNameSafe = utils.parseSqlIdentifier(indexName, "index name");
+      const checkRequest = this.pool.request();
+      checkRequest.input("indexName", indexNameSafe);
+      checkRequest.input("schemaName", schemaName);
+      const result = await checkRequest.query(`
+        SELECT t.name as table_name
+        FROM sys.indexes i
+        INNER JOIN sys.tables t ON i.object_id = t.object_id
+        INNER JOIN sys.schemas s ON t.schema_id = s.schema_id
+        WHERE i.name = @indexName
+          AND s.name = @schemaName
+      `);
+      if (!result.recordset || result.recordset.length === 0) {
+        return;
+      }
+      if (result.recordset.length > 1) {
+        const tables = result.recordset.map((r) => r.table_name).join(", ");
+        throw new error.MastraError({
+          id: "MASTRA_STORAGE_MSSQL_INDEX_AMBIGUOUS",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: `Index "${indexNameSafe}" exists on multiple tables (${tables}) in schema "${schemaName}". Please drop indexes manually or ensure unique index names.`
+        });
+      }
+      const tableName = result.recordset[0].table_name;
+      const fullTableName = getTableName({
+        indexName: tableName,
+        schemaName: getSchemaName(this.schemaName)
+      });
+      const dropSql = `DROP INDEX [${indexNameSafe}] ON ${fullTableName}`;
+      await this.pool.request().query(dropSql);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_INDEX_DROP_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  /**
+   * List indexes for a specific table or all tables
+   */
+  async listIndexes(tableName) {
+    try {
+      const schemaName = this.schemaName || "dbo";
+      let query;
+      const request = this.pool.request();
+      request.input("schemaName", schemaName);
+      if (tableName) {
+        query = `
+          SELECT 
+            i.name as name,
+            o.name as [table],
+            i.is_unique as is_unique,
+            CAST(SUM(s.used_page_count) * 8 / 1024.0 AS VARCHAR(50)) + ' MB' as size
+          FROM sys.indexes i
+          INNER JOIN sys.objects o ON i.object_id = o.object_id
+          INNER JOIN sys.schemas sch ON o.schema_id = sch.schema_id
+          LEFT JOIN sys.dm_db_partition_stats s ON i.object_id = s.object_id AND i.index_id = s.index_id
+          WHERE sch.name = @schemaName
+          AND o.name = @tableName
+          AND i.name IS NOT NULL
+          GROUP BY i.name, o.name, i.is_unique
+        `;
+        request.input("tableName", tableName);
+      } else {
+        query = `
+          SELECT 
+            i.name as name,
+            o.name as [table],
+            i.is_unique as is_unique,
+            CAST(SUM(s.used_page_count) * 8 / 1024.0 AS VARCHAR(50)) + ' MB' as size
+          FROM sys.indexes i
+          INNER JOIN sys.objects o ON i.object_id = o.object_id
+          INNER JOIN sys.schemas sch ON o.schema_id = sch.schema_id
+          LEFT JOIN sys.dm_db_partition_stats s ON i.object_id = s.object_id AND i.index_id = s.index_id
+          WHERE sch.name = @schemaName
+          AND i.name IS NOT NULL
+          GROUP BY i.name, o.name, i.is_unique
+        `;
+      }
+      const result = await request.query(query);
+      const indexes = [];
+      for (const row of result.recordset) {
+        const colRequest = this.pool.request();
+        colRequest.input("indexName", row.name);
+        colRequest.input("schemaName", schemaName);
+        const colResult = await colRequest.query(`
+          SELECT c.name as column_name
+          FROM sys.indexes i
+          INNER JOIN sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+          INNER JOIN sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+          INNER JOIN sys.objects o ON i.object_id = o.object_id
+          INNER JOIN sys.schemas s ON o.schema_id = s.schema_id
+          WHERE i.name = @indexName
+          AND s.name = @schemaName
+          ORDER BY ic.key_ordinal
+        `);
+        indexes.push({
+          name: row.name,
+          table: row.table,
+          columns: colResult.recordset.map((c) => c.column_name),
+          unique: row.is_unique || false,
+          size: row.size || "0 MB",
+          definition: ""
+          // MSSQL doesn't store definition like PG
+        });
+      }
+      return indexes;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_INDEX_LIST_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: tableName ? {
+            tableName
+          } : {}
+        },
+        error$1
+      );
+    }
+  }
+  /**
+   * Get detailed statistics for a specific index
+   */
+  async describeIndex(indexName) {
+    try {
+      const schemaName = this.schemaName || "dbo";
+      const request = this.pool.request();
+      request.input("indexName", indexName);
+      request.input("schemaName", schemaName);
+      const query = `
+        SELECT 
+          i.name as name,
+          o.name as [table],
+          i.is_unique as is_unique,
+          CAST(SUM(s.used_page_count) * 8 / 1024.0 AS VARCHAR(50)) + ' MB' as size,
+          i.type_desc as method,
+          ISNULL(us.user_scans, 0) as scans,
+          ISNULL(us.user_seeks + us.user_scans, 0) as tuples_read,
+          ISNULL(us.user_lookups, 0) as tuples_fetched
+        FROM sys.indexes i
+        INNER JOIN sys.objects o ON i.object_id = o.object_id
+        INNER JOIN sys.schemas sch ON o.schema_id = sch.schema_id
+        LEFT JOIN sys.dm_db_partition_stats s ON i.object_id = s.object_id AND i.index_id = s.index_id
+        LEFT JOIN sys.dm_db_index_usage_stats us ON i.object_id = us.object_id AND i.index_id = us.index_id
+        WHERE i.name = @indexName
+        AND sch.name = @schemaName
+        GROUP BY i.name, o.name, i.is_unique, i.type_desc, us.user_seeks, us.user_scans, us.user_lookups
+      `;
+      const result = await request.query(query);
+      if (!result.recordset || result.recordset.length === 0) {
+        throw new Error(`Index "${indexName}" not found in schema "${schemaName}"`);
+      }
+      const row = result.recordset[0];
+      const colRequest = this.pool.request();
+      colRequest.input("indexName", indexName);
+      colRequest.input("schemaName", schemaName);
+      const colResult = await colRequest.query(`
+        SELECT c.name as column_name
+        FROM sys.indexes i
+        INNER JOIN sys.index_columns ic ON i.object_id = ic.object_id AND i.index_id = ic.index_id
+        INNER JOIN sys.columns c ON ic.object_id = c.object_id AND ic.column_id = c.column_id
+        INNER JOIN sys.objects o ON i.object_id = o.object_id
+        INNER JOIN sys.schemas s ON o.schema_id = s.schema_id
+        WHERE i.name = @indexName
+        AND s.name = @schemaName
+        ORDER BY ic.key_ordinal
+      `);
+      return {
+        name: row.name,
+        table: row.table,
+        columns: colResult.recordset.map((c) => c.column_name),
+        unique: row.is_unique || false,
+        size: row.size || "0 MB",
+        definition: "",
+        method: row.method?.toLowerCase() || "nonclustered",
+        scans: Number(row.scans) || 0,
+        tuples_read: Number(row.tuples_read) || 0,
+        tuples_fetched: Number(row.tuples_fetched) || 0
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_INDEX_DESCRIBE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            indexName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  /**
+   * Returns definitions for automatic performance indexes
+   * IMPORTANT: Uses seq_id DESC instead of createdAt DESC for MSSQL due to millisecond accuracy limitations
+   * NOTE: Using NVARCHAR(400) for text columns (800 bytes) leaves room for composite indexes
+   */
+  getAutomaticIndexDefinitions() {
+    const schemaPrefix = this.schemaName ? `${this.schemaName}_` : "";
+    return [
+      // Composite indexes for optimal filtering + sorting performance
+      // NVARCHAR(400) = 800 bytes, plus BIGINT (8 bytes) = 808 bytes total (under 900-byte limit)
+      {
+        name: `${schemaPrefix}mastra_threads_resourceid_seqid_idx`,
+        table: storage.TABLE_THREADS,
+        columns: ["resourceId", "seq_id DESC"]
+      },
+      {
+        name: `${schemaPrefix}mastra_messages_thread_id_seqid_idx`,
+        table: storage.TABLE_MESSAGES,
+        columns: ["thread_id", "seq_id DESC"]
+      },
+      {
+        name: `${schemaPrefix}mastra_traces_name_seqid_idx`,
+        table: storage.TABLE_TRACES,
+        columns: ["name", "seq_id DESC"]
+      },
+      {
+        name: `${schemaPrefix}mastra_evals_agent_name_seqid_idx`,
+        table: storage.TABLE_EVALS,
+        columns: ["agent_name", "seq_id DESC"]
+      },
+      {
+        name: `${schemaPrefix}mastra_scores_trace_id_span_id_seqid_idx`,
+        table: storage.TABLE_SCORERS,
+        columns: ["traceId", "spanId", "seq_id DESC"]
+      },
+      // AI Spans indexes for optimal trace querying
+      {
+        name: `${schemaPrefix}mastra_ai_spans_traceid_startedat_idx`,
+        table: storage.TABLE_AI_SPANS,
+        columns: ["traceId", "startedAt DESC"]
+      },
+      {
+        name: `${schemaPrefix}mastra_ai_spans_parentspanid_startedat_idx`,
+        table: storage.TABLE_AI_SPANS,
+        columns: ["parentSpanId", "startedAt DESC"]
+      },
+      {
+        name: `${schemaPrefix}mastra_ai_spans_name_idx`,
+        table: storage.TABLE_AI_SPANS,
+        columns: ["name"]
+      },
+      {
+        name: `${schemaPrefix}mastra_ai_spans_spantype_startedat_idx`,
+        table: storage.TABLE_AI_SPANS,
+        columns: ["spanType", "startedAt DESC"]
+      }
+    ];
+  }
+  /**
+   * Creates automatic indexes for optimal query performance
+   * Uses getAutomaticIndexDefinitions() to determine which indexes to create
+   */
+  async createAutomaticIndexes() {
+    try {
+      const indexes = this.getAutomaticIndexDefinitions();
+      for (const indexOptions of indexes) {
+        try {
+          await this.createIndex(indexOptions);
+        } catch (error) {
+          this.logger?.warn?.(`Failed to create index ${indexOptions.name}:`, error);
+        }
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_CREATE_PERFORMANCE_INDEXES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+};
+function transformScoreRow(row) {
+  return {
+    ...row,
+    input: storage.safelyParseJSON(row.input),
+    scorer: storage.safelyParseJSON(row.scorer),
+    preprocessStepResult: storage.safelyParseJSON(row.preprocessStepResult),
+    analyzeStepResult: storage.safelyParseJSON(row.analyzeStepResult),
+    metadata: storage.safelyParseJSON(row.metadata),
+    output: storage.safelyParseJSON(row.output),
+    additionalContext: storage.safelyParseJSON(row.additionalContext),
+    runtimeContext: storage.safelyParseJSON(row.runtimeContext),
+    entity: storage.safelyParseJSON(row.entity),
+    createdAt: new Date(row.createdAt),
+    updatedAt: new Date(row.updatedAt)
+  };
+}
+var ScoresMSSQL = class extends storage.ScoresStorage {
+  pool;
+  operations;
+  schema;
+  constructor({
+    pool,
+    operations,
+    schema
+  }) {
+    super();
+    this.pool = pool;
+    this.operations = operations;
+    this.schema = schema;
+  }
+  async getScoreById({ id }) {
+    try {
+      const request = this.pool.request();
+      request.input("p1", id);
+      const result = await request.query(
+        `SELECT * FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName(this.schema) })} WHERE id = @p1`
+      );
+      if (result.recordset.length === 0) {
+        return null;
+      }
+      return transformScoreRow(result.recordset[0]);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_GET_SCORE_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async saveScore(score) {
+    let validatedScore;
+    try {
+      validatedScore = scores.saveScorePayloadSchema.parse(score);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_SAVE_SCORE_VALIDATION_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+    try {
       const scoreId = crypto.randomUUID();
       const {
         scorer,
@@ -1492,21 +2494,21 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
         runtimeContext,
         entity,
         ...rest
-      } = score;
+      } = validatedScore;
       await this.operations.insert({
         tableName: storage.TABLE_SCORERS,
         record: {
           id: scoreId,
           ...rest,
-          input: JSON.stringify(input) || "",
-          output: JSON.stringify(output) || "",
-          preprocessStepResult: preprocessStepResult ? JSON.stringify(preprocessStepResult) : null,
-          analyzeStepResult: analyzeStepResult ? JSON.stringify(analyzeStepResult) : null,
-          metadata: metadata ? JSON.stringify(metadata) : null,
-          additionalContext: additionalContext ? JSON.stringify(additionalContext) : null,
-          runtimeContext: runtimeContext ? JSON.stringify(runtimeContext) : null,
-          entity: entity ? JSON.stringify(entity) : null,
-          scorer: scorer ? JSON.stringify(scorer) : null,
+          input: input || "",
+          output: output || "",
+          preprocessStepResult: preprocessStepResult || null,
+          analyzeStepResult: analyzeStepResult || null,
+          metadata: metadata || null,
+          additionalContext: additionalContext || null,
+          runtimeContext: runtimeContext || null,
+          entity: entity || null,
+          scorer: scorer || null,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           updatedAt: (/* @__PURE__ */ new Date()).toISOString()
         }
@@ -1526,14 +2528,37 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
   }
   async getScoresByScorerId({
     scorerId,
-    pagination
+    pagination,
+    entityId,
+    entityType,
+    source
   }) {
     try {
-      const request = this.pool.request();
-      request.input("p1", scorerId);
-      const totalResult = await request.query(
-        `SELECT COUNT(*) as count FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName(this.schema) })} WHERE [scorerId] = @p1`
-      );
+      const conditions = ["[scorerId] = @p1"];
+      const params = { p1: scorerId };
+      let paramIndex = 2;
+      if (entityId) {
+        conditions.push(`[entityId] = @p${paramIndex}`);
+        params[`p${paramIndex}`] = entityId;
+        paramIndex++;
+      }
+      if (entityType) {
+        conditions.push(`[entityType] = @p${paramIndex}`);
+        params[`p${paramIndex}`] = entityType;
+        paramIndex++;
+      }
+      if (source) {
+        conditions.push(`[source] = @p${paramIndex}`);
+        params[`p${paramIndex}`] = source;
+        paramIndex++;
+      }
+      const whereClause = conditions.join(" AND ");
+      const tableName = getTableName({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName(this.schema) });
+      const countRequest = this.pool.request();
+      Object.entries(params).forEach(([key, value]) => {
+        countRequest.input(key, value);
+      });
+      const totalResult = await countRequest.query(`SELECT COUNT(*) as count FROM ${tableName} WHERE ${whereClause}`);
       const total = totalResult.recordset[0]?.count || 0;
       if (total === 0) {
         return {
@@ -1547,12 +2572,13 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
         };
       }
       const dataRequest = this.pool.request();
-      dataRequest.input("p1", scorerId);
-      dataRequest.input("p2", pagination.perPage);
-      dataRequest.input("p3", pagination.page * pagination.perPage);
-      const result = await dataRequest.query(
-        `SELECT * FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName(this.schema) })} WHERE [scorerId] = @p1 ORDER BY [createdAt] DESC OFFSET @p3 ROWS FETCH NEXT @p2 ROWS ONLY`
-      );
+      Object.entries(params).forEach(([key, value]) => {
+        dataRequest.input(key, value);
+      });
+      dataRequest.input("perPage", pagination.perPage);
+      dataRequest.input("offset", pagination.page * pagination.perPage);
+      const dataQuery = `SELECT * FROM ${tableName} WHERE ${whereClause} ORDER BY [createdAt] DESC OFFSET @offset ROWS FETCH NEXT @perPage ROWS ONLY`;
+      const result = await dataRequest.query(dataQuery);
       return {
         pagination: {
           total: Number(total),
@@ -1677,6 +2703,60 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
       );
     }
   }
+  async getScoresBySpan({
+    traceId,
+    spanId,
+    pagination
+  }) {
+    try {
+      const request = this.pool.request();
+      request.input("p1", traceId);
+      request.input("p2", spanId);
+      const totalResult = await request.query(
+        `SELECT COUNT(*) as count FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName(this.schema) })} WHERE [traceId] = @p1 AND [spanId] = @p2`
+      );
+      const total = totalResult.recordset[0]?.count || 0;
+      if (total === 0) {
+        return {
+          pagination: {
+            total: 0,
+            page: pagination.page,
+            perPage: pagination.perPage,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const limit = pagination.perPage + 1;
+      const dataRequest = this.pool.request();
+      dataRequest.input("p1", traceId);
+      dataRequest.input("p2", spanId);
+      dataRequest.input("p3", limit);
+      dataRequest.input("p4", pagination.page * pagination.perPage);
+      const result = await dataRequest.query(
+        `SELECT * FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName(this.schema) })} WHERE [traceId] = @p1 AND [spanId] = @p2 ORDER BY [createdAt] DESC OFFSET @p4 ROWS FETCH NEXT @p3 ROWS ONLY`
+      );
+      return {
+        pagination: {
+          total: Number(total),
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: result.recordset.length > pagination.perPage
+        },
+        scores: result.recordset.slice(0, pagination.perPage).map((row) => transformScoreRow(row))
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_GET_SCORES_BY_SPAN_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { traceId, spanId }
+        },
+        error$1
+      );
+    }
+  }
 };
 var TracesMSSQL = class extends storage.TracesStorage {
   pool;
@@ -1755,7 +2835,7 @@ var TracesMSSQL = class extends storage.TracesStorage {
       const countRequest = this.pool.request();
       Object.entries(paramMap).forEach(([key, value]) => {
         if (value instanceof Date) {
-          countRequest.input(key, sql2__default.default.DateTime, value);
+          countRequest.input(key, sql3__default.default.DateTime, value);
         } else {
           countRequest.input(key, value);
         }
@@ -1789,7 +2869,7 @@ var TracesMSSQL = class extends storage.TracesStorage {
     const dataRequest = this.pool.request();
     Object.entries(paramMap).forEach(([key, value]) => {
       if (value instanceof Date) {
-        dataRequest.input(key, sql2__default.default.DateTime, value);
+        dataRequest.input(key, sql3__default.default.DateTime, value);
       } else {
         dataRequest.input(key, value);
       }
@@ -1845,24 +2925,6 @@ var TracesMSSQL = class extends storage.TracesStorage {
     });
   }
 };
-function parseWorkflowRun(row) {
-  let parsedSnapshot = row.snapshot;
-  if (typeof parsedSnapshot === "string") {
-    try {
-      parsedSnapshot = JSON.parse(row.snapshot);
-    } catch (e) {
-      console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
-    }
-  }
-  return {
-    workflowName: row.workflow_name,
-    runId: row.run_id,
-    snapshot: parsedSnapshot,
-    createdAt: row.createdAt,
-    updatedAt: row.updatedAt,
-    resourceId: row.resourceId
-  };
-}
 var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
   pool;
   operations;
@@ -1877,21 +2939,164 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
     this.operations = operations;
     this.schema = schema;
   }
-  updateWorkflowResults({
-    // workflowName,
-    // runId,
-    // stepId,
-    // result,
-    // runtimeContext,
+  parseWorkflowRun(row) {
+    let parsedSnapshot = row.snapshot;
+    if (typeof parsedSnapshot === "string") {
+      try {
+        parsedSnapshot = JSON.parse(row.snapshot);
+      } catch (e) {
+        this.logger?.warn?.(`Failed to parse snapshot for workflow ${row.workflow_name}:`, e);
+      }
+    }
+    return {
+      workflowName: row.workflow_name,
+      runId: row.run_id,
+      snapshot: parsedSnapshot,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+      resourceId: row.resourceId
+    };
+  }
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    runtimeContext
   }) {
-    throw new Error("Method not implemented.");
+    const table = getTableName({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName(this.schema) });
+    const transaction = this.pool.transaction();
+    try {
+      await transaction.begin();
+      const selectRequest = new sql3__default.default.Request(transaction);
+      selectRequest.input("workflow_name", workflowName);
+      selectRequest.input("run_id", runId);
+      const existingSnapshotResult = await selectRequest.query(
+        `SELECT snapshot FROM ${table} WITH (UPDLOCK, HOLDLOCK) WHERE workflow_name = @workflow_name AND run_id = @run_id`
+      );
+      let snapshot;
+      if (!existingSnapshotResult.recordset || existingSnapshotResult.recordset.length === 0) {
+        snapshot = {
+          context: {},
+          activePaths: [],
+          activeStepsPath: {},
+          timestamp: Date.now(),
+          suspendedPaths: {},
+          resumeLabels: {},
+          serializedStepGraph: [],
+          status: "pending",
+          value: {},
+          waitingPaths: {},
+          runId,
+          runtimeContext: {}
+        };
+      } else {
+        const existingSnapshot = existingSnapshotResult.recordset[0].snapshot;
+        snapshot = typeof existingSnapshot === "string" ? JSON.parse(existingSnapshot) : existingSnapshot;
+      }
+      snapshot.context[stepId] = result;
+      snapshot.runtimeContext = { ...snapshot.runtimeContext, ...runtimeContext };
+      const upsertReq = new sql3__default.default.Request(transaction);
+      upsertReq.input("workflow_name", workflowName);
+      upsertReq.input("run_id", runId);
+      upsertReq.input("snapshot", JSON.stringify(snapshot));
+      upsertReq.input("createdAt", sql3__default.default.DateTime2, /* @__PURE__ */ new Date());
+      upsertReq.input("updatedAt", sql3__default.default.DateTime2, /* @__PURE__ */ new Date());
+      await upsertReq.query(
+        `MERGE ${table} AS target
+         USING (SELECT @workflow_name AS workflow_name, @run_id AS run_id) AS src
+           ON target.workflow_name = src.workflow_name AND target.run_id = src.run_id
+         WHEN MATCHED THEN UPDATE SET snapshot = @snapshot, [updatedAt] = @updatedAt
+         WHEN NOT MATCHED THEN INSERT (workflow_name, run_id, snapshot, [createdAt], [updatedAt])
+           VALUES (@workflow_name, @run_id, @snapshot, @createdAt, @updatedAt);`
+      );
+      await transaction.commit();
+      return snapshot.context;
+    } catch (error$1) {
+      try {
+        await transaction.rollback();
+      } catch {
+      }
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_UPDATE_WORKFLOW_RESULTS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            workflowName,
+            runId,
+            stepId
+          }
+        },
+        error$1
+      );
+    }
   }
-  updateWorkflowState({
-    // workflowName,
-    // runId,
-    // opts,
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
   }) {
-    throw new Error("Method not implemented.");
+    const table = getTableName({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName(this.schema) });
+    const transaction = this.pool.transaction();
+    try {
+      await transaction.begin();
+      const selectRequest = new sql3__default.default.Request(transaction);
+      selectRequest.input("workflow_name", workflowName);
+      selectRequest.input("run_id", runId);
+      const existingSnapshotResult = await selectRequest.query(
+        `SELECT snapshot FROM ${table} WITH (UPDLOCK, HOLDLOCK) WHERE workflow_name = @workflow_name AND run_id = @run_id`
+      );
+      if (!existingSnapshotResult.recordset || existingSnapshotResult.recordset.length === 0) {
+        await transaction.rollback();
+        return void 0;
+      }
+      const existingSnapshot = existingSnapshotResult.recordset[0].snapshot;
+      const snapshot = typeof existingSnapshot === "string" ? JSON.parse(existingSnapshot) : existingSnapshot;
+      if (!snapshot || !snapshot?.context) {
+        await transaction.rollback();
+        throw new error.MastraError(
+          {
+            id: "MASTRA_STORAGE_MSSQL_STORE_UPDATE_WORKFLOW_STATE_SNAPSHOT_NOT_FOUND",
+            domain: error.ErrorDomain.STORAGE,
+            category: error.ErrorCategory.SYSTEM,
+            details: {
+              workflowName,
+              runId
+            }
+          },
+          new Error(`Snapshot not found for runId ${runId}`)
+        );
+      }
+      const updatedSnapshot = { ...snapshot, ...opts };
+      const updateRequest = new sql3__default.default.Request(transaction);
+      updateRequest.input("snapshot", JSON.stringify(updatedSnapshot));
+      updateRequest.input("workflow_name", workflowName);
+      updateRequest.input("run_id", runId);
+      updateRequest.input("updatedAt", sql3__default.default.DateTime2, /* @__PURE__ */ new Date());
+      await updateRequest.query(
+        `UPDATE ${table} SET snapshot = @snapshot, [updatedAt] = @updatedAt WHERE workflow_name = @workflow_name AND run_id = @run_id`
+      );
+      await transaction.commit();
+      return updatedSnapshot;
+    } catch (error$1) {
+      try {
+        await transaction.rollback();
+      } catch {
+      }
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_UPDATE_WORKFLOW_STATE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            workflowName,
+            runId
+          }
+        },
+        error$1
+      );
+    }
   }
   async persistWorkflowSnapshot({
     workflowName,
@@ -1907,8 +3112,8 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
       request.input("run_id", runId);
       request.input("resourceId", resourceId);
       request.input("snapshot", JSON.stringify(snapshot));
-      request.input("createdAt", sql2__default.default.DateTime2, new Date(now));
-      request.input("updatedAt", sql2__default.default.DateTime2, new Date(now));
+      request.input("createdAt", sql3__default.default.DateTime2, new Date(now));
+      request.input("updatedAt", sql3__default.default.DateTime2, new Date(now));
       const mergeSql = `MERGE INTO ${table} AS target
         USING (SELECT @workflow_name AS workflow_name, @run_id AS run_id) AS src
         ON target.workflow_name = src.workflow_name AND target.run_id = src.run_id
@@ -1989,7 +3194,7 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
       if (!result.recordset || result.recordset.length === 0) {
         return null;
       }
-      return parseWorkflowRun(result.recordset[0]);
+      return this.parseWorkflowRun(result.recordset[0]);
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -2011,7 +3216,8 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
     toDate,
     limit,
     offset,
-    resourceId
+    resourceId,
+    status
   } = {}) {
     try {
       const conditions = [];
@@ -2020,13 +3226,17 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
         conditions.push(`[workflow_name] = @workflowName`);
         paramMap["workflowName"] = workflowName;
       }
+      if (status) {
+        conditions.push(`JSON_VALUE([snapshot], '$.status') = @status`);
+        paramMap["status"] = status;
+      }
       if (resourceId) {
         const hasResourceId = await this.operations.hasColumn(storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId");
         if (hasResourceId) {
           conditions.push(`[resourceId] = @resourceId`);
           paramMap["resourceId"] = resourceId;
         } else {
-          console.warn(`[${storage.TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
+          this.logger?.warn?.(`[${storage.TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
         }
       }
       if (fromDate instanceof Date && !isNaN(fromDate.getTime())) {
@@ -2043,7 +3253,7 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
       const request = this.pool.request();
       Object.entries(paramMap).forEach(([key, value]) => {
         if (value instanceof Date) {
-          request.input(key, sql2__default.default.DateTime, value);
+          request.input(key, sql3__default.default.DateTime, value);
         } else {
           request.input(key, value);
         }
@@ -2060,7 +3270,7 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
         request.input("offset", offset);
       }
       const result = await request.query(query);
-      const runs = (result.recordset || []).map((row) => parseWorkflowRun(row));
+      const runs = (result.recordset || []).map((row) => this.parseWorkflowRun(row));
       return { runs, total: total || runs.length };
     } catch (error$1) {
       throw new error.MastraError(
@@ -2100,7 +3310,7 @@ var MSSQLStore = class extends storage.MastraStorage {
         }
       }
       this.schema = config.schemaName || "dbo";
-      this.pool = "connectionString" in config ? new sql2__default.default.ConnectionPool(config.connectionString) : new sql2__default.default.ConnectionPool({
+      this.pool = "connectionString" in config ? new sql3__default.default.ConnectionPool(config.connectionString) : new sql3__default.default.ConnectionPool({
         server: config.server,
         database: config.database,
         user: config.user,
@@ -2114,13 +3324,15 @@ var MSSQLStore = class extends storage.MastraStorage {
       const traces = new TracesMSSQL({ pool: this.pool, operations, schema: this.schema });
       const workflows = new WorkflowsMSSQL({ pool: this.pool, operations, schema: this.schema });
       const memory = new MemoryMSSQL({ pool: this.pool, schema: this.schema, operations });
+      const observability = new ObservabilityMSSQL({ pool: this.pool, operations, schema: this.schema });
       this.stores = {
         operations,
         scores,
         traces,
         workflows,
         legacyEvals,
-        memory
+        memory,
+        observability
       };
     } catch (e) {
       throw new error.MastraError(
@@ -2140,6 +3352,11 @@ var MSSQLStore = class extends storage.MastraStorage {
     try {
       await this.isConnected;
       await super.init();
+      try {
+        await this.stores.operations.createAutomaticIndexes();
+      } catch (indexError) {
+        this.logger?.warn?.("Failed to create indexes:", indexError);
+      }
     } catch (error$1) {
       this.isConnected = null;
       throw new error.MastraError(
@@ -2166,7 +3383,10 @@ var MSSQLStore = class extends storage.MastraStorage {
       resourceWorkingMemory: true,
       hasColumn: true,
       createTable: true,
-      deleteMessages: true
+      deleteMessages: true,
+      getScoresBySpan: true,
+      aiTracing: true,
+      indexManagement: true
     };
   }
   /** @deprecated use getEvals instead */
@@ -2313,15 +3533,8 @@ var MSSQLStore = class extends storage.MastraStorage {
   }) {
     return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
   }
-  async getWorkflowRuns({
-    workflowName,
-    fromDate,
-    toDate,
-    limit,
-    offset,
-    resourceId
-  } = {}) {
-    return this.stores.workflows.getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId });
+  async getWorkflowRuns(args = {}) {
+    return this.stores.workflows.getWorkflowRuns(args);
   }
   async getWorkflowRunById({
     runId,
@@ -2332,6 +3545,60 @@ var MSSQLStore = class extends storage.MastraStorage {
   async close() {
     await this.pool.close();
   }
+  /**
+   * Index Management
+   */
+  async createIndex(options) {
+    return this.stores.operations.createIndex(options);
+  }
+  async listIndexes(tableName) {
+    return this.stores.operations.listIndexes(tableName);
+  }
+  async describeIndex(indexName) {
+    return this.stores.operations.describeIndex(indexName);
+  }
+  async dropIndex(indexName) {
+    return this.stores.operations.dropIndex(indexName);
+  }
+  /**
+   * AI Tracing / Observability
+   */
+  getObservabilityStore() {
+    if (!this.stores.observability) {
+      throw new error.MastraError({
+        id: "MSSQL_STORE_OBSERVABILITY_NOT_INITIALIZED",
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.SYSTEM,
+        text: "Observability storage is not initialized"
+      });
+    }
+    return this.stores.observability;
+  }
+  async createAISpan(span) {
+    return this.getObservabilityStore().createAISpan(span);
+  }
+  async updateAISpan({
+    spanId,
+    traceId,
+    updates
+  }) {
+    return this.getObservabilityStore().updateAISpan({ spanId, traceId, updates });
+  }
+  async getAITrace(traceId) {
+    return this.getObservabilityStore().getAITrace(traceId);
+  }
+  async getAITracesPaginated(args) {
+    return this.getObservabilityStore().getAITracesPaginated(args);
+  }
+  async batchCreateAISpans(args) {
+    return this.getObservabilityStore().batchCreateAISpans(args);
+  }
+  async batchUpdateAISpans(args) {
+    return this.getObservabilityStore().batchUpdateAISpans(args);
+  }
+  async batchDeleteAITraces(args) {
+    return this.getObservabilityStore().batchDeleteAITraces(args);
+  }
   /**
    * Scorers
    */
@@ -2340,9 +3607,18 @@ var MSSQLStore = class extends storage.MastraStorage {
   }
   async getScoresByScorerId({
     scorerId: _scorerId,
-    pagination: _pagination
+    pagination: _pagination,
+    entityId: _entityId,
+    entityType: _entityType,
+    source: _source
   }) {
-    return this.stores.scores.getScoresByScorerId({ scorerId: _scorerId, pagination: _pagination });
+    return this.stores.scores.getScoresByScorerId({
+      scorerId: _scorerId,
+      pagination: _pagination,
+      entityId: _entityId,
+      entityType: _entityType,
+      source: _source
+    });
   }
   async saveScore(_score) {
     return this.stores.scores.saveScore(_score);
@@ -2364,6 +3640,13 @@ var MSSQLStore = class extends storage.MastraStorage {
       pagination: _pagination
     });
   }
+  async getScoresBySpan({
+    traceId,
+    spanId,
+    pagination: _pagination
+  }) {
+    return this.stores.scores.getScoresBySpan({ traceId, spanId, pagination: _pagination });
+  }
 };
 
 exports.MSSQLStore = MSSQLStore;