@mastra/core 0.4.3-alpha.1 → 0.4.3-alpha.4

package/dist/agent/index.cjs

@@ -0,0 +1,1939 @@
+'use strict';
+
+var crypto$1 = require('crypto');
+var zod = require('zod');
+var stream = require('stream');
+var pino = require('pino');
+var pretty = require('pino-pretty');
+var ai = require('ai');
+var api = require('@opentelemetry/api');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var pino__default = /*#__PURE__*/_interopDefault(pino);
+var pretty__default = /*#__PURE__*/_interopDefault(pretty);
+
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = msg => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", {
+  value,
+  configurable: true
+});
+var __decoratorStart = base => [,,, __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = fn => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({
+  kind: __decoratorStrings[kind],
+  name,
+  metadata,
+  addInitializer: fn => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null))
+});
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) fns[i].call(self) ;
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var it,
+    done,
+    ctx,
+    k = flags & 7,
+    p = false;
+  var j = 0;
+  var extraInitializers = array[j] || (array[j] = []);
+  var desc = k && ((target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(target , name));
+  __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    it = (0, decorators[i])(target, ctx), done._ = 1;
+    __expectFn(it) && (target = it);
+  }
+  return __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var RegisteredLogger = {
+  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
+    }, 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.");
+  }
+};
+var delay = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+// 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
+  } = {}) {
+    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) {
+        memo[k] = {
+          description: tool.description,
+          parameters: tool.inputSchema,
+          execute: typeof tool?.execute === "function" ? async (props, options) => {
+            try {
+              this.logger.debug("Executing tool", {
+                tool: k,
+                props
+              });
+              return tool?.execute?.({
+                context: props,
+                threadId,
+                resourceId,
+                mastra: this.#mastra,
+                runId
+              }, options) ?? void 0;
+            } catch (error) {
+              this.logger.error("Error executing tool", {
+                tool: k,
+                props,
+                error,
+                runId,
+                threadId,
+                resourceId
+              });
+              throw error;
+            }
+          } : void 0
+        };
+      }
+      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,
+    ...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
+    });
+    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,
+    ...rest
+  }) {
+    const model = this.#model;
+    this.logger.debug(`[LLM] - Generating a text object`, {
+      runId
+    });
+    const finalTools = convertedTools || this.convertTools({
+      tools,
+      runId,
+      threadId,
+      resourceId
+    });
+    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,
+    ...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
+    });
+    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,
+    ...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
+    });
+    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,
+    ...rest
+  } = {}) {
+    const msgs = this.convertToMessages(messages);
+    if (!output) {
+      return await this.__text({
+        messages: msgs,
+        onStepFinish,
+        maxSteps,
+        tools,
+        convertedTools,
+        runId,
+        temperature,
+        ...rest
+      });
+    }
+    return await this.__textObject({
+      messages: msgs,
+      structuredOutput: output,
+      onStepFinish,
+      maxSteps,
+      tools,
+      convertedTools,
+      runId,
+      telemetry,
+      ...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.#mastra = config.mastra;
+    }
+    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.#mastra = p;
+    this.logger.debug(`[Agents:${this.name}] initialized.`, {
+      model: this.model,
+      name: this.name
+    });
+  }
+  /**
+   * 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 {
+      object
+    } = await this.llm.__textObject({
+      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`
+      }, {
+        role: "user",
+        content: JSON.stringify(message)
+      }],
+      structuredOutput: zod.z.object({
+        title: zod.z.string()
+      })
+    });
+    return object.title;
+  }
+  getMostRecentUserMessage(messages) {
+    const userMessages = messages.filter(message => message.role === "user");
+    return userMessages.at(-1);
+  }
+  async genTitle(userMessage) {
+    let title = "New Thread";
+    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) {
+      let thread;
+      if (!threadId) {
+        this.logger.debug(`No threadId, creating new thread for agent ${this.name}`, {
+          runId: runId || this.name
+        });
+        const title = await this.genTitle(userMessage);
+        thread = await memory.createThread({
+          threadId,
+          resourceId,
+          title,
+          memoryConfig
+        });
+      } 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 = await this.genTitle(userMessage);
+          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 (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 (typeof message.content === "string") 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 converted = Object.entries(this.tools || {}).reduce((memo, value) => {
+      const k = value[0];
+      const tool = this.tools[k];
+      if (tool) {
+        memo[k] = {
+          description: tool.description,
+          parameters: tool.inputSchema,
+          execute: typeof tool?.execute === "function" ? async (args, options) => {
+            try {
+              this.logger.debug(`[Agent:${this.name}] - Executing tool ${k}`, {
+                name: k,
+                description: tool.description,
+                args,
+                runId,
+                threadId,
+                resourceId
+              });
+              return tool?.execute?.({
+                context: args,
+                mastra: this.#mastra,
+                runId,
+                threadId,
+                resourceId
+              }, options) ?? void 0;
+            } catch (err) {
+              this.logger.error(`[Agent:${this.name}] - Failed execution`, {
+                error: err,
+                runId,
+                threadId,
+                resourceId
+              });
+              throw err;
+            }
+          } : void 0
+        };
+      }
+      return memo;
+    }, {});
+    const toolsFromToolsetsConverted = {
+      ...converted
+    };
+    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;
+          toolsFromToolsetsConverted[toolName] = {
+            description: toolObj.description || "",
+            parameters: toolObj.inputSchema,
+            execute: typeof toolObj?.execute === "function" ? async (args, options) => {
+              try {
+                this.logger.debug(`[Agent:${this.name}] - Executing tool ${toolName}`, {
+                  name: toolName,
+                  description: toolObj.description,
+                  args,
+                  runId,
+                  threadId,
+                  resourceId
+                });
+                return toolObj?.execute?.({
+                  context: args,
+                  runId,
+                  threadId,
+                  resourceId
+                }, options) ?? void 0;
+              } catch (error) {
+                this.logger.error(`[Agent:${this.name}] - Failed toolset execution`, {
+                  error,
+                  runId,
+                  threadId,
+                  resourceId
+                });
+                throw error;
+              }
+            } : void 0
+          };
+        });
+      });
+    }
+    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,
+        ...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,
+        ...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,
+      ...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,
+        ...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,
+        ...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,
+      ...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;
+})();