@openapi-flow/core 0.2.0 → 0.3.1

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

@@ -0,0 +1,171 @@
+import { z } from 'zod';
+export declare const workflowDraftValueEditSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"set">;
+    pointer: z.ZodString;
+    value: z.ZodJSONSchema;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"remove">;
+    pointer: z.ZodString;
+}, z.core.$strict>], "kind">;
+export declare const workflowDraftNativeParameterChangeSchema: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"set">;
+    pointer: z.ZodString;
+    value: z.ZodJSONSchema;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"remove">;
+    pointer: z.ZodString;
+}, z.core.$strict>], "kind">, z.ZodObject<{
+    kind: z.ZodLiteral<"defer">;
+    pointer: z.ZodString;
+}, z.core.$strict>]>;
+export declare const workflowDraftBindingEditSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"set">;
+    binding: z.ZodObject<{
+        kind: z.ZodLiteral<"node-output">;
+        targetPointer: z.ZodString;
+        sourceNodeId: z.ZodString;
+        sourcePointer: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"remove">;
+    targetPointer: z.ZodString;
+}, z.core.$strict>], "kind">;
+export declare const workflowDraftEditResolutionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    stepId: z.ZodString;
+    kind: z.ZodLiteral<"api-call">;
+    values: z.ZodObject<{
+        path: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        query: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        header: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        cookie: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        querystring: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        body: z.ZodOptional<z.ZodJSONSchema>;
+    }, z.core.$strict>;
+    requestedInputs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    bindings: z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"node-output">;
+        targetPointer: z.ZodString;
+        sourceNodeId: z.ZodString;
+        sourcePointer: z.ZodString;
+    }, z.core.$strict>>;
+    requestMediaType: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    stepId: z.ZodString;
+    kind: z.ZodLiteral<"api-inputs">;
+    edits: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"set">;
+        pointer: z.ZodString;
+        value: z.ZodJSONSchema;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"remove">;
+        pointer: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    requestMediaType: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    stepId: z.ZodString;
+    kind: z.ZodLiteral<"api-bindings">;
+    edits: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"set">;
+        binding: z.ZodObject<{
+            kind: z.ZodLiteral<"node-output">;
+            targetPointer: z.ZodString;
+            sourceNodeId: z.ZodString;
+            sourcePointer: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"remove">;
+        targetPointer: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+    valueEdits: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"set">;
+        pointer: z.ZodString;
+        value: z.ZodJSONSchema;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"remove">;
+        pointer: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>, z.ZodObject<{
+    stepId: z.ZodString;
+    kind: z.ZodLiteral<"native-literal">;
+    parameters: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+}, z.core.$strict>, z.ZodObject<{
+    stepId: z.ZodString;
+    kind: z.ZodLiteral<"native-mixed">;
+    parameters: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    runtimeParameters: z.ZodObject<{
+        pointers: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    stepId: z.ZodString;
+    kind: z.ZodLiteral<"native-parameters">;
+    edits: z.ZodArray<z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"set">;
+        pointer: z.ZodString;
+        value: z.ZodJSONSchema;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"remove">;
+        pointer: z.ZodString;
+    }, z.core.$strict>], "kind">, z.ZodObject<{
+        kind: z.ZodLiteral<"defer">;
+        pointer: z.ZodString;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>, z.ZodObject<{
+    stepId: z.ZodString;
+    kind: z.ZodLiteral<"native-runtime">;
+}, z.core.$strict>, z.ZodObject<{
+    stepId: z.ZodString;
+    kind: z.ZodLiteral<"requirement">;
+    answerMessageId: z.ZodString;
+    text: z.ZodString;
+    state: z.ZodEnum<{
+        "needs-clarification": "needs-clarification";
+        deferred: "deferred";
+        confirmed: "confirmed";
+    }>;
+    scope: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"workflow">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"nodes">;
+        nodeIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>], "kind">;
+export declare const workflowDraftEditRepairSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    taskId: z.ZodString;
+    kind: z.ZodLiteral<"api-bindings">;
+    edits: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"set">;
+        binding: z.ZodObject<{
+            kind: z.ZodLiteral<"node-output">;
+            targetPointer: z.ZodString;
+            sourceNodeId: z.ZodString;
+            sourcePointer: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"remove">;
+        targetPointer: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>, z.ZodObject<{
+    taskId: z.ZodString;
+    kind: z.ZodLiteral<"native-parameters">;
+    edits: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"set">;
+        pointer: z.ZodString;
+        value: z.ZodJSONSchema;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"remove">;
+        pointer: z.ZodString;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strict>], "kind">;
+export declare const workflowDraftEditConnectionChangeSchema: z.ZodObject<{
+    stepIds: z.ZodArray<z.ZodString>;
+    kind: z.ZodEnum<{
+        "add-edge": "add-edge";
+        "remove-edge": "remove-edge";
+    }>;
+    edge: z.ZodObject<{
+        from: z.ZodString;
+        output: z.ZodString;
+        to: z.ZodString;
+        input: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;

package/dist/schemas/workflow-draft-edit-assembly-schema.js

@@ -0,0 +1,93 @@
+import { z } from 'zod';
+import { workflowDraftApiCallSchema, workflowDraftRequirementSchema, workflowDraftEdgeSchema, } from './workflow-draft-schema.js';
+import { nativeRuntimeParametersSchema } from './native-runtime-input-slot-schema.js';
+export const workflowDraftValueEditSchema = z.discriminatedUnion('kind', [
+    z.strictObject({
+        kind: z.literal('set'),
+        pointer: z.string(),
+        value: z.json(),
+    }),
+    z.strictObject({ kind: z.literal('remove'), pointer: z.string() }),
+]);
+export const workflowDraftNativeParameterChangeSchema = z.union([
+    workflowDraftValueEditSchema,
+    z.strictObject({ kind: z.literal('defer'), pointer: z.string().min(1) }),
+]);
+export const workflowDraftBindingEditSchema = z.discriminatedUnion('kind', [
+    z.strictObject({
+        kind: z.literal('set'),
+        binding: workflowDraftApiCallSchema.shape.bindings.element,
+    }),
+    z.strictObject({
+        kind: z.literal('remove'),
+        targetPointer: z.string().min(1),
+    }),
+]);
+const stepId = z.string().min(1);
+export const workflowDraftEditResolutionSchema = z.discriminatedUnion('kind', [
+    z.strictObject({
+        stepId,
+        kind: z.literal('api-call'),
+        values: workflowDraftApiCallSchema.shape.values,
+        requestedInputs: workflowDraftApiCallSchema.shape.requestedInputs,
+        bindings: workflowDraftApiCallSchema.shape.bindings,
+        requestMediaType: z.string().min(1).optional(),
+    }),
+    z.strictObject({
+        stepId,
+        kind: z.literal('api-inputs'),
+        edits: z.array(workflowDraftValueEditSchema),
+        requestMediaType: z.string().min(1).optional(),
+    }),
+    z.strictObject({
+        stepId,
+        kind: z.literal('api-bindings'),
+        edits: z.array(workflowDraftBindingEditSchema),
+        valueEdits: z.array(workflowDraftValueEditSchema),
+    }),
+    z.strictObject({
+        stepId,
+        kind: z.literal('native-literal'),
+        parameters: z.record(z.string(), z.json()),
+    }),
+    z.strictObject({
+        stepId,
+        kind: z.literal('native-mixed'),
+        parameters: z.record(z.string(), z.json()),
+        runtimeParameters: nativeRuntimeParametersSchema.options[1],
+    }),
+    z.strictObject({
+        stepId,
+        kind: z.literal('native-parameters'),
+        edits: z.array(workflowDraftNativeParameterChangeSchema).min(1),
+    }),
+    z.strictObject({ stepId, kind: z.literal('native-runtime') }),
+    z.strictObject({
+        stepId,
+        kind: z.literal('requirement'),
+        answerMessageId: z.string().refine((value) => value.trim().length > 0),
+        text: workflowDraftRequirementSchema.shape.text,
+        state: workflowDraftRequirementSchema.shape.state,
+        scope: workflowDraftRequirementSchema.shape.scope,
+    }),
+]);
+export const workflowDraftEditRepairSchema = z.discriminatedUnion('kind', [
+    z.strictObject({
+        taskId: z.string().min(1),
+        kind: z.literal('api-bindings'),
+        edits: z.array(workflowDraftBindingEditSchema),
+    }),
+    z.strictObject({
+        taskId: z.string().min(1),
+        kind: z.literal('native-parameters'),
+        edits: z.array(workflowDraftValueEditSchema),
+    }),
+]);
+export const workflowDraftEditConnectionChangeSchema = z.strictObject({
+    stepIds: z
+        .array(stepId)
+        .min(1)
+        .refine((ids) => new Set(ids).size === ids.length),
+    kind: z.enum(['add-edge', 'remove-edge']),
+    edge: workflowDraftEdgeSchema,
+});

package/dist/schemas/workflow-draft-edit-message-fields.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+import type { WorkflowMessageEvidence } from '../types/planning-evidence.js';
+/** Shared current-request evidence and optional display fields for edit stages. */
+export declare function createWorkflowDraftEditMessageFields(messageIds: string[], includeExplanations: boolean, messageSchema?: z.ZodType<WorkflowMessageEvidence>): {
+    message: z.ZodType<WorkflowMessageEvidence, unknown, z.core.$ZodTypeInternals<WorkflowMessageEvidence, unknown>>;
+    fields: {
+        explanation: z.ZodObject<{
+            reason: z.ZodString;
+            evidence: z.ZodArray<z.ZodType<WorkflowMessageEvidence, unknown, z.core.$ZodTypeInternals<WorkflowMessageEvidence, unknown>>>;
+        }, z.core.$strict>;
+    } | {
+        explanation?: undefined;
+    };
+};

package/dist/schemas/workflow-draft-edit-message-fields.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+/** Shared current-request evidence and optional display fields for edit stages. */
+export function createWorkflowDraftEditMessageFields(messageIds, includeExplanations, messageSchema) {
+    z.strictObject({
+        messageIds: z
+            .array(z.string().refine((id) => id.trim().length > 0))
+            .min(1)
+            .refine((ids) => new Set(ids).size === ids.length),
+        includeExplanations: z.boolean(),
+    }).parse({ messageIds, includeExplanations });
+    const message = messageSchema ??
+        z.strictObject({
+            kind: z.literal('message'),
+            messageId: z.enum(messageIds),
+            quote: z
+                .string()
+                .min(1)
+                .describe('Exact quotation from this current request message.'),
+        });
+    return {
+        message,
+        fields: includeExplanations
+            ? {
+                explanation: z.strictObject({
+                    reason: z
+                        .string()
+                        .min(1)
+                        .describe('Short user-facing reason, not chain-of-thought.'),
+                    evidence: z.array(message).min(1),
+                }),
+            }
+            : {},
+    };
+}

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

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export declare const workflowDraftEditOptionsSchema: z.ZodObject<{
+    includeExplanations: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const workflowDraftEditRequestIdsSchema: z.ZodArray<z.ZodString>;

package/dist/schemas/workflow-draft-edit-options-schema.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+export const workflowDraftEditOptionsSchema = z.strictObject({
+    includeExplanations: z.boolean().optional(),
+});
+export const workflowDraftEditRequestIdsSchema = z
+    .array(z.string().min(1))
+    .min(1)
+    .refine((ids) => new Set(ids).size === ids.length);

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

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+/** Envelope validation precedes contextual decision reconstruction and identity checks. */
+export declare const workflowDraftEditPlanSchema: z.ZodObject<{
+    id: z.ZodString;
+    draftId: z.ZodString;
+    baseRevision: z.ZodNumber;
+    draftFingerprint: z.ZodString;
+    contextFingerprint: z.ZodString;
+    nodeContractsFingerprint: z.ZodString;
+    requestMessageIds: z.ZodArray<z.ZodString>;
+    options: z.ZodObject<{
+        includeExplanations: z.ZodBoolean;
+    }, z.core.$strict>;
+    status: z.ZodEnum<{
+        "needs-clarification": "needs-clarification";
+        "no-change": "no-change";
+        "ready-for-planning": "ready-for-planning";
+    }>;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        decision: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        newNodeId: z.ZodOptional<z.ZodString>;
+        stages: z.ZodArray<z.ZodEnum<{
+            "api-bindings": "api-bindings";
+            "api-arguments": "api-arguments";
+            "native-parameters": "native-parameters";
+            requirements: "requirements";
+            connections: "connections";
+            "resolve-contracts": "resolve-contracts";
+            clarification: "clarification";
+        }>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;

package/dist/schemas/workflow-draft-edit-plan-schema.js

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { draftRevisionSchema } from './workflow-draft-schema.js';
+import { workflowDraftEditRequestIdsSchema } from './workflow-draft-edit-options-schema.js';
+/** Envelope validation precedes contextual decision reconstruction and identity checks. */
+export const workflowDraftEditPlanSchema = z.strictObject({
+    id: z.string().min(1),
+    draftId: z.string().min(1),
+    baseRevision: draftRevisionSchema,
+    draftFingerprint: z.string().min(1),
+    contextFingerprint: z.string().min(1),
+    nodeContractsFingerprint: z.string().min(1),
+    requestMessageIds: workflowDraftEditRequestIdsSchema,
+    options: z.strictObject({ includeExplanations: z.boolean() }),
+    status: z.enum(['ready-for-planning', 'needs-clarification', 'no-change']),
+    steps: z
+        .array(z.strictObject({
+        id: z.string().min(1),
+        decision: z.record(z.string(), z.json()),
+        newNodeId: z.string().min(1).optional(),
+        stages: z.array(z.enum([
+            'requirements',
+            'resolve-contracts',
+            'native-parameters',
+            'api-bindings',
+            'api-arguments',
+            'connections',
+            'clarification',
+        ])),
+    }))
+        .min(1),
+});

package/dist/schemas/workflow-draft-native-dependencies-schema.d.ts

@@ -0,0 +1,4 @@
+import type { z } from 'zod';
+import type { NativeInstanceDependencyProposal } from '../types/native-instance-dependencies.js';
+import type { WorkflowDraftNativeDependenciesInput } from '../types/workflow-draft-native-dependencies.js';
+export declare function createWorkflowDraftNativeDependenciesSchema(input: WorkflowDraftNativeDependenciesInput): z.ZodType<NativeInstanceDependencyProposal>;

package/dist/schemas/workflow-draft-native-dependencies-schema.js

@@ -0,0 +1,13 @@
+import { describeWorkflowDraftNativeDependencies } from '../draft/edits/native/additions/resolve-workflow-draft-native-dependencies.js';
+import { createNativeProducerDependenciesSchema } from './native-producer-dependencies-schema.js';
+export function createWorkflowDraftNativeDependenciesSchema(input) {
+    const context = describeWorkflowDraftNativeDependencies(input);
+    return createNativeProducerDependenciesSchema({
+        targets: context.roles.map((role) => ({
+            nodeId: role.nodeId,
+            description: `Producer choices for ${role.capability}: ${role.instruction}`,
+            sourceNodeIds: context.sourceCandidatesByNodeId[role.nodeId],
+        })),
+        includeExplanations: context.includeExplanations,
+    });
+}

package/dist/schemas/workflow-draft-native-node-addition-schema.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import type { WorkflowDraftNativeNodeAdditionInput, WorkflowDraftNativeNodeAdditionProposal, WorkflowDraftNativeNodeParameterOwnershipProposal } from '../types/workflow-draft-native-node-addition.js';
+export declare function createWorkflowDraftNativeNodeParameterOwnershipSchema(input: WorkflowDraftNativeNodeAdditionInput): z.ZodType<WorkflowDraftNativeNodeParameterOwnershipProposal>;
+/** The model returns only configuration/ownership or a question, never IDs, capability selection, ports or graph edges. */
+export declare function createWorkflowDraftNativeNodeAdditionSchema(input: WorkflowDraftNativeNodeAdditionInput): z.ZodType<WorkflowDraftNativeNodeAdditionProposal>;

package/dist/schemas/workflow-draft-native-node-addition-schema.js

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import { resolveNativeNodeAdditionContext } from '../draft/edits/native/additions/resolve-native-node-addition-context.js';
+import { createWorkflowDraftSourceEvidenceFields } from './create-workflow-draft-source-evidence-fields.js';
+import { validateWorkflowDraftNativeNodeParameterOwnershipContract } from '../draft/edits/native/additions/resolve-workflow-draft-native-node-parameter-ownership.js';
+import { createNativeParameterGenerationContract } from './create-native-parameter-generation-contract.js';
+export function createWorkflowDraftNativeNodeParameterOwnershipSchema(input) {
+    const { description } = resolveNativeNodeAdditionContext(input);
+    const fields = createWorkflowDraftSourceEvidenceFields(description);
+    const choices = [
+        z.strictObject({ status: z.literal('literal'), ...fields }),
+        z.strictObject({
+            status: z.literal('needs-clarification'),
+            message: z.string().min(1),
+            ...fields,
+        }),
+    ];
+    if (description.allowRuntimeParameters &&
+        description.capability.supportsRuntimeParameters &&
+        description.parameterMode !== 'fixed-empty')
+        choices.push(z.strictObject({ status: z.literal('runtime-parameters'), ...fields }), z.strictObject({
+            status: z.literal('runtime-fields'),
+            pointers: z
+                .array(z
+                .string()
+                .min(1)
+                .describe('An explicitly deferred RFC 6901 native parameter field, never a slot ID or schema.'))
+                .min(1),
+            ...fields,
+        }));
+    return z.strictObject({
+        decision: z.union(choices),
+    });
+}
+/** The model returns only configuration/ownership or a question, never IDs, capability selection, ports or graph edges. */
+export function createWorkflowDraftNativeNodeAdditionSchema(input) {
+    const { description, parametersSchema, capability } = resolveNativeNodeAdditionContext(input);
+    const fields = createWorkflowDraftSourceEvidenceFields(description);
+    const ownership = input.parameterOwnership === undefined
+        ? undefined
+        : validateWorkflowDraftNativeNodeParameterOwnershipContract(input);
+    const contract = createNativeParameterGenerationContract({
+        nodeId: description.nodeId,
+        capability: { ...capability, parametersSchema },
+        runtimeParameters: ownership?.runtimeParameters,
+    });
+    const values = contract.valuesSchema;
+    const choices = [
+        z.strictObject({
+            status: z.literal('needs-clarification'),
+            message: z
+                .string()
+                .min(1)
+                .describe('Ask for missing structural settings or source choices. Do not invent values, producers or code.'),
+            ...fields,
+        }),
+    ];
+    if (ownership?.runtimeParameters !== true)
+        choices.unshift(z.strictObject({
+            status: z.literal('provided'),
+            parameters: values,
+            ...fields,
+        }));
+    if ((ownership === undefined &&
+        description.allowRuntimeParameters &&
+        description.capability.supportsRuntimeParameters) ||
+        ownership?.runtimeParameters === true)
+        choices.push(z.strictObject({ status: z.literal('runtime-parameters'), ...fields }));
+    return z
+        .strictObject({
+        decision: z.union(choices),
+    })
+        .meta({
+        $defs: contract.definitions,
+    });
+}

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

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import type { WorkflowDraftNativeParameterEditDescription, WorkflowDraftNativeParameterEditProposal } from '../types/workflow-draft-native-parameter-edit.js';
+import type { WorkflowMessageEvidence } from '../types/planning-evidence.js';
+export declare function createWorkflowDraftNativeParameterEditProposalSchema(context: WorkflowDraftNativeParameterEditDescription, messageSchema?: z.ZodType<WorkflowMessageEvidence>): z.ZodType<WorkflowDraftNativeParameterEditProposal>;
+export declare const workflowDraftNativeParameterEditContractSchema: z.ZodObject<{
+    id: z.ZodString;
+    fingerprint: z.ZodString;
+    stepId: z.ZodString;
+    nodeId: z.ZodString;
+    schemaResource: z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    targets: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        sources: z.ZodArray<z.ZodObject<{
+            kind: z.ZodLiteral<"message">;
+            messageId: z.ZodString;
+            quote: z.ZodString;
+        }, z.core.$strict>>;
+        explanation: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodString;
+            evidence: z.ZodArray<z.ZodObject<{
+                kind: z.ZodLiteral<"message">;
+                messageId: z.ZodString;
+                quote: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        id: z.ZodString;
+        kind: z.ZodLiteral<"set">;
+        pointer: z.ZodString;
+        schema: z.ZodUnion<readonly [z.ZodBoolean, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+    }, z.core.$strict>, z.ZodObject<{
+        sources: z.ZodArray<z.ZodObject<{
+            kind: z.ZodLiteral<"message">;
+            messageId: z.ZodString;
+            quote: z.ZodString;
+        }, z.core.$strict>>;
+        explanation: z.ZodOptional<z.ZodObject<{
+            reason: z.ZodString;
+            evidence: z.ZodArray<z.ZodObject<{
+                kind: z.ZodLiteral<"message">;
+                messageId: z.ZodString;
+                quote: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        id: z.ZodString;
+        kind: z.ZodEnum<{
+            defer: "defer";
+            remove: "remove";
+        }>;
+        pointer: z.ZodString;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;

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

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { workflowMessageEvidenceSchema } from './planning-evidence-schema.js';
+import { createWorkflowDraftEditMessageFields } from './workflow-draft-edit-message-fields.js';
+export function createWorkflowDraftNativeParameterEditProposalSchema(context, messageSchema) {
+    const evidence = createWorkflowDraftEditMessageFields(context.messages.map((message) => message.id), context.includeExplanations, messageSchema);
+    const fields = {
+        sources: z.array(evidence.message).min(1),
+        ...evidence.fields,
+    };
+    const allowsDeferral = context.allowRuntimeParameters &&
+        context.capability.supportsRuntimeParameters;
+    const choices = [
+        z.strictObject({
+            status: z.literal('targets'),
+            targets: z
+                .array(z.strictObject({
+                kind: allowsDeferral
+                    ? z.enum(['set', 'remove', 'defer'])
+                    : z.enum(['set', 'remove']),
+                pointer: z
+                    .string()
+                    .describe('Exact RFC 6901 parameter pointer. Empty means explicit whole-object set. Defer means only this explicitly requested field is supplied at execution; keep unrelated literals and owners. No node, port or schema metadata.'),
+                ...fields,
+            }))
+                .min(1),
+        }),
+        z.strictObject({
+            status: z.literal('needs-clarification'),
+            message: z.string().min(1),
+            ...fields,
+        }),
+    ];
+    if (allowsDeferral)
+        choices.push(z.strictObject({ status: z.literal('runtime-parameters'), ...fields }));
+    return z.strictObject({
+        decision: z.union(choices),
+    });
+}
+const resource = z.union([z.boolean(), z.record(z.string(), z.unknown())]);
+const evidence = {
+    sources: z.array(workflowMessageEvidenceSchema).min(1),
+    explanation: z
+        .strictObject({
+        reason: z.string().min(1),
+        evidence: z.array(workflowMessageEvidenceSchema).min(1),
+    })
+        .optional(),
+};
+export const workflowDraftNativeParameterEditContractSchema = z.strictObject({
+    id: z.string().min(1),
+    fingerprint: z.string().min(1),
+    stepId: z.string().min(1),
+    nodeId: z.string().min(1),
+    schemaResource: resource,
+    targets: z
+        .array(z.union([
+        z.strictObject({
+            id: z.string().min(1),
+            kind: z.literal('set'),
+            pointer: z.string(),
+            schema: resource,
+            ...evidence,
+        }),
+        z.strictObject({
+            id: z.string().min(1),
+            kind: z.enum(['remove', 'defer']),
+            pointer: z.string(),
+            ...evidence,
+        }),
+    ]))
+        .min(1),
+});

package/dist/schemas/workflow-draft-native-reference-repair-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { WorkflowDraftNativeReferenceRepairDescription, WorkflowDraftNativeReferenceRepairProposal } from '../types/workflow-draft-native-reference-repair.js';
+/** Fixed object keys, actual source choices, no parameter values or host-owned patch metadata. */
+export declare function createWorkflowDraftNativeReferenceRepairSchema(context: WorkflowDraftNativeReferenceRepairDescription): z.ZodType<WorkflowDraftNativeReferenceRepairProposal>;