@oomol-lab/open-flow 0.1.0-beta.4 → 0.1.0-beta.40

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

@@ -0,0 +1,11 @@
+import type { ChangeOperation, FlowDocument, JsonValue, RevisionContent } from './flow-change.js';
+export declare const currentFlowModelVersion = 4;
+/** 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;
+export declare function decodeRevisionContent(value: unknown): RevisionContent;
+export declare function decodeRevisionEnvelope(value: unknown): RevisionContent;
+export declare function parseOperation<Value>(candidate: unknown, index: number, parse: (value: unknown) => Value): Value;
+export declare function decodeChangeOperation(candidate: unknown, index: number): ChangeOperation;
+export declare function decodeChangeOperations(value: unknown): readonly ChangeOperation[];
+export declare function changeOperationsSchema(kind?: string): JsonValue;

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

@@ -1,6 +1,25 @@
+export { fixedInputValue, inputValue, inputValues } from './flow-input-value.js';
+import type { WebhookMethod } from './webhook-method.js';
+import { currentFlowModelVersion } from './flow-change-schema.js';
+export { changeOperationsSchema, currentFlowModelVersion, decodeChangeOperations } from './flow-change-schema.js';
+export type { WebhookMethod };
 export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
     readonly [key: string]: JsonValue;
 };
+export type SchemaKeyword = 'const' | 'enum' | 'exclusiveMaximum' | 'exclusiveMinimum' | 'maximum' | 'maxItems' | 'maxLength' | 'maxProperties' | 'minimum' | 'minItems' | 'minLength' | 'minProperties' | 'multipleOf' | 'pattern' | 'required' | 'type';
+export type SchemaMismatch = {
+    readonly kind: 'artifact' | 'binary' | 'nullable';
+} | {
+    readonly kind: 'keyword';
+    readonly keyword: SchemaKeyword;
+    readonly path: readonly (string | number)[];
+    readonly source: JsonValue | undefined;
+    readonly target: JsonValue | undefined;
+} | {
+    readonly kind: 'schema';
+    readonly path?: readonly (string | number)[];
+};
+export declare function isSchemaKeyword(value: string): value is SchemaKeyword;
 export declare const resourceNameMaxLength = 80;
 export type ResourceNameIssue = 'controlCharacter' | 'empty' | 'specialCharacter' | 'tooLong';
 export declare function resourceNameIssue(value: string): ResourceNameIssue | undefined;
@@ -25,6 +44,7 @@ export interface Group {
 }
 export declare function portsByHandle<Value extends Port>(ports: readonly (Value | Group)[]): Readonly<Record<string, Value>>;
 export interface NodeSource {
+    readonly field?: string;
     readonly kind: 'node';
     readonly nodeId: string;
     readonly output: string;
@@ -37,22 +57,26 @@ export interface BindingSource {
     readonly bindingId: string;
     readonly kind: 'binding';
 }
-export type InputMapping = {
-    readonly kind: 'sources';
-    readonly sources: readonly (BindingSource | FlowSource | NodeSource)[];
+export type FixedInputValue = {
+    readonly kind: 'unset';
 } | {
     readonly kind: 'value';
     readonly value: JsonValue;
 };
+export type InputValues = Readonly<Record<string, FixedInputValue>>;
+export type InputMapping = FixedInputValue | {
+    readonly kind: 'sources';
+    readonly sources: readonly (BindingSource | FlowSource | NodeSource)[];
+};
 export interface OutputMapping {
     readonly sources: readonly (FlowSource | NodeSource)[];
 }
 interface GraphNodeBase {
-    readonly concurrency: number;
     readonly description?: string;
     readonly icon?: string;
     readonly inputs: Readonly<Record<string, InputMapping>>;
     readonly name?: string;
+    readonly maxExecutions?: number;
     readonly timeoutMs?: number;
 }
 export interface SubflowNode extends GraphNodeBase {
@@ -64,31 +88,44 @@ export interface ValueNode extends GraphNodeBase {
     readonly values: readonly InputPort[];
 }
 export type WaitAction = 'approve' | 'continue' | 'reject';
-export interface WaitNode extends GraphNodeBase {
-    readonly actions: readonly ['continue'] | readonly ['approve', 'reject'];
-    readonly kind: 'wait';
-    readonly notification?: {
-        readonly inputs: Readonly<Record<string, InputMapping>>;
-        readonly messageHandle: string;
-        readonly taskId: string;
-    };
+interface ResolutionNodeBase extends GraphNodeBase {
+    readonly inputDefinitions: readonly InputPort[];
     readonly prompt: string;
+    readonly timeoutMs?: never;
 }
+export interface WaitNode extends ResolutionNodeBase {
+    readonly kind: 'wait';
+}
+export interface ApprovalNode extends ResolutionNodeBase {
+    readonly kind: 'approval';
+}
+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 ConditionOperand = {
+    readonly kind: 'value';
+    readonly value?: JsonValue;
+    readonly jsonSchema?: JsonValue;
+} | {
+    readonly kind: 'source';
+    readonly source: Source;
+};
 export interface ConditionExpression {
-    readonly input: string;
+    readonly left: ConditionOperand;
     readonly operator: ConditionOperator;
-    readonly value?: JsonValue;
+    readonly right?: ConditionOperand;
 }
-export interface ConditionCase {
+export interface ConditionGroup {
     readonly expressions: readonly ConditionExpression[];
+}
+export interface ConditionCase {
+    readonly description?: string;
+    readonly groups: readonly ConditionGroup[];
     readonly output: string;
-    readonly relation: 'all' | 'any';
 }
 export interface ConditionNode extends GraphNodeBase {
     readonly cases: readonly ConditionCase[];
-    readonly defaultOutput?: string;
-    readonly input: InputPort;
+    readonly matchMode: 'first' | 'all';
     readonly kind: 'condition';
 }
 export type ManagedTaskExecutor = {
@@ -98,12 +135,75 @@ export type ManagedTaskExecutor = {
 } | {
     readonly kind: 'llm';
     readonly mode: 'chat' | 'json';
+} | {
+    readonly kind: 'agent';
+    readonly code?: boolean;
+    readonly model: string;
+    readonly prompt: Exclude<AgentInput, {
+        readonly kind: 'model';
+    }>;
+    readonly system: string;
+    readonly maxRounds: number;
+    readonly tools: readonly AgentTool[];
+    readonly notification?: {
+        readonly taskId: string;
+        readonly messageHandle: string;
+        readonly inputs: Readonly<Record<string, Exclude<AgentInput, {
+            readonly kind: 'model';
+        }>>>;
+    };
+};
+export type AgentInput = {
+    readonly kind: 'value';
+    readonly value: JsonValue;
+} | {
+    readonly kind: 'input';
+    readonly input: string;
+} | {
+    readonly kind: 'model';
 };
-export interface ConnectorCapability {
+export interface AgentTool {
+    readonly id: string;
+    readonly name: string;
+    readonly description: string;
+    readonly action: string;
+    readonly connectionId?: string;
+    readonly approval: boolean;
+    readonly inputs: readonly (InputPort & {
+        readonly source: AgentInput;
+    })[];
+}
+export interface ConnectorAccessCapability {
+    readonly actionHints?: readonly string[];
+    readonly connectionHints?: readonly {
+        readonly action: string;
+        readonly connectionId: string;
+        readonly alias?: string;
+    }[];
+    readonly kind: 'connector';
+}
+export interface ConnectorActionCapability {
     readonly action: string;
-    readonly connectionId: string;
+    readonly connections: readonly {
+        readonly connectionId: string;
+        readonly alias?: string;
+    }[];
+    readonly connectionId?: string;
     readonly kind: 'connector';
 }
+export type ConnectorPermissionCapability = {
+    readonly kind: 'connector';
+    readonly mode: 'shared';
+} | {
+    readonly kind: 'connector';
+    readonly mode: 'independent';
+    readonly actions: readonly {
+        readonly action: string;
+        readonly connectionId?: string;
+    }[];
+};
+export type ConnectorCapability = ConnectorAccessCapability | ConnectorActionCapability | ConnectorPermissionCapability;
+export declare function decodeConnectorCapabilities(value: unknown): readonly ConnectorCapability[];
 interface TaskDefinitionBase {
     readonly inputs: readonly (InputPort | Group)[];
     readonly name: string;
@@ -129,6 +229,7 @@ export type TaskNode = GraphNodeBase & {
     readonly taskId: string;
 });
 export interface Graph {
+    readonly edges: readonly GraphEdge[];
     readonly nodes: Readonly<Record<string, GraphNode>>;
 }
 export type TriggerSchedule = {
@@ -141,13 +242,13 @@ export type TriggerSchedule = {
     readonly value: number;
 };
 interface TriggerKeySnapshotBase {
-    readonly configSchema: JsonValue;
+    readonly configInputs: readonly (InputPort | Group)[];
     readonly definitionVersion: number;
     readonly description: string;
     readonly displayName: string;
     readonly key: string;
     readonly name: string;
-    readonly payloadSchema: JsonValue;
+    readonly outputs: readonly Port[];
     readonly provider: string;
 }
 export type IntegrationEndpointMethod = 'DELETE' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT';
@@ -167,12 +268,10 @@ export type TriggerKeySnapshot = (TriggerKeySnapshotBase & {
     readonly endpoint: IntegrationEndpointDeclaration;
     readonly type: 'integration';
 });
-export interface WebhookInputDefinition extends InputPort {
+export interface WebhookBodyField extends InputPort {
 }
 export interface WebhookOptions {
-    readonly allowedMethods?: readonly string[];
     readonly allowedOrigins?: readonly string[];
-    readonly noResponseBody?: boolean;
     readonly responseData?: string;
     readonly responseHeaders?: Readonly<Record<string, string>>;
     readonly responseStatusCode?: number;
@@ -183,32 +282,35 @@ interface TriggerNodeBase {
     readonly name: string;
 }
 export type TriggerNode = (TriggerNodeBase & {
-    readonly inputsDef: readonly WebhookInputDefinition[];
+    readonly kind: 'manual';
+}) | (TriggerNodeBase & {
+    readonly bodyFields: readonly WebhookBodyField[];
     readonly kind: 'webhook';
+    readonly method: WebhookMethod;
     readonly options?: WebhookOptions;
 }) | (TriggerNodeBase & {
     readonly cronTimes: readonly TriggerSchedule[];
     readonly kind: 'cron';
 }) | (TriggerNodeBase & {
-    readonly bindingId: string;
-    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly connectionId?: string;
+    readonly config: InputValues;
     readonly definition: TriggerKeySnapshot & {
         readonly type: 'poll';
     };
     readonly kind: 'poll';
     readonly pollTimes: readonly TriggerSchedule[];
 }) | (TriggerNodeBase & {
-    readonly bindingId: string;
-    readonly config: Readonly<Record<string, JsonValue>>;
+    readonly connectionId?: string;
+    readonly config: InputValues;
     readonly definition: TriggerKeySnapshot & {
         readonly type: 'integration';
     };
     readonly kind: 'integration';
 });
-export type GraphNode = ConditionNode | SubflowNode | TaskNode | TriggerNode | ValueNode | WaitNode;
+export type GraphNode = ApprovalNode | ConditionNode | SubflowNode | TaskNode | TriggerNode | ValueNode | WaitNode;
 export interface FlowDocument {
     readonly bindings: Readonly<Record<string, {
-        readonly kind: 'connection' | 'variable';
+        readonly kind: 'variable';
         readonly target: string;
     }>>;
     readonly graph: Graph;
@@ -227,7 +329,7 @@ export interface CodeModule {
 }
 export interface RevisionContent {
     readonly document: FlowDocument;
-    readonly modelVersion: 1;
+    readonly modelVersion: 2 | typeof currentFlowModelVersion;
     readonly modules: Readonly<Record<string, CodeModule>>;
 }
 export type GraphTarget = {
@@ -238,21 +340,30 @@ export type GraphTarget = {
 };
 export interface GraphEdge {
     readonly source: string;
-    readonly sourceHandle: string;
+    readonly sourceHandle?: string;
     readonly target: string;
-    readonly targetHandle: string;
 }
+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 before?: readonly ConnectorCapability[];
+    readonly kind: 'graph.node.task.capabilities.set';
+    readonly nodeId: string;
+    readonly target: GraphTarget;
+    readonly value?: readonly ConnectorCapability[];
+} | {
     readonly binding: FlowDocument['bindings'][string];
     readonly bindingId: string;
     readonly kind: 'binding.create';
 } | {
-    readonly binding: FlowDocument['bindings'][string];
     readonly bindingId: string;
-    readonly kind: 'binding.replace';
+    readonly kind: 'binding.delete';
 } | {
+    readonly before: string;
     readonly bindingId: string;
-    readonly kind: 'binding.delete';
+    readonly kind: 'binding.target.set';
+    readonly value: string;
 } | {
     readonly kind: 'graph.edge.connect';
     readonly edge: GraphEdge;
@@ -261,6 +372,18 @@ export type ChangeOperation = {
     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;
@@ -271,10 +394,68 @@ export type ChangeOperation = {
     readonly nodeId: string;
     readonly target: GraphTarget;
 } | {
-    readonly kind: 'graph.node.replace';
-    readonly node: GraphNode;
+    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, {
+        readonly kind: 'webhook';
+    }>, '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'>;
+} | {
+    readonly before?: FixedInputValue;
+    readonly kind: 'graph.trigger.config.set';
+    readonly name: string;
+    readonly nodeId: string;
+    readonly value?: FixedInputValue;
+} | {
+    readonly before: readonly TriggerSchedule[];
+    readonly kind: 'graph.trigger.schedule.set';
+    readonly nodeId: string;
+    readonly value: readonly TriggerSchedule[];
 } | {
     readonly kind: 'module.create';
     readonly module: CodeModule;
@@ -283,10 +464,13 @@ export type ChangeOperation = {
     readonly kind: 'module.delete';
     readonly moduleId: string;
 } | {
+    readonly before: string;
     readonly kind: 'module.rename';
     readonly moduleId: string;
     readonly name: string;
 } | {
+    readonly beforeImports: readonly string[];
+    readonly beforeSource: string;
     readonly imports: readonly string[];
     readonly kind: 'module.source.replace';
     readonly moduleId: string;
@@ -296,8 +480,9 @@ export type ChangeOperation = {
     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.replace';
+    readonly kind: 'subflow.definition.set';
     readonly subflowId: string;
 } | {
     readonly kind: 'subflow.delete';
@@ -306,15 +491,31 @@ export type ChangeOperation = {
     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 kind: 'task.replace';
-    readonly task: FlowDocument['tasks'][string];
+    readonly before: ManagedTaskDefinition;
+    readonly kind: 'task.agent.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;
 };
 export declare class FlowChangeError extends Error {
+    constructor(message: string);
 }
 export declare function applyFlowChanges(content: RevisionContent, operations: readonly ChangeOperation[]): RevisionContent;
-export {};