@mastra/server 0.0.0-span-scorring-test-20251124132129 → 0.0.0-standard-schema-20260123120255

package/dist/chunk-JJLEVKG7.js

@@ -0,0 +1,576 @@
+import { createPagePaginationSchema, paginationInfoSchema } from './chunk-HT4LP3BO.js';
+import { handleError } from './chunk-7AINN3FK.js';
+import { HTTPException } from './chunk-6QWQZI4Q.js';
+import { createRoute } from './chunk-D23WBCJ6.js';
+import { deepEqual } from '@mastra/core/utils';
+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(),
+  ownerId: z.string().optional().describe("Filter agents by owner 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 storedAgentBaseSchema = 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.string().optional().describe("Memory key to resolve from Mastra registry"),
+  scorers: z.record(z.string(), scorerConfigSchema).optional().describe("Scorer keys with optional sampling config"),
+  metadata: z.record(z.string(), z.unknown()).optional().describe("Additional metadata for the agent"),
+  ownerId: z.string().optional().describe("Owner identifier for multi-tenant filtering")
+});
+var createStoredAgentBodySchema = storedAgentBaseSchema.extend({
+  id: z.string().describe("Unique identifier for the agent")
+});
+var updateStoredAgentBodySchema = storedAgentBaseSchema.partial();
+var storedAgentSchema = storedAgentBaseSchema.extend({
+  id: z.string(),
+  ownerId: z.string().optional(),
+  createdAt: z.date(),
+  updatedAt: z.date()
+});
+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({
+  name: z.string().max(100).optional().describe("Optional vanity name for this version"),
+  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, ...)"),
+  name: z.string().optional().describe("Optional vanity name for this version"),
+  snapshot: storedAgentSchema.describe("Full agent configuration snapshot"),
+  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 snapshot"
+);
+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;
+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 = 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, name, 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` });
+      }
+      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 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 snapshot, 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 {
+        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 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 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 diffs = computeVersionDiffs(
+        fromVersion.snapshot,
+        toVersion.snapshot
+      );
+      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-JJLEVKG7.js.map
+//# sourceMappingURL=chunk-JJLEVKG7.js.map