@mastra/core 0.10.13 → 0.10.14

package/dist/chunk-ZIZ3CVHN.cjs

@@ -0,0 +1,120 @@
+'use strict';
+
+// src/logger/constants.ts
+var RegisteredLogger = {
+  AGENT: "AGENT",
+  AUTH: "AUTH",
+  NETWORK: "NETWORK",
+  WORKFLOW: "WORKFLOW",
+  LLM: "LLM",
+  TTS: "TTS",
+  VOICE: "VOICE",
+  VECTOR: "VECTOR",
+  BUNDLER: "BUNDLER",
+  DEPLOYER: "DEPLOYER",
+  MEMORY: "MEMORY",
+  STORAGE: "STORAGE",
+  EMBEDDINGS: "EMBEDDINGS",
+  MCP_SERVER: "MCP_SERVER"
+};
+var LogLevel = {
+  DEBUG: "debug",
+  INFO: "info",
+  WARN: "warn",
+  ERROR: "error",
+  NONE: "silent"
+};
+
+// src/logger/logger.ts
+var MastraLogger = class {
+  name;
+  level;
+  transports;
+  constructor(options = {}) {
+    this.name = options.name || "Mastra";
+    this.level = options.level || LogLevel.ERROR;
+    this.transports = new Map(Object.entries(options.transports || {}));
+  }
+  getTransports() {
+    return this.transports;
+  }
+  trackException(_error) {
+  }
+  async getLogs(transportId, params) {
+    if (!transportId || !this.transports.has(transportId)) {
+      return { logs: [], total: 0, page: params?.page ?? 1, perPage: params?.perPage ?? 100, hasMore: false };
+    }
+    return this.transports.get(transportId).getLogs(params) ?? {
+      logs: [],
+      total: 0,
+      page: params?.page ?? 1,
+      perPage: params?.perPage ?? 100,
+      hasMore: false
+    };
+  }
+  async getLogsByRunId({
+    transportId,
+    runId,
+    fromDate,
+    toDate,
+    logLevel,
+    filters,
+    page,
+    perPage
+  }) {
+    if (!transportId || !this.transports.has(transportId) || !runId) {
+      return { logs: [], total: 0, page: page ?? 1, perPage: perPage ?? 100, hasMore: false };
+    }
+    return this.transports.get(transportId).getLogsByRunId({ runId, fromDate, toDate, logLevel, filters, page, perPage }) ?? {
+      logs: [],
+      total: 0,
+      page: page ?? 1,
+      perPage: perPage ?? 100,
+      hasMore: false
+    };
+  }
+};
+
+// src/logger/default-logger.ts
+var createLogger = (options) => {
+  const logger = new ConsoleLogger(options);
+  logger.warn(`createLogger is deprecated. Please use "new ConsoleLogger()" from "@mastra/core/logger" instead.`);
+  return logger;
+};
+var ConsoleLogger = class extends MastraLogger {
+  constructor(options = {}) {
+    super(options);
+  }
+  debug(message, ...args) {
+    if (this.level === LogLevel.DEBUG) {
+      console.debug(message, ...args);
+    }
+  }
+  info(message, ...args) {
+    if (this.level === LogLevel.INFO || this.level === LogLevel.DEBUG) {
+      console.info(message, ...args);
+    }
+  }
+  warn(message, ...args) {
+    if (this.level === LogLevel.WARN || this.level === LogLevel.INFO || this.level === LogLevel.DEBUG) {
+      console.warn(message, ...args);
+    }
+  }
+  error(message, ...args) {
+    if (this.level === LogLevel.ERROR || this.level === LogLevel.WARN || this.level === LogLevel.INFO || this.level === LogLevel.DEBUG) {
+      console.error(message, ...args);
+    }
+  }
+  async getLogs(_transportId, _params) {
+    return { logs: [], total: 0, page: _params?.page ?? 1, perPage: _params?.perPage ?? 100, hasMore: false };
+  }
+  async getLogsByRunId(_args) {
+    return { logs: [], total: 0, page: _args.page ?? 1, perPage: _args.perPage ?? 100, hasMore: false };
+  }
+};
+
+exports.ConsoleLogger = ConsoleLogger;
+exports.LogLevel = LogLevel;
+exports.MastraLogger = MastraLogger;
+exports.RegisteredLogger = RegisteredLogger;
+exports.createLogger = createLogger;

package/dist/chunk-ZPOUMTTH.cjs

@@ -0,0 +1,362 @@
+'use strict';
+
+var chunkQQ5K5TZE_cjs = require('./chunk-QQ5K5TZE.cjs');
+var chunkB6TOBUS6_cjs = require('./chunk-B6TOBUS6.cjs');
+var chunkP3Q73CAW_cjs = require('./chunk-P3Q73CAW.cjs');
+var chunkU64IJDC5_cjs = require('./chunk-U64IJDC5.cjs');
+
+// src/voice/voice.ts
+var _MastraVoice_decorators, _init, _a;
+_MastraVoice_decorators = [chunkQQ5K5TZE_cjs.InstrumentClass({
+  prefix: "voice",
+  excludeMethods: ["__setTools", "__setLogger", "__setTelemetry", "#log"]
+})];
+exports.MastraVoice = class MastraVoice extends (_a = chunkP3Q73CAW_cjs.MastraBase) {
+  listeningModel;
+  speechModel;
+  speaker;
+  realtimeConfig;
+  constructor({
+    listeningModel,
+    speechModel,
+    speaker,
+    realtimeConfig,
+    name
+  } = {}) {
+    super({
+      component: "VOICE",
+      name
+    });
+    this.listeningModel = listeningModel;
+    this.speechModel = speechModel;
+    this.speaker = speaker;
+    this.realtimeConfig = realtimeConfig;
+  }
+  traced(method, methodName) {
+    return this.telemetry?.traceMethod(method, {
+      spanName: `voice.${methodName}`,
+      attributes: {
+        "voice.type": this.speechModel?.name || this.listeningModel?.name || "unknown"
+      }
+    }) ?? method;
+  }
+  updateConfig(_options) {
+    this.logger.warn("updateConfig not implemented by this voice provider");
+  }
+  /**
+   * Initializes a WebSocket or WebRTC connection for real-time communication
+   * @returns Promise that resolves when the connection is established
+   */
+  connect(_options) {
+    this.logger.warn("connect not implemented by this voice provider");
+    return Promise.resolve();
+  }
+  /**
+   * Relay audio data to the voice provider for real-time processing
+   * @param audioData Audio data to relay
+   */
+  send(_audioData) {
+    this.logger.warn("relay not implemented by this voice provider");
+    return Promise.resolve();
+  }
+  /**
+   * Trigger voice providers to respond
+   */
+  answer(_options) {
+    this.logger.warn("answer not implemented by this voice provider");
+    return Promise.resolve();
+  }
+  /**
+   * Equip the voice provider with instructions
+   * @param instructions Instructions to add
+   */
+  addInstructions(_instructions) {}
+  /**
+   * Equip the voice provider with tools
+   * @param tools Array of tools to add
+   */
+  addTools(_tools) {}
+  /**
+   * Disconnect from the WebSocket or WebRTC connection
+   */
+  close() {
+    this.logger.warn("close not implemented by this voice provider");
+  }
+  /**
+   * Register an event listener
+   * @param event Event name (e.g., 'speaking', 'writing', 'error')
+   * @param callback Callback function that receives event data
+   */
+  on(_event, _callback) {
+    this.logger.warn("on not implemented by this voice provider");
+  }
+  /**
+   * Remove an event listener
+   * @param event Event name (e.g., 'speaking', 'writing', 'error')
+   * @param callback Callback function to remove
+   */
+  off(_event, _callback) {
+    this.logger.warn("off not implemented by this voice provider");
+  }
+  /**
+   * Get available speakers/voices
+   * @returns Array of available voice IDs and their metadata
+   */
+  getSpeakers() {
+    this.logger.warn("getSpeakers not implemented by this voice provider");
+    return Promise.resolve([]);
+  }
+  /**
+   * Get available speakers/voices
+   * @returns Array of available voice IDs and their metadata
+   */
+  getListener() {
+    this.logger.warn("getListener not implemented by this voice provider");
+    return Promise.resolve({
+      enabled: false
+    });
+  }
+};
+exports.MastraVoice = /*@__PURE__*/(_ => {
+  _init = chunkU64IJDC5_cjs.__decoratorStart(_a);
+  exports.MastraVoice = chunkU64IJDC5_cjs.__decorateElement(_init, 0, "MastraVoice", _MastraVoice_decorators, exports.MastraVoice);
+  chunkU64IJDC5_cjs.__runInitializers(_init, 1, exports.MastraVoice);
+
+  // src/voice/composite-voice.ts
+  return exports.MastraVoice;
+})();
+// src/voice/composite-voice.ts
+var CompositeVoice = class extends exports.MastraVoice {
+  speakProvider;
+  listenProvider;
+  realtimeProvider;
+  constructor({
+    input,
+    output,
+    realtime,
+    speakProvider,
+    listenProvider,
+    realtimeProvider
+  }) {
+    super();
+    this.speakProvider = output || speakProvider;
+    this.listenProvider = input || listenProvider;
+    this.realtimeProvider = realtime || realtimeProvider;
+  }
+  /**
+   * Convert text to speech using the configured provider
+   * @param input Text or text stream to convert to speech
+   * @param options Speech options including speaker and provider-specific options
+   * @returns Audio stream or void if in realtime mode
+   */
+  async speak(input, options) {
+    if (this.realtimeProvider) {
+      return this.realtimeProvider.speak(input, options);
+    } else if (this.speakProvider) {
+      return this.speakProvider.speak(input, options);
+    }
+    throw new chunkB6TOBUS6_cjs.MastraError({
+      id: "VOICE_COMPOSITE_NO_SPEAK_PROVIDER",
+      text: "No speak provider or realtime provider configured",
+      domain: "MASTRA_VOICE" /* MASTRA_VOICE */,
+      category: "USER" /* USER */
+    });
+  }
+  async listen(audioStream, options) {
+    if (this.realtimeProvider) {
+      return await this.realtimeProvider.listen(audioStream, options);
+    } else if (this.listenProvider) {
+      return await this.listenProvider.listen(audioStream, options);
+    }
+    throw new chunkB6TOBUS6_cjs.MastraError({
+      id: "VOICE_COMPOSITE_NO_LISTEN_PROVIDER",
+      text: "No listen provider or realtime provider configured",
+      domain: "MASTRA_VOICE" /* MASTRA_VOICE */,
+      category: "USER" /* USER */
+    });
+  }
+  async getSpeakers() {
+    if (this.realtimeProvider) {
+      return this.realtimeProvider.getSpeakers();
+    } else if (this.speakProvider) {
+      return this.speakProvider.getSpeakers();
+    }
+    throw new chunkB6TOBUS6_cjs.MastraError({
+      id: "VOICE_COMPOSITE_NO_SPEAKERS_PROVIDER",
+      text: "No speak provider or realtime provider configured",
+      domain: "MASTRA_VOICE" /* MASTRA_VOICE */,
+      category: "USER" /* USER */
+    });
+  }
+  async getListener() {
+    if (this.realtimeProvider) {
+      return this.realtimeProvider.getListener();
+    } else if (this.listenProvider) {
+      return this.listenProvider.getListener();
+    }
+    throw new chunkB6TOBUS6_cjs.MastraError({
+      id: "VOICE_COMPOSITE_NO_LISTENER_PROVIDER",
+      text: "No listener provider or realtime provider configured",
+      domain: "MASTRA_VOICE" /* MASTRA_VOICE */,
+      category: "USER" /* USER */
+    });
+  }
+  updateConfig(options) {
+    if (!this.realtimeProvider) {
+      return;
+    }
+    this.realtimeProvider.updateConfig(options);
+  }
+  /**
+   * Initializes a WebSocket or WebRTC connection for real-time communication
+   * @returns Promise that resolves when the connection is established
+   */
+  connect(options) {
+    if (!this.realtimeProvider) {
+      throw new chunkB6TOBUS6_cjs.MastraError({
+        id: "VOICE_COMPOSITE_NO_REALTIME_PROVIDER_CONNECT",
+        text: "No realtime provider configured",
+        domain: "MASTRA_VOICE" /* MASTRA_VOICE */,
+        category: "USER" /* USER */
+      });
+    }
+    return this.realtimeProvider.connect(options);
+  }
+  /**
+   * Relay audio data to the voice provider for real-time processing
+   * @param audioData Audio data to send
+   */
+  send(audioData) {
+    if (!this.realtimeProvider) {
+      throw new chunkB6TOBUS6_cjs.MastraError({
+        id: "VOICE_COMPOSITE_NO_REALTIME_PROVIDER_SEND",
+        text: "No realtime provider configured",
+        domain: "MASTRA_VOICE" /* MASTRA_VOICE */,
+        category: "USER" /* USER */
+      });
+    }
+    return this.realtimeProvider.send(audioData);
+  }
+  /**
+   * Trigger voice providers to respond
+   */
+  answer(options) {
+    if (!this.realtimeProvider) {
+      throw new chunkB6TOBUS6_cjs.MastraError({
+        id: "VOICE_COMPOSITE_NO_REALTIME_PROVIDER_ANSWER",
+        text: "No realtime provider configured",
+        domain: "MASTRA_VOICE" /* MASTRA_VOICE */,
+        category: "USER" /* USER */
+      });
+    }
+    return this.realtimeProvider.answer(options);
+  }
+  /**
+   * Equip the voice provider with instructions
+   * @param instructions Instructions to add
+   */
+  addInstructions(instructions) {
+    if (!this.realtimeProvider) {
+      return;
+    }
+    this.realtimeProvider.addInstructions(instructions);
+  }
+  /**
+   * Equip the voice provider with tools
+   * @param tools Array of tools to add
+   */
+  addTools(tools) {
+    if (!this.realtimeProvider) {
+      return;
+    }
+    this.realtimeProvider.addTools(tools);
+  }
+  /**
+   * Disconnect from the WebSocket or WebRTC connection
+   */
+  close() {
+    if (!this.realtimeProvider) {
+      throw new chunkB6TOBUS6_cjs.MastraError({
+        id: "VOICE_COMPOSITE_NO_REALTIME_PROVIDER_CLOSE",
+        text: "No realtime provider configured",
+        domain: "MASTRA_VOICE" /* MASTRA_VOICE */,
+        category: "USER" /* USER */
+      });
+    }
+    this.realtimeProvider.close();
+  }
+  /**
+   * Register an event listener
+   * @param event Event name (e.g., 'speaking', 'writing', 'error')
+   * @param callback Callback function that receives event data
+   */
+  on(event, callback) {
+    if (!this.realtimeProvider) {
+      throw new chunkB6TOBUS6_cjs.MastraError({
+        id: "VOICE_COMPOSITE_NO_REALTIME_PROVIDER_ON",
+        text: "No realtime provider configured",
+        domain: "MASTRA_VOICE" /* MASTRA_VOICE */,
+        category: "USER" /* USER */
+      });
+    }
+    this.realtimeProvider.on(event, callback);
+  }
+  /**
+   * Remove an event listener
+   * @param event Event name (e.g., 'speaking', 'writing', 'error')
+   * @param callback Callback function to remove
+   */
+  off(event, callback) {
+    if (!this.realtimeProvider) {
+      throw new chunkB6TOBUS6_cjs.MastraError({
+        id: "VOICE_COMPOSITE_NO_REALTIME_PROVIDER_OFF",
+        text: "No realtime provider configured",
+        domain: "MASTRA_VOICE" /* MASTRA_VOICE */,
+        category: "USER" /* USER */
+      });
+    }
+    this.realtimeProvider.off(event, callback);
+  }
+};
+
+// src/voice/default-voice.ts
+var DefaultVoice = class extends exports.MastraVoice {
+  constructor() {
+    super();
+  }
+  async speak(_input) {
+    throw new chunkB6TOBUS6_cjs.MastraError({
+      id: "VOICE_DEFAULT_NO_SPEAK_PROVIDER",
+      text: "No voice provider configured",
+      domain: "MASTRA_VOICE" /* MASTRA_VOICE */,
+      category: "USER" /* USER */
+    });
+  }
+  async listen(_input) {
+    throw new chunkB6TOBUS6_cjs.MastraError({
+      id: "VOICE_DEFAULT_NO_LISTEN_PROVIDER",
+      text: "No voice provider configured",
+      domain: "MASTRA_VOICE" /* MASTRA_VOICE */,
+      category: "USER" /* USER */
+    });
+  }
+  async getSpeakers() {
+    throw new chunkB6TOBUS6_cjs.MastraError({
+      id: "VOICE_DEFAULT_NO_SPEAKERS_PROVIDER",
+      text: "No voice provider configured",
+      domain: "MASTRA_VOICE" /* MASTRA_VOICE */,
+      category: "USER" /* USER */
+    });
+  }
+  async getListener() {
+    throw new chunkB6TOBUS6_cjs.MastraError({
+      id: "VOICE_DEFAULT_NO_LISTENER_PROVIDER",
+      text: "No voice provider configured",
+      domain: "MASTRA_VOICE" /* MASTRA_VOICE */,
+      category: "USER" /* USER */
+    });
+  }
+};
+
+exports.CompositeVoice = CompositeVoice;
+exports.DefaultVoice = DefaultVoice;

package/dist/chunk-ZZLBNB3U.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var chunkFEYYOBBG_cjs = require('./chunk-FEYYOBBG.cjs');
+
+// src/deployer/index.ts
+var MastraDeployer = class extends chunkFEYYOBBG_cjs.MastraBundler {
+  constructor({ name }) {
+    super({ component: "DEPLOYER", name });
+  }
+};
+
+exports.MastraDeployer = MastraDeployer;

package/dist/deployer/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var chunkZZLBNB3U_cjs = require('../chunk-ZZLBNB3U.cjs');
+
+
+
+Object.defineProperty(exports, "MastraDeployer", {
+  enumerable: true,
+  get: function () { return chunkZZLBNB3U_cjs.MastraDeployer; }
+});

package/dist/deployer/index.d.cts

@@ -0,0 +1,19 @@
+import { MastraBundler, IBundler } from '../bundler/index.cjs';
+import '../base-B_y9sMg0.cjs';
+import '@opentelemetry/api';
+import '../logger-B8XXh6ya.cjs';
+import '../error/index.cjs';
+import 'stream';
+import '@opentelemetry/sdk-trace-base';
+
+interface IDeployer extends IBundler {
+    deploy(outputDirectory: string): Promise<void>;
+}
+declare abstract class MastraDeployer extends MastraBundler implements IDeployer {
+    constructor({ name }: {
+        name: string;
+    });
+    abstract deploy(outputDirectory: string): Promise<void>;
+}
+
+export { type IDeployer, MastraDeployer };

package/dist/deployer/index.d.ts

@@ -0,0 +1,19 @@
+import { MastraBundler, IBundler } from '../bundler/index.js';
+import '../base-ClrXcCRx.js';
+import '@opentelemetry/api';
+import '../logger-Bpa2oLL4.js';
+import '../error/index.js';
+import 'stream';
+import '@opentelemetry/sdk-trace-base';
+
+interface IDeployer extends IBundler {
+    deploy(outputDirectory: string): Promise<void>;
+}
+declare abstract class MastraDeployer extends MastraBundler implements IDeployer {
+    constructor({ name }: {
+        name: string;
+    });
+    abstract deploy(outputDirectory: string): Promise<void>;
+}
+
+export { type IDeployer, MastraDeployer };

package/dist/deployer/index.js

@@ -0,0 +1 @@
+export { MastraDeployer } from '../chunk-JNMQKJH4.js';

package/dist/di/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var chunkLABUWBKX_cjs = require('../chunk-LABUWBKX.cjs');
+
+
+
+Object.defineProperty(exports, "RuntimeContext", {
+  enumerable: true,
+  get: function () { return chunkLABUWBKX_cjs.RuntimeContext; }
+});

package/dist/di/index.d.cts

@@ -0,0 +1 @@
+export { RuntimeContext } from '../runtime-context/index.cjs';

package/dist/di/index.d.ts

@@ -0,0 +1 @@
+export { RuntimeContext } from '../runtime-context/index.js';

package/dist/di/index.js

@@ -0,0 +1 @@
+export { RuntimeContext } from '../chunk-SGGPJWRQ.js';

package/dist/error/index.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var chunkB6TOBUS6_cjs = require('../chunk-B6TOBUS6.cjs');
+
+
+
+Object.defineProperty(exports, "ErrorCategory", {
+  enumerable: true,
+  get: function () { return chunkB6TOBUS6_cjs.ErrorCategory; }
+});
+Object.defineProperty(exports, "ErrorDomain", {
+  enumerable: true,
+  get: function () { return chunkB6TOBUS6_cjs.ErrorDomain; }
+});
+Object.defineProperty(exports, "MastraBaseError", {
+  enumerable: true,
+  get: function () { return chunkB6TOBUS6_cjs.MastraBaseError; }
+});
+Object.defineProperty(exports, "MastraError", {
+  enumerable: true,
+  get: function () { return chunkB6TOBUS6_cjs.MastraError; }
+});

package/dist/error/index.d.cts

@@ -0,0 +1,86 @@
+declare enum ErrorDomain {
+    TOOL = "TOOL",
+    AGENT = "AGENT",
+    MCP = "MCP",
+    AGENT_NETWORK = "AGENT_NETWORK",
+    MASTRA_SERVER = "MASTRA_SERVER",
+    MASTRA_TELEMETRY = "MASTRA_TELEMETRY",
+    MASTRA_WORKFLOW = "MASTRA_WORKFLOW",
+    MASTRA_VOICE = "MASTRA_VOICE",
+    MASTRA_VECTOR = "MASTRA_VECTOR",
+    LLM = "LLM",
+    EVAL = "EVAL",
+    A2A = "A2A",
+    MASTRA_INSTANCE = "MASTRA_INSTANCE",
+    MASTRA = "MASTRA",
+    DEPLOYER = "DEPLOYER",
+    STORAGE = "STORAGE"
+}
+declare enum ErrorCategory {
+    UNKNOWN = "UNKNOWN",
+    USER = "USER",
+    SYSTEM = "SYSTEM",
+    THIRD_PARTY = "THIRD_PARTY"
+}
+type Scalar = null | boolean | number | string;
+type Json<T> = [T] extends [Scalar | undefined] ? Scalar : [T] extends [{
+    [x: number]: unknown;
+}] ? {
+    [K in keyof T]: Json<T[K]>;
+} : never;
+/**
+ * Defines the structure for an error's metadata.
+ * This is used to create instances of MastraError.
+ */
+interface IErrorDefinition<D, C> {
+    /** Unique identifier for the error. */
+    id: Uppercase<string>;
+    /**
+     * Optional custom error message that overrides the original error message.
+     * If not provided, the original error message will be used, or 'Unknown error' if no error is provided.
+     */
+    text?: string;
+    /**
+     * Functional domain of the error (e.g., CONFIG, BUILD, API).
+     */
+    domain: D;
+    /** Broad category of the error (e.g., USER, SYSTEM, THIRD_PARTY). */
+    category: C;
+    details?: Record<string, Json<Scalar>>;
+}
+/**
+ * Base error class for the Mastra ecosystem.
+ * It standardizes error reporting and can be extended for more specific error types.
+ */
+declare class MastraBaseError<D, C> extends Error {
+    readonly id: Uppercase<string>;
+    readonly domain: D;
+    readonly category: C;
+    readonly details?: Record<string, Json<Scalar>>;
+    readonly message: string;
+    constructor(errorDefinition: IErrorDefinition<D, C>, originalError?: string | Error | MastraBaseError<D, C> | unknown);
+    /**
+     * Returns a structured representation of the error, useful for logging or API responses.
+     */
+    toJSONDetails(): {
+        message: string;
+        domain: D;
+        category: C;
+        details: Record<string, Scalar> | undefined;
+    };
+    toJSON(): {
+        message: string;
+        details: {
+            message: string;
+            domain: D;
+            category: C;
+            details: Record<string, Scalar> | undefined;
+        };
+        code: Uppercase<string>;
+    };
+    toString(): string;
+}
+declare class MastraError extends MastraBaseError<`${ErrorDomain}`, `${ErrorCategory}`> {
+}
+
+export { ErrorCategory, ErrorDomain, type IErrorDefinition, MastraBaseError, MastraError };