@mastra/core 0.10.13 → 0.10.15-alpha.0

package/dist/chunk-J52TXHZV.cjs

@@ -0,0 +1,73 @@
+'use strict';
+
+var chunkST5RMVLG_cjs = require('./chunk-ST5RMVLG.cjs');
+var chunkB6TOBUS6_cjs = require('./chunk-B6TOBUS6.cjs');
+
+// src/eval/metric.ts
+var Metric = class {
+};
+
+// src/eval/evaluation.ts
+async function evaluate({
+  agentName,
+  input,
+  metric,
+  output,
+  runId,
+  globalRunId,
+  testInfo,
+  instructions
+}) {
+  const runIdToUse = runId || crypto.randomUUID();
+  let metricResult;
+  let metricName = metric.constructor.name;
+  try {
+    metricResult = await metric.measure(input.toString(), output);
+  } catch (e) {
+    throw new chunkB6TOBUS6_cjs.MastraError(
+      {
+        id: "EVAL_METRIC_MEASURE_EXECUTION_FAILED",
+        domain: "EVAL" /* EVAL */,
+        category: "USER" /* USER */,
+        details: {
+          agentName,
+          metricName,
+          globalRunId
+        }
+      },
+      e
+    );
+  }
+  const traceObject = {
+    input: input.toString(),
+    output,
+    result: metricResult,
+    agentName,
+    metricName,
+    instructions,
+    globalRunId,
+    runId: runIdToUse,
+    testInfo
+  };
+  try {
+    chunkST5RMVLG_cjs.executeHook("onEvaluation" /* ON_EVALUATION */, traceObject);
+  } catch (e) {
+    throw new chunkB6TOBUS6_cjs.MastraError(
+      {
+        id: "EVAL_HOOK_EXECUTION_FAILED",
+        domain: "EVAL" /* EVAL */,
+        category: "USER" /* USER */,
+        details: {
+          agentName,
+          metricName,
+          globalRunId
+        }
+      },
+      e
+    );
+  }
+  return { ...metricResult, output };
+}
+
+exports.Metric = Metric;
+exports.evaluate = evaluate;

package/dist/chunk-J62R4M7K.js

@@ -0,0 +1,240 @@
+import { augmentWithInit } from './chunk-YOQP5T77.js';
+import { MessageList } from './chunk-DR4JS662.js';
+import { deepMerge } from './chunk-IBKM5CLQ.js';
+import { MastraBase } from './chunk-5IEKR756.js';
+
+// src/memory/memory.ts
+var MemoryProcessor = class extends 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 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 = 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 = 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 = 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 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();
+  }
+};
+
+export { MastraMemory, MemoryProcessor, memoryDefaultOptions };

package/dist/chunk-JNMQKJH4.js

@@ -0,0 +1,10 @@
+import { MastraBundler } from './chunk-ATXBSEFT.js';
+
+// src/deployer/index.ts
+var MastraDeployer = class extends MastraBundler {
+  constructor({ name }) {
+    super({ component: "DEPLOYER", name });
+  }
+};
+
+export { MastraDeployer };

package/dist/chunk-JQOMTERC.js

@@ -0,0 +1,89 @@
+import { Transform } from 'stream';
+
+// src/logger/multi-logger.ts
+var MultiLogger = class {
+  loggers;
+  constructor(loggers) {
+    this.loggers = loggers;
+  }
+  debug(message, ...args) {
+    this.loggers.forEach((logger) => logger.debug(message, ...args));
+  }
+  info(message, ...args) {
+    this.loggers.forEach((logger) => logger.info(message, ...args));
+  }
+  warn(message, ...args) {
+    this.loggers.forEach((logger) => logger.warn(message, ...args));
+  }
+  error(message, ...args) {
+    this.loggers.forEach((logger) => logger.error(message, ...args));
+  }
+  trackException(error) {
+    this.loggers.forEach((logger) => logger.trackException(error));
+  }
+  getTransports() {
+    const transports = [];
+    this.loggers.forEach((logger) => transports.push(...logger.getTransports().entries()));
+    return new Map(transports);
+  }
+  async getLogs(transportId, params) {
+    for (const logger of this.loggers) {
+      const logs = await logger.getLogs(transportId, params);
+      if (logs.total > 0) {
+        return logs;
+      }
+    }
+    return { logs: [], total: 0, page: params?.page ?? 1, perPage: params?.perPage ?? 100, hasMore: false };
+  }
+  async getLogsByRunId(args) {
+    for (const logger of this.loggers) {
+      const logs = await logger.getLogsByRunId(args);
+      if (logs.total > 0) {
+        return logs;
+      }
+    }
+    return { logs: [], total: 0, page: args.page ?? 1, perPage: args.perPage ?? 100, hasMore: false };
+  }
+};
+
+// src/logger/noop-logger.ts
+var noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  },
+  cleanup: async () => {
+  },
+  getTransports: () => /* @__PURE__ */ new Map(),
+  trackException: () => {
+  },
+  getLogs: async () => ({ logs: [], total: 0, page: 1, perPage: 100, hasMore: false }),
+  getLogsByRunId: async () => ({ logs: [], total: 0, page: 1, perPage: 100, hasMore: false })
+};
+var LoggerTransport = class extends Transform {
+  constructor(opts = {}) {
+    super({ ...opts, objectMode: true });
+  }
+  async getLogsByRunId(_args) {
+    return { logs: [], total: 0, page: _args?.page ?? 1, perPage: _args?.perPage ?? 100, hasMore: false };
+  }
+  async getLogs(_args) {
+    return { logs: [], total: 0, page: _args?.page ?? 1, perPage: _args?.perPage ?? 100, hasMore: false };
+  }
+};
+var createCustomTransport = (stream, getLogs, getLogsByRunId) => {
+  let transport = stream;
+  if (getLogs) {
+    transport.getLogs = getLogs;
+  }
+  if (getLogsByRunId) {
+    transport.getLogsByRunId = getLogsByRunId;
+  }
+  return transport;
+};
+
+export { LoggerTransport, MultiLogger, createCustomTransport, noopLogger };

package/dist/chunk-LABUWBKX.cjs

@@ -0,0 +1,71 @@
+'use strict';
+
+// src/runtime-context/index.ts
+var RuntimeContext = class {
+  registry = /* @__PURE__ */ new Map();
+  constructor(iterable) {
+    this.registry = new Map(iterable);
+  }
+  /**
+   * set a value with strict typing if `Values` is a Record and the key exists in it.
+   */
+  set(key, value) {
+    this.registry.set(key, value);
+  }
+  /**
+   * Get a value with its type
+   */
+  get(key) {
+    return this.registry.get(key);
+  }
+  /**
+   * Check if a key exists in the container
+   */
+  has(key) {
+    return this.registry.has(key);
+  }
+  /**
+   * Delete a value by key
+   */
+  delete(key) {
+    return this.registry.delete(key);
+  }
+  /**
+   * Clear all values from the container
+   */
+  clear() {
+    this.registry.clear();
+  }
+  /**
+   * Get all keys in the container
+   */
+  keys() {
+    return this.registry.keys();
+  }
+  /**
+   * Get all values in the container
+   */
+  values() {
+    return this.registry.values();
+  }
+  /**
+   * Get all entries in the container
+   */
+  entries() {
+    return this.registry.entries();
+  }
+  /**
+   * Get the size of the container
+   */
+  size() {
+    return this.registry.size;
+  }
+  /**
+   * Execute a function for each entry in the container
+   */
+  forEach(callbackfn) {
+    this.registry.forEach(callbackfn);
+  }
+};
+
+exports.RuntimeContext = RuntimeContext;