@mastra/mssql 1.2.2-alpha.1 → 1.3.0

package/dist/index.js

@@ -1,10 +1,10 @@
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
-import { BackgroundTasksStorage, TABLE_BACKGROUND_TASKS, TABLE_SCHEMAS, MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, createStorageErrorId, normalizePerPage, calculatePagination, ObservabilityStorage, TABLE_SPANS, SPAN_SCHEMA, listTracesArgsSchema, toTraceSpans, ScoresStorage, TABLE_SCORERS, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, MastraCompositeStore, getDefaultValue, transformScoreRow as transformScoreRow$1, TraceStatus } from '@mastra/core/storage';
+import { AgentsStorage, TABLE_AGENTS, TABLE_AGENT_VERSIONS, AGENTS_SCHEMA, AGENT_VERSIONS_SCHEMA, createStorageErrorId, normalizePerPage, calculatePagination, BackgroundTasksStorage, TABLE_BACKGROUND_TASKS, TABLE_SCHEMAS, MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, ObservabilityStorage, TABLE_SPANS, SPAN_SCHEMA, listTracesArgsSchema, toTraceSpans, ScoresStorage, TABLE_SCORERS, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, MastraCompositeStore, getDefaultValue, transformScoreRow as transformScoreRow$1, TraceStatus } from '@mastra/core/storage';
 import sql from 'mssql';
-import { MastraBase } from '@mastra/core/base';
+import { randomUUID } from 'crypto';
 import { parseSqlIdentifier } from '@mastra/core/utils';
+import { MastraBase } from '@mastra/core/base';
 import { MessageList } from '@mastra/core/agent';
-import { randomUUID } from 'crypto';
 import { saveScorePayloadSchema } from '@mastra/core/evals';
 
 // src/storage/index.ts
@@ -1350,7 +1350,609 @@ function transformFromSqlRow({
   return result;
 }
 
-// src/storage/domains/background-tasks/index.ts
+// src/storage/domains/agents/index.ts
+var AgentsMSSQL = class _AgentsMSSQL extends AgentsStorage {
+  pool;
+  schema;
+  db;
+  needsConnect;
+  skipDefaultIndexes;
+  indexes;
+  /** Tables managed by this domain. */
+  static MANAGED_TABLES = [TABLE_AGENTS, TABLE_AGENT_VERSIONS];
+  constructor(config) {
+    super();
+    const { pool, schemaName, skipDefaultIndexes, indexes, needsConnect } = resolveMssqlConfig(config);
+    this.pool = pool;
+    this.schema = schemaName;
+    this.db = new MssqlDB({ pool, schemaName, skipDefaultIndexes });
+    this.needsConnect = needsConnect;
+    this.skipDefaultIndexes = skipDefaultIndexes;
+    this.indexes = indexes?.filter((idx) => _AgentsMSSQL.MANAGED_TABLES.includes(idx.table));
+  }
+  async init() {
+    if (this.needsConnect) {
+      await this.pool.connect();
+      this.needsConnect = false;
+    }
+    await this.db.createTable({ tableName: TABLE_AGENTS, schema: AGENTS_SCHEMA });
+    await this.db.createTable({ tableName: TABLE_AGENT_VERSIONS, schema: AGENT_VERSIONS_SCHEMA });
+    await this.createDefaultIndexes();
+    await this.createCustomIndexes();
+  }
+  /** Default index definitions for the agents domain tables. */
+  getDefaultIndexDefinitions() {
+    const schemaPrefix = this.schema && this.schema !== "dbo" ? `${this.schema}_` : "";
+    return [
+      {
+        name: `${schemaPrefix}mastra_agents_createdat_idx`,
+        table: TABLE_AGENTS,
+        columns: ["createdAt DESC"]
+      },
+      {
+        name: `${schemaPrefix}mastra_agent_versions_agentid_versionnumber_uniq`,
+        table: TABLE_AGENT_VERSIONS,
+        columns: ["agentId", "versionNumber DESC"],
+        unique: true
+      },
+      {
+        name: `${schemaPrefix}mastra_agent_versions_agentid_createdat_idx`,
+        table: TABLE_AGENT_VERSIONS,
+        columns: ["agentId", "createdAt DESC"]
+      }
+    ];
+  }
+  async createDefaultIndexes() {
+    if (this.skipDefaultIndexes) return;
+    for (const indexDef of this.getDefaultIndexDefinitions()) {
+      try {
+        await this.db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  async createCustomIndexes() {
+    if (!this.indexes || this.indexes.length === 0) return;
+    for (const indexDef of this.indexes) {
+      try {
+        await this.db.createIndex(indexDef);
+      } catch (error) {
+        this.logger?.warn?.(`Failed to create custom index ${indexDef.name}:`, error);
+      }
+    }
+  }
+  async dangerouslyClearAll() {
+    await this.db.clearTable({ tableName: TABLE_AGENT_VERSIONS });
+    await this.db.clearTable({ tableName: TABLE_AGENTS });
+  }
+  parseJson(value, fieldName) {
+    if (value === null || value === void 0) return void 0;
+    if (typeof value !== "string") return value;
+    try {
+      return JSON.parse(value);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MSSQL", "PARSE_JSON", "INVALID_JSON"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.SYSTEM,
+          text: `Failed to parse JSON${fieldName ? ` for field "${fieldName}"` : ""}: ${error instanceof Error ? error.message : "Unknown error"}`,
+          details: { field: fieldName ?? "", valueLen: value.length }
+        },
+        error
+      );
+    }
+  }
+  serializeInstructions(instructions) {
+    if (instructions === void 0) return void 0;
+    return Array.isArray(instructions) ? JSON.stringify(instructions) : instructions;
+  }
+  deserializeInstructions(raw) {
+    if (!raw) return raw ?? void 0;
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) return parsed;
+    } catch {
+    }
+    return raw;
+  }
+  parseRow(row) {
+    return {
+      id: row.id,
+      status: row.status,
+      activeVersionId: row.activeVersionId ?? void 0,
+      authorId: row.authorId ?? void 0,
+      metadata: this.parseJson(row.metadata, "metadata"),
+      createdAt: row.createdAt instanceof Date ? row.createdAt : new Date(row.createdAt),
+      updatedAt: row.updatedAt instanceof Date ? row.updatedAt : new Date(row.updatedAt)
+    };
+  }
+  parseVersionRow(row) {
+    return {
+      id: row.id,
+      agentId: row.agentId,
+      versionNumber: row.versionNumber,
+      name: row.name,
+      description: row.description ?? void 0,
+      instructions: this.deserializeInstructions(
+        row.instructions
+      ),
+      model: this.parseJson(row.model, "model"),
+      tools: this.parseJson(row.tools, "tools"),
+      defaultOptions: this.parseJson(row.defaultOptions, "defaultOptions"),
+      workflows: this.parseJson(row.workflows, "workflows"),
+      agents: this.parseJson(row.agents, "agents"),
+      integrationTools: this.parseJson(row.integrationTools, "integrationTools"),
+      inputProcessors: this.parseJson(row.inputProcessors, "inputProcessors"),
+      outputProcessors: this.parseJson(row.outputProcessors, "outputProcessors"),
+      memory: this.parseJson(row.memory, "memory"),
+      scorers: this.parseJson(row.scorers, "scorers"),
+      mcpClients: this.parseJson(row.mcpClients, "mcpClients"),
+      requestContextSchema: this.parseJson(
+        row.requestContextSchema,
+        "requestContextSchema"
+      ),
+      workspace: this.parseJson(row.workspace, "workspace"),
+      skills: this.parseJson(row.skills, "skills"),
+      skillsFormat: row.skillsFormat ?? void 0,
+      changedFields: this.parseJson(row.changedFields, "changedFields"),
+      changeMessage: row.changeMessage ?? void 0,
+      createdAt: row.createdAt instanceof Date ? row.createdAt : new Date(row.createdAt)
+    };
+  }
+  async getById(id) {
+    try {
+      const result = await this.db.load({ tableName: TABLE_AGENTS, keys: { id } });
+      return result ? this.parseRow(result) : null;
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MSSQL", "GET_AGENT_BY_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentId: id }
+        },
+        error
+      );
+    }
+  }
+  async create(input) {
+    const { agent } = input;
+    try {
+      const now = /* @__PURE__ */ new Date();
+      await this.db.insert({
+        tableName: TABLE_AGENTS,
+        record: {
+          id: agent.id,
+          status: "draft",
+          activeVersionId: null,
+          authorId: agent.authorId ?? null,
+          metadata: agent.metadata ?? null,
+          createdAt: now,
+          updatedAt: now
+        }
+      });
+      const { id: _id, authorId: _authorId, metadata: _metadata, ...snapshotConfig } = agent;
+      const versionId = randomUUID();
+      await this.createVersion({
+        id: versionId,
+        agentId: agent.id,
+        versionNumber: 1,
+        ...snapshotConfig,
+        changedFields: Object.keys(snapshotConfig),
+        changeMessage: "Initial version"
+      });
+      const created = await this.getById(agent.id);
+      if (!created) {
+        throw new MastraError({
+          id: createStorageErrorId("MSSQL", "CREATE_AGENT", "NOT_FOUND_AFTER_CREATE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.SYSTEM,
+          text: `Agent ${agent.id} not found after creation`,
+          details: { agentId: agent.id }
+        });
+      }
+      return created;
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MSSQL", "CREATE_AGENT", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentId: agent.id }
+        },
+        error
+      );
+    }
+  }
+  async update(input) {
+    const { id, ...updates } = input;
+    try {
+      const existing = await this.getById(id);
+      if (!existing) {
+        throw new MastraError({
+          id: createStorageErrorId("MSSQL", "UPDATE_AGENT", "NOT_FOUND"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          text: `Agent ${id} not found`,
+          details: { agentId: id }
+        });
+      }
+      const { authorId, activeVersionId, metadata, status } = updates;
+      const data = { updatedAt: /* @__PURE__ */ new Date() };
+      if (authorId !== void 0) data.authorId = authorId;
+      if (activeVersionId !== void 0) data.activeVersionId = activeVersionId;
+      if (status !== void 0) data.status = status;
+      if (metadata !== void 0) data.metadata = { ...existing.metadata, ...metadata };
+      await this.db.update({ tableName: TABLE_AGENTS, keys: { id }, data });
+      const updated = await this.getById(id);
+      if (!updated) {
+        throw new MastraError({
+          id: createStorageErrorId("MSSQL", "UPDATE_AGENT", "NOT_FOUND_AFTER_UPDATE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.SYSTEM,
+          text: `Agent ${id} not found after update`,
+          details: { agentId: id }
+        });
+      }
+      return updated;
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MSSQL", "UPDATE_AGENT", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentId: id }
+        },
+        error
+      );
+    }
+  }
+  async delete(id) {
+    try {
+      await this.deleteVersionsByParentId(id);
+      const fullName = getTableName2({ indexName: TABLE_AGENTS, schemaName: getSchemaName2(this.schema) });
+      const request = this.pool.request();
+      request.input("id", id);
+      await request.query(`DELETE FROM ${fullName} WHERE [id] = @id`);
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MSSQL", "DELETE_AGENT", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentId: id }
+        },
+        error
+      );
+    }
+  }
+  async list(args) {
+    const { page = 0, perPage: perPageInput, orderBy, authorId, metadata, status } = args || {};
+    const { field, direction } = this.parseOrderBy(orderBy);
+    if (page < 0) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MSSQL", "LIST_AGENTS", "INVALID_PAGE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = normalizePerPage(perPageInput, 100);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    try {
+      const conditions = [];
+      const inputs = [];
+      if (status !== void 0) {
+        conditions.push("[status] = @status");
+        inputs.push(["status", status]);
+      }
+      if (authorId !== void 0) {
+        conditions.push("[authorId] = @authorId");
+        inputs.push(["authorId", authorId]);
+      }
+      if (metadata && Object.keys(metadata).length > 0) {
+        let metaIdx = 0;
+        for (const [key, value] of Object.entries(metadata)) {
+          if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
+            throw new MastraError({
+              id: createStorageErrorId("MSSQL", "LIST_AGENTS", "INVALID_METADATA_KEY"),
+              domain: ErrorDomain.STORAGE,
+              category: ErrorCategory.USER,
+              text: `Invalid metadata key: ${key}. Keys must be alphanumeric with underscores.`,
+              details: { key }
+            });
+          }
+          if (value !== null && typeof value === "object") {
+            throw new MastraError({
+              id: createStorageErrorId("MSSQL", "LIST_AGENTS", "NON_PRIMITIVE_METADATA"),
+              domain: ErrorDomain.STORAGE,
+              category: ErrorCategory.USER,
+              text: `Metadata filter for key "${key}" must be a primitive (string/number/boolean/null); received ${Array.isArray(value) ? "array" : "object"}.`,
+              details: { key }
+            });
+          }
+          if (value === null) {
+            conditions.push(`JSON_VALUE([metadata], '$.${key}') IS NULL`);
+            continue;
+          }
+          const paramName = `meta_${metaIdx++}`;
+          conditions.push(`JSON_VALUE([metadata], '$.${key}') = @${paramName}`);
+          inputs.push([paramName, typeof value === "string" ? value : String(value)]);
+        }
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const fullName = getTableName2({ indexName: TABLE_AGENTS, schemaName: getSchemaName2(this.schema) });
+      const countRequest = this.pool.request();
+      for (const [k, v] of inputs) countRequest.input(k, v);
+      const countResult = await countRequest.query(`SELECT COUNT(*) AS [count] FROM ${fullName} ${whereClause}`);
+      const total = Number(countResult.recordset?.[0]?.count ?? 0);
+      if (total === 0) {
+        return { agents: [], total: 0, page, perPage: perPageForResponse, hasMore: false };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const fieldSafe = parseSqlIdentifier(field, "order column");
+      const dirSafe = direction === "ASC" ? "ASC" : "DESC";
+      const listRequest = this.pool.request();
+      for (const [k, v] of inputs) listRequest.input(k, v);
+      listRequest.input("offset", offset);
+      listRequest.input("limit", limitValue);
+      const listSql = `SELECT * FROM ${fullName} ${whereClause} ORDER BY [${fieldSafe}] ${dirSafe} OFFSET @offset ROWS FETCH NEXT @limit ROWS ONLY`;
+      const listResult = await listRequest.query(listSql);
+      const agents = (listResult.recordset || []).map((row) => this.parseRow(row));
+      return {
+        agents,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MSSQL", "LIST_AGENTS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY
+        },
+        error
+      );
+    }
+  }
+  async createVersion(input) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      await this.db.insert({
+        tableName: TABLE_AGENT_VERSIONS,
+        record: {
+          id: input.id,
+          agentId: input.agentId,
+          versionNumber: input.versionNumber,
+          name: input.name ?? null,
+          description: input.description ?? null,
+          instructions: this.serializeInstructions(input.instructions) ?? null,
+          model: input.model,
+          tools: input.tools ?? null,
+          defaultOptions: input.defaultOptions ?? null,
+          workflows: input.workflows ?? null,
+          agents: input.agents ?? null,
+          integrationTools: input.integrationTools ?? null,
+          inputProcessors: input.inputProcessors ?? null,
+          outputProcessors: input.outputProcessors ?? null,
+          memory: input.memory ?? null,
+          scorers: input.scorers ?? null,
+          mcpClients: input.mcpClients ?? null,
+          requestContextSchema: input.requestContextSchema ?? null,
+          workspace: input.workspace ?? null,
+          skills: input.skills ?? null,
+          skillsFormat: input.skillsFormat ?? null,
+          changedFields: input.changedFields ?? null,
+          changeMessage: input.changeMessage ?? null,
+          createdAt: now
+        }
+      });
+      return { ...input, createdAt: now };
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MSSQL", "CREATE_VERSION", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { versionId: input.id, agentId: input.agentId }
+        },
+        error
+      );
+    }
+  }
+  async getVersion(id) {
+    try {
+      const result = await this.db.load({ tableName: TABLE_AGENT_VERSIONS, keys: { id } });
+      return result ? this.parseVersionRow(result) : null;
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MSSQL", "GET_VERSION", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error
+      );
+    }
+  }
+  async getVersionByNumber(agentId, versionNumber) {
+    try {
+      const fullName = getTableName2({ indexName: TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.schema) });
+      const request = this.pool.request();
+      request.input("agentId", agentId);
+      request.input("versionNumber", versionNumber);
+      const result = await request.query(
+        `SELECT TOP 1 * FROM ${fullName} WHERE [agentId] = @agentId AND [versionNumber] = @versionNumber`
+      );
+      const row = result.recordset?.[0];
+      return row ? this.parseVersionRow(row) : null;
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MSSQL", "GET_VERSION_BY_NUMBER", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentId, versionNumber }
+        },
+        error
+      );
+    }
+  }
+  async getLatestVersion(agentId) {
+    try {
+      const fullName = getTableName2({ indexName: TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.schema) });
+      const request = this.pool.request();
+      request.input("agentId", agentId);
+      const result = await request.query(
+        `SELECT TOP 1 * FROM ${fullName} WHERE [agentId] = @agentId ORDER BY [versionNumber] DESC`
+      );
+      const row = result.recordset?.[0];
+      return row ? this.parseVersionRow(row) : null;
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MSSQL", "GET_LATEST_VERSION", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error
+      );
+    }
+  }
+  async listVersions(input) {
+    const { agentId, page = 0, perPage: perPageInput, orderBy } = input;
+    if (page < 0) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MSSQL", "LIST_VERSIONS", "INVALID_PAGE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page }
+        },
+        new Error("page must be >= 0")
+      );
+    }
+    const perPage = normalizePerPage(perPageInput, 20);
+    const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
+    try {
+      const { field, direction } = this.parseVersionOrderBy(orderBy);
+      const fullName = getTableName2({ indexName: TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.schema) });
+      const countRequest = this.pool.request();
+      countRequest.input("agentId", agentId);
+      const countResult = await countRequest.query(
+        `SELECT COUNT(*) AS [count] FROM ${fullName} WHERE [agentId] = @agentId`
+      );
+      const total = Number(countResult.recordset?.[0]?.count ?? 0);
+      if (total === 0) {
+        return { versions: [], total: 0, page, perPage: perPageForResponse, hasMore: false };
+      }
+      const limitValue = perPageInput === false ? total : perPage;
+      const fieldSafe = parseSqlIdentifier(field, "order column");
+      const dirSafe = direction === "ASC" ? "ASC" : "DESC";
+      const listRequest = this.pool.request();
+      listRequest.input("agentId", agentId);
+      listRequest.input("offset", offset);
+      listRequest.input("limit", limitValue);
+      const listSql = `SELECT * FROM ${fullName} WHERE [agentId] = @agentId ORDER BY [${fieldSafe}] ${dirSafe} OFFSET @offset ROWS FETCH NEXT @limit ROWS ONLY`;
+      const listResult = await listRequest.query(listSql);
+      const versions = (listResult.recordset || []).map((row) => this.parseVersionRow(row));
+      return {
+        versions,
+        total,
+        page,
+        perPage: perPageForResponse,
+        hasMore: perPageInput === false ? false : offset + perPage < total
+      };
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MSSQL", "LIST_VERSIONS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error
+      );
+    }
+  }
+  async deleteVersion(id) {
+    try {
+      const fullName = getTableName2({ indexName: TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.schema) });
+      const request = this.pool.request();
+      request.input("id", id);
+      await request.query(`DELETE FROM ${fullName} WHERE [id] = @id`);
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MSSQL", "DELETE_VERSION", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { versionId: id }
+        },
+        error
+      );
+    }
+  }
+  async deleteVersionsByParentId(entityId) {
+    try {
+      const fullName = getTableName2({ indexName: TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.schema) });
+      const request = this.pool.request();
+      request.input("agentId", entityId);
+      await request.query(`DELETE FROM ${fullName} WHERE [agentId] = @agentId`);
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MSSQL", "DELETE_VERSIONS_BY_AGENT_ID", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentId: entityId }
+        },
+        error
+      );
+    }
+  }
+  async countVersions(agentId) {
+    try {
+      const fullName = getTableName2({ indexName: TABLE_AGENT_VERSIONS, schemaName: getSchemaName2(this.schema) });
+      const request = this.pool.request();
+      request.input("agentId", agentId);
+      const result = await request.query(`SELECT COUNT(*) AS [count] FROM ${fullName} WHERE [agentId] = @agentId`);
+      return Number(result.recordset?.[0]?.count ?? 0);
+    } catch (error) {
+      if (error instanceof MastraError) throw error;
+      throw new MastraError(
+        {
+          id: createStorageErrorId("MSSQL", "COUNT_VERSIONS", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { agentId }
+        },
+        error
+      );
+    }
+  }
+};
 function serializeJson(v) {
   if (typeof v === "object" && v != null) return JSON.stringify(v);
   return v ?? null;
@@ -4370,12 +4972,14 @@ var MSSQLStore = class extends MastraCompositeStore {
       const memory = new MemoryMSSQL(domainConfig);
       const observability = new ObservabilityMSSQL(domainConfig);
       const backgroundTasks = new BackgroundTasksMSSQL(domainConfig);
+      const agents = new AgentsMSSQL(domainConfig);
       this.stores = {
         scores,
         workflows,
         memory,
         observability,
-        backgroundTasks
+        backgroundTasks,
+        agents
       };
     } catch (e) {
       throw new MastraError(
@@ -4428,6 +5032,6 @@ var MSSQLStore = class extends MastraCompositeStore {
   }
 };
 
-export { BackgroundTasksMSSQL, MSSQLStore, MemoryMSSQL, ObservabilityMSSQL, ScoresMSSQL, WorkflowsMSSQL };
+export { AgentsMSSQL, BackgroundTasksMSSQL, MSSQLStore, MemoryMSSQL, ObservabilityMSSQL, ScoresMSSQL, WorkflowsMSSQL };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map