@openapi-flow/core 0.1.0 → 0.3.0

package/dist/schemas/workflow-draft-api-binding-edit-schema.js

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { createWorkflowDraftEditMessageFields } from './workflow-draft-edit-message-fields.js';
+import { workflowDraftApiBindingEditScopeSchema } from './workflow-draft-api-binding-edit-scope-schema.js';
+/** Only semantic ownership/source choices. Node kind, identities and patch values are code-owned. */
+export function createWorkflowDraftApiBindingEditProposalSchema(context, messageSchema) {
+    if (!Array.isArray(context.sourceCandidates) ||
+        !Array.isArray(context.messages))
+        throw new Error('Binding edit schema requires sourceCandidates and messages arrays');
+    const scope = workflowDraftApiBindingEditScopeSchema.parse(context.scope);
+    const sourceIds = z
+        .array(z.string().refine((id) => id.trim().length > 0))
+        .refine((ids) => new Set(ids).size === ids.length)
+        .parse(context.sourceCandidates.map((source) => source.nodeId));
+    const evidence = createWorkflowDraftEditMessageFields(context.messages.map((message) => message.id), context.includeExplanations, messageSchema);
+    const pointer = scope.kind === 'repair'
+        ? z.enum(z
+            .array(z.string().min(1))
+            .min(1)
+            .refine((items) => new Set(items).size === items.length)
+            .parse(context.requiredTargetPointers))
+        : z.string().min(1);
+    const fields = {
+        targetPointer: pointer.describe('Exact RFC 6901 input pointer whose ownership/source is explicitly requested to change. Never a JavaScript expression.'),
+        sources: z.array(evidence.message).min(1),
+        ...evidence.fields,
+    };
+    const choices = [
+        z.strictObject({ kind: z.literal('unbind'), ...fields }),
+        z.strictObject({
+            kind: z.literal('needs-clarification'),
+            message: z
+                .string()
+                .min(1)
+                .describe('A concrete question for the unresolved producer or mapping choice; never invent an API, transformation or value.'),
+            ...fields,
+        }),
+    ];
+    if (scope.kind === 'repair')
+        choices.push(z.strictObject({ kind: z.literal('keep'), ...fields }));
+    if (sourceIds.length) {
+        const sourceFields = {
+            sourceNodeId: z.enum(sourceIds),
+            sourcePointer: z
+                .string()
+                .describe('RFC 6901 pointer into the declared API response BODY or native JSON output; empty means the whole value. Use the original contracts, not transport-envelope guesses. No computation, coercion or field-name matching.'),
+        };
+        choices.push(z.strictObject({ kind: z.literal('bind'), ...fields, ...sourceFields }));
+        if (scope.kind === 'step')
+            choices.push(z.strictObject({
+                kind: z.literal('replace-literal-with-binding'),
+                ...fields,
+                ...sourceFields,
+            }));
+    }
+    return z.strictObject({
+        decisions: z.array(z.union(choices)).min(1),
+    });
+}

package/dist/schemas/workflow-draft-api-binding-edit-scope-schema.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const workflowDraftApiBindingEditScopeSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"step">;
+    stepId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"repair">;
+    taskId: z.ZodString;
+}, z.core.$strict>], "kind">;

package/dist/schemas/workflow-draft-api-binding-edit-scope-schema.js

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export const workflowDraftApiBindingEditScopeSchema = z.discriminatedUnion('kind', [
+    z.strictObject({ kind: z.literal('step'), stepId: z.string().min(1) }),
+    z.strictObject({ kind: z.literal('repair'), taskId: z.string().min(1) }),
+]);

package/dist/schemas/workflow-draft-api-binding-intent-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { WorkflowDraftApiCallPlanningInput } from '../types/workflow-draft-api-call-planning.js';
+import type { WorkflowDraftApiBindingIntentProposal } from '../types/workflow-draft-api-binding-intent.js';
+export declare function createWorkflowDraftApiBindingIntentSchema(input: WorkflowDraftApiCallPlanningInput): z.ZodType<WorkflowDraftApiBindingIntentProposal>;

package/dist/schemas/workflow-draft-api-binding-intent-schema.js

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import { describeWorkflowDraftApiBindingIntent } from '../draft/edits/api/describe-workflow-draft-api-binding-intent.js';
+import { createApiRequestInputPointerSchema } from './create-api-request-input-pointer-schema.js';
+import { createWorkflowDraftSourceEvidenceFields } from './create-workflow-draft-source-evidence-fields.js';
+export function createWorkflowDraftApiBindingIntentSchema(input) {
+    const description = describeWorkflowDraftApiBindingIntent(input);
+    // Conditional explanation fields use the same runtime-validated evidence contract.
+    return z.strictObject({
+        targets: z
+            .array(createApiRequestInputPointerSchema(description.requestSchema))
+            .describe('Only inputs the user requests to obtain from preceding node results. Empty means no requested response-to-request dependency. OAS availability or requiredness alone is not dependency intent. Do not select unrelated optional filters, literal inputs, response assertions or control edges.'),
+        ...createWorkflowDraftSourceEvidenceFields(description),
+    });
+}

package/dist/schemas/workflow-draft-api-call-arguments-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { WorkflowDraftApiCallArgumentsInput, WorkflowDraftApiCallArgumentsProposal } from '../types/workflow-draft-api-call-planning.js';
+/** Only remaining OAS-typed literal fields. All binding and confirmed-input owners are excluded. */
+export declare function createWorkflowDraftApiCallArgumentsSchema(input: WorkflowDraftApiCallArgumentsInput): z.ZodType<WorkflowDraftApiCallArgumentsProposal>;

package/dist/schemas/workflow-draft-api-call-arguments-schema.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { resolveApiCallArgumentsContext } from '../draft/edits/api/resolve-api-call-arguments-context.js';
+import { createWorkflowDraftSourceEvidenceFields } from './create-workflow-draft-source-evidence-fields.js';
+import { apiInputLiteralSourceSchema } from './api-input-literal-source-schema.js';
+import { pointerTokens } from '../bindings/json-pointer.js';
+import { createApiRequestInputPointerSchema } from './create-api-request-input-pointer-schema.js';
+/** Only remaining OAS-typed literal fields. All binding and confirmed-input owners are excluded. */
+export function createWorkflowDraftApiCallArgumentsSchema(input) {
+    const { description, contract } = resolveApiCallArgumentsContext(input);
+    const roots = [
+        ...new Set(description.requestInputRoots.map((pointer) => pointerTokens(pointer)[0])),
+    ];
+    const pointerPattern = roots.length
+        ? new RegExp(`^(?:$|/(?:${roots.join('|')})(?:/(?:[^~/]|~[01])*)*)$`)
+        : /^$/;
+    return z.strictObject({
+        values: contract.valuesSchema,
+        ...(input.trackRequestedInputs === true
+            ? {
+                requestedInputs: z
+                    .array(createApiRequestInputPointerSchema(description.requestSchema))
+                    .refine((pointers) => new Set(pointers).size === pointers.length)
+                    .describe('Exact OAS input paths explicitly requested for THIS call by the user, whether their literal values are known or unknown. Include requested optional inputs; omit unrequested filters, defaults and examples. Do not generate values here. Code checks the original OAS and missing presence separately. Use original request pointers even for confirmed fields on answer resume.'),
+            }
+            : {}),
+        literalSources: z
+            .array(apiInputLiteralSourceSchema.extend({
+            targetPointer: z
+                .string()
+                .regex(pointerPattern)
+                .describe('RFC 6901 pointer relative to proposal.values and literalInputSchema, NOT relative to the entire response. Example: /query/id, never /values/query/id. Cover each literal leaf, or cite a complete object/array subtree once. The empty pointer covers explicitly supplied whole values. Never cover a bound or confirmed field.'),
+            messageId: z
+                .enum([...description.messages, ...description.backgroundMessages].map((message) => message.id))
+                .describe('Original user message containing this value, including supplied background messages. Current edit authority remains sourceMessageIds.'),
+        }))
+            .optional()
+            .describe('Exact original text for every proposed value. Omit only for empty values; never cite OAS defaults, examples or invented text. Code verifies coverage, occurrence, parsing and typed equality.'),
+        ...createWorkflowDraftSourceEvidenceFields(description),
+    });
+}

package/dist/schemas/workflow-draft-api-call-bindings-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { WorkflowDraftApiCallBindingsInput, WorkflowDraftApiCallBindingProposal } from '../types/workflow-draft-api-call-planning.js';
+export declare function createWorkflowDraftApiCallBindingsSchema(input: WorkflowDraftApiCallBindingsInput): z.ZodType<WorkflowDraftApiCallBindingProposal>;

package/dist/schemas/workflow-draft-api-call-bindings-schema.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { describeWorkflowDraftApiCallBindings } from '../draft/edits/api/describe-workflow-draft-api-call-bindings.js';
+import { createWorkflowDraftSourceEvidenceFields } from './create-workflow-draft-source-evidence-fields.js';
+import { createWorkflowDraftApiBindingQuestionSchema } from './create-workflow-draft-api-binding-question-schema.js';
+export function createWorkflowDraftApiCallBindingsSchema(input) {
+    const description = describeWorkflowDraftApiCallBindings(input);
+    const targets = description.inputIntent?.targets;
+    const fields = createWorkflowDraftSourceEvidenceFields(description);
+    const ids = description.sources.values.map((source) => source.nodeId);
+    const mappings = ids.length && description.hasRequestInputs && targets?.length !== 0
+        ? {
+            mappings: z
+                .array(z.strictObject({
+                targetPointer: targets === undefined
+                    ? z
+                        .string()
+                        .min(1)
+                        .describe('Exact RFC 6901 request input pointer in the selected OAS. No expressions or transformations.')
+                    : z.enum(targets),
+                sourceNodeId: z.enum(ids),
+                sourcePointer: z
+                    .string()
+                    .describe('RFC 6901 pointer into the actual API response BODY or native JSON output. Empty selects the whole value. No transport envelope or name-based guesses.'),
+            }))
+                .describe('Only data dependencies explicitly requested for this selected instance. Empty means no predecessor data mapping.'),
+        }
+        : {};
+    const provided = z.strictObject({
+        status: z.literal('provided'),
+        ...mappings,
+        ...fields,
+    });
+    if (!description.hasRequestInputs || targets?.length === 0)
+        return z.strictObject({
+            decision: provided,
+        });
+    return z.strictObject({
+        decision: z.union([
+            provided,
+            z.strictObject({
+                status: z.literal('needs-clarification'),
+                ...mappings,
+                questions: z
+                    .array(createWorkflowDraftApiBindingQuestionSchema(description.requestSchema, ids, targets))
+                    .min(1)
+                    .describe('Unresolved binding decisions for actual inputs of THIS selected API only. Code generates questions, IDs, labels and original schema data. Do not generate a message or claim contracts are missing.'),
+                ...fields,
+            }),
+        ]),
+    });
+}

package/dist/schemas/workflow-draft-api-input-edit-contract-schema.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+/** Shape only; original context re-derivation remains the schema authority. */
+export declare const workflowDraftApiInputEditContractSchema: z.ZodObject<{
+    id: z.ZodString;
+    planId: z.ZodString;
+    stepId: z.ZodString;
+    nodeId: z.ZodString;
+    requestMediaType: z.ZodOptional<z.ZodString>;
+    schemaResource: z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    targets: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"set">;
+        schema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+        id: z.ZodString;
+        pointer: z.ZodString;
+        sources: z.ZodArray<z.ZodObject<{
+            kind: z.ZodLiteral<"message">;
+            messageId: z.ZodString;
+            quote: z.ZodString;
+        }, z.core.$strict>>;
+        explanation: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodString;
+            evidence: z.ZodArray<z.ZodObject<{
+                kind: z.ZodLiteral<"message">;
+                messageId: z.ZodString;
+                quote: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"remove">;
+        id: z.ZodString;
+        pointer: z.ZodString;
+        sources: z.ZodArray<z.ZodObject<{
+            kind: z.ZodLiteral<"message">;
+            messageId: z.ZodString;
+            quote: z.ZodString;
+        }, z.core.$strict>>;
+        explanation: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodString;
+            evidence: z.ZodArray<z.ZodObject<{
+                kind: z.ZodLiteral<"message">;
+                messageId: z.ZodString;
+                quote: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;

package/dist/schemas/workflow-draft-api-input-edit-contract-schema.js

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { workflowMessageEvidenceSchema } from './planning-evidence-schema.js';
+const schemaResource = z.union([
+    z.boolean(),
+    z.record(z.string(), z.unknown()),
+]);
+const fields = {
+    id: z.string().min(1),
+    pointer: z.string().min(1),
+    sources: z.array(workflowMessageEvidenceSchema).min(1),
+    explanation: z
+        .strictObject({
+        reason: z.string().min(1),
+        evidence: z.array(workflowMessageEvidenceSchema).min(1),
+    })
+        .optional(),
+};
+/** Shape only; original context re-derivation remains the schema authority. */
+export const workflowDraftApiInputEditContractSchema = z.strictObject({
+    id: z.string().min(1),
+    planId: z.string().min(1),
+    stepId: z.string().min(1),
+    nodeId: z.string().min(1),
+    requestMediaType: z.string().min(1).optional(),
+    schemaResource,
+    targets: z
+        .array(z.discriminatedUnion('kind', [
+        z.strictObject({
+            ...fields,
+            kind: z.literal('set'),
+            schema: schemaResource,
+        }),
+        z.strictObject({ ...fields, kind: z.literal('remove') }),
+    ]))
+        .min(1),
+});

package/dist/schemas/workflow-draft-api-input-edit-proposal-schema.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { WorkflowDraftApiInputEditProposal } from '../types/workflow-draft-api-input-edit.js';
+import type { WorkflowMessageEvidence } from '../types/planning-evidence.js';
+/** Targets only. Literal values and all host-owned identities are absent. */
+export declare function createWorkflowDraftApiInputEditProposalSchema(messageIds: string[], includeExplanations: boolean, messageSchema?: z.ZodType<WorkflowMessageEvidence>): z.ZodType<WorkflowDraftApiInputEditProposal>;

package/dist/schemas/workflow-draft-api-input-edit-proposal-schema.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { createWorkflowDraftEditMessageFields } from './workflow-draft-edit-message-fields.js';
+/** Targets only. Literal values and all host-owned identities are absent. */
+export function createWorkflowDraftApiInputEditProposalSchema(messageIds, includeExplanations, messageSchema) {
+    const evidence = createWorkflowDraftEditMessageFields(messageIds, includeExplanations, messageSchema);
+    return z.strictObject({
+        targets: z
+            .array(z.strictObject({
+            kind: z.enum(['set', 'remove']),
+            pointer: z
+                .string()
+                .min(1)
+                .describe('Exact RFC 6901 request-value pointer, such as /body/count or /query/name. Select only the requested fields; no whole-request reconstruction.'),
+            sources: z.array(evidence.message).min(1),
+            ...evidence.fields,
+        }))
+            .min(1),
+    });
+}

package/dist/schemas/workflow-draft-capability-gap-schema.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import type { WorkflowDraftCapabilityGapFinding, WorkflowDraftCapabilityGap } from '../types/workflow-draft-capability-gap.js';
+export declare function createWorkflowDraftCapabilityGapFindingSchema<Operation>(operationSchema?: z.ZodType<Operation>): z.ZodType<WorkflowDraftCapabilityGapFinding<Operation>>;
+export declare const workflowDraftGapInventorySchema: z.ZodObject<{
+    operations: z.ZodArray<z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>>;
+    capabilities: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fingerprint: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const workflowDraftCapabilityGapFieldsSchema: z.ZodObject<{
+    id: z.ZodString;
+    requestedBehavior: z.ZodString;
+    finding: z.ZodType<WorkflowDraftCapabilityGapFinding<{
+        documentId: string;
+        snapshotId: string;
+        operationRef: string;
+    }>, unknown, z.core.$ZodTypeInternals<WorkflowDraftCapabilityGapFinding<{
+        documentId: string;
+        snapshotId: string;
+        operationRef: string;
+    }>, unknown>>;
+    sources: z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"message">;
+        messageId: z.ZodString;
+        quote: z.ZodString;
+    }, z.core.$strict>>;
+    inventory: z.ZodObject<{
+        operations: z.ZodArray<z.ZodObject<{
+            documentId: z.ZodString;
+            snapshotId: z.ZodString;
+            operationRef: z.ZodString;
+        }, z.core.$strict>>;
+        capabilities: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            fingerprint: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const workflowDraftCapabilityGapSchema: z.ZodType<WorkflowDraftCapabilityGap>;

package/dist/schemas/workflow-draft-capability-gap-schema.js

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { apiOperationKeySchema } from './api-operation-key-schema.js';
+import { workflowMessageEvidenceSchema } from './planning-evidence-schema.js';
+const text = z.string().refine((value) => value.trim().length > 0);
+const fingerprint = z.string().regex(/^[a-f0-9]{64}$/);
+export function createWorkflowDraftCapabilityGapFindingSchema(operationSchema) {
+    const reason = text.describe('Concise user-facing reason in the user language. State the limitation of supplied OAS/native contracts, not a universal absence claim. Never invent a contract, endpoint, value or private chain-of-thought.');
+    return z.union([
+        z.strictObject({ kind: z.literal('missing-api'), reason }),
+        z.strictObject({ kind: z.literal('unsupported-native'), reason }),
+        ...(operationSchema === undefined
+            ? []
+            : [
+                z.strictObject({
+                    kind: z.literal('api-contract-gap'),
+                    operation: operationSchema,
+                    reason,
+                }),
+            ]),
+    ]);
+}
+export const workflowDraftGapInventorySchema = z.strictObject({
+    operations: z
+        .array(apiOperationKeySchema)
+        .refine((keys) => new Set(keys.map((key) => JSON.stringify(key))).size === keys.length),
+    capabilities: z
+        .array(z.strictObject({ name: text, fingerprint }))
+        .refine((entries) => new Set(entries.map((entry) => entry.name)).size === entries.length),
+});
+export const workflowDraftCapabilityGapFieldsSchema = z.strictObject({
+    id: text,
+    requestedBehavior: text,
+    finding: createWorkflowDraftCapabilityGapFindingSchema(apiOperationKeySchema),
+    sources: z
+        .array(workflowMessageEvidenceSchema)
+        .min(1)
+        .refine((sources) => new Set(sources.map((source) => source.messageId)).size ===
+        sources.length),
+    inventory: workflowDraftGapInventorySchema,
+});
+export const workflowDraftCapabilityGapSchema = workflowDraftCapabilityGapFieldsSchema.extend({ fingerprint });

package/dist/schemas/workflow-draft-clarification-planning-stage-schema.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export declare const workflowDraftClarificationPlanningStageSchema: z.ZodEnum<{
+    "api-bindings": "api-bindings";
+    "api-arguments": "api-arguments";
+    "native-parameters": "native-parameters";
+    requirements: "requirements";
+    connections: "connections";
+}>;

package/dist/schemas/workflow-draft-clarification-planning-stage-schema.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export const workflowDraftClarificationPlanningStageSchema = z.enum([
+    'api-bindings',
+    'api-arguments',
+    'native-parameters',
+    'requirements',
+    'connections',
+]);

package/dist/schemas/workflow-draft-connection-edit-schema.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { ReadyWorkflowDraftConnectionEditDescription, WorkflowDraftConnectionEditProposal } from '../types/workflow-draft-connection-edit.js';
+import type { WorkflowMessageEvidence } from '../types/planning-evidence.js';
+/** Actual endpoint/port pairs only; existing-edge IDs are computed by code. */
+export declare function createWorkflowDraftConnectionEditProposalSchema(context: ReadyWorkflowDraftConnectionEditDescription, messageSchema?: z.ZodType<WorkflowMessageEvidence>): z.ZodType<WorkflowDraftConnectionEditProposal>;

package/dist/schemas/workflow-draft-connection-edit-schema.js

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { createWorkflowDraftEditMessageFields } from './workflow-draft-edit-message-fields.js';
+function endpointSchema(contracts, direction) {
+    const choices = contracts
+        .filter((contract) => contract[direction].length)
+        .map((contract) => z.strictObject({
+        nodeId: z.literal(contract.id),
+        port: z.enum(contract[direction]),
+    }));
+    return choices.length ? z.union(choices) : undefined;
+}
+/** Actual endpoint/port pairs only; existing-edge IDs are computed by code. */
+export function createWorkflowDraftConnectionEditProposalSchema(context, messageSchema) {
+    const evidence = createWorkflowDraftEditMessageFields(context.messages.map((message) => message.id), context.includeExplanations, messageSchema);
+    const fields = {
+        sources: z.array(evidence.message).min(1),
+        ...evidence.fields,
+    };
+    const choices = [
+        z.strictObject({ kind: z.literal('keep-connections'), ...fields }),
+        z.strictObject({
+            kind: z.literal('needs-clarification'),
+            message: z
+                .string()
+                .min(1)
+                .describe('Concrete unresolved routing question.'),
+            ...fields,
+        }),
+    ];
+    const sources = endpointSchema(context.contracts, 'outputs');
+    const targets = endpointSchema(context.contracts, 'inputs');
+    const affected = context.contracts.filter((contract) => context.affectedNodeIds.includes(contract.id));
+    const affectedSources = endpointSchema(affected, 'outputs');
+    const affectedTargets = endpointSchema(affected, 'inputs');
+    if (affectedSources && targets)
+        choices.push(z.strictObject({
+            kind: z.literal('add'),
+            source: affectedSources.describe('Affected source instance and its declared output port.'),
+            target: targets.describe('Actual target instance and its declared input port.'),
+            ...fields,
+        }));
+    if (sources && affectedTargets)
+        choices.push(z.strictObject({
+            kind: z.literal('add'),
+            source: sources.describe('Actual source instance and its declared output port.'),
+            target: affectedTargets.describe('Affected target instance and its declared input port.'),
+            ...fields,
+        }));
+    const edgeIds = context.existingEdges
+        .filter((edge) => edge.editable)
+        .map((edge) => edge.id);
+    if (edgeIds.length)
+        choices.push(z.strictObject({
+            kind: z.literal('remove'),
+            edgeId: z
+                .enum(edgeIds)
+                .describe('ID of the exact existing connection to remove.'),
+            ...fields,
+        }));
+    return z.strictObject({
+        decisions: z
+            .array(z.union(choices))
+            .min(1)
+            .describe('Only requested connection changes, or keep-connections alone. Do not repeat retained edges, nodes, parameters, dependencies or starts.'),
+    });
+}