@mastra/server 0.0.0-a2a-20250421213654

package/dist/chunk-UVVUDJBW.cjs

@@ -0,0 +1,214 @@
+'use strict';
+
+var chunk57CJTIPW_cjs = require('./chunk-57CJTIPW.cjs');
+var chunk64U3UDTH_cjs = require('./chunk-64U3UDTH.cjs');
+var chunkOCWPVYNI_cjs = require('./chunk-OCWPVYNI.cjs');
+var chunkCVPOREIE_cjs = require('./chunk-CVPOREIE.cjs');
+
+// src/server/handlers/memory.ts
+var memory_exports = {};
+chunkCVPOREIE_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 chunkOCWPVYNI_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 chunk64U3UDTH_cjs.handleError(error, "Error getting memory status");
+  }
+}
+async function getThreadsHandler({
+  mastra,
+  agentId,
+  resourceId
+}) {
+  try {
+    const memory = getMemoryFromContext({ mastra, agentId });
+    if (!memory) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    chunk57CJTIPW_cjs.validateBody({ resourceId });
+    const threads = await memory.getThreadsByResourceId({ resourceId });
+    return threads;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting threads");
+  }
+}
+async function getThreadByIdHandler({
+  mastra,
+  agentId,
+  threadId
+}) {
+  try {
+    chunk57CJTIPW_cjs.validateBody({ threadId });
+    const memory = getMemoryFromContext({ mastra, agentId });
+    if (!memory) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Thread not found" });
+    }
+    return thread;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting thread");
+  }
+}
+async function saveMessagesHandler({
+  mastra,
+  agentId,
+  body
+}) {
+  try {
+    const memory = getMemoryFromContext({ mastra, agentId });
+    if (!memory) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    if (!body?.messages) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Messages are required" });
+    }
+    if (!Array.isArray(body.messages)) {
+      throw new chunkOCWPVYNI_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 chunk64U3UDTH_cjs.handleError(error, "Error saving messages");
+  }
+}
+async function createThreadHandler({
+  mastra,
+  agentId,
+  body
+}) {
+  try {
+    const memory = getMemoryFromContext({ mastra, agentId });
+    if (!memory) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    chunk57CJTIPW_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 chunk64U3UDTH_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 chunkOCWPVYNI_cjs.HTTPException(400, { message: "Body is required" });
+    }
+    const { title, metadata, resourceId } = body;
+    const updatedAt = /* @__PURE__ */ new Date();
+    chunk57CJTIPW_cjs.validateBody({ threadId });
+    if (!memory) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunkOCWPVYNI_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 chunk64U3UDTH_cjs.handleError(error, "Error updating thread");
+  }
+}
+async function deleteThreadHandler({
+  mastra,
+  agentId,
+  threadId
+}) {
+  try {
+    chunk57CJTIPW_cjs.validateBody({ threadId });
+    const memory = getMemoryFromContext({ mastra, agentId });
+    if (!memory) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Thread not found" });
+    }
+    await memory.deleteThread(threadId);
+    return { result: "Thread deleted" };
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error deleting thread");
+  }
+}
+async function getMessagesHandler({
+  mastra,
+  agentId,
+  threadId
+}) {
+  try {
+    chunk57CJTIPW_cjs.validateBody({ threadId });
+    const memory = getMemoryFromContext({ mastra, agentId });
+    if (!memory) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Memory is not initialized" });
+    }
+    const thread = await memory.getThreadById({ threadId });
+    if (!thread) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Thread not found" });
+    }
+    const result = await memory.query({ threadId });
+    return result;
+  } catch (error) {
+    return chunk64U3UDTH_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-Y7WN2UYV.cjs

@@ -0,0 +1,318 @@
+'use strict';
+
+var chunk5SWCVTNL_cjs = require('./chunk-5SWCVTNL.cjs');
+var chunk64U3UDTH_cjs = require('./chunk-64U3UDTH.cjs');
+var chunkOCWPVYNI_cjs = require('./chunk-OCWPVYNI.cjs');
+var chunkCVPOREIE_cjs = require('./chunk-CVPOREIE.cjs');
+var web = require('stream/web');
+
+// src/server/handlers/workflows.ts
+var workflows_exports = {};
+chunkCVPOREIE_cjs.__export(workflows_exports, {
+  createRunHandler: () => createRunHandler,
+  getWorkflowByIdHandler: () => getWorkflowByIdHandler,
+  getWorkflowRunHandler: () => getWorkflowRunHandler,
+  getWorkflowRunsHandler: () => getWorkflowRunsHandler,
+  getWorkflowsHandler: () => getWorkflowsHandler,
+  resumeAsyncWorkflowHandler: () => resumeAsyncWorkflowHandler,
+  resumeWorkflowHandler: () => resumeWorkflowHandler,
+  startAsyncWorkflowHandler: () => startAsyncWorkflowHandler,
+  startWorkflowRunHandler: () => startWorkflowRunHandler,
+  watchWorkflowHandler: () => watchWorkflowHandler
+});
+async function getWorkflowsHandler({ mastra }) {
+  try {
+    const workflows = mastra.getWorkflows({ serialized: false });
+    const _workflows = Object.entries(workflows).reduce((acc, [key, workflow]) => {
+      if (workflow.isNested) return acc;
+      acc[key] = {
+        stepGraph: workflow.stepGraph,
+        stepSubscriberGraph: workflow.stepSubscriberGraph,
+        serializedStepGraph: workflow.serializedStepGraph,
+        serializedStepSubscriberGraph: workflow.serializedStepSubscriberGraph,
+        name: workflow.name,
+        triggerSchema: workflow.triggerSchema ? chunk5SWCVTNL_cjs.stringify(chunk5SWCVTNL_cjs.esm_default(workflow.triggerSchema)) : void 0,
+        steps: Object.entries(workflow.steps).reduce((acc2, [key2, step]) => {
+          const _step = step;
+          acc2[key2] = {
+            ..._step,
+            inputSchema: _step.inputSchema ? chunk5SWCVTNL_cjs.stringify(chunk5SWCVTNL_cjs.esm_default(_step.inputSchema)) : void 0,
+            outputSchema: _step.outputSchema ? chunk5SWCVTNL_cjs.stringify(chunk5SWCVTNL_cjs.esm_default(_step.outputSchema)) : void 0
+          };
+          return acc2;
+        }, {})
+      };
+      return acc;
+    }, {});
+    return _workflows;
+  } catch (error) {
+    throw new chunkOCWPVYNI_cjs.HTTPException(500, { message: error?.message || "Error getting workflows" });
+  }
+}
+async function getWorkflowByIdHandler({ mastra, workflowId }) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    if (!workflow) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+    }
+    return {
+      stepGraph: workflow.stepGraph,
+      stepSubscriberGraph: workflow.stepSubscriberGraph,
+      serializedStepGraph: workflow.serializedStepGraph,
+      serializedStepSubscriberGraph: workflow.serializedStepSubscriberGraph,
+      name: workflow.name,
+      triggerSchema: workflow.triggerSchema ? chunk5SWCVTNL_cjs.stringify(chunk5SWCVTNL_cjs.esm_default(workflow.triggerSchema)) : void 0,
+      steps: Object.entries(workflow.steps).reduce((acc, [key, step]) => {
+        const _step = step;
+        acc[key] = {
+          ..._step,
+          inputSchema: _step.inputSchema ? chunk5SWCVTNL_cjs.stringify(chunk5SWCVTNL_cjs.esm_default(_step.inputSchema)) : void 0,
+          outputSchema: _step.outputSchema ? chunk5SWCVTNL_cjs.stringify(chunk5SWCVTNL_cjs.esm_default(_step.outputSchema)) : void 0
+        };
+        return acc;
+      }, {})
+    };
+  } catch (error) {
+    throw new chunkOCWPVYNI_cjs.HTTPException(500, { message: error?.message || "Error getting workflow" });
+  }
+}
+async function startAsyncWorkflowHandler({
+  mastra,
+  container,
+  workflowId,
+  runId,
+  triggerData
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    if (!workflow) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+    }
+    if (!runId) {
+      const { start } = workflow.createRun();
+      const result2 = await start({
+        triggerData,
+        container
+      });
+      return result2;
+    }
+    const run = workflow.getRun(runId);
+    if (!run) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+    }
+    const result = await run.start({
+      triggerData,
+      container
+    });
+    return result;
+  } catch (error) {
+    throw new chunkOCWPVYNI_cjs.HTTPException(500, { message: error?.message || "Error executing workflow" });
+  }
+}
+async function getWorkflowRunHandler({
+  mastra,
+  workflowId,
+  runId
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Run ID is required" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    if (!workflow) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+    }
+    const run = workflow.getRun(runId);
+    if (!run) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+    }
+    return run;
+  } catch (error) {
+    throw new chunkOCWPVYNI_cjs.HTTPException(500, { message: error?.message || "Error getting workflow run" });
+  }
+}
+async function createRunHandler({
+  mastra,
+  workflowId,
+  runId: prevRunId
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    if (!workflow) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow not found" });
+    }
+    const { runId } = workflow.createRun({ runId: prevRunId });
+    return { runId };
+  } catch (error) {
+    throw new chunkOCWPVYNI_cjs.HTTPException(500, { message: error?.message || "Error creating workflow run" });
+  }
+}
+async function startWorkflowRunHandler({
+  mastra,
+  container,
+  workflowId,
+  runId,
+  triggerData
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "runId required to start run" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    const run = workflow.getRun(runId);
+    if (!run) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+    }
+    await run.start({
+      triggerData,
+      container
+    });
+    return { message: "Workflow run started" };
+  } catch (e) {
+    return chunk64U3UDTH_cjs.handleError(e, "Error starting workflow run");
+  }
+}
+async function watchWorkflowHandler({
+  mastra,
+  workflowId,
+  runId
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "runId required to watch workflow" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    const run = workflow.getRun(runId);
+    if (!run) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+    }
+    let unwatch;
+    let asyncRef = null;
+    const stream = new web.ReadableStream({
+      start(controller) {
+        unwatch = run.watch(({ activePaths, runId: runId2, timestamp, results }) => {
+          const activePathsObj = Object.fromEntries(activePaths);
+          controller.enqueue(JSON.stringify({ activePaths: activePathsObj, runId: runId2, timestamp, results }));
+          if (asyncRef) {
+            clearImmediate(asyncRef);
+            asyncRef = null;
+          }
+          asyncRef = setImmediate(() => {
+            if (!workflow.getRun(runId2)) {
+              controller.close();
+            }
+          });
+        });
+      },
+      cancel() {
+        unwatch?.();
+      }
+    });
+    return stream;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error watching workflow");
+  }
+}
+async function resumeAsyncWorkflowHandler({
+  mastra,
+  workflowId,
+  runId,
+  body,
+  container
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "runId required to resume workflow" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    const run = workflow.getRun(runId);
+    if (!run) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+    }
+    const result = await run.resume({
+      stepId: body.stepId,
+      context: body.context,
+      container
+    });
+    return result;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error resuming workflow step");
+  }
+}
+async function resumeWorkflowHandler({
+  mastra,
+  workflowId,
+  runId,
+  body,
+  container
+}) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "runId required to resume workflow" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    const run = workflow.getRun(runId);
+    if (!run) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(404, { message: "Workflow run not found" });
+    }
+    await run.resume({
+      stepId: body.stepId,
+      context: body.context,
+      container
+    });
+    return { message: "Workflow run resumed" };
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error resuming workflow");
+  }
+}
+async function getWorkflowRunsHandler({ mastra, workflowId }) {
+  try {
+    if (!workflowId) {
+      throw new chunkOCWPVYNI_cjs.HTTPException(400, { message: "Workflow ID is required" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    const workflowRuns = await workflow.getWorkflowRuns() || {
+      runs: [],
+      total: 0
+    };
+    return workflowRuns;
+  } catch (error) {
+    return chunk64U3UDTH_cjs.handleError(error, "Error getting workflow runs");
+  }
+}
+
+exports.createRunHandler = createRunHandler;
+exports.getWorkflowByIdHandler = getWorkflowByIdHandler;
+exports.getWorkflowRunHandler = getWorkflowRunHandler;
+exports.getWorkflowRunsHandler = getWorkflowRunsHandler;
+exports.getWorkflowsHandler = getWorkflowsHandler;
+exports.resumeAsyncWorkflowHandler = resumeAsyncWorkflowHandler;
+exports.resumeWorkflowHandler = resumeWorkflowHandler;
+exports.startAsyncWorkflowHandler = startAsyncWorkflowHandler;
+exports.startWorkflowRunHandler = startWorkflowRunHandler;
+exports.watchWorkflowHandler = watchWorkflowHandler;
+exports.workflows_exports = workflows_exports;

package/dist/chunk-YB2FGKQ5.js

@@ -0,0 +1,121 @@
+import { stringify, esm_default } from './chunk-OMN3UI6X.js';
+import { validateBody } from './chunk-H5PTF3Y4.js';
+import { handleError } from './chunk-M5ABIP7D.js';
+import { HTTPException } from './chunk-NYN7KFXL.js';
+import { __export } from './chunk-4VNS5WPM.js';
+import { isVercelTool } from '@mastra/core/tools';
+
+// src/server/handlers/tools.ts
+var tools_exports = {};
+__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 ? stringify(esm_default(tool.inputSchema)) : void 0,
+          outputSchema: tool.outputSchema ? stringify(esm_default(tool.outputSchema)) : void 0
+        };
+        return acc;
+      },
+      {}
+    );
+    return serializedTools;
+  } catch (error) {
+    return 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 HTTPException(404, { message: "Tool not found" });
+    }
+    const serializedTool = {
+      ...tool,
+      inputSchema: tool.inputSchema ? stringify(esm_default(tool.inputSchema)) : void 0,
+      outputSchema: tool.outputSchema ? stringify(esm_default(tool.outputSchema)) : void 0
+    };
+    return serializedTool;
+  } catch (error) {
+    return handleError(error, "Error getting tool");
+  }
+}
+function executeToolHandler(tools) {
+  return async ({
+    mastra,
+    runId,
+    toolId,
+    data,
+    container
+  }) => {
+    try {
+      if (!toolId) {
+        throw new HTTPException(400, { message: "Tool ID is required" });
+      }
+      const tool = Object.values(tools || {}).find((tool2) => tool2.id === toolId);
+      if (!tool) {
+        throw new HTTPException(404, { message: "Tool not found" });
+      }
+      if (!tool?.execute) {
+        throw new HTTPException(400, { message: "Tool is not executable" });
+      }
+      validateBody({ data });
+      if (isVercelTool(tool)) {
+        const result2 = await tool.execute(data);
+        return result2;
+      }
+      const result = await tool.execute({
+        context: data,
+        mastra,
+        runId,
+        container
+      });
+      return result;
+    } catch (error) {
+      return handleError(error, "Error executing tool");
+    }
+  };
+}
+async function executeAgentToolHandler({
+  mastra,
+  agentId,
+  toolId,
+  data,
+  container
+}) {
+  try {
+    const agent = agentId ? mastra.getAgent(agentId) : null;
+    if (!agent) {
+      throw new HTTPException(404, { message: "Tool not found" });
+    }
+    const tool = Object.values(agent?.tools || {}).find((tool2) => tool2.id === toolId);
+    if (!tool) {
+      throw new HTTPException(404, { message: "Tool not found" });
+    }
+    if (!tool?.execute) {
+      throw new HTTPException(400, { message: "Tool is not executable" });
+    }
+    const result = await tool.execute({
+      context: data,
+      container,
+      mastra,
+      runId: agentId
+    });
+    return result;
+  } catch (error) {
+    return handleError(error, "Error executing tool");
+  }
+}
+
+export { executeAgentToolHandler, executeToolHandler, getToolByIdHandler, getToolsHandler, tools_exports };