import { createPagePaginationSchema, paginationInfoSchema } from './chunk-HT4LP3BO.js';
import { handleError } from './chunk-ONN5EA7E.js';
import { createRoute } from './chunk-OQ5GQJAS.js';
import { HTTPException } from './chunk-6QWQZI4Q.js';
import z from 'zod';

var storedAgentIdPathParams = z.object({
  storedAgentId: z.string().describe("Unique identifier for the stored agent")
});
var storageOrderBySchema = z.object({
  field: z.enum(["createdAt", "updatedAt"]).optional(),
  direction: z.enum(["ASC", "DESC"]).optional()
});
var listStoredAgentsQuerySchema = createPagePaginationSchema(100).extend({
  orderBy: storageOrderBySchema.optional(),
  authorId: z.string().optional().describe("Filter agents by author identifier"),
  metadata: z.record(z.string(), z.unknown()).optional().describe("Filter agents by metadata key-value pairs")
});
var scorerConfigSchema = z.object({
  sampling: z.object({
    type: z.enum(["ratio", "count"]),
    rate: z.number().optional(),
    count: z.number().optional()
  }).optional()
});
var snapshotConfigSchema = z.object({
  name: z.string().describe("Name of the agent"),
  description: z.string().optional().describe("Description of the agent"),
  instructions: z.string().describe("System instructions for the agent"),
  model: z.record(z.string(), z.unknown()).describe("Model configuration (provider, name, etc.)"),
  tools: z.array(z.string()).optional().describe("Array of tool keys to resolve from Mastra registry"),
  defaultOptions: z.record(z.string(), z.unknown()).optional().describe("Default options for generate/stream calls"),
  workflows: z.array(z.string()).optional().describe("Array of workflow keys to resolve from Mastra registry"),
  agents: z.array(z.string()).optional().describe("Array of agent keys to resolve from Mastra registry"),
  integrationTools: z.array(z.string()).optional().describe("Array of specific integration tool IDs (format: provider_toolkitSlug_toolSlug)"),
  inputProcessors: z.array(z.record(z.string(), z.unknown())).optional().describe("Input processor configurations"),
  outputProcessors: z.array(z.record(z.string(), z.unknown())).optional().describe("Output processor configurations"),
  memory: z.record(z.string(), z.unknown()).optional().describe("Memory configuration object"),
  scorers: z.record(z.string(), scorerConfigSchema).optional().describe("Scorer keys with optional sampling config")
});
var agentMetadataSchema = z.object({
  authorId: z.string().optional().describe("Author identifier for multi-tenant filtering"),
  metadata: z.record(z.string(), z.unknown()).optional().describe("Additional metadata for the agent")
});
var createStoredAgentBodySchema = z.object({
  id: z.string().describe("Unique identifier for the agent"),
  authorId: z.string().optional().describe("Author identifier for multi-tenant filtering"),
  metadata: z.record(z.string(), z.unknown()).optional().describe("Additional metadata for the agent")
}).merge(snapshotConfigSchema);
var updateStoredAgentBodySchema = agentMetadataSchema.partial().merge(snapshotConfigSchema.partial());
var storedAgentSchema = z.object({
  // Thin agent record fields
  id: z.string(),
  status: z.string().describe("Agent status: draft or published"),
  activeVersionId: z.string().optional(),
  authorId: z.string().optional(),
  metadata: z.record(z.string(), z.unknown()).optional(),
  createdAt: z.date(),
  updatedAt: z.date(),
  // Version snapshot config fields (resolved from active version)
  name: z.string().describe("Name of the agent"),
  description: z.string().optional().describe("Description of the agent"),
  instructions: z.string().describe("System instructions for the agent"),
  model: z.record(z.string(), z.unknown()).describe("Model configuration (provider, name, etc.)"),
  tools: z.array(z.string()).optional().describe("Array of tool keys to resolve from Mastra registry"),
  defaultOptions: z.record(z.string(), z.unknown()).optional().describe("Default options for generate/stream calls"),
  workflows: z.array(z.string()).optional().describe("Array of workflow keys to resolve from Mastra registry"),
  agents: z.array(z.string()).optional().describe("Array of agent keys to resolve from Mastra registry"),
  integrationTools: z.array(z.string()).optional().describe("Array of specific integration tool IDs (format: provider_toolkitSlug_toolSlug)"),
  inputProcessors: z.array(z.record(z.string(), z.unknown())).optional().describe("Input processor configurations"),
  outputProcessors: z.array(z.record(z.string(), z.unknown())).optional().describe("Output processor configurations"),
  memory: z.record(z.string(), z.unknown()).optional().describe("Memory configuration object"),
  scorers: z.record(z.string(), scorerConfigSchema).optional().describe("Scorer keys with optional sampling config")
});
var listStoredAgentsResponseSchema = paginationInfoSchema.extend({
  agents: z.array(storedAgentSchema)
});
var getStoredAgentResponseSchema = storedAgentSchema;
var createStoredAgentResponseSchema = storedAgentSchema;
var updateStoredAgentResponseSchema = storedAgentSchema;
var deleteStoredAgentResponseSchema = z.object({
  success: z.boolean(),
  message: z.string()
});

// src/server/schemas/agent-versions.ts
var agentVersionPathParams = z.object({
  agentId: z.string().describe("Unique identifier for the stored agent")
});
var versionIdPathParams = z.object({
  agentId: z.string().describe("Unique identifier for the stored agent"),
  versionId: z.string().describe("Unique identifier for the version (UUID)")
});
var versionOrderBySchema = z.object({
  field: z.enum(["versionNumber", "createdAt"]).optional(),
  direction: z.enum(["ASC", "DESC"]).optional()
});
var listVersionsQuerySchema = createPagePaginationSchema(20).extend({
  orderBy: versionOrderBySchema.optional()
});
var compareVersionsQuerySchema = z.object({
  from: z.string().describe("Version ID (UUID) to compare from"),
  to: z.string().describe("Version ID (UUID) to compare to")
});
var createVersionBodySchema = z.object({
  changeMessage: z.string().max(500).optional().describe("Optional message describing the changes")
});
var agentVersionSchema = z.object({
  id: z.string().describe("Unique identifier for the version (UUID)"),
  agentId: z.string().describe("ID of the agent this version belongs to"),
  versionNumber: z.number().describe("Sequential version number (1, 2, 3, ...)"),
  // Top-level config fields (from StorageAgentSnapshotType)
  name: z.string().describe("Name of the agent"),
  description: z.string().optional().describe("Description of the agent"),
  instructions: z.string().describe("System instructions for the agent"),
  model: z.record(z.string(), z.unknown()).describe("Model configuration (provider, name, etc.)"),
  tools: z.array(z.string()).optional().describe("Array of tool keys to resolve from Mastra registry"),
  defaultOptions: z.record(z.string(), z.unknown()).optional().describe("Default options for generate/stream calls"),
  workflows: z.array(z.string()).optional().describe("Array of workflow keys to resolve from Mastra registry"),
  agents: z.array(z.string()).optional().describe("Array of agent keys to resolve from Mastra registry"),
  integrationTools: z.array(z.string()).optional().describe("Array of specific integration tool IDs (format: provider_toolkitSlug_toolSlug)"),
  inputProcessors: z.array(z.record(z.string(), z.unknown())).optional().describe("Input processor configurations"),
  outputProcessors: z.array(z.record(z.string(), z.unknown())).optional().describe("Output processor configurations"),
  memory: z.record(z.string(), z.unknown()).optional().describe("Memory configuration object"),
  scorers: z.record(z.string(), scorerConfigSchema).optional().describe("Scorer keys with optional sampling config"),
  // Version metadata fields
  changedFields: z.array(z.string()).optional().describe("Array of field names that changed from the previous version"),
  changeMessage: z.string().optional().describe("Optional message describing the changes"),
  createdAt: z.date().describe("When this version was created")
});
var listVersionsResponseSchema = paginationInfoSchema.extend({
  versions: z.array(agentVersionSchema)
});
var getVersionResponseSchema = agentVersionSchema;
var createVersionResponseSchema = agentVersionSchema;
var activateVersionResponseSchema = z.object({
  success: z.boolean(),
  message: z.string(),
  activeVersionId: z.string()
});
var restoreVersionResponseSchema = agentVersionSchema.describe(
  "The newly created version from the restored configuration"
);
var deleteVersionResponseSchema = z.object({
  success: z.boolean(),
  message: z.string()
});
var versionDiffEntrySchema = z.object({
  field: z.string().describe("The field path that changed"),
  previousValue: z.unknown().describe('The value in the "from" version'),
  currentValue: z.unknown().describe('The value in the "to" version')
});
var compareVersionsResponseSchema = z.object({
  diffs: z.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;
var SNAPSHOT_CONFIG_FIELDS = [
  "name",
  "description",
  "instructions",
  "model",
  "tools",
  "defaultOptions",
  "workflows",
  "agents",
  "integrationTools",
  "inputProcessors",
  "outputProcessors",
  "memory",
  "scorers"
];
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 extractConfigFromVersion(version) {
  const config = {};
  for (const field of SNAPSHOT_CONFIG_FIELDS) {
    if (field in version) {
      config[field] = version[field];
    }
  }
  return config;
}
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(fromConfig, toConfig) {
  const diffs = [];
  const allKeys = /* @__PURE__ */ new Set([...Object.keys(fromConfig), ...Object.keys(toConfig)]);
  for (const key of allKeys) {
    if (key === "updatedAt" || key === "createdAt") {
      continue;
    }
    const prevValue = fromConfig[key];
    const currValue = toConfig[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, snapshotConfig, changedFields, options = {}) {
  const { 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({
        ...snapshotConfig,
        id: versionId,
        agentId,
        versionNumber,
        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, configFields) {
  if (!configFields || Object.keys(configFields).length === 0) {
    return { agent: updatedAgent, versionCreated: false };
  }
  const latestVersion = await agentsStore.getLatestVersion(agentId);
  const previousConfig = latestVersion ? extractConfigFromVersion(latestVersion) : null;
  const changedFields = calculateChangedFields(previousConfig, configFields);
  if (changedFields.length === 0) {
    return { agent: updatedAgent, versionCreated: false };
  }
  const fullConfig = previousConfig ? { ...previousConfig } : {};
  for (const [key, value] of Object.entries(configFields)) {
    fullConfig[key] = value;
  }
  const { versionId } = await createVersionWithRetry(agentsStore, agentId, fullConfig, 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 = 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 HTTPException(500, { message: "Storage is not configured" });
      }
      const agentsStore = await storage.getStore("agents");
      if (!agentsStore) {
        throw new HTTPException(500, { message: "Agents storage domain is not available" });
      }
      const agent = await agentsStore.getAgentById({ id: agentId });
      if (!agent) {
        throw new HTTPException(404, { message: `Agent with id ${agentId} not found` });
      }
      const result = await agentsStore.listVersions({
        agentId,
        page,
        perPage,
        orderBy
      });
      return result;
    } catch (error) {
      return handleError(error, "Error listing agent versions");
    }
  }
});
var CREATE_AGENT_VERSION_ROUTE = 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, changeMessage }) => {
    try {
      const storage = mastra.getStorage();
      if (!storage) {
        throw new HTTPException(500, { message: "Storage is not configured" });
      }
      const agentsStore = await storage.getStore("agents");
      if (!agentsStore) {
        throw new HTTPException(500, { message: "Agents storage domain is not available" });
      }
      const agent = await agentsStore.getAgentById({ id: agentId });
      if (!agent) {
        throw new HTTPException(404, { message: `Agent with id ${agentId} not found` });
      }
      let currentConfig = {};
      if (agent.activeVersionId) {
        const activeVersion = await agentsStore.getVersion(agent.activeVersionId);
        if (activeVersion) {
          currentConfig = extractConfigFromVersion(activeVersion);
        }
      }
      const latestVersion = await agentsStore.getLatestVersion(agentId);
      const previousConfig = latestVersion ? extractConfigFromVersion(latestVersion) : null;
      const changedFields = calculateChangedFields(previousConfig, currentConfig);
      const { versionId } = await createVersionWithRetry(
        agentsStore,
        agentId,
        currentConfig,
        changedFields.length > 0 ? changedFields : [],
        { changeMessage }
      );
      const version = await agentsStore.getVersion(versionId);
      if (!version) {
        throw new HTTPException(500, { message: "Failed to retrieve created version" });
      }
      await enforceRetentionLimit(agentsStore, agentId, agent.activeVersionId);
      return version;
    } catch (error) {
      return handleError(error, "Error creating agent version");
    }
  }
});
var GET_AGENT_VERSION_ROUTE = 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 HTTPException(500, { message: "Storage is not configured" });
      }
      const agentsStore = await storage.getStore("agents");
      if (!agentsStore) {
        throw new HTTPException(500, { message: "Agents storage domain is not available" });
      }
      const version = await agentsStore.getVersion(versionId);
      if (!version) {
        throw new HTTPException(404, { message: `Version with id ${versionId} not found` });
      }
      if (version.agentId !== agentId) {
        throw new HTTPException(404, { message: `Version with id ${versionId} not found for agent ${agentId}` });
      }
      return version;
    } catch (error) {
      return handleError(error, "Error getting agent version");
    }
  }
});
var ACTIVATE_AGENT_VERSION_ROUTE = 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 HTTPException(500, { message: "Storage is not configured" });
      }
      const agentsStore = await storage.getStore("agents");
      if (!agentsStore) {
        throw new HTTPException(500, { message: "Agents storage domain is not available" });
      }
      const agent = await agentsStore.getAgentById({ id: agentId });
      if (!agent) {
        throw new HTTPException(404, { message: `Agent with id ${agentId} not found` });
      }
      const version = await agentsStore.getVersion(versionId);
      if (!version) {
        throw new HTTPException(404, { message: `Version with id ${versionId} not found` });
      }
      if (version.agentId !== agentId) {
        throw new 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 handleError(error, "Error activating agent version");
    }
  }
});
var RESTORE_AGENT_VERSION_ROUTE = 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, creating a new version",
  tags: ["Agent Versions"],
  handler: async ({ mastra, agentId, versionId }) => {
    try {
      const storage = mastra.getStorage();
      if (!storage) {
        throw new HTTPException(500, { message: "Storage is not configured" });
      }
      const agentsStore = await storage.getStore("agents");
      if (!agentsStore) {
        throw new HTTPException(500, { message: "Agents storage domain is not available" });
      }
      const agent = await agentsStore.getAgentById({ id: agentId });
      if (!agent) {
        throw new HTTPException(404, { message: `Agent with id ${agentId} not found` });
      }
      const versionToRestore = await agentsStore.getVersion(versionId);
      if (!versionToRestore) {
        throw new HTTPException(404, { message: `Version with id ${versionId} not found` });
      }
      if (versionToRestore.agentId !== agentId) {
        throw new HTTPException(404, { message: `Version with id ${versionId} not found for agent ${agentId}` });
      }
      const restoredConfig = extractConfigFromVersion(versionToRestore);
      await agentsStore.updateAgent({
        id: agentId,
        ...restoredConfig
      });
      const latestVersion = await agentsStore.getLatestVersion(agentId);
      const previousConfig = latestVersion ? extractConfigFromVersion(latestVersion) : null;
      const changedFields = calculateChangedFields(previousConfig, restoredConfig);
      const { versionId: newVersionId } = await createVersionWithRetry(
        agentsStore,
        agentId,
        restoredConfig,
        changedFields,
        {
          changeMessage: `Restored from version ${versionToRestore.versionNumber}`
        }
      );
      await agentsStore.updateAgent({
        id: agentId,
        activeVersionId: newVersionId
      });
      const newVersion = await agentsStore.getVersion(newVersionId);
      if (!newVersion) {
        throw new HTTPException(500, { message: "Failed to retrieve created version" });
      }
      await enforceRetentionLimit(agentsStore, agentId, newVersionId);
      return newVersion;
    } catch (error) {
      return handleError(error, "Error restoring agent version");
    }
  }
});
var DELETE_AGENT_VERSION_ROUTE = 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 HTTPException(500, { message: "Storage is not configured" });
      }
      const agentsStore = await storage.getStore("agents");
      if (!agentsStore) {
        throw new HTTPException(500, { message: "Agents storage domain is not available" });
      }
      const agent = await agentsStore.getAgentById({ id: agentId });
      if (!agent) {
        throw new HTTPException(404, { message: `Agent with id ${agentId} not found` });
      }
      const version = await agentsStore.getVersion(versionId);
      if (!version) {
        throw new HTTPException(404, { message: `Version with id ${versionId} not found` });
      }
      if (version.agentId !== agentId) {
        throw new HTTPException(404, { message: `Version with id ${versionId} not found for agent ${agentId}` });
      }
      if (agent.activeVersionId === versionId) {
        throw new 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 handleError(error, "Error deleting agent version");
    }
  }
});
var COMPARE_AGENT_VERSIONS_ROUTE = 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 HTTPException(500, { message: "Storage is not configured" });
      }
      const agentsStore = await storage.getStore("agents");
      if (!agentsStore) {
        throw new HTTPException(500, { message: "Agents storage domain is not available" });
      }
      const fromVersion = await agentsStore.getVersion(from);
      if (!fromVersion) {
        throw new HTTPException(404, { message: `Version with id ${from} not found` });
      }
      if (fromVersion.agentId !== agentId) {
        throw new HTTPException(404, { message: `Version with id ${from} not found for agent ${agentId}` });
      }
      const toVersion = await agentsStore.getVersion(to);
      if (!toVersion) {
        throw new HTTPException(404, { message: `Version with id ${to} not found` });
      }
      if (toVersion.agentId !== agentId) {
        throw new HTTPException(404, { message: `Version with id ${to} not found for agent ${agentId}` });
      }
      const fromConfig = extractConfigFromVersion(fromVersion);
      const toConfig = extractConfigFromVersion(toVersion);
      const diffs = computeVersionDiffs(fromConfig, toConfig);
      return {
        diffs,
        fromVersion,
        toVersion
      };
    } catch (error) {
      return handleError(error, "Error comparing agent versions");
    }
  }
});

export { ACTIVATE_AGENT_VERSION_ROUTE, COMPARE_AGENT_VERSIONS_ROUTE, CREATE_AGENT_VERSION_ROUTE, DEFAULT_MAX_VERSIONS_PER_AGENT, DELETE_AGENT_VERSION_ROUTE, GET_AGENT_VERSION_ROUTE, LIST_AGENT_VERSIONS_ROUTE, RESTORE_AGENT_VERSION_ROUTE, calculateChangedFields, createStoredAgentBodySchema, createStoredAgentResponseSchema, createVersionWithRetry, deleteStoredAgentResponseSchema, enforceRetentionLimit, generateVersionId, getStoredAgentResponseSchema, handleAutoVersioning, listStoredAgentsQuerySchema, listStoredAgentsResponseSchema, storedAgentIdPathParams, updateStoredAgentBodySchema, updateStoredAgentResponseSchema };
//# sourceMappingURL=chunk-SYLEQ6LR.js.map
//# sourceMappingURL=chunk-SYLEQ6LR.js.map