@mastra/core 0.5.0-alpha.8 → 0.5.0

package/dist/agent/index.cjs

@@ -1,2107 +1,10 @@
 'use strict';
 
-var crypto$1 = require('crypto');
-var stream = require('stream');
-var pino = require('pino');
-var pretty = require('pino-pretty');
-var ai = require('ai');
-var zod = require('zod');
-var jsonSchemaToZod = require('json-schema-to-zod');
-var api = require('@opentelemetry/api');
+var chunk3ASEZT7U_cjs = require('../chunk-3ASEZT7U.cjs');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var pino__default = /*#__PURE__*/_interopDefault(pino);
-var pretty__default = /*#__PURE__*/_interopDefault(pretty);
-var jsonSchemaToZod__default = /*#__PURE__*/_interopDefault(jsonSchemaToZod);
 
-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, {
+Object.defineProperty(exports, "Agent", {
   enumerable: true,
-  configurable: true,
-  writable: true,
-  value
-}) : obj[key] = value;
-var __name = (target, value) => __defProp(target, "name", {
-  value,
-  configurable: true
+  get: function () { return chunk3ASEZT7U_cjs.Agent; }
 });
-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 = {
-  AGENT: "AGENT",
-  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,
-      formatters: {
-        level: label => {
-          return {
-            level: label
-          };
-        }
-      }
-    }, 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;
-  }
-};
-
-// 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);
-        });
-      }
-    }
-  };
-}
-
-// src/hooks/index.ts
-var hooks = mitt();
-function executeHook(hook, data) {
-  setImmediate(() => {
-    hooks.emit(hook, data);
-  });
-}
-
-// src/llm/model/base.ts
-var MastraLLMBase = class extends MastraBase {
-  // @ts-ignore
-  #mastra;
-  #model;
-  constructor({
-    name,
-    model
-  }) {
-    super({
-      component: RegisteredLogger.LLM,
-      name
-    });
-    this.#model = model;
-  }
-  getProvider() {
-    return this.#model.provider;
-  }
-  getModelId() {
-    return this.#model.modelId;
-  }
-  getModel() {
-    return this.#model;
-  }
-  convertToMessages(messages) {
-    if (Array.isArray(messages)) {
-      return messages.map(m => {
-        if (typeof m === "string") {
-          return {
-            role: "user",
-            content: m
-          };
-        }
-        return m;
-      });
-    }
-    return [{
-      role: "user",
-      content: messages
-    }];
-  }
-  __registerPrimitives(p) {
-    if (p.telemetry) {
-      this.__setTelemetry(p.telemetry);
-    }
-    if (p.logger) {
-      this.__setLogger(p.logger);
-    }
-    this.#mastra = p;
-  }
-  async __text(input) {
-    this.logger.debug(`[LLMs:${this.name}] Generating text.`, {
-      input
-    });
-    throw new Error("Method not implemented.");
-  }
-  async __textObject(input) {
-    this.logger.debug(`[LLMs:${this.name}] Generating object.`, {
-      input
-    });
-    throw new Error("Method not implemented.");
-  }
-  async generate(messages, options = {}) {
-    this.logger.debug(`[LLMs:${this.name}] Generating text.`, {
-      messages,
-      options
-    });
-    throw new Error("Method not implemented.");
-  }
-  async __stream(input) {
-    this.logger.debug(`[LLMs:${this.name}] Streaming text.`, {
-      input
-    });
-    throw new Error("Method not implemented.");
-  }
-  async __streamObject(input) {
-    this.logger.debug(`[LLMs:${this.name}] Streaming object.`, {
-      input
-    });
-    throw new Error("Method not implemented.");
-  }
-  async stream(messages, options = {}) {
-    this.logger.debug(`[LLMs:${this.name}] Streaming text.`, {
-      messages,
-      options
-    });
-    throw new Error("Method not implemented.");
-  }
-};
-
-// 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;
-  }
-};
-
-// src/utils.ts
-var delay = ms => new Promise(resolve => setTimeout(resolve, ms));
-function resolveSerializedZodOutput(schema) {
-  return Function("z", `"use strict";return (${schema});`)(zod.z);
-}
-function isVercelTool(tool) {
-  return !(tool instanceof Tool);
-}
-function createLogMessageOptions({
-  agentName,
-  toolName,
-  tool,
-  type
-}) {
-  if (!agentName) {
-    return {
-      start: `Executing tool ${toolName}`,
-      error: `Failed tool execution`
-    };
-  }
-  const prefix = `[Agent:${agentName}]`;
-  const vercelPrefix = isVercelTool(tool) ? "Vercel " : "";
-  const toolType = type === "toolset" ? "toolset" : "tool";
-  return {
-    start: `${prefix} - Executing ${vercelPrefix}${toolType} ${toolName}`,
-    error: `${prefix} - Failed ${vercelPrefix}${toolType} execution`
-  };
-}
-function createExecute(tool, options, logType) {
-  const {
-    logger,
-    ...rest
-  } = options;
-  const {
-    start,
-    error
-  } = createLogMessageOptions({
-    agentName: options.agentName,
-    toolName: options.name,
-    tool,
-    type: logType
-  });
-  const execFunction = async (args, execOptions) => {
-    if (isVercelTool(tool)) {
-      return tool?.execute?.(args, execOptions) ?? void 0;
-    }
-    return tool?.execute?.({
-      context: args,
-      threadId: options.threadId,
-      resourceId: options.resourceId,
-      mastra: options.mastra,
-      memory: options.memory,
-      runId: options.runId
-    }, execOptions) ?? void 0;
-  };
-  return async (args, execOptions) => {
-    try {
-      logger.debug(start, {
-        ...rest,
-        args
-      });
-      return await execFunction(args, execOptions);
-    } catch (err) {
-      logger.error(error, {
-        ...rest,
-        error: err,
-        args
-      });
-      throw err;
-    }
-  };
-}
-function makeCoreTool(tool, options, logType) {
-  const getParameters = () => {
-    if (isVercelTool(tool)) {
-      return tool.parameters instanceof zod.z.ZodType ? tool.parameters : resolveSerializedZodOutput(jsonSchemaToZod__default.default(tool.parameters));
-    }
-    return tool.inputSchema;
-  };
-  return {
-    description: tool.description,
-    parameters: getParameters(),
-    execute: tool.execute ? createExecute(tool, {
-      ...options,
-      description: tool.description
-    }, logType) : void 0
-  };
-}
-function createMastraProxy({
-  mastra,
-  logger
-}) {
-  return new Proxy(mastra, {
-    get(target, prop) {
-      if (Reflect.has(target, prop)) {
-        return Reflect.get(target, prop);
-      }
-      if (prop === "logger") {
-        logger.warn(`Please use 'getLogger' instead, logger is deprecated`);
-        return Reflect.apply(target.getLogger, target, []);
-      }
-      if (prop === "telemetry") {
-        logger.warn(`Please use 'getTelemetry' instead, telemetry is deprecated`);
-        return Reflect.apply(target.getTelemetry, target, []);
-      }
-      if (prop === "storage") {
-        logger.warn(`Please use 'getStorage' instead, storage is deprecated`);
-        return Reflect.get(target, "storage");
-      }
-      if (prop === "agents") {
-        logger.warn(`Please use 'getAgents' instead, agents is deprecated`);
-        return Reflect.apply(target.getAgents, target, []);
-      }
-      if (prop === "tts") {
-        logger.warn(`Please use 'getTTS' instead, tts is deprecated`);
-        return Reflect.apply(target.getTTS, target, []);
-      }
-      if (prop === "vectors") {
-        logger.warn(`Please use 'getVectors' instead, vectors is deprecated`);
-        return Reflect.apply(target.getVectors, target, []);
-      }
-      if (prop === "memory") {
-        logger.warn(`Please use 'getMemory' instead, memory is deprecated`);
-        return Reflect.get(target, "memory");
-      }
-      return Reflect.get(target, prop);
-    }
-  });
-}
-
-// src/llm/model/model.ts
-var MastraLLM = class extends MastraLLMBase {
-  #model;
-  #mastra;
-  constructor({
-    model,
-    mastra
-  }) {
-    super({
-      name: "aisdk",
-      model
-    });
-    this.#model = model;
-    if (mastra) {
-      this.#mastra = mastra;
-      if (mastra.logger) {
-        this.__setLogger(mastra.logger);
-      }
-    }
-  }
-  __registerPrimitives(p) {
-    if (p.telemetry) {
-      this.__setTelemetry(p.telemetry);
-    }
-    if (p.logger) {
-      this.__setLogger(p.logger);
-    }
-    this.#mastra = p;
-  }
-  getProvider() {
-    return this.#model.provider;
-  }
-  getModelId() {
-    return this.#model.modelId;
-  }
-  getModel() {
-    return this.#model;
-  }
-  convertTools({
-    tools,
-    runId,
-    threadId,
-    resourceId,
-    memory
-  } = {}) {
-    this.logger.debug("Starting tool conversion for LLM");
-    const converted = Object.entries(tools || {}).reduce((memo, value) => {
-      const k = value[0];
-      const tool = value[1];
-      if (tool) {
-        const options = {
-          name: k,
-          runId,
-          threadId,
-          resourceId,
-          logger: this.logger,
-          memory,
-          mastra: this.#mastra
-        };
-        memo[k] = makeCoreTool(tool, options);
-      }
-      return memo;
-    }, {});
-    this.logger.debug(`Converted tools for LLM`);
-    return converted;
-  }
-  async __text({
-    runId,
-    messages,
-    maxSteps,
-    tools,
-    convertedTools,
-    temperature,
-    toolChoice = "auto",
-    onStepFinish,
-    experimental_output,
-    telemetry,
-    threadId,
-    resourceId,
-    memory,
-    ...rest
-  }) {
-    const model = this.#model;
-    this.logger.debug(`[LLM] - Generating text`, {
-      runId,
-      messages,
-      maxSteps,
-      threadId,
-      resourceId,
-      tools: Object.keys(tools || convertedTools || {})
-    });
-    const finalTools = convertedTools || this.convertTools({
-      tools,
-      runId,
-      threadId,
-      resourceId,
-      memory
-    });
-    const argsForExecute = {
-      model,
-      temperature,
-      tools: {
-        ...finalTools
-      },
-      toolChoice,
-      maxSteps,
-      onStepFinish: async props => {
-        onStepFinish?.(JSON.stringify(props, null, 2));
-        this.logger.debug("[LLM] - Step Change:", {
-          text: props?.text,
-          toolCalls: props?.toolCalls,
-          toolResults: props?.toolResults,
-          finishReason: props?.finishReason,
-          usage: props?.usage,
-          runId
-        });
-        if (props?.response?.headers?.["x-ratelimit-remaining-tokens"] && parseInt(props?.response?.headers?.["x-ratelimit-remaining-tokens"], 10) < 2e3) {
-          this.logger.warn("Rate limit approaching, waiting 10 seconds", {
-            runId
-          });
-          await delay(10 * 1e3);
-        }
-      },
-      ...rest
-    };
-    let schema;
-    if (experimental_output) {
-      this.logger.debug("[LLM] - Using experimental output", {
-        runId
-      });
-      if (typeof experimental_output.parse === "function") {
-        schema = experimental_output;
-        if (schema instanceof zod.z.ZodArray) {
-          schema = schema._def.type;
-        }
-      } else {
-        schema = ai.jsonSchema(experimental_output);
-      }
-    }
-    return await ai.generateText({
-      messages,
-      ...argsForExecute,
-      experimental_telemetry: {
-        ...this.experimental_telemetry,
-        ...telemetry
-      },
-      experimental_output: schema ? ai.Output.object({
-        schema
-      }) : void 0
-    });
-  }
-  async __textObject({
-    messages,
-    onStepFinish,
-    maxSteps = 5,
-    tools,
-    convertedTools,
-    structuredOutput,
-    runId,
-    temperature,
-    toolChoice = "auto",
-    telemetry,
-    threadId,
-    resourceId,
-    memory,
-    ...rest
-  }) {
-    const model = this.#model;
-    this.logger.debug(`[LLM] - Generating a text object`, {
-      runId
-    });
-    const finalTools = convertedTools || this.convertTools({
-      tools,
-      runId,
-      threadId,
-      resourceId,
-      memory
-    });
-    const argsForExecute = {
-      model,
-      temperature,
-      tools: {
-        ...finalTools
-      },
-      maxSteps,
-      toolChoice,
-      onStepFinish: async props => {
-        onStepFinish?.(JSON.stringify(props, null, 2));
-        this.logger.debug("[LLM] - Step Change:", {
-          text: props?.text,
-          toolCalls: props?.toolCalls,
-          toolResults: props?.toolResults,
-          finishReason: props?.finishReason,
-          usage: props?.usage,
-          runId
-        });
-        if (props?.response?.headers?.["x-ratelimit-remaining-tokens"] && parseInt(props?.response?.headers?.["x-ratelimit-remaining-tokens"], 10) < 2e3) {
-          this.logger.warn("Rate limit approaching, waiting 10 seconds", {
-            runId
-          });
-          await delay(10 * 1e3);
-        }
-      },
-      ...rest
-    };
-    let schema;
-    let output = "object";
-    if (typeof structuredOutput.parse === "function") {
-      schema = structuredOutput;
-      if (schema instanceof zod.z.ZodArray) {
-        output = "array";
-        schema = schema._def.type;
-      }
-    } else {
-      schema = ai.jsonSchema(structuredOutput);
-    }
-    return await ai.generateObject({
-      messages,
-      ...argsForExecute,
-      output,
-      schema,
-      experimental_telemetry: {
-        ...this.experimental_telemetry,
-        ...telemetry
-      }
-    });
-  }
-  async __stream({
-    messages,
-    onStepFinish,
-    onFinish,
-    maxSteps = 5,
-    tools,
-    convertedTools,
-    runId,
-    temperature,
-    toolChoice = "auto",
-    experimental_output,
-    telemetry,
-    threadId,
-    resourceId,
-    memory,
-    ...rest
-  }) {
-    const model = this.#model;
-    this.logger.debug(`[LLM] - Streaming text`, {
-      runId,
-      threadId,
-      resourceId,
-      messages,
-      maxSteps,
-      tools: Object.keys(tools || convertedTools || {})
-    });
-    const finalTools = convertedTools || this.convertTools({
-      tools,
-      runId,
-      threadId,
-      resourceId,
-      memory
-    });
-    const argsForExecute = {
-      model,
-      temperature,
-      tools: {
-        ...finalTools
-      },
-      maxSteps,
-      toolChoice,
-      onStepFinish: async props => {
-        onStepFinish?.(JSON.stringify(props, null, 2));
-        this.logger.debug("[LLM] - Stream Step Change:", {
-          text: props?.text,
-          toolCalls: props?.toolCalls,
-          toolResults: props?.toolResults,
-          finishReason: props?.finishReason,
-          usage: props?.usage,
-          runId
-        });
-        if (props?.response?.headers?.["x-ratelimit-remaining-tokens"] && parseInt(props?.response?.headers?.["x-ratelimit-remaining-tokens"], 10) < 2e3) {
-          this.logger.warn("Rate limit approaching, waiting 10 seconds", {
-            runId
-          });
-          await delay(10 * 1e3);
-        }
-      },
-      onFinish: async props => {
-        void onFinish?.(JSON.stringify(props, null, 2));
-        this.logger.debug("[LLM] - Stream Finished:", {
-          text: props?.text,
-          toolCalls: props?.toolCalls,
-          toolResults: props?.toolResults,
-          finishReason: props?.finishReason,
-          usage: props?.usage,
-          runId,
-          threadId,
-          resourceId
-        });
-      },
-      ...rest
-    };
-    let schema;
-    if (experimental_output) {
-      this.logger.debug("[LLM] - Using experimental output", {
-        runId
-      });
-      if (typeof experimental_output.parse === "function") {
-        schema = experimental_output;
-        if (schema instanceof zod.z.ZodArray) {
-          schema = schema._def.type;
-        }
-      } else {
-        schema = ai.jsonSchema(experimental_output);
-      }
-    }
-    return await ai.streamText({
-      messages,
-      ...argsForExecute,
-      experimental_telemetry: {
-        ...this.experimental_telemetry,
-        ...telemetry
-      },
-      experimental_output: schema ? ai.Output.object({
-        schema
-      }) : void 0
-    });
-  }
-  async __streamObject({
-    messages,
-    onStepFinish,
-    onFinish,
-    maxSteps = 5,
-    tools,
-    convertedTools,
-    structuredOutput,
-    runId,
-    temperature,
-    toolChoice = "auto",
-    telemetry,
-    threadId,
-    resourceId,
-    memory,
-    ...rest
-  }) {
-    const model = this.#model;
-    this.logger.debug(`[LLM] - Streaming structured output`, {
-      runId,
-      messages,
-      maxSteps,
-      tools: Object.keys(tools || convertedTools || {})
-    });
-    const finalTools = convertedTools || this.convertTools({
-      tools,
-      runId,
-      threadId,
-      resourceId,
-      memory
-    });
-    const argsForExecute = {
-      model,
-      temperature,
-      tools: {
-        ...finalTools
-      },
-      maxSteps,
-      toolChoice,
-      onStepFinish: async props => {
-        onStepFinish?.(JSON.stringify(props, null, 2));
-        this.logger.debug("[LLM] - Stream Step Change:", {
-          text: props?.text,
-          toolCalls: props?.toolCalls,
-          toolResults: props?.toolResults,
-          finishReason: props?.finishReason,
-          usage: props?.usage,
-          runId,
-          threadId,
-          resourceId
-        });
-        if (props?.response?.headers?.["x-ratelimit-remaining-tokens"] && parseInt(props?.response?.headers?.["x-ratelimit-remaining-tokens"], 10) < 2e3) {
-          this.logger.warn("Rate limit approaching, waiting 10 seconds", {
-            runId
-          });
-          await delay(10 * 1e3);
-        }
-      },
-      onFinish: async props => {
-        void onFinish?.(JSON.stringify(props, null, 2));
-        this.logger.debug("[LLM] - Stream Finished:", {
-          text: props?.text,
-          toolCalls: props?.toolCalls,
-          toolResults: props?.toolResults,
-          finishReason: props?.finishReason,
-          usage: props?.usage,
-          runId,
-          threadId,
-          resourceId
-        });
-      },
-      ...rest
-    };
-    let schema;
-    let output = "object";
-    if (typeof structuredOutput.parse === "function") {
-      schema = structuredOutput;
-      if (schema instanceof zod.z.ZodArray) {
-        output = "array";
-        schema = schema._def.type;
-      }
-    } else {
-      schema = ai.jsonSchema(structuredOutput);
-    }
-    return ai.streamObject({
-      messages,
-      ...argsForExecute,
-      output,
-      schema,
-      experimental_telemetry: {
-        ...this.experimental_telemetry,
-        ...telemetry
-      }
-    });
-  }
-  async generate(messages, {
-    maxSteps = 5,
-    onStepFinish,
-    tools,
-    convertedTools,
-    runId,
-    output,
-    temperature,
-    telemetry,
-    memory,
-    ...rest
-  } = {}) {
-    const msgs = this.convertToMessages(messages);
-    if (!output) {
-      return await this.__text({
-        messages: msgs,
-        onStepFinish,
-        maxSteps,
-        tools,
-        convertedTools,
-        runId,
-        temperature,
-        memory,
-        ...rest
-      });
-    }
-    return await this.__textObject({
-      messages: msgs,
-      structuredOutput: output,
-      onStepFinish,
-      maxSteps,
-      tools,
-      convertedTools,
-      runId,
-      telemetry,
-      memory,
-      ...rest
-    });
-  }
-  async stream(messages, {
-    maxSteps = 5,
-    onFinish,
-    onStepFinish,
-    tools,
-    convertedTools,
-    runId,
-    output,
-    temperature,
-    telemetry,
-    ...rest
-  } = {}) {
-    const msgs = this.convertToMessages(messages);
-    if (!output) {
-      return await this.__stream({
-        messages: msgs,
-        onStepFinish,
-        onFinish,
-        maxSteps,
-        tools,
-        convertedTools,
-        runId,
-        temperature,
-        telemetry,
-        ...rest
-      });
-    }
-    return await this.__streamObject({
-      messages: msgs,
-      structuredOutput: output,
-      onStepFinish,
-      onFinish,
-      maxSteps,
-      tools,
-      convertedTools,
-      runId,
-      temperature,
-      telemetry,
-      ...rest
-    });
-  }
-};
-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/agent/index.ts
-var _Agent_decorators, _init, _a;
-_Agent_decorators = [InstrumentClass({
-  prefix: "agent",
-  excludeMethods: ["__setTools", "__setLogger", "__setTelemetry", "log"]
-})];
-exports.Agent = class Agent extends (_a = MastraBase) {
-  name;
-  llm;
-  instructions;
-  model;
-  #mastra;
-  #memory;
-  tools;
-  /** @deprecated This property is deprecated. Use evals instead. */
-  metrics;
-  evals;
-  voice;
-  constructor(config) {
-    super({
-      component: RegisteredLogger.AGENT
-    });
-    this.name = config.name;
-    this.instructions = config.instructions;
-    if (!config.model) {
-      throw new Error(`LanguageModel is required to create an Agent. Please provide the 'model'.`);
-    }
-    this.llm = new MastraLLM({
-      model: config.model
-    });
-    this.tools = {};
-    this.metrics = {};
-    this.evals = {};
-    if (config.tools) {
-      this.tools = config.tools;
-    }
-    if (config.mastra) {
-      this.__registerPrimitives({
-        telemetry: config.mastra.getTelemetry(),
-        logger: config.mastra.getLogger()
-      });
-    }
-    if (config.metrics) {
-      this.logger.warn("The metrics property is deprecated. Please use evals instead to add evaluation metrics.");
-      this.metrics = config.metrics;
-      this.evals = config.metrics;
-    }
-    if (config.evals) {
-      this.evals = config.evals;
-    }
-    if (config.memory) {
-      this.#memory = config.memory;
-    }
-    if (config.voice) {
-      this.voice = config.voice;
-    }
-  }
-  hasOwnMemory() {
-    return Boolean(this.#memory);
-  }
-  getMemory() {
-    return this.#memory ?? this.#mastra?.memory;
-  }
-  __updateInstructions(newInstructions) {
-    this.instructions = newInstructions;
-    this.logger.debug(`[Agents:${this.name}] Instructions updated.`, {
-      model: this.model,
-      name: this.name
-    });
-  }
-  __registerPrimitives(p) {
-    if (p.telemetry) {
-      this.__setTelemetry(p.telemetry);
-    }
-    if (p.logger) {
-      this.__setLogger(p.logger);
-    }
-    this.llm.__registerPrimitives(p);
-    this.logger.debug(`[Agents:${this.name}] initialized.`, {
-      model: this.model,
-      name: this.name
-    });
-  }
-  __registerMastra(mastra) {
-    this.#mastra = mastra;
-  }
-  /**
-   * Set the concrete tools for the agent
-   * @param tools
-   */
-  __setTools(tools) {
-    this.tools = tools;
-    this.logger.debug(`[Agents:${this.name}] Tools set for agent ${this.name}`, {
-      model: this.model,
-      name: this.name
-    });
-  }
-  async generateTitleFromUserMessage({
-    message
-  }) {
-    const {
-      text
-    } = await this.llm.__text({
-      messages: [{
-        role: "system",
-        content: `
-
-      - you will generate a short title based on the first message a user begins a conversation with
-      - ensure it is not more than 80 characters long
-      - the title should be a summary of the user's message
-      - do not use quotes or colons
-      - the entire text you return will be used as the title`
-      }, {
-        role: "user",
-        content: JSON.stringify(message)
-      }]
-    });
-    const cleanedText = text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
-    return cleanedText;
-  }
-  getMostRecentUserMessage(messages) {
-    const userMessages = messages.filter(message => message.role === "user");
-    return userMessages.at(-1);
-  }
-  async genTitle(userMessage) {
-    let title = `New Thread ${(/* @__PURE__ */new Date()).toISOString()}`;
-    try {
-      if (userMessage) {
-        title = await this.generateTitleFromUserMessage({
-          message: userMessage
-        });
-      }
-    } catch (e) {
-      console.error("Error generating title:", e);
-    }
-    return title;
-  }
-  async saveMemory({
-    threadId,
-    memoryConfig,
-    resourceId,
-    userMessages,
-    runId
-  }) {
-    const userMessage = this.getMostRecentUserMessage(userMessages);
-    const memory = this.getMemory();
-    if (memory) {
-      const config = memory.getMergedThreadConfig(memoryConfig);
-      let thread;
-      if (!threadId) {
-        this.logger.debug(`No threadId, creating new thread for agent ${this.name}`, {
-          runId: runId || this.name
-        });
-        const title = config?.threads?.generateTitle ? await this.genTitle(userMessage) : void 0;
-        thread = await memory.createThread({
-          threadId,
-          resourceId,
-          memoryConfig,
-          title
-        });
-      } else {
-        thread = await memory.getThreadById({
-          threadId
-        });
-        if (!thread) {
-          this.logger.debug(`Thread with id ${threadId} not found, creating new thread for agent ${this.name}`, {
-            runId: runId || this.name
-          });
-          const title = config?.threads?.generateTitle ? await this.genTitle(userMessage) : void 0;
-          thread = await memory.createThread({
-            threadId,
-            resourceId,
-            title,
-            memoryConfig
-          });
-        }
-      }
-      const newMessages = userMessage ? [userMessage] : userMessages;
-      if (thread) {
-        const messages = newMessages.map(u => {
-          return {
-            id: this.getMemory()?.generateId(),
-            createdAt: /* @__PURE__ */new Date(),
-            threadId: thread.id,
-            ...u,
-            content: u.content,
-            role: u.role,
-            type: "text"
-          };
-        });
-        const memoryMessages = threadId && memory ? (await memory.rememberMessages({
-          threadId,
-          config: memoryConfig,
-          vectorMessageSearch: messages.slice(-1).map(m => {
-            if (typeof m === `string`) {
-              return m;
-            }
-            return m?.content || ``;
-          }).join(`
-`)
-        })).messages : [];
-        if (memory) {
-          await memory.saveMessages({
-            messages,
-            memoryConfig
-          });
-        }
-        this.logger.debug("Saved messages to memory", {
-          threadId: thread.id,
-          runId
-        });
-        const memorySystemMessage = memory && threadId ? await memory.getSystemMessage({
-          threadId,
-          memoryConfig
-        }) : null;
-        return {
-          threadId: thread.id,
-          messages: [memorySystemMessage ? {
-            role: "system",
-            content: memorySystemMessage
-          } : null, ...this.sanitizeResponseMessages(memoryMessages), ...newMessages].filter(message => Boolean(message))
-        };
-      }
-      return {
-        threadId: thread?.id || threadId || "",
-        messages: userMessages
-      };
-    }
-    return {
-      threadId: threadId || "",
-      messages: userMessages
-    };
-  }
-  async saveResponse({
-    result,
-    threadId,
-    resourceId,
-    runId,
-    memoryConfig
-  }) {
-    const {
-      response
-    } = result;
-    try {
-      if (response.messages) {
-        const ms = Array.isArray(response.messages) ? response.messages : [response.messages];
-        const responseMessagesWithoutIncompleteToolCalls = this.sanitizeResponseMessages(ms);
-        const memory = this.getMemory();
-        if (memory) {
-          this.logger.debug(`[Agent:${this.name}] - Memory persistence: store=${this.getMemory()?.constructor.name} threadId=${threadId}`, {
-            runId,
-            resourceId,
-            threadId,
-            memoryStore: this.getMemory()?.constructor.name
-          });
-          await memory.saveMessages({
-            memoryConfig,
-            messages: responseMessagesWithoutIncompleteToolCalls.map((message, index) => {
-              const messageId = crypto$1.randomUUID();
-              let toolCallIds;
-              let toolCallArgs;
-              let toolNames;
-              let type = "text";
-              if (message.role === "tool") {
-                toolCallIds = message.content.map(content => content.toolCallId);
-                type = "tool-result";
-              }
-              if (message.role === "assistant") {
-                const assistantContent = message.content;
-                const assistantToolCalls = assistantContent.map(content => {
-                  if (content.type === "tool-call") {
-                    return {
-                      toolCallId: content.toolCallId,
-                      toolArgs: content.args,
-                      toolName: content.toolName
-                    };
-                  }
-                  return void 0;
-                })?.filter(Boolean);
-                toolCallIds = assistantToolCalls?.map(toolCall => toolCall.toolCallId);
-                toolCallArgs = assistantToolCalls?.map(toolCall => toolCall.toolArgs);
-                toolNames = assistantToolCalls?.map(toolCall => toolCall.toolName);
-                type = assistantContent?.[0]?.type;
-              }
-              return {
-                id: messageId,
-                threadId,
-                role: message.role,
-                content: message.content,
-                createdAt: new Date(Date.now() + index),
-                // use Date.now() + index to make sure every message is atleast one millisecond apart
-                toolCallIds: toolCallIds?.length ? toolCallIds : void 0,
-                toolCallArgs: toolCallArgs?.length ? toolCallArgs : void 0,
-                toolNames: toolNames?.length ? toolNames : void 0,
-                type
-              };
-            })
-          });
-        }
-      }
-    } catch (err) {
-      this.logger.error(`[Agent:${this.name}] - Failed to save assistant response`, {
-        error: err,
-        runId
-      });
-    }
-  }
-  sanitizeResponseMessages(messages) {
-    let toolResultIds = [];
-    let toolCallIds = [];
-    for (const message of messages) {
-      if (!Array.isArray(message.content)) continue;
-      if (message.role === "tool") {
-        for (const content of message.content) {
-          if (content.type === "tool-result") {
-            toolResultIds.push(content.toolCallId);
-          }
-        }
-      } else if (message.role === "assistant" || message.role === "user") {
-        for (const content of message.content) {
-          if (typeof content !== `string`) {
-            if (content.type === `tool-call`) {
-              toolCallIds.push(content.toolCallId);
-            }
-          }
-        }
-      }
-    }
-    const messagesBySanitizedContent = messages.map(message => {
-      if (message.role !== "assistant" && message.role !== `tool` && message.role !== `user`) return message;
-      if (!message.content || typeof message.content === "string" || typeof message.content === "number") {
-        return message;
-      }
-      const sanitizedContent = message.content.filter(content => {
-        if (content.type === `tool-call`) {
-          return toolResultIds.includes(content.toolCallId);
-        }
-        if (content.type === `text`) {
-          return content.text.trim() !== ``;
-        }
-        if (content.type === `tool-result`) {
-          return toolCallIds.includes(content.toolCallId);
-        }
-        return true;
-      });
-      return {
-        ...message,
-        content: sanitizedContent
-      };
-    });
-    return messagesBySanitizedContent.filter(message => {
-      if (typeof message.content === `string`) {
-        return message.content !== "";
-      }
-      if (Array.isArray(message.content)) {
-        return message.content.length && message.content.every(c => {
-          if (c.type === `text`) {
-            return c.text && c.text !== "";
-          }
-          return true;
-        });
-      }
-      return true;
-    });
-  }
-  convertTools({
-    toolsets,
-    threadId,
-    resourceId,
-    runId
-  }) {
-    this.logger.debug(`[Agents:${this.name}] - Assigning tools`, {
-      runId,
-      threadId,
-      resourceId
-    });
-    const memory = this.getMemory();
-    const memoryTools = memory?.getTools?.();
-    let mastraProxy = void 0;
-    const logger = this.logger;
-    if (this.#mastra) {
-      mastraProxy = createMastraProxy({
-        mastra: this.#mastra,
-        logger
-      });
-    }
-    const converted = Object.entries(this.tools || {}).reduce((memo, value) => {
-      const k = value[0];
-      const tool = this.tools[k];
-      if (tool) {
-        const options = {
-          name: k,
-          runId,
-          threadId,
-          resourceId,
-          logger: this.logger,
-          mastra: mastraProxy,
-          memory,
-          agentName: this.name
-        };
-        memo[k] = makeCoreTool(tool, options);
-      }
-      return memo;
-    }, {});
-    const convertedMemoryTools = memoryTools ? Object.entries(memoryTools).reduce((memo, [k, tool]) => {
-      memo[k] = {
-        description: tool.description,
-        parameters: tool.parameters,
-        execute: typeof tool?.execute === "function" ? async (args, options) => {
-          try {
-            this.logger.debug(`[Agent:${this.name}] - Executing memory tool ${k}`, {
-              name: k,
-              description: tool.description,
-              args,
-              runId,
-              threadId,
-              resourceId
-            });
-            return tool?.execute?.({
-              context: args,
-              mastra: mastraProxy,
-              memory,
-              runId,
-              threadId,
-              resourceId
-            }, options) ?? void 0;
-          } catch (err) {
-            this.logger.error(`[Agent:${this.name}] - Failed memory tool execution`, {
-              error: err,
-              runId,
-              threadId,
-              resourceId
-            });
-            throw err;
-          }
-        } : void 0
-      };
-      return memo;
-    }, {}) : {};
-    const toolsFromToolsetsConverted = {
-      ...converted,
-      ...convertedMemoryTools
-    };
-    const toolsFromToolsets = Object.values(toolsets || {});
-    if (toolsFromToolsets.length > 0) {
-      this.logger.debug(`[Agent:${this.name}] - Adding tools from toolsets ${Object.keys(toolsets || {}).join(", ")}`, {
-        runId
-      });
-      toolsFromToolsets.forEach(toolset => {
-        Object.entries(toolset).forEach(([toolName, tool]) => {
-          const toolObj = tool;
-          const options = {
-            name: toolName,
-            runId,
-            threadId,
-            resourceId,
-            logger: this.logger,
-            agentName: this.name
-          };
-          toolsFromToolsetsConverted[toolName] = makeCoreTool(toolObj, options, "toolset");
-        });
-      });
-    }
-    return toolsFromToolsetsConverted;
-  }
-  async preExecute({
-    resourceId,
-    runId,
-    threadId,
-    memoryConfig,
-    messages
-  }) {
-    let coreMessages = [];
-    let threadIdToUse = threadId;
-    this.logger.debug(`Saving user messages in memory for agent ${this.name}`, {
-      runId
-    });
-    const saveMessageResponse = await this.saveMemory({
-      threadId,
-      resourceId,
-      userMessages: messages,
-      memoryConfig
-    });
-    coreMessages = saveMessageResponse.messages;
-    threadIdToUse = saveMessageResponse.threadId;
-    return {
-      coreMessages,
-      threadIdToUse
-    };
-  }
-  __primitive({
-    messages,
-    context: context2,
-    threadId,
-    memoryConfig,
-    resourceId,
-    runId,
-    toolsets
-  }) {
-    return {
-      before: async () => {
-        if (process.env.NODE_ENV !== "test") {
-          this.logger.debug(`[Agents:${this.name}] - Starting generation`, {
-            runId
-          });
-        }
-        const systemMessage = {
-          role: "system",
-          content: `${this.instructions}.`
-        };
-        let coreMessages = messages;
-        let threadIdToUse = threadId;
-        const memory = this.getMemory();
-        if (threadId && memory && !resourceId) {
-          throw new Error(`A resourceId must be provided when passing a threadId and using Memory. Saw threadId ${threadId} but resourceId is ${resourceId}`);
-        }
-        if (memory && resourceId) {
-          this.logger.debug(`[Agent:${this.name}] - Memory persistence enabled: store=${this.getMemory()?.constructor.name}, resourceId=${resourceId}`, {
-            runId,
-            resourceId,
-            threadId: threadIdToUse,
-            memoryStore: this.getMemory()?.constructor.name
-          });
-          const preExecuteResult = await this.preExecute({
-            resourceId,
-            runId,
-            threadId: threadIdToUse,
-            memoryConfig,
-            messages
-          });
-          coreMessages = preExecuteResult.coreMessages;
-          threadIdToUse = preExecuteResult.threadIdToUse;
-        }
-        let convertedTools;
-        if (toolsets && Object.keys(toolsets || {}).length > 0 || this.getMemory() && resourceId) {
-          const reasons = [];
-          if (toolsets && Object.keys(toolsets || {}).length > 0) {
-            reasons.push(`toolsets present (${Object.keys(toolsets || {}).length} tools)`);
-          }
-          if (this.getMemory() && resourceId) {
-            reasons.push("memory and resourceId available");
-          }
-          this.logger.debug(`[Agent:${this.name}] - Enhancing tools: ${reasons.join(", ")}`, {
-            runId,
-            toolsets: toolsets ? Object.keys(toolsets) : void 0,
-            hasMemory: !!this.getMemory(),
-            hasResourceId: !!resourceId
-          });
-          convertedTools = this.convertTools({
-            toolsets,
-            threadId: threadIdToUse,
-            resourceId,
-            runId
-          });
-        }
-        const messageObjects = [systemMessage, ...(context2 || []), ...coreMessages];
-        return {
-          messageObjects,
-          convertedTools,
-          threadId: threadIdToUse
-        };
-      },
-      after: async ({
-        result,
-        threadId: threadId2,
-        memoryConfig: memoryConfig2,
-        outputText,
-        runId: runId2
-      }) => {
-        const resToLog = {
-          text: result?.text,
-          object: result?.object,
-          toolResults: result?.toolResults,
-          toolCalls: result?.toolCalls,
-          usage: result?.usage,
-          steps: result?.steps?.map(s => {
-            return {
-              stepType: s?.stepType,
-              text: result?.text,
-              object: result?.object,
-              toolResults: result?.toolResults,
-              toolCalls: result?.toolCalls,
-              usage: result?.usage
-            };
-          })
-        };
-        this.logger.debug(`[Agent:${this.name}] - Post processing LLM response`, {
-          runId: runId2,
-          result: resToLog,
-          threadId: threadId2
-        });
-        if (this.getMemory() && resourceId) {
-          try {
-            await this.saveResponse({
-              result,
-              threadId: threadId2,
-              resourceId,
-              memoryConfig: memoryConfig2,
-              runId: runId2
-            });
-          } catch (e) {
-            this.logger.error("Error saving response", {
-              error: e,
-              runId: runId2,
-              result: resToLog,
-              threadId: threadId2
-            });
-          }
-        }
-        if (Object.keys(this.evals || {}).length > 0) {
-          const input = messages.map(message => message.content).join("\n");
-          const runIdToUse = runId2 || crypto.randomUUID();
-          for (const metric of Object.values(this.evals || {})) {
-            executeHook("onGeneration" /* ON_GENERATION */, {
-              input,
-              output: outputText,
-              runId: runIdToUse,
-              metric,
-              agentName: this.name,
-              instructions: this.instructions
-            });
-          }
-        }
-      }
-    };
-  }
-  async generate(messages, {
-    context: context2,
-    threadId: threadIdInFn,
-    memoryOptions,
-    resourceId,
-    maxSteps = 5,
-    onStepFinish,
-    runId,
-    output,
-    toolsets,
-    temperature,
-    toolChoice = "auto",
-    experimental_output,
-    telemetry,
-    ...rest
-  } = {}) {
-    let messagesToUse = [];
-    if (typeof messages === `string`) {
-      messagesToUse = [{
-        role: "user",
-        content: messages
-      }];
-    } else {
-      messagesToUse = messages.map(message => {
-        if (typeof message === `string`) {
-          return {
-            role: "user",
-            content: message
-          };
-        }
-        return message;
-      });
-    }
-    const runIdToUse = runId || crypto$1.randomUUID();
-    const {
-      before,
-      after
-    } = this.__primitive({
-      messages: messagesToUse,
-      context: context2,
-      threadId: threadIdInFn,
-      memoryConfig: memoryOptions,
-      resourceId,
-      runId: runIdToUse,
-      toolsets
-    });
-    const {
-      threadId,
-      messageObjects,
-      convertedTools
-    } = await before();
-    if (!output && experimental_output) {
-      const result2 = await this.llm.__text({
-        messages: messageObjects,
-        tools: this.tools,
-        convertedTools,
-        onStepFinish,
-        maxSteps: maxSteps || 5,
-        runId: runIdToUse,
-        temperature,
-        toolChoice: toolChoice || "auto",
-        experimental_output,
-        threadId,
-        resourceId,
-        memory: this.getMemory(),
-        ...rest
-      });
-      const outputText2 = result2.text;
-      await after({
-        result: result2,
-        threadId,
-        memoryConfig: memoryOptions,
-        outputText: outputText2,
-        runId: runIdToUse
-      });
-      const newResult = result2;
-      newResult.object = result2.experimental_output;
-      return newResult;
-    }
-    if (!output) {
-      const result2 = await this.llm.__text({
-        messages: messageObjects,
-        tools: this.tools,
-        convertedTools,
-        onStepFinish,
-        maxSteps,
-        runId: runIdToUse,
-        temperature,
-        toolChoice,
-        telemetry,
-        threadId,
-        resourceId,
-        memory: this.getMemory(),
-        ...rest
-      });
-      const outputText2 = result2.text;
-      await after({
-        result: result2,
-        threadId,
-        memoryConfig: memoryOptions,
-        outputText: outputText2,
-        runId: runIdToUse
-      });
-      return result2;
-    }
-    const result = await this.llm.__textObject({
-      messages: messageObjects,
-      tools: this.tools,
-      structuredOutput: output,
-      convertedTools,
-      onStepFinish,
-      maxSteps,
-      runId: runIdToUse,
-      temperature,
-      toolChoice,
-      telemetry,
-      memory: this.getMemory(),
-      ...rest
-    });
-    const outputText = JSON.stringify(result.object);
-    await after({
-      result,
-      threadId,
-      memoryConfig: memoryOptions,
-      outputText,
-      runId: runIdToUse
-    });
-    return result;
-  }
-  async stream(messages, {
-    context: context2,
-    threadId: threadIdInFn,
-    memoryOptions,
-    resourceId,
-    maxSteps = 5,
-    onFinish,
-    onStepFinish,
-    runId,
-    toolsets,
-    output,
-    temperature,
-    toolChoice = "auto",
-    experimental_output,
-    telemetry,
-    ...rest
-  } = {}) {
-    const runIdToUse = runId || crypto$1.randomUUID();
-    let messagesToUse = [];
-    if (typeof messages === `string`) {
-      messagesToUse = [{
-        role: "user",
-        content: messages
-      }];
-    } else {
-      messagesToUse = messages.map(message => {
-        if (typeof message === `string`) {
-          return {
-            role: "user",
-            content: message
-          };
-        }
-        return message;
-      });
-    }
-    const {
-      before,
-      after
-    } = this.__primitive({
-      messages: messagesToUse,
-      context: context2,
-      threadId: threadIdInFn,
-      memoryConfig: memoryOptions,
-      resourceId,
-      runId: runIdToUse,
-      toolsets
-    });
-    const {
-      threadId,
-      messageObjects,
-      convertedTools
-    } = await before();
-    if (!output && experimental_output) {
-      this.logger.debug(`Starting agent ${this.name} llm stream call`, {
-        runId
-      });
-      const streamResult = await this.llm.__stream({
-        messages: messageObjects,
-        temperature,
-        tools: this.tools,
-        convertedTools,
-        onStepFinish,
-        onFinish: async result => {
-          try {
-            const res = JSON.parse(result) || {};
-            const outputText = res.text;
-            await after({
-              result: res,
-              threadId,
-              memoryConfig: memoryOptions,
-              outputText,
-              runId: runIdToUse
-            });
-          } catch (e) {
-            this.logger.error("Error saving memory on finish", {
-              error: e,
-              runId
-            });
-          }
-          onFinish?.(result);
-        },
-        maxSteps,
-        runId: runIdToUse,
-        toolChoice,
-        experimental_output,
-        memory: this.getMemory(),
-        ...rest
-      });
-      const newStreamResult = streamResult;
-      newStreamResult.partialObjectStream = streamResult.experimental_partialOutputStream;
-      return newStreamResult;
-    } else if (!output) {
-      this.logger.debug(`Starting agent ${this.name} llm stream call`, {
-        runId
-      });
-      return this.llm.__stream({
-        messages: messageObjects,
-        temperature,
-        tools: this.tools,
-        convertedTools,
-        onStepFinish,
-        onFinish: async result => {
-          try {
-            const res = JSON.parse(result) || {};
-            const outputText = res.text;
-            await after({
-              result: res,
-              threadId,
-              memoryConfig: memoryOptions,
-              outputText,
-              runId: runIdToUse
-            });
-          } catch (e) {
-            this.logger.error("Error saving memory on finish", {
-              error: e,
-              runId
-            });
-          }
-          onFinish?.(result);
-        },
-        maxSteps,
-        runId: runIdToUse,
-        toolChoice,
-        telemetry,
-        memory: this.getMemory(),
-        ...rest
-      });
-    }
-    this.logger.debug(`Starting agent ${this.name} llm streamObject call`, {
-      runId
-    });
-    return this.llm.__streamObject({
-      messages: messageObjects,
-      tools: this.tools,
-      temperature,
-      structuredOutput: output,
-      convertedTools,
-      onStepFinish,
-      onFinish: async result => {
-        try {
-          const res = JSON.parse(result) || {};
-          const outputText = JSON.stringify(res.object);
-          await after({
-            result: res,
-            threadId,
-            memoryConfig: memoryOptions,
-            outputText,
-            runId: runIdToUse
-          });
-        } catch (e) {
-          this.logger.error("Error saving memory on finish", {
-            error: e,
-            runId
-          });
-        }
-        onFinish?.(result);
-      },
-      runId: runIdToUse,
-      toolChoice,
-      telemetry,
-      memory: this.getMemory(),
-      ...rest
-    });
-  }
-  /**
-   * Convert text to speech using the configured voice provider
-   * @param input Text or text stream to convert to speech
-   * @param options Speech options including speaker and provider-specific options
-   * @returns Audio stream
-   */
-  async speak(input, options) {
-    if (!this.voice) {
-      throw new Error("No voice provider configured");
-    }
-    try {
-      return this.voice.speak(input, options);
-    } catch (e) {
-      this.logger.error("Error during agent speak", {
-        error: e
-      });
-      throw e;
-    }
-  }
-  /**
-   * Convert speech to text using the configured voice provider
-   * @param audioStream Audio stream to transcribe
-   * @param options Provider-specific transcription options
-   * @returns Text or text stream
-   */
-  async listen(audioStream, options) {
-    if (!this.voice) {
-      throw new Error("No voice provider configured");
-    }
-    try {
-      return this.voice.listen(audioStream, options);
-    } catch (e) {
-      this.logger.error("Error during agent listen", {
-        error: e
-      });
-      throw e;
-    }
-  }
-  /**
-   * Get a list of available speakers from the configured voice provider
-   * @throws {Error} If no voice provider is configured
-   * @returns {Promise<Array<{voiceId: string}>>} List of available speakers
-   */
-  async getSpeakers() {
-    if (!this.voice) {
-      throw new Error("No voice provider configured");
-    }
-    try {
-      return await this.voice.getSpeakers();
-    } catch (e) {
-      this.logger.error("Error during agent getSpeakers", {
-        error: e
-      });
-      throw e;
-    }
-  }
-};
-exports.Agent = /*@__PURE__*/(_ => {
-  _init = __decoratorStart(_a);
-  exports.Agent = __decorateElement(_init, 0, "Agent", _Agent_decorators, exports.Agent);
-  __runInitializers(_init, 1, exports.Agent);
-  return exports.Agent;
-})();