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

package/dist/index.cjs

@@ -1,132 +1,66 @@
 'use strict';
 
-var agent = require('@mastra/core/agent');
 var error = require('@mastra/core/error');
 var storage = require('@mastra/core/storage');
+var sql2 = require('mssql');
 var utils = require('@mastra/core/utils');
-var sql = require('mssql');
+var agent = require('@mastra/core/agent');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var sql__default = /*#__PURE__*/_interopDefault(sql);
+var sql2__default = /*#__PURE__*/_interopDefault(sql2);
 
 // src/storage/index.ts
-var MSSQLStore = class extends storage.MastraStorage {
-  pool;
-  schema;
-  setupSchemaPromise = null;
-  schemaSetupComplete = void 0;
-  isConnected = null;
-  constructor(config) {
-    super({ name: "MSSQLStore" });
-    try {
-      if ("connectionString" in config) {
-        if (!config.connectionString || typeof config.connectionString !== "string" || config.connectionString.trim() === "") {
-          throw new Error("MSSQLStore: connectionString must be provided and cannot be empty.");
-        }
-      } else {
-        const required = ["server", "database", "user", "password"];
-        for (const key of required) {
-          if (!(key in config) || typeof config[key] !== "string" || config[key].trim() === "") {
-            throw new Error(`MSSQLStore: ${key} must be provided and cannot be empty.`);
-          }
-        }
-      }
-      this.schema = config.schemaName;
-      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,
-        password: config.password,
-        port: config.port,
-        options: config.options || { encrypt: true, trustServerCertificate: true }
-      });
-    } catch (e) {
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_MSSQL_STORE_INITIALIZATION_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.USER
-        },
-        e
-      );
-    }
-  }
-  async init() {
-    if (this.isConnected === null) {
-      this.isConnected = this._performInitializationAndStore();
-    }
+function getSchemaName(schema) {
+  return schema ? `[${utils.parseSqlIdentifier(schema, "schema name")}]` : void 0;
+}
+function getTableName({ indexName, schemaName }) {
+  const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
+  const quotedIndexName = `[${parsedIndexName}]`;
+  const quotedSchemaName = schemaName;
+  return quotedSchemaName ? `${quotedSchemaName}.${quotedIndexName}` : quotedIndexName;
+}
+
+// src/storage/domains/legacy-evals/index.ts
+function transformEvalRow(row) {
+  let testInfoValue = null, resultValue = null;
+  if (row.test_info) {
     try {
-      await this.isConnected;
-      await super.init();
-    } catch (error$1) {
-      this.isConnected = null;
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_MSSQL_STORE_INIT_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        },
-        error$1
-      );
+      testInfoValue = typeof row.test_info === "string" ? JSON.parse(row.test_info) : row.test_info;
+    } catch {
     }
   }
-  async _performInitializationAndStore() {
+  if (row.test_info) {
     try {
-      await this.pool.connect();
-      return true;
-    } catch (err) {
-      throw err;
+      resultValue = typeof row.result === "string" ? JSON.parse(row.result) : row.result;
+    } catch {
     }
   }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: true,
-      resourceWorkingMemory: true,
-      hasColumn: true,
-      createTable: true
-    };
-  }
-  getTableName(indexName) {
-    const parsedIndexName = utils.parseSqlIdentifier(indexName, "index name");
-    const quotedIndexName = `[${parsedIndexName}]`;
-    const quotedSchemaName = this.getSchemaName();
-    return quotedSchemaName ? `${quotedSchemaName}.${quotedIndexName}` : quotedIndexName;
-  }
-  getSchemaName() {
-    return this.schema ? `[${utils.parseSqlIdentifier(this.schema, "schema name")}]` : void 0;
-  }
-  transformEvalRow(row) {
-    let testInfoValue = null, resultValue = null;
-    if (row.test_info) {
-      try {
-        testInfoValue = typeof row.test_info === "string" ? JSON.parse(row.test_info) : row.test_info;
-      } catch {
-      }
-    }
-    if (row.test_info) {
-      try {
-        resultValue = typeof row.result === "string" ? JSON.parse(row.result) : row.result;
-      } catch {
-      }
-    }
-    return {
-      agentName: row.agent_name,
-      input: row.input,
-      output: row.output,
-      result: resultValue,
-      metricName: row.metric_name,
-      instructions: row.instructions,
-      testInfo: testInfoValue,
-      globalRunId: row.global_run_id,
-      runId: row.run_id,
-      createdAt: row.created_at
-    };
+  return {
+    agentName: row.agent_name,
+    input: row.input,
+    output: row.output,
+    result: resultValue,
+    metricName: row.metric_name,
+    instructions: row.instructions,
+    testInfo: testInfoValue,
+    globalRunId: row.global_run_id,
+    runId: row.run_id,
+    createdAt: row.created_at
+  };
+}
+var LegacyEvalsMSSQL = class extends storage.LegacyEvalsStorage {
+  pool;
+  schema;
+  constructor({ pool, schema }) {
+    super();
+    this.pool = pool;
+    this.schema = schema;
   }
   /** @deprecated use getEvals instead */
   async getEvalsByAgentName(agentName, type) {
     try {
-      let query = `SELECT * FROM ${this.getTableName(storage.TABLE_EVALS)} WHERE agent_name = @p1`;
+      let query = `SELECT * FROM ${getTableName({ indexName: storage.TABLE_EVALS, schemaName: getSchemaName(this.schema) })} WHERE agent_name = @p1`;
       if (type === "test") {
         query += " AND test_info IS NOT NULL AND JSON_VALUE(test_info, '$.testPath') IS NOT NULL";
       } else if (type === "live") {
@@ -137,7 +71,7 @@ var MSSQLStore = class extends storage.MastraStorage {
       request.input("p1", agentName);
       const result = await request.query(query);
       const rows = result.recordset;
-      return typeof this.transformEvalRow === "function" ? rows?.map((row) => this.transformEvalRow(row)) ?? [] : rows ?? [];
+      return typeof transformEvalRow === "function" ? rows?.map((row) => transformEvalRow(row)) ?? [] : rows ?? [];
     } catch (error) {
       if (error && error.number === 208 && error.message && error.message.includes("Invalid object name")) {
         return [];
@@ -146,597 +80,267 @@ var MSSQLStore = class extends storage.MastraStorage {
       throw error;
     }
   }
-  async batchInsert({ tableName, records }) {
-    const transaction = this.pool.transaction();
-    try {
-      await transaction.begin();
-      for (const record of records) {
-        await this.insert({ tableName, record });
-      }
-      await transaction.commit();
-    } catch (error$1) {
-      await transaction.rollback();
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_MSSQL_STORE_BATCH_INSERT_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName,
-            numberOfRecords: records.length
-          }
-        },
-        error$1
-      );
-    }
-  }
-  /** @deprecated use getTracesPaginated instead*/
-  async getTraces(args) {
-    if (args.fromDate || args.toDate) {
-      args.dateRange = {
-        start: args.fromDate,
-        end: args.toDate
-      };
-    }
-    const result = await this.getTracesPaginated(args);
-    return result.traces;
-  }
-  async getTracesPaginated(args) {
-    const { name, scope, page = 0, perPage: perPageInput, attributes, filters, dateRange } = args;
+  async getEvals(options = {}) {
+    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
     const fromDate = dateRange?.start;
     const toDate = dateRange?.end;
-    const perPage = perPageInput !== void 0 ? perPageInput : 100;
-    const currentOffset = page * perPage;
-    const paramMap = {};
-    const conditions = [];
-    let paramIndex = 1;
-    if (name) {
-      const paramName = `p${paramIndex++}`;
-      conditions.push(`[name] LIKE @${paramName}`);
-      paramMap[paramName] = `${name}%`;
-    }
-    if (scope) {
-      const paramName = `p${paramIndex++}`;
-      conditions.push(`[scope] = @${paramName}`);
-      paramMap[paramName] = scope;
-    }
-    if (attributes) {
-      Object.entries(attributes).forEach(([key, value]) => {
-        const parsedKey = utils.parseFieldKey(key);
-        const paramName = `p${paramIndex++}`;
-        conditions.push(`JSON_VALUE([attributes], '$.${parsedKey}') = @${paramName}`);
-        paramMap[paramName] = value;
-      });
+    const where = [];
+    const params = {};
+    if (agentName) {
+      where.push("agent_name = @agentName");
+      params["agentName"] = agentName;
     }
-    if (filters) {
-      Object.entries(filters).forEach(([key, value]) => {
-        const parsedKey = utils.parseFieldKey(key);
-        const paramName = `p${paramIndex++}`;
-        conditions.push(`[${parsedKey}] = @${paramName}`);
-        paramMap[paramName] = value;
-      });
+    if (type === "test") {
+      where.push("test_info IS NOT NULL AND JSON_VALUE(test_info, '$.testPath') IS NOT NULL");
+    } else if (type === "live") {
+      where.push("(test_info IS NULL OR JSON_VALUE(test_info, '$.testPath') IS NULL)");
     }
     if (fromDate instanceof Date && !isNaN(fromDate.getTime())) {
-      const paramName = `p${paramIndex++}`;
-      conditions.push(`[createdAt] >= @${paramName}`);
-      paramMap[paramName] = fromDate.toISOString();
+      where.push(`[created_at] >= @fromDate`);
+      params[`fromDate`] = fromDate.toISOString();
     }
     if (toDate instanceof Date && !isNaN(toDate.getTime())) {
-      const paramName = `p${paramIndex++}`;
-      conditions.push(`[createdAt] <= @${paramName}`);
-      paramMap[paramName] = toDate.toISOString();
+      where.push(`[created_at] <= @toDate`);
+      params[`toDate`] = toDate.toISOString();
     }
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-    const countQuery = `SELECT COUNT(*) as total FROM ${this.getTableName(storage.TABLE_TRACES)} ${whereClause}`;
-    let total = 0;
+    const whereClause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+    const tableName = getTableName({ indexName: storage.TABLE_EVALS, schemaName: getSchemaName(this.schema) });
+    const offset = page * perPage;
+    const countQuery = `SELECT COUNT(*) as total FROM ${tableName} ${whereClause}`;
+    const dataQuery = `SELECT * FROM ${tableName} ${whereClause} ORDER BY seq_id DESC OFFSET @offset ROWS FETCH NEXT @perPage ROWS ONLY`;
     try {
-      const countRequest = this.pool.request();
-      Object.entries(paramMap).forEach(([key, value]) => {
+      const countReq = this.pool.request();
+      Object.entries(params).forEach(([key, value]) => {
         if (value instanceof Date) {
-          countRequest.input(key, sql__default.default.DateTime, value);
+          countReq.input(key, sql2__default.default.DateTime, value);
         } else {
-          countRequest.input(key, value);
+          countReq.input(key, value);
         }
       });
-      const countResult = await countRequest.query(countQuery);
-      total = parseInt(countResult.recordset[0].total, 10);
+      const countResult = await countReq.query(countQuery);
+      const total = countResult.recordset[0]?.total || 0;
+      if (total === 0) {
+        return {
+          evals: [],
+          total: 0,
+          page,
+          perPage,
+          hasMore: false
+        };
+      }
+      const req = this.pool.request();
+      Object.entries(params).forEach(([key, value]) => {
+        if (value instanceof Date) {
+          req.input(key, sql2__default.default.DateTime, value);
+        } else {
+          req.input(key, value);
+        }
+      });
+      req.input("offset", offset);
+      req.input("perPage", perPage);
+      const result = await req.query(dataQuery);
+      const rows = result.recordset;
+      return {
+        evals: rows?.map((row) => transformEvalRow(row)) ?? [],
+        total,
+        page,
+        perPage,
+        hasMore: offset + (rows?.length ?? 0) < total
+      };
     } catch (error$1) {
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_GET_TRACES_PAGINATED_FAILED_TO_RETRIEVE_TOTAL_COUNT",
+          id: "MASTRA_STORAGE_MSSQL_STORE_GET_EVALS_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            name: args.name ?? "",
-            scope: args.scope ?? ""
+            agentName: agentName || "all",
+            type: type || "all",
+            page,
+            perPage
           }
         },
         error$1
       );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      throw mastraError;
     }
-    if (total === 0) {
-      return {
-        traces: [],
-        total: 0,
-        page,
-        perPage,
-        hasMore: false
-      };
-    }
-    const dataQuery = `SELECT * FROM ${this.getTableName(storage.TABLE_TRACES)} ${whereClause} ORDER BY [seq_id] DESC OFFSET @offset ROWS FETCH NEXT @limit ROWS ONLY`;
-    const dataRequest = this.pool.request();
-    Object.entries(paramMap).forEach(([key, value]) => {
-      if (value instanceof Date) {
-        dataRequest.input(key, sql__default.default.DateTime, value);
-      } else {
-        dataRequest.input(key, value);
+  }
+};
+var MemoryMSSQL = class extends storage.MemoryStorage {
+  pool;
+  schema;
+  operations;
+  _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;
     });
-    dataRequest.input("offset", currentOffset);
-    dataRequest.input("limit", perPage);
+    const cleanMessages = messagesWithParsedContent.map(({ seq_id, ...rest }) => rest);
+    const list = new agent.MessageList().add(cleanMessages, "memory");
+    return format === "v2" ? list.get.all.v2() : list.get.all.v1();
+  }
+  constructor({
+    pool,
+    schema,
+    operations
+  }) {
+    super();
+    this.pool = pool;
+    this.schema = schema;
+    this.operations = operations;
+  }
+  async getThreadById({ threadId }) {
     try {
-      const rowsResult = await dataRequest.query(dataQuery);
-      const rows = rowsResult.recordset;
-      const traces = rows.map((row) => ({
-        id: row.id,
-        parentSpanId: row.parentSpanId,
-        traceId: row.traceId,
-        name: row.name,
-        scope: row.scope,
-        kind: row.kind,
-        status: JSON.parse(row.status),
-        events: JSON.parse(row.events),
-        links: JSON.parse(row.links),
-        attributes: JSON.parse(row.attributes),
-        startTime: row.startTime,
-        endTime: row.endTime,
-        other: row.other,
-        createdAt: row.createdAt
-      }));
+      const sql7 = `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(sql7);
+      const thread = resultSet.recordset[0] || null;
+      if (!thread) {
+        return null;
+      }
       return {
-        traces,
-        total,
-        page,
-        perPage,
-        hasMore: currentOffset + traces.length < total
+        ...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_TRACES_PAGINATED_FAILED_TO_RETRIEVE_TRACES",
+          id: "MASTRA_STORAGE_MSSQL_STORE_GET_THREAD_BY_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            name: args.name ?? "",
-            scope: args.scope ?? ""
+            threadId
           }
         },
         error$1
       );
     }
   }
-  async setupSchema() {
-    if (!this.schema || this.schemaSetupComplete) {
-      return;
-    }
-    if (!this.setupSchemaPromise) {
-      this.setupSchemaPromise = (async () => {
-        try {
-          const checkRequest = this.pool.request();
-          checkRequest.input("schemaName", this.schema);
-          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.schema}]`);
-              this.logger?.info?.(`Schema "${this.schema}" created successfully`);
-            } catch (error) {
-              this.logger?.error?.(`Failed to create schema "${this.schema}"`, { error });
-              throw new Error(
-                `Unable to create schema "${this.schema}". 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.schema}" is ready for use`);
-        } catch (error) {
-          this.schemaSetupComplete = void 0;
-          this.setupSchemaPromise = null;
-          throw error;
-        } finally {
-          this.setupSchemaPromise = null;
-        }
-      })();
-    }
-    await this.setupSchemaPromise;
-  }
-  getSqlType(type, isPrimaryKey = false) {
-    switch (type) {
-      case "text":
-        return isPrimaryKey ? "NVARCHAR(255)" : "NVARCHAR(MAX)";
-      case "timestamp":
-        return "DATETIME2(7)";
-      case "uuid":
-        return "UNIQUEIDENTIFIER";
-      case "jsonb":
-        return "NVARCHAR(MAX)";
-      case "integer":
-        return "INT";
-      case "bigint":
-        return "BIGINT";
-      default:
-        throw new error.MastraError({
-          id: "MASTRA_STORAGE_MSSQL_STORE_TYPE_NOT_SUPPORTED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY
-        });
-    }
-  }
-  async createTable({
-    tableName,
-    schema
-  }) {
+  async getThreadsByResourceIdPaginated(args) {
+    const { resourceId, page = 0, perPage: perPageInput, orderBy = "createdAt", sortDirection = "DESC" } = args;
     try {
-      const uniqueConstraintColumns = tableName === storage.TABLE_WORKFLOW_SNAPSHOT ? ["workflow_name", "run_id"] : [];
-      const columns = Object.entries(schema).map(([name, def]) => {
-        const parsedName = utils.parseSqlIdentifier(name, "column name");
-        const constraints = [];
-        if (def.primaryKey) constraints.push("PRIMARY KEY");
-        if (!def.nullable) constraints.push("NOT NULL");
-        const isIndexed = !!def.primaryKey || uniqueConstraintColumns.includes(name);
-        return `[${parsedName}] ${this.getSqlType(def.type, isIndexed)} ${constraints.join(" ")}`.trim();
-      }).join(",\n");
-      if (this.schema) {
-        await this.setupSchema();
-      }
-      const checkTableRequest = this.pool.request();
-      checkTableRequest.input("tableName", this.getTableName(tableName).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.schema || "dbo");
-      const checkTableResult = await checkTableRequest.query(checkTableSql);
-      const tableExists = Array.isArray(checkTableResult.recordset) && checkTableResult.recordset.length > 0;
-      if (!tableExists) {
-        const createSql = `CREATE TABLE ${this.getTableName(tableName)} (
-${columns}
-)`;
-        await this.pool.request().query(createSql);
-      }
-      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.schema || "dbo");
-      checkColumnRequest.input("tableName", this.getTableName(tableName).replace(/[[\]]/g, "").split(".").pop());
-      const columnResult = await checkColumnRequest.query(columnCheckSql);
-      const columnExists = Array.isArray(columnResult.recordset) && columnResult.recordset.length > 0;
-      if (!columnExists) {
-        const alterSql = `ALTER TABLE ${this.getTableName(tableName)} 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 ${this.getTableName(tableName)} ADD CONSTRAINT ${constraintName} UNIQUE ([workflow_name], [run_id])`;
-          await this.pool.request().query(addConstraintSql);
-        }
+      const perPage = perPageInput !== void 0 ? perPageInput : 100;
+      const currentOffset = page * perPage;
+      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,
+          hasMore: false
+        };
       }
+      const orderByField = orderBy === "createdAt" ? "[createdAt]" : "[updatedAt]";
+      const dataQuery = `SELECT id, [resourceId], title, metadata, [createdAt], [updatedAt] ${baseQuery} ORDER BY ${orderByField} ${sortDirection} OFFSET @offset ROWS FETCH NEXT @perPage ROWS ONLY`;
+      const dataRequest = this.pool.request();
+      dataRequest.input("resourceId", resourceId);
+      dataRequest.input("perPage", perPage);
+      dataRequest.input("offset", currentOffset);
+      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,
+        hasMore: currentOffset + threads.length < total
+      };
     } catch (error$1) {
-      throw new error.MastraError(
+      const mastraError = new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_CREATE_TABLE_FAILED",
+          id: "MASTRA_STORAGE_MSSQL_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_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: perPageInput || 100, hasMore: false };
     }
   }
-  getDefaultValue(type) {
-    switch (type) {
-      case "timestamp":
-        return "DEFAULT SYSDATETIMEOFFSET()";
-      case "jsonb":
-        return "DEFAULT N'{}'";
-      default:
-        return super.getDefaultValue(type);
-    }
-  }
-  async alterTable({
-    tableName,
-    schema,
-    ifNotExists
-  }) {
-    const fullTableName = this.getTableName(tableName);
+  async saveThread({ thread }) {
     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.schema || "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 sqlType = this.getSqlType(columnDef.type);
-            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}`);
-          }
-        }
-      }
+      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);
+      req.input("metadata", thread.metadata ? JSON.stringify(thread.metadata) : null);
+      req.input("createdAt", sql2__default.default.DateTime2, thread.createdAt);
+      req.input("updatedAt", sql2__default.default.DateTime2, thread.updatedAt);
+      await req.query(mergeSql);
+      return thread;
     } catch (error$1) {
       throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_ALTER_TABLE_FAILED",
+          id: "MASTRA_STORAGE_MSSQL_STORE_SAVE_THREAD_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
           details: {
-            tableName
+            threadId: thread.id
           }
         },
         error$1
       );
     }
   }
-  async clearTable({ tableName }) {
-    const fullTableName = this.getTableName(tableName);
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead
+   */
+  async getThreadsByResourceId(args) {
+    const { resourceId, orderBy = "createdAt", sortDirection = "DESC" } = args;
     try {
-      const fkQuery = `
-        SELECT
-          OBJECT_SCHEMA_NAME(fk.parent_object_id) AS schema_name,
-          OBJECT_NAME(fk.parent_object_id) AS table_name
-        FROM sys.foreign_keys fk
-        WHERE fk.referenced_object_id = OBJECT_ID(@fullTableName)
-      `;
-      const fkResult = await this.pool.request().input("fullTableName", fullTableName).query(fkQuery);
-      const childTables = fkResult.recordset || [];
-      for (const child of childTables) {
-        const childTableName = this.schema ? `[${child.schema_name}].[${child.table_name}]` : `[${child.table_name}]`;
-        await this.clearTable({ tableName: childTableName });
-      }
-      await this.pool.request().query(`TRUNCATE TABLE ${fullTableName}`);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_MSSQL_STORE_CLEAR_TABLE_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async insert({ tableName, record }) {
-    try {
-      const columns = Object.keys(record).map((col) => utils.parseSqlIdentifier(col, "column name"));
-      const values = Object.values(record);
-      const paramNames = values.map((_, i) => `@param${i}`);
-      const insertSql = `INSERT INTO ${this.getTableName(tableName)} (${columns.map((c) => `[${c}]`).join(", ")}) VALUES (${paramNames.join(", ")})`;
-      const request = this.pool.request();
-      values.forEach((value, i) => {
-        if (value instanceof Date) {
-          request.input(`param${i}`, sql__default.default.DateTime2, value);
-        } else if (typeof value === "object" && value !== null) {
-          request.input(`param${i}`, JSON.stringify(value));
-        } else {
-          request.input(`param${i}`, value);
-        }
-      });
-      await request.query(insertSql);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_MSSQL_STORE_INSERT_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async load({ tableName, keys }) {
-    try {
-      const keyEntries = Object.entries(keys).map(([key, value]) => [utils.parseSqlIdentifier(key, "column name"), value]);
-      const conditions = keyEntries.map(([key], i) => `[${key}] = @param${i}`).join(" AND ");
-      const values = keyEntries.map(([_, value]) => value);
-      const sql2 = `SELECT * FROM ${this.getTableName(tableName)} WHERE ${conditions}`;
-      const request = this.pool.request();
-      values.forEach((value, i) => {
-        request.input(`param${i}`, value);
-      });
-      const resultSet = await request.query(sql2);
-      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_LOAD_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            tableName
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async getThreadById({ threadId }) {
-    try {
-      const sql2 = `SELECT 
-        id,
-        [resourceId],
-        title,
-        metadata,
-        [createdAt],
-        [updatedAt]
-      FROM ${this.getTableName(storage.TABLE_THREADS)}
-      WHERE id = @threadId`;
-      const request = this.pool.request();
-      request.input("threadId", threadId);
-      const resultSet = await request.query(sql2);
-      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: "MASTRA_STORAGE_MSSQL_STORE_GET_THREAD_BY_ID_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async getThreadsByResourceIdPaginated(args) {
-    const { resourceId, page = 0, perPage: perPageInput } = args;
-    try {
-      const perPage = perPageInput !== void 0 ? perPageInput : 100;
-      const currentOffset = page * perPage;
-      const baseQuery = `FROM ${this.getTableName(storage.TABLE_THREADS)} 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,
-          hasMore: false
-        };
-      }
-      const dataQuery = `SELECT id, [resourceId], title, metadata, [createdAt], [updatedAt] ${baseQuery} ORDER BY [seq_id] DESC OFFSET @offset ROWS FETCH NEXT @perPage ROWS ONLY`;
-      const dataRequest = this.pool.request();
-      dataRequest.input("resourceId", resourceId);
-      dataRequest.input("perPage", perPage);
-      dataRequest.input("offset", currentOffset);
-      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,
-        hasMore: currentOffset + threads.length < total
-      };
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_MSSQL_STORE_GET_THREADS_BY_RESOURCE_ID_PAGINATED_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            resourceId,
-            page
-          }
-        },
-        error$1
-      );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException?.(mastraError);
-      return { threads: [], total: 0, page, perPage: perPageInput || 100, hasMore: false };
-    }
-  }
-  async saveThread({ thread }) {
-    try {
-      const table = this.getTableName(storage.TABLE_THREADS);
-      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,
-            [createdAt] = @createdAt,
-            [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);
-      req.input("metadata", thread.metadata ? JSON.stringify(thread.metadata) : null);
-      req.input("createdAt", thread.createdAt);
-      req.input("updatedAt", thread.updatedAt);
-      await req.query(mergeSql);
-      return thread;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_MSSQL_STORE_SAVE_THREAD_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            threadId: thread.id
-          }
-        },
-        error$1
-      );
-    }
-  }
-  /**
-   * @deprecated use getThreadsByResourceIdPaginated instead
-   */
-  async getThreadsByResourceId(args) {
-    const { resourceId } = args;
-    try {
-      const baseQuery = `FROM ${this.getTableName(storage.TABLE_THREADS)} WHERE [resourceId] = @resourceId`;
-      const dataQuery = `SELECT id, [resourceId], title, metadata, [createdAt], [updatedAt] ${baseQuery} ORDER BY [seq_id] DESC`;
+      const baseQuery = `FROM ${getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) })} WHERE [resourceId] = @resourceId`;
+      const orderByField = orderBy === "createdAt" ? "[createdAt]" : "[updatedAt]";
+      const dataQuery = `SELECT id, [resourceId], title, metadata, [createdAt], [updatedAt] ${baseQuery} ORDER BY ${orderByField} ${sortDirection}`;
       const request = this.pool.request();
       request.input("resourceId", resourceId);
       const resultSet = await request.query(dataQuery);
@@ -778,8 +382,8 @@ ${columns}
       ...metadata
     };
     try {
-      const table = this.getTableName(storage.TABLE_THREADS);
-      const sql2 = `UPDATE ${table}
+      const table = getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) });
+      const sql7 = `UPDATE ${table}
         SET title = @title,
             metadata = @metadata,
             [updatedAt] = @updatedAt
@@ -789,8 +393,8 @@ ${columns}
       req.input("id", id);
       req.input("title", title);
       req.input("metadata", JSON.stringify(mergedMetadata));
-      req.input("updatedAt", (/* @__PURE__ */ new Date()).toISOString());
-      const result = await req.query(sql2);
+      req.input("updatedAt", /* @__PURE__ */ new Date());
+      const result = await req.query(sql7);
       let thread = result.recordset && result.recordset[0];
       if (thread && "seq_id" in thread) {
         const { seq_id, ...rest } = thread;
@@ -830,8 +434,8 @@ ${columns}
     }
   }
   async deleteThread({ threadId }) {
-    const messagesTable = this.getTableName(storage.TABLE_MESSAGES);
-    const threadsTable = this.getTableName(storage.TABLE_THREADS);
+    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();
@@ -889,7 +493,7 @@ ${columns}
             m.seq_id
           FROM (
             SELECT *, ROW_NUMBER() OVER (${orderByStatement}) as row_num
-            FROM ${this.getTableName(storage.TABLE_MESSAGES)}
+            FROM ${getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })}
             WHERE [thread_id] = ${pThreadId}
           ) AS m
           WHERE m.id = ${pId}
@@ -897,7 +501,7 @@ ${columns}
             SELECT 1
             FROM (
               SELECT *, ROW_NUMBER() OVER (${orderByStatement}) as row_num
-              FROM ${this.getTableName(storage.TABLE_MESSAGES)}
+              FROM ${getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })}
               WHERE [thread_id] = ${pThreadId}
             ) AS target
             WHERE target.id = ${pId}
@@ -935,9 +539,9 @@ ${columns}
   }
   async getMessages(args) {
     const { threadId, format, selectBy } = args;
-    const selectStatement = `SELECT seq_id, id, content, role, type, [createdAt], thread_id AS threadId`;
+    const selectStatement = `SELECT seq_id, id, content, role, type, [createdAt], thread_id AS threadId, resourceId`;
     const orderByStatement = `ORDER BY [seq_id] DESC`;
-    const limit = this.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
+    const limit = storage.resolveMessageLimit({ last: selectBy?.last, defaultLimit: 40 });
     try {
       let rows = [];
       const include = selectBy?.include || [];
@@ -948,7 +552,7 @@ ${columns}
         }
       }
       const excludeIds = rows.map((m) => m.id).filter(Boolean);
-      let query = `${selectStatement} FROM ${this.getTableName(storage.TABLE_MESSAGES)} WHERE [thread_id] = @threadId`;
+      let query = `${selectStatement} FROM ${getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })} WHERE [thread_id] = @threadId`;
       const request = this.pool.request();
       request.input("threadId", threadId);
       if (excludeIds.length > 0) {
@@ -968,30 +572,7 @@ ${columns}
         return timeDiff;
       });
       rows = rows.map(({ seq_id, ...rest }) => rest);
-      const fetchedMessages = (rows || []).map((message) => {
-        if (typeof message.content === "string") {
-          try {
-            message.content = JSON.parse(message.content);
-          } catch {
-          }
-        }
-        if (format === "v1") {
-          if (Array.isArray(message.content)) ; else if (typeof message.content === "object" && message.content && Array.isArray(message.content.parts)) {
-            message.content = message.content.parts;
-          } else {
-            message.content = [{ type: "text", text: "" }];
-          }
-        } else {
-          if (typeof message.content !== "object" || !message.content || !("parts" in message.content)) {
-            message.content = { format: 2, parts: [{ type: "text", text: "" }] };
-          }
-        }
-        if (message.type === "v2") delete message.type;
-        return message;
-      });
-      return format === "v2" ? fetchedMessages.map(
-        (m) => ({ ...m, content: m.content || { format: 2, parts: [{ type: "text", text: "" }] } })
-      ) : fetchedMessages;
+      return this._parseAndFormatMessages(rows, format);
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
@@ -1009,6 +590,46 @@ ${columns}
       return [];
     }
   }
+  async getMessagesById({
+    messageIds,
+    format
+  }) {
+    if (messageIds.length === 0) return [];
+    const selectStatement = `SELECT seq_id, id, content, role, type, [createdAt], thread_id AS threadId, resourceId`;
+    const orderByStatement = `ORDER BY [seq_id] DESC`;
+    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;
+      });
+      rows = rows.map(({ seq_id, ...rest }) => rest);
+      if (format === `v1`) return this._parseAndFormatMessages(rows, format);
+      return this._parseAndFormatMessages(rows, `v2`);
+    } catch (error$1) {
+      const mastraError = new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_GET_MESSAGES_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            messageIds: JSON.stringify(messageIds)
+          }
+        },
+        error$1
+      );
+      this.logger?.error?.(mastraError.toString());
+      this.logger?.trackException(mastraError);
+      return [];
+    }
+  }
   async getMessagesPaginated(args) {
     const { threadId, selectBy } = args;
     const { page = 0, perPage: perPageInput } = selectBy?.pagination || {};
@@ -1021,14 +642,14 @@ ${columns}
       const { page: page2 = 0, perPage: perPageInput2, dateRange } = selectBy2?.pagination || {};
       const fromDate = dateRange?.start;
       const toDate = dateRange?.end;
-      const selectStatement = `SELECT seq_id, id, content, role, type, [createdAt], thread_id AS threadId`;
+      const selectStatement = `SELECT seq_id, id, content, role, type, [createdAt], thread_id AS threadId, resourceId`;
       const orderByStatement2 = `ORDER BY [seq_id] DESC`;
       let messages2 = [];
       if (selectBy2?.include?.length) {
         const includeMessages = await this._getIncludedMessages({ threadId: threadId2, selectBy: selectBy2, orderByStatement: orderByStatement2 });
         if (includeMessages) messages2.push(...includeMessages);
       }
-      const perPage = perPageInput2 !== void 0 ? perPageInput2 : this.resolveMessageLimit({ last: selectBy2?.last, defaultLimit: 40 });
+      const perPage = perPageInput2 !== void 0 ? perPageInput2 : storage.resolveMessageLimit({ last: selectBy2?.last, defaultLimit: 40 });
       const currentOffset = page2 * perPage;
       const conditions = ["[thread_id] = @threadId"];
       const request = this.pool.request();
@@ -1042,7 +663,7 @@ ${columns}
         request.input("toDate", toDate.toISOString());
       }
       const whereClause = `WHERE ${conditions.join(" AND ")}`;
-      const countQuery = `SELECT COUNT(*) as total FROM ${this.getTableName(storage.TABLE_MESSAGES)} ${whereClause}`;
+      const countQuery = `SELECT COUNT(*) as total FROM ${getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })} ${whereClause}`;
       const countResult = await request.query(countQuery);
       const total = parseInt(countResult.recordset[0]?.total, 10) || 0;
       if (total === 0 && messages2.length > 0) {
@@ -1062,7 +683,7 @@ ${columns}
         excludeIds.forEach((id, idx) => request.input(`id${idx}`, id));
       }
       const finalWhereClause = `WHERE ${conditions.join(" AND ")}`;
-      const dataQuery = `${selectStatement} FROM ${this.getTableName(storage.TABLE_MESSAGES)} ${finalWhereClause} ${orderByStatement2} OFFSET @offset ROWS FETCH NEXT @limit ROWS ONLY`;
+      const dataQuery = `${selectStatement} FROM ${getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })} ${finalWhereClause} ${orderByStatement2} OFFSET @offset ROWS FETCH NEXT @limit ROWS ONLY`;
       request.input("offset", currentOffset);
       request.input("limit", perPage);
       const rowsResult = await request.query(dataQuery);
@@ -1095,31 +716,6 @@ ${columns}
       return { messages: [], total: 0, page, perPage: perPageInput || 40, hasMore: false };
     }
   }
-  _parseAndFormatMessages(messages, format) {
-    const parsedMessages = messages.map((message) => {
-      let parsed = message;
-      if (typeof parsed.content === "string") {
-        try {
-          parsed = { ...parsed, content: JSON.parse(parsed.content) };
-        } catch {
-        }
-      }
-      if (format === "v1") {
-        if (Array.isArray(parsed.content)) ; else if (parsed.content?.parts) {
-          parsed.content = parsed.content.parts;
-        } else {
-          parsed.content = [{ type: "text", text: "" }];
-        }
-      } else {
-        if (!parsed.content?.parts) {
-          parsed = { ...parsed, content: { format: 2, parts: [{ type: "text", text: "" }] } };
-        }
-      }
-      return parsed;
-    });
-    const list = new agent.MessageList().add(parsedMessages, "memory");
-    return format === "v2" ? list.get.all.v2() : list.get.all.v1();
-  }
   async saveMessages({
     messages,
     format
@@ -1144,8 +740,8 @@ ${columns}
         details: { threadId }
       });
     }
-    const tableMessages = this.getTableName(storage.TABLE_MESSAGES);
-    const tableThreads = this.getTableName(storage.TABLE_THREADS);
+    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();
@@ -1168,7 +764,7 @@ ${columns}
             "content",
             typeof message.content === "string" ? message.content : JSON.stringify(message.content)
           );
-          request.input("createdAt", message.createdAt.toISOString() || (/* @__PURE__ */ new Date()).toISOString());
+          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);
@@ -1187,7 +783,7 @@ ${columns}
           await request.query(mergeSql);
         }
         const threadReq = transaction.request();
-        threadReq.input("updatedAt", (/* @__PURE__ */ new Date()).toISOString());
+        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();
@@ -1220,216 +816,6 @@ ${columns}
       );
     }
   }
-  async persistWorkflowSnapshot({
-    workflowName,
-    runId,
-    snapshot
-  }) {
-    const table = this.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    try {
-      const request = this.pool.request();
-      request.input("workflow_name", workflowName);
-      request.input("run_id", runId);
-      request.input("snapshot", JSON.stringify(snapshot));
-      request.input("createdAt", now);
-      request.input("updatedAt", 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
-        WHEN MATCHED THEN UPDATE SET
-          snapshot = @snapshot,
-          [updatedAt] = @updatedAt
-        WHEN NOT MATCHED THEN INSERT (workflow_name, run_id, snapshot, [createdAt], [updatedAt])
-          VALUES (@workflow_name, @run_id, @snapshot, @createdAt, @updatedAt);`;
-      await request.query(mergeSql);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_MSSQL_STORE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            workflowName,
-            runId
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async loadWorkflowSnapshot({
-    workflowName,
-    runId
-  }) {
-    try {
-      const result = await this.load({
-        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
-        keys: {
-          workflow_name: workflowName,
-          run_id: runId
-        }
-      });
-      if (!result) {
-        return null;
-      }
-      return result.snapshot;
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_MSSQL_STORE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            workflowName,
-            runId
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async hasColumn(table, column) {
-    const schema = this.schema || "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;
-  }
-  parseWorkflowRun(row) {
-    let parsedSnapshot = row.snapshot;
-    if (typeof parsedSnapshot === "string") {
-      try {
-        parsedSnapshot = JSON.parse(row.snapshot);
-      } catch (e) {
-        console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
-      }
-    }
-    return {
-      workflowName: row.workflow_name,
-      runId: row.run_id,
-      snapshot: parsedSnapshot,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt,
-      resourceId: row.resourceId
-    };
-  }
-  async getWorkflowRuns({
-    workflowName,
-    fromDate,
-    toDate,
-    limit,
-    offset,
-    resourceId
-  } = {}) {
-    try {
-      const conditions = [];
-      const paramMap = {};
-      if (workflowName) {
-        conditions.push(`[workflow_name] = @workflowName`);
-        paramMap["workflowName"] = workflowName;
-      }
-      if (resourceId) {
-        const hasResourceId = await this.hasColumn(storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId");
-        if (hasResourceId) {
-          conditions.push(`[resourceId] = @resourceId`);
-          paramMap["resourceId"] = resourceId;
-        } else {
-          console.warn(`[${storage.TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
-        }
-      }
-      if (fromDate instanceof Date && !isNaN(fromDate.getTime())) {
-        conditions.push(`[createdAt] >= @fromDate`);
-        paramMap[`fromDate`] = fromDate.toISOString();
-      }
-      if (toDate instanceof Date && !isNaN(toDate.getTime())) {
-        conditions.push(`[createdAt] <= @toDate`);
-        paramMap[`toDate`] = toDate.toISOString();
-      }
-      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-      let total = 0;
-      const tableName = this.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
-      const request = this.pool.request();
-      Object.entries(paramMap).forEach(([key, value]) => {
-        if (value instanceof Date) {
-          request.input(key, sql__default.default.DateTime, value);
-        } else {
-          request.input(key, value);
-        }
-      });
-      if (limit !== void 0 && offset !== void 0) {
-        const countQuery = `SELECT COUNT(*) as count FROM ${tableName} ${whereClause}`;
-        const countResult = await request.query(countQuery);
-        total = Number(countResult.recordset[0]?.count || 0);
-      }
-      let query = `SELECT * FROM ${tableName} ${whereClause} ORDER BY [seq_id] DESC`;
-      if (limit !== void 0 && offset !== void 0) {
-        query += ` OFFSET @offset ROWS FETCH NEXT @limit ROWS ONLY`;
-        request.input("limit", limit);
-        request.input("offset", offset);
-      }
-      const result = await request.query(query);
-      const runs = (result.recordset || []).map((row) => this.parseWorkflowRun(row));
-      return { runs, total: total || runs.length };
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_MSSQL_STORE_GET_WORKFLOW_RUNS_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            workflowName: workflowName || "all"
-          }
-        },
-        error$1
-      );
-    }
-  }
-  async getWorkflowRunById({
-    runId,
-    workflowName
-  }) {
-    try {
-      const conditions = [];
-      const paramMap = {};
-      if (runId) {
-        conditions.push(`[run_id] = @runId`);
-        paramMap["runId"] = runId;
-      }
-      if (workflowName) {
-        conditions.push(`[workflow_name] = @workflowName`);
-        paramMap["workflowName"] = workflowName;
-      }
-      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-      const tableName = this.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
-      const query = `SELECT * FROM ${tableName} ${whereClause}`;
-      const request = this.pool.request();
-      Object.entries(paramMap).forEach(([key, value]) => request.input(key, value));
-      const result = await request.query(query);
-      if (!result.recordset || result.recordset.length === 0) {
-        return null;
-      }
-      return this.parseWorkflowRun(result.recordset[0]);
-    } catch (error$1) {
-      throw new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_MSSQL_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            runId,
-            workflowName: workflowName || ""
-          }
-        },
-        error$1
-      );
-    }
-  }
   async updateMessages({
     messages
   }) {
@@ -1438,7 +824,7 @@ ${columns}
     }
     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 ${this.getTableName(storage.TABLE_MESSAGES)}`;
+    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 {
@@ -1495,7 +881,7 @@ ${columns}
           }
         }
         if (setClauses.length > 0) {
-          const updateSql = `UPDATE ${this.getTableName(storage.TABLE_MESSAGES)} SET ${setClauses.join(", ")} WHERE id = @id`;
+          const updateSql = `UPDATE ${getTableName({ indexName: storage.TABLE_MESSAGES, schemaName: getSchemaName(this.schema) })} SET ${setClauses.join(", ")} WHERE id = @id`;
           await req.query(updateSql);
         }
       }
@@ -1504,7 +890,7 @@ ${columns}
         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 ${this.getTableName(storage.TABLE_THREADS)} SET updatedAt = @updatedAt WHERE id IN (${threadIdParams})`;
+        const threadSql = `UPDATE ${getTableName({ indexName: storage.TABLE_THREADS, schemaName: getSchemaName(this.schema) })} SET updatedAt = @updatedAt WHERE id IN (${threadIdParams})`;
         await threadReq.query(threadSql);
       }
       await transaction.commit();
@@ -1532,101 +918,78 @@ ${columns}
       return message;
     });
   }
-  async close() {
-    if (this.pool) {
+  async deleteMessages(messageIds) {
+    if (!messageIds || messageIds.length === 0) {
+      return;
+    }
+    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 {
-        if (this.pool.connected) {
-          await this.pool.close();
-        } else if (this.pool.connecting) {
-          await this.pool.connect();
-          await this.pool.close();
+        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`);
+          }
         }
-      } catch (err) {
-        if (err.message && err.message.includes("Cannot close a pool while it is connecting")) ; else {
-          throw err;
+        await transaction.commit();
+      } catch (error) {
+        try {
+          await transaction.rollback();
+        } catch {
         }
+        throw error;
       }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_DELETE_MESSAGES_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { messageIds: messageIds.join(", ") }
+        },
+        error$1
+      );
     }
   }
-  async getEvals(options = {}) {
-    const { agentName, type, page = 0, perPage = 100, dateRange } = options;
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
-    const where = [];
-    const params = {};
-    if (agentName) {
-      where.push("agent_name = @agentName");
-      params["agentName"] = agentName;
-    }
-    if (type === "test") {
-      where.push("test_info IS NOT NULL AND JSON_VALUE(test_info, '$.testPath') IS NOT NULL");
-    } else if (type === "live") {
-      where.push("(test_info IS NULL OR JSON_VALUE(test_info, '$.testPath') IS NULL)");
-    }
-    if (fromDate instanceof Date && !isNaN(fromDate.getTime())) {
-      where.push(`[created_at] >= @fromDate`);
-      params[`fromDate`] = fromDate.toISOString();
-    }
-    if (toDate instanceof Date && !isNaN(toDate.getTime())) {
-      where.push(`[created_at] <= @toDate`);
-      params[`toDate`] = toDate.toISOString();
-    }
-    const whereClause = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
-    const tableName = this.getTableName(storage.TABLE_EVALS);
-    const offset = page * perPage;
-    const countQuery = `SELECT COUNT(*) as total FROM ${tableName} ${whereClause}`;
-    const dataQuery = `SELECT * FROM ${tableName} ${whereClause} ORDER BY seq_id DESC OFFSET @offset ROWS FETCH NEXT @perPage ROWS ONLY`;
+  async getResourceById({ resourceId }) {
+    const tableName = getTableName({ indexName: storage.TABLE_RESOURCES, schemaName: getSchemaName(this.schema) });
     try {
-      const countReq = this.pool.request();
-      Object.entries(params).forEach(([key, value]) => {
-        if (value instanceof Date) {
-          countReq.input(key, sql__default.default.DateTime, value);
-        } else {
-          countReq.input(key, value);
-        }
-      });
-      const countResult = await countReq.query(countQuery);
-      const total = countResult.recordset[0]?.total || 0;
-      if (total === 0) {
-        return {
-          evals: [],
-          total: 0,
-          page,
-          perPage,
-          hasMore: false
-        };
-      }
       const req = this.pool.request();
-      Object.entries(params).forEach(([key, value]) => {
-        if (value instanceof Date) {
-          req.input(key, sql__default.default.DateTime, value);
-        } else {
-          req.input(key, value);
-        }
-      });
-      req.input("offset", offset);
-      req.input("perPage", perPage);
-      const result = await req.query(dataQuery);
-      const rows = result.recordset;
+      req.input("resourceId", resourceId);
+      const result = (await req.query(`SELECT * FROM ${tableName} WHERE id = @resourceId`)).recordset[0];
+      if (!result) {
+        return null;
+      }
       return {
-        evals: rows?.map((row) => this.transformEvalRow(row)) ?? [],
-        total,
-        page,
-        perPage,
-        hasMore: offset + (rows?.length ?? 0) < total
+        ...result,
+        workingMemory: typeof result.workingMemory === "object" ? JSON.stringify(result.workingMemory) : result.workingMemory,
+        metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
       };
     } catch (error$1) {
       const mastraError = new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_STORE_GET_EVALS_FAILED",
+          id: "MASTRA_STORAGE_MSSQL_GET_RESOURCE_BY_ID_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: {
-            agentName: agentName || "all",
-            type: type || "all",
-            page,
-            perPage
-          }
+          details: { resourceId }
         },
         error$1
       );
@@ -1636,32 +999,14 @@ ${columns}
     }
   }
   async saveResource({ resource }) {
-    const tableName = this.getTableName(storage.TABLE_RESOURCES);
-    try {
-      const req = this.pool.request();
-      req.input("id", resource.id);
-      req.input("workingMemory", resource.workingMemory);
-      req.input("metadata", JSON.stringify(resource.metadata));
-      req.input("createdAt", resource.createdAt.toISOString());
-      req.input("updatedAt", resource.updatedAt.toISOString());
-      await req.query(
-        `INSERT INTO ${tableName} (id, workingMemory, metadata, createdAt, updatedAt) VALUES (@id, @workingMemory, @metadata, @createdAt, @updatedAt)`
-      );
-      return resource;
-    } catch (error$1) {
-      const mastraError = new error.MastraError(
-        {
-          id: "MASTRA_STORAGE_MSSQL_SAVE_RESOURCE_FAILED",
-          domain: error.ErrorDomain.STORAGE,
-          category: error.ErrorCategory.THIRD_PARTY,
-          details: { resourceId: resource.id }
-        },
-        error$1
-      );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      throw mastraError;
-    }
+    await this.operations.insert({
+      tableName: storage.TABLE_RESOURCES,
+      record: {
+        ...resource,
+        metadata: JSON.stringify(resource.metadata)
+      }
+    });
+    return resource;
   }
   async updateResource({
     resourceId,
@@ -1689,7 +1034,7 @@ ${columns}
         },
         updatedAt: /* @__PURE__ */ new Date()
       };
-      const tableName = this.getTableName(storage.TABLE_RESOURCES);
+      const tableName = getTableName({ indexName: storage.TABLE_RESOURCES, schemaName: getSchemaName(this.schema) });
       const updates = [];
       const req = this.pool.request();
       if (workingMemory !== void 0) {
@@ -1720,101 +1065,1304 @@ ${columns}
       throw mastraError;
     }
   }
-  async getResourceById({ resourceId }) {
-    const tableName = this.getTableName(storage.TABLE_RESOURCES);
+};
+var StoreOperationsMSSQL = class extends storage.StoreOperations {
+  pool;
+  schemaName;
+  setupSchemaPromise = null;
+  schemaSetupComplete = void 0;
+  getSqlType(type, isPrimaryKey = false) {
+    switch (type) {
+      case "text":
+        return isPrimaryKey ? "NVARCHAR(255)" : "NVARCHAR(MAX)";
+      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";
+      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 }) {
     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;
-      }
-      return {
-        ...result,
-        workingMemory: typeof result.workingMemory === "object" ? JSON.stringify(result.workingMemory) : result.workingMemory,
-        metadata: typeof result.metadata === "string" ? JSON.parse(result.metadata) : result.metadata
-      };
+      const columns = Object.keys(record).map((col) => utils.parseSqlIdentifier(col, "column name"));
+      const values = Object.values(record);
+      const paramNames = values.map((_, i) => `@param${i}`);
+      const insertSql = `INSERT INTO ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} (${columns.map((c) => `[${c}]`).join(", ")}) VALUES (${paramNames.join(", ")})`;
+      const request = this.pool.request();
+      values.forEach((value, i) => {
+        if (value instanceof Date) {
+          request.input(`param${i}`, sql2__default.default.DateTime2, value);
+        } else if (typeof value === "object" && value !== null) {
+          request.input(`param${i}`, JSON.stringify(value));
+        } else {
+          request.input(`param${i}`, value);
+        }
+      });
+      await request.query(insertSql);
     } catch (error$1) {
-      const mastraError = new error.MastraError(
+      throw new error.MastraError(
         {
-          id: "MASTRA_STORAGE_MSSQL_GET_RESOURCE_BY_ID_FAILED",
+          id: "MASTRA_STORAGE_MSSQL_STORE_INSERT_FAILED",
           domain: error.ErrorDomain.STORAGE,
           category: error.ErrorCategory.THIRD_PARTY,
-          details: { resourceId }
+          details: {
+            tableName
+          }
         },
         error$1
       );
-      this.logger?.error?.(mastraError.toString());
-      this.logger?.trackException(mastraError);
-      throw mastraError;
     }
   }
-  async getScoreById({ id }) {
-    throw new error.MastraError({
-      id: "STORAGE_MONGODB_STORE_GET_SCORE_BY_ID_FAILED",
-      domain: error.ErrorDomain.STORAGE,
-      category: error.ErrorCategory.THIRD_PARTY,
-      details: { id },
-      text: "getScoreById is not implemented yet in MongoDBStore"
-    });
+  async clearTable({ tableName }) {
+    const fullTableName = getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) });
+    try {
+      try {
+        await this.pool.request().query(`TRUNCATE TABLE ${fullTableName}`);
+      } catch (truncateError) {
+        if (truncateError.message && truncateError.message.includes("foreign key")) {
+          await this.pool.request().query(`DELETE FROM ${fullTableName}`);
+        } else {
+          throw truncateError;
+        }
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_CLEAR_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
   }
-  async saveScore(_score) {
-    throw new error.MastraError({
-      id: "STORAGE_MONGODB_STORE_SAVE_SCORE_FAILED",
-      domain: error.ErrorDomain.STORAGE,
-      category: error.ErrorCategory.THIRD_PARTY,
-      details: {},
-      text: "saveScore is not implemented yet in MongoDBStore"
-    });
+  getDefaultValue(type) {
+    switch (type) {
+      case "timestamp":
+        return "DEFAULT SYSDATETIMEOFFSET()";
+      case "jsonb":
+        return "DEFAULT N'{}'";
+      default:
+        return super.getDefaultValue(type);
+    }
   }
-  async getScoresByScorerId({
-    scorerId,
-    pagination: _pagination,
-    entityId,
-    entityType
+  async createTable({
+    tableName,
+    schema
   }) {
-    throw new error.MastraError({
-      id: "STORAGE_MONGODB_STORE_GET_SCORES_BY_SCORER_ID_FAILED",
-      domain: error.ErrorDomain.STORAGE,
-      category: error.ErrorCategory.THIRD_PARTY,
-      details: { scorerId, entityId: entityId || "", entityType: entityType || "" },
-      text: "getScoresByScorerId is not implemented yet in MongoDBStore"
-    });
+    try {
+      const uniqueConstraintColumns = tableName === storage.TABLE_WORKFLOW_SNAPSHOT ? ["workflow_name", "run_id"] : [];
+      const columns = Object.entries(schema).map(([name, def]) => {
+        const parsedName = utils.parseSqlIdentifier(name, "column name");
+        const constraints = [];
+        if (def.primaryKey) constraints.push("PRIMARY KEY");
+        if (!def.nullable) constraints.push("NOT NULL");
+        const isIndexed = !!def.primaryKey || uniqueConstraintColumns.includes(name);
+        return `[${parsedName}] ${this.getSqlType(def.type, isIndexed)} ${constraints.join(" ")}`.trim();
+      }).join(",\n");
+      if (this.schemaName) {
+        await this.setupSchema();
+      }
+      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 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()
+      );
+      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);
+        }
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_CREATE_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
   }
-  async getScoresByRunId({
-    runId,
-    pagination: _pagination
+  /**
+   * 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
   }) {
-    throw new error.MastraError({
-      id: "STORAGE_MONGODB_STORE_GET_SCORES_BY_RUN_ID_FAILED",
-      domain: error.ErrorDomain.STORAGE,
-      category: error.ErrorCategory.THIRD_PARTY,
-      details: { runId },
-      text: "getScoresByRunId is not implemented yet in MongoDBStore"
-    });
+    const fullTableName = getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) });
+    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 sqlType = this.getSqlType(columnDef.type);
+            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}`);
+          }
+        }
+      }
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_ALTER_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async load({ tableName, keys }) {
+    try {
+      const keyEntries = Object.entries(keys).map(([key, value]) => [utils.parseSqlIdentifier(key, "column name"), value]);
+      const conditions = keyEntries.map(([key], i) => `[${key}] = @param${i}`).join(" AND ");
+      const values = keyEntries.map(([_, value]) => value);
+      const sql7 = `SELECT * FROM ${getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) })} WHERE ${conditions}`;
+      const request = this.pool.request();
+      values.forEach((value, i) => {
+        request.input(`param${i}`, value);
+      });
+      const resultSet = await request.query(sql7);
+      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_LOAD_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async batchInsert({ tableName, records }) {
+    const transaction = this.pool.transaction();
+    try {
+      await transaction.begin();
+      for (const record of records) {
+        await this.insert({ tableName, record });
+      }
+      await transaction.commit();
+    } catch (error$1) {
+      await transaction.rollback();
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_BATCH_INSERT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName,
+            numberOfRecords: records.length
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async dropTable({ tableName }) {
+    try {
+      const tableNameWithSchema = getTableName({ indexName: tableName, schemaName: getSchemaName(this.schemaName) });
+      await this.pool.request().query(`DROP TABLE IF EXISTS ${tableNameWithSchema}`);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_DROP_TABLE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            tableName
+          }
+        },
+        error$1
+      );
+    }
+  }
+};
+function parseJSON(jsonString) {
+  try {
+    return JSON.parse(jsonString);
+  } catch {
+    return jsonString;
+  }
+}
+function transformScoreRow(row) {
+  return {
+    ...row,
+    input: parseJSON(row.input),
+    scorer: parseJSON(row.scorer),
+    preprocessStepResult: parseJSON(row.preprocessStepResult),
+    analyzeStepResult: parseJSON(row.analyzeStepResult),
+    metadata: parseJSON(row.metadata),
+    output: parseJSON(row.output),
+    additionalContext: parseJSON(row.additionalContext),
+    runtimeContext: parseJSON(row.runtimeContext),
+    entity: parseJSON(row.entity),
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt
+  };
+}
+var ScoresMSSQL = class extends storage.ScoresStorage {
+  pool;
+  operations;
+  schema;
+  constructor({
+    pool,
+    operations,
+    schema
+  }) {
+    super();
+    this.pool = pool;
+    this.operations = operations;
+    this.schema = schema;
+  }
+  async getScoreById({ id }) {
+    try {
+      const request = this.pool.request();
+      request.input("p1", id);
+      const result = await request.query(
+        `SELECT * FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName(this.schema) })} WHERE id = @p1`
+      );
+      if (result.recordset.length === 0) {
+        return null;
+      }
+      return transformScoreRow(result.recordset[0]);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_GET_SCORE_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { id }
+        },
+        error$1
+      );
+    }
+  }
+  async saveScore(score) {
+    try {
+      const scoreId = crypto.randomUUID();
+      const {
+        scorer,
+        preprocessStepResult,
+        analyzeStepResult,
+        metadata,
+        input,
+        output,
+        additionalContext,
+        runtimeContext,
+        entity,
+        ...rest
+      } = score;
+      await this.operations.insert({
+        tableName: storage.TABLE_SCORERS,
+        record: {
+          id: scoreId,
+          ...rest,
+          input: JSON.stringify(input) || "",
+          output: JSON.stringify(output) || "",
+          preprocessStepResult: preprocessStepResult ? JSON.stringify(preprocessStepResult) : null,
+          analyzeStepResult: analyzeStepResult ? JSON.stringify(analyzeStepResult) : null,
+          metadata: metadata ? JSON.stringify(metadata) : null,
+          additionalContext: additionalContext ? JSON.stringify(additionalContext) : null,
+          runtimeContext: runtimeContext ? JSON.stringify(runtimeContext) : null,
+          entity: entity ? JSON.stringify(entity) : null,
+          scorer: scorer ? JSON.stringify(scorer) : null,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+      const scoreFromDb = await this.getScoreById({ id: scoreId });
+      return { score: scoreFromDb };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_SAVE_SCORE_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async getScoresByScorerId({
+    scorerId,
+    pagination
+  }) {
+    try {
+      const request = this.pool.request();
+      request.input("p1", scorerId);
+      const totalResult = await request.query(
+        `SELECT COUNT(*) as count FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName(this.schema) })} WHERE [scorerId] = @p1`
+      );
+      const total = totalResult.recordset[0]?.count || 0;
+      if (total === 0) {
+        return {
+          pagination: {
+            total: 0,
+            page: pagination.page,
+            perPage: pagination.perPage,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const dataRequest = this.pool.request();
+      dataRequest.input("p1", scorerId);
+      dataRequest.input("p2", pagination.perPage);
+      dataRequest.input("p3", pagination.page * pagination.perPage);
+      const result = await dataRequest.query(
+        `SELECT * FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName(this.schema) })} WHERE [scorerId] = @p1 ORDER BY [createdAt] DESC OFFSET @p3 ROWS FETCH NEXT @p2 ROWS ONLY`
+      );
+      return {
+        pagination: {
+          total: Number(total),
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: Number(total) > (pagination.page + 1) * pagination.perPage
+        },
+        scores: result.recordset.map((row) => transformScoreRow(row))
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_GET_SCORES_BY_SCORER_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { scorerId }
+        },
+        error$1
+      );
+    }
+  }
+  async getScoresByRunId({
+    runId,
+    pagination
+  }) {
+    try {
+      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`
+      );
+      const total = totalResult.recordset[0]?.count || 0;
+      if (total === 0) {
+        return {
+          pagination: {
+            total: 0,
+            page: pagination.page,
+            perPage: pagination.perPage,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const dataRequest = this.pool.request();
+      dataRequest.input("p1", runId);
+      dataRequest.input("p2", pagination.perPage);
+      dataRequest.input("p3", pagination.page * pagination.perPage);
+      const result = await dataRequest.query(
+        `SELECT * FROM ${getTableName({ indexName: storage.TABLE_SCORERS, schemaName: getSchemaName(this.schema) })} WHERE [runId] = @p1 ORDER BY [createdAt] DESC OFFSET @p3 ROWS FETCH NEXT @p2 ROWS ONLY`
+      );
+      return {
+        pagination: {
+          total: Number(total),
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: Number(total) > (pagination.page + 1) * pagination.perPage
+        },
+        scores: result.recordset.map((row) => transformScoreRow(row))
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_GET_SCORES_BY_RUN_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { runId }
+        },
+        error$1
+      );
+    }
   }
   async getScoresByEntityId({
     entityId,
     entityType,
-    pagination: _pagination
+    pagination
   }) {
-    throw new error.MastraError({
-      id: "STORAGE_MONGODB_STORE_GET_SCORES_BY_ENTITY_ID_FAILED",
-      domain: error.ErrorDomain.STORAGE,
-      category: error.ErrorCategory.THIRD_PARTY,
-      details: { entityId, entityType },
-      text: "getScoresByEntityId is not implemented yet in MongoDBStore"
-    });
+    try {
+      const request = this.pool.request();
+      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`
+      );
+      const total = totalResult.recordset[0]?.count || 0;
+      if (total === 0) {
+        return {
+          pagination: {
+            total: 0,
+            page: pagination.page,
+            perPage: pagination.perPage,
+            hasMore: false
+          },
+          scores: []
+        };
+      }
+      const dataRequest = this.pool.request();
+      dataRequest.input("p1", entityId);
+      dataRequest.input("p2", entityType);
+      dataRequest.input("p3", pagination.perPage);
+      dataRequest.input("p4", pagination.page * pagination.perPage);
+      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`
+      );
+      return {
+        pagination: {
+          total: Number(total),
+          page: pagination.page,
+          perPage: pagination.perPage,
+          hasMore: Number(total) > (pagination.page + 1) * pagination.perPage
+        },
+        scores: result.recordset.map((row) => transformScoreRow(row))
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_GET_SCORES_BY_ENTITY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: { entityId, entityType }
+        },
+        error$1
+      );
+    }
   }
-  async dropTable({ tableName }) {
-    throw new error.MastraError({
-      id: "STORAGE_MONGODB_STORE_DROP_TABLE_FAILED",
-      domain: error.ErrorDomain.STORAGE,
-      category: error.ErrorCategory.THIRD_PARTY,
-      details: { tableName },
-      text: "dropTable is not implemented yet in MongoDBStore"
+};
+var TracesMSSQL = class extends storage.TracesStorage {
+  pool;
+  operations;
+  schema;
+  constructor({
+    pool,
+    operations,
+    schema
+  }) {
+    super();
+    this.pool = pool;
+    this.operations = operations;
+    this.schema = schema;
+  }
+  /** @deprecated use getTracesPaginated instead*/
+  async getTraces(args) {
+    if (args.fromDate || args.toDate) {
+      args.dateRange = {
+        start: args.fromDate,
+        end: args.toDate
+      };
+    }
+    const result = await this.getTracesPaginated(args);
+    return result.traces;
+  }
+  async getTracesPaginated(args) {
+    const { name, scope, page = 0, perPage: perPageInput, attributes, filters, dateRange } = args;
+    const fromDate = dateRange?.start;
+    const toDate = dateRange?.end;
+    const perPage = perPageInput !== void 0 ? perPageInput : 100;
+    const currentOffset = page * perPage;
+    const paramMap = {};
+    const conditions = [];
+    let paramIndex = 1;
+    if (name) {
+      const paramName = `p${paramIndex++}`;
+      conditions.push(`[name] LIKE @${paramName}`);
+      paramMap[paramName] = `${name}%`;
+    }
+    if (scope) {
+      const paramName = `p${paramIndex++}`;
+      conditions.push(`[scope] = @${paramName}`);
+      paramMap[paramName] = scope;
+    }
+    if (attributes) {
+      Object.entries(attributes).forEach(([key, value]) => {
+        const parsedKey = utils.parseFieldKey(key);
+        const paramName = `p${paramIndex++}`;
+        conditions.push(`JSON_VALUE([attributes], '$.${parsedKey}') = @${paramName}`);
+        paramMap[paramName] = value;
+      });
+    }
+    if (filters) {
+      Object.entries(filters).forEach(([key, value]) => {
+        const parsedKey = utils.parseFieldKey(key);
+        const paramName = `p${paramIndex++}`;
+        conditions.push(`[${parsedKey}] = @${paramName}`);
+        paramMap[paramName] = value;
+      });
+    }
+    if (fromDate instanceof Date && !isNaN(fromDate.getTime())) {
+      const paramName = `p${paramIndex++}`;
+      conditions.push(`[createdAt] >= @${paramName}`);
+      paramMap[paramName] = fromDate.toISOString();
+    }
+    if (toDate instanceof Date && !isNaN(toDate.getTime())) {
+      const paramName = `p${paramIndex++}`;
+      conditions.push(`[createdAt] <= @${paramName}`);
+      paramMap[paramName] = toDate.toISOString();
+    }
+    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const countQuery = `SELECT COUNT(*) as total FROM ${getTableName({ indexName: storage.TABLE_TRACES, schemaName: getSchemaName(this.schema) })} ${whereClause}`;
+    let total = 0;
+    try {
+      const countRequest = this.pool.request();
+      Object.entries(paramMap).forEach(([key, value]) => {
+        if (value instanceof Date) {
+          countRequest.input(key, sql2__default.default.DateTime, value);
+        } else {
+          countRequest.input(key, value);
+        }
+      });
+      const countResult = await countRequest.query(countQuery);
+      total = parseInt(countResult.recordset[0].total, 10);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_GET_TRACES_PAGINATED_FAILED_TO_RETRIEVE_TOTAL_COUNT",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            name: args.name ?? "",
+            scope: args.scope ?? ""
+          }
+        },
+        error$1
+      );
+    }
+    if (total === 0) {
+      return {
+        traces: [],
+        total: 0,
+        page,
+        perPage,
+        hasMore: false
+      };
+    }
+    const dataQuery = `SELECT * FROM ${getTableName({ indexName: storage.TABLE_TRACES, schemaName: getSchemaName(this.schema) })} ${whereClause} ORDER BY [seq_id] DESC OFFSET @offset ROWS FETCH NEXT @limit ROWS ONLY`;
+    const dataRequest = this.pool.request();
+    Object.entries(paramMap).forEach(([key, value]) => {
+      if (value instanceof Date) {
+        dataRequest.input(key, sql2__default.default.DateTime, value);
+      } else {
+        dataRequest.input(key, value);
+      }
+    });
+    dataRequest.input("offset", currentOffset);
+    dataRequest.input("limit", perPage);
+    try {
+      const rowsResult = await dataRequest.query(dataQuery);
+      const rows = rowsResult.recordset;
+      const traces = rows.map((row) => ({
+        id: row.id,
+        parentSpanId: row.parentSpanId,
+        traceId: row.traceId,
+        name: row.name,
+        scope: row.scope,
+        kind: row.kind,
+        status: JSON.parse(row.status),
+        events: JSON.parse(row.events),
+        links: JSON.parse(row.links),
+        attributes: JSON.parse(row.attributes),
+        startTime: row.startTime,
+        endTime: row.endTime,
+        other: row.other,
+        createdAt: row.createdAt
+      }));
+      return {
+        traces,
+        total,
+        page,
+        perPage,
+        hasMore: currentOffset + traces.length < total
+      };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_GET_TRACES_PAGINATED_FAILED_TO_RETRIEVE_TRACES",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            name: args.name ?? "",
+            scope: args.scope ?? ""
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async batchTraceInsert({ records }) {
+    this.logger.debug("Batch inserting traces", { count: records.length });
+    await this.operations.batchInsert({
+      tableName: storage.TABLE_TRACES,
+      records
+    });
+  }
+};
+function parseWorkflowRun(row) {
+  let parsedSnapshot = row.snapshot;
+  if (typeof parsedSnapshot === "string") {
+    try {
+      parsedSnapshot = JSON.parse(row.snapshot);
+    } catch (e) {
+      console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+    }
+  }
+  return {
+    workflowName: row.workflow_name,
+    runId: row.run_id,
+    snapshot: parsedSnapshot,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+    resourceId: row.resourceId
+  };
+}
+var WorkflowsMSSQL = class extends storage.WorkflowsStorage {
+  pool;
+  operations;
+  schema;
+  constructor({
+    pool,
+    operations,
+    schema
+  }) {
+    super();
+    this.pool = pool;
+    this.operations = operations;
+    this.schema = schema;
+  }
+  updateWorkflowResults({
+    // workflowName,
+    // runId,
+    // stepId,
+    // result,
+    // runtimeContext,
+  }) {
+    throw new Error("Method not implemented.");
+  }
+  updateWorkflowState({
+    // workflowName,
+    // runId,
+    // opts,
+  }) {
+    throw new Error("Method not implemented.");
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    const table = getTableName({ indexName: storage.TABLE_WORKFLOW_SNAPSHOT, schemaName: getSchemaName(this.schema) });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      const request = this.pool.request();
+      request.input("workflow_name", workflowName);
+      request.input("run_id", runId);
+      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));
+      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
+        WHEN MATCHED THEN UPDATE SET
+          snapshot = @snapshot,
+          [updatedAt] = @updatedAt
+        WHEN NOT MATCHED THEN INSERT (workflow_name, run_id, snapshot, [createdAt], [updatedAt])
+          VALUES (@workflow_name, @run_id, @snapshot, @createdAt, @updatedAt);`;
+      await request.query(mergeSql);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_PERSIST_WORKFLOW_SNAPSHOT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            workflowName,
+            runId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    try {
+      const result = await this.operations.load({
+        tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+        keys: {
+          workflow_name: workflowName,
+          run_id: runId
+        }
+      });
+      if (!result) {
+        return null;
+      }
+      return result.snapshot;
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_LOAD_WORKFLOW_SNAPSHOT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            workflowName,
+            runId
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    try {
+      const conditions = [];
+      const paramMap = {};
+      if (runId) {
+        conditions.push(`[run_id] = @runId`);
+        paramMap["runId"] = runId;
+      }
+      if (workflowName) {
+        conditions.push(`[workflow_name] = @workflowName`);
+        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 query = `SELECT * FROM ${tableName} ${whereClause}`;
+      const request = this.pool.request();
+      Object.entries(paramMap).forEach(([key, value]) => request.input(key, value));
+      const result = await request.query(query);
+      if (!result.recordset || result.recordset.length === 0) {
+        return null;
+      }
+      return parseWorkflowRun(result.recordset[0]);
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_GET_WORKFLOW_RUN_BY_ID_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            runId,
+            workflowName: workflowName || ""
+          }
+        },
+        error$1
+      );
+    }
+  }
+  async getWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    limit,
+    offset,
+    resourceId
+  } = {}) {
+    try {
+      const conditions = [];
+      const paramMap = {};
+      if (workflowName) {
+        conditions.push(`[workflow_name] = @workflowName`);
+        paramMap["workflowName"] = workflowName;
+      }
+      if (resourceId) {
+        const hasResourceId = await this.operations.hasColumn(storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId");
+        if (hasResourceId) {
+          conditions.push(`[resourceId] = @resourceId`);
+          paramMap["resourceId"] = resourceId;
+        } else {
+          console.warn(`[${storage.TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
+        }
+      }
+      if (fromDate instanceof Date && !isNaN(fromDate.getTime())) {
+        conditions.push(`[createdAt] >= @fromDate`);
+        paramMap[`fromDate`] = fromDate.toISOString();
+      }
+      if (toDate instanceof Date && !isNaN(toDate.getTime())) {
+        conditions.push(`[createdAt] <= @toDate`);
+        paramMap[`toDate`] = toDate.toISOString();
+      }
+      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 request = this.pool.request();
+      Object.entries(paramMap).forEach(([key, value]) => {
+        if (value instanceof Date) {
+          request.input(key, sql2__default.default.DateTime, value);
+        } else {
+          request.input(key, value);
+        }
+      });
+      if (limit !== void 0 && offset !== void 0) {
+        const countQuery = `SELECT COUNT(*) as count FROM ${tableName} ${whereClause}`;
+        const countResult = await request.query(countQuery);
+        total = Number(countResult.recordset[0]?.count || 0);
+      }
+      let query = `SELECT * FROM ${tableName} ${whereClause} ORDER BY [seq_id] DESC`;
+      if (limit !== void 0 && offset !== void 0) {
+        query += ` OFFSET @offset ROWS FETCH NEXT @limit ROWS ONLY`;
+        request.input("limit", limit);
+        request.input("offset", offset);
+      }
+      const result = await request.query(query);
+      const runs = (result.recordset || []).map((row) => parseWorkflowRun(row));
+      return { runs, total: total || runs.length };
+    } catch (error$1) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_GET_WORKFLOW_RUNS_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY,
+          details: {
+            workflowName: workflowName || "all"
+          }
+        },
+        error$1
+      );
+    }
+  }
+};
+
+// src/storage/index.ts
+var MSSQLStore = class extends storage.MastraStorage {
+  pool;
+  schema;
+  isConnected = null;
+  stores;
+  constructor(config) {
+    super({ name: "MSSQLStore" });
+    try {
+      if ("connectionString" in config) {
+        if (!config.connectionString || typeof config.connectionString !== "string" || config.connectionString.trim() === "") {
+          throw new Error("MSSQLStore: connectionString must be provided and cannot be empty.");
+        }
+      } else {
+        const required = ["server", "database", "user", "password"];
+        for (const key of required) {
+          if (!(key in config) || typeof config[key] !== "string" || config[key].trim() === "") {
+            throw new Error(`MSSQLStore: ${key} must be provided and cannot be empty.`);
+          }
+        }
+      }
+      this.schema = config.schemaName || "dbo";
+      this.pool = "connectionString" in config ? new sql2__default.default.ConnectionPool(config.connectionString) : new sql2__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 }
+      });
+      const legacyEvals = new LegacyEvalsMSSQL({ pool: this.pool, schema: this.schema });
+      const operations = new StoreOperationsMSSQL({ pool: this.pool, schemaName: this.schema });
+      const scores = new ScoresMSSQL({ pool: this.pool, operations, schema: this.schema });
+      const traces = new TracesMSSQL({ pool: this.pool, operations, schema: this.schema });
+      const workflows = new WorkflowsMSSQL({ pool: this.pool, operations, schema: this.schema });
+      const memory = new MemoryMSSQL({ pool: this.pool, schema: this.schema, operations });
+      this.stores = {
+        operations,
+        scores,
+        traces,
+        workflows,
+        legacyEvals,
+        memory
+      };
+    } catch (e) {
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_INITIALIZATION_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.USER
+        },
+        e
+      );
+    }
+  }
+  async init() {
+    if (this.isConnected === null) {
+      this.isConnected = this._performInitializationAndStore();
+    }
+    try {
+      await this.isConnected;
+      await super.init();
+    } catch (error$1) {
+      this.isConnected = null;
+      throw new error.MastraError(
+        {
+          id: "MASTRA_STORAGE_MSSQL_STORE_INIT_FAILED",
+          domain: error.ErrorDomain.STORAGE,
+          category: error.ErrorCategory.THIRD_PARTY
+        },
+        error$1
+      );
+    }
+  }
+  async _performInitializationAndStore() {
+    try {
+      await this.pool.connect();
+      return true;
+    } catch (err) {
+      throw err;
+    }
+  }
+  get supports() {
+    return {
+      selectByIncludeResourceScope: true,
+      resourceWorkingMemory: true,
+      hasColumn: true,
+      createTable: true,
+      deleteMessages: true
+    };
+  }
+  /** @deprecated use getEvals instead */
+  async getEvalsByAgentName(agentName, type) {
+    return this.stores.legacyEvals.getEvalsByAgentName(agentName, type);
+  }
+  async getEvals(options = {}) {
+    return this.stores.legacyEvals.getEvals(options);
+  }
+  /**
+   * @deprecated use getTracesPaginated instead
+   */
+  async getTraces(args) {
+    return this.stores.traces.getTraces(args);
+  }
+  async getTracesPaginated(args) {
+    return this.stores.traces.getTracesPaginated(args);
+  }
+  async batchTraceInsert({ records }) {
+    return this.stores.traces.batchTraceInsert({ records });
+  }
+  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
+   */
+  async getThreadById({ threadId }) {
+    return this.stores.memory.getThreadById({ threadId });
+  }
+  /**
+   * @deprecated use getThreadsByResourceIdPaginated instead
+   */
+  async getThreadsByResourceId(args) {
+    return this.stores.memory.getThreadsByResourceId(args);
+  }
+  async getThreadsByResourceIdPaginated(args) {
+    return this.stores.memory.getThreadsByResourceIdPaginated(args);
+  }
+  async saveThread({ thread }) {
+    return this.stores.memory.saveThread({ thread });
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    return this.stores.memory.updateThread({ id, title, metadata });
+  }
+  async deleteThread({ threadId }) {
+    return this.stores.memory.deleteThread({ threadId });
+  }
+  async getMessages(args) {
+    return this.stores.memory.getMessages(args);
+  }
+  async getMessagesById({
+    messageIds,
+    format
+  }) {
+    return this.stores.memory.getMessagesById({ messageIds, format });
+  }
+  async getMessagesPaginated(args) {
+    return this.stores.memory.getMessagesPaginated(args);
+  }
+  async saveMessages(args) {
+    return this.stores.memory.saveMessages(args);
+  }
+  async updateMessages({
+    messages
+  }) {
+    return this.stores.memory.updateMessages({ messages });
+  }
+  async deleteMessages(messageIds) {
+    return this.stores.memory.deleteMessages(messageIds);
+  }
+  async getResourceById({ resourceId }) {
+    return this.stores.memory.getResourceById({ resourceId });
+  }
+  async saveResource({ resource }) {
+    return this.stores.memory.saveResource({ resource });
+  }
+  async updateResource({
+    resourceId,
+    workingMemory,
+    metadata
+  }) {
+    return this.stores.memory.updateResource({ resourceId, workingMemory, metadata });
+  }
+  /**
+   * Workflows
+   */
+  async updateWorkflowResults({
+    workflowName,
+    runId,
+    stepId,
+    result,
+    runtimeContext
+  }) {
+    return this.stores.workflows.updateWorkflowResults({ workflowName, runId, stepId, result, runtimeContext });
+  }
+  async updateWorkflowState({
+    workflowName,
+    runId,
+    opts
+  }) {
+    return this.stores.workflows.updateWorkflowState({ workflowName, runId, opts });
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    return this.stores.workflows.persistWorkflowSnapshot({ workflowName, runId, snapshot });
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    return this.stores.workflows.loadWorkflowSnapshot({ workflowName, runId });
+  }
+  async getWorkflowRuns({
+    workflowName,
+    fromDate,
+    toDate,
+    limit,
+    offset,
+    resourceId
+  } = {}) {
+    return this.stores.workflows.getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId });
+  }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    return this.stores.workflows.getWorkflowRunById({ runId, workflowName });
+  }
+  async close() {
+    await this.pool.close();
+  }
+  /**
+   * Scorers
+   */
+  async getScoreById({ id: _id }) {
+    return this.stores.scores.getScoreById({ id: _id });
+  }
+  async getScoresByScorerId({
+    scorerId: _scorerId,
+    pagination: _pagination
+  }) {
+    return this.stores.scores.getScoresByScorerId({ scorerId: _scorerId, pagination: _pagination });
+  }
+  async saveScore(_score) {
+    return this.stores.scores.saveScore(_score);
+  }
+  async getScoresByRunId({
+    runId: _runId,
+    pagination: _pagination
+  }) {
+    return this.stores.scores.getScoresByRunId({ runId: _runId, pagination: _pagination });
+  }
+  async getScoresByEntityId({
+    entityId: _entityId,
+    entityType: _entityType,
+    pagination: _pagination
+  }) {
+    return this.stores.scores.getScoresByEntityId({
+      entityId: _entityId,
+      entityType: _entityType,
+      pagination: _pagination
     });
   }
 };
 
 exports.MSSQLStore = MSSQLStore;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map