@mastra/server 0.0.0-commonjs-20250414101718 → 0.0.0-custom-instrumentation-20250626084921

package/dist/chunk-PMUATKV2.js

@@ -0,0 +1,270 @@
+import { stringify, esm_default } from './chunk-OSZM4EAY.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 = {};
+__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) {
+    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-QLG2PFHE.js

@@ -0,0 +1,81 @@
+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 = {};
+__export(logs_exports, {
+  getLogTransports: () => getLogTransports,
+  getLogsByRunIdHandler: () => getLogsByRunIdHandler,
+  getLogsHandler: () => getLogsHandler
+});
+async function getLogsHandler({
+  mastra,
+  transportId,
+  params
+}) {
+  try {
+    validateBody({ transportId });
+    const { fromDate, toDate, logLevel, filters: _filters, page, perPage } = params || {};
+    const filters = _filters ? Object.fromEntries(
+      (Array.isArray(_filters) ? _filters : [_filters]).map((attr) => {
+        const [key, value] = attr.split(":");
+        return [key, value];
+      })
+    ) : void 0;
+    const logs = await mastra.getLogs(transportId, {
+      fromDate,
+      toDate,
+      logLevel,
+      filters,
+      page: page ? Number(page) : void 0,
+      perPage: perPage ? Number(perPage) : void 0
+    });
+    return logs;
+  } catch (error) {
+    return handleError(error, "Error getting logs");
+  }
+}
+async function getLogsByRunIdHandler({
+  mastra,
+  runId,
+  transportId,
+  params
+}) {
+  try {
+    validateBody({ runId, transportId });
+    const { fromDate, toDate, logLevel, filters: _filters, page, perPage } = params || {};
+    const filters = _filters ? Object.fromEntries(
+      (Array.isArray(_filters) ? _filters : [_filters]).map((attr) => {
+        const [key, value] = attr.split(":");
+        return [key, value];
+      })
+    ) : void 0;
+    const logs = await mastra.getLogsByRunId({
+      runId,
+      transportId,
+      fromDate,
+      toDate,
+      logLevel,
+      filters,
+      page: page ? Number(page) : void 0,
+      perPage: perPage ? Number(perPage) : void 0
+    });
+    return logs;
+  } catch (error) {
+    return handleError(error, "Error getting logs by run ID");
+  }
+}
+async function getLogTransports({ mastra }) {
+  try {
+    const logger = mastra.getLogger();
+    const transports = logger.getTransports();
+    return {
+      transports: transports ? [...transports.keys()] : []
+    };
+  } catch (error) {
+    return handleError(error, "Error getting log Transports");
+  }
+}
+
+export { getLogTransports, getLogsByRunIdHandler, getLogsHandler, logs_exports };

package/dist/{chunk-3RVHWGWO.js → chunk-R5VGYBV6.js}

@@ -1,12 +1,14 @@
-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';
 import { Readable } from 'stream';
 
 // src/server/handlers/voice.ts
 var voice_exports = {};
 __export(voice_exports, {
   generateSpeechHandler: () => generateSpeechHandler,
+  getListenerHandler: () => getListenerHandler,
   getSpeakersHandler: () => getSpeakersHandler,
   transcribeSpeechHandler: () => transcribeSpeechHandler
 });
@@ -19,10 +21,11 @@ async function getSpeakersHandler({ mastra, agentId }) {
     if (!agent) {
       throw new HTTPException(404, { message: "Agent not found" });
     }
-    if (!agent.voice) {
+    const voice = await agent.getVoice();
+    if (!voice) {
       throw new HTTPException(400, { message: "Agent does not have voice capabilities" });
     }
-    const speakers = await agent.voice.getSpeakers();
+    const speakers = await voice.getSpeakers();
     return speakers;
   } catch (error) {
     return handleError(error, "Error getting speakers");
@@ -38,27 +41,21 @@ async function generateSpeechHandler({
       throw new HTTPException(400, { message: "Agent ID is required" });
     }
     validateBody({
-      text: void 0,
-      speakerId: void 0,
-      ...body
+      text: body?.text
     });
     const agent = mastra.getAgent(agentId);
     if (!agent) {
       throw new HTTPException(404, { message: "Agent not found" });
     }
-    if (!agent.voice) {
+    const voice = await agent.getVoice();
+    if (!voice) {
       throw new HTTPException(400, { message: "Agent does not have voice capabilities" });
     }
-    const audioStream = await agent.voice.speak(body.text, { speaker: body.speakerId });
+    const audioStream = await 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 };
+    return audioStream;
   } catch (error) {
     return handleError(error, "Error generating speech");
   }
@@ -79,17 +76,37 @@ async function transcribeSpeechHandler({
     if (!agent) {
       throw new HTTPException(404, { message: "Agent not found" });
     }
-    if (!agent.voice) {
+    const voice = await agent.getVoice();
+    if (!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);
+    const text = await voice.listen(audioStream, body.options);
     return { text };
   } catch (error) {
     return handleError(error, "Error transcribing speech");
   }
 }
+async function getListenerHandler({ 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" });
+    }
+    const voice = await agent.getVoice();
+    if (!voice) {
+      throw new HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const listeners = await voice.getListener();
+    return listeners;
+  } catch (error) {
+    return handleError(error, "Error getting listeners");
+  }
+}
 
-export { generateSpeechHandler, getSpeakersHandler, transcribeSpeechHandler, voice_exports };
+export { generateSpeechHandler, getListenerHandler, getSpeakersHandler, transcribeSpeechHandler, voice_exports };