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

package/dist/common/flow-semantics.js

@@ -3973,6 +3973,9 @@ function hasRetiredRef(value) {
 }
 //#endregion
 //#region src/decision/common/decision.ts
+function isDecisionExecutor(executor) {
+	return executor.kind === "decision";
+}
 var decisionLimits = {
 	choice: 255,
 	score: 10
@@ -3995,7 +3998,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;
@@ -4120,7 +4123,7 @@ function decisionTask(questions = [defaultDecisionQuestion()], name = "AI Decisi
 }
 function decisionTaskIssues(task) {
 	task = limitDecisionTask(task);
-	if (task.executor.kind !== "decision") return [];
+	if (!isDecisionExecutor(task.executor)) return [];
 	const expected = decisionTask(task.executor.questions, task.name);
 	return [...decisionQuestionIssues(task.executor.questions), ...!dequal(task.inputs, expected.inputs) || !dequal(task.outputs, expected.outputs) ? [{
 		field: "ports",
@@ -9809,6 +9812,14 @@ function httpHeaderNameIssue(name, names) {
 	if (names.some((candidate) => candidate.toLowerCase() === name.toLowerCase())) return "duplicate";
 }
 //#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"),
@@ -10189,6 +10200,9 @@ function schema$1(doc, schemaValue) {
 		...Object.keys(defs).length ? { $defs: defs } : {}
 	};
 }
+function isOpenApiExecutor(executor) {
+	return executor.kind == "openapi";
+}
 function parameters(config) {
 	const doc = parseOpenApi(config.document);
 	const { item, op } = operation(doc, config.path, config.method);
@@ -10310,7 +10324,7 @@ function inlineSchema(value, index) {
 }
 /** The canvas validator and property panel share the same configuration contract. */
 function openApiFieldIssues(task) {
-	if (task.executor.kind != "openapi") return [];
+	if (!isOpenApiExecutor(task.executor)) return [];
 	const config = task.executor;
 	let field = "sourceUrl";
 	try {
@@ -10348,66 +10362,71 @@ function openApiFieldIssues(task) {
 function openApiIssues(task) {
 	return openApiFieldIssues(task).map((issue) => issue.message);
 }
-//#endregion
-//#region src/workflow/common/workflow.ts
-var portSchema = object$1({
-	handle: string().min(1),
-	jsonSchema: json$1(),
-	nullable: boolean(),
-	description: string().optional()
+strictObject({
+	scope: _enum(["draft", "live"]),
+	values: boolean().optional()
 });
 strictObject({
-	inputs: array(portSchema).nullable(),
-	outputs: array(portSchema).nullable()
+	scope: _enum(["draft", "live"]),
+	key: string().min(1).refine((key) => new TextEncoder().encode(key).length <= 256).optional()
 });
-object$1({
-	version: literal(1),
-	flowId: string().min(1),
-	name: string(),
-	revisionId: string().min(1),
-	publicationId: string().min(1),
-	inputs: array(portSchema),
-	outputs: array(portSchema).nullable()
+strictObject({
+	scope: _enum(["draft", "live"]),
+	space: string().regex(/^(flow|node:.+)$/)
+});
+var dedupeConfigSchema = strictObject({
+	field: string().default(""),
+	mode: _enum(["new", "increasing"]).default("new"),
+	space: _enum(["node", "flow"]).default("node")
 });
+var dedupeExecutorSchema = dedupeConfigSchema.extend({ kind: literal("dedupe") });
+function dedupeTask(config = dedupeConfigSchema.parse({}), name = "Remove Duplicates") {
+	return {
+		name,
+		executor: {
+			...config,
+			kind: "dedupe"
+		},
+		inputs: [{
+			handle: "items",
+			jsonSchema: { type: "array" },
+			nullable: false
+		}],
+		outputs: ["items", "duplicates"].map((handle) => ({
+			handle,
+			jsonSchema: { type: "array" },
+			nullable: false
+		}))
+	};
+}
 object$1({
 	version: literal(1),
-	direction: _enum(["incoming", "outgoing"]),
-	total: int().nonnegative(),
-	nextOffset: int().nonnegative().optional(),
-	references: array(object$1({
-		flowId: string(),
-		name: string().nullable(),
-		available: boolean(),
-		draft: boolean(),
-		live: object$1({
-			publicationId: string(),
-			enabled: boolean()
-		}).nullable()
+	scope: _enum(["draft", "live"]),
+	limits: object$1({
+		maxValueBytes: number().positive(),
+		maxValues: number().int().positive(),
+		maxSpaces: number().int().positive(),
+		maxIdentities: number().positive(),
+		maxRunWrites: number().positive()
+	}),
+	values: array(object$1({
+		key: string(),
+		size: number().nonnegative(),
+		updatedAt: number(),
+		value: json$1().optional()
+	})),
+	spaces: array(object$1({
+		space: string(),
+		mode: _enum(["new", "increasing"]),
+		count: number().nonnegative(),
+		watermark: union([
+			string(),
+			number(),
+			_null()
+		]),
+		updatedAt: number()
 	}))
 });
-/** 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/inputValue.ts
 /** An explicit clear suppresses the default; absent mappings still inherit it. */
@@ -10664,7 +10683,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$1({
 	...ports,
 	name: text,
@@ -10775,7 +10801,8 @@ var managedFields = object$1({
 			flowId: text,
 			revisionId: text
 		}),
-		httpRequestExecutorSchema
+		httpRequestExecutorSchema,
+		dedupeExecutorSchema
 	])
 });
 var managed = managedFields.transform(limitDecisionTask);
@@ -11044,7 +11071,9 @@ object$1({
 		literal(8),
 		literal(9),
 		literal(10),
-		literal(11)
+		literal(11),
+		literal(12),
+		literal(13)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -11390,7 +11419,7 @@ var nodeErrorSchema = {
 	}
 };
 function supportsNodeErrorHandling(node) {
-	return supportsNodeRetry(node);
+	return supportsNodeRetry(node) || node.kind === "task" && "executor" in node.task && node.task.executor.kind === "dedupe";
 }
 function nodeSystemOutputPorts(node) {
 	return supportsNodeErrorHandling(node) && node.onError == "error" ? { error: {
@@ -11399,13 +11428,15 @@ function nodeSystemOutputPorts(node) {
 	} } : {};
 }
 //#endregion
+//#region src/flow/common/model.ts
+function portsByHandle(ports) {
+	return Object.fromEntries(ports.flatMap((port) => "handle" in port ? [[port.handle, port]] : []));
+}
+//#endregion
 //#region src/flow/common/change.ts
 function validVariableName(value) {
 	return value.length <= 256 && /^[A-Za-z_][A-Za-z0-9_]*$/.test(value) && value.slice(0, 3).toUpperCase() != "OO_";
 }
-function portsByHandle(ports) {
-	return Object.fromEntries(ports.flatMap((port) => "handle" in port ? [[port.handle, port]] : []));
-}
 var workflowToolNamePattern = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
 function workflowToolNameIssue(name, otherNames = []) {
 	if (!workflowToolNamePattern.test(name)) return "invalid";
@@ -11421,6 +11452,8 @@ function decodeTaskCapabilities(value) {
 		if (workflowToolNameIssue(item.name, names)) throw new TypeError("Workflow tool names must be unique provider-compatible names.");
 		names.add(item.name);
 	}
+	const http = parsed.filter((item) => item.kind == "http");
+	if (http.length > 1 || http.some((item) => new Set(item.hosts).size != item.hosts.length)) throw new TypeError("Code declares HTTP hosts once, without duplicates.");
 	let connectorIndex = 0;
 	return parsed.map((item) => item.kind == "connector" ? connectors[connectorIndex++] : item);
 }
@@ -11549,6 +11582,31 @@ function isTriggerNode(node) {
 	].includes(node.kind);
 }
 //#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/flow/common/promptTemplate.ts
 var promptReferencePattern = /\{\{\s*([^{}\s]+)\s*\}\}/g;
 function renderPrompt(template, input) {
@@ -11643,7 +11701,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;
@@ -11888,22 +11946,25 @@ function normalizeTriggerOutputs(trigger, outputs) {
 	return matchesTriggerOutputs(trigger, normalized) ? normalized : void 0;
 }
 //#endregion
-//#region src/execution/common/engineContract.ts
-var currentEngineContract = "open-flow-engine/v8";
+//#region src/runtime/common/engineContract.ts
+/** v10 adds persistent Flow State to the published v9 Node compatibility and fetch contract. */
+var currentEngineContract = "open-flow-engine/v10";
+/** The published v8 Node compatibility contract, retained for existing Publications and Runs. */
 var nodejsEngineContract = "open-flow-engine/v8/nodejs-compat-v1";
-var currentContract = {
+var platformSource = (contract) => `export const engineContract = ${JSON.stringify(contract)}
+export function identity(value) { return value }
+`;
+var v8Contract = {
 	workflowTools: true,
 	httpRequests: true,
 	waitAutoContinue: true,
 	webhookResponses: true,
 	platformExports: /* @__PURE__ */ new Set(["engineContract", "identity"]),
 	platformModule: "open-flow:platform",
-	platformSource: `export const engineContract = ${JSON.stringify(currentEngineContract)}
-export function identity(value) { return value }
-`
+	platformSource: platformSource("open-flow-engine/v8")
 };
 var nodejsContract = {
-	...currentContract,
+	...v8Contract,
 	builtinModules: new Set([
 		"assert",
 		"assert/strict",
@@ -11930,28 +11991,36 @@ var nodejsContract = {
 		"util",
 		"zlib"
 	].flatMap((name) => [name, `node:${name}`])),
-	platformSource: `export const engineContract = ${JSON.stringify(nodejsEngineContract)}
-export function identity(value) { return value }
-`
+	platformSource: platformSource(nodejsEngineContract)
+};
+var v9Contract = {
+	...nodejsContract,
+	codeFetch: true,
+	platformSource: platformSource("open-flow-engine/v9")
+};
+var currentContract = {
+	...v9Contract,
+	flowState: true,
+	platformSource: platformSource(currentEngineContract)
 };
 function findEngineContract(contract) {
-	if (contract == "open-flow-engine/v8") return currentContract;
+	if (contract == "open-flow-engine/v10") return currentContract;
+	if (contract == "open-flow-engine/v9") return v9Contract;
+	if (contract == "open-flow-engine/v8") return v8Contract;
 	if (contract == "open-flow-engine/v8/nodejs-compat-v1") return nodejsContract;
 	if (contract == "open-flow-engine/v7" || contract == "open-flow-engine/v7/nodejs-compat-v1") return {
-		...contract.endsWith("/nodejs-compat-v1") ? nodejsContract : currentContract,
+		...contract.endsWith("/nodejs-compat-v1") ? nodejsContract : v8Contract,
 		workflowTools: false,
 		httpRequests: false,
-		platformSource: `export const engineContract = ${JSON.stringify(contract)}\nexport function identity(value) { return value }\n`
+		platformSource: platformSource(contract)
 	};
 	if (contract == "open-flow-engine/v6" || contract == "open-flow-engine/v6/nodejs-compat-v1") return {
-		...contract == "open-flow-engine/v6" ? currentContract : nodejsContract,
+		...contract == "open-flow-engine/v6" ? v8Contract : nodejsContract,
 		workflowTools: false,
 		httpRequests: false,
 		waitAutoContinue: false,
 		webhookResponses: false,
-		platformSource: `export const engineContract = ${JSON.stringify(contract)}
-export function identity(value) { return value }
-`
+		platformSource: platformSource(contract)
 	};
 }
 //#endregion
@@ -24938,6 +25007,16 @@ async function validateFlow(revision, engine) {
 			message,
 			path: `/document/graph/nodes/${nodeId}/task/executor`
 		});
+		if (task.executor.kind === "dedupe") {
+			const expected = dedupeTask(task.executor);
+			if (!dequal(httpPortContracts(task.inputs), httpPortContracts(expected.inputs)) || !dequal(httpPortContracts(task.outputs), httpPortContracts(expected.outputs))) checked.diagnostics.push({
+				code: "dedupe.ports-invalid",
+				column: 0,
+				line: 1,
+				message: "Deduplication ports must match the fixed contract.",
+				path: `/document/graph/nodes/${nodeId}/task`
+			});
+		}
 		if (task.executor.kind == "http-request") {
 			for (const issue of httpRequestIssues(task.executor)) checked.diagnostics.push({
 				code: "http-request.config-invalid",
@@ -25072,7 +25151,9 @@ var httpPortContracts = (ports) => ports.filter((port) => "handle" in port).map(
 async function prepareFlow(revision, engineContract, triggerId) {
 	const engine = findEngineContract(engineContract);
 	if (engine == null) return { kind: "engine-unsupported" };
+	if (!engine.flowState && Object.values(revision.document.graph.nodes).some((node) => node.kind === "task" && "executor" in node.task && node.task.executor.kind === "dedupe")) return { kind: "engine-unsupported" };
 	if (!engine.httpRequests && Object.values(revision.document.graph.nodes).some((node) => node.kind == "task" && "executor" in node.task && node.task.executor.kind == "http-request")) return { kind: "engine-unsupported" };
+	if (!engine.codeFetch && Object.values(revision.document.graph.nodes).some((node) => node.kind == "task" && "moduleId" in node.task && node.task.capabilities?.some((item) => item.kind == "http"))) return { kind: "engine-unsupported" };
 	if (!engine.workflowTools && Object.values(revision.document.graph.nodes).some((node) => nodeWorkflowReferences(node).some((ref) => ref.tool != null))) return { kind: "engine-unsupported" };
 	if (triggerId != null) {
 		const trigger = revision.document.graph.nodes[triggerId];

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

@@ -0,0 +1,123 @@
+import type { JsonValue, ManagedTaskDefinitionOf } from './flow-model.js';
+import { z } from 'zod';
+export { stateConformanceCases, type StateConformanceHarness } from './state-conformance.js';
+export type StateScope = 'draft' | 'live';
+export declare const stateQuerySchema: z.ZodObject<{
+    scope: z.ZodEnum<{
+        draft: "draft";
+        live: "live";
+    }>;
+    values: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const stateClearSchema: z.ZodObject<{
+    scope: z.ZodEnum<{
+        draft: "draft";
+        live: "live";
+    }>;
+    key: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const dedupeClearSchema: z.ZodObject<{
+    scope: z.ZodEnum<{
+        draft: "draft";
+        live: "live";
+    }>;
+    space: z.ZodString;
+}, z.core.$strict>;
+export type DedupeIdentity = string | number;
+export declare const dedupeConfigSchema: z.ZodObject<{
+    field: z.ZodDefault<z.ZodString>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        increasing: "increasing";
+        new: "new";
+    }>>;
+    space: z.ZodDefault<z.ZodEnum<{
+        flow: "flow";
+        node: "node";
+    }>>;
+}, z.core.$strict>;
+export type DedupeConfig = z.infer<typeof dedupeConfigSchema>;
+export interface DedupeExecutor extends DedupeConfig {
+    readonly kind: 'dedupe';
+}
+export declare const dedupeExecutorSchema: z.ZodObject<{
+    field: z.ZodDefault<z.ZodString>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        increasing: "increasing";
+        new: "new";
+    }>>;
+    space: z.ZodDefault<z.ZodEnum<{
+        flow: "flow";
+        node: "node";
+    }>>;
+    kind: z.ZodLiteral<"dedupe">;
+}, z.core.$strict>;
+export declare function dedupeTask(config?: DedupeConfig, name?: string): ManagedTaskDefinitionOf<DedupeExecutor>;
+export declare class StateError extends Error {
+    readonly retryable = false;
+    readonly catchable: boolean;
+    readonly code: 'capability.invalid' | 'capability.denied' | 'dedupe.full' | 'limit-exceeded';
+    constructor(code: StateError['code'], message: string);
+}
+export declare function stateKey(key: unknown): string;
+export declare function dedupeIdentities(value: unknown): DedupeIdentity[];
+export declare function hashIdentities(ids: readonly DedupeIdentity[]): Promise<Uint8Array[]>;
+export declare function watermarkValue(id: DedupeIdentity): number;
+export declare function increasingIdentities(ids: readonly DedupeIdentity[], watermark: DedupeIdentity | null): {
+    inserted: boolean[];
+    watermark: DedupeIdentity | null;
+};
+export declare function itemIdentities(items: JsonValue, field: string): DedupeIdentity[];
+export interface FlowStateView {
+    readonly version: 1;
+    readonly scope: StateScope;
+    readonly limits: {
+        readonly maxValueBytes: number;
+        readonly maxValues: number;
+        readonly maxSpaces: number;
+        readonly maxIdentities: number;
+        readonly maxRunWrites: number;
+    };
+    readonly values: readonly {
+        readonly key: string;
+        readonly size: number;
+        readonly updatedAt: number;
+        readonly value?: JsonValue;
+    }[];
+    readonly spaces: readonly {
+        readonly space: string;
+        readonly mode: 'new' | 'increasing';
+        readonly count: number;
+        readonly watermark: DedupeIdentity | null;
+        readonly updatedAt: number;
+    }[];
+}
+export declare const flowStateViewSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    scope: z.ZodEnum<{
+        draft: "draft";
+        live: "live";
+    }>;
+    limits: z.ZodObject<{
+        maxValueBytes: z.ZodNumber;
+        maxValues: z.ZodNumber;
+        maxSpaces: z.ZodNumber;
+        maxIdentities: z.ZodNumber;
+        maxRunWrites: z.ZodNumber;
+    }, z.core.$strip>;
+    values: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        size: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        value: z.ZodOptional<z.ZodJSONSchema>;
+    }, z.core.$strip>>;
+    spaces: z.ZodArray<z.ZodObject<{
+        space: z.ZodString;
+        mode: z.ZodEnum<{
+            increasing: "increasing";
+            new: "new";
+        }>;
+        count: z.ZodNumber;
+        watermark: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodNull]>;
+        updatedAt: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;