@oomol-lab/open-flow 0.1.0-beta.2 → 0.1.0-beta.21

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

@@ -1,11 +1,13 @@
 //#region src/execution/common/events.ts
 var e = new TextEncoder(), t = /* @__PURE__ */ new Set([
+	"agent",
 	"condition",
 	"connector",
 	"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.`);
@@ -105,25 +107,22 @@ function f(e, t) {
 				}
 			});
 		}
-		if (_ == "node.cache-hit" || _ == "node.preview" || _ == "run.completed" || _ == "run.failed" || _ == "run.output") {
+		if (_ == "run.completed" || _ == "run.failed") {
 			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 +168,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,17 @@
 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: 'fail-start' | 'fail-resume';
 } | {
     readonly kind: 'commit';
     readonly status: RunTerminalStatus;
@@ -16,6 +22,9 @@ export type RunTransition = {
 } | {
     readonly kind: 'running';
     readonly status: 'running';
+} | {
+    readonly kind: 'waiting';
+    readonly status: 'waiting';
 } | {
     readonly kind: 'terminal';
     readonly status: RunTerminalStatus;
@@ -28,12 +37,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';
@@ -59,8 +74,12 @@ export interface RunLifecycleHarness {
     }): Promise<RunAcceptance>;
     claim(runId: string): Promise<RunClaim>;
     commit(runId: string, status: RunTerminalStatus): Promise<boolean>;
+    failStarting(runId: string): Promise<boolean>;
+    failResume(runId: string): 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,32 @@ 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 "fail-start":
+		case "fail-resume": return e == "starting" ? {
+			kind: "committed",
+			status: t.kind == "fail-start" ? "failed" : "indeterminate"
+		} : {
+			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 +123,59 @@ async function s(e, t = "request", n = "request-a") {
 	return r.runId;
 }
 var c = [
+	{
+		name: "rejects startup failures outside the start barrier and preserves their terminal",
+		async verify(e) {
+			for (let t of ["failStarting", "failResume"]) {
+				let n = await s(e, t);
+				o(await e[t](n), !1, "Failure before claim"), await e.claim(n), o(await e.commit(n, "completed"), !1, "Completion before start"), o(await e[t](n), !0, "Startup failure");
+				let r = t == "failStarting" ? "failed" : "indeterminate";
+				o(await e.observe(n), {
+					status: r,
+					terminalEvents: [r]
+				}, "Startup terminal"), o(await e[t](n), !1, "Repeated startup failure"), o(await e.start(n), {
+					kind: "stale",
+					status: r
+				}, "Start after failure"), o(await e.commit(n, "canceled"), !1, "Cancellation after failure");
+			}
+			let t = await s(e, "running");
+			await e.claim(t), await e.start(t), o(await e.failStarting(t), !1, "Startup failure after start"), o(await e.failResume(t), !1, "Resume failure after start"), o(await e.observe(t), {
+				status: "running",
+				terminalEvents: []
+			}, "Running observation");
+		}
+	},
+	{
+		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/run-results.d.ts

@@ -0,0 +1,57 @@
+import type { JsonValue } from '../browser/flow-change.js';
+export type ResultCall = {
+    readonly id: string;
+    readonly kind: 'connector';
+    readonly action: string;
+    readonly connectionId?: string;
+} | {
+    readonly id: string;
+    readonly kind: 'code';
+};
+export interface ResultInfo {
+    readonly resultId: string;
+    readonly callId: string;
+    readonly toolId: string;
+    readonly source: {
+        readonly kind: 'connector';
+        readonly action: string;
+    } | {
+        readonly kind: 'code';
+    };
+    readonly bytes: number;
+    readonly digest: string;
+    readonly createdAt: string;
+}
+interface ResultEntry {
+    readonly pointer: string;
+    readonly type: 'object' | 'array' | 'string' | 'number' | 'boolean' | 'null';
+    readonly length?: number;
+    readonly complete: boolean;
+    readonly value?: JsonValue;
+}
+export interface ResultPage extends ResultEntry {
+    readonly offset: number;
+    readonly nextOffset?: number;
+    readonly entries?: readonly ResultEntry[];
+}
+export interface ResultQuery {
+    readonly pointer?: string;
+    readonly offset?: number;
+    readonly limit?: number;
+    readonly maxBytes?: number;
+}
+export declare function parseResultQuery(value: unknown): Required<ResultQuery>;
+export declare function decodeResultList(value: unknown): {
+    readonly version: 1;
+    readonly runId: string;
+    readonly results: readonly ResultInfo[];
+    readonly nextAfter?: string;
+};
+export declare function decodeResultRead(value: unknown): {
+    readonly version: 1;
+    readonly runId: string;
+    readonly result: ResultInfo;
+    readonly page: ResultPage;
+};
+export declare function readResult(value: JsonValue, query?: ResultQuery): ResultPage;
+export {};

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

@@ -1,6 +1,7 @@
-import type { CodeModule, JsonValue } from '../browser/flow-change.js';
-export { currentEngineContract, findEngineContract, type EngineContract } from './engine-contract.js';
+import type { CodeModule, ConnectorCapability, JsonValue } from '../browser/flow-change.js';
+export { currentEngineContract, nodejsEngineContract, findEngineContract, type EngineContract } from './engine-contract.js';
 export type RuntimeModule = Pick<CodeModule, 'imports' | 'source'>;
+export declare const nodejsRuntimeConformanceCases: readonly RuntimeConformanceCase[];
 export interface RuntimeProgram {
     readonly engineContract: string;
     readonly engineDigest: string;
@@ -8,6 +9,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;
@@ -35,7 +37,32 @@ export type LlmTaskResult = {
     readonly version: 1;
 };
 export type InvokeLlmTask = (invocation: LlmTaskInvocation) => Promise<LlmTaskResult>;
+export interface AgentCheckpoint {
+    readonly state: JsonValue;
+    readonly callId: string;
+    readonly toolId: string;
+    readonly input: Readonly<Record<string, JsonValue>>;
+    readonly rounds: number;
+    readonly version: 1;
+}
+export type AgentResult = {
+    readonly kind: 'completed';
+    readonly output: JsonValue;
+} | {
+    readonly kind: 'suspended';
+    readonly checkpoint: AgentCheckpoint;
+};
+export interface AgentInvocation {
+    readonly input: Readonly<Record<string, JsonValue>>;
+    readonly invocationId: string;
+    readonly signal: AbortSignal;
+    readonly resume?: {
+        readonly action: 'approve' | 'reject';
+        readonly checkpoint: AgentCheckpoint;
+    };
+}
 export interface RuntimeInvocation {
+    readonly capabilities?: readonly ConnectorCapability[];
     readonly capability: (call: RuntimeCapabilityCall) => Promise<RuntimeCapabilityResponse>;
     readonly input: JsonValue;
     readonly invocationId: string;
@@ -44,10 +71,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>>;
+};