@mastra/mssql 0.0.0-fix-11329-windows-path-20251222155941 → 0.0.0-fix-local-pkg-cwd-20251224015404

package/dist/index.cjs

@@ -3,9 +3,9 @@
 var error = require('@mastra/core/error');
 var storage = require('@mastra/core/storage');
 var sql = require('mssql');
+var agent = require('@mastra/core/agent');
 var base = require('@mastra/core/base');
 var utils = require('@mastra/core/utils');
-var agent = require('@mastra/core/agent');
 var crypto = require('crypto');
 var evals = require('@mastra/core/evals');
 
@@ -26,31 +26,89 @@ function getTableName({ indexName, schemaName }) {
 
 // src/storage/db/index.ts
 function resolveMssqlConfig(config) {
-  if ("pool" in config && "db" in config) {
-    return { pool: config.pool, db: config.db, schema: config.schema, needsConnect: false };
+  if ("pool" in config && !("server" in config)) {
+    return {
+      pool: config.pool,
+      schemaName: config.schemaName,
+      skipDefaultIndexes: config.skipDefaultIndexes,
+      indexes: config.indexes,
+      needsConnect: false
+    };
   }
+  const restConfig = config;
   const pool = new sql__default.default.ConnectionPool({
-    server: config.server,
-    database: config.database,
-    user: config.user,
-    password: config.password,
-    port: config.port,
-    options: config.options || { encrypt: true, trustServerCertificate: true }
+    server: restConfig.server,
+    database: restConfig.database,
+    user: restConfig.user,
+    password: restConfig.password,
+    port: restConfig.port,
+    options: restConfig.options || { encrypt: true, trustServerCertificate: true }
   });
-  const db = new MssqlDB({ pool, schemaName: config.schemaName });
-  return { pool, db, schema: config.schemaName, needsConnect: true };
+  return {
+    pool,
+    schemaName: restConfig.schemaName,
+    skipDefaultIndexes: restConfig.skipDefaultIndexes,
+    indexes: restConfig.indexes,
+    needsConnect: true
+  };
 }
 var MssqlDB = class extends base.MastraBase {
   pool;
   schemaName;
+  skipDefaultIndexes;
   setupSchemaPromise = null;
   schemaSetupComplete = void 0;
-  getSqlType(type, isPrimaryKey = false, useLargeStorage = false) {
+  /**
+   * Columns that participate in composite indexes need smaller sizes (NVARCHAR(100)).
+   * MSSQL has a 900-byte index key limit, so composite indexes with NVARCHAR(400) columns fail.
+   * These are typically ID/type fields that don't need 400 chars.
+   */
+  COMPOSITE_INDEX_COLUMNS = [
+    "traceId",
+    // Used in: PRIMARY KEY (traceId, spanId), index (traceId, spanId, seq_id)
+    "spanId",
+    // Used in: PRIMARY KEY (traceId, spanId), index (traceId, spanId, seq_id)
+    "parentSpanId",
+    // Used in: index (parentSpanId, startedAt)
+    "entityType",
+    // Used in: (entityType, entityId), (entityType, entityName)
+    "entityId",
+    // Used in: (entityType, entityId)
+    "entityName",
+    // Used in: (entityType, entityName)
+    "organizationId",
+    // Used in: (organizationId, userId)
+    "userId"
+    // Used in: (organizationId, userId)
+  ];
+  /**
+   * Columns that store large amounts of data and should use NVARCHAR(MAX).
+   * Avoid listing columns that participate in indexes (resourceId, thread_id, agent_name, name, etc.)
+   */
+  LARGE_DATA_COLUMNS = [
+    "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
+  ];
+  getSqlType(type, isPrimaryKey = false, useLargeStorage = false, useSmallStorage = false) {
     switch (type) {
       case "text":
         if (useLargeStorage) {
           return "NVARCHAR(MAX)";
         }
+        if (useSmallStorage) {
+          return "NVARCHAR(100)";
+        }
         return isPrimaryKey ? "NVARCHAR(255)" : "NVARCHAR(400)";
       case "timestamp":
         return "DATETIME2(7)";
@@ -74,10 +132,15 @@ var MssqlDB = class extends base.MastraBase {
         });
     }
   }
-  constructor({ pool, schemaName }) {
+  constructor({
+    pool,
+    schemaName,
+    skipDefaultIndexes
+  }) {
     super({ component: "STORAGE", name: "MssqlDB" });
     this.pool = pool;
     this.schemaName = schemaName;
+    this.skipDefaultIndexes = skipDefaultIndexes;
   }
   async hasColumn(table, column) {
     const schema = this.schemaName || "dbo";
@@ -209,29 +272,15 @@ var MssqlDB = class extends base.MastraBase {
   }) {
     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);
-        const useLargeStorage = largeDataColumns.includes(name);
-        return `[${parsedName}] ${this.getSqlType(def.type, isIndexed, useLargeStorage)} ${constraints.join(" ")}`.trim();
+        const useLargeStorage = this.LARGE_DATA_COLUMNS.includes(name);
+        const useSmallStorage = this.COMPOSITE_INDEX_COLUMNS.includes(name);
+        return `[${parsedName}] ${this.getSqlType(def.type, isIndexed, useLargeStorage, useSmallStorage)} ${constraints.join(" ")}`.trim();
       }).join(",\n");
       if (this.schemaName) {
         await this.setupSchema();
@@ -268,18 +317,37 @@ ${columns}
         const alterSql = `ALTER TABLE ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} ADD seq_id BIGINT IDENTITY(1,1)`;
         await this.pool.request().query(alterSql);
       }
+      const schemaPrefix = this.schemaName ? `${this.schemaName}_` : "";
       if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
-        const constraintName = "mastra_workflow_snapshot_workflow_name_run_id_key";
+        const constraintName = `${schemaPrefix}mastra_workflow_snapshot_workflow_name_run_id_key`;
         const checkConstraintSql = `SELECT 1 AS found FROM sys.key_constraints WHERE name = @constraintName`;
         const checkConstraintRequest = this.pool.request();
         checkConstraintRequest.input("constraintName", constraintName);
         const constraintResult = await checkConstraintRequest.query(checkConstraintSql);
         const constraintExists = Array.isArray(constraintResult.recordset) && constraintResult.recordset.length > 0;
         if (!constraintExists) {
-          const addConstraintSql = `ALTER TABLE ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} ADD CONSTRAINT ${constraintName} UNIQUE ([workflow_name], [run_id])`;
+          const addConstraintSql = `ALTER TABLE ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} ADD CONSTRAINT [${constraintName}] UNIQUE ([workflow_name], [run_id])`;
           await this.pool.request().query(addConstraintSql);
         }
       }
+      if (tableName === storage.TABLE_SPANS) {
+        await this.migrateSpansTable();
+        const pkConstraintName = `${schemaPrefix}mastra_ai_spans_traceid_spanid_pk`;
+        const checkPkRequest = this.pool.request();
+        checkPkRequest.input("constraintName", pkConstraintName);
+        const pkResult = await checkPkRequest.query(
+          `SELECT 1 AS found FROM sys.key_constraints WHERE name = @constraintName`
+        );
+        const pkExists = Array.isArray(pkResult.recordset) && pkResult.recordset.length > 0;
+        if (!pkExists) {
+          try {
+            const addPkSql = `ALTER TABLE ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} ADD CONSTRAINT [${pkConstraintName}] PRIMARY KEY ([traceId], [spanId])`;
+            await this.pool.request().query(addPkSql);
+          } catch (pkError) {
+            this.logger?.warn?.(`Failed to add composite primary key to spans table:`, pkError);
+          }
+        }
+      }
     } catch (error$1) {
       throw new error.MastraError(
         {
@@ -294,6 +362,34 @@ ${columns}
       );
     }
   }
+  /**
+   * Migrates the spans table schema from OLD_SPAN_SCHEMA to current SPAN_SCHEMA.
+   * This adds new columns that don't exist in old schema.
+   */
+  async migrateSpansTable() {
+    const fullTableName = getTableName({ indexName: storage.TABLE_SPANS, schemaName: getSchemaName(this.schemaName) });
+    const schema = storage.TABLE_SCHEMAS[storage.TABLE_SPANS];
+    try {
+      for (const [columnName, columnDef] of Object.entries(schema)) {
+        const columnExists = await this.hasColumn(storage.TABLE_SPANS, columnName);
+        if (!columnExists) {
+          const parsedColumnName = utils.parseSqlIdentifier(columnName, "column name");
+          const useLargeStorage = this.LARGE_DATA_COLUMNS.includes(columnName);
+          const useSmallStorage = this.COMPOSITE_INDEX_COLUMNS.includes(columnName);
+          const isIndexed = !!columnDef.primaryKey;
+          const sqlType = this.getSqlType(columnDef.type, isIndexed, useLargeStorage, useSmallStorage);
+          const nullable = columnDef.nullable ? "" : "NOT NULL";
+          const defaultValue = !columnDef.nullable ? this.getDefaultValue(columnDef.type) : "";
+          const alterSql = `ALTER TABLE ${fullTableName} ADD [${parsedColumnName}] ${sqlType} ${nullable} ${defaultValue}`.trim();
+          await this.pool.request().query(alterSql);
+          this.logger?.debug?.(`Added column '${columnName}' to ${fullTableName}`);
+        }
+      }
+      this.logger?.info?.(`Migration completed for ${fullTableName}`);
+    } catch (error) {
+      this.logger?.warn?.(`Failed to migrate spans table ${fullTableName}:`, error);
+    }
+  }
   /**
    * Alters table schema to add columns if they don't exist
    * @param tableName Name of the table
@@ -318,21 +414,12 @@ ${columns}
           const columnExists = Array.isArray(checkResult.recordset) && checkResult.recordset.length > 0;
           if (!columnExists) {
             const columnDef = schema[columnName];
-            const largeDataColumns = [
-              "workingMemory",
-              "snapshot",
-              "metadata",
-              "content",
-              "input",
-              "output",
-              "instructions",
-              "other"
-            ];
-            const useLargeStorage = largeDataColumns.includes(columnName);
+            const useLargeStorage = this.LARGE_DATA_COLUMNS.includes(columnName);
+            const useSmallStorage = this.COMPOSITE_INDEX_COLUMNS.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 sqlType = this.getSqlType(columnDef.type, isIndexed, useLargeStorage, useSmallStorage);
+            const nullable = columnDef.nullable ? "" : "NOT NULL";
+            const defaultValue = !columnDef.nullable ? this.getDefaultValue(columnDef.type) : "";
             const parsedColumnName = utils.parseSqlIdentifier(columnName, "column name");
             const alterSql = `ALTER TABLE ${fullTableName} ADD [${parsedColumnName}] ${sqlType} ${nullable} ${defaultValue}`.trim();
             await this.pool.request().query(alterSql);
@@ -916,84 +1003,6 @@ ${columns}
       );
     }
   }
-  /**
-   * 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_scores_trace_id_span_id_seqid_idx`,
-        table: storage.TABLE_SCORERS,
-        columns: ["traceId", "spanId", "seq_id DESC"]
-      },
-      // Spans indexes for optimal trace querying
-      {
-        name: `${schemaPrefix}mastra_ai_spans_traceid_startedat_idx`,
-        table: storage.TABLE_SPANS,
-        columns: ["traceId", "startedAt DESC"]
-      },
-      {
-        name: `${schemaPrefix}mastra_ai_spans_parentspanid_startedat_idx`,
-        table: storage.TABLE_SPANS,
-        columns: ["parentSpanId", "startedAt DESC"]
-      },
-      {
-        name: `${schemaPrefix}mastra_ai_spans_name_idx`,
-        table: storage.TABLE_SPANS,
-        columns: ["name"]
-      },
-      {
-        name: `${schemaPrefix}mastra_ai_spans_spantype_startedat_idx`,
-        table: storage.TABLE_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: storage.createStorageErrorId("MSSQL", "CREATE_PERFORMANCE_INDEXES", "FAILED"),
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
-    }
-  }
 };
 function getSchemaName2(schema) {
   return schema ? `[${utils.parseSqlIdentifier(schema, "schema name")}]` : void 0;
@@ -1107,11 +1116,15 @@ function transformFromSqlRow({
 }
 
 // src/storage/domains/memory/index.ts
-var MemoryMSSQL = class extends storage.MemoryStorage {
+var MemoryMSSQL = class _MemoryMSSQL extends storage.MemoryStorage {
   pool;
   schema;
   db;
   needsConnect;
+  skipDefaultIndexes;
+  indexes;
+  /** Tables managed by this domain */
+  static MANAGED_TABLES = [storage.TABLE_THREADS, storage.TABLE_MESSAGES, storage.TABLE_RESOURCES];
   _parseAndFormatMessages(messages, format) {
     const messagesWithParsedContent = messages.map((message) => {
       if (typeof message.content === "string") {
@@ -1129,11 +1142,13 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
   }
   constructor(config) {
     super();
-    const { pool, db, schema, needsConnect } = resolveMssqlConfig(config);
+    const { pool, schemaName, skipDefaultIndexes, indexes, needsConnect } = resolveMssqlConfig(config);
     this.pool = pool;
-    this.schema = schema;
-    this.db = db;
+    this.schema = schemaName;
+    this.db = new MssqlDB({ pool, schemaName, skipDefaultIndexes });
     this.needsConnect = needsConnect;
+    this.skipDefaultIndexes = skipDefaultIndexes;
+    this.indexes = indexes?.filter((idx) => _MemoryMSSQL.MANAGED_TABLES.includes(idx.table));
   }
   async init() {
     if (this.needsConnect) {
@@ -1143,6 +1158,57 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
     await this.db.createTable({ tableName: storage.TABLE_THREADS, schema: storage.TABLE_SCHEMAS[storage.TABLE_THREADS] });
     await this.db.createTable({ tableName: storage.TABLE_MESSAGES, schema: storage.TABLE_SCHEMAS[storage.TABLE_MESSAGES] });
     await this.db.createTable({ tableName: storage.TABLE_RESOURCES, schema: storage.TABLE_SCHEMAS[storage.TABLE_RESOURCES] });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  /**
+   * Returns default index definitions for the memory domain tables.
+   * IMPORTANT: Uses seq_id DESC instead of createdAt DESC for MSSQL due to millisecond accuracy limitations
+   */
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.schema ? `${this.schema}_` : "";
+    return [
+      {
+        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"]
+      }
+    ];
+  }
+  /**
+   * Creates default indexes for optimal query performance.
+   */
+  async createDefaultIndexes() {
+    if (this.skipDefaultIndexes) {
+      return;
+    }
+    for (const indexDef of this.getDefaultIndexDefinitions()) {
+      try {
+        await this.db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  /**
+   * Creates custom user-defined indexes for this domain's tables.
+   */
+  async createCustomIndexes() {
+    if (!this.indexes || this.indexes.length === 0) {
+      return;
+    }
+    for (const indexDef of this.indexes) {
+      try {
+        await this.db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
+      }
+    }
   }
   async dangerouslyClearAll() {
     await this.db.clearTable({ tableName: storage.TABLE_MESSAGES });
@@ -2021,18 +2087,24 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
     }
   }
 };
-var ObservabilityMSSQL = class extends storage.ObservabilityStorage {
+var ObservabilityMSSQL = class _ObservabilityMSSQL extends storage.ObservabilityStorage {
   pool;
   db;
   schema;
   needsConnect;
+  skipDefaultIndexes;
+  indexes;
+  /** Tables managed by this domain */
+  static MANAGED_TABLES = [storage.TABLE_SPANS];
   constructor(config) {
     super();
-    const { pool, db, schema, needsConnect } = resolveMssqlConfig(config);
+    const { pool, schemaName, skipDefaultIndexes, indexes, needsConnect } = resolveMssqlConfig(config);
     this.pool = pool;
-    this.db = db;
-    this.schema = schema;
+    this.schema = schemaName;
+    this.db = new MssqlDB({ pool, schemaName, skipDefaultIndexes });
     this.needsConnect = needsConnect;
+    this.skipDefaultIndexes = skipDefaultIndexes;
+    this.indexes = indexes?.filter((idx) => _ObservabilityMSSQL.MANAGED_TABLES.includes(idx.table));
   }
   async init() {
     if (this.needsConnect) {
@@ -2040,6 +2112,92 @@ var ObservabilityMSSQL = class extends storage.ObservabilityStorage {
       this.needsConnect = false;
     }
     await this.db.createTable({ tableName: storage.TABLE_SPANS, schema: storage.SPAN_SCHEMA });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  /**
+   * Returns default index definitions for the observability domain tables.
+   */
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.schema ? `${this.schema}_` : "";
+    return [
+      {
+        name: `${schemaPrefix}mastra_ai_spans_traceid_startedat_idx`,
+        table: storage.TABLE_SPANS,
+        columns: ["traceId", "startedAt DESC"]
+      },
+      {
+        name: `${schemaPrefix}mastra_ai_spans_parentspanid_startedat_idx`,
+        table: storage.TABLE_SPANS,
+        columns: ["parentSpanId", "startedAt DESC"]
+      },
+      {
+        name: `${schemaPrefix}mastra_ai_spans_name_idx`,
+        table: storage.TABLE_SPANS,
+        columns: ["name"]
+      },
+      {
+        name: `${schemaPrefix}mastra_ai_spans_spantype_startedat_idx`,
+        table: storage.TABLE_SPANS,
+        columns: ["spanType", "startedAt DESC"]
+      },
+      // Root spans filtered index - every listTraces query filters parentSpanId IS NULL
+      {
+        name: `${schemaPrefix}mastra_ai_spans_root_spans_idx`,
+        table: storage.TABLE_SPANS,
+        columns: ["startedAt DESC"],
+        where: "[parentSpanId] IS NULL"
+      },
+      // Entity identification indexes - common filtering patterns
+      {
+        name: `${schemaPrefix}mastra_ai_spans_entitytype_entityid_idx`,
+        table: storage.TABLE_SPANS,
+        columns: ["entityType", "entityId"]
+      },
+      {
+        name: `${schemaPrefix}mastra_ai_spans_entitytype_entityname_idx`,
+        table: storage.TABLE_SPANS,
+        columns: ["entityType", "entityName"]
+      },
+      // Multi-tenant filtering - organizationId + userId
+      {
+        name: `${schemaPrefix}mastra_ai_spans_orgid_userid_idx`,
+        table: storage.TABLE_SPANS,
+        columns: ["organizationId", "userId"]
+      }
+      // Note: MSSQL doesn't support GIN indexes for JSONB/array containment queries
+      // Metadata and tags filtering will use full table scans on NVARCHAR(MAX) columns
+    ];
+  }
+  /**
+   * Creates default indexes for optimal query performance.
+   */
+  async createDefaultIndexes() {
+    if (this.skipDefaultIndexes) {
+      return;
+    }
+    for (const indexDef of this.getDefaultIndexDefinitions()) {
+      try {
+        await this.db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  /**
+   * Creates custom user-defined indexes for this domain's tables.
+   */
+  async createCustomIndexes() {
+    if (!this.indexes || this.indexes.length === 0) {
+      return;
+    }
+    for (const indexDef of this.indexes) {
+      try {
+        await this.db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
+      }
+    }
   }
   async dangerouslyClearAll() {
     await this.db.clearTable({ tableName: storage.TABLE_SPANS });
@@ -2050,15 +2208,18 @@ var ObservabilityMSSQL = class extends storage.ObservabilityStorage {
       supported: ["batch-with-updates", "insert-only"]
     };
   }
-  async createSpan(span) {
+  async createSpan(args) {
+    const { span } = args;
     try {
       const startedAt = span.startedAt instanceof Date ? span.startedAt.toISOString() : span.startedAt;
       const endedAt = span.endedAt instanceof Date ? span.endedAt.toISOString() : span.endedAt;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
       const record = {
         ...span,
         startedAt,
-        endedAt
-        // Note: createdAt/updatedAt will be set by default values
+        endedAt,
+        createdAt: now,
+        updatedAt: now
       };
       return this.db.insert({ tableName: storage.TABLE_SPANS, record });
     } catch (error$1) {
@@ -2071,14 +2232,15 @@ var ObservabilityMSSQL = class extends storage.ObservabilityStorage {
             spanId: span.spanId,
             traceId: span.traceId,
             spanType: span.spanType,
-            spanName: span.name
+            name: span.name
           }
         },
         error$1
       );
     }
   }
-  async getTrace(traceId) {
+  async getTrace(args) {
+    const { traceId } = args;
     try {
       const tableName = getTableName2({
         indexName: storage.TABLE_SPANS,
@@ -2088,12 +2250,17 @@ var ObservabilityMSSQL = class extends storage.ObservabilityStorage {
       request.input("traceId", traceId);
       const result = await request.query(
         `SELECT
-          [traceId], [spanId], [parentSpanId], [name], [scope], [spanType],
-          [attributes], [metadata], [links], [input], [output], [error], [isEvent],
+          [traceId], [spanId], [parentSpanId], [name],
+          [entityType], [entityId], [entityName],
+          [userId], [organizationId], [resourceId],
+          [runId], [sessionId], [threadId], [requestId],
+          [environment], [source], [serviceName], [scope],
+          [spanType], [attributes], [metadata], [tags], [links],
+          [input], [output], [error], [isEvent],
           [startedAt], [endedAt], [createdAt], [updatedAt]
         FROM ${tableName}
         WHERE [traceId] = @traceId
-        ORDER BY [startedAt] DESC`
+        ORDER BY [startedAt] ASC`
       );
       if (!result.recordset || result.recordset.length === 0) {
         return null;
@@ -2121,11 +2288,95 @@ var ObservabilityMSSQL = class extends storage.ObservabilityStorage {
       );
     }
   }
-  async updateSpan({
-    spanId,
-    traceId,
-    updates
-  }) {
+  async getSpan(args) {
+    const { traceId, spanId } = args;
+    try {
+      const tableName = getTableName2({
+        indexName: storage.TABLE_SPANS,
+        schemaName: getSchemaName2(this.schema)
+      });
+      const request = this.pool.request();
+      request.input("traceId", traceId);
+      request.input("spanId", spanId);
+      const result = await request.query(
+        `SELECT
+          [traceId], [spanId], [parentSpanId], [name],
+          [entityType], [entityId], [entityName],
+          [userId], [organizationId], [resourceId],
+          [runId], [sessionId], [threadId], [requestId],
+          [environment], [source], [serviceName], [scope],
+          [spanType], [attributes], [metadata], [tags], [links],
+          [input], [output], [error], [isEvent],
+          [startedAt], [endedAt], [createdAt], [updatedAt]
+        FROM ${tableName}
+        WHERE [traceId] = @traceId AND [spanId] = @spanId`
+      );
+      if (!result.recordset || result.recordset.length === 0) {
+        return null;
+      }
+      return {
+        span: transformFromSqlRow({
+          tableName: storage.TABLE_SPANS,
+          sqlRow: result.recordset[0]
+        })
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MSSQL", "GET_SPAN", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { traceId, spanId }
+        },
+        error$1
+      );
+    }
+  }
+  async getRootSpan(args) {
+    const { traceId } = args;
+    try {
+      const tableName = getTableName2({
+        indexName: storage.TABLE_SPANS,
+        schemaName: getSchemaName2(this.schema)
+      });
+      const request = this.pool.request();
+      request.input("traceId", traceId);
+      const result = await request.query(
+        `SELECT
+          [traceId], [spanId], [parentSpanId], [name],
+          [entityType], [entityId], [entityName],
+          [userId], [organizationId], [resourceId],
+          [runId], [sessionId], [threadId], [requestId],
+          [environment], [source], [serviceName], [scope],
+          [spanType], [attributes], [metadata], [tags], [links],
+          [input], [output], [error], [isEvent],
+          [startedAt], [endedAt], [createdAt], [updatedAt]
+        FROM ${tableName}
+        WHERE [traceId] = @traceId AND [parentSpanId] IS NULL`
+      );
+      if (!result.recordset || result.recordset.length === 0) {
+        return null;
+      }
+      return {
+        span: transformFromSqlRow({
+          tableName: storage.TABLE_SPANS,
+          sqlRow: result.recordset[0]
+        })
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MSSQL", "GET_ROOT_SPAN", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: { traceId }
+        },
+        error$1
+      );
+    }
+  }
+  async updateSpan(args) {
+    const { traceId, spanId, updates } = args;
     try {
       const data = { ...updates };
       if (data.endedAt instanceof Date) {
@@ -2134,6 +2385,7 @@ var ObservabilityMSSQL = class extends storage.ObservabilityStorage {
       if (data.startedAt instanceof Date) {
         data.startedAt = data.startedAt.toISOString();
       }
+      data.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       await this.db.update({
         tableName: storage.TABLE_SPANS,
         keys: { spanId, traceId },
@@ -2154,63 +2406,184 @@ var ObservabilityMSSQL = class extends storage.ObservabilityStorage {
       );
     }
   }
-  async getTracesPaginated({
-    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: storage.createStorageErrorId("MSSQL", "GET_TRACES_PAGINATED", "INVALID_ENTITY_TYPE"),
-          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;
-    }
+  async listTraces(args) {
+    const { filters, pagination, orderBy } = storage.listTracesArgsSchema.parse(args);
+    const { page, perPage } = pagination;
     const tableName = getTableName2({
       indexName: storage.TABLE_SPANS,
       schemaName: getSchemaName2(this.schema)
     });
     try {
+      const conditions = ["r.[parentSpanId] IS NULL"];
+      const params = {};
+      let paramIndex = 1;
+      if (filters) {
+        if (filters.startedAt?.start) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[startedAt] >= @${param}`);
+          params[param] = filters.startedAt.start.toISOString();
+        }
+        if (filters.startedAt?.end) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[startedAt] <= @${param}`);
+          params[param] = filters.startedAt.end.toISOString();
+        }
+        if (filters.endedAt?.start) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[endedAt] >= @${param}`);
+          params[param] = filters.endedAt.start.toISOString();
+        }
+        if (filters.endedAt?.end) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[endedAt] <= @${param}`);
+          params[param] = filters.endedAt.end.toISOString();
+        }
+        if (filters.spanType !== void 0) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[spanType] = @${param}`);
+          params[param] = filters.spanType;
+        }
+        if (filters.entityType !== void 0) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[entityType] = @${param}`);
+          params[param] = filters.entityType;
+        }
+        if (filters.entityId !== void 0) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[entityId] = @${param}`);
+          params[param] = filters.entityId;
+        }
+        if (filters.entityName !== void 0) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[entityName] = @${param}`);
+          params[param] = filters.entityName;
+        }
+        if (filters.userId !== void 0) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[userId] = @${param}`);
+          params[param] = filters.userId;
+        }
+        if (filters.organizationId !== void 0) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[organizationId] = @${param}`);
+          params[param] = filters.organizationId;
+        }
+        if (filters.resourceId !== void 0) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[resourceId] = @${param}`);
+          params[param] = filters.resourceId;
+        }
+        if (filters.runId !== void 0) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[runId] = @${param}`);
+          params[param] = filters.runId;
+        }
+        if (filters.sessionId !== void 0) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[sessionId] = @${param}`);
+          params[param] = filters.sessionId;
+        }
+        if (filters.threadId !== void 0) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[threadId] = @${param}`);
+          params[param] = filters.threadId;
+        }
+        if (filters.requestId !== void 0) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[requestId] = @${param}`);
+          params[param] = filters.requestId;
+        }
+        if (filters.environment !== void 0) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[environment] = @${param}`);
+          params[param] = filters.environment;
+        }
+        if (filters.source !== void 0) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[source] = @${param}`);
+          params[param] = filters.source;
+        }
+        if (filters.serviceName !== void 0) {
+          const param = `p${paramIndex++}`;
+          conditions.push(`r.[serviceName] = @${param}`);
+          params[param] = filters.serviceName;
+        }
+        if (filters.scope != null) {
+          for (const [key, value] of Object.entries(filters.scope)) {
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
+              throw new error.MastraError({
+                id: storage.createStorageErrorId("MSSQL", "LIST_TRACES", "INVALID_FILTER_KEY"),
+                domain: error.ErrorDomain.STORAGE,
+                category: error.ErrorCategory.USER,
+                details: { key }
+              });
+            }
+            const param = `p${paramIndex++}`;
+            conditions.push(`JSON_VALUE(r.[scope], '$.${key}') = @${param}`);
+            params[param] = typeof value === "string" ? value : JSON.stringify(value);
+          }
+        }
+        if (filters.metadata != null) {
+          for (const [key, value] of Object.entries(filters.metadata)) {
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
+              throw new error.MastraError({
+                id: storage.createStorageErrorId("MSSQL", "LIST_TRACES", "INVALID_FILTER_KEY"),
+                domain: error.ErrorDomain.STORAGE,
+                category: error.ErrorCategory.USER,
+                details: { key }
+              });
+            }
+            const param = `p${paramIndex++}`;
+            conditions.push(`JSON_VALUE(r.[metadata], '$.${key}') = @${param}`);
+            params[param] = typeof value === "string" ? value : JSON.stringify(value);
+          }
+        }
+        if (filters.tags != null && filters.tags.length > 0) {
+          for (const tag of filters.tags) {
+            const param = `p${paramIndex++}`;
+            conditions.push(`EXISTS (SELECT 1 FROM OPENJSON(r.[tags]) WHERE [value] = @${param})`);
+            params[param] = tag;
+          }
+        }
+        if (filters.status !== void 0) {
+          switch (filters.status) {
+            case storage.TraceStatus.ERROR:
+              conditions.push(`r.[error] IS NOT NULL`);
+              break;
+            case storage.TraceStatus.RUNNING:
+              conditions.push(`r.[endedAt] IS NULL AND r.[error] IS NULL`);
+              break;
+            case storage.TraceStatus.SUCCESS:
+              conditions.push(`r.[endedAt] IS NOT NULL AND r.[error] IS NULL`);
+              break;
+          }
+        }
+        if (filters.hasChildError !== void 0) {
+          if (filters.hasChildError) {
+            conditions.push(`EXISTS (
+              SELECT 1 FROM ${tableName} c
+              WHERE c.[traceId] = r.[traceId] AND c.[error] IS NOT NULL
+            )`);
+          } else {
+            conditions.push(`NOT EXISTS (
+              SELECT 1 FROM ${tableName} c
+              WHERE c.[traceId] = r.[traceId] AND c.[error] IS NOT NULL
+            )`);
+          }
+        }
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const sortField = orderBy.field;
+      const sortDirection = orderBy.direction;
       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}`
+        `SELECT COUNT(*) as count FROM ${tableName} r ${whereClause}`
       );
-      const total = countResult.recordset[0]?.count ?? 0;
-      if (total === 0) {
+      const count = countResult.recordset[0]?.count ?? 0;
+      if (count === 0) {
         return {
           pagination: {
             total: 0,
@@ -2227,28 +2600,39 @@ var ObservabilityMSSQL = class extends storage.ObservabilityStorage {
       });
       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_SPANS,
-          sqlRow: row
-        })
+      const result = await dataRequest.query(
+        `SELECT
+          r.[traceId], r.[spanId], r.[parentSpanId], r.[name],
+          r.[entityType], r.[entityId], r.[entityName],
+          r.[userId], r.[organizationId], r.[resourceId],
+          r.[runId], r.[sessionId], r.[threadId], r.[requestId],
+          r.[environment], r.[source], r.[serviceName], r.[scope],
+          r.[spanType], r.[attributes], r.[metadata], r.[tags], r.[links],
+          r.[input], r.[output], r.[error], r.[isEvent],
+          r.[startedAt], r.[endedAt], r.[createdAt], r.[updatedAt]
+        FROM ${tableName} r
+        ${whereClause}
+        ORDER BY r.[${sortField}] ${sortDirection}
+        OFFSET @offset ROWS FETCH NEXT @limit ROWS ONLY`
       );
       return {
         pagination: {
-          total,
+          total: count,
           page,
           perPage,
-          hasMore: (page + 1) * perPage < total
+          hasMore: (page + 1) * perPage < count
         },
-        spans
+        spans: result.recordset.map(
+          (span) => transformFromSqlRow({
+            tableName: storage.TABLE_SPANS,
+            sqlRow: span
+          })
+        )
       };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: storage.createStorageErrorId("MSSQL", "GET_TRACES_PAGINATED", "FAILED"),
+          id: storage.createStorageErrorId("MSSQL", "LIST_TRACES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER
         },
@@ -2261,12 +2645,15 @@ var ObservabilityMSSQL = class extends storage.ObservabilityStorage {
       return;
     }
     try {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
       await this.db.batchInsert({
         tableName: storage.TABLE_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
+          endedAt: span.endedAt instanceof Date ? span.endedAt.toISOString() : span.endedAt,
+          createdAt: now,
+          updatedAt: now
         }))
       });
     } catch (error$1) {
@@ -2287,6 +2674,7 @@ var ObservabilityMSSQL = class extends storage.ObservabilityStorage {
     if (!args.records || args.records.length === 0) {
       return;
     }
+    const now = (/* @__PURE__ */ new Date()).toISOString();
     try {
       const updates = args.records.map(({ traceId, spanId, updates: data }) => {
         const processedData = { ...data };
@@ -2296,6 +2684,7 @@ var ObservabilityMSSQL = class extends storage.ObservabilityStorage {
         if (processedData.startedAt instanceof Date) {
           processedData.startedAt = processedData.startedAt.toISOString();
         }
+        processedData.updatedAt = now;
         return {
           keys: { spanId, traceId },
           data: processedData
@@ -2349,18 +2738,24 @@ function transformScoreRow(row) {
     convertTimestamps: true
   });
 }
-var ScoresMSSQL = class extends storage.ScoresStorage {
+var ScoresMSSQL = class _ScoresMSSQL extends storage.ScoresStorage {
   pool;
   db;
   schema;
   needsConnect;
+  skipDefaultIndexes;
+  indexes;
+  /** Tables managed by this domain */
+  static MANAGED_TABLES = [storage.TABLE_SCORERS];
   constructor(config) {
     super();
-    const { pool, db, schema, needsConnect } = resolveMssqlConfig(config);
+    const { pool, schemaName, skipDefaultIndexes, indexes, needsConnect } = resolveMssqlConfig(config);
     this.pool = pool;
-    this.db = db;
-    this.schema = schema;
+    this.schema = schemaName;
+    this.db = new MssqlDB({ pool, schemaName, skipDefaultIndexes });
     this.needsConnect = needsConnect;
+    this.skipDefaultIndexes = skipDefaultIndexes;
+    this.indexes = indexes?.filter((idx) => _ScoresMSSQL.MANAGED_TABLES.includes(idx.table));
   }
   async init() {
     if (this.needsConnect) {
@@ -2368,6 +2763,52 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
       this.needsConnect = false;
     }
     await this.db.createTable({ tableName: storage.TABLE_SCORERS, schema: storage.TABLE_SCHEMAS[storage.TABLE_SCORERS] });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  /**
+   * Returns default index definitions for the scores domain tables.
+   * IMPORTANT: Uses seq_id DESC instead of createdAt DESC for MSSQL due to millisecond accuracy limitations
+   */
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.schema ? `${this.schema}_` : "";
+    return [
+      {
+        name: `${schemaPrefix}mastra_scores_trace_id_span_id_seqid_idx`,
+        table: storage.TABLE_SCORERS,
+        columns: ["traceId", "spanId", "seq_id DESC"]
+      }
+    ];
+  }
+  /**
+   * Creates default indexes for optimal query performance.
+   */
+  async createDefaultIndexes() {
+    if (this.skipDefaultIndexes) {
+      return;
+    }
+    for (const indexDef of this.getDefaultIndexDefinitions()) {
+      try {
+        await this.db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  /**
+   * Creates custom user-defined indexes for this domain's tables.
+   */
+  async createCustomIndexes() {
+    if (!this.indexes || this.indexes.length === 0) {
+      return;
+    }
+    for (const indexDef of this.indexes) {
+      try {
+        await this.db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
+      }
+    }
   }
   async dangerouslyClearAll() {
     await this.db.clearTable({ tableName: storage.TABLE_SCORERS });
@@ -2406,7 +2847,7 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER,
           details: {
-            scorer: score.scorer?.id ?? "unknown",
+            scorer: typeof score.scorer?.id === "string" ? score.scorer.id : String(score.scorer?.id ?? "unknown"),
             entityId: score.entityId ?? "unknown",
             entityType: score.entityType ?? "unknown",
             traceId: score.traceId ?? "",
@@ -2712,18 +3153,40 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
     }
   }
 };
-var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
+var WorkflowsMSSQL = class _WorkflowsMSSQL extends storage.WorkflowsStorage {
   pool;
   db;
   schema;
   needsConnect;
+  skipDefaultIndexes;
+  indexes;
+  /** Tables managed by this domain */
+  static MANAGED_TABLES = [storage.TABLE_WORKFLOW_SNAPSHOT];
   constructor(config) {
     super();
-    const { pool, db, schema, needsConnect } = resolveMssqlConfig(config);
+    const { pool, schemaName, skipDefaultIndexes, indexes, needsConnect } = resolveMssqlConfig(config);
     this.pool = pool;
-    this.db = db;
-    this.schema = schema;
+    this.schema = schemaName;
+    this.db = new MssqlDB({ pool, schemaName, skipDefaultIndexes });
     this.needsConnect = needsConnect;
+    this.skipDefaultIndexes = skipDefaultIndexes;
+    this.indexes = indexes?.filter((idx) => _WorkflowsMSSQL.MANAGED_TABLES.includes(idx.table));
+  }
+  /**
+   * Returns default index definitions for the workflows domain tables.
+   * Currently no default indexes are defined for workflows.
+   */
+  getDefaultIndexDefinitions() {
+    return [];
+  }
+  /**
+   * Creates default indexes for optimal query performance.
+   * Currently no default indexes are defined for workflows.
+   */
+  async createDefaultIndexes() {
+    if (this.skipDefaultIndexes) {
+      return;
+    }
   }
   async init() {
     if (this.needsConnect) {
@@ -2731,6 +3194,23 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
       this.needsConnect = false;
     }
     await this.db.createTable({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT, schema: storage.TABLE_SCHEMAS[storage.TABLE_WORKFLOW_SNAPSHOT] });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  /**
+   * Creates custom user-defined indexes for this domain's tables.
+   */
+  async createCustomIndexes() {
+    if (!this.indexes || this.indexes.length === 0) {
+      return;
+    }
+    for (const indexDef of this.indexes) {
+      try {
+        await this.db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
+      }
+    }
   }
   async dangerouslyClearAll() {
     await this.db.clearTable({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT });
@@ -3125,7 +3605,6 @@ var MSSQLStore = class extends storage.MastraStorage {
   pool;
   schema;
   isConnected = null;
-  #db;
   stores;
   constructor(config) {
     if (!config.id || typeof config.id !== "string" || config.id.trim() === "") {
@@ -3157,8 +3636,12 @@ var MSSQLStore = class extends storage.MastraStorage {
           options: config.options || { encrypt: true, trustServerCertificate: true }
         });
       }
-      this.#db = new MssqlDB({ pool: this.pool, schemaName: this.schema });
-      const domainConfig = { pool: this.pool, db: this.#db, schema: this.schema };
+      const domainConfig = {
+        pool: this.pool,
+        schemaName: this.schema,
+        skipDefaultIndexes: config.skipDefaultIndexes,
+        indexes: config.indexes
+      };
       const scores = new ScoresMSSQL(domainConfig);
       const workflows = new WorkflowsMSSQL(domainConfig);
       const memory = new MemoryMSSQL(domainConfig);
@@ -3187,11 +3670,6 @@ var MSSQLStore = class extends storage.MastraStorage {
     try {
       await this.isConnected;
       await super.init();
-      try {
-        await this.#db.createAutomaticIndexes();
-      } catch (indexError) {
-        this.logger?.warn?.("Failed to create indexes:", indexError);
-      }
     } catch (error$1) {
       this.isConnected = null;
       throw new error.MastraError(
@@ -3219,207 +3697,20 @@ var MSSQLStore = class extends storage.MastraStorage {
       hasColumn: true,
       createTable: true,
       deleteMessages: true,
+      observability: true,
+      indexManagement: true,
       listScoresBySpan: true,
-      observabilityInstance: true,
-      indexManagement: true
+      agents: false
     };
   }
   /**
-   * Memory
+   * Closes the MSSQL connection pool.
+   *
+   * This will close the connection pool, including pre-configured pools.
    */
-  async getThreadById({ threadId }) {
-    return this.stores.memory.getThreadById({ threadId });
-  }
-  async saveThread({ thread }) {
-    return this.stores.memory.saveThread({ thread });
-  }
-  async updateThread({
-    id,
-    title,
-    metadata
-  }) {
-    return this.stores.memory.updateThread({ id, title, metadata });
-  }
-  async deleteThread({ threadId }) {
-    return this.stores.memory.deleteThread({ threadId });
-  }
-  async listMessagesById({ messageIds }) {
-    return this.stores.memory.listMessagesById({ messageIds });
-  }
-  async saveMessages(args) {
-    return this.stores.memory.saveMessages(args);
-  }
-  async updateMessages({
-    messages
-  }) {
-    return this.stores.memory.updateMessages({ messages });
-  }
-  async deleteMessages(messageIds) {
-    return this.stores.memory.deleteMessages(messageIds);
-  }
-  async getResourceById({ resourceId }) {
-    return this.stores.memory.getResourceById({ resourceId });
-  }
-  async saveResource({ resource }) {
-    return this.stores.memory.saveResource({ resource });
-  }
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata
-  }) {
-    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
-  }
-  /**
-   * Workflows
-   */
-  async updateWorkflowResults({
-    workflowName,
-    runId,
-    stepId,
-    result,
-    requestContext
-  }) {
-    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, requestContext });
-  }
-  async updateWorkflowState({
-    workflowName,
-    runId,
-    opts
-  }) {
-    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
-  }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    resourceId,
-    snapshot
-  }) {
-    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, resourceId, snapshot });
-  }
-  async loadWorkflowSnapshot({
-    workflowName,
-    runId
-  }) {
-    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
-  }
-  async listWorkflowRuns(args = {}) {
-    return this.stores.workflows.listWorkflowRuns(args);
-  }
-  async getWorkflowRunById({
-    runId,
-    workflowName
-  }) {
-    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
-  }
-  async deleteWorkflowRunById({ runId, workflowName }) {
-    return this.stores.workflows.deleteWorkflowRunById({ runId, workflowName });
-  }
   async close() {
     await this.pool.close();
   }
-  /**
-   * Index Management
-   */
-  async createIndex(options) {
-    return this.#db.createIndex(options);
-  }
-  async listIndexes(tableName) {
-    return this.#db.listIndexes(tableName);
-  }
-  async describeIndex(indexName) {
-    return this.#db.describeIndex(indexName);
-  }
-  async dropIndex(indexName) {
-    return this.#db.dropIndex(indexName);
-  }
-  /**
-   * Tracing / Observability
-   */
-  getObservabilityStore() {
-    if (!this.stores.observability) {
-      throw new error.MastraError({
-        id: storage.createStorageErrorId("MSSQL", "OBSERVABILITY", "NOT_INITIALIZED"),
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.SYSTEM,
-        text: "Observability storage is not initialized"
-      });
-    }
-    return this.stores.observability;
-  }
-  async createSpan(span) {
-    return this.getObservabilityStore().createSpan(span);
-  }
-  async updateSpan({
-    spanId,
-    traceId,
-    updates
-  }) {
-    return this.getObservabilityStore().updateSpan({ spanId, traceId, updates });
-  }
-  async getTrace(traceId) {
-    return this.getObservabilityStore().getTrace(traceId);
-  }
-  async getTracesPaginated(args) {
-    return this.getObservabilityStore().getTracesPaginated(args);
-  }
-  async batchCreateSpans(args) {
-    return this.getObservabilityStore().batchCreateSpans(args);
-  }
-  async batchUpdateSpans(args) {
-    return this.getObservabilityStore().batchUpdateSpans(args);
-  }
-  async batchDeleteTraces(args) {
-    return this.getObservabilityStore().batchDeleteTraces(args);
-  }
-  /**
-   * Scorers
-   */
-  async getScoreById({ id: _id }) {
-    return this.stores.scores.getScoreById({ id: _id });
-  }
-  async listScoresByScorerId({
-    scorerId: _scorerId,
-    pagination: _pagination,
-    entityId: _entityId,
-    entityType: _entityType,
-    source: _source
-  }) {
-    return this.stores.scores.listScoresByScorerId({
-      scorerId: _scorerId,
-      pagination: _pagination,
-      entityId: _entityId,
-      entityType: _entityType,
-      source: _source
-    });
-  }
-  async saveScore(score) {
-    return this.stores.scores.saveScore(score);
-  }
-  async listScoresByRunId({
-    runId: _runId,
-    pagination: _pagination
-  }) {
-    return this.stores.scores.listScoresByRunId({ runId: _runId, pagination: _pagination });
-  }
-  async listScoresByEntityId({
-    entityId: _entityId,
-    entityType: _entityType,
-    pagination: _pagination
-  }) {
-    return this.stores.scores.listScoresByEntityId({
-      entityId: _entityId,
-      entityType: _entityType,
-      pagination: _pagination
-    });
-  }
-  async listScoresBySpan({
-    traceId,
-    spanId,
-    pagination: _pagination
-  }) {
-    return this.stores.scores.listScoresBySpan({ traceId, spanId, pagination: _pagination });
-  }
 };
 
 exports.MSSQLStore = MSSQLStore;