@mastra/core 0.10.13 → 0.10.14

package/dist/workflows/index.d.ts

@@ -0,0 +1,282 @@
+import { bm as ExecutionEngine, f as Step, bo as Emitter, bu as StepResult, bl as ExecutionGraph, bc as SerializedStepFlowEntry, ba as StepFlowEntry, bn as ExecuteFunction, aw as DefaultEngineType } from '../base-DBhKcre4.js';
+export { bw as DynamicMapping, bz as ExtractSchemaFromStep, by as ExtractSchemaType, bx as PathsToStringProps, bk as Run, bb as SerializedStep, bq as StepFailure, bs as StepRunning, bp as StepSuccess, br as StepSuspended, bt as StepWaiting, bd as StepWithComponent, bv as StepsRecord, bB as StreamEvent, bA as VariableReference, bD as WatchEvent, e as Workflow, ax as WorkflowConfig, bj as WorkflowResult, bF as WorkflowRunState, bC as WorkflowRunStatus, bE as ZodPathType, bg as cloneStep, bi as cloneWorkflow, bf as createStep, bh as createWorkflow, be as mapVariable } from '../base-DBhKcre4.js';
+import { Span } from '@opentelemetry/api';
+import { RuntimeContext } from '../runtime-context/index.js';
+import 'ai';
+import '../base-ClrXcCRx.js';
+import '../logger-Bpa2oLL4.js';
+import '../error/index.js';
+import 'stream';
+import '@opentelemetry/sdk-trace-base';
+import 'zod';
+import 'json-schema';
+import '../types-Bo1uigWx.js';
+import 'sift';
+import 'xstate';
+import 'node:events';
+import '../vector/index.js';
+import '../vector/filter/index.js';
+import '../tts/index.js';
+import 'node:http';
+import 'hono';
+import 'stream/web';
+import 'events';
+import 'node:stream/web';
+import './constants.js';
+import 'ai/test';
+import '../deployer/index.js';
+import '../bundler/index.js';
+import 'hono/cors';
+import 'hono-openapi';
+
+type ExecutionContext = {
+    workflowId: string;
+    runId: string;
+    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 {
+    /**
+     * The runCounts map is used to keep track of the run count for each step.
+     * The step id is used as the key and the run count is the value.
+     */
+    protected runCounts: Map<string, number>;
+    /**
+     * Get or generate the run count for a step.
+     * If the step id is not in the map, it will be added and the run count will be 0.
+     * If the step id is in the map, it will return the run count.
+     *
+     * @param stepId - The id of the step.
+     * @returns The run count for the step.
+     */
+    protected getOrGenerateRunCount(stepId: Step['id']): number;
+    protected fmtReturnValue<TOutput>(executionSpan: Span | undefined, emitter: Emitter, stepResults: Record<string, StepResult<any, any, any, any>>, lastOutput: StepResult<any, any, any, 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;
+        serializedStepGraph: SerializedStepFlowEntry[];
+        input?: TInput;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        emitter: Emitter;
+        retryConfig?: {
+            attempts?: number;
+            delay?: number;
+        };
+        runtimeContext: RuntimeContext;
+        abortController: AbortController;
+    }): Promise<TOutput>;
+    getStepOutput(stepResults: Record<string, any>, step?: StepFlowEntry): any;
+    executeSleep({ runId, entry, prevOutput, stepResults, emitter, abortController, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        serializedStepGraph: SerializedStepFlowEntry[];
+        entry: {
+            type: 'sleep';
+            id: string;
+            duration?: number;
+            fn?: ExecuteFunction<any, any, any, any, DefaultEngineType>;
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: Emitter;
+        abortController: AbortController;
+        runtimeContext: RuntimeContext;
+    }): Promise<void>;
+    executeSleepUntil({ runId, entry, prevOutput, stepResults, emitter, abortController, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        serializedStepGraph: SerializedStepFlowEntry[];
+        entry: {
+            type: 'sleepUntil';
+            id: string;
+            date?: Date;
+            fn?: ExecuteFunction<any, any, any, any, DefaultEngineType>;
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: Emitter;
+        abortController: AbortController;
+        runtimeContext: RuntimeContext;
+    }): Promise<void>;
+    executeWaitForEvent({ event, emitter, timeout, }: {
+        event: string;
+        emitter: Emitter;
+        timeout?: number;
+    }): Promise<any>;
+    executeStep({ workflowId, runId, step, stepResults, executionContext, resume, prevOutput, emitter, abortController, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        step: Step<string, any, any>;
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        executionContext: ExecutionContext;
+        resume?: {
+            steps: string[];
+            resumePayload: any;
+        };
+        prevOutput: any;
+        emitter: Emitter;
+        abortController: AbortController;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any, any, any, any>>;
+    executeParallel({ workflowId, runId, entry, prevStep, serializedStepGraph, stepResults, resume, executionContext, emitter, abortController, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'parallel';
+            steps: StepFlowEntry[];
+        };
+        serializedStepGraph: SerializedStepFlowEntry[];
+        prevStep: StepFlowEntry;
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: Emitter;
+        abortController: AbortController;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any, any, any, any>>;
+    executeConditional({ workflowId, runId, entry, prevOutput, prevStep, serializedStepGraph, stepResults, resume, executionContext, emitter, abortController, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        serializedStepGraph: SerializedStepFlowEntry[];
+        entry: {
+            type: 'conditional';
+            steps: StepFlowEntry[];
+            conditions: ExecuteFunction<any, any, any, any, DefaultEngineType>[];
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: Emitter;
+        abortController: AbortController;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any, any, any, any>>;
+    executeLoop({ workflowId, runId, entry, prevOutput, stepResults, resume, executionContext, emitter, abortController, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'loop';
+            step: Step;
+            condition: ExecuteFunction<any, any, any, any, DefaultEngineType>;
+            loopType: 'dowhile' | 'dountil';
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: Emitter;
+        abortController: AbortController;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any, any, any, any>>;
+    executeForeach({ workflowId, runId, entry, prevOutput, stepResults, resume, executionContext, emitter, abortController, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: {
+            type: 'foreach';
+            step: Step;
+            opts: {
+                concurrency: number;
+            };
+        };
+        prevStep: StepFlowEntry;
+        prevOutput: any;
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: Emitter;
+        abortController: AbortController;
+        runtimeContext: RuntimeContext;
+    }): Promise<StepResult<any, any, any, any>>;
+    protected persistStepUpdate({ workflowId, runId, stepResults, serializedStepGraph, executionContext, workflowStatus, result, error, }: {
+        workflowId: string;
+        runId: string;
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        serializedStepGraph: SerializedStepFlowEntry[];
+        executionContext: ExecutionContext;
+        workflowStatus: 'success' | 'failed' | 'suspended' | 'running' | 'waiting';
+        result?: Record<string, any>;
+        error?: string | Error;
+    }): Promise<void>;
+    executeEntry({ workflowId, runId, entry, prevStep, serializedStepGraph, stepResults, resume, executionContext, emitter, abortController, runtimeContext, }: {
+        workflowId: string;
+        runId: string;
+        entry: StepFlowEntry;
+        prevStep: StepFlowEntry;
+        serializedStepGraph: SerializedStepFlowEntry[];
+        stepResults: Record<string, StepResult<any, any, any, any>>;
+        resume?: {
+            steps: string[];
+            stepResults: Record<string, StepResult<any, any, any, any>>;
+            resumePayload: any;
+            resumePath: number[];
+        };
+        executionContext: ExecutionContext;
+        emitter: Emitter;
+        abortController: AbortController;
+        runtimeContext: RuntimeContext;
+    }): Promise<{
+        result: StepResult<any, any, any, any>;
+        stepResults?: Record<string, StepResult<any, any, any, any>>;
+        executionContext?: ExecutionContext;
+    }>;
+}
+
+export { DefaultEngineType, DefaultExecutionEngine, Emitter, ExecuteFunction, type ExecutionContext, ExecutionEngine, ExecutionGraph, SerializedStepFlowEntry, Step, StepFlowEntry, StepResult };

package/dist/workflows/index.js

@@ -0,0 +1 @@
+export { DefaultExecutionEngine, ExecutionEngine, Run, Workflow, cloneStep, cloneWorkflow, createStep, createWorkflow, mapVariable } from '../chunk-2HDFKWFU.js';

package/dist/workflows/legacy/index.cjs

@@ -0,0 +1,90 @@
+'use strict';
+
+var chunkFBKJ3652_cjs = require('../../chunk-FBKJ3652.cjs');
+
+
+
+Object.defineProperty(exports, "LegacyStep", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.LegacyStep; }
+});
+Object.defineProperty(exports, "LegacyWorkflow", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.LegacyWorkflow; }
+});
+Object.defineProperty(exports, "WhenConditionReturnValue", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.WhenConditionReturnValue; }
+});
+Object.defineProperty(exports, "agentToStep", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.agentToStep; }
+});
+Object.defineProperty(exports, "getActivePathsAndStatus", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.getActivePathsAndStatus; }
+});
+Object.defineProperty(exports, "getResultActivePaths", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.getResultActivePaths; }
+});
+Object.defineProperty(exports, "getStepResult", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.getStepResult; }
+});
+Object.defineProperty(exports, "getSuspendedPaths", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.getSuspendedPaths; }
+});
+Object.defineProperty(exports, "isAgent", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.isAgent; }
+});
+Object.defineProperty(exports, "isConditionalKey", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.isConditionalKey; }
+});
+Object.defineProperty(exports, "isErrorEvent", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.isErrorEvent; }
+});
+Object.defineProperty(exports, "isFinalState", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.isFinalState; }
+});
+Object.defineProperty(exports, "isLimboState", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.isLimboState; }
+});
+Object.defineProperty(exports, "isTransitionEvent", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.isTransitionEvent; }
+});
+Object.defineProperty(exports, "isVariableReference", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.isVariableReference; }
+});
+Object.defineProperty(exports, "isWorkflow", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.isWorkflow; }
+});
+Object.defineProperty(exports, "mergeChildValue", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.mergeChildValue; }
+});
+Object.defineProperty(exports, "recursivelyCheckForFinalState", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.recursivelyCheckForFinalState; }
+});
+Object.defineProperty(exports, "resolveVariables", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.resolveVariables; }
+});
+Object.defineProperty(exports, "updateStepInHierarchy", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.updateStepInHierarchy; }
+});
+Object.defineProperty(exports, "workflowToStep", {
+  enumerable: true,
+  get: function () { return chunkFBKJ3652_cjs.workflowToStep; }
+});

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

@@ -0,0 +1,91 @@
+import { Q as VariableReference, R as StepResult, d as LegacyStep, L as LegacyWorkflow, A as Agent, W as WorkflowContext, T as ToolsInput, M as Mastra, U as StepAction, X as LegacyWorkflowRunResult } from '../../base-CS5eSXbL.cjs';
+export { a2 as ActionContext, a1 as BaseCondition, ad as DependencyCheckOutput, ak as ExtractSchemaFromStep, an as ExtractSchemaType, al as ExtractStepResult, ap as LegacyWorkflowRunState, ai as LegacyWorkflowState, ao as PathsToStringProps, aa as ResolverFunctionInput, ab as ResolverFunctionOutput, a0 as RetryConfig, a5 as StepCondition, a6 as StepConfig, a4 as StepDef, S as StepExecutionContext, $ as StepGraph, aj as StepId, am as StepInputType, _ as StepNode, ae as StepResolverOutput, Z as StepVariableType, a7 as StepsRecord, ac as SubscriberFunctionOutput, a3 as WhenConditionReturnValue, ag as WorkflowActionParams, ah as WorkflowActions, af as WorkflowActors, a9 as WorkflowEvent, a8 as WorkflowLogMessage, Y as WorkflowOptions, aq as WorkflowResumeResult } from '../../base-CS5eSXbL.cjs';
+import { z } from 'zod';
+import { M as Metric } from '../../types-Bo1uigWx.cjs';
+import { I as IMastraLogger } from '../../logger-B8XXh6ya.cjs';
+import '../../base-B_y9sMg0.cjs';
+import 'ai';
+import 'json-schema';
+import 'sift';
+import '../../runtime-context/index.cjs';
+import '@opentelemetry/api';
+import 'xstate';
+import 'node:events';
+import '../../vector/index.cjs';
+import '../../vector/filter/index.cjs';
+import '../../tts/index.cjs';
+import '../../error/index.cjs';
+import 'stream';
+import '@opentelemetry/sdk-trace-base';
+import 'node:http';
+import 'hono';
+import 'stream/web';
+import 'events';
+import 'node:stream/web';
+import '../constants.cjs';
+import 'ai/test';
+import '../../deployer/index.cjs';
+import '../../bundler/index.cjs';
+import 'hono/cors';
+import 'hono-openapi';
+
+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: LegacyStep<any, any, any, any> | LegacyWorkflow<any, any, any, any> | Agent<any, any, any>): step is LegacyWorkflow<any, any, any, any>;
+declare function isAgent(step: LegacyStep<any, any, any, any> | Agent<any, any, any> | LegacyWorkflow<any, any, any, any>): step is Agent<any, any, any>;
+declare function resolveVariables({ runId, logger, variables, context, }: {
+    runId: string;
+    logger: IMastraLogger;
+    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 LegacyStep<any, any, any, any>[], TStepId extends string = any, TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any>(workflow: LegacyWorkflow<TSteps, TStepId, TTriggerSchema, TResultSchema>, { mastra }: {
+    mastra?: Mastra;
+}): StepAction<TStepId, TTriggerSchema, z.ZodType<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>>, any>;
+declare function isConditionalKey(key: string): boolean;
+
+export { LegacyStep, LegacyWorkflow, LegacyWorkflowRunResult, StepAction, StepResult, VariableReference, WorkflowContext, agentToStep, getActivePathsAndStatus, getResultActivePaths, getStepResult, getSuspendedPaths, isAgent, isConditionalKey, isErrorEvent, isFinalState, isLimboState, isTransitionEvent, isVariableReference, isWorkflow, mergeChildValue, recursivelyCheckForFinalState, resolveVariables, updateStepInHierarchy, workflowToStep };

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

@@ -0,0 +1,91 @@
+import { Q as VariableReference, R as StepResult, d as LegacyStep, L as LegacyWorkflow, A as Agent, W as WorkflowContext, T as ToolsInput, M as Mastra, U as StepAction, X as LegacyWorkflowRunResult } from '../../base-DBhKcre4.js';
+export { a2 as ActionContext, a1 as BaseCondition, ad as DependencyCheckOutput, ak as ExtractSchemaFromStep, an as ExtractSchemaType, al as ExtractStepResult, ap as LegacyWorkflowRunState, ai as LegacyWorkflowState, ao as PathsToStringProps, aa as ResolverFunctionInput, ab as ResolverFunctionOutput, a0 as RetryConfig, a5 as StepCondition, a6 as StepConfig, a4 as StepDef, S as StepExecutionContext, $ as StepGraph, aj as StepId, am as StepInputType, _ as StepNode, ae as StepResolverOutput, Z as StepVariableType, a7 as StepsRecord, ac as SubscriberFunctionOutput, a3 as WhenConditionReturnValue, ag as WorkflowActionParams, ah as WorkflowActions, af as WorkflowActors, a9 as WorkflowEvent, a8 as WorkflowLogMessage, Y as WorkflowOptions, aq as WorkflowResumeResult } from '../../base-DBhKcre4.js';
+import { z } from 'zod';
+import { M as Metric } from '../../types-Bo1uigWx.js';
+import { I as IMastraLogger } from '../../logger-Bpa2oLL4.js';
+import '../../base-ClrXcCRx.js';
+import 'ai';
+import 'json-schema';
+import 'sift';
+import '../../runtime-context/index.js';
+import '@opentelemetry/api';
+import 'xstate';
+import 'node:events';
+import '../../vector/index.js';
+import '../../vector/filter/index.js';
+import '../../tts/index.js';
+import '../../error/index.js';
+import 'stream';
+import '@opentelemetry/sdk-trace-base';
+import 'node:http';
+import 'hono';
+import 'stream/web';
+import 'events';
+import 'node:stream/web';
+import '../constants.js';
+import 'ai/test';
+import '../../deployer/index.js';
+import '../../bundler/index.js';
+import 'hono/cors';
+import 'hono-openapi';
+
+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: LegacyStep<any, any, any, any> | LegacyWorkflow<any, any, any, any> | Agent<any, any, any>): step is LegacyWorkflow<any, any, any, any>;
+declare function isAgent(step: LegacyStep<any, any, any, any> | Agent<any, any, any> | LegacyWorkflow<any, any, any, any>): step is Agent<any, any, any>;
+declare function resolveVariables({ runId, logger, variables, context, }: {
+    runId: string;
+    logger: IMastraLogger;
+    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 LegacyStep<any, any, any, any>[], TStepId extends string = any, TTriggerSchema extends z.ZodObject<any> = any, TResultSchema extends z.ZodObject<any> = any>(workflow: LegacyWorkflow<TSteps, TStepId, TTriggerSchema, TResultSchema>, { mastra }: {
+    mastra?: Mastra;
+}): StepAction<TStepId, TTriggerSchema, z.ZodType<LegacyWorkflowRunResult<TTriggerSchema, TSteps, TResultSchema>>, any>;
+declare function isConditionalKey(key: string): boolean;
+
+export { LegacyStep, LegacyWorkflow, LegacyWorkflowRunResult, StepAction, StepResult, VariableReference, WorkflowContext, agentToStep, getActivePathsAndStatus, getResultActivePaths, getStepResult, getSuspendedPaths, isAgent, isConditionalKey, isErrorEvent, isFinalState, isLimboState, isTransitionEvent, isVariableReference, isWorkflow, mergeChildValue, recursivelyCheckForFinalState, resolveVariables, updateStepInHierarchy, workflowToStep };

package/dist/workflows/legacy/index.js

@@ -0,0 +1 @@
+export { LegacyStep, LegacyWorkflow, WhenConditionReturnValue, agentToStep, getActivePathsAndStatus, getResultActivePaths, getStepResult, getSuspendedPaths, isAgent, isConditionalKey, isErrorEvent, isFinalState, isLimboState, isTransitionEvent, isVariableReference, isWorkflow, mergeChildValue, recursivelyCheckForFinalState, resolveVariables, updateStepInHierarchy, workflowToStep } from '../../chunk-EWCOOO3H.js';

package/error.d.ts

@@ -0,0 +1 @@
+export * from './dist/error';

package/eval.d.ts

@@ -0,0 +1 @@
+export * from './dist/eval';

package/hooks.d.ts

@@ -0,0 +1 @@
+export * from './dist/hooks';

package/integration.d.ts

@@ -0,0 +1 @@
+export * from './dist/integration';

package/llm.d.ts

@@ -0,0 +1 @@
+export * from './dist/llm';

package/logger.d.ts

@@ -0,0 +1 @@
+export * from './dist/logger';

package/mastra.d.ts

@@ -0,0 +1 @@
+export * from './dist/mastra';

package/mcp.d.ts

@@ -0,0 +1 @@
+export * from './dist/mcp';

package/memory.d.ts

@@ -0,0 +1 @@
+export * from './dist/memory';

package/network/vNext.d.ts

@@ -0,0 +1 @@
+export * from './../dist/network/vNext';

package/network.d.ts

@@ -0,0 +1 @@
+export * from './dist/network';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/core",
-  "version": "0.10.13",
+  "version": "0.10.14",
   "license": "Apache-2.0",
   "type": "module",
   "main": "dist/index.js",

package/relevance.d.ts

@@ -0,0 +1 @@
+export * from './dist/relevance';

package/runtime-context.d.ts

@@ -0,0 +1 @@
+export * from './dist/runtime-context';

package/server.d.ts

@@ -0,0 +1 @@
+export * from './dist/server';

package/storage.d.ts

@@ -0,0 +1 @@
+export * from './dist/storage';

package/telemetry/otel-vendor.d.ts

@@ -0,0 +1 @@
+export * from './../dist/telemetry/otel-vendor.d.cts';

package/telemetry.d.ts

@@ -0,0 +1 @@
+export * from './dist/telemetry';

package/tools.d.ts

@@ -0,0 +1 @@
+export * from './dist/tools';

package/tts.d.ts

@@ -0,0 +1 @@
+export * from './dist/tts';

package/utils.d.ts

@@ -0,0 +1 @@
+export * from './dist/utils.d.cts';

package/vector/filter.d.ts

@@ -0,0 +1 @@
+export * from './../dist/vector/filter';

package/vector.d.ts

@@ -0,0 +1 @@
+export * from './dist/vector';

package/voice.d.ts

@@ -0,0 +1 @@
+export * from './dist/voice';

package/workflows/_constants.d.ts

@@ -0,0 +1 @@
+export * from './../dist/workflows/constants.d.cts';

package/workflows/legacy.d.ts

@@ -0,0 +1 @@
+export * from './../dist/workflows/legacy';

package/workflows.d.ts

@@ -0,0 +1 @@
+export * from './dist/workflows';