@oomol-lab/open-flow 0.1.0-beta.55 → 0.1.0-beta.57

package/dist/browser/flow-change-schema.d.ts

@@ -1,5 +1,271 @@
 import type { ChangeOperation, FlowDocument, JsonValue, RevisionContent } from './flow-change.js';
-export declare const currentFlowModelVersion = 5;
+import { z } from 'zod';
+export declare const currentFlowModelVersion = 6;
+/** Configuration schemas shared by the node authoring boundary. */
+export declare const authoringDefinitionSchemas: {
+    input: z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        jsonSchema: z.ZodJSONSchema;
+        nullable: z.ZodBoolean;
+        handle: z.ZodString;
+        value: z.ZodOptional<z.ZodJSONSchema>;
+    }, z.core.$strip>;
+    port: z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        jsonSchema: z.ZodJSONSchema;
+        nullable: z.ZodBoolean;
+        handle: z.ZodString;
+    }, z.core.$strip>;
+    ports: {
+        inputs: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            jsonSchema: z.ZodJSONSchema;
+            nullable: z.ZodBoolean;
+            handle: z.ZodString;
+            value: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strip>, z.ZodObject<{
+            collapsed: z.ZodOptional<z.ZodBoolean>;
+            group: z.ZodString;
+        }, z.core.$strip>]>>;
+        outputs: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            jsonSchema: z.ZodJSONSchema;
+            nullable: z.ZodBoolean;
+            handle: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            collapsed: z.ZodOptional<z.ZodBoolean>;
+            group: z.ZodString;
+        }, z.core.$strip>]>>;
+    };
+    condition: z.ZodObject<{
+        matchMode: z.ZodEnum<{
+            all: "all";
+            first: "first";
+        }>;
+        cases: z.ZodArray<z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            output: z.ZodString;
+            groups: z.ZodArray<z.ZodObject<{
+                expressions: z.ZodArray<z.ZodObject<{
+                    left: z.ZodUnion<readonly [z.ZodObject<{
+                        kind: z.ZodLiteral<"value">;
+                        value: z.ZodOptional<z.ZodJSONSchema>;
+                        jsonSchema: z.ZodOptional<z.ZodJSONSchema>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"source">;
+                        source: z.ZodUnion<readonly [z.ZodObject<{
+                            kind: z.ZodLiteral<"node">;
+                            nodeId: z.ZodString;
+                            output: z.ZodString;
+                            field: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            kind: z.ZodLiteral<"binding">;
+                            bindingId: z.ZodString;
+                        }, z.core.$strip>]>;
+                    }, z.core.$strip>]>;
+                    operator: z.ZodEnum<{
+                        "!=": "!=";
+                        "<": "<";
+                        "<=": "<=";
+                        "==": "==";
+                        ">": ">";
+                        ">=": ">=";
+                        contains: "contains";
+                        endsWith: "endsWith";
+                        hasKey: "hasKey";
+                        hasValue: "hasValue";
+                        isEmpty: "isEmpty";
+                        isFalse: "isFalse";
+                        isNotEmpty: "isNotEmpty";
+                        isNotNull: "isNotNull";
+                        isNull: "isNull";
+                        isTrue: "isTrue";
+                        notContains: "notContains";
+                        notHasKey: "notHasKey";
+                        notHasValue: "notHasValue";
+                        startsWith: "startsWith";
+                    }>;
+                    right: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                        kind: z.ZodLiteral<"value">;
+                        value: z.ZodOptional<z.ZodJSONSchema>;
+                        jsonSchema: z.ZodOptional<z.ZodJSONSchema>;
+                    }, z.core.$strip>, z.ZodObject<{
+                        kind: z.ZodLiteral<"source">;
+                        source: z.ZodUnion<readonly [z.ZodObject<{
+                            kind: z.ZodLiteral<"node">;
+                            nodeId: z.ZodString;
+                            output: z.ZodString;
+                            field: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>, z.ZodObject<{
+                            kind: z.ZodLiteral<"binding">;
+                            bindingId: z.ZodString;
+                        }, z.core.$strip>]>;
+                    }, z.core.$strip>]>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>;
+    wait: z.ZodObject<{
+        inputDefinitions: z.ZodArray<z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            jsonSchema: z.ZodJSONSchema;
+            nullable: z.ZodBoolean;
+            handle: z.ZodString;
+            value: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strip>>;
+        prompt: z.ZodString;
+    }, z.core.$strict>;
+    webhook: z.ZodObject<{
+        bodyFields: z.ZodArray<z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            jsonSchema: z.ZodJSONSchema;
+            nullable: z.ZodBoolean;
+            handle: z.ZodString;
+            value: z.ZodOptional<z.ZodJSONSchema>;
+        }, z.core.$strip>>;
+        method: z.ZodEnum<{
+            DELETE: "DELETE";
+            GET: "GET";
+            PATCH: "PATCH";
+            POST: "POST";
+            PUT: "PUT";
+        }>;
+        options: z.ZodOptional<z.ZodObject<{
+            allowedMethods: z.ZodOptional<z.ZodNever>;
+            allowedOrigins: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            noResponseBody: z.ZodOptional<z.ZodNever>;
+            responseData: z.ZodOptional<z.ZodString>;
+            responseHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            responseStatusCode: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>;
+    schedule: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"cron">;
+        expression: z.ZodString;
+        timezone: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"every">;
+        unit: z.ZodEnum<{
+            day: "day";
+            hour: "hour";
+            minute: "minute";
+            month: "month";
+            week: "week";
+        }>;
+        value: z.ZodNumber;
+    }, z.core.$strip>]>>;
+    capabilities: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"connector">;
+        action: z.ZodString;
+        connectionId: z.ZodOptional<z.ZodString>;
+        connections: z.ZodArray<z.ZodObject<{
+            connectionId: z.ZodString;
+            alias: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"connector">;
+        mode: z.ZodLiteral<"shared">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"connector">;
+        mode: z.ZodLiteral<"independent">;
+        actions: z.ZodArray<z.ZodObject<{
+            action: z.ZodString;
+            connectionId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"connector">;
+        actionHints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        connectionHints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            action: z.ZodString;
+            connectionId: z.ZodString;
+            alias: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>]>>;
+    connector: z.ZodObject<{
+        action: z.ZodString;
+        connectionId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    openapi: z.ZodObject<{
+        sourceUrl: z.ZodString;
+        method: z.ZodString;
+        path: z.ZodString;
+        serverUrl: z.ZodString;
+        document: z.ZodJSONSchema;
+        auth: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodEnum<{
+                apiKey: "apiKey";
+                basic: "basic";
+                bearer: "bearer";
+            }>;
+            name: z.ZodOptional<z.ZodString>;
+            in: z.ZodOptional<z.ZodEnum<{
+                header: "header";
+                query: "query";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>;
+    decision: z.ZodObject<{
+        questions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            name: z.ZodString;
+            instructions: z.ZodString;
+            type: z.ZodLiteral<"noul">;
+            criteria: z.ZodOptional<z.ZodObject<{
+                true: z.ZodOptional<z.ZodString>;
+                false: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            name: z.ZodString;
+            instructions: z.ZodString;
+            type: z.ZodLiteral<"choice">;
+            criteria: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>, z.ZodObject<{
+            name: z.ZodString;
+            instructions: z.ZodString;
+            type: z.ZodLiteral<"score">;
+            criteria: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>], "type">>;
+    }, z.core.$strict>;
+    llm: z.ZodObject<{
+        mode: z.ZodEnum<{
+            chat: "chat";
+            json: "json";
+        }>;
+    }, z.core.$strict>;
+    agent: z.ZodObject<{
+        code: z.ZodOptional<z.ZodBoolean>;
+        model: z.ZodString;
+        prompt: z.ZodString;
+        maxRounds: z.ZodNumber;
+        tools: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodString;
+            action: z.ZodString;
+            connectionId: z.ZodOptional<z.ZodString>;
+            approval: z.ZodBoolean;
+            inputs: z.ZodArray<z.ZodObject<{
+                description: z.ZodOptional<z.ZodString>;
+                jsonSchema: z.ZodJSONSchema;
+                nullable: z.ZodBoolean;
+                handle: z.ZodString;
+                value: z.ZodOptional<z.ZodJSONSchema>;
+                source: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodLiteral<"value">;
+                    value: z.ZodJSONSchema;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"input">;
+                    input: z.ZodString;
+                }, z.core.$strip>]>, z.ZodObject<{
+                    kind: z.ZodLiteral<"model">;
+                }, z.core.$strip>]>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>;
+};
 /** Best-effort recovery for a parseable Revision envelope. Invalid collection entries are discarded. */
 export declare function repairRevisionEnvelope(value: unknown): RevisionContent;
 export declare function decodeFlowDocument(value: unknown): FlowDocument;

package/dist/browser/flow-change.d.ts

@@ -40,10 +40,6 @@ export interface NodeSource {
     readonly nodeId: string;
     readonly output: string;
 }
-export interface FlowSource {
-    readonly input: string;
-    readonly kind: 'flow';
-}
 export interface BindingSource {
     readonly bindingId: string;
     readonly kind: 'binding';
@@ -57,11 +53,8 @@ export type FixedInputValue = {
 export type InputValues = Readonly<Record<string, FixedInputValue>>;
 export type InputMapping = FixedInputValue | {
     readonly kind: 'sources';
-    readonly sources: readonly (BindingSource | FlowSource | NodeSource)[];
+    readonly sources: readonly (BindingSource | NodeSource)[];
 };
-export interface OutputMapping {
-    readonly sources: readonly (FlowSource | NodeSource)[];
-}
 interface GraphNodeBase {
     readonly description?: string;
     readonly icon?: string;
@@ -70,10 +63,6 @@ interface GraphNodeBase {
     readonly maxExecutions?: number;
     readonly timeoutMs?: number;
 }
-export interface SubflowNode extends GraphNodeBase {
-    readonly kind: 'subflow';
-    readonly subflowId: string;
-}
 export interface ValueNode extends GraphNodeBase {
     readonly kind: 'value';
     readonly values: readonly InputPort[];
@@ -92,7 +81,7 @@ export interface ApprovalNode extends ResolutionNodeBase {
 }
 export type ResolutionNode = ApprovalNode | WaitNode;
 export type ConditionOperator = '!=' | '<' | '<=' | '==' | '>' | '>=' | 'contains' | 'endsWith' | 'hasKey' | 'hasValue' | 'isEmpty' | 'isFalse' | 'isNotEmpty' | 'isNotNull' | 'isNull' | 'isTrue' | 'notContains' | 'notHasKey' | 'notHasValue' | 'startsWith';
-export type Source = BindingSource | FlowSource | NodeSource;
+export type Source = BindingSource | NodeSource;
 export type ConditionOperand = {
     readonly kind: 'value';
     readonly value?: JsonValue;
@@ -134,7 +123,9 @@ export type ManagedTaskExecutor = import('../common/decision.js').DecisionExecut
     readonly maxRounds: number;
     readonly tools: readonly AgentTool[];
     readonly notification?: {
-        readonly taskId: string;
+        readonly action: string;
+        readonly connectionId?: string;
+        readonly inputDefinitions: readonly InputPort[];
         readonly messageHandle: string;
         readonly inputs: Readonly<Record<string, Exclude<AgentInput, {
             readonly kind: 'model';
@@ -205,17 +196,11 @@ export interface ManagedTaskDefinition extends TaskDefinitionBase {
     readonly executor: ManagedTaskExecutor;
 }
 export type TaskDefinition = InlineTaskDefinition | ManagedTaskDefinition;
-export type TaskNode = GraphNodeBase & {
+export interface TaskNode extends GraphNodeBase {
     readonly kind: 'task';
-} & ({
-    readonly additionalInputs?: readonly InputPort[];
-    readonly task: InlineTaskDefinition;
-    readonly taskId?: never;
-} | {
     readonly additionalInputs?: readonly InputPort[];
-    readonly task?: never;
-    readonly taskId: string;
-});
+    readonly task: TaskDefinition;
+}
 export interface Graph {
     readonly edges: readonly GraphEdge[];
     readonly nodes: Readonly<Record<string, GraphNode>>;
@@ -298,20 +283,13 @@ export type TriggerNode = (TriggerNodeBase & {
     };
     readonly kind: 'integration';
 });
-export type GraphNode = ApprovalNode | ConditionNode | SubflowNode | TaskNode | TriggerNode | ValueNode | WaitNode;
+export type GraphNode = ApprovalNode | ConditionNode | TaskNode | TriggerNode | ValueNode | WaitNode;
 export interface FlowDocument {
     readonly bindings: Readonly<Record<string, {
         readonly kind: 'variable';
         readonly target: string;
     }>>;
     readonly graph: Graph;
-    readonly subflows: Readonly<Record<string, {
-        readonly graph: Graph;
-        readonly inputs: readonly InputPort[];
-        readonly name: string;
-        readonly outputs: readonly (OutputMapping & Port)[];
-    }>>;
-    readonly tasks: Readonly<Record<string, ManagedTaskDefinition>>;
 }
 export interface CodeModule {
     readonly imports: readonly string[];
@@ -320,15 +298,9 @@ export interface CodeModule {
 }
 export interface RevisionContent {
     readonly document: FlowDocument;
-    readonly modelVersion: 2 | 4 | typeof currentFlowModelVersion;
+    readonly modelVersion: 2 | 4 | 5 | typeof currentFlowModelVersion;
     readonly modules: Readonly<Record<string, CodeModule>>;
 }
-export type GraphTarget = {
-    readonly kind: 'flow';
-} | {
-    readonly id: string;
-    readonly kind: 'subflow';
-};
 export interface GraphEdge {
     readonly source: string;
     readonly sourceHandle?: string;
@@ -338,10 +310,14 @@ export declare function normalizeNodeName(value: string): string;
 export declare function nextNodeName(value: string, names: Iterable<string>): string;
 export declare function nodeNameIssue(graph: Graph, nodeId: string, value: string): 'duplicate' | 'empty' | undefined;
 export type ChangeOperation = {
+    readonly kind: 'graph.node.replace';
+    readonly nodeId: string;
+    readonly before: GraphNode;
+    readonly node: GraphNode;
+} | {
     readonly before?: readonly ConnectorCapability[];
     readonly kind: 'graph.node.task.capabilities.set';
     readonly nodeId: string;
-    readonly target: GraphTarget;
     readonly value?: readonly ConnectorCapability[];
 } | {
     readonly kind: 'graph.trigger.sources.set';
@@ -363,71 +339,57 @@ export type ChangeOperation = {
 } | {
     readonly kind: 'graph.edge.connect';
     readonly edge: GraphEdge;
-    readonly target: GraphTarget;
 } | {
     readonly kind: 'graph.edge.disconnect';
     readonly edge: GraphEdge;
-    readonly target: GraphTarget;
 } | {
     readonly before?: readonly InputPort[];
     readonly kind: 'graph.node.additional-inputs.set';
     readonly nodeId: string;
-    readonly target: GraphTarget;
     readonly value?: readonly InputPort[];
 } | {
     readonly before: Pick<ConditionNode, 'cases' | 'matchMode'>;
     readonly kind: 'graph.node.condition.set';
     readonly nodeId: string;
-    readonly target: GraphTarget;
     readonly value: Pick<ConditionNode, 'cases' | 'matchMode'>;
 } | {
     readonly kind: 'graph.node.create';
     readonly node: GraphNode;
     readonly nodeId: string;
-    readonly target: GraphTarget;
 } | {
     readonly kind: 'graph.node.delete';
     readonly nodeId: string;
-    readonly target: GraphTarget;
 } | {
     readonly before?: number | string;
     readonly field: 'connectionId' | 'description' | 'icon' | 'maxExecutions' | 'name' | 'timeoutMs';
     readonly kind: 'graph.node.field.set';
     readonly nodeId: string;
-    readonly target: GraphTarget;
     readonly value?: number | string;
 } | {
     readonly before?: InputMapping;
     readonly handle: string;
     readonly kind: 'graph.node.input.set';
     readonly nodeId: string;
-    readonly target: GraphTarget;
     readonly value?: InputMapping;
 } | {
     readonly before: Pick<InlineTaskDefinition, 'inputs' | 'outputs'>;
     readonly kind: 'graph.node.task.ports.set';
     readonly nodeId: string;
-    readonly target: GraphTarget;
     readonly value: Pick<InlineTaskDefinition, 'inputs' | 'outputs'>;
 } | {
     readonly before: string;
     readonly kind: 'graph.node.task.name.set';
     readonly nodeId: string;
-    readonly target: GraphTarget;
     readonly value: string;
 } | {
     readonly before: readonly InputPort[];
     readonly kind: 'graph.node.values.set';
     readonly nodeId: string;
-    readonly target: GraphTarget;
     readonly value: readonly InputPort[];
 } | {
     readonly before: Pick<ResolutionNode, 'inputDefinitions' | 'prompt'>;
     readonly kind: 'graph.node.resolution.set';
     readonly nodeId: string;
-    readonly target: Extract<GraphTarget, {
-        readonly kind: 'flow';
-    }>;
     readonly value: Pick<ResolutionNode, 'inputDefinitions' | 'prompt'>;
 } | {
     readonly before: Pick<Extract<TriggerNode, {
@@ -435,9 +397,6 @@ export type ChangeOperation = {
     }>, 'bodyFields' | 'method' | 'options'>;
     readonly kind: 'graph.node.webhook.set';
     readonly nodeId: string;
-    readonly target: Extract<GraphTarget, {
-        readonly kind: 'flow';
-    }>;
     readonly value: Pick<Extract<TriggerNode, {
         readonly kind: 'webhook';
     }>, 'bodyFields' | 'method' | 'options'>;
@@ -472,54 +431,10 @@ export type ChangeOperation = {
     readonly moduleId: string;
     readonly source: string;
 } | {
-    readonly kind: 'subflow.create';
-    readonly subflow: FlowDocument['subflows'][string];
-    readonly subflowId: string;
-} | {
-    readonly before: Omit<FlowDocument['subflows'][string], 'graph'>;
-    readonly definition: Omit<FlowDocument['subflows'][string], 'graph'>;
-    readonly kind: 'subflow.definition.set';
-    readonly subflowId: string;
-} | {
-    readonly kind: 'subflow.delete';
-    readonly subflowId: string;
-} | {
-    readonly kind: 'task.create';
-    readonly task: FlowDocument['tasks'][string];
-    readonly taskId: string;
-} | {
-    readonly before?: string;
-    readonly kind: 'task.connector.connection.set';
-    readonly taskId: string;
-    readonly value?: string;
-} | {
-    readonly kind: 'task.delete';
-    readonly taskId: string;
-} | {
-    readonly before: ManagedTaskDefinition;
-    readonly kind: 'task.openapi.set';
-    readonly taskId: string;
-    readonly value: ManagedTaskDefinition;
-} | {
-    readonly before: ManagedTaskDefinition;
-    readonly kind: 'task.agent.set';
-    readonly taskId: string;
-    readonly value: ManagedTaskDefinition;
-} | {
-    readonly before: ManagedTaskDefinition;
-    readonly kind: 'task.decision.set';
-    readonly taskId: string;
-    readonly value: ManagedTaskDefinition;
-} | {
-    readonly before: 'chat' | 'json';
-    readonly kind: 'task.llm.mode.set';
-    readonly taskId: string;
-    readonly value: 'chat' | 'json';
-} | {
-    readonly before: string;
-    readonly kind: 'task.name.set';
-    readonly taskId: string;
-    readonly value: string;
+    readonly kind: 'graph.node.task.set';
+    readonly nodeId: string;
+    readonly before: TaskDefinition;
+    readonly value: TaskDefinition;
 };
 export declare class FlowChangeError extends Error {
     constructor(message: string);