@mastra/server 0.0.0-separate-trace-data-from-component-20250501141108 → 0.0.0-support-d1-client-20250701191943

package/dist/{chunk-2FJURXCL.cjs → chunk-3DKDT264.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 chunk57CJTIPW_cjs = require('./chunk-57CJTIPW.cjs');
+var chunkMTR2B27E_cjs = require('./chunk-MTR2B27E.cjs');
+var chunkOCWPVYNI_cjs = require('./chunk-OCWPVYNI.cjs');
+var chunk75ZPJI57_cjs = require('./chunk-75ZPJI57.cjs');
 
 // src/server/handlers/memory.ts
 var memory_exports = {};
-chunkFV45V6WC_cjs.__export(memory_exports, {
+chunk75ZPJI57_cjs.__export(memory_exports, {
   createThreadHandler: () => createThreadHandler,
   deleteThreadHandler: () => deleteThreadHandler,
   getMemoryStatusHandler: () => getMemoryStatusHandler,
@@ -16,80 +17,102 @@ chunkFV45V6WC_cjs.__export(memory_exports, {
   saveMessagesHandler: () => saveMessagesHandler,
   updateThreadHandler: () => updateThreadHandler
 });
-function getMemoryFromContext({
+async function getMemoryFromContext({
   mastra,
-  agentId
+  agentId,
+  networkId,
+  runtimeContext
 }) {
   const agent = agentId ? mastra.getAgent(agentId) : null;
   if (agentId && !agent) {
-    throw new chunkFV45V6WC_cjs.HTTPException(404, { message: "Agent not found" });
+    throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Agent not found" });
+  }
+  const network = networkId ? mastra.vnext_getNetwork(networkId) : null;
+  if (networkId && !network) {
+    throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Network not found" });
+  }
+  if (agent) {
+    return agent?.getMemory() || mastra.getMemory();
+  }
+  if (network) {
+    return await network?.getMemory({ runtimeContext }) || mastra.getMemory();
   }
-  const memory = agent?.getMemory?.() || mastra.getMemory();
-  return memory;
+  return mastra.getMemory();
 }
-async function getMemoryStatusHandler({ mastra, agentId }) {
+async function getMemoryStatusHandler({
+  mastra,
+  agentId,
+  networkId,
+  runtimeContext
+}) {
   try {
-    const memory = getMemoryFromContext({ mastra, agentId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
     if (!memory) {
       return { result: false };
     }
     return { result: true };
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error getting memory status");
+    return chunkMTR2B27E_cjs.handleError(error, "Error getting memory status");
   }
 }
 async function getThreadsHandler({
   mastra,
   agentId,
-  resourceId
+  resourceId,
+  networkId,
+  runtimeContext
 }) {
   try {
-    const memory = getMemoryFromContext({ mastra, agentId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
     if (!memory) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
-    chunkQN4KF3BH_cjs.validateBody({ resourceId });
+    chunk57CJTIPW_cjs.validateBody({ resourceId });
     const threads = await memory.getThreadsByResourceId({ resourceId });
     return threads;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error getting threads");
+    return chunkMTR2B27E_cjs.handleError(error, "Error getting threads");
   }
 }
 async function getThreadByIdHandler({
   mastra,
   agentId,
-  threadId
+  threadId,
+  networkId,
+  runtimeContext
 }) {
   try {
-    chunkQN4KF3BH_cjs.validateBody({ threadId });
-    const memory = getMemoryFromContext({ mastra, agentId });
+    chunk57CJTIPW_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
     if (!memory) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunkOCWPVYNI_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" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Thread not found" });
     }
     return thread;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error getting thread");
+    return chunkMTR2B27E_cjs.handleError(error, "Error getting thread");
   }
 }
 async function saveMessagesHandler({
   mastra,
   agentId,
-  body
+  body,
+  networkId,
+  runtimeContext
 }) {
   try {
-    const memory = getMemoryFromContext({ mastra, agentId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
     if (!memory) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
     if (!body?.messages) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Messages are required" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Messages are required" });
     }
     if (!Array.isArray(body.messages)) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Messages should be an array" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Messages should be an array" });
     }
     const processedMessages = body.messages.map((message) => ({
       ...message,
@@ -99,20 +122,22 @@ async function saveMessagesHandler({
     const result = await memory.saveMessages({ messages: processedMessages, memoryConfig: {} });
     return result;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error saving messages");
+    return chunkMTR2B27E_cjs.handleError(error, "Error saving messages");
   }
 }
 async function createThreadHandler({
   mastra,
   agentId,
-  body
+  body,
+  networkId,
+  runtimeContext
 }) {
   try {
-    const memory = getMemoryFromContext({ mastra, agentId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
     if (!memory) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
     }
-    chunkQN4KF3BH_cjs.validateBody({ resourceId: body?.resourceId });
+    chunk57CJTIPW_cjs.validateBody({ resourceId: body?.resourceId });
     const result = await memory.createThread({
       resourceId: body?.resourceId,
       title: body?.title,
@@ -121,29 +146,31 @@ async function createThreadHandler({
     });
     return result;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error saving thread to memory");
+    return chunkMTR2B27E_cjs.handleError(error, "Error saving thread to memory");
   }
 }
 async function updateThreadHandler({
   mastra,
   agentId,
   threadId,
-  body
+  body,
+  networkId,
+  runtimeContext
 }) {
   try {
-    const memory = getMemoryFromContext({ mastra, agentId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
     if (!body) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Body is required" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Body is required" });
     }
     const { title, metadata, resourceId } = body;
     const updatedAt = /* @__PURE__ */ new Date();
-    chunkQN4KF3BH_cjs.validateBody({ threadId });
+    chunk57CJTIPW_cjs.validateBody({ threadId });
     if (!memory) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunkOCWPVYNI_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" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Thread not found" });
     }
     const updatedThread = {
       ...thread,
@@ -156,49 +183,60 @@ async function updateThreadHandler({
     const result = await memory.saveThread({ thread: updatedThread });
     return result;
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error updating thread");
+    return chunkMTR2B27E_cjs.handleError(error, "Error updating thread");
   }
 }
 async function deleteThreadHandler({
   mastra,
   agentId,
-  threadId
+  threadId,
+  networkId,
+  runtimeContext
 }) {
   try {
-    chunkQN4KF3BH_cjs.validateBody({ threadId });
-    const memory = getMemoryFromContext({ mastra, agentId });
+    chunk57CJTIPW_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
     if (!memory) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunkOCWPVYNI_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" });
+      throw new chunkOCWPVYNI_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");
+    return chunkMTR2B27E_cjs.handleError(error, "Error deleting thread");
   }
 }
 async function getMessagesHandler({
   mastra,
   agentId,
-  threadId
+  threadId,
+  limit,
+  networkId,
+  runtimeContext
 }) {
+  if (limit !== void 0 && (!Number.isInteger(limit) || limit <= 0)) {
+    throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Invalid limit: must be a positive integer" });
+  }
   try {
-    chunkQN4KF3BH_cjs.validateBody({ threadId });
-    const memory = getMemoryFromContext({ mastra, agentId });
+    chunk57CJTIPW_cjs.validateBody({ threadId });
+    const memory = await getMemoryFromContext({ mastra, agentId, networkId, runtimeContext });
     if (!memory) {
-      throw new chunkFV45V6WC_cjs.HTTPException(400, { message: "Memory is not initialized" });
+      throw new chunkOCWPVYNI_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" });
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Thread not found" });
     }
-    const result = await memory.query({ threadId });
-    return result;
+    const result = await memory.query({
+      threadId,
+      ...limit && { selectBy: { last: limit } }
+    });
+    return { messages: result.messages, uiMessages: result.uiMessages };
   } catch (error) {
-    return chunkZLBRQFDD_cjs.handleError(error, "Error getting messages");
+    return chunkMTR2B27E_cjs.handleError(error, "Error getting messages");
   }
 }
 

package/dist/{chunk-Y3SV5XK4.js → chunk-4QBIUKVY.js}

@@ -1,7 +1,9 @@
-import { stringify, esm_default } from './chunk-OMN3UI6X.js';
-import { validateBody } from './chunk-L7XE5QTW.js';
-import { handleError } from './chunk-3AHQ5RGN.js';
-import { __export, HTTPException } from './chunk-TRDNDNGQ.js';
+import { stringify, esm_default } from './chunk-MEGCYGBU.js';
+import { validateBody } from './chunk-H5PTF3Y4.js';
+import { handleError } from './chunk-QDOJJCS4.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 = {};
@@ -21,6 +23,8 @@ async function getAgentsHandler({ mastra, runtimeContext }) {
         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] = {
@@ -30,13 +34,33 @@ async function getAgentsHandler({ mastra, runtimeContext }) {
           };
           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()
+          modelId: llm?.getModelId(),
+          defaultGenerateOptions,
+          defaultStreamOptions
         };
       })
     );
@@ -52,7 +76,8 @@ async function getAgentsHandler({ mastra, runtimeContext }) {
 async function getAgentByIdHandler({
   mastra,
   runtimeContext,
-  agentId
+  agentId,
+  isPlayground = false
 }) {
   try {
     const agent = mastra.getAgent(agentId);
@@ -69,14 +94,59 @@ async function getAgentByIdHandler({
       };
       return acc;
     }, {});
-    const instructions = await agent.getInstructions({ runtimeContext });
+    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()
+      modelId: llm?.getModelId(),
+      defaultGenerateOptions,
+      defaultStreamOptions
     };
   } catch (error) {
     return handleError(error, "Error getting agent");
@@ -124,21 +194,27 @@ async function generateHandler({
   mastra,
   runtimeContext,
   agentId,
-  body
+  body,
+  abortSignal
 }) {
   try {
     const agent = mastra.getAgent(agentId);
     if (!agent) {
       throw new HTTPException(404, { message: "Agent not found" });
     }
-    const { messages, resourceId, resourceid, ...rest } = body;
+    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
+      runtimeContext: finalRuntimeContext,
+      signal: abortSignal
     });
     return result;
   } catch (error) {
@@ -149,32 +225,45 @@ async function streamGenerateHandler({
   mastra,
   runtimeContext,
   agentId,
-  body
+  body,
+  abortSignal
 }) {
   try {
     const agent = mastra.getAgent(agentId);
     if (!agent) {
       throw new HTTPException(404, { message: "Agent not found" });
     }
-    const { messages, resourceId, resourceid, ...rest } = body;
+    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
+      runtimeContext: finalRuntimeContext,
+      signal: abortSignal
     });
-    const streamResponse = rest.output ? streamResult.toTextStreamResponse() : streamResult.toDataStreamResponse({
+    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" });
+    return handleError(error, "error streaming agent response");
   }
 }
 

package/dist/{chunk-QN4KF3BH.cjs → chunk-57CJTIPW.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkFV45V6WC_cjs = require('./chunk-FV45V6WC.cjs');
+var chunkOCWPVYNI_cjs = require('./chunk-OCWPVYNI.cjs');
 
 // src/server/handlers/utils.ts
 function validateBody(body) {
@@ -11,7 +11,7 @@ function validateBody(body) {
     return acc;
   }, {});
   if (Object.keys(errorResponse).length > 0) {
-    throw new chunkFV45V6WC_cjs.HTTPException(400, { message: Object.values(errorResponse)[0] });
+    throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: Object.values(errorResponse)[0] });
   }
 }