@oomol-lab/open-flow 0.1.0-beta.70 → 0.1.0-beta.72

package/dist/common/scheduler-checkpoint.d.ts

@@ -0,0 +1,42 @@
+import type { Graph, JsonValue } from '../browser/flow-change.js';
+import type { DependenciesCheckpoint } from './scheduler-dependencies.js';
+import type { ExecutableNode } from './scheduler-node-execution.js';
+import type { AgentCheckpoint } from './runtime-contract.js';
+export interface PendingWait {
+    readonly jobId: string;
+    readonly nodeId: string;
+    readonly value: JsonValue;
+    readonly waitId: string;
+    readonly pending?: JsonValue;
+}
+export interface PendingWorkflowCall {
+    readonly jobId: string;
+    readonly nodeId: string;
+    readonly childRunId: string;
+    readonly input: Readonly<Record<string, JsonValue>>;
+}
+export interface FlowRunCheckpoint {
+    readonly calls?: readonly PendingWorkflowCall[];
+    readonly bindingValues: Readonly<Record<string, string>>;
+    readonly inputs: Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
+    readonly results: Readonly<Record<string, {
+        readonly handled?: true;
+        readonly jobId: string;
+        readonly outputs: Readonly<Record<string, JsonValue>>;
+        readonly systemOutputs?: Readonly<Record<string, JsonValue>>;
+    }>>;
+    readonly counts: Readonly<Record<string, Readonly<Record<string, number>>>>;
+    readonly dependencies: DependenciesCheckpoint;
+    readonly version: 6;
+    readonly waits: readonly PendingWait[];
+    readonly agents: Readonly<Record<string, {
+        readonly invocationId: string;
+        readonly input: Readonly<Record<string, JsonValue>>;
+        readonly remainingMs?: number;
+        readonly checkpoint: AgentCheckpoint;
+    }>>;
+}
+export declare function decodeFlowRunCheckpoint(input: unknown): FlowRunCheckpoint;
+export declare function validateCheckpoint(target: {
+    readonly graph: Graph;
+}, checkpoint: FlowRunCheckpoint, resolveInputs: (nodeId: string, node: ExecutableNode) => Readonly<Record<string, JsonValue>>): void;

package/dist/common/scheduler-dependencies.d.ts

@@ -0,0 +1,80 @@
+import type { Graph, JsonValue } from '../browser/flow-change.js';
+import { z } from 'zod';
+export interface DependenciesCheckpoint {
+    nextId: number;
+    iterations: Record<string, number>;
+    nodes: Record<string, DependencyState>;
+}
+interface DependencyState {
+    id: number;
+    status: 'pending' | 'running' | 'completed' | 'skipped';
+    input: Record<string, {
+        readonly execution: number;
+        readonly outputs: Readonly<Record<string, JsonValue>>;
+        readonly systemOutputs?: Readonly<Record<string, JsonValue>>;
+    }>;
+    systemOutputs?: Readonly<Record<string, JsonValue>>;
+    output?: Readonly<Record<string, JsonValue>>;
+    previous: string[];
+    released: string[];
+    jobId?: string;
+    seeded: boolean;
+}
+type InputSnapshot = DependenciesCheckpoint['nodes'][string]['input'];
+export declare function dependencyValues(input: InputSnapshot): Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
+export declare const dependenciesSchema: z.ZodObject<{
+    nextId: z.ZodNumber;
+    iterations: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    nodes: z.ZodRecord<z.ZodString, z.ZodObject<{
+        id: z.ZodNumber;
+        status: z.ZodEnum<{
+            completed: "completed";
+            pending: "pending";
+            running: "running";
+            skipped: "skipped";
+        }>;
+        input: z.ZodRecord<z.ZodString, z.ZodObject<{
+            execution: z.ZodNumber;
+            outputs: z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>;
+            systemOutputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+        }, z.core.$strict>>;
+        output: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+        systemOutputs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<JsonValue, unknown, z.core.$ZodTypeInternals<JsonValue, unknown>>>>;
+        previous: z.ZodArray<z.ZodString>;
+        released: z.ZodArray<z.ZodString>;
+        jobId: z.ZodOptional<z.ZodString>;
+        seeded: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Dependency completion belongs to an invocation, never to a Run-wide latest-result table. */
+export declare class Dependencies {
+    readonly state: DependenciesCheckpoint;
+    private readonly forward;
+    private readonly loops;
+    private readonly innerLoopsFirst;
+    private readonly outgoing;
+    private readonly incoming;
+    private readonly candidates;
+    private readonly frames;
+    private readonly graph;
+    constructor(graph: Graph, saved?: DependenciesCheckpoint);
+    private fresh;
+    private validate;
+    start(nodeId: string, outputs: Readonly<Record<string, JsonValue>>): void;
+    private edge;
+    private edgeResult;
+    input(nodeId: string, sourceId: string): InputSnapshot[string] | undefined;
+    private snapshot;
+    private collectInputs;
+    private loopSettled;
+    private blockedByLoop;
+    private continuationPending;
+    private selectedIncoming;
+    private readyAcyclic;
+    /** Resolve skips and iteration boundaries before admitting another invocation. */
+    ready(): string[];
+    begin(nodeId: string, jobId: string): void;
+    release(nodeId: string, outputs: Readonly<Record<string, JsonValue>>, handles: readonly string[], complete: boolean, systemOutputs?: Readonly<Record<string, JsonValue>>): void;
+    get incomplete(): boolean;
+}
+export {};

package/dist/common/scheduler-node-execution.d.ts

@@ -0,0 +1,75 @@
+import type { AgentConfig } from './flow-agent.js';
+import type { Graph, GraphNode, JsonValue, TriggerNode } from '../browser/flow-change.js';
+import type { WebhookResponseSnapshot } from './webhook-response.js';
+import type { FlowRunCheckpoint } from './scheduler-checkpoint.js';
+import type { Dependencies } from './scheduler-dependencies.js';
+import type { AgentCheckpoint } from './runtime-contract.js';
+import type { FlowRunOptions, SchedulerEvent, SchedulerFailure } from './scheduler.js';
+import * as Effect from 'effect/Effect';
+import { z } from 'zod';
+interface NodeExecutionContext {
+    readonly createId: FlowRunOptions['createId'];
+    readonly emit: (event: SchedulerEvent) => Effect.Effect<void, Error>;
+    readonly invokeTask: FlowRunOptions['invokeTask'];
+    readonly projectFailure: FlowRunOptions['projectFailure'];
+}
+export declare class PortValidationError extends Error {
+}
+export type ExecutableNode = Exclude<GraphNode, TriggerNode>;
+export declare function usesPending(graph: Graph, nodeId: string): boolean;
+export declare class NodeValidationError extends PortValidationError {
+    readonly code: 'node.input-invalid' | 'node.output-invalid' | 'webhook.response-status-invalid' | 'webhook.response-headers-invalid';
+    constructor(code: NodeValidationError['code'], error: unknown);
+}
+export declare function nodeFailure(error: unknown, project: FlowRunOptions['projectFailure']): SchedulerFailure;
+export declare function nodeTitle(node: GraphNode): string | undefined;
+export declare function jsonValue(value: unknown, description: string, depth?: number): JsonValue;
+export declare const agentCheckpointSchema: z.ZodObject<{
+    state: z.ZodJSONSchema;
+    callId: z.ZodString;
+    toolId: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    rounds: z.ZodNumber;
+    version: z.ZodLiteral<1>;
+}, z.core.$strict>;
+export declare function jsonEqual(left: JsonValue, right: JsonValue): boolean;
+export declare function outputRecord(value: unknown, nodeId: string): Readonly<Record<string, JsonValue>>;
+export declare function agentConfig(node: ExecutableNode): AgentConfig | undefined;
+export declare function agentNotice(node: ExecutableNode, values: Readonly<Record<string, JsonValue>>): {
+    messageHandle: string;
+    input: {
+        [k: string]: JsonValue;
+    };
+} | undefined;
+export declare function agentApproval(config: AgentConfig, checkpoint: AgentCheckpoint, inputs: Readonly<Record<string, JsonValue>>): JsonValue;
+export declare function validateOutputs(nodeId: string, node: ExecutableNode, value: unknown): Readonly<Record<string, JsonValue>>;
+export type NodeResult = {
+    readonly kind: 'calling';
+    readonly childRunId: string;
+    readonly input: Readonly<Record<string, JsonValue>>;
+} | {
+    readonly kind: 'completed';
+    readonly releasedHandles?: readonly string[];
+    readonly outputs: Readonly<Record<string, JsonValue>>;
+    readonly response?: WebhookResponseSnapshot;
+} | {
+    readonly kind: 'suspended';
+    readonly value: JsonValue;
+    readonly agent: FlowRunCheckpoint['agents'][string];
+};
+export declare function resolveNodeInputs(nodeId: string, node: ExecutableNode, dependencies: Pick<Dependencies, 'input'>, bindingValues: Readonly<Record<string, string>>, launchInputs?: Readonly<Record<string, JsonValue>>): Readonly<Record<string, JsonValue>>;
+export declare function executeNode(context: NodeExecutionContext, input: {
+    readonly nodeId: string;
+    readonly node: ExecutableNode;
+    readonly jobId: string;
+    readonly nodeInputs: Readonly<Record<string, JsonValue>>;
+    readonly flowId: string;
+    readonly runId: string;
+    readonly graph: Graph;
+    readonly dependencies: Pick<Dependencies, 'input'>;
+    readonly previousIds: readonly string[];
+    readonly saved?: FlowRunCheckpoint['agents'][string];
+    readonly workflowRunId?: string;
+    readonly resolution?: 'approve' | 'reject';
+}): Effect.Effect<NodeResult, Error>;
+export {};

package/dist/common/scheduler.d.ts

@@ -2,8 +2,13 @@ import type { ConnectorCapability, JsonValue, WaitAction, WaitAutoContinue } fro
 import type { PreparedFlow } from './flow-semantics.js';
 import type { WebhookResponseSnapshot } from './webhook-response.js';
 import type { PreviousNode } from '../index.js';
+import type { FlowRunCheckpoint } from './scheduler-checkpoint.js';
 import type { AgentCheckpoint } from './runtime-contract.js';
 import * as Effect from 'effect/Effect';
+export type { DependenciesCheckpoint } from './scheduler-dependencies.js';
+export type { FlowRunCheckpoint, PendingWait, PendingWorkflowCall } from './scheduler-checkpoint.js';
+export { decodeFlowRunCheckpoint } from './scheduler-checkpoint.js';
+export { PortValidationError } from './scheduler-node-execution.js';
 export declare const withWaitNotificationMessage: (value: JsonValue) => JsonValue;
 export declare const normalizeWaitComment: (value?: string | null) => string | null;
 export declare const waitAutoContinueAt: (config: WaitAutoContinue, waitingSince: number) => number;
@@ -12,8 +17,6 @@ export interface WaitResolution {
     readonly resolvedAt: string;
     readonly comment: string | null;
 }
-export declare class PortValidationError extends Error {
-}
 export type SchedulerEvent = {
     readonly flowId: string;
     readonly parentJobId?: string;
@@ -81,13 +84,6 @@ export interface FlowRunResult {
         readonly outputs: Readonly<Record<string, JsonValue>>;
     }[];
 }
-export interface PendingWait {
-    readonly jobId: string;
-    readonly nodeId: string;
-    readonly value: JsonValue;
-    readonly waitId: string;
-    readonly pending?: JsonValue;
-}
 export interface WaitRequest {
     readonly autoContinue?: WaitAutoContinue;
     readonly jobId: string;
@@ -115,53 +111,6 @@ export interface WaitHost {
     readonly resolutions: (waitIds: readonly string[], block: boolean) => Effect.Effect<Readonly<Record<string, WaitResolution>>, Error>;
 }
 export declare const waitRetentionMs = 120000;
-export interface DependenciesCheckpoint {
-    nextId: number;
-    iterations: Record<string, number>;
-    nodes: Record<string, DependencyState>;
-}
-interface DependencyState {
-    id: number;
-    status: 'pending' | 'running' | 'completed' | 'skipped';
-    input: Record<string, {
-        readonly execution: number;
-        readonly outputs: Readonly<Record<string, JsonValue>>;
-        readonly systemOutputs?: Readonly<Record<string, JsonValue>>;
-    }>;
-    systemOutputs?: Readonly<Record<string, JsonValue>>;
-    output?: Readonly<Record<string, JsonValue>>;
-    previous: string[];
-    released: string[];
-    jobId?: string;
-    seeded: boolean;
-}
-export interface PendingWorkflowCall {
-    readonly jobId: string;
-    readonly nodeId: string;
-    readonly childRunId: string;
-    readonly input: Readonly<Record<string, JsonValue>>;
-}
-export interface FlowRunCheckpoint {
-    readonly calls?: readonly PendingWorkflowCall[];
-    readonly bindingValues: Readonly<Record<string, string>>;
-    readonly inputs: Readonly<Record<string, Readonly<Record<string, JsonValue>>>>;
-    readonly results: Readonly<Record<string, {
-        readonly handled?: true;
-        readonly jobId: string;
-        readonly outputs: Readonly<Record<string, JsonValue>>;
-        readonly systemOutputs?: Readonly<Record<string, JsonValue>>;
-    }>>;
-    readonly counts: Readonly<Record<string, Readonly<Record<string, number>>>>;
-    readonly dependencies: DependenciesCheckpoint;
-    readonly version: 6;
-    readonly waits: readonly PendingWait[];
-    readonly agents: Readonly<Record<string, {
-        readonly invocationId: string;
-        readonly input: Readonly<Record<string, JsonValue>>;
-        readonly remainingMs?: number;
-        readonly checkpoint: AgentCheckpoint;
-    }>>;
-}
 export type FlowRunOutcome = FlowRunResult | {
     readonly checkpoint: FlowRunCheckpoint;
     readonly kind: 'waiting';
@@ -223,6 +172,4 @@ export type RunLaunch = {
     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 {};