@mastra/core 0.9.0 → 0.9.1-alpha.1

package/dist/workflows/vNext/index.d.cts

@@ -0,0 +1,180 @@
+import { i as ExecutionEngine, j as ExecutionGraph, k as StepResult, l as StepFlowEntry, N as NewStep, m as ExecuteFunction } from '../../base-CZmT-p10.cjs';
+export { y as ExtractSchemaFromStep, x as ExtractSchemaType, s as NewWorkflow, r as NewWorkflowConfig, P as PathsToStringProps, R as Run, u as StepFailure, t as StepSuccess, v as StepSuspended, w as StepsRecord, z as VariableReference, B as WatchEvent, q as WorkflowResult, Z as ZodPathType, o as cloneStep, n as createStep, p as createWorkflow } from '../../base-CZmT-p10.cjs';
+import EventEmitter from 'events';
+import { RuntimeContext } from '../../runtime-context/index.cjs';
+import 'ai';
+import '../../base-BihKcqDY.cjs';
+import '@opentelemetry/api';
+import '../../index-CquI0inB.cjs';
+import 'stream';
+import 'pino';
+import '@opentelemetry/sdk-trace-base';
+import '../../types-BtMyV38I.cjs';
+import 'sift';
+import 'zod';
+import 'json-schema';
+import 'xstate';
+import 'node:events';
+import '../../vector/index.cjs';
+import '../../vector/filter/index.cjs';
+import '../../tts/index.cjs';
+import '../../deployer/index.cjs';
+import '../../bundler/index.cjs';
+import 'hono';
+import 'hono/cors';
+import 'hono-openapi';
+import 'ai/test';
+
+type ExecutionContext = {
+    executionPath: number[];
+    suspendedPaths: Record<string, number[]>;
+    retryConfig: {
+        attempts: number;
+        delay: number;
+    };
+};
+/**
+ * Default implementation of the ExecutionEngine using XState
+ */
+declare class DefaultExecutionEngine extends ExecutionEngine {
+    /**
+     * Executes a workflow run with the provided execution graph and input
+     * @param graph The execution graph to execute
+     * @param input The input data for the workflow
+     * @returns A promise that resolves to the workflow output
+     */
+    execute<TInput, TOutput>(params: {
+        workflowId: string;
+        runId: string;
+        graph: ExecutionGraph;
+        input?: TInput;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        emitter: EventEmitter;
+        retryConfig?: {
+            attempts?: number;
+            delay?: number;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<TOutput>;
+    getStepOutput(stepResults: Record<string, any>, step?: StepFlowEntry): any;
+    executeStep({ step, stepResults, executionContext, resume, prevOutput, emitter, runtimeContext, }: {
+        step: NewStep<string, any, any>;
+        stepResults: Record<string, StepResult<any>>;
+        executionContext: ExecutionContext;
+        resume?: {
+            steps: string[];
+            resumePayload: any;
+        };
+        prevOutput: any;
+        emitter: EventEmitter;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeParallel({ workflowId, runId, entry, prevStep, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'parallel';
+            steps: StepFlowEntry[];
+        };
+        prevStep: StepFlowEntry;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: EventEmitter;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeConditional({ workflowId, runId, entry, prevOutput, prevStep, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'conditional';
+            steps: StepFlowEntry[];
+            conditions: ExecuteFunction<any, any, any, any>[];
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: EventEmitter;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeLoop({ entry, prevOutput, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'loop';
+            step: NewStep;
+            condition: ExecuteFunction<any, any, any, any>;
+            loopType: 'dowhile' | 'dountil';
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: EventEmitter;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeForeach({ entry, prevOutput, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'foreach';
+            step: NewStep;
+            opts: {
+                concurrency: number;
+            };
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: EventEmitter;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeEntry({ workflowId, runId, entry, prevStep, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: StepFlowEntry;
+        prevStep: StepFlowEntry;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: EventEmitter;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+}
+
+export { DefaultExecutionEngine, ExecuteFunction, ExecutionEngine, ExecutionGraph, NewStep, StepFlowEntry, StepResult };

package/dist/workflows/vNext/index.d.ts

@@ -0,0 +1,180 @@
+import { i as ExecutionEngine, j as ExecutionGraph, k as StepResult, l as StepFlowEntry, N as NewStep, m as ExecuteFunction } from '../../base-DDoWFpFc.js';
+export { y as ExtractSchemaFromStep, x as ExtractSchemaType, s as NewWorkflow, r as NewWorkflowConfig, P as PathsToStringProps, R as Run, u as StepFailure, t as StepSuccess, v as StepSuspended, w as StepsRecord, z as VariableReference, B as WatchEvent, q as WorkflowResult, Z as ZodPathType, o as cloneStep, n as createStep, p as createWorkflow } from '../../base-DDoWFpFc.js';
+import EventEmitter from 'events';
+import { RuntimeContext } from '../../runtime-context/index.js';
+import 'ai';
+import '../../base-DT2poiVK.js';
+import '@opentelemetry/api';
+import '../../index-CquI0inB.js';
+import 'stream';
+import 'pino';
+import '@opentelemetry/sdk-trace-base';
+import '../../types-BtMyV38I.js';
+import 'sift';
+import 'zod';
+import 'json-schema';
+import 'xstate';
+import 'node:events';
+import '../../vector/index.js';
+import '../../vector/filter/index.js';
+import '../../tts/index.js';
+import '../../deployer/index.js';
+import '../../bundler/index.js';
+import 'hono';
+import 'hono/cors';
+import 'hono-openapi';
+import 'ai/test';
+
+type ExecutionContext = {
+    executionPath: number[];
+    suspendedPaths: Record<string, number[]>;
+    retryConfig: {
+        attempts: number;
+        delay: number;
+    };
+};
+/**
+ * Default implementation of the ExecutionEngine using XState
+ */
+declare class DefaultExecutionEngine extends ExecutionEngine {
+    /**
+     * Executes a workflow run with the provided execution graph and input
+     * @param graph The execution graph to execute
+     * @param input The input data for the workflow
+     * @returns A promise that resolves to the workflow output
+     */
+    execute<TInput, TOutput>(params: {
+        workflowId: string;
+        runId: string;
+        graph: ExecutionGraph;
+        input?: TInput;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        emitter: EventEmitter;
+        retryConfig?: {
+            attempts?: number;
+            delay?: number;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<TOutput>;
+    getStepOutput(stepResults: Record<string, any>, step?: StepFlowEntry): any;
+    executeStep({ step, stepResults, executionContext, resume, prevOutput, emitter, runtimeContext, }: {
+        step: NewStep<string, any, any>;
+        stepResults: Record<string, StepResult<any>>;
+        executionContext: ExecutionContext;
+        resume?: {
+            steps: string[];
+            resumePayload: any;
+        };
+        prevOutput: any;
+        emitter: EventEmitter;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeParallel({ workflowId, runId, entry, prevStep, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'parallel';
+            steps: StepFlowEntry[];
+        };
+        prevStep: StepFlowEntry;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: EventEmitter;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeConditional({ workflowId, runId, entry, prevOutput, prevStep, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'conditional';
+            steps: StepFlowEntry[];
+            conditions: ExecuteFunction<any, any, any, any>[];
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: EventEmitter;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeLoop({ entry, prevOutput, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'loop';
+            step: NewStep;
+            condition: ExecuteFunction<any, any, any, any>;
+            loopType: 'dowhile' | 'dountil';
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: EventEmitter;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeForeach({ entry, prevOutput, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'foreach';
+            step: NewStep;
+            opts: {
+                concurrency: number;
+            };
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: EventEmitter;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeEntry({ workflowId, runId, entry, prevStep, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: StepFlowEntry;
+        prevStep: StepFlowEntry;
+        stepResults: Record<string, StepResult<any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: EventEmitter;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+}
+
+export { DefaultExecutionEngine, ExecuteFunction, ExecutionEngine, ExecutionGraph, NewStep, StepFlowEntry, StepResult };