@mastra/core 0.5.0-alpha.8 → 0.5.0

package/dist/{base-DIn_km7X.d.ts → base-C_Oq53qk.d.ts}

@@ -1,6 +1,6 @@
 import * as ai from 'ai';
 import { Tool, ToolExecutionOptions, EmbeddingModel, CoreMessage as CoreMessage$1, Message, UserContent, AssistantContent, LanguageModelV1, TelemetrySettings, generateText, generateObject, streamText, GenerateTextResult, GenerateObjectResult, streamObject, 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, O as OtelConfig, T as Telemetry } from './base-BZViaFTt.js';
+import { M as MastraBase, T as Telemetry, O as OtelConfig } from './base-BZViaFTt.js';
 import { Query } from 'sift';
 import { z, ZodSchema } from 'zod';
 import { JSONSchema7 } from 'json-schema';
@@ -23,7 +23,7 @@ interface ToolExecutionContext<TSchemaIn extends z.ZodSchema | undefined = undef
 }
 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>;
+    execute?: (context: TContext, options?: TOptions) => Promise<TSchemaOut extends z.ZodSchema ? z.infer<TSchemaOut> : unknown>;
     mastra?: Mastra;
 }
 
@@ -62,8 +62,9 @@ declare abstract class MastraMemory extends MastraBase {
         indexName: string;
     }>;
     getMergedThreadConfig(config?: MemoryConfig): MemoryConfig;
-    abstract rememberMessages({ threadId, vectorMessageSearch, config, }: {
+    abstract rememberMessages({ threadId, resourceId, vectorMessageSearch, config, }: {
         threadId: string;
+        resourceId?: string;
         vectorMessageSearch?: string;
         config?: MemoryConfig;
     }): Promise<{
@@ -108,7 +109,7 @@ declare abstract class MastraMemory extends MastraBase {
      * @param threadId - The unique identifier of the thread
      * @returns Promise resolving to array of messages and uiMessages
      */
-    abstract query({ threadId, selectBy, }: StorageGetMessagesArg): Promise<{
+    abstract query({ threadId, resourceId, selectBy, }: StorageGetMessagesArg): Promise<{
         messages: CoreMessage$1[];
         uiMessages: Message[];
     }>;
@@ -158,6 +159,19 @@ declare abstract class MastraMemory extends MastraBase {
     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>);
+}
+declare function createStep<TId extends string, TSchemaIn extends z.ZodSchema | undefined, TSchemaOut extends z.ZodSchema | undefined, TContext extends StepExecutionContext<TSchemaIn>>(opts: StepAction<TId, TSchemaIn, TSchemaOut, TContext>): Step<TId, TSchemaIn, TSchemaOut, TContext>;
+
 interface WorkflowOptions<TTriggerSchema extends z.ZodObject<any> = any> {
     name: string;
     triggerSchema?: TTriggerSchema;
@@ -166,13 +180,14 @@ interface WorkflowOptions<TTriggerSchema extends z.ZodObject<any> = any> {
 }
 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: () => Promise<void>;
+    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 {
@@ -224,14 +239,15 @@ type ActionContext<TSchemaIn extends z.ZodType<any>> = StepExecutionContext<z.in
 declare enum WhenConditionReturnValue {
     CONTINUE = "continue",
     CONTINUE_FAILED = "continue_failed",
-    ABORT = "abort"
+    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, {
-    snapshotOnTimeout?: boolean;
     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>>;
 }>;
@@ -249,10 +265,9 @@ type Condition<TStep extends StepVariableType<any, any, any, any>, TTriggerSchem
 } | {
     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>> {
-    snapshotOnTimeout?: boolean;
+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>;
+        context: WorkflowContext<TTriggerSchema, TSteps>;
         mastra?: Mastra;
     }) => Promise<boolean | WhenConditionReturnValue>);
     variables?: StepInputType<TStep, 'inputSchema'> extends never ? Record<string, VariableReference<VarStep, TTriggerSchema>> : {
@@ -274,13 +289,35 @@ type StepFailure = {
     status: 'failed';
     error: string;
 };
-type StepResult<T> = StepSuccess<T> | StepFailure | StepSuspended | StepWaiting;
-interface WorkflowContext<TTrigger extends z.ZodObject<any> = any> {
+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<string, {
+        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: Record<string, StepResult<any>>;
+    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>;
     attempts: Record<string, number>;
-    getStepResult: <T = unknown>(stepId: string) => T | undefined;
+    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']>>;
 }
 interface WorkflowLogMessage extends BaseLogMessage {
     type: typeof RegisteredLogger.WORKFLOW;
@@ -336,11 +373,22 @@ type DependencyCheckOutput = {
     type: 'SUSPENDED';
 } | {
     type: 'WAITING';
+} | {
+    type: 'CONDITIONS_LIMBO';
+};
+type StepResolverOutput = {
+    type: 'STEP_SUCCESS';
+    output: unknown;
+} | {
+    type: 'STEP_FAILED';
+    error: string;
+} | {
+    type: 'STEP_WAITING';
 };
 type WorkflowActors = {
     resolverFunction: {
         input: ResolverFunctionInput;
-        output: ResolverFunctionOutput;
+        output: StepResolverOutput;
     };
     conditionCheck: {
         input: {
@@ -442,7 +490,7 @@ interface WorkflowRunState {
     value: Record<string, string>;
     context: {
         steps: Record<string, {
-            status: 'success' | 'failed' | 'suspended' | 'waiting';
+            status: 'success' | 'failed' | 'suspended' | 'waiting' | 'skipped';
             payload?: any;
             error?: string;
         }>;
@@ -464,35 +512,14 @@ type WorkflowResumeResult<TTriggerSchema extends z.ZodObject<any>> = {
     results: Record<string, StepResult<any>>;
 };
 
-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>);
-}
-declare function createStep<TId extends string, TSchemaIn extends z.ZodSchema | undefined, TSchemaOut extends z.ZodSchema | undefined, TContext extends StepExecutionContext<TSchemaIn>>(opts: StepAction<TId, TSchemaIn, TSchemaOut, TContext>): Step<TId, TSchemaIn, TSchemaOut, TContext>;
-
-interface WorkflowResultReturn<T extends z.ZodType<any>> {
+interface WorkflowResultReturn<T extends z.ZodType<any>, TSteps extends Step<any, any, any>[]> {
     runId: string;
     start: (props?: {
         triggerData?: z.infer<T>;
-    } | undefined) => Promise<{
-        triggerData?: z.infer<T>;
-        results: Record<string, StepResult<any>>;
-        runId: string;
-        activePaths: Map<string, {
-            status: string;
-            suspendPayload?: any;
-        }>;
-    }>;
+    } | undefined) => Promise<WorkflowRunResult<T, TSteps>>;
 }
 
-declare class Workflow<TSteps extends Step<any, any, any>[] = any, TTriggerSchema extends z.ZodObject<any> = any> extends MastraBase {
+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;
@@ -506,7 +533,7 @@ declare class Workflow<TSteps extends Step<any, any, any>[] = any, TTriggerSchem
     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>['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">;
@@ -516,7 +543,7 @@ declare class Workflow<TSteps extends Step<any, any, any>[] = any, TTriggerSchem
      * @returns Promise resolving to workflow results or rejecting with error
      * @throws Error if trigger schema validation fails
      */
-    createRun(): WorkflowResultReturn<TTriggerSchema>;
+    createRun(): WorkflowResultReturn<TTriggerSchema, TSteps>;
     /**
      * Rebuilds the machine with the current steps configuration and validates the workflow
      *
@@ -533,26 +560,12 @@ declare class Workflow<TSteps extends Step<any, any, any>[] = any, TTriggerSchem
         runId: string;
         stepId: string;
         context?: Record<string, any>;
-    }): Promise<{
-        triggerData?: z.TypeOf<TTriggerSchema> | undefined;
-        results: Record<string, StepResult<any>>;
-        activePaths: Map<string, {
-            status: string;
-            suspendPayload?: any;
-        }>;
-    } | undefined>;
+    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps>, "runId"> | undefined>;
     _resume({ runId, stepId, context: resumeContext, }: {
         runId: string;
         stepId: string;
         context?: Record<string, any>;
-    }): Promise<{
-        triggerData?: z.TypeOf<TTriggerSchema> | undefined;
-        results: Record<string, StepResult<any>>;
-        activePaths: Map<string, {
-            status: string;
-            suspendPayload?: any;
-        }>;
-    } | undefined>;
+    }): Promise<Omit<WorkflowRunResult<TTriggerSchema, TSteps>, "runId"> | undefined>;
     __registerMastra(mastra: Mastra): void;
     __registerPrimitives(p: MastraPrimitives): void;
     get stepGraph(): StepGraph;
@@ -569,18 +582,30 @@ interface Config<TAgents extends Record<string, Agent<any>> = Record<string, Age
     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 vectors?;
-    private agents;
-    private logger;
-    private workflows;
-    private telemetry?;
-    private tts?;
-    private deployer?;
+    #private;
+    /**
+     * @deprecated use getStorage() instead
+     */
     storage?: MastraStorage;
+    /**
+     * @deprecated use getMemory() instead
+     */
     memory?: MastraMemory;
+    /**
+     * @deprecated use getTelemetry() instead
+     */
+    get telemetry(): Telemetry | undefined;
     constructor(config?: Config<TAgents, TWorkflows, TVectors, TTTS, TLogger>);
     getAgent<TAgentName extends keyof TAgents>(name: TAgentName): TAgents[TAgentName];
     getAgents(): TAgents;
@@ -601,6 +626,12 @@ declare class Mastra<TAgents extends Record<string, Agent<any>> = Record<string,
     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;
@@ -631,15 +662,16 @@ interface IAction<TId extends string, TSchemaIn extends z.ZodSchema | undefined,
     description?: string;
     inputSchema?: TSchemaIn;
     outputSchema?: TSchemaOut;
-    execute: (context: TContext, options?: TOptions) => Promise<TSchemaOut extends z.ZodSchema ? z.infer<TSchemaOut> : unknown>;
+    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: LanguageModelV1;
+    model: MastraLanguageModel;
     tools?: TTools;
     mastra?: Mastra;
     /** @deprecated This property is deprecated. Use evals instead to add evaluation metrics. */
@@ -693,7 +725,7 @@ type AgentStreamOptions<Z extends ZodSchema | JSONSchema7 | undefined = undefine
     threadId: string;
 }) & (Z extends undefined ? DefaultLLMStreamOptions : DefaultLLMStreamObjectOptions);
 
-type LanguageModel = LanguageModelV1;
+type LanguageModel = MastraLanguageModel;
 type CoreMessage = CoreMessage$1;
 type CoreSystemMessage = CoreSystemMessage$1;
 type CoreAssistantMessage = CoreAssistantMessage$1;
@@ -783,7 +815,7 @@ declare class Agent<TTools extends ToolsInput = ToolsInput, TMetrics extends Rec
     name: string;
     readonly llm: MastraLLMBase;
     instructions: string;
-    readonly model?: LanguageModelV1;
+    readonly model?: MastraLanguageModel;
     tools: TTools;
     /** @deprecated This property is deprecated. Use evals instead. */
     metrics: TMetrics;
@@ -933,6 +965,7 @@ interface WorkflowRow {
 }
 type StorageGetMessagesArg = {
     threadId: string;
+    resourceId?: string;
     selectBy?: {
         vectorSearchString?: string;
         last?: number | false;
@@ -1120,4 +1153,4 @@ declare abstract class MastraStorage extends MastraBase {
     __getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
 }
 
-export { type RetryConfig as $, Agent as A, type BaseStructuredOutputType as B, type CoreTool as C, type DefaultLLMTextOptions as D, type EvalRow as E, type LLMTextOptions as F, type GenerateReturn as G, type LLMTextObjectOptions as H, type LLMStreamOptions as I, type LLMInnerStreamOptions as J, type LLMStreamObjectOptions as K, type LanguageModel as L, Mastra as M, type Config as N, type OutputType as O, type MessageResponse as P, type MemoryConfig as Q, type SharedMemoryConfig as R, type StorageColumn as S, type ToolAction as T, type StepExecutionContext as U, type VercelTool as V, Workflow as W, type StepAction as X, type StepVariableType as Y, type StepNode as Z, type StepGraph as _, type MastraPrimitives as a, type VariableReference as a0, type BaseCondition as a1, type ActionContext as a2, WhenConditionReturnValue as a3, type StepDef as a4, type StepCondition as a5, type StepConfig as a6, type StepResult as a7, type WorkflowContext as a8, type WorkflowLogMessage as a9, TABLE_TRACES as aA, type WorkflowEvent as aa, type ResolverFunctionInput as ab, type ResolverFunctionOutput as ac, type SubscriberFunctionOutput as ad, type DependencyCheckOutput as ae, type WorkflowActors as af, type WorkflowActionParams as ag, type WorkflowActions as ah, type WorkflowState as ai, type StepId as aj, type ExtractSchemaFromStep as ak, type ExtractStepResult as al, type StepInputType as am, type ExtractSchemaType as an, type PathsToStringProps as ao, type WorkflowRunState as ap, type WorkflowResumeResult as aq, createStep as ar, type ToolsInput as as, type ToolsetsInput as at, type AgentGenerateOptions as au, type AgentStreamOptions as av, TABLE_WORKFLOW_SNAPSHOT as aw, TABLE_EVALS as ax, TABLE_MESSAGES as ay, TABLE_THREADS as az, MastraMemory as b, MastraStorage as c, type TABLE_NAMES as d, type StorageThreadType as e, type MessageType as f, type StorageGetMessagesArg as g, type AgentConfig as h, type ToolExecutionContext as i, Step as j, type WorkflowOptions as k, type WorkflowRow as l, type CoreMessage as m, type CoreSystemMessage as n, type CoreAssistantMessage as o, type CoreUserMessage as p, type CoreToolMessage as q, type EmbedResult as r, type EmbedManyResult as s, type StructuredOutputType as t, type StructuredOutputArrayItem as u, type StructuredOutput as v, type StreamReturn as w, type DefaultLLMTextObjectOptions as x, type DefaultLLMStreamOptions as y, type DefaultLLMStreamObjectOptions as z };
+export { type StepNode as $, Agent as A, type BaseStructuredOutputType as B, type CoreTool as C, type DefaultLLMTextOptions as D, type EvalRow as E, type DefaultLLMTextObjectOptions as F, type GenerateReturn as G, type DefaultLLMStreamOptions as H, type DefaultLLMStreamObjectOptions as I, type LLMTextOptions as J, type LLMTextObjectOptions as K, type LanguageModel as L, Mastra as M, type LLMStreamOptions as N, type OutputType as O, type LLMInnerStreamOptions as P, type LLMStreamObjectOptions as Q, type Config as R, Step as S, type ToolAction as T, type MessageResponse as U, type VercelTool as V, Workflow as W, type MemoryConfig as X, type SharedMemoryConfig as Y, type StepAction as Z, type StepVariableType as _, type ToolsInput as a, type StepGraph as a0, type RetryConfig as a1, type VariableReference as a2, type BaseCondition as a3, type ActionContext as a4, WhenConditionReturnValue as a5, type StepDef as a6, type StepCondition as a7, type StepConfig as a8, type StepResult as a9, TABLE_WORKFLOW_SNAPSHOT as aA, TABLE_EVALS as aB, TABLE_MESSAGES as aC, TABLE_THREADS as aD, TABLE_TRACES as aE, type StepsRecord as aa, type WorkflowRunResult as ab, type WorkflowLogMessage as ac, type WorkflowEvent as ad, type ResolverFunctionInput as ae, type ResolverFunctionOutput as af, type SubscriberFunctionOutput as ag, type DependencyCheckOutput as ah, type StepResolverOutput as ai, type WorkflowActors as aj, type WorkflowActionParams as ak, type WorkflowActions as al, type WorkflowState as am, type StepId as an, type ExtractSchemaFromStep as ao, type ExtractStepResult as ap, type StepInputType as aq, type ExtractSchemaType as ar, type PathsToStringProps as as, type WorkflowRunState as at, type WorkflowResumeResult as au, createStep as av, type MastraLanguageModel as aw, type ToolsetsInput as ax, type AgentGenerateOptions as ay, type AgentStreamOptions as az, type MastraPrimitives as b, MastraMemory as c, type StepExecutionContext as d, type WorkflowContext as e, MastraStorage as f, type TABLE_NAMES as g, type StorageColumn as h, type StorageThreadType as i, type MessageType as j, type StorageGetMessagesArg as k, type AgentConfig as l, type ToolExecutionContext as m, type WorkflowOptions as n, type WorkflowRow as o, type CoreMessage 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 };

package/dist/base.cjs

@@ -1,145 +1,10 @@
 'use strict';
 
-var stream = require('stream');
-var pino = require('pino');
-var pretty = require('pino-pretty');
+var chunkIIWRJFLQ_cjs = require('./chunk-IIWRJFLQ.cjs');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var pino__default = /*#__PURE__*/_interopDefault(pino);
-var pretty__default = /*#__PURE__*/_interopDefault(pretty);
 
-// src/logger/index.ts
-var RegisteredLogger = {
-  LLM: "LLM"};
-var LogLevel = {
-  INFO: "info"};
-var Logger = class {
-  logger;
-  transports;
-  constructor(options = {}) {
-    this.transports = options.transports || {};
-    const transportsAry = Object.entries(this.transports);
-    this.logger = pino__default.default(
-      {
-        name: options.name || "app",
-        level: options.level || LogLevel.INFO,
-        formatters: {
-          level: (label) => {
-            return {
-              level: label
-            };
-          }
-        }
-      },
-      options.overrideDefaultTransports ? options?.transports?.default : transportsAry.length === 0 ? pretty__default.default({
-        colorize: true,
-        levelFirst: true,
-        ignore: "pid,hostname",
-        colorizeObjects: true,
-        translateTime: "SYS:standard",
-        singleLine: false
-      }) : pino__default.default.multistream([
-        ...transportsAry.map(([_, transport]) => ({
-          stream: transport,
-          level: options.level || LogLevel.INFO
-        })),
-        {
-          stream: pretty__default.default({
-            colorize: true,
-            levelFirst: true,
-            ignore: "pid,hostname",
-            colorizeObjects: true,
-            translateTime: "SYS:standard",
-            singleLine: false
-          }),
-          level: options.level || LogLevel.INFO
-        }
-      ])
-    );
-  }
-  debug(message, args = {}) {
-    this.logger.debug(args, message);
-  }
-  info(message, args = {}) {
-    this.logger.info(args, message);
-  }
-  warn(message, args = {}) {
-    this.logger.warn(args, message);
-  }
-  error(message, args = {}) {
-    this.logger.error(args, message);
-  }
-  // Stream creation for process output handling
-  createStream() {
-    return new stream.Transform({
-      transform: (chunk, _encoding, callback) => {
-        const line = chunk.toString().trim();
-        if (line) {
-          this.info(line);
-        }
-        callback(null, chunk);
-      }
-    });
-  }
-  async getLogs(transportId) {
-    if (!transportId || !this.transports[transportId]) {
-      return [];
-    }
-    return this.transports[transportId].getLogs();
-  }
-  async getLogsByRunId({ runId, transportId }) {
-    return this.transports[transportId]?.getLogsByRunId({ runId });
-  }
-};
-function createLogger(options) {
-  return new Logger(options);
-}
-
-// src/base.ts
-var MastraBase = class {
-  component = RegisteredLogger.LLM;
-  logger;
-  name;
-  telemetry;
-  constructor({ component, name }) {
-    this.component = component || RegisteredLogger.LLM;
-    this.name = name;
-    this.logger = createLogger({ name: `${this.component} - ${this.name}` });
-  }
-  /**
-   * Set the logger for the agent
-   * @param logger
-   */
-  __setLogger(logger) {
-    this.logger = logger;
-    this.logger.debug(`Logger updated [component=${this.component}] [name=${this.name}]`);
-  }
-  /**
-   * Set the telemetry for the
-   * @param telemetry
-   */
-  __setTelemetry(telemetry) {
-    this.telemetry = telemetry;
-    this.logger.debug(`Telemetry updated [component=${this.component}] [tracer=${this.telemetry.tracer}]`);
-  }
-  /**
-   * Get the telemetry on the vector
-   * @returns telemetry
-   */
-  __getTelemetry() {
-    return this.telemetry;
-  }
-  /* 
-    get experimental_telemetry config
-    */
-  get experimental_telemetry() {
-    return this.telemetry ? {
-      // tracer: this.telemetry.tracer,
-      tracer: this.telemetry.getBaggageTracer(),
-      isEnabled: !!this.telemetry.tracer
-    } : void 0;
-  }
-};
-
-exports.MastraBase = MastraBase;
+Object.defineProperty(exports, "MastraBase", {
+  enumerable: true,
+  get: function () { return chunkIIWRJFLQ_cjs.MastraBase; }
+});