@oomol-lab/open-flow 0.1.0-beta.74 → 0.1.0-beta.76

package/dist/common/flow-encoding.js

@@ -1,12 +1,3 @@
-//#region src/openapi/common/authBindings.ts
-/** Never allow credentials to enter a Revision as literal node inputs. */
-function assertOpenApiAuthBindings(document) {
-	for (const node of Object.values(document.graph.nodes)) {
-		if (node.kind != "task" || !("executor" in node.task) || node.task.executor.kind != "openapi") continue;
-		for (const [handle, mapping] of Object.entries(node.inputs)) if (handle.startsWith("auth.") && mapping.kind == "value") throw new TypeError("OpenAPI 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,66 @@ 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"),
+	names: array(string()).default([])
+});
+var httpRequestExecutorSchema = strictObject({
+	method: _enum([
+		"GET",
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE",
+		"HEAD",
+		"OPTIONS"
+	]).default("GET"),
+	query: parameterSchema.default({
+		mode: "fields",
+		names: []
+	}),
+	headers: parameterSchema.default({
+		mode: "fields",
+		names: []
+	}),
+	bodyFormat: _enum([
+		"none",
+		"json",
+		"text",
+		"form"
+	]).default("none"),
+	authentication: union([
+		strictObject({ type: literal("none") }),
+		strictObject({ type: _enum(["bearer", "basic"]) }),
+		strictObject({
+			type: literal("apiKey"),
+			name: string(),
+			in: _enum(["header", "query"])
+		})
+	]).default({ type: "none" }),
+	responseFormat: _enum([
+		"auto",
+		"json",
+		"text"
+	]).default("auto"),
+	statusPolicy: _enum(["success", "all"]).default("success")
+}).extend({ kind: literal("http-request") });
+//#endregion
 //#region src/flow/common/json.ts
 var maxJsonDepth = 64;
 function checkJsonDepth(value, depth = 0) {
@@ -8718,7 +8772,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,
@@ -8828,7 +8889,8 @@ var managedFields = object({
 			kind: literal("workflow"),
 			flowId: text,
 			revisionId: text
-		})
+		}),
+		httpRequestExecutorSchema
 	])
 });
 var managed = managedFields.transform(limitDecisionTask);
@@ -9081,7 +9143,8 @@ var revision = object({
 		literal(8),
 		literal(9),
 		literal(10),
-		literal(11)
+		literal(11),
+		literal(12)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -9336,14 +9399,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 > 12) 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: 12,
 		document: {
 			bindings: repairedEntries(sourceDocument.bindings, binding),
 			graph: sourceGraph
@@ -9359,7 +9422,7 @@ function decodeRevisionContent(value) {
 	checkJsonDepth(value);
 	const content = revision.parse(value);
 	checkModelVersion(content);
-	assertOpenApiAuthBindings(content.document);
+	assertDocumentHttpAuthBindings(content.document);
 	return content;
 }
 function decodeRevisionEnvelope(value) {
@@ -9371,7 +9434,7 @@ function decodeRevisionEnvelope(value) {
 	} : value;
 	const content = envelope$1.parse(candidate);
 	checkModelVersion(content);
-	assertOpenApiAuthBindings(content.document);
+	assertDocumentHttpAuthBindings(content.document);
 	return {
 		modelVersion: content.modelVersion,
 		document: content.document,
@@ -9545,6 +9608,8 @@ array(union([...new Map(Object.entries(shapes).map(([kind, shape]) => [kind, sha
 	...shape
 })])).values()])).min(1);
 function checkModelVersion(content) {
+	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.");
 	if (content.modelVersion < 9 && Object.values(content.document.graph.nodes).some((candidateNode) => "retry" in candidateNode && candidateNode.retry != null)) throw new TypeError("Node retries require Flow model version 9.");
@@ -9559,6 +9624,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) {
@@ -9601,10 +9669,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 == 12) return content;
 	return {
 		...content,
-		modelVersion: 11,
+		modelVersion: 12,
 		document: {
 			...content.document,
 			graph: hasManual ? {
@@ -9680,7 +9748,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;
@@ -10176,7 +10244,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 < 12 ? "upgrade" : "repair";
 }
 function repairRevision(bytes) {
 	return repairRevisionEnvelope(revisionValue(bytes));

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

@@ -1,3 +1,4 @@
+import type { InputPort } from './flow-change.js';
 import type { Graph, GraphNode, InputPortDefinition, NodeSource, PortDefinition, RevisionContent, SchemaMismatch } from './flow-change.js';
 import type { Diagnostic } from './flow-semantics.js';
 export declare function isResolutionNode(node: GraphNode | undefined): node is Extract<GraphNode, {
@@ -58,7 +59,7 @@ export interface InputSourcesCheck {
 export declare function checkInputSource(graph: Graph, target: string, handle: string, source: Pick<NodeSource, 'nodeId' | 'output' | 'field' | 'system'>): InputSourceCheck;
 export declare function checkInputSources(graph: Graph, target: string, handle: string, sources: readonly Pick<NodeSource, 'nodeId' | 'output' | 'field' | 'system'>[]): InputSourcesCheck;
 /** Enumerate structurally available outputs while retaining their compatibility with one input. */
-export declare function inputSourceCandidates(graph: Graph, target: string, handle: string): Readonly<Record<string, readonly InputSourceCandidate[]>>;
+export declare function inputSourceCandidates(graph: Graph, target: string, handle: string, inputPort?: InputPort): Readonly<Record<string, readonly InputSourceCandidate[]>>;
 export declare function availableOutputs(graph: Graph, target: string, handle: string | undefined): Readonly<Record<string, readonly string[]>>;
 export declare function validateFlowGraph(revision: RevisionContent): readonly Diagnostic[];
 export {};

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,10 +1,8 @@
 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 declare const retryNodeTypes: readonly ['code', 'connector', 'openapi', 'llm', 'decision'];
+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;
     readonly minIntervalMs: 1000;