@mastra/server 0.0.0-separate-trace-data-from-component-20250501141108 → 0.0.0-share-agent-metadata-with-cloud-20250718123411

package/dist/{chunk-FV45V6WC.cjs → chunk-2KZFMI6P.cjs}

@@ -1,11 +1,5 @@
 'use strict';
 
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
 // src/server/http-exception.ts
 var HTTPException = class extends Error {
   res;
@@ -19,6 +13,7 @@ var HTTPException = class extends Error {
     super(options?.message, { cause: options?.cause });
     this.res = options?.res;
     this.status = status;
+    this.stack = options?.stack || this.stack;
   }
   /**
    * Returns the response object associated with the exception.
@@ -40,4 +35,3 @@ var HTTPException = class extends Error {
 };
 
 exports.HTTPException = HTTPException;
-exports.__export = __export;

package/dist/{chunk-5YGDYMRB.cjs → chunk-2SLFAFTR.cjs}

@@ -1,12 +1,13 @@
 'use strict';
 
-var chunkQN4KF3BH_cjs = require('./chunk-QN4KF3BH.cjs');
-var chunkZLBRQFDD_cjs = require('./chunk-ZLBRQFDD.cjs');
-var chunkFV45V6WC_cjs = require('./chunk-FV45V6WC.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');
 
 // src/server/handlers/network.ts
 var network_exports = {};
-chunkFV45V6WC_cjs.__export(network_exports, {
+chunk75ZPJI57_cjs.__export(network_exports, {
   generateHandler: () => generateHandler,
   getNetworkByIdHandler: () => getNetworkByIdHandler,
   getNetworksHandler: () => getNetworksHandler,
@@ -46,7 +47,7 @@ async function getNetworksHandler({
     );
     return serializedNetworks;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error getting networks");
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting networks");
   }
 }
 async function getNetworkByIdHandler({
@@ -61,7 +62,7 @@ async function getNetworkByIdHandler({
       return network2.formatAgentId(routingAgent2.name) === networkId;
     });
     if (!network) {
-      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Network not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Network not found" });
     }
     const routingAgent = network.getRoutingAgent();
     const routingLLM = await routingAgent.getLLM({ runtimeContext });
@@ -87,7 +88,7 @@ async function getNetworkByIdHandler({
     };
     return serializedNetwork;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error getting network by ID");
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting network by ID");
   }
 }
 async function generateHandler({
@@ -99,14 +100,14 @@ async function generateHandler({
   try {
     const network = mastra.getNetwork(networkId);
     if (!network) {
-      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Network not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Network not found" });
     }
-    chunkQN4KF3BH_cjs.validateBody({ messages: body.messages });
+    chunkCCGRCYWJ_cjs.validateBody({ messages: body.messages });
     const { messages, ...rest } = body;
     const result = await network.generate(messages, { ...rest, runtimeContext });
     return result;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error generating from network");
+    return chunkPZQDCRPV_cjs.handleError(error, "Error generating from network");
   }
 }
 async function streamGenerateHandler({
@@ -118,9 +119,9 @@ async function streamGenerateHandler({
   try {
     const network = mastra.getNetwork(networkId);
     if (!network) {
-      throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Network not found" });
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Network not found" });
     }
-    chunkQN4KF3BH_cjs.validateBody({ messages: body.messages });
+    chunkCCGRCYWJ_cjs.validateBody({ messages: body.messages });
     const { messages, output, ...rest } = body;
     const streamResult = await network.stream(messages, {
       output,
@@ -136,7 +137,7 @@ async function streamGenerateHandler({
     });
     return streamResponse;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error streaming from network");
+    return chunkPZQDCRPV_cjs.handleError(error, "Error streaming from network");
   }
 }
 

package/dist/chunk-3CNDE7QY.cjs

@@ -0,0 +1,308 @@
+'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 core = require('@mastra/core');
+
+// src/server/handlers/memory.ts
+var memory_exports = {};
+chunk75ZPJI57_cjs.__export(memory_exports, {
+  createThreadHandler: () => createThreadHandler,
+  deleteThreadHandler: () => deleteThreadHandler,
+  getMemoryStatusHandler: () => getMemoryStatusHandler,
+  getMessagesHandler: () => getMessagesHandler,
+  getThreadByIdHandler: () => getThreadByIdHandler,
+  getThreadsHandler: () => getThreadsHandler,
+  getWorkingMemoryHandler: () => getWorkingMemoryHandler,
+  saveMessagesHandler: () => saveMessagesHandler,
+  updateThreadHandler: () => updateThreadHandler,
+  updateWorkingMemoryHandler: () => updateWorkingMemoryHandler
+});
+async function getMemoryFromContext({
+  mastra,
+  agentId,
+  networkId,
+  runtimeContext
+}) {
+  const agent = agentId ? mastra.getAgent(agentId) : null;
+  if (agentId && !agent) {
+    throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Agent not found" });
+  }
+  const network = networkId ? mastra.vnext_getNetwork(networkId) : null;
+  if (networkId && !network) {
+    throw new chunk2KZFMI6P_cjs.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 chunkPZQDCRPV_cjs.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 chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    chunkCCGRCYWJ_cjs.validateBody({ resourceId });
+    const threads = await memory.getThreadsByResourceId({ resourceId });
+    return threads;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting threads");
+  }
+}
+async function getThreadByIdHandler({
+  mastra,
+  agentId,
+  threadId,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    chunkCCGRCYWJ_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Thread not found" });
+    }
+    return thread;
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.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 chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    if (!body?.messages) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Messages are required" });
+    }
+    if (!Array.isArray(body.messages)) {
+      throw new chunk2KZFMI6P_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 chunkPZQDCRPV_cjs.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 chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    chunkCCGRCYWJ_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 chunkPZQDCRPV_cjs.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 chunk2KZFMI6P_cjs.HTTPException(400, { message: "Body is required" });
+    }
+    const { title, metadata, resourceId } = body;
+    const updatedAt = /* @__PURE__ */ new Date();
+    chunkCCGRCYWJ_cjs.validateBody({ threadId });
+    if (!memory) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunk2KZFMI6P_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 chunkPZQDCRPV_cjs.handleError(error, "Error updating thread");
+  }
+}
+async function deleteThreadHandler({
+  mastra,
+  agentId,
+  threadId,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    chunkCCGRCYWJ_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Thread not found" });
+    }
+    await memory.deleteThread(threadId);
+    return { result: "Thread deleted" };
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.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 chunk2KZFMI6P_cjs.HTTPException(400, { message: "Invalid limit: must be a positive integer" });
+  }
+  try {
+    chunkCCGRCYWJ_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    if (!memory) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunk2KZFMI6P_cjs.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 chunkPZQDCRPV_cjs.handleError(error, "Error getting messages");
+  }
+}
+async function getWorkingMemoryHandler({
+  mastra,
+  agentId,
+  threadId,
+  resourceId,
+  networkId,
+  runtimeContext,
+  memoryConfig
+}) {
+  try {
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    chunkCCGRCYWJ_cjs.validateBody({ threadId });
+    if (!memory) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    const threadExists = !!thread;
+    const template = await memory.getWorkingMemoryTemplate({ memoryConfig });
+    const workingMemoryTemplate = template?.format === "json" ? { ...template, content: JSON.stringify(core.generateEmptyFromSchema(template.content)) } : template;
+    const workingMemory = await memory.getWorkingMemory({ threadId, resourceId, memoryConfig });
+    const config = memory.getMergedThreadConfig(memoryConfig || {});
+    const source = config.workingMemory?.scope === "resource" && resourceId ? "resource" : "thread";
+    return { workingMemory, source, workingMemoryTemplate, threadExists };
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error getting working memory");
+  }
+}
+async function updateWorkingMemoryHandler({
+  mastra,
+  agentId,
+  threadId,
+  body,
+  networkId,
+  runtimeContext
+}) {
+  try {
+    chunkCCGRCYWJ_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
+    const { resourceId, memoryConfig, workingMemory } = body;
+    if (!memory) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunk2KZFMI6P_cjs.HTTPException(404, { message: "Thread not found" });
+    }
+    await memory.updateWorkingMemory({ threadId, resourceId, workingMemory, memoryConfig });
+    return { success: true };
+  } catch (error) {
+    return chunkPZQDCRPV_cjs.handleError(error, "Error updating working memory");
+  }
+}
+
+exports.createThreadHandler = createThreadHandler;
+exports.deleteThreadHandler = deleteThreadHandler;
+exports.getMemoryStatusHandler = getMemoryStatusHandler;
+exports.getMessagesHandler = getMessagesHandler;
+exports.getThreadByIdHandler = getThreadByIdHandler;
+exports.getThreadsHandler = getThreadsHandler;
+exports.getWorkingMemoryHandler = getWorkingMemoryHandler;
+exports.memory_exports = memory_exports;
+exports.saveMessagesHandler = saveMessagesHandler;
+exports.updateThreadHandler = updateThreadHandler;
+exports.updateWorkingMemoryHandler = updateWorkingMemoryHandler;

package/dist/chunk-4D66QEKC.js

@@ -0,0 +1,81 @@
+import { validateBody } from './chunk-RSEO4XPX.js';
+import { handleError } from './chunk-LF7P5PLR.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 };