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

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

@@ -110,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");
@@ -170,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/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;
@@ -51,3 +53,9 @@ export interface RuntimeConformanceCase {
     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 }
@@ -130,30 +195,19 @@ var c = [
 		}
 	},
 	{
-		name: "submits Task outputs and accepts a void result",
+		name: "returns final outputs without exposing intermediate output capability",
 		async verify(e) {
-			let t = [];
 			o(await e.invoke({
-				capability: async (e) => (t.push(e), {
-					body: null,
-					status: 200
-				}),
+				capability: async () => {
+					throw Error("Capability must not be called.");
+				},
 				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");
+				invocationId: "final-outputs",
+				program: a(e, "export default (_input, context) => ({ available: typeof context.outputs, value: 1 })")
+			}), {
+				available: "undefined",
+				value: 1
+			}, "Final Task outputs");
 		}
 	},
 	{
@@ -162,17 +216,73 @@ var c = [
 			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

@@ -21,16 +21,10 @@ export type SchedulerEvent = {
     readonly nodeTitle?: string;
     readonly runId: string;
     readonly type: 'node.started';
-} | {
-    readonly handle: string;
-    readonly jobId: string;
-    readonly nodeId: string;
-    readonly runId: string;
-    readonly type: 'node.output';
-    readonly value: JsonValue;
 } | {
     readonly jobId: string;
     readonly nodeId: string;
+    readonly outputs: Readonly<Record<string, JsonValue>>;
     readonly runId: string;
     readonly type: 'node.completed';
 } | {
@@ -59,39 +53,24 @@ 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 buffers: Readonly<Record<string, {
-        readonly slots: Readonly<Record<string, {
-            readonly provided: boolean;
-            readonly queue: readonly JsonValue[];
-            readonly value: JsonValue;
-        }>>;
-        readonly staticTaken: boolean;
+    readonly inputs: Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
+    readonly results: Readonly<Record<string, {
+        readonly jobId: string;
+        readonly outputs: Readonly<Record<string, JsonValue>>;
     }>>;
-    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 skipped: readonly string[];
     readonly version: 1;
     readonly wait: {
         readonly jobId: string;
         readonly nodeId: string;
-        readonly order: number;
         readonly value: JsonValue;
         readonly waitId: string;
     };
@@ -108,7 +87,6 @@ export type FlowRunOutcome = FlowRunResult | {
         readonly actions: readonly ['continue'] | readonly ['approve', 'reject'];
         readonly jobId: string;
         readonly nodeId: string;
-        readonly order: number;
         readonly waitId: string;
     };
 };
@@ -147,7 +125,7 @@ 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, outputs: (value: unknown) => Effect.Effect<void, Error>) => Effect.Effect<unknown, Error>;
+    readonly invokeTask: (invocation: TaskInvocation) => Effect.Effect<unknown, Error>;
     readonly projectFailure?: (error: unknown) => SchedulerFailure;
     readonly resume?: {
         readonly action: WaitAction;
@@ -156,6 +134,6 @@ export interface FlowRunOptions {
     readonly runId: string;
     readonly trigger?: TriggerSeed;
 }
-export declare function decodeFlowRunCheckpoint(value: unknown): FlowRunCheckpoint;
+export declare function decodeFlowRunCheckpoint(input: unknown): FlowRunCheckpoint;
 export declare function runFlow(prepared: PreparedFlow, options: FlowRunOptions): Effect.Effect<FlowRunOutcome, Error>;
 export {};