@mastra/server 0.10.13 → 0.10.15-alpha.0

package/dist/chunk-BK4XT6EG.js

@@ -0,0 +1,270 @@
+import { stringify, esm_default } from './chunk-MEGCYGBU.js';
+import { validateBody } from './chunk-RSEO4XPX.js';
+import { handleError } from './chunk-LF7P5PLR.js';
+import { HTTPException } from './chunk-LCM566I4.js';
+import { __export } from './chunk-MLKGABMK.js';
+import { RuntimeContext } from '@mastra/core/runtime-context';
+
+// 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, runtimeContext }) {
+  try {
+    const agents = mastra.getAgents();
+    const serializedAgentsMap = await Promise.all(
+      Object.entries(agents).map(async ([id, agent]) => {
+        const instructions = await agent.getInstructions({ runtimeContext });
+        const tools = await agent.getTools({ runtimeContext });
+        const llm = await agent.getLLM({ runtimeContext });
+        const defaultGenerateOptions = await agent.getDefaultGenerateOptions({ runtimeContext });
+        const defaultStreamOptions = await agent.getDefaultStreamOptions({ runtimeContext });
+        const serializedAgentTools = Object.entries(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;
+        }, {});
+        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(),
+          defaultGenerateOptions,
+          defaultStreamOptions
+        };
+      })
+    );
+    const serializedAgents = serializedAgentsMap.reduce((acc, { id, ...rest }) => {
+      acc[id] = rest;
+      return acc;
+    }, {});
+    return serializedAgents;
+  } catch (error) {
+    return handleError(error, "Error getting agents");
+  }
+}
+async function getAgentByIdHandler({
+  mastra,
+  runtimeContext,
+  agentId,
+  isPlayground = false
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new HTTPException(404, { message: "Agent not found" });
+    }
+    const tools = await agent.getTools({ runtimeContext });
+    const serializedAgentTools = Object.entries(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;
+    }, {});
+    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,
+              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 proxyRuntimeContext = runtimeContext;
+    if (isPlayground) {
+      proxyRuntimeContext = new Proxy(runtimeContext, {
+        get(target, prop) {
+          if (prop === "get") {
+            return function(key) {
+              const value = target.get(key);
+              return value ?? `<${key}>`;
+            };
+          }
+          return Reflect.get(target, prop);
+        }
+      });
+    }
+    const instructions = await agent.getInstructions({ runtimeContext: proxyRuntimeContext });
+    const llm = await agent.getLLM({ runtimeContext });
+    const defaultGenerateOptions = await agent.getDefaultGenerateOptions({ runtimeContext: proxyRuntimeContext });
+    const defaultStreamOptions = await agent.getDefaultStreamOptions({ runtimeContext: proxyRuntimeContext });
+    return {
+      name: agent.name,
+      instructions,
+      tools: serializedAgentTools,
+      workflows: serializedAgentWorkflows,
+      provider: llm?.getProvider(),
+      modelId: llm?.getModelId(),
+      defaultGenerateOptions,
+      defaultStreamOptions
+    };
+  } catch (error) {
+    return handleError(error, "Error getting agent");
+  }
+}
+async function getEvalsByAgentIdHandler({
+  mastra,
+  runtimeContext,
+  agentId
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    const evals = await mastra.getStorage()?.getEvalsByAgentName?.(agent.name, "test") || [];
+    const instructions = await agent.getInstructions({ runtimeContext });
+    return {
+      id: agentId,
+      name: agent.name,
+      instructions,
+      evals
+    };
+  } catch (error) {
+    return handleError(error, "Error getting test evals");
+  }
+}
+async function getLiveEvalsByAgentIdHandler({
+  mastra,
+  runtimeContext,
+  agentId
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    const evals = await mastra.getStorage()?.getEvalsByAgentName?.(agent.name, "live") || [];
+    const instructions = await agent.getInstructions({ runtimeContext });
+    return {
+      id: agentId,
+      name: agent.name,
+      instructions,
+      evals
+    };
+  } catch (error) {
+    return handleError(error, "Error getting live evals");
+  }
+}
+async function generateHandler({
+  mastra,
+  runtimeContext,
+  agentId,
+  body,
+  abortSignal
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new HTTPException(404, { message: "Agent not found" });
+    }
+    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: finalRuntimeContext,
+      signal: abortSignal
+    });
+    return result;
+  } catch (error) {
+    return handleError(error, "Error generating from agent");
+  }
+}
+async function streamGenerateHandler({
+  mastra,
+  runtimeContext,
+  agentId,
+  body,
+  abortSignal
+}) {
+  try {
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new HTTPException(404, { message: "Agent not found" });
+    }
+    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: finalRuntimeContext,
+      signal: abortSignal
+    });
+    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");
+  }
+}
+
+export { agents_exports, generateHandler, getAgentByIdHandler, getAgentsHandler, getEvalsByAgentIdHandler, getLiveEvalsByAgentIdHandler, streamGenerateHandler };

package/dist/chunk-CCGRCYWJ.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var chunk2KZFMI6P_cjs = require('./chunk-2KZFMI6P.cjs');
+
+// 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 chunk2KZFMI6P_cjs.HTTPException(400, { message: Object.values(errorResponse)[0] });
+  }
+}
+
+exports.validateBody = validateBody;

package/dist/chunk-CRCR3ZUK.js

@@ -0,0 +1,142 @@
+import { validateBody } from './chunk-RSEO4XPX.js';
+import { handleError } from './chunk-LF7P5PLR.js';
+import { HTTPException } from './chunk-LCM566I4.js';
+import { __export } from './chunk-MLKGABMK.js';
+
+// src/server/handlers/network.ts
+var network_exports = {};
+__export(network_exports, {
+  generateHandler: () => generateHandler,
+  getNetworkByIdHandler: () => getNetworkByIdHandler,
+  getNetworksHandler: () => getNetworksHandler,
+  streamGenerateHandler: () => streamGenerateHandler
+});
+async function getNetworksHandler({
+  mastra,
+  runtimeContext
+}) {
+  try {
+    const networks = mastra.getNetworks();
+    const serializedNetworks = await Promise.all(
+      networks.map(async (network) => {
+        const routingAgent = network.getRoutingAgent();
+        const routingLLM = await routingAgent.getLLM({ runtimeContext });
+        const agents = network.getAgents();
+        return {
+          id: network.formatAgentId(routingAgent.name),
+          name: routingAgent.name,
+          instructions: routingAgent.instructions,
+          agents: await Promise.all(
+            agents.map(async (agent) => {
+              const llm = await agent.getLLM({ runtimeContext });
+              return {
+                name: agent.name,
+                provider: llm?.getProvider(),
+                modelId: llm?.getModelId()
+              };
+            })
+          ),
+          routingModel: {
+            provider: routingLLM?.getProvider(),
+            modelId: routingLLM?.getModelId()
+          }
+        };
+      })
+    );
+    return serializedNetworks;
+  } catch (error) {
+    return handleError(error, "Error getting networks");
+  }
+}
+async function getNetworkByIdHandler({
+  mastra,
+  networkId,
+  runtimeContext
+}) {
+  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 routingLLM = await routingAgent.getLLM({ runtimeContext });
+    const agents = network.getAgents();
+    const serializedNetwork = {
+      id: network.formatAgentId(routingAgent.name),
+      name: routingAgent.name,
+      instructions: routingAgent.instructions,
+      agents: await Promise.all(
+        agents.map(async (agent) => {
+          const llm = await agent.getLLM({ runtimeContext });
+          return {
+            name: agent.name,
+            provider: llm?.getProvider(),
+            modelId: llm?.getModelId()
+          };
+        })
+      ),
+      routingModel: {
+        provider: routingLLM?.getProvider(),
+        modelId: routingLLM?.getModelId()
+      }
+    };
+    return serializedNetwork;
+  } catch (error) {
+    return handleError(error, "Error getting network by ID");
+  }
+}
+async function generateHandler({
+  mastra,
+  runtimeContext,
+  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, runtimeContext });
+    return result;
+  } catch (error) {
+    return handleError(error, "Error generating from network");
+  }
+}
+async function streamGenerateHandler({
+  mastra,
+  networkId,
+  body,
+  runtimeContext
+}) {
+  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,
+      runtimeContext
+    });
+    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-FRVBFMO2.cjs

@@ -0,0 +1,128 @@
+'use strict';
+
+var chunkLI436ITD_cjs = require('./chunk-LI436ITD.cjs');
+var chunkCCGRCYWJ_cjs = require('./chunk-CCGRCYWJ.cjs');
+var chunkPZQDCRPV_cjs = require('./chunk-PZQDCRPV.cjs');
+var chunk2KZFMI6P_cjs = require('./chunk-2KZFMI6P.cjs');
+var chunk75ZPJI57_cjs = require('./chunk-75ZPJI57.cjs');
+var tools = require('@mastra/core/tools');
+
+// src/server/handlers/tools.ts
+var tools_exports = {};
+chunk75ZPJI57_cjs.__export(tools_exports, {
+  executeAgentToolHandler: () => executeAgentToolHandler,
+  executeToolHandler: () => executeToolHandler,
+  getToolByIdHandler: () => getToolByIdHandler,
+  getToolsHandler: () => getToolsHandler
+});
+async function getToolsHandler({ tools }) {
+  try {
+    if (!tools) {
+      return {};
+    }
+    const serializedTools = Object.entries(tools).reduce(
+      (acc, [id, _tool]) => {
+        const tool = _tool;
+        acc[id] = {
+          ...tool,
+          inputSchema: tool.inputSchema ? chunkLI436ITD_cjs.stringify(chunkLI436ITD_cjs.esm_default(tool.inputSchema)) : void 0,
+          outputSchema: tool.outputSchema ? chunkLI436ITD_cjs.stringify(chunkLI436ITD_cjs.esm_default(tool.outputSchema)) : void 0
+        };
+        return acc;
+      },
+      {}
+    );
+    return serializedTools;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting tools");
+  }
+}
+async function getToolByIdHandler({ tools, toolId }) {
+  try {
+    const tool = Object.values(tools || {}).find((tool2) => tool2.id === toolId);
+    if (!tool) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Tool not found" });
+    }
+    const serializedTool = {
+      ...tool,
+      inputSchema: tool.inputSchema ? chunkLI436ITD_cjs.stringify(chunkLI436ITD_cjs.esm_default(tool.inputSchema)) : void 0,
+      outputSchema: tool.outputSchema ? chunkLI436ITD_cjs.stringify(chunkLI436ITD_cjs.esm_default(tool.outputSchema)) : void 0
+    };
+    return serializedTool;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting tool");
+  }
+}
+function executeToolHandler(tools$1) {
+  return async ({
+    mastra,
+    runId,
+    toolId,
+    data,
+    runtimeContext
+  }) => {
+    try {
+      if (!toolId) {
+        throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Tool ID is required" });
+      }
+      const tool = Object.values(tools$1 || {}).find((tool2) => tool2.id === toolId);
+      if (!tool) {
+        throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Tool not found" });
+      }
+      if (!tool?.execute) {
+        throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Tool is not executable" });
+      }
+      chunkCCGRCYWJ_cjs.validateBody({ data });
+      if (tools.isVercelTool(tool)) {
+        const result2 = await tool.execute(data);
+        return result2;
+      }
+      const result = await tool.execute({
+        context: data,
+        mastra,
+        runId,
+        runtimeContext
+      });
+      return result;
+    } catch (error) {
+      return chunkPZQDCRPV_cjs.handleError(error, "Error executing tool");
+    }
+  };
+}
+async function executeAgentToolHandler({
+  mastra,
+  agentId,
+  toolId,
+  data,
+  runtimeContext
+}) {
+  try {
+    const agent = agentId ? mastra.getAgent(agentId) : null;
+    if (!agent) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Tool not found" });
+    }
+    const agentTools = await agent.getTools({ runtimeContext });
+    const tool = Object.values(agentTools || {}).find((tool2) => tool2.id === toolId);
+    if (!tool) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Tool not found" });
+    }
+    if (!tool?.execute) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Tool is not executable" });
+    }
+    const result = await tool.execute({
+      context: data,
+      runtimeContext,
+      mastra,
+      runId: agentId
+    });
+    return result;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error executing tool");
+  }
+}
+
+exports.executeAgentToolHandler = executeAgentToolHandler;
+exports.executeToolHandler = executeToolHandler;
+exports.getToolByIdHandler = getToolByIdHandler;
+exports.getToolsHandler = getToolsHandler;
+exports.tools_exports = tools_exports;

package/dist/chunk-G7KH752Y.cjs

@@ -0,0 +1,145 @@
+'use strict';
+
+var chunkPZQDCRPV_cjs = require('./chunk-PZQDCRPV.cjs');
+var chunk2KZFMI6P_cjs = require('./chunk-2KZFMI6P.cjs');
+var chunk75ZPJI57_cjs = require('./chunk-75ZPJI57.cjs');
+
+// src/server/handlers/telemetry.ts
+var telemetry_exports = {};
+chunk75ZPJI57_cjs.__export(telemetry_exports, {
+  getTelemetryHandler: () => getTelemetryHandler,
+  storeTelemetryHandler: () => storeTelemetryHandler
+});
+async function getTelemetryHandler({ mastra, body }) {
+  try {
+    const telemetry = mastra.getTelemetry();
+    const storage = mastra.getStorage();
+    if (!telemetry) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Telemetry is not initialized" });
+    }
+    if (!storage) {
+      return [];
+    }
+    if (!body) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Body is required" });
+    }
+    const { name, scope, page, perPage, attribute, fromDate, toDate } = body;
+    const attributes = attribute ? Object.fromEntries(
+      (Array.isArray(attribute) ? attribute : [attribute]).map((attr) => {
+        const [key, value] = attr.split(":");
+        return [key, value];
+      })
+    ) : void 0;
+    const traces = await storage.getTraces({
+      name,
+      scope,
+      page: Number(page ?? 0),
+      perPage: Number(perPage ?? 100),
+      attributes,
+      fromDate: fromDate ? new Date(fromDate) : void 0,
+      toDate: toDate ? new Date(toDate) : void 0
+    });
+    return traces;
+  } catch (error2) {
+    return chunkPZQDCRPV_cjs.handleError(error2, "Error getting telemetry");
+  }
+}
+async function storeTelemetryHandler({ mastra, body }) {
+  try {
+    const storage = mastra.getStorage();
+    const logger = mastra.getLogger();
+    if (!storage) {
+      return {
+        status: "error",
+        message: "Storage is not initialized"
+      };
+    }
+    const now = /* @__PURE__ */ new Date();
+    const items = body?.resourceSpans?.[0]?.scopeSpans;
+    logger.debug("[Telemetry Handler] Received spans:", {
+      totalSpans: items?.reduce((acc, scope) => acc + scope.spans.length, 0) || 0,
+      timestamp: now.toISOString()
+    });
+    if (!items?.length) {
+      return {
+        status: "success",
+        message: "No spans to process",
+        traceCount: 0
+      };
+    }
+    const allSpans = items.reduce((acc, scopedSpans) => {
+      const { scope, spans } = scopedSpans;
+      for (const span of spans) {
+        const {
+          spanId,
+          parentSpanId,
+          traceId,
+          name,
+          kind,
+          attributes,
+          status,
+          events,
+          links,
+          startTimeUnixNano,
+          endTimeUnixNano,
+          ...rest
+        } = span;
+        const startTime = Number(BigInt(startTimeUnixNano) / 1000n);
+        const endTime = Number(BigInt(endTimeUnixNano) / 1000n);
+        acc.push({
+          id: spanId,
+          parentSpanId,
+          traceId,
+          name,
+          scope: scope.name,
+          kind,
+          status: JSON.stringify(status),
+          events: JSON.stringify(events),
+          links: JSON.stringify(links),
+          attributes: JSON.stringify(
+            attributes.reduce((acc2, attr) => {
+              const valueKey = Object.keys(attr.value)[0];
+              if (valueKey) {
+                acc2[attr.key] = attr.value[valueKey];
+              }
+              return acc2;
+            }, {})
+          ),
+          startTime,
+          endTime,
+          other: JSON.stringify(rest),
+          createdAt: now
+        });
+      }
+      return acc;
+    }, []);
+    return storage.batchTraceInsert({
+      records: allSpans
+    }).then(() => {
+      return {
+        status: "success",
+        message: "Traces received and processed successfully",
+        traceCount: body.resourceSpans?.length || 0
+      };
+    }).catch(() => {
+      return {
+        status: "error",
+        message: "Failed to process traces",
+        // @ts-ignore
+        error: error.message
+      };
+    });
+  } catch (error2) {
+    console.error("Error processing traces:", error2);
+    return {
+      status: "error",
+      message: "Failed to process traces",
+      // @ts-ignore
+      error: error2.message
+    };
+  }
+}
+
+exports.getTelemetryHandler = getTelemetryHandler;
+exports.storeTelemetryHandler = storeTelemetryHandler;
+exports.telemetry_exports = telemetry_exports;