@openapi-flow/core 0.2.0 → 0.3.0

package/dist/schemas/api-input-source-selection-schema.js

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export const apiInputSourceSelectionSchema = z.discriminatedUnion('kind', [
+    z.strictObject({ kind: z.literal('json'), candidateId: z.string().min(1) }),
+    z.strictObject({
+        kind: z.literal('text'),
+        startTokenId: z.string().min(1),
+        endTokenId: z.string().min(1),
+    }),
+]);
+export const apiInputAnswerSelectionsSchema = z.array(z.strictObject({
+    requirementId: z.string().min(1),
+    source: apiInputSourceSelectionSchema,
+}));
+/** Only code-owned IDs can be selected; strings and values are input-only. */
+export function createApiInputSourceSelectionSchema(catalog) {
+    const jsonIds = catalog.json.map((candidate) => candidate.id);
+    const textIds = catalog.text.flatMap((segment) => segment.tokens.map((token) => token.id));
+    const choices = [];
+    if (jsonIds.length)
+        choices.push(z.strictObject({
+            kind: z.literal('json'),
+            candidateId: z
+                .enum(jsonIds)
+                .describe('Select a complete original JSON literal candidate. Code owns its exact text and JSON parsing, including string delimiters.'),
+        }));
+    if (textIds.length) {
+        const boundary = z.enum(textIds);
+        choices.push(z.strictObject({
+            kind: z.literal('text'),
+            startTokenId: boundary.describe('First token of the exact unquoted string. Start and end must be in the same offered text segment, in original order.'),
+            endTokenId: boundary
+                .clone()
+                .describe('Last token, inclusive, of the exact unquoted string. Code copies every original character between these boundaries, including whitespace.'),
+        }));
+    }
+    if (!choices.length)
+        throw new Error('API input source selection requires an available original source');
+    return z.union(choices);
+}

package/dist/schemas/api-literal-generation-schema.d.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import type { ApiArgumentValues } from '../types/api-arguments.js';
+export declare const apiLiteralGenerationIdentitySchema: z.ZodObject<{
+    callId: z.ZodString;
+    scenario: z.ZodString;
+    purpose: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const apiLiteralGenerationOperationSchema: z.ZodObject<{
+    key: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+    method: z.ZodString;
+    path: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const apiLiteralGenerationContextSchema: z.ZodObject<{
+    scenario: z.ZodString;
+    purpose: z.ZodOptional<z.ZodString>;
+    operation: z.ZodObject<{
+        key: z.ZodObject<{
+            documentId: z.ZodString;
+            snapshotId: z.ZodString;
+            operationRef: z.ZodString;
+        }, z.core.$strict>;
+        method: z.ZodString;
+        path: z.ZodString;
+        summary: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    literalInputSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    requestMediaType: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare function createApiLiteralGenerationRecordSchema(valuesSchema: z.ZodType<ApiArgumentValues>): z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"not-needed">;
+    callId: z.ZodString;
+    operation: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"proposed-literals">;
+    callId: z.ZodString;
+    operation: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+    proposedValues: z.ZodType<ApiArgumentValues, unknown, z.core.$ZodTypeInternals<ApiArgumentValues, unknown>>;
+    explanation: z.ZodObject<{
+        reason: z.ZodString;
+        evidence: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"scenario">;
+            text: z.ZodString;
+            purpose: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"literal-input-contract">;
+            operation: z.ZodObject<{
+                key: z.ZodObject<{
+                    documentId: z.ZodString;
+                    snapshotId: z.ZodString;
+                    operationRef: z.ZodString;
+                }, z.core.$strict>;
+                method: z.ZodString;
+                path: z.ZodString;
+                summary: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            requestMediaType: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>], "kind">>;
+    }, z.core.$strict>;
+}, z.core.$strict>], "kind">;

package/dist/schemas/api-literal-generation-schema.js

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { apiOperationKeySchema } from './api-operation-key-schema.js';
+import { planningEvidenceTextSchema } from './planning-evidence-schema.js';
+export const apiLiteralGenerationIdentitySchema = z.strictObject({
+    callId: planningEvidenceTextSchema,
+    scenario: planningEvidenceTextSchema,
+    purpose: planningEvidenceTextSchema.optional(),
+});
+export const apiLiteralGenerationOperationSchema = z.strictObject({
+    key: apiOperationKeySchema,
+    method: planningEvidenceTextSchema,
+    path: z.string(),
+    summary: z.string().optional(),
+    description: z.string().optional(),
+});
+export const apiLiteralGenerationContextSchema = z.strictObject({
+    scenario: planningEvidenceTextSchema,
+    purpose: planningEvidenceTextSchema.optional(),
+    operation: apiLiteralGenerationOperationSchema,
+    literalInputSchema: z.record(z.string(), z.unknown()),
+    requestMediaType: planningEvidenceTextSchema.optional(),
+});
+export function createApiLiteralGenerationRecordSchema(valuesSchema) {
+    return z.discriminatedUnion('kind', [
+        z.strictObject({
+            kind: z.literal('not-needed'),
+            callId: planningEvidenceTextSchema,
+            operation: apiOperationKeySchema,
+        }),
+        z.strictObject({
+            kind: z.literal('proposed-literals'),
+            callId: planningEvidenceTextSchema,
+            operation: apiOperationKeySchema,
+            proposedValues: valuesSchema,
+            explanation: z.strictObject({
+                reason: planningEvidenceTextSchema,
+                evidence: z.array(z.discriminatedUnion('kind', [
+                    z.strictObject({
+                        kind: z.literal('scenario'),
+                        text: z.string(),
+                        purpose: planningEvidenceTextSchema.optional(),
+                    }),
+                    z.strictObject({
+                        kind: z.literal('literal-input-contract'),
+                        operation: apiLiteralGenerationOperationSchema,
+                        schema: z.record(z.string(), z.unknown()),
+                        requestMediaType: planningEvidenceTextSchema.optional(),
+                    }),
+                ])),
+            }),
+        }),
+    ]);
+}

package/dist/schemas/api-operation-answers-schema.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const apiOperationAnswersSchema: z.ZodArray<z.ZodObject<{
+    questionId: z.ZodString;
+    operation: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>>;

package/dist/schemas/api-operation-answers-schema.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import { apiOperationKeySchema } from './api-operation-key-schema.js';
+export const apiOperationAnswersSchema = z
+    .array(z.strictObject({
+    questionId: z.string().min(1),
+    operation: apiOperationKeySchema,
+}))
+    .min(1);

package/dist/schemas/api-operation-candidate-schema.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const apiOperationCandidateSchema: z.ZodObject<{
+    key: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+    source: z.ZodEnum<{
+        paths: "paths";
+        webhooks: "webhooks";
+        callbacks: "callbacks";
+    }>;
+    operationRef: z.ZodString;
+    method: z.ZodString;
+    path: z.ZodString;
+    operationId: z.ZodOptional<z.ZodString>;
+    summary: z.ZodString;
+    description: z.ZodString;
+    tags: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;

package/dist/schemas/api-operation-candidate-schema.js

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+import { apiOperationKeySchema } from './api-operation-key-schema.js';
+export const apiOperationCandidateSchema = z
+    .strictObject({
+    key: apiOperationKeySchema,
+    source: z.enum(['paths', 'webhooks', 'callbacks']),
+    operationRef: z.string().min(1),
+    method: z.string().min(1),
+    path: z.string(),
+    operationId: z.string().optional(),
+    summary: z.string(),
+    description: z.string(),
+    tags: z.array(z.string()),
+})
+    .refine((candidate) => candidate.operationRef === candidate.key.operationRef, {
+    message: 'candidate.operationRef must equal candidate.key.operationRef',
+    path: ['operationRef'],
+});

package/dist/schemas/api-operation-key-schema.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const apiOperationKeySchema: z.ZodObject<{
+    documentId: z.ZodString;
+    snapshotId: z.ZodString;
+    operationRef: z.ZodString;
+}, z.core.$strict>;

package/dist/schemas/api-operation-key-schema.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export const apiOperationKeySchema = z.strictObject({
+    documentId: z.string().min(1),
+    snapshotId: z.string().min(1),
+    operationRef: z.string().min(1),
+});

package/dist/schemas/api-request-media-type-decision-schema.d.ts

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+export declare const apiRequestMediaTypeContextSchema: z.ZodObject<{
+    scenario: z.ZodString;
+    purpose: z.ZodOptional<z.ZodString>;
+    operation: z.ZodObject<{
+        key: z.ZodObject<{
+            documentId: z.ZodString;
+            snapshotId: z.ZodString;
+            operationRef: z.ZodString;
+        }, z.core.$strict>;
+        method: z.ZodString;
+        path: z.ZodString;
+        requestBody: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strict>;
+    mediaTypes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const apiRequestMediaTypeAssessmentProposalSchema: z.ZodObject<{
+    requestMediaType: z.ZodNullable<z.ZodString>;
+    explanation: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const apiRequestMediaTypeDecisionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"no-request-body">;
+    operation: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+    declaredMediaTypes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"single-declared-format">;
+    requestMediaType: z.ZodString;
+    operation: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+    declaredMediaTypes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"model-selection">;
+    requestMediaType: z.ZodString;
+    assessment: z.ZodObject<{
+        requestMediaType: z.ZodString;
+        explanation: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodString;
+            evidence: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"scenario">;
+                text: z.ZodString;
+                purpose: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"oas-request-body">;
+                operation: z.ZodObject<{
+                    documentId: z.ZodString;
+                    snapshotId: z.ZodString;
+                    operationRef: z.ZodString;
+                }, z.core.$strict>;
+                pointer: z.ZodLiteral<"/requestBody">;
+                value: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strict>], "kind">>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    operation: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+    declaredMediaTypes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"documented-default">;
+    requestMediaType: z.ZodString;
+    policy: z.ZodLiteral<"json-form-concrete-wildcard-code-point">;
+    assessment: z.ZodObject<{
+        requestMediaType: z.ZodNull;
+        explanation: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodString;
+            evidence: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"scenario">;
+                text: z.ZodString;
+                purpose: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"oas-request-body">;
+                operation: z.ZodObject<{
+                    documentId: z.ZodString;
+                    snapshotId: z.ZodString;
+                    operationRef: z.ZodString;
+                }, z.core.$strict>;
+                pointer: z.ZodLiteral<"/requestBody">;
+                value: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strict>], "kind">>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    operation: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+    declaredMediaTypes: z.ZodArray<z.ZodString>;
+}, z.core.$strict>], "kind">;

package/dist/schemas/api-request-media-type-decision-schema.js

@@ -0,0 +1,67 @@
+import { z } from 'zod';
+import { apiOperationKeySchema } from './api-operation-key-schema.js';
+import { planningEvidenceTextSchema } from './planning-evidence-schema.js';
+export const apiRequestMediaTypeContextSchema = z.strictObject({
+    scenario: planningEvidenceTextSchema,
+    purpose: planningEvidenceTextSchema.optional(),
+    operation: z.strictObject({
+        key: apiOperationKeySchema,
+        method: planningEvidenceTextSchema,
+        path: z.string(),
+        requestBody: z.record(z.string(), z.unknown()).optional(),
+    }),
+    mediaTypes: z.array(z.string().min(1)),
+});
+export const apiRequestMediaTypeAssessmentProposalSchema = z.strictObject({
+    requestMediaType: z.string().min(1).nullable(),
+    explanation: z
+        .strictObject({ reason: planningEvidenceTextSchema })
+        .optional(),
+});
+const explanationSchema = z.strictObject({
+    reason: planningEvidenceTextSchema,
+    evidence: z.array(z.discriminatedUnion('kind', [
+        z.strictObject({
+            kind: z.literal('scenario'),
+            text: z.string(),
+            purpose: planningEvidenceTextSchema.optional(),
+        }),
+        z.strictObject({
+            kind: z.literal('oas-request-body'),
+            operation: apiOperationKeySchema,
+            pointer: z.literal('/requestBody'),
+            value: z.record(z.string(), z.unknown()),
+        }),
+    ])),
+});
+const decisionFields = {
+    operation: apiOperationKeySchema,
+    declaredMediaTypes: z.array(z.string().min(1)),
+};
+export const apiRequestMediaTypeDecisionSchema = z.discriminatedUnion('kind', [
+    z.strictObject({ ...decisionFields, kind: z.literal('no-request-body') }),
+    z.strictObject({
+        ...decisionFields,
+        kind: z.literal('single-declared-format'),
+        requestMediaType: z.string().min(1),
+    }),
+    z.strictObject({
+        ...decisionFields,
+        kind: z.literal('model-selection'),
+        requestMediaType: z.string().min(1),
+        assessment: z.strictObject({
+            requestMediaType: z.string().min(1),
+            explanation: explanationSchema.optional(),
+        }),
+    }),
+    z.strictObject({
+        ...decisionFields,
+        kind: z.literal('documented-default'),
+        requestMediaType: z.string().min(1),
+        policy: z.literal('json-form-concrete-wildcard-code-point'),
+        assessment: z.strictObject({
+            requestMediaType: z.null(),
+            explanation: explanationSchema.optional(),
+        }),
+    }),
+]);

package/dist/schemas/api-selection-evidence-schema.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+export declare const apiSelectionContextSchema: z.ZodObject<{
+    scenario: z.ZodString;
+    operations: z.ZodArray<z.ZodObject<{
+        key: z.ZodObject<{
+            documentId: z.ZodString;
+            snapshotId: z.ZodString;
+            operationRef: z.ZodString;
+        }, z.core.$strict>;
+        source: z.ZodEnum<{
+            paths: "paths";
+            webhooks: "webhooks";
+            callbacks: "callbacks";
+        }>;
+        operationRef: z.ZodString;
+        method: z.ZodString;
+        path: z.ZodString;
+        operationId: z.ZodOptional<z.ZodString>;
+        summary: z.ZodString;
+        description: z.ZodString;
+        tags: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const apiSelectionExplanationBasisSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"catalog">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"candidates">;
+    operations: z.ZodArray<z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "kind">;
+export declare const apiSelectionExplanationSchema: z.ZodObject<{
+    reason: z.ZodString;
+    evidence: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"scenario">;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"discovery">;
+        candidates: z.ZodArray<z.ZodObject<{
+            key: z.ZodObject<{
+                documentId: z.ZodString;
+                snapshotId: z.ZodString;
+                operationRef: z.ZodString;
+            }, z.core.$strict>;
+            source: z.ZodEnum<{
+                paths: "paths";
+                webhooks: "webhooks";
+                callbacks: "callbacks";
+            }>;
+            operationRef: z.ZodString;
+            method: z.ZodString;
+            path: z.ZodString;
+            operationId: z.ZodOptional<z.ZodString>;
+            summary: z.ZodString;
+            description: z.ZodString;
+            tags: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;

package/dist/schemas/api-selection-evidence-schema.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { apiOperationCandidateSchema } from './api-operation-candidate-schema.js';
+import { apiOperationKeySchema } from './api-operation-key-schema.js';
+import { planningEvidenceTextSchema } from './planning-evidence-schema.js';
+export const apiSelectionContextSchema = z.strictObject({
+    scenario: planningEvidenceTextSchema,
+    operations: z.array(apiOperationCandidateSchema),
+});
+export const apiSelectionExplanationBasisSchema = z.discriminatedUnion('kind', [
+    z.strictObject({ kind: z.literal('catalog') }),
+    z.strictObject({
+        kind: z.literal('candidates'),
+        operations: z.array(apiOperationKeySchema).min(1),
+    }),
+]);
+export const apiSelectionExplanationSchema = z.strictObject({
+    reason: planningEvidenceTextSchema,
+    evidence: z.array(z.discriminatedUnion('kind', [
+        z.strictObject({ kind: z.literal('scenario'), text: z.string() }),
+        z.strictObject({
+            kind: z.literal('discovery'),
+            candidates: z.array(apiOperationCandidateSchema),
+        }),
+    ])),
+});

package/dist/schemas/confirmed-api-input-schema.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const confirmedApiInputSchema: z.ZodObject<{
+    callId: z.ZodString;
+    operation: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+    targetPointer: z.ZodString;
+    value: z.ZodJSONSchema;
+}, z.core.$strict>;
+export declare const confirmedApiInputsSchema: z.ZodArray<z.ZodObject<{
+    callId: z.ZodString;
+    operation: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+    targetPointer: z.ZodString;
+    value: z.ZodJSONSchema;
+}, z.core.$strict>>;
+export declare const apiInputAnswersSchema: z.ZodArray<z.ZodObject<{
+    requirementId: z.ZodString;
+    value: z.ZodJSONSchema;
+}, z.core.$strict>>;

package/dist/schemas/confirmed-api-input-schema.js

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+import { apiOperationKeySchema } from './api-operation-key-schema.js';
+export const confirmedApiInputSchema = z.strictObject({
+    callId: z.string().min(1),
+    operation: apiOperationKeySchema,
+    targetPointer: z.string().min(1),
+    value: z.json(),
+});
+export const confirmedApiInputsSchema = z.array(confirmedApiInputSchema);
+export const apiInputAnswersSchema = z
+    .array(z.strictObject({
+    requirementId: z.string().min(1),
+    value: z.json(),
+}))
+    .min(1);

package/dist/schemas/create-api-argument-generation-contract.d.ts

@@ -1,4 +1,4 @@
-import type { ApiArgumentsSchemaInput } from '../types/api-arguments.js';
 import type { ApiArgumentGenerationContract } from '../types/api-argument-generation.js';
+import type { ApiArgumentGenerationInput } from '../types/api-clarification.js';
 /** The OAS-derived schema decides whether the model has any values to propose. */
-export declare function createApiArgumentGenerationContract({ operation, bindings, requestMediaType, }: ApiArgumentsSchemaInput): ApiArgumentGenerationContract;
+export declare function createApiArgumentGenerationContract(input: ApiArgumentGenerationInput): ApiArgumentGenerationContract;

package/dist/schemas/create-api-argument-generation-contract.js

@@ -7,11 +7,18 @@ import { pointerTokens } from '../bindings/json-pointer.js';
 import { requestBindingSchemas } from '../bindings/request-binding-schema.js';
 import { projectLiteralInputSchema } from './project-literal-input-schema.js';
 import { createOasValueSchema } from './create-oas-value-schema.js';
+import { readConfirmedApiInputs } from '../arguments/clarification/read-confirmed-api-inputs.js';
 /** The OAS-derived schema decides whether the model has any values to propose. */
-export function createApiArgumentGenerationContract({ operation, bindings, requestMediaType, }) {
+export function createApiArgumentGenerationContract(input) {
+    const { operation, bindings, requestMediaType } = input;
     if (!Array.isArray(bindings))
         throw new Error('arguments.bindings must be an array');
     validateApiArguments({ operation, bindings, requestMediaType, values: {} });
+    const confirmed = readConfirmedApiInputs(input);
+    const ownedPointers = [
+        ...bindings.map((binding) => binding.targetPointer),
+        ...confirmed.map((item) => item.targetPointer),
+    ];
     for (const binding of bindings)
         if (!requestBindingSchemas({ operation, requestMediaType, callId: operation.key.operationRef }, binding.targetPointer).length)
             throw new Error(`binding ${binding.targetPointer} is not declared by ${operation.key.operationRef}`);
@@ -27,11 +34,11 @@ export function createApiArgumentGenerationContract({ operation, bindings, reque
             ['accept', 'content-type', 'authorization'].includes(name.toLowerCase()))
             continue;
         const pointer = '/' + location + '/' + name.replaceAll('~', '~0').replaceAll('/', '~1');
-        if (bindings.some((binding) => binding.targetPointer === pointer))
+        if (ownedPointers.includes(pointer))
             continue;
-        const projection = projectLiteralInputSchema(optionalRequestProperties(parameterSchema(parameter, pointer)), bindings
-            .filter((entry) => entry.targetPointer.startsWith(pointer + '/'))
-            .map((entry) => pointerTokens(entry.targetPointer).slice(2)), pointer);
+        const projection = projectLiteralInputSchema(optionalRequestProperties(parameterSchema(parameter, pointer)), ownedPointers
+            .filter((target) => target.startsWith(pointer + '/'))
+            .map((target) => pointerTokens(target).slice(2)), pointer);
         if (!projection.hasLiteralValues)
             continue;
         const value = createOasValueSchema(projection.schema, dialect, `${operation.key.operationRef}${pointer}`).describe(typeof parameter.description === 'string'
@@ -49,23 +56,26 @@ export function createApiArgumentGenerationContract({ operation, bindings, reque
         z.object(properties).strict().optional(),
     ]));
     const body = bodyMediaSchema(operation, requestMediaType);
-    if (body !== undefined &&
-        !bindings.some((binding) => binding.targetPointer === '/body')) {
-        const projection = projectLiteralInputSchema(optionalRequestProperties(body), bindings
-            .filter((entry) => entry.targetPointer.startsWith('/body/'))
-            .map((entry) => pointerTokens(entry.targetPointer).slice(1)), '/body');
+    if (body !== undefined && !ownedPointers.includes('/body')) {
+        const projection = projectLiteralInputSchema(optionalRequestProperties(body), ownedPointers
+            .filter((target) => target.startsWith('/body/'))
+            .map((target) => pointerTokens(target).slice(1)), '/body');
         if (projection.hasLiteralValues)
             fields.body = createOasValueSchema(projection.schema, dialect, `${operation.key.operationRef}/body`)
                 .describe('Request body literal values explicitly supplied by the scenario; forbidden properties are owned by preceding nodes.')
                 .optional();
     }
+    const valuesSchema = z
+        .object(fields)
+        .strict();
     const schema = z
         .object({
-        values: z.object(fields).strict(),
+        values: valuesSchema,
     })
         .strict();
     return {
         schema,
+        valuesSchema,
         literalInputSchema: z.toJSONSchema(schema),
         hasLiteralInputs: Object.keys(fields).length > 0,
     };

package/dist/schemas/create-api-arguments-schema.d.ts

@@ -1,3 +1,4 @@
 import type { z } from 'zod';
-import type { ApiArgumentProposal, ApiArgumentsSchemaInput } from '../types/api-arguments.js';
-export declare function createApiArgumentsSchema(input: ApiArgumentsSchemaInput): z.ZodType<ApiArgumentProposal>;
+import type { ApiArgumentProposal } from '../types/api-arguments.js';
+import type { ApiArgumentGenerationInput } from '../types/api-clarification.js';
+export declare function createApiArgumentsSchema(input: ApiArgumentGenerationInput): z.ZodType<ApiArgumentProposal>;

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

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import type { ApiInputRequirement } from '../types/api-clarification.js';
+export declare function createApiInputAnswersSchema(requirements: ApiInputRequirement[]): z.ZodObject<{
+    answers: z.ZodArray<z.ZodObject<{
+        requirementId: z.ZodLiteral<string>;
+        value: z.ZodType<import("../public-api.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../public-api.js").JsonValue, unknown>>;
+    }, z.core.$strict> | z.ZodUnion<z.ZodObject<{
+        requirementId: z.ZodLiteral<string>;
+        value: z.ZodType<import("../public-api.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../public-api.js").JsonValue, unknown>>;
+    }, z.core.$strict>[]>>;
+}, z.core.$strict>;