@oomol-lab/open-flow 0.1.0-beta.1 → 0.1.0-beta.11

package/dist/common/integration-trigger.d.ts

@@ -27,6 +27,7 @@ export interface IntegrationStateContext {
     readonly saveSubscription: (subscription: Readonly<Record<string, JsonValue>>, reconcileAt: Date) => Promise<void>;
 }
 export interface IntegrationReceiveContext {
+    readonly signal?: AbortSignal;
     readonly admit: boolean;
     readonly allow?: () => Promise<boolean>;
     readonly bindingId: string;
@@ -48,6 +49,7 @@ export interface IntegrationReconcileContext {
     readonly config: Readonly<Record<string, JsonValue>>;
     readonly connector: ConnectorProxy;
     readonly endpointUrl: string;
+    readonly idempotencyKey: string;
     readonly now: Date;
     readonly signal?: AbortSignal;
     readonly state?: IntegrationStateContext;

package/dist/common/provider-triggers.js

@@ -3923,7 +3923,10 @@ var ci = 300, H = "/v1/webhook_endpoints", li = { "Content-Type": "application/x
 			let t = await U(e, "endpoint create", {
 				body: fi(e.endpointUrl, n),
 				endpoint: H,
-				headers: li,
+				headers: {
+					...li,
+					"Idempotency-Key": e.idempotencyKey
+				},
 				method: "POST"
 			});
 			W(t, "endpoint create");

package/dist/common/run-events.d.ts

@@ -1,9 +1,9 @@
 export type ProjectedRunEvent = {
-    readonly kind: 'node.output';
+    readonly kind: 'node.completed';
     readonly payload: Readonly<Record<string, unknown>>;
     readonly value: unknown;
 } | {
-    readonly kind: 'node.artifact' | 'node.completed' | 'node.failed' | 'node.log' | 'node.progress' | 'node.started' | 'run.progress' | 'run.started';
+    readonly kind: 'node.artifact' | 'node.failed' | 'node.log' | 'node.progress' | 'node.started' | 'run.progress' | 'run.started';
     readonly payload: Readonly<Record<string, unknown>>;
 };
 export declare function createEventProjector(platformRunId: string, nodeFailureCodes: ReadonlySet<string>): (event: unknown) => Promise<ProjectedRunEvent | undefined>;

package/dist/common/run-events.js

@@ -5,7 +5,8 @@ var e = new TextEncoder(), t = /* @__PURE__ */ new Set([
 	"javascript",
 	"llm",
 	"subflow",
-	"value"
+	"value",
+	"wait"
 ]);
 function n(e, t) {
 	if (typeof e != "object" || !e || Array.isArray(e)) throw TypeError(`${t} must be an object.`);
@@ -109,21 +110,18 @@ function f(e, t) {
 			o(g);
 			return;
 		}
-		if (_ == "node.started" || _ == "node.output" || _ == "node.progress" || _ == "node.artifact" || _ == "node.log" || _ == "node.completed" || _ == "node.failed") {
-			let n = s(g, f, e), o = await n.executionId, m = {
+		if (_ == "node.started" || _ == "node.progress" || _ == "node.artifact" || _ == "node.log" || _ == "node.completed" || _ == "node.failed") {
+			let r = s(g, f, e), o = await r.executionId, m = {
 				executionId: o,
-				flowId: n.flowId,
-				nodeId: n.nodeId,
-				scopeId: await c("scope", e, n.rawRunId)
+				flowId: r.flowId,
+				nodeId: r.nodeId,
+				scopeId: await c("scope", e, r.rawRunId)
 			};
 			switch (_) {
-				case "node.output": return {
+				case "node.completed": return {
 					kind: _,
-					payload: {
-						...m,
-						handle: r(g.handle, "Runtime node.output handle")
-					},
-					value: g.value
+					payload: m,
+					value: n(g.outputs, "Runtime node.completed outputs")
 				};
 				case "node.started": {
 					let e = a(g.nodeKind), t = i(g.nodeTitle, "Runtime node.started nodeTitle"), n = i(g.operation, "Runtime node.started operation");
@@ -169,10 +167,6 @@ function f(e, t) {
 							message: l(g.message)
 						}
 					};
-				case "node.completed": return {
-					kind: _,
-					payload: m
-				};
 				case "node.failed": return {
 					kind: _,
 					payload: {

package/dist/common/run-lifecycle.d.ts

@@ -1,11 +1,15 @@
 export declare const runTerminalStatuses: readonly ['canceled', 'completed', 'failed', 'indeterminate'];
-export declare const runStatuses: readonly ["canceled", "completed", "failed", "indeterminate", "queued", "running", "starting"];
+export declare const runStatuses: readonly ["canceled", "completed", "failed", "indeterminate", "queued", "running", "starting", "waiting"];
 export type RunStatus = (typeof runStatuses)[number];
 export type RunTerminalStatus = (typeof runTerminalStatuses)[number];
 export type RunOperation = {
     readonly kind: 'claim';
 } | {
     readonly kind: 'start';
+} | {
+    readonly kind: 'wait';
+} | {
+    readonly kind: 'resolve';
 } | {
     readonly kind: 'commit';
     readonly status: RunTerminalStatus;
@@ -16,6 +20,9 @@ export type RunTransition = {
 } | {
     readonly kind: 'running';
     readonly status: 'running';
+} | {
+    readonly kind: 'waiting';
+    readonly status: 'waiting';
 } | {
     readonly kind: 'terminal';
     readonly status: RunTerminalStatus;
@@ -28,12 +35,18 @@ export type RunTransition = {
 } | {
     readonly kind: 'committed';
     readonly status: RunTerminalStatus;
+} | {
+    readonly kind: 'waited';
+    readonly status: 'waiting';
+} | {
+    readonly kind: 'resolved';
+    readonly status: 'queued';
 } | {
     readonly kind: 'stale';
     readonly status: RunStatus;
 };
 export type RunClaim = Extract<RunTransition, {
-    readonly kind: 'ready' | 'running' | 'terminal';
+    readonly kind: 'ready' | 'running' | 'terminal' | 'waiting';
 }>;
 export type RunStart = Extract<RunTransition, {
     readonly kind: 'already-started' | 'started' | 'stale';
@@ -60,7 +73,9 @@ export interface RunLifecycleHarness {
     claim(runId: string): Promise<RunClaim>;
     commit(runId: string, status: RunTerminalStatus): Promise<boolean>;
     observe(runId: string): Promise<RunObservation>;
+    resolve(runId: string): Promise<boolean>;
     start(runId: string): Promise<RunStart>;
+    wait(runId: string): Promise<boolean>;
 }
 export interface RunLifecycleConformanceCase {
     readonly name: string;

package/dist/common/run-lifecycle.js

@@ -28,7 +28,8 @@ var n = [
 	...n,
 	"queued",
 	"running",
-	"starting"
+	"starting",
+	"waiting"
 ];
 function i(e) {
 	return e == "canceled" || e == "completed" || e == "failed" || e == "indeterminate";
@@ -45,6 +46,10 @@ function a(e, t) {
 				kind: "running",
 				status: e
 			};
+			case "waiting": return {
+				kind: "waiting",
+				status: e
+			};
 			case "canceled":
 			case "completed":
 			case "failed":
@@ -63,6 +68,7 @@ function a(e, t) {
 				status: e
 			};
 			case "queued":
+			case "waiting":
 			case "canceled":
 			case "completed":
 			case "failed":
@@ -71,10 +77,24 @@ function a(e, t) {
 				status: e
 			};
 		}
+		case "wait": return e == "running" ? {
+			kind: "waited",
+			status: "waiting"
+		} : {
+			kind: "stale",
+			status: e
+		};
+		case "resolve": return e == "waiting" ? {
+			kind: "resolved",
+			status: "queued"
+		} : {
+			kind: "stale",
+			status: e
+		};
 		case "commit": return i(e) ? {
 			kind: "stale",
 			status: e
-		} : t.status == "canceled" || e == "running" ? {
+		} : t.status == "canceled" || e == "running" || t.status == "failed" && e == "waiting" ? {
 			kind: "committed",
 			status: t.status
 		} : {
@@ -95,6 +115,37 @@ async function s(e, t = "request", n = "request-a") {
 	return r.runId;
 }
 var c = [
+	{
+		name: "pauses and resumes the same Run through the ordinary start barrier",
+		async verify(e) {
+			let t = await s(e), n = await e.claim(t);
+			if (n.kind != "ready") throw Error("Initial Run claim was not ready.");
+			o(await e.start(t), a(n.status, { kind: "start" }), "Initial start"), o(await e.wait(t), !0, "Wait commit"), o(await e.observe(t), {
+				status: "waiting",
+				terminalEvents: []
+			}, "Waiting Run observation"), o(await e.claim(t), a("waiting", { kind: "claim" }), "Claim while waiting"), o(await e.resolve(t), !0, "Wait resolution"), o(await e.resolve(t), !1, "Repeated Wait resolution");
+			let r = await e.claim(t);
+			if (r.kind != "ready") throw Error("Resolved Run claim was not ready.");
+			o(await e.start(t), a(r.status, { kind: "start" }), "Resume start"), o(await e.commit(t, "completed"), !0, "Completion after resume"), o(await e.observe(t), {
+				status: "completed",
+				terminalEvents: ["completed"]
+			}, "Resumed Run observation");
+		}
+	},
+	{
+		name: "allows cancellation and expiry failure while waiting",
+		async verify(e) {
+			let t = await s(e, "cancel-wait");
+			if ((await e.claim(t)).kind != "ready") throw Error("Canceled Run claim was not ready.");
+			await e.start(t), o(await e.wait(t), !0, "Canceled Run Wait commit"), o(await e.commit(t, "canceled"), !0, "Waiting cancellation"), o(await e.resolve(t), !1, "Resolution after cancellation");
+			let n = await s(e, "expire-wait");
+			if ((await e.claim(n)).kind != "ready") throw Error("Expired Run claim was not ready.");
+			await e.start(n), o(await e.wait(n), !0, "Expired Run Wait commit"), o(await e.commit(n, "failed"), !0, "Waiting expiry failure"), o(await e.observe(n), {
+				status: "failed",
+				terminalEvents: ["failed"]
+			}, "Expired Run observation");
+		}
+	},
 	{
 		name: "replays idempotent acceptance and rejects a conflicting request",
 		async verify(e) {

package/dist/common/runtime-contract.d.ts

@@ -1,4 +1,4 @@
-import type { CodeModule, JsonValue } from '../browser/flow-change.js';
+import type { CodeModule, ConnectorCapability, JsonValue } from '../browser/flow-change.js';
 export { currentEngineContract, findEngineContract, type EngineContract } from './engine-contract.js';
 export type RuntimeModule = Pick<CodeModule, 'imports' | 'source'>;
 export interface RuntimeProgram {
@@ -8,6 +8,7 @@ export interface RuntimeProgram {
     readonly modules: Readonly<Record<string, RuntimeModule>>;
 }
 export interface RuntimeCapabilityCall {
+    readonly callId: string;
     readonly invocationId: string;
     readonly kind: string;
     readonly payload: JsonValue;
@@ -36,6 +37,7 @@ export type LlmTaskResult = {
 };
 export type InvokeLlmTask = (invocation: LlmTaskInvocation) => Promise<LlmTaskResult>;
 export interface RuntimeInvocation {
+    readonly capabilities?: readonly ConnectorCapability[];
     readonly capability: (call: RuntimeCapabilityCall) => Promise<RuntimeCapabilityResponse>;
     readonly input: JsonValue;
     readonly invocationId: string;
@@ -44,10 +46,16 @@ export interface RuntimeInvocation {
 }
 export interface RuntimeHarness {
     readonly engineDigest: string;
-    invoke(invocation: RuntimeInvocation): Promise<JsonValue>;
+    invoke(invocation: RuntimeInvocation): Promise<JsonValue | undefined>;
 }
 export interface RuntimeConformanceCase {
     readonly name: string;
     verify(harness: RuntimeHarness): Promise<void>;
 }
 export declare const runtimeConformanceCases: readonly RuntimeConformanceCase[];
+export declare function createActions(declarations: readonly ConnectorCapability[], invoke: (payload: JsonValue) => Promise<RuntimeCapabilityResponse>): Readonly<Record<string, unknown>>;
+export declare function resolveAction(declarations: readonly ConnectorCapability[], payload: unknown): {
+    readonly action: string;
+    readonly connectionId?: string;
+    readonly input: Readonly<Record<string, JsonValue>>;
+};

package/dist/common/runtime-contract.js

@@ -19,7 +19,7 @@ function t(n, r) {
 }
 //#endregion
 //#region src/execution/common/engineContract.ts
-var n = "open-flow-engine/v1", r = {
+var n = "open-flow-engine/v2", r = {
 	platformExports: /* @__PURE__ */ new Set(["engineContract", "identity"]),
 	platformModule: "open-flow:platform",
 	platformSource: `export const engineContract = ${JSON.stringify(n)}
@@ -27,7 +27,7 @@ export function identity(value) { return value }
 `
 };
 function i(e) {
-	return e == "open-flow-engine/v1" ? r : void 0;
+	return e == "open-flow-engine/v2" ? r : void 0;
 }
 //#endregion
 //#region src/execution/common/runtime.ts
@@ -58,6 +58,71 @@ async function s(e, t, n) {
 	throw Error(`${n}: operation unexpectedly succeeded.`);
 }
 var c = [
+	{
+		name: "preserves Action error codes and fixed per-call Connection selection",
+		async verify(e) {
+			let t = [{
+				kind: "connector",
+				action: "example.echo",
+				connections: [{
+					connectionId: "work",
+					alias: "office"
+				}, { connectionId: "home" }]
+			}];
+			o(await e.invoke({
+				capabilities: t,
+				capability: async ({ payload: e }) => {
+					let n = u(t, e);
+					if (n.input.fail) throw Object.assign(/* @__PURE__ */ Error("Provider unavailable."), { code: "connector.unavailable" });
+					return {
+						body: n.connectionId ?? null,
+						status: 200
+					};
+				},
+				input: null,
+				invocationId: "action-accounts",
+				program: a(e, "export default async (_, context) => {\n          const values = await Promise.all([\n            context.actions.example.echo({}, { connectionAlias: 'office' }),\n            context.actions['example.echo']({}, { connectionId: 'home' }),\n          ])\n          try { await context.actions.example.echo({ fail: true }, { connectionId: 'work' }) }\n          catch (error) { values.push(error.code) }\n          return values\n        }")
+			}), [
+				"work",
+				"home",
+				"connector.unavailable"
+			], "Action selection and recovery");
+		}
+	},
+	{
+		name: "shares Action entries and assigns independent concurrent call identities",
+		async verify(e) {
+			let t = [];
+			o(await e.invoke({
+				capabilities: [{
+					kind: "connector",
+					action: "example.echo",
+					connections: []
+				}],
+				capability: async (e) => (t.push(e), {
+					body: e.payload,
+					status: 200
+				}),
+				input: null,
+				invocationId: "action-calls",
+				program: a(e, "export default async (_input, context) => {\n          const call = context.actions.example.echo\n          return { same: call === context.actions['example.echo'], values: await Promise.all([call({ value: 1 }), call({ value: 2 }), call({ value: 3 })]) }\n        }")
+			}), {
+				same: !0,
+				values: [
+					1,
+					2,
+					3
+				].map((e) => ({
+					action: "example.echo",
+					input: { value: e }
+				}))
+			}, "Action results"), o(new Set(t.map((e) => e.callId)).size, 3, "Independent Action identities"), o(t.map((e) => e.invocationId), [
+				"action-calls",
+				"action-calls",
+				"action-calls"
+			], "Task identity");
+		}
+	},
 	{
 		name: "loads the fixed ESM closure and platform module",
 		async verify(e) {
@@ -105,7 +170,7 @@ var c = [
 				}),
 				input: { issue: 42 },
 				invocationId: "async-capability",
-				program: a(e, "export default async (input, capability) => capability.connector({ action: 'read', input })")
+				program: a(e, "export default async (input, capability) => capability.artifact.put({ action: 'read', input })")
 			}), {
 				body: {
 					accepted: !0,
@@ -121,7 +186,7 @@ var c = [
 				payload: n
 			})), [{
 				invocationId: "async-capability",
-				kind: "connector",
+				kind: "artifact.put",
 				payload: {
 					action: "read",
 					input: { issue: 42 }
@@ -129,23 +194,95 @@ var c = [
 			}], "Capability request");
 		}
 	},
+	{
+		name: "returns final outputs without exposing intermediate output capability",
+		async verify(e) {
+			o(await e.invoke({
+				capability: async () => {
+					throw Error("Capability must not be called.");
+				},
+				input: null,
+				invocationId: "final-outputs",
+				program: a(e, "export default (_input, context) => ({ available: typeof context.outputs, value: 1 })")
+			}), {
+				available: "undefined",
+				value: 1
+			}, "Final Task outputs");
+		}
+	},
 	{
 		name: "cancels a pending Capability and the user invocation",
 		async verify(e) {
 			let t = new AbortController(), n = !1, r, i = new Promise((e) => {
 				r = e;
 			}), c = e.invoke({
+				capabilities: [{
+					kind: "connector",
+					action: "example.wait",
+					connections: []
+				}],
 				capability: async ({ signal: e }) => (r(), await new Promise((t, r) => e.addEventListener("abort", () => {
 					n = !0, r(e.reason);
 				}, { once: !0 }))),
 				input: null,
 				invocationId: "canceled-capability",
-				program: a(e, "export default async (_input, capability) => capability.connector({ action: 'wait' })"),
+				program: a(e, "export default async (_input, context) => context.actions.example.wait({})"),
 				signal: t.signal
 			});
 			await i, t.abort(/* @__PURE__ */ Error("Invocation canceled.")), await s(c, /cancel|abort|disposed/i, "Canceled invocation"), o(n, !0, "Capability cancellation");
 		}
 	}
 ];
+function l(e, t) {
+	let n = (e, t) => {
+		if (!(e === null || typeof e == "string" || typeof e == "boolean" || typeof e == "number" && Number.isFinite(e))) {
+			if (typeof e != "object" || t.has(e) || !Array.isArray(e) && Object.getPrototypeOf(e) !== Object.prototype && Object.getPrototypeOf(e) !== null || Object.getOwnPropertySymbols(e).length > 0) throw Object.assign(/* @__PURE__ */ Error("Action parameters must contain only JSON values."), { code: "capability.invalid" });
+			t.add(e);
+			for (let r of Array.isArray(e) ? e : Object.values(e)) n(r, t);
+			t.delete(e);
+		}
+	}, r = Object.create(null), i = /* @__PURE__ */ new Map();
+	for (let a of e) {
+		let e = a.action.indexOf("."), o = a.action.slice(0, e), s = a.action.slice(e + 1), c = i.get(o);
+		c ?? (c = Object.create(null), i.set(o, c), r[o] = c);
+		let l = async (e = {}, r) => (n(e, /* @__PURE__ */ new Set()), r !== void 0 && n(r, /* @__PURE__ */ new Set()), (await t({
+			action: a.action,
+			input: e,
+			...r === void 0 ? {} : { options: r }
+		})).body);
+		r[a.action] = l, c[s] = l;
+	}
+	for (let e of i.values()) Object.freeze(e);
+	return Object.freeze(r);
+}
+function u(e, t) {
+	let n = Object.assign(/* @__PURE__ */ Error("The Action request is invalid."), { code: "capability.invalid" }), r = Object.assign(/* @__PURE__ */ Error("The Action or Connection is not declared for this Task."), { code: "capability.denied" });
+	if (typeof t != "object" || !t || Array.isArray(t)) throw n;
+	let i = t;
+	if (Object.keys(i).some((e) => ![
+		"action",
+		"input",
+		"options"
+	].includes(e)) || typeof i.action != "string" || i.input == null || typeof i.input != "object" || Array.isArray(i.input)) throw n;
+	let a = e.find((e) => e.action == i.action);
+	if (a == null) throw r;
+	let o = a.connectionId;
+	if (Object.hasOwn(i, "options")) {
+		if (i.options == null || typeof i.options != "object" || Array.isArray(i.options)) throw n;
+		let e = i.options, t = Object.keys(e);
+		if (t.length != 1) throw n;
+		if (typeof e.connectionId == "string" && e.connectionId.length > 0 && t[0] == "connectionId") o = e.connectionId;
+		else if (typeof e.connectionAlias == "string" && e.connectionAlias.length > 0 && t[0] == "connectionAlias") {
+			if (o = a.connections.find((t) => t.alias == e.connectionAlias)?.connectionId, o == null) throw r;
+		} else throw n;
+	}
+	if (o != null && !a.connections.some((e) => e.connectionId == o)) throw r;
+	if (o == null && a.connections.length > 0) throw Object.assign(/* @__PURE__ */ Error("Choose a Connector Connection for this Action."), { code: "connector.connection-required" });
+	return {
+		action: i.action,
+		input: i.input,
+		...o == null ? {} : { connectionId: o }
+	};
+}
 //#endregion
-export { n as currentEngineContract, i as findEngineContract, c as runtimeConformanceCases };
+export { l as createActions, n as currentEngineContract, i as findEngineContract, u as resolveAction, c as runtimeConformanceCases };

package/dist/common/scheduler.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectorCapability, JsonValue } from '../browser/flow-change.js';
+import type { ConnectorCapability, JsonValue, WaitAction } from '../browser/flow-change.js';
 import type { PreparedFlow } from './flow-semantics.js';
 import * as Effect from 'effect/Effect';
 export type SchedulerEvent = {
@@ -17,29 +17,30 @@ export type SchedulerEvent = {
     readonly inputs: Readonly<Record<string, JsonValue>>;
     readonly jobId: string;
     readonly nodeId: string;
-    readonly nodeKind: 'condition' | 'connector' | 'javascript' | 'llm' | 'subflow' | 'value';
+    readonly nodeKind: 'condition' | 'connector' | 'javascript' | 'llm' | 'subflow' | 'value' | 'wait';
     readonly nodeTitle?: string;
     readonly runId: string;
     readonly type: 'node.started';
 } | {
-    readonly handle: string;
     readonly jobId: string;
     readonly nodeId: string;
+    readonly outputs: Readonly<Record<string, JsonValue>>;
     readonly runId: string;
-    readonly type: 'node.output';
-    readonly value: JsonValue;
+    readonly type: 'node.completed';
 } | {
+    readonly code: string;
     readonly jobId: string;
+    readonly message: string;
     readonly nodeId: string;
     readonly runId: string;
-    readonly type: 'node.completed';
+    readonly type: 'node.failed';
 } | {
-    readonly code: string;
     readonly jobId: string;
+    readonly level: 'debug' | 'error' | 'info' | 'warn';
     readonly message: string;
     readonly nodeId: string;
     readonly runId: string;
-    readonly type: 'node.failed';
+    readonly type: 'node.log';
 } | {
     readonly result: FlowRunResult | SubflowRunResult;
     readonly runId: string;
@@ -52,19 +53,52 @@ export type SchedulerEvent = {
 export interface FlowRunResult {
     readonly kind: 'node-results';
     readonly nodes: readonly {
-        readonly jobs: readonly {
-            readonly jobId: string;
-            readonly outputs: Readonly<Record<string, JsonValue>>;
-        }[];
         readonly nodeId: string;
+        readonly status: 'completed';
+        readonly jobId: string;
+        readonly outputs: Readonly<Record<string, JsonValue>>;
     }[];
 }
+export interface FlowRunCheckpoint {
+    readonly bindingValues: Readonly<Record<string, string>>;
+    readonly inputs: Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
+    readonly results: Readonly<Record<string, {
+        readonly jobId: string;
+        readonly outputs: Readonly<Record<string, JsonValue>>;
+    }>>;
+    readonly skipped: readonly string[];
+    readonly version: 1;
+    readonly wait: {
+        readonly jobId: string;
+        readonly nodeId: string;
+        readonly value: JsonValue;
+        readonly waitId: string;
+    };
+}
+export type FlowRunOutcome = FlowRunResult | {
+    readonly checkpoint: FlowRunCheckpoint;
+    readonly kind: 'waiting';
+    readonly notification?: {
+        readonly input: Readonly<Record<string, JsonValue>>;
+        readonly messageHandle: string;
+        readonly taskId: string;
+    };
+    readonly wait: {
+        readonly actions: readonly ['continue'] | readonly ['approve', 'reject'];
+        readonly jobId: string;
+        readonly nodeId: string;
+        readonly waitId: string;
+    };
+};
 export interface SubflowRunResult {
     readonly kind: 'function-outputs';
     readonly outputs: Readonly<Record<string, JsonValue>>;
     readonly target: 'subflow';
 }
 interface TaskInvocationBase {
+    readonly additionalInputs: Readonly<Record<string, JsonValue>>;
+    readonly blockId: string;
+    readonly flowId: string;
     readonly input: Readonly<Record<string, JsonValue>>;
     readonly invocationId: string;
     readonly jobId: string;
@@ -93,8 +127,13 @@ export interface FlowRunOptions {
     readonly inputs?: Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
     readonly invokeTask: (invocation: TaskInvocation) => Effect.Effect<unknown, Error>;
     readonly projectFailure?: (error: unknown) => SchedulerFailure;
+    readonly resume?: {
+        readonly action: WaitAction;
+        readonly checkpoint: unknown;
+    };
     readonly runId: string;
     readonly trigger?: TriggerSeed;
 }
-export declare function runFlow(prepared: PreparedFlow, options: FlowRunOptions): Effect.Effect<FlowRunResult, Error>;
+export declare function decodeFlowRunCheckpoint(input: unknown): FlowRunCheckpoint;
+export declare function runFlow(prepared: PreparedFlow, options: FlowRunOptions): Effect.Effect<FlowRunOutcome, Error>;
 export {};