@mastra/core 0.10.13 → 0.10.15-alpha.0

package/dist/chunk-ATXBSEFT.js

@@ -0,0 +1,22 @@
+import { MastraBase } from './chunk-5IEKR756.js';
+import { readFile } from 'fs/promises';
+import { parse } from 'dotenv';
+
+var MastraBundler = class extends 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 readFile(file, "utf-8");
+      const config = parse(content);
+      Object.entries(config).forEach(([key, value]) => {
+        envVars.set(key, value);
+      });
+    }
+    return envVars;
+  }
+};
+
+export { MastraBundler };

package/dist/chunk-B6TOBUS6.cjs

@@ -0,0 +1,80 @@
+'use strict';
+
+// src/error/index.ts
+var ErrorDomain = /* @__PURE__ */ ((ErrorDomain2) => {
+  ErrorDomain2["TOOL"] = "TOOL";
+  ErrorDomain2["AGENT"] = "AGENT";
+  ErrorDomain2["MCP"] = "MCP";
+  ErrorDomain2["AGENT_NETWORK"] = "AGENT_NETWORK";
+  ErrorDomain2["MASTRA_SERVER"] = "MASTRA_SERVER";
+  ErrorDomain2["MASTRA_TELEMETRY"] = "MASTRA_TELEMETRY";
+  ErrorDomain2["MASTRA_WORKFLOW"] = "MASTRA_WORKFLOW";
+  ErrorDomain2["MASTRA_VOICE"] = "MASTRA_VOICE";
+  ErrorDomain2["MASTRA_VECTOR"] = "MASTRA_VECTOR";
+  ErrorDomain2["LLM"] = "LLM";
+  ErrorDomain2["EVAL"] = "EVAL";
+  ErrorDomain2["A2A"] = "A2A";
+  ErrorDomain2["MASTRA_INSTANCE"] = "MASTRA_INSTANCE";
+  ErrorDomain2["MASTRA"] = "MASTRA";
+  ErrorDomain2["DEPLOYER"] = "DEPLOYER";
+  ErrorDomain2["STORAGE"] = "STORAGE";
+  return ErrorDomain2;
+})(ErrorDomain || {});
+var ErrorCategory = /* @__PURE__ */ ((ErrorCategory2) => {
+  ErrorCategory2["UNKNOWN"] = "UNKNOWN";
+  ErrorCategory2["USER"] = "USER";
+  ErrorCategory2["SYSTEM"] = "SYSTEM";
+  ErrorCategory2["THIRD_PARTY"] = "THIRD_PARTY";
+  return ErrorCategory2;
+})(ErrorCategory || {});
+var MastraBaseError = class extends Error {
+  id;
+  domain;
+  category;
+  details = {};
+  message;
+  constructor(errorDefinition, originalError) {
+    let error;
+    if (originalError instanceof Error) {
+      error = originalError;
+    } else if (originalError) {
+      error = new Error(String(originalError));
+    }
+    const message = errorDefinition.text ?? error?.message ?? "Unknown error";
+    super(message, { cause: error });
+    this.id = errorDefinition.id;
+    this.domain = errorDefinition.domain;
+    this.category = errorDefinition.category;
+    this.details = errorDefinition.details ?? {};
+    this.message = message;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /**
+   * Returns a structured representation of the error, useful for logging or API responses.
+   */
+  toJSONDetails() {
+    return {
+      message: this.message,
+      domain: this.domain,
+      category: this.category,
+      details: this.details
+    };
+  }
+  toJSON() {
+    return {
+      message: this.message,
+      details: this.toJSONDetails(),
+      code: this.id
+    };
+  }
+  toString() {
+    return JSON.stringify(this.toJSON());
+  }
+};
+var MastraError = class extends MastraBaseError {
+};
+
+exports.ErrorCategory = ErrorCategory;
+exports.ErrorDomain = ErrorDomain;
+exports.MastraBaseError = MastraBaseError;
+exports.MastraError = MastraError;

package/dist/chunk-B7SQOKEC.cjs

@@ -0,0 +1,91 @@
+'use strict';
+
+var chunk4Z3OU5RY_cjs = require('./chunk-4Z3OU5RY.cjs');
+var zod = require('zod');
+
+// src/integration/integration.ts
+var Integration = class {
+  name = "Integration";
+  workflows;
+  constructor() {
+    this.workflows = {};
+  }
+  /**
+   * Workflows
+   */
+  registerWorkflow(name, fn) {
+    if (this.workflows[name]) {
+      throw new Error(`Sync function "${name}" already registered`);
+    }
+    this.workflows[name] = fn;
+  }
+  getWorkflows({ serialized }) {
+    if (serialized) {
+      return Object.entries(this.workflows).reduce((acc, [k, v]) => {
+        return {
+          ...acc,
+          [k]: {
+            name: v.name
+          }
+        };
+      }, {});
+    }
+    return this.workflows;
+  }
+  /**
+   * TOOLS
+   */
+  getStaticTools(_params) {
+    throw new Error("Method not implemented.");
+  }
+  async getTools(_params) {
+    throw new Error("Method not implemented.");
+  }
+  async getApiClient() {
+    throw new Error("Method not implemented");
+  }
+};
+var OpenAPIToolset = class {
+  authType = "API_KEY";
+  constructor() {
+  }
+  get toolSchemas() {
+    return {};
+  }
+  get toolDocumentations() {
+    return {};
+  }
+  get baseClient() {
+    return {};
+  }
+  async getApiClient() {
+    throw new Error("API not implemented");
+  }
+  _generateIntegrationTools() {
+    const { client: _client, ...clientMethods } = this.baseClient;
+    const schemas = this.toolSchemas;
+    const documentations = this.toolDocumentations;
+    const tools = Object.keys(clientMethods).reduce((acc, key) => {
+      const comment = documentations[key]?.comment;
+      const fallbackComment = `Execute ${key}`;
+      const tool = chunk4Z3OU5RY_cjs.createTool({
+        id: key,
+        inputSchema: schemas[key] || zod.z.object({}),
+        description: comment || fallbackComment,
+        // documentation: doc || fallbackComment,
+        execute: async ({ context }) => {
+          const client = await this.getApiClient();
+          const value = client[key];
+          return value({
+            ...context
+          });
+        }
+      });
+      return { ...acc, [key]: tool };
+    }, {});
+    return tools;
+  }
+};
+
+exports.Integration = Integration;
+exports.OpenAPIToolset = OpenAPIToolset;

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-BB6DPGIV.cjs

@@ -0,0 +1,6 @@
+'use strict';
+
+// src/workflows/constants.ts
+var EMITTER_SYMBOL = Symbol("emitter");
+
+exports.EMITTER_SYMBOL = EMITTER_SYMBOL;

package/dist/chunk-BVD7NVAR.cjs

@@ -0,0 +1,244 @@
+'use strict';
+
+var chunkLXFZUKP3_cjs = require('./chunk-LXFZUKP3.cjs');
+var chunkZTPPDHQK_cjs = require('./chunk-ZTPPDHQK.cjs');
+var chunkLBUQ6YNU_cjs = require('./chunk-LBUQ6YNU.cjs');
+var chunkP3Q73CAW_cjs = require('./chunk-P3Q73CAW.cjs');
+
+// src/memory/memory.ts
+var MemoryProcessor = class extends chunkP3Q73CAW_cjs.MastraBase {
+  /**
+   * Process a list of messages and return a filtered or transformed list.
+   * @param messages The messages to process
+   * @returns The processed messages
+   */
+  process(messages, _opts) {
+    return messages;
+  }
+};
+var memoryDefaultOptions = {
+  lastMessages: 10,
+  semanticRecall: false,
+  threads: {
+    generateTitle: false
+  },
+  workingMemory: {
+    enabled: false,
+    template: `
+# User Information
+- **First Name**: 
+- **Last Name**: 
+- **Location**: 
+- **Occupation**: 
+- **Interests**: 
+- **Goals**: 
+- **Events**: 
+- **Facts**: 
+- **Projects**: 
+`
+  }
+};
+var MastraMemory = class extends chunkP3Q73CAW_cjs.MastraBase {
+  MAX_CONTEXT_TOKENS;
+  _storage;
+  vector;
+  embedder;
+  processors = [];
+  threadConfig = { ...memoryDefaultOptions };
+  constructor(config) {
+    super({ component: "MEMORY", name: config.name });
+    if (config.options) this.threadConfig = this.getMergedThreadConfig(config.options);
+    if (config.processors) this.processors = config.processors;
+    if (config.storage) {
+      this._storage = chunkLXFZUKP3_cjs.augmentWithInit(config.storage);
+      this._hasOwnStorage = true;
+    }
+    if (this.threadConfig.semanticRecall) {
+      if (!config.vector) {
+        throw new Error(
+          `Semantic recall requires a vector store to be configured.
+
+https://mastra.ai/en/docs/memory/semantic-recall`
+        );
+      }
+      this.vector = config.vector;
+      if (!config.embedder) {
+        throw new Error(
+          `Semantic recall requires an embedder to be configured.
+
+https://mastra.ai/en/docs/memory/semantic-recall`
+        );
+      }
+      this.embedder = config.embedder;
+    }
+  }
+  _hasOwnStorage = false;
+  get hasOwnStorage() {
+    return this._hasOwnStorage;
+  }
+  get storage() {
+    if (!this._storage) {
+      throw new Error(
+        `Memory requires a storage provider to function. Add a storage configuration to Memory or to your Mastra instance.
+
+https://mastra.ai/en/docs/memory/overview`
+      );
+    }
+    return this._storage;
+  }
+  setStorage(storage) {
+    this._storage = chunkLXFZUKP3_cjs.augmentWithInit(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;
+  }
+  /**
+   * Get tools that should be available to the agent.
+   * This will be called when converting tools for the agent.
+   * Implementations can override this to provide additional tools.
+   */
+  getTools(_config) {
+    return {};
+  }
+  async createEmbeddingIndex(dimensions) {
+    const defaultDimensions = 1536;
+    const isDefault = dimensions === defaultDimensions;
+    const usedDimensions = dimensions ?? defaultDimensions;
+    const separator = this.vector?.indexSeparator ?? "_";
+    const indexName = isDefault ? `memory${separator}messages` : `memory${separator}messages${separator}${usedDimensions}`;
+    if (typeof this.vector === `undefined`) {
+      throw new Error(`Tried to create embedding index but no vector db is attached to this Memory instance.`);
+    }
+    await this.vector.createIndex({
+      indexName,
+      dimension: usedDimensions
+    });
+    return { indexName };
+  }
+  getMergedThreadConfig(config) {
+    if (config?.workingMemory && "use" in config.workingMemory) {
+      throw new Error("The workingMemory.use option has been removed. Working memory always uses tool-call mode.");
+    }
+    const mergedConfig = chunkLBUQ6YNU_cjs.deepMerge(this.threadConfig, config || {});
+    if (config?.workingMemory?.schema) {
+      if (mergedConfig.workingMemory) {
+        mergedConfig.workingMemory.schema = config.workingMemory.schema;
+      }
+    }
+    return mergedConfig;
+  }
+  /**
+   * Apply all configured message processors to a list of messages.
+   * @param messages The messages to process
+   * @returns The processed messages
+   */
+  applyProcessors(messages, opts) {
+    const processors = opts.processors || this.processors;
+    if (!processors || processors.length === 0) {
+      return messages;
+    }
+    let processedMessages = [...messages];
+    for (const processor of processors) {
+      processedMessages = processor.process(processedMessages, {
+        systemMessage: opts.systemMessage,
+        newMessages: opts.newMessages,
+        memorySystemMessage: opts.memorySystemMessage
+      });
+    }
+    return processedMessages;
+  }
+  processMessages({
+    messages,
+    processors,
+    ...opts
+  }) {
+    return this.applyProcessors(messages, { processors: processors || this.processors, ...opts });
+  }
+  estimateTokens(text) {
+    return Math.ceil(text.split(" ").length * 1.3);
+  }
+  /**
+   * 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 ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      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
+   * @deprecated use saveMessages instead
+   */
+  async addMessage({
+    threadId,
+    resourceId,
+    config,
+    content,
+    role,
+    type,
+    toolNames,
+    toolCallArgs,
+    toolCallIds
+  }) {
+    const message = {
+      id: this.generateId(),
+      content,
+      role,
+      createdAt: /* @__PURE__ */ new Date(),
+      threadId,
+      resourceId,
+      type,
+      toolNames,
+      toolCallArgs,
+      toolCallIds
+    };
+    const savedMessages = await this.saveMessages({ messages: [message], memoryConfig: config });
+    const list = new chunkZTPPDHQK_cjs.MessageList({ threadId, resourceId }).add(savedMessages[0], "memory");
+    return list.get.all.v1()[0];
+  }
+  /**
+   * Generates a unique identifier
+   * @returns A unique string ID
+   */
+  generateId() {
+    return crypto.randomUUID();
+  }
+};
+
+exports.MastraMemory = MastraMemory;
+exports.MemoryProcessor = MemoryProcessor;
+exports.memoryDefaultOptions = memoryDefaultOptions;

package/dist/chunk-C4LMN2IR.js

@@ -0,0 +1,27 @@
+// 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);
+}
+
+// src/tools/toolchecks.ts
+function isVercelTool(tool) {
+  return !!(tool && !(tool instanceof Tool) && "parameters" in tool);
+}
+
+export { Tool, createTool, isVercelTool };