@mastra/server 0.0.0-commonjs-20250414101718

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-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-3EJZQ6TQ.js

@@ -0,0 +1,49 @@
+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-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;

package/dist/chunk-4JINXASC.js

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