@mastra/core 0.24.0 → 1.0.0-beta.1

package/dist/workflows/legacy/machine.d.ts

@@ -1,386 +0,0 @@
-import EventEmitter from 'node:events';
-import type { Span } from '@opentelemetry/api';
-import type { Snapshot } from 'xstate';
-import type { z } from 'zod';
-import type { MastraUnion } from '../../action/index.js';
-import type { IMastraLogger } from '../../logger/index.js';
-import type { Mastra } from '../../mastra/index.js';
-import type { RuntimeContext } from '../../runtime-context/index.js';
-import type { LegacyStep as Step } from './step.js';
-import type { ResolverFunctionInput, ResolverFunctionOutput, RetryConfig, StepGraph, StepNode, WorkflowContext, LegacyWorkflowRunResult as WorkflowRunResult } from './types.js';
-import type { WorkflowInstance } from './workflow-instance.js';
-export declare class Machine<TSteps extends Step<any, any, any, any>[] = Step<any, any, any, any>[], TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any> extends EventEmitter {
-    #private;
-    logger: IMastraLogger;
-    name: string;
-    constructor({ logger, mastra, runtimeContext, workflowInstance, executionSpan, name, runId, steps, stepGraph, retryConfig, startStepId, }: {
-        logger: IMastraLogger;
-        mastra?: Mastra;
-        runtimeContext: RuntimeContext;
-        workflowInstance: WorkflowInstance;
-        executionSpan?: Span;
-        name: string;
-        runId: string;
-        steps: Record<string, StepNode>;
-        stepGraph: StepGraph;
-        retryConfig?: RetryConfig;
-        startStepId: string;
-    });
-    get startStepId(): string;
-    execute({ stepId, input, snapshot, resumeData, }?: {
-        stepId?: string;
-        input?: any;
-        snapshot?: Snapshot<any>;
-        resumeData?: any;
-    }): Promise<Pick<WorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>, 'results' | 'activePaths' | 'runId' | 'timestamp'>>;
-    private initializeMachine;
-    getSnapshot(): import("xstate").MachineSnapshot<Omit<WorkflowContext<any, Step<string, any, any, any>[], Record<string, any>>, "getStepResult">, {
-        type: "RESET_TO_PENDING";
-        stepId: string;
-    } | {
-        type: "CONDITIONS_MET";
-        stepId: string;
-    } | {
-        type: "CONDITION_FAILED";
-        stepId: string;
-        error: string;
-    } | {
-        type: "SUSPENDED";
-        stepId: string;
-        suspendPayload?: any;
-        softSuspend?: any;
-    } | {
-        type: "WAITING";
-        stepId: string;
-    } | {
-        type: `xstate.error.actor.${string}`;
-        error: Error;
-    } | {
-        type: `xstate.done.actor.${string}`;
-        output: ResolverFunctionOutput;
-    }, {
-        [x: string]: import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<{
-            type: "CONDITIONS_MET";
-            error?: undefined;
-        } | {
-            type: "CONDITIONS_SKIP_TO_COMPLETED";
-            error?: undefined;
-        } | {
-            type: "CONDITIONS_LIMBO";
-            error?: undefined;
-        } | {
-            type: "CONDITIONS_SKIPPED";
-            error?: undefined;
-        } | {
-            type: "CONDITION_FAILED";
-            error: string;
-        }, {
-            context: WorkflowContext;
-            stepNode: StepNode;
-        }, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<{
-            type: "STEP_FAILED";
-            error: string;
-            stepId: string;
-            result?: undefined;
-        } | {
-            type: "STEP_WAITING";
-            stepId: string;
-            error?: undefined;
-            result?: undefined;
-        } | {
-            type: "STEP_SUCCESS";
-            result: any;
-            stepId: string;
-            error?: undefined;
-        }, ResolverFunctionInput, import("xstate").EventObject>> | import("xstate").ActorRefFromLogic<import("xstate").PromiseActorLogic<{
-            steps: {};
-        }, {
-            parentStepId: string;
-            context: WorkflowContext;
-        }, import("xstate").EventObject>> | undefined;
-    }, {
-        [x: string]: {} | {
-            [x: string]: {} | /*elided*/ any | {
-                [x: string]: {} | /*elided*/ any | /*elided*/ any;
-            };
-        } | {
-            [x: string]: {} | {
-                [x: string]: {} | /*elided*/ any | /*elided*/ any;
-            } | /*elided*/ any;
-        };
-    }, string, import("xstate").NonReducibleUnknown, import("xstate").MetaObject, {
-        readonly id: string;
-        readonly type: "parallel";
-        readonly context: ({ input }: {
-            spawn: {
-                <TSrc extends "conditionCheck" | "resolverFunction" | "spawnSubscriberFunction">(logic: TSrc, ...[options]: ({
-                    src: "conditionCheck";
-                    logic: import("xstate").PromiseActorLogic<{
-                        type: "CONDITIONS_MET";
-                        error?: undefined;
-                    } | {
-                        type: "CONDITIONS_SKIP_TO_COMPLETED";
-                        error?: undefined;
-                    } | {
-                        type: "CONDITIONS_LIMBO";
-                        error?: undefined;
-                    } | {
-                        type: "CONDITIONS_SKIPPED";
-                        error?: undefined;
-                    } | {
-                        type: "CONDITION_FAILED";
-                        error: string;
-                    }, {
-                        context: WorkflowContext;
-                        stepNode: StepNode;
-                    }, import("xstate").EventObject>;
-                    id: string | undefined;
-                } extends infer T ? T extends {
-                    src: "conditionCheck";
-                    logic: import("xstate").PromiseActorLogic<{
-                        type: "CONDITIONS_MET";
-                        error?: undefined;
-                    } | {
-                        type: "CONDITIONS_SKIP_TO_COMPLETED";
-                        error?: undefined;
-                    } | {
-                        type: "CONDITIONS_LIMBO";
-                        error?: undefined;
-                    } | {
-                        type: "CONDITIONS_SKIPPED";
-                        error?: undefined;
-                    } | {
-                        type: "CONDITION_FAILED";
-                        error: string;
-                    }, {
-                        context: WorkflowContext;
-                        stepNode: StepNode;
-                    }, import("xstate").EventObject>;
-                    id: string | undefined;
-                } ? T extends {
-                    src: TSrc;
-                } ? import("xstate").ConditionalRequired<[options?: ({
-                    id?: T["id"] | undefined;
-                    systemId?: string;
-                    input?: import("xstate").InputFrom<T["logic"]> | undefined;
-                    syncSnapshot?: boolean;
-                } & { [K in import("xstate").RequiredActorOptions<T>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T>>> : never : never : never) | ({
-                    src: "resolverFunction";
-                    logic: import("xstate").PromiseActorLogic<{
-                        type: "STEP_FAILED";
-                        error: string;
-                        stepId: string;
-                        result?: undefined;
-                    } | {
-                        type: "STEP_WAITING";
-                        stepId: string;
-                        error?: undefined;
-                        result?: undefined;
-                    } | {
-                        type: "STEP_SUCCESS";
-                        result: any;
-                        stepId: string;
-                        error?: undefined;
-                    }, ResolverFunctionInput, import("xstate").EventObject>;
-                    id: string | undefined;
-                } extends infer T_1 ? T_1 extends {
-                    src: "resolverFunction";
-                    logic: import("xstate").PromiseActorLogic<{
-                        type: "STEP_FAILED";
-                        error: string;
-                        stepId: string;
-                        result?: undefined;
-                    } | {
-                        type: "STEP_WAITING";
-                        stepId: string;
-                        error?: undefined;
-                        result?: undefined;
-                    } | {
-                        type: "STEP_SUCCESS";
-                        result: any;
-                        stepId: string;
-                        error?: undefined;
-                    }, ResolverFunctionInput, import("xstate").EventObject>;
-                    id: string | undefined;
-                } ? T_1 extends {
-                    src: TSrc;
-                } ? import("xstate").ConditionalRequired<[options?: ({
-                    id?: T_1["id"] | undefined;
-                    systemId?: string;
-                    input?: import("xstate").InputFrom<T_1["logic"]> | undefined;
-                    syncSnapshot?: boolean;
-                } & { [K_1 in import("xstate").RequiredActorOptions<T_1>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T_1>>> : never : never : never) | ({
-                    src: "spawnSubscriberFunction";
-                    logic: import("xstate").PromiseActorLogic<{
-                        steps: {};
-                    }, {
-                        parentStepId: string;
-                        context: WorkflowContext;
-                    }, import("xstate").EventObject>;
-                    id: string | undefined;
-                } extends infer T_2 ? T_2 extends {
-                    src: "spawnSubscriberFunction";
-                    logic: import("xstate").PromiseActorLogic<{
-                        steps: {};
-                    }, {
-                        parentStepId: string;
-                        context: WorkflowContext;
-                    }, import("xstate").EventObject>;
-                    id: string | undefined;
-                } ? T_2 extends {
-                    src: TSrc;
-                } ? import("xstate").ConditionalRequired<[options?: ({
-                    id?: T_2["id"] | undefined;
-                    systemId?: string;
-                    input?: import("xstate").InputFrom<T_2["logic"]> | undefined;
-                    syncSnapshot?: boolean;
-                } & { [K_2 in import("xstate").RequiredActorOptions<T_2>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredActorOptions<T_2>>> : never : never : never)): import("xstate").ActorRefFromLogic<import("xstate").GetConcreteByKey<import("xstate").Values<{
-                    conditionCheck: {
-                        src: "conditionCheck";
-                        logic: import("xstate").PromiseActorLogic<{
-                            type: "CONDITIONS_MET";
-                            error?: undefined;
-                        } | {
-                            type: "CONDITIONS_SKIP_TO_COMPLETED";
-                            error?: undefined;
-                        } | {
-                            type: "CONDITIONS_LIMBO";
-                            error?: undefined;
-                        } | {
-                            type: "CONDITIONS_SKIPPED";
-                            error?: undefined;
-                        } | {
-                            type: "CONDITION_FAILED";
-                            error: string;
-                        }, {
-                            context: WorkflowContext;
-                            stepNode: StepNode;
-                        }, import("xstate").EventObject>;
-                        id: string | undefined;
-                    };
-                    resolverFunction: {
-                        src: "resolverFunction";
-                        logic: import("xstate").PromiseActorLogic<{
-                            type: "STEP_FAILED";
-                            error: string;
-                            stepId: string;
-                            result?: undefined;
-                        } | {
-                            type: "STEP_WAITING";
-                            stepId: string;
-                            error?: undefined;
-                            result?: undefined;
-                        } | {
-                            type: "STEP_SUCCESS";
-                            result: any;
-                            stepId: string;
-                            error?: undefined;
-                        }, ResolverFunctionInput, import("xstate").EventObject>;
-                        id: string | undefined;
-                    };
-                    spawnSubscriberFunction: {
-                        src: "spawnSubscriberFunction";
-                        logic: import("xstate").PromiseActorLogic<{
-                            steps: {};
-                        }, {
-                            parentStepId: string;
-                            context: WorkflowContext;
-                        }, import("xstate").EventObject>;
-                        id: string | undefined;
-                    };
-                }>, "src", TSrc>["logic"]>;
-                <TLogic extends import("xstate").AnyActorLogic>(src: TLogic, ...[options]: import("xstate").ConditionalRequired<[options?: ({
-                    id?: never;
-                    systemId?: string;
-                    input?: import("xstate").InputFrom<TLogic> | undefined;
-                    syncSnapshot?: boolean;
-                } & { [K in import("xstate").RequiredLogicInput<TLogic>]: unknown; }) | undefined], import("xstate").IsNotNever<import("xstate").RequiredLogicInput<TLogic>>>): import("xstate").ActorRefFromLogic<TLogic>;
-            };
-            input: Omit<WorkflowContext<any, Step<string, any, any, any>[], Record<string, any>>, "getStepResult">;
-            self: import("xstate").ActorRef<import("xstate").MachineSnapshot<Omit<WorkflowContext<any, Step<string, any, any, any>[], Record<string, any>>, "getStepResult">, {
-                type: "RESET_TO_PENDING";
-                stepId: string;
-            } | {
-                type: "CONDITIONS_MET";
-                stepId: string;
-            } | {
-                type: "CONDITION_FAILED";
-                stepId: string;
-                error: string;
-            } | {
-                type: "SUSPENDED";
-                stepId: string;
-                suspendPayload?: any;
-                softSuspend?: any;
-            } | {
-                type: "WAITING";
-                stepId: string;
-            } | {
-                type: `xstate.error.actor.${string}`;
-                error: Error;
-            } | {
-                type: `xstate.done.actor.${string}`;
-                output: ResolverFunctionOutput;
-            }, Record<string, import("xstate").AnyActorRef | undefined>, import("xstate").StateValue, string, unknown, any, any>, {
-                type: "RESET_TO_PENDING";
-                stepId: string;
-            } | {
-                type: "CONDITIONS_MET";
-                stepId: string;
-            } | {
-                type: "CONDITION_FAILED";
-                stepId: string;
-                error: string;
-            } | {
-                type: "SUSPENDED";
-                stepId: string;
-                suspendPayload?: any;
-                softSuspend?: any;
-            } | {
-                type: "WAITING";
-                stepId: string;
-            } | {
-                type: `xstate.error.actor.${string}`;
-                error: Error;
-            } | {
-                type: `xstate.done.actor.${string}`;
-                output: ResolverFunctionOutput;
-            }, import("xstate").AnyEventObject>;
-        }) => {
-            mastra?: MastraUnion | undefined;
-            inputData: Record<string, any>;
-            steps: {
-                [x: string]: {
-                    status: "failed";
-                    error: string;
-                } | {
-                    status: "waiting";
-                } | {
-                    status: "skipped";
-                } | {
-                    status: "success";
-                    output: unknown;
-                } | {
-                    status: "suspended";
-                    suspendPayload?: any;
-                    output?: unknown;
-                } | {
-                    status: "success";
-                    output: any;
-                } | {
-                    status: "suspended";
-                    suspendPayload?: any;
-                    output?: any;
-                };
-            };
-            triggerData: any;
-            isResume?: {
-                runId: string;
-                stepId: string;
-            } | undefined;
-            attempts: Record<string, number>;
-        };
-        readonly states: any;
-    }> | undefined;
-}
-//# sourceMappingURL=machine.d.ts.map

package/dist/workflows/legacy/machine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"machine.d.ts","sourceRoot":"","sources":["../../../src/workflows/legacy/machine.ts"],"names":[],"mappings":"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"}

package/dist/workflows/legacy/step.d.ts

@@ -1,15 +0,0 @@
-import type { Mastra } from '../../mastra/index.js';
-import type { ZodLikeSchema, InferZodLikeSchema } from '../../types/zod-compat.js';
-import type { RetryConfig, StepAction, StepExecutionContext } from './types.js';
-export declare class LegacyStep<TStepId extends string = any, TSchemaIn extends ZodLikeSchema | undefined = undefined, TSchemaOut extends ZodLikeSchema | 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 ZodLikeSchema ? Partial<InferZodLikeSchema<TSchemaIn>> : unknown;
-    execute: (context: TContext) => Promise<TSchemaOut extends ZodLikeSchema ? InferZodLikeSchema<TSchemaOut> : unknown>;
-    retryConfig?: RetryConfig;
-    mastra?: Mastra;
-    constructor({ id, description, execute, payload, outputSchema, inputSchema, retryConfig, }: StepAction<TStepId, TSchemaIn, TSchemaOut, TContext>);
-}
-//# sourceMappingURL=step.d.ts.map

package/dist/workflows/legacy/step.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../../src/workflows/legacy/step.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAChF,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAE7E,qBAAa,UAAU,CACrB,OAAO,SAAS,MAAM,GAAG,GAAG,EAC5B,SAAS,SAAS,aAAa,GAAG,SAAS,GAAG,SAAS,EACvD,UAAU,SAAS,aAAa,GAAG,SAAS,GAAG,SAAS,EACxD,QAAQ,SAAS,oBAAoB,CAAC,SAAS,CAAC,GAAG,oBAAoB,CAAC,SAAS,CAAC,CAClF,YAAW,UAAU,CAAC,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,CAAC;IAE/D,EAAE,EAAE,OAAO,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,SAAS,CAAC;IACxB,YAAY,CAAC,EAAE,UAAU,CAAC;IAC1B,OAAO,CAAC,EAAE,SAAS,SAAS,aAAa,GAAG,OAAO,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,GAAG,OAAO,CAAC;IAC7F,OAAO,EAAE,CAAC,OAAO,EAAE,QAAQ,KAAK,OAAO,CAAC,UAAU,SAAS,aAAa,GAAG,kBAAkB,CAAC,UAAU,CAAC,GAAG,OAAO,CAAC,CAAC;IACrH,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;gBAEJ,EACV,EAAE,EACF,WAAW,EACX,OAAO,EACP,OAAO,EACP,YAAY,EACZ,WAAW,EACX,WAAW,GACZ,EAAE,UAAU,CAAC,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,CAAC;CASxD"}