@mastra/server 0.0.0-a2a-20250421213654

package/dist/chunk-CZOSYERC.js

@@ -0,0 +1,312 @@
+import { __export } from './chunk-4VNS5WPM.js';
+
+// src/server/handlers/a2a.ts
+var a2a_exports = {};
+__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 });
+}
+
+export { a2a_exports, generateAgentCard, handleA2ARequest, handleAgentCardRequest, handleCancelTask, handleGetTask, handlePushNotification, handleSendTask };

package/dist/chunk-FFRES7WX.js

@@ -0,0 +1,157 @@
+import { stringify, esm_default } from './chunk-OMN3UI6X.js';
+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/agents.ts
+var agents_exports = {};
+__export(agents_exports, {
+  generateHandler: () => generateHandler,
+  getAgentByIdHandler: () => getAgentByIdHandler,
+  getAgentsHandler: () => getAgentsHandler,
+  getEvalsByAgentIdHandler: () => getEvalsByAgentIdHandler,
+  getLiveEvalsByAgentIdHandler: () => getLiveEvalsByAgentIdHandler,
+  streamGenerateHandler: () => streamGenerateHandler
+});
+async function getAgentsHandler({ mastra }) {
+  try {
+    const agents = mastra.getAgents();
+    const serializedAgents = Object.entries(agents).reduce((acc, [_id, _agent]) => {
+      const agent = _agent;
+      const serializedAgentTools = Object.entries(agent?.tools || {}).reduce((acc2, [key, tool]) => {
+        const _tool = tool;
+        acc2[key] = {
+          ..._tool,
+          inputSchema: _tool.inputSchema ? stringify(esm_default(_tool.inputSchema)) : void 0,
+          outputSchema: _tool.outputSchema ? stringify(esm_default(_tool.outputSchema)) : void 0
+        };
+        return acc2;
+      }, {});
+      acc[_id] = {
+        name: agent.name,
+        instructions: agent.instructions,
+        tools: serializedAgentTools,
+        provider: agent.llm?.getProvider(),
+        modelId: agent.llm?.getModelId()
+      };
+      return acc;
+    }, {});
+    return serializedAgents;
+  } catch (error) {
+    return handleError(error, "Error getting agents");
+  }
+}
+async function getAgentByIdHandler({ mastra, agentId }) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new HTTPException(404, { message: "Agent not found" });
+    }
+    const serializedAgentTools = Object.entries(agent?.tools || {}).reduce((acc, [key, tool]) => {
+      const _tool = tool;
+      acc[key] = {
+        ..._tool,
+        inputSchema: _tool.inputSchema ? stringify(esm_default(_tool.inputSchema)) : void 0,
+        outputSchema: _tool.outputSchema ? stringify(esm_default(_tool.outputSchema)) : void 0
+      };
+      return acc;
+    }, {});
+    return {
+      name: agent.name,
+      instructions: agent.instructions,
+      tools: serializedAgentTools,
+      provider: agent.llm?.getProvider(),
+      modelId: agent.llm?.getModelId()
+    };
+  } catch (error) {
+    return handleError(error, "Error getting agent");
+  }
+}
+async function getEvalsByAgentIdHandler({ mastra, agentId }) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    const evals = await mastra.getStorage()?.getEvalsByAgentName?.(agent.name, "test") || [];
+    return {
+      id: agentId,
+      name: agent.name,
+      instructions: agent.instructions,
+      evals
+    };
+  } catch (error) {
+    return handleError(error, "Error getting test evals");
+  }
+}
+async function getLiveEvalsByAgentIdHandler({ mastra, agentId }) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    const evals = await mastra.getStorage()?.getEvalsByAgentName?.(agent.name, "live") || [];
+    return {
+      id: agentId,
+      name: agent.name,
+      instructions: agent.instructions,
+      evals
+    };
+  } catch (error) {
+    return handleError(error, "Error getting live evals");
+  }
+}
+async function generateHandler({
+  mastra,
+  container,
+  agentId,
+  body
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new HTTPException(404, { message: "Agent not found" });
+    }
+    const { messages, resourceId, resourceid, ...rest } = body;
+    const finalResourceId = resourceId ?? resourceid;
+    validateBody({ messages });
+    const result = await agent.generate(messages, {
+      ...rest,
+      // @ts-expect-error TODO fix types
+      resourceId: finalResourceId,
+      container
+    });
+    return result;
+  } catch (error) {
+    return handleError(error, "Error generating from agent");
+  }
+}
+async function streamGenerateHandler({
+  mastra,
+  container,
+  agentId,
+  body
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new HTTPException(404, { message: "Agent not found" });
+    }
+    const { messages, resourceId, resourceid, ...rest } = body;
+    const finalResourceId = resourceId ?? resourceid;
+    validateBody({ messages });
+    const streamResult = await agent.stream(messages, {
+      ...rest,
+      // @ts-expect-error TODO fix types
+      resourceId: finalResourceId,
+      container
+    });
+    const streamResponse = rest.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) {
+    throw new HTTPException(error?.status ?? 500, { message: error?.message ?? "Error streaming from agent" });
+  }
+}
+
+export { agents_exports, generateHandler, getAgentByIdHandler, getAgentsHandler, getEvalsByAgentIdHandler, getLiveEvalsByAgentIdHandler, streamGenerateHandler };

package/dist/chunk-H5PTF3Y4.js

@@ -0,0 +1,16 @@
+import { HTTPException } from './chunk-NYN7KFXL.js';
+
+// src/server/handlers/utils.ts
+function validateBody(body) {
+  const errorResponse = Object.entries(body).reduce((acc, [key, value]) => {
+    if (!value) {
+      acc[key] = `Argument "${key}" is required`;
+    }
+    return acc;
+  }, {});
+  if (Object.keys(errorResponse).length > 0) {
+    throw new HTTPException(400, { message: Object.values(errorResponse)[0] });
+  }
+}
+
+export { validateBody };

package/dist/chunk-IDPBXKRV.js

@@ -0,0 +1,121 @@
+import { handleError } from './chunk-M5ABIP7D.js';
+import { HTTPException } from './chunk-NYN7KFXL.js';
+import { __export } from './chunk-4VNS5WPM.js';
+
+// src/server/handlers/vector.ts
+var vector_exports = {};
+__export(vector_exports, {
+  createIndex: () => createIndex,
+  deleteIndex: () => deleteIndex,
+  describeIndex: () => describeIndex,
+  listIndexes: () => listIndexes,
+  queryVectors: () => queryVectors,
+  upsertVectors: () => upsertVectors
+});
+function getVector(mastra, vectorName) {
+  if (!vectorName) {
+    throw new HTTPException(400, { message: "Vector name is required" });
+  }
+  const vector = mastra.getVector(vectorName);
+  if (!vector) {
+    throw new HTTPException(404, { message: `Vector store ${vectorName} not found` });
+  }
+  return vector;
+}
+async function upsertVectors({ mastra, vectorName, index }) {
+  try {
+    if (!index?.indexName || !index?.vectors || !Array.isArray(index.vectors)) {
+      throw new HTTPException(400, { message: "Invalid request index. indexName and vectors array are required." });
+    }
+    const vector = getVector(mastra, vectorName);
+    const result = await vector.upsert(index);
+    return { ids: result };
+  } catch (error) {
+    return handleError(error, "Error upserting vectors");
+  }
+}
+async function createIndex({
+  mastra,
+  vectorName,
+  index
+}) {
+  try {
+    const { indexName, dimension, metric } = index;
+    if (!indexName || typeof dimension !== "number" || dimension <= 0) {
+      throw new HTTPException(400, {
+        message: "Invalid request index, indexName and positive dimension number are required."
+      });
+    }
+    if (metric && !["cosine", "euclidean", "dotproduct"].includes(metric)) {
+      throw new HTTPException(400, { message: "Invalid metric. Must be one of: cosine, euclidean, dotproduct" });
+    }
+    const vector = getVector(mastra, vectorName);
+    await vector.createIndex({ indexName, dimension, metric });
+    return { success: true };
+  } catch (error) {
+    return handleError(error, "Error creating index");
+  }
+}
+async function queryVectors({
+  mastra,
+  vectorName,
+  query
+}) {
+  try {
+    if (!query?.indexName || !query?.queryVector || !Array.isArray(query.queryVector)) {
+      throw new HTTPException(400, { message: "Invalid request query. indexName and queryVector array are required." });
+    }
+    const vector = getVector(mastra, vectorName);
+    const results = await vector.query(query);
+    return results;
+  } catch (error) {
+    return handleError(error, "Error querying vectors");
+  }
+}
+async function listIndexes({ mastra, vectorName }) {
+  try {
+    const vector = getVector(mastra, vectorName);
+    const indexes = await vector.listIndexes();
+    return indexes.filter(Boolean);
+  } catch (error) {
+    return handleError(error, "Error listing indexes");
+  }
+}
+async function describeIndex({
+  mastra,
+  vectorName,
+  indexName
+}) {
+  try {
+    if (!indexName) {
+      throw new HTTPException(400, { message: "Index name is required" });
+    }
+    const vector = getVector(mastra, vectorName);
+    const stats = await vector.describeIndex(indexName);
+    return {
+      dimension: stats.dimension,
+      count: stats.count,
+      metric: stats.metric?.toLowerCase()
+    };
+  } catch (error) {
+    return handleError(error, "Error describing index");
+  }
+}
+async function deleteIndex({
+  mastra,
+  vectorName,
+  indexName
+}) {
+  try {
+    if (!indexName) {
+      throw new HTTPException(400, { message: "Index name is required" });
+    }
+    const vector = getVector(mastra, vectorName);
+    await vector.deleteIndex(indexName);
+    return { success: true };
+  } catch (error) {
+    return handleError(error, "Error deleting index");
+  }
+}
+
+export { createIndex, deleteIndex, describeIndex, listIndexes, queryVectors, upsertVectors, vector_exports };