@mastra/server 1.0.0-beta.1 → 1.0.0-beta.10

package/dist/chunk-Q6SVIZLX.js

@@ -0,0 +1,786 @@
+import { sanitizeBody, validateBody } from './chunk-XWGAT2DA.js';
+import { listAgentsResponseSchema, serializedAgentSchema, agentIdPathParams, generateResponseSchema, agentExecutionBodySchema, streamResponseSchema, providersResponseSchema, toolCallResponseSchema, approveToolCallBodySchema, declineToolCallBodySchema, modelManagementResponseSchema, updateAgentModelBodySchema, reorderAgentModelListBodySchema, updateAgentModelInModelListBodySchema, modelConfigIdPathParams } from './chunk-WE4USCF3.js';
+import { stringify } from './chunk-LF2ZLOFP.js';
+import { createRoute } from './chunk-SXVANU23.js';
+import { handleError } from './chunk-UXGQZUYZ.js';
+import { HTTPException } from './chunk-6QWQZI4Q.js';
+import { __export } from './chunk-PR4QN5HX.js';
+import { MastraError, ErrorDomain, ErrorCategory } from '@mastra/core/error';
+import { PROVIDER_REGISTRY } from '@mastra/core/llm';
+import { zodToJsonSchema } from '@mastra/core/utils/zod-to-json';
+import { z } from 'zod';
+
+// src/server/handlers/agents.ts
+var agents_exports = {};
+__export(agents_exports, {
+  APPROVE_TOOL_CALL_ROUTE: () => APPROVE_TOOL_CALL_ROUTE,
+  DECLINE_TOOL_CALL_ROUTE: () => DECLINE_TOOL_CALL_ROUTE,
+  GENERATE_AGENT_ROUTE: () => GENERATE_AGENT_ROUTE,
+  GENERATE_AGENT_VNEXT_ROUTE: () => GENERATE_AGENT_VNEXT_ROUTE,
+  GENERATE_LEGACY_ROUTE: () => GENERATE_LEGACY_ROUTE,
+  GET_AGENT_BY_ID_ROUTE: () => GET_AGENT_BY_ID_ROUTE,
+  GET_PROVIDERS_ROUTE: () => GET_PROVIDERS_ROUTE,
+  LIST_AGENTS_ROUTE: () => LIST_AGENTS_ROUTE,
+  REORDER_AGENT_MODEL_LIST_ROUTE: () => REORDER_AGENT_MODEL_LIST_ROUTE,
+  RESET_AGENT_MODEL_ROUTE: () => RESET_AGENT_MODEL_ROUTE,
+  STREAM_GENERATE_LEGACY_ROUTE: () => STREAM_GENERATE_LEGACY_ROUTE,
+  STREAM_GENERATE_ROUTE: () => STREAM_GENERATE_ROUTE,
+  STREAM_GENERATE_VNEXT_DEPRECATED_ROUTE: () => STREAM_GENERATE_VNEXT_DEPRECATED_ROUTE,
+  STREAM_NETWORK_ROUTE: () => STREAM_NETWORK_ROUTE,
+  STREAM_UI_MESSAGE_DEPRECATED_ROUTE: () => STREAM_UI_MESSAGE_DEPRECATED_ROUTE,
+  STREAM_UI_MESSAGE_VNEXT_DEPRECATED_ROUTE: () => STREAM_UI_MESSAGE_VNEXT_DEPRECATED_ROUTE,
+  STREAM_VNEXT_DEPRECATED_ROUTE: () => STREAM_VNEXT_DEPRECATED_ROUTE,
+  UPDATE_AGENT_MODEL_IN_MODEL_LIST_ROUTE: () => UPDATE_AGENT_MODEL_IN_MODEL_LIST_ROUTE,
+  UPDATE_AGENT_MODEL_ROUTE: () => UPDATE_AGENT_MODEL_ROUTE,
+  getAgentFromSystem: () => getAgentFromSystem,
+  getSerializedAgentTools: () => getSerializedAgentTools,
+  getSerializedProcessors: () => getSerializedProcessors
+});
+async function getSerializedAgentTools(tools, partial = false) {
+  return Object.entries(tools || {}).reduce((acc, [key, tool]) => {
+    const toolId = tool.id ?? `tool-${key}`;
+    let inputSchemaForReturn = void 0;
+    let outputSchemaForReturn = void 0;
+    if (!partial) {
+      try {
+        if (tool.inputSchema) {
+          if (tool.inputSchema && typeof tool.inputSchema === "object" && "jsonSchema" in tool.inputSchema) {
+            inputSchemaForReturn = stringify(tool.inputSchema.jsonSchema);
+          } else if (typeof tool.inputSchema === "function") {
+            const inputSchema = tool.inputSchema();
+            if (inputSchema && inputSchema.jsonSchema) {
+              inputSchemaForReturn = stringify(inputSchema.jsonSchema);
+            }
+          } else if (tool.inputSchema) {
+            inputSchemaForReturn = stringify(
+              zodToJsonSchema(tool.inputSchema)
+            );
+          }
+        }
+        if (tool.outputSchema) {
+          if (tool.outputSchema && typeof tool.outputSchema === "object" && "jsonSchema" in tool.outputSchema) {
+            outputSchemaForReturn = stringify(tool.outputSchema.jsonSchema);
+          } else if (typeof tool.outputSchema === "function") {
+            const outputSchema = tool.outputSchema();
+            if (outputSchema && outputSchema.jsonSchema) {
+              outputSchemaForReturn = stringify(outputSchema.jsonSchema);
+            }
+          } else if (tool.outputSchema) {
+            outputSchemaForReturn = stringify(
+              zodToJsonSchema(tool.outputSchema)
+            );
+          }
+        }
+      } catch (error) {
+        console.error(`Error getting serialized tool`, {
+          toolId: tool.id,
+          error
+        });
+      }
+    }
+    acc[key] = {
+      ...tool,
+      id: toolId,
+      inputSchema: inputSchemaForReturn,
+      outputSchema: outputSchemaForReturn
+    };
+    return acc;
+  }, {});
+}
+function getSerializedProcessors(processors) {
+  return processors.map((processor) => {
+    return {
+      id: processor.id,
+      name: processor.name || processor.constructor.name
+    };
+  });
+}
+async function getSerializedAgentDefinition({
+  agent,
+  requestContext
+}) {
+  let serializedAgentAgents = {};
+  if ("listAgents" in agent) {
+    const agents = await agent.listAgents({ requestContext });
+    serializedAgentAgents = Object.entries(agents || {}).reduce(
+      (acc, [key, agent2]) => {
+        return {
+          ...acc,
+          [key]: { id: agent2.id, name: agent2.name }
+        };
+      },
+      {}
+    );
+  }
+  return serializedAgentAgents;
+}
+async function formatAgentList({
+  id,
+  mastra,
+  agent,
+  requestContext,
+  partial = false
+}) {
+  const description = agent.getDescription();
+  const instructions = await agent.getInstructions({ requestContext });
+  const tools = await agent.listTools({ requestContext });
+  const llm = await agent.getLLM({ requestContext });
+  const defaultGenerateOptionsLegacy = await agent.getDefaultGenerateOptionsLegacy({ requestContext });
+  const defaultStreamOptionsLegacy = await agent.getDefaultStreamOptionsLegacy({ requestContext });
+  const defaultOptions = await agent.getDefaultOptions({ requestContext });
+  const serializedAgentTools = await getSerializedAgentTools(tools, partial);
+  let serializedAgentWorkflows = {};
+  if ("listWorkflows" in agent) {
+    const logger = mastra.getLogger();
+    try {
+      const workflows = await agent.listWorkflows({ requestContext });
+      serializedAgentWorkflows = Object.entries(workflows || {}).reduce((acc, [key, workflow]) => {
+        return {
+          ...acc,
+          [key]: {
+            name: workflow.name || "Unnamed workflow"
+          }
+        };
+      }, {});
+    } catch (error) {
+      logger.error("Error getting workflows for agent", { agentName: agent.name, error });
+    }
+  }
+  const serializedAgentAgents = await getSerializedAgentDefinition({ agent, requestContext });
+  const inputProcessors = await agent.listInputProcessors(requestContext);
+  const outputProcessors = await agent.listOutputProcessors(requestContext);
+  const serializedInputProcessors = getSerializedProcessors(inputProcessors);
+  const serializedOutputProcessors = getSerializedProcessors(outputProcessors);
+  const model = llm?.getModel();
+  const models = await agent.getModelList(requestContext);
+  const modelList = models?.map((md) => ({
+    ...md,
+    model: {
+      modelId: md.model.modelId,
+      provider: md.model.provider,
+      modelVersion: md.model.specificationVersion
+    }
+  }));
+  return {
+    id: agent.id || id,
+    name: agent.name,
+    description,
+    instructions,
+    agents: serializedAgentAgents,
+    tools: serializedAgentTools,
+    workflows: serializedAgentWorkflows,
+    inputProcessors: serializedInputProcessors,
+    outputProcessors: serializedOutputProcessors,
+    provider: llm?.getProvider(),
+    modelId: llm?.getModelId(),
+    modelVersion: model?.specificationVersion,
+    defaultOptions,
+    modelList,
+    defaultGenerateOptionsLegacy,
+    defaultStreamOptionsLegacy
+  };
+}
+async function getAgentFromSystem({ mastra, agentId }) {
+  const logger = mastra.getLogger();
+  if (!agentId) {
+    throw new HTTPException(400, { message: "Agent ID is required" });
+  }
+  let agent;
+  try {
+    agent = mastra.getAgentById(agentId);
+  } catch (error) {
+    logger.debug("Error getting agent from mastra, searching agents for agent", error);
+  }
+  if (!agent) {
+    logger.debug(`Agent ${agentId} not found, looking through sub-agents`);
+    const agents = mastra.listAgents();
+    if (Object.keys(agents || {}).length) {
+      for (const [_, ag] of Object.entries(agents)) {
+        try {
+          const subAgents = await ag.listAgents();
+          if (subAgents[agentId]) {
+            agent = subAgents[agentId];
+            break;
+          }
+        } catch (error) {
+          logger.debug("Error getting agent from agent", error);
+        }
+      }
+    }
+  }
+  if (!agent) {
+    throw new HTTPException(404, { message: `Agent with id ${agentId} not found` });
+  }
+  return agent;
+}
+async function formatAgent({
+  mastra,
+  agent,
+  requestContext,
+  isStudio
+}) {
+  const description = agent.getDescription();
+  const tools = await agent.listTools({ requestContext });
+  const serializedAgentTools = await getSerializedAgentTools(tools);
+  let serializedAgentWorkflows = {};
+  if ("listWorkflows" in agent) {
+    const logger = mastra.getLogger();
+    try {
+      const workflows = await agent.listWorkflows({ requestContext });
+      serializedAgentWorkflows = Object.entries(workflows || {}).reduce((acc, [key, workflow]) => {
+        return {
+          ...acc,
+          [key]: {
+            name: workflow.name || "Unnamed workflow",
+            steps: Object.entries(workflow.steps).reduce(
+              (acc2, [key2, step]) => {
+                return {
+                  ...acc2,
+                  [key2]: {
+                    id: step.id,
+                    description: step.description
+                  }
+                };
+              },
+              {}
+            )
+          }
+        };
+      }, {});
+    } catch (error) {
+      logger.error("Error getting workflows for agent", { agentName: agent.name, error });
+    }
+  }
+  let proxyRequestContext = requestContext;
+  const instructions = await agent.getInstructions({ requestContext: proxyRequestContext });
+  const llm = await agent.getLLM({ requestContext });
+  const defaultGenerateOptionsLegacy = await agent.getDefaultGenerateOptionsLegacy({
+    requestContext: proxyRequestContext
+  });
+  const defaultStreamOptionsLegacy = await agent.getDefaultStreamOptionsLegacy({ requestContext: proxyRequestContext });
+  const defaultOptions = await agent.getDefaultOptions({ requestContext: proxyRequestContext });
+  const model = llm?.getModel();
+  const models = await agent.getModelList(requestContext);
+  const modelList = models?.map((md) => ({
+    ...md,
+    model: {
+      modelId: md.model.modelId,
+      provider: md.model.provider,
+      modelVersion: md.model.specificationVersion
+    }
+  }));
+  const serializedAgentAgents = await getSerializedAgentDefinition({ agent, requestContext: proxyRequestContext });
+  const inputProcessors = await agent.listInputProcessors(proxyRequestContext);
+  const outputProcessors = await agent.listOutputProcessors(proxyRequestContext);
+  const serializedInputProcessors = getSerializedProcessors(inputProcessors);
+  const serializedOutputProcessors = getSerializedProcessors(outputProcessors);
+  return {
+    name: agent.name,
+    description,
+    instructions,
+    tools: serializedAgentTools,
+    agents: serializedAgentAgents,
+    workflows: serializedAgentWorkflows,
+    inputProcessors: serializedInputProcessors,
+    outputProcessors: serializedOutputProcessors,
+    provider: llm?.getProvider(),
+    modelId: llm?.getModelId(),
+    modelVersion: model?.specificationVersion,
+    modelList,
+    defaultOptions,
+    defaultGenerateOptionsLegacy,
+    defaultStreamOptionsLegacy
+  };
+}
+var LIST_AGENTS_ROUTE = createRoute({
+  method: "GET",
+  path: "/api/agents",
+  responseType: "json",
+  queryParamSchema: z.object({
+    partial: z.string().optional()
+  }),
+  responseSchema: listAgentsResponseSchema,
+  summary: "List all agents",
+  description: "Returns a list of all available agents in the system",
+  tags: ["Agents"],
+  handler: async ({ mastra, requestContext, partial }) => {
+    try {
+      const agents = mastra.listAgents();
+      const isPartial = partial === "true";
+      const serializedAgentsMap = await Promise.all(
+        Object.entries(agents).map(async ([id, agent]) => {
+          return formatAgentList({ id, mastra, agent, requestContext, partial: isPartial });
+        })
+      );
+      const serializedAgents = serializedAgentsMap.reduce(
+        (acc, { id, ...rest }) => {
+          acc[id] = { id, ...rest };
+          return acc;
+        },
+        {}
+      );
+      return serializedAgents;
+    } catch (error) {
+      return handleError(error, "Error getting agents");
+    }
+  }
+});
+var GET_AGENT_BY_ID_ROUTE = createRoute({
+  method: "GET",
+  path: "/api/agents/:agentId",
+  responseType: "json",
+  pathParamSchema: agentIdPathParams,
+  responseSchema: serializedAgentSchema,
+  summary: "Get agent by ID",
+  description: "Returns details for a specific agent including configuration, tools, and memory settings",
+  tags: ["Agents"],
+  handler: async ({ agentId, mastra, requestContext }) => {
+    try {
+      const agent = await getAgentFromSystem({ mastra, agentId });
+      const isStudio = false;
+      const result = await formatAgent({
+        mastra,
+        agent,
+        requestContext,
+        isStudio
+      });
+      return result;
+    } catch (error) {
+      return handleError(error, "Error getting agent");
+    }
+  }
+});
+var GENERATE_AGENT_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agents/:agentId/generate",
+  responseType: "json",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: agentExecutionBodySchema,
+  responseSchema: generateResponseSchema,
+  summary: "Generate agent response",
+  description: "Executes an agent with the provided messages and returns the complete response",
+  tags: ["Agents"],
+  handler: async ({ agentId, mastra, abortSignal, ...params }) => {
+    try {
+      const agent = await getAgentFromSystem({ mastra, agentId });
+      sanitizeBody(params, ["tools"]);
+      const { messages, ...rest } = params;
+      validateBody({ messages });
+      const result = await agent.generate(messages, {
+        ...rest,
+        abortSignal
+      });
+      return result;
+    } catch (error) {
+      return handleError(error, "Error generating from agent");
+    }
+  }
+});
+var GENERATE_LEGACY_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agents/:agentId/generate-legacy",
+  responseType: "json",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: agentExecutionBodySchema,
+  responseSchema: generateResponseSchema,
+  summary: "[DEPRECATED] Generate with legacy format",
+  description: "Legacy endpoint for generating agent responses. Use /api/agents/:agentId/generate instead.",
+  tags: ["Agents", "Legacy"],
+  handler: async ({ mastra, agentId, abortSignal, ...params }) => {
+    try {
+      const agent = await getAgentFromSystem({ mastra, agentId });
+      sanitizeBody(params, ["tools"]);
+      const { messages, resourceId, resourceid, threadId, ...rest } = params;
+      const finalResourceId = resourceId ?? resourceid;
+      validateBody({ messages });
+      if (threadId && !finalResourceId || !threadId && finalResourceId) {
+        throw new HTTPException(400, { message: "Both threadId or resourceId must be provided" });
+      }
+      const result = await agent.generateLegacy(messages, {
+        ...rest,
+        abortSignal,
+        resourceId: finalResourceId ?? "",
+        threadId: threadId ?? ""
+      });
+      return result;
+    } catch (error) {
+      return handleError(error, "Error generating from agent");
+    }
+  }
+});
+var STREAM_GENERATE_LEGACY_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agents/:agentId/stream-legacy",
+  responseType: "datastream-response",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: agentExecutionBodySchema,
+  responseSchema: streamResponseSchema,
+  summary: "[DEPRECATED] Stream with legacy format",
+  description: "Legacy endpoint for streaming agent responses. Use /api/agents/:agentId/stream instead.",
+  tags: ["Agents", "Legacy"],
+  handler: async ({ mastra, agentId, abortSignal, ...params }) => {
+    try {
+      const agent = await getAgentFromSystem({ mastra, agentId });
+      sanitizeBody(params, ["tools"]);
+      const { messages, resourceId, resourceid, threadId, ...rest } = params;
+      const finalResourceId = resourceId ?? resourceid;
+      validateBody({ messages });
+      if (threadId && !finalResourceId || !threadId && finalResourceId) {
+        throw new HTTPException(400, { message: "Both threadId or resourceId must be provided" });
+      }
+      const streamResult = await agent.streamLegacy(messages, {
+        ...rest,
+        abortSignal,
+        resourceId: finalResourceId ?? "",
+        threadId: threadId ?? ""
+      });
+      const streamResponse = rest.output ? streamResult.toTextStreamResponse({
+        headers: {
+          "Transfer-Encoding": "chunked"
+        }
+      }) : streamResult.toDataStreamResponse({
+        sendUsage: true,
+        sendReasoning: true,
+        getErrorMessage: (error) => {
+          return `An error occurred while processing your request. ${error instanceof Error ? error.message : JSON.stringify(error)}`;
+        },
+        headers: {
+          "Transfer-Encoding": "chunked"
+        }
+      });
+      return streamResponse;
+    } catch (error) {
+      return handleError(error, "error streaming agent response");
+    }
+  }
+});
+var GET_PROVIDERS_ROUTE = createRoute({
+  method: "GET",
+  path: "/api/agents/providers",
+  responseType: "json",
+  responseSchema: providersResponseSchema,
+  summary: "List AI providers",
+  description: "Returns a list of all configured AI model providers",
+  tags: ["Agents"],
+  handler: async () => {
+    try {
+      const providers = Object.entries(PROVIDER_REGISTRY).map(([id, provider]) => {
+        const envVars = Array.isArray(provider.apiKeyEnvVar) ? provider.apiKeyEnvVar : [provider.apiKeyEnvVar];
+        const connected = envVars.every((envVar) => !!process.env[envVar]);
+        return {
+          id,
+          name: provider.name,
+          label: provider.label || provider.name,
+          description: provider.description || "",
+          envVar: provider.apiKeyEnvVar,
+          connected,
+          docUrl: provider.docUrl,
+          models: [...provider.models]
+          // Convert readonly array to regular array
+        };
+      });
+      return { providers };
+    } catch (error) {
+      return handleError(error, "Error fetching providers");
+    }
+  }
+});
+var GENERATE_AGENT_VNEXT_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agents/:agentId/generate/vnext",
+  responseType: "json",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: agentExecutionBodySchema,
+  responseSchema: generateResponseSchema,
+  summary: "Generate a response from an agent",
+  description: "Generate a response from an agent",
+  tags: ["Agents"],
+  handler: GENERATE_AGENT_ROUTE.handler
+});
+var STREAM_GENERATE_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agents/:agentId/stream",
+  responseType: "stream",
+  streamFormat: "sse",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: agentExecutionBodySchema,
+  responseSchema: streamResponseSchema,
+  summary: "Stream agent response",
+  description: "Executes an agent with the provided messages and streams the response in real-time",
+  tags: ["Agents"],
+  handler: async ({ mastra, agentId, abortSignal, ...params }) => {
+    try {
+      const agent = await getAgentFromSystem({ mastra, agentId });
+      sanitizeBody(params, ["tools"]);
+      const { messages, ...rest } = params;
+      validateBody({ messages });
+      const streamResult = await agent.stream(messages, {
+        ...rest,
+        abortSignal
+      });
+      return streamResult.fullStream;
+    } catch (error) {
+      return handleError(error, "error streaming agent response");
+    }
+  }
+});
+var STREAM_GENERATE_VNEXT_DEPRECATED_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agents/:agentId/stream/vnext",
+  responseType: "stream",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: agentExecutionBodySchema,
+  responseSchema: streamResponseSchema,
+  summary: "Stream a response from an agent",
+  description: "[DEPRECATED] This endpoint is deprecated. Please use /stream instead.",
+  tags: ["Agents"],
+  deprecated: true,
+  handler: STREAM_GENERATE_ROUTE.handler
+});
+var APPROVE_TOOL_CALL_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agents/:agentId/approve-tool-call",
+  responseType: "stream",
+  streamFormat: "sse",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: approveToolCallBodySchema,
+  responseSchema: toolCallResponseSchema,
+  summary: "Approve tool call",
+  description: "Approves a pending tool call and continues agent execution",
+  tags: ["Agents", "Tools"],
+  handler: async ({ mastra, agentId, abortSignal, ...params }) => {
+    try {
+      const agent = await getAgentFromSystem({ mastra, agentId });
+      if (!params.runId) {
+        throw new HTTPException(400, { message: "Run id is required" });
+      }
+      if (!params.toolCallId) {
+        throw new HTTPException(400, { message: "Tool call id is required" });
+      }
+      sanitizeBody(params, ["tools"]);
+      const streamResult = await agent.approveToolCall({
+        ...params,
+        abortSignal
+      });
+      return streamResult.fullStream;
+    } catch (error) {
+      return handleError(error, "error approving tool call");
+    }
+  }
+});
+var DECLINE_TOOL_CALL_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agents/:agentId/decline-tool-call",
+  responseType: "stream",
+  streamFormat: "sse",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: declineToolCallBodySchema,
+  responseSchema: toolCallResponseSchema,
+  summary: "Decline tool call",
+  description: "Declines a pending tool call and continues agent execution without executing the tool",
+  tags: ["Agents", "Tools"],
+  handler: async ({ mastra, agentId, abortSignal, ...params }) => {
+    try {
+      const agent = await getAgentFromSystem({ mastra, agentId });
+      if (!params.runId) {
+        throw new HTTPException(400, { message: "Run id is required" });
+      }
+      if (!params.toolCallId) {
+        throw new HTTPException(400, { message: "Tool call id is required" });
+      }
+      sanitizeBody(params, ["tools"]);
+      const streamResult = await agent.declineToolCall({
+        ...params,
+        abortSignal
+      });
+      return streamResult.fullStream;
+    } catch (error) {
+      return handleError(error, "error declining tool call");
+    }
+  }
+});
+var STREAM_NETWORK_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agents/:agentId/network",
+  responseType: "stream",
+  streamFormat: "sse",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: agentExecutionBodySchema.extend({ thread: z.string().optional() }),
+  responseSchema: streamResponseSchema,
+  summary: "Stream agent network",
+  description: "Executes an agent network with multiple agents and streams the response",
+  tags: ["Agents"],
+  handler: async ({ mastra, messages, agentId, ...params }) => {
+    try {
+      const agent = await getAgentFromSystem({ mastra, agentId });
+      sanitizeBody(params, ["tools"]);
+      validateBody({ messages });
+      const streamResult = await agent.network(messages, {
+        ...params,
+        memory: {
+          thread: params.thread ?? params.threadId ?? "",
+          resource: params.resourceId ?? "",
+          options: params.memory?.options ?? {}
+        }
+      });
+      return streamResult;
+    } catch (error) {
+      return handleError(error, "error streaming agent loop response");
+    }
+  }
+});
+var UPDATE_AGENT_MODEL_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agents/:agentId/model",
+  responseType: "json",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: updateAgentModelBodySchema,
+  responseSchema: modelManagementResponseSchema,
+  summary: "Update agent model",
+  description: "Updates the AI model used by the agent",
+  tags: ["Agents", "Models"],
+  handler: async ({ mastra, agentId, modelId, provider }) => {
+    try {
+      const agent = await getAgentFromSystem({ mastra, agentId });
+      const newModel = `${provider}/${modelId}`;
+      agent.__updateModel({ model: newModel });
+      return { message: "Agent model updated" };
+    } catch (error) {
+      return handleError(error, "error updating agent model");
+    }
+  }
+});
+var RESET_AGENT_MODEL_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agents/:agentId/model/reset",
+  responseType: "json",
+  pathParamSchema: agentIdPathParams,
+  responseSchema: modelManagementResponseSchema,
+  summary: "Reset agent model",
+  description: "Resets the agent model to its original configuration",
+  tags: ["Agents", "Models"],
+  handler: async ({ mastra, agentId }) => {
+    try {
+      const agent = await getAgentFromSystem({ mastra, agentId });
+      agent.__resetToOriginalModel();
+      return { message: "Agent model reset to original" };
+    } catch (error) {
+      return handleError(error, "error resetting agent model");
+    }
+  }
+});
+var REORDER_AGENT_MODEL_LIST_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agents/:agentId/models/reorder",
+  responseType: "json",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: reorderAgentModelListBodySchema,
+  responseSchema: modelManagementResponseSchema,
+  summary: "Reorder agent model list",
+  description: "Reorders the model list for agents with multiple model configurations",
+  tags: ["Agents", "Models"],
+  handler: async ({ mastra, agentId, reorderedModelIds }) => {
+    try {
+      const agent = await getAgentFromSystem({ mastra, agentId });
+      const modelList = await agent.getModelList();
+      if (!modelList || modelList.length === 0) {
+        throw new HTTPException(400, { message: "Agent model list is not found or empty" });
+      }
+      agent.reorderModels(reorderedModelIds);
+      return { message: "Model list reordered" };
+    } catch (error) {
+      return handleError(error, "error reordering model list");
+    }
+  }
+});
+var UPDATE_AGENT_MODEL_IN_MODEL_LIST_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agents/:agentId/models/:modelConfigId",
+  responseType: "json",
+  pathParamSchema: modelConfigIdPathParams,
+  bodySchema: updateAgentModelInModelListBodySchema,
+  responseSchema: modelManagementResponseSchema,
+  summary: "Update model in model list",
+  description: "Updates a specific model configuration in the agent model list",
+  tags: ["Agents", "Models"],
+  handler: async ({ mastra, agentId, modelConfigId, model: bodyModel, maxRetries, enabled }) => {
+    try {
+      const agent = await getAgentFromSystem({ mastra, agentId });
+      const modelList = await agent.getModelList();
+      if (!modelList || modelList.length === 0) {
+        throw new HTTPException(400, { message: "Agent model list is not found or empty" });
+      }
+      const modelConfig = modelList.find((config) => config.id === modelConfigId);
+      if (!modelConfig) {
+        throw new HTTPException(404, { message: `Model config with id ${modelConfigId} not found` });
+      }
+      const newModel = bodyModel?.modelId && bodyModel?.provider ? `${bodyModel.provider}/${bodyModel.modelId}` : modelConfig.model;
+      const updated = {
+        ...modelConfig,
+        model: newModel,
+        ...maxRetries !== void 0 ? { maxRetries } : {},
+        ...enabled !== void 0 ? { enabled } : {}
+      };
+      agent.updateModelInModelList(updated);
+      return { message: "Model updated in model list" };
+    } catch (error) {
+      return handleError(error, "error updating model in model list");
+    }
+  }
+});
+var STREAM_VNEXT_DEPRECATED_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agents/:agentId/streamVNext",
+  responseType: "stream",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: agentExecutionBodySchema,
+  responseSchema: streamResponseSchema,
+  summary: "Stream a response from an agent",
+  description: "[DEPRECATED] This endpoint is deprecated. Please use /stream instead.",
+  tags: ["Agents"],
+  deprecated: true,
+  handler: async () => {
+    throw new HTTPException(410, { message: "This endpoint is deprecated. Please use /stream instead." });
+  }
+});
+var STREAM_UI_MESSAGE_VNEXT_DEPRECATED_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agents/:agentId/stream/vnext/ui",
+  responseType: "stream",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: agentExecutionBodySchema,
+  responseSchema: streamResponseSchema,
+  summary: "Stream UI messages from an agent",
+  description: "[DEPRECATED] This endpoint is deprecated. Please use the @mastra/ai-sdk package for uiMessage transformations",
+  tags: ["Agents"],
+  deprecated: true,
+  handler: async () => {
+    try {
+      throw new MastraError({
+        category: ErrorCategory.USER,
+        domain: ErrorDomain.MASTRA_SERVER,
+        id: "DEPRECATED_ENDPOINT",
+        text: "This endpoint is deprecated. Please use the @mastra/ai-sdk package to for uiMessage transformations"
+      });
+    } catch (error) {
+      return handleError(error, "error streaming agent response");
+    }
+  }
+});
+var STREAM_UI_MESSAGE_DEPRECATED_ROUTE = createRoute({
+  method: "POST",
+  path: "/api/agents/:agentId/stream/ui",
+  responseType: "stream",
+  pathParamSchema: agentIdPathParams,
+  bodySchema: agentExecutionBodySchema,
+  responseSchema: streamResponseSchema,
+  summary: "Stream UI messages from an agent",
+  description: "[DEPRECATED] This endpoint is deprecated. Please use the @mastra/ai-sdk package for uiMessage transformations",
+  tags: ["Agents"],
+  deprecated: true,
+  handler: STREAM_UI_MESSAGE_VNEXT_DEPRECATED_ROUTE.handler
+});
+
+export { APPROVE_TOOL_CALL_ROUTE, DECLINE_TOOL_CALL_ROUTE, GENERATE_AGENT_ROUTE, GENERATE_AGENT_VNEXT_ROUTE, GENERATE_LEGACY_ROUTE, GET_AGENT_BY_ID_ROUTE, GET_PROVIDERS_ROUTE, LIST_AGENTS_ROUTE, REORDER_AGENT_MODEL_LIST_ROUTE, RESET_AGENT_MODEL_ROUTE, STREAM_GENERATE_LEGACY_ROUTE, STREAM_GENERATE_ROUTE, STREAM_GENERATE_VNEXT_DEPRECATED_ROUTE, STREAM_NETWORK_ROUTE, STREAM_UI_MESSAGE_DEPRECATED_ROUTE, STREAM_UI_MESSAGE_VNEXT_DEPRECATED_ROUTE, STREAM_VNEXT_DEPRECATED_ROUTE, UPDATE_AGENT_MODEL_IN_MODEL_LIST_ROUTE, UPDATE_AGENT_MODEL_ROUTE, agents_exports, getAgentFromSystem, getSerializedAgentTools, getSerializedProcessors };
+//# sourceMappingURL=chunk-Q6SVIZLX.js.map
+//# sourceMappingURL=chunk-Q6SVIZLX.js.map