@oomol-lab/open-flow 0.1.0-beta.65 → 0.1.0-beta.67

package/dist/common/webhook-trigger.js

@@ -5810,6 +5810,7 @@ function webhookSupportsBody(method) {
 	return method !== "GET";
 }
 var text = string();
+var actionConnection = text.describe("Account selection: omit while unconfigured; use an account ID to select it; use \"\" to explicitly defer configuration. Deferred Actions fail if called; deferred Agent tools are excluded from the callable tool set. Not supported by Triggers.");
 var json = json$1();
 var strings = array(text);
 var port = object({
@@ -5818,6 +5819,7 @@ var port = object({
 	nullable: boolean(),
 	handle: text
 });
+var workflowInputDefs = array(port.strict());
 var input = port.extend({ value: json.optional() });
 var group = object({
 	collapsed: boolean().optional(),
@@ -5864,7 +5866,7 @@ var capability = union([
 		mode: literal("independent"),
 		actions: array(strictObject({
 			action: text,
-			connectionId: text.optional()
+			connectionId: actionConnection.optional()
 		}))
 	}),
 	strictObject({
@@ -5924,7 +5926,7 @@ var managedFields = object({
 		object({
 			kind: literal("connector"),
 			action: text,
-			connectionId: text.optional(),
+			connectionId: actionConnection.optional(),
 			outputMode: literal("value").optional()
 		}),
 		object({
@@ -5964,17 +5966,22 @@ var managedFields = object({
 				name: text,
 				description: text,
 				action: text,
-				connectionId: text.optional(),
+				connectionId: actionConnection.optional(),
 				approval: boolean(),
 				inputs: array(input.extend({ source: agentInput }))
 			})),
 			notification: object({
 				action: text,
-				connectionId: text.optional(),
+				connectionId: actionConnection.optional(),
 				inputDefinitions: array(input),
 				messageHandle: text,
 				inputs: record$1(text, agentValue)
 			}).optional()
+		}),
+		strictObject({
+			kind: literal("workflow"),
+			flowId: text,
+			revisionId: text
 		})
 	])
 });
@@ -6083,6 +6090,12 @@ var base = {
 	timeoutMs: number().optional()
 };
 var node = union([
+	strictObject({
+		...base,
+		kind: literal("outputs"),
+		outputDefs: array(port.strict()),
+		outputMappings: inputs
+	}).omit({ inputs: true }),
 	object({
 		...base,
 		inputs: record$1(text, never()),
@@ -6115,6 +6128,11 @@ var node = union([
 		...trigger,
 		kind: literal("manual")
 	}),
+	strictObject({
+		...trigger,
+		kind: literal("start"),
+		inputDefs: workflowInputDefs
+	}),
 	strictObject({
 		...trigger,
 		kind: literal("error"),
@@ -6179,7 +6197,7 @@ var module = object({
 	imports: strings,
 	source: text
 });
-var document = preprocess(rejectRetiredDefinitions, object({
+var document = preprocess(normalizeDocument, object({
 	bindings: record$1(text, binding),
 	graph
 }));
@@ -6188,7 +6206,9 @@ object({
 		literal(2),
 		literal(4),
 		literal(5),
-		literal(6)
+		literal(6),
+		literal(7),
+		literal(8)
 	]),
 	document,
 	modules: record$1(text, module)
@@ -6196,13 +6216,19 @@ object({
 	kind: literal("open-flow-flow-revision"),
 	version: literal(1)
 });
-function rejectRetiredDefinitions(value) {
+function normalizeDocument(value) {
 	const candidate = record(value);
 	if (candidate.tasks !== void 0 && (candidate.tasks === null || typeof candidate.tasks !== "object" || Array.isArray(candidate.tasks) || Object.keys(candidate.tasks).length > 0)) throw new TypeError("Independent Task definitions are no longer supported.");
 	if (Object.values(record(record(candidate.graph).nodes)).some((candidateNode) => Object.hasOwn(record(candidateNode), "taskId"))) throw new TypeError("Task references are no longer supported.");
 	const subflows = candidate.subflows;
 	if (subflows !== void 0 && (subflows === null || typeof subflows !== "object" || Array.isArray(subflows) || Object.keys(subflows).length > 0)) throw new TypeError("Subflows are no longer supported.");
 	if (Object.values(record(record(candidate.graph).nodes)).some((candidateNode) => record(candidateNode).kind === "subflow")) throw new TypeError("Subflow nodes are no longer supported.");
+	if ([
+		"inputDefs",
+		"outputDefs",
+		"outputMappings"
+	].some((field) => Object.hasOwn(candidate, field))) throw new TypeError("Workflow interface configuration must belong to Start and Outputs nodes.");
+	if (Object.values(record(record(candidate.graph).nodes)).some((candidateNode) => record(candidateNode).kind == "start" && Object.hasOwn(record(candidateNode), "parameters"))) throw new TypeError("Legacy Start.parameters is unsupported; configure node.inputDefs.");
 	return value;
 }
 function record(value) {

package/dist/common/workflow.d.ts

@@ -0,0 +1,93 @@
+import type { TaskNode, ManagedTaskDefinition, Port, JsonValue, RevisionContent } from '../browser/flow-change.js';
+import { z } from 'zod';
+export interface WorkflowExecutor {
+    readonly kind: 'workflow';
+    readonly flowId: string;
+    readonly revisionId: string;
+}
+export declare const publishedWorkflowInterfaceSchema: z.ZodObject<{
+    inputs: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        handle: z.ZodString;
+        jsonSchema: z.ZodType<JsonValue>;
+        nullable: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    outputs: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        handle: z.ZodString;
+        jsonSchema: z.ZodType<JsonValue>;
+        nullable: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strict>;
+export type PublishedWorkflowInterface = z.infer<typeof publishedWorkflowInterfaceSchema>;
+/** The callable interface of one fixed definition; absence differs from empty ports. */
+export declare function publishedWorkflowInterface(content: Pick<RevisionContent, 'document'>): PublishedWorkflowInterface;
+export declare function sameWorkflowInterface(left: PublishedWorkflowInterface, right: PublishedWorkflowInterface): boolean;
+export declare const workflowContractSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    flowId: z.ZodString;
+    name: z.ZodString;
+    revisionId: z.ZodString;
+    publicationId: z.ZodString;
+    inputs: z.ZodArray<z.ZodObject<{
+        handle: z.ZodString;
+        jsonSchema: z.ZodType<JsonValue>;
+        nullable: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    outputs: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        handle: z.ZodString;
+        jsonSchema: z.ZodType<JsonValue>;
+        nullable: z.ZodBoolean;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type WorkflowContract = z.infer<typeof workflowContractSchema>;
+export interface WorkflowCandidate {
+    readonly flowId: string;
+    readonly name: string;
+    readonly problem: 'unpublished' | 'disabled' | 'retiring' | 'recursive' | 'missing-start' | null;
+}
+/** Classify only list metadata; opening the selector does not inspect a Revision. */
+export declare function workflowCandidate(flow: {
+    flowId: string;
+    name: string;
+    status: string;
+    live?: {
+        enabled: boolean;
+        hasStart: boolean;
+    } | null;
+}, sourceFlowId?: string): WorkflowCandidate;
+export declare function workflowCandidateGroup(candidate: WorkflowCandidate): 'published' | 'missingStart' | 'other';
+/** A selected target is durable even before its callable interface is available. */
+export declare function workflowSelectionTask(candidate: Pick<WorkflowCandidate, 'flowId' | 'name'>, contract?: WorkflowContract, previous?: ManagedTaskDefinition): ManagedTaskDefinition;
+export declare function workflowTask(contract: WorkflowContract, name?: string): ManagedTaskDefinition;
+export declare function workflowPorts(ports: readonly Port[]): WorkflowContract['inputs'];
+export declare function workflowCompatibility(node: TaskNode, contract: WorkflowContract, previous?: PublishedWorkflowInterface): readonly {
+    side: 'revision' | 'input' | 'output';
+    field: string;
+    message: string;
+    reason?: 'snapshot-missing' | 'interface-required' | 'revision-stale';
+}[];
+/** Refresh capability ports by exact name; removed outputs remain unresolved at consumers. */
+export declare function withWorkflowTask(node: TaskNode, task: ManagedTaskDefinition): TaskNode;
+export declare const workflowReferencesSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    direction: z.ZodEnum<{
+        incoming: "incoming";
+        outgoing: "outgoing";
+    }>;
+    total: z.ZodInt;
+    nextOffset: z.ZodOptional<z.ZodInt>;
+    references: z.ZodArray<z.ZodObject<{
+        flowId: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        available: z.ZodBoolean;
+        draft: z.ZodBoolean;
+        live: z.ZodNullable<z.ZodObject<{
+            publicationId: z.ZodString;
+            enabled: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WorkflowReferences = z.infer<typeof workflowReferencesSchema>;