@oomol-lab/open-flow 0.1.0-beta.81 → 0.1.0-beta.83

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

@@ -1,8 +1,12 @@
 import type { GraphNode } from './flow-change.js';
 import type { WorkflowCapability } from './flow-model.js';
+type WorkflowTarget = Pick<WorkflowCapability, 'flowId' | 'revisionId'>;
+/** Rewrite only declared workflow identities, preserving business values and saved ports. */
+export declare function mapNodeWorkflowTargets(node: GraphNode, map: (target: WorkflowTarget) => WorkflowTarget): GraphNode;
 /** Workflow declarations share discovery across authoring, admission and resource indexing. */
 export declare function nodeWorkflowReferences(node: GraphNode): readonly {
     readonly target: Omit<WorkflowCapability, 'kind' | 'name'>;
     readonly path: string;
     readonly tool?: string;
 }[];
+export {};

package/dist/common/mcp.d.ts

@@ -349,6 +349,7 @@ export declare const mcpTools: {
                 validate(value: unknown): {
                     value: {
                         flowId: string;
+                        includeDependencies?: boolean | undefined;
                     };
                 } | {
                     issues: {
@@ -380,6 +381,7 @@ export declare const mcpTools: {
                         file: JsonValue;
                         name?: string | undefined;
                         teamId?: string | undefined;
+                        tagIds?: string[] | undefined;
                         idempotencyKey: string;
                     };
                 } | {

package/dist/common/mcp.js

@@ -9692,6 +9692,27 @@ function checkModelVersion(content) {
 function assertDocumentHttpAuthBindings(content) {
 	for (const graphNode of Object.values(content.graph.nodes)) if (graphNode.kind == "task" && "executor" in graphNode.task && ["openapi", "http-request"].includes(graphNode.task.executor.kind)) assertHttpAuthBindings(graphNode.inputs);
 }
+//#endregion
+//#region src/flow/common/condition.ts
+function clearConditionBinding(operand) {
+	return operand.kind == "source" && operand.source.kind == "binding" ? { kind: "value" } : operand;
+}
+function clearConditionBindings(node) {
+	return {
+		...node,
+		cases: node.cases.map((item) => ({
+			...item,
+			groups: item.groups.map((group) => ({
+				...group,
+				expressions: group.expressions.map((expression) => ({
+					...expression,
+					left: clearConditionBinding(expression.left),
+					...expression.right == null ? {} : { right: clearConditionBinding(expression.right) }
+				}))
+			}))
+		}))
+	};
+}
 function resourceNameIssue(value) {
 	const name = value.trim();
 	if (name.length == 0) return "empty";
@@ -10154,6 +10175,31 @@ var resultQuerySchema = strictObject({
 	maxBytes: number().int().min(1).max(1048576).default(15e3)
 });
 //#endregion
+//#region src/flow/common/workflowReferences.ts
+/** Workflow declarations share discovery across authoring, admission and resource indexing. */
+function nodeWorkflowReferences(node) {
+	if (node.kind != "task") return [];
+	if ("moduleId" in node.task) return (node.task.capabilities ?? []).flatMap((item, index) => item.kind == "workflow" ? [{
+		target: item,
+		path: `task/capabilities/${index}`,
+		tool: item.name
+	}] : []);
+	if (node.task.executor.kind == "workflow") return [{
+		target: {
+			...node.task.executor,
+			inputs: node.task.inputs.filter((port) => "handle" in port),
+			outputs: node.task.outputs.filter((port) => "handle" in port)
+		},
+		path: "task/executor"
+	}];
+	if (node.task.executor.kind == "agent") return node.task.executor.tools.flatMap((item, index) => item.kind == "workflow" ? [{
+		target: item,
+		path: `task/executor/tools/${index}`,
+		tool: item.name
+	}] : []);
+	return [];
+}
+//#endregion
 //#region src/workflow/common/workflow.ts
 var portSchema = object({
 	handle: string$1().min(1),
@@ -10702,12 +10748,12 @@ function decodeLiveDetails(value) {
 		publication: current,
 		status,
 		enabled: source.enabled,
-		entries: decodeEntries(source.entries, current),
+		entries: decodeEntries$1(source.entries, current),
 		version: 1
 	};
 }
 /** Both producers and consumers enforce the same published-entry invariants. */
-function decodeEntries(values, current) {
+function decodeEntries$1(values, current) {
 	const parsed = array(entrySchema).safeParse(values);
 	if (!parsed.success) return invalidResponse();
 	const ids = /* @__PURE__ */ new Set();
@@ -10754,11 +10800,109 @@ function providerIconAppearance(metadata, position) {
 	};
 }
 //#endregion
+//#region src/trigger/common/config.ts
+/** Deployment-bound selections owned by the Trigger configuration contract. */
+function clearTriggerExternalConfig(key, config) {
+	const fields = key == "jira.on_issue_event" || key == "intercom.on_conversation_event" || key == "sentry.on_issue_alert" || key == "zoom.on_recording_ready" || key == "fireflies.on_meeting_ready" ? ["sourceId", "eventTypes"] : key == "slackbot.on_event" ? [
+		"sourceId",
+		"eventTypes",
+		"channelIds"
+	] : key == "feishu_app_bot.on_event" ? [
+		"sourceId",
+		"eventTypes",
+		"resource",
+		"chatIds"
+	] : key == "linear.on_issue_changed" ? ["teamId", "stateIds"] : [];
+	return {
+		...config,
+		...Object.fromEntries(fields.map((field) => [field, { kind: "unset" }]))
+	};
+}
+//#endregion
+//#region src/flow/common/connectionUsage.ts
+function clearNodeConnections(graph, connectionId) {
+	return {
+		...graph,
+		nodes: Object.fromEntries(Object.entries(graph.nodes).map(([id, node]) => {
+			if ((node.kind == "poll" || node.kind == "integration") && (connectionId == null || node.connectionId == connectionId)) {
+				const { connectionId: _, ...remaining } = node;
+				return [id, remaining];
+			}
+			if (node.kind != "task") return [id, node];
+			if ("executor" in node.task) {
+				const executor = node.task.executor;
+				const clear = (value) => {
+					if (value.connectionId === "") return value;
+					if (connectionId != null && value.connectionId != connectionId) return value;
+					const { connectionId: _, ...rest } = value;
+					return rest;
+				};
+				if (executor.kind == "connector") return [id, {
+					...node,
+					task: {
+						...node.task,
+						executor: clear(executor)
+					}
+				}];
+				if (executor.kind == "agent") return [id, {
+					...node,
+					task: {
+						...node.task,
+						executor: {
+							...executor,
+							tools: executor.tools.map(clear),
+							...executor.notification == null ? {} : { notification: clear(executor.notification) }
+						}
+					}
+				}];
+				return [id, node];
+			}
+			const capabilities = node.task.capabilities?.map((capability) => {
+				if (capability.kind == "workflow" || capability.kind == "http") 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 === "") return action;
+						if (connectionId != null && action.connectionId != connectionId) return action;
+						const { connectionId: _, ...remaining } = action;
+						return remaining;
+					})
+				};
+			});
+			return [id, capabilities == null ? node : {
+				...node,
+				task: {
+					...node.task,
+					capabilities
+				}
+			}];
+		}))
+	};
+}
+//#endregion
 //#region src/flow/common/workflowFile.ts
 var envelope = strictObject({
 	kind: literal("open-flow-workflow"),
 	version: literal(1),
 	name: string$1().optional(),
+	icon: string$1().optional(),
+	description: string$1().optional(),
 	content: unknown(),
 	presentation: record$2(string$1(), json$4()).optional()
 });
@@ -10771,6 +10915,126 @@ function decodeWorkflowFile(value) {
 		content: decodeRevisionContent(file.content)
 	};
 }
+function cleanInput(input) {
+	if (input.kind != "sources" || !input.sources.some((source) => source.kind == "binding")) return input;
+	const sources = input.sources.filter((source) => source.kind != "binding");
+	return sources.length == 0 ? { kind: "unset" } : {
+		kind: "sources",
+		sources
+	};
+}
+/** Clear only owned structured references, never strings in code or business values. */
+function cleanWorkflowFile(value) {
+	const file = decodeWorkflowFile(value);
+	const original = file.content.document.graph;
+	const graph = clearNodeConnections(original);
+	const nodes = Object.fromEntries(Object.entries(graph.nodes).map(([id, source]) => {
+		let node = source;
+		if ("inputs" in node) node = {
+			...node,
+			inputs: Object.fromEntries(Object.entries(node.inputs).map(([key, input]) => [key, cleanInput(input)]))
+		};
+		if (node.kind == "outputs") node = {
+			...node,
+			outputMappings: Object.fromEntries(Object.entries(node.outputMappings).map(([key, input]) => [key, cleanInput(input)]))
+		};
+		if (node.kind == "condition") node = clearConditionBindings(node);
+		if (node.kind == "error" && node.sourceFlowIds != null) node = {
+			...node,
+			sourceFlowIds: []
+		};
+		if (node.kind == "poll" || node.kind == "integration") node = {
+			...node,
+			config: clearTriggerExternalConfig(node.definition.key, node.config)
+		};
+		return [id, node];
+	}));
+	return {
+		file: {
+			...file,
+			content: {
+				...file.content,
+				document: {
+					...file.content.document,
+					bindings: {},
+					graph: {
+						...graph,
+						nodes
+					}
+				}
+			}
+		},
+		summary: {
+			changedNodeIds: Object.keys(nodes).filter((id) => !dequal(nodes[id], original.nodes[id])),
+			removedBindings: Object.keys(file.content.document.bindings).length
+		}
+	};
+}
+//#endregion
+//#region src/flow/common/workflowBundle.ts
+var entries = array(strictObject({
+	flowId: string$1().min(1),
+	file: unknown()
+})).min(1);
+var bundleSchema = strictObject({
+	kind: literal("open-flow-workflow-bundle"),
+	version: literal(1),
+	entryFlowId: string$1().min(1),
+	workflows: entries
+});
+var previewSchema = strictObject({
+	version: literal(1),
+	entryFlowId: string$1().min(1),
+	workflows: entries,
+	unavailableFlowIds: array(string$1().min(1))
+});
+function decodeEntries(value, entryFlowId, unavailableFlowIds = []) {
+	const workflows = value.map(({ flowId, file }) => ({
+		flowId,
+		file: decodeWorkflowFile(file)
+	}));
+	const ids = new Set(workflows.map(({ flowId }) => flowId));
+	if (ids.size != workflows.length || !ids.has(entryFlowId)) throw new TypeError("Workflow identities must be unique and include the entry workflow.");
+	const unavailable = new Set(unavailableFlowIds);
+	if (unavailable.size != unavailableFlowIds.length || unavailableFlowIds.some((id) => ids.has(id))) throw new TypeError("Invalid unavailable workflow identities.");
+	for (const { file } of workflows) for (const node of Object.values(file.content.document.graph.nodes)) for (const { target } of nodeWorkflowReferences(node)) if (target.flowId && !ids.has(target.flowId) && !unavailable.has(target.flowId)) throw new TypeError("A referenced workflow is missing from the bundle.");
+	return workflows;
+}
+function decodeWorkflowBundle(value) {
+	checkJsonDepth(value, -4);
+	const bundle = bundleSchema.parse(value);
+	return {
+		...bundle,
+		workflows: decodeEntries(bundle.workflows, bundle.entryFlowId)
+	};
+}
+function decodeWorkflowExportPreview(value) {
+	checkJsonDepth(value, -4);
+	const preview = previewSchema.parse(value);
+	return {
+		...preview,
+		workflows: decodeEntries(preview.workflows, preview.entryFlowId, preview.unavailableFlowIds)
+	};
+}
+function cleanWorkflowBundle(value) {
+	const bundle = decodeWorkflowBundle(value);
+	return {
+		...bundle,
+		workflows: bundle.workflows.map(({ flowId, file }) => ({
+			flowId,
+			file: cleanWorkflowFile(file).file
+		}))
+	};
+}
+function workflowBundleFromPreview(preview) {
+	if (preview.unavailableFlowIds.length) throw new TypeError("Some referenced workflows are unavailable.");
+	return cleanWorkflowBundle({
+		kind: "open-flow-workflow-bundle",
+		version: 1,
+		entryFlowId: preview.entryFlowId,
+		workflows: preview.workflows
+	});
+}
 new TextEncoder();
 //#endregion
 //#region src/control/common/providerAccess.ts
@@ -11509,6 +11773,8 @@ function flow$1(value) {
 		resourceReferences: resourceReferences(source.resourceReferences),
 		flowId: string(source.flowId),
 		name: string(source.name),
+		...source.icon === void 0 ? {} : { icon: string(source.icon) },
+		...source.description === void 0 ? {} : { description: string(source.description) },
 		status,
 		updatedAt: string(source.updatedAt),
 		version: 1
@@ -11984,6 +12250,18 @@ function decodeTagListItem(value) {
 }
 //#endregion
 //#region src/control/common/api.ts
+function decodeWorkflowBundleImportResult(value) {
+	const source = record(value);
+	if (source.version != 1 || !Array.isArray(source.flows) || source.flows.length == 0) return invalidResponse();
+	const entry = flow$1(source.flow);
+	const flows = source.flows.map(flow$1);
+	if (new Set(flows.map((item) => item.flowId)).size != flows.length || !flows.some((item) => item.flowId == entry.flowId)) return invalidResponse();
+	return {
+		version: 1,
+		flow: entry,
+		flows
+	};
+}
 function decodeRunEvent(value) {
 	const source = record(value);
 	const sequence = integer(source.sequence);
@@ -12298,6 +12576,32 @@ var ControlClient = class {
 			return invalidResponse();
 		}
 	}
+	async getFlowExportPreview(flowId) {
+		const value = await this.request(`/v1/flows/${segment(flowId)}/export-preview`);
+		try {
+			return decodeWorkflowExportPreview(value);
+		} catch {
+			return invalidResponse();
+		}
+	}
+	async exportFlowBundle(flowId) {
+		const preview = await this.getFlowExportPreview(flowId);
+		if (preview.unavailableFlowIds.length) throw new ApiError(400, "flow.invalid", "Some referenced workflows are unavailable.");
+		return workflowBundleFromPreview(preview);
+	}
+	async importFlowBundle(file, options = {}) {
+		return decodeWorkflowBundleImportResult(await this.request("/v1/flows/import-bundle", {
+			method: "POST",
+			headers: { "Idempotency-Key": options.idempotencyKey ?? `flow-${randomId()}` },
+			body: JSON.stringify({
+				file,
+				name: options.name,
+				teamId: options.teamId,
+				tagIds: options.tagIds,
+				version: 1
+			})
+		}));
+	}
 	async importFlow(file, options = {}) {
 		return flow$1(await this.request("/v1/flows/import", {
 			method: "POST",
@@ -13206,11 +13510,15 @@ var mcpTools = {
 	flow_read: tool("Read an outline, selected node details, or a bounded code/prompt excerpt. Carry the returned revision into subsequent reads and edits.", authoringReadSchema.safeExtend({ flowId: flow }).meta({ ...authoringReadSchema.meta() }), true),
 	flow_search: tool("Find nodes by name, configuration or source text in a fixed Revision. Follow nextOffset for more matches.", authoringSearchSchema.extend({ flowId: flow }), true),
 	flow_schema: tool("Read node configuration schemas and the edit grammar, or an Action contract. Action lookup requires a flowId.", authoringSchemaQuery.safeExtend({ flowId: flow.optional() }), true),
-	flow_export: tool("Export the current draft as a shareable workflow JSON file. Structured external references are cleared. Literal secrets in code, prompts or business JSON remain; review before sharing.", strictObject({ flowId: flow }), true),
-	flow_import: tool("Import workflow JSON as a new unpublished draft. External references are cleared and must be configured again. Keep identical arguments and idempotencyKey when retrying.", strictObject({
+	flow_export: tool("Export the current draft as shareable workflow JSON. Set includeDependencies to bundle all referenced drafts. Structured external references are cleared. Literal secrets in code, prompts or business JSON remain; review before sharing.", strictObject({
+		flowId: flow,
+		includeDependencies: boolean().optional()
+	}), true),
+	flow_import: tool("Import workflow JSON or a bundle as new unpublished drafts. tagIds apply to every imported workflow. External references are cleared and must be configured again. Keep identical arguments and idempotencyKey when retrying.", strictObject({
 		file: json,
 		name: id.optional(),
 		teamId: id.optional(),
+		tagIds: array(id).optional(),
 		idempotencyKey: mutationKey
 	}), false),
 	flow_create: tool("Create an empty Flow. If this deployment uses OOMOL Connector, choose a teamId from connector_teams. Keep the key and arguments stable when retrying.", strictObject({