@mastra/core 0.0.0-commonjs-20250227130920

package/dist/vector/libsql/index.d.cts

@@ -0,0 +1,29 @@
+import { Filter } from '../../filter/index.cjs';
+import { MastraVector, QueryResult, IndexStats } from '../index.cjs';
+import '../../base-hs9NDAZ2.cjs';
+import '@opentelemetry/api';
+import '../../index-mKY1XrpK.cjs';
+import 'stream';
+import 'pino';
+import '@opentelemetry/sdk-trace-base';
+
+declare class LibSQLVector extends MastraVector {
+    private turso;
+    constructor({ connectionUrl, authToken, syncUrl, syncInterval, }: {
+        connectionUrl: string;
+        authToken?: string;
+        syncUrl?: string;
+        syncInterval?: number;
+    });
+    protected rewriteDbUrl(url: string): string;
+    transformFilter(filter?: Filter): Filter;
+    query(indexName: string, queryVector: number[], topK?: number, filter?: Filter, includeVector?: boolean, minScore?: number): Promise<QueryResult[]>;
+    upsert(indexName: string, vectors: number[][], metadata?: Record<string, any>[], ids?: string[]): Promise<string[]>;
+    createIndex(indexName: string, dimension: number, _metric?: 'cosine' | 'euclidean' | 'dotproduct'): Promise<void>;
+    deleteIndex(indexName: string): Promise<void>;
+    listIndexes(): Promise<string[]>;
+    describeIndex(indexName: string): Promise<IndexStats>;
+    truncateIndex(indexName: string): Promise<void>;
+}
+
+export { LibSQLVector as DefaultVectorDB, LibSQLVector };

package/dist/vector/libsql/index.d.ts

@@ -0,0 +1,29 @@
+import { Filter } from '../../filter/index.js';
+import { MastraVector, QueryResult, IndexStats } from '../index.js';
+import '../../base-D90KQ4XI.js';
+import '@opentelemetry/api';
+import '../../index-mKY1XrpK.js';
+import 'stream';
+import 'pino';
+import '@opentelemetry/sdk-trace-base';
+
+declare class LibSQLVector extends MastraVector {
+    private turso;
+    constructor({ connectionUrl, authToken, syncUrl, syncInterval, }: {
+        connectionUrl: string;
+        authToken?: string;
+        syncUrl?: string;
+        syncInterval?: number;
+    });
+    protected rewriteDbUrl(url: string): string;
+    transformFilter(filter?: Filter): Filter;
+    query(indexName: string, queryVector: number[], topK?: number, filter?: Filter, includeVector?: boolean, minScore?: number): Promise<QueryResult[]>;
+    upsert(indexName: string, vectors: number[][], metadata?: Record<string, any>[], ids?: string[]): Promise<string[]>;
+    createIndex(indexName: string, dimension: number, _metric?: 'cosine' | 'euclidean' | 'dotproduct'): Promise<void>;
+    deleteIndex(indexName: string): Promise<void>;
+    listIndexes(): Promise<string[]>;
+    describeIndex(indexName: string): Promise<IndexStats>;
+    truncateIndex(indexName: string): Promise<void>;
+}
+
+export { LibSQLVector as DefaultVectorDB, LibSQLVector };

package/dist/vector/libsql/index.js

@@ -0,0 +1 @@
+export { LibSQLVector as DefaultVectorDB, LibSQLVector } from '../../chunk-33GSTUNK.js';

package/dist/voice/index.cjs

@@ -0,0 +1,369 @@
+'use strict';
+
+var stream = require('stream');
+var pino = require('pino');
+var pretty = require('pino-pretty');
+var api = require('@opentelemetry/api');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var pino__default = /*#__PURE__*/_interopDefault(pino);
+var pretty__default = /*#__PURE__*/_interopDefault(pretty);
+
+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++) fns[i].call(self) ;
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var it,
+    done,
+    ctx,
+    k = flags & 7,
+    p = false;
+  var j = 0;
+  var extraInitializers = array[j] || (array[j] = []);
+  var desc = k && ((target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(target , name));
+  __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    it = (0, decorators[i])(target, ctx), done._ = 1;
+    __expectFn(it) && (target = it);
+  }
+  return __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var RegisteredLogger = {
+  LLM: "LLM"};
+var LogLevel = {
+  INFO: "info"};
+var Logger = class {
+  logger;
+  transports;
+  constructor(options = {}) {
+    this.transports = options.transports || {};
+    const transportsAry = Object.entries(this.transports);
+    this.logger = pino__default.default({
+      name: options.name || "app",
+      level: options.level || LogLevel.INFO
+    }, options.overrideDefaultTransports ? options?.transports?.default : transportsAry.length === 0 ? pretty__default.default({
+      colorize: true,
+      levelFirst: true,
+      ignore: "pid,hostname",
+      colorizeObjects: true,
+      translateTime: "SYS:standard",
+      singleLine: false
+    }) : pino__default.default.multistream([...transportsAry.map(([_, transport]) => ({
+      stream: transport,
+      level: options.level || LogLevel.INFO
+    })), {
+      stream: pretty__default.default({
+        colorize: true,
+        levelFirst: true,
+        ignore: "pid,hostname",
+        colorizeObjects: true,
+        translateTime: "SYS:standard",
+        singleLine: false
+      }),
+      level: options.level || LogLevel.INFO
+    }]));
+  }
+  debug(message, args = {}) {
+    this.logger.debug(args, message);
+  }
+  info(message, args = {}) {
+    this.logger.info(args, message);
+  }
+  warn(message, args = {}) {
+    this.logger.warn(args, message);
+  }
+  error(message, args = {}) {
+    this.logger.error(args, message);
+  }
+  // Stream creation for process output handling
+  createStream() {
+    return new stream.Transform({
+      transform: (chunk, _encoding, callback) => {
+        const line = chunk.toString().trim();
+        if (line) {
+          this.info(line);
+        }
+        callback(null, chunk);
+      }
+    });
+  }
+  async getLogs(transportId) {
+    if (!transportId || !this.transports[transportId]) {
+      return [];
+    }
+    return this.transports[transportId].getLogs();
+  }
+  async getLogsByRunId({
+    runId,
+    transportId
+  }) {
+    return this.transports[transportId]?.getLogsByRunId({
+      runId
+    });
+  }
+};
+function createLogger(options) {
+  return new Logger(options);
+}
+
+// src/base.ts
+var MastraBase = class {
+  component = RegisteredLogger.LLM;
+  logger;
+  name;
+  telemetry;
+  constructor({
+    component,
+    name
+  }) {
+    this.component = component || RegisteredLogger.LLM;
+    this.name = name;
+    this.logger = createLogger({
+      name: `${this.component} - ${this.name}`
+    });
+  }
+  /**
+   * Set the logger for the agent
+   * @param logger
+   */
+  __setLogger(logger) {
+    this.logger = logger;
+    this.logger.debug(`Logger updated [component=${this.component}] [name=${this.name}]`);
+  }
+  /**
+   * Set the telemetry for the
+   * @param telemetry
+   */
+  __setTelemetry(telemetry) {
+    this.telemetry = telemetry;
+    this.logger.debug(`Telemetry updated [component=${this.component}] [tracer=${this.telemetry.tracer}]`);
+  }
+  /**
+   * Get the telemetry on the vector
+   * @returns telemetry
+   */
+  __getTelemetry() {
+    return this.telemetry;
+  }
+  /* 
+    get experimental_telemetry config
+    */
+  get experimental_telemetry() {
+    return this.telemetry ? {
+      // tracer: this.telemetry.tracer,
+      tracer: this.telemetry.getBaggageTracer(),
+      isEnabled: !!this.telemetry.tracer
+    } : void 0;
+  }
+};
+function hasActiveTelemetry(tracerName = "default-tracer") {
+  try {
+    return !!api.trace.getTracer(tracerName);
+  } catch {
+    return false;
+  }
+}
+
+// src/telemetry/telemetry.decorators.ts
+function withSpan(options) {
+  return function (_target, propertyKey, descriptor) {
+    if (!descriptor || typeof descriptor === "number") return;
+    const originalMethod = descriptor.value;
+    const methodName = String(propertyKey);
+    descriptor.value = function (...args) {
+      if (options?.skipIfNoTelemetry && !hasActiveTelemetry(options?.tracerName)) {
+        return originalMethod.apply(this, args);
+      }
+      const tracer = api.trace.getTracer(options?.tracerName ?? "default-tracer");
+      let spanName;
+      let spanKind;
+      if (typeof options === "string") {
+        spanName = options;
+      } else if (options) {
+        spanName = options.spanName || methodName;
+        spanKind = options.spanKind;
+      } else {
+        spanName = methodName;
+      }
+      const span = tracer.startSpan(spanName, {
+        kind: spanKind
+      });
+      let ctx = api.trace.setSpan(api.context.active(), span);
+      args.forEach((arg, index) => {
+        try {
+          span.setAttribute(`${spanName}.argument.${index}`, JSON.stringify(arg));
+        } catch {
+          span.setAttribute(`${spanName}.argument.${index}`, "[Not Serializable]");
+        }
+      });
+      const currentBaggage = api.propagation.getBaggage(ctx);
+      if (currentBaggage?.componentName) {
+        span.setAttribute("componentName", currentBaggage?.componentName);
+        span.setAttribute("runId", currentBaggage?.runId);
+      } else if (this && this.name) {
+        span.setAttribute("componentName", this.name);
+        span.setAttribute("runId", this.runId);
+        ctx = api.propagation.setBaggage(ctx, {
+          componentName: this.name,
+          runId: this.runId
+        });
+      }
+      let result;
+      try {
+        result = api.context.with(ctx, () => originalMethod.apply(this, args));
+        if (result instanceof Promise) {
+          return result.then(resolvedValue => {
+            try {
+              span.setAttribute(`${spanName}.result`, JSON.stringify(resolvedValue));
+            } catch {
+              span.setAttribute(`${spanName}.result`, "[Not Serializable]");
+            }
+            return resolvedValue;
+          }).finally(() => span.end());
+        }
+        try {
+          span.setAttribute(`${spanName}.result`, JSON.stringify(result));
+        } catch {
+          span.setAttribute(`${spanName}.result`, "[Not Serializable]");
+        }
+        return result;
+      } catch (error) {
+        span.setStatus({
+          code: api.SpanStatusCode.ERROR,
+          message: error instanceof Error ? error.message : "Unknown error"
+        });
+        if (error instanceof Error) {
+          span.recordException(error);
+        }
+        throw error;
+      } finally {
+        if (!(result instanceof Promise)) {
+          span.end();
+        }
+      }
+    };
+    return descriptor;
+  };
+}
+function InstrumentClass(options) {
+  return function (target) {
+    const methods = Object.getOwnPropertyNames(target.prototype);
+    methods.forEach(method => {
+      if (options?.excludeMethods?.includes(method) || method === "constructor") return;
+      if (options?.methodFilter && !options.methodFilter(method)) return;
+      const descriptor = Object.getOwnPropertyDescriptor(target.prototype, method);
+      if (descriptor && typeof descriptor.value === "function") {
+        Object.defineProperty(target.prototype, method, withSpan({
+          spanName: options?.prefix ? `${options.prefix}.${method}` : method,
+          skipIfNoTelemetry: true,
+          spanKind: options?.spanKind || api.SpanKind.INTERNAL,
+          tracerName: options?.tracerName
+        })(target, method, descriptor));
+      }
+    });
+    return target;
+  };
+}
+
+// src/voice/voice.ts
+var _MastraVoice_decorators, _init, _a;
+_MastraVoice_decorators = [InstrumentClass({
+  prefix: "voice",
+  excludeMethods: ["__setTools", "__setLogger", "__setTelemetry", "#log"]
+})];
+exports.MastraVoice = class MastraVoice extends (_a = MastraBase) {
+  listeningModel;
+  speechModel;
+  speaker;
+  constructor({
+    listeningModel,
+    speechModel,
+    speaker
+  } = {}) {
+    super({
+      component: "VOICE"
+    });
+    this.listeningModel = listeningModel;
+    this.speechModel = speechModel;
+    this.speaker = speaker;
+  }
+  traced(method, methodName) {
+    return this.telemetry?.traceMethod(method, {
+      spanName: `voice.${methodName}`,
+      attributes: {
+        "voice.type": this.speechModel?.name || this.listeningModel?.name || "unknown"
+      }
+    }) ?? method;
+  }
+};
+exports.MastraVoice = /*@__PURE__*/(_ => {
+  _init = __decoratorStart(_a);
+  exports.MastraVoice = __decorateElement(_init, 0, "MastraVoice", _MastraVoice_decorators, exports.MastraVoice);
+  __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;
+  constructor({
+    speakProvider,
+    listenProvider
+  }) {
+    super();
+    this.speakProvider = speakProvider;
+    this.listenProvider = listenProvider;
+  }
+  async speak(input, options) {
+    if (!this.speakProvider) {
+      throw new Error("No speak provider configured");
+    }
+    return this.speakProvider.speak(input, options);
+  }
+  async listen(audioStream, options) {
+    if (!this.listenProvider) {
+      throw new Error("No listen provider configured");
+    }
+    return this.listenProvider.listen(audioStream, options);
+  }
+  async getSpeakers() {
+    if (!this.speakProvider) {
+      throw new Error("No speak provider configured");
+    }
+    return this.speakProvider.getSpeakers();
+  }
+};
+
+exports.CompositeVoice = CompositeVoice;

package/dist/voice/index.d.cts

@@ -0,0 +1,67 @@
+import { M as MastraBase } from '../base-hs9NDAZ2.cjs';
+import '@opentelemetry/api';
+import '../index-mKY1XrpK.cjs';
+import 'stream';
+import 'pino';
+import '@opentelemetry/sdk-trace-base';
+
+interface BuiltInModelConfig {
+    name: string;
+    apiKey?: string;
+}
+interface VoiceConfig {
+    listeningModel?: BuiltInModelConfig;
+    speechModel?: BuiltInModelConfig;
+    speaker?: string;
+}
+declare abstract class MastraVoice extends MastraBase {
+    protected listeningModel?: BuiltInModelConfig;
+    protected speechModel?: BuiltInModelConfig;
+    protected speaker?: string;
+    constructor({ listeningModel, speechModel, speaker }?: VoiceConfig);
+    traced<T extends Function>(method: T, methodName: string): T;
+    /**
+     * Convert text to speech
+     * @param input Text or text stream to convert to speech
+     * @param options Speech options including speaker and provider-specific options
+     * @returns Audio stream
+     */
+    abstract speak(input: string | NodeJS.ReadableStream, options?: {
+        speaker?: string;
+        [key: string]: any;
+    }): Promise<NodeJS.ReadableStream>;
+    /**
+     * Convert speech to text
+     * @param audioStream Audio stream to transcribe
+     * @param options Provider-specific transcription options
+     * @returns Text or text stream
+     */
+    abstract listen(audioStream: NodeJS.ReadableStream, options?: {
+        [key: string]: any;
+    }): Promise<string | NodeJS.ReadableStream>;
+    /**
+     * Get available speakers/voices
+     * @returns Array of available voice IDs and their metadata
+     */
+    abstract getSpeakers(): Promise<Array<{
+        voiceId: string;
+        [key: string]: any;
+    }>>;
+}
+
+declare class CompositeVoice extends MastraVoice {
+    protected speakProvider?: MastraVoice;
+    protected listenProvider?: MastraVoice;
+    constructor({ speakProvider, listenProvider }: {
+        speakProvider?: MastraVoice;
+        listenProvider?: MastraVoice;
+    });
+    speak(input: string | NodeJS.ReadableStream, options?: any): Promise<NodeJS.ReadableStream>;
+    listen(audioStream: NodeJS.ReadableStream, options?: any): Promise<string | NodeJS.ReadableStream>;
+    getSpeakers(): Promise<{
+        [key: string]: any;
+        voiceId: string;
+    }[]>;
+}
+
+export { CompositeVoice, MastraVoice, type VoiceConfig };

package/dist/voice/index.d.ts

@@ -0,0 +1,67 @@
+import { M as MastraBase } from '../base-D90KQ4XI.js';
+import '@opentelemetry/api';
+import '../index-mKY1XrpK.js';
+import 'stream';
+import 'pino';
+import '@opentelemetry/sdk-trace-base';
+
+interface BuiltInModelConfig {
+    name: string;
+    apiKey?: string;
+}
+interface VoiceConfig {
+    listeningModel?: BuiltInModelConfig;
+    speechModel?: BuiltInModelConfig;
+    speaker?: string;
+}
+declare abstract class MastraVoice extends MastraBase {
+    protected listeningModel?: BuiltInModelConfig;
+    protected speechModel?: BuiltInModelConfig;
+    protected speaker?: string;
+    constructor({ listeningModel, speechModel, speaker }?: VoiceConfig);
+    traced<T extends Function>(method: T, methodName: string): T;
+    /**
+     * Convert text to speech
+     * @param input Text or text stream to convert to speech
+     * @param options Speech options including speaker and provider-specific options
+     * @returns Audio stream
+     */
+    abstract speak(input: string | NodeJS.ReadableStream, options?: {
+        speaker?: string;
+        [key: string]: any;
+    }): Promise<NodeJS.ReadableStream>;
+    /**
+     * Convert speech to text
+     * @param audioStream Audio stream to transcribe
+     * @param options Provider-specific transcription options
+     * @returns Text or text stream
+     */
+    abstract listen(audioStream: NodeJS.ReadableStream, options?: {
+        [key: string]: any;
+    }): Promise<string | NodeJS.ReadableStream>;
+    /**
+     * Get available speakers/voices
+     * @returns Array of available voice IDs and their metadata
+     */
+    abstract getSpeakers(): Promise<Array<{
+        voiceId: string;
+        [key: string]: any;
+    }>>;
+}
+
+declare class CompositeVoice extends MastraVoice {
+    protected speakProvider?: MastraVoice;
+    protected listenProvider?: MastraVoice;
+    constructor({ speakProvider, listenProvider }: {
+        speakProvider?: MastraVoice;
+        listenProvider?: MastraVoice;
+    });
+    speak(input: string | NodeJS.ReadableStream, options?: any): Promise<NodeJS.ReadableStream>;
+    listen(audioStream: NodeJS.ReadableStream, options?: any): Promise<string | NodeJS.ReadableStream>;
+    getSpeakers(): Promise<{
+        [key: string]: any;
+        voiceId: string;
+    }[]>;
+}
+
+export { CompositeVoice, MastraVoice, type VoiceConfig };

package/dist/voice/index.js

@@ -0,0 +1,76 @@
+import { InstrumentClass } from '../chunk-W5HVJX45.js';
+import { MastraBase } from '../chunk-OZ4XVJ6F.js';
+import { __decoratorStart, __decorateElement, __runInitializers } from '../chunk-C6A6W6XS.js';
+
+// src/voice/voice.ts
+var _MastraVoice_decorators, _init, _a;
+_MastraVoice_decorators = [InstrumentClass({
+  prefix: "voice",
+  excludeMethods: ["__setTools", "__setLogger", "__setTelemetry", "#log"]
+})];
+var MastraVoice = class extends (_a = MastraBase) {
+  listeningModel;
+  speechModel;
+  speaker;
+  constructor({
+    listeningModel,
+    speechModel,
+    speaker
+  } = {}) {
+    super({
+      component: "VOICE"
+    });
+    this.listeningModel = listeningModel;
+    this.speechModel = speechModel;
+    this.speaker = speaker;
+  }
+  traced(method, methodName) {
+    return this.telemetry?.traceMethod(method, {
+      spanName: `voice.${methodName}`,
+      attributes: {
+        "voice.type": this.speechModel?.name || this.listeningModel?.name || "unknown"
+      }
+    }) ?? method;
+  }
+};
+MastraVoice = /*@__PURE__*/(_ => {
+  _init = __decoratorStart(_a);
+  MastraVoice = __decorateElement(_init, 0, "MastraVoice", _MastraVoice_decorators, MastraVoice);
+  __runInitializers(_init, 1, MastraVoice);
+
+  // src/voice/composite-voice.ts
+  return MastraVoice;
+})();
+// src/voice/composite-voice.ts
+var CompositeVoice = class extends MastraVoice {
+  speakProvider;
+  listenProvider;
+  constructor({
+    speakProvider,
+    listenProvider
+  }) {
+    super();
+    this.speakProvider = speakProvider;
+    this.listenProvider = listenProvider;
+  }
+  async speak(input, options) {
+    if (!this.speakProvider) {
+      throw new Error("No speak provider configured");
+    }
+    return this.speakProvider.speak(input, options);
+  }
+  async listen(audioStream, options) {
+    if (!this.listenProvider) {
+      throw new Error("No listen provider configured");
+    }
+    return this.listenProvider.listen(audioStream, options);
+  }
+  async getSpeakers() {
+    if (!this.speakProvider) {
+      throw new Error("No speak provider configured");
+    }
+    return this.speakProvider.getSpeakers();
+  }
+};
+
+export { CompositeVoice, MastraVoice };