@oxygen-agent/cli 1.700.10 → 1.717.9

package/node_modules/@oxygen/workflows/dist/graph/manifest-schema.d.ts

@@ -147,6 +147,15 @@ export declare const workflowGraphManifestSchema: {
                             readonly required: readonly ["type"];
                         };
                     };
+                    readonly payload_source: {
+                        readonly type: "string";
+                        readonly description: "Imported v1 tool nodes only: sandboxed payload function preserved until converted to mapped params.";
+                    };
+                    readonly legacy_context: {
+                        readonly type: "string";
+                        readonly enum: readonly ["v1"];
+                        readonly description: "Imported v1 source receives the original raw-step-output context shape.";
+                    };
                     readonly when: {
                         readonly type: "object";
                         readonly description: "A structured predicate: { type: 'group', op: 'all' | 'any', not?: boolean, children: [...] } or { type: 'compare', left, op, right? }. 'is_empty' / 'is_not_empty' take no right operand.";
@@ -429,6 +438,40 @@ export declare const workflowGraphManifestSchema: {
                         readonly type: "string";
                         readonly description: "code nodes: sandboxed pure-function source.";
                     };
+                    readonly recipe: {
+                        readonly type: "object";
+                        readonly description: "Imported durable-recipe code nodes: the complete executable recipe manifest. Exactly one of run_source or recipe is required.";
+                        readonly additionalProperties: true;
+                    };
+                    readonly configuration: {
+                        readonly type: "object";
+                        readonly description: "Imported durable-recipe code nodes: configuration field -> value ref.";
+                        readonly additionalProperties: {
+                            readonly type: "object";
+                            readonly description: "How a node input is bound at run time. Scope paths are 'trigger.input.x', 'steps.<node_id>.output.y', or 'loop.<loop_node_id>.item.z'.";
+                            readonly properties: {
+                                readonly type: {
+                                    readonly enum: readonly ["literal", "template", "ref", "formula", "context_profile", "context_asset"];
+                                };
+                                readonly value: {
+                                    readonly description: "literal: used verbatim. template: interpolated string, e.g. 'Hi {{ steps.find.output.first_name }}'.";
+                                };
+                                readonly path: {
+                                    readonly type: "string";
+                                    readonly description: "ref: a scope path. context_*: an optional path inside the context value.";
+                                };
+                                readonly expression: {
+                                    readonly type: "string";
+                                    readonly description: "formula: an OXYGEN formula-language expression.";
+                                };
+                                readonly assetId: {
+                                    readonly type: "string";
+                                    readonly description: "context_asset: the Knowledge-layer asset id.";
+                                };
+                            };
+                            readonly required: readonly ["type"];
+                        };
+                    };
                     readonly workflow_id: {
                         readonly type: "string";
                         readonly description: "workflow nodes: the child workflow to run.";
@@ -504,3 +547,639 @@ export declare const workflowGraphManifestSchema: {
     };
     readonly required: readonly ["manifest_version", "workflow", "nodes", "edges", "source_hash", "compiler_version"];
 };
+export declare const portableWorkflowDefinitionSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly title: "OXYGEN Portable Workflow Definition";
+    readonly description: "A portable, editable oxygen-workflows-v2 graph. It never contains source-workspace connection UUIDs or standing trigger authority.";
+    readonly type: "object";
+    readonly additionalProperties: false;
+    readonly properties: {
+        readonly kind: {
+            readonly const: "oxygen-workflow-definition";
+        };
+        readonly definition_version: {
+            readonly const: 1;
+        };
+        readonly graph: {
+            readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+            readonly title: "OXYGEN Workflow Graph Manifest (oxygen-workflows-v2)";
+            readonly description: "A node + edge workflow graph. Exactly one trigger node; every node reachable from it; cycles are illegal except a single back-edge from inside a loop's body to that loop node.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly properties: {
+                readonly manifest_version: {
+                    readonly const: 2;
+                };
+                readonly compiler_version: {
+                    readonly const: "oxygen-workflows-v2";
+                };
+                readonly workflow: {
+                    readonly type: "object";
+                    readonly properties: {
+                        readonly id: {
+                            readonly type: "string";
+                        };
+                        readonly name: {
+                            readonly type: "string";
+                        };
+                        readonly status: {
+                            readonly enum: readonly ["active", "disabled"];
+                        };
+                    };
+                    readonly required: readonly ["id", "name"];
+                };
+                readonly specification: {
+                    readonly type: "string";
+                };
+                readonly trigger: {
+                    readonly type: "object";
+                    readonly additionalProperties: true;
+                    readonly description: "See the 'trigger' schema subject.";
+                };
+                readonly input_schema: {
+                    readonly type: "object";
+                    readonly additionalProperties: true;
+                };
+                readonly nodes: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: true;
+                        readonly properties: {
+                            readonly id: {
+                                readonly type: "string";
+                                readonly description: "Unique node id. Becomes a key on the run scope ('steps.<id>.output'), so '__proto__', 'constructor' and 'prototype' are rejected.";
+                            };
+                            readonly name: {
+                                readonly type: "string";
+                            };
+                            readonly description: {
+                                readonly type: "string";
+                            };
+                            readonly kind: {
+                                readonly enum: readonly ["trigger", "tool", "filter", "switch", "loop", "merge", "set", "wait", "approval", "code", "workflow"];
+                            };
+                            readonly ui: {
+                                readonly type: "object";
+                                readonly description: "Canvas position. Presentation only — it never affects execution order.";
+                                readonly properties: {
+                                    readonly x: {
+                                        readonly type: "number";
+                                    };
+                                    readonly y: {
+                                        readonly type: "number";
+                                    };
+                                };
+                                readonly required: readonly ["x", "y"];
+                            };
+                            readonly disabled: {
+                                readonly type: "boolean";
+                                readonly description: "Kept in the graph but skipped at run time.";
+                            };
+                            readonly continue_on_error: {
+                                readonly type: "boolean";
+                                readonly description: "Route failures to the 'error' handle instead of failing the run.";
+                            };
+                            readonly retry: {
+                                readonly type: "object";
+                                readonly description: string;
+                                readonly properties: {
+                                    readonly max_attempts: {
+                                        readonly type: "integer";
+                                        readonly minimum: 1;
+                                        readonly maximum: 5;
+                                        readonly description: "Attempts for this node, counting the first.";
+                                    };
+                                    readonly wait_seconds: {
+                                        readonly type: "number";
+                                        readonly minimum: 0;
+                                        readonly maximum: 3600;
+                                        readonly description: "Fixed pause between attempts. Omit to use the run's own backoff.";
+                                    };
+                                };
+                                readonly required: readonly ["max_attempts"];
+                            };
+                            readonly tool: {
+                                readonly type: "string";
+                                readonly description: "tool nodes: the tool id to call.";
+                            };
+                            readonly effect: {
+                                readonly enum: readonly ["none", "external_read", "external_write"];
+                                readonly description: "tool nodes: must equal the tool's canonical effect.";
+                            };
+                            readonly mode: {
+                                readonly enum: readonly ["dry_run", "live", "smoke_test"];
+                            };
+                            readonly connection_id: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                                readonly description: "tool nodes: optional active organization connection id to pin for execution.";
+                            };
+                            readonly max_credits: {
+                                readonly type: "number";
+                                readonly exclusiveMinimum: 0;
+                                readonly description: "Per-node managed-credit ceiling.";
+                            };
+                            readonly params: {
+                                readonly type: "object";
+                                readonly description: "tool nodes: parameter name -> value ref.";
+                                readonly additionalProperties: {
+                                    readonly type: "object";
+                                    readonly description: "How a node input is bound at run time. Scope paths are 'trigger.input.x', 'steps.<node_id>.output.y', or 'loop.<loop_node_id>.item.z'.";
+                                    readonly properties: {
+                                        readonly type: {
+                                            readonly enum: readonly ["literal", "template", "ref", "formula", "context_profile", "context_asset"];
+                                        };
+                                        readonly value: {
+                                            readonly description: "literal: used verbatim. template: interpolated string, e.g. 'Hi {{ steps.find.output.first_name }}'.";
+                                        };
+                                        readonly path: {
+                                            readonly type: "string";
+                                            readonly description: "ref: a scope path. context_*: an optional path inside the context value.";
+                                        };
+                                        readonly expression: {
+                                            readonly type: "string";
+                                            readonly description: "formula: an OXYGEN formula-language expression.";
+                                        };
+                                        readonly assetId: {
+                                            readonly type: "string";
+                                            readonly description: "context_asset: the Knowledge-layer asset id.";
+                                        };
+                                    };
+                                    readonly required: readonly ["type"];
+                                };
+                            };
+                            readonly payload_source: {
+                                readonly type: "string";
+                                readonly description: "Imported v1 tool nodes only: sandboxed payload function preserved until converted to mapped params.";
+                            };
+                            readonly legacy_context: {
+                                readonly type: "string";
+                                readonly enum: readonly ["v1"];
+                                readonly description: "Imported v1 source receives the original raw-step-output context shape.";
+                            };
+                            readonly when: {
+                                readonly type: "object";
+                                readonly description: "A structured predicate: { type: 'group', op: 'all' | 'any', not?: boolean, children: [...] } or { type: 'compare', left, op, right? }. 'is_empty' / 'is_not_empty' take no right operand.";
+                                readonly properties: {
+                                    readonly type: {
+                                        readonly enum: readonly ["group", "compare"];
+                                    };
+                                    readonly op: {
+                                        readonly enum: readonly ["all", "any", "eq", "neq", "gt", "gte", "lt", "lte", "contains", "not_contains", "starts_with", "ends_with", "is_empty", "is_not_empty", "in", "not_in", "matches"];
+                                    };
+                                    readonly not: {
+                                        readonly type: "boolean";
+                                    };
+                                    readonly children: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "object";
+                                            readonly additionalProperties: true;
+                                        };
+                                    };
+                                    readonly left: {
+                                        readonly type: "object";
+                                        readonly description: "How a node input is bound at run time. Scope paths are 'trigger.input.x', 'steps.<node_id>.output.y', or 'loop.<loop_node_id>.item.z'.";
+                                        readonly properties: {
+                                            readonly type: {
+                                                readonly enum: readonly ["literal", "template", "ref", "formula", "context_profile", "context_asset"];
+                                            };
+                                            readonly value: {
+                                                readonly description: "literal: used verbatim. template: interpolated string, e.g. 'Hi {{ steps.find.output.first_name }}'.";
+                                            };
+                                            readonly path: {
+                                                readonly type: "string";
+                                                readonly description: "ref: a scope path. context_*: an optional path inside the context value.";
+                                            };
+                                            readonly expression: {
+                                                readonly type: "string";
+                                                readonly description: "formula: an OXYGEN formula-language expression.";
+                                            };
+                                            readonly assetId: {
+                                                readonly type: "string";
+                                                readonly description: "context_asset: the Knowledge-layer asset id.";
+                                            };
+                                        };
+                                        readonly required: readonly ["type"];
+                                    };
+                                    readonly right: {
+                                        readonly type: "object";
+                                        readonly description: "How a node input is bound at run time. Scope paths are 'trigger.input.x', 'steps.<node_id>.output.y', or 'loop.<loop_node_id>.item.z'.";
+                                        readonly properties: {
+                                            readonly type: {
+                                                readonly enum: readonly ["literal", "template", "ref", "formula", "context_profile", "context_asset"];
+                                            };
+                                            readonly value: {
+                                                readonly description: "literal: used verbatim. template: interpolated string, e.g. 'Hi {{ steps.find.output.first_name }}'.";
+                                            };
+                                            readonly path: {
+                                                readonly type: "string";
+                                                readonly description: "ref: a scope path. context_*: an optional path inside the context value.";
+                                            };
+                                            readonly expression: {
+                                                readonly type: "string";
+                                                readonly description: "formula: an OXYGEN formula-language expression.";
+                                            };
+                                            readonly assetId: {
+                                                readonly type: "string";
+                                                readonly description: "context_asset: the Knowledge-layer asset id.";
+                                            };
+                                        };
+                                        readonly required: readonly ["type"];
+                                    };
+                                };
+                                readonly required: readonly ["type"];
+                            };
+                            readonly cases: {
+                                readonly type: "array";
+                                readonly description: "switch nodes: each case id names the outgoing edge handle it owns.";
+                                readonly items: {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly id: {
+                                            readonly type: "string";
+                                        };
+                                        readonly label: {
+                                            readonly type: "string";
+                                        };
+                                        readonly when: {
+                                            readonly type: "object";
+                                            readonly description: "A structured predicate: { type: 'group', op: 'all' | 'any', not?: boolean, children: [...] } or { type: 'compare', left, op, right? }. 'is_empty' / 'is_not_empty' take no right operand.";
+                                            readonly properties: {
+                                                readonly type: {
+                                                    readonly enum: readonly ["group", "compare"];
+                                                };
+                                                readonly op: {
+                                                    readonly enum: readonly ["all", "any", "eq", "neq", "gt", "gte", "lt", "lte", "contains", "not_contains", "starts_with", "ends_with", "is_empty", "is_not_empty", "in", "not_in", "matches"];
+                                                };
+                                                readonly not: {
+                                                    readonly type: "boolean";
+                                                };
+                                                readonly children: {
+                                                    readonly type: "array";
+                                                    readonly items: {
+                                                        readonly type: "object";
+                                                        readonly additionalProperties: true;
+                                                    };
+                                                };
+                                                readonly left: {
+                                                    readonly type: "object";
+                                                    readonly description: "How a node input is bound at run time. Scope paths are 'trigger.input.x', 'steps.<node_id>.output.y', or 'loop.<loop_node_id>.item.z'.";
+                                                    readonly properties: {
+                                                        readonly type: {
+                                                            readonly enum: readonly ["literal", "template", "ref", "formula", "context_profile", "context_asset"];
+                                                        };
+                                                        readonly value: {
+                                                            readonly description: "literal: used verbatim. template: interpolated string, e.g. 'Hi {{ steps.find.output.first_name }}'.";
+                                                        };
+                                                        readonly path: {
+                                                            readonly type: "string";
+                                                            readonly description: "ref: a scope path. context_*: an optional path inside the context value.";
+                                                        };
+                                                        readonly expression: {
+                                                            readonly type: "string";
+                                                            readonly description: "formula: an OXYGEN formula-language expression.";
+                                                        };
+                                                        readonly assetId: {
+                                                            readonly type: "string";
+                                                            readonly description: "context_asset: the Knowledge-layer asset id.";
+                                                        };
+                                                    };
+                                                    readonly required: readonly ["type"];
+                                                };
+                                                readonly right: {
+                                                    readonly type: "object";
+                                                    readonly description: "How a node input is bound at run time. Scope paths are 'trigger.input.x', 'steps.<node_id>.output.y', or 'loop.<loop_node_id>.item.z'.";
+                                                    readonly properties: {
+                                                        readonly type: {
+                                                            readonly enum: readonly ["literal", "template", "ref", "formula", "context_profile", "context_asset"];
+                                                        };
+                                                        readonly value: {
+                                                            readonly description: "literal: used verbatim. template: interpolated string, e.g. 'Hi {{ steps.find.output.first_name }}'.";
+                                                        };
+                                                        readonly path: {
+                                                            readonly type: "string";
+                                                            readonly description: "ref: a scope path. context_*: an optional path inside the context value.";
+                                                        };
+                                                        readonly expression: {
+                                                            readonly type: "string";
+                                                            readonly description: "formula: an OXYGEN formula-language expression.";
+                                                        };
+                                                        readonly assetId: {
+                                                            readonly type: "string";
+                                                            readonly description: "context_asset: the Knowledge-layer asset id.";
+                                                        };
+                                                    };
+                                                    readonly required: readonly ["type"];
+                                                };
+                                            };
+                                            readonly required: readonly ["type"];
+                                        };
+                                    };
+                                    readonly required: readonly ["id", "label", "when"];
+                                };
+                            };
+                            readonly fallthrough: {
+                                readonly type: "boolean";
+                                readonly description: "switch nodes: fire every matching case, not only the first.";
+                            };
+                            readonly over: {
+                                readonly type: "object";
+                                readonly description: "How a node input is bound at run time. Scope paths are 'trigger.input.x', 'steps.<node_id>.output.y', or 'loop.<loop_node_id>.item.z'.";
+                                readonly properties: {
+                                    readonly type: {
+                                        readonly enum: readonly ["literal", "template", "ref", "formula", "context_profile", "context_asset"];
+                                    };
+                                    readonly value: {
+                                        readonly description: "literal: used verbatim. template: interpolated string, e.g. 'Hi {{ steps.find.output.first_name }}'.";
+                                    };
+                                    readonly path: {
+                                        readonly type: "string";
+                                        readonly description: "ref: a scope path. context_*: an optional path inside the context value.";
+                                    };
+                                    readonly expression: {
+                                        readonly type: "string";
+                                        readonly description: "formula: an OXYGEN formula-language expression.";
+                                    };
+                                    readonly assetId: {
+                                        readonly type: "string";
+                                        readonly description: "context_asset: the Knowledge-layer asset id.";
+                                    };
+                                };
+                                readonly required: readonly ["type"];
+                            };
+                            readonly item_name: {
+                                readonly type: "string";
+                            };
+                            readonly max_iterations: {
+                                readonly type: "integer";
+                                readonly exclusiveMinimum: 0;
+                                readonly description: "loop nodes: declared iteration cap. Without it the workflow's automation-action estimate can only assume a single pass, and cron cadence checks treat the run cost as unbounded.";
+                            };
+                            readonly concurrency: {
+                                readonly type: "integer";
+                                readonly exclusiveMinimum: 0;
+                            };
+                            readonly strategy: {
+                                readonly enum: readonly ["append", "first", "wait_all"];
+                                readonly description: "merge nodes: how inbound branches are joined.";
+                            };
+                            readonly fields: {
+                                readonly type: "array";
+                                readonly description: "set nodes: the object built from bound fields.";
+                                readonly items: {
+                                    readonly type: "object";
+                                    readonly properties: {
+                                        readonly key: {
+                                            readonly type: "string";
+                                        };
+                                        readonly value: {
+                                            readonly type: "object";
+                                            readonly description: "How a node input is bound at run time. Scope paths are 'trigger.input.x', 'steps.<node_id>.output.y', or 'loop.<loop_node_id>.item.z'.";
+                                            readonly properties: {
+                                                readonly type: {
+                                                    readonly enum: readonly ["literal", "template", "ref", "formula", "context_profile", "context_asset"];
+                                                };
+                                                readonly value: {
+                                                    readonly description: "literal: used verbatim. template: interpolated string, e.g. 'Hi {{ steps.find.output.first_name }}'.";
+                                                };
+                                                readonly path: {
+                                                    readonly type: "string";
+                                                    readonly description: "ref: a scope path. context_*: an optional path inside the context value.";
+                                                };
+                                                readonly expression: {
+                                                    readonly type: "string";
+                                                    readonly description: "formula: an OXYGEN formula-language expression.";
+                                                };
+                                                readonly assetId: {
+                                                    readonly type: "string";
+                                                    readonly description: "context_asset: the Knowledge-layer asset id.";
+                                                };
+                                            };
+                                            readonly required: readonly ["type"];
+                                        };
+                                    };
+                                    readonly required: readonly ["key", "value"];
+                                };
+                            };
+                            readonly keep_input: {
+                                readonly type: "boolean";
+                            };
+                            readonly duration_seconds: {
+                                readonly type: "number";
+                                readonly exclusiveMinimum: 0;
+                                readonly description: "wait nodes: exactly one of duration_seconds or until.";
+                            };
+                            readonly until: {
+                                readonly type: "object";
+                                readonly description: "How a node input is bound at run time. Scope paths are 'trigger.input.x', 'steps.<node_id>.output.y', or 'loop.<loop_node_id>.item.z'.";
+                                readonly properties: {
+                                    readonly type: {
+                                        readonly enum: readonly ["literal", "template", "ref", "formula", "context_profile", "context_asset"];
+                                    };
+                                    readonly value: {
+                                        readonly description: "literal: used verbatim. template: interpolated string, e.g. 'Hi {{ steps.find.output.first_name }}'.";
+                                    };
+                                    readonly path: {
+                                        readonly type: "string";
+                                        readonly description: "ref: a scope path. context_*: an optional path inside the context value.";
+                                    };
+                                    readonly expression: {
+                                        readonly type: "string";
+                                        readonly description: "formula: an OXYGEN formula-language expression.";
+                                    };
+                                    readonly assetId: {
+                                        readonly type: "string";
+                                        readonly description: "context_asset: the Knowledge-layer asset id.";
+                                    };
+                                };
+                                readonly required: readonly ["type"];
+                            };
+                            readonly run_source: {
+                                readonly type: "string";
+                                readonly description: "code nodes: sandboxed pure-function source.";
+                            };
+                            readonly recipe: {
+                                readonly type: "object";
+                                readonly description: "Imported durable-recipe code nodes: the complete executable recipe manifest. Exactly one of run_source or recipe is required.";
+                                readonly additionalProperties: true;
+                            };
+                            readonly configuration: {
+                                readonly type: "object";
+                                readonly description: "Imported durable-recipe code nodes: configuration field -> value ref.";
+                                readonly additionalProperties: {
+                                    readonly type: "object";
+                                    readonly description: "How a node input is bound at run time. Scope paths are 'trigger.input.x', 'steps.<node_id>.output.y', or 'loop.<loop_node_id>.item.z'.";
+                                    readonly properties: {
+                                        readonly type: {
+                                            readonly enum: readonly ["literal", "template", "ref", "formula", "context_profile", "context_asset"];
+                                        };
+                                        readonly value: {
+                                            readonly description: "literal: used verbatim. template: interpolated string, e.g. 'Hi {{ steps.find.output.first_name }}'.";
+                                        };
+                                        readonly path: {
+                                            readonly type: "string";
+                                            readonly description: "ref: a scope path. context_*: an optional path inside the context value.";
+                                        };
+                                        readonly expression: {
+                                            readonly type: "string";
+                                            readonly description: "formula: an OXYGEN formula-language expression.";
+                                        };
+                                        readonly assetId: {
+                                            readonly type: "string";
+                                            readonly description: "context_asset: the Knowledge-layer asset id.";
+                                        };
+                                    };
+                                    readonly required: readonly ["type"];
+                                };
+                            };
+                            readonly workflow_id: {
+                                readonly type: "string";
+                                readonly description: "workflow nodes: the child workflow to run.";
+                            };
+                            readonly input: {
+                                readonly type: "object";
+                                readonly description: "workflow nodes: child input name -> value ref.";
+                                readonly additionalProperties: {
+                                    readonly type: "object";
+                                    readonly description: "How a node input is bound at run time. Scope paths are 'trigger.input.x', 'steps.<node_id>.output.y', or 'loop.<loop_node_id>.item.z'.";
+                                    readonly properties: {
+                                        readonly type: {
+                                            readonly enum: readonly ["literal", "template", "ref", "formula", "context_profile", "context_asset"];
+                                        };
+                                        readonly value: {
+                                            readonly description: "literal: used verbatim. template: interpolated string, e.g. 'Hi {{ steps.find.output.first_name }}'.";
+                                        };
+                                        readonly path: {
+                                            readonly type: "string";
+                                            readonly description: "ref: a scope path. context_*: an optional path inside the context value.";
+                                        };
+                                        readonly expression: {
+                                            readonly type: "string";
+                                            readonly description: "formula: an OXYGEN formula-language expression.";
+                                        };
+                                        readonly assetId: {
+                                            readonly type: "string";
+                                            readonly description: "context_asset: the Knowledge-layer asset id.";
+                                        };
+                                    };
+                                    readonly required: readonly ["type"];
+                                };
+                            };
+                        };
+                        readonly required: readonly ["id", "name", "kind", "ui"];
+                    };
+                    readonly minItems: 1;
+                };
+                readonly edges: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly id: {
+                                readonly type: "string";
+                            };
+                            readonly source: {
+                                readonly type: "string";
+                            };
+                            readonly source_handle: {
+                                readonly type: "string";
+                                readonly description: "Which output of the source node this edge leaves from: a switch case id, 'loop_body', 'loop_done', 'error', or omitted for the default output.";
+                            };
+                            readonly target: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly required: readonly ["id", "source", "target"];
+                    };
+                };
+                readonly max_credits: {
+                    readonly type: "number";
+                    readonly exclusiveMinimum: 0;
+                    readonly description: "Per-RUN managed-credit ceiling.";
+                };
+                readonly source_hash: {
+                    readonly type: "string";
+                };
+                readonly created_at: {
+                    readonly type: "string";
+                };
+            };
+            readonly required: readonly ["manifest_version", "workflow", "nodes", "edges", "source_hash", "compiler_version"];
+        };
+        readonly requirements: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly connections: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly additionalProperties: false;
+                        readonly properties: {
+                            readonly binding_id: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly integration_id: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly node_ids: {
+                                readonly type: "array";
+                                readonly minItems: 1;
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                            };
+                            readonly account_hint: {
+                                readonly type: "object";
+                                readonly additionalProperties: false;
+                                readonly properties: {
+                                    readonly external_account_id: {
+                                        readonly type: "string";
+                                    };
+                                    readonly display_name: {
+                                        readonly type: "string";
+                                    };
+                                    readonly auth_scheme: {
+                                        readonly type: "string";
+                                    };
+                                };
+                            };
+                        };
+                        readonly required: readonly ["binding_id", "integration_id", "node_ids"];
+                    };
+                };
+            };
+            readonly required: readonly ["connections"];
+        };
+        readonly exported_at: {
+            readonly type: "string";
+            readonly format: "date-time";
+        };
+        readonly exported_from: {
+            readonly type: "object";
+            readonly additionalProperties: false;
+            readonly properties: {
+                readonly workflow_slug: {
+                    readonly type: "string";
+                };
+                readonly revision_version: {
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly oxygen_version: {
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly compiler_version: {
+            readonly const: "oxygen-workflow-definition-v1";
+        };
+    };
+    readonly required: readonly ["kind", "definition_version", "graph", "requirements", "exported_at", "compiler_version"];
+};