@mastra/core 0.5.0-alpha.8 → 0.5.0

package/dist/{chunk-KBSR2LLT.js → chunk-OD7ZMKHY.js}

@@ -1,4 +1,4 @@
-import { createMastraProxy } from './chunk-HBHPTMAC.js';
+import { createMastraProxy } from './chunk-4Y74D74B.js';
 import { MastraBase } from './chunk-4VHCCQ7P.js';
 import { setTimeout } from 'node:timers/promises';
 import { context, trace } from '@opentelemetry/api';
@@ -12,6 +12,7 @@ var WhenConditionReturnValue = /* @__PURE__ */ ((WhenConditionReturnValue2) => {
   WhenConditionReturnValue2["CONTINUE"] = "continue";
   WhenConditionReturnValue2["CONTINUE_FAILED"] = "continue_failed";
   WhenConditionReturnValue2["ABORT"] = "abort";
+  WhenConditionReturnValue2["LIMBO"] = "limbo";
   return WhenConditionReturnValue2;
 })(WhenConditionReturnValue || {});
 
@@ -47,13 +48,16 @@ function getSuspendedPaths({
 function isFinalState(status) {
   return ["completed", "failed"].includes(status);
 }
+function isLimboState(status) {
+  return status === "limbo";
+}
 function recursivelyCheckForFinalState({
   value,
   suspendedPaths,
   path
 }) {
   if (typeof value === "string") {
-    return isFinalState(value) || suspendedPaths.has(path);
+    return isFinalState(value) || isLimboState(value) || suspendedPaths.has(path);
   }
   return Object.keys(value).every(
     (key) => recursivelyCheckForFinalState({ value: value[key], suspendedPaths, path: path ? `${path}.${key}` : key })
@@ -320,6 +324,7 @@ var Machine = class extends EventEmitter {
     return {
       resolverFunction: fromPromise(async ({ input }) => {
         const { stepNode, context } = input;
+        const attemptCount = context.attempts[stepNode.step.id];
         const resolvedData = this.#resolveVariables({
           stepConfig: stepNode.config,
           context,
@@ -334,54 +339,65 @@ var Machine = class extends EventEmitter {
         if (this.#mastra) {
           mastraProxy = createMastraProxy({ mastra: this.#mastra, logger });
         }
-        const result = await stepNode.config.handler({
-          context: resolvedData,
-          suspend: async (payload) => {
-            await this.#workflowInstance.suspend(stepNode.step.id, this);
-            if (this.#actor) {
-              context.steps[stepNode.step.id] = {
-                status: "suspended",
-                suspendPayload: payload
-              };
-              this.logger.debug(`Sending SUSPENDED event for step ${stepNode.step.id}`);
-              this.#actor?.send({ type: "SUSPENDED", suspendPayload: payload, stepId: stepNode.step.id });
-            } else {
-              this.logger.debug(`Actor not available for step ${stepNode.step.id}`);
-            }
-          },
-          runId: this.#runId,
-          mastra: mastraProxy
-        });
+        let result = void 0;
+        try {
+          result = await stepNode.config.handler({
+            context: resolvedData,
+            suspend: async (payload) => {
+              await this.#workflowInstance.suspend(stepNode.step.id, this);
+              if (this.#actor) {
+                context.steps[stepNode.step.id] = {
+                  status: "suspended",
+                  suspendPayload: payload
+                };
+                this.logger.debug(`Sending SUSPENDED event for step ${stepNode.step.id}`);
+                this.#actor?.send({ type: "SUSPENDED", suspendPayload: payload, stepId: stepNode.step.id });
+              } else {
+                this.logger.debug(`Actor not available for step ${stepNode.step.id}`);
+              }
+            },
+            runId: this.#runId,
+            mastra: mastraProxy
+          });
+        } catch (error) {
+          this.logger.debug(`Step ${stepNode.step.id} failed`, {
+            stepId: stepNode.step.id,
+            error,
+            runId: this.#runId
+          });
+          this.logger.debug(`Attempt count for step ${stepNode.step.id}`, {
+            attemptCount,
+            attempts: context.attempts,
+            runId: this.#runId,
+            stepId: stepNode.step.id
+          });
+          if (!attemptCount || attemptCount < 0) {
+            return {
+              type: "STEP_FAILED",
+              error: error instanceof Error ? error.message : `Step:${stepNode.step.id} failed with error: ${error}`,
+              stepId: stepNode.step.id
+            };
+          }
+          return { type: "STEP_WAITING", stepId: stepNode.step.id };
+        }
         this.logger.debug(`Step ${stepNode.step.id} result`, {
           stepId: stepNode.step.id,
           result,
           runId: this.#runId
         });
         return {
-          stepId: stepNode.step.id,
-          result
+          type: "STEP_SUCCESS",
+          result,
+          stepId: stepNode.step.id
         };
       }),
       conditionCheck: fromPromise(async ({ input }) => {
         const { context, stepNode } = input;
         const stepConfig = stepNode.config;
-        const attemptCount = context.attempts[stepNode.step.id];
         this.logger.debug(`Checking conditions for step ${stepNode.step.id}`, {
           stepId: stepNode.step.id,
           runId: this.#runId
         });
-        this.logger.debug(`Attempt count for step ${stepNode.step.id}`, {
-          attemptCount,
-          attempts: context.attempts,
-          runId: this.#runId,
-          stepId: stepNode.step.id
-        });
-        if (!attemptCount || attemptCount < 0) {
-          if (stepConfig?.snapshotOnTimeout) {
-            return { type: "SUSPENDED", stepId: stepNode.step.id };
-          }
-          return { type: "CONDITION_FAILED", error: `Step:${stepNode.step.id} condition check failed` };
-        }
         if (!stepConfig?.when) {
           return { type: "CONDITIONS_MET" };
         }
@@ -394,10 +410,11 @@ var Machine = class extends EventEmitter {
             context: {
               ...context,
               getStepResult: (stepId) => {
-                if (stepId === "trigger") {
+                const resolvedStepId = typeof stepId === "string" ? stepId : stepId.id;
+                if (resolvedStepId === "trigger") {
                   return context.triggerData;
                 }
-                const result = context.steps[stepId];
+                const result = context.steps[resolvedStepId];
                 if (result && result.status === "success") {
                   return result.output;
                 }
@@ -410,6 +427,8 @@ var Machine = class extends EventEmitter {
             conditionMet = false;
           } else if (conditionMet === "continue_failed" /* CONTINUE_FAILED */) {
             return { type: "CONDITIONS_SKIPPED" };
+          } else if (conditionMet === "limbo" /* LIMBO */) {
+            return { type: "CONDITIONS_LIMBO" };
           } else if (conditionMet) {
             this.logger.debug(`Condition met for step ${stepNode.step.id}`, {
               stepId: stepNode.step.id,
@@ -417,10 +436,7 @@ var Machine = class extends EventEmitter {
             });
             return { type: "CONDITIONS_MET" };
           }
-          if (!attemptCount || attemptCount < 0) {
-            return { type: "CONDITION_FAILED", error: `Step:${stepNode.step.id} condition check failed` };
-          }
-          return { type: "WAITING", stepId: stepNode.step.id };
+          return { type: "CONDITIONS_LIMBO" };
         } else {
           const conditionMet = this.#evaluateCondition(stepConfig.when, context);
           if (!conditionMet) {
@@ -459,10 +475,11 @@ var Machine = class extends EventEmitter {
     const resolvedData = {
       ...context,
       getStepResult: (stepId2) => {
-        if (stepId2 === "trigger") {
+        const resolvedStepId = typeof stepId2 === "string" ? stepId2 : stepId2.id;
+        if (resolvedStepId === "trigger") {
           return context.triggerData;
         }
-        const result = context.steps[stepId2];
+        const result = context.steps[resolvedStepId];
         if (result && result.status === "success") {
           return result.output;
         }
@@ -608,6 +625,27 @@ var Machine = class extends EventEmitter {
                 },
                 target: "completed"
               },
+              {
+                guard: ({ event }) => {
+                  return event.output.type === "CONDITIONS_LIMBO";
+                },
+                target: "limbo",
+                actions: assign({
+                  steps: ({ context }) => {
+                    const newStep = {
+                      ...context.steps,
+                      [stepNode.step.id]: {
+                        status: "skipped"
+                      }
+                    };
+                    this.logger.debug(`Step ${stepNode.step.id} skipped`, {
+                      stepId: stepNode.step.id,
+                      runId: this.#runId
+                    });
+                    return newStep;
+                  }
+                })
+              },
               {
                 guard: ({ event }) => {
                   return event.output.type === "CONDITION_FAILED";
@@ -654,6 +692,23 @@ var Machine = class extends EventEmitter {
             }
           }
         },
+        limbo: {
+          // no target, will stay in limbo indefinitely
+          entry: () => {
+            this.logger.debug(`Step ${stepNode.step.id} limbo`, {
+              stepId: stepNode.step.id,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              runId: this.#runId
+            });
+          },
+          exit: () => {
+            this.logger.debug(`Step ${stepNode.step.id} finished limbo`, {
+              stepId: stepNode.step.id,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+              runId: this.#runId
+            });
+          }
+        },
         suspended: {
           type: "final",
           entry: [
@@ -708,18 +763,68 @@ var Machine = class extends EventEmitter {
               context,
               stepNode
             }),
-            onDone: {
-              target: "runningSubscribers",
-              actions: [
-                ({ event }) => this.logger.debug(`Step ${stepNode.step.id} finished executing`, {
-                  stepId: stepNode.step.id,
-                  output: event.output,
-                  runId: this.#runId
-                }),
-                { type: "updateStepResult", params: { stepId: stepNode.step.id } },
-                { type: "spawnSubscribers", params: { stepId: stepNode.step.id } }
-              ]
-            },
+            onDone: [
+              {
+                guard: ({ event }) => {
+                  return event.output.type === "STEP_FAILED";
+                },
+                target: "failed",
+                actions: assign({
+                  steps: ({ context, event }) => {
+                    if (event.output.type !== "STEP_FAILED") return context.steps;
+                    const newStep = {
+                      ...context.steps,
+                      [stepNode.step.id]: {
+                        status: "failed",
+                        error: event.output.error
+                      }
+                    };
+                    this.logger.debug(`Step ${stepNode.step.id} failed`, {
+                      error: event.output.error,
+                      stepId: stepNode.step.id
+                    });
+                    return newStep;
+                  }
+                })
+              },
+              {
+                guard: ({ event }) => {
+                  return event.output.type === "STEP_SUCCESS";
+                },
+                actions: [
+                  ({ event }) => {
+                    this.logger.debug(`Step ${stepNode.step.id} finished executing`, {
+                      stepId: stepNode.step.id,
+                      output: event.output,
+                      runId: this.#runId
+                    });
+                  },
+                  { type: "updateStepResult", params: { stepId: stepNode.step.id } },
+                  { type: "spawnSubscribers", params: { stepId: stepNode.step.id } }
+                ],
+                target: "runningSubscribers"
+              },
+              {
+                guard: ({ event }) => {
+                  return event.output.type === "STEP_WAITING";
+                },
+                target: "waiting",
+                actions: [
+                  { type: "decrementAttemptCount", params: { stepId: stepNode.step.id } },
+                  assign({
+                    steps: ({ context, event }) => {
+                      if (event.output.type !== "STEP_WAITING") return context.steps;
+                      return {
+                        ...context.steps,
+                        [stepNode.step.id]: {
+                          status: "waiting"
+                        }
+                      };
+                    }
+                  })
+                ]
+              }
+            ],
             onError: {
               target: "failed",
               actions: [{ type: "setStepError", params: { stepId: stepNode.step.id } }]
@@ -973,7 +1078,8 @@ var WorkflowInstance = class {
       steps: this.#steps,
       stepGraph,
       executionSpan: this.#executionSpan,
-      startStepId
+      startStepId,
+      retryConfig: this.#retryConfig
     });
     this.#machines[startStepId] = defaultMachine;
     const stateUpdateHandler = (startStepId2, state, context) => {
@@ -1004,7 +1110,7 @@ var WorkflowInstance = class {
     const stepStatus = input.steps[parentStepId]?.status;
     const subscriberKeys = Object.keys(this.#stepSubscriberGraph).filter((key) => key.split("&&").includes(parentStepId));
     subscriberKeys.forEach((key) => {
-      if (["success", "failure"].includes(stepStatus) && this.#isCompoundKey(key)) {
+      if (["success", "failure", "skipped"].includes(stepStatus) && this.#isCompoundKey(key)) {
         this.#compoundDependencies[key][parentStepId] = true;
       }
     });
@@ -1207,6 +1313,7 @@ var Workflow = class extends MastraBase {
         telemetry: mastra.getTelemetry(),
         logger: mastra.getLogger()
       });
+      this.#mastra = mastra;
     }
   }
   step(step, config) {
@@ -1223,6 +1330,7 @@ var Workflow = class extends MastraBase {
       config: {
         ...this.#makeStepDef(stepKey),
         ...config,
+        serializedWhen: typeof config?.when === "function" ? config.when.toString() : config?.when,
         data: requiredData
       }
     };
@@ -1259,6 +1367,7 @@ var Workflow = class extends MastraBase {
       config: {
         ...this.#makeStepDef(stepKey),
         ...config,
+        serializedWhen: typeof config?.when === "function" ? config.when.toString() : config?.when,
         data: requiredData
       }
     };
@@ -1508,10 +1617,14 @@ var Workflow = class extends MastraBase {
         return await context.with(
           trace.setSpan(context.active(), this.getExecutionSpan(attributes?.runId ?? data?.runId)),
           async () => {
-            return this.#mastra.telemetry.traceMethod(handler2, {
-              spanName,
-              attributes
-            })(data);
+            if (this?.telemetry) {
+              return this.telemetry.traceMethod(handler2, {
+                spanName,
+                attributes
+              })(data);
+            } else {
+              return handler2(data);
+            }
           }
         );
       };
@@ -1525,7 +1638,7 @@ var Workflow = class extends MastraBase {
         ...payload,
         ...context
       };
-      const finalAction = this.#mastra?.getTelemetry() ? executeStep(execute, `workflow.${this.name}.action.${stepId}`, {
+      const finalAction = this.telemetry ? executeStep(execute, `workflow.${this.name}.action.${stepId}`, {
         componentName: this.name,
         runId: rest.runId
       }) : execute;
@@ -1730,4 +1843,4 @@ function createStep(opts) {
   return new Step(opts);
 }
 
-export { Step, WhenConditionReturnValue, Workflow, createStep, getActivePathsAndStatus, getResultActivePaths, getStepResult, getSuspendedPaths, isErrorEvent, isFinalState, isTransitionEvent, isVariableReference, mergeChildValue, recursivelyCheckForFinalState, updateStepInHierarchy };
+export { Step, WhenConditionReturnValue, Workflow, createStep, getActivePathsAndStatus, getResultActivePaths, getStepResult, getSuspendedPaths, isErrorEvent, isFinalState, isLimboState, isTransitionEvent, isVariableReference, mergeChildValue, recursivelyCheckForFinalState, updateStepInHierarchy };

package/dist/chunk-OTFLHXHZ.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+var chunk3ASEZT7U_cjs = require('./chunk-3ASEZT7U.cjs');
+var cohereAi = require('cohere-ai');
+
+var CohereRelevanceScorer = class {
+  client;
+  model;
+  constructor(model, apiKey) {
+    this.client = new cohereAi.CohereClient({
+      token: apiKey || process.env.COHERE_API_KEY || ""
+    });
+    this.model = model;
+  }
+  async getRelevanceScore(query, text) {
+    const response = await this.client.rerank({
+      query,
+      documents: [text],
+      model: this.model,
+      topN: 1
+    });
+    return response.results[0].relevanceScore;
+  }
+};
+
+// src/relevance/relevance-score-provider.ts
+function createSimilarityPrompt(query, text) {
+  return `Rate the semantic similarity between the following the query and the text on a scale from 0 to 1 (decimals allowed), where 1 means exactly the same meaning and 0 means completely different:
+
+Query: ${query}
+
+Text: ${text}
+
+Relevance score (0-1):`;
+}
+
+// src/relevance/mastra-agent/index.ts
+var MastraAgentRelevanceScorer = class {
+  agent;
+  constructor(name, model) {
+    this.agent = new chunk3ASEZT7U_cjs.Agent({
+      name: `Relevance Scorer ${name}`,
+      instructions: `You are a specialized agent for evaluating the relevance of text to queries.
+Your task is to rate how well a text passage answers a given query.
+Output only a number between 0 and 1, where:
+1.0 = Perfectly relevant, directly answers the query
+0.0 = Completely irrelevant
+Consider:
+- Direct relevance to the question
+- Completeness of information
+- Quality and specificity
+Always return just the number, no explanation.`,
+      model
+    });
+  }
+  async getRelevanceScore(query, text) {
+    const prompt = createSimilarityPrompt(query, text);
+    const response = await this.agent.generate(prompt);
+    return parseFloat(response.text);
+  }
+};
+
+exports.CohereRelevanceScorer = CohereRelevanceScorer;
+exports.MastraAgentRelevanceScorer = MastraAgentRelevanceScorer;
+exports.createSimilarityPrompt = createSimilarityPrompt;

package/dist/chunk-RWTSGWWL.cjs

@@ -0,0 +1,81 @@
+'use strict';
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = msg => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", {
+  value,
+  configurable: true
+});
+var __decoratorStart = base => [,,, __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = fn => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({
+  kind: __decoratorStrings[kind],
+  name,
+  metadata,
+  addInitializer: fn => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null))
+});
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn,
+    it,
+    done,
+    ctx,
+    access,
+    k = flags & 7,
+    s = !!(flags & 8),
+    p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0,
+    key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []),
+    extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : {
+    get [name]() {
+      return __privateGet(this, extra);
+    },
+    set [name](x) {
+      return __privateSet(this, extra, x);
+    }
+  }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = {
+        has: p ? x => __privateIn(target, x) : x => name in x
+      };
+      if (k ^ 3) access.get = p ? x => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : x => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : {
+      get: desc.get,
+      set: desc.set
+    } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);else if (typeof it !== "object" || it === null) __typeError("Object expected");else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+exports.__decorateElement = __decorateElement;
+exports.__decoratorStart = __decoratorStart;
+exports.__runInitializers = __runInitializers;

package/dist/chunk-ST5RMVLG.cjs

@@ -0,0 +1,87 @@
+'use strict';
+
+// src/hooks/mitt.ts
+function mitt(all) {
+  all = all || /* @__PURE__ */ new Map();
+  return {
+    /**
+     * A Map of event names to registered handler functions.
+     */
+    all,
+    /**
+     * Register an event handler for the given type.
+     * @param {string|symbol} type Type of event to listen for, or `'*'` for all events
+     * @param {Function} handler Function to call in response to given event
+     * @memberOf mitt
+     */
+    on(type, handler) {
+      const handlers = all.get(type);
+      if (handlers) {
+        handlers.push(handler);
+      } else {
+        all.set(type, [handler]);
+      }
+    },
+    /**
+     * Remove an event handler for the given type.
+     * If `handler` is omitted, all handlers of the given type are removed.
+     * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)
+     * @param {Function} [handler] Handler function to remove
+     * @memberOf mitt
+     */
+    off(type, handler) {
+      const handlers = all.get(type);
+      if (handlers) {
+        if (handler) {
+          handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+        } else {
+          all.set(type, []);
+        }
+      }
+    },
+    /**
+     * Invoke all handlers for the given type.
+     * If present, `'*'` handlers are invoked after type-matched handlers.
+     *
+     * Note: Manually firing '*' handlers is not supported.
+     *
+     * @param {string|symbol} type The event type to invoke
+     * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
+     * @memberOf mitt
+     */
+    emit(type, evt) {
+      let handlers = all.get(type);
+      if (handlers) {
+        handlers.slice().map((handler) => {
+          handler(evt);
+        });
+      }
+      handlers = all.get("*");
+      if (handlers) {
+        handlers.slice().map((handler) => {
+          handler(type, evt);
+        });
+      }
+    }
+  };
+}
+
+// src/hooks/index.ts
+var AvailableHooks = /* @__PURE__ */ ((AvailableHooks2) => {
+  AvailableHooks2["ON_EVALUATION"] = "onEvaluation";
+  AvailableHooks2["ON_GENERATION"] = "onGeneration";
+  return AvailableHooks2;
+})(AvailableHooks || {});
+var hooks = mitt();
+function registerHook(hook, action) {
+  hooks.on(hook, action);
+}
+function executeHook(hook, data) {
+  setImmediate(() => {
+    hooks.emit(hook, data);
+  });
+}
+
+exports.AvailableHooks = AvailableHooks;
+exports.executeHook = executeHook;
+exports.registerHook = registerHook;

package/dist/chunk-SYQ7NK2E.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+var chunkIIWRJFLQ_cjs = require('./chunk-IIWRJFLQ.cjs');
+var promises = require('fs/promises');
+var dotenv = require('dotenv');
+
+var MastraBundler = class extends chunkIIWRJFLQ_cjs.MastraBase {
+  constructor({ name, component = "BUNDLER" }) {
+    super({ component, name });
+  }
+  async loadEnvVars() {
+    const envVars = /* @__PURE__ */ new Map();
+    for (const file of await this.getEnvFiles()) {
+      const content = await promises.readFile(file, "utf-8");
+      const config = dotenv.parse(content);
+      Object.entries(config).forEach(([key, value]) => {
+        envVars.set(key, value);
+      });
+    }
+    return envVars;
+  }
+};
+
+exports.MastraBundler = MastraBundler;