@openapi-flow/core 0.3.10 → 0.3.12

package/dist/draft/edits/api/resolve-workflow-draft-api-call-arguments.js

@@ -5,6 +5,7 @@ import { inspectApiArgumentRequirements } from '../../../arguments/clarification
 import { resolveWorkflowDraftSourceEvidence } from '../references/resolve-workflow-draft-source-evidence.js';
 import { jsonValuesEqual } from '../../../utils/json-values-equal.js';
 import { resolveWorkflowDraftApiLiteralSources } from './resolve-workflow-draft-api-literal-sources.js';
+import { resolveWorkflowDraftApiEnumSelections } from './resolve-workflow-draft-api-enum-selections.js';
 /** Resolve one actual request; partial values become typed questions/slots, never dummy data. */
 export function resolveWorkflowDraftApiCallArguments(input) {
     const { description, fingerprint } = resolveApiCallArgumentsContext(input);
@@ -13,13 +14,18 @@ export function resolveWorkflowDraftApiCallArguments(input) {
     const proposal = createWorkflowDraftApiCallArgumentsSchema(input).parse(input.proposal);
     if (!jsonValuesEqual(proposal, input.proposal))
         throw new Error('API call arguments must validate without defaults, coercion or transformation');
+    const literalSources = resolveWorkflowDraftApiLiteralSources({
+        description,
+        proposal,
+    });
+    const enums = resolveWorkflowDraftApiEnumSelections({ ...input, proposal });
     const values = applyConfirmedApiInputs({
         callId: description.nodeId,
         operation: description.operation,
         requestMediaType: description.requestMediaType,
         bindings: input.bindingPlan.bindings,
         confirmedInputs: input.confirmedInputs,
-        values: proposal.values,
+        values: enums.values,
     });
     const inspected = inspectApiArgumentRequirements({
         callId: description.nodeId,
@@ -32,10 +38,8 @@ export function resolveWorkflowDraftApiCallArguments(input) {
     const fields = {
         fingerprint,
         proposal,
-        literalSources: resolveWorkflowDraftApiLiteralSources({
-            description,
-            proposal,
-        }),
+        literalSources,
+        ...(enums.selections.length ? { enumSelections: enums.selections } : {}),
         ...resolveWorkflowDraftSourceEvidence({
             description,
             decision: proposal,

package/dist/draft/edits/api/resolve-workflow-draft-api-enum-selections.d.ts

@@ -0,0 +1,4 @@
+import type { ResolveWorkflowDraftApiCallArgumentsInput } from '../../../types/workflow-draft-api-call-planning.js';
+import type { WorkflowDraftApiEnumResolution } from '../../../types/workflow-draft-api-enum-selection.js';
+/** Copy from the current OAS, never from model-supplied values or same-name fields. */
+export declare function resolveWorkflowDraftApiEnumSelections(input: ResolveWorkflowDraftApiCallArgumentsInput): WorkflowDraftApiEnumResolution;

package/dist/draft/edits/api/resolve-workflow-draft-api-enum-selections.js

@@ -0,0 +1,38 @@
+import { describeWorkflowDraftApiEnumChoices } from './describe-workflow-draft-api-enum-choices.js';
+import { createWorkflowDraftApiEnumSelectionSchema } from '../../../schemas/workflow-draft-api-enum-selection-schema.js';
+import { assignApiInputValue } from '../../../arguments/clarification/assign-api-input-value.js';
+import { resolveApiCallArgumentsContext } from './resolve-api-call-arguments-context.js';
+import { verifyWorkflowDraftApiEnumSelection } from '../enum/verify-workflow-draft-api-enum-selection.js';
+/** Copy from the current OAS, never from model-supplied values or same-name fields. */
+export function resolveWorkflowDraftApiEnumSelections(input) {
+    const values = structuredClone(input.proposal.values);
+    const verified = [];
+    if (input.enumSelections === undefined)
+        return { values, selections: verified };
+    const { candidates } = describeWorkflowDraftApiEnumChoices(input);
+    const proposal = createWorkflowDraftApiEnumSelectionSchema(input).parse({
+        selections: input.enumSelections,
+    });
+    const { description } = resolveApiCallArgumentsContext(input);
+    for (const selection of proposal.selections) {
+        const candidate = candidates.find((item) => item.id === selection.candidateId);
+        if (!candidate)
+            throw new Error(`API enum selection ${selection.candidateId} is absent from the current OAS choices`);
+        if (verified.some((item) => item.targetPointer === candidate.targetPointer ||
+            item.targetPointer.startsWith(candidate.targetPointer + '/') ||
+            candidate.targetPointer.startsWith(item.targetPointer + '/')))
+            throw new Error(`API enum selections overlap at ${candidate.targetPointer}`);
+        const receipt = verifyWorkflowDraftApiEnumSelection({
+            selection,
+            candidates,
+            messages: [...description.messages, ...description.backgroundMessages],
+        });
+        assignApiInputValue(values, candidate.targetPointer, structuredClone(candidate.value), {
+            operation: description.operation,
+            requestMediaType: description.requestMediaType,
+            callId: description.nodeId,
+        });
+        verified.push(receipt);
+    }
+    return { values, selections: verified };
+}

package/dist/draft/edits/api/resolve-workflow-draft-api-literal-sources.js

@@ -1,60 +1,13 @@
-import { pointerTokens, pointerValue } from '../../../bindings/json-pointer.js';
-import { verifyApiInputLiteralSource } from '../../../arguments/sources/verify-api-input-literal-source.js';
+import { resolveApiLiteralProposalSources } from '../../../arguments/sources/resolve-api-literal-proposal-sources.js';
 /** OAS validation and message existence alone do not establish a literal's origin. */
 export function resolveWorkflowDraftApiLiteralSources(input) {
     const { description, proposal } = input;
-    const sources = [];
-    const messages = [...description.messages, ...description.backgroundMessages];
-    if (proposal.literalSources !== undefined) {
-        for (const selection of proposal.literalSources) {
-            pointerTokens(selection.targetPointer);
-            const label = `API ${description.nodeId} literal ${selection.targetPointer}`;
-            if (sources.some((source) => overlaps(source.targetPointer, selection.targetPointer)))
-                throw new Error(`${label} has duplicate or overlapping literalSources`);
-            const message = messages.find((entry) => entry.id === selection.messageId);
-            if (!message)
-                throw new Error(`${label} cites unavailable user message ${selection.messageId}`);
-            const proposed = pointerValue(proposal.values, selection.targetPointer);
-            if (proposed === undefined)
-                throw new Error(`${label} source targets an absent proposed value`);
-            const parsed = verifyApiInputLiteralSource({
-                ...selection,
-                text: message.text,
-                label,
-                value: proposed,
-            });
-            sources.push({ ...selection, occurrences: parsed.occurrences });
-        }
-    }
-    function check(value, pointer) {
-        if (sources.some((source) => isAncestor(source.targetPointer, pointer)))
-            return;
-        if (value !== null &&
-            typeof value === 'object' &&
-            Object.keys(value).length) {
-            for (const [key, child] of Object.entries(value))
-                check(child, `${pointer}/${key.replaceAll('~', '~0').replaceAll('/', '~1')}`);
-            return;
-        }
-        throw new Error(`API ${description.nodeId} literal ${pointer} requires an exact user source in literalSources`);
-    }
-    for (const [root, value] of Object.entries(proposal.values)) {
-        // Empty parameter-location objects contain no request values. Empty body
-        // objects/arrays are actual data and still require their own source.
-        if (root !== 'body' &&
-            value !== null &&
-            typeof value === 'object' &&
-            !Object.keys(value).length)
-            continue;
-        check(value, `/${root}`);
-    }
-    return sources;
-}
-function isAncestor(ancestor, pointer) {
-    return (ancestor === '' ||
-        pointer === ancestor ||
-        pointer.startsWith(`${ancestor}/`));
-}
-function overlaps(left, right) {
-    return isAncestor(left, right) || isAncestor(right, left);
+    // Empty parameter-location objects contain no request values. Empty body
+    // objects/arrays are actual data and still require their own source.
+    return resolveApiLiteralProposalSources({
+        callId: description.nodeId,
+        values: proposal.values,
+        sources: proposal.literalSources === undefined ? [] : proposal.literalSources,
+        messages: [...description.messages, ...description.backgroundMessages],
+    });
 }

package/dist/draft/edits/enum/verify-workflow-draft-api-enum-selection.d.ts

@@ -0,0 +1,3 @@
+import type { VerifyWorkflowDraftApiEnumSelectionInput, VerifiedWorkflowDraftApiEnumSelection } from '../../../types/workflow-draft-api-enum-selection.js';
+/** Human intent is a separate receipt; the selected request value comes only from the OAS. */
+export declare function verifyWorkflowDraftApiEnumSelection(input: VerifyWorkflowDraftApiEnumSelectionInput): VerifiedWorkflowDraftApiEnumSelection;

package/dist/draft/edits/enum/verify-workflow-draft-api-enum-selection.js

@@ -0,0 +1,23 @@
+import { createWorkflowDraftApiEnumChoiceSchema } from '../../../schemas/workflow-draft-api-enum-choice-schema.js';
+import { readApiInputLiteralSource } from '../../../arguments/sources/read-api-input-literal-source.js';
+/** Human intent is a separate receipt; the selected request value comes only from the OAS. */
+export function verifyWorkflowDraftApiEnumSelection(input) {
+    const selection = createWorkflowDraftApiEnumChoiceSchema(input.candidates, input.messages.map((message) => message.id)).parse(input.selection);
+    const candidate = input.candidates.find((item) => item.id === selection.candidateId);
+    if (!candidate)
+        throw new Error(`API enum selection ${selection.candidateId} is absent from the current OAS choices`);
+    const message = input.messages.find((item) => item.id === selection.messageId);
+    if (!message)
+        throw new Error(`API enum selection cites unavailable message ${selection.messageId}`);
+    const source = readApiInputLiteralSource({
+        sourceFormat: 'text',
+        sourceText: selection.sourceText,
+        text: message.text,
+        label: `API enum ${candidate.targetPointer}`,
+    });
+    return {
+        ...structuredClone(candidate),
+        ...selection,
+        occurrences: source.occurrences,
+    };
+}

package/dist/draft/edits/inputs/describe-workflow-draft-api-input-edit-answer-requirements.d.ts

@@ -0,0 +1,4 @@
+import type { ResolveWorkflowDraftApiInputEditsInput } from '../../../types/workflow-draft-api-input-edit.js';
+import type { ApiInputRequirement } from '../../../types/api-clarification.js';
+/** Questions for actual pending set-targets, retaining references and declaring the compiled dialect. */
+export declare function describeWorkflowDraftApiInputEditAnswerRequirements(input: ResolveWorkflowDraftApiInputEditsInput): ApiInputRequirement[];

package/dist/draft/edits/inputs/describe-workflow-draft-api-input-edit-answer-requirements.js

@@ -0,0 +1,30 @@
+import { describeWorkflowDraftApiInputEdit } from './describe-workflow-draft-api-input-edit.js';
+import { resolveWorkflowDraftApiInputEdits } from './resolve-workflow-draft-api-input-edits.js';
+import { createSchemaResourceContext } from '../../../bindings/resources/create-schema-resource-context.js';
+/** Questions for actual pending set-targets, retaining references and declaring the compiled dialect. */
+export function describeWorkflowDraftApiInputEditAnswerRequirements(input) {
+    const result = resolveWorkflowDraftApiInputEdits(input);
+    if (result.status === 'ready')
+        return [];
+    const described = describeWorkflowDraftApiInputEdit(input);
+    const resources = createSchemaResourceContext(input.contract.schemaResource);
+    return result.pendingTargets.map((target) => {
+        if (target.kind !== 'set')
+            throw new Error(`Pending API edit ${input.contract.id}:${target.id} is not a set-target`);
+        return {
+            kind: 'requested-input',
+            id: `${input.contract.id}:${target.id}`,
+            callId: described.call.id,
+            operation: structuredClone(described.operation.key),
+            targetPointer: target.pointer,
+            schema: resources.bundle(target.schema),
+            openapiVersion: described.operation.openapiVersion,
+            schemaDialect: 'draft-2020-12',
+            requestedInputs: [target.pointer],
+            ...(typeof described.operation.operation.summary === 'string'
+                ? { operationSummary: described.operation.operation.summary }
+                : {}),
+            message: `Provide the new explicitly requested value at ${target.pointer}. The existing value is not an answer to this edit.`,
+        };
+    });
+}

package/dist/draft/edits/inputs/describe-workflow-draft-api-input-edit-enum-choices.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDraftApiInputEditContractInput } from '../../../types/workflow-draft-api-input-edit.js';
+import type { WorkflowDraftApiEnumChoicesDescription } from '../../../types/workflow-draft-api-enum-selection.js';
+/** Only previously validated set-targets; never advertise remove targets, bindings or unrelated fields. */
+export declare function describeWorkflowDraftApiInputEditEnumChoices(input: WorkflowDraftApiInputEditContractInput): WorkflowDraftApiEnumChoicesDescription;

package/dist/draft/edits/inputs/describe-workflow-draft-api-input-edit-enum-choices.js

@@ -0,0 +1,42 @@
+import { validateWorkflowDraftApiInputEditContract } from './validate-workflow-draft-api-input-edit-contract.js';
+import { describeWorkflowDraftApiInputEdit } from './describe-workflow-draft-api-input-edit.js';
+import { createSchemaResourceContext } from '../../../bindings/resources/create-schema-resource-context.js';
+import { listApiInputEnumCandidates } from '../../../arguments/enum/list-api-input-enum-candidates.js';
+/** Only previously validated set-targets; never advertise remove targets, bindings or unrelated fields. */
+export function describeWorkflowDraftApiInputEditEnumChoices(input) {
+    validateWorkflowDraftApiInputEditContract(input);
+    if (input.selectOasEnums !== undefined &&
+        typeof input.selectOasEnums !== 'boolean')
+        throw new Error('API input edit selectOasEnums must be a boolean');
+    const result = {
+        candidates: [],
+        targets: [],
+    };
+    if (input.selectOasEnums !== true)
+        return result;
+    const description = describeWorkflowDraftApiInputEdit(input);
+    const resources = createSchemaResourceContext(input.contract.schemaResource);
+    for (const target of input.contract.targets) {
+        if (target.kind !== 'set')
+            continue;
+        const candidates = listApiInputEnumCandidates({
+            source: {
+                kind: 'operation',
+                callId: description.call.id,
+                operation: description.operation,
+                requestMediaType: description.call.requestMediaType,
+                targetPointer: target.pointer,
+            },
+            schemas: [target.schema],
+            resources,
+        });
+        if (candidates.length) {
+            result.candidates.push(...candidates);
+            result.targets.push({
+                targetPointer: target.pointer,
+                schema: resources.bundle(target.schema),
+            });
+        }
+    }
+    return result;
+}

package/dist/draft/edits/inputs/resolve-workflow-draft-api-input-edit-reply.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveWorkflowDraftApiInputEditReplyInput, WorkflowDraftApiInputEditAnswers } from '../../../types/workflow-draft-api-input-edit.js';
+/** Interpretations become validated answer values, never a replacement model proposal. */
+export declare function resolveWorkflowDraftApiInputEditReply(input: ResolveWorkflowDraftApiInputEditReplyInput): WorkflowDraftApiInputEditAnswers;

package/dist/draft/edits/inputs/resolve-workflow-draft-api-input-edit-reply.js

@@ -0,0 +1,24 @@
+import { describeWorkflowDraftApiInputEditAnswerRequirements } from './describe-workflow-draft-api-input-edit-answer-requirements.js';
+import { validateApiInputAnswerAnalysis } from '../../../arguments/clarification/extraction/validate-api-input-answer-analysis.js';
+import { createWorkflowDraftApiInputEditAnswersSchema } from '../../../schemas/create-workflow-draft-api-input-edit-answers-schema.js';
+/** Interpretations become validated answer values, never a replacement model proposal. */
+export function resolveWorkflowDraftApiInputEditReply(input) {
+    const requirements = describeWorkflowDraftApiInputEditAnswerRequirements(input);
+    validateApiInputAnswerAnalysis({
+        reply: input.reply,
+        requirements,
+        ...(input.selectOasEnums === undefined
+            ? {}
+            : { selectOasEnums: input.selectOasEnums }),
+        analysis: input.analysis,
+    });
+    return createWorkflowDraftApiInputEditAnswersSchema(input).parse({
+        contractId: input.contract.id,
+        answers: input.analysis.answers.map((answer) => {
+            const target = input.contract.targets.find((target) => `${input.contract.id}:${target.id}` === answer.requirementId);
+            if (!target)
+                throw new Error(`API edit reply references an unavailable target ${answer.requirementId}`);
+            return { targetId: target.id, value: structuredClone(answer.value) };
+        }),
+    });
+}

package/dist/draft/edits/inputs/resolve-workflow-draft-api-input-edits.js

@@ -6,6 +6,8 @@ import { applyWorkflowDraftApiInputEdits } from '../values/apply-workflow-draft-
 import { validateApiArguments } from '../../../arguments/validate-api-arguments.js';
 import { orderWorkflowDraftValueEdits } from '../values/order-workflow-draft-value-edits.js';
 import { verifyApiInputLiteralSource } from '../../../arguments/sources/verify-api-input-literal-source.js';
+import { describeWorkflowDraftApiInputEditEnumChoices } from './describe-workflow-draft-api-input-edit-enum-choices.js';
+import { verifyWorkflowDraftApiEnumSelection } from '../enum/verify-workflow-draft-api-enum-selection.js';
 /** Exact-source validation is deterministic; it is not semantic entailment proof. */
 export function resolveWorkflowDraftApiInputEdits(input) {
     const output = createWorkflowDraftApiInputEditValuesSchema(input).parse(input.output);
@@ -19,12 +21,28 @@ export function resolveWorkflowDraftApiInputEdits(input) {
     const sets = [];
     const removals = [];
     const pendingTargets = [];
+    const enumSelections = [];
+    const { candidates } = describeWorkflowDraftApiInputEditEnumChoices(input);
     for (const target of input.contract.targets) {
         if (target.kind === 'remove') {
             removals.push({ kind: 'remove', pointer: target.pointer });
             continue;
         }
         const answer = output.values[target.id];
+        if (answer.status === 'oas-enum') {
+            const selection = verifyWorkflowDraftApiEnumSelection({
+                selection: answer.selection,
+                candidates: candidates.filter((candidate) => candidate.targetPointer === target.pointer),
+                messages: described.messages,
+            });
+            sets.push({
+                kind: 'set',
+                pointer: target.pointer,
+                value: structuredClone(selection.value),
+            });
+            enumSelections.push(selection);
+            continue;
+        }
         if (answer.explanation)
             validateWorkflowPlanningEvidence({
                 context: { messages: described.messages },
@@ -60,6 +78,7 @@ export function resolveWorkflowDraftApiInputEdits(input) {
             values: output,
             pendingTargets,
             ...human,
+            ...(enumSelections.length ? { enumSelections } : {}),
         };
     // Targets address the original value. Set before deletion; remove higher array
     // indices first so one deletion does not retarget another original index.
@@ -80,6 +99,7 @@ export function resolveWorkflowDraftApiInputEdits(input) {
         contractId: input.contract.id,
         values: output,
         ...human,
+        ...(enumSelections.length ? { enumSelections } : {}),
         resolution: {
             stepId: input.stepId,
             kind: 'api-inputs',

package/dist/public-api.d.ts

@@ -14,6 +14,13 @@ export type * from './types/api-operation.js';
 export { createApiArgumentsSchema } from './schemas/create-api-arguments-schema.js';
 export { createApiArgumentGenerationContract } from './schemas/create-api-argument-generation-contract.js';
 export type * from './types/api-argument-generation.js';
+export type * from './types/api-argument-enum.js';
+export type * from './types/api-input-literal-source.js';
+export { apiInputLiteralSourceSchema } from './schemas/api-input-literal-source-schema.js';
+export { resolveApiLiteralProposalSources } from './arguments/sources/resolve-api-literal-proposal-sources.js';
+export { createApiRequestInputPointerSchema } from './schemas/create-api-request-input-pointer-schema.js';
+export { describeApiArgumentEnumContext } from './arguments/enum/describe-api-argument-enum-context.js';
+export { resolveApiArgumentEnumInterpretation } from './arguments/enum/resolve-api-argument-enum-interpretation.js';
 export type * from './types/api-literal-generation.js';
 export { describeApiLiteralGeneration } from './arguments/generation/describe-api-literal-generation.js';
 export { createApiLiteralGenerationRecord } from './arguments/generation/create-api-literal-generation-record.js';
@@ -32,8 +39,14 @@ export { resolveApiInputSourceSelections } from './arguments/clarification/extra
 export { createApiInputSourceSelectionSchema } from './schemas/api-input-source-selection-schema.js';
 export { captureApiInputAnswerContext } from './arguments/clarification/extraction/capture-api-input-answer-context.js';
 export { resolveApiInputAnswerSources } from './arguments/clarification/extraction/resolve-api-input-answer-sources.js';
+export { resolveApiInputAnswerInterpretations } from './arguments/clarification/extraction/resolve-api-input-answer-interpretations.js';
+export { describeApiInputEnumAnswerChoices } from './arguments/enum/describe-api-input-enum-answer-choices.js';
+export type * from './types/api-input-enum-answers.js';
 export { createApiInputAnswerExtractionRecord } from './arguments/clarification/extraction/create-api-input-answer-extraction-record.js';
 export { validateApiInputAnswerExtractionRecord } from './arguments/clarification/extraction/validate-api-input-answer-extraction-record.js';
+export { validateApiInputAnswerAnalysis } from './arguments/clarification/extraction/validate-api-input-answer-analysis.js';
+export { describeWorkflowDraftApiInputEditAnswerRequirements } from './draft/edits/inputs/describe-workflow-draft-api-input-edit-answer-requirements.js';
+export { resolveWorkflowDraftApiInputEditReply } from './draft/edits/inputs/resolve-workflow-draft-api-input-edit-reply.js';
 export { applyConfirmedApiInputs } from './arguments/clarification/apply-confirmed-api-inputs.js';
 export { inspectApiArgumentRequirements } from './arguments/clarification/inspect-api-argument-requirements.js';
 export { validateApiInputAnswers } from './arguments/clarification/validate-api-input-answers.js';
@@ -166,6 +179,11 @@ export type * from './types/workflow-draft-native-dependencies.js';
 export { createWorkflowDraftNativeDependenciesSchema } from './schemas/workflow-draft-native-dependencies-schema.js';
 export { describeWorkflowDraftNativeDependencies, resolveWorkflowDraftNativeDependencies, validateWorkflowDraftNativeDependencies, validateWorkflowDraftNativeDependencyResolutions, } from './draft/edits/native/additions/resolve-workflow-draft-native-dependencies.js';
 export type * from './types/workflow-draft-api-call-planning.js';
+export type * from './types/workflow-draft-api-enum-selection.js';
+export type { ApiInputEnumCandidate } from './types/api-input-enum.js';
+export { describeWorkflowDraftApiEnumChoices } from './draft/edits/api/describe-workflow-draft-api-enum-choices.js';
+export { createWorkflowDraftApiEnumSelectionSchema } from './schemas/workflow-draft-api-enum-selection-schema.js';
+export { describeWorkflowDraftApiInputEditEnumChoices } from './draft/edits/inputs/describe-workflow-draft-api-input-edit-enum-choices.js';
 export type * from './types/workflow-draft-api-binding-intent.js';
 export { describeWorkflowDraftApiBindingIntent } from './draft/edits/api/describe-workflow-draft-api-binding-intent.js';
 export { createWorkflowDraftApiBindingIntentSchema } from './schemas/workflow-draft-api-binding-intent-schema.js';

package/dist/public-api.js

@@ -10,6 +10,11 @@ export { createApiSelectionExplanation } from './openapi/selection/evidence/crea
 export { validateApiSelectionExplanation } from './openapi/selection/evidence/validate-api-selection-explanation.js';
 export { createApiArgumentsSchema } from './schemas/create-api-arguments-schema.js';
 export { createApiArgumentGenerationContract } from './schemas/create-api-argument-generation-contract.js';
+export { apiInputLiteralSourceSchema } from './schemas/api-input-literal-source-schema.js';
+export { resolveApiLiteralProposalSources } from './arguments/sources/resolve-api-literal-proposal-sources.js';
+export { createApiRequestInputPointerSchema } from './schemas/create-api-request-input-pointer-schema.js';
+export { describeApiArgumentEnumContext } from './arguments/enum/describe-api-argument-enum-context.js';
+export { resolveApiArgumentEnumInterpretation } from './arguments/enum/resolve-api-argument-enum-interpretation.js';
 export { describeApiLiteralGeneration } from './arguments/generation/describe-api-literal-generation.js';
 export { createApiLiteralGenerationRecord } from './arguments/generation/create-api-literal-generation-record.js';
 export { validateApiLiteralGenerationRecord } from './arguments/generation/validate-api-literal-generation-record.js';
@@ -22,8 +27,13 @@ export { resolveApiInputSourceSelections } from './arguments/clarification/extra
 export { createApiInputSourceSelectionSchema } from './schemas/api-input-source-selection-schema.js';
 export { captureApiInputAnswerContext } from './arguments/clarification/extraction/capture-api-input-answer-context.js';
 export { resolveApiInputAnswerSources } from './arguments/clarification/extraction/resolve-api-input-answer-sources.js';
+export { resolveApiInputAnswerInterpretations } from './arguments/clarification/extraction/resolve-api-input-answer-interpretations.js';
+export { describeApiInputEnumAnswerChoices } from './arguments/enum/describe-api-input-enum-answer-choices.js';
 export { createApiInputAnswerExtractionRecord } from './arguments/clarification/extraction/create-api-input-answer-extraction-record.js';
 export { validateApiInputAnswerExtractionRecord } from './arguments/clarification/extraction/validate-api-input-answer-extraction-record.js';
+export { validateApiInputAnswerAnalysis } from './arguments/clarification/extraction/validate-api-input-answer-analysis.js';
+export { describeWorkflowDraftApiInputEditAnswerRequirements } from './draft/edits/inputs/describe-workflow-draft-api-input-edit-answer-requirements.js';
+export { resolveWorkflowDraftApiInputEditReply } from './draft/edits/inputs/resolve-workflow-draft-api-input-edit-reply.js';
 export { applyConfirmedApiInputs } from './arguments/clarification/apply-confirmed-api-inputs.js';
 export { inspectApiArgumentRequirements } from './arguments/clarification/inspect-api-argument-requirements.js';
 export { validateApiInputAnswers } from './arguments/clarification/validate-api-input-answers.js';
@@ -124,6 +134,9 @@ export { resolveWorkflowDraftNativeNodeParameterOwnership, validateWorkflowDraft
 export { resolveWorkflowDraftNativeNodeAddition } from './draft/edits/native/additions/resolve-workflow-draft-native-node-addition.js';
 export { createWorkflowDraftNativeDependenciesSchema } from './schemas/workflow-draft-native-dependencies-schema.js';
 export { describeWorkflowDraftNativeDependencies, resolveWorkflowDraftNativeDependencies, validateWorkflowDraftNativeDependencies, validateWorkflowDraftNativeDependencyResolutions, } from './draft/edits/native/additions/resolve-workflow-draft-native-dependencies.js';
+export { describeWorkflowDraftApiEnumChoices } from './draft/edits/api/describe-workflow-draft-api-enum-choices.js';
+export { createWorkflowDraftApiEnumSelectionSchema } from './schemas/workflow-draft-api-enum-selection-schema.js';
+export { describeWorkflowDraftApiInputEditEnumChoices } from './draft/edits/inputs/describe-workflow-draft-api-input-edit-enum-choices.js';
 export { describeWorkflowDraftApiBindingIntent } from './draft/edits/api/describe-workflow-draft-api-binding-intent.js';
 export { createWorkflowDraftApiBindingIntentSchema } from './schemas/workflow-draft-api-binding-intent-schema.js';
 export { resolveWorkflowDraftApiBindingIntent } from './draft/edits/api/resolve-workflow-draft-api-binding-intent.js';

package/dist/schemas/api-input-answer-extraction-schema.d.ts

@@ -15,6 +15,7 @@ export declare const apiInputRequirementSchema: z.ZodObject<{
     targetPointer: z.ZodString;
     schema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodJSONSchema>]>;
     openapiVersion: z.ZodString;
+    schemaDialect: z.ZodOptional<z.ZodLiteral<"draft-2020-12">>;
     operationSummary: z.ZodOptional<z.ZodString>;
     parameterDescription: z.ZodOptional<z.ZodString>;
     message: z.ZodString;
@@ -37,10 +38,13 @@ export declare const apiInputAnswerContextSchema: z.ZodObject<{
         targetPointer: z.ZodString;
         schema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodJSONSchema>]>;
         openapiVersion: z.ZodString;
+        schemaDialect: z.ZodOptional<z.ZodLiteral<"draft-2020-12">>;
         operationSummary: z.ZodOptional<z.ZodString>;
         parameterDescription: z.ZodOptional<z.ZodString>;
         message: z.ZodString;
     }, z.core.$strict>>;
+    purpose: z.ZodOptional<z.ZodString>;
+    selectOasEnums: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 export declare const apiInputAnswerSourceSchema: z.ZodObject<{
     sourceFormat: z.ZodEnum<{
@@ -69,4 +73,16 @@ export declare const apiInputAnswerExtractionDecisionSchema: z.ZodObject<{
         requirementId: z.ZodString;
         reason: z.ZodString;
     }, z.core.$strict>>;
+    enumSelections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        requirementId: z.ZodString;
+        candidateId: z.ZodString;
+        intent: z.ZodObject<{
+            sourceFormat: z.ZodEnum<{
+                text: "text";
+                json: "json";
+            }>;
+            sourceText: z.ZodString;
+        }, z.core.$strict>;
+        reason: z.ZodString;
+    }, z.core.$strict>>>;
 }, z.core.$strict>;

package/dist/schemas/api-input-answer-extraction-schema.js

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import { apiOperationKeySchema } from './api-operation-key-schema.js';
 import { apiInputLiteralSourceSchema } from './api-input-literal-source-schema.js';
 import { requestedApiInputsSchema } from './requested-api-inputs-schema.js';
+import { apiInputEnumAnswerSelectionsSchema } from './api-input-enum-answer-selection-schema.js';
 export const apiInputRequirementSchema = z.strictObject({
     kind: z.enum(['missing-input', 'requested-input']),
     requestedInputs: requestedApiInputsSchema.optional(),
@@ -11,6 +12,7 @@ export const apiInputRequirementSchema = z.strictObject({
     targetPointer: z.string().min(1),
     schema: z.union([z.boolean(), z.record(z.string(), z.json())]),
     openapiVersion: z.string().min(1),
+    schemaDialect: z.literal('draft-2020-12').optional(),
     operationSummary: z.string().optional(),
     parameterDescription: z.string().optional(),
     message: z.string().min(1),
@@ -18,6 +20,12 @@ export const apiInputRequirementSchema = z.strictObject({
 export const apiInputAnswerContextSchema = z.strictObject({
     reply: z.string(),
     requirements: z.array(apiInputRequirementSchema),
+    purpose: z
+        .string()
+        .min(1)
+        .refine((value) => value.trim().length > 0)
+        .optional(),
+    selectOasEnums: z.boolean().optional(),
 });
 export const apiInputAnswerSourceSchema = apiInputLiteralSourceSchema.extend({
     requirementId: z.string().min(1),
@@ -26,4 +34,5 @@ export const apiInputAnswerSourcesSchema = z.array(apiInputAnswerSourceSchema);
 export const apiInputAnswerExtractionDecisionSchema = z.strictObject({
     reason: z.string().min(1),
     answers: z.array(apiInputAnswerSourceSchema.extend({ reason: z.string().min(1) })),
+    enumSelections: apiInputEnumAnswerSelectionsSchema.optional(),
 });

package/dist/schemas/api-input-enum-answer-selection-schema.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const apiInputEnumAnswerSelectionSchema: z.ZodObject<{
+    requirementId: z.ZodString;
+    candidateId: z.ZodString;
+    intent: z.ZodObject<{
+        sourceFormat: z.ZodEnum<{
+            text: "text";
+            json: "json";
+        }>;
+        sourceText: z.ZodString;
+    }, z.core.$strict>;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export declare const apiInputEnumAnswerSelectionsSchema: z.ZodArray<z.ZodObject<{
+    requirementId: z.ZodString;
+    candidateId: z.ZodString;
+    intent: z.ZodObject<{
+        sourceFormat: z.ZodEnum<{
+            text: "text";
+            json: "json";
+        }>;
+        sourceText: z.ZodString;
+    }, z.core.$strict>;
+    reason: z.ZodString;
+}, z.core.$strict>>;

package/dist/schemas/api-input-enum-answer-selection-schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { apiInputLiteralSourceSchema } from './api-input-literal-source-schema.js';
+export const apiInputEnumAnswerSelectionSchema = z.strictObject({
+    requirementId: z.string().min(1),
+    candidateId: z.string().min(1),
+    intent: apiInputLiteralSourceSchema,
+    reason: z
+        .string()
+        .refine((value) => value.trim().length > 0, 'An enum choice requires a reason'),
+});
+export const apiInputEnumAnswerSelectionsSchema = z.array(apiInputEnumAnswerSelectionSchema);

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

@@ -1,12 +1,13 @@
 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 { createWorkflowDraftApiInputEditTargetValueSchema } from './create-workflow-draft-api-input-edit-target-value-schema.js';
 import { createSchemaResourceContext } from '../bindings/resources/create-schema-resource-context.js';
 import { apiInputLiteralSourceSchema } from './api-input-literal-source-schema.js';
+import { describeWorkflowDraftApiInputEditEnumChoices } from '../draft/edits/inputs/describe-workflow-draft-api-input-edit-enum-choices.js';
+import { createWorkflowDraftApiEnumChoiceSchema } from './workflow-draft-api-enum-choice-schema.js';
 /** Only selected set-values are model-owned; per-field OAS assertions stay intact. */
 export function createWorkflowDraftApiInputEditValuesSchema(input, messageSchema) {
-    validateWorkflowDraftApiInputEditContract(input);
+    const { candidates } = describeWorkflowDraftApiInputEditEnumChoices(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
@@ -31,6 +32,14 @@ export function createWorkflowDraftApiInputEditValuesSchema(input, messageSchema
                     status: z.literal('needs-input'),
                     ...evidence.fields,
                 }),
+                ...(candidates.some((candidate) => candidate.targetPointer === target.pointer)
+                    ? [
+                        z.strictObject({
+                            status: z.literal('oas-enum'),
+                            selection: createWorkflowDraftApiEnumChoiceSchema(candidates.filter((candidate) => candidate.targetPointer === target.pointer), input.requestMessageIds),
+                        }),
+                    ]
+                    : []),
             ]),
         ]))),
     })

package/dist/schemas/workflow-draft-api-enum-choice-schema.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { WorkflowDraftApiEnumSelection } from '../types/workflow-draft-api-enum-selection.js';
+import type { ApiInputEnumCandidate } from '../types/api-input-enum.js';
+/** No generated value or schema field exists in a semantic enum choice. */
+export declare function createWorkflowDraftApiEnumChoiceSchema(candidates: ApiInputEnumCandidate[], messageIds: string[]): z.ZodType<WorkflowDraftApiEnumSelection>;

package/dist/schemas/workflow-draft-api-enum-choice-schema.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+/** No generated value or schema field exists in a semantic enum choice. */
+export function createWorkflowDraftApiEnumChoiceSchema(candidates, messageIds) {
+    if (!messageIds.length)
+        throw new Error('API enum choice requires original human message IDs');
+    if (!candidates.length)
+        return z.never();
+    return z.strictObject({
+        candidateId: z
+            .enum(candidates.map((candidate) => candidate.id))
+            .describe('Choose an offered original-OAS enum candidate ID. Code copies its original value; never generate a request value.'),
+        messageId: z
+            .enum(messageIds)
+            .describe('Actual supplied human message expressing this enum intent, not an OAS quotation.'),
+        sourceText: z
+            .string()
+            .min(1)
+            .describe('Exact original human text expressing the intended meaning; it need not contain the enum literal.'),
+        reason: z
+            .string()
+            .min(1)
+            .refine((value) => value.trim().length > 0)
+            .describe('Brief user-facing reason why this OAS choice matches the cited request. Not private chain-of-thought.'),
+    });
+}

package/dist/schemas/workflow-draft-api-enum-selection-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { WorkflowDraftApiEnumChoicesInput, WorkflowDraftApiEnumSelectionProposal } from '../types/workflow-draft-api-enum-selection.js';
+/** The model selects IDs and explains intent; there is deliberately no value field. */
+export declare function createWorkflowDraftApiEnumSelectionSchema(input: WorkflowDraftApiEnumChoicesInput): z.ZodType<WorkflowDraftApiEnumSelectionProposal>;