@mastra/core 0.5.0-alpha.8 → 0.5.0

package/dist/chunk-XB2TJ7LX.cjs

@@ -0,0 +1,408 @@
+'use strict';
+
+var chunkF5UYWPV4_cjs = require('./chunk-F5UYWPV4.cjs');
+var api = require('@opentelemetry/api');
+var core = require('@opentelemetry/core');
+var otlpTransformer = require('@opentelemetry/otlp-transformer');
+
+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;
+  };
+}
+var OTLPTraceExporter = class {
+  storage;
+  queue = [];
+  serializer;
+  logger;
+  activeFlush = void 0;
+  constructor({ logger, storage }) {
+    this.storage = storage;
+    this.serializer = otlpTransformer.JsonTraceSerializer;
+    this.logger = logger;
+  }
+  export(internalRepresentation, resultCallback) {
+    const serializedRequest = this.serializer.serializeRequest(internalRepresentation);
+    const payload = JSON.parse(Buffer.from(serializedRequest.buffer, "utf8"));
+    const items = payload?.resourceSpans?.[0]?.scopeSpans;
+    this.logger.debug(`Exporting telemetry: ${items.length} scope spans to be processed [trace batch]`);
+    this.queue.push({ data: items, resultCallback });
+    if (!this.activeFlush) {
+      this.activeFlush = this.flush();
+    }
+  }
+  shutdown() {
+    return this.forceFlush();
+  }
+  flush() {
+    const now = /* @__PURE__ */ new Date();
+    const items = this.queue.shift();
+    if (!items) return Promise.resolve();
+    const allSpans = items.data.reduce((acc, scopedSpans) => {
+      const { scope, spans } = scopedSpans;
+      for (const span of spans) {
+        const {
+          spanId,
+          parentSpanId,
+          traceId,
+          name,
+          kind,
+          attributes,
+          status,
+          events,
+          links,
+          startTimeUnixNano,
+          endTimeUnixNano,
+          ...rest
+        } = span;
+        const startTime = Number(BigInt(startTimeUnixNano) / 1000n);
+        const endTime = Number(BigInt(endTimeUnixNano) / 1000n);
+        acc.push({
+          id: spanId,
+          parentSpanId,
+          traceId,
+          name,
+          scope: scope.name,
+          kind,
+          status: JSON.stringify(status),
+          events: JSON.stringify(events),
+          links: JSON.stringify(links),
+          attributes: JSON.stringify(
+            attributes.reduce((acc2, attr) => {
+              const valueKey = Object.keys(attr.value)[0];
+              if (valueKey) {
+                acc2[attr.key] = attr.value[valueKey];
+              }
+              return acc2;
+            }, {})
+          ),
+          startTime,
+          endTime,
+          other: JSON.stringify(rest),
+          createdAt: now
+        });
+      }
+      return acc;
+    }, []);
+    return this.storage.__batchInsert({
+      tableName: chunkF5UYWPV4_cjs.TABLE_TRACES,
+      records: allSpans
+    }).then(() => {
+      items.resultCallback({
+        code: core.ExportResultCode.SUCCESS
+      });
+    }).catch((e) => {
+      this.logger.error("span err:" + e?.message);
+      items.resultCallback({
+        code: core.ExportResultCode.FAILED,
+        error: e
+      });
+    }).finally(() => {
+      this.activeFlush = void 0;
+    });
+  }
+  async forceFlush() {
+    if (!this.queue.length) {
+      return;
+    }
+    await this.activeFlush;
+    while (this.queue.length) {
+      await this.flush();
+    }
+  }
+  __setLogger(logger) {
+    this.logger = logger;
+  }
+};
+var Telemetry = class _Telemetry {
+  tracer = api.trace.getTracer("default");
+  name = "default-service";
+  constructor(config) {
+    this.name = config.serviceName ?? "default-service";
+    this.tracer = api.trace.getTracer(this.name);
+  }
+  /**
+   * @deprecated This method does not do anything
+   */
+  async shutdown() {
+  }
+  /**
+   * Initialize telemetry with the given configuration
+   * @param config - Optional telemetry configuration object
+   * @returns Telemetry instance that can be used for tracing
+   */
+  static init(config = {}) {
+    try {
+      if (!global.__TELEMETRY__) {
+        global.__TELEMETRY__ = new _Telemetry(config);
+      }
+      return global.__TELEMETRY__;
+    } catch (error) {
+      console.error("Failed to initialize telemetry:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get the global telemetry instance
+   * @throws {Error} If telemetry has not been initialized
+   * @returns {Telemetry} The global telemetry instance
+   */
+  static get() {
+    if (!global.__TELEMETRY__) {
+      throw new Error("Telemetry not initialized");
+    }
+    return global.__TELEMETRY__;
+  }
+  /**
+   * Wraps a class instance with telemetry tracing
+   * @param instance The class instance to wrap
+   * @param options Optional configuration for tracing
+   * @returns Wrapped instance with all methods traced
+   */
+  traceClass(instance, options = {}) {
+    const { skipIfNoTelemetry = true } = options;
+    if (skipIfNoTelemetry && !hasActiveTelemetry()) {
+      return instance;
+    }
+    const { spanNamePrefix = instance.constructor.name.toLowerCase(), attributes = {}, excludeMethods = [] } = options;
+    return new Proxy(instance, {
+      get: (target, prop) => {
+        const value = target[prop];
+        if (typeof value === "function" && prop !== "constructor" && !prop.toString().startsWith("_") && !excludeMethods.includes(prop.toString())) {
+          return this.traceMethod(value.bind(target), {
+            spanName: `${spanNamePrefix}.${prop.toString()}`,
+            attributes: {
+              ...attributes,
+              [`${spanNamePrefix}.name`]: target.constructor.name,
+              [`${spanNamePrefix}.method.name`]: prop.toString()
+            }
+          });
+        }
+        return value;
+      }
+    });
+  }
+  /**
+   * method to trace individual methods with proper context
+   * @param method The method to trace
+   * @param context Additional context for the trace
+   * @returns Wrapped method with tracing
+   */
+  traceMethod(method, context3) {
+    let ctx = api.context.active();
+    const { skipIfNoTelemetry = true } = context3;
+    if (skipIfNoTelemetry && !hasActiveTelemetry()) {
+      return method;
+    }
+    return (...args) => {
+      const span = this.tracer.startSpan(context3.spanName);
+      function handleError(error) {
+        span.recordException(error);
+        span.setStatus({
+          code: api.SpanStatusCode.ERROR,
+          message: error.message
+        });
+        span.end();
+        throw error;
+      }
+      try {
+        let recordResult2 = function(res) {
+          try {
+            span.setAttribute(`${context3.spanName}.result`, JSON.stringify(res));
+          } catch {
+            span.setAttribute(`${context3.spanName}.result`, "[Not Serializable]");
+          }
+          span.end();
+          return res;
+        };
+        if (context3.attributes) {
+          span.setAttributes(context3.attributes);
+        }
+        if (context3.attributes?.componentName) {
+          ctx = api.propagation.setBaggage(ctx, {
+            // @ts-ignore
+            componentName: context3.attributes.componentName,
+            runId: context3.attributes.runId
+          });
+        } else {
+          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 });
+          }
+        }
+        args.forEach((arg, index) => {
+          try {
+            span.setAttribute(`${context3.spanName}.argument.${index}`, JSON.stringify(arg));
+          } catch {
+            span.setAttribute(`${context3.spanName}.argument.${index}`, "[Not Serializable]");
+          }
+        });
+        let result;
+        api.context.with(api.trace.setSpan(ctx, span), () => {
+          result = method(...args);
+        });
+        if (result instanceof Promise) {
+          return result.then(recordResult2).catch(handleError);
+        } else {
+          return recordResult2(result);
+        }
+      } catch (error) {
+        handleError(error);
+      }
+    };
+  }
+  getBaggageTracer() {
+    return new BaggageTracer(this.tracer);
+  }
+};
+var BaggageTracer = class {
+  _tracer;
+  constructor(tracer) {
+    this._tracer = tracer;
+  }
+  startSpan(name, options = {}, ctx) {
+    ctx = ctx ?? api.context.active();
+    const span = this._tracer.startSpan(name, options, ctx);
+    const currentBaggage = api.propagation.getBaggage(ctx);
+    span.setAttribute("componentName", currentBaggage?.componentName);
+    span.setAttribute("runId", currentBaggage?.runId);
+    return span;
+  }
+  startActiveSpan(name, optionsOrFn, ctxOrFn, fn) {
+    if (typeof optionsOrFn === "function") {
+      const wrappedFn2 = (span) => {
+        const currentBaggage = api.propagation.getBaggage(api.context.active());
+        span.setAttribute("componentName", currentBaggage?.componentName);
+        return optionsOrFn(span);
+      };
+      return this._tracer.startActiveSpan(name, {}, api.context.active(), wrappedFn2);
+    }
+    if (typeof ctxOrFn === "function") {
+      const wrappedFn2 = (span) => {
+        const currentBaggage = api.propagation.getBaggage(api.context.active());
+        span.setAttribute("componentName", currentBaggage?.componentName);
+        return ctxOrFn(span);
+      };
+      return this._tracer.startActiveSpan(name, optionsOrFn, api.context.active(), wrappedFn2);
+    }
+    const wrappedFn = (span) => {
+      const currentBaggage = api.propagation.getBaggage(ctxOrFn ?? api.context.active());
+      span.setAttribute("componentName", currentBaggage?.componentName);
+      return fn(span);
+    };
+    return this._tracer.startActiveSpan(name, optionsOrFn, ctxOrFn, wrappedFn);
+  }
+};
+
+exports.InstrumentClass = InstrumentClass;
+exports.OTLPTraceExporter = OTLPTraceExporter;
+exports.Telemetry = Telemetry;
+exports.hasActiveTelemetry = hasActiveTelemetry;
+exports.withSpan = withSpan;

package/dist/{chunk-QABMKXI3.js → chunk-XF2FMJYK.js}

@@ -1,4 +1,4 @@
-import { Agent } from './chunk-SWDQYPJS.js';
+import { Agent } from './chunk-KP5UAFLN.js';
 import { CohereClient } from 'cohere-ai';
 
 var CohereRelevanceScorer = class {

package/dist/chunk-XLSROQ26.cjs

@@ -0,0 +1,91 @@
+'use strict';
+
+var chunk2W2GYEYQ_cjs = require('./chunk-2W2GYEYQ.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, ...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 = chunk2W2GYEYQ_cjs.createTool({
+        id: key,
+        inputSchema: schemas[key] || zod.z.object({}),
+        description: comment || fallbackComment,
+        // documentation: doc || fallbackComment,
+        execute: async ({ context }) => {
+          const client2 = await this.getApiClient();
+          const value = client2[key];
+          return value({
+            ...context
+          });
+        }
+      });
+      return { ...acc, [key]: tool };
+    }, {});
+    return tools;
+  }
+};
+
+exports.Integration = Integration;
+exports.OpenAPIToolset = OpenAPIToolset;

package/dist/chunk-YK3XJ52U.cjs

@@ -0,0 +1,192 @@
+'use strict';
+
+// src/vector/filter/base.ts
+var BaseFilterTranslator = class _BaseFilterTranslator {
+  /**
+   * Operator type checks
+   */
+  isOperator(key) {
+    return key.startsWith("$");
+  }
+  static BASIC_OPERATORS = ["$eq", "$ne"];
+  static NUMERIC_OPERATORS = ["$gt", "$gte", "$lt", "$lte"];
+  static ARRAY_OPERATORS = ["$in", "$nin", "$all", "$elemMatch"];
+  static LOGICAL_OPERATORS = ["$and", "$or", "$not", "$nor"];
+  static ELEMENT_OPERATORS = ["$exists"];
+  static REGEX_OPERATORS = ["$regex", "$options"];
+  static DEFAULT_OPERATORS = {
+    logical: _BaseFilterTranslator.LOGICAL_OPERATORS,
+    basic: _BaseFilterTranslator.BASIC_OPERATORS,
+    numeric: _BaseFilterTranslator.NUMERIC_OPERATORS,
+    array: _BaseFilterTranslator.ARRAY_OPERATORS,
+    element: _BaseFilterTranslator.ELEMENT_OPERATORS,
+    regex: _BaseFilterTranslator.REGEX_OPERATORS
+  };
+  isLogicalOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.logical.includes(key);
+  }
+  isBasicOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.basic.includes(key);
+  }
+  isNumericOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.numeric.includes(key);
+  }
+  isArrayOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.array.includes(key);
+  }
+  isElementOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.element.includes(key);
+  }
+  isRegexOperator(key) {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS.regex.includes(key);
+  }
+  isFieldOperator(key) {
+    return this.isOperator(key) && !this.isLogicalOperator(key);
+  }
+  isCustomOperator(key) {
+    const support = this.getSupportedOperators();
+    return support.custom?.includes(key) ?? false;
+  }
+  getSupportedOperators() {
+    return _BaseFilterTranslator.DEFAULT_OPERATORS;
+  }
+  isValidOperator(key) {
+    const support = this.getSupportedOperators();
+    const allSupported = Object.values(support).flat();
+    return allSupported.includes(key);
+  }
+  /**
+   * Value normalization for comparison operators
+   */
+  normalizeComparisonValue(value) {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (typeof value === "number" && Object.is(value, -0)) {
+      return 0;
+    }
+    return value;
+  }
+  /**
+   * Helper method to simulate $all operator using $and + $eq when needed.
+   * Some vector stores don't support $all natively.
+   */
+  simulateAllOperator(field, values) {
+    return {
+      $and: values.map((value) => ({
+        [field]: { $in: [this.normalizeComparisonValue(value)] }
+      }))
+    };
+  }
+  /**
+   * Utility functions for type checking
+   */
+  isPrimitive(value) {
+    return value === null || value === void 0 || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+  }
+  isRegex(value) {
+    return value instanceof RegExp;
+  }
+  isEmpty(obj) {
+    return obj === null || obj === void 0 || typeof obj === "object" && Object.keys(obj).length === 0;
+  }
+  static ErrorMessages = {
+    UNSUPPORTED_OPERATOR: (op) => `Unsupported operator: ${op}`,
+    INVALID_LOGICAL_OPERATOR_LOCATION: (op, path) => `Logical operator ${op} cannot be used at field level: ${path}`,
+    NOT_REQUIRES_OBJECT: `$not operator requires an object`,
+    NOT_CANNOT_BE_EMPTY: `$not operator cannot be empty`,
+    INVALID_LOGICAL_OPERATOR_CONTENT: (path) => `Logical operators must contain field conditions, not direct operators: ${path}`,
+    INVALID_TOP_LEVEL_OPERATOR: (op) => `Invalid top-level operator: ${op}`,
+    ELEM_MATCH_REQUIRES_OBJECT: `$elemMatch requires an object with conditions`
+  };
+  /**
+   * Helper to handle array value normalization consistently
+   */
+  normalizeArrayValues(values) {
+    return values.map((value) => this.normalizeComparisonValue(value));
+  }
+  validateFilter(filter) {
+    const validation = this.validateFilterSupport(filter);
+    if (!validation.supported) {
+      throw new Error(validation.messages.join(", "));
+    }
+  }
+  /**
+   * Validates if a filter structure is supported by the specific vector DB
+   * and returns detailed validation information.
+   */
+  validateFilterSupport(node, path = "") {
+    const messages = [];
+    if (this.isPrimitive(node) || this.isEmpty(node)) {
+      return { supported: true, messages: [] };
+    }
+    if (Array.isArray(node)) {
+      const arrayResults = node.map((item) => this.validateFilterSupport(item, path));
+      const arrayMessages = arrayResults.flatMap((r) => r.messages);
+      return {
+        supported: arrayResults.every((r) => r.supported),
+        messages: arrayMessages
+      };
+    }
+    const nodeObj = node;
+    let isSupported = true;
+    for (const [key, value] of Object.entries(nodeObj)) {
+      const newPath = path ? `${path}.${key}` : key;
+      if (this.isOperator(key)) {
+        if (!this.isValidOperator(key)) {
+          isSupported = false;
+          messages.push(_BaseFilterTranslator.ErrorMessages.UNSUPPORTED_OPERATOR(key));
+          continue;
+        }
+        if (!path && !this.isLogicalOperator(key)) {
+          isSupported = false;
+          messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_TOP_LEVEL_OPERATOR(key));
+          continue;
+        }
+        if (key === "$elemMatch" && (typeof value !== "object" || Array.isArray(value))) {
+          isSupported = false;
+          messages.push(_BaseFilterTranslator.ErrorMessages.ELEM_MATCH_REQUIRES_OBJECT);
+          continue;
+        }
+        if (this.isLogicalOperator(key)) {
+          if (key === "$not") {
+            if (Array.isArray(value) || typeof value !== "object") {
+              isSupported = false;
+              messages.push(_BaseFilterTranslator.ErrorMessages.NOT_REQUIRES_OBJECT);
+              continue;
+            }
+            if (this.isEmpty(value)) {
+              isSupported = false;
+              messages.push(_BaseFilterTranslator.ErrorMessages.NOT_CANNOT_BE_EMPTY);
+              continue;
+            }
+            continue;
+          }
+          if (path && !this.isLogicalOperator(path.split(".").pop())) {
+            isSupported = false;
+            messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_LOGICAL_OPERATOR_LOCATION(key, newPath));
+            continue;
+          }
+          if (Array.isArray(value)) {
+            const hasDirectOperators = value.some(
+              (item) => typeof item === "object" && Object.keys(item).length === 1 && this.isFieldOperator(Object.keys(item)[0])
+            );
+            if (hasDirectOperators) {
+              isSupported = false;
+              messages.push(_BaseFilterTranslator.ErrorMessages.INVALID_LOGICAL_OPERATOR_CONTENT(newPath));
+              continue;
+            }
+          }
+        }
+      }
+      const nestedValidation = this.validateFilterSupport(value, newPath);
+      if (!nestedValidation.supported) {
+        isSupported = false;
+        messages.push(...nestedValidation.messages);
+      }
+    }
+    return { supported: isSupported, messages };
+  }
+};
+
+exports.BaseFilterTranslator = BaseFilterTranslator;