@mastra/server 0.10.13 → 0.10.14

package/dist/chunk-MKLYEKEF.js

@@ -0,0 +1,241 @@
+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/memory.ts
+var memory_exports = {};
+__export(memory_exports, {
+  createThreadHandler: () => createThreadHandler,
+  deleteThreadHandler: () => deleteThreadHandler,
+  getMemoryStatusHandler: () => getMemoryStatusHandler,
+  getMessagesHandler: () => getMessagesHandler,
+  getThreadByIdHandler: () => getThreadByIdHandler,
+  getThreadsHandler: () => getThreadsHandler,
+  saveMessagesHandler: () => saveMessagesHandler,
+  updateThreadHandler: () => updateThreadHandler
+});
+async function getMemoryFromContext({
+  mastra,
+  agentId,
+  networkId,
+  runtimeContext
+}) {
+  const agent = agentId ? mastra.getAgent(agentId) : null;
+  if (agentId && !agent) {
+    throw new HTTPException(404, { message: "Agent not found" });
+  }
+  const network = networkId ? mastra.vnext_getNetwork(networkId) : null;
+  if (networkId && !network) {
+    throw new HTTPException(404, { message: "Network not found" });
+  }
+  if (agent) {
+    return agent?.getMemory() || mastra.getMemory();
+  }
+  if (network) {
+    return await network?.getMemory({ runtimeContext }) || mastra.getMemory();
+  }
+  return mastra.getMemory();
+}
+async function getMemoryStatusHandler({
+  mastra,
+  agentId,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      return { result: false };
+    }
+    return { result: true };
+  } catch (error) {
+    return handleError(error, "Error getting memory status");
+  }
+}
+async function getThreadsHandler({
+  mastra,
+  agentId,
+  resourceId,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      throw new HTTPException(400, { message: "Memory is not initialized" });
+    }
+    validateBody({ resourceId });
+    const threads = await memory.getThreadsByResourceId({ resourceId });
+    return threads;
+  } catch (error) {
+    return handleError(error, "Error getting threads");
+  }
+}
+async function getThreadByIdHandler({
+  mastra,
+  agentId,
+  threadId,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      throw new HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new HTTPException(404, { message: "Thread not found" });
+    }
+    return thread;
+  } catch (error) {
+    return handleError(error, "Error getting thread");
+  }
+}
+async function saveMessagesHandler({
+  mastra,
+  agentId,
+  body,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      throw new HTTPException(400, { message: "Memory is not initialized" });
+    }
+    if (!body?.messages) {
+      throw new HTTPException(400, { message: "Messages are required" });
+    }
+    if (!Array.isArray(body.messages)) {
+      throw new 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 handleError(error, "Error saving messages");
+  }
+}
+async function createThreadHandler({
+  mastra,
+  agentId,
+  body,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      throw new HTTPException(400, { message: "Memory is not initialized" });
+    }
+    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 handleError(error, "Error saving thread to memory");
+  }
+}
+async function updateThreadHandler({
+  mastra,
+  agentId,
+  threadId,
+  body,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!body) {
+      throw new HTTPException(400, { message: "Body is required" });
+    }
+    const { title, metadata, resourceId } = body;
+    const updatedAt = /* @__PURE__ */ new Date();
+    validateBody({ threadId });
+    if (!memory) {
+      throw new HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new 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 handleError(error, "Error updating thread");
+  }
+}
+async function deleteThreadHandler({
+  mastra,
+  agentId,
+  threadId,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      throw new HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new HTTPException(404, { message: "Thread not found" });
+    }
+    await memory.deleteThread(threadId);
+    return { result: "Thread deleted" };
+  } catch (error) {
+    return handleError(error, "Error deleting thread");
+  }
+}
+async function getMessagesHandler({
+  mastra,
+  agentId,
+  threadId,
+  limit,
+  networkId,
+  runtimeContext
+}) {
+  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 = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      throw new HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new HTTPException(404, { message: "Thread not found" });
+    }
+    const result = await memory.query({
+      threadId,
+      ...limit && { selectBy: { last: limit } }
+    });
+    return { messages: result.messages, uiMessages: result.uiMessages };
+  } catch (error) {
+    return handleError(error, "Error getting messages");
+  }
+}
+
+export { createThreadHandler, deleteThreadHandler, getMemoryStatusHandler, getMessagesHandler, getThreadByIdHandler, getThreadsHandler, memory_exports, saveMessagesHandler, updateThreadHandler };

package/dist/chunk-MLKGABMK.js

@@ -0,0 +1,7 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export { __export };

package/dist/chunk-PZQDCRPV.cjs

@@ -0,0 +1,16 @@
+'use strict';
+
+var chunk2KZFMI6P_cjs = require('./chunk-2KZFMI6P.cjs');
+
+// src/server/handlers/error.ts
+function handleError(error, defaultMessage) {
+  const apiError = error;
+  const apiErrorStatus = apiError.status || apiError.details?.status || 500;
+  throw new chunk2KZFMI6P_cjs.HTTPException(apiErrorStatus, {
+    message: apiError.message || defaultMessage,
+    stack: apiError.stack,
+    cause: apiError.cause
+  });
+}
+
+exports.handleError = handleError;

package/dist/chunk-QGX47B5D.cjs

@@ -0,0 +1,86 @@
+'use strict';
+
+var chunkCCGRCYWJ_cjs = require('./chunk-CCGRCYWJ.cjs');
+var chunkPZQDCRPV_cjs = require('./chunk-PZQDCRPV.cjs');
+var chunk75ZPJI57_cjs = require('./chunk-75ZPJI57.cjs');
+
+// src/server/handlers/logs.ts
+var logs_exports = {};
+chunk75ZPJI57_cjs.__export(logs_exports, {
+  getLogTransports: () => getLogTransports,
+  getLogsByRunIdHandler: () => getLogsByRunIdHandler,
+  getLogsHandler: () => getLogsHandler
+});
+async function getLogsHandler({
+  mastra,
+  transportId,
+  params
+}) {
+  try {
+    chunkCCGRCYWJ_cjs.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 chunkPZQDCRPV_cjs.handleError(error, "Error getting logs");
+  }
+}
+async function getLogsByRunIdHandler({
+  mastra,
+  runId,
+  transportId,
+  params
+}) {
+  try {
+    chunkCCGRCYWJ_cjs.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 chunkPZQDCRPV_cjs.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 chunkPZQDCRPV_cjs.handleError(error, "Error getting log Transports");
+  }
+}
+
+exports.getLogTransports = getLogTransports;
+exports.getLogsByRunIdHandler = getLogsByRunIdHandler;
+exports.getLogsHandler = getLogsHandler;
+exports.logs_exports = logs_exports;

package/dist/chunk-RG473F6Y.js

@@ -0,0 +1,141 @@
+import { handleError } from './chunk-LF7P5PLR.js';
+import { HTTPException } from './chunk-LCM566I4.js';
+import { __export } from './chunk-MLKGABMK.js';
+
+// src/server/handlers/telemetry.ts
+var telemetry_exports = {};
+__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 HTTPException(400, { message: "Telemetry is not initialized" });
+    }
+    if (!storage) {
+      return [];
+    }
+    if (!body) {
+      throw new 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 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
+    };
+  }
+}
+
+export { getTelemetryHandler, storeTelemetryHandler, telemetry_exports };

package/dist/chunk-RHSWAXKB.cjs

@@ -0,0 +1,118 @@
+'use strict';
+
+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 stream = require('stream');
+
+// src/server/handlers/voice.ts
+var voice_exports = {};
+chunk75ZPJI57_cjs.__export(voice_exports, {
+  generateSpeechHandler: () => generateSpeechHandler,
+  getListenerHandler: () => getListenerHandler,
+  getSpeakersHandler: () => getSpeakersHandler,
+  transcribeSpeechHandler: () => transcribeSpeechHandler
+});
+async function getSpeakersHandler({ mastra, agentId }) {
+  try {
+    if (!agentId) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Agent ID is required" });
+    }
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    const voice = await agent.getVoice();
+    if (!voice) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const speakers = await voice.getSpeakers();
+    return speakers;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting speakers");
+  }
+}
+async function generateSpeechHandler({
+  mastra,
+  agentId,
+  body
+}) {
+  try {
+    if (!agentId) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Agent ID is required" });
+    }
+    chunkCCGRCYWJ_cjs.validateBody({
+      text: body?.text
+    });
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    const voice = await agent.getVoice();
+    if (!voice) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const audioStream = await voice.speak(body.text, { speaker: body.speakerId });
+    if (!audioStream) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(500, { message: "Failed to generate speech" });
+    }
+    return audioStream;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error generating speech");
+  }
+}
+async function transcribeSpeechHandler({
+  mastra,
+  agentId,
+  body
+}) {
+  try {
+    if (!agentId) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Agent ID is required" });
+    }
+    if (!body?.audioData) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Audio data is required" });
+    }
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    const voice = await agent.getVoice();
+    if (!voice) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const audioStream = new stream.Readable();
+    audioStream.push(body.audioData);
+    audioStream.push(null);
+    const text = await voice.listen(audioStream, body.options);
+    return { text };
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error transcribing speech");
+  }
+}
+async function getListenerHandler({ mastra, agentId }) {
+  try {
+    if (!agentId) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Agent ID is required" });
+    }
+    const agent = mastra.getAgent(agentId);
+    if (!agent) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Agent not found" });
+    }
+    const voice = await agent.getVoice();
+    if (!voice) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Agent does not have voice capabilities" });
+    }
+    const listeners = await voice.getListener();
+    return listeners;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting listeners");
+  }
+}
+
+exports.generateSpeechHandler = generateSpeechHandler;
+exports.getListenerHandler = getListenerHandler;
+exports.getSpeakersHandler = getSpeakersHandler;
+exports.transcribeSpeechHandler = transcribeSpeechHandler;
+exports.voice_exports = voice_exports;

package/dist/chunk-RSEO4XPX.js

@@ -0,0 +1,16 @@
+import { HTTPException } from './chunk-LCM566I4.js';
+
+// 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 HTTPException(400, { message: Object.values(errorResponse)[0] });
+  }
+}
+
+export { validateBody };