@oomol-lab/open-flow 0.1.0-beta.62 → 0.1.0-beta.64

package/dist/common/flow-semantics.js

@@ -6725,7 +6725,8 @@ var managedFields = object$1({
 		object$1({
 			kind: literal("connector"),
 			action: text,
-			connectionId: text.optional()
+			connectionId: text.optional(),
+			outputMode: literal("value").optional()
 		}),
 		object$1({
 			kind: literal("openapi"),
@@ -8382,10 +8383,10 @@ function compileEnumAndConst(context, enumList, constValue, schema) {
 		}
 		if (compiledEnum.length === 0) recordWarn(context, "all of elements from list is rejected by currently schema object", "enum");
 	}
-	if (constValue && valid(schema, constValue) === ValidResult.Invalid) isNever = true;
+	if (constValue !== void 0 && valid(schema, constValue) === ValidResult.Invalid) isNever = true;
 	if (compiledEnum) {
 		if (compiledEnum.length === 0) isNever = true;
-		else if (constValue) {
+		else if (constValue !== void 0) {
 			let foundEquals = false;
 			for (const enumValue of compiledEnum) if (isDeepEquals(enumValue, constValue)) {
 				foundEquals = true;
@@ -8398,7 +8399,7 @@ function compileEnumAndConst(context, enumList, constValue, schema) {
 	const compiledSchema = {};
 	if (schema.type) compiledSchema.type = schema.type;
 	if (compiledEnum) compiledSchema.enum = compiledEnum;
-	if (constValue) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
+	if (constValue !== void 0) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
 	return wrapCompiledSchema(kind, compiledSchema, context.delegate, context.path);
 }
 //#endregion
@@ -8793,7 +8794,7 @@ function compileSchema(context, schema) {
 	let targetSchema = schema;
 	let shouldHandleEnumAndConst = false;
 	const { enum: enumList, const: constValue } = schema;
-	if (enumList || constValue) {
+	if (enumList || constValue !== void 0) {
 		const { enum: _0, const: _1, ...rest } = schema;
 		targetSchema = rest;
 		shouldHandleEnumAndConst = true;
@@ -9383,7 +9384,7 @@ function schemaEqualsChecker(extendsContext) {
 	}
 	function isValueEquals(value1, value2) {
 		if (value1 === value2) return true;
-		if (value1 === null) return false;
+		if (value1 === null || value2 === null) return false;
 		if (typeof value1 !== "object") return false;
 		if (typeof value1 !== typeof value2) return false;
 		if (isCompiledSchema(value1) && isCompiledSchema(value2)) return isCompiledSchemaEquals(value1, value2);
@@ -9949,7 +9950,7 @@ function findMismatchPath(source, target) {
 			if ((sourceSchema.maxProperties ?? Number.POSITIVE_INFINITY) > (targetSchema.maxProperties ?? Number.POSITIVE_INFINITY)) return [...targetPath, "maxProperties"];
 			break;
 		}
-		case CompiledKind.EnumOrConst: return [...targetPath, targetSchema.const == null ? "enum" : "const"];
+		case CompiledKind.EnumOrConst: return [...targetPath, targetSchema.const === void 0 ? "enum" : "const"];
 	}
 	return targetPath;
 }
@@ -11051,7 +11052,7 @@ function clearNodeConnections(graph, connectionId) {
 	return {
 		...graph,
 		nodes: Object.fromEntries(Object.entries(graph.nodes).map(([id, node]) => {
-			if ((node.kind == "poll" || node.kind == "integration") && node.connectionId == connectionId) {
+			if ((node.kind == "poll" || node.kind == "integration") && (connectionId == null || node.connectionId == connectionId)) {
 				const { connectionId: _, ...remaining } = node;
 				return [id, remaining];
 			}
@@ -11059,7 +11060,7 @@ function clearNodeConnections(graph, connectionId) {
 			if ("executor" in node.task) {
 				const executor = node.task.executor;
 				const clear = (value) => {
-					if (value.connectionId != connectionId) return value;
+					if (connectionId != null && value.connectionId != connectionId) return value;
 					const { connectionId: _, ...rest } = value;
 					return rest;
 				};
@@ -11084,11 +11085,26 @@ function clearNodeConnections(graph, connectionId) {
 				return [id, node];
 			}
 			const capabilities = node.task.capabilities?.map((capability) => {
-				if (!("mode" in capability) || capability.mode != "independent") return capability;
+				if (!("mode" in capability)) {
+					if ("action" in capability) {
+						const { connectionId: selected, ...rest } = capability;
+						return {
+							...rest,
+							connections: capability.connections.filter((item) => connectionId != null && item.connectionId != connectionId),
+							...selected != null && connectionId != null && selected != connectionId ? { connectionId: selected } : {}
+						};
+					}
+					return {
+						...capability,
+						...connectionId == null && (capability.connectionHints?.length ?? 0) > 0 ? { actionHints: [.../* @__PURE__ */ new Set([...capability.actionHints ?? [], ...capability.connectionHints.map((hint) => hint.action)])] } : {},
+						...capability.connectionHints == null ? {} : { connectionHints: capability.connectionHints.filter((item) => connectionId != null && item.connectionId != connectionId) }
+					};
+				}
+				if (capability.mode != "independent") return capability;
 				return {
 					...capability,
 					actions: capability.actions.map((action) => {
-						if (action.connectionId != connectionId) return action;
+						if (connectionId != null && action.connectionId != connectionId) return action;
 						const { connectionId: _, ...remaining } = action;
 						return remaining;
 					})
@@ -11603,6 +11619,36 @@ function agentToolInput(tool, input, argumentsValue) {
 	}));
 }
 //#endregion
+//#region src/trigger/common/config.ts
+function triggerConfigValue(input, config) {
+	return inputValue(config[input.handle], input.value);
+}
+function missingTriggerConfig(inputs, config) {
+	return inputs.flatMap((input) => "handle" in input && !input.nullable && triggerConfigValue(input, config) === void 0 ? [input.handle] : []);
+}
+/** Resolves fixed inputs before a Provider sees them, using the same defaults/null semantics as node inputs. */
+function resolveTriggerConfig(inputs, config) {
+	const fields = inputs.filter((input) => "handle" in input);
+	const handles = new Set(fields.map((input) => input.handle));
+	if (handles.size !== fields.length) throw new TypeError("Trigger config has duplicate input handles.");
+	const unknown = Object.keys(config).find((handle) => !handles.has(handle));
+	if (unknown != null) throw new TypeError(`Unknown Trigger config input "${unknown}".`);
+	const resolved = Object.fromEntries(fields.map((input) => {
+		const value = triggerConfigValue(input, config) ?? null;
+		if (!(value === null && input.nullable) && !matchesSchema(value, input.jsonSchema)) throw new TypeError(`Trigger config input "${input.handle}" does not match its declared schema.`);
+		return [input.handle, value];
+	}));
+	if (new TextEncoder().encode(JSON.stringify(resolved)).byteLength > 65536) throw new TypeError("Trigger config exceeds the 65536-byte limit.");
+	return resolved;
+}
+strictObject({
+	kind: literal("open-flow-workflow"),
+	version: literal(1),
+	name: string().optional(),
+	content: unknown(),
+	presentation: record$1(string(), json$1()).optional()
+});
+//#endregion
 //#region src/flow/common/encoding.ts
 var encoder = new TextEncoder();
 function canonicalText(value) {
@@ -11890,29 +11936,6 @@ function canonicalModule(module) {
 	};
 }
 //#endregion
-//#region src/trigger/common/config.ts
-function triggerConfigValue(input, config) {
-	return inputValue(config[input.handle], input.value);
-}
-function missingTriggerConfig(inputs, config) {
-	return inputs.flatMap((input) => "handle" in input && !input.nullable && triggerConfigValue(input, config) === void 0 ? [input.handle] : []);
-}
-/** Resolves fixed inputs before a Provider sees them, using the same defaults/null semantics as node inputs. */
-function resolveTriggerConfig(inputs, config) {
-	const fields = inputs.filter((input) => "handle" in input);
-	const handles = new Set(fields.map((input) => input.handle));
-	if (handles.size !== fields.length) throw new TypeError("Trigger config has duplicate input handles.");
-	const unknown = Object.keys(config).find((handle) => !handles.has(handle));
-	if (unknown != null) throw new TypeError(`Unknown Trigger config input "${unknown}".`);
-	const resolved = Object.fromEntries(fields.map((input) => {
-		const value = triggerConfigValue(input, config) ?? null;
-		if (!(value === null && input.nullable) && !matchesSchema(value, input.jsonSchema)) throw new TypeError(`Trigger config input "${input.handle}" does not match its declared schema.`);
-		return [input.handle, value];
-	}));
-	if (new TextEncoder().encode(JSON.stringify(resolved)).byteLength > 65536) throw new TypeError("Trigger config exceeds the 65536-byte limit.");
-	return resolved;
-}
-//#endregion
 //#region src/flow/common/sourceField.ts
 /** Only explicitly declared, first-level object properties are selectable. */
 function sourceFields(output) {
@@ -12194,18 +12217,13 @@ function mappingAvailable(graph, target, mapping, analysis) {
 	if (target != null && mapping.sources.some((source) => source.kind == "node" && isResolutionNode(graph.nodes[source.nodeId]) && !analysis.resolutionOutputs.get(target)?.has(resolutionOutputKey(source.nodeId, source.output)))) return false;
 	const sources = mapping.sources.map((source) => sourcePaths(graph, paths, source));
 	const targetPaths = target == null ? [{}] : paths.get(target) ?? [];
-	for (const [index, routes] of sources.entries()) for (const [offset, other] of sources.slice(index + 1).entries()) {
-		const leftSource = mapping.sources[index];
-		const rightSource = mapping.sources[index + offset + 1];
-		if (target != null && leftSource.kind == "node" && rightSource.kind == "node" && leftSource.nodeId != rightSource.nodeId && !ancestors.get(leftSource.nodeId)?.has(rightSource.nodeId) && !ancestors.get(rightSource.nodeId)?.has(leftSource.nodeId)) continue;
-		for (const left of routes) for (const targetRoute of targetPaths) {
-			if (!routesCompatible(left, targetRoute)) continue;
-			const path = {
-				...targetRoute,
-				...left
-			};
-			if (other.some((right) => routesCompatible(right, path))) return false;
-		}
+	for (const [index, routes] of sources.entries()) for (const other of sources.slice(index + 1)) for (const left of routes) for (const targetRoute of targetPaths) {
+		if (!routesCompatible(left, targetRoute)) continue;
+		const path = {
+			...targetRoute,
+			...left
+		};
+		if (other.some((right) => routesCompatible(right, path))) return false;
 	}
 	return true;
 }

package/dist/common/flow-workflowFile.d.ts

@@ -0,0 +1,23 @@
+import type { JsonValue, RevisionContent } from '../browser/flow-change.js';
+export interface WorkflowFile {
+    readonly kind: 'open-flow-workflow';
+    readonly version: 1;
+    readonly name?: string;
+    readonly content: RevisionContent;
+    readonly presentation?: Readonly<Record<string, JsonValue>>;
+}
+export interface WorkflowCleanupSummary {
+    readonly changedNodeIds: readonly string[];
+    readonly removedBindings: number;
+}
+/** Structural decoding only: incomplete drafts are supported, repair is never attempted. */
+export declare function decodeWorkflowFile(value: unknown): WorkflowFile;
+export declare function parseWorkflowFile(text: string): WorkflowFile;
+/** Clear only owned structured references, never strings in code or business values. */
+export declare function cleanWorkflowFile(value: unknown): {
+    readonly file: WorkflowFile;
+    readonly summary: WorkflowCleanupSummary;
+};
+export declare function encodeWorkflowFile(file: WorkflowFile): string;
+export declare function workflowFileName(name: string): string;
+export declare function workflowNameFromFile(name: string): string;

package/dist/common/integration-trigger.js

@@ -6808,7 +6808,8 @@ var managedFields = object({
 		object({
 			kind: literal("connector"),
 			action: text,
-			connectionId: text.optional()
+			connectionId: text.optional(),
+			outputMode: literal("value").optional()
 		}),
 		object({
 			kind: literal("openapi"),
@@ -8193,10 +8194,10 @@ function compileEnumAndConst(context, enumList, constValue, schema) {
 		}
 		if (compiledEnum.length === 0) recordWarn(context, "all of elements from list is rejected by currently schema object", "enum");
 	}
-	if (constValue && valid(schema, constValue) === ValidResult.Invalid) isNever = true;
+	if (constValue !== void 0 && valid(schema, constValue) === ValidResult.Invalid) isNever = true;
 	if (compiledEnum) {
 		if (compiledEnum.length === 0) isNever = true;
-		else if (constValue) {
+		else if (constValue !== void 0) {
 			let foundEquals = false;
 			for (const enumValue of compiledEnum) if (isDeepEquals(enumValue, constValue)) {
 				foundEquals = true;
@@ -8209,7 +8210,7 @@ function compileEnumAndConst(context, enumList, constValue, schema) {
 	const compiledSchema = {};
 	if (schema.type) compiledSchema.type = schema.type;
 	if (compiledEnum) compiledSchema.enum = compiledEnum;
-	if (constValue) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
+	if (constValue !== void 0) compiledSchema.const = wrapCompiledValue(deepCopy(constValue));
 	return wrapCompiledSchema(kind, compiledSchema, context.delegate, context.path);
 }
 //#endregion
@@ -8604,7 +8605,7 @@ function compileSchema(context, schema) {
 	let targetSchema = schema;
 	let shouldHandleEnumAndConst = false;
 	const { enum: enumList, const: constValue } = schema;
-	if (enumList || constValue) {
+	if (enumList || constValue !== void 0) {
 		const { enum: _0, const: _1, ...rest } = schema;
 		targetSchema = rest;
 		shouldHandleEnumAndConst = true;
@@ -9194,7 +9195,7 @@ function schemaEqualsChecker(extendsContext) {
 	}
 	function isValueEquals(value1, value2) {
 		if (value1 === value2) return true;
-		if (value1 === null) return false;
+		if (value1 === null || value2 === null) return false;
 		if (typeof value1 !== "object") return false;
 		if (typeof value1 !== typeof value2) return false;
 		if (isCompiledSchema(value1) && isCompiledSchema(value2)) return isCompiledSchemaEquals(value1, value2);
@@ -9760,7 +9761,7 @@ function findMismatchPath(source, target) {
 			if ((sourceSchema.maxProperties ?? Number.POSITIVE_INFINITY) > (targetSchema.maxProperties ?? Number.POSITIVE_INFINITY)) return [...targetPath, "maxProperties"];
 			break;
 		}
-		case CompiledKind.EnumOrConst: return [...targetPath, targetSchema.const == null ? "enum" : "const"];
+		case CompiledKind.EnumOrConst: return [...targetPath, targetSchema.const === void 0 ? "enum" : "const"];
 	}
 	return targetPath;
 }

package/dist/common/localization.d.ts

@@ -21,3 +21,4 @@ export declare function isCjkLanguage(language: string): boolean;
 export declare function userLocaleFallbackChain(language: string): readonly string[];
 /** Resolve metadata query/header preferences using the same language mapping as the UI. */
 export declare function resolveMetadataLanguage(query: string | undefined, acceptLanguage?: string): UiLanguage;
+export declare function importedWorkflowName(language: UiLanguage): string;

package/dist/common/localization.js

@@ -124,5 +124,16 @@ function resolveMetadataLanguage(query, acceptLanguage) {
 		}];
 	}).toSorted((a, b) => b.q - a.q || a.order - b.order)[0]?.language ?? "en";
 }
+function importedWorkflowName(language) {
+	return {
+		"en": "Imported workflow",
+		"zh-CN": "导入的工作流",
+		"zh-TW": "匯入的工作流",
+		"ja": "インポートしたワークフロー",
+		"ko": "가져온 워크플로",
+		"fr": "Workflow importé",
+		"ru": "Импортированный процесс"
+	}[language];
+}
 //#endregion
-export { defaultUiLanguage, isCjkLanguage, isUiLanguage, resolveMetadataLanguage, resolveUiLanguage, uiLanguageNames, uiLanguages, userLocaleFallbackChain };
+export { defaultUiLanguage, importedWorkflowName, isCjkLanguage, isUiLanguage, resolveMetadataLanguage, resolveUiLanguage, uiLanguageNames, uiLanguages, userLocaleFallbackChain };

package/dist/common/mcp.d.ts

@@ -3,6 +3,48 @@ import { z } from 'zod';
 export declare const mcpProtocolVersion = "2026-07-28";
 export declare const mcpInstructions: string;
 export declare const mcpTools: {
+    flow_canvas: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        flowId: string;
+                        command: {
+                            type: "focus";
+                            nodeId: string;
+                        } | {
+                            type: "zoom";
+                            zoom: number;
+                        } | {
+                            type: "pan";
+                            dx: number;
+                            dy: number;
+                        } | {
+                            type: "fit";
+                        };
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
     flow_live: {
         description: string;
         annotations: {
@@ -164,6 +206,67 @@ export declare const mcpTools: {
             };
         };
     };
+    flow_export: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        flowId: string;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
+    flow_import: {
+        description: string;
+        annotations: {
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            idempotentHint: boolean;
+            openWorldHint: boolean;
+        };
+        inputSchema: {
+            '~standard': {
+                version: 1;
+                vendor: string;
+                jsonSchema: {
+                    input: () => Record<string, unknown>;
+                    output: () => Record<string, unknown>;
+                };
+                validate(value: unknown): {
+                    value: {
+                        file: JsonValue;
+                        name?: string | undefined;
+                        teamId?: string | undefined;
+                        idempotencyKey: string;
+                    };
+                } | {
+                    issues: {
+                        message: string;
+                        path: string[];
+                    }[];
+                };
+            };
+        };
+    };
     flow_create: {
         description: string;
         annotations: {