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

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

@@ -8771,7 +8771,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 +8842,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 +8874,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 +8897,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 +8979,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(),
@@ -9189,10 +9205,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 +9260,8 @@ var revision = object({
 		literal(7),
 		literal(8),
 		literal(9),
-		literal(10)
+		literal(10),
+		literal(11)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -9429,6 +9462,7 @@ 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" && ("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 +9539,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 +9684,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 +9722,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 +9836,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 +9858,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 +9957,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: {
@@ -10118,7 +10170,7 @@ function applyFlowChanges(content, operations) {
 	assertOpenApiAuthBindings(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. */

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

@@ -1,17 +1,17 @@
 import type { JsonValue, Port, PortDefinition } from '../index.js';
 export { fixedInputValue, inputValue, inputValues } from './flow-input-value.js';
-import type { RetryConfiguration } from '../common/flow-retry.js';
+import type { RetryConfiguration } from './flow-retry.js';
 import type { WebhookMethod } from './webhook-method.js';
 import { currentFlowModelVersion } from './flow-change-schema.js';
 export { changeOperationsSchema, currentFlowModelVersion, decodeChangeOperations } from './flow-change-schema.js';
-export type { RetryConfiguration } from '../common/flow-retry.js';
-export { supportsNodeRetry } from '../common/flow-retry.js';
-export { nodeSystemOutputPorts, supportsNodeErrorHandling, nodeErrorSchema } from '../common/flow-errorHandling.js';
-export type { NodeErrorData } from '../common/flow-errorHandling.js';
+export type { RetryConfiguration } from './flow-retry.js';
+export { supportsNodeRetry } from './flow-retry.js';
+export { nodeSystemOutputPorts, supportsNodeErrorHandling, nodeErrorSchema } from './flow-errorHandling.js';
+export type { NodeErrorData } from './flow-errorHandling.js';
 export type { WebhookMethod };
 export type { JsonValue, Port, PortDefinition } from '../index.js';
-export { isSchemaKeyword } from '../common/flow-schemaKeywords.js';
-export type { SchemaKeyword, SchemaMismatch } from '../common/flow-schemaKeywords.js';
+export { isSchemaKeyword } from './flow-schemaKeywords.js';
+export type { SchemaKeyword, SchemaMismatch } from './flow-schemaKeywords.js';
 export declare const resourceNameMaxLength = 80;
 export type ResourceNameIssue = 'controlCharacter' | 'empty' | 'specialCharacter' | 'tooLong';
 export declare function resourceNameIssue(value: string): ResourceNameIssue | undefined;
@@ -113,7 +113,7 @@ export interface ConditionNode extends GraphNodeBase {
     readonly matchMode: 'first' | 'all';
     readonly kind: 'condition';
 }
-export type ManagedTaskExecutor = import('../common/workflow.js').WorkflowExecutor | import('../common/decision.js').DecisionExecutor | import('../common/openapi.js').OpenApiExecutor | {
+export type ManagedTaskExecutor = import('./workflow.js').WorkflowExecutor | import('./decision.js').DecisionExecutor | import('./openapi.js').OpenApiExecutor | {
     readonly kind: 'connector';
     readonly action: string;
     readonly connectionId?: string;
@@ -147,17 +147,37 @@ export type AgentInput = {
 } | {
     readonly kind: 'model';
 };
-export interface AgentTool {
+interface AgentToolBase {
     readonly id: string;
     readonly name: string;
     readonly description: string;
-    readonly action: string;
-    readonly connectionId?: string;
     readonly approval: boolean;
     readonly inputs: readonly (InputPort & {
         readonly source: AgentInput;
     })[];
 }
+export interface AgentConnectorTool extends AgentToolBase {
+    readonly kind?: 'connector';
+    readonly action: string;
+    readonly connectionId?: string;
+}
+export interface WorkflowCapability {
+    readonly kind: 'workflow';
+    readonly name: string;
+    readonly flowId: string;
+    readonly revisionId: string;
+    readonly inputs: readonly Port[];
+    readonly outputs: readonly Port[] | null;
+}
+export interface AgentWorkflowTool extends AgentToolBase, Omit<WorkflowCapability, 'inputs'> {
+    readonly action?: never;
+    readonly connectionId?: never;
+}
+export type AgentTool = AgentConnectorTool | AgentWorkflowTool;
+export type TaskCapability = ConnectorCapability | WorkflowCapability;
+export declare const workflowToolNamePattern: RegExp;
+export declare function workflowToolNameIssue(name: string, otherNames?: Iterable<string>): 'invalid' | 'duplicate' | undefined;
+export declare function decodeTaskCapabilities(value: unknown): readonly TaskCapability[];
 export interface ConnectorAccessCapability {
     readonly actionHints?: readonly string[];
     readonly connectionHints?: readonly {
@@ -195,7 +215,7 @@ interface TaskDefinitionBase {
     readonly outputs: readonly (Port | Group)[];
 }
 export interface InlineTaskDefinition extends TaskDefinitionBase {
-    readonly capabilities?: readonly ConnectorCapability[];
+    readonly capabilities?: readonly TaskCapability[];
     readonly moduleId: string;
 }
 export interface ManagedTaskDefinition extends TaskDefinitionBase {
@@ -334,7 +354,7 @@ export interface CodeModule {
 }
 export interface RevisionContent {
     readonly document: FlowDocument;
-    readonly modelVersion: 2 | 4 | 5 | 6 | 7 | 8 | 9 | typeof currentFlowModelVersion;
+    readonly modelVersion: 2 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | typeof currentFlowModelVersion;
     readonly modules: Readonly<Record<string, CodeModule>>;
 }
 export interface GraphEdge {
@@ -354,10 +374,10 @@ export type ChangeOperation = {
     readonly before: GraphNode;
     readonly node: GraphNode;
 } | {
-    readonly before?: readonly ConnectorCapability[];
+    readonly before?: readonly TaskCapability[];
     readonly kind: 'graph.node.task.capabilities.set';
     readonly nodeId: string;
-    readonly value?: readonly ConnectorCapability[];
+    readonly value?: readonly TaskCapability[];
 } | {
     readonly kind: 'graph.trigger.sources.set';
     readonly nodeId: string;