@mastra/core 0.2.0-alpha.99 → 0.2.1-alpha.0

package/dist/chunk-V5UMPUKC.js

@@ -0,0 +1,218 @@
+import { DefaultStorage } from './chunk-5HXXWLRX.js';
+import { DefaultVectorDB } from './chunk-AN562ICT.js';
+import { defaultEmbedder } from './chunk-ZJOXJFJI.js';
+import { deepMerge } from './chunk-55GTEVHJ.js';
+import { MastraBase } from './chunk-AWEACB2T.js';
+
+// src/memory/memory.ts
+var MastraMemory = class extends MastraBase {
+  MAX_CONTEXT_TOKENS;
+  storage;
+  vector;
+  embedder;
+  threadConfig = {
+    lastMessages: 40,
+    semanticRecall: true
+  };
+  constructor(config) {
+    super({ component: "MEMORY", name: config.name });
+    this.storage = config.storage || new DefaultStorage({
+      config: {
+        url: "file:memory.db"
+      }
+    });
+    if (config.vector) {
+      this.vector = config.vector;
+    } else {
+      this.vector = new DefaultVectorDB({
+        connectionUrl: "file:memory-vector.db"
+        // file name needs to be different than default storage or it wont work properly
+      });
+    }
+    if (config.embedder) {
+      this.embedder = config.embedder;
+    } else {
+      this.embedder = defaultEmbedder("bge-small-en-v1.5");
+    }
+    if (config.options) {
+      this.threadConfig = this.getMergedThreadConfig(config.options);
+    }
+  }
+  setStorage(storage) {
+    this.storage = storage;
+  }
+  setVector(vector) {
+    this.vector = vector;
+  }
+  setEmbedder(embedder) {
+    this.embedder = embedder;
+  }
+  /**
+   * Get a system message to inject into the conversation.
+   * This will be called before each conversation turn.
+   * Implementations can override this to inject custom system messages.
+   */
+  async getSystemMessage(_input) {
+    return null;
+  }
+  async createEmbeddingIndex() {
+    const defaultDimensions = 1536;
+    const dimensionsByModelId = {
+      "bge-small-en-v1.5": 384,
+      "bge-base-en-v1.5": 768
+    };
+    const dimensions = dimensionsByModelId[this.embedder.modelId] || defaultDimensions;
+    const isDefault = dimensions === defaultDimensions;
+    const indexName = isDefault ? "memory_messages" : `memory_messages_${dimensions}`;
+    await this.vector.createIndex(indexName, dimensions);
+    return { indexName };
+  }
+  getMergedThreadConfig(config) {
+    return deepMerge(this.threadConfig, config || {});
+  }
+  estimateTokens(text) {
+    return Math.ceil(text.split(" ").length * 1.3);
+  }
+  parseMessages(messages) {
+    return messages.map((msg) => ({
+      ...msg,
+      content: typeof msg.content === "string" && (msg.content.startsWith("[") || msg.content.startsWith("{")) ? JSON.parse(msg.content) : msg.content
+    }));
+  }
+  convertToUIMessages(messages) {
+    function addToolMessageToChat({
+      toolMessage,
+      messages: messages2,
+      toolResultContents
+    }) {
+      const chatMessages2 = messages2.map((message) => {
+        if (message.toolInvocations) {
+          return {
+            ...message,
+            toolInvocations: message.toolInvocations.map((toolInvocation) => {
+              const toolResult = toolMessage.content.find((tool) => tool.toolCallId === toolInvocation.toolCallId);
+              if (toolResult) {
+                return {
+                  ...toolInvocation,
+                  state: "result",
+                  result: toolResult.result
+                };
+              }
+              return toolInvocation;
+            })
+          };
+        }
+        return message;
+      });
+      const resultContents = [...toolResultContents, ...toolMessage.content];
+      return { chatMessages: chatMessages2, toolResultContents: resultContents };
+    }
+    const { chatMessages } = messages.reduce(
+      (obj, message) => {
+        if (message.role === "tool") {
+          return addToolMessageToChat({
+            toolMessage: message,
+            messages: obj.chatMessages,
+            toolResultContents: obj.toolResultContents
+          });
+        }
+        let textContent = "";
+        let toolInvocations = [];
+        if (typeof message.content === "string") {
+          textContent = message.content;
+        } else if (Array.isArray(message.content)) {
+          for (const content of message.content) {
+            if (content.type === "text") {
+              textContent += content.text;
+            } else if (content.type === "tool-call") {
+              const toolResult = obj.toolResultContents.find((tool) => tool.toolCallId === content.toolCallId);
+              toolInvocations.push({
+                state: toolResult ? "result" : "call",
+                toolCallId: content.toolCallId,
+                toolName: content.toolName,
+                args: content.args,
+                result: toolResult?.result
+              });
+            }
+          }
+        }
+        obj.chatMessages.push({
+          id: message.id,
+          role: message.role,
+          content: textContent,
+          toolInvocations
+        });
+        return obj;
+      },
+      { chatMessages: [], toolResultContents: [] }
+    );
+    return chatMessages;
+  }
+  /**
+   * Helper method to create a new thread
+   * @param title - Optional title for the thread
+   * @param metadata - Optional metadata for the thread
+   * @returns Promise resolving to the created thread
+   */
+  async createThread({
+    threadId,
+    resourceId,
+    title,
+    metadata,
+    memoryConfig
+  }) {
+    const thread = {
+      id: threadId || this.generateId(),
+      title: title || "New Thread",
+      resourceId,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      metadata
+    };
+    return this.saveThread({ thread, memoryConfig });
+  }
+  /**
+   * Helper method to add a single message to a thread
+   * @param threadId - The thread to add the message to
+   * @param content - The message content
+   * @param role - The role of the message sender
+   * @param type - The type of the message
+   * @param toolNames - Optional array of tool names that were called
+   * @param toolCallArgs - Optional array of tool call arguments
+   * @param toolCallIds - Optional array of tool call ids
+   * @returns Promise resolving to the saved message
+   */
+  async addMessage({
+    threadId,
+    config,
+    content,
+    role,
+    type,
+    toolNames,
+    toolCallArgs,
+    toolCallIds
+  }) {
+    const message = {
+      id: this.generateId(),
+      content,
+      role,
+      createdAt: /* @__PURE__ */ new Date(),
+      threadId,
+      type,
+      toolNames,
+      toolCallArgs,
+      toolCallIds
+    };
+    const savedMessages = await this.saveMessages({ messages: [message], memoryConfig: config });
+    return savedMessages[0];
+  }
+  /**
+   * Generates a unique identifier
+   * @returns A unique string ID
+   */
+  generateId() {
+    return crypto.randomUUID();
+  }
+};
+
+export { MastraMemory };

package/dist/{chunk-DHCULRJM.js → chunk-VE4JJJSW.js}

@@ -1,31 +1,25 @@
-import { DefaultStorage } from './chunk-Z7JFMQZZ.js';
-import { InstrumentClass, Telemetry } from './chunk-4ZUSEHLH.js';
-import { LogLevel, createLogger, noopLogger } from './chunk-ICMEXHKD.js';
-import { __name, __publicField } from './chunk-AJJZUHB4.js';
+import { DefaultStorage } from './chunk-5HXXWLRX.js';
+import { InstrumentClass, OTLPTraceExporter, Telemetry } from './chunk-4ZRHVG25.js';
+import { createLogger, LogLevel, noopLogger } from './chunk-O2VP5JBC.js';
+import { __decoratorStart, __decorateElement, __runInitializers } from './chunk-C6A6W6XS.js';
 
 // src/mastra/index.ts
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
-function _ts_metadata(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata, "_ts_metadata");
-var _Mastra = class _Mastra {
+var _Mastra_decorators, _init;
+_Mastra_decorators = [InstrumentClass({
+  prefix: "mastra",
+  excludeMethods: ["getLogger", "getTelemetry"]
+})];
+var Mastra = class {
+  vectors;
+  agents;
+  logger;
+  workflows;
+  telemetry;
+  tts;
+  deployer;
+  storage;
+  memory;
   constructor(config) {
-    __publicField(this, "vectors");
-    __publicField(this, "agents");
-    __publicField(this, "logger");
-    __publicField(this, "workflows");
-    __publicField(this, "telemetry");
-    __publicField(this, "tts");
-    __publicField(this, "deployer");
-    __publicField(this, "storage");
-    __publicField(this, "memory");
     let logger;
     if (config?.logger === false) {
       logger = noopLogger;
@@ -41,35 +35,41 @@ var _Mastra = class _Mastra {
       }
     }
     this.logger = logger;
-    if (config?.telemetry) {
-      this.telemetry = Telemetry.init(config.telemetry);
+    let storage = config?.storage;
+    if (!storage) {
+      storage = new DefaultStorage({
+        config: {
+          url: process.env.MASTRA_DEFAULT_STORAGE_URL || `:memory:`
+        }
+      });
+    }
+    if (storage instanceof DefaultStorage && config?.telemetry?.export?.type !== "custom") {
+      const newTelemetry = {
+        ...(config?.telemetry || {}),
+        export: {
+          type: "custom",
+          exporter: new OTLPTraceExporter({
+            logger: this.getLogger(),
+            storage
+          })
+        }
+      };
+      this.telemetry = Telemetry.init(newTelemetry);
+    } else if (config?.telemetry) {
+      this.telemetry = Telemetry.init(config?.telemetry);
     }
     if (config?.deployer) {
       this.deployer = config.deployer;
       if (this.telemetry) {
         this.deployer = this.telemetry.traceClass(config.deployer, {
-          excludeMethods: [
-            "__setTelemetry",
-            "__getTelemetry"
-          ]
+          excludeMethods: ["__setTelemetry", "__getTelemetry"]
         });
         this.deployer.__setTelemetry(this.telemetry);
       }
     }
-    let storage = config?.storage;
-    if (!storage) {
-      storage = new DefaultStorage({
-        config: {
-          url: ":memory:"
-        }
-      });
-    }
     if (this.telemetry) {
       this.storage = this.telemetry.traceClass(storage, {
-        excludeMethods: [
-          "__setTelemetry",
-          "__getTelemetry"
-        ]
+        excludeMethods: ["__setTelemetry", "__getTelemetry"]
       });
       this.storage.__setTelemetry(this.telemetry);
     } else {
@@ -80,10 +80,7 @@ var _Mastra = class _Mastra {
       Object.entries(config.vectors).forEach(([key, vector]) => {
         if (this.telemetry) {
           vectors[key] = this.telemetry.traceClass(vector, {
-            excludeMethods: [
-              "__setTelemetry",
-              "__getTelemetry"
-            ]
+            excludeMethods: ["__setTelemetry", "__getTelemetry"]
           });
           vectors[key].__setTelemetry(this.telemetry);
         } else {
@@ -99,10 +96,7 @@ var _Mastra = class _Mastra {
       this.memory = config.memory;
       if (this.telemetry) {
         this.memory = this.telemetry.traceClass(config.memory, {
-          excludeMethods: [
-            "__setTelemetry",
-            "__getTelemetry"
-          ]
+          excludeMethods: ["__setTelemetry", "__getTelemetry"]
         });
         this.memory.__setTelemetry(this.telemetry);
       }
@@ -113,10 +107,7 @@ var _Mastra = class _Mastra {
         if (this.tts?.[key]) {
           if (this.telemetry) {
             this.tts[key] = this.telemetry.traceClass(ttsCl, {
-              excludeMethods: [
-                "__setTelemetry",
-                "__getTelemetry"
-              ]
+              excludeMethods: ["__setTelemetry", "__getTelemetry"]
             });
             this.tts[key].__setTelemetry(this.telemetry);
           }
@@ -184,7 +175,9 @@ var _Mastra = class _Mastra {
   getDeployer() {
     return this.deployer;
   }
-  getWorkflow(id, { serialized } = {}) {
+  getWorkflow(id, {
+    serialized
+  } = {}) {
     const workflow = this.workflows?.[id];
     if (!workflow) {
       throw new Error(`Workflow with ID ${String(id)} not found`);
@@ -209,18 +202,20 @@ var _Mastra = class _Mastra {
     }
     return this.workflows;
   }
-  setStorage({ storage }) {
+  setStorage(storage) {
     this.storage = storage;
   }
-  setLogger({ logger }) {
+  setLogger({
+    logger
+  }) {
     this.logger = logger;
     if (this.agents) {
-      Object.keys(this.agents).forEach((key) => {
+      Object.keys(this.agents).forEach(key => {
         this.agents?.[key]?.__setLogger(this.logger);
       });
     }
     if (this.workflows) {
-      Object.keys(this.workflows).forEach((key) => {
+      Object.keys(this.workflows).forEach(key => {
         this.workflows?.[key]?.__setLogger(this.logger);
       });
     }
@@ -231,7 +226,7 @@ var _Mastra = class _Mastra {
       this.deployer.__setLogger(this.logger);
     }
     if (this.tts) {
-      Object.keys(this.tts).forEach((key) => {
+      Object.keys(this.tts).forEach(key => {
         this.tts?.[key]?.__setLogger(this.logger);
       });
     }
@@ -239,18 +234,80 @@ var _Mastra = class _Mastra {
       this.storage.__setLogger(this.logger);
     }
     if (this.vectors) {
-      Object.keys(this.vectors).forEach((key) => {
+      Object.keys(this.vectors).forEach(key => {
         this.vectors?.[key]?.__setLogger(this.logger);
       });
     }
   }
+  setTelemetry(telemetry) {
+    this.telemetry = Telemetry.init(telemetry);
+    if (this.agents) {
+      Object.keys(this.agents).forEach(key => {
+        if (this.telemetry) {
+          this.agents?.[key]?.__setTelemetry(this.telemetry);
+        }
+      });
+    }
+    if (this.workflows) {
+      Object.keys(this.workflows).forEach(key => {
+        if (this.telemetry) {
+          this.workflows?.[key]?.__setTelemetry(this.telemetry);
+        }
+      });
+    }
+    if (this.memory) {
+      this.memory = this.telemetry.traceClass(this.memory, {
+        excludeMethods: ["__setTelemetry", "__getTelemetry"]
+      });
+      this.memory.__setTelemetry(this.telemetry);
+    }
+    if (this.deployer) {
+      this.deployer = this.telemetry.traceClass(this.deployer, {
+        excludeMethods: ["__setTelemetry", "__getTelemetry"]
+      });
+      this.deployer.__setTelemetry(this.telemetry);
+    }
+    if (this.tts) {
+      let tts = {};
+      Object.entries(this.tts).forEach(([key, ttsCl]) => {
+        if (this.telemetry) {
+          tts[key] = this.telemetry.traceClass(ttsCl, {
+            excludeMethods: ["__setTelemetry", "__getTelemetry"]
+          });
+          tts[key].__setTelemetry(this.telemetry);
+        }
+      });
+      this.tts = tts;
+    }
+    if (this.storage) {
+      this.storage = this.telemetry.traceClass(this.storage, {
+        excludeMethods: ["__setTelemetry", "__getTelemetry"]
+      });
+      this.storage.__setTelemetry(this.telemetry);
+    }
+    if (this.vectors) {
+      let vectors = {};
+      Object.entries(this.vectors).forEach(([key, vector]) => {
+        if (this.telemetry) {
+          vectors[key] = this.telemetry.traceClass(vector, {
+            excludeMethods: ["__setTelemetry", "__getTelemetry"]
+          });
+          vectors[key].__setTelemetry(this.telemetry);
+        }
+      });
+      this.vectors = vectors;
+    }
+  }
   getLogger() {
     return this.logger;
   }
   getTelemetry() {
     return this.telemetry;
   }
-  async getLogsByRunId({ runId, transportId }) {
+  async getLogsByRunId({
+    runId,
+    transportId
+  }) {
     if (!transportId) {
       throw new Error("Transport ID is required");
     }
@@ -266,20 +323,11 @@ var _Mastra = class _Mastra {
     return await this.logger.getLogs(transportId);
   }
 };
-__name(_Mastra, "Mastra");
-var Mastra = _Mastra;
-Mastra = _ts_decorate([
-  InstrumentClass({
-    prefix: "mastra",
-    excludeMethods: [
-      "getLogger",
-      "getTelemetry"
-    ]
-  }),
-  _ts_metadata("design:type", Function),
-  _ts_metadata("design:paramtypes", [
-    Object
-  ])
-], Mastra);
+Mastra = /*@__PURE__*/(_ => {
+  _init = __decoratorStart(null);
+  Mastra = __decorateElement(_init, 0, "Mastra", _Mastra_decorators, Mastra);
+  __runInitializers(_init, 1, Mastra);
+  return Mastra;
+})();
 
 export { Mastra };

package/dist/chunk-ZINPRHAN.js

@@ -0,0 +1,22 @@
+// src/tools/tool.ts
+var Tool = class {
+  id;
+  description;
+  inputSchema;
+  outputSchema;
+  execute;
+  mastra;
+  constructor(opts) {
+    this.id = opts.id;
+    this.description = opts.description;
+    this.inputSchema = opts.inputSchema;
+    this.outputSchema = opts.outputSchema;
+    this.execute = opts.execute;
+    this.mastra = opts.mastra;
+  }
+};
+function createTool(opts) {
+  return new Tool(opts);
+}
+
+export { Tool, createTool };

package/dist/{chunk-C55JWGDU.js → chunk-ZJOXJFJI.js}

@@ -1,5 +1,4 @@
-import { MastraBase } from './chunk-G4MCO7XF.js';
-import { __name } from './chunk-AJJZUHB4.js';
+import { MastraBase } from './chunk-AWEACB2T.js';
 import { experimental_customProvider } from 'ai';
 import node_modulesPath from 'node_modules-path';
 import path from 'path';
@@ -11,11 +10,45 @@ function getModelCachePath() {
   cachedPath = path.join(firstNodeModules, "node_modules", ".fastembed-model-cache");
   return cachedPath;
 }
-__name(getModelCachePath, "getModelCachePath");
-var fastEmbedImportPath = "fastembed?" + Date.now();
+function unbundleableImport(name) {
+  const nonStaticallyAnalyzableName = `${name}?d=${Date.now()}`;
+  return import(nonStaticallyAnalyzableName.split(`?`)[0]);
+}
 async function generateEmbeddings(values, modelType) {
   try {
-    const { EmbeddingModel, FlagEmbedding } = await import(fastEmbedImportPath);
+    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
+`);
+    }
+    const { FlagEmbedding, EmbeddingModel } = mod;
     const model = await FlagEmbedding.init({
       model: EmbeddingModel[modelType],
       cacheDir: getModelCachePath()
@@ -34,7 +67,6 @@ async function generateEmbeddings(values, modelType) {
     throw error;
   }
 }
-__name(generateEmbeddings, "generateEmbeddings");
 var fastEmbedProvider = experimental_customProvider({
   textEmbeddingModels: {
     "bge-small-en-v1.5": {
@@ -59,18 +91,13 @@ var fastEmbedProvider = experimental_customProvider({
     }
   }
 });
-var localEmbedder = fastEmbedProvider.textEmbeddingModel;
+var defaultEmbedder = fastEmbedProvider.textEmbeddingModel;
 
 // src/vector/index.ts
-var _MastraVector = class _MastraVector extends MastraBase {
+var MastraVector = class extends MastraBase {
   constructor() {
-    super({
-      name: "MastraVector",
-      component: "VECTOR"
-    });
+    super({ name: "MastraVector", component: "VECTOR" });
   }
 };
-__name(_MastraVector, "MastraVector");
-var MastraVector = _MastraVector;
 
-export { MastraVector, localEmbedder };
+export { MastraVector, defaultEmbedder };

package/dist/deployer/index.d.ts

@@ -1,11 +1,9 @@
-import { IBundler, MastraBundler } from '../bundler/index.js';
-import '../base.js';
+import { MastraBundler, IBundler } from '../bundler/index.js';
+import '../base-BbtPAA6f.js';
 import '@opentelemetry/api';
-import '../index-CBZ2mk2H.js';
+import '../index-B2JCcAQt.js';
 import 'pino';
 import 'stream';
-import '../telemetry-oCUM52DG.js';
-import '@opentelemetry/sdk-node';
 import '@opentelemetry/sdk-trace-base';
 
 interface IDeployer extends IBundler {

package/dist/deployer/index.js

@@ -1,5 +1 @@
-export { MastraDeployer } from '../chunk-JJ57BXQR.js';
-import '../chunk-MCB4M5W4.js';
-import '../chunk-G4MCO7XF.js';
-import '../chunk-ICMEXHKD.js';
-import '../chunk-AJJZUHB4.js';
+export { MastraDeployer } from '../chunk-K36NSQWH.js';

package/dist/eval/index.d.ts

@@ -1,17 +1,15 @@
-import { a as Metric, M as MetricResult } from '../metric-BWeQNZt6.js';
-import { A as Agent } from '../index-Cwb-5AzX.js';
+import { a as Metric, T as TestInfo, M as MetricResult } from '../types-m9RryK9a.js';
+import { A as Agent } from '../base-C7R9FwZ6.js';
 import 'ai';
-import 'json-schema';
-import 'zod';
-import '../base.js';
+import '../base-BbtPAA6f.js';
 import '@opentelemetry/api';
-import '../index-CBZ2mk2H.js';
+import '../index-B2JCcAQt.js';
 import 'pino';
 import 'stream';
-import '../telemetry-oCUM52DG.js';
-import '@opentelemetry/sdk-node';
 import '@opentelemetry/sdk-trace-base';
 import 'sift';
+import 'zod';
+import 'json-schema';
 import '../vector/index.js';
 import '../tts/index.js';
 
@@ -22,11 +20,8 @@ declare function evaluate<T extends Agent>({ agentName, input, metric, output, r
     output: string;
     globalRunId: string;
     runId?: string;
-    testInfo?: {
-        testName?: string;
-        testPath?: string;
-    } | null;
+    testInfo?: TestInfo;
     instructions: string;
 }): Promise<MetricResult>;
 
-export { Metric, MetricResult, evaluate };
+export { Metric, MetricResult, TestInfo, evaluate };

package/dist/eval/index.js

@@ -1,3 +1 @@
-export { Metric, evaluate } from '../chunk-JP37ODNX.js';
-import '../chunk-HBTQNIAX.js';
-import '../chunk-AJJZUHB4.js';
+export { Metric, evaluate } from '../chunk-NUDAZEOG.js';