@openapi-flow/core 0.2.0 → 0.3.0

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

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { createWorkflowDraftSourceEvidenceFields } from './create-workflow-draft-source-evidence-fields.js';
+/** Fixed object keys, actual source choices, no parameter values or host-owned patch metadata. */
+export function createWorkflowDraftNativeReferenceRepairSchema(context) {
+    const fields = createWorkflowDraftSourceEvidenceFields(context);
+    if (!context.bindings.length ||
+        new Set(context.bindings.map((binding) => binding.id)).size !==
+            context.bindings.length)
+        throw new Error('Native reference repair schema requires distinct actual binding locations');
+    return z.strictObject({
+        decisions: z.strictObject(Object.fromEntries(context.bindings.map((binding) => {
+            const sourceIds = binding.reference.source === 'exclusive-output'
+                ? context.sources.exclusiveOutputs.map((source) => source.nodeId)
+                : context.sources.values
+                    .filter((source) => source.kind ===
+                    (binding.reference.source === 'response'
+                        ? 'api'
+                        : 'native'))
+                    .map((source) => source.nodeId);
+            const choices = [
+                z.strictObject({ kind: z.literal('keep'), ...fields }),
+                z.strictObject({
+                    kind: z.literal('needs-clarification'),
+                    message: z
+                        .string()
+                        .min(1)
+                        .describe('Ask about the missing source/reference. Do not invent a producer, literal, conversion or altered condition.'),
+                    ...fields,
+                }),
+            ];
+            if (sourceIds.length)
+                choices.push(z.strictObject({
+                    kind: z.literal('bind'),
+                    sourceNodeId: z.enum(sourceIds),
+                    ...(binding.valuePointer === undefined
+                        ? {}
+                        : {
+                            sourcePointer: z
+                                .string()
+                                .describe('Exact RFC 6901 API response-body/native-output pointer declared by the selected source; empty means the whole value. No transformations or guessed envelopes.'),
+                        }),
+                    ...fields,
+                }));
+            return [binding.id, z.union(choices)];
+        }))),
+    });
+}

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

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import type { WorkflowDraft, WorkflowDraftContent } from '../types/workflow-draft.js';
+export declare const draftRevisionSchema: z.ZodNumber;
+export declare const workflowDraftScopeSchema: 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">;
+export declare const workflowDraftRequirementSchema: z.ZodObject<{
+    id: 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">;
+    sourceMessageIds: z.ZodArray<z.ZodString>;
+    origin: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "clarification-fact": "clarification-fact";
+            "clarification-question": "clarification-question";
+        }>;
+        roundId: z.ZodString;
+        sourceId: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const workflowDraftApiCallSchema: z.ZodObject<{
+    id: z.ZodString;
+    requestedInputs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    operation: z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>;
+    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>;
+    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>;
+export declare const workflowDraftNativeNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    capability: z.ZodString;
+    parameters: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    runtimeParameters: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+        pointers: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export declare const workflowDraftEdgeSchema: z.ZodObject<{
+    from: z.ZodString;
+    output: z.ZodString;
+    to: z.ZodString;
+    input: z.ZodString;
+}, z.core.$strict>;
+export declare const workflowDraftContentSchema: z.ZodType<WorkflowDraftContent>;
+export declare const workflowDraftSchema: z.ZodType<WorkflowDraft>;

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

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+import { apiOperationKeySchema } from './api-operation-key-schema.js';
+import { createWorkflowDraftRequirementHistorySchema } from './create-workflow-draft-requirement-history-schema.js';
+import { nativeRuntimeParametersSchema } from './native-runtime-input-slot-schema.js';
+import { requestedApiInputsSchema } from './requested-api-inputs-schema.js';
+import { workflowDraftCapabilityGapSchema } from './workflow-draft-capability-gap-schema.js';
+const identity = z.string().refine((value) => value.trim().length > 0);
+const distinctIds = z
+    .array(identity)
+    .min(1)
+    .refine((ids) => new Set(ids).size === ids.length);
+export const draftRevisionSchema = z
+    .number()
+    .int()
+    .min(0)
+    .max(Number.MAX_SAFE_INTEGER);
+export const workflowDraftScopeSchema = z.discriminatedUnion('kind', [
+    z.strictObject({ kind: z.literal('workflow') }),
+    z.strictObject({ kind: z.literal('nodes'), nodeIds: distinctIds }),
+]);
+export const workflowDraftRequirementSchema = z.strictObject({
+    id: identity,
+    text: identity,
+    state: z.enum(['confirmed', 'needs-clarification', 'deferred']),
+    scope: workflowDraftScopeSchema,
+    sourceMessageIds: distinctIds,
+    origin: z
+        .strictObject({
+        kind: z.enum(['clarification-fact', 'clarification-question']),
+        roundId: identity,
+        sourceId: identity,
+    })
+        .optional(),
+});
+export const workflowDraftApiCallSchema = z.strictObject({
+    id: identity,
+    requestedInputs: requestedApiInputsSchema.optional(),
+    operation: apiOperationKeySchema,
+    values: z.strictObject({
+        path: z.record(z.string(), z.json()).optional(),
+        query: z.record(z.string(), z.json()).optional(),
+        header: z.record(z.string(), z.json()).optional(),
+        cookie: z.record(z.string(), z.json()).optional(),
+        querystring: z.record(z.string(), z.json()).optional(),
+        body: z.json().optional(),
+    }),
+    bindings: z.array(z.strictObject({
+        kind: z.literal('node-output'),
+        targetPointer: identity,
+        sourceNodeId: identity,
+        sourcePointer: z.string(),
+    })),
+    requestMediaType: identity.optional(),
+});
+export const workflowDraftNativeNodeSchema = z.strictObject({
+    id: identity,
+    capability: identity,
+    parameters: z.record(z.string(), z.json()),
+    runtimeParameters: nativeRuntimeParametersSchema.optional(),
+});
+export const workflowDraftEdgeSchema = z.strictObject({
+    from: identity,
+    output: identity,
+    to: identity,
+    input: identity,
+});
+const content = {
+    id: identity,
+    requirements: z.array(workflowDraftRequirementSchema),
+    apiCalls: z.array(workflowDraftApiCallSchema),
+    nativeNodes: z.array(workflowDraftNativeNodeSchema),
+    gapNodes: z.array(workflowDraftCapabilityGapSchema).optional(),
+    edges: z.array(workflowDraftEdgeSchema),
+};
+export const workflowDraftContentSchema = z.strictObject(content);
+export const workflowDraftSchema = z.strictObject({
+    ...content,
+    revision: draftRevisionSchema,
+    requirementHistory: z.array(createWorkflowDraftRequirementHistorySchema(workflowDraftRequirementSchema)),
+    approvals: z.array(z.strictObject({
+        id: identity,
+        revision: draftRevisionSchema,
+        nodeIds: distinctIds,
+        invalidatedNodeIds: z
+            .array(identity)
+            .refine((ids) => new Set(ids).size === ids.length),
+    })),
+});

package/dist/schemas/workflow-graph-planning-schema.d.ts

@@ -0,0 +1,331 @@
+import { z } from 'zod';
+import type { WorkflowGraphPlanningContext, WorkflowGraphPlanningVerification } from '../types/workflow-graph-planning.js';
+import type { WorkflowPlanningSourceEvidence } from '../types/workflow-planning-materials.js';
+export declare const workflowGraphPlanningIdentitySchema: z.ZodObject<{
+    mode: z.ZodEnum<{
+        executable: "executable";
+        reviewable: "reviewable";
+    }>;
+    scenario: z.ZodString;
+}, z.core.$strict>;
+export declare const workflowGraphPlanningProposalSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mode: z.ZodLiteral<"executable">;
+    additionalNativeNodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        capability: z.ZodString;
+        parameters: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        runtimeParameters: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+            pointers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        output: z.ZodString;
+        to: z.ZodString;
+        input: z.ZodString;
+    }, z.core.$strict>>;
+    gaps: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>, z.ZodObject<{
+    mode: z.ZodLiteral<"reviewable">;
+    additionalNativeNodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        capability: z.ZodString;
+        parameters: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        runtimeParameters: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+            pointers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        output: z.ZodString;
+        to: z.ZodString;
+        input: z.ZodString;
+    }, z.core.$strict>>;
+    additionalGaps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strict>>;
+    blockedCalls: z.ZodArray<z.ZodObject<{
+        callId: z.ZodString;
+        gapIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>], "mode">;
+export declare const workflowGraphPlanningAssessmentSchema: z.ZodObject<{
+    reason: z.ZodString;
+    nodes: z.ZodArray<z.ZodObject<{
+        nodeId: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        output: z.ZodString;
+        to: z.ZodString;
+        input: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+    blockedCalls: z.ZodArray<z.ZodObject<{
+        callId: z.ZodString;
+        gapIds: z.ZodArray<z.ZodString>;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const executableGraphPlanningResultSchema: z.ZodObject<{
+    nativeNodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        capability: z.ZodString;
+        parameters: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        runtimeParameters: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+            pointers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        output: z.ZodString;
+        to: z.ZodString;
+        input: z.ZodString;
+    }, z.core.$strict>>;
+    gaps: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+    }, z.core.$strict>>;
+    starts: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const reviewableGraphPlanningResultSchema: z.ZodObject<{
+    nativeNodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        capability: z.ZodString;
+        parameters: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        runtimeParameters: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+            pointers: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>]>>;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        output: z.ZodString;
+        to: z.ZodString;
+        input: z.ZodString;
+    }, z.core.$strict>>;
+    starts: z.ZodArray<z.ZodString>;
+    gaps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        stage: z.ZodEnum<{
+            "api-selection": "api-selection";
+            "api-bindings": "api-bindings";
+            "workflow-graph": "workflow-graph";
+        }>;
+        description: z.ZodString;
+        operation: z.ZodOptional<z.ZodObject<{
+            documentId: z.ZodString;
+            snapshotId: z.ZodString;
+            operationRef: z.ZodString;
+        }, z.core.$strict>>;
+        callId: z.ZodOptional<z.ZodString>;
+        targetPointer: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    blockedCalls: z.ZodArray<z.ZodObject<{
+        callId: z.ZodString;
+        gapIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Context, plan and verification must match independent reconstruction from supplied contracts. */
+export declare const workflowGraphPlanningRecordSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"executable">;
+    plan: z.ZodObject<{
+        nativeNodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            capability: z.ZodString;
+            parameters: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            runtimeParameters: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+                pointers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            output: z.ZodString;
+            to: z.ZodString;
+            input: z.ZodString;
+        }, z.core.$strict>>;
+        gaps: z.ZodArray<z.ZodObject<{
+            description: z.ZodString;
+        }, z.core.$strict>>;
+        starts: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    proposal: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"executable">;
+        additionalNativeNodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            capability: z.ZodString;
+            parameters: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            runtimeParameters: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+                pointers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            output: z.ZodString;
+            to: z.ZodString;
+            input: z.ZodString;
+        }, z.core.$strict>>;
+        gaps: z.ZodArray<z.ZodObject<{
+            description: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"reviewable">;
+        additionalNativeNodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            capability: z.ZodString;
+            parameters: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            runtimeParameters: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+                pointers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            output: z.ZodString;
+            to: z.ZodString;
+            input: z.ZodString;
+        }, z.core.$strict>>;
+        additionalGaps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strict>>;
+        blockedCalls: z.ZodArray<z.ZodObject<{
+            callId: z.ZodString;
+            gapIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "mode">;
+    assessment: z.ZodObject<{
+        reason: z.ZodString;
+        nodes: z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            output: z.ZodString;
+            to: z.ZodString;
+            input: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+        blockedCalls: z.ZodArray<z.ZodObject<{
+            callId: z.ZodString;
+            gapIds: z.ZodArray<z.ZodString>;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    evidence: z.ZodObject<{
+        kind: z.ZodLiteral<"supplied-graph-materials">;
+        context: z.ZodCustom<WorkflowGraphPlanningContext, WorkflowGraphPlanningContext>;
+        sources: z.ZodCustom<WorkflowPlanningSourceEvidence, WorkflowPlanningSourceEvidence>;
+    }, z.core.$strict>;
+    verification: z.ZodCustom<WorkflowGraphPlanningVerification, WorkflowGraphPlanningVerification>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"reviewable">;
+    plan: z.ZodObject<{
+        nativeNodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            capability: z.ZodString;
+            parameters: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            runtimeParameters: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+                pointers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            output: z.ZodString;
+            to: z.ZodString;
+            input: z.ZodString;
+        }, z.core.$strict>>;
+        starts: z.ZodArray<z.ZodString>;
+        gaps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            stage: z.ZodEnum<{
+                "api-selection": "api-selection";
+                "api-bindings": "api-bindings";
+                "workflow-graph": "workflow-graph";
+            }>;
+            description: z.ZodString;
+            operation: z.ZodOptional<z.ZodObject<{
+                documentId: z.ZodString;
+                snapshotId: z.ZodString;
+                operationRef: z.ZodString;
+            }, z.core.$strict>>;
+            callId: z.ZodOptional<z.ZodString>;
+            targetPointer: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        blockedCalls: z.ZodArray<z.ZodObject<{
+            callId: z.ZodString;
+            gapIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    proposal: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"executable">;
+        additionalNativeNodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            capability: z.ZodString;
+            parameters: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            runtimeParameters: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+                pointers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            output: z.ZodString;
+            to: z.ZodString;
+            input: z.ZodString;
+        }, z.core.$strict>>;
+        gaps: z.ZodArray<z.ZodObject<{
+            description: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"reviewable">;
+        additionalNativeNodes: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            capability: z.ZodString;
+            parameters: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            runtimeParameters: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<true>, z.ZodObject<{
+                pointers: z.ZodArray<z.ZodString>;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            output: z.ZodString;
+            to: z.ZodString;
+            input: z.ZodString;
+        }, z.core.$strict>>;
+        additionalGaps: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strict>>;
+        blockedCalls: z.ZodArray<z.ZodObject<{
+            callId: z.ZodString;
+            gapIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>], "mode">;
+    assessment: z.ZodObject<{
+        reason: z.ZodString;
+        nodes: z.ZodArray<z.ZodObject<{
+            nodeId: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+        edges: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            output: z.ZodString;
+            to: z.ZodString;
+            input: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+        blockedCalls: z.ZodArray<z.ZodObject<{
+            callId: z.ZodString;
+            gapIds: z.ZodArray<z.ZodString>;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    evidence: z.ZodObject<{
+        kind: z.ZodLiteral<"supplied-graph-materials">;
+        context: z.ZodCustom<WorkflowGraphPlanningContext, WorkflowGraphPlanningContext>;
+        sources: z.ZodCustom<WorkflowPlanningSourceEvidence, WorkflowPlanningSourceEvidence>;
+    }, z.core.$strict>;
+    verification: z.ZodCustom<WorkflowGraphPlanningVerification, WorkflowGraphPlanningVerification>;
+}, z.core.$strict>], "kind">;

package/dist/schemas/workflow-graph-planning-schema.js

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+import { planningEvidenceTextSchema } from './planning-evidence-schema.js';
+import { workflowDraftNativeNodeSchema, workflowDraftEdgeSchema, } from './workflow-draft-schema.js';
+import { workflowReviewGapSchema, workflowBlockedCallSchema, } from './workflow-planning-material-schema.js';
+export const workflowGraphPlanningIdentitySchema = z.strictObject({
+    mode: z.enum(['executable', 'reviewable']),
+    scenario: planningEvidenceTextSchema,
+});
+export const workflowGraphPlanningProposalSchema = z.discriminatedUnion('mode', [
+    z.strictObject({
+        mode: z.literal('executable'),
+        additionalNativeNodes: z.array(workflowDraftNativeNodeSchema),
+        edges: z.array(workflowDraftEdgeSchema),
+        gaps: z.array(z.strictObject({ description: planningEvidenceTextSchema })),
+    }),
+    z.strictObject({
+        mode: z.literal('reviewable'),
+        additionalNativeNodes: z.array(workflowDraftNativeNodeSchema),
+        edges: z.array(workflowDraftEdgeSchema),
+        additionalGaps: z.array(z.strictObject({
+            id: planningEvidenceTextSchema,
+            description: planningEvidenceTextSchema,
+        })),
+        blockedCalls: z.array(workflowBlockedCallSchema),
+    }),
+]);
+export const workflowGraphPlanningAssessmentSchema = z.strictObject({
+    reason: planningEvidenceTextSchema,
+    nodes: z.array(z.strictObject({
+        nodeId: planningEvidenceTextSchema,
+        reason: planningEvidenceTextSchema,
+    })),
+    edges: z.array(workflowDraftEdgeSchema.extend({ reason: planningEvidenceTextSchema })),
+    blockedCalls: z.array(workflowBlockedCallSchema.extend({ reason: planningEvidenceTextSchema })),
+});
+export const executableGraphPlanningResultSchema = z.strictObject({
+    nativeNodes: z.array(workflowDraftNativeNodeSchema),
+    edges: z.array(workflowDraftEdgeSchema),
+    gaps: z.array(z.strictObject({ description: planningEvidenceTextSchema })),
+    starts: z.array(planningEvidenceTextSchema),
+});
+export const reviewableGraphPlanningResultSchema = executableGraphPlanningResultSchema.extend({
+    gaps: z.array(workflowReviewGapSchema),
+    blockedCalls: z.array(workflowBlockedCallSchema),
+});
+const fields = {
+    proposal: workflowGraphPlanningProposalSchema,
+    assessment: workflowGraphPlanningAssessmentSchema,
+    evidence: z.strictObject({
+        kind: z.literal('supplied-graph-materials'),
+        context: z.custom(),
+        sources: z.custom(),
+    }),
+    verification: z.custom(),
+};
+/** Context, plan and verification must match independent reconstruction from supplied contracts. */
+export const workflowGraphPlanningRecordSchema = z.discriminatedUnion('kind', [
+    z.strictObject({
+        ...fields,
+        kind: z.literal('executable'),
+        plan: executableGraphPlanningResultSchema,
+    }),
+    z.strictObject({
+        ...fields,
+        kind: z.literal('reviewable'),
+        plan: reviewableGraphPlanningResultSchema,
+    }),
+]);

package/dist/schemas/workflow-planning-material-schema.d.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+export declare const workflowMaterialArgumentSchema: z.ZodObject<{
+    callId: z.ZodString;
+    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>;
+    bindings: z.ZodArray<z.ZodObject<{
+        kind: z.ZodLiteral<"node-output">;
+        targetPointer: z.ZodString;
+        sourceNodeId: z.ZodString;
+        sourcePointer: z.ZodString;
+    }, z.core.$strict>>;
+    requestedInputs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    unresolvedInputs: z.ZodArray<z.ZodString>;
+    requestMediaType: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const workflowReviewGapSchema: z.ZodObject<{
+    id: z.ZodString;
+    stage: z.ZodEnum<{
+        "api-selection": "api-selection";
+        "api-bindings": "api-bindings";
+        "workflow-graph": "workflow-graph";
+    }>;
+    description: z.ZodString;
+    operation: z.ZodOptional<z.ZodObject<{
+        documentId: z.ZodString;
+        snapshotId: z.ZodString;
+        operationRef: z.ZodString;
+    }, z.core.$strict>>;
+    callId: z.ZodOptional<z.ZodString>;
+    targetPointer: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const workflowBlockedCallSchema: z.ZodObject<{
+    callId: z.ZodString;
+    gapIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;

package/dist/schemas/workflow-planning-material-schema.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+import { planningEvidenceTextSchema } from './planning-evidence-schema.js';
+import { apiOperationKeySchema } from './api-operation-key-schema.js';
+import { workflowDraftApiCallSchema } from './workflow-draft-schema.js';
+export const workflowMaterialArgumentSchema = z.strictObject({
+    callId: planningEvidenceTextSchema,
+    values: workflowDraftApiCallSchema.shape.values,
+    bindings: workflowDraftApiCallSchema.shape.bindings,
+    requestedInputs: workflowDraftApiCallSchema.shape.requestedInputs,
+    unresolvedInputs: z.array(z.string()),
+    requestMediaType: planningEvidenceTextSchema.optional(),
+});
+export const workflowReviewGapSchema = z.strictObject({
+    id: planningEvidenceTextSchema,
+    stage: z.enum(['api-selection', 'api-bindings', 'workflow-graph']),
+    description: planningEvidenceTextSchema,
+    operation: apiOperationKeySchema.optional(),
+    callId: planningEvidenceTextSchema.optional(),
+    targetPointer: z.string().optional(),
+});
+export const workflowBlockedCallSchema = z.strictObject({
+    callId: planningEvidenceTextSchema,
+    gapIds: z.array(planningEvidenceTextSchema).min(1),
+});

package/dist/schemas/workflow-planning-message-ids-schema.d.ts

@@ -0,0 +1,2 @@
+import { z } from 'zod';
+export declare const workflowPlanningMessageIdsSchema: z.ZodArray<z.ZodString>;