@mastra/core 0.9.5-alpha.0 → 0.10.0

package/dist/voice/index.js

@@ -1 +1 @@
-export { CompositeVoice, DefaultVoice, MastraVoice } from '../chunk-NOPY74PV.js';
+export { CompositeVoice, DefaultVoice, MastraVoice } from '../chunk-KJQFFEEQ.js';

package/dist/workflows/index.cjs

@@ -1,90 +1,38 @@
 'use strict';
 
-var chunkS3Y7QBO7_cjs = require('../chunk-S3Y7QBO7.cjs');
+var chunkTTKQ37ZZ_cjs = require('../chunk-TTKQ37ZZ.cjs');
 
 
 
-Object.defineProperty(exports, "Step", {
+Object.defineProperty(exports, "DefaultExecutionEngine", {
   enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.Step; }
+  get: function () { return chunkTTKQ37ZZ_cjs.DefaultExecutionEngine; }
 });
-Object.defineProperty(exports, "WhenConditionReturnValue", {
+Object.defineProperty(exports, "ExecutionEngine", {
   enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.WhenConditionReturnValue; }
+  get: function () { return chunkTTKQ37ZZ_cjs.ExecutionEngine; }
 });
-Object.defineProperty(exports, "Workflow", {
-  enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.Workflow; }
-});
-Object.defineProperty(exports, "agentToStep", {
-  enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.agentToStep; }
-});
-Object.defineProperty(exports, "getActivePathsAndStatus", {
-  enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.getActivePathsAndStatus; }
-});
-Object.defineProperty(exports, "getResultActivePaths", {
-  enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.getResultActivePaths; }
-});
-Object.defineProperty(exports, "getStepResult", {
-  enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.getStepResult; }
-});
-Object.defineProperty(exports, "getSuspendedPaths", {
-  enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.getSuspendedPaths; }
-});
-Object.defineProperty(exports, "isAgent", {
-  enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.isAgent; }
-});
-Object.defineProperty(exports, "isConditionalKey", {
-  enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.isConditionalKey; }
-});
-Object.defineProperty(exports, "isErrorEvent", {
-  enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.isErrorEvent; }
-});
-Object.defineProperty(exports, "isFinalState", {
-  enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.isFinalState; }
-});
-Object.defineProperty(exports, "isLimboState", {
+Object.defineProperty(exports, "Run", {
   enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.isLimboState; }
+  get: function () { return chunkTTKQ37ZZ_cjs.Run; }
 });
-Object.defineProperty(exports, "isTransitionEvent", {
-  enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.isTransitionEvent; }
-});
-Object.defineProperty(exports, "isVariableReference", {
-  enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.isVariableReference; }
-});
-Object.defineProperty(exports, "isWorkflow", {
-  enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.isWorkflow; }
-});
-Object.defineProperty(exports, "mergeChildValue", {
+Object.defineProperty(exports, "Workflow", {
   enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.mergeChildValue; }
+  get: function () { return chunkTTKQ37ZZ_cjs.Workflow; }
 });
-Object.defineProperty(exports, "recursivelyCheckForFinalState", {
+Object.defineProperty(exports, "cloneStep", {
   enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.recursivelyCheckForFinalState; }
+  get: function () { return chunkTTKQ37ZZ_cjs.cloneStep; }
 });
-Object.defineProperty(exports, "resolveVariables", {
+Object.defineProperty(exports, "cloneWorkflow", {
   enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.resolveVariables; }
+  get: function () { return chunkTTKQ37ZZ_cjs.cloneWorkflow; }
 });
-Object.defineProperty(exports, "updateStepInHierarchy", {
+Object.defineProperty(exports, "createStep", {
   enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.updateStepInHierarchy; }
+  get: function () { return chunkTTKQ37ZZ_cjs.createStep; }
 });
-Object.defineProperty(exports, "workflowToStep", {
+Object.defineProperty(exports, "createWorkflow", {
   enumerable: true,
-  get: function () { return chunkS3Y7QBO7_cjs.workflowToStep; }
+  get: function () { return chunkTTKQ37ZZ_cjs.createWorkflow; }
 });

package/dist/workflows/index.d.cts

@@ -1,88 +1,208 @@
-import { aD as VariableReference, aK as StepResult, L as Step, O as Workflow, G as Agent, aN as WorkflowContext, b7 as ToolsInput, a as Mastra, ay as StepAction, aM as WorkflowRunResult } from '../base-BV8SNIdm.cjs';
-export { aF as ActionContext, aE as BaseCondition, aT as DependencyCheckOutput, a_ as ExtractSchemaFromStep, b1 as ExtractSchemaType, a$ as ExtractStepResult, b2 as PathsToStringProps, aQ as ResolverFunctionInput, aR as ResolverFunctionOutput, aC as RetryConfig, aI as StepCondition, aJ as StepConfig, aH as StepDef, ax as StepExecutionContext, aB as StepGraph, aZ as StepId, b0 as StepInputType, aA as StepNode, aU as StepResolverOutput, az as StepVariableType, aL as StepsRecord, aS as SubscriberFunctionOutput, aG as WhenConditionReturnValue, aW as WorkflowActionParams, aX as WorkflowActions, aV as WorkflowActors, aP as WorkflowEvent, aO as WorkflowLogMessage, Q as WorkflowOptions, b4 as WorkflowResumeResult, b3 as WorkflowRunState, aY as WorkflowState } from '../base-BV8SNIdm.cjs';
-import { z } from 'zod';
-import { a as Metric } from '../types-BtMyV38I.cjs';
-import { L as Logger } from '../index-QV27jkxQ.cjs';
-import '../base-H7siSAfu.cjs';
+import { a$ as ExecutionEngine, b4 as StepResult, a_ as ExecutionGraph, aR as StepFlowEntry, ae as Step, b0 as ExecuteFunction } from '../base-aJ3etsh5.cjs';
+export { b6 as DynamicMapping, b9 as ExtractSchemaFromStep, b8 as ExtractSchemaType, b7 as PathsToStringProps, aZ as Run, aS as SerializedStep, aT as SerializedStepFlowEntry, b2 as StepFailure, b1 as StepSuccess, b3 as StepSuspended, b5 as StepsRecord, ba as VariableReference, bb as WatchEvent, af as Workflow, ag as WorkflowConfig, aY as WorkflowResult, bd as WorkflowRunState, bc as ZodPathType, aV as cloneStep, aX as cloneWorkflow, aU as createStep, aW as createWorkflow } from '../base-aJ3etsh5.cjs';
+import { Span } from '@opentelemetry/api';
+import { RuntimeContext } from '../runtime-context/index.cjs';
 import 'ai';
+import '../base-aPYtPBT2.cjs';
+import '../logger-EhZkzZOr.cjs';
+import 'stream';
+import '@opentelemetry/sdk-trace-base';
+import '../types-Bo1uigWx.cjs';
 import 'sift';
+import 'zod';
 import 'json-schema';
-import '../runtime-context/index.cjs';
-import '@opentelemetry/api';
-import 'xstate';
-import 'node:events';
+import '../deployer/index.cjs';
+import '../bundler/index.cjs';
 import 'node:http';
 import 'hono';
-import '../tts/index.cjs';
-import 'stream';
-import 'pino';
-import '@opentelemetry/sdk-trace-base';
 import '../vector/index.cjs';
 import '../vector/filter/index.cjs';
-import 'events';
-import '../deployer/index.cjs';
-import '../bundler/index.cjs';
 import 'hono/cors';
 import 'hono-openapi';
+import '../tts/index.cjs';
+import 'xstate';
+import 'node:events';
+import 'events';
 import 'ai/test';
 
-declare function isErrorEvent(stateEvent: any): stateEvent is {
-    type: `xstate.error.actor.${string}`;
-    error: Error;
-};
-declare function isTransitionEvent(stateEvent: any): stateEvent is {
-    type: `xstate.done.actor.${string}`;
-    output?: unknown;
-};
-declare function isVariableReference(value: any): value is VariableReference<any, any>;
-declare function getStepResult(result?: StepResult<any>): any;
-declare function getSuspendedPaths({ value, path, suspendedPaths, }: {
-    value: string | Record<string, string>;
-    path: string;
-    suspendedPaths: Set<string>;
-}): void;
-declare function isFinalState(status: string): boolean;
-declare function isLimboState(status: string): boolean;
-declare function recursivelyCheckForFinalState({ value, suspendedPaths, path, }: {
-    value: string | Record<string, string>;
-    suspendedPaths: Set<string>;
-    path: string;
-}): boolean;
-declare function getActivePathsAndStatus(value: Record<string, any>): Array<{
-    stepPath: string[];
-    stepId: string;
-    status: string;
-}>;
-declare function mergeChildValue(startStepId: string, parent: Record<string, any>, child: Record<string, any>): Record<string, any>;
-declare const updateStepInHierarchy: (value: Record<string, any>, targetStepId: string) => Record<string, any>;
-declare function getResultActivePaths(state: {
-    value: Record<string, string>;
-    context: {
-        steps: Record<string, any>;
-    };
-}): Map<string, {
-    status: string;
-    suspendPayload?: any;
-    stepPath: string[];
-}>;
-declare function isWorkflow(step: Step<any, any, any, any> | Workflow<any, any, any, any> | Agent<any, any, any>): step is Workflow<any, any, any, any>;
-declare function isAgent(step: Step<any, any, any, any> | Agent<any, any, any> | Workflow<any, any, any, any>): step is Agent<any, any, any>;
-declare function resolveVariables({ runId, logger, variables, context, }: {
+type ExecutionContext = {
+    workflowId: string;
     runId: string;
-    logger: Logger;
-    variables: Record<string, VariableReference<any, any>>;
-    context: WorkflowContext;
-}): Record<string, any>;
-declare function agentToStep<TAgentId extends string = string, TTools extends ToolsInput = ToolsInput, TMetrics extends Record<string, Metric> = Record<string, Metric>>(agent: Agent<TAgentId, TTools, TMetrics>, { mastra }?: {
-    mastra?: Mastra;
-}): StepAction<TAgentId, z.ZodObject<{
-    prompt: z.ZodString;
-}>, z.ZodObject<{
-    text: z.ZodString;
-}>, any>;
-declare function workflowToStep<TSteps extends Step<any, any, any, any>[], TStepId extends string = any, TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any>(workflow: Workflow<TSteps, TStepId, TTriggerSchema, TResultSchema>, { mastra }: {
-    mastra?: Mastra;
-}): StepAction<TStepId, TTriggerSchema, z.ZodType<WorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>>, any>;
-declare function isConditionalKey(key: string): boolean;
+    executionPath: number[];
+    suspendedPaths: Record<string, number[]>;
+    retryConfig: {
+        attempts: number;
+        delay: number;
+    };
+    executionSpan: Span;
+};
+/**
+ * Default implementation of the ExecutionEngine using XState
+ */
+declare class DefaultExecutionEngine extends ExecutionEngine {
+    protected fmtReturnValue<TOutput>(executionSpan: Span | undefined, emitter: {
+        emit: (event: string, data: any) => Promise<void>;
+    }, stepResults: Record<string, StepResult<any>>, lastOutput: StepResult<any>, error?: Error | string): Promise<TOutput>;
+    /**
+     * 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: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        retryConfig?: {
+            attempts?: number;
+            delay?: number;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<TOutput>;
+    getStepOutput(stepResults: Record<string, any>, step?: StepFlowEntry): any;
+    executeStep({ workflowId, runId, step, stepResults, executionContext, resume, prevOutput, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        step: Step<string, any, any>;
+        stepResults: Record<string, StepResult<any>>;
+        executionContext: ExecutionContext;
+        resume?: {
+            steps: string[];
+            resumePayload: any;
+        };
+        prevOutput: any;
+        emitter: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        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: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        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: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeLoop({ workflowId, runId, entry, prevOutput, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'loop';
+            step: Step;
+            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: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    executeForeach({ workflowId, runId, entry, prevOutput, stepResults, resume, executionContext, emitter, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'foreach';
+            step: Step;
+            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: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+    protected persistStepUpdate({ workflowId, runId, stepResults, executionContext, }: {
+        workflowId: string;
+        runId: string;
+        stepResults: Record<string, StepResult<any>>;
+        executionContext: ExecutionContext;
+    }): Promise<void>;
+    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: {
+            emit: (event: string, data: any) => Promise<void>;
+        };
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any>>;
+}
 
-export { Step, StepAction, StepResult, VariableReference, Workflow, WorkflowContext, WorkflowRunResult, agentToStep, getActivePathsAndStatus, getResultActivePaths, getStepResult, getSuspendedPaths, isAgent, isConditionalKey, isErrorEvent, isFinalState, isLimboState, isTransitionEvent, isVariableReference, isWorkflow, mergeChildValue, recursivelyCheckForFinalState, resolveVariables, updateStepInHierarchy, workflowToStep };
+export { DefaultExecutionEngine, ExecuteFunction, type ExecutionContext, ExecutionEngine, ExecutionGraph, Step, StepFlowEntry, StepResult };