@oomol-lab/open-flow 0.1.0-beta.80 → 0.1.0-beta.82

package/dist/common/flow-encoding.js

@@ -9856,6 +9856,8 @@ var envelope = strictObject({
 	kind: literal("open-flow-workflow"),
 	version: literal(1),
 	name: string().optional(),
+	icon: string().optional(),
+	description: string().optional(),
 	content: unknown(),
 	presentation: record$1(string(), json$1()).optional()
 });
@@ -9936,6 +9938,170 @@ function workflowNameFromFile(name) {
 	return name.replace(/(?:\.openflow)?\.json$/i, "");
 }
 //#endregion
+//#region src/flow/common/workflowReferences.ts
+/** Rewrite only declared workflow identities, preserving business values and saved ports. */
+function mapNodeWorkflowTargets(node, map) {
+	if (node.kind != "task") return node;
+	const task = node.task;
+	if ("moduleId" in task) return task.capabilities?.some((item) => item.kind == "workflow") ? {
+		...node,
+		task: {
+			...task,
+			capabilities: task.capabilities.map((item) => item.kind == "workflow" ? Object.assign({}, item, map(item)) : item)
+		}
+	} : node;
+	const executor = task.executor;
+	if (executor.kind == "workflow") return {
+		...node,
+		task: {
+			...task,
+			executor: {
+				...executor,
+				...map(executor)
+			}
+		}
+	};
+	if (executor.kind == "agent") return {
+		...node,
+		task: {
+			...task,
+			executor: {
+				...executor,
+				tools: executor.tools.map((tool) => tool.kind == "workflow" ? Object.assign({}, tool, map(tool)) : tool)
+			}
+		}
+	};
+	return node;
+}
+/** 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/flow/common/workflowBundle.ts
+var entries$1 = array(strictObject({
+	flowId: string().min(1),
+	file: unknown()
+})).min(1);
+var bundleSchema = strictObject({
+	kind: literal("open-flow-workflow-bundle"),
+	version: literal(1),
+	entryFlowId: string().min(1),
+	workflows: entries$1
+});
+var previewSchema = strictObject({
+	version: literal(1),
+	entryFlowId: string().min(1),
+	workflows: entries$1,
+	unavailableFlowIds: array(string().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
+	});
+}
+function encodeWorkflowBundle(bundle) {
+	return `${JSON.stringify(cleanWorkflowBundle(bundle), null, 2)}\n`;
+}
+function parseWorkflowImportFile(text) {
+	const value = JSON.parse(text);
+	return value != null && typeof value == "object" && "kind" in value && value.kind == "open-flow-workflow-bundle" ? decodeWorkflowBundle(value) : decodeWorkflowFile(value);
+}
+/** A bundle creates new drafts, so old published interface provenance must be refreshed. */
+function remapWorkflowBundle(bundle, flowIds) {
+	const cleaned = cleanWorkflowBundle(bundle);
+	function identity(flowId) {
+		const mapped = flowIds.get(flowId);
+		if (mapped == null || mapped.length == 0) throw new TypeError("Missing imported workflow identity.");
+		return mapped;
+	}
+	const workflows = cleaned.workflows.map(({ flowId, file }) => ({
+		flowId: identity(flowId),
+		file: {
+			...file,
+			content: {
+				...file.content,
+				document: {
+					...file.content.document,
+					graph: {
+						...file.content.document.graph,
+						nodes: Object.fromEntries(Object.entries(file.content.document.graph.nodes).map(([id, node]) => [id, mapNodeWorkflowTargets(node, (target) => ({
+							flowId: target.flowId ? identity(target.flowId) : "",
+							revisionId: ""
+						}))]))
+					}
+				}
+			}
+		}
+	}));
+	return decodeWorkflowBundle({
+		...cleaned,
+		entryFlowId: identity(cleaned.entryFlowId),
+		workflows
+	});
+}
+//#endregion
 //#region src/flow/common/encoding.ts
 var encoder = new TextEncoder();
 function canonicalText(value) {
@@ -10315,4 +10481,4 @@ function repairRevision(bytes) {
 	return repairRevisionEnvelope(revisionValue(bytes));
 }
 //#endregion
-export { canonicalDocument, canonicalGraph, canonicalInputs, canonicalJsonBytes, canonicalModule, canonicalPorts, canonicalRevisionGraph, canonicalTask, cleanWorkflowFile, decodeFlowDocument, decodeRevision, decodeRevisionContent, decodeWorkflowFile, digestBytes, encodeRevision, encodeWorkflowFile, maxJsonDepth, parseWorkflowFile, repairRevision, revisionRepairKind, triggerRuntimeJson, upgradeRevisionContent, upgradeWorkflowInterfaceDocument, workflowFileName, workflowNameFromFile };
+export { canonicalDocument, canonicalGraph, canonicalInputs, canonicalJsonBytes, canonicalModule, canonicalPorts, canonicalRevisionGraph, canonicalTask, cleanWorkflowBundle, cleanWorkflowFile, decodeFlowDocument, decodeRevision, decodeRevisionContent, decodeWorkflowBundle, decodeWorkflowExportPreview, decodeWorkflowFile, digestBytes, encodeRevision, encodeWorkflowBundle, encodeWorkflowFile, maxJsonDepth, parseWorkflowFile, parseWorkflowImportFile, remapWorkflowBundle, repairRevision, revisionRepairKind, triggerRuntimeJson, upgradeRevisionContent, upgradeWorkflowInterfaceDocument, workflowBundleFromPreview, workflowFileName, workflowNameFromFile };

package/dist/common/flow-semantics.js

@@ -22,6 +22,21 @@ function dequal(foo, bar) {
 	return foo !== foo && bar !== bar;
 }
 //#endregion
+//#region src/connector/common/actionContract.ts
+/** These rules also apply to existing Revision snapshots without a catalog lookup. */
+var connectorActionContracts = { "leina.send_notification": {
+	inputConstraints: [{
+		handle: "leinaId",
+		jsonSchema: {
+			type: "string",
+			pattern: "\\S"
+		},
+		code: "leina.robot-required",
+		message: "Select a Leina robot or bind its identifier to an input source."
+	}],
+	pendingMessageInput: "message"
+} };
+//#endregion
 //#region ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/deep-compare-strict.js
 function deepCompareStrict(a, b) {
 	const typeofa = typeof a;
@@ -12321,10 +12336,30 @@ strictObject({
 	kind: literal("open-flow-workflow"),
 	version: literal(1),
 	name: string().optional(),
+	icon: string().optional(),
+	description: string().optional(),
 	content: unknown(),
 	presentation: record$1(string(), json$1()).optional()
 });
 //#endregion
+//#region src/flow/common/workflowBundle.ts
+var entries$2 = array(strictObject({
+	flowId: string().min(1),
+	file: unknown()
+})).min(1);
+strictObject({
+	kind: literal("open-flow-workflow-bundle"),
+	version: literal(1),
+	entryFlowId: string().min(1),
+	workflows: entries$2
+});
+strictObject({
+	version: literal(1),
+	entryFlowId: string().min(1),
+	workflows: entries$2,
+	unavailableFlowIds: array(string().min(1))
+});
+//#endregion
 //#region src/flow/common/encoding.ts
 var encoder = new TextEncoder();
 function canonicalText(value) {
@@ -25089,15 +25124,17 @@ async function validateFlow(revision, engine) {
 			message,
 			path: `/document/graph/nodes/${nodeId}/task/executor`
 		});
-		if (task.executor.kind == "connector" && task.executor.action == "leina.send_notification") {
-			const mapping = node.inputs.leinaId;
-			const value = inputValue(mapping, nodeInputPorts(node).leinaId?.value);
-			if ((mapping?.kind != "sources" || mapping.sources.length == 0) && (typeof value != "string" || value.trim().length == 0)) checked.diagnostics.push({
-				code: "leina.robot-required",
+		if (task.executor.kind == "connector") for (const constraint of connectorActionContracts[task.executor.action]?.inputConstraints ?? []) {
+			const mapping = node.inputs[constraint.handle];
+			if (mapping?.kind == "sources" && mapping.sources.length > 0) continue;
+			const value = inputValue(mapping, nodeInputPorts(node)[constraint.handle]?.value);
+			if (value !== void 0 && matchesSchema(value, constraint.jsonSchema)) continue;
+			checked.diagnostics.push({
+				code: constraint.code,
 				column: 0,
 				line: 1,
-				message: "Select a Leina robot or bind its identifier to an input source.",
-				path: `/document/graph/nodes/${nodeId}/inputs/leinaId`
+				message: constraint.message,
+				path: `/document/graph/nodes/${nodeId}/inputs/${constraint.handle}`
 			});
 		}
 		if (task.executor.kind == "connector" && task.executor.action.length == 0) checked.diagnostics.push({

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

@@ -0,0 +1,27 @@
+import type { WorkflowFile } from './flow-workflowFile.js';
+export interface WorkflowBundleEntry {
+    readonly flowId: string;
+    readonly file: WorkflowFile;
+}
+export interface WorkflowBundle {
+    readonly kind: 'open-flow-workflow-bundle';
+    readonly version: 1;
+    readonly entryFlowId: string;
+    readonly workflows: readonly WorkflowBundleEntry[];
+}
+/** A saved export snapshot; unavailable targets carry no account metadata. */
+export interface WorkflowExportPreview {
+    readonly version: 1;
+    readonly entryFlowId: string;
+    readonly workflows: readonly WorkflowBundleEntry[];
+    readonly unavailableFlowIds: readonly string[];
+}
+export declare function decodeWorkflowBundle(value: unknown): WorkflowBundle;
+export declare function decodeWorkflowExportPreview(value: unknown): WorkflowExportPreview;
+export declare function cleanWorkflowBundle(value: unknown): WorkflowBundle;
+export declare function workflowBundleFromPreview(preview: WorkflowExportPreview): WorkflowBundle;
+export declare function encodeWorkflowBundle(bundle: WorkflowBundle): string;
+export type WorkflowImportFile = WorkflowFile | WorkflowBundle;
+export declare function parseWorkflowImportFile(text: string): WorkflowImportFile;
+/** A bundle creates new drafts, so old published interface provenance must be refreshed. */
+export declare function remapWorkflowBundle(bundle: WorkflowBundle, flowIds: ReadonlyMap<string, string>): WorkflowBundle;

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

@@ -3,6 +3,8 @@ export interface WorkflowFile {
     readonly kind: 'open-flow-workflow';
     readonly version: 1;
     readonly name?: string;
+    readonly icon?: string;
+    readonly description?: string;
     readonly content: RevisionContent;
     readonly presentation?: Readonly<Record<string, JsonValue>>;
 }

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;
                     };
                 } | {