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

package/dist/browser/{createResourceDialog-Btjes3wD.js → createResourceDialog-C23SBjYd.js}

@@ -1,6 +1,6 @@
 import { l as useTranslate } from "./dist-BFmpkX4P.js";
-import { C as FieldDescription, E as FieldLabel, S as Field, T as FieldGroup, c as DialogTitle, gi as Button, i as DialogContent, ir as Input, n as Dialog, o as DialogFooter, r as DialogClose, s as DialogHeader, t as Icon, w as FieldError, x as Spinner } from "./icons-p2A9zs8t.js";
-import { t as WorkbenchSelect } from "./workbenchSelect-LRp_Xjeq.js";
+import { C as FieldDescription, E as FieldLabel, S as Field, T as FieldGroup, c as DialogTitle, i as DialogContent, n as Dialog, o as DialogFooter, or as Input, r as DialogClose, s as DialogHeader, t as Icon, vi as Button, w as FieldError, x as Spinner } from "./icons-6oQ8Q9Wm.js";
+import { t as WorkbenchSelect } from "./workbenchSelect-DpLbIr29.js";
 import { useEffect, useRef, useState } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 //#region src/workbench/browser/runtime/shell/createResourceDialog.tsx

package/dist/browser/flow-authoring-node.d.ts

@@ -1,5 +1,8 @@
 import type { DecisionQuestion } from '../common/decision.js';
-import type { ChangeOperation, CodeModule, ConnectorCapability, GraphNode, InputMapping, InputValues, JsonValue, PortDefinition, RevisionContent, TaskDefinition, TriggerKeySnapshot, TriggerNode, TriggerSchedule, WebhookOptions } from './flow-change.js';
+import type { ChangeOperation, CodeModule, ConnectorCapability, GraphNode, InputMapping, InputValues, InputPort, JsonValue, PortDefinition, RevisionContent, TaskDefinition, TriggerKeySnapshot, TriggerNode, TriggerSchedule, WebhookOptions } from './flow-change.js';
+export declare const defaultCodeTaskPorts: Pick<Extract<TaskDefinition, {
+    readonly moduleId: string;
+}>, 'inputs' | 'outputs' | 'capabilities'>;
 export interface Settings {
     readonly name?: string;
     readonly maxExecutions?: number;
@@ -56,12 +59,13 @@ export declare function createAgentTask(identity: {
 }, name: string, defaults?: {
     readonly prompt?: string;
     readonly outputDescription?: string;
+    readonly inputs?: TaskDefinition['inputs'];
 }): readonly ChangeOperation[];
 export declare function createLlmTask(identity: {
     readonly nodeId: string;
 }, name: string, mode: 'chat' | 'json', outputDescription: string, options?: LlmTaskOptions): readonly ChangeOperation[];
 export declare function createCondition(nodeId: string, name: string): readonly ChangeOperation[];
-export declare function createValue(nodeId: string, name: string): readonly ChangeOperation[];
+export declare function createValue(nodeId: string, name: string, values?: readonly InputPort[]): readonly ChangeOperation[];
 export declare function createWait(nodeId: string, name: string): readonly ChangeOperation[];
 export declare function createApproval(nodeId: string, name: string): readonly ChangeOperation[];
 export declare function createBuiltinTrigger(nodeId: string, node: Extract<TriggerNode, {

package/dist/browser/flow-authoring.js

@@ -5937,7 +5937,7 @@ var decisionQuestion = discriminatedUnion("type", [
 		criteria: strings
 	})
 ]);
-var managed = object({
+var managedFields = object({
 	...ports,
 	name: text,
 	executor: union([
@@ -5996,7 +5996,8 @@ var managed = object({
 			}).optional()
 		})
 	])
-}).transform(limitDecisionTask);
+});
+var managed = managedFields.transform(limitDecisionTask);
 var operand = union([object({
 	kind: literal("value"),
 	value: json.optional(),
@@ -6171,6 +6172,10 @@ var node = union([
 		})
 	})
 ]);
+strictObject(condition), strictObject(wait), strictObject(webhook), managedFields.shape.executor.options[0].omit({ kind: true }).strict(), managedFields.shape.executor.options[1].omit({ kind: true }).strict(), managedFields.shape.executor.options[2].omit({ kind: true }).strict(), managedFields.shape.executor.options[3].omit({ kind: true }).strict(), managedFields.shape.executor.options[4].omit({
+	kind: true,
+	notification: true
+}).strict();
 var edge = object({
 	source: text,
 	target: text,
@@ -6250,6 +6255,11 @@ var shapes = {
 		...at,
 		node
 	},
+	"graph.node.replace": {
+		...at,
+		before: node,
+		node
+	},
 	"graph.node.delete": at,
 	"graph.node.field.set": union([
 		object({
@@ -6665,6 +6675,27 @@ function applyFlowChanges(content, operations) {
 			} });
 			break;
 		}
+		case "graph.node.replace": {
+			const graph = document.graph;
+			if (!dequal(graph.nodes[operation.nodeId], operation.before)) invalid("The Node changed before this operation was applied.");
+			if (operation.node.kind != operation.before.kind) invalid("Replacing a Node cannot change its kind.");
+			if (operation.node.kind == "task" && "moduleId" in operation.node.task && operation.node.task.capabilities !== void 0) decodeConnectorCapabilities(operation.node.task.capabilities);
+			const name = normalizeNodeName(operation.node.name ?? "");
+			const issue = nodeNameIssue(graph, operation.nodeId, name);
+			if (issue != null) invalid(`Node name is ${issue}.`);
+			const node = name == operation.node.name ? operation.node : {
+				...operation.node,
+				name
+			};
+			Object.assign(document, { graph: {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: node
+				}
+			} });
+			break;
+		}
 		case "graph.node.create": {
 			const graph = document.graph;
 			if (graph.nodes[operation.nodeId] != null) invalid("A Node with this ID already exists in the target graph.");
@@ -9852,7 +9883,7 @@ var codeTaskTemplate = `export default async function (inputs, context) {
   return { result: inputs.value }
 }
 `;
-function createCodeTask(identity, name, module = void 0, ports = {
+var defaultCodeTaskPorts = {
 	inputs: [{
 		handle: "value",
 		jsonSchema: { type: "string" },
@@ -9864,7 +9895,8 @@ function createCodeTask(identity, name, module = void 0, ports = {
 		jsonSchema: {},
 		nullable: true
 	}]
-}) {
+};
+function createCodeTask(identity, name, module = void 0, ports = defaultCodeTaskPorts) {
 	return [{
 		kind: "module.create",
 		module: {
@@ -9911,7 +9943,7 @@ function createManagedTask(identity, task) {
 function createAgentTask(identity, name, defaults = {}) {
 	return createManagedTask(identity, {
 		name,
-		inputs: [{
+		inputs: defaults.inputs ?? [{
 			handle: "input",
 			jsonSchema: { type: "string" },
 			nullable: false,
@@ -10005,19 +10037,19 @@ function createCondition(nodeId, name) {
 		nodeId
 	}];
 }
-function createValue(nodeId, name) {
+function createValue(nodeId, name, values = [{
+	handle: "value",
+	jsonSchema: {},
+	nullable: true,
+	value: null
+}]) {
 	return [{
 		kind: "graph.node.create",
 		node: {
 			inputs: {},
 			kind: "value",
 			name,
-			values: [{
-				handle: "value",
-				jsonSchema: {},
-				nullable: true,
-				value: null
-			}]
+			values
 		},
 		nodeId
 	}];

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

@@ -1,5 +1,271 @@
 import type { ChangeOperation, FlowDocument, JsonValue, RevisionContent } from './flow-change.js';
+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

@@ -310,6 +310,11 @@ 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;

package/dist/browser/flow-change.js

@@ -8892,7 +8892,7 @@ var decisionQuestion = discriminatedUnion("type", [
 		criteria: strings
 	})
 ]);
-var managed = object({
+var managedFields = object({
 	...ports,
 	name: text,
 	executor: union([
@@ -8951,7 +8951,8 @@ var managed = object({
 			}).optional()
 		})
 	])
-}).transform(limitDecisionTask);
+});
+var managed = managedFields.transform(limitDecisionTask);
 var operand = union([object({
 	kind: literal("value"),
 	value: json.optional(),
@@ -9126,6 +9127,10 @@ var node = union([
 		})
 	})
 ]);
+strictObject(condition), strictObject(wait), strictObject(webhook), managedFields.shape.executor.options[0].omit({ kind: true }).strict(), managedFields.shape.executor.options[1].omit({ kind: true }).strict(), managedFields.shape.executor.options[2].omit({ kind: true }).strict(), managedFields.shape.executor.options[3].omit({ kind: true }).strict(), managedFields.shape.executor.options[4].omit({
+	kind: true,
+	notification: true
+}).strict();
 var edge = object({
 	source: text,
 	target: text,
@@ -9205,6 +9210,11 @@ var shapes = {
 		...at,
 		node
 	},
+	"graph.node.replace": {
+		...at,
+		before: node,
+		node
+	},
 	"graph.node.delete": at,
 	"graph.node.field.set": union([
 		object({
@@ -9694,6 +9704,27 @@ function applyFlowChanges(content, operations) {
 			} });
 			break;
 		}
+		case "graph.node.replace": {
+			const graph = document.graph;
+			if (!dequal(graph.nodes[operation.nodeId], operation.before)) invalid("The Node changed before this operation was applied.");
+			if (operation.node.kind != operation.before.kind) invalid("Replacing a Node cannot change its kind.");
+			if (operation.node.kind == "task" && "moduleId" in operation.node.task && operation.node.task.capabilities !== void 0) decodeConnectorCapabilities(operation.node.task.capabilities);
+			const name = normalizeNodeName(operation.node.name ?? "");
+			const issue = nodeNameIssue(graph, operation.nodeId, name);
+			if (issue != null) invalid(`Node name is ${issue}.`);
+			const node = name == operation.node.name ? operation.node : {
+				...operation.node,
+				name
+			};
+			Object.assign(document, { graph: {
+				...graph,
+				nodes: {
+					...graph.nodes,
+					[operation.nodeId]: node
+				}
+			} });
+			break;
+		}
 		case "graph.node.create": {
 			const graph = document.graph;
 			if (graph.nodes[operation.nodeId] != null) invalid("A Node with this ID already exists in the target graph.");