@openapi-flow/core 0.1.0 → 0.3.0

package/dist/schemas/create-native-runtime-parameters-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { WorkflowCapability } from '../types/workflow-plan.js';
+/** Official conversion; do not silently discard executable refinements or transforms. */
+export declare function createNativeRuntimeParametersSchema(capability: WorkflowCapability): z.core.ZodStandardJSONSchemaPayload<z.ZodType<import("../public-api.js").JsonValueObject, unknown, z.core.$ZodTypeInternals<import("../public-api.js").JsonValueObject, unknown>>>;

package/dist/schemas/create-native-runtime-parameters-schema.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+/** Official conversion; do not silently discard executable refinements or transforms. */
+export function createNativeRuntimeParametersSchema(capability) {
+    return z.toJSONSchema(capability.parametersSchema, {
+        io: 'output',
+        override(context) {
+            const definition = context.zodSchema._zod.def;
+            if (['pipe', 'transform', 'custom', 'catch'].includes(definition.type))
+                throw new Error(`Native runtime parameters ${capability.name} cannot serialize ${definition.type} validation`);
+            for (const check of definition.checks ?? []) {
+                const kind = check._zod.def.check;
+                if (![
+                    'less_than',
+                    'greater_than',
+                    'multiple_of',
+                    'number_format',
+                    'min_length',
+                    'max_length',
+                    'length_equals',
+                    'string_format',
+                ].includes(kind))
+                    throw new Error(`Native runtime parameters ${capability.name} cannot serialize check ${kind}`);
+            }
+        },
+    });
+}

package/dist/schemas/create-oas-value-schema.d.ts

@@ -0,0 +1,6 @@
+import type { 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,7 @@
+import { createOasValueValidator } from '../openapi/common/create-oas-value-validator.js';
+import { createOasValueValidationSchema } from './create-oas-value-validation-schema.js';
+/** Keep OAS assertions intact instead of round-tripping through Zod types. */
+export function createOasValueSchema(input, dialect, source) {
+    const contract = createOasValueValidator(input, dialect, source);
+    return createOasValueValidationSchema(contract, source).meta(contract.schema);
+}

package/dist/schemas/create-oas-value-validation-schema.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { JsonValue } from '../types/api-arguments.js';
+import type { OasValueValidator } from '../types/oas-value-validation.js';
+/** Runtime validation only; the owning composition supplies its wire metadata. */
+export declare function createOasValueValidationSchema(contract: OasValueValidator, source: string): z.ZodType<JsonValue>;

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

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+/** Runtime validation only; the owning composition supplies its wire metadata. */
+export function createOasValueValidationSchema(contract, 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;
+        }
+        for (const error of contract.validate(value).errors)
+            context.addIssue({
+                code: 'custom',
+                message: `${source} does not match the OAS schema: ${error.message}`,
+            });
+    });
+}

package/dist/schemas/create-workflow-draft-api-binding-question-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { JsonObject } from '../types/openapi.js';
+import type { ProposedWorkflowDraftApiBindingQuestion } from '../types/workflow-draft-api-binding-clarification.js';
+export declare function createWorkflowDraftApiBindingQuestionSchema(requestSchema: JsonObject, sourceIds: string[], targets?: string[]): z.ZodType<ProposedWorkflowDraftApiBindingQuestion>;

package/dist/schemas/create-workflow-draft-api-binding-question-schema.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+import { createApiRequestInputPointerSchema } from './create-api-request-input-pointer-schema.js';
+export function createWorkflowDraftApiBindingQuestionSchema(requestSchema, sourceIds, targets) {
+    const targetPointer = targets === undefined
+        ? createApiRequestInputPointerSchema(requestSchema)
+        : targets.length
+            ? z.enum(targets)
+            : z.never();
+    const intent = z.strictObject({
+        kind: z.literal('binding-intent'),
+        targetPointer,
+    });
+    if (!sourceIds.length)
+        return intent;
+    return z.union([
+        intent,
+        z.strictObject({
+            kind: z.literal('choose-source'),
+            targetPointer,
+            candidates: z
+                .array(z.strictObject({
+                sourceNodeId: z.enum(sourceIds),
+                sourcePointer: z
+                    .string()
+                    .describe('Exact supplied response-body/native output pointer. Each candidate must be compatible with this target input.'),
+            }))
+                .min(1),
+        }),
+    ]);
+}

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

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { WorkflowDraftApiInputEditContractInput, WorkflowDraftApiInputEditValuesSchema } from '../types/workflow-draft-api-input-edit.js';
+import type { WorkflowMessageEvidence } from '../types/planning-evidence.js';
+/** Only selected set-values are model-owned; per-field OAS assertions stay intact. */
+export declare function createWorkflowDraftApiInputEditValuesSchema(input: WorkflowDraftApiInputEditContractInput, messageSchema?: z.ZodType<WorkflowMessageEvidence>): WorkflowDraftApiInputEditValuesSchema;

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

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { validateWorkflowDraftApiInputEditContract } from '../draft/edits/inputs/validate-workflow-draft-api-input-edit-contract.js';
+import { createWorkflowDraftEditMessageFields } from './workflow-draft-edit-message-fields.js';
+import { createOasValueValidator } from '../openapi/common/create-oas-value-validator.js';
+import { createOasValueValidationSchema } from './create-oas-value-validation-schema.js';
+import { createSchemaResourceContext } from '../bindings/resources/create-schema-resource-context.js';
+import { apiInputLiteralSourceSchema } from './api-input-literal-source-schema.js';
+function targetValueSchema(target, resources, nodeId, projection) {
+    if (target.kind !== 'set')
+        throw new Error(`API input edit set target ${target.pointer} has no OAS schema`);
+    const assertions = typeof target.schema === 'boolean'
+        ? target.schema
+            ? {}
+            : { not: {} }
+        : target.schema;
+    const source = `API input edit ${nodeId}${target.pointer}`;
+    const wireAssertions = typeof projection === 'boolean'
+        ? projection
+            ? {}
+            : { not: {} }
+        : projection;
+    return createOasValueValidationSchema(createOasValueValidator({ ...assertions, $defs: { resource: resources.root } }, 'draft-2020-12', source), source).meta(typeof wireAssertions.$ref === 'string'
+        ? wireAssertions
+        : {
+            ...wireAssertions,
+            description: 'The complete actual value explicitly supplied by the current user request. Preserve its type. No examples, defaults, old field values or invented placeholders.',
+        });
+}
+/** Only selected set-values are model-owned; per-field OAS assertions stay intact. */
+export function createWorkflowDraftApiInputEditValuesSchema(input, messageSchema) {
+    validateWorkflowDraftApiInputEditContract(input);
+    const evidence = createWorkflowDraftEditMessageFields(input.requestMessageIds, input.plan.options.includeExplanations, messageSchema);
+    const resources = createSchemaResourceContext(input.contract.schemaResource);
+    const wire = resources.bundleStaticProjections(Object.fromEntries(input.contract.targets
+        .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) => [
+            target.id,
+            z.union([
+                z.strictObject({
+                    status: z.literal('provided'),
+                    value: targetValueSchema(target, resources, input.contract.nodeId, wire.projections[target.id]),
+                    source: apiInputLiteralSourceSchema.extend({
+                        messageId: z.enum(input.requestMessageIds),
+                    }),
+                    ...evidence.fields,
+                }),
+                z.strictObject({
+                    status: z.literal('needs-input'),
+                    ...evidence.fields,
+                }),
+            ]),
+        ]))),
+    })
+        .meta({
+        $defs: wire.definitions,
+    });
+}

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

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { WorkflowDraftClarificationScopeInput, WorkflowDraftClarificationScopeProposal } from '../types/workflow-draft-clarification.js';
+import type { WorkflowMessageEvidence } from '../types/planning-evidence.js';
+/** Known requirement IDs are object keys; the model chooses only scope and optional user-facing evidence. */
+export declare function createWorkflowDraftClarificationScopeSchema(input: WorkflowDraftClarificationScopeInput, messageSchema?: z.ZodType<WorkflowMessageEvidence>): z.ZodType<WorkflowDraftClarificationScopeProposal>;

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

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { describeWorkflowDraftClarificationScopes } from '../draft/requirements/describe-workflow-draft-clarification-scopes.js';
+import { workflowMessageEvidenceSchema } from './planning-evidence-schema.js';
+import { createWorkflowDraftSelectedScopeSchema } from './create-workflow-draft-selected-scope-schema.js';
+/** Known requirement IDs are object keys; the model chooses only scope and optional user-facing evidence. */
+export function createWorkflowDraftClarificationScopeSchema(input, messageSchema = workflowMessageEvidenceSchema) {
+    const description = describeWorkflowDraftClarificationScopes(input);
+    const nodeIds = description.nodes.map((node) => node.id);
+    const scope = createWorkflowDraftSelectedScopeSchema(nodeIds);
+    const decision = (question) => z.strictObject({
+        scope: question
+            ? z.union([
+                scope,
+                z.strictObject({ kind: z.literal('unselected-work') }),
+            ])
+            : scope,
+        ...(description.includeExplanations
+            ? {
+                explanation: z.strictObject({
+                    reason: z.string().min(1),
+                    evidence: z.array(messageSchema).min(1),
+                }),
+            }
+            : {}),
+    });
+    return z.strictObject({
+        scopes: z.strictObject(Object.fromEntries(description.requirements.map((requirement) => [
+            requirement.id,
+            decision(requirement.origin?.kind === 'clarification-question'),
+        ]))),
+    });
+}

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

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { ResolvedWorkflowDraftEditOptions, WorkflowDraftEditProposal, WorkflowDraftEditSchemaSources } from '../types/workflow-draft-edit.js';
+/** Identical decision vocabulary, specialized to canonical or model candidate references. */
+export declare function createWorkflowDraftEditProposalSchema<Operation, Evidence>(options: ResolvedWorkflowDraftEditOptions, sources: WorkflowDraftEditSchemaSources<Operation, Evidence>): z.ZodType<WorkflowDraftEditProposal<Operation, Evidence>>;

package/dist/schemas/create-workflow-draft-edit-proposal-schema.js

@@ -0,0 +1,148 @@
+import { z } from 'zod';
+import { workflowDraftClarificationPlanningStageSchema } from './workflow-draft-clarification-planning-stage-schema.js';
+import { createWorkflowDraftCapabilityGapFindingSchema } from './workflow-draft-capability-gap-schema.js';
+/** Identical decision vocabulary, specialized to canonical or model candidate references. */
+export function createWorkflowDraftEditProposalSchema(options, sources) {
+    const explanation = z.strictObject({
+        reason: z
+            .string()
+            .min(1)
+            .describe('A short user-facing reason, not chain-of-thought.'),
+        evidence: z.array(sources.evidenceSchema).min(1),
+    });
+    const fields = {
+        instruction: z
+            .string()
+            .min(1)
+            .describe('The specific requested change or distinct role of an added instance. Do not invent literal values, bindings, settings or connections here.'),
+        sources: z
+            .array(sources.messageSchema)
+            .min(1)
+            .describe('Provenance from current edit-request messages using the supplied evidence contract, not old requirements that were already accepted.'),
+        ...(options.includeExplanations
+            ? {
+                explanation,
+            }
+            : {}),
+    };
+    const ids = [
+        ...sources.apiNodeIds,
+        ...sources.nativeNodeIds,
+        ...(sources.gapNodeIds === undefined ? [] : sources.gapNodeIds),
+    ];
+    const scope = z.union([
+        z.strictObject({ kind: z.literal('workflow') }),
+        ...(ids.length
+            ? [
+                z.strictObject({
+                    kind: z.literal('nodes'),
+                    nodeIds: z.array(z.enum(ids)).min(1),
+                }),
+            ]
+            : []),
+    ]);
+    const decisions = [
+        z.strictObject({
+            kind: z.literal('report-capability-gap'),
+            finding: createWorkflowDraftCapabilityGapFindingSchema(sources.operationSchema).describe('An explicitly requested role that supplied OAS/native contracts cannot fulfill. This creates a structural unresolved node, not an API, schema, fabricated response or permission to substitute another task.'),
+            ...fields,
+        }),
+        z.strictObject({
+            kind: z.literal('needs-clarification'),
+            owner: z
+                .union([
+                z
+                    .strictObject({ kind: z.literal('semantic'), scope })
+                    .describe('A consequential unresolved meaning/selection choice not owned by a selected planning step. Only this owner creates a new blocking semantic requirement.'),
+                z
+                    .strictObject({
+                    kind: z.literal('planning-step'),
+                    stage: workflowDraftClarificationPlanningStageSchema.describe('The exact question-owning stage of the referenced decision: API literals use api-arguments; replacement requirement fields use requirements. Do not replay input questions as connection questions.'),
+                    decisionIndex: z
+                        .number()
+                        .int()
+                        .min(0)
+                        .max(Number.MAX_SAFE_INTEGER)
+                        .describe('Zero-based position of the actual value, requirement or connection planning decision in this same decisions array. Not a node ID or another clarification.'),
+                })
+                    .describe('The identified planning step owns this concern and its typed questions; do not also create a semantic/workflow blocker for it.'),
+            ])
+                .describe('Declare the real question owner. API inputs, native settings, connection details and typed requirement replacement fields belong to their selected planning decision, not a generic semantic blocker.'),
+            ...fields,
+        }),
+    ];
+    if (sources.operationSchema) {
+        decisions.push(z.strictObject({
+            kind: z.literal('add-api-call'),
+            operation: sources.operationSchema,
+            ...fields,
+        }));
+        if (sources.apiNodeIds.length)
+            decisions.push(z.strictObject({
+                kind: z.literal('replace-api-operation'),
+                nodeId: z.enum(sources.apiNodeIds),
+                operation: sources.operationSchema,
+                ...fields,
+            }));
+    }
+    if (sources.capabilityNames.length)
+        decisions.push(z.strictObject({
+            kind: z.literal('add-native-node'),
+            capability: z.enum(sources.capabilityNames),
+            ...fields,
+        }));
+    if (sources.apiNodeIds.length)
+        for (const kind of ['revise-api-inputs', 'revise-api-bindings'])
+            decisions.push(z.strictObject({
+                kind: z.literal(kind),
+                nodeId: z.enum(sources.apiNodeIds),
+                ...fields,
+            }));
+    if (sources.nativeNodeIds.length)
+        decisions.push(z.strictObject({
+            kind: z.literal('revise-native-node'),
+            nodeId: z.enum(sources.nativeNodeIds),
+            ...fields,
+        }));
+    if (ids.length)
+        decisions.push(z
+            .strictObject({
+            kind: z.literal('remove-node'),
+            nodeId: z.enum(ids),
+            ...fields,
+        })
+            .describe('Explicitly withdraw this existing instance. Code records and removes its incident control edges; other nodes and replacement routes require separate justified decisions.'), z.strictObject({
+            kind: z.literal('revise-connections'),
+            nodeIds: z.array(z.enum(ids)).min(1),
+            ...fields,
+        }));
+    if (sources.requirementIds.length)
+        for (const kind of ['revise-requirement', 'remove-requirement'])
+            decisions.push(z.strictObject({
+                kind: z.literal(kind),
+                requirementId: z.enum(sources.requirementIds),
+                ...fields,
+            }));
+    if (sources.removedRequirementIds.length)
+        decisions.push(z.strictObject({
+            kind: z.literal('restore-requirement'),
+            requirementId: z
+                .enum(sources.removedRequirementIds)
+                .describe('A currently removed requirement explicitly requested for restoration. Historical text/state/scope are reference only; a separate typed human answer supplies replacement fields.'),
+            ...fields,
+        }));
+    // Conditional field omission loses generic inference in Zod's object output;
+    // this boundary names the same runtime-validated decision contract.
+    return z.strictObject({
+        decisions: z.union([
+            z
+                .array(z.strictObject({ kind: z.literal('no-change'), ...fields }))
+                .length(1)
+                .describe('Exactly one no-change decision for the entire request; never combine it with edits or concerns about selected work.'),
+            z
+                .array(z.union(decisions))
+                .min(1)
+                .describe('Actual edits and explicitly owned concerns. Unchanged sibling nodes are preserved by code; do not append a no-change decision for them.'),
+        ]),
+    });
+}

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

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { WorkflowDraftNativeParameterEditContractInput, WorkflowDraftNativeParameterEditValues } from '../types/workflow-draft-native-parameter-edit.js';
+import type { WorkflowMessageEvidence } from '../types/planning-evidence.js';
+export declare function createWorkflowDraftNativeParameterEditValuesSchema(input: WorkflowDraftNativeParameterEditContractInput, messageSchema?: z.ZodType<WorkflowMessageEvidence>): z.ZodType<WorkflowDraftNativeParameterEditValues>;

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