@oomol-lab/open-flow 0.1.0-beta.75 → 0.1.0-beta.77

package/dist/common/flow-encoding.js

@@ -1,12 +1,3 @@
-//#region src/http/common/authBindings.ts
-/** Never allow credentials to enter a Revision as literal node inputs. */
-function assertHttpAuthBindings(document) {
-	for (const node of Object.values(document.graph.nodes)) {
-		if (node.kind != "task" || !("executor" in node.task) || !["openapi", "http-request"].includes(node.task.executor.kind)) continue;
-		for (const [handle, mapping] of Object.entries(node.inputs)) if (handle.startsWith("auth.") && mapping.kind == "value") throw new TypeError("HTTP authentication accepts deployment variables and upstream outputs only.");
-	}
-}
-//#endregion
 //#region ../../node_modules/.bun/dequal@2.0.3/node_modules/dequal/lite/index.mjs
 var has = Object.prototype.hasOwnProperty;
 function dequal(foo, bar) {
@@ -8462,6 +8453,9 @@ function createSchemaComparer() {
 createSchemaComparer();
 //#endregion
 //#region src/decision/common/decision.ts
+function isDecisionExecutor(executor) {
+	return executor.kind === "decision";
+}
 var decisionLimits = {
 	choice: 255,
 	score: 10
@@ -8484,7 +8478,7 @@ function limitDecisionQuestions(questions) {
 }
 /** Loading an oversized task also updates its previously generated output schemas. */
 function limitDecisionTask(task) {
-	if (task.executor.kind !== "decision") return task;
+	if (!isDecisionExecutor(task.executor)) return task;
 	const original = task.executor.questions;
 	const questions = limitDecisionQuestions(original);
 	if (questions === original) return task;
@@ -8551,6 +8545,20 @@ function answerSchema(question) {
 	};
 }
 //#endregion
+//#region src/http/common/authBindings.ts
+/** Never allow credentials to enter a Revision as literal inputs of an OpenAPI or HTTP request node. */
+function assertHttpAuthBindings(inputs) {
+	for (const [handle, mapping] of Object.entries(inputs)) if (handle.startsWith("auth.") && mapping.kind == "value") throw new TypeError("HTTP authentication accepts deployment variables and upstream outputs only.");
+}
+//#endregion
+//#region src/http/common/hosts.ts
+/** Hosts of a Code `http` Capability: lowercase DNS names or IPv4 addresses; `*.example.com` matches subdomains only. */
+var httpHostPattern = /^(?:\*\.)?(?=.{1,253}$)(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)*[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+/** Wildcards must name a registrable suffix, so `*.com` is rejected. */
+function isHttpHost(value) {
+	return httpHostPattern.test(value) && (!value.startsWith("*.") || value.slice(2).includes("."));
+}
+//#endregion
 //#region src/http/common/httpRequest.ts
 var parameterSchema = strictObject({
 	mode: _enum(["fields", "object"]).default("fields"),
@@ -8596,6 +8604,51 @@ var httpRequestExecutorSchema = strictObject({
 	]).default("auto"),
 	statusPolicy: _enum(["success", "all"]).default("success")
 }).extend({ kind: literal("http-request") });
+strictObject({
+	scope: _enum(["draft", "live"]),
+	values: boolean().optional()
+});
+strictObject({
+	scope: _enum(["draft", "live"]),
+	key: string().min(1).refine((key) => new TextEncoder().encode(key).length <= 256).optional()
+});
+strictObject({
+	scope: _enum(["draft", "live"]),
+	space: string().regex(/^(flow|node:.+)$/)
+});
+var dedupeExecutorSchema = strictObject({
+	field: string().default(""),
+	mode: _enum(["new", "increasing"]).default("new"),
+	space: _enum(["node", "flow"]).default("node")
+}).extend({ kind: literal("dedupe") });
+object({
+	version: literal(1),
+	scope: _enum(["draft", "live"]),
+	limits: object({
+		maxValueBytes: number().positive(),
+		maxValues: number().int().positive(),
+		maxSpaces: number().int().positive(),
+		maxIdentities: number().positive(),
+		maxRunWrites: number().positive()
+	}),
+	values: array(object({
+		key: string(),
+		size: number().nonnegative(),
+		updatedAt: number(),
+		value: json$1().optional()
+	})),
+	spaces: array(object({
+		space: string(),
+		mode: _enum(["new", "increasing"]),
+		count: number().nonnegative(),
+		watermark: union([
+			string(),
+			number(),
+			_null()
+		]),
+		updatedAt: number()
+	}))
+});
 //#endregion
 //#region src/flow/common/json.ts
 var maxJsonDepth = 64;
@@ -8764,7 +8817,14 @@ var workflowCapabilitySchema = strictObject({
 	inputs: array(port),
 	outputs: array(port).nullable()
 });
-var capability = union([connectorCapabilitySchema, workflowCapabilitySchema]);
+var capability = union([
+	connectorCapabilitySchema,
+	workflowCapabilitySchema,
+	strictObject({
+		kind: literal("http"),
+		hosts: array(text.refine(isHttpHost, "Use a lowercase host name or IPv4 address, optionally prefixed by \"*.\" for subdomains.")).min(1).max(20).describe("Hosts Code may call with context.fetch. \"*.example.com\" matches subdomains only.")
+	})
+]);
 var inline = object({
 	...ports,
 	name: text,
@@ -8875,7 +8935,8 @@ var managedFields = object({
 			flowId: text,
 			revisionId: text
 		}),
-		httpRequestExecutorSchema
+		httpRequestExecutorSchema,
+		dedupeExecutorSchema
 	])
 });
 var managed = managedFields.transform(limitDecisionTask);
@@ -9128,7 +9189,9 @@ var revision = object({
 		literal(8),
 		literal(9),
 		literal(10),
-		literal(11)
+		literal(11),
+		literal(12),
+		literal(13)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -9383,14 +9446,14 @@ function repairRevisionEnvelope(value) {
 	checkJsonDepth(value);
 	const envelopeSource = record(value);
 	if (envelopeSource.kind != "open-flow-flow-revision" || envelopeSource.version != 1) throw new TypeError("The value is not an Open Flow Revision envelope.");
-	if (typeof envelopeSource.modelVersion == "number" && envelopeSource.modelVersion > 11) throw new TypeError("The Flow model is newer than this package.");
+	if (typeof envelopeSource.modelVersion == "number" && envelopeSource.modelVersion > 13) throw new TypeError("The Flow model is newer than this package.");
 	let sourceDocument = record(envelopeSource.modelVersion == 1 || envelopeSource.modelVersion == 2 ? upgradeLegacyDocument(envelopeSource.document) : envelopeSource.document);
 	if (typeof envelopeSource.modelVersion == "number" && envelopeSource.modelVersion < 6) sourceDocument = upgradeTaskNodes(sourceDocument);
 	sourceDocument = record(normalizeDocument(sourceDocument));
 	const bindings = record(sourceDocument.bindings);
 	const sourceGraph = repairGraph(sourceDocument.graph, bindings);
 	return decodeRevisionContent({
-		modelVersion: 11,
+		modelVersion: 13,
 		document: {
 			bindings: repairedEntries(sourceDocument.bindings, binding),
 			graph: sourceGraph
@@ -9406,7 +9469,7 @@ function decodeRevisionContent(value) {
 	checkJsonDepth(value);
 	const content = revision.parse(value);
 	checkModelVersion(content);
-	assertHttpAuthBindings(content.document);
+	assertDocumentHttpAuthBindings(content.document);
 	return content;
 }
 function decodeRevisionEnvelope(value) {
@@ -9418,7 +9481,7 @@ function decodeRevisionEnvelope(value) {
 	} : value;
 	const content = envelope$1.parse(candidate);
 	checkModelVersion(content);
-	assertHttpAuthBindings(content.document);
+	assertDocumentHttpAuthBindings(content.document);
 	return {
 		modelVersion: content.modelVersion,
 		document: content.document,
@@ -9592,6 +9655,8 @@ array(union([...new Map(Object.entries(shapes).map(([kind, shape]) => [kind, sha
 	...shape
 })])).values()])).min(1);
 function checkModelVersion(content) {
+	if (content.modelVersion < 13 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind === "task" && "executor" in candidateNode.task && candidateNode.task.executor.kind === "dedupe")) throw new Error("Deduplication requires Flow model v13.");
+	if (content.modelVersion < 12 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "task" && "moduleId" in candidateNode.task && candidateNode.task.capabilities?.some((item) => item.kind == "http"))) throw new TypeError("Code HTTP access requires Flow model version 12.");
 	if (content.modelVersion < 11 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "task" && "executor" in candidateNode.task && candidateNode.task.executor.kind == "http-request")) throw new TypeError("HTTP Request requires Flow model version 11.");
 	if (content.modelVersion < 11 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "task" && ("moduleId" in candidateNode.task ? candidateNode.task.capabilities?.some((item) => item.kind == "workflow") : candidateNode.task.executor.kind == "agent" && candidateNode.task.executor.tools.some((item) => item.kind == "workflow")))) throw new TypeError("Workflow tools require Flow model version 11.");
 	if (content.modelVersion < 10 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "webhook" && (candidateNode.options?.responseBody != null || candidateNode.options?.responseStatusCodeOutput != null || candidateNode.options?.responseHeadersSource != null || candidateNode.options?.responseHeaderOutputs != null))) throw new TypeError("Dynamic Webhook responses require Flow model version 10.");
@@ -9607,6 +9672,9 @@ function checkModelVersion(content) {
 	if (content.modelVersion < 6 && Object.values(content.document.graph.nodes).some((candidateNode) => candidateNode.kind == "task" && "executor" in candidateNode.task)) throw new TypeError("Node-owned managed Tasks require Flow model version 6.");
 	if (content.modelVersion < 5 && Object.values(content.document.graph.nodes).some((itemNode) => itemNode.kind == "error")) throw new TypeError("Error workflows require Flow model version 5.");
 }
+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) {
@@ -9649,10 +9717,10 @@ function upgradeRevisionContent(content) {
 function upgradeDecodedRevisionContent(content) {
 	const graph = content.document.graph;
 	const hasManual = Object.values(graph.nodes).some((node) => node.kind == "manual");
-	if (!hasManual && content.modelVersion == 11) return content;
+	if (!hasManual && content.modelVersion == 13) return content;
 	return {
 		...content,
-		modelVersion: 11,
+		modelVersion: 13,
 		document: {
 			...content.document,
 			graph: hasManual ? {
@@ -9728,7 +9796,7 @@ function clearNodeConnections(graph, connectionId) {
 				return [id, node];
 			}
 			const capabilities = node.task.capabilities?.map((capability) => {
-				if (capability.kind == "workflow") return capability;
+				if (capability.kind == "workflow" || capability.kind == "http") return capability;
 				if (!("mode" in capability)) {
 					if ("action" in capability) {
 						const { connectionId: selected, ...rest } = capability;
@@ -10224,7 +10292,7 @@ function revisionRepairKind(bytes) {
 		return;
 	}
 	const source = value;
-	return typeof source.modelVersion == "number" && source.modelVersion < 11 ? "upgrade" : "repair";
+	return typeof source.modelVersion == "number" && source.modelVersion < 13 ? "upgrade" : "repair";
 }
 function repairRevision(bytes) {
 	return repairRevisionEnvelope(revisionValue(bytes));

package/dist/common/flow-input-value.d.ts

@@ -1,4 +1,4 @@
-import type { FixedInputValue, InputValues, InputMapping, JsonValue } from './flow-change.js';
+import type { FixedInputValue, InputValues, InputMapping, JsonValue } from './flow-model.js';
 /** An explicit clear suppresses the default; absent mappings still inherit it. */
 export declare function inputValue(mapping: InputMapping | undefined, fallback: JsonValue | undefined): JsonValue | undefined;
 /** Converts explicit user values at authoring boundaries, never persisted legacy data. */

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

@@ -0,0 +1,121 @@
+import type { JsonValue, Port, PortDefinition } from '../index.js';
+export type { JsonValue, Port, PortDefinition } from '../index.js';
+/** Primitives shared by every node family. Node unions and graph operations belong to change.ts. */
+export interface RetryConfiguration {
+    readonly maxRetries: number;
+    readonly intervalMs: number;
+}
+export interface InputPortDefinition extends PortDefinition {
+    readonly value?: JsonValue;
+}
+export interface InputPort extends InputPortDefinition {
+    readonly handle: string;
+}
+export interface Group {
+    readonly collapsed?: boolean;
+    readonly group: string;
+}
+export declare function portsByHandle<Value extends Port>(ports: readonly (Value | Group)[]): Readonly<Record<string, Value>>;
+export interface NodeSource {
+    readonly system?: true;
+    readonly field?: string;
+    readonly kind: 'node';
+    readonly nodeId: string;
+    readonly output: string;
+}
+export interface BindingSource {
+    readonly bindingId: string;
+    readonly kind: 'binding';
+}
+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 | NodeSource)[];
+};
+export interface GraphNodeBase {
+    readonly description?: string;
+    readonly icon?: string;
+    readonly inputs: Readonly<Record<string, InputMapping>>;
+    readonly name?: string;
+    readonly maxExecutions?: number;
+    readonly timeoutMs?: number;
+    readonly retry?: RetryConfiguration;
+    readonly onError?: 'stop' | 'error';
+}
+export type Source = BindingSource | NodeSource;
+export interface WorkflowCapability {
+    readonly kind: 'workflow';
+    readonly name: string;
+    readonly flowId: string;
+    readonly revisionId: string;
+    readonly inputs: readonly Port[];
+    readonly outputs: readonly Port[] | null;
+}
+/** Hosts that Code may call through `context.fetch`; requires Flow model 12 and Engine v9. */
+export interface HttpCapability {
+    readonly kind: 'http';
+    readonly hosts: readonly string[];
+}
+export type TaskCapability = ConnectorCapability | WorkflowCapability | HttpCapability;
+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 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 interface TaskDefinitionBase {
+    readonly inputs: readonly (InputPort | Group)[];
+    readonly name: string;
+    readonly outputs: readonly (Port | Group)[];
+}
+export interface InlineTaskDefinition extends TaskDefinitionBase {
+    readonly capabilities?: readonly TaskCapability[];
+    readonly moduleId: string;
+}
+/** The executor shape every managed Task shares; each node family narrows it with its own executor. */
+export interface TaskExecutor {
+    readonly kind: string;
+}
+export interface ManagedTaskDefinitionOf<Executor extends TaskExecutor> extends TaskDefinitionBase {
+    readonly executor: Executor;
+}
+export interface WorkflowExecutor {
+    readonly kind: 'workflow';
+    readonly flowId: string;
+    readonly revisionId: string;
+}
+export interface CodeModule {
+    readonly imports: readonly string[];
+    readonly name: string;
+    readonly source: string;
+}

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

@@ -1,4 +1,4 @@
-import type { CanvasCommand } from '../common/canvas-commands.js';
+import type { CanvasCommand } from './canvas-commands.js';
 export type FlowCatalogEvent = {
     readonly kind: 'flows.changed';
     readonly version: 1;

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

@@ -1,9 +1,7 @@
 import type { GraphNode } from './flow-change.js';
+import type { RetryConfiguration } from './flow-model.js';
 import { z } from 'zod';
-export interface RetryConfiguration {
-    readonly maxRetries: number;
-    readonly intervalMs: number;
-}
+export type { RetryConfiguration } from './flow-model.js';
 export declare const retryNodeTypes: readonly ['code', 'connector', 'openapi', 'http-request', 'llm', 'decision'];
 export declare const nodeRetryLimits: {
     readonly maxRetries: 5;