@mastra/server 0.0.0-a2a-20250421213654

package/dist/chunk-J2MCTUD4.js

@@ -0,0 +1,121 @@
+import { validateBody } from './chunk-H5PTF3Y4.js';
+import { handleError } from './chunk-M5ABIP7D.js';
+import { HTTPException } from './chunk-NYN7KFXL.js';
+import { __export } from './chunk-4VNS5WPM.js';
+
+// src/server/handlers/network.ts
+var network_exports = {};
+__export(network_exports, {
+  generateHandler: () => generateHandler,
+  getNetworkByIdHandler: () => getNetworkByIdHandler,
+  getNetworksHandler: () => getNetworksHandler,
+  streamGenerateHandler: () => streamGenerateHandler
+});
+async function getNetworksHandler({ mastra }) {
+  try {
+    const networks = mastra.getNetworks();
+    const serializedNetworks = networks.map((network) => {
+      const routingAgent = network.getRoutingAgent();
+      const agents = network.getAgents();
+      return {
+        id: network.formatAgentId(routingAgent.name),
+        name: routingAgent.name,
+        instructions: routingAgent.instructions,
+        agents: agents.map((agent) => ({
+          name: agent.name,
+          provider: agent.llm?.getProvider(),
+          modelId: agent.llm?.getModelId()
+        })),
+        routingModel: {
+          provider: routingAgent.llm?.getProvider(),
+          modelId: routingAgent.llm?.getModelId()
+        }
+      };
+    });
+    return serializedNetworks;
+  } catch (error) {
+    return handleError(error, "Error getting networks");
+  }
+}
+async function getNetworkByIdHandler({ mastra, networkId }) {
+  try {
+    const networks = mastra.getNetworks();
+    const network = networks.find((network2) => {
+      const routingAgent2 = network2.getRoutingAgent();
+      return network2.formatAgentId(routingAgent2.name) === networkId;
+    });
+    if (!network) {
+      throw new HTTPException(404, { message: "Network not found" });
+    }
+    const routingAgent = network.getRoutingAgent();
+    const agents = network.getAgents();
+    const serializedNetwork = {
+      id: network.formatAgentId(routingAgent.name),
+      name: routingAgent.name,
+      instructions: routingAgent.instructions,
+      agents: agents.map((agent) => ({
+        name: agent.name,
+        provider: agent.llm?.getProvider(),
+        modelId: agent.llm?.getModelId()
+      })),
+      routingModel: {
+        provider: routingAgent.llm?.getProvider(),
+        modelId: routingAgent.llm?.getModelId()
+      }
+    };
+    return serializedNetwork;
+  } catch (error) {
+    return handleError(error, "Error getting network by ID");
+  }
+}
+async function generateHandler({
+  mastra,
+  container,
+  networkId,
+  body
+}) {
+  try {
+    const network = mastra.getNetwork(networkId);
+    if (!network) {
+      throw new HTTPException(404, { message: "Network not found" });
+    }
+    validateBody({ messages: body.messages });
+    const { messages, ...rest } = body;
+    const result = await network.generate(messages, { ...rest, container });
+    return result;
+  } catch (error) {
+    return handleError(error, "Error generating from network");
+  }
+}
+async function streamGenerateHandler({
+  mastra,
+  networkId,
+  body,
+  container
+}) {
+  try {
+    const network = mastra.getNetwork(networkId);
+    if (!network) {
+      throw new HTTPException(404, { message: "Network not found" });
+    }
+    validateBody({ messages: body.messages });
+    const { messages, output, ...rest } = body;
+    const streamResult = await network.stream(messages, {
+      output,
+      ...rest,
+      container
+    });
+    const streamResponse = output ? streamResult.toTextStreamResponse() : streamResult.toDataStreamResponse({
+      sendUsage: true,
+      sendReasoning: true,
+      getErrorMessage: (error) => {
+        return `An error occurred while processing your request. ${error instanceof Error ? error.message : JSON.stringify(error)}`;
+      }
+    });
+    return streamResponse;
+  } catch (error) {
+    return handleError(error, "Error streaming from network");
+  }
+}
+
+export { generateHandler, getNetworkByIdHandler, getNetworksHandler, network_exports, streamGenerateHandler };

package/dist/chunk-JQCFFVSK.cjs

@@ -0,0 +1,127 @@
+'use strict';
+
+var chunk57CJTIPW_cjs = require('./chunk-57CJTIPW.cjs');
+var chunk64U3UDTH_cjs = require('./chunk-64U3UDTH.cjs');
+var chunkOCWPVYNI_cjs = require('./chunk-OCWPVYNI.cjs');
+var chunkCVPOREIE_cjs = require('./chunk-CVPOREIE.cjs');
+
+// src/server/handlers/network.ts
+var network_exports = {};
+chunkCVPOREIE_cjs.__export(network_exports, {
+  generateHandler: () => generateHandler,
+  getNetworkByIdHandler: () => getNetworkByIdHandler,
+  getNetworksHandler: () => getNetworksHandler,
+  streamGenerateHandler: () => streamGenerateHandler
+});
+async function getNetworksHandler({ mastra }) {
+  try {
+    const networks = mastra.getNetworks();
+    const serializedNetworks = networks.map((network) => {
+      const routingAgent = network.getRoutingAgent();
+      const agents = network.getAgents();
+      return {
+        id: network.formatAgentId(routingAgent.name),
+        name: routingAgent.name,
+        instructions: routingAgent.instructions,
+        agents: agents.map((agent) => ({
+          name: agent.name,
+          provider: agent.llm?.getProvider(),
+          modelId: agent.llm?.getModelId()
+        })),
+        routingModel: {
+          provider: routingAgent.llm?.getProvider(),
+          modelId: routingAgent.llm?.getModelId()
+        }
+      };
+    });
+    return serializedNetworks;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting networks");
+  }
+}
+async function getNetworkByIdHandler({ mastra, networkId }) {
+  try {
+    const networks = mastra.getNetworks();
+    const network = networks.find((network2) => {
+      const routingAgent2 = network2.getRoutingAgent();
+      return network2.formatAgentId(routingAgent2.name) === networkId;
+    });
+    if (!network) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Network not found" });
+    }
+    const routingAgent = network.getRoutingAgent();
+    const agents = network.getAgents();
+    const serializedNetwork = {
+      id: network.formatAgentId(routingAgent.name),
+      name: routingAgent.name,
+      instructions: routingAgent.instructions,
+      agents: agents.map((agent) => ({
+        name: agent.name,
+        provider: agent.llm?.getProvider(),
+        modelId: agent.llm?.getModelId()
+      })),
+      routingModel: {
+        provider: routingAgent.llm?.getProvider(),
+        modelId: routingAgent.llm?.getModelId()
+      }
+    };
+    return serializedNetwork;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting network by ID");
+  }
+}
+async function generateHandler({
+  mastra,
+  container,
+  networkId,
+  body
+}) {
+  try {
+    const network = mastra.getNetwork(networkId);
+    if (!network) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Network not found" });
+    }
+    chunk57CJTIPW_cjs.validateBody({ messages: body.messages });
+    const { messages, ...rest } = body;
+    const result = await network.generate(messages, { ...rest, container });
+    return result;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error generating from network");
+  }
+}
+async function streamGenerateHandler({
+  mastra,
+  networkId,
+  body,
+  container
+}) {
+  try {
+    const network = mastra.getNetwork(networkId);
+    if (!network) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Network not found" });
+    }
+    chunk57CJTIPW_cjs.validateBody({ messages: body.messages });
+    const { messages, output, ...rest } = body;
+    const streamResult = await network.stream(messages, {
+      output,
+      ...rest,
+      container
+    });
+    const streamResponse = output ? streamResult.toTextStreamResponse() : streamResult.toDataStreamResponse({
+      sendUsage: true,
+      sendReasoning: true,
+      getErrorMessage: (error) => {
+        return `An error occurred while processing your request. ${error instanceof Error ? error.message : JSON.stringify(error)}`;
+      }
+    });
+    return streamResponse;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error streaming from network");
+  }
+}
+
+exports.generateHandler = generateHandler;
+exports.getNetworkByIdHandler = getNetworkByIdHandler;
+exports.getNetworksHandler = getNetworksHandler;
+exports.network_exports = network_exports;
+exports.streamGenerateHandler = streamGenerateHandler;

package/dist/chunk-LGJ46RCS.js

@@ -0,0 +1,96 @@
+import { validateBody } from './chunk-H5PTF3Y4.js';
+import { handleError } from './chunk-M5ABIP7D.js';
+import { HTTPException } from './chunk-NYN7KFXL.js';
+import { __export } from './chunk-4VNS5WPM.js';
+import { Readable } from 'stream';
+
+// src/server/handlers/voice.ts
+var voice_exports = {};
+__export(voice_exports, {
+  generateSpeechHandler: () => generateSpeechHandler,
+  getSpeakersHandler: () => getSpeakersHandler,
+  transcribeSpeechHandler: () => transcribeSpeechHandler
+});
+async function getSpeakersHandler({ mastra, agentId }) {
+  try {
+    if (!agentId) {
+      throw new HTTPException(400, { message: "Agent ID is required" });
+    }
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new HTTPException(404, { message: "Agent not found" });
+    }
+    if (!agent.voice) {
+      throw new HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const speakers = await agent.voice.getSpeakers();
+    return speakers;
+  } catch (error) {
+    return handleError(error, "Error getting speakers");
+  }
+}
+async function generateSpeechHandler({
+  mastra,
+  agentId,
+  body
+}) {
+  try {
+    if (!agentId) {
+      throw new HTTPException(400, { message: "Agent ID is required" });
+    }
+    validateBody({
+      text: void 0,
+      speakerId: void 0,
+      ...body
+    });
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new HTTPException(404, { message: "Agent not found" });
+    }
+    if (!agent.voice) {
+      throw new HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const audioStream = await agent.voice.speak(body.text, { speaker: body.speakerId });
+    if (!audioStream) {
+      throw new HTTPException(500, { message: "Failed to generate speech" });
+    }
+    const chunks = [];
+    for await (const chunk of audioStream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const audioData = Buffer.concat(chunks);
+    return { audioData };
+  } catch (error) {
+    return handleError(error, "Error generating speech");
+  }
+}
+async function transcribeSpeechHandler({
+  mastra,
+  agentId,
+  body
+}) {
+  try {
+    if (!agentId) {
+      throw new HTTPException(400, { message: "Agent ID is required" });
+    }
+    if (!body?.audioData) {
+      throw new HTTPException(400, { message: "Audio data is required" });
+    }
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new HTTPException(404, { message: "Agent not found" });
+    }
+    if (!agent.voice) {
+      throw new HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const audioStream = new Readable();
+    audioStream.push(body.audioData);
+    audioStream.push(null);
+    const text = await agent.voice.listen(audioStream, body.options);
+    return { text };
+  } catch (error) {
+    return handleError(error, "Error transcribing speech");
+  }
+}
+
+export { generateSpeechHandler, getSpeakersHandler, transcribeSpeechHandler, voice_exports };

package/dist/chunk-LTP7PHVE.cjs

@@ -0,0 +1,321 @@
+'use strict';
+
+var chunkCVPOREIE_cjs = require('./chunk-CVPOREIE.cjs');
+
+// src/server/handlers/a2a.ts
+var a2a_exports = {};
+chunkCVPOREIE_cjs.__export(a2a_exports, {
+  generateAgentCard: () => generateAgentCard,
+  handleA2ARequest: () => handleA2ARequest,
+  handleAgentCardRequest: () => handleAgentCardRequest,
+  handleCancelTask: () => handleCancelTask,
+  handleGetTask: () => handleGetTask,
+  handlePushNotification: () => handlePushNotification,
+  handleSendTask: () => handleSendTask
+});
+var tasks = /* @__PURE__ */ new Map();
+function convertToA2AMessage({ message, role }) {
+  if (typeof message === "string") {
+    return {
+      role,
+      parts: [
+        {
+          type: "text",
+          text: message
+        }
+      ]
+    };
+  }
+  if (message && message.text) {
+    return {
+      role,
+      parts: [
+        {
+          type: "text",
+          text: message.text
+        }
+      ]
+    };
+  }
+  let parts = [];
+  if (message && message.content) {
+    if (typeof message.content === "string") {
+      parts.push({
+        type: "text",
+        text: message.content
+      });
+    } else if (Array.isArray(message.content)) {
+      parts = message.content.map((item) => {
+        if (typeof item === "string") {
+          return {
+            type: "text",
+            text: item
+          };
+        } else if (item && item.type === "text") {
+          return {
+            type: "text",
+            text: item.text || ""
+          };
+        } else if (item && item.type === "file") {
+          return {
+            type: "file",
+            file: {
+              name: item.name || null,
+              mimeType: item.mimeType || null,
+              uri: item.uri || null
+            }
+          };
+        } else {
+          return {
+            type: "data",
+            data: item || {}
+          };
+        }
+      });
+    }
+  }
+  if (parts.length === 0 && typeof message === "object" && message !== null) {
+    try {
+      const textRepresentation = JSON.stringify(message, null, 2);
+      parts.push({
+        type: "text",
+        text: textRepresentation
+      });
+    } catch (_e) {
+      parts.push({
+        type: "text",
+        text: "Unable to convert agent response to text"
+      });
+    }
+  }
+  return {
+    role,
+    parts
+  };
+}
+function convertFromA2AMessage({ message }) {
+  if (message.parts && message.parts.length === 1 && message.parts[0]?.type === "text") {
+    return message.parts[0]?.text || "";
+  }
+  const content = (message.parts || []).map((part) => {
+    if (part.type === "text") {
+      return part.text || "";
+    } else if (part.type === "file" && part.file) {
+      return {
+        type: "file",
+        name: part.file.name || "",
+        mimeType: part.file.mimeType || "",
+        uri: part.file.uri || ""
+      };
+    } else if (part.type === "data") {
+      return part.data || {};
+    }
+    return null;
+  }).filter(Boolean);
+  return {
+    role: message.role || "user",
+    content: content.length === 1 ? content[0] : content
+  };
+}
+function createErrorResponse({
+  id,
+  code,
+  message,
+  data
+}) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code,
+      message,
+      data
+    }
+  };
+}
+function createSuccessResponse({ id, result }) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    result
+  };
+}
+async function handleSendTask({
+  request,
+  agent
+}) {
+  try {
+    const { id, message, sessionId } = request.params;
+    const agentMessage = convertFromA2AMessage({ message });
+    const response = await agent.generate(agentMessage);
+    const a2aResponse = convertToA2AMessage({ message: response, role: "agent" });
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const task = {
+      id,
+      sessionId: sessionId || null,
+      status: {
+        state: "completed" /* COMPLETED */,
+        message: a2aResponse,
+        timestamp: now
+      },
+      history: [message, a2aResponse]
+    };
+    tasks.set(id, task);
+    return createSuccessResponse({ id: request.id || null, result: task });
+  } catch (error) {
+    console.error("Error handling send task:", error);
+    return createErrorResponse({
+      id: request.id || null,
+      code: -32603 /* INTERNAL_ERROR */,
+      message: "Internal error processing task",
+      data: { error: String(error) }
+    });
+  }
+}
+async function handleGetTask({ request }) {
+  try {
+    const { id, historyLength } = request.params;
+    const task = tasks.get(id);
+    if (!task) {
+      return createErrorResponse({
+        id: request.id || null,
+        code: -32001 /* TASK_NOT_FOUND */,
+        message: "Task not found"
+      });
+    }
+    if (historyLength !== void 0 && historyLength !== null && task.history) {
+      task.history = task.history.slice(-historyLength);
+    }
+    return createSuccessResponse({ id: request.id || null, result: task });
+  } catch (error) {
+    console.error("Error handling get task:", error);
+    return createErrorResponse({
+      id: request.id || null,
+      code: -32603 /* INTERNAL_ERROR */,
+      message: "Internal error retrieving task",
+      data: { error: String(error) }
+    });
+  }
+}
+async function handleCancelTask({ request }) {
+  try {
+    const { id } = request.params;
+    const task = tasks.get(id);
+    if (!task) {
+      return createErrorResponse({
+        id: request.id || null,
+        code: -32001 /* TASK_NOT_FOUND */,
+        message: "Task not found"
+      });
+    }
+    if (task.status.state === "completed" /* COMPLETED */ || task.status.state === "canceled" /* CANCELED */ || task.status.state === "failed" /* FAILED */) {
+      return createErrorResponse({
+        id: request.id || null,
+        code: -32002 /* TASK_NOT_CANCELABLE */,
+        message: "Task cannot be canceled"
+      });
+    }
+    task.status = {
+      state: "canceled" /* CANCELED */,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    tasks.set(id, task);
+    return createSuccessResponse({ id: request.id || null, result: task });
+  } catch (error) {
+    console.error("Error handling cancel task:", error);
+    return createErrorResponse({
+      id: request.id || null,
+      code: -32603 /* INTERNAL_ERROR */,
+      message: "Internal error canceling task",
+      data: { error: String(error) }
+    });
+  }
+}
+function handlePushNotification() {
+  return createErrorResponse({
+    id: null,
+    code: -32003 /* PUSH_NOTIFICATION_NOT_SUPPORTED */,
+    message: "Push Notification is not supported"
+  });
+}
+async function handleA2ARequest({
+  request,
+  agent
+}) {
+  try {
+    const requestId = "id" in request ? request.id : null;
+    switch (request.method) {
+      case "tasks/send":
+        return await handleSendTask({ request, agent });
+      case "tasks/get":
+        return await handleGetTask({ request });
+      case "tasks/cancel":
+        return await handleCancelTask({ request });
+      case "tasks/pushNotification/set":
+      case "tasks/pushNotification/get":
+      case "tasks/resubscribe":
+        return handlePushNotification();
+      default:
+        return createErrorResponse({
+          id: requestId,
+          code: -32601 /* METHOD_NOT_FOUND */,
+          message: "Method not found"
+        });
+    }
+  } catch (error) {
+    console.error("Error handling A2A request:", error);
+    const errorRequestId = "id" in request && request.id !== void 0 ? request.id : null;
+    return createErrorResponse({
+      id: errorRequestId,
+      code: -32603 /* INTERNAL_ERROR */,
+      message: "Internal error",
+      data: { error: String(error) }
+    });
+  }
+}
+function generateAgentCard({ agent, baseUrl }) {
+  const skills = [];
+  if (agent.tools) {
+    Object.entries(agent.tools).forEach(([id, tool]) => {
+      const toolName = typeof tool === "object" && tool !== null ? tool.id || id : id;
+      const toolDescription = typeof tool === "object" && tool !== null ? tool.description || null : null;
+      skills.push({
+        id,
+        name: toolName,
+        description: toolDescription
+      });
+    });
+  }
+  if (skills.length === 0) {
+    skills.push({
+      id: "conversation",
+      name: "Conversation",
+      description: "General conversation capabilities"
+    });
+  }
+  const capabilities = {
+    streaming: false,
+    pushNotifications: false,
+    stateTransitionHistory: false
+  };
+  return {
+    name: agent.name || "Mastra Agent",
+    description: typeof agent.instructions === "string" ? agent.instructions : null,
+    url: `${baseUrl}/a2a`,
+    version: "1.0.0",
+    capabilities,
+    skills
+  };
+}
+function handleAgentCardRequest({ agent, baseUrl }) {
+  return generateAgentCard({ agent, baseUrl });
+}
+
+exports.a2a_exports = a2a_exports;
+exports.generateAgentCard = generateAgentCard;
+exports.handleA2ARequest = handleA2ARequest;
+exports.handleAgentCardRequest = handleAgentCardRequest;
+exports.handleCancelTask = handleCancelTask;
+exports.handleGetTask = handleGetTask;
+exports.handlePushNotification = handlePushNotification;
+exports.handleSendTask = handleSendTask;

package/dist/chunk-M5ABIP7D.js

@@ -0,0 +1,11 @@
+import { HTTPException } from './chunk-NYN7KFXL.js';
+
+// src/server/handlers/error.ts
+function handleError(error, defaultMessage) {
+  const apiError = error;
+  throw new HTTPException(apiError.status || 500, {
+    message: apiError.message || defaultMessage
+  });
+}
+
+export { handleError };