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

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

@@ -1,4 +1,4 @@
-import type { JsonValue, TriggerSchedule } from '../browser/flow-change.js';
+import type { JsonValue, TriggerSchedule } from './flow-change.js';
 export declare function validateTriggerSchedule(rules: readonly TriggerSchedule[]): void;
 export declare function validateCronExpression(expression: string, timezone: string): void;
 export declare function nextTriggerScheduledAt(rules: readonly TriggerSchedule[], afterMs: number): number;

package/dist/common/decision.d.ts

@@ -1,4 +1,4 @@
-import type { JsonValue, ManagedTaskDefinition } from '../browser/flow-change.js';
+import type { JsonValue, ManagedTaskDefinition } from './flow-change.js';
 export type DecisionQuestion = {
     readonly name: string;
     readonly instructions: string;

package/dist/common/draftOperations.d.ts

@@ -1,4 +1,4 @@
-import type { ChangeOperation, JsonValue, TriggerKeySnapshot, TriggerSchedule } from '../browser/flow-change.js';
+import type { ChangeOperation, JsonValue, TriggerKeySnapshot, TriggerSchedule } from './flow-change.js';
 export type DraftOperation = ChangeOperation | {
     readonly kind: 'graph.trigger.create';
     readonly nodeId: string;

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

@@ -5,7 +5,9 @@ export interface EngineContract {
     readonly platformSource: string;
     readonly waitAutoContinue?: boolean;
     readonly webhookResponses?: boolean;
+    readonly workflowTools?: boolean;
+    readonly httpRequests?: boolean;
 }
-export declare const currentEngineContract = "open-flow-engine/v7";
-export declare const nodejsEngineContract = "open-flow-engine/v7/nodejs-compat-v1";
+export declare const currentEngineContract = "open-flow-engine/v8";
+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 '../browser/flow-change.js';
+import type { JsonValue } from './flow-change.js';
 export interface SourceConfiguration {
     readonly identity: string;
     readonly eventTypes: string[];

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

@@ -1,4 +1,4 @@
-import type { AgentInput, AgentTool, JsonValue, ManagedTaskDefinition, ManagedTaskExecutor } from '../browser/flow-change.js';
+import type { AgentInput, AgentTool, JsonValue, ManagedTaskDefinition, ManagedTaskExecutor } from './flow-change.js';
 export type AgentConfig = Extract<ManagedTaskExecutor, {
     readonly kind: 'agent';
 }>;

package/dist/{browser → common}/flow-authoring-node.d.ts

@@ -1,5 +1,5 @@
-import type { DecisionQuestion } from '../common/decision.js';
-import type { ChangeOperation, CodeModule, ConnectorCapability, Group, GraphNode, InputMapping, InputValues, InputPort, JsonValue, Port, PortDefinition, RetryConfiguration, RevisionContent, TaskDefinition, TriggerKeySnapshot, TriggerNode, TriggerSchedule, WebhookOptions } from './flow-change.js';
+import type { DecisionQuestion } from './decision.js';
+import type { ChangeOperation, CodeModule, TaskCapability, Group, GraphNode, InputMapping, InputValues, InputPort, JsonValue, Port, PortDefinition, RetryConfiguration, RevisionContent, TaskDefinition, TriggerKeySnapshot, TriggerNode, TriggerSchedule, WebhookOptions } from './flow-change.js';
 export declare const defaultCodeTaskPorts: Pick<Extract<TaskDefinition, {
     readonly moduleId: string;
 }>, 'inputs' | 'outputs' | 'capabilities'>;
@@ -103,7 +103,7 @@ export declare function updateTrigger(content: RevisionContent, nodeId: string,
 export declare function updateTriggerConfig(content: RevisionContent, nodeId: string, name: string, value: JsonValue | undefined): readonly ChangeOperation[] | undefined;
 export declare function updateTriggerSchedule(content: RevisionContent, nodeId: string, schedule: readonly TriggerSchedule[]): readonly ChangeOperation[] | undefined;
 export declare function setTriggerConnection(content: RevisionContent, nodeId: string, connectionId: string | undefined): readonly ChangeOperation[] | undefined;
-export declare function setCodeActions(content: RevisionContent, nodeId: string, capabilities: readonly ConnectorCapability[]): readonly ChangeOperation[] | undefined;
+export declare function setCodeActions(content: RevisionContent, nodeId: string, capabilities: readonly TaskCapability[]): readonly ChangeOperation[] | undefined;
 export declare function createDecisionTask(identity: {
     readonly nodeId: string;
 }, name?: string, questions?: readonly DecisionQuestion[]): readonly ChangeOperation[];

package/dist/{browser → common}/flow-authoring.js

@@ -3009,12 +3009,12 @@ function decisionTask(questions = [defaultDecisionQuestion()], name = "AI Decisi
 	};
 }
 //#endregion
-//#region src/openapi/common/authBindings.ts
+//#region src/http/common/authBindings.ts
 /** Never allow credentials to enter a Revision as literal node inputs. */
-function assertOpenApiAuthBindings(document) {
+function assertHttpAuthBindings(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.");
+		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
@@ -8706,6 +8706,52 @@ function preprocess(fn, schema) {
 function datetime(params) {
 	return /* @__PURE__ */ _isoDateTime(ZodISODateTime, params);
 }
+//#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") });
 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);
@@ -8716,6 +8762,7 @@ var retryNodeTypes = [
 	"code",
 	"connector",
 	"openapi",
+	"http-request",
 	"llm",
 	"decision"
 ];
@@ -8771,7 +8818,8 @@ var waitAutoContinueDraftSchema = discriminatedUnion("kind", [strictObject({
 	at: string(),
 	timezone: string().optional()
 })]);
-discriminatedUnion("kind", [waitAutoContinueDraftSchema.options[0].extend({ durationMs: number().int().positive().max(Number.MAX_SAFE_INTEGER) }), waitAutoContinueDraftSchema.options[1].extend({
+/** Static business configuration; the deployment owns the allowed wait lifetime. */
+var waitAutoContinueSchema = discriminatedUnion("kind", [waitAutoContinueDraftSchema.options[0].extend({ durationMs: number().int().positive().max(Number.MAX_SAFE_INTEGER) }), waitAutoContinueDraftSchema.options[1].extend({
 	at: datetime({ offset: true }),
 	timezone: string().refine(isTimeZone, "Select a valid IANA timezone.").optional()
 })]);
@@ -8841,7 +8889,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,
@@ -8873,6 +8921,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,
@@ -8887,6 +8944,20 @@ var agentValue = union([object({
 	input: text
 })]);
 var agentInput = union([agentValue, object({ kind: literal("model") })]);
+var agentToolFields = {
+	id: text,
+	name: text,
+	description: text,
+	approval: boolean(),
+	inputs: array(input.extend({ source: agentInput }))
+};
+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,
@@ -8955,15 +9026,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 }))
-			})),
+			tools: array(union([workflowAgentToolSchema, connectorAgentToolSchema])),
 			notification: object({
 				action: text,
 				connectionId: actionConnection.optional(),
@@ -8976,7 +9039,8 @@ var managedFields = object({
 			kind: literal("workflow"),
 			flowId: text,
 			revisionId: text
-		})
+		}),
+		httpRequestExecutorSchema
 	])
 });
 var managed = managedFields.transform(limitDecisionTask);
@@ -9189,10 +9253,26 @@ var node = union([
 		})
 	})
 ]);
-strictObject(condition), strictObject(wait), strictObject(webhook), managedFields.shape.executor.options[0].omit({ kind: true }).strict(), managedFields.shape.executor.options[1].omit({ kind: true }).strict(), managedFields.shape.executor.options[2].omit({ kind: true }).strict(), managedFields.shape.executor.options[3].omit({ kind: true }).strict(), managedFields.shape.executor.options[4].omit({
-	kind: true,
-	notification: true
-}).strict();
+/** Configuration schemas shared by the node authoring boundary. */
+var authoringDefinitionSchemas = {
+	input,
+	port,
+	ports,
+	condition: strictObject(condition),
+	wait: strictObject(wait),
+	waitAutoContinue: waitAutoContinueSchema,
+	webhook: strictObject(webhook),
+	schedule: triggerScheduleSchema,
+	capabilities: array(capability),
+	connector: managedFields.shape.executor.options[0].omit({ kind: true }).strict(),
+	openapi: managedFields.shape.executor.options[1].omit({ kind: true }).strict(),
+	decision: managedFields.shape.executor.options[2].omit({ kind: true }).strict(),
+	llm: managedFields.shape.executor.options[3].omit({ kind: true }).strict(),
+	agent: managedFields.shape.executor.options[4].omit({
+		kind: true,
+		notification: true
+	}).strict()
+};
 var edge = object({
 	source: text,
 	target: text,
@@ -9228,7 +9308,8 @@ var revision = object({
 		literal(7),
 		literal(8),
 		literal(9),
-		literal(10)
+		literal(10),
+		literal(11)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -9259,7 +9340,7 @@ function decodeRevisionContent(value) {
 	checkJsonDepth(value);
 	const content = revision.parse(value);
 	checkModelVersion(content);
-	assertOpenApiAuthBindings(content.document);
+	assertHttpAuthBindings(content.document);
 	return content;
 }
 var shapes = {
@@ -9429,6 +9510,8 @@ array(union([...new Map(Object.entries(shapes).map(([kind, shape]) => [kind, sha
 	...shape
 })])).values()])).min(1);
 function checkModelVersion(content) {
+	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.");
 	if (content.modelVersion < 9 && Object.values(content.document.graph.nodes).some((candidateNode) => {
@@ -9505,6 +9588,24 @@ function supportsNodeErrorHandling(node) {
 }
 //#endregion
 //#region src/flow/common/change.ts
+var workflowToolNamePattern = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+function workflowToolNameIssue(name, otherNames = []) {
+	if (!workflowToolNamePattern.test(name)) return "invalid";
+	for (const other of otherNames) if (other == name) return "duplicate";
+}
+function decodeTaskCapabilities(value) {
+	if (!Array.isArray(value)) throw new TypeError("Task capabilities must be an array.");
+	const parsed = authoringDefinitionSchemas.capabilities.parse(value);
+	const connectors = decodeConnectorCapabilities(parsed.filter((item) => item.kind == "connector"));
+	const names = /* @__PURE__ */ new Set();
+	for (const item of parsed) {
+		if (item.kind != "workflow") continue;
+		if (workflowToolNameIssue(item.name, names)) throw new TypeError("Workflow tool names must be unique provider-compatible names.");
+		names.add(item.name);
+	}
+	let connectorIndex = 0;
+	return parsed.map((item) => item.kind == "connector" ? connectors[connectorIndex++] : item);
+}
 function decodeConnectorCapabilities(value) {
 	if (!Array.isArray(value)) throw new TypeError("Connector capabilities must be an array.");
 	if (value.length == 0) return [];
@@ -9632,10 +9733,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 == 10) return content;
+	if (!hasManual && content.modelVersion == 11) return content;
 	return {
 		...content,
-		modelVersion: 10,
+		modelVersion: 11,
 		document: {
 			...content.document,
 			graph: hasManual ? {
@@ -9670,7 +9771,7 @@ function invalid(message) {
 	throw new FlowChangeError(message);
 }
 function applyFlowChanges(content, operations) {
-	const source = content.modelVersion != 10 || Object.values(content.document.graph.nodes).some((node) => node.kind == "manual") ? decodeRevisionContent(content) : content;
+	const source = content.modelVersion != 11 || 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) {
@@ -9784,7 +9885,7 @@ function applyFlowChanges(content, operations) {
 			const graph = document.graph;
 			if (!dequal(graph.nodes[operation.nodeId], operation.before)) invalid("The Node changed before this operation was applied.");
 			if (operation.node.kind != operation.before.kind) invalid("Replacing a Node cannot change its kind.");
-			if (operation.node.kind == "task" && "moduleId" in operation.node.task && operation.node.task.capabilities !== void 0) decodeConnectorCapabilities(operation.node.task.capabilities);
+			if (operation.node.kind == "task" && "moduleId" in operation.node.task && operation.node.task.capabilities !== void 0) decodeTaskCapabilities(operation.node.task.capabilities);
 			const name = normalizeNodeName(operation.node.name ?? "");
 			const issue = nodeNameIssue(graph, operation.nodeId, name);
 			if (issue != null) invalid(`Node name is ${issue}.`);
@@ -9806,7 +9907,7 @@ function applyFlowChanges(content, operations) {
 			if (graph.nodes[operation.nodeId] != null) invalid("A Node with this ID already exists in the target graph.");
 			if (operation.node.kind == "error" && Object.values(graph.nodes).some((node) => node.kind == "error")) invalid("A graph can contain only one Flow Error node.");
 			if ((operation.node.kind == "manual" || operation.node.kind == "start") && Object.values(graph.nodes).some((node) => node.kind == "manual" || node.kind == "start")) invalid("A graph can contain only one Start Trigger.");
-			if (operation.node.kind == "task" && "moduleId" in operation.node.task && operation.node.task.capabilities !== void 0) decodeConnectorCapabilities(operation.node.task.capabilities);
+			if (operation.node.kind == "task" && "moduleId" in operation.node.task && operation.node.task.capabilities !== void 0) decodeTaskCapabilities(operation.node.task.capabilities);
 			if (operation.node.name == null) invalid("A Node name cannot be empty.");
 			if (operation.node.kind == "outputs" && Object.values(graph.nodes).some((node) => node.kind == "outputs")) invalid("A graph can contain only one Outputs node.");
 			const name = normalizeNodeName(operation.node.name);
@@ -9905,7 +10006,7 @@ function applyFlowChanges(content, operations) {
 			if (!dequal(node.task.capabilities, operation.before)) invalid("The inline Task capabilities changed before this operation was applied.");
 			const task = { ...node.task };
 			if (operation.value === void 0) delete task.capabilities;
-			else task.capabilities = decodeConnectorCapabilities(operation.value);
+			else task.capabilities = decodeTaskCapabilities(operation.value);
 			Object.assign(document, { graph: {
 				...graph,
 				nodes: {
@@ -10115,10 +10216,10 @@ function applyFlowChanges(content, operations) {
 			break;
 		}
 	}
-	assertOpenApiAuthBindings(document);
+	assertHttpAuthBindings(document);
 	return upgradeDecodedRevisionContent({
 		document,
-		modelVersion: 10,
+		modelVersion: 11,
 		modules
 	});
 }

package/dist/{browser → common}/flow-change-schema.d.ts

@@ -1,6 +1,129 @@
 import type { ChangeOperation, FlowDocument, JsonValue, RevisionContent } from './flow-change.js';
 import { z } from 'zod';
-export declare const currentFlowModelVersion = 10;
+export declare const currentFlowModelVersion = 11;
+export declare const connectorCapabilitySchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"connector">;
+    action: z.ZodString;
+    connectionId: z.ZodOptional<z.ZodString>;
+    connections: z.ZodArray<z.ZodObject<{
+        connectionId: z.ZodString;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"connector">;
+    mode: z.ZodLiteral<"shared">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"connector">;
+    mode: z.ZodLiteral<"independent">;
+    actions: z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        connectionId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"connector">;
+    actionHints: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    connectionHints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        action: z.ZodString;
+        connectionId: z.ZodString;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>]>;
+export declare const workflowCapabilitySchema: z.ZodObject<{
+    kind: z.ZodLiteral<"workflow">;
+    name: z.ZodString;
+    flowId: z.ZodString;
+    revisionId: z.ZodString;
+    inputs: z.ZodArray<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        jsonSchema: z.ZodJSONSchema;
+        nullable: z.ZodBoolean;
+        handle: z.ZodString;
+    }, z.core.$strip>>;
+    outputs: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        jsonSchema: z.ZodJSONSchema;
+        nullable: z.ZodBoolean;
+        handle: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strict>;
+export declare const agentToolFields: {
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    approval: z.ZodBoolean;
+    inputs: z.ZodArray<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        jsonSchema: z.ZodJSONSchema;
+        nullable: z.ZodBoolean;
+        handle: z.ZodString;
+        value: z.ZodOptional<z.ZodJSONSchema>;
+        source: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"value">;
+            value: z.ZodJSONSchema;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"input">;
+            input: z.ZodString;
+        }, z.core.$strip>]>, z.ZodObject<{
+            kind: z.ZodLiteral<"model">;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>>;
+};
+export declare const connectorAgentToolSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    approval: z.ZodBoolean;
+    inputs: z.ZodArray<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        jsonSchema: z.ZodJSONSchema;
+        nullable: z.ZodBoolean;
+        handle: z.ZodString;
+        value: z.ZodOptional<z.ZodJSONSchema>;
+        source: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"value">;
+            value: z.ZodJSONSchema;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"input">;
+            input: z.ZodString;
+        }, z.core.$strip>]>, z.ZodObject<{
+            kind: z.ZodLiteral<"model">;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>>;
+    kind: z.ZodOptional<z.ZodLiteral<"connector">>;
+    action: z.ZodString;
+    connectionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const workflowAgentToolSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"workflow">;
+    flowId: z.ZodString;
+    revisionId: z.ZodString;
+    outputs: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        jsonSchema: z.ZodJSONSchema;
+        nullable: z.ZodBoolean;
+        handle: z.ZodString;
+    }, z.core.$strip>>>;
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    approval: z.ZodBoolean;
+    inputs: z.ZodArray<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        jsonSchema: z.ZodJSONSchema;
+        nullable: z.ZodBoolean;
+        handle: z.ZodString;
+        value: z.ZodOptional<z.ZodJSONSchema>;
+        source: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"value">;
+            value: z.ZodJSONSchema;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"input">;
+            input: z.ZodString;
+        }, z.core.$strip>]>, z.ZodObject<{
+            kind: z.ZodLiteral<"model">;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>>;
+}, z.core.$strict>;
 /** Configuration schemas shared by the node authoring boundary. */
 export declare const authoringDefinitionSchemas: {
     input: z.ZodObject<{
@@ -179,7 +302,7 @@ export declare const authoringDefinitionSchemas: {
         }>;
         value: z.ZodNumber;
     }, z.core.$strip>]>>;
-    capabilities: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+    capabilities: z.ZodArray<z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
         kind: z.ZodLiteral<"connector">;
         action: z.ZodString;
         connectionId: z.ZodOptional<z.ZodString>;
@@ -205,6 +328,23 @@ export declare const authoringDefinitionSchemas: {
             connectionId: z.ZodString;
             alias: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>>>;
+    }, z.core.$strict>]>, z.ZodObject<{
+        kind: z.ZodLiteral<"workflow">;
+        name: z.ZodString;
+        flowId: z.ZodString;
+        revisionId: z.ZodString;
+        inputs: z.ZodArray<z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            jsonSchema: z.ZodJSONSchema;
+            nullable: z.ZodBoolean;
+            handle: z.ZodString;
+        }, z.core.$strip>>;
+        outputs: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            jsonSchema: z.ZodJSONSchema;
+            nullable: z.ZodBoolean;
+            handle: z.ZodString;
+        }, z.core.$strip>>>;
     }, z.core.$strict>]>>;
     connector: z.ZodObject<{
         action: z.ZodString;
@@ -266,12 +406,19 @@ export declare const authoringDefinitionSchemas: {
         model: z.ZodString;
         prompt: z.ZodString;
         maxRounds: z.ZodNumber;
-        tools: z.ZodArray<z.ZodObject<{
+        tools: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"workflow">;
+            flowId: z.ZodString;
+            revisionId: z.ZodString;
+            outputs: z.ZodNullable<z.ZodArray<z.ZodObject<{
+                description: z.ZodOptional<z.ZodString>;
+                jsonSchema: z.ZodJSONSchema;
+                nullable: z.ZodBoolean;
+                handle: z.ZodString;
+            }, z.core.$strip>>>;
             id: z.ZodString;
             name: z.ZodString;
             description: z.ZodString;
-            action: z.ZodString;
-            connectionId: z.ZodOptional<z.ZodString>;
             approval: z.ZodBoolean;
             inputs: z.ZodArray<z.ZodObject<{
                 description: z.ZodOptional<z.ZodString>;
@@ -289,7 +436,31 @@ export declare const authoringDefinitionSchemas: {
                     kind: z.ZodLiteral<"model">;
                 }, z.core.$strip>]>;
             }, z.core.$strip>>;
-        }, z.core.$strip>>;
+        }, z.core.$strict>, z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            description: z.ZodString;
+            approval: z.ZodBoolean;
+            inputs: z.ZodArray<z.ZodObject<{
+                description: z.ZodOptional<z.ZodString>;
+                jsonSchema: z.ZodJSONSchema;
+                nullable: z.ZodBoolean;
+                handle: z.ZodString;
+                value: z.ZodOptional<z.ZodJSONSchema>;
+                source: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
+                    kind: z.ZodLiteral<"value">;
+                    value: z.ZodJSONSchema;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"input">;
+                    input: z.ZodString;
+                }, z.core.$strip>]>, z.ZodObject<{
+                    kind: z.ZodLiteral<"model">;
+                }, z.core.$strip>]>;
+            }, z.core.$strip>>;
+            kind: z.ZodOptional<z.ZodLiteral<"connector">>;
+            action: z.ZodString;
+            connectionId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>;
     }, z.core.$strict>;
 };
 /** Explicit storage upgrade only. Normal reads and authoring still reject retired fields. */