@mastra/mssql 0.0.0-netlify-no-bundle-20251127120354 → 0.0.0-new-button-export-20251219130424

package/dist/index.cjs

@@ -2,15 +2,16 @@
 
 var error = require('@mastra/core/error');
 var storage = require('@mastra/core/storage');
-var sql2 = require('mssql');
-var agent = require('@mastra/core/agent');
+var sql = require('mssql');
+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');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var sql2__default = /*#__PURE__*/_interopDefault(sql2);
+var sql__default = /*#__PURE__*/_interopDefault(sql);
 
 // src/storage/index.ts
 function getSchemaName(schema) {
@@ -22,259 +23,271 @@ 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;
-    }
+
+// 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 };
+  }
+  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 }
   });
-  return result;
+  const db = new MssqlDB({ pool, schemaName: config.schemaName });
+  return { pool, db, schema: config.schemaName, needsConnect: true };
 }
-
-// src/storage/domains/memory/index.ts
-var MemoryMSSQL = class extends storage.MemoryStorage {
+var MssqlDB = class extends base.MastraBase {
   pool;
-  schema;
-  operations;
-  _parseAndFormatMessages(messages, format) {
-    const messagesWithParsedContent = messages.map((message) => {
-      if (typeof message.content === "string") {
+  schemaName;
+  setupSchemaPromise = null;
+  schemaSetupComplete = void 0;
+  getSqlType(type, isPrimaryKey = false, useLargeStorage = false) {
+    switch (type) {
+      case "text":
+        if (useLargeStorage) {
+          return "NVARCHAR(MAX)";
+        }
+        return isPrimaryKey ? "NVARCHAR(255)" : "NVARCHAR(400)";
+      case "timestamp":
+        return "DATETIME2(7)";
+      case "uuid":
+        return "UNIQUEIDENTIFIER";
+      case "jsonb":
+        return "NVARCHAR(MAX)";
+      case "integer":
+        return "INT";
+      case "bigint":
+        return "BIGINT";
+      case "float":
+        return "FLOAT";
+      case "boolean":
+        return "BIT";
+      default:
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MSSQL", "TYPE", "NOT_SUPPORTED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        });
+    }
+  }
+  constructor({ pool, schemaName }) {
+    super({ component: "STORAGE", name: "MssqlDB" });
+    this.pool = pool;
+    this.schemaName = schemaName;
+  }
+  async hasColumn(table, column) {
+    const schema = this.schemaName || "dbo";
+    const request = this.pool.request();
+    request.input("schema", schema);
+    request.input("table", table);
+    request.input("column", column);
+    request.input("columnLower", column.toLowerCase());
+    const result = await request.query(
+      `SELECT 1 FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @table AND (COLUMN_NAME = @column OR COLUMN_NAME = @columnLower)`
+    );
+    return result.recordset.length > 0;
+  }
+  async setupSchema() {
+    if (!this.schemaName || this.schemaSetupComplete) {
+      return;
+    }
+    if (!this.setupSchemaPromise) {
+      this.setupSchemaPromise = (async () => {
         try {
-          return { ...message, content: JSON.parse(message.content) };
-        } catch {
-          return message;
+          const checkRequest = this.pool.request();
+          checkRequest.input("schemaName", this.schemaName);
+          const checkResult = await checkRequest.query(`
+            SELECT 1 AS found FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = @schemaName
+          `);
+          const schemaExists = Array.isArray(checkResult.recordset) && checkResult.recordset.length > 0;
+          if (!schemaExists) {
+            try {
+              await this.pool.request().query(`CREATE SCHEMA [${this.schemaName}]`);
+              this.logger?.info?.(`Schema "${this.schemaName}" created successfully`);
+            } catch (error) {
+              this.logger?.error?.(`Failed to create schema "${this.schemaName}"`, { error });
+              throw new Error(
+                `Unable to create schema "${this.schemaName}". This requires CREATE privilege on the database. Either create the schema manually or grant CREATE privilege to the user.`
+              );
+            }
+          }
+          this.schemaSetupComplete = true;
+          this.logger?.debug?.(`Schema "${this.schemaName}" is ready for use`);
+        } catch (error) {
+          this.schemaSetupComplete = void 0;
+          this.setupSchemaPromise = null;
+          throw error;
+        } finally {
+          this.setupSchemaPromise = null;
         }
-      }
-      return message;
-    });
-    const cleanMessages = messagesWithParsedContent.map(({ seq_id, ...rest }) => rest);
-    const list = new agent.MessageList().add(cleanMessages, "memory");
-    return format === "v2" ? list.get.all.db() : list.get.all.v1();
+      })();
+    }
+    await this.setupSchemaPromise;
   }
-  constructor({
-    pool,
-    schema,
-    operations
+  async insert({
+    tableName,
+    record,
+    transaction
   }) {
-    super();
-    this.pool = pool;
-    this.schema = schema;
-    this.operations = operations;
+    try {
+      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}`, sql__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}`, preparedValue);
+        }
+      });
+      await request.query(insertSql);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MSSQL", "INSERT", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
   }
-  async getThreadById({ threadId }) {
+  async clearTable({ tableName }) {
+    const fullTableName = getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) });
     try {
-      const sql5 = `SELECT 
-        id,
-        [resourceId],
-        title,
-        metadata,
-        [createdAt],
-        [updatedAt]
-      FROM ${getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) })}
-      WHERE id = @threadId`;
-      const request = this.pool.request();
-      request.input("threadId", threadId);
-      const resultSet = await request.query(sql5);
-      const thread = resultSet.recordset[0] || null;
-      if (!thread) {
-        return null;
+      try {
+        await this.pool.request().query(`TRUNCATE TABLE ${fullTableName}`);
+      } catch (truncateError) {
+        if (truncateError?.number === 4712) {
+          await this.pool.request().query(`DELETE FROM ${fullTableName}`);
+        } else {
+          throw truncateError;
+        }
       }
-      return {
-        ...thread,
-        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
-        createdAt: thread.createdAt,
-        updatedAt: thread.updatedAt
-      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_GET_THREAD_BY_ID_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "CLEAR_TABLE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            threadId
+            tableName
           }
         },
         error$1
       );
     }
   }
-  async listThreadsByResourceId(args) {
-    const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
-    if (page < 0) {
-      throw new error.MastraError({
-        id: "MASTRA_STORAGE_MSSQL_STORE_INVALID_PAGE",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "Page number must be non-negative",
-        details: {
-          resourceId,
-          page
-        }
-      });
+  getDefaultValue(type) {
+    switch (type) {
+      case "timestamp":
+        return "DEFAULT SYSUTCDATETIME()";
+      case "jsonb":
+        return "DEFAULT N'{}'";
+      case "boolean":
+        return "DEFAULT 0";
+      default:
+        return storage.getDefaultValue(type);
     }
-    const perPage = storage.normalizePerPage(perPageInput, 100);
-    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
-    const { field, direction } = this.parseOrderBy(orderBy);
-    try {
-      const baseQuery = `FROM ${getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) })} WHERE [resourceId] = @resourceId`;
-      const countQuery = `SELECT COUNT(*) as count ${baseQuery}`;
-      const countRequest = this.pool.request();
-      countRequest.input("resourceId", resourceId);
-      const countResult = await countRequest.query(countQuery);
-      const total = parseInt(countResult.recordset[0]?.count ?? "0", 10);
-      if (total === 0) {
-        return {
-          threads: [],
-          total: 0,
-          page,
-          perPage: perPageForResponse,
-          hasMore: false
-        };
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    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();
+      }).join(",\n");
+      if (this.schemaName) {
+        await this.setupSchema();
       }
-      const orderByField = field === "createdAt" ? "[createdAt]" : "[updatedAt]";
-      const dir = (direction || "DESC").toUpperCase() === "ASC" ? "ASC" : "DESC";
-      const limitValue = perPageInput === false ? total : perPage;
-      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("offset", offset);
-      if (limitValue > 2147483647) {
-        dataRequest.input("perPage", sql2__default.default.BigInt, limitValue);
-      } else {
-        dataRequest.input("perPage", limitValue);
+      const checkTableRequest = this.pool.request();
+      checkTableRequest.input(
+        "tableName",
+        getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) }).replace(/[[\]]/g, "").split(".").pop()
+      );
+      const checkTableSql = `SELECT 1 AS found FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @tableName`;
+      checkTableRequest.input("schema", this.schemaName || "dbo");
+      const checkTableResult = await checkTableRequest.query(checkTableSql);
+      const tableExists = Array.isArray(checkTableResult.recordset) && checkTableResult.recordset.length > 0;
+      if (!tableExists) {
+        const createSql = `CREATE TABLE ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} (
+${columns}
+)`;
+        await this.pool.request().query(createSql);
       }
-      const rowsResult = await dataRequest.query(dataQuery);
-      const rows = rowsResult.recordset || [];
-      const threads = rows.map((thread) => ({
-        ...thread,
-        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
-        createdAt: thread.createdAt,
-        updatedAt: thread.updatedAt
-      }));
-      return {
-        threads,
-        total,
-        page,
-        perPage: perPageForResponse,
-        hasMore: perPageInput === false ? false : offset + perPage < total
-      };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_MSSQL_STORE_LIST_THREADS_BY_RESOURCE_ID_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            resourceId,
-            page
-          }
-        },
-        error$1
+      const columnCheckSql = `
+        SELECT 1 AS found
+        FROM INFORMATION_SCHEMA.COLUMNS
+        WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @tableName AND COLUMN_NAME = 'seq_id'
+      `;
+      const checkColumnRequest = this.pool.request();
+      checkColumnRequest.input("schema", this.schemaName || "dbo");
+      checkColumnRequest.input(
+        "tableName",
+        getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) }).replace(/[[\]]/g, "").split(".").pop()
       );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException?.(mastraError);
-      return {
-        threads: [],
-        total: 0,
-        page,
-        perPage: perPageForResponse,
-        hasMore: false
-      };
-    }
-  }
-  async saveThread({ thread }) {
-    try {
-      const table = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
-      const mergeSql = `MERGE INTO ${table} WITH (HOLDLOCK) AS target
-        USING (SELECT @id AS id) AS source
-        ON (target.id = source.id)
-        WHEN MATCHED THEN
-          UPDATE SET
-            [resourceId] = @resourceId,
-            title = @title,
-            metadata = @metadata,
-            [updatedAt] = @updatedAt
-        WHEN NOT MATCHED THEN
-          INSERT (id, [resourceId], title, metadata, [createdAt], [updatedAt])
-          VALUES (@id, @resourceId, @title, @metadata, @createdAt, @updatedAt);`;
-      const req = this.pool.request();
-      req.input("id", thread.id);
-      req.input("resourceId", thread.resourceId);
-      req.input("title", thread.title);
-      const metadata = thread.metadata ? JSON.stringify(thread.metadata) : null;
-      if (metadata === null) {
-        req.input("metadata", sql2__default.default.NVarChar, null);
-      } else {
-        req.input("metadata", metadata);
+      const columnResult = await checkColumnRequest.query(columnCheckSql);
+      const columnExists = Array.isArray(columnResult.recordset) && columnResult.recordset.length > 0;
+      if (!columnExists) {
+        const alterSql = `ALTER TABLE ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} ADD seq_id BIGINT IDENTITY(1,1)`;
+        await this.pool.request().query(alterSql);
+      }
+      if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
+        const constraintName = "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])`;
+          await this.pool.request().query(addConstraintSql);
+        }
       }
-      req.input("createdAt", sql2__default.default.DateTime2, thread.createdAt);
-      req.input("updatedAt", sql2__default.default.DateTime2, thread.updatedAt);
-      await req.query(mergeSql);
-      return thread;
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_SAVE_THREAD_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "CREATE_TABLE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            threadId: thread.id
+            tableName
           }
         },
         error$1
@@ -282,1978 +295,2049 @@ var MemoryMSSQL = class extends storage.MemoryStorage {
     }
   }
   /**
-   * Updates a thread's title and metadata, merging with existing metadata. Returns the updated thread.
+   * Alters table schema to add columns if they don't exist
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
    */
-  async updateThread({
-    id,
-    title,
-    metadata
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists
   }) {
-    const existingThread = await this.getThreadById({ threadId: id });
-    if (!existingThread) {
-      throw new error.MastraError({
-        id: "MASTRA_STORAGE_MSSQL_STORE_UPDATE_THREAD_FAILED",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: `Thread ${id} not found`,
-        details: {
-          threadId: id,
-          title
-        }
-      });
-    }
-    const mergedMetadata = {
-      ...existingThread.metadata,
-      ...metadata
-    };
+    const fullTableName = getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) });
     try {
-      const table = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
-      const sql5 = `UPDATE ${table}
-        SET title = @title,
-            metadata = @metadata,
-            [updatedAt] = @updatedAt
-        OUTPUT INSERTED.*
-        WHERE id = @id`;
-      const req = this.pool.request();
-      req.input("id", id);
-      req.input("title", title);
-      req.input("metadata", JSON.stringify(mergedMetadata));
-      req.input("updatedAt", /* @__PURE__ */ new Date());
-      const result = await req.query(sql5);
-      let thread = result.recordset && result.recordset[0];
-      if (thread && "seq_id" in thread) {
-        const { seq_id, ...rest } = thread;
-        thread = rest;
-      }
-      if (!thread) {
-        throw new error.MastraError({
-          id: "MASTRA_STORAGE_MSSQL_STORE_UPDATE_THREAD_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          text: `Thread ${id} not found after update`,
-          details: {
-            threadId: id,
-            title
+      for (const columnName of ifNotExists) {
+        if (schema[columnName]) {
+          const columnCheckRequest = this.pool.request();
+          columnCheckRequest.input("tableName", fullTableName.replace(/[[\]]/g, "").split(".").pop());
+          columnCheckRequest.input("columnName", columnName);
+          columnCheckRequest.input("schema", this.schemaName || "dbo");
+          const checkSql = `SELECT 1 AS found FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @tableName AND COLUMN_NAME = @columnName`;
+          const checkResult = await columnCheckRequest.query(checkSql);
+          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 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");
+            const alterSql = `ALTER TABLE ${fullTableName} ADD [${parsedColumnName}] ${sqlType} ${nullable} ${defaultValue}`.trim();
+            await this.pool.request().query(alterSql);
+            this.logger?.debug?.(`Ensured column ${parsedColumnName} exists in table ${fullTableName}`);
           }
-        });
+        }
       }
-      return {
-        ...thread,
-        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
-        createdAt: thread.createdAt,
-        updatedAt: thread.updatedAt
-      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_UPDATE_THREAD_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "ALTER_TABLE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            threadId: id,
-            title
+            tableName
           }
         },
         error$1
       );
     }
   }
-  async deleteThread({ threadId }) {
-    const messagesTable = getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
-    const threadsTable = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
-    const deleteMessagesSql = `DELETE FROM ${messagesTable} WHERE [thread_id] = @threadId`;
-    const deleteThreadSql = `DELETE FROM ${threadsTable} WHERE id = @threadId`;
-    const tx = this.pool.transaction();
+  async load({ tableName, keys }) {
     try {
-      await tx.begin();
-      const req = tx.request();
-      req.input("threadId", threadId);
-      await req.query(deleteMessagesSql);
-      await req.query(deleteThreadSql);
-      await tx.commit();
-    } catch (error$1) {
-      await tx.rollback().catch(() => {
+      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 sqlQuery = `SELECT * FROM ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} WHERE ${conditions}`;
+      const request = this.pool.request();
+      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(sqlQuery);
+      const result = resultSet.recordset[0] || null;
+      if (!result) {
+        return null;
+      }
+      if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
+        const snapshot = result;
+        if (typeof snapshot.snapshot === "string") {
+          snapshot.snapshot = JSON.parse(snapshot.snapshot);
+        }
+        return snapshot;
+      }
+      return result;
+    } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_DELETE_THREAD_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "LOAD", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            threadId
+            tableName
           }
         },
         error$1
       );
     }
   }
-  async _getIncludedMessages({
-    threadId,
-    include
-  }) {
-    if (!threadId.trim()) throw new Error("threadId must be a non-empty string");
-    if (!include) return null;
-    const unionQueries = [];
-    const paramValues = [];
-    let paramIdx = 1;
-    const paramNames = [];
-    for (const inc of include) {
-      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
-      const searchId = inc.threadId || threadId;
-      const pThreadId = `@p${paramIdx}`;
-      const pId = `@p${paramIdx + 1}`;
-      const pPrev = `@p${paramIdx + 2}`;
-      const pNext = `@p${paramIdx + 3}`;
-      unionQueries.push(
-        `
-          SELECT
-            m.id, 
-            m.content, 
-            m.role, 
-            m.type,
-            m.[createdAt], 
-            m.thread_id AS threadId,
-            m.[resourceId],
-            m.seq_id
-          FROM (
-            SELECT *, ROW_NUMBER() OVER (ORDER BY [createdAt] ASC) as row_num
-            FROM ${getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })}
-            WHERE [thread_id] = ${pThreadId}
-          ) AS m
-          WHERE m.id = ${pId}
-          OR EXISTS (
-            SELECT 1
-            FROM (
-              SELECT *, ROW_NUMBER() OVER (ORDER BY [createdAt] ASC) as row_num
-              FROM ${getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })}
-              WHERE [thread_id] = ${pThreadId}
-            ) AS target
-            WHERE target.id = ${pId}
-            AND (
-              -- Get previous messages (messages that come BEFORE the target)
-              (m.row_num < target.row_num AND m.row_num >= target.row_num - ${pPrev})
-              OR
-              -- Get next messages (messages that come AFTER the target)
-              (m.row_num > target.row_num AND m.row_num <= target.row_num + ${pNext})
-            )
-          )
-        `
-      );
-      paramValues.push(searchId, id, withPreviousMessages, withNextMessages);
-      paramNames.push(`p${paramIdx}`, `p${paramIdx + 1}`, `p${paramIdx + 2}`, `p${paramIdx + 3}`);
-      paramIdx += 4;
-    }
-    const finalQuery = `
-      SELECT * FROM (
-        ${unionQueries.join(" UNION ALL ")}
-      ) AS union_result
-      ORDER BY [seq_id] ASC
-    `;
-    const req = this.pool.request();
-    for (let i = 0; i < paramValues.length; ++i) {
-      req.input(paramNames[i], paramValues[i]);
-    }
-    const result = await req.query(finalQuery);
-    const includedRows = result.recordset || [];
-    const seen = /* @__PURE__ */ new Set();
-    const dedupedRows = includedRows.filter((row) => {
-      if (seen.has(row.id)) return false;
-      seen.add(row.id);
-      return true;
-    });
-    return dedupedRows;
-  }
-  async listMessagesById({ messageIds }) {
-    if (messageIds.length === 0) return { messages: [] };
-    const selectStatement = `SELECT seq_id, id, content, role, type, [createdAt], thread_id AS threadId, resourceId`;
-    const orderByStatement = `ORDER BY [seq_id] DESC`;
+  async batchInsert({ tableName, records }) {
+    const transaction = this.pool.transaction();
     try {
-      let rows = [];
-      let query = `${selectStatement} FROM ${getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })} WHERE [id] IN (${messageIds.map((_, i) => `@id${i}`).join(", ")})`;
-      const request = this.pool.request();
-      messageIds.forEach((id, i) => request.input(`id${i}`, id));
-      query += ` ${orderByStatement}`;
-      const result = await request.query(query);
-      const remainingRows = result.recordset || [];
-      rows.push(...remainingRows);
-      rows.sort((a, b) => {
-        const timeDiff = a.seq_id - b.seq_id;
-        return timeDiff;
-      });
-      const messagesWithParsedContent = rows.map((row) => {
-        if (typeof row.content === "string") {
-          try {
-            return { ...row, content: JSON.parse(row.content) };
-          } catch {
-            return row;
-          }
-        }
-        return row;
-      });
-      const cleanMessages = messagesWithParsedContent.map(({ seq_id, ...rest }) => rest);
-      const list = new agent.MessageList().add(cleanMessages, "memory");
-      return { messages: list.get.all.db() };
+      await transaction.begin();
+      for (const record of records) {
+        await this.insert({ tableName, record, transaction });
+      }
+      await transaction.commit();
     } catch (error$1) {
-      const mastraError = new error.MastraError(
+      await transaction.rollback();
+      throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_LIST_MESSAGES_BY_ID_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "BATCH_INSERT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            messageIds: JSON.stringify(messageIds)
+            tableName,
+            numberOfRecords: records.length
           }
         },
         error$1
       );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException?.(mastraError);
-      return { messages: [] };
     }
   }
-  async listMessages(args) {
-    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
-    if (!threadId.trim()) {
-      throw new error.MastraError(
-        {
-          id: "STORAGE_MSSQL_LIST_MESSAGES_INVALID_THREAD_ID",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
-        },
-        new Error("threadId must be a non-empty string")
-      );
-    }
-    if (page < 0) {
-      throw new error.MastraError({
-        id: "MASTRA_STORAGE_MSSQL_STORE_INVALID_PAGE",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.USER,
-        text: "Page number must be non-negative",
-        details: {
-          threadId,
-          page
-        }
-      });
-    }
-    const perPage = storage.normalizePerPage(perPageInput, 40);
-    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+  async dropTable({ tableName }) {
     try {
-      const { field, direction } = this.parseOrderBy(orderBy, "ASC");
-      const orderByStatement = `ORDER BY [${field}] ${direction}, [seq_id] ${direction}`;
-      const tableName = getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
-      const baseQuery = `SELECT seq_id, id, content, role, type, [createdAt], thread_id AS threadId, resourceId FROM ${tableName}`;
-      const filters = {
-        thread_id: threadId,
-        ...resourceId ? { resourceId } : {},
-        ...buildDateRangeFilter(filter?.dateRange, "createdAt")
-      };
-      const { sql: actualWhereClause = "", params: whereParams } = prepareWhereClause(
-        filters);
-      const bindWhereParams = (req) => {
-        Object.entries(whereParams).forEach(([paramName, paramValue]) => req.input(paramName, paramValue));
-      };
-      const countRequest = this.pool.request();
-      bindWhereParams(countRequest);
-      const countResult = await countRequest.query(`SELECT COUNT(*) as total FROM ${tableName}${actualWhereClause}`);
-      const total = parseInt(countResult.recordset[0]?.total, 10) || 0;
-      const fetchBaseMessages = async () => {
-        const request = this.pool.request();
-        bindWhereParams(request);
-        if (perPageInput === false) {
-          const result2 = await request.query(`${baseQuery}${actualWhereClause} ${orderByStatement}`);
-          return result2.recordset || [];
-        }
-        request.input("offset", offset);
-        request.input("limit", perPage > 2147483647 ? sql2__default.default.BigInt : sql2__default.default.Int, perPage);
-        const result = await request.query(
-          `${baseQuery}${actualWhereClause} ${orderByStatement} OFFSET @offset ROWS FETCH NEXT @limit ROWS ONLY`
-        );
-        return result.recordset || [];
-      };
-      const baseRows = perPage === 0 ? [] : await fetchBaseMessages();
-      const messages = [...baseRows];
-      const seqById = /* @__PURE__ */ new Map();
-      messages.forEach((msg) => {
-        if (typeof msg.seq_id === "number") seqById.set(msg.id, msg.seq_id);
-      });
-      if (total === 0 && messages.length === 0 && (!include || include.length === 0)) {
-        return {
-          messages: [],
-          total: 0,
-          page,
-          perPage: perPageForResponse,
-          hasMore: false
-        };
-      }
-      if (include?.length) {
-        const messageIds = new Set(messages.map((m) => m.id));
-        const includeMessages = await this._getIncludedMessages({ threadId, include });
-        includeMessages?.forEach((msg) => {
-          if (!messageIds.has(msg.id)) {
-            messages.push(msg);
-            messageIds.add(msg.id);
-            if (typeof msg.seq_id === "number") seqById.set(msg.id, msg.seq_id);
-          }
-        });
-      }
-      const parsed = this._parseAndFormatMessages(messages, "v2");
-      const mult = direction === "ASC" ? 1 : -1;
-      const finalMessages = parsed.sort((a, b) => {
-        const aVal = field === "createdAt" ? new Date(a.createdAt).getTime() : a[field];
-        const bVal = field === "createdAt" ? new Date(b.createdAt).getTime() : b[field];
-        if (aVal == null || bVal == null) {
-          return aVal == null && bVal == null ? a.id.localeCompare(b.id) : aVal == null ? 1 : -1;
-        }
-        const diff = (typeof aVal === "number" && typeof bVal === "number" ? aVal - bVal : String(aVal).localeCompare(String(bVal))) * mult;
-        if (diff !== 0) return diff;
-        const seqA = seqById.get(a.id);
-        const seqB = seqById.get(b.id);
-        return seqA != null && seqB != null ? (seqA - seqB) * mult : a.id.localeCompare(b.id);
-      });
-      const returnedThreadMessageCount = finalMessages.filter((m) => m.threadId === threadId).length;
-      const hasMore = perPageInput !== false && returnedThreadMessageCount < total && offset + perPage < total;
-      return {
-        messages: finalMessages,
-        total,
-        page,
-        perPage: perPageForResponse,
-        hasMore
-      };
+      const tableNameWithSchema = getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) });
+      await this.pool.request().query(`DROP TABLE IF EXISTS ${tableNameWithSchema}`);
     } catch (error$1) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_LIST_MESSAGES_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "DROP_TABLE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            threadId,
-            resourceId: resourceId ?? ""
+            tableName
           }
         },
         error$1
       );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException?.(mastraError);
-      return {
-        messages: [],
-        total: 0,
-        page,
-        perPage: perPageForResponse,
-        hasMore: false
-      };
     }
   }
-  async saveMessages({ messages }) {
-    if (messages.length === 0) return { messages: [] };
-    const threadId = messages[0]?.threadId;
-    if (!threadId) {
-      throw new error.MastraError({
-        id: "MASTRA_STORAGE_MSSQL_STORE_SAVE_MESSAGES_FAILED",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.THIRD_PARTY,
-        text: `Thread ID is required`
-      });
+  /**
+   * Prepares a value for database operations, handling Date objects and JSON serialization
+   */
+  prepareValue(value, columnName, tableName) {
+    if (value === null || value === void 0) {
+      return value;
     }
-    const thread = await this.getThreadById({ threadId });
-    if (!thread) {
-      throw new error.MastraError({
-        id: "MASTRA_STORAGE_MSSQL_STORE_SAVE_MESSAGES_FAILED",
-        domain: error.ErrorDomain.STORAGE,
-        category: error.ErrorCategory.THIRD_PARTY,
-        text: `Thread ${threadId} not found`,
-        details: { threadId }
-      });
+    if (value instanceof Date) {
+      return value;
     }
-    const tableMessages = getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
-    const tableThreads = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
-    try {
-      const transaction = this.pool.transaction();
-      await transaction.begin();
-      try {
-        for (const message of messages) {
-          if (!message.threadId) {
-            throw new Error(
-              `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`
-            );
-          }
-          if (!message.resourceId) {
-            throw new Error(
-              `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`
-            );
-          }
-          const request = transaction.request();
-          request.input("id", message.id);
-          request.input("thread_id", message.threadId);
-          request.input(
-            "content",
-            typeof message.content === "string" ? message.content : JSON.stringify(message.content)
-          );
-          request.input("createdAt", sql2__default.default.DateTime2, message.createdAt);
-          request.input("role", message.role);
-          request.input("type", message.type || "v2");
-          request.input("resourceId", message.resourceId);
-          const mergeSql = `MERGE INTO ${tableMessages} AS target
-            USING (SELECT @id AS id) AS src
-            ON target.id = src.id
-            WHEN MATCHED THEN UPDATE SET
-              thread_id = @thread_id,
-              content = @content,
-              [createdAt] = @createdAt,
-              role = @role,
-              type = @type,
-              resourceId = @resourceId
-            WHEN NOT MATCHED THEN INSERT (id, thread_id, content, [createdAt], role, type, resourceId)
-              VALUES (@id, @thread_id, @content, @createdAt, @role, @type, @resourceId);`;
-          await request.query(mergeSql);
-        }
-        const threadReq = transaction.request();
-        threadReq.input("updatedAt", sql2__default.default.DateTime2, /* @__PURE__ */ new Date());
-        threadReq.input("id", threadId);
-        await threadReq.query(`UPDATE ${tableThreads} SET [updatedAt] = @updatedAt WHERE id = @id`);
-        await transaction.commit();
-      } catch (error) {
-        await transaction.rollback();
-        throw error;
-      }
-      const messagesWithParsedContent = messages.map((message) => {
-        if (typeof message.content === "string") {
+    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 {
-            return { ...message, content: JSON.parse(message.content) };
+            JSON.parse(trimmed);
+            return trimmed;
           } catch {
-            return message;
           }
         }
-        return message;
+        return JSON.stringify(value);
+      }
+      if (typeof value === "bigint") {
+        return value.toString();
+      }
+      return JSON.stringify(value);
+    }
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return value;
+  }
+  /**
+   * 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 sql__default.default.NVarChar;
+      case "timestamp":
+        return sql__default.default.DateTime2;
+      case "uuid":
+        return sql__default.default.UniqueIdentifier;
+      case "jsonb":
+        return sql__default.default.NVarChar;
+      case "integer":
+        return sql__default.default.Int;
+      case "bigint":
+        return sql__default.default.BigInt;
+      case "float":
+        return sql__default.default.Float;
+      case "boolean":
+        return sql__default.default.Bit;
+      default:
+        return sql__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: storage.createStorageErrorId("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: storage.createStorageErrorId("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 list = new agent.MessageList().add(messagesWithParsedContent, "memory");
-      return { messages: list.get.all.db() };
+      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_SAVE_MESSAGES_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "UPDATE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { threadId }
+          details: {
+            tableName
+          }
         },
         error$1
       );
     }
   }
-  async updateMessages({
-    messages
+  /**
+   * Update multiple records in a single batch transaction
+   */
+  async batchUpdate({
+    tableName,
+    updates
   }) {
-    if (!messages || messages.length === 0) {
-      return [];
-    }
-    const messageIds = messages.map((m) => m.id);
-    const idParams = messageIds.map((_, i) => `@id${i}`).join(", ");
-    let selectQuery = `SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId FROM ${getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })}`;
-    if (idParams.length > 0) {
-      selectQuery += ` WHERE id IN (${idParams})`;
-    } else {
-      return [];
-    }
-    const selectReq = this.pool.request();
-    messageIds.forEach((id, i) => selectReq.input(`id${i}`, id));
-    const existingMessagesDb = (await selectReq.query(selectQuery)).recordset;
-    if (!existingMessagesDb || existingMessagesDb.length === 0) {
-      return [];
-    }
-    const existingMessages = existingMessagesDb.map((msg) => {
-      if (typeof msg.content === "string") {
-        try {
-          msg.content = JSON.parse(msg.content);
-        } catch {
-        }
-      }
-      return msg;
-    });
-    const threadIdsToUpdate = /* @__PURE__ */ new Set();
     const transaction = this.pool.transaction();
     try {
       await transaction.begin();
-      for (const existingMessage of existingMessages) {
-        const updatePayload = messages.find((m) => m.id === existingMessage.id);
-        if (!updatePayload) continue;
-        const { id, ...fieldsToUpdate } = updatePayload;
-        if (Object.keys(fieldsToUpdate).length === 0) continue;
-        threadIdsToUpdate.add(existingMessage.threadId);
-        if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
-          threadIdsToUpdate.add(updatePayload.threadId);
-        }
-        const setClauses = [];
-        const req = transaction.request();
-        req.input("id", id);
-        const columnMapping = { threadId: "thread_id" };
-        const updatableFields = { ...fieldsToUpdate };
-        if (updatableFields.content) {
-          const newContent = {
-            ...existingMessage.content,
-            ...updatableFields.content,
-            ...existingMessage.content?.metadata && updatableFields.content.metadata ? { metadata: { ...existingMessage.content.metadata, ...updatableFields.content.metadata } } : {}
-          };
-          setClauses.push(`content = @content`);
-          req.input("content", JSON.stringify(newContent));
-          delete updatableFields.content;
-        }
-        for (const key in updatableFields) {
-          if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
-            const dbColumn = columnMapping[key] || key;
-            setClauses.push(`[${dbColumn}] = @${dbColumn}`);
-            req.input(dbColumn, updatableFields[key]);
-          }
-        }
-        if (setClauses.length > 0) {
-          const updateSql = `UPDATE ${getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })} SET ${setClauses.join(", ")} WHERE id = @id`;
-          await req.query(updateSql);
-        }
-      }
-      if (threadIdsToUpdate.size > 0) {
-        const threadIdParams = Array.from(threadIdsToUpdate).map((_, i) => `@tid${i}`).join(", ");
-        const threadReq = transaction.request();
-        Array.from(threadIdsToUpdate).forEach((tid, i) => threadReq.input(`tid${i}`, tid));
-        threadReq.input("updatedAt", (/* @__PURE__ */ new Date()).toISOString());
-        const threadSql = `UPDATE ${getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) })} SET updatedAt = @updatedAt WHERE id IN (${threadIdParams})`;
-        await threadReq.query(threadSql);
+      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_UPDATE_MESSAGES_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "BATCH_UPDATE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName,
+            numberOfRecords: updates.length
+          }
+        },
+        error$1
       );
     }
-    const refetchReq = this.pool.request();
-    messageIds.forEach((id, i) => refetchReq.input(`id${i}`, id));
-    const updatedMessages = (await refetchReq.query(selectQuery)).recordset;
-    return (updatedMessages || []).map((message) => {
-      if (typeof message.content === "string") {
-        try {
-          message.content = JSON.parse(message.content);
-        } catch {
-        }
-      }
-      return message;
-    });
   }
-  async deleteMessages(messageIds) {
-    if (!messageIds || messageIds.length === 0) {
+  /**
+   * 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 {
-      const messageTableName = getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) });
-      const threadTableName = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
-      const placeholders = messageIds.map((_, idx) => `@p${idx + 1}`).join(",");
-      const request = this.pool.request();
-      messageIds.forEach((id, idx) => {
-        request.input(`p${idx + 1}`, id);
-      });
-      const messages = await request.query(
-        `SELECT DISTINCT [thread_id] FROM ${messageTableName} WHERE [id] IN (${placeholders})`
-      );
-      const threadIds = messages.recordset?.map((msg) => msg.thread_id).filter(Boolean) || [];
-      const transaction = this.pool.transaction();
       await transaction.begin();
-      try {
-        const deleteRequest = transaction.request();
-        messageIds.forEach((id, idx) => {
-          deleteRequest.input(`p${idx + 1}`, id);
-        });
-        await deleteRequest.query(`DELETE FROM ${messageTableName} WHERE [id] IN (${placeholders})`);
-        if (threadIds.length > 0) {
-          for (const threadId of threadIds) {
-            const updateRequest = transaction.request();
-            updateRequest.input("p1", threadId);
-            await updateRequest.query(`UPDATE ${threadTableName} SET [updatedAt] = GETDATE() WHERE [id] = @p1`);
+      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);
           }
-        }
-        await transaction.commit();
-      } catch (error) {
-        try {
-          await transaction.rollback();
-        } catch {
-        }
-        throw error;
+        });
+        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_DELETE_MESSAGES_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "BATCH_DELETE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { messageIds: messageIds.join(", ") }
+          details: {
+            tableName,
+            numberOfRecords: keys.length
+          }
         },
         error$1
       );
     }
   }
-  async getResourceById({ resourceId }) {
-    const tableName = getTableName({ indexName: storage.TABLE_RESOURCES, schemaName: getSchemaName(this.schema) });
+  /**
+   * Create a new index on a table
+   */
+  async createIndex(options) {
     try {
-      const req = this.pool.request();
-      req.input("resourceId", resourceId);
-      const result = (await req.query(`SELECT * FROM ${tableName} WHERE id = @resourceId`)).recordset[0];
-      if (!result) {
-        return null;
+      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;
       }
-      return {
-        id: result.id,
-        createdAt: result.createdAt,
-        updatedAt: result.updatedAt,
-        workingMemory: result.workingMemory,
-        metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
-      };
+      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) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_GET_RESOURCE_BY_ID_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "INDEX_CREATE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { resourceId }
+          details: {
+            indexName: options.name,
+            tableName: options.table
+          }
         },
         error$1
       );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException?.(mastraError);
-      throw mastraError;
     }
   }
-  async saveResource({ resource }) {
-    await this.operations.insert({
-      tableName: storage.TABLE_RESOURCES,
-      record: {
-        ...resource,
-        metadata: resource.metadata
-      }
-    });
-    return resource;
-  }
-  async updateResource({
-    resourceId,
-    workingMemory,
-    metadata
-  }) {
+  /**
+   * Drop an existing index
+   */
+  async dropIndex(indexName) {
     try {
-      const existingResource = await this.getResourceById({ resourceId });
-      if (!existingResource) {
-        const newResource = {
-          id: resourceId,
-          workingMemory,
-          metadata: metadata || {},
-          createdAt: /* @__PURE__ */ new Date(),
-          updatedAt: /* @__PURE__ */ new Date()
-        };
-        return this.saveResource({ resource: newResource });
-      }
-      const updatedResource = {
-        ...existingResource,
-        workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
-        metadata: {
-          ...existingResource.metadata,
-          ...metadata
-        },
-        updatedAt: /* @__PURE__ */ new Date()
-      };
-      const tableName = getTableName({ indexName: storage.TABLE_RESOURCES, schemaName: getSchemaName(this.schema) });
-      const updates = [];
-      const req = this.pool.request();
-      if (workingMemory !== void 0) {
-        updates.push("workingMemory = @workingMemory");
-        req.input("workingMemory", workingMemory);
+      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 (metadata) {
-        updates.push("metadata = @metadata");
-        req.input("metadata", JSON.stringify(updatedResource.metadata));
+      if (result.recordset.length > 1) {
+        const tables = result.recordset.map((r) => r.table_name).join(", ");
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("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.`
+        });
       }
-      updates.push("updatedAt = @updatedAt");
-      req.input("updatedAt", updatedResource.updatedAt.toISOString());
-      req.input("id", resourceId);
-      await req.query(`UPDATE ${tableName} SET ${updates.join(", ")} WHERE id = @id`);
-      return updatedResource;
+      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) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_UPDATE_RESOURCE_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "INDEX_DROP", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { resourceId }
+          details: {
+            indexName
+          }
         },
         error$1
       );
-      this.logger?.error?.(mastraError.toString());
-      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 tracingStrategy() {
-    return {
-      preferred: "batch-with-updates",
-      supported: ["batch-with-updates", "insert-only"]
-    };
-  }
-  async createSpan(span) {
+  /**
+   * List indexes for a specific table or all tables
+   */
+  async listIndexes(tableName) {
     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_SPANS, record });
+      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: "MSSQL_STORE_CREATE_SPAN_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "INDEX_LIST", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: {
-            spanId: span.spanId,
-            traceId: span.traceId,
-            spanType: span.spanType,
-            spanName: span.name
-          }
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: tableName ? {
+            tableName
+          } : {}
         },
         error$1
       );
     }
   }
-  async getTrace(traceId) {
+  /**
+   * Get detailed statistics for a specific index
+   */
+  async describeIndex(indexName) {
     try {
-      const tableName = getTableName({
-        indexName: storage.TABLE_SPANS,
-        schemaName: getSchemaName(this.schema)
-      });
+      const schemaName = this.schemaName || "dbo";
       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`
-      );
+      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) {
-        return null;
+        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 {
-        traceId,
-        spans: result.recordset.map(
-          (span) => transformFromSqlRow({
-            tableName: storage.TABLE_SPANS,
-            sqlRow: span
-          })
-        )
+        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: "MSSQL_STORE_GET_TRACE_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "INDEX_DESCRIBE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
+          category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            traceId
+            indexName
           }
         },
         error$1
       );
     }
   }
-  async updateSpan({
-    spanId,
-    traceId,
-    updates
-  }) {
-    try {
-      const data = { ...updates };
-      if (data.endedAt instanceof Date) {
-        data.endedAt = data.endedAt.toISOString();
+  /**
+   * 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"]
       }
-      if (data.startedAt instanceof Date) {
-        data.startedAt = data.startedAt.toISOString();
+    ];
+  }
+  /**
+   * 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);
+        }
       }
-      await this.operations.update({
-        tableName: storage.TABLE_SPANS,
-        keys: { spanId, traceId },
-        data
-      });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MSSQL_STORE_UPDATE_SPAN_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "CREATE_PERFORMANCE_INDEXES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: {
-            spanId,
-            traceId
-          }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
   }
-  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}'`;
+};
+function getSchemaName2(schema) {
+  return schema ? `[${utils.parseSqlIdentifier(schema, "schema name")}]` : void 0;
+}
+function getTableName2({ indexName, schemaName }) {
+  const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
+  const quotedIndexName = `[${parsedIndexName}]`;
+  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 isInOperator(value) {
+  return typeof value === "object" && value !== null && "$in" in value && Array.isArray(value.$in);
+}
+function prepareWhereClause(filters, _schema) {
+  const conditions = [];
+  const params = {};
+  let paramIndex = 1;
+  Object.entries(filters).forEach(([key, value]) => {
+    if (value === void 0) return;
+    if (key.endsWith("_gte")) {
+      const paramName = `p${paramIndex++}`;
+      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 paramName = `p${paramIndex++}`;
+      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 if (isInOperator(value)) {
+      const inValues = value.$in;
+      if (inValues.length === 0) {
+        conditions.push("1 = 0");
+      } else if (inValues.length === 1) {
+        const paramName = `p${paramIndex++}`;
+        conditions.push(`[${utils.parseSqlIdentifier(key, "field name")}] = @${paramName}`);
+        params[paramName] = inValues[0] instanceof Date ? inValues[0].toISOString() : inValues[0];
       } else {
-        const error$1 = new error.MastraError({
-          id: "MSSQL_STORE_GET_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}`;
+        const inParamNames = [];
+        for (const item of inValues) {
+          const paramName = `p${paramIndex++}`;
+          inParamNames.push(`@${paramName}`);
+          params[paramName] = item instanceof Date ? item.toISOString() : item;
+        }
+        conditions.push(`[${utils.parseSqlIdentifier(key, "field name")}] IN (${inParamNames.join(", ")})`);
+      }
+    } else if (Array.isArray(value)) {
+      if (value.length === 0) {
+        conditions.push("1 = 0");
+      } else if (value.length === 1) {
+        const paramName = `p${paramIndex++}`;
+        conditions.push(`[${utils.parseSqlIdentifier(key, "field name")}] = @${paramName}`);
+        params[paramName] = value[0] instanceof Date ? value[0].toISOString() : value[0];
       } else {
-        actualWhereClause = ` WHERE [name] = @${entityParam}`;
+        const inParamNames = [];
+        for (const item of value) {
+          const paramName = `p${paramIndex++}`;
+          inParamNames.push(`@${paramName}`);
+          params[paramName] = item instanceof Date ? item.toISOString() : item;
+        }
+        conditions.push(`[${utils.parseSqlIdentifier(key, "field name")}] IN (${inParamNames.join(", ")})`);
       }
-      params[entityParam] = name;
+    } else {
+      const paramName = `p${paramIndex++}`;
+      conditions.push(`[${utils.parseSqlIdentifier(key, "field name")}] = @${paramName}`);
+      params[paramName] = value instanceof Date ? value.toISOString() : value;
     }
-    const tableName = getTableName({
-      indexName: storage.TABLE_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: []
-        };
+  });
+  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;
       }
-      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_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_TRACES_PAGINATED_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER
-        },
-        error$1
-      );
+    } 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/memory/index.ts
+var MemoryMSSQL = class extends storage.MemoryStorage {
+  pool;
+  schema;
+  db;
+  needsConnect;
+  _parseAndFormatMessages(messages, format) {
+    const messagesWithParsedContent = messages.map((message) => {
+      if (typeof message.content === "string") {
+        try {
+          return { ...message, content: JSON.parse(message.content) };
+        } catch {
+          return message;
+        }
+      }
+      return message;
+    });
+    const cleanMessages = messagesWithParsedContent.map(({ seq_id, ...rest }) => rest);
+    const list = new agent.MessageList().add(cleanMessages, "memory");
+    return format === "v2" ? list.get.all.db() : list.get.all.v1();
   }
-  async batchCreateSpans(args) {
-    if (!args.records || args.records.length === 0) {
-      return;
-    }
-    try {
-      await this.operations.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
-        }))
-      });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "MSSQL_STORE_BATCH_CREATE_SPANS_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: {
-            count: args.records.length
-          }
-        },
-        error$1
-      );
-    }
+  constructor(config) {
+    super();
+    const { pool, db, schema, needsConnect } = resolveMssqlConfig(config);
+    this.pool = pool;
+    this.schema = schema;
+    this.db = db;
+    this.needsConnect = needsConnect;
   }
-  async batchUpdateSpans(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_SPANS,
-        updates
-      });
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "MSSQL_STORE_BATCH_UPDATE_SPANS_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
-          details: {
-            count: args.records.length
-          }
-        },
-        error$1
-      );
+  async init() {
+    if (this.needsConnect) {
+      await this.pool.connect();
+      this.needsConnect = false;
     }
+    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] });
   }
-  async batchDeleteTraces(args) {
-    if (!args.traceIds || args.traceIds.length === 0) {
-      return;
-    }
+  async dangerouslyClearAll() {
+    await this.db.clearTable({ tableName: storage.TABLE_MESSAGES });
+    await this.db.clearTable({ tableName: storage.TABLE_THREADS });
+    await this.db.clearTable({ tableName: storage.TABLE_RESOURCES });
+  }
+  async getThreadById({ threadId }) {
     try {
-      const keys = args.traceIds.map((traceId) => ({ traceId }));
-      await this.operations.batchDelete({
-        tableName: storage.TABLE_SPANS,
-        keys
-      });
+      const sql5 = `SELECT 
+        id,
+        [resourceId],
+        title,
+        metadata,
+        [createdAt],
+        [updatedAt]
+      FROM ${getTableName2({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName2(this.schema) })}
+      WHERE id = @threadId`;
+      const request = this.pool.request();
+      request.input("threadId", threadId);
+      const resultSet = await request.query(sql5);
+      const thread = resultSet.recordset[0] || null;
+      if (!thread) {
+        return null;
+      }
+      return {
+        ...thread,
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt
+      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MSSQL_STORE_BATCH_DELETE_TRACES_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "GET_THREAD_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER,
+          category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            count: args.traceIds.length
+            threadId
           }
         },
         error$1
       );
     }
   }
-};
-var StoreOperationsMSSQL = class extends storage.StoreOperations {
-  pool;
-  schemaName;
-  setupSchemaPromise = null;
-  schemaSetupComplete = void 0;
-  getSqlType(type, isPrimaryKey = false, useLargeStorage = false) {
-    switch (type) {
-      case "text":
-        if (useLargeStorage) {
-          return "NVARCHAR(MAX)";
-        }
-        return isPrimaryKey ? "NVARCHAR(255)" : "NVARCHAR(400)";
-      case "timestamp":
-        return "DATETIME2(7)";
-      case "uuid":
-        return "UNIQUEIDENTIFIER";
-      case "jsonb":
-        return "NVARCHAR(MAX)";
-      case "integer":
-        return "INT";
-      case "bigint":
-        return "BIGINT";
-      case "float":
-        return "FLOAT";
-      case "boolean":
-        return "BIT";
-      default:
-        throw new error.MastraError({
-          id: "MASTRA_STORAGE_MSSQL_STORE_TYPE_NOT_SUPPORTED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        });
-    }
-  }
-  constructor({ pool, schemaName }) {
-    super();
-    this.pool = pool;
-    this.schemaName = schemaName;
-  }
-  async hasColumn(table, column) {
-    const schema = this.schemaName || "dbo";
-    const request = this.pool.request();
-    request.input("schema", schema);
-    request.input("table", table);
-    request.input("column", column);
-    request.input("columnLower", column.toLowerCase());
-    const result = await request.query(
-      `SELECT 1 FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @table AND (COLUMN_NAME = @column OR COLUMN_NAME = @columnLower)`
-    );
-    return result.recordset.length > 0;
-  }
-  async setupSchema() {
-    if (!this.schemaName || this.schemaSetupComplete) {
-      return;
-    }
-    if (!this.setupSchemaPromise) {
-      this.setupSchemaPromise = (async () => {
-        try {
-          const checkRequest = this.pool.request();
-          checkRequest.input("schemaName", this.schemaName);
-          const checkResult = await checkRequest.query(`
-            SELECT 1 AS found FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = @schemaName
-          `);
-          const schemaExists = Array.isArray(checkResult.recordset) && checkResult.recordset.length > 0;
-          if (!schemaExists) {
-            try {
-              await this.pool.request().query(`CREATE SCHEMA [${this.schemaName}]`);
-              this.logger?.info?.(`Schema "${this.schemaName}" created successfully`);
-            } catch (error) {
-              this.logger?.error?.(`Failed to create schema "${this.schemaName}"`, { error });
-              throw new Error(
-                `Unable to create schema "${this.schemaName}". This requires CREATE privilege on the database. Either create the schema manually or grant CREATE privilege to the user.`
-              );
-            }
-          }
-          this.schemaSetupComplete = true;
-          this.logger?.debug?.(`Schema "${this.schemaName}" is ready for use`);
-        } catch (error) {
-          this.schemaSetupComplete = void 0;
-          this.setupSchemaPromise = null;
-          throw error;
-        } finally {
-          this.setupSchemaPromise = null;
-        }
-      })();
-    }
-    await this.setupSchemaPromise;
-  }
-  async insert({
-    tableName,
-    record,
-    transaction
-  }) {
-    try {
-      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}`, sql2__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}`, preparedValue);
+  async listThreadsByResourceId(args) {
+    const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
+    if (page < 0) {
+      throw new error.MastraError({
+        id: storage.createStorageErrorId("MSSQL", "LIST_THREADS_BY_RESOURCE_ID", "INVALID_PAGE"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: "Page number must be non-negative",
+        details: {
+          resourceId,
+          page
         }
       });
-      await request.query(insertSql);
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 100);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
+    const { field, direction } = this.parseOrderBy(orderBy);
+    try {
+      const baseQuery = `FROM ${getTableName2({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName2(this.schema) })} WHERE [resourceId] = @resourceId`;
+      const countQuery = `SELECT COUNT(*) as count ${baseQuery}`;
+      const countRequest = this.pool.request();
+      countRequest.input("resourceId", resourceId);
+      const countResult = await countRequest.query(countQuery);
+      const total = parseInt(countResult.recordset[0]?.count ?? "0", 10);
+      if (total === 0) {
+        return {
+          threads: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
+      const orderByField = field === "createdAt" ? "[createdAt]" : "[updatedAt]";
+      const dir = (direction || "DESC").toUpperCase() === "ASC" ? "ASC" : "DESC";
+      const limitValue = perPageInput === false ? total : perPage;
+      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("offset", offset);
+      if (limitValue > 2147483647) {
+        dataRequest.input("perPage", sql__default.default.BigInt, limitValue);
+      } else {
+        dataRequest.input("perPage", limitValue);
+      }
+      const rowsResult = await dataRequest.query(dataQuery);
+      const rows = rowsResult.recordset || [];
+      const threads = rows.map((thread) => ({
+        ...thread,
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt
+      }));
+      return {
+        threads,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
     } catch (error$1) {
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_INSERT_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "LIST_THREADS_BY_RESOURCE_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            tableName
+            resourceId,
+            page
           }
         },
         error$1
       );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException?.(mastraError);
+      return {
+        threads: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
     }
   }
-  async clearTable({ tableName }) {
-    const fullTableName = getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) });
+  async saveThread({ thread }) {
     try {
-      try {
-        await this.pool.request().query(`TRUNCATE TABLE ${fullTableName}`);
-      } catch (truncateError) {
-        if (truncateError?.number === 4712) {
-          await this.pool.request().query(`DELETE FROM ${fullTableName}`);
-        } else {
-          throw truncateError;
-        }
+      const table = getTableName2({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName2(this.schema) });
+      const mergeSql = `MERGE INTO ${table} WITH (HOLDLOCK) AS target
+        USING (SELECT @id AS id) AS source
+        ON (target.id = source.id)
+        WHEN MATCHED THEN
+          UPDATE SET
+            [resourceId] = @resourceId,
+            title = @title,
+            metadata = @metadata,
+            [updatedAt] = @updatedAt
+        WHEN NOT MATCHED THEN
+          INSERT (id, [resourceId], title, metadata, [createdAt], [updatedAt])
+          VALUES (@id, @resourceId, @title, @metadata, @createdAt, @updatedAt);`;
+      const req = this.pool.request();
+      req.input("id", thread.id);
+      req.input("resourceId", thread.resourceId);
+      req.input("title", thread.title);
+      const metadata = thread.metadata ? JSON.stringify(thread.metadata) : null;
+      if (metadata === null) {
+        req.input("metadata", sql__default.default.NVarChar, null);
+      } else {
+        req.input("metadata", metadata);
       }
+      req.input("createdAt", sql__default.default.DateTime2, thread.createdAt);
+      req.input("updatedAt", sql__default.default.DateTime2, thread.updatedAt);
+      await req.query(mergeSql);
+      return thread;
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_CLEAR_TABLE_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "SAVE_THREAD", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            tableName
+            threadId: thread.id
           }
         },
         error$1
       );
     }
   }
-  getDefaultValue(type) {
-    switch (type) {
-      case "timestamp":
-        return "DEFAULT SYSUTCDATETIME()";
-      case "jsonb":
-        return "DEFAULT N'{}'";
-      case "boolean":
-        return "DEFAULT 0";
-      default:
-        return super.getDefaultValue(type);
-    }
-  }
-  async createTable({
-    tableName,
-    schema
+  /**
+   * Updates a thread's title and metadata, merging with existing metadata. Returns the updated thread.
+   */
+  async updateThread({
+    id,
+    title,
+    metadata
   }) {
+    const existingThread = await this.getThreadById({ threadId: id });
+    if (!existingThread) {
+      throw new error.MastraError({
+        id: storage.createStorageErrorId("MSSQL", "UPDATE_THREAD", "NOT_FOUND"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: `Thread ${id} not found`,
+        details: {
+          threadId: id,
+          title
+        }
+      });
+    }
+    const mergedMetadata = {
+      ...existingThread.metadata,
+      ...metadata
+    };
     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();
-      }).join(",\n");
-      if (this.schemaName) {
-        await this.setupSchema();
+      const table = getTableName2({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName2(this.schema) });
+      const sql5 = `UPDATE ${table}
+        SET title = @title,
+            metadata = @metadata,
+            [updatedAt] = @updatedAt
+        OUTPUT INSERTED.*
+        WHERE id = @id`;
+      const req = this.pool.request();
+      req.input("id", id);
+      req.input("title", title);
+      req.input("metadata", JSON.stringify(mergedMetadata));
+      req.input("updatedAt", /* @__PURE__ */ new Date());
+      const result = await req.query(sql5);
+      let thread = result.recordset && result.recordset[0];
+      if (thread && "seq_id" in thread) {
+        const { seq_id, ...rest } = thread;
+        thread = rest;
       }
-      const checkTableRequest = this.pool.request();
-      checkTableRequest.input(
-        "tableName",
-        getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) }).replace(/[[\]]/g, "").split(".").pop()
-      );
-      const checkTableSql = `SELECT 1 AS found FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @tableName`;
-      checkTableRequest.input("schema", this.schemaName || "dbo");
-      const checkTableResult = await checkTableRequest.query(checkTableSql);
-      const tableExists = Array.isArray(checkTableResult.recordset) && checkTableResult.recordset.length > 0;
-      if (!tableExists) {
-        const createSql = `CREATE TABLE ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} (
-${columns}
-)`;
-        await this.pool.request().query(createSql);
+      if (!thread) {
+        throw new error.MastraError({
+          id: storage.createStorageErrorId("MSSQL", "UPDATE_THREAD", "NOT_FOUND"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          text: `Thread ${id} not found after update`,
+          details: {
+            threadId: id,
+            title
+          }
+        });
       }
-      const columnCheckSql = `
-        SELECT 1 AS found
-        FROM INFORMATION_SCHEMA.COLUMNS
-        WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @tableName AND COLUMN_NAME = 'seq_id'
-      `;
-      const checkColumnRequest = this.pool.request();
-      checkColumnRequest.input("schema", this.schemaName || "dbo");
-      checkColumnRequest.input(
-        "tableName",
-        getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) }).replace(/[[\]]/g, "").split(".").pop()
+      return {
+        ...thread,
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MSSQL", "UPDATE_THREAD", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            threadId: id,
+            title
+          }
+        },
+        error$1
       );
-      const columnResult = await checkColumnRequest.query(columnCheckSql);
-      const columnExists = Array.isArray(columnResult.recordset) && columnResult.recordset.length > 0;
-      if (!columnExists) {
-        const alterSql = `ALTER TABLE ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} ADD seq_id BIGINT IDENTITY(1,1)`;
-        await this.pool.request().query(alterSql);
-      }
-      if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
-        const constraintName = "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])`;
-          await this.pool.request().query(addConstraintSql);
-        }
-      }
+    }
+  }
+  async deleteThread({ threadId }) {
+    const messagesTable = getTableName2({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName2(this.schema) });
+    const threadsTable = getTableName2({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName2(this.schema) });
+    const deleteMessagesSql = `DELETE FROM ${messagesTable} WHERE [thread_id] = @threadId`;
+    const deleteThreadSql = `DELETE FROM ${threadsTable} WHERE id = @threadId`;
+    const tx = this.pool.transaction();
+    try {
+      await tx.begin();
+      const req = tx.request();
+      req.input("threadId", threadId);
+      await req.query(deleteMessagesSql);
+      await req.query(deleteThreadSql);
+      await tx.commit();
     } catch (error$1) {
+      await tx.rollback().catch(() => {
+      });
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_CREATE_TABLE_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "DELETE_THREAD", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            tableName
+            threadId
           }
         },
         error$1
       );
     }
   }
-  /**
-   * Alters table schema to add columns if they don't exist
-   * @param tableName Name of the table
-   * @param schema Schema of the table
-   * @param ifNotExists Array of column names to add if they don't exist
-   */
-  async alterTable({
-    tableName,
-    schema,
-    ifNotExists
-  }) {
-    const fullTableName = getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) });
+  async _getIncludedMessages({ include }) {
+    if (!include || include.length === 0) return null;
+    const unionQueries = [];
+    const paramValues = [];
+    let paramIdx = 1;
+    const paramNames = [];
+    const tableName = getTableName2({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName2(this.schema) });
+    for (const inc of include) {
+      const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
+      const pId = `@p${paramIdx}`;
+      const pPrev = `@p${paramIdx + 1}`;
+      const pNext = `@p${paramIdx + 2}`;
+      unionQueries.push(
+        `
+          SELECT
+            m.id, 
+            m.content, 
+            m.role, 
+            m.type,
+            m.[createdAt], 
+            m.thread_id AS threadId,
+            m.[resourceId],
+            m.seq_id
+          FROM (
+            SELECT *, ROW_NUMBER() OVER (ORDER BY [createdAt] ASC) as row_num
+            FROM ${tableName}
+            WHERE [thread_id] = (SELECT thread_id FROM ${tableName} WHERE id = ${pId})
+          ) AS m
+          WHERE m.id = ${pId}
+          OR EXISTS (
+            SELECT 1
+            FROM (
+              SELECT *, ROW_NUMBER() OVER (ORDER BY [createdAt] ASC) as row_num
+              FROM ${tableName}
+              WHERE [thread_id] = (SELECT thread_id FROM ${tableName} WHERE id = ${pId})
+            ) AS target
+            WHERE target.id = ${pId}
+            AND (
+              -- Get previous messages (messages that come BEFORE the target)
+              (m.row_num < target.row_num AND m.row_num >= target.row_num - ${pPrev})
+              OR
+              -- Get next messages (messages that come AFTER the target)
+              (m.row_num > target.row_num AND m.row_num <= target.row_num + ${pNext})
+            )
+          )
+        `
+      );
+      paramValues.push(id, withPreviousMessages, withNextMessages);
+      paramNames.push(`p${paramIdx}`, `p${paramIdx + 1}`, `p${paramIdx + 2}`);
+      paramIdx += 3;
+    }
+    const finalQuery = `
+      SELECT * FROM (
+        ${unionQueries.join(" UNION ALL ")}
+      ) AS union_result
+      ORDER BY [seq_id] ASC
+    `;
+    const req = this.pool.request();
+    for (let i = 0; i < paramValues.length; ++i) {
+      req.input(paramNames[i], paramValues[i]);
+    }
+    const result = await req.query(finalQuery);
+    const includedRows = result.recordset || [];
+    const seen = /* @__PURE__ */ new Set();
+    const dedupedRows = includedRows.filter((row) => {
+      if (seen.has(row.id)) return false;
+      seen.add(row.id);
+      return true;
+    });
+    return dedupedRows;
+  }
+  async listMessagesById({ messageIds }) {
+    if (messageIds.length === 0) return { messages: [] };
+    const selectStatement = `SELECT seq_id, id, content, role, type, [createdAt], thread_id AS threadId, resourceId`;
+    const orderByStatement = `ORDER BY [seq_id] DESC`;
     try {
-      for (const columnName of ifNotExists) {
-        if (schema[columnName]) {
-          const columnCheckRequest = this.pool.request();
-          columnCheckRequest.input("tableName", fullTableName.replace(/[[\]]/g, "").split(".").pop());
-          columnCheckRequest.input("columnName", columnName);
-          columnCheckRequest.input("schema", this.schemaName || "dbo");
-          const checkSql = `SELECT 1 AS found FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @tableName AND COLUMN_NAME = @columnName`;
-          const checkResult = await columnCheckRequest.query(checkSql);
-          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 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");
-            const alterSql = `ALTER TABLE ${fullTableName} ADD [${parsedColumnName}] ${sqlType} ${nullable} ${defaultValue}`.trim();
-            await this.pool.request().query(alterSql);
-            this.logger?.debug?.(`Ensured column ${parsedColumnName} exists in table ${fullTableName}`);
+      let rows = [];
+      let query = `${selectStatement} FROM ${getTableName2({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName2(this.schema) })} WHERE [id] IN (${messageIds.map((_, i) => `@id${i}`).join(", ")})`;
+      const request = this.pool.request();
+      messageIds.forEach((id, i) => request.input(`id${i}`, id));
+      query += ` ${orderByStatement}`;
+      const result = await request.query(query);
+      const remainingRows = result.recordset || [];
+      rows.push(...remainingRows);
+      rows.sort((a, b) => {
+        const timeDiff = a.seq_id - b.seq_id;
+        return timeDiff;
+      });
+      const messagesWithParsedContent = rows.map((row) => {
+        if (typeof row.content === "string") {
+          try {
+            return { ...row, content: JSON.parse(row.content) };
+          } catch {
+            return row;
           }
         }
-      }
+        return row;
+      });
+      const cleanMessages = messagesWithParsedContent.map(({ seq_id, ...rest }) => rest);
+      const list = new agent.MessageList().add(cleanMessages, "memory");
+      return { messages: list.get.all.db() };
     } catch (error$1) {
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_ALTER_TABLE_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "LIST_MESSAGES_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            tableName
+            messageIds: JSON.stringify(messageIds)
           }
         },
         error$1
       );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException?.(mastraError);
+      return { messages: [] };
     }
   }
-  async load({ tableName, keys }) {
+  async listMessages(args) {
+    const { threadId, resourceId, include, filter, perPage: perPageInput, page = 0, orderBy } = args;
+    const threadIds = Array.isArray(threadId) ? threadId : [threadId];
+    if (threadIds.length === 0 || threadIds.some((id) => !id.trim())) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MSSQL", "LIST_MESSAGES", "INVALID_THREAD_ID"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { threadId: Array.isArray(threadId) ? threadId.join(",") : threadId }
+        },
+        new Error("threadId must be a non-empty string or array of non-empty strings")
+      );
+    }
+    if (page < 0) {
+      throw new error.MastraError({
+        id: storage.createStorageErrorId("MSSQL", "LIST_MESSAGES", "INVALID_PAGE"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.USER,
+        text: "Page number must be non-negative",
+        details: {
+          threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
+          page
+        }
+      });
+    }
+    const perPage = storage.normalizePerPage(perPageInput, 40);
+    const { offset, perPage: perPageForResponse } = storage.calculatePagination(page, perPageInput, perPage);
     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 sql5 = `SELECT * FROM ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} WHERE ${conditions}`;
-      const request = this.pool.request();
-      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 { field, direction } = this.parseOrderBy(orderBy, "ASC");
+      const orderByStatement = `ORDER BY [${field}] ${direction}, [seq_id] ${direction}`;
+      const tableName = getTableName2({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName2(this.schema) });
+      const baseQuery = `SELECT seq_id, id, content, role, type, [createdAt], thread_id AS threadId, resourceId FROM ${tableName}`;
+      const filters = {
+        thread_id: threadIds.length === 1 ? threadIds[0] : { $in: threadIds },
+        ...resourceId ? { resourceId } : {},
+        ...buildDateRangeFilter(filter?.dateRange, "createdAt")
+      };
+      const { sql: actualWhereClause = "", params: whereParams } = prepareWhereClause(
+        filters);
+      const bindWhereParams = (req) => {
+        Object.entries(whereParams).forEach(([paramName, paramValue]) => req.input(paramName, paramValue));
+      };
+      const countRequest = this.pool.request();
+      bindWhereParams(countRequest);
+      const countResult = await countRequest.query(`SELECT COUNT(*) as total FROM ${tableName}${actualWhereClause}`);
+      const total = parseInt(countResult.recordset[0]?.total, 10) || 0;
+      const fetchBaseMessages = async () => {
+        const request = this.pool.request();
+        bindWhereParams(request);
+        if (perPageInput === false) {
+          const result2 = await request.query(`${baseQuery}${actualWhereClause} ${orderByStatement}`);
+          return result2.recordset || [];
         }
+        request.input("offset", offset);
+        request.input("limit", perPage > 2147483647 ? sql__default.default.BigInt : sql__default.default.Int, perPage);
+        const result = await request.query(
+          `${baseQuery}${actualWhereClause} ${orderByStatement} OFFSET @offset ROWS FETCH NEXT @limit ROWS ONLY`
+        );
+        return result.recordset || [];
+      };
+      const baseRows = perPage === 0 ? [] : await fetchBaseMessages();
+      const messages = [...baseRows];
+      const seqById = /* @__PURE__ */ new Map();
+      messages.forEach((msg) => {
+        if (typeof msg.seq_id === "number") seqById.set(msg.id, msg.seq_id);
       });
-      const resultSet = await request.query(sql5);
-      const result = resultSet.recordset[0] || null;
-      if (!result) {
-        return null;
+      if (total === 0 && messages.length === 0 && (!include || include.length === 0)) {
+        return {
+          messages: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
       }
-      if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
-        const snapshot = result;
-        if (typeof snapshot.snapshot === "string") {
-          snapshot.snapshot = JSON.parse(snapshot.snapshot);
-        }
-        return snapshot;
+      if (include?.length) {
+        const messageIds = new Set(messages.map((m) => m.id));
+        const includeMessages = await this._getIncludedMessages({ include });
+        includeMessages?.forEach((msg) => {
+          if (!messageIds.has(msg.id)) {
+            messages.push(msg);
+            messageIds.add(msg.id);
+            if (typeof msg.seq_id === "number") seqById.set(msg.id, msg.seq_id);
+          }
+        });
       }
-      return result;
+      const parsed = this._parseAndFormatMessages(messages, "v2");
+      const mult = direction === "ASC" ? 1 : -1;
+      const finalMessages = parsed.sort((a, b) => {
+        const aVal = field === "createdAt" ? new Date(a.createdAt).getTime() : a[field];
+        const bVal = field === "createdAt" ? new Date(b.createdAt).getTime() : b[field];
+        if (aVal == null || bVal == null) {
+          return aVal == null && bVal == null ? a.id.localeCompare(b.id) : aVal == null ? 1 : -1;
+        }
+        const diff = (typeof aVal === "number" && typeof bVal === "number" ? aVal - bVal : String(aVal).localeCompare(String(bVal))) * mult;
+        if (diff !== 0) return diff;
+        const seqA = seqById.get(a.id);
+        const seqB = seqById.get(b.id);
+        return seqA != null && seqB != null ? (seqA - seqB) * mult : a.id.localeCompare(b.id);
+      });
+      const threadIdSet = new Set(threadIds);
+      const returnedThreadMessageCount = finalMessages.filter((m) => m.threadId && threadIdSet.has(m.threadId)).length;
+      const hasMore = perPageInput !== false && returnedThreadMessageCount < total && offset + perPage < total;
+      return {
+        messages: finalMessages,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore
+      };
     } catch (error$1) {
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_LOAD_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "LIST_MESSAGES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            tableName
+            threadId: Array.isArray(threadId) ? threadId.join(",") : threadId,
+            resourceId: resourceId ?? ""
           }
         },
         error$1
       );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException?.(mastraError);
+      return {
+        messages: [],
+        total: 0,
+        page,
+        perPage: perPageForResponse,
+        hasMore: false
+      };
     }
   }
-  async batchInsert({ tableName, records }) {
-    const transaction = this.pool.transaction();
+  async saveMessages({ messages }) {
+    if (messages.length === 0) return { messages: [] };
+    const threadId = messages[0]?.threadId;
+    if (!threadId) {
+      throw new error.MastraError({
+        id: storage.createStorageErrorId("MSSQL", "SAVE_MESSAGES", "INVALID_THREAD_ID"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.THIRD_PARTY,
+        text: `Thread ID is required`
+      });
+    }
+    const thread = await this.getThreadById({ threadId });
+    if (!thread) {
+      throw new error.MastraError({
+        id: storage.createStorageErrorId("MSSQL", "SAVE_MESSAGES", "THREAD_NOT_FOUND"),
+        domain: error.ErrorDomain.STORAGE,
+        category: error.ErrorCategory.THIRD_PARTY,
+        text: `Thread ${threadId} not found`,
+        details: { threadId }
+      });
+    }
+    const tableMessages = getTableName2({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName2(this.schema) });
+    const tableThreads = getTableName2({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName2(this.schema) });
     try {
+      const transaction = this.pool.transaction();
       await transaction.begin();
-      for (const record of records) {
-        await this.insert({ tableName, record, transaction });
+      try {
+        for (const message of messages) {
+          if (!message.threadId) {
+            throw new Error(
+              `Expected to find a threadId for message, but couldn't find one. An unexpected error has occurred.`
+            );
+          }
+          if (!message.resourceId) {
+            throw new Error(
+              `Expected to find a resourceId for message, but couldn't find one. An unexpected error has occurred.`
+            );
+          }
+          const request = transaction.request();
+          request.input("id", message.id);
+          request.input("thread_id", message.threadId);
+          request.input(
+            "content",
+            typeof message.content === "string" ? message.content : JSON.stringify(message.content)
+          );
+          request.input("createdAt", sql__default.default.DateTime2, message.createdAt);
+          request.input("role", message.role);
+          request.input("type", message.type || "v2");
+          request.input("resourceId", message.resourceId);
+          const mergeSql = `MERGE INTO ${tableMessages} AS target
+            USING (SELECT @id AS id) AS src
+            ON target.id = src.id
+            WHEN MATCHED THEN UPDATE SET
+              thread_id = @thread_id,
+              content = @content,
+              [createdAt] = @createdAt,
+              role = @role,
+              type = @type,
+              resourceId = @resourceId
+            WHEN NOT MATCHED THEN INSERT (id, thread_id, content, [createdAt], role, type, resourceId)
+              VALUES (@id, @thread_id, @content, @createdAt, @role, @type, @resourceId);`;
+          await request.query(mergeSql);
+        }
+        const threadReq = transaction.request();
+        threadReq.input("updatedAt", sql__default.default.DateTime2, /* @__PURE__ */ new Date());
+        threadReq.input("id", threadId);
+        await threadReq.query(`UPDATE ${tableThreads} SET [updatedAt] = @updatedAt WHERE id = @id`);
+        await transaction.commit();
+      } catch (error) {
+        await transaction.rollback();
+        throw error;
       }
-      await transaction.commit();
+      const messagesWithParsedContent = messages.map((message) => {
+        if (typeof message.content === "string") {
+          try {
+            return { ...message, content: JSON.parse(message.content) };
+          } catch {
+            return message;
+          }
+        }
+        return message;
+      });
+      const list = new agent.MessageList().add(messagesWithParsedContent, "memory");
+      return { messages: list.get.all.db() };
     } catch (error$1) {
-      await transaction.rollback();
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_BATCH_INSERT_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "SAVE_MESSAGES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName,
-            numberOfRecords: records.length
-          }
+          details: { threadId }
         },
         error$1
       );
     }
   }
-  async dropTable({ tableName }) {
+  async updateMessages({
+    messages
+  }) {
+    if (!messages || messages.length === 0) {
+      return [];
+    }
+    const messageIds = messages.map((m) => m.id);
+    const idParams = messageIds.map((_, i) => `@id${i}`).join(", ");
+    let selectQuery = `SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId FROM ${getTableName2({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName2(this.schema) })}`;
+    if (idParams.length > 0) {
+      selectQuery += ` WHERE id IN (${idParams})`;
+    } else {
+      return [];
+    }
+    const selectReq = this.pool.request();
+    messageIds.forEach((id, i) => selectReq.input(`id${i}`, id));
+    const existingMessagesDb = (await selectReq.query(selectQuery)).recordset;
+    if (!existingMessagesDb || existingMessagesDb.length === 0) {
+      return [];
+    }
+    const existingMessages = existingMessagesDb.map((msg) => {
+      if (typeof msg.content === "string") {
+        try {
+          msg.content = JSON.parse(msg.content);
+        } catch {
+        }
+      }
+      return msg;
+    });
+    const threadIdsToUpdate = /* @__PURE__ */ new Set();
+    const transaction = this.pool.transaction();
     try {
-      const tableNameWithSchema = getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) });
-      await this.pool.request().query(`DROP TABLE IF EXISTS ${tableNameWithSchema}`);
+      await transaction.begin();
+      for (const existingMessage of existingMessages) {
+        const updatePayload = messages.find((m) => m.id === existingMessage.id);
+        if (!updatePayload) continue;
+        const { id, ...fieldsToUpdate } = updatePayload;
+        if (Object.keys(fieldsToUpdate).length === 0) continue;
+        threadIdsToUpdate.add(existingMessage.threadId);
+        if (updatePayload.threadId && updatePayload.threadId !== existingMessage.threadId) {
+          threadIdsToUpdate.add(updatePayload.threadId);
+        }
+        const setClauses = [];
+        const req = transaction.request();
+        req.input("id", id);
+        const columnMapping = { threadId: "thread_id" };
+        const updatableFields = { ...fieldsToUpdate };
+        if (updatableFields.content) {
+          const newContent = {
+            ...existingMessage.content,
+            ...updatableFields.content,
+            ...existingMessage.content?.metadata && updatableFields.content.metadata ? { metadata: { ...existingMessage.content.metadata, ...updatableFields.content.metadata } } : {}
+          };
+          setClauses.push(`content = @content`);
+          req.input("content", JSON.stringify(newContent));
+          delete updatableFields.content;
+        }
+        for (const key in updatableFields) {
+          if (Object.prototype.hasOwnProperty.call(updatableFields, key)) {
+            const dbColumn = columnMapping[key] || key;
+            setClauses.push(`[${dbColumn}] = @${dbColumn}`);
+            req.input(dbColumn, updatableFields[key]);
+          }
+        }
+        if (setClauses.length > 0) {
+          const updateSql = `UPDATE ${getTableName2({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName2(this.schema) })} SET ${setClauses.join(", ")} WHERE id = @id`;
+          await req.query(updateSql);
+        }
+      }
+      if (threadIdsToUpdate.size > 0) {
+        const threadIdParams = Array.from(threadIdsToUpdate).map((_, i) => `@tid${i}`).join(", ");
+        const threadReq = transaction.request();
+        Array.from(threadIdsToUpdate).forEach((tid, i) => threadReq.input(`tid${i}`, tid));
+        threadReq.input("updatedAt", (/* @__PURE__ */ new Date()).toISOString());
+        const threadSql = `UPDATE ${getTableName2({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName2(this.schema) })} SET updatedAt = @updatedAt WHERE id IN (${threadIdParams})`;
+        await threadReq.query(threadSql);
+      }
+      await transaction.commit();
     } catch (error$1) {
+      await transaction.rollback();
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_DROP_TABLE_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "UPDATE_MESSAGES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
+          category: error.ErrorCategory.THIRD_PARTY
         },
         error$1
       );
     }
-  }
-  /**
-   * 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 {
-          }
+    const refetchReq = this.pool.request();
+    messageIds.forEach((id, i) => refetchReq.input(`id${i}`, id));
+    const updatedMessages = (await refetchReq.query(selectQuery)).recordset;
+    return (updatedMessages || []).map((message) => {
+      if (typeof message.content === "string") {
+        try {
+          message.content = JSON.parse(message.content);
+        } catch {
         }
-        return JSON.stringify(value);
-      }
-      if (typeof value === "bigint") {
-        return value.toString();
       }
-      return JSON.stringify(value);
-    }
-    if (typeof value === "object") {
-      return JSON.stringify(value);
-    }
-    return value;
+      return message;
+    });
   }
-  /**
-   * 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 sql2__default.default.NVarChar;
-      case "timestamp":
-        return sql2__default.default.DateTime2;
-      case "uuid":
-        return sql2__default.default.UniqueIdentifier;
-      case "jsonb":
-        return sql2__default.default.NVarChar;
-      case "integer":
-        return sql2__default.default.Int;
-      case "bigint":
-        return sql2__default.default.BigInt;
-      case "float":
-        return sql2__default.default.Float;
-      case "boolean":
-        return sql2__default.default.Bit;
-      default:
-        return sql2__default.default.NVarChar;
+  async deleteMessages(messageIds) {
+    if (!messageIds || messageIds.length === 0) {
+      return;
     }
-  }
-  /**
-   * 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 messageTableName = getTableName2({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName2(this.schema) });
+      const threadTableName = getTableName2({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName2(this.schema) });
+      const placeholders = messageIds.map((_, idx) => `@p${idx + 1}`).join(",");
+      const request = this.pool.request();
+      messageIds.forEach((id, idx) => {
+        request.input(`p${idx + 1}`, id);
+      });
+      const messages = await request.query(
+        `SELECT DISTINCT [thread_id] FROM ${messageTableName} WHERE [id] IN (${placeholders})`
+      );
+      const threadIds = messages.recordset?.map((msg) => msg.thread_id).filter(Boolean) || [];
+      const transaction = this.pool.transaction();
+      await transaction.begin();
+      try {
+        const deleteRequest = transaction.request();
+        messageIds.forEach((id, idx) => {
+          deleteRequest.input(`p${idx + 1}`, id);
         });
-      }
-      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);
+        await deleteRequest.query(`DELETE FROM ${messageTableName} WHERE [id] IN (${placeholders})`);
+        if (threadIds.length > 0) {
+          for (const threadId of threadIds) {
+            const updateRequest = transaction.request();
+            updateRequest.input("p1", threadId);
+            await updateRequest.query(`UPDATE ${threadTableName} SET [updatedAt] = GETDATE() WHERE [id] = @p1`);
+          }
         }
-      });
-      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);
+        await transaction.commit();
+      } catch (error) {
+        try {
+          await transaction.rollback();
+        } catch {
         }
-      });
-      const tableName_ = getTableName({
-        indexName: tableName,
-        schemaName: getSchemaName(this.schemaName)
-      });
-      const updateSql = `UPDATE ${tableName_} SET ${setClauses.join(", ")} WHERE ${whereConditions.join(" AND ")}`;
-      await request.query(updateSql);
+        throw error;
+      }
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_UPDATE_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "DELETE_MESSAGES", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
+          details: { messageIds: messageIds.join(", ") }
         },
         error$1
       );
     }
   }
-  /**
-   * Update multiple records in a single batch transaction
-   */
-  async batchUpdate({
-    tableName,
-    updates
-  }) {
-    const transaction = this.pool.transaction();
+  async getResourceById({ resourceId }) {
+    const tableName = getTableName2({ indexName: storage.TABLE_RESOURCES, schemaName: getSchemaName2(this.schema) });
     try {
-      await transaction.begin();
-      for (const { keys, data } of updates) {
-        await this.update({ tableName, keys, data, transaction });
+      const req = this.pool.request();
+      req.input("resourceId", resourceId);
+      const result = (await req.query(`SELECT * FROM ${tableName} WHERE id = @resourceId`)).recordset[0];
+      if (!result) {
+        return null;
       }
-      await transaction.commit();
+      return {
+        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) {
-      await transaction.rollback();
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_BATCH_UPDATE_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "GET_RESOURCE_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName,
-            numberOfRecords: updates.length
-          }
+          details: { resourceId }
         },
         error$1
       );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException?.(mastraError);
+      throw mastraError;
     }
   }
-  /**
-   * Delete multiple records by keys
-   */
-  async batchDelete({ tableName, keys }) {
-    if (keys.length === 0) {
-      return;
-    }
-    const tableName_ = getTableName({
-      indexName: tableName,
-      schemaName: getSchemaName(this.schemaName)
+  async saveResource({ resource }) {
+    await this.db.insert({
+      tableName: storage.TABLE_RESOURCES,
+      record: {
+        ...resource,
+        metadata: resource.metadata
+      }
     });
-    const transaction = this.pool.transaction();
+    return resource;
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
     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);
+      const existingResource = await this.getResourceById({ resourceId });
+      if (!existingResource) {
+        const newResource = {
+          id: resourceId,
+          workingMemory,
+          metadata: metadata || {},
+          createdAt: /* @__PURE__ */ new Date(),
+          updatedAt: /* @__PURE__ */ new Date()
+        };
+        return this.saveResource({ resource: newResource });
       }
-      await transaction.commit();
+      const updatedResource = {
+        ...existingResource,
+        workingMemory: workingMemory !== void 0 ? workingMemory : existingResource.workingMemory,
+        metadata: {
+          ...existingResource.metadata,
+          ...metadata
+        },
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      const tableName = getTableName2({ indexName: storage.TABLE_RESOURCES, schemaName: getSchemaName2(this.schema) });
+      const updates = [];
+      const req = this.pool.request();
+      if (workingMemory !== void 0) {
+        updates.push("workingMemory = @workingMemory");
+        req.input("workingMemory", workingMemory);
+      }
+      if (metadata) {
+        updates.push("metadata = @metadata");
+        req.input("metadata", JSON.stringify(updatedResource.metadata));
+      }
+      updates.push("updatedAt = @updatedAt");
+      req.input("updatedAt", updatedResource.updatedAt.toISOString());
+      req.input("id", resourceId);
+      await req.query(`UPDATE ${tableName} SET ${updates.join(", ")} WHERE id = @id`);
+      return updatedResource;
     } catch (error$1) {
-      await transaction.rollback();
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_BATCH_DELETE_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "UPDATE_RESOURCE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName,
-            numberOfRecords: keys.length
-          }
+          details: { resourceId }
         },
         error$1
       );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException?.(mastraError);
+      throw mastraError;
     }
   }
-  /**
-   * 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);
+};
+var ObservabilityMSSQL = class extends storage.ObservabilityStorage {
+  pool;
+  db;
+  schema;
+  needsConnect;
+  constructor(config) {
+    super();
+    const { pool, db, schema, needsConnect } = resolveMssqlConfig(config);
+    this.pool = pool;
+    this.db = db;
+    this.schema = schema;
+    this.needsConnect = needsConnect;
+  }
+  async init() {
+    if (this.needsConnect) {
+      await this.pool.connect();
+      this.needsConnect = false;
+    }
+    await this.db.createTable({ tableName: storage.TABLE_SPANS, schema: storage.SPAN_SCHEMA });
+  }
+  async dangerouslyClearAll() {
+    await this.db.clearTable({ tableName: storage.TABLE_SPANS });
+  }
+  get tracingStrategy() {
+    return {
+      preferred: "batch-with-updates",
+      supported: ["batch-with-updates", "insert-only"]
+    };
+  }
+  async createSpan(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.db.insert({ tableName: storage.TABLE_SPANS, record });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_INDEX_CREATE_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "CREATE_SPAN", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
+          category: error.ErrorCategory.USER,
           details: {
-            indexName: options.name,
-            tableName: options.table
+            spanId: span.spanId,
+            traceId: span.traceId,
+            spanType: span.spanType,
+            spanName: span.name
           }
         },
         error$1
       );
     }
   }
-  /**
-   * Drop an existing index
-   */
-  async dropIndex(indexName) {
+  async getTrace(traceId) {
     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
-      `);
+      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], [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;
+        return null;
       }
-      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",
+      return {
+        traceId,
+        spans: result.recordset.map(
+          (span) => transformFromSqlRow({
+            tableName: storage.TABLE_SPANS,
+            sqlRow: span
+          })
+        )
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MSSQL", "GET_TRACE", "FAILED"),
           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.`
-        });
+          details: {
+            traceId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async updateSpan({
+    spanId,
+    traceId,
+    updates
+  }) {
+    try {
+      const data = { ...updates };
+      if (data.endedAt instanceof Date) {
+        data.endedAt = data.endedAt.toISOString();
       }
-      const tableName = result.recordset[0].table_name;
-      const fullTableName = getTableName({
-        indexName: tableName,
-        schemaName: getSchemaName(this.schemaName)
+      if (data.startedAt instanceof Date) {
+        data.startedAt = data.startedAt.toISOString();
+      }
+      await this.db.update({
+        tableName: storage.TABLE_SPANS,
+        keys: { spanId, traceId },
+        data
       });
-      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",
+          id: storage.createStorageErrorId("MSSQL", "UPDATE_SPAN", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
+          category: error.ErrorCategory.USER,
           details: {
-            indexName
+            spanId,
+            traceId
           }
         },
         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);
+  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 {
-        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
+        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;
       }
-      return indexes;
+      const entityParam = `p${currentParamIndex++}`;
+      if (actualWhereClause) {
+        actualWhereClause += ` AND [name] = @${entityParam}`;
+      } else {
+        actualWhereClause = ` WHERE [name] = @${entityParam}`;
+      }
+      params[entityParam] = name;
+    }
+    const tableName = getTableName2({
+      indexName: storage.TABLE_SPANS,
+      schemaName: getSchemaName2(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_SPANS,
+          sqlRow: row
+        })
+      );
+      return {
+        pagination: {
+          total,
+          page,
+          perPage,
+          hasMore: (page + 1) * perPage < total
+        },
+        spans
+      };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_INDEX_LIST_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "GET_TRACES_PAGINATED", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: tableName ? {
-            tableName
-          } : {}
+          category: error.ErrorCategory.USER
         },
         error$1
       );
     }
   }
-  /**
-   * Get detailed statistics for a specific index
-   */
-  async describeIndex(indexName) {
+  async batchCreateSpans(args) {
+    if (!args.records || args.records.length === 0) {
+      return;
+    }
     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
-      };
+      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
+        }))
+      });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_INDEX_DESCRIBE_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "BATCH_CREATE_SPANS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
+          category: error.ErrorCategory.USER,
           details: {
-            indexName
+            count: args.records.length
           }
         },
         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_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() {
+  async batchUpdateSpans(args) {
+    if (!args.records || args.records.length === 0) {
+      return;
+    }
     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);
+      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.db.batchUpdate({
+        tableName: storage.TABLE_SPANS,
+        updates
+      });
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_CREATE_PERFORMANCE_INDEXES_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "BATCH_UPDATE_SPANS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
+          category: error.ErrorCategory.USER,
+          details: {
+            count: args.records.length
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async batchDeleteTraces(args) {
+    if (!args.traceIds || args.traceIds.length === 0) {
+      return;
+    }
+    try {
+      const keys = args.traceIds.map((traceId) => ({ traceId }));
+      await this.db.batchDelete({
+        tableName: storage.TABLE_SPANS,
+        keys
+      });
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MSSQL", "BATCH_DELETE_TRACES", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER,
+          details: {
+            count: args.traceIds.length
+          }
         },
         error$1
       );
@@ -2261,41 +2345,39 @@ ${columns}
   }
 };
 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),
-    requestContext: storage.safelyParseJSON(row.requestContext),
-    entity: storage.safelyParseJSON(row.entity),
-    createdAt: new Date(row.createdAt),
-    updatedAt: new Date(row.updatedAt)
-  };
+  return storage.transformScoreRow(row, {
+    convertTimestamps: true
+  });
 }
 var ScoresMSSQL = class extends storage.ScoresStorage {
   pool;
-  operations;
+  db;
   schema;
-  constructor({
-    pool,
-    operations,
-    schema
-  }) {
+  needsConnect;
+  constructor(config) {
     super();
+    const { pool, db, schema, needsConnect } = resolveMssqlConfig(config);
     this.pool = pool;
-    this.operations = operations;
+    this.db = db;
     this.schema = schema;
+    this.needsConnect = needsConnect;
+  }
+  async init() {
+    if (this.needsConnect) {
+      await this.pool.connect();
+      this.needsConnect = false;
+    }
+    await this.db.createTable({ tableName: storage.TABLE_SCORERS, schema: storage.TABLE_SCHEMAS[storage.TABLE_SCORERS] });
+  }
+  async dangerouslyClearAll() {
+    await this.db.clearTable({ tableName: storage.TABLE_SCORERS });
   }
   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`
+        `SELECT * FROM ${getTableName2({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName2(this.schema) })} WHERE id = @p1`
       );
       if (result.recordset.length === 0) {
         return null;
@@ -2304,7 +2386,7 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_GET_SCORE_BY_ID_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "GET_SCORE_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { id }
@@ -2320,15 +2402,23 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_SAVE_SCORE_VALIDATION_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "SAVE_SCORE", "VALIDATION_FAILED"),
           domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
+          category: error.ErrorCategory.USER,
+          details: {
+            scorer: score.scorer?.id ?? "unknown",
+            entityId: score.entityId ?? "unknown",
+            entityType: score.entityType ?? "unknown",
+            traceId: score.traceId ?? "",
+            spanId: score.spanId ?? ""
+          }
         },
         error$1
       );
     }
     try {
       const scoreId = crypto.randomUUID();
+      const now = /* @__PURE__ */ new Date();
       const {
         scorer,
         preprocessStepResult,
@@ -2341,7 +2431,7 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
         entity,
         ...rest
       } = validatedScore;
-      await this.operations.insert({
+      await this.db.insert({
         tableName: storage.TABLE_SCORERS,
         record: {
           id: scoreId,
@@ -2355,16 +2445,15 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
           requestContext: requestContext || null,
           entity: entity || null,
           scorer: scorer || null,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+          createdAt: now.toISOString(),
+          updatedAt: now.toISOString()
         }
       });
-      const scoreFromDb = await this.getScoreById({ id: scoreId });
-      return { score: scoreFromDb };
+      return { score: { ...validatedScore, id: scoreId, createdAt: now, updatedAt: now } };
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_SAVE_SCORE_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "SAVE_SCORE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -2399,7 +2488,7 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
         paramIndex++;
       }
       const whereClause = conditions.join(" AND ");
-      const tableName = getTableName({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName(this.schema) });
+      const tableName = getTableName2({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName2(this.schema) });
       const countRequest = this.pool.request();
       Object.entries(params).forEach(([key, value]) => {
         countRequest.input(key, value);
@@ -2442,7 +2531,7 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_GET_SCORES_BY_SCORER_ID_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "LIST_SCORES_BY_SCORER_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { scorerId }
@@ -2459,7 +2548,7 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
       const request = this.pool.request();
       request.input("p1", runId);
       const totalResult = await request.query(
-        `SELECT COUNT(*) as count FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName(this.schema) })} WHERE [runId] = @p1`
+        `SELECT COUNT(*) as count FROM ${getTableName2({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName2(this.schema) })} WHERE [runId] = @p1`
       );
       const total = totalResult.recordset[0]?.count || 0;
       const { page, perPage: perPageInput } = pagination;
@@ -2483,7 +2572,7 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
       dataRequest.input("p2", limitValue);
       dataRequest.input("p3", start);
       const result = await dataRequest.query(
-        `SELECT * FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName(this.schema) })} WHERE [runId] = @p1 ORDER BY [createdAt] DESC OFFSET @p3 ROWS FETCH NEXT @p2 ROWS ONLY`
+        `SELECT * FROM ${getTableName2({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName2(this.schema) })} WHERE [runId] = @p1 ORDER BY [createdAt] DESC OFFSET @p3 ROWS FETCH NEXT @p2 ROWS ONLY`
       );
       return {
         pagination: {
@@ -2497,7 +2586,7 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_GET_SCORES_BY_RUN_ID_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "LIST_SCORES_BY_RUN_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { runId }
@@ -2516,7 +2605,7 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
       request.input("p1", entityId);
       request.input("p2", entityType);
       const totalResult = await request.query(
-        `SELECT COUNT(*) as count FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName(this.schema) })} WHERE [entityId] = @p1 AND [entityType] = @p2`
+        `SELECT COUNT(*) as count FROM ${getTableName2({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName2(this.schema) })} WHERE [entityId] = @p1 AND [entityType] = @p2`
       );
       const total = totalResult.recordset[0]?.count || 0;
       const { page, perPage: perPageInput } = pagination;
@@ -2541,7 +2630,7 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
       dataRequest.input("p3", limitValue);
       dataRequest.input("p4", start);
       const result = await dataRequest.query(
-        `SELECT * FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName(this.schema) })} WHERE [entityId] = @p1 AND [entityType] = @p2 ORDER BY [createdAt] DESC OFFSET @p4 ROWS FETCH NEXT @p3 ROWS ONLY`
+        `SELECT * FROM ${getTableName2({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName2(this.schema) })} WHERE [entityId] = @p1 AND [entityType] = @p2 ORDER BY [createdAt] DESC OFFSET @p4 ROWS FETCH NEXT @p3 ROWS ONLY`
       );
       return {
         pagination: {
@@ -2555,7 +2644,7 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_GET_SCORES_BY_ENTITY_ID_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "LIST_SCORES_BY_ENTITY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { entityId, entityType }
@@ -2574,7 +2663,7 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
       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`
+        `SELECT COUNT(*) as count FROM ${getTableName2({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName2(this.schema) })} WHERE [traceId] = @p1 AND [spanId] = @p2`
       );
       const total = totalResult.recordset[0]?.count || 0;
       const { page, perPage: perPageInput } = pagination;
@@ -2599,7 +2688,7 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
       dataRequest.input("p3", limitValue);
       dataRequest.input("p4", start);
       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`
+        `SELECT * FROM ${getTableName2({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName2(this.schema) })} WHERE [traceId] = @p1 AND [spanId] = @p2 ORDER BY [createdAt] DESC OFFSET @p4 ROWS FETCH NEXT @p3 ROWS ONLY`
       );
       return {
         pagination: {
@@ -2613,7 +2702,7 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_GET_SCORES_BY_SPAN_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "LIST_SCORES_BY_SPAN", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: { traceId, spanId }
@@ -2625,17 +2714,26 @@ var ScoresMSSQL = class extends storage.ScoresStorage {
 };
 var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
   pool;
-  operations;
+  db;
   schema;
-  constructor({
-    pool,
-    operations,
-    schema
-  }) {
+  needsConnect;
+  constructor(config) {
     super();
+    const { pool, db, schema, needsConnect } = resolveMssqlConfig(config);
     this.pool = pool;
-    this.operations = operations;
+    this.db = db;
     this.schema = schema;
+    this.needsConnect = needsConnect;
+  }
+  async init() {
+    if (this.needsConnect) {
+      await this.pool.connect();
+      this.needsConnect = false;
+    }
+    await this.db.createTable({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT, schema: storage.TABLE_SCHEMAS[storage.TABLE_WORKFLOW_SNAPSHOT] });
+  }
+  async dangerouslyClearAll() {
+    await this.db.clearTable({ tableName: storage.TABLE_WORKFLOW_SNAPSHOT });
   }
   parseWorkflowRun(row) {
     let parsedSnapshot = row.snapshot;
@@ -2662,11 +2760,11 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
     result,
     requestContext
   }) {
-    const table = getTableName({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName(this.schema) });
+    const table = getTableName2({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName2(this.schema) });
     const transaction = this.pool.transaction();
     try {
       await transaction.begin();
-      const selectRequest = new sql2__default.default.Request(transaction);
+      const selectRequest = new sql__default.default.Request(transaction);
       selectRequest.input("workflow_name", workflowName);
       selectRequest.input("run_id", runId);
       const existingSnapshotResult = await selectRequest.query(
@@ -2694,12 +2792,12 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
       }
       snapshot.context[stepId] = result;
       snapshot.requestContext = { ...snapshot.requestContext, ...requestContext };
-      const upsertReq = new sql2__default.default.Request(transaction);
+      const upsertReq = new sql__default.default.Request(transaction);
       upsertReq.input("workflow_name", workflowName);
       upsertReq.input("run_id", runId);
       upsertReq.input("snapshot", JSON.stringify(snapshot));
-      upsertReq.input("createdAt", sql2__default.default.DateTime2, /* @__PURE__ */ new Date());
-      upsertReq.input("updatedAt", sql2__default.default.DateTime2, /* @__PURE__ */ new Date());
+      upsertReq.input("createdAt", sql__default.default.DateTime2, /* @__PURE__ */ new Date());
+      upsertReq.input("updatedAt", sql__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
@@ -2717,7 +2815,7 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
       }
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_UPDATE_WORKFLOW_RESULTS_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "UPDATE_WORKFLOW_RESULTS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
@@ -2735,11 +2833,11 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
     runId,
     opts
   }) {
-    const table = getTableName({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName(this.schema) });
+    const table = getTableName2({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName2(this.schema) });
     const transaction = this.pool.transaction();
     try {
       await transaction.begin();
-      const selectRequest = new sql2__default.default.Request(transaction);
+      const selectRequest = new sql__default.default.Request(transaction);
       selectRequest.input("workflow_name", workflowName);
       selectRequest.input("run_id", runId);
       const existingSnapshotResult = await selectRequest.query(
@@ -2755,7 +2853,7 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
         await transaction.rollback();
         throw new error.MastraError(
           {
-            id: "MASTRA_STORAGE_MSSQL_STORE_UPDATE_WORKFLOW_STATE_SNAPSHOT_NOT_FOUND",
+            id: storage.createStorageErrorId("MSSQL", "UPDATE_WORKFLOW_STATE", "SNAPSHOT_NOT_FOUND"),
             domain: error.ErrorDomain.STORAGE,
             category: error.ErrorCategory.SYSTEM,
             details: {
@@ -2767,11 +2865,11 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
         );
       }
       const updatedSnapshot = { ...snapshot, ...opts };
-      const updateRequest = new sql2__default.default.Request(transaction);
+      const updateRequest = new sql__default.default.Request(transaction);
       updateRequest.input("snapshot", JSON.stringify(updatedSnapshot));
       updateRequest.input("workflow_name", workflowName);
       updateRequest.input("run_id", runId);
-      updateRequest.input("updatedAt", sql2__default.default.DateTime2, /* @__PURE__ */ new Date());
+      updateRequest.input("updatedAt", sql__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`
       );
@@ -2782,9 +2880,10 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
         await transaction.rollback();
       } catch {
       }
+      if (error$1 instanceof error.MastraError) throw error$1;
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_UPDATE_WORKFLOW_STATE_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "UPDATE_WORKFLOW_STATE", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
@@ -2802,7 +2901,7 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
     resourceId,
     snapshot
   }) {
-    const table = getTableName({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName(this.schema) });
+    const table = getTableName2({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName2(this.schema) });
     const now = (/* @__PURE__ */ new Date()).toISOString();
     try {
       const request = this.pool.request();
@@ -2810,8 +2909,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", sql__default.default.DateTime2, new Date(now));
+      request.input("updatedAt", sql__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
@@ -2825,7 +2924,7 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "PERSIST_WORKFLOW_SNAPSHOT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
@@ -2842,7 +2941,7 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
     runId
   }) {
     try {
-      const result = await this.operations.load({
+      const result = await this.db.load({
         tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
         keys: {
           workflow_name: workflowName,
@@ -2856,7 +2955,7 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "LOAD_WORKFLOW_SNAPSHOT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
@@ -2884,7 +2983,7 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
         paramMap["workflowName"] = workflowName;
       }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-      const tableName = getTableName({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName(this.schema) });
+      const tableName = getTableName2({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName2(this.schema) });
       const query = `SELECT * FROM ${tableName} ${whereClause}`;
       const request = this.pool.request();
       Object.entries(paramMap).forEach(([key, value]) => request.input(key, value));
@@ -2896,7 +2995,7 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "GET_WORKFLOW_RUN_BY_ID", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
@@ -2908,6 +3007,35 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
       );
     }
   }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    const table = getTableName2({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName2(this.schema) });
+    const transaction = this.pool.transaction();
+    try {
+      await transaction.begin();
+      const deleteRequest = new sql__default.default.Request(transaction);
+      deleteRequest.input("workflow_name", workflowName);
+      deleteRequest.input("run_id", runId);
+      await deleteRequest.query(`DELETE FROM ${table} WHERE workflow_name = @workflow_name AND run_id = @run_id`);
+      await transaction.commit();
+    } catch (error$1) {
+      try {
+        await transaction.rollback();
+      } catch {
+      }
+      throw new error.MastraError(
+        {
+          id: storage.createStorageErrorId("MSSQL", "DELETE_WORKFLOW_RUN_BY_ID", "FAILED"),
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            runId,
+            workflowName
+          }
+        },
+        error$1
+      );
+    }
+  }
   async listWorkflowRuns({
     workflowName,
     fromDate,
@@ -2929,7 +3057,7 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
         paramMap["status"] = status;
       }
       if (resourceId) {
-        const hasResourceId = await this.operations.hasColumn(storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId");
+        const hasResourceId = await this.db.hasColumn(storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId");
         if (hasResourceId) {
           conditions.push(`[resourceId] = @resourceId`);
           paramMap["resourceId"] = resourceId;
@@ -2947,11 +3075,11 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
       }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
       let total = 0;
-      const tableName = getTableName({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName(this.schema) });
+      const tableName = getTableName2({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName2(this.schema) });
       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, sql__default.default.DateTime, value);
         } else {
           request.input(key, value);
         }
@@ -2976,7 +3104,7 @@ var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_LIST_WORKFLOW_RUNS_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "LIST_WORKFLOW_RUNS", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
@@ -2994,12 +3122,13 @@ var MSSQLStore = class extends storage.MastraStorage {
   pool;
   schema;
   isConnected = null;
+  #db;
   stores;
   constructor(config) {
     if (!config.id || typeof config.id !== "string" || config.id.trim() === "") {
       throw new Error("MSSQLStore: id must be provided and cannot be empty.");
     }
-    super({ id: config.id, name: "MSSQLStore" });
+    super({ id: config.id, name: "MSSQLStore", disableInit: config.disableInit });
     try {
       if ("connectionString" in config) {
         if (!config.connectionString || typeof config.connectionString !== "string" || config.connectionString.trim() === "") {
@@ -3014,7 +3143,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 sql__default.default.ConnectionPool(config.connectionString) : new sql__default.default.ConnectionPool({
         server: config.server,
         database: config.database,
         user: config.user,
@@ -3022,13 +3151,13 @@ var MSSQLStore = class extends storage.MastraStorage {
         port: config.port,
         options: config.options || { encrypt: true, trustServerCertificate: true }
       });
-      const operations = new StoreOperationsMSSQL({ pool: this.pool, schemaName: this.schema });
-      const scores = new ScoresMSSQL({ 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.#db = new MssqlDB({ pool: this.pool, schemaName: this.schema });
+      const domainConfig = { pool: this.pool, db: this.#db, schema: this.schema };
+      const scores = new ScoresMSSQL(domainConfig);
+      const workflows = new WorkflowsMSSQL(domainConfig);
+      const memory = new MemoryMSSQL(domainConfig);
+      const observability = new ObservabilityMSSQL(domainConfig);
       this.stores = {
-        operations,
         scores,
         workflows,
         memory,
@@ -3037,7 +3166,7 @@ var MSSQLStore = class extends storage.MastraStorage {
     } catch (e) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_INITIALIZATION_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "INITIALIZATION", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.USER
         },
@@ -3053,7 +3182,7 @@ var MSSQLStore = class extends storage.MastraStorage {
       await this.isConnected;
       await super.init();
       try {
-        await this.stores.operations.createAutomaticIndexes();
+        await this.#db.createAutomaticIndexes();
       } catch (indexError) {
         this.logger?.warn?.("Failed to create indexes:", indexError);
       }
@@ -3061,7 +3190,7 @@ var MSSQLStore = class extends storage.MastraStorage {
       this.isConnected = null;
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_INIT_FAILED",
+          id: storage.createStorageErrorId("MSSQL", "INIT", "FAILED"),
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY
         },
@@ -3089,34 +3218,6 @@ var MSSQLStore = class extends storage.MastraStorage {
       indexManagement: true
     };
   }
-  async createTable({
-    tableName,
-    schema
-  }) {
-    return this.stores.operations.createTable({ tableName, schema });
-  }
-  async alterTable({
-    tableName,
-    schema,
-    ifNotExists
-  }) {
-    return this.stores.operations.alterTable({ tableName, schema, ifNotExists });
-  }
-  async clearTable({ tableName }) {
-    return this.stores.operations.clearTable({ tableName });
-  }
-  async dropTable({ tableName }) {
-    return this.stores.operations.dropTable({ tableName });
-  }
-  async insert({ tableName, record }) {
-    return this.stores.operations.insert({ tableName, record });
-  }
-  async batchInsert({ tableName, records }) {
-    return this.stores.operations.batchInsert({ tableName, records });
-  }
-  async load({ tableName, keys }) {
-    return this.stores.operations.load({ tableName, keys });
-  }
   /**
    * Memory
    */
@@ -3205,6 +3306,9 @@ var MSSQLStore = class extends storage.MastraStorage {
   }) {
     return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
   }
+  async deleteWorkflowRunById({ runId, workflowName }) {
+    return this.stores.workflows.deleteWorkflowRunById({ runId, workflowName });
+  }
   async close() {
     await this.pool.close();
   }
@@ -3212,16 +3316,16 @@ var MSSQLStore = class extends storage.MastraStorage {
    * Index Management
    */
   async createIndex(options) {
-    return this.stores.operations.createIndex(options);
+    return this.#db.createIndex(options);
   }
   async listIndexes(tableName) {
-    return this.stores.operations.listIndexes(tableName);
+    return this.#db.listIndexes(tableName);
   }
   async describeIndex(indexName) {
-    return this.stores.operations.describeIndex(indexName);
+    return this.#db.describeIndex(indexName);
   }
   async dropIndex(indexName) {
-    return this.stores.operations.dropIndex(indexName);
+    return this.#db.dropIndex(indexName);
   }
   /**
    * Tracing / Observability
@@ -3229,7 +3333,7 @@ var MSSQLStore = class extends storage.MastraStorage {
   getObservabilityStore() {
     if (!this.stores.observability) {
       throw new error.MastraError({
-        id: "MSSQL_STORE_OBSERVABILITY_NOT_INITIALIZED",
+        id: storage.createStorageErrorId("MSSQL", "OBSERVABILITY", "NOT_INITIALIZED"),
         domain: error.ErrorDomain.STORAGE,
         category: error.ErrorCategory.SYSTEM,
         text: "Observability storage is not initialized"
@@ -3283,8 +3387,8 @@ var MSSQLStore = class extends storage.MastraStorage {
       source: _source
     });
   }
-  async saveScore(_score) {
-    return this.stores.scores.saveScore(_score);
+  async saveScore(score) {
+    return this.stores.scores.saveScore(score);
   }
   async listScoresByRunId({
     runId: _runId,