@remoraflow/core 0.1.0

package/dist/example-tasks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"example-tasks.d.ts","sourceRoot":"","sources":["../src/example-tasks.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAyHP,OAAO;uBAAS,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+qBxC,CAAC"}

package/dist/executor/context.d.ts

@@ -0,0 +1,42 @@
+export interface WaitForConditionOptions {
+    maxAttempts: number;
+    intervalMs: number;
+    backoffMultiplier: number;
+    timeoutMs?: number;
+}
+/**
+ * Injectable execution context for durable execution environments.
+ *
+ * In a durable environment (AWS Step Functions, Temporal, Inngest, etc.),
+ * each `step()` runs in its own execution environment. The workflow code
+ * **outside** of `step()` closures re-executes on every resume, so it
+ * must be idempotent (pure reads, expression evaluation, scope construction).
+ * Code **inside** a `step()` closure runs exactly once — the environment
+ * records its result and replays the cached value on subsequent resumes
+ * instead of re-executing the function.
+ */
+export interface DurableContext {
+    /**
+     * Wrap a step that should execute exactly once. In durable environments,
+     * `fn` runs on the first invocation and its result is persisted; on
+     * subsequent resumes the cached result is returned without calling `fn`
+     * again. All code outside `step()` must be idempotent because it
+     * re-runs on every resume.
+     * Default: executes the function directly (passthrough).
+     */
+    step: (name: string, fn: () => Promise<unknown>) => Promise<unknown>;
+    /**
+     * Sleep for the given duration. In durable environments,
+     * this uses a durable timer that survives process restarts.
+     * Default: setTimeout-based promise.
+     */
+    sleep: (name: string, durationMs: number) => Promise<void>;
+    /**
+     * Wait for a condition by polling. In durable environments,
+     * this might use waitForCallback or durable polling.
+     * Default: loop with setTimeout + backoff.
+     */
+    waitForCondition: (name: string, checkFn: () => Promise<unknown>, options: WaitForConditionOptions) => Promise<unknown>;
+}
+export declare function createDefaultDurableContext(): DurableContext;
+//# sourceMappingURL=context.d.ts.map

package/dist/executor/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/executor/context.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,uBAAuB;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,cAAc;IAC9B;;;;;;;OAOG;IACH,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAErE;;;;OAIG;IACH,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3D;;;;OAIG;IACH,gBAAgB,EAAE,CACjB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,EAC/B,OAAO,EAAE,uBAAuB,KAC5B,OAAO,CAAC,OAAO,CAAC,CAAC;CACtB;AAID,wBAAgB,2BAA2B,IAAI,cAAc,CAuC5D"}

package/dist/executor/errors.d.ts

@@ -0,0 +1,57 @@
+/** Strategy for recovering from a step execution error. */
+export type RecoveryStrategy = "none" | "retry" | "llm-transform" | "llm-reprompt";
+/**
+ * High-level category of a step execution error.
+ * - `configuration` — the workflow is misconfigured (missing tools, no agent)
+ * - `validation` — input or output data doesn't match the expected schema
+ * - `external-service` — a tool or LLM call failed
+ * - `expression` — a JMESPath or template expression failed to evaluate
+ * - `output-quality` — the LLM produced output that couldn't be parsed
+ */
+export type ErrorCategory = "configuration" | "validation" | "external-service" | "expression" | "output-quality";
+/** Machine-readable error code identifying the specific failure. */
+export type ErrorCode = "TOOL_NOT_FOUND" | "TOOL_MISSING_EXECUTE" | "AGENT_NOT_PROVIDED" | "TOOL_INPUT_VALIDATION_FAILED" | "FOREACH_TARGET_NOT_ARRAY" | "WORKFLOW_OUTPUT_VALIDATION_FAILED" | "TOOL_EXECUTION_FAILED" | "LLM_API_ERROR" | "LLM_RATE_LIMITED" | "LLM_NETWORK_ERROR" | "LLM_NO_CONTENT" | "JMESPATH_EVALUATION_ERROR" | "TEMPLATE_INTERPOLATION_ERROR" | "LLM_OUTPUT_PARSE_ERROR" | "EXTRACTION_GAVE_UP" | "SLEEP_INVALID_DURATION" | "WAIT_CONDITION_TIMEOUT" | "WAIT_CONDITION_MAX_ATTEMPTS" | "EXECUTION_TOTAL_TIMEOUT" | "EXECUTION_ACTIVE_TIMEOUT";
+/**
+ * Base error class for all step execution failures. Contains the step ID,
+ * error code, error category, and optional cause. All executor error classes
+ * extend this.
+ */
+export declare class StepExecutionError extends Error {
+    readonly stepId: string;
+    readonly code: ErrorCode;
+    readonly category: ErrorCategory;
+    readonly cause?: unknown | undefined;
+    readonly name = "StepExecutionError";
+    constructor(stepId: string, code: ErrorCode, category: ErrorCategory, message: string, cause?: unknown | undefined);
+}
+/** Thrown when the workflow is misconfigured (missing tools, missing agent, missing execute function). Not retryable. */
+export declare class ConfigurationError extends StepExecutionError {
+    constructor(stepId: string, code: ErrorCode, message: string);
+}
+/** Thrown when input or output data doesn't match the expected schema. Not retryable. */
+export declare class ValidationError extends StepExecutionError {
+    readonly input: unknown;
+    constructor(stepId: string, code: ErrorCode, message: string, input: unknown, cause?: unknown);
+}
+/** Thrown when a tool execution or LLM API call fails. May be retryable (check {@link isRetryable}). */
+export declare class ExternalServiceError extends StepExecutionError {
+    readonly statusCode?: number | undefined;
+    readonly isRetryable: boolean;
+    constructor(stepId: string, code: ErrorCode, message: string, cause?: unknown, statusCode?: number | undefined, isRetryable?: boolean);
+}
+/** Thrown when a JMESPath expression or template interpolation fails to evaluate. Not retryable. */
+export declare class ExpressionError extends StepExecutionError {
+    readonly expression: string;
+    constructor(stepId: string, code: ErrorCode, message: string, expression: string, cause?: unknown);
+}
+/** Thrown when an LLM produces output that can't be parsed as valid JSON. Retryable via automatic retry. */
+export declare class OutputQualityError extends StepExecutionError {
+    readonly rawOutput: unknown;
+    constructor(stepId: string, code: ErrorCode, message: string, rawOutput: unknown, cause?: unknown);
+}
+/** Thrown when the LLM determines that the requested data cannot be found or extracted from the source data during probe mode. Not retryable. */
+export declare class ExtractionError extends StepExecutionError {
+    readonly reason: string;
+    constructor(stepId: string, message: string, reason: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/executor/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/executor/errors.ts"],"names":[],"mappings":"AAEA,2DAA2D;AAC3D,MAAM,MAAM,gBAAgB,GACzB,MAAM,GACN,OAAO,GACP,eAAe,GACf,cAAc,CAAC;AAElB;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GACtB,eAAe,GACf,YAAY,GACZ,kBAAkB,GAClB,YAAY,GACZ,gBAAgB,CAAC;AAEpB,oEAAoE;AACpE,MAAM,MAAM,SAAS,GAElB,gBAAgB,GAChB,sBAAsB,GACtB,oBAAoB,GAEpB,8BAA8B,GAC9B,0BAA0B,GAC1B,mCAAmC,GAEnC,uBAAuB,GACvB,eAAe,GACf,kBAAkB,GAClB,mBAAmB,GACnB,gBAAgB,GAEhB,2BAA2B,GAC3B,8BAA8B,GAE9B,wBAAwB,GAExB,oBAAoB,GAEpB,wBAAwB,GACxB,wBAAwB,GACxB,6BAA6B,GAE7B,yBAAyB,GACzB,0BAA0B,CAAC;AAI9B;;;;GAIG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;aAI3B,MAAM,EAAE,MAAM;aACd,IAAI,EAAE,SAAS;aACf,QAAQ,EAAE,aAAa;aAEd,KAAK,CAAC,EAAE,OAAO;IAPzC,SAAkB,IAAI,wBAAwB;gBAG7B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,aAAa,EACvC,OAAO,EAAE,MAAM,EACU,KAAK,CAAC,EAAE,OAAO,YAAA;CAIzC;AAID,yHAAyH;AACzH,qBAAa,kBAAmB,SAAQ,kBAAkB;gBAC7C,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM;CAG5D;AAED,yFAAyF;AACzF,qBAAa,eAAgB,SAAQ,kBAAkB;aAKrC,KAAK,EAAE,OAAO;gBAH9B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,MAAM,EACC,KAAK,EAAE,OAAO,EAC9B,KAAK,CAAC,EAAE,OAAO;CAIhB;AAED,wGAAwG;AACxG,qBAAa,oBAAqB,SAAQ,kBAAkB;aAM1C,UAAU,CAAC,EAAE,MAAM;aACnB,WAAW,EAAE,OAAO;gBALpC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,OAAO,EACC,UAAU,CAAC,EAAE,MAAM,YAAA,EACnB,WAAW,GAAE,OAAc;CAI5C;AAED,oGAAoG;AACpG,qBAAa,eAAgB,SAAQ,kBAAkB;aAKrC,UAAU,EAAE,MAAM;gBAHlC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,MAAM,EACC,UAAU,EAAE,MAAM,EAClC,KAAK,CAAC,EAAE,OAAO;CAIhB;AAED,4GAA4G;AAC5G,qBAAa,kBAAmB,SAAQ,kBAAkB;aAKxC,SAAS,EAAE,OAAO;gBAHlC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,SAAS,EACf,OAAO,EAAE,MAAM,EACC,SAAS,EAAE,OAAO,EAClC,KAAK,CAAC,EAAE,OAAO;CAIhB;AAED,iJAAiJ;AACjJ,qBAAa,eAAgB,SAAQ,kBAAkB;aAIrC,MAAM,EAAE,MAAM;gBAF9B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACC,MAAM,EAAE,MAAM;CAI/B"}

package/dist/executor/executor-types.d.ts

@@ -0,0 +1,117 @@
+import type { Agent, LanguageModel, ToolSet } from "ai";
+import type { WorkflowStep } from "../types";
+import type { DurableContext } from "./context";
+import { type StepExecutionError } from "./errors";
+import type { ExecutionDelta, ExecutionPathSegment, ExecutionState, RetryRecord, TraceEntry } from "./state";
+/** The result of executing a workflow. */
+export interface ExecutionResult {
+    /** Whether the workflow completed without errors. */
+    success: boolean;
+    /** Map of step ID to that step's output value. */
+    stepOutputs: Record<string, unknown>;
+    /** The workflow's final output (from the `end` step's output expression), if any. */
+    output?: unknown;
+    /** The error that caused execution to fail, if `success` is `false`. */
+    error?: StepExecutionError;
+    /** The final execution state snapshot after the run completes. */
+    executionState: ExecutionState;
+}
+export interface ExecutorLimits {
+    /** Max wall-clock time from start to finish, including sleeps/waits. Default: 600_000 (10 min). */
+    maxTotalMs?: number;
+    /** Max active execution time (inside step() + checkFn, excluding sleeps/waits). Default: 300_000 (5 min). */
+    maxActiveMs?: number;
+    /** Soft cap on sleep durationMs and wait intervalMs. Clamped silently. Default: 300_000 (5 min). */
+    maxSleepMs?: number;
+    /** Soft cap on wait-for-condition maxAttempts. Clamped silently. Default: Infinity (unbounded). */
+    maxAttempts?: number;
+    /** Soft cap on backoffMultiplier upper bound. Clamped silently. Default: 2. */
+    maxBackoffMultiplier?: number;
+    /** Soft cap on backoffMultiplier lower bound. Clamped silently. Default: 1. */
+    minBackoffMultiplier?: number;
+    /** Soft cap on wait-for-condition timeoutMs. Clamped silently. Default: 600_000 (10 min). */
+    maxTimeoutMs?: number;
+    /** Byte threshold above which extract-data uses probe mode instead of inline data. Default: 50_000 (50KB). */
+    probeThresholdBytes?: number;
+    /** Maximum bytes returned per probe-data call. Default: 10_000 (10KB). */
+    probeResultMaxBytes?: number;
+    /** Maximum probe steps for extract-data probe mode. Default: 10. */
+    probeMaxSteps?: number;
+}
+/** Options for {@link executeWorkflow}. */
+export interface ExecuteWorkflowOptions {
+    /** Tool definitions. Every tool referenced by a `tool-call` step must be present with an `execute` function. */
+    tools: ToolSet;
+    /** An AI SDK `LanguageModel` for `llm-prompt`, `extract-data`, and `agent-loop` steps. Required if the workflow contains LLM steps. */
+    model?: LanguageModel;
+    /** An AI SDK `Agent` to use for `agent-loop` steps. When provided, agent-loop steps use the Agent's own tools
+     *  and describe the expected output shape in the prompt. The bare `model` is then used to coerce the Agent's
+     *  text output into the structured format. Only applies to `agent-loop` steps. */
+    agent?: Agent<any, any, any>;
+    /** Input values passed to the workflow's `start` step. Validated against the start step's `inputSchema`. */
+    inputs?: Record<string, unknown>;
+    /** Maximum number of retries for recoverable errors (rate limits, network errors, parse failures). Defaults to 3. */
+    maxRetries?: number;
+    /** Base delay in milliseconds for exponential backoff between retries. Defaults to 1000. */
+    retryDelayMs?: number;
+    /** Called when a step begins execution. */
+    onStepStart?: (stepId: string, step: WorkflowStep) => void;
+    /** Called when a step completes successfully. */
+    onStepComplete?: (stepId: string, output: unknown) => void;
+    /** Called on every state transition with the full execution state and the idempotent delta that produced it. */
+    onStateChange?: (state: ExecutionState, delta: ExecutionDelta) => void;
+    /** Injectable durable execution context. Default: simple in-process implementation. */
+    context?: DurableContext;
+    /** Execution limits for sleep/wait/timeout bounds. */
+    limits?: ExecutorLimits;
+}
+export type Expression = {
+    type: "literal";
+    value: unknown;
+} | {
+    type: "jmespath";
+    expression: string;
+} | {
+    type: "template";
+    template: string;
+};
+/**
+ * Internal resolved options. Currently identical to the public options
+ * but kept as a separate type for future internal-only fields.
+ */
+export type ResolvedExecuteWorkflowOptions = ExecuteWorkflowOptions;
+/**
+ * Callback type for `executeChain`, injected into structural steps
+ * (switch-case, for-each, wait-for-condition) to avoid circular imports.
+ */
+export type ExecuteChainFn = (startStepId: string, stepIndex: Map<string, WorkflowStep>, stepOutputs: Record<string, unknown>, loopVars: Record<string, unknown>, options: ResolvedExecuteWorkflowOptions, context: DurableContext, timer: ExecutionTimer | undefined, stateManager: ExecutionStateManager | undefined, execPath: ExecutionPathSegment[]) => Promise<unknown>;
+export declare const DEFAULT_EXECUTOR_LIMITS: Required<ExecutorLimits>;
+export declare class ExecutionTimer {
+    private readonly startTime;
+    private activeMs;
+    private activeStart;
+    private readonly limits;
+    constructor(limits?: ExecutorLimits);
+    get resolvedLimits(): Required<ExecutorLimits>;
+    /** Call before entering active work (step execution, condition check). */
+    beginActive(): void;
+    /** Call after active work completes. Checks active timeout. */
+    endActive(stepId: string): void;
+    /** Check total wall-clock timeout before starting a step. */
+    checkTotal(stepId: string): void;
+}
+export declare class ExecutionStateManager {
+    private state;
+    private readonly onChange?;
+    constructor(onChange?: (state: ExecutionState, delta: ExecutionDelta) => void);
+    get currentState(): ExecutionState;
+    private emit;
+    runStarted(): void;
+    stepStarted(stepId: string, path: ExecutionPathSegment[]): void;
+    stepCompleted(stepId: string, path: ExecutionPathSegment[], output: unknown, durationMs: number, resolvedInputs?: unknown, trace?: TraceEntry[]): void;
+    stepFailed(stepId: string, path: ExecutionPathSegment[], error: StepExecutionError, durationMs: number, resolvedInputs?: unknown): void;
+    retryAttempted(stepId: string, path: ExecutionPathSegment[], retry: RetryRecord): void;
+    runCompleted(output?: unknown): void;
+    runFailed(error: StepExecutionError): void;
+}
+//# sourceMappingURL=executor-types.d.ts.map

package/dist/executor/executor-types.d.ts.map

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

package/dist/executor/helpers.d.ts

@@ -0,0 +1,21 @@
+import { type StepExecutionError } from "./errors";
+import type { Expression } from "./executor-types";
+export declare function stripCodeFence(text: string): string;
+export declare function evaluateExpression(expr: Expression, scope: Record<string, unknown>, stepId: string): unknown;
+export declare function stringifyValue(value: unknown): string;
+export declare function interpolateTemplate(template: string, scope: Record<string, unknown>, stepId: string): string;
+export declare function classifyLlmError(stepId: string, e: unknown): StepExecutionError;
+export declare function createProbeDataTool(sourceData: unknown, limits: {
+    probeResultMaxBytes: number;
+}): import("ai").Tool<{
+    expression: string;
+}, string>;
+export declare function createGiveUpTool(): {
+    tool: import("ai").Tool<{
+        reason: string;
+    }, {
+        acknowledged: boolean;
+    }>;
+    getReason: () => string | undefined;
+};
+//# sourceMappingURL=helpers.d.ts.map

package/dist/executor/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/executor/helpers.ts"],"names":[],"mappings":"AAYA,OAAO,EAIN,KAAK,kBAAkB,EACvB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAInD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAGnD;AAID,wBAAgB,kBAAkB,CACjC,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,MAAM,EAAE,MAAM,GACZ,OAAO,CAkBT;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAIrD;AAED,wBAAgB,mBAAmB,CAClC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,MAAM,EAAE,MAAM,GACZ,MAAM,CA2BR;AAID,wBAAgB,gBAAgB,CAC/B,MAAM,EAAE,MAAM,EACd,CAAC,EAAE,OAAO,GACR,kBAAkB,CA2DpB;AAID,wBAAgB,mBAAmB,CAClC,UAAU,EAAE,OAAO,EACnB,MAAM,EAAE;IAAE,mBAAmB,EAAE,MAAM,CAAA;CAAE;;WAiCvC;AAED,wBAAgB,gBAAgB;;;;;;;EAqB/B"}

package/dist/executor/index.d.ts

@@ -0,0 +1,16 @@
+import type { WorkflowDefinition } from "../types";
+import { type ExecuteWorkflowOptions, type ExecutionResult } from "./executor-types";
+export type { ExecuteWorkflowOptions, ExecutionResult, ExecutorLimits, } from "./executor-types";
+/**
+ * Executes a compiled workflow by walking its step graph from `initialStepId`.
+ *
+ * Handles all step types (tool calls, LLM prompts, data extraction, branching,
+ * loops) and supports automatic retry with exponential backoff for recoverable
+ * errors (rate limits, network failures, LLM parse errors).
+ *
+ * @param workflow - The workflow definition to execute (should be compiled first via {@link compileWorkflow}).
+ * @param options - Execution options including tools, agent, inputs, and callbacks.
+ * @returns An {@link ExecutionResult} with success status, all step outputs, and the final workflow output.
+ */
+export declare function executeWorkflow(workflow: WorkflowDefinition, options: ExecuteWorkflowOptions): Promise<ExecutionResult>;
+//# sourceMappingURL=index.d.ts.map

package/dist/executor/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/executor/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAgB,MAAM,UAAU,CAAC;AAQjE,OAAO,EAEN,KAAK,sBAAsB,EAC3B,KAAK,eAAe,EAIpB,MAAM,kBAAkB,CAAC;AAG1B,YAAY,EACX,sBAAsB,EACtB,eAAe,EACf,cAAc,GACd,MAAM,kBAAkB,CAAC;AAolB1B;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CACpC,QAAQ,EAAE,kBAAkB,EAC5B,OAAO,EAAE,sBAAsB,GAC7B,OAAO,CAAC,eAAe,CAAC,CA8E1B"}

package/dist/executor/schema-inference.d.ts

@@ -0,0 +1,3 @@
+export declare function inferSchema(value: unknown, types?: unknown[], maxKeys?: number): unknown;
+export declare function summarizeObjectStructure(value: object, indent?: string | number): string;
+//# sourceMappingURL=schema-inference.d.ts.map

package/dist/executor/schema-inference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-inference.d.ts","sourceRoot":"","sources":["../../src/executor/schema-inference.ts"],"names":[],"mappings":"AAwDA,wBAAgB,WAAW,CAC1B,KAAK,EAAE,OAAO,EACd,KAAK,GAAE,OAAO,EAAO,EACrB,OAAO,SAAK,WAgGZ;AAiFD,wBAAgB,wBAAwB,CACvC,KAAK,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,UAIxB"}

package/dist/executor/state.d.ts

@@ -0,0 +1,292 @@
+import type { StepExecutionError } from "./errors";
+export declare const stepStatusSchema: import("arktype/internal/variants/string.ts").StringType<"pending" | "running" | "completed" | "failed" | "skipped", {}>;
+export type StepStatus = typeof stepStatusSchema.infer;
+export declare const runStatusSchema: import("arktype/internal/variants/string.ts").StringType<"pending" | "running" | "completed" | "failed", {}>;
+export type RunStatus = typeof runStatusSchema.infer;
+export declare const errorSnapshotSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    code: string;
+    category: string;
+    message: string;
+    stepId?: string | undefined;
+    statusCode?: number | undefined;
+    isRetryable?: boolean | undefined;
+}, {}>;
+export type ErrorSnapshot = typeof errorSnapshotSchema.infer;
+export declare const retryRecordSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    attempt: number;
+    startedAt: string;
+    failedAt: string;
+    errorCode: string;
+    errorMessage: string;
+}, {}>;
+export type RetryRecord = typeof retryRecordSchema.infer;
+export declare const executionPathSegmentSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    type: "for-each";
+    stepId: string;
+    iterationIndex: number;
+    itemValue: unknown;
+} | {
+    type: "switch-case";
+    stepId: string;
+    matchedCaseIndex: number;
+    matchedValue: unknown;
+} | {
+    type: "wait-for-condition";
+    stepId: string;
+    pollAttempt: number;
+}, {}>;
+export type ExecutionPathSegment = typeof executionPathSegmentSchema.infer;
+export declare const traceEntrySchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    type: "log";
+    message: string;
+    data?: unknown;
+} | {
+    type: "agent-step";
+    step: unknown;
+}, {}>;
+export type TraceEntry = typeof traceEntrySchema.infer;
+export declare const stepExecutionRecordSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    stepId: string;
+    status: "pending" | "running" | "completed" | "failed" | "skipped";
+    retries: {
+        attempt: number;
+        startedAt: string;
+        failedAt: string;
+        errorCode: string;
+        errorMessage: string;
+    }[];
+    path: ({
+        type: "for-each";
+        stepId: string;
+        iterationIndex: number;
+        itemValue: unknown;
+    } | {
+        type: "switch-case";
+        stepId: string;
+        matchedCaseIndex: number;
+        matchedValue: unknown;
+    } | {
+        type: "wait-for-condition";
+        stepId: string;
+        pollAttempt: number;
+    })[];
+    startedAt?: string | undefined;
+    completedAt?: string | undefined;
+    durationMs?: number | undefined;
+    output?: unknown;
+    error?: {
+        code: string;
+        category: string;
+        message: string;
+        stepId?: string | undefined;
+        statusCode?: number | undefined;
+        isRetryable?: boolean | undefined;
+    } | undefined;
+    resolvedInputs?: unknown;
+    trace?: ({
+        type: "log";
+        message: string;
+        data?: unknown;
+    } | {
+        type: "agent-step";
+        step: unknown;
+    })[] | undefined;
+}, {}>;
+export type StepExecutionRecord = typeof stepExecutionRecordSchema.infer;
+export declare const executionStateSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    runId: string;
+    status: "pending" | "running" | "completed" | "failed";
+    startedAt: string;
+    stepRecords: {
+        stepId: string;
+        status: "pending" | "running" | "completed" | "failed" | "skipped";
+        retries: {
+            attempt: number;
+            startedAt: string;
+            failedAt: string;
+            errorCode: string;
+            errorMessage: string;
+        }[];
+        path: ({
+            type: "for-each";
+            stepId: string;
+            iterationIndex: number;
+            itemValue: unknown;
+        } | {
+            type: "switch-case";
+            stepId: string;
+            matchedCaseIndex: number;
+            matchedValue: unknown;
+        } | {
+            type: "wait-for-condition";
+            stepId: string;
+            pollAttempt: number;
+        })[];
+        startedAt?: string | undefined;
+        completedAt?: string | undefined;
+        durationMs?: number | undefined;
+        output?: unknown;
+        error?: {
+            code: string;
+            category: string;
+            message: string;
+            stepId?: string | undefined;
+            statusCode?: number | undefined;
+            isRetryable?: boolean | undefined;
+        } | undefined;
+        resolvedInputs?: unknown;
+        trace?: ({
+            type: "log";
+            message: string;
+            data?: unknown;
+        } | {
+            type: "agent-step";
+            step: unknown;
+        })[] | undefined;
+    }[];
+    completedAt?: string | undefined;
+    durationMs?: number | undefined;
+    output?: unknown;
+    error?: {
+        code: string;
+        category: string;
+        message: string;
+        stepId?: string | undefined;
+        statusCode?: number | undefined;
+        isRetryable?: boolean | undefined;
+    } | undefined;
+}, {}>;
+export type ExecutionState = typeof executionStateSchema.infer;
+export declare const executionDeltaSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    type: "run-started";
+    runId: string;
+    startedAt: string;
+} | {
+    type: "step-started";
+    stepId: string;
+    path: ({
+        type: "for-each";
+        stepId: string;
+        iterationIndex: number;
+        itemValue: unknown;
+    } | {
+        type: "switch-case";
+        stepId: string;
+        matchedCaseIndex: number;
+        matchedValue: unknown;
+    } | {
+        type: "wait-for-condition";
+        stepId: string;
+        pollAttempt: number;
+    })[];
+    startedAt: string;
+} | {
+    type: "step-completed";
+    stepId: string;
+    path: ({
+        type: "for-each";
+        stepId: string;
+        iterationIndex: number;
+        itemValue: unknown;
+    } | {
+        type: "switch-case";
+        stepId: string;
+        matchedCaseIndex: number;
+        matchedValue: unknown;
+    } | {
+        type: "wait-for-condition";
+        stepId: string;
+        pollAttempt: number;
+    })[];
+    completedAt: string;
+    durationMs: number;
+    output: unknown;
+    resolvedInputs?: unknown;
+    trace?: ({
+        type: "log";
+        message: string;
+        data?: unknown;
+    } | {
+        type: "agent-step";
+        step: unknown;
+    })[] | undefined;
+} | {
+    type: "step-failed";
+    stepId: string;
+    path: ({
+        type: "for-each";
+        stepId: string;
+        iterationIndex: number;
+        itemValue: unknown;
+    } | {
+        type: "switch-case";
+        stepId: string;
+        matchedCaseIndex: number;
+        matchedValue: unknown;
+    } | {
+        type: "wait-for-condition";
+        stepId: string;
+        pollAttempt: number;
+    })[];
+    failedAt: string;
+    durationMs: number;
+    error: {
+        code: string;
+        category: string;
+        message: string;
+        stepId?: string | undefined;
+        statusCode?: number | undefined;
+        isRetryable?: boolean | undefined;
+    };
+    resolvedInputs?: unknown;
+} | {
+    type: "step-retry";
+    stepId: string;
+    path: ({
+        type: "for-each";
+        stepId: string;
+        iterationIndex: number;
+        itemValue: unknown;
+    } | {
+        type: "switch-case";
+        stepId: string;
+        matchedCaseIndex: number;
+        matchedValue: unknown;
+    } | {
+        type: "wait-for-condition";
+        stepId: string;
+        pollAttempt: number;
+    })[];
+    retry: {
+        attempt: number;
+        startedAt: string;
+        failedAt: string;
+        errorCode: string;
+        errorMessage: string;
+    };
+} | {
+    type: "run-completed";
+    runId: string;
+    completedAt: string;
+    durationMs: number;
+    output?: unknown;
+} | {
+    type: "run-failed";
+    runId: string;
+    failedAt: string;
+    durationMs: number;
+    error: {
+        code: string;
+        category: string;
+        message: string;
+        stepId?: string | undefined;
+        statusCode?: number | undefined;
+        isRetryable?: boolean | undefined;
+    };
+}, {}>;
+export type ExecutionDelta = typeof executionDeltaSchema.infer;
+/** Convert a StepExecutionError class instance to a serializable snapshot. */
+export declare function snapshotError(err: StepExecutionError): ErrorSnapshot;
+/** Apply a delta to an execution state, returning a new state. Pure — no mutations. */
+export declare function applyDelta(state: ExecutionState, delta: ExecutionDelta): ExecutionState;
+//# sourceMappingURL=state.d.ts.map

package/dist/executor/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/executor/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAInD,eAAO,MAAM,gBAAgB,0HAE5B,CAAC;AACF,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,CAAC,KAAK,CAAC;AAEvD,eAAO,MAAM,eAAe,8GAE3B,CAAC;AACF,MAAM,MAAM,SAAS,GAAG,OAAO,eAAe,CAAC,KAAK,CAAC;AAIrD,eAAO,MAAM,mBAAmB;;;;;;;MAO9B,CAAC;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,mBAAmB,CAAC,KAAK,CAAC;AAE7D,eAAO,MAAM,iBAAiB;;;;;;MAM5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,KAAK,CAAC;AAIzD,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;MAgBpC,CAAC;AACJ,MAAM,MAAM,oBAAoB,GAAG,OAAO,0BAA0B,CAAC,KAAK,CAAC;AAI3E,eAAO,MAAM,gBAAgB;;;;;;;MAO3B,CAAC;AACH,MAAM,MAAM,UAAU,GAAG,OAAO,gBAAgB,CAAC,KAAK,CAAC;AAIvD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAYpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,yBAAyB,CAAC,KAAK,CAAC;AAIzE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAS/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,KAAK,CAAC;AAI/D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiD9B,CAAC;AACJ,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,KAAK,CAAC;AAI/D,8EAA8E;AAC9E,wBAAgB,aAAa,CAAC,GAAG,EAAE,kBAAkB,GAAG,aAAa,CAcpE;AAkDD,uFAAuF;AACvF,wBAAgB,UAAU,CACzB,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,cAAc,GACnB,cAAc,CA6FhB"}

package/dist/executor/steps/agent-loop.d.ts

@@ -0,0 +1,15 @@
+import type { WorkflowStep } from "../../types";
+import type { ExecutorLimits, ResolvedExecuteWorkflowOptions } from "../executor-types";
+import type { TraceEntry } from "../state";
+type StepOutput = {
+    output: unknown;
+    trace?: TraceEntry[];
+};
+export declare function executeAgentLoop(step: WorkflowStep & {
+    type: "agent-loop";
+}, scope: Record<string, unknown>, options: ResolvedExecuteWorkflowOptions, limits: Required<ExecutorLimits>): Promise<StepOutput>;
+export declare function resolveAgentLoopInputs(step: WorkflowStep & {
+    type: "agent-loop";
+}, scope: Record<string, unknown>): unknown;
+export {};
+//# sourceMappingURL=agent-loop.d.ts.map

package/dist/executor/steps/agent-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-loop.d.ts","sourceRoot":"","sources":["../../../src/executor/steps/agent-loop.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAOhD,OAAO,KAAK,EACX,cAAc,EAEd,8BAA8B,EAC9B,MAAM,mBAAmB,CAAC;AAQ3B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,KAAK,UAAU,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,UAAU,EAAE,CAAA;CAAE,CAAC;AAE5D,wBAAsB,gBAAgB,CACrC,IAAI,EAAE,YAAY,GAAG;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,EAC3C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,8BAA8B,EACvC,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,GAC9B,OAAO,CAAC,UAAU,CAAC,CAuCrB;AAsID,wBAAgB,sBAAsB,CACrC,IAAI,EAAE,YAAY,GAAG;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,EAC3C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAYT"}

package/dist/executor/steps/end.d.ts

@@ -0,0 +1,5 @@
+import type { WorkflowStep } from "../../types";
+export declare function executeEnd(step: WorkflowStep & {
+    type: "end";
+}, scope: Record<string, unknown>): unknown;
+//# sourceMappingURL=end.d.ts.map

package/dist/executor/steps/end.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"end.d.ts","sourceRoot":"","sources":["../../../src/executor/steps/end.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAIhD,wBAAgB,UAAU,CACzB,IAAI,EAAE,YAAY,GAAG;IAAE,IAAI,EAAE,KAAK,CAAA;CAAE,EACpC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAKT"}

package/dist/executor/steps/extract-data.d.ts

@@ -0,0 +1,15 @@
+import type { WorkflowStep } from "../../types";
+import type { ExecutorLimits, ResolvedExecuteWorkflowOptions } from "../executor-types";
+import type { TraceEntry } from "../state";
+type StepOutput = {
+    output: unknown;
+    trace?: TraceEntry[];
+};
+export declare function executeExtractData(step: WorkflowStep & {
+    type: "extract-data";
+}, scope: Record<string, unknown>, options: ResolvedExecuteWorkflowOptions, limits: Required<ExecutorLimits>): Promise<StepOutput>;
+export declare function resolveExtractDataInputs(step: WorkflowStep & {
+    type: "extract-data";
+}, scope: Record<string, unknown>): unknown;
+export {};
+//# sourceMappingURL=extract-data.d.ts.map

package/dist/executor/steps/extract-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-data.d.ts","sourceRoot":"","sources":["../../../src/executor/steps/extract-data.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAOhD,OAAO,KAAK,EACX,cAAc,EAEd,8BAA8B,EAC9B,MAAM,mBAAmB,CAAC;AAQ3B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,KAAK,UAAU,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,UAAU,EAAE,CAAA;CAAE,CAAC;AAE5D,wBAAsB,kBAAkB,CACvC,IAAI,EAAE,YAAY,GAAG;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,EAC7C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,EAAE,8BAA8B,EACvC,MAAM,EAAE,QAAQ,CAAC,cAAc,CAAC,GAC9B,OAAO,CAAC,UAAU,CAAC,CA+DrB;AA4ID,wBAAgB,wBAAwB,CACvC,IAAI,EAAE,YAAY,GAAG;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,EAC7C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAYT"}