freestyle-sandboxes 0.0.97 → 0.1.0

package/dist/mastra/index.d.mts

@@ -1,2623 +0,0 @@
-/// <reference types="node" />
-import { z, ZodSchema } from 'zod';
-import { S as SpanAttributes, H as HrTime, b as SpanKind, c as SpanContext, d as SpanStatus, L as Link, e as Tracer, f as Span, T as Tool$1, g as LanguageModel, h as LanguageModelV1, C as CoreMessage$1, U as UserContent, A as AssistantContent, i as ToolContent, E as EmbeddingModel, a as ToolExecutionOptions, M as Message, J as JSONSchema7, j as TelemetrySettings, k as generateText, G as GenerateTextResult, l as generateObject, m as GenerateObjectResult, s as streamText, n as StreamTextResult, o as streamObject, p as StreamObjectResult, D as DeepPartial, q as CoreUserMessage } from '../index.d-9H_wnIbz.js';
-import { Transform } from 'stream';
-import { EventEmitter } from 'events';
-import { ServerResponse, IncomingMessage } from 'http';
-import { WorkerOptions } from 'worker_threads';
-import { F as FreestyleExecuteScriptParamsConfiguration } from '../types.gen-CJa21P0C.js';
-import 'node:http';
-
-// Type definitions for pino-std-serializers 2.4
-// Definitions by: Connor Fitzgerald <https://github.com/connorjayfitzgerald>
-//                 Igor Savin <https://github.com/kibertoad>
-// TypeScript Version: 2.7
-
-
-
-interface SerializedError {
-  /**
-   * The name of the object's constructor.
-   */
-  type: string;
-  /**
-   * The supplied error message.
-   */
-  message: string;
-  /**
-   * The stack when the error was generated.
-   */
-  stack: string;
-  /**
-   * Non-enumerable. The original Error object. This will not be included in the logged output.
-   * This is available for subsequent serializers to use.
-   */
-  raw: Error;
-  /**
-   * `cause` is never included in the log output, if you need the `cause`, use {@link raw.cause}
-   */
-  cause?: never;
-  /**
-   * Any other extra properties that have been attached to the object will also be present on the serialized object.
-   */
-  [key: string]: any;
-  [key: number]: any;
-}
-
-/**
- * Serializes an Error object. Does not serialize "err.cause" fields (will append the err.cause.message to err.message
- * and err.cause.stack to err.stack)
- */
-declare function err(err: Error): SerializedError;
-
-/**
- * Serializes an Error object, including full serialization for any err.cause fields recursively.
- */
-declare function errWithCause(err: Error): SerializedError;
-
-interface SerializedRequest {
-  /**
-   * Defaults to `undefined`, unless there is an `id` property already attached to the `request` object or
-   * to the `request.info` object. Attach a synchronous function to the `request.id` that returns an
-   * identifier to have the value filled.
-   */
-  id: string | undefined;
-  /**
-   * HTTP method.
-   */
-  method: string;
-  /**
-   * Request pathname (as per req.url in core HTTP).
-   */
-  url: string;
-  /**
-   * Reference to the `headers` object from the request (as per req.headers in core HTTP).
-   */
-  headers: Record<string, string>;
-  remoteAddress: string;
-  remotePort: number;
-  params: Record<string, string>;
-  query: Record<string, string>;
-
-  /**
-   * Non-enumerable, i.e. will not be in the output, original request object. This is available for subsequent
-   * serializers to use. In cases where the `request` input already has  a `raw` property this will
-   * replace the original `request.raw` property.
-   */
-  raw: IncomingMessage;
-}
-
-/**
- * Serializes a Request object.
- */
-declare function req(req: IncomingMessage): SerializedRequest;
-
-/**
- * Used internally by Pino for general request logging.
- */
-declare function mapHttpRequest(req: IncomingMessage): {
-  req: SerializedRequest
-};
-
-interface SerializedResponse {
-  /**
-   * HTTP status code.
-   */
-  statusCode: number;
-  /**
-   * The headers to be sent in the response.
-   */
-  headers: Record<string, string>;
-  /**
-   * Non-enumerable, i.e. will not be in the output, original response object. This is available for subsequent serializers to use.
-   */
-  raw: ServerResponse;
-}
-
-/**
- * Serializes a Response object.
- */
-declare function res(res: ServerResponse): SerializedResponse;
-
-/**
- * Used internally by Pino for general response logging.
- */
-declare function mapHttpResponse(res: ServerResponse): {
-  res: SerializedResponse
-};
-
-type CustomErrorSerializer = (err: SerializedError) => Record<string, any>;
-
-/**
- * A utility method for wrapping the default error serializer.
- * This allows custom serializers to work with the already serialized object.
- * The customSerializer accepts one parameter — the newly serialized error object — and returns the new (or updated) error object.
- */
-declare function wrapErrorSerializer(customSerializer: CustomErrorSerializer): (err: Error) => Record<string, any>;
-
-type CustomRequestSerializer = (req: SerializedRequest) => Record<string, any>;
-
-/**
- * A utility method for wrapping the default request serializer.
- * This allows custom serializers to work with the already serialized object.
- * The customSerializer accepts one parameter — the newly serialized request object — and returns the new (or updated) request object.
- */
-declare function wrapRequestSerializer(customSerializer: CustomRequestSerializer): (req: IncomingMessage) => Record<string, any>;
-
-type CustomResponseSerializer = (res: SerializedResponse) => Record<string, any>;
-
-/**
- * A utility method for wrapping the default response serializer.
- * This allows custom serializers to work with the already serialized object.
- * The customSerializer accepts one parameter — the newly serialized response object — and returns the new (or updated) response object.
- */
-declare function wrapResponseSerializer(customSerializer: CustomResponseSerializer): (res: ServerResponse) => Record<string, any>;
-
-type pinoStdSerializers_CustomErrorSerializer = CustomErrorSerializer;
-type pinoStdSerializers_CustomRequestSerializer = CustomRequestSerializer;
-type pinoStdSerializers_CustomResponseSerializer = CustomResponseSerializer;
-type pinoStdSerializers_SerializedError = SerializedError;
-type pinoStdSerializers_SerializedRequest = SerializedRequest;
-type pinoStdSerializers_SerializedResponse = SerializedResponse;
-declare const pinoStdSerializers_err: typeof err;
-declare const pinoStdSerializers_errWithCause: typeof errWithCause;
-declare const pinoStdSerializers_mapHttpRequest: typeof mapHttpRequest;
-declare const pinoStdSerializers_mapHttpResponse: typeof mapHttpResponse;
-declare const pinoStdSerializers_req: typeof req;
-declare const pinoStdSerializers_res: typeof res;
-declare const pinoStdSerializers_wrapErrorSerializer: typeof wrapErrorSerializer;
-declare const pinoStdSerializers_wrapRequestSerializer: typeof wrapRequestSerializer;
-declare const pinoStdSerializers_wrapResponseSerializer: typeof wrapResponseSerializer;
-declare namespace pinoStdSerializers {
-  export { type pinoStdSerializers_CustomErrorSerializer as CustomErrorSerializer, type pinoStdSerializers_CustomRequestSerializer as CustomRequestSerializer, type pinoStdSerializers_CustomResponseSerializer as CustomResponseSerializer, type pinoStdSerializers_SerializedError as SerializedError, type pinoStdSerializers_SerializedRequest as SerializedRequest, type pinoStdSerializers_SerializedResponse as SerializedResponse, pinoStdSerializers_err as err, pinoStdSerializers_errWithCause as errWithCause, pinoStdSerializers_mapHttpRequest as mapHttpRequest, pinoStdSerializers_mapHttpResponse as mapHttpResponse, pinoStdSerializers_req as req, pinoStdSerializers_res as res, pinoStdSerializers_wrapErrorSerializer as wrapErrorSerializer, pinoStdSerializers_wrapRequestSerializer as wrapRequestSerializer, pinoStdSerializers_wrapResponseSerializer as wrapResponseSerializer };
-}
-
-// Type definitions for sonic-boom 0.7
-// Definitions by: Alex Ferrando <https://github.com/alferpal>
-//                 Igor Savin <https://github.com/kibertoad>
-
-
-type SonicBoomOpts = {
-    fd?: number | string | symbol
-    dest?: string | number
-    maxLength?: number
-    minLength?: number
-    maxWrite?: number
-    periodicFlush?: number
-    sync?: boolean
-    fsync?: boolean
-    append?: boolean
-    mode?: string | number
-    mkdir?: boolean
-    contentMode?: 'buffer' | 'utf8'
-    retryEAGAIN?: (err: Error, writeBufferLen: number, remainingBufferLen: number) => boolean
-}
-
-declare class SonicBoom extends EventEmitter {
-    /**
-     * @param [fileDescriptor] File path or numerical file descriptor
-     * relative protocol is enabled. Default: process.stdout
-     * @returns a new sonic-boom instance
-     */
-    constructor(opts: SonicBoomOpts)
-
-    /**
-     * Writes the string to the file. It will return false to signal the producer to slow down.
-     */
-    write(string: string): boolean;
-
-    /**
-     * Writes the current buffer to the file if a write was not in progress.
-     * Do nothing if minLength is zero or if it is already writing.
-     */
-    flush(cb?: (err?: Error) => unknown): void;
-
-    /**
-     * Reopen the file in place, useful for log rotation.
-     */
-    reopen(fileDescriptor?: string | number): void;
-
-    /**
-     * Flushes the buffered data synchronously. This is a costly operation.
-     */
-    flushSync(): void;
-
-    /**
-     * Closes the stream, the data will be flushed down asynchronously
-     */
-    end(): void;
-
-    /**
-     * Closes the stream immediately, the data is not flushed.
-     */
-    destroy(): void;
-}
-
-// Project: https://github.com/pinojs/pino.git, http://getpino.io
-// Definitions by: Peter Snider <https://github.com/psnider>
-//                 BendingBender <https://github.com/BendingBender>
-//                 Christian Rackerseder <https://github.com/screendriver>
-//                 GP <https://github.com/paambaati>
-//                 Alex Ferrando <https://github.com/alferpal>
-//                 Oleksandr Sidko <https://github.com/mortiy>
-//                 Harris Lummis <https://github.com/lummish>
-//                 Raoul Jaeckel <https://github.com/raoulus>
-//                 Cory Donkin <https://github.com/Cooryd>
-//                 Adam Vigneaux <https://github.com/AdamVig>
-//                 Austin Beer <https://github.com/austin-beer>
-//                 Michel Nemnom <https://github.com/Pegase745>
-//                 Igor Savin <https://github.com/kibertoad>
-//                 James Bromwell <https://github.com/thw0rted>
-// TypeScript Version: 4.4
-
-
-
-
-
-//// Non-exported types and interfaces
-
-// ToDo https://github.com/pinojs/thread-stream/issues/24
-type ThreadStream = any
-
-type TimeFn = () => string;
-type MixinFn<CustomLevels extends string = never> = (mergeObject: object, level: number, logger:pino.Logger<CustomLevels>) => object;
-type MixinMergeStrategyFn = (mergeObject: object, mixinObject: object) => object;
-
-type CustomLevelLogger<CustomLevels extends string, UseOnlyCustomLevels extends boolean = boolean> = { 
-    /**
-     * Define additional logging levels.
-     */
-    customLevels: { [level in CustomLevels]: number };
-    /**
-     * Use only defined `customLevels` and omit Pino's levels.
-     */
-    useOnlyCustomLevels: UseOnlyCustomLevels;
- } & {
-    // This will override default log methods
-    [K in Exclude<pino.Level, CustomLevels>]: UseOnlyCustomLevels extends true ? never : pino.LogFn;
- } & {
-    [level in CustomLevels]: pino.LogFn;
- };
-
-/**
-* A synchronous callback that will run on each creation of a new child.
-* @param child: The newly created child logger instance.
-*/
-type OnChildCallback<CustomLevels extends string = never> = (child: pino.Logger<CustomLevels>) => void
-
-interface redactOptions {
-    paths: string[];
-    censor?: string | ((value: any, path: string[]) => any);
-    remove?: boolean;
-}
-
-interface LoggerExtras<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean> extends EventEmitter {
-    /**
-     * Exposes the Pino package version. Also available on the exported pino function.
-     */
-    readonly version: string;
-
-    levels: pino.LevelMapping;
-
-    /**
-     * Outputs the level as a string instead of integer.
-     */
-    useLevelLabels: boolean;
-    /**
-     * Returns the integer value for the logger instance's logging level.
-     */
-    levelVal: number;
-
-    /**
-     * Creates a child logger, setting all key-value pairs in `bindings` as properties in the log lines. All serializers will be applied to the given pair.
-     * Child loggers use the same output stream as the parent and inherit the current log level of the parent at the time they are spawned.
-     * From v2.x.x the log level of a child is mutable (whereas in v1.x.x it was immutable), and can be set independently of the parent.
-     * If a `level` property is present in the object passed to `child` it will override the child logger level.
-     *
-     * @param bindings: an object of key-value pairs to include in log lines as properties.
-     * @param options: an options object that will override child logger inherited options.
-     * @returns a child logger instance.
-     */
-    child<ChildCustomLevels extends string = never>(bindings: pino.Bindings, options?: ChildLoggerOptions<ChildCustomLevels>): pino.Logger<CustomLevels | ChildCustomLevels>;
-
-    /**
-     * This can be used to modify the callback function on creation of a new child.
-     */
-    onChild: OnChildCallback<CustomLevels>;
-
-    /**
-     * Registers a listener function that is triggered when the level is changed.
-     * Note: When browserified, this functionality will only be available if the `events` module has been required elsewhere
-     * (e.g. if you're using streams in the browser). This allows for a trade-off between bundle size and functionality.
-     *
-     * @param event: only ever fires the `'level-change'` event
-     * @param listener: The listener is passed four arguments: `levelLabel`, `levelValue`, `previousLevelLabel`, `previousLevelValue`.
-     */
-    on(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): this;
-    addListener(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): this;
-    once(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): this;
-    prependListener(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): this;
-    prependOnceListener(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): this;
-    removeListener(event: "level-change", listener: pino.LevelChangeEventListener<CustomLevels, UseOnlyCustomLevels>): this;
-
-    /**
-     * A utility method for determining if a given log level will write to the destination.
-     */
-    isLevelEnabled(level: pino.LevelWithSilentOrString): boolean;
-
-    /**
-     * Returns an object containing all the current bindings, cloned from the ones passed in via logger.child().
-     */
-    bindings(): pino.Bindings;
-
-    /**
-     * Adds to the bindings of this logger instance.
-     * Note: Does not overwrite bindings. Can potentially result in duplicate keys in log lines.
-     *
-     * @param bindings: an object of key-value pairs to include in log lines as properties.
-     */
-    setBindings(bindings: pino.Bindings): void;
-
-    /**
-     * Flushes the content of the buffer when using pino.destination({ sync: false }).
-     * call the callback when finished
-     */
-    flush(cb?: (err?: Error) => void): void;
-}
-
-
-declare namespace pino {
-    //// Exported types and interfaces
-
-    interface BaseLogger {
-        /**
-         * Set this property to the desired logging level. In order of priority, available levels are:
-         *
-         * - 'fatal'
-         * - 'error'
-         * - 'warn'
-         * - 'info'
-         * - 'debug'
-         * - 'trace'
-         *
-         * The logging level is a __minimum__ level. For instance if `logger.level` is `'info'` then all `'fatal'`, `'error'`, `'warn'`,
-         * and `'info'` logs will be enabled.
-         *
-         * You can pass `'silent'` to disable logging.
-         */
-        level: pino.LevelWithSilentOrString;
-
-        /**
-         * Log at `'fatal'` level the given msg. If the first argument is an object, all its properties will be included in the JSON line.
-         * If more args follows `msg`, these will be used to format `msg` using `util.format`.
-         *
-         * @typeParam T: the interface of the object being serialized. Default is object.
-         * @param obj: object to be serialized
-         * @param msg: the log message to write
-         * @param ...args: format string values when `msg` is a format string
-         */
-        fatal: pino.LogFn;
-        /**
-         * Log at `'error'` level the given msg. If the first argument is an object, all its properties will be included in the JSON line.
-         * If more args follows `msg`, these will be used to format `msg` using `util.format`.
-         *
-         * @typeParam T: the interface of the object being serialized. Default is object.
-         * @param obj: object to be serialized
-         * @param msg: the log message to write
-         * @param ...args: format string values when `msg` is a format string
-         */
-        error: pino.LogFn;
-        /**
-         * Log at `'warn'` level the given msg. If the first argument is an object, all its properties will be included in the JSON line.
-         * If more args follows `msg`, these will be used to format `msg` using `util.format`.
-         *
-         * @typeParam T: the interface of the object being serialized. Default is object.
-         * @param obj: object to be serialized
-         * @param msg: the log message to write
-         * @param ...args: format string values when `msg` is a format string
-         */
-        warn: pino.LogFn;
-        /**
-         * Log at `'info'` level the given msg. If the first argument is an object, all its properties will be included in the JSON line.
-         * If more args follows `msg`, these will be used to format `msg` using `util.format`.
-         *
-         * @typeParam T: the interface of the object being serialized. Default is object.
-         * @param obj: object to be serialized
-         * @param msg: the log message to write
-         * @param ...args: format string values when `msg` is a format string
-         */
-        info: pino.LogFn;
-        /**
-         * Log at `'debug'` level the given msg. If the first argument is an object, all its properties will be included in the JSON line.
-         * If more args follows `msg`, these will be used to format `msg` using `util.format`.
-         *
-         * @typeParam T: the interface of the object being serialized. Default is object.
-         * @param obj: object to be serialized
-         * @param msg: the log message to write
-         * @param ...args: format string values when `msg` is a format string
-         */
-        debug: pino.LogFn;
-        /**
-         * Log at `'trace'` level the given msg. If the first argument is an object, all its properties will be included in the JSON line.
-         * If more args follows `msg`, these will be used to format `msg` using `util.format`.
-         *
-         * @typeParam T: the interface of the object being serialized. Default is object.
-         * @param obj: object to be serialized
-         * @param msg: the log message to write
-         * @param ...args: format string values when `msg` is a format string
-         */
-        trace: pino.LogFn;
-        /**
-         * Noop function.
-         */
-        silent: pino.LogFn;
-    }
-
-    type Bindings = Record<string, any>;
-
-    type Level = "fatal" | "error" | "warn" | "info" | "debug" | "trace";
-    type LevelOrString = Level | (string & {});
-    type LevelWithSilent = pino.Level | "silent";
-    type LevelWithSilentOrString = LevelWithSilent | (string & {});
-
-    type SerializerFn = (value: any) => any;
-    type WriteFn = (o: object) => void;
-
-    type LevelChangeEventListener<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean> = (
-        lvl: LevelWithSilentOrString,
-        val: number,
-        prevLvl: LevelWithSilentOrString,
-        prevVal: number,
-        logger: Logger<CustomLevels, UseOnlyCustomLevels>
-    ) => void;
-
-    type LogDescriptor = Record<string, any>;
-
-    type Logger<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean> = BaseLogger & LoggerExtras<CustomLevels> & CustomLevelLogger<CustomLevels, UseOnlyCustomLevels>;
-
-    type SerializedError = SerializedError;
-    type SerializedResponse = SerializedResponse;
-    type SerializedRequest = SerializedRequest;
-
-
-    interface TransportTargetOptions<TransportOptions = Record<string, any>> {
-        target: string
-        options?: TransportOptions
-        level?: LevelWithSilentOrString
-    }
-
-    interface TransportBaseOptions<TransportOptions = Record<string, any>> {
-        options?: TransportOptions
-        worker?: WorkerOptions & { autoEnd?: boolean}
-    }
-
-    interface TransportSingleOptions<TransportOptions = Record<string, any>> extends TransportBaseOptions<TransportOptions>{
-        target: string
-    }
-
-    interface TransportPipelineOptions<TransportOptions = Record<string, any>> extends TransportBaseOptions<TransportOptions>{
-        pipeline: TransportSingleOptions<TransportOptions>[]
-        level?: LevelWithSilentOrString
-    }
-
-    interface TransportMultiOptions<TransportOptions = Record<string, any>> extends TransportBaseOptions<TransportOptions>{
-        targets: readonly (TransportTargetOptions<TransportOptions>|TransportPipelineOptions<TransportOptions>)[],
-        levels?: Record<string, number>
-        dedupe?: boolean
-    }
-
-    interface MultiStreamOptions {
-        levels?: Record<string, number>
-        dedupe?: boolean
-    }
-
-    interface DestinationStream {
-        write(msg: string): void;
-    }
-
-    interface DestinationStreamHasMetadata {
-      [symbols.needsMetadataGsym]: true;
-      lastLevel: number;
-      lastTime: string;
-      lastMsg: string;
-      lastObj: object;
-      lastLogger: pino.Logger;
-    }
-
-    type DestinationStreamWithMetadata = DestinationStream & ({ [symbols.needsMetadataGsym]?: false } | DestinationStreamHasMetadata);
-
-    interface StreamEntry<TLevel = Level> {
-        stream: DestinationStream
-        level?: TLevel
-    }
-
-    interface MultiStreamRes<TOriginLevel = Level> {
-        write: (data: any) => void,
-        add: <TLevel = Level>(dest: StreamEntry<TLevel> | DestinationStream) => MultiStreamRes<TOriginLevel & TLevel>,
-        flushSync: () => void,
-        minLevel: number,
-        streams: StreamEntry<TOriginLevel>[],
-        clone<TLevel = Level>(level: TLevel): MultiStreamRes<TLevel>,
-    }
-
-    interface LevelMapping {
-        /**
-         * Returns the mappings of level names to their respective internal number representation.
-         */
-        values: { [level: string]: number };
-        /**
-         * Returns the mappings of level internal level numbers to their string representations.
-         */
-        labels: { [level: number]: string };
-    }
-
-    interface LogFn {
-        // TODO: why is this different from `obj: object` or `obj: any`?
-        /* tslint:disable:no-unnecessary-generics */
-        <T extends object>(obj: T, msg?: string, ...args: any[]): void;
-        (obj: unknown, msg?: string, ...args: any[]): void;
-        (msg: string, ...args: any[]): void;
-    }
-
-    interface LoggerOptions<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean> {
-        transport?: TransportSingleOptions | TransportMultiOptions | TransportPipelineOptions
-        /**
-         * Avoid error causes by circular references in the object tree. Default: `true`.
-         */
-        safe?: boolean;
-        /**
-         * The name of the logger. Default: `undefined`.
-         */
-        name?: string;
-        /**
-         * an object containing functions for custom serialization of objects.
-         * These functions should return an JSONifiable object and they should never throw. When logging an object,
-         * each top-level property matching the exact key of a serializer will be serialized using the defined serializer.
-         */
-        serializers?: { [key: string]: SerializerFn };
-        /**
-         * Enables or disables the inclusion of a timestamp in the log message. If a function is supplied, it must
-         * synchronously return a JSON string representation of the time. If set to `false`, no timestamp will be included in the output.
-         * See stdTimeFunctions for a set of available functions for passing in as a value for this option.
-         * Caution: any sort of formatted time will significantly slow down Pino's performance.
-         */
-        timestamp?: TimeFn | boolean;
-        /**
-         * One of the supported levels or `silent` to disable logging. Any other value defines a custom level and
-         * requires supplying a level value via `levelVal`. Default: 'info'.
-         */
-        level?: LevelWithSilentOrString;
-
-        /**
-         * Use this option to define additional logging levels.
-         * The keys of the object correspond the namespace of the log level, and the values should be the numerical value of the level.
-         */
-        customLevels?: { [level in CustomLevels]: number };
-
-        /**
-         * Use this option to only use defined `customLevels` and omit Pino's levels.
-         * Logger's default `level` must be changed to a value in `customLevels` in order to use `useOnlyCustomLevels`
-         * Warning: this option may not be supported by downstream transports.
-         */
-        useOnlyCustomLevels?: UseOnlyCustomLevels;
-
-        /**
-         *  Use this option to define custom comparison of log levels.
-         *  Useful to compare custom log levels or non-standard level values.
-         *  Default: "ASC"
-         */
-        levelComparison?: "ASC" | "DESC" | ((current: number, expected: number) => boolean);
-
-        /**
-         * If provided, the `mixin` function is called each time one of the active logging methods
-         * is called. The function must synchronously return an object. The properties of the
-         * returned object will be added to the logged JSON.
-         */
-        mixin?: MixinFn<CustomLevels>;
-
-        /**
-         * If provided, the `mixinMergeStrategy` function is called each time one of the active
-         * logging methods is called. The first parameter is the value `mergeObject` or an empty object,
-         * the second parameter is the value resulting from `mixin()` or an empty object.
-         * The function must synchronously return an object.
-         */
-        mixinMergeStrategy?: MixinMergeStrategyFn
-
-        /**
-         * As an array, the redact option specifies paths that should have their values redacted from any log output.
-         *
-         * Each path must be a string using a syntax which corresponds to JavaScript dot and bracket notation.
-         *
-         * If an object is supplied, three options can be specified:
-         *
-         *      paths (String[]): Required. An array of paths
-         *      censor (String): Optional. A value to overwrite key which are to be redacted. Default: '[Redacted]'
-         *      remove (Boolean): Optional. Instead of censoring the value, remove both the key and the value. Default: false
-         */
-        redact?: string[] | redactOptions;
-
-        /**
-         * When defining a custom log level via level, set to an integer value to define the new level. Default: `undefined`.
-         */
-        levelVal?: number;
-        /**
-         * The string key for the 'message' in the JSON object. Default: "msg".
-         */
-        messageKey?: string;
-        /**
-         * The string key for the 'error' in the JSON object. Default: "err".
-         */
-        errorKey?: string;
-        /**
-         * The string key to place any logged object under.
-         */
-        nestedKey?: string;
-        /**
-         * Enables logging. Default: `true`.
-         */
-        enabled?: boolean;
-        /**
-         * Browser only, see http://getpino.io/#/docs/browser.
-         */
-        browser?: {
-            /**
-             * The `asObject` option will create a pino-like log object instead of passing all arguments to a console
-             * method. When `write` is set, `asObject` will always be true.
-             *
-             * @example
-             * pino.info('hi') // creates and logs {msg: 'hi', level: 30, time: <ts>}
-             */
-            asObject?: boolean;
-            formatters?: {
-                /**
-                 * Changes the shape of the log level.
-                 * The default shape is { level: number }.
-                 */
-                level?: (label: string, number: number) => object;
-                /**
-                 * Changes the shape of the log object.
-                 */
-                log?: (object: Record<string, unknown>) => Record<string, unknown>;
-            }
-            /**
-             * Instead of passing log messages to `console.log` they can be passed to a supplied function. If `write` is
-             * set to a single function, all logging objects are passed to this function. If `write` is an object, it
-             * can have methods that correspond to the levels. When a message is logged at a given level, the
-             * corresponding method is called. If a method isn't present, the logging falls back to using the `console`.
-             *
-             * @example
-             * const pino = require('pino')({
-             *   browser: {
-             *     write: (o) => {
-             *       // do something with o
-             *     }
-             *   }
-             * })
-             *
-             * @example
-             * const pino = require('pino')({
-             *   browser: {
-             *     write: {
-             *       info: function (o) {
-             *         //process info log object
-             *       },
-             *       error: function (o) {
-             *         //process error log object
-             *       }
-             *     }
-             *   }
-             * })
-             */
-            write?:
-                | WriteFn
-                | ({
-                fatal?: WriteFn;
-                error?: WriteFn;
-                warn?: WriteFn;
-                info?: WriteFn;
-                debug?: WriteFn;
-                trace?: WriteFn;
-            } & { [logLevel: string]: WriteFn });
-
-            /**
-             * The serializers provided to `pino` are ignored by default in the browser, including the standard
-             * serializers provided with Pino. Since the default destination for log messages is the console, values
-             * such as `Error` objects are enhanced for inspection, which they otherwise wouldn't be if the Error
-             * serializer was enabled. We can turn all serializers on or we can selectively enable them via an array.
-             *
-             * When `serialize` is `true` the standard error serializer is also enabled (see
-             * {@link https://github.com/pinojs/pino/blob/master/docs/api.md#pino-stdserializers}). This is a global
-             * serializer which will apply to any `Error` objects passed to the logger methods.
-             *
-             * If `serialize` is an array the standard error serializer is also automatically enabled, it can be
-             * explicitly disabled by including a string in the serialize array: `!stdSerializers.err` (see example).
-             *
-             * The `serialize` array also applies to any child logger serializers (see
-             * {@link https://github.com/pinojs/pino/blob/master/docs/api.md#bindingsserializers-object} for how to
-             * set child-bound serializers).
-             *
-             * Unlike server pino the serializers apply to every object passed to the logger method, if the `asObject`
-             * option is `true`, this results in the serializers applying to the first object (as in server pino).
-             *
-             * For more info on serializers see
-             * {@link https://github.com/pinojs/pino/blob/master/docs/api.md#serializers-object}.
-             *
-             * @example
-             * const pino = require('pino')({
-             *   browser: {
-             *     serialize: true
-             *   }
-             * })
-             *
-             * @example
-             * const pino = require('pino')({
-             *   serializers: {
-             *     custom: myCustomSerializer,
-             *     another: anotherSerializer
-             *   },
-             *   browser: {
-             *     serialize: ['custom']
-             *   }
-             * })
-             * // following will apply myCustomSerializer to the custom property,
-             * // but will not apply anotherSerializer to another key
-             * pino.info({custom: 'a', another: 'b'})
-             *
-             * @example
-             * const pino = require('pino')({
-             *   serializers: {
-             *     custom: myCustomSerializer,
-             *     another: anotherSerializer
-             *   },
-             *   browser: {
-             *     serialize: ['!stdSerializers.err', 'custom'] //will not serialize Errors, will serialize `custom` keys
-             *   }
-             * })
-             */
-            serialize?: boolean | string[];
-
-            /**
-             * Options for transmission of logs.
-             *
-             * @example
-             * const pino = require('pino')({
-             *   browser: {
-             *     transmit: {
-             *       level: 'warn',
-             *       send: function (level, logEvent) {
-             *         if (level === 'warn') {
-             *           // maybe send the logEvent to a separate endpoint
-             *           // or maybe analyse the messages further before sending
-             *         }
-             *         // we could also use the `logEvent.level.value` property to determine
-             *         // numerical value
-             *         if (logEvent.level.value >= 50) { // covers error and fatal
-             *
-             *           // send the logEvent somewhere
-             *         }
-             *       }
-             *     }
-             *   }
-             * })
-             */
-            transmit?: {
-                /**
-                 * Specifies the minimum level (inclusive) of when the `send` function should be called, if not supplied
-                 * the `send` function will be called based on the main logging `level` (set via `options.level`,
-                 * defaulting to `info`).
-                 */
-                level?: LevelOrString;
-                /**
-                 * Remotely record log messages.
-                 *
-                 * @description Called after writing the log message.
-                 */
-                send: (level: Level, logEvent: LogEvent) => void;
-            };
-            /**
-             * The disabled option will disable logging in browser if set to true, by default it is set to false.
-             *
-             * @example
-             * const pino = require('pino')({browser: {disabled: true}})
-             */
-            disabled?: boolean;
-        };
-        /**
-         * key-value object added as child logger to each log line. If set to null the base child logger is not added
-         */
-        base?: { [key: string]: any } | null;
-
-        /**
-         * An object containing functions for formatting the shape of the log lines.
-         * These functions should return a JSONifiable object and should never throw.
-         * These functions allow for full customization of the resulting log lines.
-         * For example, they can be used to change the level key name or to enrich the default metadata.
-         */
-        formatters?: {
-            /**
-             * Changes the shape of the log level.
-             * The default shape is { level: number }.
-             * The function takes two arguments, the label of the level (e.g. 'info') and the numeric value (e.g. 30).
-             */
-            level?: (label: string, number: number) => object;
-            /**
-             * Changes the shape of the bindings.
-             * The default shape is { pid, hostname }.
-             * The function takes a single argument, the bindings object.
-             * It will be called every time a child logger is created.
-             */
-            bindings?: (bindings: Bindings) => object;
-            /**
-             * Changes the shape of the log object.
-             * This function will be called every time one of the log methods (such as .info) is called.
-             * All arguments passed to the log method, except the message, will be pass to this function.
-             * By default it does not change the shape of the log object.
-             */
-            log?: (object: Record<string, unknown>) => Record<string, unknown>;
-        };
-
-        /**
-         * A string that would be prefixed to every message (and child message)
-         */
-        msgPrefix?: string
-
-        /**
-         * An object mapping to hook functions. Hook functions allow for customizing internal logger operations.
-         * Hook functions must be synchronous functions.
-         */
-        hooks?: {
-            /**
-             * Allows for manipulating the parameters passed to logger methods. The signature for this hook is
-             * logMethod (args, method, level) {}, where args is an array of the arguments that were passed to the
-             * log method and method is the log method itself, and level is the log level. This hook must invoke the method function by
-             * using apply, like so: method.apply(this, newArgumentsArray).
-             */
-            logMethod?: (this: Logger, args: Parameters<LogFn>, method: LogFn, level: number) => void;
-
-            /**
-             * Allows for manipulating the stringified JSON log output just before writing to various transports.
-             * This function must return a string and must be valid JSON.
-             */
-            streamWrite?: (s: string) => string;
-        };
-
-        /**
-         * Stringification limit at a specific nesting depth when logging circular object. Default: `5`.
-         */
-         depthLimit?: number
-
-         /**
-          * Stringification limit of properties/elements when logging a specific object/array with circular references. Default: `100`.
-          */
-          edgeLimit?: number
-
-        /**
-         * Optional child creation callback.
-         */
-        onChild?: OnChildCallback<CustomLevels>;
-
-        /**
-         * logs newline delimited JSON with `\r\n` instead of `\n`. Default: `false`.
-         */
-        crlf?: boolean;
-    }
-
-    interface ChildLoggerOptions<CustomLevels extends string = never> {
-        level?: LevelOrString;
-        serializers?: { [key: string]: SerializerFn };
-        customLevels?: { [level in CustomLevels]: number };
-        formatters?: {
-            level?: (label: string, number: number) => object;
-            bindings?: (bindings: Bindings) => object;
-            log?: (object: object) => object;
-        };
-        redact?: string[] | redactOptions;
-        msgPrefix?: string
-    }
-
-    /**
-     * A data structure representing a log message, it represents the arguments passed to a logger statement, the level
-     * at which they were logged and the hierarchy of child bindings.
-     *
-     * @description By default serializers are not applied to log output in the browser, but they will always be applied
-     * to `messages` and `bindings` in the `logEvent` object. This allows  us to ensure a consistent format for all
-     * values between server and client.
-     */
-    interface LogEvent {
-        /**
-         * Unix epoch timestamp in milliseconds, the time is taken from the moment the logger method is called.
-         */
-        ts: number;
-        /**
-         * All arguments passed to logger method, (for instance `logger.info('a', 'b', 'c')` would result in `messages`
-         * array `['a', 'b', 'c']`).
-         */
-        messages: any[];
-        /**
-         * Represents each child logger (if any), and the relevant bindings.
-         *
-         * @description For instance, given `logger.child({a: 1}).child({b: 2}).info({c: 3})`, the bindings array would
-         * hold `[{a: 1}, {b: 2}]` and the `messages` array would be `[{c: 3}]`. The `bindings` are ordered according to
-         * their position in the child logger hierarchy, with the lowest index being the top of the hierarchy.
-         */
-        bindings: Bindings[];
-        /**
-         * Holds the `label` (for instance `info`), and the corresponding numerical `value` (for instance `30`).
-         * This could be important in cases where client side level values and labels differ from server side.
-         */
-        level: {
-            label: string;
-            value: number;
-        };
-    }
-
-
-
-    //// Top level variable (const) exports
-
-    /**
-     * Provides functions for serializing objects common to many projects.
-     */
-    export const stdSerializers: typeof pinoStdSerializers;
-
-    /**
-     * Holds the current log format version (as output in the v property of each log record).
-     */
-    export const levels: LevelMapping;
-    export const symbols: {
-        readonly setLevelSym: unique symbol;
-        readonly getLevelSym: unique symbol;
-        readonly levelValSym: unique symbol;
-        readonly useLevelLabelsSym: unique symbol;
-        readonly mixinSym: unique symbol;
-        readonly lsCacheSym: unique symbol;
-        readonly chindingsSym: unique symbol;
-        readonly parsedChindingsSym: unique symbol;
-        readonly asJsonSym: unique symbol;
-        readonly writeSym: unique symbol;
-        readonly serializersSym: unique symbol;
-        readonly redactFmtSym: unique symbol;
-        readonly timeSym: unique symbol;
-        readonly timeSliceIndexSym: unique symbol;
-        readonly streamSym: unique symbol;
-        readonly stringifySym: unique symbol;
-        readonly stringifySafeSym: unique symbol;
-        readonly stringifiersSym: unique symbol;
-        readonly endSym: unique symbol;
-        readonly formatOptsSym: unique symbol;
-        readonly messageKeySym: unique symbol;
-        readonly errorKeySym: unique symbol;
-        readonly nestedKeySym: unique symbol;
-        readonly wildcardFirstSym: unique symbol;
-        readonly needsMetadataGsym: unique symbol;
-        readonly useOnlyCustomLevelsSym: unique symbol;
-        readonly formattersSym: unique symbol;
-        readonly hooksSym: unique symbol;
-    };
-
-    /**
-     * Exposes the Pino package version. Also available on the logger instance.
-     */
-    export const version: string;
-
-    /**
-     * Provides functions for generating the timestamp property in the log output. You can set the `timestamp` option during
-     * initialization to one of these functions to adjust the output format. Alternatively, you can specify your own time function.
-     * A time function must synchronously return a string that would be a valid component of a JSON string. For example,
-     * the default function returns a string like `,"time":1493426328206`.
-     */
-    export const stdTimeFunctions: {
-        /**
-         * The default time function for Pino. Returns a string like `,"time":1493426328206`.
-         */
-        epochTime: TimeFn;
-        /*
-            * Returns the seconds since Unix epoch
-            */
-        unixTime: TimeFn;
-        /**
-         * Returns an empty string. This function is used when the `timestamp` option is set to `false`.
-         */
-        nullTime: TimeFn;
-        /*
-            * Returns ISO 8601-formatted time in UTC
-            */
-        isoTime: TimeFn;
-    };
-
-    //// Exported functions
-
-    /**
-     * Create a Pino Destination instance: a stream-like object with significantly more throughput (over 30%) than a standard Node.js stream.
-     * @param [dest]: The `destination` parameter, can be a file descriptor, a file path, or an object with `dest` property pointing to a fd or path.
-     *                An ordinary Node.js `stream` file descriptor can be passed as the destination (such as the result of `fs.createWriteStream`)
-     *                but for peak log writing performance, it is strongly recommended to use `pino.destination` to create the destination stream.
-     * @returns A Sonic-Boom  stream to be used as destination for the pino function
-     */
-    export function destination(
-        dest?: number | object | string | DestinationStream | NodeJS.WritableStream | SonicBoomOpts,
-    ): SonicBoom;
-
-    export function transport<TransportOptions = Record<string, any>>(
-        options: TransportSingleOptions<TransportOptions> | TransportMultiOptions<TransportOptions> | TransportPipelineOptions<TransportOptions>
-    ): ThreadStream
-
-    export function multistream<TLevel = Level>(
-        streamsArray: (DestinationStream | StreamEntry<TLevel>)[] | DestinationStream | StreamEntry<TLevel>,
-        opts?: MultiStreamOptions
-    ): MultiStreamRes<TLevel>
-}
-
-//// Callable default export
-
-/**
- * @param [optionsOrStream]: an options object or a writable stream where the logs will be written. It can also receive some log-line metadata, if the
- * relative protocol is enabled. Default: process.stdout
- * @returns a new logger instance.
- */
-declare function pino<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean>(optionsOrStream?: LoggerOptions<CustomLevels, UseOnlyCustomLevels> | DestinationStream): Logger$1<CustomLevels, UseOnlyCustomLevels>;
-
-/**
- * @param [options]: an options object
- * @param [stream]: a writable stream where the logs will be written. It can also receive some log-line metadata, if the
- * relative protocol is enabled. Default: process.stdout
- * @returns a new logger instance.
- */
-declare function pino<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean>(options: LoggerOptions<CustomLevels, UseOnlyCustomLevels>, stream?: DestinationStream | undefined): Logger$1<CustomLevels, UseOnlyCustomLevels>;
-type Logger$1<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean> = pino.Logger<CustomLevels, UseOnlyCustomLevels>;
-interface ChildLoggerOptions<CustomLevels extends string = never> extends pino.ChildLoggerOptions<CustomLevels> {}
-interface DestinationStream extends pino.DestinationStream {}
-interface LoggerOptions<CustomLevels extends string = never, UseOnlyCustomLevels extends boolean = boolean> extends pino.LoggerOptions<CustomLevels, UseOnlyCustomLevels> {}
-
-type RunStatus = 'created' | 'running' | 'completed' | 'failed';
-type Run = {
-    runId?: string;
-    runStatus?: RunStatus;
-};
-
-declare const RegisteredLogger: {
-    readonly AGENT: "AGENT";
-    readonly WORKFLOW: "WORKFLOW";
-    readonly LLM: "LLM";
-    readonly TTS: "TTS";
-    readonly VOICE: "VOICE";
-    readonly VECTOR: "VECTOR";
-    readonly BUNDLER: "BUNDLER";
-    readonly DEPLOYER: "DEPLOYER";
-    readonly MEMORY: "MEMORY";
-    readonly STORAGE: "STORAGE";
-    readonly EMBEDDINGS: "EMBEDDINGS";
-};
-type RegisteredLogger = (typeof RegisteredLogger)[keyof typeof RegisteredLogger];
-declare const LogLevel: {
-    readonly DEBUG: "debug";
-    readonly INFO: "info";
-    readonly WARN: "warn";
-    readonly ERROR: "error";
-    readonly NONE: "silent";
-};
-type LogLevel = (typeof LogLevel)[keyof typeof LogLevel];
-interface BaseLogMessage extends Run {
-    msg: string;
-    level: number;
-    time: Date;
-    pid: number;
-    hostname: string;
-    name: string;
-}
-declare class LoggerTransport extends Transform {
-    constructor(opts?: any);
-    getLogsByRunId(_args: {
-        runId: string;
-    }): Promise<BaseLogMessage[]>;
-    getLogs(): Promise<BaseLogMessage[]>;
-}
-type TransportMap = Record<string, LoggerTransport>;
-declare class Logger {
-    protected logger: pino.Logger;
-    transports: TransportMap;
-    constructor(options?: {
-        name?: string;
-        level?: LogLevel;
-        transports?: TransportMap;
-        overrideDefaultTransports?: boolean;
-    });
-    debug(message: string, args?: Record<string, any>): void;
-    info(message: string, args?: Record<string, any>): void;
-    warn(message: string, args?: Record<string, any>): void;
-    error(message: string, args?: Record<string, any>): void;
-    createStream(): Transform;
-    getLogs(transportId: string): Promise<BaseLogMessage[]>;
-    getLogsByRunId({ runId, transportId }: {
-        transportId: string;
-        runId: string;
-    }): Promise<BaseLogMessage[] | undefined>;
-}
-
-/**
- * An instrumentation library consists of the name and optional version
- * used to obtain a tracer or meter from a provider. This metadata is made
- * available on ReadableSpan and MetricRecord for use by the export pipeline.
- * @deprecated Use {@link InstrumentationScope} instead.
- */
-interface InstrumentationLibrary {
-    readonly name: string;
-    readonly version?: string;
-    readonly schemaUrl?: string;
-}
-
-interface ExportResult {
-    code: ExportResultCode;
-    error?: Error;
-}
-declare enum ExportResultCode {
-    SUCCESS = 0,
-    FAILED = 1
-}
-
-/**
- * An interface that represents a resource. A Resource describes the entity for which signals (metrics or trace) are
- * collected.
- *
- */
-interface IResource {
-    /**
-     * Check if async attributes have resolved. This is useful to avoid awaiting
-     * waitForAsyncAttributes (which will introduce asynchronous behavior) when not necessary.
-     *
-     * @returns true if the resource "attributes" property is not yet settled to its final value
-     */
-    asyncAttributesPending?: boolean;
-    /**
-     * @returns the Resource's attributes.
-     */
-    readonly attributes: ResourceAttributes;
-    /**
-     * Returns a promise that will never be rejected. Resolves when all async attributes have finished being added to
-     * this Resource's attributes. This is useful in exporters to block until resource detection
-     * has finished.
-     */
-    waitForAsyncAttributes?(): Promise<void>;
-    /**
-     * Returns a new, merged {@link Resource} by merging the current Resource
-     * with the other Resource. In case of a collision, other Resource takes
-     * precedence.
-     *
-     * @param other the Resource that will be merged with this.
-     * @returns the newly merged Resource.
-     */
-    merge(other: IResource | null): IResource;
-}
-
-/**
- * Interface for Resource attributes.
- * General `Attributes` interface is added in api v1.1.0.
- * To backward support older api (1.0.x), the deprecated `SpanAttributes` is used here.
- */
-declare type ResourceAttributes = SpanAttributes;
-
-/**
- * Represents a timed event.
- * A timed event is an event with a timestamp.
- */
-interface TimedEvent {
-    time: HrTime;
-    /** The name of the event. */
-    name: string;
-    /** The attributes of the event. */
-    attributes?: SpanAttributes;
-    /** Count of attributes of the event that were dropped due to collection limits */
-    droppedAttributesCount?: number;
-}
-
-interface ReadableSpan {
-    readonly name: string;
-    readonly kind: SpanKind;
-    readonly spanContext: () => SpanContext;
-    readonly parentSpanId?: string;
-    readonly startTime: HrTime;
-    readonly endTime: HrTime;
-    readonly status: SpanStatus;
-    readonly attributes: SpanAttributes;
-    readonly links: Link[];
-    readonly events: TimedEvent[];
-    readonly duration: HrTime;
-    readonly ended: boolean;
-    readonly resource: IResource;
-    readonly instrumentationLibrary: InstrumentationLibrary;
-    readonly droppedAttributesCount: number;
-    readonly droppedEventsCount: number;
-    readonly droppedLinksCount: number;
-}
-
-/**
- * An interface that allows different tracing services to export recorded data
- * for sampled spans in their own format.
- *
- * To export data this MUST be register to the Tracer SDK using a optional
- * config.
- */
-interface SpanExporter {
-    /**
-     * Called to export sampled {@link ReadableSpan}s.
-     * @param spans the list of sampled Spans to be exported.
-     */
-    export(spans: ReadableSpan[], resultCallback: (result: ExportResult) => void): void;
-    /** Stops the exporter. */
-    shutdown(): Promise<void>;
-    /** Immediately export all spans */
-    forceFlush?(): Promise<void>;
-}
-
-/** Sampling strategy configuration for OpenTelemetry */
-type SamplingStrategy = {
-    /** Sample traces based on a probability between 0 and 1 */
-    type: 'ratio';
-    /** Probability between 0 and 1 (e.g., 0.1 for 10% sampling) */
-    probability: number;
-} | {
-    /** Sample all traces */
-    type: 'always_on';
-} | {
-    /** Don't sample any traces */
-    type: 'always_off';
-} | {
-    /** Use parent sampling decision if available, otherwise use root sampler */
-    type: 'parent_based';
-    /** Configuration for the root sampler when no parent context exists */
-    root: {
-        /** Probability between 0 and 1 for the root sampler */
-        probability: number;
-    };
-};
-/** Configuration options for OpenTelemetry */
-type OtelConfig = {
-    /** Name of the service for telemetry identification */
-    serviceName?: string;
-    /** Whether telemetry is enabled. Defaults to true */
-    enabled?: boolean;
-    /** Name of the tracer to use. Defaults to 'mastra-tracer' */
-    tracerName?: string;
-    /** Sampling configuration to control trace data volume */
-    sampling?: SamplingStrategy;
-    /** Export configuration for sending telemetry data */
-    export?: {
-        /** Export to an OTLP (OpenTelemetry Protocol) endpoint */
-        type: 'otlp';
-        /** Whether to use gRPC or HTTP for OTLP */
-        protocol?: 'grpc' | 'http';
-        /** OTLP endpoint URL */
-        endpoint?: string;
-        /** Optional headers for OTLP requests */
-        headers?: Record<string, string>;
-    } | {
-        /** Export to console for development/debugging */
-        type: 'console';
-    } | {
-        type: 'custom';
-        tracerName?: string;
-        exporter: SpanExporter;
-    };
-};
-
-declare global {
-    var __TELEMETRY__: Telemetry | undefined;
-}
-declare class Telemetry {
-    tracer: Tracer;
-    name: string;
-    private constructor();
-    /**
-     * @deprecated This method does not do anything
-     */
-    shutdown(): Promise<void>;
-    /**
-     * Initialize telemetry with the given configuration
-     * @param config - Optional telemetry configuration object
-     * @returns Telemetry instance that can be used for tracing
-     */
-    static init(config?: OtelConfig): Telemetry;
-    /**
-     * Get the global telemetry instance
-     * @throws {Error} If telemetry has not been initialized
-     * @returns {Telemetry} The global telemetry instance
-     */
-    static get(): Telemetry;
-    /**
-     * Wraps a class instance with telemetry tracing
-     * @param instance The class instance to wrap
-     * @param options Optional configuration for tracing
-     * @returns Wrapped instance with all methods traced
-     */
-    traceClass<T extends object>(instance: T, options?: {
-        /** Base name for spans (e.g. 'integration', 'agent') */
-        spanNamePrefix?: string;
-        /** Additional attributes to add to all spans */
-        attributes?: Record<string, string>;
-        /** Methods to exclude from tracing */
-        excludeMethods?: string[];
-        /** Skip tracing if telemetry is not active */
-        skipIfNoTelemetry?: boolean;
-    }): T;
-    /**
-     * method to trace individual methods with proper context
-     * @param method The method to trace
-     * @param context Additional context for the trace
-     * @returns Wrapped method with tracing
-     */
-    traceMethod<TMethod extends Function>(method: TMethod, context: {
-        spanName: string;
-        attributes?: Record<string, string>;
-        skipIfNoTelemetry?: boolean;
-        parentSpan?: Span;
-    }): TMethod;
-    getBaggageTracer(): Tracer;
-}
-
-declare class MastraBase {
-    component: RegisteredLogger;
-    protected logger: Logger;
-    name?: string;
-    telemetry?: Telemetry;
-    constructor({ component, name }: {
-        component?: RegisteredLogger;
-        name?: string;
-    });
-    /**
-     * Set the logger for the agent
-     * @param logger
-     */
-    __setLogger(logger: Logger): void;
-    /**
-     * Set the telemetry for the
-     * @param telemetry
-     */
-    __setTelemetry(telemetry: Telemetry): void;
-    /**
-     * Get the telemetry on the vector
-     * @returns telemetry
-     */
-    __getTelemetry(): Telemetry | undefined;
-    get experimental_telemetry(): {
-        tracer: Tracer;
-        isEnabled: boolean;
-    } | undefined;
-}
-
-type BasicValueQuery<TValue> = {
-    $eq?: TValue;
-    $ne?: TValue;
-    $lt?: TValue;
-    $gt?: TValue;
-    $lte?: TValue;
-    $gte?: TValue;
-    $in?: TValue[];
-    $nin?: TValue[];
-    $all?: TValue[];
-    $mod?: [number, number];
-    $exists?: boolean;
-    $regex?: string | RegExp;
-    $size?: number;
-    $where?: ((this: TValue, obj: TValue) => boolean) | string;
-    $options?: "i" | "g" | "m" | "u";
-    $type?: Function;
-    $not?: NestedQuery<TValue>;
-    $or?: NestedQuery<TValue>[];
-    $nor?: NestedQuery<TValue>[];
-    $and?: NestedQuery<TValue>[];
-};
-type ArrayValueQuery<TValue> = {
-    $elemMatch?: Query<TValue>;
-} & BasicValueQuery<TValue>;
-type Unpacked<T> = T extends (infer U)[] ? U : T;
-type ValueQuery<TValue> = TValue extends Array<any> ? ArrayValueQuery<Unpacked<TValue>> : BasicValueQuery<TValue>;
-type NotObject = string | number | Date | boolean | Array<any>;
-type ShapeQuery<TItemSchema> = TItemSchema extends NotObject ? {} : {
-    [k in keyof TItemSchema]?: TItemSchema[k] | ValueQuery<TItemSchema[k]>;
-};
-type NestedQuery<TItemSchema> = ValueQuery<TItemSchema> & ShapeQuery<TItemSchema>;
-type Query<TItemSchema> = TItemSchema | RegExp | NestedQuery<TItemSchema>;
-
-interface MetricResult {
-    score: number;
-    info?: Record<string, any>;
-}
-declare abstract class Metric {
-    abstract measure(input: string, output: string): Promise<MetricResult>;
-}
-
-interface TestInfo {
-    testName?: string;
-    testPath?: string;
-}
-
-interface IBundler {
-    loadEnvVars(): Promise<Map<string, string>>;
-    getEnvFiles(): Promise<string[]>;
-    bundle(entryFile: string, outputDirectory: string): Promise<void>;
-    prepare(outputDirectory: string): Promise<void>;
-    writePackageJson(outputDirectory: string, dependencies: Map<string, string>): Promise<void>;
-}
-declare abstract class MastraBundler extends MastraBase implements IBundler {
-    constructor({ name, component }: {
-        name: string;
-        component?: 'BUNDLER' | 'DEPLOYER';
-    });
-    loadEnvVars(): Promise<Map<string, string>>;
-    abstract prepare(outputDirectory: string): Promise<void>;
-    abstract writePackageJson(outputDirectory: string, dependencies: Map<string, string>): Promise<void>;
-    abstract writeInstrumentationFile(outputDirectory: string): Promise<void>;
-    abstract getEnvFiles(): Promise<string[]>;
-    abstract bundle(entryFile: string, outputDirectory: string): Promise<void>;
-}
-
-interface IDeployer extends IBundler {
-    deploy(outputDirectory: string): Promise<void>;
-}
-declare abstract class MastraDeployer extends MastraBundler implements IDeployer {
-    constructor({ name }: {
-        name: string;
-    });
-    abstract deploy(outputDirectory: string): Promise<void>;
-}
-
-type BasicOperator = '$eq' | '$ne';
-type NumericOperator = '$gt' | '$gte' | '$lt' | '$lte';
-type LogicalOperator = '$and' | '$not' | '$nor' | '$or';
-type ArrayOperator = '$all' | '$in' | '$nin' | '$elemMatch';
-type ElementOperator = '$exists';
-type RegexOperator = '$regex' | '$options';
-type QueryOperator = BasicOperator | NumericOperator | LogicalOperator | ArrayOperator | ElementOperator | RegexOperator;
-type OperatorCondition = {
-    [K in QueryOperator]?: any;
-};
-type FieldCondition = OperatorCondition | any;
-type VectorFilter = {
-    [field: string]: FieldCondition | VectorFilter;
-} | null | undefined;
-
-interface QueryResult {
-    id: string;
-    score: number;
-    metadata?: Record<string, any>;
-    vector?: number[];
-    /**
-     * The document content, if available.
-     * Note: Currently only supported by Chroma vector store.
-     * For other vector stores, documents should be stored in metadata.
-     */
-    document?: string;
-}
-interface IndexStats {
-    dimension: number;
-    count: number;
-    metric?: 'cosine' | 'euclidean' | 'dotproduct';
-}
-interface UpsertVectorParams {
-    indexName: string;
-    vectors: number[][];
-    metadata?: Record<string, any>[];
-    ids?: string[];
-}
-type UpsertVectorArgs = [string, number[][], Record<string, any>[], string[]?];
-interface CreateIndexParams {
-    indexName: string;
-    dimension: number;
-    metric?: 'cosine' | 'euclidean' | 'dotproduct';
-}
-type CreateIndexArgs = [string, number, 'cosine' | 'euclidean' | 'dotproduct'];
-interface QueryVectorParams {
-    indexName: string;
-    queryVector: number[];
-    topK?: number;
-    filter?: VectorFilter;
-    includeVector?: boolean;
-}
-type QueryVectorArgs = [string, number[], number, VectorFilter?, boolean?];
-type ParamsToArgs<T> = [T] | (T extends QueryVectorParams ? QueryVectorArgs : never) | (T extends UpsertVectorParams ? UpsertVectorArgs : never) | (T extends CreateIndexParams ? CreateIndexArgs : never);
-
-declare abstract class MastraVector extends MastraBase {
-    constructor();
-    private readonly baseKeys;
-    protected normalizeArgs<T, E extends any[] = never>(method: string, [first, ...rest]: ParamsToArgs<T> | E, extendedKeys?: string[]): T;
-    abstract query<E extends QueryVectorArgs = QueryVectorArgs>(...args: ParamsToArgs<QueryVectorParams> | E): Promise<QueryResult[]>;
-    abstract upsert<E extends UpsertVectorArgs = UpsertVectorArgs>(...args: ParamsToArgs<UpsertVectorParams> | E): Promise<string[]>;
-    abstract createIndex<E extends CreateIndexArgs = CreateIndexArgs>(...args: ParamsToArgs<CreateIndexParams> | E): Promise<void>;
-    abstract listIndexes(): Promise<string[]>;
-    abstract describeIndex(indexName: string): Promise<IndexStats>;
-    abstract deleteIndex(indexName: string): Promise<void>;
-    updateIndexById(_indexName: string, _id: string, _update: {
-        vector?: number[];
-        metadata?: Record<string, any>;
-    }): Promise<void>;
-    deleteIndexById(_indexName: string, _id: string): Promise<void>;
-}
-
-interface BuiltInModelConfig$1 {
-    provider: string;
-    name: string;
-    apiKey?: string;
-}
-interface TTSConfig {
-    model: BuiltInModelConfig$1;
-}
-declare abstract class MastraTTS extends MastraBase {
-    model: BuiltInModelConfig$1;
-    constructor({ model }: TTSConfig);
-    traced<T extends Function>(method: T, methodName: string): T;
-    abstract generate({ text }: {
-        text: string;
-    }): Promise<any>;
-    abstract stream({ text }: {
-        text: string;
-    }): Promise<any>;
-}
-
-interface BuiltInModelConfig {
-    name: string;
-    apiKey?: string;
-}
-interface VoiceConfig {
-    listeningModel?: BuiltInModelConfig;
-    speechModel?: BuiltInModelConfig;
-    speaker?: string;
-}
-declare abstract class MastraVoice extends MastraBase {
-    protected listeningModel?: BuiltInModelConfig;
-    protected speechModel?: BuiltInModelConfig;
-    protected speaker?: string;
-    constructor({ listeningModel, speechModel, speaker }?: VoiceConfig);
-    traced<T extends Function>(method: T, methodName: string): T;
-    /**
-     * Convert text to speech
-     * @param input Text or text stream to convert to speech
-     * @param options Speech options including speaker and provider-specific options
-     * @returns Audio stream
-     */
-    abstract speak(input: string | NodeJS.ReadableStream, options?: {
-        speaker?: string;
-        [key: string]: any;
-    }): Promise<NodeJS.ReadableStream>;
-    /**
-     * Convert speech to text
-     * @param audioStream Audio stream to transcribe
-     * @param options Provider-specific transcription options
-     * @returns Text or text stream
-     */
-    abstract listen(audioStream: NodeJS.ReadableStream, options?: {
-        [key: string]: any;
-    }): Promise<string | NodeJS.ReadableStream>;
-    /**
-     * Get available speakers/voices
-     * @returns Array of available voice IDs and their metadata
-     */
-    abstract getSpeakers(): Promise<Array<{
-        voiceId: string;
-        [key: string]: any;
-    }>>;
-}
-
-declare class CompositeVoice extends MastraVoice {
-    protected speakProvider?: MastraVoice;
-    protected listenProvider?: MastraVoice;
-    constructor({ speakProvider, listenProvider }: {
-        speakProvider?: MastraVoice;
-        listenProvider?: MastraVoice;
-    });
-    speak(input: string | NodeJS.ReadableStream, options?: any): Promise<NodeJS.ReadableStream>;
-    listen(audioStream: NodeJS.ReadableStream, options?: any): Promise<string | NodeJS.ReadableStream>;
-    getSpeakers(): Promise<{
-        [key: string]: any;
-        voiceId: string;
-    }[]>;
-}
-
-type VercelTool = Tool$1;
-type CoreTool = {
-    description?: string;
-    parameters: ZodSchema;
-    execute?: (params: any, options: ToolExecutionOptions) => Promise<any>;
-};
-interface ToolExecutionContext<TSchemaIn extends z.ZodSchema | undefined = undefined> extends IExecutionContext<TSchemaIn> {
-    mastra?: MastraUnion;
-}
-interface ToolAction<TSchemaIn extends z.ZodSchema | undefined = undefined, TSchemaOut extends z.ZodSchema | undefined = undefined, TContext extends ToolExecutionContext<TSchemaIn> = ToolExecutionContext<TSchemaIn>, TOptions extends unknown = unknown> extends IAction<string, TSchemaIn, TSchemaOut, TContext, TOptions> {
-    description: string;
-    execute?: (context: TContext, options?: TOptions) => Promise<TSchemaOut extends z.ZodSchema ? z.infer<TSchemaOut> : unknown>;
-    mastra?: Mastra;
-}
-
-/**
- * Abstract Memory class that defines the interface for storing and retrieving
- * conversation threads and messages.
- */
-declare abstract class MastraMemory extends MastraBase {
-    MAX_CONTEXT_TOKENS?: number;
-    storage: MastraStorage;
-    vector: MastraVector;
-    embedder: EmbeddingModel<string>;
-    protected threadConfig: MemoryConfig;
-    constructor(config: {
-        name: string;
-    } & SharedMemoryConfig);
-    setStorage(storage: MastraStorage): void;
-    setVector(vector: MastraVector): void;
-    setEmbedder(embedder: EmbeddingModel<string>): void;
-    /**
-     * Get a system message to inject into the conversation.
-     * This will be called before each conversation turn.
-     * Implementations can override this to inject custom system messages.
-     */
-    getSystemMessage(_input: {
-        threadId: string;
-        memoryConfig?: MemoryConfig;
-    }): Promise<string | null>;
-    /**
-     * Get tools that should be available to the agent.
-     * This will be called when converting tools for the agent.
-     * Implementations can override this to provide additional tools.
-     */
-    getTools(_config?: MemoryConfig): Record<string, CoreTool>;
-    protected createEmbeddingIndex(): Promise<{
-        indexName: string;
-    }>;
-    getMergedThreadConfig(config?: MemoryConfig): MemoryConfig;
-    abstract rememberMessages({ threadId, resourceId, vectorMessageSearch, config, }: {
-        threadId: string;
-        resourceId?: string;
-        vectorMessageSearch?: string;
-        config?: MemoryConfig;
-    }): Promise<{
-        threadId: string;
-        messages: CoreMessage$1[];
-        uiMessages: Message[];
-    }>;
-    estimateTokens(text: string): number;
-    protected parseMessages(messages: MessageType[]): CoreMessage$1[];
-    protected convertToUIMessages(messages: MessageType[]): Message[];
-    /**
-     * Retrieves a specific thread by its ID
-     * @param threadId - The unique identifier of the thread
-     * @returns Promise resolving to the thread or null if not found
-     */
-    abstract getThreadById({ threadId }: {
-        threadId: string;
-    }): Promise<StorageThreadType | null>;
-    abstract getThreadsByResourceId({ resourceId }: {
-        resourceId: string;
-    }): Promise<StorageThreadType[]>;
-    /**
-     * Saves or updates a thread
-     * @param thread - The thread data to save
-     * @returns Promise resolving to the saved thread
-     */
-    abstract saveThread({ thread, memoryConfig, }: {
-        thread: StorageThreadType;
-        memoryConfig?: MemoryConfig;
-    }): Promise<StorageThreadType>;
-    /**
-     * Saves messages to a thread
-     * @param messages - Array of messages to save
-     * @returns Promise resolving to the saved messages
-     */
-    abstract saveMessages({ messages, memoryConfig, }: {
-        messages: MessageType[];
-        memoryConfig: MemoryConfig | undefined;
-    }): Promise<MessageType[]>;
-    /**
-     * Retrieves all messages for a specific thread
-     * @param threadId - The unique identifier of the thread
-     * @returns Promise resolving to array of messages and uiMessages
-     */
-    abstract query({ threadId, resourceId, selectBy, }: StorageGetMessagesArg): Promise<{
-        messages: CoreMessage$1[];
-        uiMessages: Message[];
-    }>;
-    /**
-     * Helper method to create a new thread
-     * @param title - Optional title for the thread
-     * @param metadata - Optional metadata for the thread
-     * @returns Promise resolving to the created thread
-     */
-    createThread({ threadId, resourceId, title, metadata, memoryConfig, }: {
-        resourceId: string;
-        threadId?: string;
-        title?: string;
-        metadata?: Record<string, unknown>;
-        memoryConfig?: MemoryConfig;
-    }): Promise<StorageThreadType>;
-    /**
-     * Helper method to delete a thread
-     * @param threadId - the id of the thread to delete
-     */
-    abstract deleteThread(threadId: string): Promise<void>;
-    /**
-     * Helper method to add a single message to a thread
-     * @param threadId - The thread to add the message to
-     * @param content - The message content
-     * @param role - The role of the message sender
-     * @param type - The type of the message
-     * @param toolNames - Optional array of tool names that were called
-     * @param toolCallArgs - Optional array of tool call arguments
-     * @param toolCallIds - Optional array of tool call ids
-     * @returns Promise resolving to the saved message
-     */
-    addMessage({ threadId, config, content, role, type, toolNames, toolCallArgs, toolCallIds, }: {
-        threadId: string;
-        config?: MemoryConfig;
-        content: UserContent | AssistantContent;
-        role: 'user' | 'assistant';
-        type: 'text' | 'tool-call' | 'tool-result';
-        toolNames?: string[];
-        toolCallArgs?: Record<string, unknown>[];
-        toolCallIds?: string[];
-    }): Promise<MessageType>;
-    /**
-     * Generates a unique identifier
-     * @returns A unique string ID
-     */
-    generateId(): string;
-}
-
-declare class Step<TStepId extends string = any, TSchemaIn extends z.ZodSchema | undefined = undefined, TSchemaOut extends z.ZodSchema | undefined = undefined, TContext extends StepExecutionContext<TSchemaIn> = StepExecutionContext<TSchemaIn>> implements StepAction<TStepId, TSchemaIn, TSchemaOut, TContext> {
-    id: TStepId;
-    description?: string;
-    inputSchema?: TSchemaIn;
-    outputSchema?: TSchemaOut;
-    payload?: TSchemaIn extends z.ZodSchema ? Partial<z.infer<TSchemaIn>> : unknown;
-    execute: (context: TContext) => Promise<TSchemaOut extends z.ZodSchema ? z.infer<TSchemaOut> : unknown>;
-    retryConfig?: RetryConfig;
-    mastra?: Mastra;
-    constructor({ id, description, execute, payload, outputSchema, inputSchema, retryConfig, }: StepAction<TStepId, TSchemaIn, TSchemaOut, TContext>);
-}
-
-interface WorkflowOptions<TTriggerSchema extends z.ZodObject<any> = any> {
-    name: string;
-    triggerSchema?: TTriggerSchema;
-    events?: Record<string, {
-        schema: z.ZodObject<any>;
-    }>;
-    retryConfig?: RetryConfig;
-    mastra?: Mastra;
-}
-interface StepExecutionContext<TSchemaIn extends z.ZodSchema | undefined = undefined, TContext extends WorkflowContext = WorkflowContext> extends IExecutionContext<TSchemaIn> {
-    context: TSchemaIn extends z.ZodSchema ? z.infer<TSchemaIn> & TContext : TContext;
-    suspend: (payload?: unknown) => Promise<void>;
-    runId: string;
-    mastra?: MastraUnion;
-}
-interface StepAction<TId extends string, TSchemaIn extends z.ZodSchema | undefined, TSchemaOut extends z.ZodSchema | undefined, TContext extends StepExecutionContext<TSchemaIn>> extends IAction<TId, TSchemaIn, TSchemaOut, TContext> {
-    mastra?: Mastra;
-    payload?: TSchemaIn extends z.ZodSchema ? Partial<z.infer<TSchemaIn>> : unknown;
-    execute: (context: TContext) => Promise<TSchemaOut extends z.ZodSchema ? z.infer<TSchemaOut> : unknown>;
-    retryConfig?: RetryConfig;
-}
-interface SimpleConditionalType {
-    [key: `${string}.${string}`]: string | Query<any>;
-}
-type StepVariableType<TId extends string, TSchemaIn extends z.ZodSchema | undefined, TSchemaOut extends z.ZodSchema | undefined, TContext extends StepExecutionContext<TSchemaIn>> = StepAction<TId, TSchemaIn, TSchemaOut, TContext> | 'trigger' | {
-    id: string;
-};
-type StepNode = {
-    step: StepAction<any, any, any, any>;
-    config: StepDef<any, any, any, any>[any];
-};
-type StepGraph = {
-    initial: StepNode[];
-    [key: string]: StepNode[];
-};
-type RetryConfig = {
-    attempts?: number;
-    delay?: number;
-};
-type VariableReference<TStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodObject<any>> = TStep extends StepAction<any, any, any, any> ? {
-    step: TStep;
-    path: PathsToStringProps<ExtractSchemaType<ExtractSchemaFromStep<TStep, 'outputSchema'>>> | '' | '.';
-} : TStep extends 'trigger' ? {
-    step: 'trigger';
-    path: PathsToStringProps<ExtractSchemaType<TTriggerSchema>> | '.' | '';
-} : {
-    step: {
-        id: string;
-    };
-    path: string;
-};
-interface BaseCondition<TStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodObject<any>> {
-    ref: TStep extends StepAction<any, any, any, any> ? {
-        step: TStep;
-        path: PathsToStringProps<ExtractSchemaType<ExtractSchemaFromStep<TStep, 'outputSchema'>>> | '' | '.' | 'status';
-    } : TStep extends 'trigger' ? {
-        step: 'trigger';
-        path: PathsToStringProps<ExtractSchemaType<TTriggerSchema>> | '.' | '';
-    } : {
-        step: {
-            id: string;
-        };
-        path: string;
-    };
-    query: Query<any>;
-}
-type ActionContext<TSchemaIn extends z.ZodType<any>> = StepExecutionContext<z.infer<TSchemaIn>, WorkflowContext>;
-declare enum WhenConditionReturnValue {
-    CONTINUE = "continue",
-    CONTINUE_FAILED = "continue_failed",
-    ABORT = "abort",
-    LIMBO = "limbo"
-}
-type StepDef<TStepId extends TSteps[number]['id'], TSteps extends StepAction<any, any, any, any>[], TSchemaIn extends z.ZodType<any>, TSchemaOut extends z.ZodType<any>> = Record<TStepId, {
-    when?: Condition<any, any> | ((args: {
-        context: WorkflowContext;
-        mastra?: Mastra;
-    }) => Promise<boolean | WhenConditionReturnValue>);
-    serializedWhen?: Condition<any, any> | string;
-    data: TSchemaIn;
-    handler: (args: ActionContext<TSchemaIn>) => Promise<z.infer<TSchemaOut>>;
-}>;
-type Condition<TStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodObject<any>> = BaseCondition<TStep, TTriggerSchema> | SimpleConditionalType | {
-    and: Condition<TStep, TTriggerSchema>[];
-} | {
-    or: Condition<TStep, TTriggerSchema>[];
-} | {
-    not: Condition<TStep, TTriggerSchema>;
-};
-interface StepConfig<TStep extends StepAction<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodObject<any>, TSteps extends Step<string, any, any, any>[] = Step<string, any, any, any>[]> {
-    when?: Condition<CondStep, TTriggerSchema> | ((args: {
-        context: WorkflowContext<TTriggerSchema, TSteps>;
-        mastra?: Mastra;
-    }) => Promise<boolean | WhenConditionReturnValue>);
-    variables?: StepInputType<TStep, 'inputSchema'> extends never ? Record<string, VariableReference<VarStep, TTriggerSchema>> : {
-        [K in keyof StepInputType<TStep, 'inputSchema'>]?: VariableReference<VarStep, TTriggerSchema>;
-    };
-}
-type StepSuccess<T> = {
-    status: 'success';
-    output: T;
-};
-type StepSuspended = {
-    status: 'suspended';
-    suspendPayload?: any;
-};
-type StepWaiting = {
-    status: 'waiting';
-};
-type StepFailure = {
-    status: 'failed';
-    error: string;
-};
-type StepSkipped = {
-    status: 'skipped';
-};
-type StepResult<T> = StepSuccess<T> | StepFailure | StepSuspended | StepWaiting | StepSkipped;
-type StepsRecord<T extends readonly Step<any, any, z.ZodType<any> | undefined>[]> = {
-    [K in T[number]['id']]: Extract<T[number], {
-        id: K;
-    }>;
-};
-interface WorkflowRunResult<T extends z.ZodType<any>, TSteps extends Step<string, any, z.ZodType<any> | undefined>[]> {
-    triggerData?: z.infer<T>;
-    results: {
-        [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['outputSchema']>>>;
-    };
-    runId: string;
-    activePaths: Map<keyof StepsRecord<TSteps>, {
-        status: string;
-        suspendPayload?: any;
-    }>;
-}
-interface WorkflowContext<TTrigger extends z.ZodObject<any> = any, TSteps extends Step<string, any, any, any>[] = Step<string, any, any, any>[]> {
-    mastra?: MastraUnion;
-    steps: {
-        [K in keyof StepsRecord<TSteps>]: StepsRecord<TSteps>[K]['outputSchema'] extends undefined ? StepResult<unknown> : StepResult<z.infer<NonNullable<StepsRecord<TSteps>[K]['outputSchema']>>>;
-    };
-    triggerData: z.infer<TTrigger>;
-    resumeData?: any;
-    attempts: Record<string, number>;
-    getStepResult(stepId: 'trigger'): z.infer<TTrigger>;
-    getStepResult<T extends keyof StepsRecord<TSteps> | unknown>(stepId: T extends keyof StepsRecord<TSteps> ? T : string): T extends keyof StepsRecord<TSteps> ? StepsRecord<TSteps>[T]['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<StepsRecord<TSteps>[T]['outputSchema']>> : T;
-    getStepResult<T extends Step<any, any, any, any>>(stepId: T): T['outputSchema'] extends undefined ? unknown : z.infer<NonNullable<T['outputSchema']>>;
-}
-type ExtractSchemaFromStep<TStep extends StepAction<any, any, any, any>, TKey extends 'inputSchema' | 'outputSchema'> = TStep[TKey];
-type StepInputType<TStep extends StepAction<any, any, any, any>, TKey extends 'inputSchema' | 'outputSchema'> = ExtractSchemaFromStep<TStep, TKey> extends infer Schema ? Schema extends z.ZodType<any> ? z.infer<Schema> : never : never;
-type ExtractSchemaType<T extends z.ZodSchema> = T extends z.ZodSchema<infer V> ? V : never;
-type PathsToStringProps<T> = T extends object ? {
-    [K in keyof T]: T[K] extends object ? K extends string ? K | `${K}.${PathsToStringProps<T[K]>}` : never : K extends string ? K : never;
-}[keyof T] : never;
-interface WorkflowRunState {
-    value: Record<string, string>;
-    context: {
-        steps: Record<string, {
-            status: 'success' | 'failed' | 'suspended' | 'waiting' | 'skipped';
-            payload?: any;
-            error?: string;
-        }>;
-        triggerData: Record<string, any>;
-        attempts: Record<string, number>;
-    };
-    activePaths: Array<{
-        stepPath: string[];
-        stepId: string;
-        status: string;
-    }>;
-    runId: string;
-    timestamp: number;
-    childStates?: Record<string, WorkflowRunState>;
-    suspendedSteps?: Record<string, string>;
-}
-
-interface WorkflowResultReturn<T extends z.ZodType<any>, TSteps extends Step<any, any, any>[]> {
-    runId: string;
-    start: (props?: {
-        triggerData?: z.infer<T>;
-    } | undefined) => Promise<WorkflowRunResult<T, TSteps>>;
-}
-
-declare class Workflow<TSteps extends Step<string, any, any>[] = Step<string, any, any>[], TTriggerSchema extends z.ZodObject<any> = any> extends MastraBase {
-    #private;
-    name: string;
-    triggerSchema?: TTriggerSchema;
-    events?: Record<string, {
-        schema: z.ZodObject<any>;
-    }>;
-    /**
-     * Creates a new Workflow instance
-     * @param name - Identifier for the workflow (not necessarily unique)
-     * @param logger - Optional logger instance
-     */
-    constructor({ name, triggerSchema, retryConfig, mastra, events }: WorkflowOptions<TTriggerSchema>);
-    step<TStep extends StepAction<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(step: TStep, config?: StepConfig<TStep, CondStep, VarStep, TTriggerSchema>): this;
-    then<TStep extends StepAction<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(step: TStep, config?: StepConfig<TStep, CondStep, VarStep, TTriggerSchema>): this;
-    private loop;
-    while<FallbackStep extends StepAction<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(condition: StepConfig<FallbackStep, CondStep, VarStep, TTriggerSchema>['when'], fallbackStep: FallbackStep): this;
-    until<FallbackStep extends StepAction<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>>(condition: StepConfig<FallbackStep, CondStep, VarStep, TTriggerSchema, TSteps>['when'], fallbackStep: FallbackStep): this;
-    if<TStep extends StepAction<any, any, any, any>>(condition: StepConfig<TStep, any, any, TTriggerSchema>['when']): this;
-    else(): this;
-    after<TStep extends StepAction<any, any, any, any>>(steps: TStep | TStep[]): Omit<typeof this, "then" | "after">;
-    afterEvent(eventName: string): this;
-    /**
-     * Executes the workflow with the given trigger data
-     * @param triggerData - Initial data to start the workflow with
-     * @returns Promise resolving to workflow results or rejecting with error
-     * @throws Error if trigger schema validation fails
-     */
-    createRun(): WorkflowResultReturn<TTriggerSchema, TSteps>;
-    /**
-     * Rebuilds the machine with the current steps configuration and validates the workflow
-     *
-     * This is the last step of a workflow builder method chain
-     * @throws Error if validation fails
-     *
-     * @returns this instance for method chaining
-     */
-    commit(): this;
-    getExecutionSpan(runId: string): Span | undefined;
-    getState(runId: string): Promise<WorkflowRunState | null>;
-    watch(onTransition: (state: WorkflowRunState) => void): () => void;
-    resume({ runId, stepId, context: resumeContext, }: {
-        runId: string;
-        stepId: string;
-        context?: Record<string, any>;
-    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps>, "runId"> | undefined>;
-    _resume({ runId, stepId, context: resumeContext, }: {
-        runId: string;
-        stepId: string;
-        context?: Record<string, any>;
-    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps>, "runId"> | undefined>;
-    resumeWithEvent(runId: string, eventName: string, data: any): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps>, "runId"> | undefined>;
-    __registerMastra(mastra: Mastra): void;
-    __registerPrimitives(p: MastraPrimitives): void;
-    get stepGraph(): StepGraph;
-    get stepSubscriberGraph(): Record<string, StepGraph>;
-    get steps(): Record<string, StepAction<any, any, any, any>>;
-}
-
-interface Config<TAgents extends Record<string, Agent<any>> = Record<string, Agent<any>>, TWorkflows extends Record<string, Workflow> = Record<string, Workflow>, TVectors extends Record<string, MastraVector> = Record<string, MastraVector>, TTTS extends Record<string, MastraTTS> = Record<string, MastraTTS>, TLogger extends Logger = Logger> {
-    agents?: TAgents;
-    storage?: MastraStorage;
-    vectors?: TVectors;
-    logger?: TLogger | false;
-    workflows?: TWorkflows;
-    tts?: TTTS;
-    telemetry?: OtelConfig;
-    deployer?: MastraDeployer;
-    /**
-     * Server middleware functions to be applied to API routes
-     * Each middleware can specify a path pattern (defaults to '/api/*')
-     */
-    serverMiddleware?: Array<{
-        handler: (c: any, next: () => Promise<void>) => Promise<Response | void>;
-        path?: string;
-    }>;
-    memory?: MastraMemory;
-}
-declare class Mastra<TAgents extends Record<string, Agent<any>> = Record<string, Agent<any>>, TWorkflows extends Record<string, Workflow> = Record<string, Workflow>, TVectors extends Record<string, MastraVector> = Record<string, MastraVector>, TTTS extends Record<string, MastraTTS> = Record<string, MastraTTS>, TLogger extends Logger = Logger> {
-    #private;
-    /**
-     * @deprecated use getTelemetry() instead
-     */
-    get telemetry(): Telemetry | undefined;
-    /**
-     * @deprecated use getStorage() instead
-     */
-    get storage(): MastraStorage | undefined;
-    /**
-     * @deprecated use getMemory() instead
-     */
-    get memory(): MastraMemory | undefined;
-    constructor(config?: Config<TAgents, TWorkflows, TVectors, TTTS, TLogger>);
-    getAgent<TAgentName extends keyof TAgents>(name: TAgentName): TAgents[TAgentName];
-    getAgents(): TAgents;
-    getVector<TVectorName extends keyof TVectors>(name: TVectorName): TVectors[TVectorName];
-    getVectors(): TVectors | undefined;
-    getDeployer(): MastraDeployer | undefined;
-    getWorkflow<TWorkflowId extends keyof TWorkflows>(id: TWorkflowId, { serialized }?: {
-        serialized?: boolean;
-    }): TWorkflows[TWorkflowId];
-    getWorkflows(props?: {
-        serialized?: boolean;
-    }): Record<string, Workflow>;
-    setStorage(storage: MastraStorage): void;
-    setLogger({ logger }: {
-        logger: TLogger;
-    }): void;
-    setTelemetry(telemetry: OtelConfig): void;
-    getTTS(): TTTS | undefined;
-    getLogger(): TLogger;
-    getTelemetry(): Telemetry | undefined;
-    getMemory(): MastraMemory | undefined;
-    getStorage(): MastraStorage | undefined;
-    getServerMiddleware(): {
-        handler: (c: any, next: () => Promise<void>) => Promise<Response | void>;
-        path: string;
-    }[];
-    getLogsByRunId({ runId, transportId }: {
-        runId: string;
-        transportId: string;
-    }): Promise<BaseLogMessage[] | undefined>;
-    getLogs(transportId: string): Promise<BaseLogMessage[]>;
-}
-
-type MastraPrimitives = {
-    logger?: Logger;
-    telemetry?: Telemetry;
-    storage?: MastraStorage;
-    agents?: Record<string, Agent>;
-    tts?: Record<string, MastraTTS>;
-    vectors?: Record<string, MastraVector>;
-    memory?: MastraMemory;
-};
-type MastraUnion = {
-    [K in keyof Mastra]: Mastra[K];
-} & MastraPrimitives;
-interface IExecutionContext<TSchemaIn extends z.ZodSchema | undefined = undefined> {
-    context: TSchemaIn extends z.ZodSchema ? z.infer<TSchemaIn> : {};
-    runId?: string;
-    threadId?: string;
-    resourceId?: string;
-}
-interface IAction<TId extends string, TSchemaIn extends z.ZodSchema | undefined, TSchemaOut extends z.ZodSchema | undefined, TContext extends IExecutionContext<TSchemaIn>, TOptions extends unknown = unknown> {
-    id: TId;
-    description?: string;
-    inputSchema?: TSchemaIn;
-    outputSchema?: TSchemaOut;
-    execute?: (context: TContext, options?: TOptions) => Promise<TSchemaOut extends z.ZodSchema ? z.infer<TSchemaOut> : unknown>;
-}
-
-type ToolsInput = Record<string, ToolAction<any, any, any> | VercelTool>;
-type ToolsetsInput = Record<string, ToolsInput>;
-type MastraLanguageModel = LanguageModelV1;
-interface AgentConfig<TTools extends ToolsInput = ToolsInput, TMetrics extends Record<string, Metric> = Record<string, Metric>> {
-    name: string;
-    instructions: string;
-    model: MastraLanguageModel;
-    tools?: TTools;
-    mastra?: Mastra;
-    /** @deprecated This property is deprecated. Use evals instead to add evaluation metrics. */
-    metrics?: TMetrics;
-    evals?: TMetrics;
-    memory?: MastraMemory;
-    voice?: CompositeVoice;
-}
-type AgentGenerateOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    toolsets?: ToolsetsInput;
-    context?: CoreMessage[];
-    memoryOptions?: MemoryConfig;
-    runId?: string;
-    onStepFinish?: (step: string) => void;
-    maxSteps?: number;
-    output?: OutputType | Z;
-    experimental_output?: Z;
-    toolChoice?: 'auto' | 'none' | 'required' | {
-        type: 'tool';
-        toolName: string;
-    };
-    telemetry?: TelemetrySettings;
-} & ({
-    resourceId?: undefined;
-    threadId?: undefined;
-} | {
-    resourceId: string;
-    threadId: string;
-}) & (Z extends undefined ? DefaultLLMTextOptions : DefaultLLMTextObjectOptions);
-type AgentStreamOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    toolsets?: ToolsetsInput;
-    context?: CoreMessage[];
-    memoryOptions?: MemoryConfig;
-    runId?: string;
-    onFinish?: (result: string) => unknown;
-    onStepFinish?: (step: string) => unknown;
-    maxSteps?: number;
-    output?: OutputType | Z;
-    temperature?: number;
-    toolChoice?: 'auto' | 'none' | 'required' | {
-        type: 'tool';
-        toolName: string;
-    };
-    experimental_output?: Z;
-    telemetry?: TelemetrySettings;
-} & ({
-    resourceId?: undefined;
-    threadId?: undefined;
-} | {
-    resourceId: string;
-    threadId: string;
-}) & (Z extends undefined ? DefaultLLMStreamOptions : DefaultLLMStreamObjectOptions);
-type CoreMessage = CoreMessage$1;
-type BaseStructuredOutputType = 'string' | 'number' | 'boolean' | 'date';
-type StructuredOutputArrayItem = {
-    type: BaseStructuredOutputType;
-} | {
-    type: 'object';
-    items: StructuredOutput;
-};
-type StructuredOutput = {
-    [key: string]: {
-        type: BaseStructuredOutputType;
-    } | {
-        type: 'object';
-        items: StructuredOutput;
-    } | {
-        type: 'array';
-        items: StructuredOutputArrayItem;
-    };
-};
-type GenerateReturn<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = Z extends undefined ? GenerateTextResult<any, Z extends ZodSchema ? z.infer<Z> : unknown> : GenerateObjectResult<Z extends ZodSchema ? z.infer<Z> : unknown>;
-type StreamReturn<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = Z extends undefined ? StreamTextResult<any, Z extends ZodSchema ? z.infer<Z> : unknown> : StreamObjectResult<any, Z extends ZodSchema ? z.infer<Z> : unknown, any>;
-type OutputType = StructuredOutput | ZodSchema | JSONSchema7 | undefined;
-type GenerateTextOptions = Parameters<typeof generateText>[0];
-type StreamTextOptions = Parameters<typeof streamText>[0];
-type GenerateObjectOptions = Parameters<typeof generateObject>[0];
-type StreamObjectOptions = Parameters<typeof streamObject>[0];
-type MastraCustomLLMOptionsKeys = 'messages' | 'tools' | 'model' | 'onStepFinish' | 'experimental_output' | 'experimental_telemetry' | 'messages' | 'onFinish' | 'output';
-type DefaultLLMTextOptions = Omit<GenerateTextOptions, MastraCustomLLMOptionsKeys>;
-type DefaultLLMTextObjectOptions = Omit<GenerateObjectOptions, MastraCustomLLMOptionsKeys>;
-type DefaultLLMStreamOptions = Omit<StreamTextOptions, MastraCustomLLMOptionsKeys>;
-type DefaultLLMStreamObjectOptions = Omit<StreamObjectOptions, MastraCustomLLMOptionsKeys>;
-type MastraCustomLLMOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    tools?: ToolsInput;
-    convertedTools?: Record<string, CoreTool>;
-    onStepFinish?: (step: string) => void;
-    experimental_output?: Z;
-    telemetry?: TelemetrySettings;
-    threadId?: string;
-    resourceId?: string;
-} & Run;
-type LLMTextOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    messages: CoreMessage[];
-} & MastraCustomLLMOptions<Z> & DefaultLLMTextOptions;
-type LLMTextObjectOptions<T extends ZodSchema | JSONSchema7 | undefined = undefined> = LLMTextOptions<T> & DefaultLLMTextObjectOptions & {
-    structuredOutput: JSONSchema7 | z.ZodType<T> | StructuredOutput;
-};
-type LLMStreamOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    output?: OutputType | Z;
-    onFinish?: (result: string) => Promise<void> | void;
-} & MastraCustomLLMOptions<Z> & DefaultLLMStreamOptions;
-type LLMInnerStreamOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    messages: CoreMessage[];
-    onFinish?: (result: string) => Promise<void> | void;
-} & MastraCustomLLMOptions<Z> & DefaultLLMStreamOptions;
-type LLMStreamObjectOptions<T extends ZodSchema | JSONSchema7 | undefined = undefined> = {
-    structuredOutput: JSONSchema7 | z.ZodType<T> | StructuredOutput;
-} & LLMInnerStreamOptions<T> & DefaultLLMStreamObjectOptions;
-
-declare class MastraLLMBase extends MastraBase {
-    #private;
-    constructor({ name, model }: {
-        name: string;
-        model: LanguageModel;
-    });
-    getProvider(): string;
-    getModelId(): string;
-    getModel(): LanguageModelV1;
-    convertToMessages(messages: string | string[] | CoreMessage$1[]): CoreMessage$1[];
-    __registerPrimitives(p: MastraPrimitives): void;
-    __text<Z extends ZodSchema | JSONSchema7 | undefined>(input: LLMTextOptions<Z>): Promise<GenerateTextResult<any, any>>;
-    __textObject<T extends ZodSchema | JSONSchema7 | undefined>(input: LLMTextObjectOptions<T>): Promise<GenerateObjectResult<T>>;
-    generate<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], options?: LLMStreamOptions<Z>): Promise<GenerateReturn<Z>>;
-    __stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(input: LLMInnerStreamOptions<Z>): Promise<StreamTextResult<any, any>>;
-    __streamObject<T extends ZodSchema | JSONSchema7 | undefined>(input: LLMStreamObjectOptions<T>): Promise<StreamObjectResult<DeepPartial<T>, T, never>>;
-    stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], options?: LLMStreamOptions<Z>): Promise<StreamReturn<Z>>;
-}
-
-declare class Agent<TTools extends ToolsInput = ToolsInput, TMetrics extends Record<string, Metric> = Record<string, Metric>> extends MastraBase {
-    #private;
-    name: string;
-    readonly llm: MastraLLMBase;
-    instructions: string;
-    readonly model?: MastraLanguageModel;
-    tools: TTools;
-    /** @deprecated This property is deprecated. Use evals instead. */
-    metrics: TMetrics;
-    evals: TMetrics;
-    voice?: CompositeVoice;
-    constructor(config: AgentConfig<TTools, TMetrics>);
-    hasOwnMemory(): boolean;
-    getMemory(): MastraMemory | undefined;
-    __updateInstructions(newInstructions: string): void;
-    __registerPrimitives(p: MastraPrimitives): void;
-    __registerMastra(mastra: Mastra): void;
-    /**
-     * Set the concrete tools for the agent
-     * @param tools
-     */
-    __setTools(tools: TTools): void;
-    generateTitleFromUserMessage({ message }: {
-        message: CoreUserMessage;
-    }): Promise<string>;
-    getMostRecentUserMessage(messages: Array<CoreMessage$1>): CoreUserMessage | undefined;
-    genTitle(userMessage: CoreUserMessage | undefined): Promise<string>;
-    saveMemory({ threadId, memoryConfig, resourceId, userMessages, runId, }: {
-        resourceId: string;
-        threadId?: string;
-        memoryConfig?: MemoryConfig;
-        userMessages: CoreMessage$1[];
-        time?: Date;
-        keyword?: string;
-        runId?: string;
-    }): Promise<{
-        threadId: string;
-        messages: NonNullable<CoreMessage$1 | null>[];
-    }>;
-    saveResponse({ result, threadId, resourceId, runId, memoryConfig, }: {
-        runId: string;
-        resourceId: string;
-        result: Record<string, any>;
-        threadId: string;
-        memoryConfig: MemoryConfig | undefined;
-    }): Promise<void>;
-    sanitizeResponseMessages(messages: Array<CoreMessage$1>): Array<CoreMessage$1>;
-    convertTools({ toolsets, threadId, resourceId, runId, }: {
-        toolsets?: ToolsetsInput;
-        threadId?: string;
-        resourceId?: string;
-        runId?: string;
-    }): Record<string, CoreTool>;
-    preExecute({ resourceId, runId, threadId, memoryConfig, messages, }: {
-        runId?: string;
-        threadId?: string;
-        memoryConfig?: MemoryConfig;
-        messages: CoreMessage$1[];
-        resourceId: string;
-    }): Promise<{
-        coreMessages: CoreMessage$1[];
-        threadIdToUse: string;
-    }>;
-    __primitive({ messages, context, threadId, memoryConfig, resourceId, runId, toolsets, }: {
-        toolsets?: ToolsetsInput;
-        resourceId?: string;
-        threadId?: string;
-        memoryConfig?: MemoryConfig;
-        context?: CoreMessage$1[];
-        runId?: string;
-        messages: CoreMessage$1[];
-    }): {
-        before: () => Promise<{
-            messageObjects: CoreMessage$1[];
-            convertedTools: Record<string, CoreTool> | undefined;
-            threadId: string;
-        }>;
-        after: ({ result, threadId, memoryConfig, outputText, runId, }: {
-            runId: string;
-            result: Record<string, any>;
-            threadId: string;
-            memoryConfig: MemoryConfig | undefined;
-            outputText: string;
-        }) => Promise<void>;
-    };
-    generate<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], args?: AgentGenerateOptions<Z> & {
-        output?: never;
-        experimental_output?: never;
-    }): Promise<GenerateTextResult<any, Z extends ZodSchema ? z.infer<Z> : unknown>>;
-    generate<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], args?: AgentGenerateOptions<Z> & ({
-        output: Z;
-        experimental_output?: never;
-    } | {
-        experimental_output: Z;
-        output?: never;
-    })): Promise<GenerateObjectResult<Z extends ZodSchema ? z.infer<Z> : unknown>>;
-    stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], args?: AgentStreamOptions<Z> & {
-        output?: never;
-        experimental_output?: never;
-    }): Promise<StreamTextResult<any, Z extends ZodSchema ? z.infer<Z> : unknown>>;
-    stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], args?: AgentStreamOptions<Z> & ({
-        output: Z;
-        experimental_output?: never;
-    } | {
-        experimental_output: Z;
-        output?: never;
-    })): Promise<StreamObjectResult<any, Z extends ZodSchema ? z.infer<Z> : unknown, any>>;
-    /**
-     * 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
-     */
-    speak(input: string | NodeJS.ReadableStream, options?: {
-        speaker?: string;
-        [key: string]: any;
-    }): Promise<NodeJS.ReadableStream>;
-    /**
-     * 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
-     */
-    listen(audioStream: NodeJS.ReadableStream, options?: {
-        [key: string]: any;
-    }): Promise<string | NodeJS.ReadableStream>;
-    /**
-     * 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
-     */
-    getSpeakers(): Promise<{
-        [key: string]: any;
-        voiceId: string;
-    }[]>;
-}
-
-interface StorageColumn {
-    type: 'text' | 'timestamp' | 'uuid' | 'jsonb' | 'integer' | 'bigint';
-    primaryKey?: boolean;
-    nullable?: boolean;
-    references?: {
-        table: string;
-        column: string;
-    };
-}
-type StorageGetMessagesArg = {
-    threadId: string;
-    resourceId?: string;
-    selectBy?: {
-        vectorSearchString?: string;
-        last?: number | false;
-        include?: {
-            id: string;
-            withPreviousMessages?: number;
-            withNextMessages?: number;
-        }[];
-    };
-    threadConfig?: MemoryConfig;
-};
-type EvalRow = {
-    input: string;
-    output: string;
-    result: MetricResult;
-    agentName: string;
-    createdAt: string;
-    metricName: string;
-    instructions: string;
-    runId: string;
-    globalRunId: string;
-    testInfo?: TestInfo;
-};
-
-declare const TABLE_WORKFLOW_SNAPSHOT = "mastra_workflow_snapshot";
-declare const TABLE_EVALS = "mastra_evals";
-declare const TABLE_MESSAGES = "mastra_messages";
-declare const TABLE_THREADS = "mastra_threads";
-declare const TABLE_TRACES = "mastra_traces";
-type TABLE_NAMES = typeof TABLE_WORKFLOW_SNAPSHOT | typeof TABLE_EVALS | typeof TABLE_MESSAGES | typeof TABLE_THREADS | typeof TABLE_TRACES;
-
-type MessageType = {
-    id: string;
-    content: UserContent | AssistantContent | ToolContent;
-    role: 'system' | 'user' | 'assistant' | 'tool';
-    createdAt: Date;
-    threadId: string;
-    toolCallIds?: string[];
-    toolCallArgs?: Record<string, unknown>[];
-    toolNames?: string[];
-    type: 'text' | 'tool-call' | 'tool-result';
-};
-type StorageThreadType = {
-    id: string;
-    title?: string;
-    resourceId: string;
-    createdAt: Date;
-    updatedAt: Date;
-    metadata?: Record<string, unknown>;
-};
-type MemoryConfig = {
-    lastMessages?: number | false;
-    semanticRecall?: boolean | {
-        topK: number;
-        messageRange: number | {
-            before: number;
-            after: number;
-        };
-    };
-    workingMemory?: {
-        enabled: boolean;
-        template?: string;
-        use?: 'text-stream' | 'tool-call';
-    };
-    threads?: {
-        generateTitle?: boolean;
-    };
-};
-type SharedMemoryConfig = {
-    storage?: MastraStorage;
-    options?: MemoryConfig;
-    vector?: MastraVector;
-    embedder?: EmbeddingModel<string>;
-};
-
-declare abstract class MastraStorage extends MastraBase {
-    /** @deprecated import from { TABLE_WORKFLOW_SNAPSHOT } '@mastra/core/storage' instead */
-    static readonly TABLE_WORKFLOW_SNAPSHOT = "mastra_workflow_snapshot";
-    /** @deprecated import from { TABLE_EVALS } '@mastra/core/storage' instead */
-    static readonly TABLE_EVALS = "mastra_evals";
-    /** @deprecated import from { TABLE_MESSAGES } '@mastra/core/storage' instead */
-    static readonly TABLE_MESSAGES = "mastra_messages";
-    /** @deprecated import from { TABLE_THREADS } '@mastra/core/storage' instead */
-    static readonly TABLE_THREADS = "mastra_threads";
-    /** @deprecated import { TABLE_TRACES } from '@mastra/core/storage' instead */
-    static readonly TABLE_TRACES = "mastra_traces";
-    protected hasInitialized: null | Promise<boolean>;
-    protected shouldCacheInit: boolean;
-    constructor({ name }: {
-        name: string;
-    });
-    abstract createTable({ tableName }: {
-        tableName: TABLE_NAMES;
-        schema: Record<string, StorageColumn>;
-    }): Promise<void>;
-    abstract clearTable({ tableName }: {
-        tableName: TABLE_NAMES;
-    }): Promise<void>;
-    abstract insert({ tableName, record }: {
-        tableName: TABLE_NAMES;
-        record: Record<string, any>;
-    }): Promise<void>;
-    abstract batchInsert({ tableName, records, }: {
-        tableName: TABLE_NAMES;
-        records: Record<string, any>[];
-    }): Promise<void>;
-    __batchInsert({ tableName, records, }: {
-        tableName: TABLE_NAMES;
-        records: Record<string, any>[];
-    }): Promise<void>;
-    abstract load<R>({ tableName, keys }: {
-        tableName: TABLE_NAMES;
-        keys: Record<string, string>;
-    }): Promise<R | null>;
-    abstract getThreadById({ threadId }: {
-        threadId: string;
-    }): Promise<StorageThreadType | null>;
-    __getThreadById({ threadId }: {
-        threadId: string;
-    }): Promise<StorageThreadType | null>;
-    abstract getThreadsByResourceId({ resourceId }: {
-        resourceId: string;
-    }): Promise<StorageThreadType[]>;
-    __getThreadsByResourceId({ resourceId }: {
-        resourceId: string;
-    }): Promise<StorageThreadType[]>;
-    abstract saveThread({ thread }: {
-        thread: StorageThreadType;
-    }): Promise<StorageThreadType>;
-    __saveThread({ thread }: {
-        thread: StorageThreadType;
-    }): Promise<StorageThreadType>;
-    abstract updateThread({ id, title, metadata, }: {
-        id: string;
-        title: string;
-        metadata: Record<string, unknown>;
-    }): Promise<StorageThreadType>;
-    __updateThread({ id, title, metadata, }: {
-        id: string;
-        title: string;
-        metadata: Record<string, unknown>;
-    }): Promise<StorageThreadType>;
-    abstract deleteThread({ threadId }: {
-        threadId: string;
-    }): Promise<void>;
-    __deleteThread({ threadId }: {
-        threadId: string;
-    }): Promise<void>;
-    abstract getMessages({ threadId, selectBy, threadConfig }: StorageGetMessagesArg): Promise<MessageType[]>;
-    __getMessages({ threadId, selectBy, threadConfig }: StorageGetMessagesArg): Promise<MessageType[]>;
-    abstract saveMessages({ messages }: {
-        messages: MessageType[];
-    }): Promise<MessageType[]>;
-    __saveMessages({ messages }: {
-        messages: MessageType[];
-    }): Promise<MessageType[]>;
-    abstract getTraces({ name, scope, page, perPage, attributes, }: {
-        name?: string;
-        scope?: string;
-        page: number;
-        perPage: number;
-        attributes?: Record<string, string>;
-    }): Promise<any[]>;
-    __getTraces({ scope, page, perPage, attributes, }: {
-        scope?: string;
-        page: number;
-        perPage: number;
-        attributes?: Record<string, string>;
-    }): Promise<any[]>;
-    init(): Promise<void>;
-    persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
-        workflowName: string;
-        runId: string;
-        snapshot: WorkflowRunState;
-    }): Promise<void>;
-    loadWorkflowSnapshot({ workflowName, runId, }: {
-        workflowName: string;
-        runId: string;
-    }): Promise<WorkflowRunState | null>;
-    abstract getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
-    __getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
-}
-
-declare class Tool<TSchemaIn extends z.ZodSchema | undefined = undefined, TSchemaOut extends z.ZodSchema | undefined = undefined, TContext extends ToolExecutionContext<TSchemaIn> = ToolExecutionContext<TSchemaIn>, TOptions extends unknown = unknown> implements ToolAction<TSchemaIn, TSchemaOut, TContext, TOptions> {
-    id: string;
-    description: string;
-    inputSchema?: TSchemaIn;
-    outputSchema?: TSchemaOut;
-    execute?: (context: TContext, options?: TOptions) => Promise<TSchemaOut extends z.ZodSchema ? z.infer<TSchemaOut> : unknown>;
-    mastra?: Mastra;
-    constructor(opts: ToolAction<TSchemaIn, TSchemaOut, TContext>);
-}
-
-declare const executeTool: (config: FreestyleExecuteScriptParamsConfiguration & {
-    apiKey: string;
-}) => Tool<z.ZodObject<{
-    script: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    script?: string;
-}, {
-    script?: string;
-}>, z.ZodObject<{
-    logs: z.ZodArray<z.ZodObject<{
-        message: z.ZodString;
-        type: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        message?: string;
-        type?: string;
-    }, {
-        message?: string;
-        type?: string;
-    }>, "many">;
-    result: z.ZodUnknown;
-}, "strip", z.ZodTypeAny, {
-    logs?: {
-        message?: string;
-        type?: string;
-    }[];
-    result?: unknown;
-}, {
-    logs?: {
-        message?: string;
-        type?: string;
-    }[];
-    result?: unknown;
-}>, ToolExecutionContext<z.ZodObject<{
-    script: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    script?: string;
-}, {
-    script?: string;
-}>>, unknown>;
-
-export { executeTool };