@mastra/core 0.4.2-alpha.0 → 0.4.2-alpha.2

package/dist/{chunk-ORM3OCHX.js → chunk-7TG2Y45H.js}

@@ -1,12 +1,12 @@
-import { InstrumentClass } from './chunk-4ZRHVG25.js';
+import { InstrumentClass } from './chunk-W5HVJX45.js';
 import { delay } from './chunk-WIBGG4X6.js';
-import { MastraBase } from './chunk-6RDA4JYW.js';
-import { RegisteredLogger } from './chunk-KP5SHTKA.js';
+import { MastraBase } from './chunk-OZ4XVJ6F.js';
+import { RegisteredLogger } from './chunk-PHMSPCTC.js';
 import { executeHook } from './chunk-BB4KXGBU.js';
 import { __decoratorStart, __decorateElement, __runInitializers } from './chunk-C6A6W6XS.js';
 import { randomUUID } from 'crypto';
 import { z } from 'zod';
-import { generateText, jsonSchema, generateObject, streamText, streamObject } from 'ai';
+import { jsonSchema, generateText, Output, generateObject, streamText, streamObject } from 'ai';
 
 // src/llm/model/base.ts
 var MastraLLMBase = class extends MastraBase {
@@ -152,11 +152,11 @@ var MastraLLM = class extends MastraLLMBase {
                 tool: k,
                 props
               });
-              return tool.execute({
+              return tool?.execute?.({
                 context: props,
                 mastra: this.#mastra,
                 runId
-              });
+              }) ?? void 0;
             } catch (error) {
               this.logger.error("Error executing tool", {
                 tool: k,
@@ -181,7 +181,8 @@ var MastraLLM = class extends MastraLLMBase {
     convertedTools,
     temperature,
     toolChoice = "auto",
-    onStepFinish
+    onStepFinish,
+    experimental_output
   }) {
     const model = this.#model;
     this.logger.debug(`[LLM] - Generating text`, {
@@ -213,15 +214,34 @@ var MastraLLM = class extends MastraLLMBase {
           runId
         });
         if (props?.response?.headers?.["x-ratelimit-remaining-tokens"] && parseInt(props?.response?.headers?.["x-ratelimit-remaining-tokens"], 10) < 2e3) {
-          this.logger.warn("Rate limit approaching, waiting 10 seconds");
+          this.logger.warn("Rate limit approaching, waiting 10 seconds", {
+            runId
+          });
           await delay(10 * 1e3);
         }
       }
     };
+    let schema;
+    if (experimental_output) {
+      this.logger.debug("[LLM] - Using experimental output", {
+        runId
+      });
+      if (typeof experimental_output.parse === "function") {
+        schema = experimental_output;
+        if (schema instanceof z.ZodArray) {
+          schema = schema._def.type;
+        }
+      } else {
+        schema = jsonSchema(experimental_output);
+      }
+    }
     return await generateText({
       messages,
       ...argsForExecute,
-      experimental_telemetry: this.experimental_telemetry
+      experimental_telemetry: this.experimental_telemetry,
+      experimental_output: schema ? Output.object({
+        schema
+      }) : void 0
     });
   }
   async __textObject({
@@ -297,7 +317,8 @@ var MastraLLM = class extends MastraLLMBase {
     convertedTools,
     runId,
     temperature,
-    toolChoice = "auto"
+    toolChoice = "auto",
+    experimental_output
   }) {
     const model = this.#model;
     this.logger.debug(`[LLM] - Streaming text`, {
@@ -347,10 +368,27 @@ var MastraLLM = class extends MastraLLMBase {
         });
       }
     };
+    let schema;
+    if (experimental_output) {
+      this.logger.debug("[LLM] - Using experimental output", {
+        runId
+      });
+      if (typeof experimental_output.parse === "function") {
+        schema = experimental_output;
+        if (schema instanceof z.ZodArray) {
+          schema = schema._def.type;
+        }
+      } else {
+        schema = jsonSchema(experimental_output);
+      }
+    }
     return await streamText({
       messages,
       ...argsForExecute,
-      experimental_telemetry: this.experimental_telemetry
+      experimental_telemetry: this.experimental_telemetry,
+      experimental_output: schema ? Output.object({
+        schema
+      }) : void 0
     });
   }
   async __streamObject({
@@ -525,7 +563,7 @@ var Agent = class extends (_a = MastraBase) {
     this.name = config.name;
     this.instructions = config.instructions;
     if (!config.model) {
-      throw new Error(`LanugageModel is required to create an Agent. Please provider the 'model'.`);
+      throw new Error(`LanguageModel is required to create an Agent. Please provide the 'model'.`);
     }
     this.llm = new MastraLLM({
       model: config.model
@@ -880,11 +918,11 @@ var Agent = class extends (_a = MastraBase) {
                 args,
                 runId
               });
-              return tool.execute({
+              return tool?.execute?.({
                 context: args,
                 mastra: this.#mastra,
                 runId
-              });
+              }) ?? void 0;
             } catch (err) {
               this.logger.error(`[Agent:${this.name}] - Failed execution`, {
                 error: err,
@@ -1104,7 +1142,8 @@ var Agent = class extends (_a = MastraBase) {
     toolsets,
     output = "text",
     temperature,
-    toolChoice = "auto"
+    toolChoice = "auto",
+    experimental_output
   } = {}) {
     let messagesToUse = [];
     if (typeof messages === `string`) {
@@ -1141,6 +1180,30 @@ var Agent = class extends (_a = MastraBase) {
       messageObjects,
       convertedTools
     } = await before();
+    if (output === "text" && experimental_output) {
+      const result2 = await this.llm.__text({
+        messages: messageObjects,
+        tools: this.tools,
+        convertedTools,
+        onStepFinish,
+        maxSteps,
+        runId: runIdToUse,
+        temperature,
+        toolChoice,
+        experimental_output
+      });
+      const outputText2 = result2.text;
+      await after({
+        result: result2,
+        threadId,
+        memoryConfig: memoryOptions,
+        outputText: outputText2,
+        runId: runIdToUse
+      });
+      const newResult = result2;
+      newResult.object = result2.experimental_output;
+      return newResult;
+    }
     if (output === "text") {
       const result2 = await this.llm.__text({
         messages: messageObjects,
@@ -1195,7 +1258,8 @@ var Agent = class extends (_a = MastraBase) {
     toolsets,
     output = "text",
     temperature,
-    toolChoice = "auto"
+    toolChoice = "auto",
+    experimental_output
   } = {}) {
     const runIdToUse = runId || randomUUID();
     let messagesToUse = [];
@@ -1232,7 +1296,44 @@ var Agent = class extends (_a = MastraBase) {
       messageObjects,
       convertedTools
     } = await before();
-    if (output === "text") {
+    if (output === "text" && experimental_output) {
+      this.logger.debug(`Starting agent ${this.name} llm stream call`, {
+        runId
+      });
+      const streamResult = await this.llm.__stream({
+        messages: messageObjects,
+        temperature,
+        tools: this.tools,
+        convertedTools,
+        onStepFinish,
+        onFinish: async result => {
+          try {
+            const res = JSON.parse(result) || {};
+            const outputText = res.text;
+            await after({
+              result: res,
+              threadId,
+              memoryConfig: memoryOptions,
+              outputText,
+              runId: runIdToUse
+            });
+          } catch (e) {
+            this.logger.error("Error saving memory on finish", {
+              error: e,
+              runId
+            });
+          }
+          onFinish?.(result);
+        },
+        maxSteps,
+        runId: runIdToUse,
+        toolChoice,
+        experimental_output
+      });
+      const newStreamResult = streamResult;
+      newStreamResult.partialObjectStream = streamResult.experimental_partialOutputStream;
+      return newStreamResult;
+    } else if (output === "text") {
       this.logger.debug(`Starting agent ${this.name} llm stream call`, {
         runId
       });

package/dist/{chunk-HPIB5X7E.js → chunk-KM7PRKJ2.js}

@@ -1,6 +1,6 @@
-import { DefaultStorage } from './chunk-JIV6PDIN.js';
-import { InstrumentClass, OTLPTraceExporter, Telemetry } from './chunk-4ZRHVG25.js';
-import { createLogger, LogLevel, noopLogger } from './chunk-KP5SHTKA.js';
+import { LibSQLStore } from './chunk-YLCBP7MP.js';
+import { InstrumentClass, OTLPTraceExporter, Telemetry } from './chunk-W5HVJX45.js';
+import { createLogger, LogLevel, noopLogger } from './chunk-PHMSPCTC.js';
 import { __decoratorStart, __decorateElement, __runInitializers } from './chunk-C6A6W6XS.js';
 
 // src/mastra/index.ts
@@ -37,13 +37,13 @@ var Mastra = class {
     this.logger = logger;
     let storage = config?.storage;
     if (!storage) {
-      storage = new DefaultStorage({
+      storage = new LibSQLStore({
         config: {
           url: process.env.MASTRA_DEFAULT_STORAGE_URL || `:memory:`
         }
       });
     }
-    if (storage instanceof DefaultStorage && config?.telemetry?.export?.type !== "custom") {
+    if (storage instanceof LibSQLStore && config?.telemetry?.export?.type !== "custom") {
       const newTelemetry = {
         ...(config?.telemetry || {}),
         export: {

package/dist/{chunk-XD7K4XPP.js → chunk-M626YCHO.js}

@@ -1,8 +1,108 @@
-import { DefaultStorage } from './chunk-JIV6PDIN.js';
-import { DefaultVectorDB } from './chunk-LKOVXFLE.js';
-import { defaultEmbedder } from './chunk-7NPRQT5A.js';
+import { LibSQLVector } from './chunk-33GSTUNK.js';
+import { LibSQLStore } from './chunk-YLCBP7MP.js';
 import { deepMerge } from './chunk-WIBGG4X6.js';
-import { MastraBase } from './chunk-6RDA4JYW.js';
+import { MastraBase } from './chunk-OZ4XVJ6F.js';
+import path from 'path';
+import { experimental_customProvider } from 'ai';
+import node_modulesPath from 'node_modules-path';
+
+var cachedPath = false;
+function getModelCachePath() {
+  if (cachedPath) return cachedPath;
+  const firstNodeModules = node_modulesPath().split("node_modules")[0];
+  cachedPath = path.join(firstNodeModules, "node_modules", ".fastembed-model-cache");
+  return cachedPath;
+}
+function unbundleableImport(name) {
+  const nonStaticallyAnalyzableName = `${name}?d=${Date.now()}`;
+  return import(nonStaticallyAnalyzableName.split(`?`)[0]);
+}
+async function generateEmbeddings(values, modelType) {
+  try {
+    let mod;
+    const importErrors = [];
+    {
+      try {
+        mod = await unbundleableImport("fastembed");
+      } catch (e) {
+        if (e instanceof Error) {
+          importErrors.push(e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    if (!mod) {
+      throw new Error(`${importErrors.map((e) => e.message).join(`
+`)}
+
+This runtime does not support fastembed-js, which is the default embedder in Mastra. 
+Scroll up to read import errors. These errors mean you can't use the default Mastra embedder on this hosting platform.
+You can either use Mastra Cloud which supports the default embedder, or you can configure an alternate provider.
+
+For example if you're using Memory:
+
+import { openai } from "@ai-sdk/openai";
+
+const memory = new Memory({
+  embedder: openai.embedding("text-embedding-3-small"), // <- doesn't have to be openai
+})
+
+Visit https://sdk.vercel.ai/docs/foundations/overview#embedding-models to find an alternate embedding provider
+
+If you do not want to use the Memory semantic recall feature, you can disable it entirely and this error will go away.
+
+const memory = new Memory({
+  options: {
+    semanticRecall: false // <- an embedder will not be required with this set to false
+  }
+})
+`);
+    }
+    const { FlagEmbedding, EmbeddingModel } = mod;
+    const model = await FlagEmbedding.init({
+      model: EmbeddingModel[modelType],
+      cacheDir: getModelCachePath()
+    });
+    const embeddings = await model.embed(values);
+    const allResults = [];
+    for await (const result of embeddings) {
+      allResults.push(...result.map((embedding) => Array.from(embedding)));
+    }
+    if (allResults.length === 0) throw new Error("No embeddings generated");
+    return {
+      embeddings: allResults
+    };
+  } catch (error) {
+    console.error("Error generating embeddings:", error);
+    throw error;
+  }
+}
+var fastEmbedProvider = experimental_customProvider({
+  textEmbeddingModels: {
+    "bge-small-en-v1.5": {
+      specificationVersion: "v1",
+      provider: "fastembed",
+      modelId: "bge-small-en-v1.5",
+      maxEmbeddingsPerCall: 256,
+      supportsParallelCalls: true,
+      async doEmbed({ values }) {
+        return generateEmbeddings(values, "BGESmallENV15");
+      }
+    },
+    "bge-base-en-v1.5": {
+      specificationVersion: "v1",
+      provider: "fastembed",
+      modelId: "bge-base-en-v1.5",
+      maxEmbeddingsPerCall: 256,
+      supportsParallelCalls: true,
+      async doEmbed({ values }) {
+        return generateEmbeddings(values, "BGEBaseENV15");
+      }
+    }
+  }
+});
+var defaultEmbedder = fastEmbedProvider.textEmbeddingModel;
 
 // src/memory/memory.ts
 var MastraMemory = class extends MastraBase {
@@ -16,7 +116,7 @@ var MastraMemory = class extends MastraBase {
   };
   constructor(config) {
     super({ component: "MEMORY", name: config.name });
-    this.storage = config.storage || new DefaultStorage({
+    this.storage = config.storage || new LibSQLStore({
       config: {
         url: "file:memory.db"
       }
@@ -24,7 +124,7 @@ var MastraMemory = class extends MastraBase {
     if (config.vector) {
       this.vector = config.vector;
     } else {
-      this.vector = new DefaultVectorDB({
+      this.vector = new LibSQLVector({
         connectionUrl: "file:memory-vector.db"
         // file name needs to be different than default storage or it wont work properly
       });

package/dist/{chunk-6RDA4JYW.js → chunk-OZ4XVJ6F.js}

@@ -1,4 +1,4 @@
-import { RegisteredLogger, createLogger } from './chunk-KP5SHTKA.js';
+import { RegisteredLogger, createLogger } from './chunk-PHMSPCTC.js';
 
 // src/base.ts
 var MastraBase = class {

package/dist/{chunk-KP5SHTKA.js → chunk-PHMSPCTC.js}

@@ -1,6 +1,6 @@
+import { Transform } from 'stream';
 import pino from 'pino';
 import pretty from 'pino-pretty';
-import { Transform } from 'stream';
 
 // src/logger/index.ts
 var RegisteredLogger = {
@@ -27,7 +27,7 @@ var LoggerTransport = class extends Transform {
   constructor(opts = {}) {
     super({ ...opts, objectMode: true });
   }
-  async getLogsByRunId({ runId }) {
+  async getLogsByRunId(_args) {
     return [];
   }
   async getLogs() {

package/dist/{chunk-N7KZVQDK.js → chunk-PL6URKH2.js}

@@ -1,4 +1,4 @@
-import { Agent } from './chunk-ORM3OCHX.js';
+import { Agent } from './chunk-7TG2Y45H.js';
 import { CohereClient } from 'cohere-ai';
 
 var CohereRelevanceScorer = class {

package/dist/{chunk-NDQR6IPC.js → chunk-QAAJAHDB.js}

@@ -1,5 +1,5 @@
-import { InstrumentClass } from './chunk-4ZRHVG25.js';
-import { MastraBase } from './chunk-6RDA4JYW.js';
+import { InstrumentClass } from './chunk-W5HVJX45.js';
+import { MastraBase } from './chunk-OZ4XVJ6F.js';
 import { __decoratorStart, __decorateElement, __runInitializers } from './chunk-C6A6W6XS.js';
 
 // src/tts/index.ts

package/dist/{chunk-YUOADWSP.js → chunk-SVEAENO7.js}

@@ -1,6 +1,6 @@
-import { MastraBase } from './chunk-6RDA4JYW.js';
-import { parse } from 'dotenv';
+import { MastraBase } from './chunk-OZ4XVJ6F.js';
 import { readFile } from 'fs/promises';
+import { parse } from 'dotenv';
 
 var MastraBundler = class extends MastraBase {
   constructor({ name, component = "BUNDLER" }) {

package/dist/{chunk-4ZRHVG25.js → chunk-W5HVJX45.js}

@@ -37,7 +37,7 @@ function withSpan(options) {
       args.forEach((arg, index) => {
         try {
           span.setAttribute(`${spanName}.argument.${index}`, JSON.stringify(arg));
-        } catch (e) {
+        } catch {
           span.setAttribute(`${spanName}.argument.${index}`, "[Not Serializable]");
         }
       });
@@ -57,7 +57,7 @@ function withSpan(options) {
           return result.then((resolvedValue) => {
             try {
               span.setAttribute(`${spanName}.result`, JSON.stringify(resolvedValue));
-            } catch (e) {
+            } catch {
               span.setAttribute(`${spanName}.result`, "[Not Serializable]");
             }
             return resolvedValue;
@@ -65,7 +65,7 @@ function withSpan(options) {
         }
         try {
           span.setAttribute(`${spanName}.result`, JSON.stringify(result));
-        } catch (e) {
+        } catch {
           span.setAttribute(`${spanName}.result`, "[Not Serializable]");
         }
         return result;
@@ -309,7 +309,7 @@ var Telemetry = class _Telemetry {
         let recordResult2 = function(res) {
           try {
             span.setAttribute(`${context3.spanName}.result`, JSON.stringify(res));
-          } catch (e) {
+          } catch {
             span.setAttribute(`${context3.spanName}.result`, "[Not Serializable]");
           }
           span.end();
@@ -338,7 +338,7 @@ var Telemetry = class _Telemetry {
         args.forEach((arg, index) => {
           try {
             span.setAttribute(`${context3.spanName}.argument.${index}`, JSON.stringify(arg));
-          } catch (e) {
+          } catch {
             span.setAttribute(`${context3.spanName}.argument.${index}`, "[Not Serializable]");
           }
         });

package/dist/{chunk-TCMOYQ74.js → chunk-XVS6QFTX.js}

@@ -1,4 +1,4 @@
-import { MastraBase } from './chunk-6RDA4JYW.js';
+import { MastraBase } from './chunk-OZ4XVJ6F.js';
 import { context, trace } from '@opentelemetry/api';
 import { get } from 'radash';
 import sift from 'sift';
@@ -747,7 +747,22 @@ var Workflow = class extends MastraBase {
           runId: this.#runId
         });
         if (typeof stepConfig?.when === "function") {
-          const conditionMet = await stepConfig.when({ context });
+          const conditionMet = await stepConfig.when({
+            context: {
+              ...context,
+              getStepResult: (stepId) => {
+                if (stepId === "trigger") {
+                  return context.triggerData;
+                }
+                const result = context.steps[stepId];
+                if (result && result.status === "success") {
+                  return result.output;
+                }
+                return void 0;
+              }
+            },
+            ...this.#getInjectables()
+          });
           if (conditionMet) {
             this.logger.debug(`Condition met for step ${stepNode.step.id}`, {
               stepId: stepNode.step.id,
@@ -868,7 +883,7 @@ var Workflow = class extends MastraBase {
     });
     const resolvedData = {
       ...context,
-      getStepPayload: (stepId2) => {
+      getStepResult: (stepId2) => {
         if (stepId2 === "trigger") {
           return context.triggerData;
         }
@@ -984,7 +999,8 @@ var Workflow = class extends MastraBase {
     const handler = async ({ context, ...rest }) => {
       const targetStep = this.#steps[stepId];
       if (!targetStep) throw new Error(`Step not found`);
-      const { payload = {}, execute } = targetStep;
+      const { payload = {}, execute = async () => {
+      } } = targetStep;
       const mergedData = {
         ...payload,
         ...context