@openapi-flow/core 0.1.0 → 0.2.0

package/dist/openapi/response/list-api-response-pointers.js

@@ -0,0 +1,30 @@
+import { isObject } from '../../utils/is-object.js';
+import { normalizeOasValueSchema } from '../common/normalize-oas-value-schema.js';
+import { listDeclaredSchemaPointers } from './list-declared-schema-pointers.js';
+/** Describe finite schema declarations, not guaranteed runtime fields or a whitelist. */
+export function listApiResponsePointers(operation) {
+    const catalogs = [];
+    for (const [responseKey, response] of Object.entries(operation.operation.responses ?? {})) {
+        if (!isObject(response) || !isObject(response.content))
+            continue;
+        for (const [mediaType, media] of Object.entries(response.content)) {
+            if (!isObject(media))
+                continue;
+            const schema = media.schema;
+            if (typeof schema !== 'boolean' && !isObject(schema))
+                continue;
+            const normalized = normalizeOasValueSchema(schema, operation.openapiVersion.startsWith('3.0.')
+                ? 'openapi-3.0'
+                : 'draft-2020-12');
+            const catalog = {
+                responseKey,
+                mediaType,
+                declaredPointers: [],
+                dynamicLocations: [],
+            };
+            listDeclaredSchemaPointers(normalized, catalog);
+            catalogs.push(catalog);
+        }
+    }
+    return catalogs;
+}

package/dist/openapi/response/list-declared-schema-pointers.d.ts

@@ -0,0 +1,4 @@
+import type { BindingSchema } from '../../types/api-bindings.js';
+import type { ApiResponsePointerCatalog } from '../../types/api-response-pointers.js';
+/** Visit schema-valued declarations only; never invent a dictionary key or item index. */
+export declare function listDeclaredSchemaPointers(schema: BindingSchema, catalog: ApiResponsePointerCatalog): void;

package/dist/openapi/response/list-declared-schema-pointers.js

@@ -0,0 +1,91 @@
+import { isObject } from '../../utils/is-object.js';
+function pointerToken(value) {
+    return value.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+/** Visit schema-valued declarations only; never invent a dictionary key or item index. */
+export function listDeclaredSchemaPointers(schema, catalog) {
+    const active = new Set();
+    function visit(current, pointer, location) {
+        if (current === false)
+            return;
+        function boundary(kind, suffix = '', constraint) {
+            catalog.dynamicLocations.push({
+                pointer,
+                schemaLocation: location + suffix,
+                kind,
+                ...(constraint === undefined ? {} : { constraint }),
+            });
+        }
+        if (active.has(current)) {
+            boundary('recursive-schema');
+            return;
+        }
+        catalog.declaredPointers.push({
+            pointer,
+            schemaLocation: location,
+            ...(typeof current !== 'boolean' &&
+                (typeof current.type === 'string' ||
+                    (Array.isArray(current.type) &&
+                        current.type.every((value) => typeof value === 'string')))
+                ? { type: structuredClone(current.type) }
+                : {}),
+            ...(typeof current !== 'boolean' &&
+                typeof current.description === 'string'
+                ? { description: current.description }
+                : {}),
+        });
+        if (current === true) {
+            boundary('unconstrained');
+            return;
+        }
+        active.add(current);
+        try {
+            for (const keyword of ['$ref', '$dynamicRef'])
+                if (typeof current[keyword] === 'string')
+                    boundary('reference', '/' + keyword, current[keyword]);
+            if (isObject(current.properties))
+                for (const [name, child] of Object.entries(current.properties))
+                    if (typeof child === 'boolean' || isObject(child))
+                        visit(child, pointer + '/' + pointerToken(name), location + '/properties/' + pointerToken(name));
+            const types = Array.isArray(current.type) ? current.type : [current.type];
+            if ((current.type === undefined || types.includes('object')) &&
+                current.additionalProperties !== false)
+                boundary('additional-properties', current.additionalProperties === undefined
+                    ? ''
+                    : '/additionalProperties');
+            if (isObject(current.patternProperties))
+                for (const [pattern, child] of Object.entries(current.patternProperties))
+                    if (child !== false)
+                        boundary('pattern-properties', '/patternProperties/' + pointerToken(pattern), pattern);
+            if (Array.isArray(current.prefixItems))
+                current.prefixItems.forEach((child, index) => {
+                    if (typeof child === 'boolean' || isObject(child))
+                        visit(child, pointer + '/' + index, location + '/prefixItems/' + index);
+                });
+            if ((current.type === undefined || types.includes('array')) &&
+                current.items !== false)
+                boundary('array-items', current.items === undefined ? '' : '/items');
+            for (const keyword of ['allOf', 'anyOf', 'oneOf']) {
+                const branches = current[keyword];
+                if (Array.isArray(branches))
+                    branches.forEach((child, index) => {
+                        if (typeof child === 'boolean' || isObject(child))
+                            visit(child, pointer, location + '/' + keyword + '/' + index);
+                    });
+            }
+            for (const keyword of ['then', 'else']) {
+                const child = current[keyword];
+                if (typeof child === 'boolean' || isObject(child))
+                    visit(child, pointer, location + '/' + keyword);
+            }
+            if (isObject(current.dependentSchemas))
+                for (const [name, child] of Object.entries(current.dependentSchemas))
+                    if (typeof child === 'boolean' || isObject(child))
+                        visit(child, pointer, location + '/dependentSchemas/' + pointerToken(name));
+        }
+        finally {
+            active.delete(current);
+        }
+    }
+    visit(schema, '', '');
+}

package/dist/public-api.d.ts

@@ -1,7 +1,49 @@
-export { operationsFromSpec } from './openapi/parse-spec.js';
-export { validateOpenApi } from './openapi/validate-spec.js';
-export { generateWorkflow } from './planning/generate-workflow.js';
-export { compileSequence } from './workflow/compile-sequence.js';
-export { compileWorkflow } from './workflow/compile-workflow.js';
-export type { Operation, OperationCandidate } from './types/openapi.js';
-export type { CompileRequest, CompileResult, GenerateRequest, ResponseReference, SequencePlan, SequenceRequest, SequenceResult, WorkflowPlan, } from './types/workflow.js';
+export { operationsFromSpec } from './openapi/request/parse-request-operations.js';
+export { inboundOperationsFromSpec } from './openapi/inbound/list-inbound-operations.js';
+export { validateOpenApi } from './openapi/common/validate-spec.js';
+export { UnsupportedOperationError } from './openapi/common/unsupported-operation-error.js';
+export { createApiCatalog } from './openapi/catalog/create-api-catalog.js';
+export { listApiOperations } from './openapi/catalog/list-api-operations.js';
+export { resolveApiOperations } from './openapi/resolve-api-operations.js';
+export type * from './types/api-catalog.js';
+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-arguments.js';
+export { validateApiArguments } from './arguments/validate-api-arguments.js';
+export { listApiRequestMediaTypes } from './arguments/list-api-request-media-types.js';
+export { selectDefaultApiRequestMediaType } from './arguments/select-default-api-request-media-type.js';
+export type * from './types/openapi.js';
+export type * from './types/inbound.js';
+export type * from './types/workflow-plan.js';
+export { validateWorkflowGraphPlan } from './workflow/validate-workflow-graph-plan.js';
+export { createWorkflowGraphPlan } from './workflow/create-workflow-graph-plan.js';
+export type * from './types/api-bindings.js';
+export type * from './types/node-output.js';
+export { createNativeOutputContracts } from './workflow/create-native-output-contracts.js';
+export { createReviewableNodeContracts } from './workflow/create-reviewable-node-contracts.js';
+export { validateWorkflowEdges } from './workflow/validate-workflow-edges.js';
+export { validateNativeOutputContracts } from './bindings/validate-native-output-contracts.js';
+export { parseNativeNodeParameters } from './workflow/parse-native-node-parameters.js';
+export { createWorkflowPlanningCapabilities } from './workflow/create-workflow-planning-capabilities.js';
+export { validateNativeApiResponseReferences } from './workflow/validate-native-api-response-references.js';
+export type * from './types/workflow-capability-planning.js';
+export { validateApiBindingPlan } from './bindings/validate-api-binding-plan.js';
+export { materializeApiArguments } from './bindings/materialize-api-arguments.js';
+export { createApiRequestSchema } from './schemas/create-api-request-schema.js';
+export { validateApiBindingAssignments } from './bindings/validate-api-binding-assignments.js';
+export { validateApiBindingGaps } from './bindings/validate-api-binding-gaps.js';
+export type * from './types/reviewable-workflow.js';
+export { createReviewableWorkflowGraphPlan } from './workflow/create-reviewable-workflow-graph-plan.js';
+export { validateReviewableWorkflowGraphPlan } from './workflow/validate-reviewable-workflow-graph-plan.js';
+export { resolveOpenApiSecurity } from './openapi/common/resolve-openapi-security.js';
+export type * from './types/security.js';
+export { createApiResponseSchema } from './openapi/response/create-api-response-schema.js';
+export { apiResponseValidationValue } from './openapi/response/api-response-validation-value.js';
+export type * from './types/api-response.js';
+export { createResponseArrayItemSchema } from './openapi/response/create-response-array-item-schema.js';
+export { createNativeArrayItemSchema } from './bindings/create-native-array-item-schema.js';
+export { createResponseValueSchema } from './openapi/response/create-response-value-schema.js';
+export { listApiResponsePointers } from './openapi/response/list-api-response-pointers.js';
+export type * from './types/api-response-pointers.js';

package/dist/public-api.js

@@ -1,5 +1,35 @@
-export { operationsFromSpec } from './openapi/parse-spec.js';
-export { validateOpenApi } from './openapi/validate-spec.js';
-export { generateWorkflow } from './planning/generate-workflow.js';
-export { compileSequence } from './workflow/compile-sequence.js';
-export { compileWorkflow } from './workflow/compile-workflow.js';
+export { operationsFromSpec } from './openapi/request/parse-request-operations.js';
+export { inboundOperationsFromSpec } from './openapi/inbound/list-inbound-operations.js';
+export { validateOpenApi } from './openapi/common/validate-spec.js';
+export { UnsupportedOperationError } from './openapi/common/unsupported-operation-error.js';
+export { createApiCatalog } from './openapi/catalog/create-api-catalog.js';
+export { listApiOperations } from './openapi/catalog/list-api-operations.js';
+export { resolveApiOperations } from './openapi/resolve-api-operations.js';
+export { createApiArgumentsSchema } from './schemas/create-api-arguments-schema.js';
+export { createApiArgumentGenerationContract } from './schemas/create-api-argument-generation-contract.js';
+export { validateApiArguments } from './arguments/validate-api-arguments.js';
+export { listApiRequestMediaTypes } from './arguments/list-api-request-media-types.js';
+export { selectDefaultApiRequestMediaType } from './arguments/select-default-api-request-media-type.js';
+export { validateWorkflowGraphPlan } from './workflow/validate-workflow-graph-plan.js';
+export { createWorkflowGraphPlan } from './workflow/create-workflow-graph-plan.js';
+export { createNativeOutputContracts } from './workflow/create-native-output-contracts.js';
+export { createReviewableNodeContracts } from './workflow/create-reviewable-node-contracts.js';
+export { validateWorkflowEdges } from './workflow/validate-workflow-edges.js';
+export { validateNativeOutputContracts } from './bindings/validate-native-output-contracts.js';
+export { parseNativeNodeParameters } from './workflow/parse-native-node-parameters.js';
+export { createWorkflowPlanningCapabilities } from './workflow/create-workflow-planning-capabilities.js';
+export { validateNativeApiResponseReferences } from './workflow/validate-native-api-response-references.js';
+export { validateApiBindingPlan } from './bindings/validate-api-binding-plan.js';
+export { materializeApiArguments } from './bindings/materialize-api-arguments.js';
+export { createApiRequestSchema } from './schemas/create-api-request-schema.js';
+export { validateApiBindingAssignments } from './bindings/validate-api-binding-assignments.js';
+export { validateApiBindingGaps } from './bindings/validate-api-binding-gaps.js';
+export { createReviewableWorkflowGraphPlan } from './workflow/create-reviewable-workflow-graph-plan.js';
+export { validateReviewableWorkflowGraphPlan } from './workflow/validate-reviewable-workflow-graph-plan.js';
+export { resolveOpenApiSecurity } from './openapi/common/resolve-openapi-security.js';
+export { createApiResponseSchema } from './openapi/response/create-api-response-schema.js';
+export { apiResponseValidationValue } from './openapi/response/api-response-validation-value.js';
+export { createResponseArrayItemSchema } from './openapi/response/create-response-array-item-schema.js';
+export { createNativeArrayItemSchema } from './bindings/create-native-array-item-schema.js';
+export { createResponseValueSchema } from './openapi/response/create-response-value-schema.js';
+export { listApiResponsePointers } from './openapi/response/list-api-response-pointers.js';

package/dist/runtime-api.d.ts

@@ -0,0 +1,6 @@
+export { materializeApiArguments } from './bindings/materialize-api-arguments.js';
+export * from './openapi/request/serialize-parameter.js';
+export { serializeFormBody } from './openapi/request/serialize-form-body.js';
+export { UnsupportedOperationError } from './openapi/common/unsupported-operation-error.js';
+export { apiResponseValidationValue } from './openapi/response/api-response-validation-value.js';
+export { pointerValue } from './bindings/json-pointer.js';

package/dist/runtime-api.js

@@ -0,0 +1,7 @@
+// Execution-only entrypoint: excludes catalog hashing and document intake.
+export { materializeApiArguments } from './bindings/materialize-api-arguments.js';
+export * from './openapi/request/serialize-parameter.js';
+export { serializeFormBody } from './openapi/request/serialize-form-body.js';
+export { UnsupportedOperationError } from './openapi/common/unsupported-operation-error.js';
+export { apiResponseValidationValue } from './openapi/response/api-response-validation-value.js';
+export { pointerValue } from './bindings/json-pointer.js';

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

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

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

@@ -0,0 +1,72 @@
+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';
+/** The OAS-derived schema decides whether the model has any values to propose. */
+export function createApiArgumentGenerationContract({ operation, bindings, requestMediaType, }) {
+    if (!Array.isArray(bindings))
+        throw new Error('arguments.bindings must be an array');
+    validateApiArguments({ operation, bindings, requestMediaType, values: {} });
+    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 (bindings.some((binding) => binding.targetPointer === pointer))
+            continue;
+        const projection = projectLiteralInputSchema(optionalRequestProperties(parameterSchema(parameter, pointer)), bindings
+            .filter((entry) => entry.targetPointer.startsWith(pointer + '/'))
+            .map((entry) => pointerTokens(entry.targetPointer).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 &&
+        !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 (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 schema = z
+        .object({
+        values: z.object(fields).strict(),
+    })
+        .strict();
+    return {
+        schema,
+        literalInputSchema: z.toJSONSchema(schema),
+        hasLiteralInputs: Object.keys(fields).length > 0,
+    };
+}

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

@@ -0,0 +1,3 @@
+import type { z } from 'zod';
+import type { ApiArgumentProposal, ApiArgumentsSchemaInput } from '../types/api-arguments.js';
+export declare function createApiArgumentsSchema(input: ApiArgumentsSchemaInput): 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-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-oas-value-schema.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import type { JsonValue } from '../types/api-arguments.js';
+import type { OasValueSchema } from '../types/oas-value-validation.js';
+import type { SchemaDialect } from '../types/schema-dialect.js';
+/** Keep OAS assertions intact instead of round-tripping through Zod types. */
+export declare function createOasValueSchema(input: OasValueSchema, dialect: SchemaDialect, source: string): z.ZodType<JsonValue>;

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

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

package/dist/schemas/operation-plan-schema.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import type { Operation } from '../types/request.js';
+export declare function optionalRequestProperties(schema: unknown): unknown;
+export declare function createOperationPlanSchema(operation: Operation, openapiVersion: string, requestMediaType?: string): z.ZodObject<{
+    inputs: z.ZodObject<{
+        body?: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>> | undefined;
+    }, z.core.$strict>;
+}, z.core.$strict>;

package/dist/schemas/operation-plan-schema.js

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+import { isObject } from '../utils/is-object.js';
+import { createOasValueSchema } from './create-oas-value-schema.js';
+function parameterGroup(parameters, location, dialect) {
+    const fields = parameters
+        .filter((parameter) => parameter.in === location)
+        .map((parameter) => [
+        parameter.name,
+        createOasValueSchema(optionalRequestProperties(parameter.schema), dialect, `${location}.${parameter.name}`)
+            .describe(`Value explicitly stated for ${location} parameter ${parameter.name}`)
+            .optional(),
+    ]);
+    if (fields.length === 0)
+        return undefined;
+    return z.object(Object.fromEntries(fields)).strict().optional();
+}
+// The model may omit values absent from the scenario. The compiler still checks
+// the unchanged OAS schema and reports missing required request values.
+export function optionalRequestProperties(schema) {
+    if (!isObject(schema))
+        return schema;
+    const result = { ...schema };
+    delete result.required;
+    delete result.default;
+    for (const key of [
+        'properties',
+        'patternProperties',
+        '$defs',
+        'definitions',
+        'dependentSchemas',
+    ]) {
+        if (!isObject(result[key]))
+            continue;
+        result[key] = Object.fromEntries(Object.entries(result[key]).map(([name, value]) => [
+            name,
+            optionalRequestProperties(value),
+        ]));
+    }
+    for (const key of [
+        'items',
+        'additionalProperties',
+        'not',
+        'if',
+        'then',
+        'else',
+        'contains',
+        'unevaluatedProperties',
+        'propertyNames',
+    ]) {
+        if (result[key] !== undefined)
+            result[key] = optionalRequestProperties(result[key]);
+    }
+    for (const key of ['allOf', 'anyOf', 'oneOf', 'prefixItems']) {
+        if (Array.isArray(result[key]))
+            result[key] = result[key].map(optionalRequestProperties);
+    }
+    return result;
+}
+function requestBodySchema(operation, dialect, requestMediaType) {
+    if (!operation.body)
+        return undefined;
+    const mediaTypes = Object.entries(operation.body.mediaTypes).filter(([mediaType]) => requestMediaType === undefined || mediaType === requestMediaType);
+    if (requestMediaType !== undefined && mediaTypes.length === 0)
+        throw new Error(`operationRef ${operation.operationRef}.requestBody has no media type ${requestMediaType}`);
+    if (mediaTypes.length === 0)
+        throw new Error(`operationRef ${operation.operationRef}.requestBody.content has no media types`);
+    const schemas = mediaTypes.map(([mediaType, media]) => media.schema === undefined
+        ? z.json()
+        : createOasValueSchema(optionalRequestProperties(media.schema), dialect, `operationRef ${operation.operationRef}.requestBody.${mediaType}.schema`));
+    const body = schemas
+        .slice(1)
+        .reduce((combined, schema) => z.union([combined, schema]), schemas[0]);
+    return body
+        .describe('Request body values explicitly stated in the scenario')
+        .optional();
+}
+export function createOperationPlanSchema(operation, openapiVersion, requestMediaType) {
+    let dialect;
+    if (openapiVersion.startsWith('3.0.'))
+        dialect = 'openapi-3.0';
+    else if (openapiVersion.startsWith('3.1.') ||
+        openapiVersion.startsWith('3.2.'))
+        dialect = 'draft-2020-12';
+    else
+        throw new Error(`spec.openapi is not a supported OAS version: ${openapiVersion}`);
+    const groups = Object.fromEntries(['path', 'query', 'header', 'cookie']
+        .map((location) => [
+        location,
+        parameterGroup(operation.parameters, location, dialect),
+    ])
+        .filter(([, schema]) => schema !== undefined));
+    const body = requestBodySchema(operation, dialect, requestMediaType);
+    return z
+        .object({
+        inputs: z.object({ ...groups, ...(body ? { body } : {}) }).strict(),
+    })
+        .strict()
+        .describe('Only request values explicitly stated in the scenario');
+}

package/dist/schemas/project-literal-array-schema.d.ts

@@ -0,0 +1,4 @@
+import type { LiteralInputProjection } from '../types/api-argument-generation.js';
+import type { JsonObject } from '../types/openapi.js';
+/** Project specific array positions, never every item because one index is bound. */
+export declare function projectLiteralArraySchema(schema: JsonObject, targets: string[][], source: string): LiteralInputProjection;

package/dist/schemas/project-literal-array-schema.js

@@ -0,0 +1,55 @@
+import { isObject } from '../utils/is-object.js';
+import { projectLiteralInputSchema } from './project-literal-input-schema.js';
+/** Project specific array positions, never every item because one index is bound. */
+export function projectLiteralArraySchema(schema, targets, source) {
+    const prefix = [];
+    const original = Array.isArray(schema.prefixItems)
+        ? schema.prefixItems
+        : Array.isArray(schema.items)
+            ? schema.items
+            : [];
+    for (const child of original) {
+        if (typeof child !== 'boolean' && !isObject(child))
+            throw new Error(`${source}.prefixItems must contain schemas`);
+        prefix.push(child);
+    }
+    const rawRest = Array.isArray(schema.items)
+        ? schema.additionalItems
+        : schema.items;
+    if (rawRest !== undefined &&
+        typeof rawRest !== 'boolean' &&
+        !isObject(rawRest))
+        throw new Error(`${source}.items must be a schema`);
+    const rest = rawRest === undefined ? true : rawRest;
+    const availability = prefix.map((child) => child !== false);
+    let limit = typeof schema.maxItems === 'number' ? schema.maxItems : Infinity;
+    for (const token of new Set(targets.map(([index]) => index))) {
+        if (!/^(0|[1-9][0-9]*)$/.test(token) ||
+            !Number.isSafeInteger(Number(token)))
+            throw new Error(`${source}/${token}: binding requires an array index`);
+        const index = Number(token);
+        while (prefix.length <= index) {
+            prefix.push(structuredClone(rest));
+            availability.push(rest !== false);
+        }
+        const projected = projectLiteralInputSchema(prefix[index], targets.filter(([key]) => key === token).map((tokens) => tokens.slice(1)), `${source}/${token}`);
+        prefix[index] = projected.schema;
+        availability[index] = projected.hasLiteralValues;
+        // JSON literals cannot leave a hole for a fully bound element.
+        if (projected.schema === false)
+            limit = Math.min(limit, index);
+    }
+    schema.prefixItems = prefix;
+    schema.items = rest;
+    delete schema.additionalItems;
+    if (Number.isFinite(limit))
+        schema.maxItems = limit;
+    if (typeof schema.minItems === 'number' &&
+        targets.some(([index]) => Number(index) + 1 >= Number(schema.minItems)))
+        schema.minItems = 0;
+    return {
+        schema,
+        hasLiteralValues: availability.slice(0, limit).some(Boolean) ||
+            (rest !== false && prefix.length < limit),
+    };
+}

package/dist/schemas/project-literal-input-schema.d.ts

@@ -0,0 +1,3 @@
+import type { LiteralInputProjection, LiteralInputSchema } from '../types/api-argument-generation.js';
+/** Bound fields do not belong in the model's literal-value output schema. */
+export declare function projectLiteralInputSchema(input: LiteralInputSchema, targets: string[][], source: string): LiteralInputProjection;