@scoutqa/mastra-core 0.24.6-fork.1

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

@@ -0,0 +1,386 @@
+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;
+            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;
+            inputData: Record<string, any>;
+            attempts: Record<string, number>;
+        };
+        readonly states: any;
+    }> | undefined;
+}
+//# sourceMappingURL=machine.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1 @@
+{"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"}