@mastra/core 0.2.0-alpha.93 → 0.2.0-alpha.95

package/dist/index-CBxGSZZE.d.ts

@@ -0,0 +1,808 @@
+import { Message, UserContent, AssistantContent, ToolContent, CoreMessage as CoreMessage$1, EmbeddingModel, LanguageModelV1, CoreSystemMessage as CoreSystemMessage$1, CoreAssistantMessage as CoreAssistantMessage$1, CoreUserMessage as CoreUserMessage$1, CoreToolMessage as CoreToolMessage$1, EmbedResult as EmbedResult$1, EmbedManyResult as EmbedManyResult$1, GenerateTextResult, GenerateObjectResult, StreamTextResult, StreamObjectResult, LanguageModel as LanguageModel$1, DeepPartial } from 'ai';
+import { JSONSchema7 } from 'json-schema';
+import { z, ZodSchema } from 'zod';
+import { MastraBase } from './base.js';
+import { M as Metric } from './metric-D2V4CR8D.js';
+import { T as Telemetry } from './telemetry-oCUM52DG.js';
+import { Query } from 'sift';
+import { B as BaseLogMessage, R as RegisteredLogger, L as Logger, b as Run } from './index-CBZ2mk2H.js';
+import { MastraVector } from './vector/index.js';
+import { MastraTTS } from './tts/index.js';
+
+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';
+    payload: 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> {
+    stepResults: 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: {
+        stepResults: 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;
+}
+
+interface StorageColumn {
+    type: 'text' | 'timestamp' | 'uuid' | 'jsonb' | 'integer';
+    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 TABLE_NAMES = typeof MastraStorage.TABLE_WORKFLOW_SNAPSHOT | typeof MastraStorage.TABLE_EVALS | typeof MastraStorage.TABLE_MESSAGES | typeof MastraStorage.TABLE_THREADS;
+declare abstract class MastraStorage extends MastraBase {
+    static readonly TABLE_WORKFLOW_SNAPSHOT = "mastra_workflow_snapshot";
+    static readonly TABLE_EVALS = "mastra_evals";
+    static readonly TABLE_MESSAGES = "mastra_messages";
+    static readonly TABLE_THREADS = "mastra_threads";
+    hasInit: 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 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[]>;
+    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>;
+}
+
+type AiMessageType = Message;
+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>;
+};
+/**
+ * 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);
+    /**
+     * 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 getEmbedder(): EmbeddingModel<string>;
+    protected getMergedThreadConfig(config?: MemoryConfig): MemoryConfig;
+    abstract rememberMessages({ threadId, vectorMessageSearch, config, }: {
+        threadId: string;
+        vectorMessageSearch?: string;
+        config?: MemoryConfig;
+    }): Promise<{
+        messages: CoreMessage$1[];
+        uiMessages: AiMessageType[];
+    }>;
+    estimateTokens(text: string): number;
+    protected parseMessages(messages: MessageType[]): CoreMessage$1[];
+    protected convertToUIMessages(messages: MessageType[]): AiMessageType[];
+    /**
+     * 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: AiMessageType[];
+    }>;
+    /**
+     * 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;
+}
+
+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> & {
+        machineContext?: TContext;
+    } : {
+        machineContext?: 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;
+    metrics?: TMetrics;
+    memory?: MastraMemory;
+}
+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) => Promise<void> | void;
+    onStepFinish?: (step: string) => void;
+    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) => void;
+    onFinish?: (result: string) => Promise<void> | void;
+    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;
+    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;
+    readonly instructions: string;
+    readonly model?: LanguageModelV1;
+    tools: TTools;
+    metrics: TMetrics;
+    constructor(config: AgentConfig<TTools, TMetrics>);
+    hasOwnMemory(): boolean;
+    getMemory(): MastraMemory | undefined;
+    __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: any[];
+    }>;
+    saveResponse({ result, threadId, resourceId, runId, memoryConfig, }: {
+        runId: string;
+        resourceId: string;
+        result: Record<string, any>;
+        threadId: string;
+        memoryConfig: MemoryConfig | undefined;
+    }): Promise<void>;
+    sanitizeResponseMessages(messages: Array<CoreToolMessage$1 | CoreAssistantMessage$1>): Array<CoreToolMessage$1 | CoreAssistantMessage$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>>;
+}
+
+export { type StepCondition as $, Agent as A, type BaseStructuredOutputType as B, type CoreMessage as C, type LLMInnerStreamOptions as D, type EmbedResult as E, type LLMStreamObjectOptions as F, type GenerateReturn as G, type AiMessageType as H, type IAction as I, type MessageType as J, type StorageThreadType 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 StepExecutionContext as S, type ToolAction 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, type IExecutionContext as ah, type StepAction as b, type MastraPrimitives as c, type StepVariableType as d, type StepConfig as e, type StepResult as f, type WorkflowRunState as g, type StepGraph as h, type AgentConfig as i, type ToolExecutionContext as j, type TABLE_NAMES as k, type StorageColumn as l, type WorkflowRow as m, type StorageGetMessagesArg as n, type CoreSystemMessage as o, type CoreAssistantMessage as p, type CoreUserMessage as q, type CoreToolMessage as r, type EmbedManyResult as s, type StructuredOutputType as t, type StructuredOutputArrayItem as u, type StructuredOutput as v, type StreamReturn as w, type LLMStreamOptions as x, type LLMTextOptions as y, type LLMTextObjectOptions as z };