@mastra/core 0.0.0-storage-20250225005900

package/dist/base-CHNzbTDj.d.ts

@@ -0,0 +1,894 @@
+import * as ai from 'ai';
+import { EmbeddingModel, CoreMessage as CoreMessage$1, Message, UserContent, AssistantContent, LanguageModelV1, GenerateTextResult, GenerateObjectResult, StreamTextResult, StreamObjectResult, CoreSystemMessage as CoreSystemMessage$1, CoreAssistantMessage as CoreAssistantMessage$1, CoreUserMessage as CoreUserMessage$1, CoreToolMessage as CoreToolMessage$1, EmbedResult as EmbedResult$1, EmbedManyResult as EmbedManyResult$1, LanguageModel as LanguageModel$1, DeepPartial, ToolContent } from 'ai';
+import { M as MastraBase, T as Telemetry } from './base-eWkcLLSb.js';
+import { a as Metric, M as MetricResult, T as TestInfo } from './types-m9RryK9a.js';
+import { Query } from 'sift';
+import { z, ZodSchema } from 'zod';
+import { JSONSchema7 } from 'json-schema';
+import { MastraVector } from './vector/index.js';
+import { CompositeVoice } from './voice/index.js';
+import { B as BaseLogMessage, R as RegisteredLogger, L as Logger, d as Run } from './index-C5uPdbs4.js';
+import { MastraTTS } from './tts/index.js';
+
+/**
+ * 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>;
+    protected createEmbeddingIndex(): Promise<{
+        indexName: string;
+    }>;
+    protected getMergedThreadConfig(config?: MemoryConfig): MemoryConfig;
+    abstract rememberMessages({ threadId, vectorMessageSearch, config, }: {
+        threadId: string;
+        vectorMessageSearch?: string;
+        config?: MemoryConfig;
+    }): Promise<{
+        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, 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;
+}
+
+interface WorkflowOptions<TTriggerSchema extends z.ZodType<any> = any> {
+    name: string;
+    triggerSchema?: TTriggerSchema;
+    retryConfig?: RetryConfig;
+    mastra?: MastraPrimitives;
+}
+interface StepExecutionContext<TSchemaIn extends z.ZodSchema | undefined = undefined, TContext extends WorkflowContext = WorkflowContext> extends IExecutionContext<TSchemaIn, TContext> {
+    runId: string;
+}
+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> {
+    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 IExecutionContext<TSchemaIn>> = IAction<TId, TSchemaIn, TSchemaOut, TContext> | 'trigger' | {
+    id: string;
+};
+type StepNode = {
+    step: IAction<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.ZodType<any>> = TStep extends IAction<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.ZodType<any>> {
+    ref: TStep extends IAction<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>> = IExecutionContext<z.infer<TSchemaIn>, WorkflowContext>;
+type StepDef<TStepId extends TSteps[number]['id'], TSteps extends IAction<any, any, any, any>[], TSchemaIn extends z.ZodType<any>, TSchemaOut extends z.ZodType<any>> = Record<TStepId, {
+    snapshotOnTimeout?: boolean;
+    when?: Condition<any, any> | ((args: {
+        context: WorkflowContext;
+    }) => Promise<boolean>);
+    data: TSchemaIn;
+    handler: (args: ActionContext<TSchemaIn>) => Promise<z.infer<TSchemaOut>>;
+}>;
+type StepCondition<TStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodType<any>> = BaseCondition<TStep, TTriggerSchema> | SimpleConditionalType | {
+    and: StepCondition<TStep, TTriggerSchema>[];
+} | {
+    or: StepCondition<TStep, TTriggerSchema>[];
+};
+type Condition<TStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodType<any>> = BaseCondition<TStep, TTriggerSchema> | SimpleConditionalType | {
+    and: Condition<TStep, TTriggerSchema>[];
+} | {
+    or: Condition<TStep, TTriggerSchema>[];
+};
+interface StepConfig<TStep extends IAction<any, any, any, any>, CondStep extends StepVariableType<any, any, any, any>, VarStep extends StepVariableType<any, any, any, any>, TTriggerSchema extends z.ZodType<any>> {
+    snapshotOnTimeout?: boolean;
+    when?: Condition<CondStep, TTriggerSchema> | ((args: {
+        context: WorkflowContext<TTriggerSchema>;
+    }) => Promise<boolean>);
+    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';
+};
+type StepWaiting = {
+    status: 'waiting';
+};
+type StepFailure = {
+    status: 'failed';
+    error: string;
+};
+type StepResult<T> = StepSuccess<T> | StepFailure | StepSuspended | StepWaiting;
+interface WorkflowContext<TTrigger extends z.ZodType<any> = any> {
+    steps: Record<string, StepResult<any>>;
+    triggerData: z.infer<TTrigger>;
+    attempts: Record<string, number>;
+    getStepPayload: <T = unknown>(stepId: string) => T | undefined;
+}
+interface WorkflowLogMessage extends BaseLogMessage {
+    type: typeof RegisteredLogger.WORKFLOW;
+    workflowName: string;
+    stepId?: StepId;
+    data?: unknown;
+    runId?: string;
+}
+type WorkflowEvent = {
+    type: 'RESET_TO_PENDING';
+    stepId: string;
+} | {
+    type: 'CONDITIONS_MET';
+    stepId: string;
+} | {
+    type: 'CONDITION_FAILED';
+    stepId: string;
+    error: string;
+} | {
+    type: 'SUSPENDED';
+    stepId: string;
+} | {
+    type: 'WAITING';
+    stepId: string;
+} | {
+    type: `xstate.error.actor.${string}`;
+    error: Error;
+} | {
+    type: `xstate.done.actor.${string}`;
+    output: ResolverFunctionOutput;
+};
+type ResolverFunctionInput = {
+    stepNode: StepNode;
+    context: WorkflowContext;
+};
+type ResolverFunctionOutput = {
+    stepId: StepId;
+    result: unknown;
+};
+type SubscriberFunctionOutput = {
+    stepId: StepId;
+    result: unknown;
+};
+type DependencyCheckOutput = {
+    type: 'CONDITIONS_MET';
+} | {
+    type: 'CONDITION_FAILED';
+    error: string;
+} | {
+    type: 'SUSPENDED';
+} | {
+    type: 'WAITING';
+};
+type WorkflowActors = {
+    resolverFunction: {
+        input: ResolverFunctionInput;
+        output: ResolverFunctionOutput;
+    };
+    conditionCheck: {
+        input: {
+            context: WorkflowContext;
+            stepId: string;
+        };
+        output: DependencyCheckOutput;
+    };
+    spawnSubscriberFunction: {
+        input: {
+            context: WorkflowContext;
+            stepId: string;
+        };
+        output: SubscriberFunctionOutput;
+    };
+};
+type WorkflowActionParams = {
+    stepId: string;
+};
+type WorkflowActions = {
+    type: 'updateStepResult' | 'setStepError' | 'notifyStepCompletion' | 'decrementAttemptCount';
+    params: WorkflowActionParams;
+};
+type WorkflowState = {
+    [key: string]: {
+        initial: 'pending';
+        states: {
+            pending: {
+                invoke: {
+                    src: 'conditionCheck';
+                    input: ({ context }: {
+                        context: WorkflowContext;
+                    }) => {
+                        context: WorkflowContext;
+                        stepId: string;
+                    };
+                    onDone: [
+                        {
+                            guard: (_: any, event: {
+                                output: DependencyCheckOutput;
+                            }) => boolean;
+                            target: 'executing';
+                        },
+                        {
+                            guard: (_: any, event: {
+                                output: DependencyCheckOutput;
+                            }) => boolean;
+                            target: 'waiting';
+                        }
+                    ];
+                };
+            };
+            waiting: {
+                after: {
+                    CHECK_INTERVAL: {
+                        target: 'pending';
+                    };
+                };
+            };
+            executing: {
+                invoke: {
+                    src: 'resolverFunction';
+                    input: ({ context }: {
+                        context: WorkflowContext;
+                    }) => ResolverFunctionInput;
+                    onDone: {
+                        target: 'completed';
+                        actions: ['updateStepResult'];
+                    };
+                    onError: {
+                        target: 'failed';
+                        actions: ['setStepError'];
+                    };
+                };
+            };
+            completed: {
+                type: 'final';
+                entry: ['notifyStepCompletion'];
+            };
+            failed: {
+                type: 'final';
+                entry: ['notifyStepCompletion'];
+            };
+        };
+    };
+};
+declare const StepIdBrand: unique symbol;
+type StepId = string & {
+    readonly [StepIdBrand]: typeof StepIdBrand;
+};
+type ExtractSchemaFromStep<TStep extends IAction<any, any, any, any>, TKey extends 'inputSchema' | 'outputSchema'> = TStep[TKey];
+type ExtractStepResult<T> = T extends (data: any) => Promise<infer R> ? R : never;
+type StepInputType<TStep extends IAction<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';
+            payload?: any;
+            error?: string;
+        }>;
+        triggerData: Record<string, any>;
+        attempts: Record<string, number>;
+    };
+    activePaths: Array<{
+        stepPath: string[];
+        stepId: string;
+        status: string;
+    }>;
+    runId: string;
+    timestamp: number;
+}
+
+type MastraPrimitives = {
+    logger?: Logger;
+    telemetry?: Telemetry;
+    storage?: MastraStorage;
+    agents?: Record<string, Agent>;
+    tts?: Record<string, MastraTTS>;
+    vectors?: Record<string, MastraVector>;
+    memory?: MastraMemory;
+};
+interface IExecutionContext<TSchemaIn extends z.ZodSchema | undefined = undefined, TContext extends WorkflowContext = WorkflowContext> {
+    context: TSchemaIn extends z.ZodSchema ? z.infer<TSchemaIn> & TContext : TContext;
+    runId?: string;
+    mastra?: MastraPrimitives;
+    suspend: () => Promise<void>;
+}
+interface IAction<TId extends string, TSchemaIn extends z.ZodSchema | undefined, TSchemaOut extends z.ZodSchema | undefined, TContext extends IExecutionContext<TSchemaIn>> {
+    id: TId;
+    description?: string;
+    inputSchema?: TSchemaIn;
+    outputSchema?: TSchemaOut;
+    mastra?: MastraPrimitives;
+    payload?: TSchemaIn extends z.ZodSchema ? Partial<z.infer<TSchemaIn>> : unknown;
+    execute: (context: TContext) => Promise<TSchemaOut extends z.ZodSchema ? z.infer<TSchemaOut> : unknown>;
+    [key: string]: any;
+}
+
+type CoreTool = {
+    description?: string;
+    parameters: ZodSchema;
+    execute: (params: any) => Promise<any>;
+};
+interface ToolExecutionContext<TSchemaIn extends z.ZodSchema | undefined = undefined, TContext extends WorkflowContext = WorkflowContext> extends IExecutionContext<TSchemaIn, TContext> {
+}
+interface ToolAction<TId extends string, TSchemaIn extends z.ZodSchema | undefined = undefined, TSchemaOut extends z.ZodSchema | undefined = undefined, TContext extends ToolExecutionContext<TSchemaIn> = ToolExecutionContext<TSchemaIn>> extends IAction<TId, TSchemaIn, TSchemaOut, TContext> {
+}
+
+type ToolsetsInput = Record<string, Record<string, ToolAction<any, any, any, any>>>;
+type ToolsInput = Record<string, ToolAction<any, any, any, any>>;
+interface AgentConfig<TTools extends Record<string, ToolAction<any, any, any, any>> = Record<string, ToolAction<any, any, any, any>>, TMetrics extends Record<string, Metric> = Record<string, Metric>> {
+    name: string;
+    instructions: string;
+    model: LanguageModelV1;
+    tools?: TTools;
+    mastra?: MastraPrimitives;
+    /** @deprecated This property is deprecated. Use evals instead to add evaluation metrics. */
+    metrics?: TMetrics;
+    evals?: TMetrics;
+    memory?: MastraMemory;
+    voice?: CompositeVoice;
+}
+interface AgentGenerateOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> {
+    toolsets?: ToolsetsInput;
+    resourceId?: string;
+    context?: CoreMessage[];
+    threadId?: string;
+    memoryOptions?: MemoryConfig;
+    runId?: string;
+    onStepFinish?: (step: string) => void;
+    maxSteps?: number;
+    output?: OutputType | Z;
+    temperature?: number;
+    toolChoice?: 'auto' | 'required';
+}
+interface AgentStreamOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> {
+    toolsets?: ToolsetsInput;
+    resourceId?: string;
+    context?: CoreMessage[];
+    threadId?: string;
+    memoryOptions?: MemoryConfig;
+    runId?: string;
+    onFinish?: (result: string) => unknown;
+    onStepFinish?: (step: string) => unknown;
+    maxSteps?: number;
+    output?: OutputType | Z;
+    temperature?: number;
+    toolChoice?: 'auto' | 'required';
+}
+
+type LanguageModel = LanguageModelV1;
+type CoreMessage = CoreMessage$1;
+type CoreSystemMessage = CoreSystemMessage$1;
+type CoreAssistantMessage = CoreAssistantMessage$1;
+type CoreUserMessage = CoreUserMessage$1;
+type CoreToolMessage = CoreToolMessage$1;
+type EmbedResult<T> = EmbedResult$1<T>;
+type EmbedManyResult<T> = EmbedManyResult$1<T>;
+type BaseStructuredOutputType = 'string' | 'number' | 'boolean' | 'date';
+type StructuredOutputType = 'array' | 'string' | 'number' | 'object' | '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, any> : GenerateObjectResult<any>;
+type StreamReturn<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = Z extends undefined ? StreamTextResult<any, any> : StreamObjectResult<any, any, any>;
+type OutputType = 'text' | StructuredOutput;
+type LLMStreamOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefined> = {
+    runId?: string;
+    onFinish?: (result: string) => Promise<void> | void;
+    onStepFinish?: (step: string) => void;
+    maxSteps?: number;
+    tools?: ToolsInput;
+    convertedTools?: Record<string, CoreTool>;
+    output?: OutputType | Z;
+    temperature?: number;
+};
+type LLMTextOptions = {
+    tools?: ToolsInput;
+    convertedTools?: Record<string, CoreTool>;
+    messages: CoreMessage[];
+    onStepFinish?: (step: string) => void;
+    toolChoice?: 'auto' | 'required';
+    maxSteps?: number;
+    temperature?: number;
+} & Run;
+type LLMTextObjectOptions<T> = LLMTextOptions & {
+    structuredOutput: JSONSchema7 | z.ZodType<T> | StructuredOutput;
+};
+type LLMInnerStreamOptions = {
+    tools?: ToolsInput;
+    convertedTools?: Record<string, CoreTool>;
+    messages: CoreMessage[];
+    onStepFinish?: (step: string) => unknown;
+    onFinish?: (result: string) => unknown;
+    maxSteps?: number;
+    temperature?: number;
+    toolChoice?: 'auto' | 'required';
+} & Run;
+type LLMStreamObjectOptions<T> = LLMInnerStreamOptions & {
+    structuredOutput: JSONSchema7 | z.ZodType<T> | StructuredOutput;
+};
+
+declare class MastraLLMBase extends MastraBase {
+    #private;
+    constructor({ name, model }: {
+        name: string;
+        model: LanguageModel$1;
+    });
+    getProvider(): string;
+    getModelId(): string;
+    getModel(): ai.LanguageModelV1;
+    convertToMessages(messages: string | string[] | CoreMessage$1[]): CoreMessage$1[];
+    __registerPrimitives(p: MastraPrimitives): void;
+    __text(input: LLMTextOptions): Promise<GenerateTextResult<any, any>>;
+    __textObject<T>(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(input: LLMInnerStreamOptions): Promise<StreamTextResult<any, any>>;
+    __streamObject<T>(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 Record<string, ToolAction<any, any, any, any>> = Record<string, ToolAction<any, any, any, any>>, TMetrics extends Record<string, Metric> = Record<string, Metric>> extends MastraBase {
+    #private;
+    name: string;
+    readonly llm: MastraLLMBase;
+    instructions: string;
+    readonly model?: LanguageModelV1;
+    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;
+    /**
+     * Set the concrete tools for the agent
+     * @param tools
+     */
+    __setTools(tools: TTools): void;
+    generateTitleFromUserMessage({ message }: {
+        message: CoreUserMessage$1;
+    }): Promise<string>;
+    getMostRecentUserMessage(messages: Array<CoreMessage$1>): CoreUserMessage$1 | undefined;
+    genTitle(userMessage: CoreUserMessage$1 | 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, runId, }: {
+        toolsets?: ToolsetsInput;
+        threadId?: 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[], { context, threadId: threadIdInFn, memoryOptions, resourceId, maxSteps, onStepFinish, runId, toolsets, output, temperature, toolChoice, }?: AgentGenerateOptions<Z>): Promise<GenerateReturn<Z>>;
+    stream<Z extends ZodSchema | JSONSchema7 | undefined = undefined>(messages: string | string[] | CoreMessage$1[], { context, threadId: threadIdInFn, memoryOptions, resourceId, maxSteps, onFinish, onStepFinish, runId, toolsets, output, temperature, toolChoice, }?: AgentStreamOptions<Z>): Promise<StreamReturn<Z>>;
+    /**
+     * 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;
+    };
+}
+interface WorkflowRow {
+    workflow_name: string;
+    run_id: string;
+    snapshot: WorkflowRunState;
+    created_at: Date;
+    updated_at: Date;
+}
+type StorageGetMessagesArg = {
+    threadId: 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 MessageResponse<T extends 'raw' | 'core_message'> = {
+    raw: MessageType[];
+    core_message: CoreMessage$1[];
+}[T];
+type MemoryConfig = {
+    lastMessages?: number | false;
+    semanticRecall?: boolean | {
+        topK: number;
+        messageRange: number | {
+            before: number;
+            after: number;
+        };
+    };
+    workingMemory?: {
+        enabled: boolean;
+        template?: string;
+    };
+};
+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>;
+    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[]>;
+}
+
+export { type StepCondition as $, Agent as A, type BaseStructuredOutputType as B, type CoreMessage as C, type LLMStreamOptions as D, type EvalRow as E, type LLMTextOptions as F, type GenerateReturn as G, type LLMTextObjectOptions as H, type IAction as I, type LLMInnerStreamOptions as J, type LLMStreamObjectOptions as K, type LanguageModel as L, MastraStorage as M, type MessageResponse as N, type OutputType as O, type MemoryConfig as P, type SharedMemoryConfig as Q, type RetryConfig as R, type StorageColumn as S, type TABLE_NAMES as T, type CoreTool as U, type StepNode as V, type WorkflowOptions as W, type VariableReference as X, type BaseCondition as Y, type ActionContext as Z, type StepDef as _, MastraMemory as a, type WorkflowContext as a0, type WorkflowLogMessage as a1, type WorkflowEvent as a2, type ResolverFunctionInput as a3, type ResolverFunctionOutput as a4, type SubscriberFunctionOutput as a5, type DependencyCheckOutput as a6, type WorkflowActors as a7, type WorkflowActionParams as a8, type WorkflowActions as a9, type WorkflowState as aa, type StepId as ab, type ExtractSchemaFromStep as ac, type ExtractStepResult as ad, type StepInputType as ae, type ExtractSchemaType as af, type PathsToStringProps as ag, TABLE_WORKFLOW_SNAPSHOT as ah, TABLE_EVALS as ai, TABLE_MESSAGES as aj, TABLE_THREADS as ak, TABLE_TRACES as al, type StorageThreadType as b, type MessageType as c, type StorageGetMessagesArg as d, type StepExecutionContext as e, type StepAction as f, type MastraPrimitives as g, type StepVariableType as h, type StepConfig as i, type StepResult as j, type WorkflowRunState as k, type StepGraph as l, type ToolAction as m, type AgentConfig as n, type ToolExecutionContext as o, type WorkflowRow as p, type CoreSystemMessage as q, type CoreAssistantMessage as r, type CoreUserMessage as s, type CoreToolMessage as t, type EmbedResult as u, type EmbedManyResult as v, type StructuredOutputType as w, type StructuredOutputArrayItem as x, type StructuredOutput as y, type StreamReturn as z };