@openapi-flow/core 0.2.0 → 0.3.0

package/dist/schemas/create-api-input-answers-schema.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { createOasValueSchema } from './create-oas-value-schema.js';
+export function createApiInputAnswersSchema(requirements) {
+    if (!Array.isArray(requirements) ||
+        !requirements.length ||
+        new Set(requirements.map((item) => item.id)).size !== requirements.length)
+        throw new Error('Answer schema requires distinct pending requirements');
+    const alternatives = requirements.map((requirement) => z.strictObject({
+        requirementId: z.literal(requirement.id).describe(requirement.message),
+        value: createOasValueSchema(requirement.schema, requirement.openapiVersion.startsWith('3.0.')
+            ? 'openapi-3.0'
+            : 'draft-2020-12', requirement.targetPointer).describe('Only the value explicitly supplied by the current user reply for this requested input.'),
+    }));
+    return z.strictObject({
+        answers: z
+            .array(alternatives.length === 1 ? alternatives[0] : z.union(alternatives))
+            .describe('Return only explicitly answered pending inputs. Return [] when no requested value is supplied; do not invent values or copy OAS examples/defaults.'),
+    });
+}

package/dist/schemas/create-api-input-slot-value-schema.d.ts

@@ -0,0 +1,5 @@
+import type { z } from 'zod';
+import type { JsonValue } from '../types/api-arguments.js';
+import type { DeferredApiInputSlot } from '../types/deferred-api-inputs.js';
+/** Keep original OAS wire metadata; in-process presence is a separate assertion. */
+export declare function createApiInputSlotValueSchema(slot: DeferredApiInputSlot): z.ZodType<JsonValue>;

package/dist/schemas/create-api-input-slot-value-schema.js

@@ -0,0 +1,26 @@
+import { createOasValueSchema } from './create-oas-value-schema.js';
+import { listMissingRequestedApiInputs } from '../arguments/clarification/list-missing-requested-api-inputs.js';
+/** Keep original OAS wire metadata; in-process presence is a separate assertion. */
+export function createApiInputSlotValueSchema(slot) {
+    const schema = createOasValueSchema(slot.schema, slot.openapiVersion.startsWith('3.0.') ? 'openapi-3.0' : 'draft-2020-12', `inputValues[${slot.id}] for ${slot.callId}${slot.targetPointer}`);
+    if (slot.requestedInputs === undefined)
+        return schema;
+    const metadata = schema.meta();
+    if (metadata === undefined)
+        throw new Error(`Input slot ${slot.id} requires its original OAS metadata`);
+    return schema
+        .superRefine((value, context) => {
+        const missing = listMissingRequestedApiInputs({
+            source: `Runtime input ${slot.id}`,
+            rootPointer: slot.targetPointer,
+            value,
+            requestedInputs: slot.requestedInputs,
+        });
+        if (missing.length)
+            context.addIssue({
+                code: 'custom',
+                message: `Runtime input omits scenario-requested inputs: ${missing.join(', ')}`,
+            });
+    })
+        .meta(metadata);
+}

package/dist/schemas/create-api-request-input-pointer-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { JsonObject } from '../types/openapi.js';
+/** Only declaration roots are finite; dynamic descendants remain OAS-validated. */
+export declare function createApiRequestInputPointerSchema(requestSchema: JsonObject): z.ZodString | z.ZodNever;

package/dist/schemas/create-api-request-input-pointer-schema.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { listApiRequestInputRoots } from '../arguments/list-api-request-input-roots.js';
+/** Only declaration roots are finite; dynamic descendants remain OAS-validated. */
+export function createApiRequestInputPointerSchema(requestSchema) {
+    const roots = listApiRequestInputRoots(requestSchema);
+    if (!roots.length)
+        return z.never();
+    const pattern = String.raw `^(?:${roots.map((root) => root.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|')})(?:/[\s\S]*)?$`;
+    return z
+        .string()
+        .regex(new RegExp(pattern))
+        .describe('Exact RFC 6901 input pointer of this selected OAS operation. Original OAS validates nested, array and dynamic pointers. Never name another operation input.');
+}

package/dist/schemas/create-deferred-api-inputs-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { DeferredApiInputSlot, DeferredApiInputValues } from '../types/deferred-api-inputs.js';
+/** Presentation/input contract; execution re-derives slots from OAS materials. */
+export declare function createDeferredApiInputsSchema(slots: DeferredApiInputSlot[]): z.ZodType<DeferredApiInputValues>;

package/dist/schemas/create-deferred-api-inputs-schema.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { deferredApiInputSlotsSchema } from './deferred-api-input-schema.js';
+import { createApiInputSlotValueSchema } from './create-api-input-slot-value-schema.js';
+/** Presentation/input contract; execution re-derives slots from OAS materials. */
+export function createDeferredApiInputsSchema(slots) {
+    const checked = deferredApiInputSlotsSchema.parse(slots);
+    return z
+        .strictObject(Object.fromEntries(checked.map((slot) => [
+        slot.id,
+        createApiInputSlotValueSchema(slot).describe(`Actual runtime value for ${slot.callId}${slot.targetPointer}. Preserve the OAS type and constraints; no placeholder, example or default is a confirmed value.`),
+    ])))
+        .describe('Explicit runtime values keyed by the declared input slot IDs.');
+}

package/dist/schemas/create-json-schema-value-schema.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { JsonObject } from '../types/openapi.js';
+import type { JsonValue } from '../types/api-arguments.js';
+/** Keep a JSON Schema's assertions intact; parsing validates without data conversion. */
+export declare function createJsonSchemaValueSchema(schema: JsonObject, source: string): z.ZodType<JsonValue>;

package/dist/schemas/create-json-schema-value-schema.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { createValidator } from '@scalar/json-schema-validator';
+/** Keep a JSON Schema's assertions intact; parsing validates without data conversion. */
+export function createJsonSchemaValueSchema(schema, source) {
+    const validate = createValidator(schema);
+    return z.unknown().superRefine((value, context) => {
+        if (!z.json().safeParse(value).success) {
+            context.addIssue({
+                code: 'custom',
+                message: `${source} must be a JSON value`,
+            });
+            return;
+        }
+        const result = validate(typeof value === 'string' ? JSON.stringify(value) : value);
+        for (const error of result.errors)
+            context.addIssue({
+                code: 'custom',
+                message: `${source} does not match its JSON Schema: ${error.message}`,
+            });
+    });
+}

package/dist/schemas/create-native-parameter-generation-contract.d.ts

@@ -0,0 +1,3 @@
+import type { NativeParameterGenerationInput, NativeParameterGenerationContract } from '../types/native-node-planning.js';
+/** Shared by standalone and draft planning; only explicit owners remove value choices. */
+export declare function createNativeParameterGenerationContract(input: NativeParameterGenerationInput): NativeParameterGenerationContract;

package/dist/schemas/create-native-parameter-generation-contract.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+import { collectNativeRuntimeInputSlots } from '../inputs/native/collect-native-runtime-input-slots.js';
+import { hasFixedEmptyNativeParameters } from '../workflow/planning/has-fixed-empty-native-parameters.js';
+import { projectNativeLiteralParameters } from './project-native-literal-parameters.js';
+import { createJsonSchemaValueSchema } from './create-json-schema-value-schema.js';
+import { createSchemaResourceContext } from '../bindings/resources/create-schema-resource-context.js';
+/** Shared by standalone and draft planning; only explicit owners remove value choices. */
+export function createNativeParameterGenerationContract(input) {
+    const { capability, runtimeParameters } = input;
+    const original = z.toJSONSchema(capability.parametersSchema, {
+        io: 'input',
+        target: 'draft-2020-12',
+        reused: 'inline',
+        cycles: 'ref',
+    });
+    if (runtimeParameters !== undefined)
+        collectNativeRuntimeInputSlots({
+            nativeNodes: [
+                {
+                    id: input.nodeId,
+                    capability: capability.name,
+                    parameters: {},
+                    runtimeParameters,
+                },
+            ],
+            capabilities: [capability],
+        });
+    if (runtimeParameters === undefined)
+        return {
+            literalParametersSchema: original,
+            valuesSchema: capability.parametersSchema,
+            definitions: {},
+            hasLiteralParameters: !hasFixedEmptyNativeParameters(original, capability),
+        };
+    if (runtimeParameters === true)
+        return {
+            literalParametersSchema: false,
+            valuesSchema: z.strictObject({}),
+            definitions: {},
+            hasLiteralParameters: false,
+        };
+    const projected = projectNativeLiteralParameters(original, runtimeParameters.pointers, `Native instance ${input.nodeId}`);
+    if (typeof projected.schema === 'boolean')
+        throw new Error(`Native instance ${input.nodeId} literal parameters require an object schema`);
+    const resources = createSchemaResourceContext(projected.schema);
+    const wire = resources.bundleStaticProjections({
+        parameters: resources.root,
+    });
+    const projection = wire.projections.parameters;
+    return {
+        literalParametersSchema: projected.schema,
+        hasLiteralParameters: projected.hasLiteralValues,
+        definitions: wire.definitions,
+        valuesSchema: createJsonSchemaValueSchema(projected.schema, `Native instance ${input.nodeId} literals`).meta(typeof projection === 'boolean' ? { not: {} } : projection),
+    };
+}

package/dist/schemas/create-native-runtime-parameters-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { WorkflowCapability } from '../types/workflow-plan.js';
+/** Official conversion; do not silently discard executable refinements or transforms. */
+export declare function createNativeRuntimeParametersSchema(capability: WorkflowCapability): z.core.ZodStandardJSONSchemaPayload<z.ZodType<import("../public-api.js").JsonValueObject, unknown, z.core.$ZodTypeInternals<import("../public-api.js").JsonValueObject, unknown>>>;

package/dist/schemas/create-native-runtime-parameters-schema.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+/** Official conversion; do not silently discard executable refinements or transforms. */
+export function createNativeRuntimeParametersSchema(capability) {
+    return z.toJSONSchema(capability.parametersSchema, {
+        io: 'output',
+        override(context) {
+            const definition = context.zodSchema._zod.def;
+            if (['pipe', 'transform', 'custom', 'catch'].includes(definition.type))
+                throw new Error(`Native runtime parameters ${capability.name} cannot serialize ${definition.type} validation`);
+            for (const check of definition.checks ?? []) {
+                const kind = check._zod.def.check;
+                if (![
+                    'less_than',
+                    'greater_than',
+                    'multiple_of',
+                    'number_format',
+                    'min_length',
+                    'max_length',
+                    'length_equals',
+                    'string_format',
+                ].includes(kind))
+                    throw new Error(`Native runtime parameters ${capability.name} cannot serialize check ${kind}`);
+            }
+        },
+    });
+}

package/dist/schemas/create-oas-value-schema.d.ts

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import type { z } from 'zod';
 import type { JsonValue } from '../types/api-arguments.js';
 import type { OasValueSchema } from '../types/oas-value-validation.js';
 import type { SchemaDialect } from '../types/schema-dialect.js';

package/dist/schemas/create-oas-value-schema.js

@@ -1,25 +1,7 @@
-import { z } from 'zod';
 import { createOasValueValidator } from '../openapi/common/create-oas-value-validator.js';
+import { createOasValueValidationSchema } from './create-oas-value-validation-schema.js';
 /** Keep OAS assertions intact instead of round-tripping through Zod types. */
 export function createOasValueSchema(input, dialect, source) {
     const contract = createOasValueValidator(input, dialect, source);
-    const jsonValue = z.json();
-    return z
-        .unknown()
-        .superRefine((value, context) => {
-        if (!jsonValue.safeParse(value).success) {
-            context.addIssue({
-                code: 'custom',
-                message: `${source} must be a JSON value`,
-            });
-            return;
-        }
-        const result = contract.validate(value);
-        for (const error of result.errors)
-            context.addIssue({
-                code: 'custom',
-                message: `${source} does not match the OAS schema: ${error.message}`,
-            });
-    })
-        .meta(contract.schema);
+    return createOasValueValidationSchema(contract, source).meta(contract.schema);
 }

package/dist/schemas/create-oas-value-validation-schema.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { JsonValue } from '../types/api-arguments.js';
+import type { OasValueValidator } from '../types/oas-value-validation.js';
+/** Runtime validation only; the owning composition supplies its wire metadata. */
+export declare function createOasValueValidationSchema(contract: OasValueValidator, source: string): z.ZodType<JsonValue>;

package/dist/schemas/create-oas-value-validation-schema.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+/** Runtime validation only; the owning composition supplies its wire metadata. */
+export function createOasValueValidationSchema(contract, source) {
+    const jsonValue = z.json();
+    return z.unknown().superRefine((value, context) => {
+        if (!jsonValue.safeParse(value).success) {
+            context.addIssue({
+                code: 'custom',
+                message: `${source} must be a JSON value`,
+            });
+            return;
+        }
+        for (const error of contract.validate(value).errors)
+            context.addIssue({
+                code: 'custom',
+                message: `${source} does not match the OAS schema: ${error.message}`,
+            });
+    });
+}

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

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { JsonObject } from '../types/openapi.js';
+import type { ProposedWorkflowDraftApiBindingQuestion } from '../types/workflow-draft-api-binding-clarification.js';
+export declare function createWorkflowDraftApiBindingQuestionSchema(requestSchema: JsonObject, sourceIds: string[], targets?: string[]): z.ZodType<ProposedWorkflowDraftApiBindingQuestion>;

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

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { createApiRequestInputPointerSchema } from './create-api-request-input-pointer-schema.js';
+export function createWorkflowDraftApiBindingQuestionSchema(requestSchema, sourceIds, targets) {
+    const targetPointer = targets === undefined
+        ? createApiRequestInputPointerSchema(requestSchema)
+        : targets.length
+            ? z.enum(targets)
+            : z.never();
+    const intent = z.strictObject({
+        kind: z.literal('binding-intent'),
+        targetPointer,
+    });
+    if (!sourceIds.length)
+        return intent;
+    return z.union([
+        intent,
+        z.strictObject({
+            kind: z.literal('choose-source'),
+            targetPointer,
+            candidates: z
+                .array(z.strictObject({
+                sourceNodeId: z.enum(sourceIds),
+                sourcePointer: z
+                    .string()
+                    .describe('Exact supplied response-body/native output pointer. Each candidate must be compatible with this target input.'),
+            }))
+                .min(1),
+        }),
+    ]);
+}

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

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { WorkflowDraftApiInputEditContractInput, WorkflowDraftApiInputEditValuesSchema } from '../types/workflow-draft-api-input-edit.js';
+import type { WorkflowMessageEvidence } from '../types/planning-evidence.js';
+/** Only selected set-values are model-owned; per-field OAS assertions stay intact. */
+export declare function createWorkflowDraftApiInputEditValuesSchema(input: WorkflowDraftApiInputEditContractInput, messageSchema?: z.ZodType<WorkflowMessageEvidence>): WorkflowDraftApiInputEditValuesSchema;

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

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { validateWorkflowDraftApiInputEditContract } from '../draft/edits/inputs/validate-workflow-draft-api-input-edit-contract.js';
+import { createWorkflowDraftEditMessageFields } from './workflow-draft-edit-message-fields.js';
+import { createOasValueValidator } from '../openapi/common/create-oas-value-validator.js';
+import { createOasValueValidationSchema } from './create-oas-value-validation-schema.js';
+import { createSchemaResourceContext } from '../bindings/resources/create-schema-resource-context.js';
+import { apiInputLiteralSourceSchema } from './api-input-literal-source-schema.js';
+function targetValueSchema(target, resources, nodeId, projection) {
+    if (target.kind !== 'set')
+        throw new Error(`API input edit set target ${target.pointer} has no OAS schema`);
+    const assertions = typeof target.schema === 'boolean'
+        ? target.schema
+            ? {}
+            : { not: {} }
+        : target.schema;
+    const source = `API input edit ${nodeId}${target.pointer}`;
+    const wireAssertions = typeof projection === 'boolean'
+        ? projection
+            ? {}
+            : { not: {} }
+        : projection;
+    return createOasValueValidationSchema(createOasValueValidator({ ...assertions, $defs: { resource: resources.root } }, 'draft-2020-12', source), source).meta(typeof wireAssertions.$ref === 'string'
+        ? wireAssertions
+        : {
+            ...wireAssertions,
+            description: 'The complete actual value explicitly supplied by the current user request. Preserve its type. No examples, defaults, old field values or invented placeholders.',
+        });
+}
+/** Only selected set-values are model-owned; per-field OAS assertions stay intact. */
+export function createWorkflowDraftApiInputEditValuesSchema(input, messageSchema) {
+    validateWorkflowDraftApiInputEditContract(input);
+    const evidence = createWorkflowDraftEditMessageFields(input.requestMessageIds, input.plan.options.includeExplanations, messageSchema);
+    const resources = createSchemaResourceContext(input.contract.schemaResource);
+    const wire = resources.bundleStaticProjections(Object.fromEntries(input.contract.targets
+        .filter((target) => target.kind === 'set')
+        .map((target) => [target.id, target.schema])));
+    return z
+        .strictObject({
+        values: z.strictObject(Object.fromEntries(input.contract.targets
+            .filter((target) => target.kind === 'set')
+            .map((target) => [
+            target.id,
+            z.union([
+                z.strictObject({
+                    status: z.literal('provided'),
+                    value: targetValueSchema(target, resources, input.contract.nodeId, wire.projections[target.id]),
+                    source: apiInputLiteralSourceSchema.extend({
+                        messageId: z.enum(input.requestMessageIds),
+                    }),
+                    ...evidence.fields,
+                }),
+                z.strictObject({
+                    status: z.literal('needs-input'),
+                    ...evidence.fields,
+                }),
+            ]),
+        ]))),
+    })
+        .meta({
+        $defs: wire.definitions,
+    });
+}

package/dist/schemas/create-workflow-draft-clarification-scope-schema.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { WorkflowDraftClarificationScopeInput, WorkflowDraftClarificationScopeProposal } from '../types/workflow-draft-clarification.js';
+import type { WorkflowMessageEvidence } from '../types/planning-evidence.js';
+/** Known requirement IDs are object keys; the model chooses only scope and optional user-facing evidence. */
+export declare function createWorkflowDraftClarificationScopeSchema(input: WorkflowDraftClarificationScopeInput, messageSchema?: z.ZodType<WorkflowMessageEvidence>): z.ZodType<WorkflowDraftClarificationScopeProposal>;

package/dist/schemas/create-workflow-draft-clarification-scope-schema.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { describeWorkflowDraftClarificationScopes } from '../draft/requirements/describe-workflow-draft-clarification-scopes.js';
+import { workflowMessageEvidenceSchema } from './planning-evidence-schema.js';
+import { createWorkflowDraftSelectedScopeSchema } from './create-workflow-draft-selected-scope-schema.js';
+/** Known requirement IDs are object keys; the model chooses only scope and optional user-facing evidence. */
+export function createWorkflowDraftClarificationScopeSchema(input, messageSchema = workflowMessageEvidenceSchema) {
+    const description = describeWorkflowDraftClarificationScopes(input);
+    const nodeIds = description.nodes.map((node) => node.id);
+    const scope = createWorkflowDraftSelectedScopeSchema(nodeIds);
+    const decision = (question) => z.strictObject({
+        scope: question
+            ? z.union([
+                scope,
+                z.strictObject({ kind: z.literal('unselected-work') }),
+            ])
+            : scope,
+        ...(description.includeExplanations
+            ? {
+                explanation: z.strictObject({
+                    reason: z.string().min(1),
+                    evidence: z.array(messageSchema).min(1),
+                }),
+            }
+            : {}),
+    });
+    return z.strictObject({
+        scopes: z.strictObject(Object.fromEntries(description.requirements.map((requirement) => [
+            requirement.id,
+            decision(requirement.origin?.kind === 'clarification-question'),
+        ]))),
+    });
+}

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

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { ResolvedWorkflowDraftEditOptions, WorkflowDraftEditProposal, WorkflowDraftEditSchemaSources } from '../types/workflow-draft-edit.js';
+/** Identical decision vocabulary, specialized to canonical or model candidate references. */
+export declare function createWorkflowDraftEditProposalSchema<Operation, Evidence>(options: ResolvedWorkflowDraftEditOptions, sources: WorkflowDraftEditSchemaSources<Operation, Evidence>): z.ZodType<WorkflowDraftEditProposal<Operation, Evidence>>;

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

@@ -0,0 +1,148 @@
+import { z } from 'zod';
+import { workflowDraftClarificationPlanningStageSchema } from './workflow-draft-clarification-planning-stage-schema.js';
+import { createWorkflowDraftCapabilityGapFindingSchema } from './workflow-draft-capability-gap-schema.js';
+/** Identical decision vocabulary, specialized to canonical or model candidate references. */
+export function createWorkflowDraftEditProposalSchema(options, sources) {
+    const explanation = z.strictObject({
+        reason: z
+            .string()
+            .min(1)
+            .describe('A short user-facing reason, not chain-of-thought.'),
+        evidence: z.array(sources.evidenceSchema).min(1),
+    });
+    const fields = {
+        instruction: z
+            .string()
+            .min(1)
+            .describe('The specific requested change or distinct role of an added instance. Do not invent literal values, bindings, settings or connections here.'),
+        sources: z
+            .array(sources.messageSchema)
+            .min(1)
+            .describe('Provenance from current edit-request messages using the supplied evidence contract, not old requirements that were already accepted.'),
+        ...(options.includeExplanations
+            ? {
+                explanation,
+            }
+            : {}),
+    };
+    const ids = [
+        ...sources.apiNodeIds,
+        ...sources.nativeNodeIds,
+        ...(sources.gapNodeIds === undefined ? [] : sources.gapNodeIds),
+    ];
+    const scope = z.union([
+        z.strictObject({ kind: z.literal('workflow') }),
+        ...(ids.length
+            ? [
+                z.strictObject({
+                    kind: z.literal('nodes'),
+                    nodeIds: z.array(z.enum(ids)).min(1),
+                }),
+            ]
+            : []),
+    ]);
+    const decisions = [
+        z.strictObject({
+            kind: z.literal('report-capability-gap'),
+            finding: createWorkflowDraftCapabilityGapFindingSchema(sources.operationSchema).describe('An explicitly requested role that supplied OAS/native contracts cannot fulfill. This creates a structural unresolved node, not an API, schema, fabricated response or permission to substitute another task.'),
+            ...fields,
+        }),
+        z.strictObject({
+            kind: z.literal('needs-clarification'),
+            owner: z
+                .union([
+                z
+                    .strictObject({ kind: z.literal('semantic'), scope })
+                    .describe('A consequential unresolved meaning/selection choice not owned by a selected planning step. Only this owner creates a new blocking semantic requirement.'),
+                z
+                    .strictObject({
+                    kind: z.literal('planning-step'),
+                    stage: workflowDraftClarificationPlanningStageSchema.describe('The exact question-owning stage of the referenced decision: API literals use api-arguments; replacement requirement fields use requirements. Do not replay input questions as connection questions.'),
+                    decisionIndex: z
+                        .number()
+                        .int()
+                        .min(0)
+                        .max(Number.MAX_SAFE_INTEGER)
+                        .describe('Zero-based position of the actual value, requirement or connection planning decision in this same decisions array. Not a node ID or another clarification.'),
+                })
+                    .describe('The identified planning step owns this concern and its typed questions; do not also create a semantic/workflow blocker for it.'),
+            ])
+                .describe('Declare the real question owner. API inputs, native settings, connection details and typed requirement replacement fields belong to their selected planning decision, not a generic semantic blocker.'),
+            ...fields,
+        }),
+    ];
+    if (sources.operationSchema) {
+        decisions.push(z.strictObject({
+            kind: z.literal('add-api-call'),
+            operation: sources.operationSchema,
+            ...fields,
+        }));
+        if (sources.apiNodeIds.length)
+            decisions.push(z.strictObject({
+                kind: z.literal('replace-api-operation'),
+                nodeId: z.enum(sources.apiNodeIds),
+                operation: sources.operationSchema,
+                ...fields,
+            }));
+    }
+    if (sources.capabilityNames.length)
+        decisions.push(z.strictObject({
+            kind: z.literal('add-native-node'),
+            capability: z.enum(sources.capabilityNames),
+            ...fields,
+        }));
+    if (sources.apiNodeIds.length)
+        for (const kind of ['revise-api-inputs', 'revise-api-bindings'])
+            decisions.push(z.strictObject({
+                kind: z.literal(kind),
+                nodeId: z.enum(sources.apiNodeIds),
+                ...fields,
+            }));
+    if (sources.nativeNodeIds.length)
+        decisions.push(z.strictObject({
+            kind: z.literal('revise-native-node'),
+            nodeId: z.enum(sources.nativeNodeIds),
+            ...fields,
+        }));
+    if (ids.length)
+        decisions.push(z
+            .strictObject({
+            kind: z.literal('remove-node'),
+            nodeId: z.enum(ids),
+            ...fields,
+        })
+            .describe('Explicitly withdraw this existing instance. Code records and removes its incident control edges; other nodes and replacement routes require separate justified decisions.'), z.strictObject({
+            kind: z.literal('revise-connections'),
+            nodeIds: z.array(z.enum(ids)).min(1),
+            ...fields,
+        }));
+    if (sources.requirementIds.length)
+        for (const kind of ['revise-requirement', 'remove-requirement'])
+            decisions.push(z.strictObject({
+                kind: z.literal(kind),
+                requirementId: z.enum(sources.requirementIds),
+                ...fields,
+            }));
+    if (sources.removedRequirementIds.length)
+        decisions.push(z.strictObject({
+            kind: z.literal('restore-requirement'),
+            requirementId: z
+                .enum(sources.removedRequirementIds)
+                .describe('A currently removed requirement explicitly requested for restoration. Historical text/state/scope are reference only; a separate typed human answer supplies replacement fields.'),
+            ...fields,
+        }));
+    // Conditional field omission loses generic inference in Zod's object output;
+    // this boundary names the same runtime-validated decision contract.
+    return z.strictObject({
+        decisions: z.union([
+            z
+                .array(z.strictObject({ kind: z.literal('no-change'), ...fields }))
+                .length(1)
+                .describe('Exactly one no-change decision for the entire request; never combine it with edits or concerns about selected work.'),
+            z
+                .array(z.union(decisions))
+                .min(1)
+                .describe('Actual edits and explicitly owned concerns. Unchanged sibling nodes are preserved by code; do not append a no-change decision for them.'),
+        ]),
+    });
+}

package/dist/schemas/create-workflow-draft-native-parameter-edit-values-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { WorkflowDraftNativeParameterEditContractInput, WorkflowDraftNativeParameterEditValues } from '../types/workflow-draft-native-parameter-edit.js';
+import type { WorkflowMessageEvidence } from '../types/planning-evidence.js';
+export declare function createWorkflowDraftNativeParameterEditValuesSchema(input: WorkflowDraftNativeParameterEditContractInput, messageSchema?: z.ZodType<WorkflowMessageEvidence>): z.ZodType<WorkflowDraftNativeParameterEditValues>;