@mastra/deployer 0.10.0 → 0.10.1-alpha.1

package/dist/{chunk-EHPJDSR3.js → chunk-W46BY5GT.js}

@@ -1,5 +1,5 @@
 import { tsConfigPaths, removeDeployer } from './chunk-WVBUOQT6.js';
-import commonjs from '@rollup/plugin-commonjs';
+import commonjs2 from '@rollup/plugin-commonjs';
 import json from '@rollup/plugin-json';
 import nodeResolve from '@rollup/plugin-node-resolve';
 import virtual from '@rollup/plugin-virtual';
@@ -11,6 +11,8 @@ import { builtinModules } from 'node:module';
 import { join, dirname } from 'node:path';
 import { spawn as spawn$1 } from 'node:child_process';
 import { writeFile } from 'node:fs/promises';
+import * as babel from '@babel/core';
+import babel__default from '@babel/core';
 
 function isNodeBuiltin(dep) {
   const [pkg] = dep.split("/");
@@ -65,6 +67,230 @@ function validate(file) {
     }
   );
 }
+function removeAllOptionsFromMastraExcept(result, option) {
+  const t = babel__default.types;
+  return {
+    name: "remove-all-except-" + option + "-config",
+    visitor: {
+      ExportNamedDeclaration: {
+        // remove all exports
+        exit(path) {
+          path.remove();
+        }
+      },
+      NewExpression(path, state) {
+        const varDeclaratorPath = path.findParent((path2) => t.isVariableDeclarator(path2.node));
+        if (!varDeclaratorPath) {
+          return;
+        }
+        const parentNode = path.parentPath.node;
+        if (!t.isVariableDeclarator(parentNode) || !t.isIdentifier(parentNode.id) || parentNode.id.name !== "mastra") {
+          return;
+        }
+        let mastraArgs = t.objectExpression([]);
+        if (t.isObjectExpression(path.node.arguments[0])) {
+          mastraArgs = path.node.arguments[0];
+        }
+        let telemetry = mastraArgs.properties.find(
+          // @ts-ignore
+          (prop) => prop.key.name === option
+        );
+        let telemetryValue = t.objectExpression([]);
+        const programPath = path.scope.getProgramParent().path;
+        if (!programPath) {
+          return;
+        }
+        if (telemetry && t.isObjectProperty(telemetry) && t.isExpression(telemetry.value)) {
+          result.hasCustomConfig = true;
+          telemetryValue = telemetry.value;
+          if (t.isIdentifier(telemetry.value) && telemetry.value.name === option) {
+            const telemetryBinding = state.file.scope.getBinding(option);
+            if (telemetryBinding && t.isVariableDeclarator(telemetryBinding.path.node)) {
+              const id = path.scope.generateUidIdentifier(option);
+              telemetryBinding.path.replaceWith(t.variableDeclarator(id, telemetryBinding.path.node.init));
+              telemetryValue = id;
+            }
+          }
+        }
+        const exportDeclaration = t.exportNamedDeclaration(
+          t.variableDeclaration("const", [t.variableDeclarator(t.identifier(option), telemetryValue)]),
+          []
+        );
+        programPath.node.body.push(exportDeclaration);
+      }
+    }
+  };
+}
+
+// src/build/babel/remove-all-options-bundler.ts
+function removeAllOptionsExceptBundler(result) {
+  return removeAllOptionsFromMastraExcept(result, "bundler");
+}
+function removeNonReferencedNodes() {
+  const t = babel__default.types;
+  return {
+    name: "remove-non-referenced-nodes",
+    visitor: {
+      Program(path) {
+        const scope = path.scope;
+        const currentBody = path.get("body");
+        const filteredBody = currentBody.filter((childPath) => {
+          if (childPath.isExportDeclaration()) {
+            return true;
+          }
+          if (childPath.isVariableDeclaration()) {
+            return childPath.node.declarations.some((decl) => {
+              if (!t.isIdentifier(decl.id)) {
+                return false;
+              }
+              const name = decl.id.name;
+              const binding = scope.getBinding(name);
+              return binding && (binding.referenced || binding.referencePaths.length > 0);
+            });
+          }
+          if (childPath.isFunctionDeclaration() || childPath.isClassDeclaration()) {
+            if (!t.isIdentifier(childPath.node.id)) {
+              return false;
+            }
+            const name = childPath.node.id.name;
+            const binding = scope.getBinding(name);
+            return binding && (binding.referenced || binding.referencePaths.length > 0);
+          }
+          if (childPath.isImportDeclaration()) {
+            return childPath.node.specifiers.some((specifier) => {
+              const importedName = specifier.local.name;
+              const binding = scope.getBinding(importedName);
+              return binding && (binding.referenced || binding.referencePaths.length > 0);
+            });
+          }
+          return false;
+        });
+        path.set(
+          "body",
+          filteredBody.map((p) => p.node)
+        );
+      }
+    }
+  };
+}
+
+// src/build/plugins/remove-unused-references.ts
+function recursiveRemoveNonReferencedNodes(code) {
+  return new Promise(async (resolve, reject) => {
+    babel.transform(
+      code,
+      {
+        babelrc: false,
+        configFile: false,
+        plugins: [removeNonReferencedNodes()]
+      },
+      (err, result) => {
+        if (err) {
+          return reject(err);
+        }
+        if (result && result.code !== code) {
+          return recursiveRemoveNonReferencedNodes(result.code).then(resolve, reject);
+        }
+        resolve({
+          code: result.code,
+          map: result.map
+        });
+      }
+    );
+  });
+}
+
+// src/build/bundlerOptions.ts
+function getBundlerOptionsBundler(entryFile, result) {
+  return rollup({
+    logLevel: "silent",
+    input: {
+      "bundler-config": entryFile
+    },
+    treeshake: "smallest",
+    plugins: [
+      tsConfigPaths(),
+      // transpile typescript to something we understand
+      esbuild({
+        target: "node20",
+        platform: "node",
+        minify: false
+      }),
+      commonjs2({
+        extensions: [".js", ".ts"],
+        strictRequires: "strict",
+        transformMixedEsModules: true,
+        ignoreTryCatch: false
+      }),
+      {
+        name: "get-bundler-config",
+        transform(code, id) {
+          if (id !== entryFile) {
+            return;
+          }
+          return new Promise((resolve, reject) => {
+            babel.transform(
+              code,
+              {
+                babelrc: false,
+                configFile: false,
+                filename: id,
+                plugins: [removeAllOptionsExceptBundler(result)]
+              },
+              (err, result2) => {
+                if (err) {
+                  return reject(err);
+                }
+                resolve({
+                  code: result2.code,
+                  map: result2.map
+                });
+              }
+            );
+          });
+        }
+      },
+      // let esbuild remove all unused imports
+      esbuild({
+        target: "node20",
+        platform: "node",
+        minify: false
+      }),
+      {
+        name: "cleanup",
+        transform(code, id) {
+          if (id !== entryFile) {
+            return;
+          }
+          return recursiveRemoveNonReferencedNodes(code);
+        }
+      },
+      // let esbuild remove all unused imports
+      esbuild({
+        target: "node20",
+        platform: "node",
+        minify: false
+      })
+    ]
+  });
+}
+async function getBundlerOptions(entryFile, outputDir) {
+  const result = {
+    hasCustomConfig: false
+  };
+  const bundle = await getBundlerOptionsBundler(entryFile, result);
+  await bundle.write({
+    dir: outputDir,
+    format: "es",
+    entryFileNames: "[name].mjs"
+  });
+  if (result.hasCustomConfig) {
+    return (await import(`file:${outputDir}/bundler-config.mjs`)).bundler;
+  }
+  return null;
+}
+
+// src/build/analyze.ts
 var globalExternals = [
   "pino",
   "pino-pretty",
@@ -136,7 +362,7 @@ async function analyze(entry, mastraEntry, isVirtualFile, platform, logger) {
         platform,
         minify: false
       }),
-      commonjs({
+      commonjs2({
         strictRequires: "debug",
         ignoreTryCatch: false,
         transformMixedEsModules: true,
@@ -173,11 +399,12 @@ async function analyze(entry, mastraEntry, isVirtualFile, platform, logger) {
   }
   return depsToOptimize;
 }
-async function bundleExternals(depsToOptimize, outputDir, logger) {
+async function bundleExternals(depsToOptimize, outputDir, logger, customExternals) {
   logger.info("Optimizing dependencies...");
   logger.debug(
     `${Array.from(depsToOptimize.keys()).map((key) => `- ${key}`).join("\n")}`
   );
+  const allExternals = [...globalExternals, ...customExternals || []];
   const reverseVirtualReferenceMap = /* @__PURE__ */ new Map();
   const virtualDependencies = /* @__PURE__ */ new Map();
   for (const [dep, exports] of depsToOptimize.entries()) {
@@ -213,7 +440,7 @@ async function bundleExternals(depsToOptimize, outputDir, logger) {
     ),
     // this dependency breaks the build, so we need to exclude it
     // TODO actually fix this so we don't need to exclude it
-    external: globalExternals,
+    external: allExternals,
     treeshake: "smallest",
     plugins: [
       virtual(
@@ -225,7 +452,7 @@ async function bundleExternals(depsToOptimize, outputDir, logger) {
           {}
         )
       ),
-      commonjs({
+      commonjs2({
         strictRequires: "strict",
         transformMixedEsModules: true,
         ignoreTryCatch: false
@@ -250,7 +477,7 @@ async function bundleExternals(depsToOptimize, outputDir, logger) {
   const moduleResolveMap = {};
   const filteredChunks = output.filter((o) => o.type === "chunk");
   for (const o of filteredChunks.filter((o2) => o2.isEntry || o2.isDynamicEntry)) {
-    for (const external of globalExternals) {
+    for (const external of allExternals) {
       const importer = findExternalImporter(o, external, filteredChunks);
       if (importer) {
         const fullPath = join(outputDir, importer.fileName);
@@ -309,13 +536,15 @@ async function validateOutput({
 async function analyzeBundle(entry, mastraEntry, outputDir, platform, logger) {
   const isVirtualFile = entry.includes("\n") || !existsSync(entry);
   const depsToOptimize = await analyze(entry, mastraEntry, isVirtualFile, platform, logger);
+  const customExternals = (await getBundlerOptions(mastraEntry, outputDir))?.externals;
   const { output, reverseVirtualReferenceMap, usedExternals } = await bundleExternals(
     depsToOptimize,
     outputDir,
-    logger
+    logger,
+    customExternals
   );
   const result = await validateOutput({ output, reverseVirtualReferenceMap, usedExternals, outputDir }, logger);
   return result;
 }
 
-export { aliasHono, analyzeBundle };
+export { aliasHono, analyzeBundle, getBundlerOptions, recursiveRemoveNonReferencedNodes, removeAllOptionsFromMastraExcept };

package/dist/chunk-WK63QOD5.cjs

@@ -0,0 +1,125 @@
+'use strict';
+
+var chunkOJY5LJPT_cjs = require('./chunk-OJY5LJPT.cjs');
+var babel = require('@babel/core');
+var rollup = require('rollup');
+var esbuild = require('rollup-plugin-esbuild');
+var commonjs = require('@rollup/plugin-commonjs');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var babel__namespace = /*#__PURE__*/_interopNamespace(babel);
+var esbuild__default = /*#__PURE__*/_interopDefault(esbuild);
+var commonjs__default = /*#__PURE__*/_interopDefault(commonjs);
+
+// src/build/babel/remove-all-options-telemetry.ts
+function removeAllOptionsExceptTelemetry(result) {
+  return chunkOJY5LJPT_cjs.removeAllOptionsFromMastraExcept(result, "telemetry");
+}
+
+// src/build/telemetry.ts
+function getTelemetryBundler(entryFile, result) {
+  return rollup.rollup({
+    logLevel: "silent",
+    input: {
+      "telemetry-config": entryFile
+    },
+    treeshake: "smallest",
+    plugins: [
+      // transpile typescript to something we understand
+      esbuild__default.default({
+        target: "node20",
+        platform: "node",
+        minify: false
+      }),
+      commonjs__default.default({
+        extensions: [".js", ".ts"],
+        strictRequires: "strict",
+        transformMixedEsModules: true,
+        ignoreTryCatch: false
+      }),
+      {
+        name: "get-telemetry-config",
+        transform(code, id) {
+          if (id !== entryFile) {
+            return;
+          }
+          return new Promise((resolve, reject) => {
+            babel__namespace.transform(
+              code,
+              {
+                babelrc: false,
+                configFile: false,
+                filename: id,
+                plugins: [removeAllOptionsExceptTelemetry(result)]
+              },
+              (err, result2) => {
+                if (err) {
+                  return reject(err);
+                }
+                resolve({
+                  code: result2.code,
+                  map: result2.map
+                });
+              }
+            );
+          });
+        }
+      },
+      // let esbuild remove all unused imports
+      esbuild__default.default({
+        target: "node20",
+        platform: "node",
+        minify: false
+      }),
+      {
+        name: "cleanup",
+        transform(code, id) {
+          if (id !== entryFile) {
+            return;
+          }
+          return chunkOJY5LJPT_cjs.recursiveRemoveNonReferencedNodes(code);
+        }
+      },
+      // let esbuild remove all unused imports
+      esbuild__default.default({
+        target: "node20",
+        platform: "node",
+        minify: false
+      })
+    ]
+  });
+}
+async function writeTelemetryConfig(entryFile, outputDir) {
+  const result = {
+    hasCustomConfig: false
+  };
+  const bundle = await getTelemetryBundler(entryFile, result);
+  const { output } = await bundle.write({
+    dir: outputDir,
+    format: "es",
+    entryFileNames: "[name].mjs"
+  });
+  const externals = output[0].imports.filter((x) => !x.startsWith("./"));
+  return { ...result, externalDependencies: externals };
+}
+
+exports.writeTelemetryConfig = writeTelemetryConfig;

package/dist/{chunk-WHD7NHLX.cjs → chunk-YHCVXGZM.cjs}

@@ -1,7 +1,6 @@
 'use strict';
 
-var chunk3R6WDRBB_cjs = require('./chunk-3R6WDRBB.cjs');
-var chunkHHZDRBPV_cjs = require('./chunk-HHZDRBPV.cjs');
+var chunkOJY5LJPT_cjs = require('./chunk-OJY5LJPT.cjs');
 var chunkIMGVLBV7_cjs = require('./chunk-IMGVLBV7.cjs');
 var chunk54KOF3NB_cjs = require('./chunk-54KOF3NB.cjs');
 var rollup = require('rollup');
@@ -49,7 +48,7 @@ async function getInputOptions2(entryFile, platform, env) {
       // @ts-ignore
       (plugin) => !plugin || !plugin?.name || plugin.name !== "node-resolve"
     );
-    inputOptions.plugins.push(chunkHHZDRBPV_cjs.aliasHono());
+    inputOptions.plugins.push(chunkOJY5LJPT_cjs.aliasHono());
   }
   return inputOptions;
 }
@@ -68,7 +67,7 @@ async function createWatcher(inputOptions, outputOptions) {
 
 // src/build/babel/remove-all-options-server.ts
 function removeAllOptionsExceptServer(result) {
-  return chunk3R6WDRBB_cjs.removeAllOptionsFromMastraExcept(result, "server");
+  return chunkOJY5LJPT_cjs.removeAllOptionsFromMastraExcept(result, "server");
 }
 function getServerOptionsBundler(entryFile, result) {
   return rollup.rollup({
@@ -131,7 +130,7 @@ function getServerOptionsBundler(entryFile, result) {
           if (id !== entryFile) {
             return;
           }
-          return chunk3R6WDRBB_cjs.recursiveRemoveNonReferencedNodes(code);
+          return chunkOJY5LJPT_cjs.recursiveRemoveNonReferencedNodes(code);
         }
       },
       // let esbuild remove all unused imports

package/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var chunkBQAYAQTU_cjs = require('./chunk-BQAYAQTU.cjs');
-var chunk3R6WDRBB_cjs = require('./chunk-3R6WDRBB.cjs');
+var chunkPJB6TDF7_cjs = require('./chunk-PJB6TDF7.cjs');
+var chunkOJY5LJPT_cjs = require('./chunk-OJY5LJPT.cjs');
 var chunk4VC5Z4YR_cjs = require('./chunk-4VC5Z4YR.cjs');
 var babel = require('@babel/core');
 var rollup = require('rollup');
@@ -33,7 +33,7 @@ var esbuild__default = /*#__PURE__*/_interopDefault(esbuild);
 var commonjs__default = /*#__PURE__*/_interopDefault(commonjs);
 
 // src/deploy/base.ts
-var Deployer = class extends chunkBQAYAQTU_cjs.Bundler {
+var Deployer = class extends chunkPJB6TDF7_cjs.Bundler {
   deps = new chunk4VC5Z4YR_cjs.DepsService();
   constructor(args) {
     super(args.name, "DEPLOYER");
@@ -148,7 +148,7 @@ function getDeployerBundler(entryFile, result) {
           if (id !== entryFile) {
             return;
           }
-          return chunk3R6WDRBB_cjs.recursiveRemoveNonReferencedNodes(code);
+          return chunkOJY5LJPT_cjs.recursiveRemoveNonReferencedNodes(code);
         }
       },
       // let esbuild remove all unused imports

package/dist/index.js

@@ -1,5 +1,5 @@
-import { Bundler } from './chunk-YU2QBGOU.js';
-import { recursiveRemoveNonReferencedNodes } from './chunk-TUMXQX4H.js';
+import { Bundler } from './chunk-DGNRILK6.js';
+import { recursiveRemoveNonReferencedNodes } from './chunk-W46BY5GT.js';
 import { DepsService, FileService } from './chunk-UV4RQQ3R.js';
 export { Deps, FileService, createChildProcessLogger, createPinoStream } from './chunk-UV4RQQ3R.js';
 import * as babel from '@babel/core';

package/dist/server/index.cjs

@@ -4180,16 +4180,16 @@ function watchWorkflowHandler(c2) {
             workflowId,
             runId
           });
+          const reader = result.getReader();
           stream4.onAbort(() => {
-            if (!result.locked) {
-              return result.cancel();
-            }
+            void reader.cancel("request aborted");
           });
-          for await (const chunk of result) {
-            await stream4.write(chunk.toString() + "");
+          let chunkResult;
+          while ((chunkResult = await reader.read()) && !chunkResult.done) {
+            await stream4.write(JSON.stringify(chunkResult.value) + "");
           }
         } catch (err) {
-          console.log(err);
+          mastra.getLogger().error("Error in watch stream: " + (err?.message ?? "Unknown error"));
         }
       },
       async (err) => {
@@ -4200,6 +4200,46 @@ function watchWorkflowHandler(c2) {
     return handleError(error, "Error watching workflow");
   }
 }
+async function streamWorkflowHandler(c2) {
+  try {
+    const mastra = c2.get("mastra");
+    const logger2 = mastra.getLogger();
+    const workflowId = c2.req.param("workflowId");
+    const runtimeContext = c2.get("runtimeContext");
+    const { inputData, runtimeContext: runtimeContextFromRequest } = await c2.req.json();
+    const runId = c2.req.query("runId");
+    return streaming.stream(
+      c2,
+      async (stream4) => {
+        try {
+          const result = workflows.streamWorkflowHandler({
+            mastra,
+            workflowId,
+            runId,
+            inputData,
+            runtimeContext,
+            runtimeContextFromRequest
+          });
+          const reader = result.stream.getReader();
+          stream4.onAbort(() => {
+            void reader.cancel("request aborted");
+          });
+          let chunkResult;
+          while ((chunkResult = await reader.read()) && !chunkResult.done) {
+            await stream4.write(JSON.stringify(chunkResult.value) + "");
+          }
+        } catch (err) {
+          console.log(err);
+        }
+      },
+      async (err) => {
+        logger2.error("Error in workflow stream: " + err?.message);
+      }
+    );
+  } catch (error) {
+    return handleError(error, "Error streaming workflow");
+  }
+}
 async function resumeAsyncWorkflowHandler(c2) {
   try {
     const mastra = c2.get("mastra");
@@ -5501,7 +5541,7 @@ async function createHonoServer(mastra, options = {}) {
     executeAgentToolHandler
   );
   app.post(
-    "/api/mcp/:serverId/mcp",
+    "/api/servers/:serverId/mcp",
     bodyLimit.bodyLimit(bodyLimitOptions),
     h({
       description: "Send a message to an MCP server using Streamable HTTP",
@@ -5528,8 +5568,8 @@ async function createHonoServer(mastra, options = {}) {
     }),
     getMcpServerMessageHandler
   );
-  const mcpSseBasePath = "/api/mcp/:serverId/sse";
-  const mcpSseMessagePath = "/api/mcp/:serverId/messages";
+  const mcpSseBasePath = "/api/servers/:serverId/sse";
+  const mcpSseMessagePath = "/api/servers/:serverId/messages";
   app.get(
     mcpSseBasePath,
     h({
@@ -6286,7 +6326,7 @@ async function createHonoServer(mastra, options = {}) {
         {
           name: "runId",
           in: "query",
-          required: false,
+          required: true,
           schema: { type: "string" }
         }
       ],
@@ -6299,6 +6339,53 @@ async function createHonoServer(mastra, options = {}) {
     }),
     watchLegacyWorkflowHandler
   );
+  app.post(
+    "/api/workflows/:workflowId/stream",
+    h({
+      description: "Stream workflow in real-time",
+      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",
+                  description: "Runtime context for the workflow execution"
+                }
+              }
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "vNext workflow run started"
+        },
+        404: {
+          description: "vNext workflow not found"
+        }
+      },
+      tags: ["vNextWorkflows"]
+    }),
+    streamWorkflowHandler
+  );
   app.get(
     "/api/workflows",
     h({
@@ -7011,7 +7098,7 @@ async function createNodeServer(mastra, options = {}) {
     {
       fetch: app.fetch,
       port,
-      hostname: serverOptions?.host
+      hostname: serverOptions?.host ?? "localhost"
     },
     () => {
       const logger2 = mastra.getLogger();