@mastra/server 1.0.4-alpha.2 → 1.1.0-alpha.0

package/dist/chunk-TGDBGIDA.cjs

@@ -0,0 +1,623 @@
+'use strict';
+
+var chunkMCYD5LW7_cjs = require('./chunk-MCYD5LW7.cjs');
+var chunkSUKFO7UM_cjs = require('./chunk-SUKFO7UM.cjs');
+var chunk4LVJBXI2_cjs = require('./chunk-4LVJBXI2.cjs');
+var chunk64ITUOXI_cjs = require('./chunk-64ITUOXI.cjs');
+var z = require('zod');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var z__default = /*#__PURE__*/_interopDefault(z);
+
+var storedAgentIdPathParams = z__default.default.object({
+  storedAgentId: z__default.default.string().describe("Unique identifier for the stored agent")
+});
+var storageOrderBySchema = z__default.default.object({
+  field: z__default.default.enum(["createdAt", "updatedAt"]).optional(),
+  direction: z__default.default.enum(["ASC", "DESC"]).optional()
+});
+var listStoredAgentsQuerySchema = chunkMCYD5LW7_cjs.createPagePaginationSchema(100).extend({
+  orderBy: storageOrderBySchema.optional(),
+  ownerId: z__default.default.string().optional().describe("Filter agents by owner identifier"),
+  metadata: z__default.default.record(z__default.default.string(), z__default.default.unknown()).optional().describe("Filter agents by metadata key-value pairs")
+});
+var scorerConfigSchema = z__default.default.object({
+  sampling: z__default.default.object({
+    type: z__default.default.enum(["ratio", "count"]),
+    rate: z__default.default.number().optional(),
+    count: z__default.default.number().optional()
+  }).optional()
+});
+var storedAgentBaseSchema = z__default.default.object({
+  name: z__default.default.string().describe("Name of the agent"),
+  description: z__default.default.string().optional().describe("Description of the agent"),
+  instructions: z__default.default.string().describe("System instructions for the agent"),
+  model: z__default.default.record(z__default.default.string(), z__default.default.unknown()).describe("Model configuration (provider, name, etc.)"),
+  tools: z__default.default.array(z__default.default.string()).optional().describe("Array of tool keys to resolve from Mastra registry"),
+  defaultOptions: z__default.default.record(z__default.default.string(), z__default.default.unknown()).optional().describe("Default options for generate/stream calls"),
+  workflows: z__default.default.array(z__default.default.string()).optional().describe("Array of workflow keys to resolve from Mastra registry"),
+  agents: z__default.default.array(z__default.default.string()).optional().describe("Array of agent keys to resolve from Mastra registry"),
+  integrationTools: z__default.default.array(z__default.default.string()).optional().describe("Array of specific integration tool IDs (format: provider_toolkitSlug_toolSlug)"),
+  inputProcessors: z__default.default.array(z__default.default.record(z__default.default.string(), z__default.default.unknown())).optional().describe("Input processor configurations"),
+  outputProcessors: z__default.default.array(z__default.default.record(z__default.default.string(), z__default.default.unknown())).optional().describe("Output processor configurations"),
+  memory: z__default.default.string().optional().describe("Memory key to resolve from Mastra registry"),
+  scorers: z__default.default.record(z__default.default.string(), scorerConfigSchema).optional().describe("Scorer keys with optional sampling config"),
+  metadata: z__default.default.record(z__default.default.string(), z__default.default.unknown()).optional().describe("Additional metadata for the agent"),
+  ownerId: z__default.default.string().optional().describe("Owner identifier for multi-tenant filtering")
+});
+var createStoredAgentBodySchema = storedAgentBaseSchema.extend({
+  id: z__default.default.string().describe("Unique identifier for the agent")
+});
+var updateStoredAgentBodySchema = storedAgentBaseSchema.partial();
+var storedAgentSchema = storedAgentBaseSchema.extend({
+  id: z__default.default.string(),
+  ownerId: z__default.default.string().optional(),
+  createdAt: z__default.default.date(),
+  updatedAt: z__default.default.date()
+});
+var listStoredAgentsResponseSchema = chunkMCYD5LW7_cjs.paginationInfoSchema.extend({
+  agents: z__default.default.array(storedAgentSchema)
+});
+var getStoredAgentResponseSchema = storedAgentSchema;
+var createStoredAgentResponseSchema = storedAgentSchema;
+var updateStoredAgentResponseSchema = storedAgentSchema;
+var deleteStoredAgentResponseSchema = z__default.default.object({
+  success: z__default.default.boolean(),
+  message: z__default.default.string()
+});
+
+// src/server/schemas/agent-versions.ts
+var agentVersionPathParams = z__default.default.object({
+  agentId: z__default.default.string().describe("Unique identifier for the stored agent")
+});
+var versionIdPathParams = z__default.default.object({
+  agentId: z__default.default.string().describe("Unique identifier for the stored agent"),
+  versionId: z__default.default.string().describe("Unique identifier for the version (UUID)")
+});
+var versionOrderBySchema = z__default.default.object({
+  field: z__default.default.enum(["versionNumber", "createdAt"]).optional(),
+  direction: z__default.default.enum(["ASC", "DESC"]).optional()
+});
+var listVersionsQuerySchema = chunkMCYD5LW7_cjs.createPagePaginationSchema(20).extend({
+  orderBy: versionOrderBySchema.optional()
+});
+var compareVersionsQuerySchema = z__default.default.object({
+  from: z__default.default.string().describe("Version ID (UUID) to compare from"),
+  to: z__default.default.string().describe("Version ID (UUID) to compare to")
+});
+var createVersionBodySchema = z__default.default.object({
+  name: z__default.default.string().max(100).optional().describe("Optional vanity name for this version"),
+  changeMessage: z__default.default.string().max(500).optional().describe("Optional message describing the changes")
+});
+var agentVersionSchema = z__default.default.object({
+  id: z__default.default.string().describe("Unique identifier for the version (UUID)"),
+  agentId: z__default.default.string().describe("ID of the agent this version belongs to"),
+  versionNumber: z__default.default.number().describe("Sequential version number (1, 2, 3, ...)"),
+  name: z__default.default.string().optional().describe("Optional vanity name for this version"),
+  snapshot: storedAgentSchema.describe("Full agent configuration snapshot"),
+  changedFields: z__default.default.array(z__default.default.string()).optional().describe("Array of field names that changed from the previous version"),
+  changeMessage: z__default.default.string().optional().describe("Optional message describing the changes"),
+  createdAt: z__default.default.date().describe("When this version was created")
+});
+var listVersionsResponseSchema = chunkMCYD5LW7_cjs.paginationInfoSchema.extend({
+  versions: z__default.default.array(agentVersionSchema)
+});
+var getVersionResponseSchema = agentVersionSchema;
+var createVersionResponseSchema = agentVersionSchema;
+var activateVersionResponseSchema = z__default.default.object({
+  success: z__default.default.boolean(),
+  message: z__default.default.string(),
+  activeVersionId: z__default.default.string()
+});
+var restoreVersionResponseSchema = agentVersionSchema.describe(
+  "The newly created version from the restored snapshot"
+);
+var deleteVersionResponseSchema = z__default.default.object({
+  success: z__default.default.boolean(),
+  message: z__default.default.string()
+});
+var versionDiffEntrySchema = z__default.default.object({
+  field: z__default.default.string().describe("The field path that changed"),
+  previousValue: z__default.default.unknown().describe('The value in the "from" version'),
+  currentValue: z__default.default.unknown().describe('The value in the "to" version')
+});
+var compareVersionsResponseSchema = z__default.default.object({
+  diffs: z__default.default.array(versionDiffEntrySchema).describe("List of differences between versions"),
+  fromVersion: agentVersionSchema.describe("The source version"),
+  toVersion: agentVersionSchema.describe("The target version")
+});
+
+// src/server/handlers/agent-versions.ts
+var DEFAULT_MAX_VERSIONS_PER_AGENT = 50;
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return a === b;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, index) => deepEqual(item, b[index]));
+  }
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime();
+  }
+  if (typeof a === "object" && typeof b === "object") {
+    const aObj = a;
+    const bObj = b;
+    const aKeys = Object.keys(aObj);
+    const bKeys = Object.keys(bObj);
+    if (aKeys.length !== bKeys.length) return false;
+    return aKeys.every((key) => Object.prototype.hasOwnProperty.call(bObj, key) && deepEqual(aObj[key], bObj[key]));
+  }
+  return false;
+}
+function generateVersionId() {
+  return crypto.randomUUID();
+}
+function calculateChangedFields(previous, current) {
+  if (!previous) {
+    return Object.keys(current);
+  }
+  const changedFields = [];
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(previous), ...Object.keys(current)]);
+  for (const key of allKeys) {
+    if (key === "updatedAt" || key === "createdAt") {
+      continue;
+    }
+    const prevValue = previous[key];
+    const currValue = current[key];
+    if (!deepEqual(prevValue, currValue)) {
+      changedFields.push(key);
+    }
+  }
+  return changedFields;
+}
+function computeVersionDiffs(fromSnapshot, toSnapshot) {
+  const diffs = [];
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(fromSnapshot), ...Object.keys(toSnapshot)]);
+  for (const key of allKeys) {
+    if (key === "updatedAt" || key === "createdAt") {
+      continue;
+    }
+    const prevValue = fromSnapshot[key];
+    const currValue = toSnapshot[key];
+    if (!deepEqual(prevValue, currValue)) {
+      diffs.push({
+        field: key,
+        previousValue: prevValue,
+        currentValue: currValue
+      });
+    }
+  }
+  return diffs;
+}
+async function enforceRetentionLimit(agentsStore, agentId, activeVersionId, maxVersions = DEFAULT_MAX_VERSIONS_PER_AGENT) {
+  const { total } = await agentsStore.listVersions({ agentId, perPage: 1 });
+  if (total <= maxVersions) {
+    return { deletedCount: 0 };
+  }
+  const versionsToDelete = total - maxVersions;
+  const { versions: oldestVersions } = await agentsStore.listVersions({
+    agentId,
+    perPage: versionsToDelete + 1,
+    // Get one extra in case we need to skip the active version
+    orderBy: { field: "versionNumber", direction: "ASC" }
+  });
+  let deletedCount = 0;
+  for (const version of oldestVersions) {
+    if (deletedCount >= versionsToDelete) {
+      break;
+    }
+    if (version.id === activeVersionId) {
+      continue;
+    }
+    await agentsStore.deleteVersion(version.id);
+    deletedCount++;
+  }
+  return { deletedCount };
+}
+function isVersionNumberConflictError(error) {
+  if (error instanceof Error) {
+    const message = error.message.toLowerCase();
+    return message.includes("unique") && message.includes("constraint") || message.includes("duplicate key") || message.includes("unique_violation") || message.includes("sqlite_constraint_unique") || message.includes("versionnumber");
+  }
+  return false;
+}
+async function createVersionWithRetry(agentsStore, agentId, snapshot, changedFields, options = {}) {
+  const { name, changeMessage, maxRetries = 3 } = options;
+  let lastError;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    try {
+      const latestVersion = await agentsStore.getLatestVersion(agentId);
+      const versionNumber = latestVersion ? latestVersion.versionNumber + 1 : 1;
+      const versionId = generateVersionId();
+      await agentsStore.createVersion({
+        id: versionId,
+        agentId,
+        versionNumber,
+        name,
+        snapshot,
+        changedFields,
+        changeMessage
+      });
+      return { versionId, versionNumber };
+    } catch (error) {
+      lastError = error;
+      if (isVersionNumberConflictError(error) && attempt < maxRetries - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 10 * (attempt + 1)));
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw lastError;
+}
+async function handleAutoVersioning(agentsStore, agentId, existingAgent, updatedAgent) {
+  const changedFields = calculateChangedFields(
+    existingAgent,
+    updatedAgent
+  );
+  if (changedFields.length === 0) {
+    return { agent: updatedAgent, versionCreated: false };
+  }
+  const { versionId } = await createVersionWithRetry(agentsStore, agentId, updatedAgent, changedFields, {
+    changeMessage: "Auto-saved after edit"
+  });
+  const finalAgent = await agentsStore.updateAgent({
+    id: agentId,
+    activeVersionId: versionId
+  });
+  await enforceRetentionLimit(agentsStore, agentId, versionId);
+  return { agent: finalAgent, versionCreated: true };
+}
+var LIST_AGENT_VERSIONS_ROUTE = chunk4LVJBXI2_cjs.createRoute({
+  method: "GET",
+  path: "/stored/agents/:agentId/versions",
+  responseType: "json",
+  pathParamSchema: agentVersionPathParams,
+  queryParamSchema: listVersionsQuerySchema,
+  responseSchema: listVersionsResponseSchema,
+  summary: "List agent versions",
+  description: "Returns a paginated list of all versions for a stored agent",
+  tags: ["Agent Versions"],
+  handler: async ({ mastra, agentId, page, perPage, orderBy }) => {
+    try {
+      const storage = mastra.getStorage();
+      if (!storage) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Storage is not configured" });
+      }
+      const agentsStore = await storage.getStore("agents");
+      if (!agentsStore) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Agents storage domain is not available" });
+      }
+      const agent = await agentsStore.getAgentById({ id: agentId });
+      if (!agent) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Agent with id ${agentId} not found` });
+      }
+      const result = await agentsStore.listVersions({
+        agentId,
+        page,
+        perPage,
+        orderBy
+      });
+      return result;
+    } catch (error) {
+      return chunkSUKFO7UM_cjs.handleError(error, "Error listing agent versions");
+    }
+  }
+});
+var CREATE_AGENT_VERSION_ROUTE = chunk4LVJBXI2_cjs.createRoute({
+  method: "POST",
+  path: "/stored/agents/:agentId/versions",
+  responseType: "json",
+  pathParamSchema: agentVersionPathParams,
+  bodySchema: createVersionBodySchema,
+  responseSchema: createVersionResponseSchema,
+  summary: "Create agent version",
+  description: "Creates a new version snapshot of the current agent configuration",
+  tags: ["Agent Versions"],
+  handler: async ({ mastra, agentId, name, changeMessage }) => {
+    try {
+      const storage = mastra.getStorage();
+      if (!storage) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Storage is not configured" });
+      }
+      const agentsStore = await storage.getStore("agents");
+      if (!agentsStore) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Agents storage domain is not available" });
+      }
+      const agent = await agentsStore.getAgentById({ id: agentId });
+      if (!agent) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Agent with id ${agentId} not found` });
+      }
+      const latestVersion = await agentsStore.getLatestVersion(agentId);
+      const changedFields = calculateChangedFields(
+        latestVersion?.snapshot,
+        agent
+      );
+      const { versionId } = await createVersionWithRetry(
+        agentsStore,
+        agentId,
+        agent,
+        changedFields.length > 0 ? changedFields : [],
+        { name, changeMessage }
+      );
+      const version = await agentsStore.getVersion(versionId);
+      if (!version) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Failed to retrieve created version" });
+      }
+      await enforceRetentionLimit(agentsStore, agentId, agent.activeVersionId);
+      return version;
+    } catch (error) {
+      return chunkSUKFO7UM_cjs.handleError(error, "Error creating agent version");
+    }
+  }
+});
+var GET_AGENT_VERSION_ROUTE = chunk4LVJBXI2_cjs.createRoute({
+  method: "GET",
+  path: "/stored/agents/:agentId/versions/:versionId",
+  responseType: "json",
+  pathParamSchema: versionIdPathParams,
+  responseSchema: getVersionResponseSchema,
+  summary: "Get agent version",
+  description: "Returns a specific version of an agent by its version ID",
+  tags: ["Agent Versions"],
+  handler: async ({ mastra, agentId, versionId }) => {
+    try {
+      const storage = mastra.getStorage();
+      if (!storage) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Storage is not configured" });
+      }
+      const agentsStore = await storage.getStore("agents");
+      if (!agentsStore) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Agents storage domain is not available" });
+      }
+      const version = await agentsStore.getVersion(versionId);
+      if (!version) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Version with id ${versionId} not found` });
+      }
+      if (version.agentId !== agentId) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Version with id ${versionId} not found for agent ${agentId}` });
+      }
+      return version;
+    } catch (error) {
+      return chunkSUKFO7UM_cjs.handleError(error, "Error getting agent version");
+    }
+  }
+});
+var ACTIVATE_AGENT_VERSION_ROUTE = chunk4LVJBXI2_cjs.createRoute({
+  method: "POST",
+  path: "/stored/agents/:agentId/versions/:versionId/activate",
+  responseType: "json",
+  pathParamSchema: versionIdPathParams,
+  responseSchema: activateVersionResponseSchema,
+  summary: "Activate agent version",
+  description: "Sets a specific version as the active version for the agent",
+  tags: ["Agent Versions"],
+  handler: async ({ mastra, agentId, versionId }) => {
+    try {
+      const storage = mastra.getStorage();
+      if (!storage) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Storage is not configured" });
+      }
+      const agentsStore = await storage.getStore("agents");
+      if (!agentsStore) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Agents storage domain is not available" });
+      }
+      const agent = await agentsStore.getAgentById({ id: agentId });
+      if (!agent) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Agent with id ${agentId} not found` });
+      }
+      const version = await agentsStore.getVersion(versionId);
+      if (!version) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Version with id ${versionId} not found` });
+      }
+      if (version.agentId !== agentId) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Version with id ${versionId} not found for agent ${agentId}` });
+      }
+      await agentsStore.updateAgent({
+        id: agentId,
+        activeVersionId: versionId
+      });
+      return {
+        success: true,
+        message: `Version ${version.versionNumber} is now active`,
+        activeVersionId: versionId
+      };
+    } catch (error) {
+      return chunkSUKFO7UM_cjs.handleError(error, "Error activating agent version");
+    }
+  }
+});
+var RESTORE_AGENT_VERSION_ROUTE = chunk4LVJBXI2_cjs.createRoute({
+  method: "POST",
+  path: "/stored/agents/:agentId/versions/:versionId/restore",
+  responseType: "json",
+  pathParamSchema: versionIdPathParams,
+  responseSchema: restoreVersionResponseSchema,
+  summary: "Restore agent version",
+  description: "Restores the agent configuration from a version snapshot, creating a new version",
+  tags: ["Agent Versions"],
+  handler: async ({ mastra, agentId, versionId }) => {
+    try {
+      const storage = mastra.getStorage();
+      if (!storage) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Storage is not configured" });
+      }
+      const agentsStore = await storage.getStore("agents");
+      if (!agentsStore) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Agents storage domain is not available" });
+      }
+      const agent = await agentsStore.getAgentById({ id: agentId });
+      if (!agent) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Agent with id ${agentId} not found` });
+      }
+      const versionToRestore = await agentsStore.getVersion(versionId);
+      if (!versionToRestore) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Version with id ${versionId} not found` });
+      }
+      if (versionToRestore.agentId !== agentId) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Version with id ${versionId} not found for agent ${agentId}` });
+      }
+      const {
+        id: _id,
+        createdAt: _createdAt,
+        updatedAt: _updatedAt,
+        activeVersionId: _activeVersionId,
+        ...snapshotData
+      } = versionToRestore.snapshot;
+      await agentsStore.updateAgent({
+        id: agentId,
+        ...snapshotData
+      });
+      const updatedAgent = await agentsStore.getAgentById({ id: agentId });
+      if (!updatedAgent) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Failed to retrieve updated agent" });
+      }
+      const latestVersion = await agentsStore.getLatestVersion(agentId);
+      const changedFields = calculateChangedFields(
+        latestVersion?.snapshot,
+        updatedAgent
+      );
+      const { versionId: newVersionId } = await createVersionWithRetry(
+        agentsStore,
+        agentId,
+        updatedAgent,
+        changedFields,
+        {
+          changeMessage: `Restored from version ${versionToRestore.versionNumber}${versionToRestore.name ? ` (${versionToRestore.name})` : ""}`
+        }
+      );
+      await agentsStore.updateAgent({
+        id: agentId,
+        activeVersionId: newVersionId
+      });
+      const newVersion = await agentsStore.getVersion(newVersionId);
+      if (!newVersion) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Failed to retrieve created version" });
+      }
+      await enforceRetentionLimit(agentsStore, agentId, newVersionId);
+      return newVersion;
+    } catch (error) {
+      return chunkSUKFO7UM_cjs.handleError(error, "Error restoring agent version");
+    }
+  }
+});
+var DELETE_AGENT_VERSION_ROUTE = chunk4LVJBXI2_cjs.createRoute({
+  method: "DELETE",
+  path: "/stored/agents/:agentId/versions/:versionId",
+  responseType: "json",
+  pathParamSchema: versionIdPathParams,
+  responseSchema: deleteVersionResponseSchema,
+  summary: "Delete agent version",
+  description: "Deletes a specific version (cannot delete the active version)",
+  tags: ["Agent Versions"],
+  handler: async ({ mastra, agentId, versionId }) => {
+    try {
+      const storage = mastra.getStorage();
+      if (!storage) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Storage is not configured" });
+      }
+      const agentsStore = await storage.getStore("agents");
+      if (!agentsStore) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Agents storage domain is not available" });
+      }
+      const agent = await agentsStore.getAgentById({ id: agentId });
+      if (!agent) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Agent with id ${agentId} not found` });
+      }
+      const version = await agentsStore.getVersion(versionId);
+      if (!version) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Version with id ${versionId} not found` });
+      }
+      if (version.agentId !== agentId) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Version with id ${versionId} not found for agent ${agentId}` });
+      }
+      if (agent.activeVersionId === versionId) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, {
+          message: "Cannot delete the active version. Activate a different version first."
+        });
+      }
+      await agentsStore.deleteVersion(versionId);
+      return {
+        success: true,
+        message: `Version ${version.versionNumber} deleted successfully`
+      };
+    } catch (error) {
+      return chunkSUKFO7UM_cjs.handleError(error, "Error deleting agent version");
+    }
+  }
+});
+var COMPARE_AGENT_VERSIONS_ROUTE = chunk4LVJBXI2_cjs.createRoute({
+  method: "GET",
+  path: "/stored/agents/:agentId/versions/compare",
+  responseType: "json",
+  pathParamSchema: agentVersionPathParams,
+  queryParamSchema: compareVersionsQuerySchema,
+  responseSchema: compareVersionsResponseSchema,
+  summary: "Compare agent versions",
+  description: "Compares two versions and returns the differences between them",
+  tags: ["Agent Versions"],
+  handler: async ({ mastra, agentId, from, to }) => {
+    try {
+      const storage = mastra.getStorage();
+      if (!storage) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Storage is not configured" });
+      }
+      const agentsStore = await storage.getStore("agents");
+      if (!agentsStore) {
+        throw new chunk64ITUOXI_cjs.HTTPException(500, { message: "Agents storage domain is not available" });
+      }
+      const fromVersion = await agentsStore.getVersion(from);
+      if (!fromVersion) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Version with id ${from} not found` });
+      }
+      if (fromVersion.agentId !== agentId) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Version with id ${from} not found for agent ${agentId}` });
+      }
+      const toVersion = await agentsStore.getVersion(to);
+      if (!toVersion) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Version with id ${to} not found` });
+      }
+      if (toVersion.agentId !== agentId) {
+        throw new chunk64ITUOXI_cjs.HTTPException(404, { message: `Version with id ${to} not found for agent ${agentId}` });
+      }
+      const diffs = computeVersionDiffs(
+        fromVersion.snapshot,
+        toVersion.snapshot
+      );
+      return {
+        diffs,
+        fromVersion,
+        toVersion
+      };
+    } catch (error) {
+      return chunkSUKFO7UM_cjs.handleError(error, "Error comparing agent versions");
+    }
+  }
+});
+
+exports.ACTIVATE_AGENT_VERSION_ROUTE = ACTIVATE_AGENT_VERSION_ROUTE;
+exports.COMPARE_AGENT_VERSIONS_ROUTE = COMPARE_AGENT_VERSIONS_ROUTE;
+exports.CREATE_AGENT_VERSION_ROUTE = CREATE_AGENT_VERSION_ROUTE;
+exports.DEFAULT_MAX_VERSIONS_PER_AGENT = DEFAULT_MAX_VERSIONS_PER_AGENT;
+exports.DELETE_AGENT_VERSION_ROUTE = DELETE_AGENT_VERSION_ROUTE;
+exports.GET_AGENT_VERSION_ROUTE = GET_AGENT_VERSION_ROUTE;
+exports.LIST_AGENT_VERSIONS_ROUTE = LIST_AGENT_VERSIONS_ROUTE;
+exports.RESTORE_AGENT_VERSION_ROUTE = RESTORE_AGENT_VERSION_ROUTE;
+exports.calculateChangedFields = calculateChangedFields;
+exports.createStoredAgentBodySchema = createStoredAgentBodySchema;
+exports.createStoredAgentResponseSchema = createStoredAgentResponseSchema;
+exports.createVersionWithRetry = createVersionWithRetry;
+exports.deleteStoredAgentResponseSchema = deleteStoredAgentResponseSchema;
+exports.enforceRetentionLimit = enforceRetentionLimit;
+exports.generateVersionId = generateVersionId;
+exports.getStoredAgentResponseSchema = getStoredAgentResponseSchema;
+exports.handleAutoVersioning = handleAutoVersioning;
+exports.listStoredAgentsQuerySchema = listStoredAgentsQuerySchema;
+exports.listStoredAgentsResponseSchema = listStoredAgentsResponseSchema;
+exports.storedAgentIdPathParams = storedAgentIdPathParams;
+exports.updateStoredAgentBodySchema = updateStoredAgentBodySchema;
+exports.updateStoredAgentResponseSchema = updateStoredAgentResponseSchema;
+//# sourceMappingURL=chunk-TGDBGIDA.cjs.map
+//# sourceMappingURL=chunk-TGDBGIDA.cjs.map