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

package/dist/common/scheduler.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectorCapability, JsonValue, WaitAction, WaitAutoContinue } from '../browser/flow-change.js';
+import type { TaskCapability, JsonValue, WaitAction, WaitAutoContinue } from './flow-change.js';
 import type { PreparedFlow } from './flow-semantics.js';
 import type { WebhookResponseSnapshot } from './webhook-response.js';
 import type { PreviousNode } from '../index.js';
@@ -33,7 +33,7 @@ export type SchedulerEvent = {
     readonly inputs: Readonly<Record<string, JsonValue>>;
     readonly jobId: string;
     readonly nodeId: string;
-    readonly nodeKind: 'agent' | 'approval' | 'condition' | 'connector' | 'decision' | 'javascript' | 'openapi' | 'llm' | 'value' | 'wait' | 'outputs' | 'workflow' | 'webhook-response';
+    readonly nodeKind: 'agent' | 'approval' | 'condition' | 'connector' | 'decision' | 'javascript' | 'openapi' | 'http-request' | 'llm' | 'value' | 'wait' | 'outputs' | 'workflow' | 'webhook-response';
     readonly nodeTitle?: string;
     readonly runId: string;
     readonly type: 'node.started';
@@ -132,7 +132,7 @@ interface TaskInvocationBase {
     readonly runId: string;
 }
 export type TaskInvocation = TaskInvocationBase & ({
-    readonly capabilities: readonly ConnectorCapability[];
+    readonly capabilities: readonly TaskCapability[];
     readonly moduleId: string;
     readonly getPrevious: () => readonly PreviousNode[];
 } | {

package/dist/common/scheduler.js

@@ -9472,11 +9472,65 @@ function answerSchema(question) {
 	};
 }
 //#endregion
+//#region src/http/common/headers.ts
+/** Header names are case-insensitive; never silently combine duplicate business fields. */
+function httpHeaderNameIssue(name, names) {
+	if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name)) return "invalid";
+	if (names.some((candidate) => candidate.toLowerCase() === name.toLowerCase())) return "duplicate";
+}
+//#endregion
+//#region src/http/common/httpRequest.ts
+var parameterSchema = strictObject({
+	mode: _enum(["fields", "object"]).default("fields"),
+	names: array(string$1()).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$1(),
+			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/retry.ts
 var retryNodeTypes = [
 	"code",
 	"connector",
 	"openapi",
+	"http-request",
 	"llm",
 	"decision"
 ];
@@ -9565,22 +9619,6 @@ var webhookResponseTimeout = {
 function webhookResponseAllowsBody(status) {
 	return status !== 204 && status !== 205 && status !== 304;
 }
-var webhookHeadersPort = {
-	jsonSchema: {
-		type: "object",
-		additionalProperties: { type: [
-			"string",
-			"number",
-			"boolean"
-		] }
-	},
-	nullable: true
-};
-/** Header names are case-insensitive; never silently combine duplicate business fields. */
-function webhookHeaderNameIssue(name, names) {
-	if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name)) return "invalid";
-	if (names.some((candidate) => candidate.toLowerCase() === name.toLowerCase())) return "duplicate";
-}
 /** Fixed inputs belong to the node, not author-supplied definitions. */
 var webhookResponseInputs = [
 	{
@@ -9597,7 +9635,17 @@ var webhookResponseInputs = [
 	},
 	{
 		handle: "headers",
-		jsonSchema: webhookHeadersPort.jsonSchema,
+		jsonSchema: {
+			jsonSchema: {
+				type: "object",
+				additionalProperties: { type: [
+					"string",
+					"number",
+					"boolean"
+				] }
+			},
+			nullable: true
+		}.jsonSchema,
 		nullable: false,
 		value: {}
 	}
@@ -9611,7 +9659,7 @@ function webhookHeaderValues(source) {
 	const headers = {};
 	const names = [];
 	for (const [name, value] of Object.entries(source)) {
-		if (webhookHeaderNameIssue(name, names) != null) return;
+		if (httpHeaderNameIssue(name, names) != null) return;
 		if (typeof value !== "string" && typeof value !== "boolean" && !(typeof value === "number" && Number.isFinite(value))) return;
 		const text = String(value);
 		if ([...text].some((character) => character.charCodeAt(0) > 255 || /[\0\r\n]/.test(character))) return;
@@ -9672,7 +9720,7 @@ var ports = {
 	inputs: array(union([input, group])),
 	outputs: array(union([port, group]))
 };
-var capability = union([
+var connectorCapabilitySchema = union([
 	strictObject({
 		kind: literal("connector"),
 		action: text,
@@ -9704,6 +9752,15 @@ var capability = union([
 		})).optional()
 	})
 ]);
+var workflowCapabilitySchema = strictObject({
+	kind: literal("workflow"),
+	name: text,
+	flowId: text,
+	revisionId: text,
+	inputs: array(port),
+	outputs: array(port).nullable()
+});
+var capability = union([connectorCapabilitySchema, workflowCapabilitySchema]);
 var inline = object({
 	...ports,
 	name: text,
@@ -9718,6 +9775,20 @@ var agentValue = union([object({
 	input: text
 })]);
 var agentInput$1 = union([agentValue, object({ kind: literal("model") })]);
+var agentToolFields = {
+	id: text,
+	name: text,
+	description: text,
+	approval: boolean(),
+	inputs: array(input.extend({ source: agentInput$1 }))
+};
+var connectorAgentToolSchema = object({
+	...agentToolFields,
+	kind: literal("connector").optional(),
+	action: text,
+	connectionId: actionConnection.optional()
+});
+var workflowAgentToolSchema = workflowCapabilitySchema.extend(agentToolFields);
 var decisionQuestion = discriminatedUnion("type", [
 	strictObject({
 		name: text,
@@ -9786,15 +9857,7 @@ var managedFields = object({
 			model: text,
 			prompt: text,
 			maxRounds: number(),
-			tools: array(object({
-				id: text,
-				name: text,
-				description: text,
-				action: text,
-				connectionId: actionConnection.optional(),
-				approval: boolean(),
-				inputs: array(input.extend({ source: agentInput$1 }))
-			})),
+			tools: array(union([workflowAgentToolSchema, connectorAgentToolSchema])),
 			notification: object({
 				action: text,
 				connectionId: actionConnection.optional(),
@@ -9807,7 +9870,8 @@ var managedFields = object({
 			kind: literal("workflow"),
 			flowId: text,
 			revisionId: text
-		})
+		}),
+		httpRequestExecutorSchema
 	])
 });
 var managed = managedFields.transform(limitDecisionTask);
@@ -10059,7 +10123,8 @@ object({
 		literal(7),
 		literal(8),
 		literal(9),
-		literal(10)
+		literal(10),
+		literal(11)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -11379,7 +11444,10 @@ function agentApproval(config, checkpoint, inputs) {
 	return {
 		callId: checkpoint.callId,
 		toolId: tool.id,
-		action: tool.action,
+		...tool.kind == "workflow" ? {
+			kind: "workflow",
+			flowId: tool.flowId
+		} : { action: tool.action },
 		...tool.connectionId == null ? {} : { connectionId: tool.connectionId },
 		input: checkpoint.input
 	};
@@ -11439,7 +11507,7 @@ function executeNode(context, input) {
 		const kind = nodeKind(node);
 		const title = nodeTitle(node);
 		const projectedInputs = Object.fromEntries(Object.entries(nodeInputs).filter(([handle]) => {
-			if (node.kind == "task" && "executor" in node.task && node.task?.executor.kind == "openapi" && handle.startsWith("auth.")) return false;
+			if (node.kind == "task" && "executor" in node.task && ["openapi", "http-request"].includes(node.task.executor.kind) && handle.startsWith("auth.")) return false;
 			const mapping = nodeInputMappings(node)[handle];
 			return mapping?.kind != "sources" || mapping.sources.every((source) => source.kind != "binding");
 		}));
@@ -11490,7 +11558,7 @@ function executeNode(context, input) {
 					input: Object.fromEntries(Object.entries(nodeInputs).filter(([handle]) => {
 						if (additional.has(handle)) return false;
 						const task = "executor" in node.task ? node.task : void 0;
-						if (task?.executor.kind != "openapi") return true;
+						if (task == null || !["openapi", "http-request"].includes(task.executor.kind)) return true;
 						const mapping = node.inputs[handle];
 						return mapping?.kind != "unset" && (mapping != null || task.inputs.some((port) => "handle" in port && port.handle == handle && port.value !== void 0));
 					})),

package/dist/common/trigger-catalog.d.ts

@@ -1,4 +1,4 @@
-import type { TriggerKeySnapshot } from '../browser/flow-change.js';
+import type { TriggerKeySnapshot } from './flow-change.js';
 import type { UiLanguage } from './localization.js';
 import type { TriggerKeySummary } from './control-api.js';
 export interface TriggerDisplay {

package/dist/common/trigger-config-options.d.ts

@@ -1,5 +1,5 @@
 import type { ConnectorProxy } from './connector-proxy.js';
-import type { JsonValue } from '../browser/flow-change.js';
+import type { JsonValue } from './flow-change.js';
 export interface TriggerConfigOption {
     readonly value: string;
     readonly label: string;

package/dist/common/trigger-config.d.ts

@@ -1,4 +1,4 @@
-import type { Group, InputPort, InputValues, JsonValue } from '../browser/flow-change.js';
+import type { Group, InputPort, InputValues, JsonValue } from './flow-change.js';
 /** Deployment-bound selections owned by the Trigger configuration contract. */
 export declare function clearTriggerExternalConfig(key: string, config: InputValues): InputValues;
 export declare function triggerConfigValue(input: InputPort, config: InputValues): JsonValue | undefined;

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

@@ -1,5 +1,5 @@
-import type { JsonValue, Port, PortDefinition, TriggerNode } from '../browser/flow-change.js';
-import { webhookMethods, webhookSupportsBody } from '../browser/webhook-method.js';
+import type { JsonValue, Port, PortDefinition, TriggerNode } from './flow-change.js';
+import { webhookMethods, webhookSupportsBody } from './webhook-method.js';
 export { webhookMethods, webhookSupportsBody };
 export declare const errorOutputs: readonly Port[];
 export declare const sampleErrorOutputs: Readonly<Record<string, JsonValue>>;

package/dist/common/trigger-localization.d.ts

@@ -1,5 +1,5 @@
 import type { TriggerDisplay } from './trigger-catalog.js';
-import type { TriggerKeySnapshot } from '../browser/flow-change.js';
+import type { TriggerKeySnapshot } from './flow-change.js';
 import type { UiLanguage } from './localization.js';
 type Translations = Readonly<Record<string, Partial<TriggerDisplay>>>;
 export declare function loadTriggerTranslations(locale: UiLanguage): Promise<Translations>;

package/dist/common/webhook-response.d.ts

@@ -1,4 +1,4 @@
-import type { InputPort, JsonValue, Port, PortDefinition } from '../browser/flow-change.js';
+import type { InputPort, JsonValue, Port, PortDefinition } from './flow-change.js';
 export declare const webhookResponseTimeout: {
     readonly defaultMs: 30000;
     readonly minMs: 1000;
@@ -27,8 +27,6 @@ export declare const webhookHeadersPort: {
     readonly nullable: true;
 };
 export declare function workflowOutputsPort(outputs: readonly Port[]): PortDefinition;
-/** Header names are case-insensitive; never silently combine duplicate business fields. */
-export declare function webhookHeaderNameIssue(name: string, names: readonly string[]): 'invalid' | 'duplicate' | undefined;
 /** Fixed inputs belong to the node, not author-supplied definitions. */
 export declare const webhookResponseInputs: readonly InputPort[];
 export interface WebhookResponseSnapshot {

package/dist/common/webhook-trigger.d.ts

@@ -1,4 +1,4 @@
-import type { JsonValue, WebhookBodyField, WebhookMethod, WebhookOptions } from '../browser/flow-change.js';
+import type { JsonValue, WebhookBodyField, WebhookMethod, WebhookOptions } from './flow-change.js';
 export { webhookSupportsBody } from './trigger-contract.js';
 export { webhookResponseAllowsBody, webhookResponseTimeout } from './webhook-response.js';
 export type { WebhookResponseSnapshot } from './webhook-response.js';

package/dist/common/webhook-trigger.js

@@ -91,6 +91,13 @@ function isJsonObject(value) {
 	}
 }
 //#endregion
+//#region src/http/common/headers.ts
+/** Header names are case-insensitive; never silently combine duplicate business fields. */
+function httpHeaderNameIssue(name, names) {
+	if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name)) return "invalid";
+	if (names.some((candidate) => candidate.toLowerCase() === name.toLowerCase())) return "duplicate";
+}
+//#endregion
 //#region src/flow/common/webhookResponse.ts
 var webhookResponseTimeout = {
 	defaultMs: 3e4,
@@ -100,7 +107,7 @@ var webhookResponseTimeout = {
 function webhookResponseAllowsBody(status) {
 	return status !== 204 && status !== 205 && status !== 304;
 }
-var webhookHeadersPort = {
+({
 	jsonSchema: {
 		type: "object",
 		additionalProperties: { type: [
@@ -110,13 +117,7 @@ var webhookHeadersPort = {
 		] }
 	},
 	nullable: true
-};
-/** Header names are case-insensitive; never silently combine duplicate business fields. */
-function webhookHeaderNameIssue(name, names) {
-	if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name)) return "invalid";
-	if (names.some((candidate) => candidate.toLowerCase() === name.toLowerCase())) return "duplicate";
-}
-webhookHeadersPort.jsonSchema;
+}).jsonSchema;
 function validWebhookStatus(value) {
 	return typeof value === "number" && Number.isInteger(value) && value >= 200 && value <= 599 && webhookResponseAllowsBody(value);
 }
@@ -126,7 +127,7 @@ function webhookHeaderValues(source) {
 	const headers = {};
 	const names = [];
 	for (const [name, value] of Object.entries(source)) {
-		if (webhookHeaderNameIssue(name, names) != null) return;
+		if (httpHeaderNameIssue(name, names) != null) return;
 		if (typeof value !== "string" && typeof value !== "boolean" && !(typeof value === "number" && Number.isFinite(value))) return;
 		const text = String(value);
 		if ([...text].some((character) => character.charCodeAt(0) > 255 || /[\0\r\n]/.test(character))) return;
@@ -2929,7 +2930,7 @@ function webhookResponseHeaders(result, options) {
 	if (!isJsonObject(source)) return;
 	const values = /* @__PURE__ */ new Map();
 	for (const [name, value] of Object.entries(source)) {
-		if (webhookHeaderNameIssue(name, [...values.values()].map((entry) => entry.name)) != null) return;
+		if (httpHeaderNameIssue(name, [...values.values()].map((entry) => entry.name)) != null) return;
 		values.set(name.toLowerCase(), {
 			name,
 			value
@@ -2938,7 +2939,7 @@ function webhookResponseHeaders(result, options) {
 	if (whole == null) {
 		const names = [];
 		for (const [name, output] of Object.entries(options.responseHeaderOutputs ?? {})) {
-			if (webhookHeaderNameIssue(name, names) != null) return;
+			if (httpHeaderNameIssue(name, names) != null) return;
 			names.push(name);
 			values.set(name.toLowerCase(), {
 				name,

package/dist/common/workflow.d.ts

@@ -1,4 +1,4 @@
-import type { TaskNode, ManagedTaskDefinition, Port, JsonValue, RevisionContent } from '../browser/flow-change.js';
+import type { TaskNode, ManagedTaskDefinition, Port, JsonValue, RevisionContent, GraphNode, WorkflowCapability, AgentWorkflowTool } from './flow-change.js';
 import { z } from 'zod';
 export interface WorkflowExecutor {
     readonly kind: 'workflow';
@@ -91,3 +91,19 @@ export declare const workflowReferencesSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type WorkflowReferences = z.infer<typeof workflowReferencesSchema>;
+/** 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 declare function workflowCapability(name: string, target: WorkflowContract | WorkflowCandidate): WorkflowCapability;
+export declare function workflowAgentTool(id: string, name: string, target: WorkflowContract | WorkflowCandidate, previous?: AgentWorkflowTool): AgentWorkflowTool;
+export declare function workflowInterfaceIssues(target: {
+    readonly revisionId: string;
+}, contract: WorkflowContract, previous?: PublishedWorkflowInterface): readonly {
+    side: 'revision';
+    field: string;
+    message: string;
+    reason: 'snapshot-missing' | 'interface-required' | 'revision-stale';
+}[];

package/dist/common/workflow.js

@@ -9621,27 +9621,8 @@ function workflowPorts(ports) {
 function workflowCompatibility(node, contract, previous) {
 	const issues = [];
 	if ("executor" in node.task && node.task.executor.kind == "workflow") {
-		const saved = node.task.executor.revisionId;
-		if (!saved) return [{
-			side: "revision",
-			field: "revisionId",
-			reason: "interface-required",
-			message: "The called workflow interface has not been loaded. Refresh the interface definition."
-		}];
-		if (saved != contract.revisionId) {
-			if (previous == null) return [{
-				side: "revision",
-				field: "revisionId",
-				reason: "snapshot-missing",
-				message: "The saved workflow interface snapshot is unavailable. Refresh the interface definition."
-			}];
-			if (!sameWorkflowInterface(previous, contract)) return [{
-				side: "revision",
-				field: "revisionId",
-				reason: "revision-stale",
-				message: "The called workflow interface has changed. Update the interface definition."
-			}];
-		}
+		const interfaceIssues = workflowInterfaceIssues(node.task.executor, contract, previous);
+		if (interfaceIssues.length) return interfaceIssues;
 	}
 	for (const port of contract.inputs) {
 		const source = node.inputs[port.handle];
@@ -9705,5 +9686,70 @@ var workflowReferencesSchema = object({
 		}).nullable()
 	}))
 });
+/** 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 [];
+}
+function workflowCapability(name, target) {
+	return {
+		kind: "workflow",
+		name,
+		flowId: target.flowId,
+		revisionId: "inputs" in target ? target.revisionId : "",
+		inputs: "inputs" in target ? target.inputs : [],
+		outputs: "inputs" in target ? target.outputs : null
+	};
+}
+function workflowAgentTool(id, name, target, previous) {
+	const capability = workflowCapability(name, target);
+	return {
+		...capability,
+		id,
+		description: previous?.description ?? target.name,
+		approval: previous?.approval ?? false,
+		inputs: capability.inputs.map((port) => Object.assign({}, port, { source: previous?.inputs.find((old) => old.handle == port.handle)?.source ?? { kind: "model" } }))
+	};
+}
+function workflowInterfaceIssues(target, contract, previous) {
+	if (!target.revisionId) return [{
+		side: "revision",
+		field: "revisionId",
+		reason: "interface-required",
+		message: "The called workflow interface has not been loaded. Refresh the interface definition."
+	}];
+	if (target.revisionId == contract.revisionId) return [];
+	if (previous == null) return [{
+		side: "revision",
+		field: "revisionId",
+		reason: "snapshot-missing",
+		message: "The saved workflow interface snapshot is unavailable. Refresh the interface definition."
+	}];
+	if (!sameWorkflowInterface(previous, contract)) return [{
+		side: "revision",
+		field: "revisionId",
+		reason: "revision-stale",
+		message: "The called workflow interface has changed. Update the interface definition."
+	}];
+	return [];
+}
 //#endregion
-export { publishedWorkflowInterface, publishedWorkflowInterfaceSchema, sameWorkflowInterface, withWorkflowTask, workflowCandidate, workflowCandidateGroup, workflowCompatibility, workflowContractSchema, workflowPorts, workflowReferencesSchema, workflowSelectionTask, workflowTask };
+export { nodeWorkflowReferences, publishedWorkflowInterface, publishedWorkflowInterfaceSchema, sameWorkflowInterface, withWorkflowTask, workflowAgentTool, workflowCandidate, workflowCandidateGroup, workflowCapability, workflowCompatibility, workflowContractSchema, workflowInterfaceIssues, workflowPorts, workflowReferencesSchema, workflowSelectionTask, workflowTask };

package/dist/index.d.ts

@@ -66,7 +66,10 @@ export interface TaskLogger {
     warn(message: string, data?: unknown): void;
     error(message: string, data?: unknown): void;
 }
-export interface TaskContext<Actions extends object = Record<string, never>> {
+export interface TaskContext<Actions extends object = Record<string, never>, Workflows extends object = {
+    call: (name: never, input?: never) => Promise<never>;
+}> {
+    readonly workflows: Workflows;
     readonly actions: Actions;
     readonly signal: AbortSignal;
     readonly flowId: string;
@@ -82,6 +85,6 @@ export interface TaskContext<Actions extends object = Record<string, never>> {
     reportProgress(progress: number): Promise<void>;
 }
 export type TaskResult<Outputs extends object> = keyof Outputs extends never ? Outputs | void : Outputs;
-export interface Task<Inputs extends object = Record<string, unknown>, Outputs extends object = Record<string, unknown>, Actions extends object = Record<string, never>> {
-    (inputs: Inputs, context: TaskContext<Actions>): TaskResult<Outputs> | Promise<TaskResult<Outputs>>;
+export interface Task<Inputs extends object = Record<string, unknown>, Outputs extends object = Record<string, unknown>, Actions extends object = Record<string, never>, Workflows extends object = TaskContext['workflows']> {
+    (inputs: Inputs, context: TaskContext<Actions, Workflows>): TaskResult<Outputs> | Promise<TaskResult<Outputs>>;
 }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@oomol-lab/open-flow",
-  "version": "0.1.0-beta.73",
+  "version": "0.1.0-beta.75",
   "description": "TypeScript contracts and Browser runtime for Open Flow.",
-  "license": "Apache-2.0",
+  "license": "SEE LICENSE IN LICENSE",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/oomol-lab/open-flow.git",
@@ -25,6 +25,10 @@
       "types": "./dist/common/decision.d.ts",
       "import": "./dist/common/decision.js"
     },
+    "./http-request": {
+      "types": "./dist/common/http-request.d.ts",
+      "import": "./dist/common/http-request.js"
+    },
     "./openapi": {
       "types": "./dist/common/openapi.d.ts",
       "import": "./dist/common/openapi.js"
@@ -82,12 +86,12 @@
       "import": "./dist/common/provider-triggers.js"
     },
     "./flow-authoring": {
-      "types": "./dist/browser/flow-authoring.d.ts",
-      "import": "./dist/browser/flow-authoring.js"
+      "types": "./dist/common/flow-authoring.d.ts",
+      "import": "./dist/common/flow-authoring.js"
     },
     "./flow-change": {
-      "types": "./dist/browser/flow-change.d.ts",
-      "import": "./dist/browser/flow-change.js"
+      "types": "./dist/common/flow-change.d.ts",
+      "import": "./dist/common/flow-change.js"
     },
     "./flow-encoding": {
       "types": "./dist/common/flow-encoding.d.ts",
@@ -152,6 +156,7 @@
   },
   "files": [
     "dist",
+    "src",
     "skills",
     "README.md",
     "NOTICE",

package/skills/open-flow/references/flow-authoring.md

@@ -298,6 +298,7 @@ For Connector Tasks, independent Code Actions, Agent tools and notifications, an
 | Manual, HTTP or scheduled entry | `start`, `webhook`, `cron`: workflow `inputDefs`, HTTP body fields, or schedule.                                                                                                                                                    |
 | Workflow failure handler        | `error`: published upstream Flows' automatic Run failures; not a node-level catch or a handler for manual Run failures.                                                                                                             |
 | Call another workflow           | `workflow`: select an owned published Flow ID; inputs and outputs derive from its saved contract. Use `node.refresh` to update it.                                                                                                  |
+| Single HTTP request             | `http-request`: method, parameter modes, authentication, body and response configuration; URL and request values use public inputs.                                                                                                 |
 | Fixed HTTP operation            | `openapi`: an OpenAPI source, path and method; resolved authentication choices and ports appear in node details.                                                                                                                    |
 | Reusable constants              | `value`: named JSON values and optional output constraints.                                                                                                                                                                         |
 | Durable interaction             | `wait`, `approval`: prompt and named inputs; resume through the Run's Wait ID. Wait additionally supports optional `config.autoContinue` with `{kind:"after",durationMs:86400000}` or `{kind:"at",at:"2026-10-25T10:00:00+08:00"}`. |

package/skills/open-flow/references/flow-n8n-conversion.md

@@ -13,17 +13,17 @@ publishing and enabling remain separate actions within the user's authorization.
 
 ## Choose a representation
 
-| Source behavior                               | Open Flow building blocks                       | What determines a good fit                                                     |
-| --------------------------------------------- | ----------------------------------------------- | ------------------------------------------------------------------------------ |
-| Scheduled, webhook or provider event          | Cron, Webhook, Poll or Integration Trigger      | Schedule/timezone, event payload, delivery and response behavior.              |
-| Provider read or write                        | Connector                                       | Exact operation, input/output shape, account and number of calls.              |
-| Field shaping, filtering, aggregation or join | Code with named input/output fields             | Explicit collection representation, ordering, keys and empty-input behavior.   |
-| IF or Switch                                  | Condition and named execution branches          | Predicate, first/all matches, fallback route and data sent onward.             |
-| Prompt plus model and output parser           | LLM with template, inputs and `resultSchema`    | Supported model, result shape and any parser repair behavior.                  |
-| Agent with tools or memory                    | Agent where its current contract fits           | Tool permissions, state lifetime and how context is supplied.                  |
-| HTTP request                                  | OpenAPI where an actual operation contract fits | Method, parameters, auth, response format and error behavior.                  |
-| Human response or durable pause               | Wait or Approval                                | Who resumes it, payload, timing, notification and external response lifecycle. |
-| Workflow failure handling                     | Error Trigger where its scope fits              | Which failures trigger it and what failure data it receives.                   |
+| Source behavior                               | Open Flow building blocks                               | What determines a good fit                                                     |
+| --------------------------------------------- | ------------------------------------------------------- | ------------------------------------------------------------------------------ |
+| Scheduled, webhook or provider event          | Cron, Webhook, Poll or Integration Trigger              | Schedule/timezone, event payload, delivery and response behavior.              |
+| Provider read or write                        | Connector                                               | Exact operation, input/output shape, account and number of calls.              |
+| Field shaping, filtering, aggregation or join | Code with named input/output fields                     | Explicit collection representation, ordering, keys and empty-input behavior.   |
+| IF or Switch                                  | Condition and named execution branches                  | Predicate, first/all matches, fallback route and data sent onward.             |
+| Prompt plus model and output parser           | LLM with template, inputs and `resultSchema`            | Supported model, result shape and any parser repair behavior.                  |
+| Agent with tools or memory                    | Agent where its current contract fits                   | Tool permissions, state lifetime and how context is supplied.                  |
+| HTTP request                                  | `http-request`, or `openapi` for a documented operation | Method, parameters, auth, response format and error behavior.                  |
+| Human response or durable pause               | Wait or Approval                                        | Who resumes it, payload, timing, notification and external response lifecycle. |
+| Workflow failure handling                     | Error Trigger where its scope fits                      | Which failures trigger it and what failure data it receives.                   |
 
 Use `schema TYPE` and provider discovery for the actual deployment. A node's
 name alone does not establish equivalence. Provider operations can differ even
@@ -120,10 +120,14 @@ inside URLs, headers, expressions or Code; keep those out of Drafts and reports.
 Use supported credential bindings for the selected operation. A missing account
 can leave a Draft incomplete without implying that the action itself is absent.
 
-For HTTP Request conversion, `schema openapi` describes source URL, operation
-selection and supported authentication. Check the actual operation's response,
-non-success status, redirect, binary and retry requirements against that contract.
-An invented API specification does not establish support for an unknown operation.
+For HTTP Request conversion, `schema http-request` describes a single request's
+method, parameter modes, body, authentication and response handling. Bind `url`,
+request parameters and body through public inputs. Authentication inputs require
+variables or upstream outputs. Query arrays become repeated parameters; response
+arrays remain one value. The first version does not follow redirects or support
+pagination, files, OAuth or direct Agent tools. Check these requirements before
+calling the conversion equivalent. Use `schema openapi` when an actual operation
+contract is available; do not invent an API specification to make a request.
 
 A provider event may expose an ID where the source expected a full record. A
 Connector read can supply the missing data if it preserves the desired behavior.