@mastra/server 0.0.1-alpha.0

package/dist/chunk-QN4KF3BH.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+var chunkFV45V6WC_cjs = require('./chunk-FV45V6WC.cjs');
+
+// 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 chunkFV45V6WC_cjs.HTTPException(400, { message: Object.values(errorResponse)[0] });
+  }
+}
+
+exports.validateBody = validateBody;

package/dist/chunk-RBQASTUP.js

@@ -0,0 +1,203 @@
+import { validateBody } from './chunk-L7XE5QTW.js';
+import { handleError } from './chunk-3AHQ5RGN.js';
+import { __export, HTTPException } from './chunk-TRDNDNGQ.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
+});
+function getMemoryFromContext({
+  mastra,
+  agentId
+}) {
+  const agent = agentId ? mastra.getAgent(agentId) : null;
+  if (agentId && !agent) {
+    throw new 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 handleError(error, "Error getting memory status");
+  }
+}
+async function getThreadsHandler({
+  mastra,
+  agentId,
+  resourceId
+}) {
+  try {
+    const memory = getMemoryFromContext({ mastra, agentId });
+    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
+}) {
+  try {
+    validateBody({ threadId });
+    const memory = getMemoryFromContext({ mastra, agentId });
+    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
+}) {
+  try {
+    const memory = getMemoryFromContext({ mastra, agentId });
+    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
+}) {
+  try {
+    const memory = getMemoryFromContext({ mastra, agentId });
+    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
+}) {
+  try {
+    const memory = getMemoryFromContext({ mastra, agentId });
+    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
+}) {
+  try {
+    validateBody({ threadId });
+    const memory = getMemoryFromContext({ mastra, agentId });
+    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
+}) {
+  try {
+    validateBody({ threadId });
+    const memory = getMemoryFromContext({ mastra, agentId });
+    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 });
+    return result;
+  } catch (error) {
+    return handleError(error, "Error getting messages");
+  }
+}
+
+export { createThreadHandler, deleteThreadHandler, getMemoryStatusHandler, getMessagesHandler, getThreadByIdHandler, getThreadsHandler, memory_exports, saveMessagesHandler, updateThreadHandler };

package/dist/chunk-S6GTZWMY.js

@@ -0,0 +1,275 @@
+import { stringify, esm_default } from './chunk-VK6FX47H.js';
+import { handleError } from './chunk-3AHQ5RGN.js';
+import { __export, HTTPException } from './chunk-TRDNDNGQ.js';
+import { ReadableStream } from 'node:stream/web';
+
+// src/server/handlers/workflows.ts
+var workflows_exports = {};
+__export(workflows_exports, {
+  createRunHandler: () => createRunHandler,
+  getWorkflowByIdHandler: () => getWorkflowByIdHandler,
+  getWorkflowRunHandler: () => getWorkflowRunHandler,
+  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]) => {
+      acc[key] = {
+        stepGraph: workflow.stepGraph,
+        stepSubscriberGraph: workflow.stepSubscriberGraph,
+        serializedStepGraph: workflow.serializedStepGraph,
+        serializedStepSubscriberGraph: workflow.serializedStepSubscriberGraph,
+        name: workflow.name,
+        triggerSchema: workflow.triggerSchema ? stringify(esm_default(workflow.triggerSchema)) : void 0,
+        steps: Object.entries(workflow.steps).reduce((acc2, [key2, step]) => {
+          const _step = step;
+          acc2[key2] = {
+            ..._step,
+            inputSchema: _step.inputSchema ? stringify(esm_default(_step.inputSchema)) : void 0,
+            outputSchema: _step.outputSchema ? stringify(esm_default(_step.outputSchema)) : void 0
+          };
+          return acc2;
+        }, {})
+      };
+      return acc;
+    }, {});
+    return _workflows;
+  } catch (error) {
+    throw new HTTPException(500, { message: error?.message || "Error getting workflows" });
+  }
+}
+async function getWorkflowByIdHandler({ mastra, workflowId }) {
+  try {
+    if (!workflowId) {
+      throw new HTTPException(400, { message: "Workflow ID is required" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    if (!workflow) {
+      throw new 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 ? stringify(esm_default(workflow.triggerSchema)) : void 0,
+      steps: Object.entries(workflow.steps).reduce((acc, [key, step]) => {
+        const _step = step;
+        acc[key] = {
+          ..._step,
+          inputSchema: _step.inputSchema ? stringify(esm_default(_step.inputSchema)) : void 0,
+          outputSchema: _step.outputSchema ? stringify(esm_default(_step.outputSchema)) : void 0
+        };
+        return acc;
+      }, {})
+    };
+  } catch (error) {
+    throw new HTTPException(500, { message: error?.message || "Error getting workflow" });
+  }
+}
+async function startAsyncWorkflowHandler({
+  mastra,
+  workflowId,
+  runId,
+  triggerData
+}) {
+  try {
+    if (!workflowId) {
+      throw new HTTPException(400, { message: "Workflow ID is required" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to start run" });
+    }
+    if (!workflow) {
+      throw new HTTPException(404, { message: "Workflow not found" });
+    }
+    const run = workflow.getRun(runId);
+    if (!run) {
+      throw new HTTPException(404, { message: "Workflow run not found" });
+    }
+    const result = await run.start({
+      triggerData
+    });
+    return result;
+  } catch (error) {
+    throw new HTTPException(500, { message: error?.message || "Error executing workflow" });
+  }
+}
+async function getWorkflowRunHandler({
+  mastra,
+  workflowId,
+  runId
+}) {
+  try {
+    if (!workflowId) {
+      throw new HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new HTTPException(400, { message: "Run ID is required" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    if (!workflow) {
+      throw new HTTPException(404, { message: "Workflow not found" });
+    }
+    const run = workflow.getRun(runId);
+    if (!run) {
+      throw new HTTPException(404, { message: "Workflow run not found" });
+    }
+    return run;
+  } catch (error) {
+    throw new HTTPException(500, { message: error?.message || "Error getting workflow run" });
+  }
+}
+async function createRunHandler({
+  mastra,
+  workflowId,
+  runId: prevRunId
+}) {
+  try {
+    if (!workflowId) {
+      throw new HTTPException(400, { message: "Workflow ID is required" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    if (!workflow) {
+      throw new HTTPException(404, { message: "Workflow not found" });
+    }
+    const { runId } = workflow.createRun({ runId: prevRunId });
+    return { runId };
+  } catch (error) {
+    throw new HTTPException(500, { message: error?.message || "Error creating workflow run" });
+  }
+}
+async function startWorkflowRunHandler({
+  mastra,
+  workflowId,
+  runId,
+  triggerData
+}) {
+  try {
+    if (!workflowId) {
+      throw new HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to start run" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    const run = workflow.getRun(runId);
+    if (!run) {
+      throw new HTTPException(404, { message: "Workflow run not found" });
+    }
+    await run.start({
+      triggerData
+    });
+    return { message: "Workflow run started" };
+  } catch (e) {
+    return handleError(e, "Error starting workflow run");
+  }
+}
+async function watchWorkflowHandler({
+  mastra,
+  workflowId,
+  runId
+}) {
+  try {
+    if (!workflowId) {
+      throw new HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to watch workflow" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    const run = workflow.getRun(runId);
+    if (!run) {
+      throw new HTTPException(404, { message: "Workflow run not found" });
+    }
+    let unwatch;
+    let asyncRef = null;
+    const stream = new 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 handleError(error, "Error watching workflow");
+  }
+}
+async function resumeAsyncWorkflowHandler({
+  mastra,
+  workflowId,
+  runId,
+  body
+}) {
+  try {
+    if (!workflowId) {
+      throw new HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to resume workflow" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    const run = workflow.getRun(runId);
+    if (!run) {
+      throw new HTTPException(404, { message: "Workflow run not found" });
+    }
+    const result = await run.resume({
+      stepId: body.stepId,
+      context: body.context
+    });
+    return result;
+  } catch (error) {
+    return handleError(error, "Error resuming workflow step");
+  }
+}
+async function resumeWorkflowHandler({
+  mastra,
+  workflowId,
+  runId,
+  body
+}) {
+  try {
+    if (!workflowId) {
+      throw new HTTPException(400, { message: "Workflow ID is required" });
+    }
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to resume workflow" });
+    }
+    const workflow = mastra.getWorkflow(workflowId);
+    const run = workflow.getRun(runId);
+    if (!run) {
+      throw new HTTPException(404, { message: "Workflow run not found" });
+    }
+    await run.resume({
+      stepId: body.stepId,
+      context: body.context
+    });
+    return { message: "Workflow run resumed" };
+  } catch (error) {
+    return handleError(error, "Error resuming workflow");
+  }
+}
+
+export { createRunHandler, getWorkflowByIdHandler, getWorkflowRunHandler, getWorkflowsHandler, resumeAsyncWorkflowHandler, resumeWorkflowHandler, startAsyncWorkflowHandler, startWorkflowRunHandler, watchWorkflowHandler, workflows_exports };