@mastra/server 0.0.1-alpha.0

package/dist/chunk-2FJURXCL.cjs

@@ -0,0 +1,213 @@
+'use strict';
+
+var chunkQN4KF3BH_cjs = require('./chunk-QN4KF3BH.cjs');
+var chunkZLBRQFDD_cjs = require('./chunk-ZLBRQFDD.cjs');
+var chunkFV45V6WC_cjs = require('./chunk-FV45V6WC.cjs');
+
+// src/server/handlers/memory.ts
+var memory_exports = {};
+chunkFV45V6WC_cjs.__export(memory_exports, {
+  createThreadHandler: () => createThreadHandler,
+  deleteThreadHandler: () => deleteThreadHandler,
+  getMemoryStatusHandler: () => getMemoryStatusHandler,
+  getMessagesHandler: () => getMessagesHandler,
+  getThreadByIdHandler: () => getThreadByIdHandler,
+  getThreadsHandler: () => getThreadsHandler,
+  saveMessagesHandler: () => saveMessagesHandler,
+  updateThreadHandler: () => updateThreadHandler
+});
+function getMemoryFromContext({
+  mastra,
+  agentId
+}) {
+  const agent = agentId ? mastra.getAgent(agentId) : null;
+  if (agentId && !agent) {
+    throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Agent not found" });
+  }
+  const memory = agent?.getMemory?.() || mastra.getMemory();
+  return memory;
+}
+async function getMemoryStatusHandler({ mastra, agentId }) {
+  try {
+    const memory = getMemoryFromContext({ mastra, agentId });
+    if (!memory) {
+      return { result: false };
+    }
+    return { result: true };
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error getting memory status");
+  }
+}
+async function getThreadsHandler({
+  mastra,
+  agentId,
+  resourceId
+}) {
+  try {
+    const memory = getMemoryFromContext({ mastra, agentId });
+    if (!memory) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    chunkQN4KF3BH_cjs.validateBody({ resourceId });
+    const threads = await memory.getThreadsByResourceId({ resourceId });
+    return threads;
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error getting threads");
+  }
+}
+async function getThreadByIdHandler({
+  mastra,
+  agentId,
+  threadId
+}) {
+  try {
+    chunkQN4KF3BH_cjs.validateBody({ threadId });
+    const memory = getMemoryFromContext({ mastra, agentId });
+    if (!memory) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Thread not found" });
+    }
+    return thread;
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error getting thread");
+  }
+}
+async function saveMessagesHandler({
+  mastra,
+  agentId,
+  body
+}) {
+  try {
+    const memory = getMemoryFromContext({ mastra, agentId });
+    if (!memory) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    if (!body?.messages) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Messages are required" });
+    }
+    if (!Array.isArray(body.messages)) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Messages should be an array" });
+    }
+    const processedMessages = body.messages.map((message) => ({
+      ...message,
+      id: memory.generateId(),
+      createdAt: message.createdAt ? new Date(message.createdAt) : /* @__PURE__ */ new Date()
+    }));
+    const result = await memory.saveMessages({ messages: processedMessages, memoryConfig: {} });
+    return result;
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error saving messages");
+  }
+}
+async function createThreadHandler({
+  mastra,
+  agentId,
+  body
+}) {
+  try {
+    const memory = getMemoryFromContext({ mastra, agentId });
+    if (!memory) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    chunkQN4KF3BH_cjs.validateBody({ resourceId: body?.resourceId });
+    const result = await memory.createThread({
+      resourceId: body?.resourceId,
+      title: body?.title,
+      metadata: body?.metadata,
+      threadId: body?.threadId
+    });
+    return result;
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error saving thread to memory");
+  }
+}
+async function updateThreadHandler({
+  mastra,
+  agentId,
+  threadId,
+  body
+}) {
+  try {
+    const memory = getMemoryFromContext({ mastra, agentId });
+    if (!body) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Body is required" });
+    }
+    const { title, metadata, resourceId } = body;
+    const updatedAt = /* @__PURE__ */ new Date();
+    chunkQN4KF3BH_cjs.validateBody({ threadId });
+    if (!memory) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Thread not found" });
+    }
+    const updatedThread = {
+      ...thread,
+      title: title || thread.title,
+      metadata: metadata || thread.metadata,
+      resourceId: resourceId || thread.resourceId,
+      createdAt: thread.createdAt,
+      updatedAt
+    };
+    const result = await memory.saveThread({ thread: updatedThread });
+    return result;
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error updating thread");
+  }
+}
+async function deleteThreadHandler({
+  mastra,
+  agentId,
+  threadId
+}) {
+  try {
+    chunkQN4KF3BH_cjs.validateBody({ threadId });
+    const memory = getMemoryFromContext({ mastra, agentId });
+    if (!memory) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Thread not found" });
+    }
+    await memory.deleteThread(threadId);
+    return { result: "Thread deleted" };
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error deleting thread");
+  }
+}
+async function getMessagesHandler({
+  mastra,
+  agentId,
+  threadId
+}) {
+  try {
+    chunkQN4KF3BH_cjs.validateBody({ threadId });
+    const memory = getMemoryFromContext({ mastra, agentId });
+    if (!memory) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Thread not found" });
+    }
+    const result = await memory.query({ threadId });
+    return result;
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error getting messages");
+  }
+}
+
+exports.createThreadHandler = createThreadHandler;
+exports.deleteThreadHandler = deleteThreadHandler;
+exports.getMemoryStatusHandler = getMemoryStatusHandler;
+exports.getMessagesHandler = getMessagesHandler;
+exports.getThreadByIdHandler = getThreadByIdHandler;
+exports.getThreadsHandler = getThreadsHandler;
+exports.memory_exports = memory_exports;
+exports.saveMessagesHandler = saveMessagesHandler;
+exports.updateThreadHandler = updateThreadHandler;

package/dist/chunk-2JQC6JWP.js

@@ -0,0 +1,46 @@
+import { validateBody } from './chunk-L7XE5QTW.js';
+import { handleError } from './chunk-3AHQ5RGN.js';
+import { __export } from './chunk-TRDNDNGQ.js';
+
+// src/server/handlers/logs.ts
+var logs_exports = {};
+__export(logs_exports, {
+  getLogTransports: () => getLogTransports,
+  getLogsByRunIdHandler: () => getLogsByRunIdHandler,
+  getLogsHandler: () => getLogsHandler
+});
+async function getLogsHandler({ mastra, transportId }) {
+  try {
+    validateBody({ transportId });
+    const logs = await mastra.getLogs(transportId);
+    return logs;
+  } catch (error) {
+    return handleError(error, "Error getting logs");
+  }
+}
+async function getLogsByRunIdHandler({
+  mastra,
+  runId,
+  transportId
+}) {
+  try {
+    validateBody({ runId, transportId });
+    const logs = await mastra.getLogsByRunId({ runId, transportId });
+    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.transports;
+    return {
+      transports: transports ? Object.keys(transports) : []
+    };
+  } catch (error) {
+    return handleError(error, "Error getting log Transports");
+  }
+}
+
+export { getLogTransports, getLogsByRunIdHandler, getLogsHandler, logs_exports };

package/dist/chunk-2YONKUWB.js

@@ -0,0 +1,117 @@
+import { validateBody } from './chunk-L7XE5QTW.js';
+import { handleError } from './chunk-3AHQ5RGN.js';
+import { __export, HTTPException } from './chunk-TRDNDNGQ.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,
+  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);
+    return result;
+  } catch (error) {
+    return handleError(error, "Error generating from network");
+  }
+}
+async function streamGenerateHandler({
+  mastra,
+  networkId,
+  body
+}) {
+  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
+    });
+    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-3AHQ5RGN.js

@@ -0,0 +1,11 @@
+import { HTTPException } from './chunk-TRDNDNGQ.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 };

package/dist/chunk-3RVHWGWO.js

@@ -0,0 +1,95 @@
+import { validateBody } from './chunk-L7XE5QTW.js';
+import { handleError } from './chunk-3AHQ5RGN.js';
+import { __export, HTTPException } from './chunk-TRDNDNGQ.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-4C3EPMMF.cjs

@@ -0,0 +1,122 @@
+'use strict';
+
+var chunkQH6XWSXP_cjs = require('./chunk-QH6XWSXP.cjs');
+var chunkQN4KF3BH_cjs = require('./chunk-QN4KF3BH.cjs');
+var chunkZLBRQFDD_cjs = require('./chunk-ZLBRQFDD.cjs');
+var chunkFV45V6WC_cjs = require('./chunk-FV45V6WC.cjs');
+var tools = require('@mastra/core/tools');
+
+// src/server/handlers/tools.ts
+var tools_exports = {};
+chunkFV45V6WC_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 ? chunkQH6XWSXP_cjs.stringify(chunkQH6XWSXP_cjs.esm_default(tool.inputSchema)) : void 0,
+          outputSchema: tool.outputSchema ? chunkQH6XWSXP_cjs.stringify(chunkQH6XWSXP_cjs.esm_default(tool.outputSchema)) : void 0
+        };
+        return acc;
+      },
+      {}
+    );
+    return serializedTools;
+  } catch (error) {
+    return chunkZLBRQFDD_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 chunkFV45V6WC_cjs.HTTPException(404, { message: "Tool not found" });
+    }
+    const serializedTool = {
+      ...tool,
+      inputSchema: tool.inputSchema ? chunkQH6XWSXP_cjs.stringify(chunkQH6XWSXP_cjs.esm_default(tool.inputSchema)) : void 0,
+      outputSchema: tool.outputSchema ? chunkQH6XWSXP_cjs.stringify(chunkQH6XWSXP_cjs.esm_default(tool.outputSchema)) : void 0
+    };
+    return serializedTool;
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error getting tool");
+  }
+}
+function executeToolHandler(tools$1) {
+  return async ({
+    mastra,
+    runId,
+    toolId,
+    data
+  }) => {
+    try {
+      if (!toolId) {
+        throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Tool ID is required" });
+      }
+      const tool = Object.values(tools$1 || {}).find((tool2) => tool2.id === toolId);
+      if (!tool) {
+        throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Tool not found" });
+      }
+      if (!tool?.execute) {
+        throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Tool is not executable" });
+      }
+      chunkQN4KF3BH_cjs.validateBody({ data });
+      if (tools.isVercelTool(tool)) {
+        const result2 = await tool.execute(data);
+        return result2;
+      }
+      const result = await tool.execute({
+        context: data,
+        mastra,
+        runId
+      });
+      return result;
+    } catch (error) {
+      return chunkZLBRQFDD_cjs.handleError(error, "Error executing tool");
+    }
+  };
+}
+async function executeAgentToolHandler({
+  mastra,
+  agentId,
+  toolId,
+  data
+}) {
+  try {
+    const agent = agentId ? mastra.getAgent(agentId) : null;
+    if (!agent) {
+      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Tool not found" });
+    }
+    const tool = Object.values(agent?.tools || {}).find((tool2) => tool2.id === toolId);
+    if (!tool) {
+      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Tool not found" });
+    }
+    if (!tool?.execute) {
+      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Tool is not executable" });
+    }
+    const result = await tool.execute({
+      context: data,
+      mastra,
+      runId: agentId
+    });
+    return result;
+  } catch (error) {
+    return chunkZLBRQFDD_cjs.handleError(error, "Error executing tool");
+  }
+}
+
+exports.executeAgentToolHandler = executeAgentToolHandler;
+exports.executeToolHandler = executeToolHandler;
+exports.getToolByIdHandler = getToolByIdHandler;
+exports.getToolsHandler = getToolsHandler;
+exports.tools_exports = tools_exports;