@openapi-flow/core 0.2.0 → 0.3.0

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

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { validateWorkflowDraftNativeParameterEditContract } from '../draft/edits/native/validate-workflow-draft-native-parameter-edit-contract.js';
+import { createWorkflowDraftEditMessageFields } from './workflow-draft-edit-message-fields.js';
+import { createJsonSchemaValueSchema } from './create-json-schema-value-schema.js';
+import { createSchemaResourceContext } from '../bindings/resources/create-schema-resource-context.js';
+export function createWorkflowDraftNativeParameterEditValuesSchema(input, messageSchema) {
+    validateWorkflowDraftNativeParameterEditContract(input);
+    const evidence = createWorkflowDraftEditMessageFields(input.requestMessageIds, input.plan.options.includeExplanations, messageSchema);
+    const fields = {
+        sources: z.array(evidence.message).min(1),
+        ...evidence.fields,
+    };
+    const resources = createSchemaResourceContext(input.contract.schemaResource);
+    const wire = resources.bundleStaticProjections(Object.fromEntries(input.contract.targets
+        .filter((target) => target.kind === 'set')
+        .map((target) => [target.id, target.schema])));
+    return z
+        .strictObject({
+        values: z.strictObject(Object.fromEntries(input.contract.targets
+            .filter((target) => target.kind === 'set')
+            .map((target) => {
+            const assertions = typeof target.schema === 'boolean'
+                ? target.schema
+                    ? {}
+                    : { not: {} }
+                : target.schema;
+            const projected = wire.projections[target.id];
+            const wireAssertions = typeof projected === 'boolean'
+                ? projected
+                    ? {}
+                    : { not: {} }
+                : projected;
+            const value = createJsonSchemaValueSchema({
+                ...assertions,
+                $defs: { resource: input.contract.schemaResource },
+            }, `Native parameter ${input.contract.nodeId}${target.pointer}`).meta(typeof wireAssertions.$ref === 'string'
+                ? wireAssertions
+                : {
+                    ...wireAssertions,
+                    description: 'Only this requested parameter value, following the registered native contract. Preserve actual types. Do not output the node, unchanged siblings, inferred literals, code or a workflow.',
+                });
+            return [
+                target.id,
+                z.union([
+                    z.strictObject({
+                        status: z.literal('provided'),
+                        value,
+                        ...fields,
+                    }),
+                    z.strictObject({
+                        status: z.literal('needs-input'),
+                        message: z.string().min(1),
+                        ...fields,
+                    }),
+                ]),
+            ];
+        }))),
+    })
+        .meta({
+        $defs: wire.definitions,
+    });
+}

package/dist/schemas/create-workflow-draft-requirement-answer-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { WorkflowDraftRequirementEditDescription, WorkflowDraftRequirementAnswer } from '../types/workflow-draft-requirement-edit.js';
+/** UI schema only; mutation boundaries re-derive selected identities from the original plan. */
+export declare function createWorkflowDraftRequirementAnswerSchema(description: WorkflowDraftRequirementEditDescription): z.ZodType<WorkflowDraftRequirementAnswer>;

package/dist/schemas/create-workflow-draft-requirement-answer-schema.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import { workflowDraftRequirementSchema } from './workflow-draft-schema.js';
+import { planningEvidenceTextSchema } from './planning-evidence-schema.js';
+import { createWorkflowDraftSelectedScopeSchema } from './create-workflow-draft-selected-scope-schema.js';
+/** UI schema only; mutation boundaries re-derive selected identities from the original plan. */
+export function createWorkflowDraftRequirementAnswerSchema(description) {
+    return z.strictObject({
+        answerMessageId: planningEvidenceTextSchema.describe('The explicit submitted human action ID; distinct from existing evidence IDs.'),
+        text: workflowDraftRequirementSchema.shape.text.describe('The requirement statement explicitly confirmed by the human.'),
+        state: workflowDraftRequirementSchema.shape.state.describe('The human-selected confirmation or deferral state; never execution readiness.'),
+        scope: createWorkflowDraftSelectedScopeSchema(description.nodes.map((node) => node.id)).describe('The whole workflow or actual selected API/native identities; pending values do not remove identities.'),
+    });
+}

package/dist/schemas/create-workflow-draft-requirement-history-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { WorkflowDraftRequirement } from '../types/workflow-draft.js';
+import type { WorkflowDraftRequirementHistoryEntry } from '../types/workflow-draft-requirement-history.js';
+export declare function createWorkflowDraftRequirementHistorySchema(requirement: z.ZodType<WorkflowDraftRequirement>): z.ZodType<WorkflowDraftRequirementHistoryEntry>;

package/dist/schemas/create-workflow-draft-requirement-history-schema.js

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export function createWorkflowDraftRequirementHistorySchema(requirement) {
+    const identity = z.string().refine((value) => value.trim().length > 0);
+    const fields = {
+        id: identity,
+        revision: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+        requirementId: identity,
+        previousEntryId: identity.optional(),
+        evidence: z
+            .array(z.strictObject({
+            kind: z.literal('message'),
+            messageId: identity,
+            quote: z.string(),
+        }))
+            .min(1),
+    };
+    return z.discriminatedUnion('kind', [
+        z.strictObject({
+            ...fields,
+            kind: z.literal('created'),
+            after: requirement,
+        }),
+        z.strictObject({
+            ...fields,
+            kind: z.literal('restored'),
+            after: requirement,
+        }),
+        z.strictObject({
+            ...fields,
+            kind: z.literal('revised'),
+            before: requirement,
+            after: requirement,
+        }),
+        z.strictObject({
+            ...fields,
+            kind: z.literal('removed'),
+            before: requirement,
+        }),
+    ]);
+}

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

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { WorkflowDraftScope } from '../types/workflow-draft.js';
+/** Scope identity is shared by clarification and explicit requirement edits, never material readiness. */
+export declare function createWorkflowDraftSelectedScopeSchema(nodeIds: string[]): z.ZodType<WorkflowDraftScope>;

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

@@ -0,0 +1,18 @@
+import { z } from 'zod';
+/** Scope identity is shared by clarification and explicit requirement edits, never material readiness. */
+export function createWorkflowDraftSelectedScopeSchema(nodeIds) {
+    return z.union([
+        z.strictObject({ kind: z.literal('workflow') }),
+        ...(nodeIds.length
+            ? [
+                z.strictObject({
+                    kind: z.literal('nodes'),
+                    nodeIds: z
+                        .array(z.enum(nodeIds))
+                        .min(1)
+                        .refine((ids) => new Set(ids).size === ids.length),
+                }),
+            ]
+            : []),
+    ]);
+}

package/dist/schemas/create-workflow-draft-source-evidence-fields.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import type { WorkflowDraftSourceEvidenceDescription, WorkflowDraftSourceEvidence } from '../types/workflow-draft-source-evidence.js';
+/** The model chooses known sources; code attaches unchanged text and original contract identities. */
+export declare function createWorkflowDraftSourceEvidenceFields(context: WorkflowDraftSourceEvidenceDescription): {
+    explanation?: z.ZodObject<{
+        reason: z.ZodString;
+        evidence: z.ZodArray<z.ZodUnion<z.ZodType<WorkflowDraftSourceEvidence, unknown, z.core.$ZodTypeInternals<WorkflowDraftSourceEvidence, unknown>>[]>>;
+    }, z.core.$strict> | undefined;
+    sourceMessageIds: z.ZodArray<z.ZodEnum<{
+        [x: string]: string;
+    }>>;
+};

package/dist/schemas/create-workflow-draft-source-evidence-fields.js

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+/** The model chooses known sources; code attaches unchanged text and original contract identities. */
+export function createWorkflowDraftSourceEvidenceFields(context) {
+    const metadata = z
+        .strictObject({
+        messageIds: z
+            .array(z.string().min(1))
+            .min(1)
+            .refine((ids) => new Set(ids).size === ids.length),
+        sourceIds: z.array(z.string().min(1)),
+        includeExplanations: z.boolean(),
+    })
+        .parse({
+        messageIds: context.messages.map((message) => message.id),
+        sourceIds: [
+            ...new Set([...context.sources.values, ...context.sources.exclusiveOutputs].map((source) => source.nodeId)),
+        ],
+        includeExplanations: context.includeExplanations,
+    });
+    const sourceMessageIds = z
+        .array(z.enum(metadata.messageIds))
+        .min(1)
+        .refine((ids) => new Set(ids).size === ids.length)
+        .describe('Select current request message IDs only. Code attaches their original text; do not generate quotations.');
+    const choices = [
+        z.strictObject({
+            kind: z.literal('message'),
+            messageId: z.enum(metadata.messageIds),
+        }),
+    ];
+    if (metadata.sourceIds.length)
+        choices.push(z.strictObject({
+            kind: z.literal('source'),
+            nodeId: z
+                .enum(metadata.sourceIds)
+                .describe('A supplied actual source contract. Code attaches its OAS identity/root or native capability; never label schema text as user speech.'),
+        }));
+    return {
+        sourceMessageIds,
+        ...(metadata.includeExplanations
+            ? {
+                explanation: z.strictObject({
+                    reason: z
+                        .string()
+                        .min(1)
+                        .describe('Concise user-facing reason, not chain-of-thought.'),
+                    evidence: z
+                        .array(z.union(choices))
+                        .min(1)
+                        .refine((items) => new Set(items.map((item) => JSON.stringify(item))).size ===
+                        items.length),
+                }),
+            }
+            : {}),
+    };
+}

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

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { ClarificationQuestionLimits, ResolvedWorkflowClarificationOptions, WorkflowRequirementsProposal } from '../types/workflow-clarification.js';
+import type { WorkflowMessageEvidence } from '../types/planning-evidence.js';
+/** Reusable described shape; model references and canonical evidence use different schemas. */
+export declare function createWorkflowRequirementsProposalSchema<Evidence>(configuredLimits: ClarificationQuestionLimits, options: ResolvedWorkflowClarificationOptions, evidenceSchema: z.ZodType<Evidence>, messageEvidenceSchema?: z.ZodType<WorkflowMessageEvidence>): z.ZodType<WorkflowRequirementsProposal<Evidence>>;

package/dist/schemas/create-workflow-requirements-proposal-schema.js

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+import { clarificationQuestionLimitsSchema } from './workflow-clarification-settings-schema.js';
+import { createPlanningEvidenceTextSchema, workflowMessageEvidenceSchema, } from './planning-evidence-schema.js';
+/** Reusable described shape; model references and canonical evidence use different schemas. */
+export function createWorkflowRequirementsProposalSchema(configuredLimits, options, evidenceSchema, messageEvidenceSchema = workflowMessageEvidenceSchema) {
+    const limits = clarificationQuestionLimitsSchema.parse(configuredLimits);
+    const explanation = options.includeExplanations
+        ? {
+            explanation: z.strictObject({
+                reason: createPlanningEvidenceTextSchema().describe('A short user-facing justification, not private chain-of-thought.'),
+                evidence: z
+                    .array(evidenceSchema)
+                    .min(1)
+                    .describe('Only supplied, checkable sources supporting this decision.'),
+            }),
+        }
+        : {};
+    const choices = z
+        .array(z.strictObject({
+        label: createPlanningEvidenceTextSchema().describe('A distinct meaningful alternative the user can explicitly adopt.'),
+        ...explanation,
+    }))
+        .min(1)
+        .max(limits.maxChoicesPerQuestion);
+    // Literal kinds are mutually exclusive, so a union retains the same contract
+    // while exporting the anyOf form accepted by structured-output providers.
+    const answer = z.union([
+        z.strictObject({ kind: z.literal('text') }),
+        z.strictObject({ kind: z.literal('single-choice'), choices }),
+        z.strictObject({ kind: z.literal('multiple-choice'), choices }),
+    ]);
+    return z
+        .strictObject({
+        statements: z.array(z.strictObject({
+            text: createPlanningEvidenceTextSchema().describe('A requirement explicitly supported by the supplied user messages. Do not add inferred related work or business defaults.'),
+            sources: z
+                .array(messageEvidenceSchema)
+                .min(1)
+                .describe('Exact user-message quotations supporting the stated requirement.'),
+            ...explanation,
+        })),
+        categories: z
+            .array(z.strictObject({
+            title: createPlanningEvidenceTextSchema().describe('A request-specific grouping, not a fixed business taxonomy.'),
+            questions: z
+                .array(z.strictObject({
+                message: createPlanningEvidenceTextSchema().describe('Ask only a consequential unresolved semantic choice. Missing concrete runtime values become input slots later, not mandatory questions here.'),
+                answer,
+                ...explanation,
+            }))
+                .min(1)
+                .max(limits.maxQuestionsPerCategory),
+            ...explanation,
+        }))
+            .max(limits.maxCategories)
+            .describe('Return [] when the user intent is sufficiently clear; never create empty categories.'),
+        ...(options.includeSuggestions
+            ? {
+                suggestions: z.array(z.strictObject({
+                    text: createPlanningEvidenceTextSchema().describe('Optional follow-up or related business extension. It is not a confirmed requirement and must not change scope before explicit adoption.'),
+                    ...explanation,
+                })),
+            }
+            : {}),
+    })
+        .superRefine((proposal, context) => {
+        if (proposal.categories.reduce((sum, category) => sum + category.questions.length, 0) > limits.maxQuestionsPerRound)
+            context.addIssue({
+                code: 'custom',
+                path: ['categories'],
+                message: `Question count exceeds maxQuestionsPerRound ${limits.maxQuestionsPerRound}`,
+            });
+        const questionMessages = proposal.categories.flatMap((category) => category.questions.map((question) => question.message));
+        if (new Set(questionMessages).size !== questionMessages.length)
+            context.addIssue({
+                code: 'custom',
+                path: ['categories'],
+                message: 'Questions must be distinct within a round',
+            });
+        for (const [categoryIndex, category] of proposal.categories.entries())
+            for (const [questionIndex, question] of category.questions.entries()) {
+                if (question.answer.kind === 'text')
+                    continue;
+                if (new Set(question.answer.choices.map((choice) => choice.label))
+                    .size !== question.answer.choices.length)
+                    context.addIssue({
+                        code: 'custom',
+                        path: [
+                            'categories',
+                            categoryIndex,
+                            'questions',
+                            questionIndex,
+                            'answer',
+                            'choices',
+                        ],
+                        message: 'Choice labels must be distinct',
+                    });
+            }
+        if (!proposal.statements.length && !questionMessages.length)
+            context.addIssue({
+                code: 'custom',
+                message: 'A requirements analysis must state a user-grounded requirement or ask a question',
+            });
+    });
+}

package/dist/schemas/create-workflow-review-suggestions-proposal-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { WorkflowReviewSuggestionsDescription, WorkflowReviewSuggestionsProposal } from '../types/workflow-review-suggestions.js';
+/** Only user-facing proposed messages and actual source choices are model-owned. */
+export declare function createWorkflowReviewSuggestionsProposalSchema<Evidence>(description: WorkflowReviewSuggestionsDescription, evidenceSchema: z.ZodType<Evidence>): z.ZodType<WorkflowReviewSuggestionsProposal<Evidence>>;

package/dist/schemas/create-workflow-review-suggestions-proposal-schema.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { workflowReviewBoundarySchema, workflowReviewSuggestionLimitsSchema, workflowReviewSuggestionOptionsSchema, } from './workflow-review-suggestion-settings-schema.js';
+/** Only user-facing proposed messages and actual source choices are model-owned. */
+export function createWorkflowReviewSuggestionsProposalSchema(description, evidenceSchema) {
+    workflowReviewBoundarySchema.parse(description.boundary);
+    workflowReviewSuggestionLimitsSchema.parse(description.limits);
+    workflowReviewSuggestionOptionsSchema.parse(description.options);
+    const fields = {
+        text: z
+            .string()
+            .refine((text) => text.trim().length > 0)
+            .describe('A concrete message the user may explicitly adopt. Not a confirmed instruction, a workflow, a value default or a credential.'),
+        sources: z.array(evidenceSchema).min(1),
+        ...(description.options.includeExplanations
+            ? {
+                reason: z
+                    .string()
+                    .min(1)
+                    .describe('Concise user-facing reason and relevance, not private chain-of-thought.'),
+            }
+            : {}),
+    };
+    const choices = [
+        z.strictObject({ kind: z.literal('change-request'), ...fields }),
+    ];
+    if (description.options.includeExtensions)
+        choices.push(z.strictObject({ kind: z.literal('extend-workflow'), ...fields }));
+    if (description.boundary.questions.length)
+        choices.push(z.strictObject({
+            kind: z.literal('answer-question'),
+            questionIds: z
+                .array(z.enum(description.boundary.questions.map((question) => question.id)))
+                .min(1)
+                .refine((ids) => new Set(ids).size === ids.length),
+            ...fields,
+        }));
+    const suggestion = z.union(choices);
+    return z.strictObject({
+        suggestions: z
+            .array(suggestion)
+            .max(description.limits.maxSuggestions)
+            .refine((items) => new Set(items.map((item) => item.text)).size === items.length)
+            .describe('Return only useful grounded options; [] is valid. Never regenerate review identities, questions, facts, approval or readiness.'),
+    });
+}

package/dist/schemas/create-workflow-runtime-inputs-schema.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+import type { WorkflowRuntimeInputSlot } from '../types/native-runtime-inputs.js';
+/** In-process input contract; export each field separately to retain independent resource IDs. */
+export declare function createWorkflowRuntimeInputsSchema(slots: WorkflowRuntimeInputSlot[]): z.ZodObject<{
+    [x: string]: z.ZodType<import("../public-api.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../public-api.js").JsonValue, unknown>>;
+}, z.core.$strict>;

package/dist/schemas/create-workflow-runtime-inputs-schema.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { deferredApiInputSlotsSchema } from './deferred-api-input-schema.js';
+import { nativeRuntimeInputSlotSchema, nativeParameterValuesSchema, } from './native-runtime-input-slot-schema.js';
+import { createOasValueSchema } from './create-oas-value-schema.js';
+import { createApiInputSlotValueSchema } from './create-api-input-slot-value-schema.js';
+/** In-process input contract; export each field separately to retain independent resource IDs. */
+export function createWorkflowRuntimeInputsSchema(slots) {
+    const fields = slots.map((slot) => {
+        if (slot.kind === 'api-request-input') {
+            deferredApiInputSlotsSchema.parse([slot]);
+            return [slot.id, createApiInputSlotValueSchema(slot)];
+        }
+        nativeRuntimeInputSlotSchema.parse(slot);
+        return [
+            slot.id,
+            slot.targetPointer === ''
+                ? z.intersection(nativeParameterValuesSchema, createOasValueSchema(slot.schema, 'draft-2020-12', `inputValues[${slot.id}] for native ${slot.nodeId}`))
+                : createOasValueSchema(slot.schema, 'draft-2020-12', `inputValues[${slot.id}] for native ${slot.nodeId}${slot.targetPointer}`),
+        ];
+    });
+    if (new Set(fields.map(([id]) => id)).size !== fields.length)
+        throw new Error('Workflow input slots require distinct IDs');
+    return z.strictObject(Object.fromEntries(fields));
+}

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

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { DeferredApiInputSlot } from '../types/deferred-api-inputs.js';
+export declare const deferredApiInputSlotSchema: z.ZodType<DeferredApiInputSlot>;
+export declare const deferredApiInputSlotsSchema: z.ZodArray<z.ZodType<DeferredApiInputSlot, unknown, z.core.$ZodTypeInternals<DeferredApiInputSlot, unknown>>>;
+export declare const deferredApiInputValuesSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { apiOperationKeySchema } from './api-operation-key-schema.js';
+import { requestedApiInputsSchema } from './requested-api-inputs-schema.js';
+export const deferredApiInputSlotSchema = z.strictObject({
+    kind: z.literal('api-request-input'),
+    state: z.literal('deferred'),
+    id: z.string().min(1),
+    callId: z.string().refine((value) => value.trim().length > 0),
+    operation: apiOperationKeySchema,
+    targetPointer: z
+        .string()
+        .regex(/^\/(?:[^~]|~[01])*$/u)
+        .min(2),
+    requestedInputs: requestedApiInputsSchema.optional(),
+    schema: z.union([z.boolean(), z.record(z.string(), z.unknown())]),
+    openapiVersion: z.string().min(1),
+    operationSummary: z.string().optional(),
+    parameterDescription: z.string().optional(),
+});
+export const deferredApiInputSlotsSchema = z
+    .array(deferredApiInputSlotSchema)
+    .superRefine((slots, context) => {
+    const ids = new Set();
+    const targets = new Map();
+    for (const [index, slot] of slots.entries()) {
+        const previous = targets.get(slot.callId) ?? [];
+        if (ids.has(slot.id) ||
+            previous.some((target) => target === slot.targetPointer ||
+                target.startsWith(slot.targetPointer + '/') ||
+                slot.targetPointer.startsWith(target + '/')))
+            context.addIssue({
+                code: 'custom',
+                path: [index],
+                message: 'Input slots require distinct IDs and non-overlapping call targets',
+            });
+        ids.add(slot.id);
+        targets.set(slot.callId, [...previous, slot.targetPointer]);
+    }
+});
+export const deferredApiInputValuesSchema = z.record(z.string(), z.json());

package/dist/schemas/draft-change-set-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { DraftChangeSet } from '../types/workflow-draft-changes.js';
+export declare const draftChangeSetSchema: z.ZodType<DraftChangeSet>;

package/dist/schemas/draft-change-set-schema.js

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { workflowDraftCapabilityGapSchema } from './workflow-draft-capability-gap-schema.js';
+import { draftRevisionSchema, workflowDraftApiCallSchema, workflowDraftNativeNodeSchema, workflowDraftEdgeSchema, workflowDraftRequirementSchema, } from './workflow-draft-schema.js';
+export const draftChangeSetSchema = z.strictObject({
+    baseRevision: draftRevisionSchema,
+    changes: z
+        .array(z.discriminatedUnion('kind', [
+        z.strictObject({
+            kind: z.literal('add-capability-gap'),
+            node: workflowDraftCapabilityGapSchema,
+        }),
+        z.strictObject({
+            kind: z.literal('add-api-call'),
+            call: workflowDraftApiCallSchema,
+        }),
+        z.strictObject({
+            kind: z.literal('update-api-call'),
+            call: workflowDraftApiCallSchema,
+        }),
+        z.strictObject({
+            kind: z.literal('add-native-node'),
+            node: workflowDraftNativeNodeSchema,
+        }),
+        z.strictObject({
+            kind: z.literal('update-native-node'),
+            node: workflowDraftNativeNodeSchema,
+        }),
+        z.strictObject({
+            kind: z.literal('remove-node'),
+            nodeId: z.string().min(1),
+        }),
+        z.strictObject({
+            kind: z.literal('add-edge'),
+            edge: workflowDraftEdgeSchema,
+        }),
+        z.strictObject({
+            kind: z.literal('remove-edge'),
+            edge: workflowDraftEdgeSchema,
+        }),
+        z.strictObject({
+            kind: z.literal('set-requirement'),
+            requirement: workflowDraftRequirementSchema,
+        }),
+        z.strictObject({
+            kind: z.literal('remove-requirement'),
+            requirementId: z.string().min(1),
+            sourceMessageIds: z
+                .array(z.string().min(1))
+                .min(1)
+                .refine((ids) => new Set(ids).size === ids.length),
+        }),
+    ]))
+        .min(1),
+});

package/dist/schemas/native-instance-dependencies-schema.d.ts

@@ -0,0 +1,5 @@
+import type { z } from 'zod';
+import type { NativeSelectedPlanningInput } from '../types/native-node-planning.js';
+import type { NativeInstanceDependencyProposal } from '../types/native-instance-dependencies.js';
+/** All row keys and candidates come from the original selection; the model chooses only actual source roles. */
+export declare function createNativeInstanceDependenciesSchema(input: NativeSelectedPlanningInput): z.ZodType<NativeInstanceDependencyProposal>;

package/dist/schemas/native-instance-dependencies-schema.js

@@ -0,0 +1,14 @@
+import { describeNativeInstanceDependencies } from '../workflow/planning/resolve-native-instance-dependencies.js';
+import { createNativeProducerDependenciesSchema } from './native-producer-dependencies-schema.js';
+/** All row keys and candidates come from the original selection; the model chooses only actual source roles. */
+export function createNativeInstanceDependenciesSchema(input) {
+    const context = describeNativeInstanceDependencies(input);
+    return createNativeProducerDependenciesSchema({
+        targets: context.instances.map((instance) => ({
+            nodeId: instance.id,
+            description: `Producer choices for ${instance.capability}: ${instance.purpose}`,
+            sourceNodeIds: context.sourceCandidatesByNodeId[instance.id],
+        })),
+        includeExplanations: input.includeExplanations === true,
+    });
+}

package/dist/schemas/native-instance-planning-schema.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import type { NativeInstanceSelectionInput, NativeInstanceSelectionProposal, NativeNodeConfigurationInput, NativeNodeParameterProposal } from '../types/native-node-planning.js';
+/** User answers are data, not model output and not permission to change the selected role. */
+export declare const nativeNodeConfigurationRepliesSchema: z.ZodArray<z.ZodObject<{
+    question: z.ZodObject<{
+        status: z.ZodLiteral<"needs-clarification">;
+        id: z.ZodString;
+        fingerprint: z.ZodString;
+        nodeId: z.ZodString;
+        message: z.ZodString;
+        proposal: z.ZodObject<{
+            decision: z.ZodObject<{
+                status: z.ZodLiteral<"needs-clarification">;
+                message: z.ZodString;
+                reason: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    text: z.ZodString;
+}, z.core.$strict>>;
+export declare function createNativeInstanceSelectionSchema(input: NativeInstanceSelectionInput): z.ZodType<NativeInstanceSelectionProposal>;
+export declare function createNativeNodeParametersSchema(input: NativeNodeConfigurationInput): z.ZodType<NativeNodeParameterProposal>;