@mastra/core 0.0.0-commonjs-20250227130920

package/dist/chunk-BB4KXGBU.js

@@ -0,0 +1,83 @@
+// 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);
+  });
+}
+
+export { AvailableHooks, executeHook, registerHook };

package/dist/chunk-C6A6W6XS.js

@@ -0,0 +1,77 @@
+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);
+
+export { __decorateElement, __decoratorStart, __runInitializers };

package/dist/chunk-HQ55LN2U.js

@@ -0,0 +1,318 @@
+import { LibSQLVector } from './chunk-33GSTUNK.js';
+import { LibSQLStore } from './chunk-KNVTCZW7.js';
+import { deepMerge } from './chunk-WIBGG4X6.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 {
+  MAX_CONTEXT_TOKENS;
+  storage;
+  vector;
+  embedder;
+  threadConfig = {
+    lastMessages: 40,
+    semanticRecall: true
+  };
+  constructor(config) {
+    super({ component: "MEMORY", name: config.name });
+    this.storage = config.storage || new LibSQLStore({
+      config: {
+        url: "file:memory.db"
+      }
+    });
+    if (config.vector) {
+      this.vector = config.vector;
+    } else {
+      this.vector = new LibSQLVector({
+        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 };