@mastra/server 0.0.0-separate-trace-data-from-component-20250501141108 → 0.0.0-taofeeqInngest-20250603090617

package/dist/{chunk-RBQASTUP.js → chunk-DJJIUEL2.js}

@@ -1,6 +1,7 @@
-import { validateBody } from './chunk-L7XE5QTW.js';
-import { handleError } from './chunk-3AHQ5RGN.js';
-import { __export, HTTPException } from './chunk-TRDNDNGQ.js';
+import { validateBody } from './chunk-H5PTF3Y4.js';
+import { handleError } from './chunk-M5ABIP7D.js';
+import { HTTPException } from './chunk-NYN7KFXL.js';
+import { __export } from './chunk-MLKGABMK.js';
 
 // src/server/handlers/memory.ts
 var memory_exports = {};
@@ -181,8 +182,12 @@ async function deleteThreadHandler({
 async function getMessagesHandler({
   mastra,
   agentId,
-  threadId
+  threadId,
+  limit
 }) {
+  if (limit !== void 0 && (!Number.isInteger(limit) || limit <= 0)) {
+    throw new HTTPException(400, { message: "Invalid limit: must be a positive integer" });
+  }
   try {
     validateBody({ threadId });
     const memory = getMemoryFromContext({ mastra, agentId });
@@ -193,7 +198,10 @@ async function getMessagesHandler({
     if (!thread) {
       throw new HTTPException(404, { message: "Thread not found" });
     }
-    const result = await memory.query({ threadId });
+    const result = await memory.query({
+      threadId,
+      ...limit && { selectBy: { last: limit } }
+    });
     return result;
   } catch (error) {
     return handleError(error, "Error getting messages");

package/dist/{chunk-3EJZQ6TQ.js → chunk-DQLE3DVM.js}

@@ -1,6 +1,6 @@
-import { validateBody } from './chunk-L7XE5QTW.js';
-import { handleError } from './chunk-3AHQ5RGN.js';
-import { __export } from './chunk-TRDNDNGQ.js';
+import { validateBody } from './chunk-H5PTF3Y4.js';
+import { handleError } from './chunk-M5ABIP7D.js';
+import { __export } from './chunk-MLKGABMK.js';
 
 // src/server/handlers/logs.ts
 var logs_exports = {};
@@ -37,9 +37,9 @@ async function getLogsByRunIdHandler({
 async function getLogTransports({ mastra }) {
   try {
     const logger = mastra.getLogger();
-    const transports = logger.transports;
+    const transports = logger.getTransports();
     return {
-      transports: transports ? Object.keys(transports) : []
+      transports: transports ? [...transports.keys()] : []
     };
   } catch (error) {
     return handleError(error, "Error getting log Transports");

package/dist/chunk-GHC4YV6R.js

@@ -0,0 +1,504 @@
+import { __export } from './chunk-MLKGABMK.js';
+import { A2AError } from '@mastra/core/a2a';
+import { z } from 'zod';
+
+// src/server/handlers/a2a.ts
+var a2a_exports = {};
+__export(a2a_exports, {
+  getAgentCardByIdHandler: () => getAgentCardByIdHandler,
+  getAgentExecutionHandler: () => getAgentExecutionHandler,
+  handleTaskCancel: () => handleTaskCancel,
+  handleTaskGet: () => handleTaskGet,
+  handleTaskSend: () => handleTaskSend,
+  handleTaskSendSubscribe: () => handleTaskSendSubscribe
+});
+function normalizeError(error, reqId, taskId, logger) {
+  let a2aError;
+  if (error instanceof A2AError) {
+    a2aError = error;
+  } else if (error instanceof Error) {
+    a2aError = A2AError.internalError(error.message, { stack: error.stack });
+  } else {
+    a2aError = A2AError.internalError("An unknown error occurred.", error);
+  }
+  if (taskId && !a2aError.taskId) {
+    a2aError.taskId = taskId;
+  }
+  logger?.error(`Error processing request (Task: ${a2aError.taskId ?? "N/A"}, ReqID: ${reqId ?? "N/A"}):`, a2aError);
+  return createErrorResponse(reqId, a2aError.toJSONRPCError());
+}
+function createErrorResponse(id, error) {
+  return {
+    jsonrpc: "2.0",
+    id,
+    // Can be null if request ID was invalid/missing
+    error
+  };
+}
+function createSuccessResponse(id, result) {
+  if (!id) {
+    throw A2AError.internalError("Cannot create success response for null ID.");
+  }
+  return {
+    jsonrpc: "2.0",
+    id,
+    result
+  };
+}
+function convertToCoreMessage(message) {
+  return {
+    role: message.role === "user" ? "user" : "assistant",
+    content: message.parts.map((msg) => convertToCoreMessagePart(msg))
+  };
+}
+function convertToCoreMessagePart(part) {
+  switch (part.type) {
+    case "text":
+      return {
+        type: "text",
+        text: part.text
+      };
+    case "file":
+      return {
+        type: "file",
+        data: new URL(part.file.uri),
+        mimeType: part.file.mimeType
+      };
+    case "data":
+      throw new Error("Data parts are not supported in core messages");
+  }
+}
+
+// src/server/a2a/store.ts
+var InMemoryTaskStore = class {
+  store = /* @__PURE__ */ new Map();
+  activeCancellations = /* @__PURE__ */ new Set();
+  async load({ agentId, taskId }) {
+    const entry = this.store.get(`${agentId}-${taskId}`);
+    if (!entry) {
+      return null;
+    }
+    return { task: { ...entry.task }, history: [...entry.history] };
+  }
+  async save({ agentId, data }) {
+    const key = `${agentId}-${data.task.id}`;
+    if (!data.task.id) {
+      throw new Error("Task ID is required");
+    }
+    this.store.set(key, {
+      task: { ...data.task },
+      history: [...data.history]
+    });
+  }
+};
+
+// src/server/a2a/tasks.ts
+function isTaskStatusUpdate(update) {
+  return "state" in update && !("parts" in update);
+}
+function isArtifactUpdate(update) {
+  return "parts" in update;
+}
+function applyUpdateToTaskAndHistory(current, update) {
+  let newTask = structuredClone(current.task);
+  let newHistory = structuredClone(current.history);
+  if (isTaskStatusUpdate(update)) {
+    newTask.status = {
+      ...newTask.status,
+      // Keep existing properties if not overwritten
+      ...update,
+      // Apply updates
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (update.message?.role === "agent") {
+      newHistory.push(update.message);
+    }
+  } else if (isArtifactUpdate(update)) {
+    if (!newTask.artifacts) {
+      newTask.artifacts = [];
+    } else {
+      newTask.artifacts = [...newTask.artifacts];
+    }
+    const existingIndex = update.index ?? -1;
+    let replaced = false;
+    if (existingIndex >= 0 && existingIndex < newTask.artifacts.length) {
+      const existingArtifact = newTask.artifacts[existingIndex];
+      if (update.append) {
+        const appendedArtifact = JSON.parse(JSON.stringify(existingArtifact));
+        appendedArtifact.parts.push(...update.parts);
+        if (update.metadata) {
+          appendedArtifact.metadata = {
+            ...appendedArtifact.metadata || {},
+            ...update.metadata
+          };
+        }
+        if (update.lastChunk !== void 0) appendedArtifact.lastChunk = update.lastChunk;
+        if (update.description) appendedArtifact.description = update.description;
+        newTask.artifacts[existingIndex] = appendedArtifact;
+        replaced = true;
+      } else {
+        newTask.artifacts[existingIndex] = { ...update };
+        replaced = true;
+      }
+    } else if (update.name) {
+      const namedIndex = newTask.artifacts.findIndex((a) => a.name === update.name);
+      if (namedIndex >= 0) {
+        newTask.artifacts[namedIndex] = { ...update };
+        replaced = true;
+      }
+    }
+    if (!replaced) {
+      newTask.artifacts.push({ ...update });
+      if (newTask.artifacts.some((a) => a.index !== void 0)) {
+        newTask.artifacts.sort((a, b) => (a.index ?? 0) - (b.index ?? 0));
+      }
+    }
+  }
+  return { task: newTask, history: newHistory };
+}
+async function loadOrCreateTaskAndHistory({
+  agentId,
+  taskId,
+  taskStore,
+  message,
+  sessionId,
+  metadata,
+  logger
+}) {
+  const data = await taskStore.load({ agentId, taskId });
+  if (!data) {
+    const initialTask = {
+      id: taskId,
+      sessionId,
+      status: {
+        state: "submitted",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        message: null
+      },
+      artifacts: [],
+      metadata
+    };
+    const initialData = {
+      task: initialTask,
+      history: [message]
+    };
+    logger?.info(`[Task ${taskId}] Created new task and history.`);
+    await taskStore.save({ agentId, data: initialData });
+    return initialData;
+  }
+  logger?.info(`[Task ${taskId}] Loaded existing task and history.`);
+  let updatedData = {
+    task: data.task,
+    history: [...data.history, message]
+  };
+  const { status } = data.task;
+  const finalStates = ["completed", "failed", "canceled"];
+  if (finalStates.includes(status.state)) {
+    logger?.warn(`[Task ${taskId}] Received message for task in final state ${status.state}. Restarting.`);
+    updatedData = applyUpdateToTaskAndHistory(updatedData, {
+      state: "submitted",
+      message: null
+    });
+  } else if (status.state === "input-required") {
+    logger?.info(`[Task ${taskId}] Changing state from 'input-required' to 'working'.`);
+    updatedData = applyUpdateToTaskAndHistory(updatedData, { state: "working" });
+  } else if (status.state === "working") {
+    logger?.warn(`[Task ${taskId}] Received message while already 'working'. Proceeding.`);
+  }
+  await taskStore.save({ agentId, data: updatedData });
+  return {
+    task: { ...updatedData.task },
+    history: [...updatedData.history]
+  };
+}
+function createTaskContext({
+  task,
+  userMessage,
+  history,
+  activeCancellations
+}) {
+  return {
+    task: structuredClone(task),
+    userMessage,
+    history: structuredClone(history),
+    isCancelled: () => activeCancellations.has(task.id)
+  };
+}
+
+// src/server/handlers/a2a.ts
+var taskSendParamsSchema = z.object({
+  id: z.string().min(1, "Invalid or missing task ID (params.id)."),
+  message: z.object({
+    parts: z.array(
+      z.object({
+        type: z.enum(["text"]),
+        text: z.string()
+      })
+    )
+  })
+});
+async function getAgentCardByIdHandler({
+  mastra,
+  agentId,
+  executionUrl = `/a2a/${agentId}`,
+  provider = {
+    organization: "Mastra",
+    url: "https://mastra.ai"
+  },
+  version = "1.0",
+  runtimeContext
+}) {
+  const agent = mastra.getAgent(agentId);
+  if (!agent) {
+    throw new Error(`Agent with ID ${agentId} not found`);
+  }
+  const [instructions, tools] = await Promise.all([
+    agent.getInstructions({ runtimeContext }),
+    agent.getTools({ runtimeContext })
+  ]);
+  const agentCard = {
+    name: agent.id || agentId,
+    description: instructions,
+    url: executionUrl,
+    provider,
+    version,
+    capabilities: {
+      streaming: true,
+      // All agents support streaming
+      pushNotifications: false,
+      stateTransitionHistory: false
+    },
+    defaultInputModes: ["text"],
+    defaultOutputModes: ["text"],
+    // Convert agent tools to skills format for A2A protocol
+    skills: Object.entries(tools).map(([toolId, tool]) => ({
+      id: toolId,
+      name: toolId,
+      description: tool.description || `Tool: ${toolId}`,
+      // Optional fields
+      tags: ["tool"]
+    }))
+  };
+  return agentCard;
+}
+function validateTaskSendParams(params) {
+  try {
+    taskSendParamsSchema.parse(params);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      throw A2AError.invalidParams(error.errors[0].message);
+    }
+    throw error;
+  }
+}
+async function handleTaskSend({
+  requestId,
+  params,
+  taskStore,
+  agent,
+  agentId,
+  logger,
+  runtimeContext
+}) {
+  validateTaskSendParams(params);
+  const { id: taskId, message, sessionId, metadata } = params;
+  let currentData = await loadOrCreateTaskAndHistory({
+    taskId,
+    taskStore,
+    agentId,
+    message,
+    sessionId,
+    metadata
+  });
+  createTaskContext({
+    task: currentData.task,
+    userMessage: message,
+    history: currentData.history,
+    activeCancellations: taskStore.activeCancellations
+  });
+  try {
+    const { text } = await agent.generate([convertToCoreMessage(message)], {
+      runId: taskId,
+      runtimeContext
+    });
+    currentData = applyUpdateToTaskAndHistory(currentData, {
+      state: "completed",
+      message: {
+        role: "agent",
+        parts: [
+          {
+            type: "text",
+            text
+          }
+        ]
+      }
+    });
+    await taskStore.save({ agentId, data: currentData });
+  } catch (handlerError) {
+    const failureStatusUpdate = {
+      state: "failed",
+      message: {
+        role: "agent",
+        parts: [
+          {
+            type: "text",
+            text: `Handler failed: ${handlerError instanceof Error ? handlerError.message : String(handlerError)}`
+          }
+        ]
+      }
+    };
+    currentData = applyUpdateToTaskAndHistory(currentData, failureStatusUpdate);
+    try {
+      await taskStore.save({ agentId, data: currentData });
+    } catch (saveError) {
+      logger?.error(`Failed to save task ${taskId} after handler error:`, saveError?.message);
+    }
+    return normalizeError(handlerError, requestId, taskId, logger);
+  }
+  return createSuccessResponse(requestId, currentData.task);
+}
+async function handleTaskGet({
+  requestId,
+  taskStore,
+  agentId,
+  taskId
+}) {
+  const task = await taskStore.load({ agentId, taskId });
+  if (!task) {
+    throw A2AError.taskNotFound(taskId);
+  }
+  return createSuccessResponse(requestId, task);
+}
+async function* handleTaskSendSubscribe({
+  requestId,
+  params,
+  taskStore,
+  agent,
+  agentId,
+  logger,
+  runtimeContext
+}) {
+  yield createSuccessResponse(requestId, {
+    state: "working",
+    message: {
+      role: "agent",
+      parts: [{ type: "text", text: "Generating response..." }]
+    }
+  });
+  let result;
+  try {
+    result = await handleTaskSend({
+      requestId,
+      params,
+      taskStore,
+      agent,
+      agentId,
+      runtimeContext,
+      logger
+    });
+  } catch (err) {
+    if (!(err instanceof A2AError)) {
+      throw err;
+    }
+    result = createErrorResponse(requestId, err.toJSONRPCError());
+  }
+  yield result;
+}
+async function handleTaskCancel({
+  requestId,
+  taskStore,
+  agentId,
+  taskId,
+  logger
+}) {
+  let data = await taskStore.load({
+    agentId,
+    taskId
+  });
+  if (!data) {
+    throw A2AError.taskNotFound(taskId);
+  }
+  const finalStates = ["completed", "failed", "canceled"];
+  if (finalStates.includes(data.task.status.state)) {
+    logger?.info(`Task ${taskId} already in final state ${data.task.status.state}, cannot cancel.`);
+    return createSuccessResponse(requestId, data.task);
+  }
+  taskStore.activeCancellations.add(taskId);
+  const cancelUpdate = {
+    state: "canceled",
+    message: {
+      role: "agent",
+      parts: [{ type: "text", text: "Task cancelled by request." }]
+    }
+  };
+  data = applyUpdateToTaskAndHistory(data, cancelUpdate);
+  await taskStore.save({ agentId, data });
+  taskStore.activeCancellations.delete(taskId);
+  return createSuccessResponse(requestId, data.task);
+}
+async function getAgentExecutionHandler({
+  requestId,
+  mastra,
+  agentId,
+  runtimeContext,
+  method,
+  params,
+  taskStore = new InMemoryTaskStore(),
+  logger
+}) {
+  const agent = mastra.getAgent(agentId);
+  let taskId;
+  try {
+    taskId = params.id;
+    switch (method) {
+      case "tasks/send": {
+        const result2 = await handleTaskSend({
+          requestId,
+          params,
+          taskStore,
+          agent,
+          agentId,
+          runtimeContext
+        });
+        return result2;
+      }
+      case "tasks/sendSubscribe":
+        const result = await handleTaskSendSubscribe({
+          requestId,
+          taskStore,
+          params,
+          agent,
+          agentId,
+          runtimeContext
+        });
+        return result;
+      case "tasks/get": {
+        const result2 = await handleTaskGet({
+          requestId,
+          taskStore,
+          agentId,
+          taskId
+        });
+        return result2;
+      }
+      case "tasks/cancel": {
+        const result2 = await handleTaskCancel({
+          requestId,
+          taskStore,
+          agentId,
+          taskId
+        });
+        return result2;
+      }
+      default:
+        throw A2AError.methodNotFound(method);
+    }
+  } catch (error) {
+    if (error instanceof A2AError && taskId && !error.taskId) {
+      error.taskId = taskId;
+    }
+    return normalizeError(error, requestId, taskId, logger);
+  }
+}
+
+export { a2a_exports, getAgentCardByIdHandler, getAgentExecutionHandler, handleTaskCancel, handleTaskGet, handleTaskSend, handleTaskSendSubscribe };

package/dist/{chunk-L7XE5QTW.js → chunk-H5PTF3Y4.js}

@@ -1,4 +1,4 @@
-import { HTTPException } from './chunk-TRDNDNGQ.js';
+import { HTTPException } from './chunk-NYN7KFXL.js';
 
 // src/server/handlers/utils.ts
 function validateBody(body) {

package/dist/{chunk-Y3SV5XK4.js → chunk-J3PKLB3A.js}

@@ -1,7 +1,9 @@
-import { stringify, esm_default } from './chunk-OMN3UI6X.js';
-import { validateBody } from './chunk-L7XE5QTW.js';
-import { handleError } from './chunk-3AHQ5RGN.js';
-import { __export, HTTPException } from './chunk-TRDNDNGQ.js';
+import { stringify, esm_default } from './chunk-LIVAK2DM.js';
+import { validateBody } from './chunk-H5PTF3Y4.js';
+import { handleError } from './chunk-M5ABIP7D.js';
+import { HTTPException } from './chunk-NYN7KFXL.js';
+import { __export } from './chunk-MLKGABMK.js';
+import { RuntimeContext } from '@mastra/core/runtime-context';
 
 // src/server/handlers/agents.ts
 var agents_exports = {};
@@ -30,13 +32,33 @@ async function getAgentsHandler({ mastra, runtimeContext }) {
           };
           return acc;
         }, {});
+        let serializedAgentWorkflows = {};
+        if ("getWorkflows" in agent) {
+          const logger = mastra.getLogger();
+          try {
+            const workflows = await agent.getWorkflows({ runtimeContext });
+            serializedAgentWorkflows = Object.entries(workflows || {}).reduce((acc, [key, workflow]) => {
+              return {
+                ...acc,
+                [key]: {
+                  name: workflow.name
+                }
+              };
+            }, {});
+          } catch (error) {
+            logger.error("Error getting workflows for agent", { agentName: agent.name, error });
+          }
+        }
         return {
           id,
           name: agent.name,
           instructions,
           tools: serializedAgentTools,
+          workflows: serializedAgentWorkflows,
           provider: llm?.getProvider(),
-          modelId: llm?.getModelId()
+          modelId: llm?.getModelId(),
+          defaultGenerateOptions: agent.getDefaultGenerateOptions(),
+          defaultStreamOptions: agent.getDefaultStreamOptions()
         };
       })
     );
@@ -69,14 +91,34 @@ async function getAgentByIdHandler({
       };
       return acc;
     }, {});
+    let serializedAgentWorkflows = {};
+    if ("getWorkflows" in agent) {
+      const logger = mastra.getLogger();
+      try {
+        const workflows = await agent.getWorkflows({ runtimeContext });
+        serializedAgentWorkflows = Object.entries(workflows || {}).reduce((acc, [key, workflow]) => {
+          return {
+            ...acc,
+            [key]: {
+              name: workflow.name
+            }
+          };
+        }, {});
+      } catch (error) {
+        logger.error("Error getting workflows for agent", { agentName: agent.name, error });
+      }
+    }
     const instructions = await agent.getInstructions({ runtimeContext });
     const llm = await agent.getLLM({ runtimeContext });
     return {
       name: agent.name,
       instructions,
       tools: serializedAgentTools,
+      workflows: serializedAgentWorkflows,
       provider: llm?.getProvider(),
-      modelId: llm?.getModelId()
+      modelId: llm?.getModelId(),
+      defaultGenerateOptions: agent.getDefaultGenerateOptions(),
+      defaultStreamOptions: agent.getDefaultStreamOptions()
     };
   } catch (error) {
     return handleError(error, "Error getting agent");
@@ -131,14 +173,18 @@ async function generateHandler({
     if (!agent) {
       throw new HTTPException(404, { message: "Agent not found" });
     }
-    const { messages, resourceId, resourceid, ...rest } = body;
+    const { messages, resourceId, resourceid, runtimeContext: agentRuntimeContext, ...rest } = body;
     const finalResourceId = resourceId ?? resourceid;
+    const finalRuntimeContext = new RuntimeContext([
+      ...Array.from(runtimeContext.entries()),
+      ...Array.from(Object.entries(agentRuntimeContext ?? {}))
+    ]);
     validateBody({ messages });
     const result = await agent.generate(messages, {
       ...rest,
       // @ts-expect-error TODO fix types
       resourceId: finalResourceId,
-      runtimeContext
+      runtimeContext: finalRuntimeContext
     });
     return result;
   } catch (error) {
@@ -156,14 +202,18 @@ async function streamGenerateHandler({
     if (!agent) {
       throw new HTTPException(404, { message: "Agent not found" });
     }
-    const { messages, resourceId, resourceid, ...rest } = body;
+    const { messages, resourceId, resourceid, runtimeContext: agentRuntimeContext, ...rest } = body;
     const finalResourceId = resourceId ?? resourceid;
+    const finalRuntimeContext = new RuntimeContext([
+      ...Array.from(runtimeContext.entries()),
+      ...Array.from(Object.entries(agentRuntimeContext ?? {}))
+    ]);
     validateBody({ messages });
     const streamResult = await agent.stream(messages, {
       ...rest,
       // @ts-expect-error TODO fix types
       resourceId: finalResourceId,
-      runtimeContext
+      runtimeContext: finalRuntimeContext
     });
     const streamResponse = rest.output ? streamResult.toTextStreamResponse() : streamResult.toDataStreamResponse({
       sendUsage: true,