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

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

@@ -48,6 +48,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.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.`);

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

@@ -44,7 +44,7 @@ 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;

package/dist/common/runtime-contract.js

@@ -129,6 +129,33 @@ var c = [
 			}], "Capability request");
 		}
 	},
+	{
+		name: "submits Task outputs and accepts a void result",
+		async verify(e) {
+			let t = [];
+			o(await e.invoke({
+				capability: async (e) => (t.push(e), {
+					body: null,
+					status: 200
+				}),
+				input: null,
+				invocationId: "task-outputs",
+				program: a(e, "export default async (_input, context) => {\n  await context.outputs({ first: 1 })\n  await context.outputs({ second: 2 })\n}")
+			}), void 0, "Void Task result"), o(t.map(({ invocationId: e, kind: t, payload: n }) => ({
+				invocationId: e,
+				kind: t,
+				payload: n
+			})), [{
+				invocationId: "task-outputs",
+				kind: "outputs",
+				payload: { first: 1 }
+			}, {
+				invocationId: "task-outputs",
+				kind: "outputs",
+				payload: { second: 2 }
+			}], "Task outputs request");
+		}
+	},
 	{
 		name: "cancels a pending Capability and the user invocation",
 		async verify(e) {

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,7 +17,7 @@ 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';
@@ -40,6 +40,13 @@ export type SchedulerEvent = {
     readonly nodeId: string;
     readonly runId: string;
     readonly type: 'node.failed';
+} | {
+    readonly jobId: string;
+    readonly level: 'debug' | 'error' | 'info' | 'warn';
+    readonly message: string;
+    readonly nodeId: string;
+    readonly runId: string;
+    readonly type: 'node.log';
 } | {
     readonly result: FlowRunResult | SubflowRunResult;
     readonly runId: string;
@@ -59,12 +66,61 @@ export interface FlowRunResult {
         readonly nodeId: string;
     }[];
 }
+export interface FlowRunCheckpoint {
+    readonly bindingValues: Readonly<Record<string, string>>;
+    readonly buffers: Readonly<Record<string, {
+        readonly slots: Readonly<Record<string, {
+            readonly provided: boolean;
+            readonly queue: readonly JsonValue[];
+            readonly value: JsonValue;
+        }>>;
+        readonly staticTaken: boolean;
+    }>>;
+    readonly completedNodes: readonly string[];
+    readonly nextJobs: Readonly<Record<string, number>>;
+    readonly outputs: Readonly<Record<string, JsonValue>>;
+    readonly results: readonly {
+        readonly jobs: readonly {
+            readonly jobId: string;
+            readonly order: number;
+            readonly outputs: Readonly<Record<string, JsonValue>>;
+        }[];
+        readonly nodeId: string;
+    }[];
+    readonly version: 1;
+    readonly wait: {
+        readonly jobId: string;
+        readonly nodeId: string;
+        readonly order: number;
+        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 order: number;
+        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;
@@ -91,10 +147,15 @@ export interface FlowRunOptions {
     readonly emit?: (event: SchedulerEvent) => Effect.Effect<void, Error>;
     readonly flowId: string;
     readonly inputs?: Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
-    readonly invokeTask: (invocation: TaskInvocation) => Effect.Effect<unknown, Error>;
+    readonly invokeTask: (invocation: TaskInvocation, outputs: (value: unknown) => Effect.Effect<void, Error>) => 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(value: unknown): FlowRunCheckpoint;
+export declare function runFlow(prepared: PreparedFlow, options: FlowRunOptions): Effect.Effect<FlowRunOutcome, Error>;
 export {};