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

package/dist/common/engine-contract.d.ts

@@ -7,7 +7,12 @@ export interface EngineContract {
     readonly webhookResponses?: boolean;
     readonly workflowTools?: boolean;
     readonly httpRequests?: boolean;
+    /** Code may call `context.fetch` for hosts declared by its `http` Capability. */
+    readonly codeFetch?: boolean;
+    readonly flowState?: boolean;
 }
-export declare const currentEngineContract = "open-flow-engine/v8";
+/** v10 adds persistent Flow State to the published v9 Node compatibility and fetch contract. */
+export declare const currentEngineContract = "open-flow-engine/v10";
+/** The published v8 Node compatibility contract, retained for existing Publications and Runs. */
 export declare const nodejsEngineContract = "open-flow-engine/v8/nodejs-compat-v1";
 export declare function findEngineContract(contract: string): EngineContract | undefined;

package/dist/common/event-source-definition.d.ts

@@ -1,4 +1,4 @@
-import type { JsonValue } from './flow-change.js';
+import type { JsonValue } from '../index.js';
 export interface SourceConfiguration {
     readonly identity: string;
     readonly eventTypes: string[];

package/dist/common/event-source-view.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+/** Public projection of a source that Connector validates and Open Flow exposes unchanged. */
+export declare const eventSourceViewSchema: z.ZodObject<{
+    appId: z.ZodNullable<z.ZodString>;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    installationId: z.ZodOptional<z.ZodString>;
+    organizationId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    projectKey: z.ZodOptional<z.ZodString>;
+    subscriptionStatus: z.ZodOptional<z.ZodEnum<{
+        error: "error";
+        idle: "idle";
+        pending: "pending";
+        ready: "ready";
+    }>>;
+    lastError: z.ZodOptional<z.ZodString>;
+    signingSecretConfigured: z.ZodOptional<z.ZodBoolean>;
+    manageSubscriptions: z.ZodNullable<z.ZodBoolean>;
+    verificationTokenConfigured: z.ZodNullable<z.ZodBoolean>;
+    encryptKeyConfigured: z.ZodNullable<z.ZodBoolean>;
+    verifiedAt: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;

package/dist/common/event-source.d.ts

@@ -1,6 +1,6 @@
 import type { EventSourceDefinition, SourceConfiguration } from './event-source-definition.js';
 import { z } from 'zod';
-import { eventSourceViewSchema } from './event-sources.js';
+import { eventSourceViewSchema } from './event-source-view.js';
 export type { EventSourceDefinition, SourceConfiguration, SourceEvent, SourceSubscription, SourceOperation, SourceReference, SourceReferenceOperation, } from './event-source-definition.js';
 export { SourceIdentityError } from './event-source-definition.js';
 export declare function eventSourceDefinition(kind: string): EventSourceDefinition;

package/dist/common/event-source.js

@@ -5569,71 +5569,6 @@ function json(params) {
 	return jsonSchema;
 }
 //#endregion
-//#region src/control/common/eventSources.ts
-var id = string().min(1).max(256);
-var eventType = string().regex(/^[a-z][a-z0-9_.:]{0,127}$/);
-var name = string().trim().min(1).max(128);
-var eventSourceViewSchema = object({
-	version: literal(1),
-	sourceId: id,
-	revision: int().positive(),
-	name,
-	provider: _enum([
-		"feishu",
-		"feishu_app_bot",
-		"slackbot",
-		"intercom",
-		"sentry",
-		"zoom",
-		"fireflies",
-		"jira"
-	]),
-	appId: id.nullable(),
-	workspaceId: id.optional(),
-	installationId: id.optional(),
-	organizationId: id.optional(),
-	projectId: id.optional(),
-	projectKey: id.optional(),
-	subscriptionStatus: _enum([
-		"idle",
-		"pending",
-		"ready",
-		"error"
-	]).optional(),
-	lastError: string().optional(),
-	signingSecretConfigured: boolean().optional(),
-	connectionId: id,
-	teamId: id.nullable(),
-	enabled: boolean(),
-	eventTypes: array(eventType),
-	manageSubscriptions: boolean().nullable(),
-	verificationTokenConfigured: boolean().nullable(),
-	encryptKeyConfigured: boolean().nullable(),
-	endpointUrl: string().nullable(),
-	verifiedAt: string().nullable(),
-	lastReceivedAt: string().nullable(),
-	updatedAt: string(),
-	consumers: array(object({
-		flowId: id,
-		flowName: string(),
-		triggerNodeId: id
-	}))
-}).pick({
-	appId: true,
-	workspaceId: true,
-	installationId: true,
-	organizationId: true,
-	projectId: true,
-	projectKey: true,
-	subscriptionStatus: true,
-	lastError: true,
-	signingSecretConfigured: true,
-	manageSubscriptions: true,
-	verificationTokenConfigured: true,
-	encryptKeyConfigured: true,
-	verifiedAt: true
-});
-//#endregion
 //#region src/event-source/common/catalog.generated.json
 var catalog_generated_default = [
 	{
@@ -5704,6 +5639,30 @@ var catalog_generated_default = [
 //#region src/event-source/common/definition.ts
 var SourceIdentityError = class extends Error {};
 //#endregion
+//#region src/event-source/common/view.ts
+var id = string().min(1).max(256);
+/** Public projection of a source that Connector validates and Open Flow exposes unchanged. */
+var eventSourceViewSchema = object({
+	appId: id.nullable(),
+	workspaceId: id.optional(),
+	installationId: id.optional(),
+	organizationId: id.optional(),
+	projectId: id.optional(),
+	projectKey: id.optional(),
+	subscriptionStatus: _enum([
+		"idle",
+		"pending",
+		"ready",
+		"error"
+	]).optional(),
+	lastError: string().optional(),
+	signingSecretConfigured: boolean().optional(),
+	manageSubscriptions: boolean().nullable(),
+	verificationTokenConfigured: boolean().nullable(),
+	encryptKeyConfigured: boolean().nullable(),
+	verifiedAt: string().nullable()
+});
+//#endregion
 //#region src/event-source/common/index.ts
 function eventSourceDefinition(kind) {
 	for (const entry of catalog_generated_default) if (entry.kind === kind) return entry;

package/dist/common/event-sources.d.ts

@@ -1,24 +1,3 @@
-import { z } from 'zod';
-export declare const eventSourceViewSchema: z.ZodObject<{
-    appId: z.ZodNullable<z.ZodString>;
-    workspaceId: z.ZodOptional<z.ZodString>;
-    installationId: z.ZodOptional<z.ZodString>;
-    organizationId: z.ZodOptional<z.ZodString>;
-    projectId: z.ZodOptional<z.ZodString>;
-    projectKey: z.ZodOptional<z.ZodString>;
-    subscriptionStatus: z.ZodOptional<z.ZodEnum<{
-        error: "error";
-        idle: "idle";
-        pending: "pending";
-        ready: "ready";
-    }>>;
-    lastError: z.ZodOptional<z.ZodString>;
-    signingSecretConfigured: z.ZodOptional<z.ZodBoolean>;
-    manageSubscriptions: z.ZodNullable<z.ZodBoolean>;
-    verificationTokenConfigured: z.ZodNullable<z.ZodBoolean>;
-    encryptKeyConfigured: z.ZodNullable<z.ZodBoolean>;
-    verifiedAt: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
 export interface CreateFeishuEventSource {
     readonly kind?: 'feishu';
     readonly version: 1;

package/dist/common/flow-authoring.js

@@ -2887,6 +2887,9 @@ function createSchemaComparer() {
 createSchemaComparer();
 //#endregion
 //#region src/decision/common/decision.ts
+function isDecisionExecutor(executor) {
+	return executor.kind === "decision";
+}
 var decisionLimits = {
 	choice: 255,
 	score: 10
@@ -2909,7 +2912,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;
@@ -3009,15 +3012,6 @@ function decisionTask(questions = [defaultDecisionQuestion()], name = "AI Decisi
 	};
 }
 //#endregion
-//#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 src/flow/common/inputValue.ts
 /** Converts explicit user values at authoring boundaries, never persisted legacy data. */
 function inputValues(values) {
@@ -8707,6 +8701,20 @@ function datetime(params) {
 	return /* @__PURE__ */ _isoDateTime(ZodISODateTime, params);
 }
 //#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"),
@@ -8752,6 +8760,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()
+	}))
+});
 function checkJsonDepth(value, depth = 0) {
 	if (depth > 64) throw new TypeError("Value exceeds the maximum JSON depth.");
 	if (value != null && typeof value == "object") for (const child of Object.values(value)) checkJsonDepth(child, depth + 1);
@@ -8929,7 +8982,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,
@@ -9040,7 +9100,8 @@ var managedFields = object({
 			flowId: text,
 			revisionId: text
 		}),
-		httpRequestExecutorSchema
+		httpRequestExecutorSchema,
+		dedupeExecutorSchema
 	])
 });
 var managed = managedFields.transform(limitDecisionTask);
@@ -9309,7 +9370,9 @@ var revision = object({
 		literal(8),
 		literal(9),
 		literal(10),
-		literal(11)
+		literal(11),
+		literal(12),
+		literal(13)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -9340,7 +9403,7 @@ function decodeRevisionContent(value) {
 	checkJsonDepth(value);
 	const content = revision.parse(value);
 	checkModelVersion(content);
-	assertHttpAuthBindings(content.document);
+	assertDocumentHttpAuthBindings(content.document);
 	return content;
 }
 var shapes = {
@@ -9510,6 +9573,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.");
@@ -9525,6 +9590,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
 var unaryOperator = (operator) => operator.startsWith("is");
@@ -9584,7 +9652,7 @@ function setConditionInput(node, handle, mapping) {
 //#endregion
 //#region src/flow/common/errorHandling.ts
 function supportsNodeErrorHandling(node) {
-	return supportsNodeRetry(node);
+	return supportsNodeRetry(node) || node.kind === "task" && "executor" in node.task && node.task.executor.kind === "dedupe";
 }
 //#endregion
 //#region src/flow/common/change.ts
@@ -9603,6 +9671,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);
 }
@@ -9733,10 +9803,10 @@ function isTriggerNode(node) {
 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 ? {
@@ -9771,7 +9841,7 @@ function invalid(message) {
 	throw new FlowChangeError(message);
 }
 function applyFlowChanges(content, operations) {
-	const source = content.modelVersion != 11 || Object.values(content.document.graph.nodes).some((node) => node.kind == "manual") ? decodeRevisionContent(content) : content;
+	const source = content.modelVersion != 13 || Object.values(content.document.graph.nodes).some((node) => node.kind == "manual") ? decodeRevisionContent(content) : content;
 	const document = { ...source.document };
 	const modules = { ...source.modules };
 	for (const operation of operations) switch (operation.kind) {
@@ -10216,10 +10286,10 @@ function applyFlowChanges(content, operations) {
 			break;
 		}
 	}
-	assertHttpAuthBindings(document);
+	assertDocumentHttpAuthBindings(document);
 	return upgradeDecodedRevisionContent({
 		document,
-		modelVersion: 11,
+		modelVersion: 13,
 		modules
 	});
 }

package/dist/common/flow-change-schema.d.ts

@@ -1,6 +1,6 @@
 import type { ChangeOperation, FlowDocument, JsonValue, RevisionContent } from './flow-change.js';
 import { z } from 'zod';
-export declare const currentFlowModelVersion = 11;
+export declare const currentFlowModelVersion = 13;
 export declare const connectorCapabilitySchema: z.ZodUnion<readonly [z.ZodObject<{
     kind: z.ZodLiteral<"connector">;
     action: z.ZodString;
@@ -46,6 +46,10 @@ export declare const workflowCapabilitySchema: z.ZodObject<{
         handle: z.ZodString;
     }, z.core.$strip>>>;
 }, z.core.$strict>;
+export declare const httpCapabilitySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"http">;
+    hosts: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
 export declare const agentToolFields: {
     id: z.ZodString;
     name: z.ZodString;
@@ -345,6 +349,9 @@ export declare const authoringDefinitionSchemas: {
             nullable: z.ZodBoolean;
             handle: z.ZodString;
         }, z.core.$strip>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"http">;
+        hosts: z.ZodArray<z.ZodString>;
     }, z.core.$strict>]>>;
     connector: z.ZodObject<{
         action: z.ZodString;
@@ -474,3 +481,4 @@ export declare function parseOperation<Value>(candidate: unknown, index: number,
 export declare function decodeChangeOperation(candidate: unknown, index: number): ChangeOperation;
 export declare function decodeChangeOperations(value: unknown): readonly ChangeOperation[];
 export declare function changeOperationsSchema(kind?: string): JsonValue;
+export declare function assertDocumentHttpAuthBindings(content: FlowDocument): void;