@mastra/deployer 0.3.0 → 0.3.1-alpha.1

package/dist/server/index.js

@@ -1,8 +1,6 @@
 import crypto, { randomUUID } from 'crypto';
 import { readFile } from 'fs/promises';
-import { dirname } from 'path';
 import { join } from 'path/posix';
-import { fileURLToPath, pathToFileURL } from 'url';
 import { createServer } from 'http';
 import { Http2ServerRequest } from 'http2';
 import { Readable } from 'stream';
@@ -11,7 +9,7 @@ import { getMimeType } from 'hono/utils/mime';
 import { createReadStream, lstatSync } from 'fs';
 import { html } from 'hono/html';
 import { Telemetry } from '@mastra/core';
-import { RuntimeContext } from '@mastra/core/di';
+import { RuntimeContext } from '@mastra/core/runtime-context';
 import { Hono } from 'hono';
 import { bodyLimit } from 'hono/body-limit';
 import { cors } from 'hono/cors';
@@ -27,9 +25,10 @@ import { z } from 'zod';
 import { getTelemetryHandler as getTelemetryHandler$1, storeTelemetryHandler as storeTelemetryHandler$1 } from '@mastra/server/handlers/telemetry';
 import { executeAgentToolHandler as executeAgentToolHandler$1, getToolsHandler as getToolsHandler$1, getToolByIdHandler as getToolByIdHandler$1, executeToolHandler as executeToolHandler$1 } from '@mastra/server/handlers/tools';
 import { upsertVectors as upsertVectors$1, createIndex as createIndex$1, queryVectors as queryVectors$1, listIndexes as listIndexes$1, describeIndex as describeIndex$1, deleteIndex as deleteIndex$1 } from '@mastra/server/handlers/vector';
+import { getVNextWorkflowsHandler as getVNextWorkflowsHandler$1, getVNextWorkflowByIdHandler as getVNextWorkflowByIdHandler$1, getVNextWorkflowRunsHandler as getVNextWorkflowRunsHandler$1, resumeVNextWorkflowHandler as resumeVNextWorkflowHandler$1, resumeAsyncVNextWorkflowHandler as resumeAsyncVNextWorkflowHandler$1, createVNextWorkflowRunHandler as createVNextWorkflowRunHandler$1, startAsyncVNextWorkflowHandler as startAsyncVNextWorkflowHandler$1, startVNextWorkflowRunHandler as startVNextWorkflowRunHandler$1, watchVNextWorkflowHandler as watchVNextWorkflowHandler$1 } from '@mastra/server/handlers/vNextWorkflows';
+import { stream } from 'hono/streaming';
 import { getSpeakersHandler as getSpeakersHandler$1, generateSpeechHandler, transcribeSpeechHandler } from '@mastra/server/handlers/voice';
 import { getWorkflowsHandler as getWorkflowsHandler$1, getWorkflowByIdHandler as getWorkflowByIdHandler$1, getWorkflowRunsHandler as getWorkflowRunsHandler$1, resumeWorkflowHandler as resumeWorkflowHandler$1, resumeAsyncWorkflowHandler as resumeAsyncWorkflowHandler$1, createRunHandler as createRunHandler$1, startAsyncWorkflowHandler as startAsyncWorkflowHandler$1, startWorkflowRunHandler as startWorkflowRunHandler$1, watchWorkflowHandler as watchWorkflowHandler$1 } from '@mastra/server/handlers/workflows';
-import { stream } from 'hono/streaming';
 
 // src/server/index.ts
 var RequestError = class extends Error {
@@ -167,14 +166,14 @@ var newRequest = (incoming, defaultHostname) => {
   req[urlKey] = url.href;
   return req;
 };
-function writeFromReadableStream(stream2, writable) {
-  if (stream2.locked) {
+function writeFromReadableStream(stream3, writable) {
+  if (stream3.locked) {
     throw new TypeError("ReadableStream is locked.");
   } else if (writable.destroyed) {
-    stream2.cancel();
+    stream3.cancel();
     return;
   }
-  const reader = stream2.getReader();
+  const reader = stream3.getReader();
   writable.on("close", cancel);
   writable.on("error", cancel);
   reader.read().then(flow, cancel);
@@ -372,7 +371,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
   const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
   const internalBody = getInternalBody(res);
   if (internalBody) {
-    const { length, source, stream: stream2 } = internalBody;
+    const { length, source, stream: stream3 } = internalBody;
     if (source instanceof Uint8Array && source.byteLength !== length) ; else {
       if (length) {
         resHeaderRecord["content-length"] = length;
@@ -383,7 +382,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
       } else if (source instanceof Blob) {
         outgoing.end(new Uint8Array(await source.arrayBuffer()));
       } else {
-        await writeFromReadableStream(stream2, outgoing);
+        await writeFromReadableStream(stream3, outgoing);
       }
       return;
     }
@@ -487,18 +486,18 @@ var ENCODINGS = {
   gzip: ".gz"
 };
 var ENCODINGS_ORDERED_KEYS = Object.keys(ENCODINGS);
-var createStreamBody = (stream2) => {
+var createStreamBody = (stream3) => {
   const body = new ReadableStream({
     start(controller) {
-      stream2.on("data", (chunk) => {
+      stream3.on("data", (chunk) => {
         controller.enqueue(chunk);
       });
-      stream2.on("end", () => {
+      stream3.on("end", () => {
         controller.close();
       });
     },
     cancel() {
-      stream2.destroy();
+      stream3.destroy();
     }
   });
   return body;
@@ -594,10 +593,10 @@ var serveStatic = (options = { root: "" }) => {
       end = size - 1;
     }
     const chunksize = end - start + 1;
-    const stream2 = createReadStream(path, { start, end });
+    const stream3 = createReadStream(path, { start, end });
     c2.header("Content-Length", chunksize.toString());
     c2.header("Content-Range", `bytes ${start}-${end}/${stats.size}`);
-    return c2.body(createStreamBody(stream2), 206);
+    return c2.body(createStreamBody(stream3), 206);
   };
 };
 var RENDER_TYPE = {
@@ -955,7 +954,7 @@ async function setAgentInstructionsHandler(c2) {
 // src/server/handlers/client.ts
 var clients = /* @__PURE__ */ new Set();
 function handleClientsRefresh(c2) {
-  const stream2 = new ReadableStream({
+  const stream3 = new ReadableStream({
     start(controller) {
       clients.add(controller);
       controller.enqueue("data: connected\n\n");
@@ -964,7 +963,7 @@ function handleClientsRefresh(c2) {
       });
     }
   });
-  return new Response(stream2, {
+  return new Response(stream3, {
     headers: {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
@@ -1501,6 +1500,174 @@ async function deleteIndex(c2) {
     return handleError(error, "Error deleting index");
   }
 }
+async function getVNextWorkflowsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflows = await getVNextWorkflowsHandler$1({
+      mastra
+    });
+    return c2.json(workflows);
+  } catch (error) {
+    return handleError(error, "Error getting workflows");
+  }
+}
+async function getVNextWorkflowByIdHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const workflow = await getVNextWorkflowByIdHandler$1({
+      mastra,
+      workflowId
+    });
+    return c2.json(workflow);
+  } catch (error) {
+    return handleError(error, "Error getting workflow");
+  }
+}
+async function createVNextWorkflowRunHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const prevRunId = c2.req.query("runId");
+    const result = await createVNextWorkflowRunHandler$1({
+      mastra,
+      workflowId,
+      runId: prevRunId
+    });
+    return c2.json(result);
+  } catch (e2) {
+    return handleError(e2, "Error creating run");
+  }
+}
+async function startAsyncVNextWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const { inputData, runtimeContext } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    const result = await startAsyncVNextWorkflowHandler$1({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      inputData
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error executing workflow");
+  }
+}
+async function startVNextWorkflowRunHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const { inputData, runtimeContext } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    await startVNextWorkflowRunHandler$1({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      inputData
+    });
+    return c2.json({ message: "Workflow run started" });
+  } catch (e2) {
+    return handleError(e2, "Error starting workflow run");
+  }
+}
+function watchVNextWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const logger2 = mastra.getLogger();
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.query("runId");
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to watch workflow" });
+    }
+    return stream(
+      c2,
+      async (stream3) => {
+        try {
+          const result = await watchVNextWorkflowHandler$1({
+            mastra,
+            workflowId,
+            runId
+          });
+          stream3.onAbort(() => {
+            if (!result.locked) {
+              return result.cancel();
+            }
+          });
+          for await (const chunk of result) {
+            await stream3.write(chunk.toString() + "");
+          }
+        } catch (err) {
+          console.log(err);
+        }
+      },
+      async (err) => {
+        logger2.error("Error in watch stream: " + err?.message);
+      }
+    );
+  } catch (error) {
+    return handleError(error, "Error watching workflow");
+  }
+}
+async function resumeAsyncVNextWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.query("runId");
+    const { step, resumeData, runtimeContext } = await c2.req.json();
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to resume workflow" });
+    }
+    const result = await resumeAsyncVNextWorkflowHandler$1({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      body: { step, resumeData }
+    });
+    return c2.json(result);
+  } catch (error) {
+    return handleError(error, "Error resuming workflow step");
+  }
+}
+async function resumeVNextWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const runId = c2.req.query("runId");
+    const { step, resumeData, runtimeContext } = await c2.req.json();
+    if (!runId) {
+      throw new HTTPException(400, { message: "runId required to resume workflow" });
+    }
+    await resumeVNextWorkflowHandler$1({
+      mastra,
+      runtimeContext,
+      workflowId,
+      runId,
+      body: { step, resumeData }
+    });
+    return c2.json({ message: "Workflow run resumed" });
+  } catch (error) {
+    return handleError(error, "Error resuming workflow");
+  }
+}
+async function getVNextWorkflowRunsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflowId = c2.req.param("workflowId");
+    const workflowRuns = await getVNextWorkflowRunsHandler$1({
+      mastra,
+      workflowId
+    });
+    return c2.json(workflowRuns);
+  } catch (error) {
+    return handleError(error, "Error getting workflow runs");
+  }
+}
 async function getSpeakersHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -1648,20 +1815,20 @@ function watchWorkflowHandler(c2) {
     }
     return stream(
       c2,
-      async (stream2) => {
+      async (stream3) => {
         try {
           const result = await watchWorkflowHandler$1({
             mastra,
             workflowId,
             runId
           });
-          stream2.onAbort(() => {
+          stream3.onAbort(() => {
             if (!result.locked) {
               return result.cancel();
             }
           });
           for await (const chunk of result) {
-            await stream2.write(chunk.toString() + "");
+            await stream3.write(chunk.toString() + "");
           }
         } catch (err) {
           console.log(err);
@@ -1844,12 +2011,12 @@ var html2 = `
 async function createHonoServer(mastra, options = {}) {
   const app = new Hono();
   const server = mastra.getServer();
-  const __dirname = dirname(fileURLToPath(import.meta.url));
-  const mastraToolsPaths = (await import(pathToFileURL(join(__dirname, "tools.mjs")).href)).tools;
+  const toolsPath = "./tools.mjs";
+  const mastraToolsPaths = (await import(toolsPath)).tools;
   const toolImports = mastraToolsPaths ? await Promise.all(
     // @ts-ignore
     mastraToolsPaths.map(async (toolPath) => {
-      return import(pathToFileURL(join(__dirname, toolPath)).href);
+      return import(toolPath);
     })
   ) : [];
   const tools = toolImports.reduce((acc, toolModule) => {
@@ -1948,7 +2115,7 @@ async function createHonoServer(mastra, options = {}) {
       }
     }
   }
-  if (options?.isDev || server?.build?.apiReqLogs) {
+  if (server?.build?.apiReqLogs) {
     app.use(logger());
   }
   app.get(
@@ -3085,6 +3252,289 @@ async function createHonoServer(mastra, options = {}) {
     }),
     storeTelemetryHandler
   );
+  app.get(
+    "/api/workflows/v-next",
+    h({
+      description: "Get all vNext workflows",
+      tags: ["vNextWorkflows"],
+      responses: {
+        200: {
+          description: "List of all vNext workflows"
+        }
+      }
+    }),
+    getVNextWorkflowsHandler
+  );
+  app.get(
+    "/api/workflows/v-next/:workflowId",
+    h({
+      description: "Get vNext workflow by ID",
+      tags: ["vNextWorkflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "vNext workflow details"
+        },
+        404: {
+          description: "vNext workflow not found"
+        }
+      }
+    }),
+    getVNextWorkflowByIdHandler
+  );
+  app.get(
+    "/api/workflows/v-next/:workflowId/runs",
+    h({
+      description: "Get all runs for a vNext workflow",
+      tags: ["vNextWorkflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "List of vNext workflow runs from storage"
+        }
+      }
+    }),
+    getVNextWorkflowRunsHandler
+  );
+  app.post(
+    "/api/workflows/v-next/:workflowId/resume",
+    h({
+      description: "Resume a suspended vNext workflow step",
+      tags: ["vNextWorkflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                step: {
+                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+                },
+                resumeData: { type: "object" },
+                runtimeContext: { type: "object" }
+              },
+              required: ["step"]
+            }
+          }
+        }
+      }
+    }),
+    resumeVNextWorkflowHandler
+  );
+  app.post(
+    "/api/workflows/v-next/:workflowId/resume-async",
+    bodyLimit(bodyLimitOptions),
+    h({
+      description: "Resume a suspended vNext workflow step",
+      tags: ["vNextWorkflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                step: {
+                  oneOf: [{ type: "string" }, { type: "array", items: { type: "string" } }]
+                },
+                resumeData: { type: "object" },
+                runtimeContext: { type: "object" }
+              },
+              required: ["step"]
+            }
+          }
+        }
+      }
+    }),
+    resumeAsyncVNextWorkflowHandler
+  );
+  app.post(
+    "/api/workflows/v-next/:workflowId/create-run",
+    bodyLimit(bodyLimitOptions),
+    h({
+      description: "Create a new vNext workflow run",
+      tags: ["vNextWorkflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: false,
+          schema: { type: "string" }
+        }
+      ],
+      responses: {
+        200: {
+          description: "New vNext workflow run created"
+        }
+      }
+    }),
+    createVNextWorkflowRunHandler
+  );
+  app.post(
+    "/api/workflows/v-next/:workflowId/start-async",
+    bodyLimit(bodyLimitOptions),
+    h({
+      description: "Execute/Start a vNext workflow",
+      tags: ["vNextWorkflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: false,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                inputData: { type: "object" },
+                runtimeContext: { type: "object" }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "vNext workflow execution result"
+        },
+        404: {
+          description: "vNext workflow not found"
+        }
+      }
+    }),
+    startAsyncVNextWorkflowHandler
+  );
+  app.post(
+    "/api/workflows/v-next/:workflowId/start",
+    h({
+      description: "Create and start a new vNext workflow run",
+      tags: ["vNextWorkflows"],
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: true,
+          schema: { type: "string" }
+        }
+      ],
+      requestBody: {
+        required: true,
+        content: {
+          "application/json": {
+            schema: {
+              type: "object",
+              properties: {
+                inputData: { type: "object" },
+                runtimeContext: { type: "object" }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "vNext workflow run started"
+        },
+        404: {
+          description: "vNext workflow not found"
+        }
+      }
+    }),
+    startVNextWorkflowRunHandler
+  );
+  app.get(
+    "/api/workflows/v-next/:workflowId/watch",
+    h({
+      description: "Watch vNext workflow transitions in real-time",
+      parameters: [
+        {
+          name: "workflowId",
+          in: "path",
+          required: true,
+          schema: { type: "string" }
+        },
+        {
+          name: "runId",
+          in: "query",
+          required: false,
+          schema: { type: "string" }
+        }
+      ],
+      tags: ["vNextWorkflows"],
+      responses: {
+        200: {
+          description: "vNext workflow transitions in real-time"
+        }
+      }
+    }),
+    watchVNextWorkflowHandler
+  );
   app.get(
     "/api/workflows",
     h({
@@ -3284,7 +3734,7 @@ async function createHonoServer(mastra, options = {}) {
     "/api/workflows/:workflowId/startAsync",
     bodyLimit(bodyLimitOptions),
     h({
-      description: "Execute/Start a workflow",
+      description: "@deprecated Use /api/workflows/:workflowId/start-async instead",
       tags: ["workflows"],
       parameters: [
         {
@@ -3328,7 +3778,7 @@ async function createHonoServer(mastra, options = {}) {
     "/api/workflows/:workflowId/start-async",
     bodyLimit(bodyLimitOptions),
     h({
-      description: "@deprecated Use /api/workflows/:workflowId/start-async instead",
+      description: "Execute/Start a workflow",
       tags: ["workflows"],
       parameters: [
         {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/deployer",
-  "version": "0.3.0",
+  "version": "0.3.1-alpha.1",
   "description": "",
   "type": "module",
   "files": [
@@ -107,8 +107,8 @@
     "rollup-plugin-node-externals": "^8.0.0",
     "typescript-paths": "^1.5.1",
     "zod": "^3.24.2",
-    "@mastra/core": "^0.9.0",
-    "@mastra/server": "^2.0.0"
+    "@mastra/server": "^2.0.1-alpha.1",
+    "@mastra/core": "^0.9.1-alpha.1"
   },
   "devDependencies": {
     "@hono/node-server": "^1.13.8",