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

package/dist/common/run-events.js

@@ -1,5 +1,6 @@
 //#region src/execution/common/events.ts
 var e = new TextEncoder(), t = /* @__PURE__ */ new Set([
+	"agent",
 	"condition",
 	"connector",
 	"javascript",
@@ -106,7 +107,7 @@ function f(e, t) {
 				}
 			});
 		}
-		if (_ == "node.cache-hit" || _ == "node.preview" || _ == "run.completed" || _ == "run.failed" || _ == "run.output") {
+		if (_ == "run.completed" || _ == "run.failed") {
 			o(g);
 			return;
 		}

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

@@ -10,6 +10,8 @@ export type RunOperation = {
     readonly kind: 'wait';
 } | {
     readonly kind: 'resolve';
+} | {
+    readonly kind: 'fail-start' | 'fail-resume';
 } | {
     readonly kind: 'commit';
     readonly status: RunTerminalStatus;
@@ -72,6 +74,8 @@ 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>;

package/dist/common/run-lifecycle.js

@@ -91,6 +91,14 @@ function a(e, t) {
 			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
@@ -115,6 +123,28 @@ 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) {

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

@@ -0,0 +1,56 @@
+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;
+}
+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

@@ -36,6 +36,30 @@ 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>;

package/dist/common/scheduler.d.ts

@@ -1,5 +1,6 @@
 import type { ConnectorCapability, JsonValue, WaitAction } from '../browser/flow-change.js';
 import type { PreparedFlow } from './flow-semantics.js';
+import type { AgentCheckpoint } from './runtime-contract.js';
 import * as Effect from 'effect/Effect';
 export type SchedulerEvent = {
     readonly flowId: string;
@@ -17,7 +18,7 @@ export type SchedulerEvent = {
     readonly inputs: Readonly<Record<string, JsonValue>>;
     readonly jobId: string;
     readonly nodeId: string;
-    readonly nodeKind: 'condition' | 'connector' | 'javascript' | 'llm' | 'subflow' | 'value' | 'wait';
+    readonly nodeKind: 'agent' | 'condition' | 'connector' | 'javascript' | 'llm' | 'subflow' | 'value' | 'wait';
     readonly nodeTitle?: string;
     readonly runId: string;
     readonly type: 'node.started';
@@ -67,7 +68,14 @@ export interface FlowRunCheckpoint {
         readonly outputs: Readonly<Record<string, JsonValue>>;
     }>>;
     readonly skipped: readonly string[];
-    readonly version: 1;
+    readonly version: 2;
+    readonly queue: readonly FlowRunCheckpoint['wait'][];
+    readonly agents: Readonly<Record<string, {
+        readonly invocationId: string;
+        readonly input: Readonly<Record<string, JsonValue>>;
+        readonly remainingMs?: number;
+        readonly checkpoint: AgentCheckpoint;
+    }>>;
     readonly wait: {
         readonly jobId: string;
         readonly nodeId: string;
@@ -85,6 +93,7 @@ export type FlowRunOutcome = FlowRunResult | {
     };
     readonly wait: {
         readonly actions: readonly ['continue'] | readonly ['approve', 'reject'];
+        readonly prompt: string;
         readonly jobId: string;
         readonly nodeId: string;
         readonly waitId: string;
@@ -96,6 +105,10 @@ export interface SubflowRunResult {
     readonly target: 'subflow';
 }
 interface TaskInvocationBase {
+    readonly agent?: {
+        readonly action: 'approve' | 'reject';
+        readonly checkpoint: AgentCheckpoint;
+    };
     readonly additionalInputs: Readonly<Record<string, JsonValue>>;
     readonly blockId: string;
     readonly flowId: string;
@@ -119,21 +132,28 @@ export interface SchedulerFailure {
     readonly code: string;
     readonly message: string;
 }
-export interface FlowRunOptions {
-    readonly bindingValues?: Readonly<Record<string, string>>;
+export type FlowRunOptions = {
     readonly createId: () => string;
     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 projectFailure?: (error: unknown) => SchedulerFailure;
-    readonly resume?: {
+    readonly runId: string;
+} & RunLaunch;
+export type RunLaunch = {
+    readonly bindingValues?: Readonly<Record<string, string>>;
+    readonly inputs?: Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
+    readonly trigger: TriggerSeed;
+    readonly resume?: never;
+} | {
+    readonly resume: {
         readonly action: WaitAction;
         readonly checkpoint: unknown;
     };
-    readonly runId: string;
-    readonly trigger?: TriggerSeed;
-}
+    readonly bindingValues?: never;
+    readonly inputs?: never;
+    readonly trigger?: never;
+};
 export declare function decodeFlowRunCheckpoint(input: unknown): FlowRunCheckpoint;
 export declare function runFlow(prepared: PreparedFlow, options: FlowRunOptions): Effect.Effect<FlowRunOutcome, Error>;
 export {};