@mastra/core 0.2.0-alpha.99 → 0.2.1-alpha.0

package/dist/chunk-4ZUSEHLH.js

@@ -1,285 +0,0 @@
-import { __name, __publicField } from './chunk-AJJZUHB4.js';
-import { trace, context, SpanStatusCode, SpanKind } from '@opentelemetry/api';
-import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
-import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
-import { Resource } from '@opentelemetry/resources';
-import { NodeSDK } from '@opentelemetry/sdk-node';
-import { ConsoleSpanExporter, AlwaysOnSampler, AlwaysOffSampler, TraceIdRatioBasedSampler, ParentBasedSampler } from '@opentelemetry/sdk-trace-base';
-import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
-
-function hasActiveTelemetry() {
-  try {
-    return !!trace.getTracer("default-tracer");
-  } catch {
-    return false;
-  }
-}
-__name(hasActiveTelemetry, "hasActiveTelemetry");
-
-// 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()) {
-        return originalMethod.apply(this, args);
-      }
-      const tracer = trace.getTracer("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
-      });
-      const ctx = trace.setSpan(context.active(), span);
-      args.forEach((arg, index) => {
-        try {
-          span.setAttribute(`${spanName}.argument.${index}`, JSON.stringify(arg));
-        } catch (e) {
-          span.setAttribute(`${spanName}.argument.${index}`, "[Not Serializable]");
-        }
-      });
-      let result;
-      try {
-        result = context.with(ctx, () => originalMethod.apply(this, args));
-        if (result instanceof Promise) {
-          return result.then((resolvedValue) => {
-            try {
-              span.setAttribute(`${spanName}.result`, JSON.stringify(resolvedValue));
-            } catch (e) {
-              span.setAttribute(`${spanName}.result`, "[Not Serializable]");
-            }
-            return resolvedValue;
-          }).finally(() => span.end());
-        }
-        try {
-          span.setAttribute(`${spanName}.result`, JSON.stringify(result));
-        } catch (e) {
-          span.setAttribute(`${spanName}.result`, "[Not Serializable]");
-        }
-        return result;
-      } catch (error) {
-        span.setStatus({
-          code: 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;
-  };
-}
-__name(withSpan, "withSpan");
-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 || SpanKind.INTERNAL
-        })(target, method, descriptor));
-      }
-    });
-    return target;
-  };
-}
-__name(InstrumentClass, "InstrumentClass");
-var sdkInstance = null;
-var _Telemetry = class _Telemetry {
-  constructor(config) {
-    __publicField(this, "sdk", null);
-    __publicField(this, "tracer", trace.getTracer("default"));
-    __publicField(this, "name", "default-service");
-    this.name = config.serviceName ?? "default-service";
-    if (typeof window === "undefined") {
-      if (process.env.NODE_ENV === "development" || !sdkInstance) {
-        if (sdkInstance) {
-          this.shutdown();
-        }
-        const exporter = config.export?.type === "otlp" ? new OTLPTraceExporter({
-          url: config.export.endpoint,
-          headers: config.export.headers
-        }) : config.export?.type === "custom" ? config.export.exporter : new ConsoleSpanExporter();
-        const sampler = this.getSampler(config);
-        sdkInstance = new NodeSDK({
-          resource: new Resource({
-            [ATTR_SERVICE_NAME]: this.name
-          }),
-          traceExporter: exporter,
-          sampler,
-          instrumentations: [
-            getNodeAutoInstrumentations()
-          ]
-        });
-        try {
-          sdkInstance.start();
-          this.sdk = sdkInstance;
-          _Telemetry.isInitialized = true;
-        } catch (error) {
-          console.warn("Failed to initialize OpenTelemetry:", error);
-        }
-      }
-    }
-    this.tracer = trace.getTracer(this.name);
-  }
-  getSampler(config) {
-    if (!config.sampling) {
-      return new AlwaysOnSampler();
-    }
-    if (!config.enabled) {
-      return new AlwaysOffSampler();
-    }
-    switch (config.sampling.type) {
-      case "ratio":
-        return new TraceIdRatioBasedSampler(config.sampling.probability);
-      case "always_on":
-        return new AlwaysOnSampler();
-      case "always_off":
-        return new AlwaysOffSampler();
-      case "parent_based":
-        const rootSampler = new TraceIdRatioBasedSampler(config.sampling.root?.probability || 1);
-        return new ParentBasedSampler({
-          root: rootSampler
-        });
-      default:
-        return new AlwaysOnSampler();
-    }
-  }
-  async shutdown() {
-    if (this.sdk && _Telemetry.isInitialized) {
-      try {
-        await this.sdk.shutdown();
-        _Telemetry.isInitialized = false;
-        global.__OTEL_SDK__ = void 0;
-        global.__TELEMETRY__ = void 0;
-      } catch (error) {
-        console.warn("Error shutting down OpenTelemetry:", error);
-      }
-    }
-  }
-  /**
-  * 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: /* @__PURE__ */ __name((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;
-      }, "get")
-    });
-  }
-  /**
-  * 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, context2) {
-    const { skipIfNoTelemetry = true } = context2;
-    if (skipIfNoTelemetry && !hasActiveTelemetry()) {
-      return method;
-    }
-    return async (...args) => {
-      const span = this.tracer.startSpan(context2.spanName);
-      try {
-        if (context2.attributes) {
-          span.setAttributes(context2.attributes);
-        }
-        args.forEach((arg, index) => {
-          try {
-            span.setAttribute(`${context2.spanName}.argument.${index}`, JSON.stringify(arg));
-          } catch (e) {
-            span.setAttribute(`${context2.spanName}.argument.${index}`, "[Not Serializable]");
-          }
-        });
-        const result = await method(...args);
-        try {
-          span.setAttribute(`${context2.spanName}.result`, JSON.stringify(result));
-        } catch (e) {
-          span.setAttribute(`${context2.spanName}.result`, "[Not Serializable]");
-        }
-        span.end();
-        return result;
-      } catch (error) {
-        span.recordException(error);
-        span.setStatus({
-          code: SpanStatusCode.ERROR,
-          message: error.message
-        });
-        span.end();
-        throw error;
-      }
-    };
-  }
-};
-__name(_Telemetry, "Telemetry");
-__publicField(_Telemetry, "isInitialized", false);
-var Telemetry = _Telemetry;
-
-export { InstrumentClass, Telemetry, hasActiveTelemetry, withSpan };

package/dist/chunk-AJJZUHB4.js

@@ -1,14 +0,0 @@
-var __defProp = Object.defineProperty;
-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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
-
-export { __name, __privateAdd, __privateGet, __privateMethod, __privateSet, __publicField };

package/dist/chunk-G4MCO7XF.js

@@ -1,70 +0,0 @@
-import { RegisteredLogger, createLogger } from './chunk-ICMEXHKD.js';
-import { __name, __publicField } from './chunk-AJJZUHB4.js';
-
-// src/base.ts
-var _MastraBase = class _MastraBase {
-  constructor({ component, name }) {
-    __publicField(this, "component", RegisteredLogger.LLM);
-    __publicField(this, "logger");
-    __publicField(this, "name");
-    __publicField(this, "telemetry");
-    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 for ${this.component}:${this.name}`);
-  }
-  /**
-  * Internal logging helper that formats and sends logs to the configured logger
-  * @param level - Severity level of the log
-  * @param message - Main log message
-  * @param opts - Optional object for the log
-  */
-  log(level, message, opts) {
-    if (!this.logger) return;
-    const logMessage = {
-      type: this.component,
-      message,
-      destinationPath: this.name ? `${this.component}/${this.name}` : this.component,
-      ...opts || {}
-    };
-    const logMethod = level.toLowerCase();
-    this.logger[logMethod]?.(logMessage);
-  }
-  /**
-  * Set the telemetry for the
-  * @param telemetry
-  */
-  __setTelemetry(telemetry) {
-    this.telemetry = telemetry;
-    this.logger.debug(`Telemetry updated for ${this.component} ${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,
-      isEnabled: !!this.telemetry.tracer
-    } : undefined;
-  }
-};
-__name(_MastraBase, "MastraBase");
-var MastraBase = _MastraBase;
-
-export { MastraBase };

package/dist/chunk-HBTQNIAX.js

@@ -1,90 +0,0 @@
-import { __name } from './chunk-AJJZUHB4.js';
-
-// src/hooks/mitt.ts
-function mitt(all) {
-  all = all || /* @__PURE__ */ new Map();
-  return {
-    /**
-    * A Map of event names to registered handler functions.
-    */
-    all,
-    /**
-    * Register an event handler for the given type.
-    * @param {string|symbol} type Type of event to listen for, or `'*'` for all events
-    * @param {Function} handler Function to call in response to given event
-    * @memberOf mitt
-    */
-    on(type, handler) {
-      const handlers = all.get(type);
-      if (handlers) {
-        handlers.push(handler);
-      } else {
-        all.set(type, [
-          handler
-        ]);
-      }
-    },
-    /**
-    * Remove an event handler for the given type.
-    * If `handler` is omitted, all handlers of the given type are removed.
-    * @param {string|symbol} type Type of event to unregister `handler` from (`'*'` to remove a wildcard handler)
-    * @param {Function} [handler] Handler function to remove
-    * @memberOf mitt
-    */
-    off(type, handler) {
-      const handlers = all.get(type);
-      if (handlers) {
-        if (handler) {
-          handlers.splice(handlers.indexOf(handler) >>> 0, 1);
-        } else {
-          all.set(type, []);
-        }
-      }
-    },
-    /**
-    * Invoke all handlers for the given type.
-    * If present, `'*'` handlers are invoked after type-matched handlers.
-    *
-    * Note: Manually firing '*' handlers is not supported.
-    *
-    * @param {string|symbol} type The event type to invoke
-    * @param {Any} [evt] Any value (object is recommended and powerful), passed to each handler
-    * @memberOf mitt
-    */
-    emit(type, evt) {
-      let handlers = all.get(type);
-      if (handlers) {
-        handlers.slice().map((handler) => {
-          handler(evt);
-        });
-      }
-      handlers = all.get("*");
-      if (handlers) {
-        handlers.slice().map((handler) => {
-          handler(type, evt);
-        });
-      }
-    }
-  };
-}
-__name(mitt, "mitt");
-
-// src/hooks/index.ts
-var AvailableHooks = /* @__PURE__ */ function(AvailableHooks2) {
-  AvailableHooks2["ON_EVALUATION"] = "onEvaluation";
-  AvailableHooks2["ON_GENERATION"] = "onGeneration";
-  return AvailableHooks2;
-}({});
-var hooks = mitt();
-function registerHook(hook, action) {
-  hooks.on(hook, action);
-}
-__name(registerHook, "registerHook");
-function executeHook(hook, data) {
-  setImmediate(() => {
-    hooks.emit(hook, data);
-  });
-}
-__name(executeHook, "executeHook");
-
-export { AvailableHooks, executeHook, registerHook };

package/dist/chunk-HPXWJBQK.js

@@ -1,222 +0,0 @@
-import { DefaultStorage } from './chunk-Z7JFMQZZ.js';
-import { deepMerge } from './chunk-KNPBNSJ7.js';
-import { MastraBase } from './chunk-G4MCO7XF.js';
-import { __name, __publicField } from './chunk-AJJZUHB4.js';
-
-// src/memory/index.ts
-var _MastraMemory = class _MastraMemory extends MastraBase {
-  constructor(config) {
-    super({
-      component: "MEMORY",
-      name: config.name
-    });
-    __publicField(this, "MAX_CONTEXT_TOKENS");
-    __publicField(this, "storage");
-    __publicField(this, "vector");
-    __publicField(this, "embedder");
-    __publicField(this, "threadConfig", {
-      lastMessages: 40,
-      semanticRecall: false
-    });
-    this.storage = config.storage || new DefaultStorage({
-      config: {
-        url: "file:memory.db"
-      }
-    });
-    if (config.vector) {
-      this.vector = config.vector;
-      this.threadConfig.semanticRecall = true;
-    }
-    if (config.embedder) {
-      this.embedder = config.embedder;
-    }
-    if (config.options) {
-      this.threadConfig = this.getMergedThreadConfig(config.options);
-    }
-  }
-  /**
-  * 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;
-  }
-  async createEmbeddingIndex() {
-    if (!this.vector) {
-      throw new Error(`Cannot call MastraMemory.createEmbeddingIndex() without a vector db attached.`);
-    }
-    const defaultDimensions = 1536;
-    const dimensionsByModelId = {
-      "bge-small-en-v1.5": 384,
-      "bge-base-en-v1.5": 768
-    };
-    const dimensions = dimensionsByModelId[this.getEmbedder().modelId] || defaultDimensions;
-    const isDefault = dimensions === defaultDimensions;
-    const indexName = isDefault ? "memory_messages" : `memory_messages_${dimensions}`;
-    await this.vector.createIndex(indexName, dimensions);
-    return {
-      indexName
-    };
-  }
-  getEmbedder() {
-    if (!this.embedder) {
-      throw new Error(`Cannot use vector features without setting new Memory({ embedder: embedderInstance })
-
-For example:
-
-new Memory({
-  vector,
-  embedder: openai("text-embedding-3-small") // example
-});
-`);
-    }
-    return this.embedder;
-  }
-  getMergedThreadConfig(config) {
-    return deepMerge(this.threadConfig, config || {});
-  }
-  estimateTokens(text) {
-    return Math.ceil(text.split(" ").length * 1.3);
-  }
-  parseMessages(messages) {
-    return messages.map((msg) => ({
-      ...msg,
-      content: typeof msg.content === "string" && (msg.content.startsWith("[") || msg.content.startsWith("{")) ? JSON.parse(msg.content) : msg.content
-    }));
-  }
-  convertToUIMessages(messages) {
-    function addToolMessageToChat({ toolMessage, messages: messages2, toolResultContents }) {
-      const chatMessages2 = messages2.map((message) => {
-        if (message.toolInvocations) {
-          return {
-            ...message,
-            toolInvocations: message.toolInvocations.map((toolInvocation) => {
-              const toolResult = toolMessage.content.find((tool) => tool.toolCallId === toolInvocation.toolCallId);
-              if (toolResult) {
-                return {
-                  ...toolInvocation,
-                  state: "result",
-                  result: toolResult.result
-                };
-              }
-              return toolInvocation;
-            })
-          };
-        }
-        return message;
-      });
-      const resultContents = [
-        ...toolResultContents,
-        ...toolMessage.content
-      ];
-      return {
-        chatMessages: chatMessages2,
-        toolResultContents: resultContents
-      };
-    }
-    __name(addToolMessageToChat, "addToolMessageToChat");
-    const { chatMessages } = messages.reduce((obj, message) => {
-      if (message.role === "tool") {
-        return addToolMessageToChat({
-          toolMessage: message,
-          messages: obj.chatMessages,
-          toolResultContents: obj.toolResultContents
-        });
-      }
-      let textContent = "";
-      let toolInvocations = [];
-      if (typeof message.content === "string") {
-        textContent = message.content;
-      } else if (Array.isArray(message.content)) {
-        for (const content of message.content) {
-          if (content.type === "text") {
-            textContent += content.text;
-          } else if (content.type === "tool-call") {
-            const toolResult = obj.toolResultContents.find((tool) => tool.toolCallId === content.toolCallId);
-            toolInvocations.push({
-              state: toolResult ? "result" : "call",
-              toolCallId: content.toolCallId,
-              toolName: content.toolName,
-              args: content.args,
-              result: toolResult?.result
-            });
-          }
-        }
-      }
-      obj.chatMessages.push({
-        id: message.id,
-        role: message.role,
-        content: textContent,
-        toolInvocations
-      });
-      return obj;
-    }, {
-      chatMessages: [],
-      toolResultContents: []
-    });
-    return chatMessages;
-  }
-  /**
-  * 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",
-      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
-  */
-  async addMessage({ threadId, config, content, role, type, toolNames, toolCallArgs, toolCallIds }) {
-    const message = {
-      id: this.generateId(),
-      content,
-      role,
-      createdAt: /* @__PURE__ */ new Date(),
-      threadId,
-      type,
-      toolNames,
-      toolCallArgs,
-      toolCallIds
-    };
-    const savedMessages = await this.saveMessages({
-      messages: [
-        message
-      ],
-      memoryConfig: config
-    });
-    return savedMessages[0];
-  }
-  /**
-  * Generates a unique identifier
-  * @returns A unique string ID
-  */
-  generateId() {
-    return crypto.randomUUID();
-  }
-};
-__name(_MastraMemory, "MastraMemory");
-var MastraMemory = _MastraMemory;
-
-export { MastraMemory };

package/dist/chunk-JJ57BXQR.js

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