@openapi-flow/core 0.1.0 → 0.3.0

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

@@ -0,0 +1,4 @@
+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(input: ApiArgumentGenerationInput): ApiArgumentGenerationContract;

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

@@ -0,0 +1,82 @@
+import { z } from 'zod';
+import { object } from '../openapi/common/parse-spec-utils.js';
+import { bodyMediaSchema, parameterSchema, } from '../arguments/request-contract.js';
+import { validateApiArguments } from '../arguments/validate-api-arguments.js';
+import { optionalRequestProperties } from './operation-plan-schema.js';
+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(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}`);
+    const dialect = operation.openapiVersion.startsWith('3.0.')
+        ? 'openapi-3.0'
+        : 'draft-2020-12';
+    const groups = {};
+    for (const raw of operation.effective.parameters) {
+        const parameter = object(raw, `${operation.key.operationRef}.parameters`);
+        const location = String(parameter.in);
+        const name = String(parameter.name);
+        if (location === 'header' &&
+            ['accept', 'content-type', 'authorization'].includes(name.toLowerCase()))
+            continue;
+        const pointer = '/' + location + '/' + name.replaceAll('~', '~0').replaceAll('/', '~1');
+        if (ownedPointers.includes(pointer))
+            continue;
+        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'
+            ? parameter.description
+            : `Scenario value for ${location} parameter ${name}`);
+        if (!Object.hasOwn(groups, location))
+            groups[location] = {};
+        Object.defineProperty(groups[location], name, {
+            value: value.optional(),
+            enumerable: true,
+        });
+    }
+    const fields = Object.fromEntries(Object.entries(groups).map(([location, properties]) => [
+        location,
+        z.object(properties).strict().optional(),
+    ]));
+    const body = bodyMediaSchema(operation, requestMediaType);
+    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: valuesSchema,
+    })
+        .strict();
+    return {
+        schema,
+        valuesSchema,
+        literalInputSchema: z.toJSONSchema(schema),
+        hasLiteralInputs: Object.keys(fields).length > 0,
+    };
+}

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

@@ -0,0 +1,4 @@
+import type { z } from 'zod';
+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-arguments-schema.js

@@ -0,0 +1,4 @@
+import { createApiArgumentGenerationContract } from './create-api-argument-generation-contract.js';
+export function createApiArgumentsSchema(input) {
+    return createApiArgumentGenerationContract(input).schema;
+}

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>;

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-api-request-schema.d.ts

@@ -0,0 +1,4 @@
+import type { ApiRequestSchemaInput } from '../types/api-arguments.js';
+import type { JsonObject } from '../types/openapi.js';
+/** Full unchanged OAS constraints, unlike the model's partial-value schema. */
+export declare function createApiRequestSchema({ operation, requestMediaType, }: ApiRequestSchemaInput): JsonObject;

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

@@ -0,0 +1,50 @@
+import { bodyMediaSchema, parameterSchema, } from '../arguments/request-contract.js';
+import { createOasValueValidator } from '../openapi/common/create-oas-value-validator.js';
+/** Full unchanged OAS constraints, unlike the model's partial-value schema. */
+export function createApiRequestSchema({ operation, requestMediaType, }) {
+    const properties = {};
+    const dialect = operation.openapiVersion.startsWith('3.0.')
+        ? 'openapi-3.0'
+        : 'draft-2020-12';
+    const required = [];
+    for (const location of ['path', 'query', 'header', 'cookie', 'querystring']) {
+        const parameters = operation.effective.parameters.filter((item) => item.in === location &&
+            !(location === 'header' &&
+                ['accept', 'content-type', 'authorization'].includes(item.name.toLowerCase())));
+        if (!parameters.length)
+            continue;
+        const requiredNames = parameters
+            .filter((item) => item.required === true)
+            .map((item) => item.name);
+        Object.defineProperty(properties, location, {
+            value: {
+                type: 'object',
+                additionalProperties: false,
+                properties: Object.fromEntries(parameters.map((item) => [
+                    item.name,
+                    createOasValueValidator(parameterSchema(item, `${location}.${item.name}`), dialect, `${operation.key.operationRef}/${location}/${item.name}`).schema,
+                ])),
+                required: requiredNames,
+            },
+            enumerable: true,
+        });
+        if (requiredNames.length)
+            required.push(location);
+    }
+    const body = bodyMediaSchema(operation, requestMediaType);
+    if (body !== undefined) {
+        properties.body = createOasValueValidator(body, dialect, `${operation.key.operationRef}/body`).schema;
+        const requestBody = operation.operation.requestBody;
+        if (requestBody &&
+            'required' in requestBody &&
+            requestBody.required === true)
+            required.push('body');
+    }
+    return {
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        type: 'object',
+        properties,
+        required,
+        additionalProperties: false,
+    };
+}

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),
+    };
+}