@mastra/core 0.0.0-commonjs-20250227130920

package/dist/telemetry/otel-vendor.cjs

@@ -0,0 +1,52 @@
+'use strict';
+
+var sdkNode = require('@opentelemetry/sdk-node');
+var sdkTraceNode = require('@opentelemetry/sdk-trace-node');
+var autoInstrumentationsNode = require('@opentelemetry/auto-instrumentations-node');
+var semanticConventions = require('@opentelemetry/semantic-conventions');
+var resources = require('@opentelemetry/resources');
+var exporterTraceOtlpHttp = require('@opentelemetry/exporter-trace-otlp-http');
+var sdkTraceBase = require('@opentelemetry/sdk-trace-base');
+
+
+
+Object.defineProperty(exports, "NodeSDK", {
+  enumerable: true,
+  get: function () { return sdkNode.NodeSDK; }
+});
+Object.defineProperty(exports, "ConsoleSpanExporter", {
+  enumerable: true,
+  get: function () { return sdkTraceNode.ConsoleSpanExporter; }
+});
+Object.defineProperty(exports, "getNodeAutoInstrumentations", {
+  enumerable: true,
+  get: function () { return autoInstrumentationsNode.getNodeAutoInstrumentations; }
+});
+Object.defineProperty(exports, "ATTR_SERVICE_NAME", {
+  enumerable: true,
+  get: function () { return semanticConventions.ATTR_SERVICE_NAME; }
+});
+Object.defineProperty(exports, "Resource", {
+  enumerable: true,
+  get: function () { return resources.Resource; }
+});
+Object.defineProperty(exports, "OTLPHttpExporter", {
+  enumerable: true,
+  get: function () { return exporterTraceOtlpHttp.OTLPTraceExporter; }
+});
+Object.defineProperty(exports, "AlwaysOffSampler", {
+  enumerable: true,
+  get: function () { return sdkTraceBase.AlwaysOffSampler; }
+});
+Object.defineProperty(exports, "AlwaysOnSampler", {
+  enumerable: true,
+  get: function () { return sdkTraceBase.AlwaysOnSampler; }
+});
+Object.defineProperty(exports, "ParentBasedSampler", {
+  enumerable: true,
+  get: function () { return sdkTraceBase.ParentBasedSampler; }
+});
+Object.defineProperty(exports, "TraceIdRatioBasedSampler", {
+  enumerable: true,
+  get: function () { return sdkTraceBase.TraceIdRatioBasedSampler; }
+});

package/dist/telemetry/otel-vendor.d.cts

@@ -0,0 +1,7 @@
+export { NodeSDK } from '@opentelemetry/sdk-node';
+export { ConsoleSpanExporter } from '@opentelemetry/sdk-trace-node';
+export { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+export { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+export { Resource } from '@opentelemetry/resources';
+export { OTLPTraceExporter as OTLPHttpExporter } from '@opentelemetry/exporter-trace-otlp-http';
+export { AlwaysOffSampler, AlwaysOnSampler, ParentBasedSampler, Sampler, TraceIdRatioBasedSampler } from '@opentelemetry/sdk-trace-base';

package/dist/telemetry/otel-vendor.d.ts

@@ -0,0 +1,7 @@
+export { NodeSDK } from '@opentelemetry/sdk-node';
+export { ConsoleSpanExporter } from '@opentelemetry/sdk-trace-node';
+export { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+export { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+export { Resource } from '@opentelemetry/resources';
+export { OTLPTraceExporter as OTLPHttpExporter } from '@opentelemetry/exporter-trace-otlp-http';
+export { AlwaysOffSampler, AlwaysOnSampler, ParentBasedSampler, Sampler, TraceIdRatioBasedSampler } from '@opentelemetry/sdk-trace-base';

package/dist/telemetry/otel-vendor.js

@@ -0,0 +1,7 @@
+export { NodeSDK } from '@opentelemetry/sdk-node';
+export { ConsoleSpanExporter } from '@opentelemetry/sdk-trace-node';
+export { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
+export { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+export { Resource } from '@opentelemetry/resources';
+export { OTLPTraceExporter as OTLPHttpExporter } from '@opentelemetry/exporter-trace-otlp-http';
+export { AlwaysOffSampler, AlwaysOnSampler, ParentBasedSampler, TraceIdRatioBasedSampler } from '@opentelemetry/sdk-trace-base';

package/dist/tools/index.cjs

@@ -0,0 +1,25 @@
+'use strict';
+
+// 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);
+}
+
+exports.Tool = Tool;
+exports.createTool = createTool;

package/dist/tools/index.d.cts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { o as ToolExecutionContext, m as ToolAction, g as MastraPrimitives } from '../base-nhesrHv3.cjs';
+export { U as CoreTool } from '../base-nhesrHv3.cjs';
+import 'ai';
+import '../base-hs9NDAZ2.cjs';
+import '@opentelemetry/api';
+import '../index-mKY1XrpK.cjs';
+import 'stream';
+import 'pino';
+import '@opentelemetry/sdk-trace-base';
+import 'sift';
+import 'json-schema';
+import '../types-m9RryK9a.cjs';
+import '../vector/index.cjs';
+import '../voice/index.cjs';
+import '../tts/index.cjs';
+
+declare class Tool<TId extends string, TSchemaIn extends z.ZodSchema | undefined = undefined, TSchemaOut extends z.ZodSchema | undefined = undefined, TContext extends ToolExecutionContext<TSchemaIn> = ToolExecutionContext<TSchemaIn>> implements ToolAction<TId, TSchemaIn, TSchemaOut, TContext> {
+    id: TId;
+    description?: string;
+    inputSchema?: TSchemaIn;
+    outputSchema?: TSchemaOut;
+    execute?: (context: TContext) => Promise<TSchemaOut extends z.ZodSchema ? z.infer<TSchemaOut> : unknown>;
+    mastra?: MastraPrimitives;
+    constructor(opts: ToolAction<TId, TSchemaIn, TSchemaOut, TContext>);
+}
+declare function createTool<TId extends string, TSchemaIn extends z.ZodSchema | undefined = undefined, TSchemaOut extends z.ZodSchema | undefined = undefined, TContext extends ToolExecutionContext<TSchemaIn> = ToolExecutionContext<TSchemaIn>>(opts: ToolAction<TId, TSchemaIn, TSchemaOut, TContext>): Tool<TId, TSchemaIn, TSchemaOut, TContext>;
+
+export { Tool, ToolAction, ToolExecutionContext, createTool };

package/dist/tools/index.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { o as ToolExecutionContext, m as ToolAction, g as MastraPrimitives } from '../base-nKCMCNrM.js';
+export { U as CoreTool } from '../base-nKCMCNrM.js';
+import 'ai';
+import '../base-D90KQ4XI.js';
+import '@opentelemetry/api';
+import '../index-mKY1XrpK.js';
+import 'stream';
+import 'pino';
+import '@opentelemetry/sdk-trace-base';
+import 'sift';
+import 'json-schema';
+import '../types-m9RryK9a.js';
+import '../vector/index.js';
+import '../voice/index.js';
+import '../tts/index.js';
+
+declare class Tool<TId extends string, TSchemaIn extends z.ZodSchema | undefined = undefined, TSchemaOut extends z.ZodSchema | undefined = undefined, TContext extends ToolExecutionContext<TSchemaIn> = ToolExecutionContext<TSchemaIn>> implements ToolAction<TId, TSchemaIn, TSchemaOut, TContext> {
+    id: TId;
+    description?: string;
+    inputSchema?: TSchemaIn;
+    outputSchema?: TSchemaOut;
+    execute?: (context: TContext) => Promise<TSchemaOut extends z.ZodSchema ? z.infer<TSchemaOut> : unknown>;
+    mastra?: MastraPrimitives;
+    constructor(opts: ToolAction<TId, TSchemaIn, TSchemaOut, TContext>);
+}
+declare function createTool<TId extends string, TSchemaIn extends z.ZodSchema | undefined = undefined, TSchemaOut extends z.ZodSchema | undefined = undefined, TContext extends ToolExecutionContext<TSchemaIn> = ToolExecutionContext<TSchemaIn>>(opts: ToolAction<TId, TSchemaIn, TSchemaOut, TContext>): Tool<TId, TSchemaIn, TSchemaOut, TContext>;
+
+export { Tool, ToolAction, ToolExecutionContext, createTool };

package/dist/tools/index.js

@@ -0,0 +1 @@
+export { Tool, createTool } from '../chunk-ZINPRHAN.js';

package/dist/tts/index.cjs

@@ -0,0 +1,328 @@
+'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/tts/index.ts
+var _MastraTTS_decorators, _init, _a;
+_MastraTTS_decorators = [InstrumentClass({
+  prefix: "tts",
+  excludeMethods: ["__setTools", "__setLogger", "__setTelemetry", "#log"]
+})];
+exports.MastraTTS = class MastraTTS extends (_a = MastraBase) {
+  model;
+  constructor({
+    model
+  }) {
+    super({
+      component: "TTS"
+    });
+    this.model = model;
+  }
+  traced(method, methodName) {
+    return this.telemetry?.traceMethod(method, {
+      spanName: `${this.model.name}-tts.${methodName}`,
+      attributes: {
+        "tts.type": `${this.model.name}`
+      }
+    }) ?? method;
+  }
+};
+exports.MastraTTS = /*@__PURE__*/(_ => {
+  _init = __decoratorStart(_a);
+  exports.MastraTTS = __decorateElement(_init, 0, "MastraTTS", _MastraTTS_decorators, exports.MastraTTS);
+  __runInitializers(_init, 1, exports.MastraTTS);
+  return exports.MastraTTS;
+})();

package/dist/tts/index.d.cts

@@ -0,0 +1,28 @@
+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 {
+    provider: string;
+    name: string;
+    apiKey?: string;
+}
+interface TTSConfig {
+    model: BuiltInModelConfig;
+}
+declare abstract class MastraTTS extends MastraBase {
+    model: BuiltInModelConfig;
+    constructor({ model }: TTSConfig);
+    traced<T extends Function>(method: T, methodName: string): T;
+    abstract generate({ text }: {
+        text: string;
+    }): Promise<any>;
+    abstract stream({ text }: {
+        text: string;
+    }): Promise<any>;
+}
+
+export { MastraTTS, type TTSConfig };

package/dist/tts/index.d.ts

@@ -0,0 +1,28 @@
+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 {
+    provider: string;
+    name: string;
+    apiKey?: string;
+}
+interface TTSConfig {
+    model: BuiltInModelConfig;
+}
+declare abstract class MastraTTS extends MastraBase {
+    model: BuiltInModelConfig;
+    constructor({ model }: TTSConfig);
+    traced<T extends Function>(method: T, methodName: string): T;
+    abstract generate({ text }: {
+        text: string;
+    }): Promise<any>;
+    abstract stream({ text }: {
+        text: string;
+    }): Promise<any>;
+}
+
+export { MastraTTS, type TTSConfig };

package/dist/tts/index.js

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

package/dist/types-m9RryK9a.d.cts

@@ -0,0 +1,14 @@
+interface MetricResult {
+    score: number;
+    info?: Record<string, any>;
+}
+declare abstract class Metric {
+    abstract measure(input: string, output: string): Promise<MetricResult>;
+}
+
+interface TestInfo {
+    testName?: string;
+    testPath?: string;
+}
+
+export { type MetricResult as M, type TestInfo as T, Metric as a };

package/dist/types-m9RryK9a.d.ts

@@ -0,0 +1,14 @@
+interface MetricResult {
+    score: number;
+    info?: Record<string, any>;
+}
+declare abstract class Metric {
+    abstract measure(input: string, output: string): Promise<MetricResult>;
+}
+
+interface TestInfo {
+    testName?: string;
+    testPath?: string;
+}
+
+export { type MetricResult as M, type TestInfo as T, Metric as a };