@mastra/deployer 0.3.0-alpha.9 → 0.3.1-alpha.1

package/dist/server/index.cjs

@@ -2,9 +2,7 @@
 
 var crypto = require('crypto');
 var promises = require('fs/promises');
-var path = require('path');
 var posix = require('path/posix');
-var url = require('url');
 var http = require('http');
 var http2 = require('http2');
 var stream = require('stream');
@@ -13,7 +11,7 @@ var mime = require('hono/utils/mime');
 var fs = require('fs');
 var html = require('hono/html');
 var core = require('@mastra/core');
-var di = require('@mastra/core/di');
+var runtimeContext = require('@mastra/core/runtime-context');
 var hono = require('hono');
 var bodyLimit = require('hono/body-limit');
 var cors = require('hono/cors');
@@ -29,11 +27,11 @@ var zod = require('zod');
 var telemetry = require('@mastra/server/handlers/telemetry');
 var tools = require('@mastra/server/handlers/tools');
 var vector = require('@mastra/server/handlers/vector');
+var vNextWorkflows = require('@mastra/server/handlers/vNextWorkflows');
+var streaming = require('hono/streaming');
 var voice = require('@mastra/server/handlers/voice');
 var workflows = require('@mastra/server/handlers/workflows');
-var streaming = require('hono/streaming');
 
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var crypto__default = /*#__PURE__*/_interopDefault(crypto);
@@ -174,14 +172,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);
@@ -379,7 +377,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;
@@ -390,7 +388,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;
     }
@@ -494,18 +492,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;
@@ -601,10 +599,10 @@ var serveStatic = (options = { root: "" }) => {
       end = size - 1;
     }
     const chunksize = end - start + 1;
-    const stream2 = fs.createReadStream(path, { start, end });
+    const stream3 = fs.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 = {
@@ -962,7 +960,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");
@@ -971,7 +969,7 @@ function handleClientsRefresh(c2) {
       });
     }
   });
-  return new Response(stream2, {
+  return new Response(stream3, {
     headers: {
       "Content-Type": "text/event-stream",
       "Cache-Control": "no-cache",
@@ -1508,6 +1506,174 @@ async function deleteIndex(c2) {
     return handleError(error, "Error deleting index");
   }
 }
+async function getVNextWorkflowsHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const workflows = await vNextWorkflows.getVNextWorkflowsHandler({
+      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 vNextWorkflows.getVNextWorkflowByIdHandler({
+      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 vNextWorkflows.createVNextWorkflowRunHandler({
+      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 vNextWorkflows.startAsyncVNextWorkflowHandler({
+      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 vNextWorkflows.startVNextWorkflowRunHandler({
+      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.HTTPException(400, { message: "runId required to watch workflow" });
+    }
+    return streaming.stream(
+      c2,
+      async (stream3) => {
+        try {
+          const result = await vNextWorkflows.watchVNextWorkflowHandler({
+            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.HTTPException(400, { message: "runId required to resume workflow" });
+    }
+    const result = await vNextWorkflows.resumeAsyncVNextWorkflowHandler({
+      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.HTTPException(400, { message: "runId required to resume workflow" });
+    }
+    await vNextWorkflows.resumeVNextWorkflowHandler({
+      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 vNextWorkflows.getVNextWorkflowRunsHandler({
+      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");
@@ -1655,20 +1821,20 @@ function watchWorkflowHandler(c2) {
     }
     return streaming.stream(
       c2,
-      async (stream2) => {
+      async (stream3) => {
         try {
           const result = await workflows.watchWorkflowHandler({
             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);
@@ -1851,12 +2017,12 @@ var html2 = `
 async function createHonoServer(mastra, options = {}) {
   const app = new hono.Hono();
   const server = mastra.getServer();
-  const __dirname = path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
-  const mastraToolsPaths = (await import(url.pathToFileURL(posix.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(url.pathToFileURL(posix.join(__dirname, toolPath)).href);
+      return import(toolPath);
     })
   ) : [];
   const tools = toolImports.reduce((acc, toolModule) => {
@@ -1886,8 +2052,8 @@ async function createHonoServer(mastra, options = {}) {
   });
   app.onError(errorHandler);
   app.use("*", function setContext(c2, next) {
-    const runtimeContext = new di.RuntimeContext();
-    c2.set("runtimeContext", runtimeContext);
+    const runtimeContext$1 = new runtimeContext.RuntimeContext();
+    c2.set("runtimeContext", runtimeContext$1);
     c2.set("mastra", mastra);
     c2.set("tools", tools);
     c2.set("playground", options.playground === true);
@@ -1955,7 +2121,7 @@ async function createHonoServer(mastra, options = {}) {
       }
     }
   }
-  if (options?.isDev || server?.build?.apiReqLogs) {
+  if (server?.build?.apiReqLogs) {
     app.use(logger.logger());
   }
   app.get(
@@ -3092,6 +3258,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.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.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.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({
@@ -3291,7 +3740,7 @@ async function createHonoServer(mastra, options = {}) {
     "/api/workflows/:workflowId/startAsync",
     bodyLimit.bodyLimit(bodyLimitOptions),
     h({
-      description: "Execute/Start a workflow",
+      description: "@deprecated Use /api/workflows/:workflowId/start-async instead",
       tags: ["workflows"],
       parameters: [
         {
@@ -3335,7 +3784,7 @@ async function createHonoServer(mastra, options = {}) {
     "/api/workflows/:workflowId/start-async",
     bodyLimit.bodyLimit(bodyLimitOptions),
     h({
-      description: "@deprecated Use /api/workflows/:workflowId/start-async instead",
+      description: "Execute/Start a workflow",
       tags: ["workflows"],
       parameters: [
         {