@openapi-flow/langchain 0.3.18 → 0.4.1

package/dist/workflow/connections/plan-workflow-connection-outline.js

@@ -0,0 +1,93 @@
+import { isDeepStrictEqual } from 'node:util';
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { createWorkflowConnectionOutline, runOpenApiFlowOperation, } from '@openapi-flow/core';
+import { createWorkflowConnectionOutlineSchema } from '../../schemas/workflow-connection-outline-schema.js';
+import { workflowConnectionOutlinePrompt } from '../../prompts/workflow-connection-outline-prompt.js';
+import { modelSignalSchema } from '../../schemas/model-signal-schema.js';
+import { workflowConnectionOutlineRejectionSchema } from '../../schemas/workflow-connection-outline-rejection-schema.js';
+import { describeWorkflowConnectionOutlineRequest } from './describe-workflow-connection-outline-request.js';
+import { invokeConnectionPlanningModel } from './invoke-connection-planning-model.js';
+import { validateConnectionProposal, WorkflowConnectionPlanningError, } from './workflow-connection-planning-error.js';
+/** One outline proposal; the host owns selection, retry, checkpoints and adoption. */
+export async function planWorkflowConnectionOutline(input) {
+    const operation = 'planWorkflowConnectionOutline';
+    const { description, previousOutline, requestFingerprint, rejectedSnapshot } = runOpenApiFlowOperation({
+        owner: 'langchain',
+        operation,
+        stage: 'input-validation',
+        code: 'PLANNING_INPUT_INVALID',
+    }, () => {
+        modelSignalSchema.parse(input.signal);
+        const request = describeWorkflowConnectionOutlineRequest(input);
+        if (input.rejectedProposals !== undefined) {
+            if (!Array.isArray(input.rejectedProposals))
+                throw new Error('Outline rejectedProposals must be an array when supplied');
+            for (const rejection of input.rejectedProposals) {
+                const parsed = workflowConnectionOutlineRejectionSchema.parse(rejection);
+                if (!isDeepStrictEqual(parsed, rejection) ||
+                    parsed.requestFingerprint !== request.requestFingerprint ||
+                    !isDeepStrictEqual(parsed.expected, request.description.expected))
+                    throw new Error('Outline feedback must belong to this exact source, session, goals, revision and previous outline');
+            }
+        }
+        return {
+            ...request,
+            rejectedSnapshot: input.rejectedProposals === undefined
+                ? undefined
+                : structuredClone(input.rejectedProposals),
+        };
+    });
+    const checkCurrent = (output, originalFailure) => validateConnectionProposal({
+        operation,
+        stage: 'input-validation',
+        code: 'PLANNING_INPUT_INVALID',
+        output,
+        sourceFingerprint: description.expected.sourceFingerprint,
+        requestFingerprint,
+    }, () => {
+        try {
+            if (!isDeepStrictEqual(describeWorkflowConnectionOutlineRequest(input)
+                .requestFingerprint, requestFingerprint) ||
+                !isDeepStrictEqual(input.rejectedProposals, rejectedSnapshot))
+                throw new Error('Outline source, session, previous outline or feedback changed during model invocation');
+        }
+        catch (error) {
+            if (originalFailure !== undefined)
+                throw new AggregateError([originalFailure, error], 'Outline input changed while an invalid output was received', { cause: error });
+            throw error;
+        }
+    });
+    const output = await invokeConnectionPlanningModel({
+        model: input.model,
+        operation,
+        name: 'plan_workflow_connection_outline',
+        schema: createWorkflowConnectionOutlineSchema(description),
+        sourceFingerprint: description.expected.sourceFingerprint,
+        requestFingerprint,
+        messages: [
+            new SystemMessage(workflowConnectionOutlinePrompt),
+            new HumanMessage(JSON.stringify({
+                ...description,
+                ...(previousOutline === undefined ? {} : { previousOutline }),
+                ...(rejectedSnapshot === undefined
+                    ? {}
+                    : { rejectedProposals: rejectedSnapshot }),
+            })),
+        ],
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    }).catch((error) => {
+        if (error instanceof WorkflowConnectionPlanningError &&
+            error.diagnostic.stage === 'model-output')
+            checkCurrent(error.output, error);
+        throw error;
+    });
+    checkCurrent(output);
+    return validateConnectionProposal({
+        operation,
+        stage: 'contract-validation',
+        code: 'WORKFLOW_GRAPH_PLANNING_FAILED',
+        output,
+        sourceFingerprint: description.expected.sourceFingerprint,
+        requestFingerprint,
+    }, () => createWorkflowConnectionOutline({ ...input, proposal: output }));
+}

package/dist/workflow/connections/plan-workflow-connection-revision.d.ts

@@ -0,0 +1,3 @@
+import type { PlanWorkflowConnectionRevisionInput, PlanWorkflowConnectionRevisionResult } from '../../types/workflow-connection-revision.js';
+/** One originating-stage decision. The caller owns repetition, material generation, budgets and adoption. */
+export declare function planWorkflowConnectionRevision(input: PlanWorkflowConnectionRevisionInput): Promise<PlanWorkflowConnectionRevisionResult>;

package/dist/workflow/connections/plan-workflow-connection-revision.js

@@ -0,0 +1,163 @@
+import { isDeepStrictEqual } from 'node:util';
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowConnectionRevision, applyWorkflowConnectionRevision, validateWorkflowConnectionMaterialRepairRequest, validateWorkflowConnectionMaterialRepairReceipt, runOpenApiFlowOperation, workflowConnectionRejectedProposalSchema, validateWorkflowConnectionRevision, validateWorkflowConnectionGoalReview, } from '@openapi-flow/core';
+import { createWorkflowConnectionRevisionSchema } from '../../schemas/workflow-connection-revision-schema.js';
+import { modelSignalSchema } from '../../schemas/model-signal-schema.js';
+import { workflowConnectionRevisionRejectionSchema } from '../../schemas/workflow-connection-revision-rejection-schema.js';
+import { workflowConnectionRevisionPrompt } from '../../prompts/workflow-connection-revision-prompt.js';
+import { invokeConnectionPlanningModel } from './invoke-connection-planning-model.js';
+import { validateConnectionProposal, WorkflowConnectionPlanningError, } from './workflow-connection-planning-error.js';
+import { resolveConnectionGoalSelections, resolveConnectionEdgeSelections, resolveConnectionEndpointSelections, } from './resolve-connection-selections.js';
+/** One originating-stage decision. The caller owns repetition, material generation, budgets and adoption. */
+export async function planWorkflowConnectionRevision(input) {
+    const operation = 'planWorkflowConnectionRevision';
+    const { description, schema, rejectedProposals, rejectedConnections, rejectedGoalReviews, } = runOpenApiFlowOperation({
+        owner: 'langchain',
+        operation,
+        stage: 'input-validation',
+        code: 'PLANNING_INPUT_INVALID',
+    }, () => {
+        modelSignalSchema.parse(input.signal);
+        const description = describeWorkflowConnectionRevision(input);
+        if (input.rejectedConnections !== undefined) {
+            if (!Array.isArray(input.rejectedConnections))
+                throw new Error('rejectedConnections must be an array when supplied');
+            for (const rejection of input.rejectedConnections) {
+                const checked = workflowConnectionRejectedProposalSchema.parse(rejection);
+                if (!isDeepStrictEqual(checked, rejection) ||
+                    !isDeepStrictEqual(rejection.expected, description.before.expected))
+                    throw new Error('Rejected connection evidence must belong to the current original session/revision');
+            }
+        }
+        if (input.rejectedGoalReviews !== undefined) {
+            if (!Array.isArray(input.rejectedGoalReviews))
+                throw new Error('rejectedGoalReviews must be an array when supplied');
+            for (const candidate of input.rejectedGoalReviews) {
+                validateWorkflowConnectionRevision({
+                    ...input,
+                    proposal: candidate.revision.proposal,
+                    revision: candidate.revision,
+                });
+                validateWorkflowConnectionGoalReview({
+                    ...input.after,
+                    ...candidate.revision.sourceUpdate,
+                    session: candidate.revision.session,
+                    review: candidate.review,
+                });
+                if (candidate.review.accepted)
+                    throw new Error('Revision rejection history cannot contain an accepted goal review');
+            }
+        }
+        if (input.rejectedProposals !== undefined) {
+            if (!Array.isArray(input.rejectedProposals))
+                throw new Error('rejectedProposals must be an array when supplied');
+            for (const rejection of input.rejectedProposals) {
+                const checked = workflowConnectionRevisionRejectionSchema.parse(rejection);
+                if (!isDeepStrictEqual(checked, rejection) ||
+                    rejection.sourceFingerprint !== description.sourceFingerprint ||
+                    !isDeepStrictEqual(rejection.expected, description.before.expected))
+                    throw new Error('Rejected revisions must belong to the unchanged source epochs and original session');
+            }
+        }
+        return {
+            description,
+            schema: createWorkflowConnectionRevisionSchema(description),
+            rejectedProposals: input.rejectedProposals === undefined
+                ? undefined
+                : structuredClone(input.rejectedProposals),
+            rejectedConnections: input.rejectedConnections === undefined
+                ? undefined
+                : structuredClone(input.rejectedConnections),
+            rejectedGoalReviews: input.rejectedGoalReviews === undefined
+                ? undefined
+                : structuredClone(input.rejectedGoalReviews),
+        };
+    });
+    const checkCurrentInput = (output, rejectedOutputError) => {
+        validateConnectionProposal({
+            operation,
+            stage: 'input-validation',
+            code: 'PLANNING_INPUT_INVALID',
+            output,
+            sourceFingerprint: description.sourceFingerprint,
+        }, () => {
+            try {
+                if (!isDeepStrictEqual(describeWorkflowConnectionRevision(input), description) ||
+                    !isDeepStrictEqual(input.rejectedProposals, rejectedProposals) ||
+                    !isDeepStrictEqual(input.rejectedConnections, rejectedConnections) ||
+                    !isDeepStrictEqual(input.rejectedGoalReviews, rejectedGoalReviews))
+                    throw new Error('Connection revision source, session or rejection evidence changed during model invocation', { cause: rejectedOutputError });
+            }
+            catch (error) {
+                if (rejectedOutputError !== undefined)
+                    throw new AggregateError([rejectedOutputError, error], 'Connection revision input changed while invalid model output was received', { cause: error });
+                throw error;
+            }
+        });
+    };
+    const output = await invokeConnectionPlanningModel({
+        model: input.model,
+        operation,
+        name: 'plan_workflow_connection_revision',
+        schema,
+        sourceFingerprint: description.sourceFingerprint,
+        messages: [
+            new SystemMessage(workflowConnectionRevisionPrompt),
+            new HumanMessage(JSON.stringify({
+                ...description,
+                ...(rejectedProposals === undefined ? {} : { rejectedProposals }),
+                ...(rejectedConnections === undefined ? {} : { rejectedConnections }),
+                ...(rejectedGoalReviews === undefined ? {} : { rejectedGoalReviews }),
+            })),
+        ],
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    }).catch((error) => {
+        // A malformed model response must not skip the input guard and become retryable after a concurrent edit.
+        if (error instanceof WorkflowConnectionPlanningError &&
+            error.diagnostic.stage === 'model-output')
+            checkCurrentInput(error.output, error);
+        throw error;
+    });
+    checkCurrentInput(output);
+    return validateConnectionProposal({
+        operation,
+        stage: 'contract-validation',
+        code: 'WORKFLOW_GRAPH_PLANNING_FAILED',
+        output,
+        sourceFingerprint: description.sourceFingerprint,
+    }, () => {
+        if (output.decision.kind === 'replan-materials') {
+            validateWorkflowConnectionMaterialRepairRequest({
+                ...input,
+                request: output.decision,
+            });
+            const receipt = {
+                kind: 'replan-materials',
+                expected: {
+                    before: structuredClone(description.before.expected),
+                    afterSourceFingerprint: description.after.sourceFingerprint,
+                    revisionSourceFingerprint: description.sourceFingerprint,
+                },
+                request: output.decision,
+            };
+            validateWorkflowConnectionMaterialRepairReceipt({ ...input, receipt });
+            return receipt;
+        }
+        const addEdges = resolveConnectionEdgeSelections(output.decision.graphChange.addEdges, description.after.context.nodes);
+        const revision = applyWorkflowConnectionRevision({
+            ...input,
+            proposal: {
+                goals: resolveConnectionGoalSelections(output.decision.goals, description.after.context.nodes),
+                graphChange: {
+                    ...output.decision.graphChange,
+                    addEdges,
+                    addTerminals: resolveConnectionEndpointSelections(output.decision.graphChange.addTerminals, description.after.context.nodes),
+                    removeTerminals: resolveConnectionEndpointSelections(output.decision.graphChange.removeTerminals, description.before.context.nodes),
+                },
+            },
+        });
+        if (rejectedGoalReviews?.some((candidate) => candidate.revision.session.id === revision.session.id))
+            throw new Error('Connection revision repeats a candidate already rejected by the configured goal review');
+        return { kind: 'revised-connections', revision };
+    });
+}

package/dist/workflow/connections/plan-workflow-connection-step.js

@@ -1,20 +1,29 @@
 import { isDeepStrictEqual } from 'node:util';
 import { HumanMessage, SystemMessage } from '@langchain/core/messages';
-import { describeWorkflowConnectionStep, workflowConnectionPlanningDecisionSchema, workflowConnectionRejectedProposalSchema, runOpenApiFlowOperation, } from '@openapi-flow/core';
+import { describeWorkflowConnectionStep, workflowConnectionPlanningDecisionSchema, workflowConnectionRejectedProposalSchema, runOpenApiFlowOperation, describeWorkflowConnectionOutlineBundle, } from '@openapi-flow/core';
 import { createWorkflowConnectionStepSchema } from '../../schemas/workflow-connection-step-schema.js';
 import { workflowConnectionStepPrompt } from '../../prompts/incremental-workflow-connections-prompt.js';
 import { invokeConnectionPlanningModel } from './invoke-connection-planning-model.js';
-import { resolveConnectionPortSelection } from './resolve-connection-port-selection.js';
-import { validateConnectionProposal } from './workflow-connection-planning-error.js';
+import { resolveConnectionEdgeSelections, resolveConnectionEndpointSelections, } from './resolve-connection-selections.js';
+import { validateConnectionProposal, WorkflowConnectionPlanningError, } from './workflow-connection-planning-error.js';
 export async function planWorkflowConnectionStep(input) {
     const operation = 'planWorkflowConnectionStep';
-    const { description, capabilities, capabilityIndex, schema } = runOpenApiFlowOperation({
+    const { description, capabilities, capabilityIndex, schema, outlineContext, rejectedSnapshot, } = runOpenApiFlowOperation({
         owner: 'langchain',
         operation,
         stage: 'input-validation',
         code: 'PLANNING_INPUT_INVALID',
     }, () => {
         const description = describeWorkflowConnectionStep(input);
+        if ((input.outline === undefined) !== (input.bundleId === undefined))
+            throw new Error('Connection outline and bundleId must be supplied together');
+        const outlineContext = input.outline === undefined
+            ? undefined
+            : describeWorkflowConnectionOutlineBundle({
+                ...input,
+                outline: input.outline,
+                bundleId: input.bundleId,
+            });
         if (input.rejectedProposals !== undefined) {
             if (!Array.isArray(input.rejectedProposals))
                 throw new Error('rejectedProposals must be an array when supplied');
@@ -31,14 +40,50 @@ export async function planWorkflowConnectionStep(input) {
         const capabilities = input.capabilities === undefined ? [] : input.capabilities;
         return {
             description,
+            outlineContext,
+            rejectedSnapshot: input.rejectedProposals === undefined
+                ? undefined
+                : structuredClone(input.rejectedProposals),
             capabilities,
             capabilityIndex: capabilities.map(({ name, description }) => ({
                 name,
                 description,
             })),
-            schema: createWorkflowConnectionStepSchema(description, capabilities),
+            schema: createWorkflowConnectionStepSchema(description, capabilities, outlineContext),
         };
     });
+    const checkCurrent = (output, originalFailure) => validateConnectionProposal({
+        operation,
+        stage: 'input-validation',
+        code: 'PLANNING_INPUT_INVALID',
+        output,
+        sourceFingerprint: description.expected.sourceFingerprint,
+    }, () => {
+        try {
+            if ((input.outline === undefined) !== (input.bundleId === undefined))
+                throw new Error('Connection outline and bundleId changed during model invocation');
+            const currentOutline = input.outline === undefined
+                ? undefined
+                : describeWorkflowConnectionOutlineBundle({
+                    ...input,
+                    outline: input.outline,
+                    bundleId: input.bundleId,
+                });
+            if (!isDeepStrictEqual(describeWorkflowConnectionStep(input), description) ||
+                !isDeepStrictEqual(currentOutline, outlineContext) ||
+                !isDeepStrictEqual(input.rejectedProposals, rejectedSnapshot) ||
+                !isDeepStrictEqual(capabilities.map(({ name, description }) => ({
+                    name,
+                    description,
+                })), capabilityIndex))
+                throw new Error('Connection source, session, outline, feedback or native capabilities changed during model invocation');
+        }
+        catch (error) {
+            if (originalFailure !== undefined)
+                throw new AggregateError([originalFailure, error], 'Planning input changed while an invalid connection output was received', { cause: error });
+            throw error;
+        }
+    });
     const output = await invokeConnectionPlanningModel({
         model: input.model,
         operation,
@@ -48,47 +93,48 @@ export async function planWorkflowConnectionStep(input) {
             new SystemMessage(workflowConnectionStepPrompt),
             new HumanMessage(JSON.stringify({
                 ...description,
+                ...(outlineContext === undefined
+                    ? {}
+                    : {
+                        planningOutline: {
+                            outline: outlineContext.outline,
+                            bundles: outlineContext.bundles,
+                            selectedBundle: outlineContext.bundle,
+                            requiredProducerIds: outlineContext.requiredProducerIds,
+                            crossingEdges: outlineContext.crossingEdges,
+                        },
+                    }),
                 availableNativeCapabilities: capabilityIndex,
-                ...(input.rejectedProposals === undefined
+                ...(rejectedSnapshot === undefined
                     ? {}
-                    : { rejectedProposals: input.rejectedProposals }),
+                    : { rejectedProposals: rejectedSnapshot }),
             })),
         ],
         ...(input.signal === undefined ? {} : { signal: input.signal }),
+    }).catch((error) => {
+        if (error instanceof WorkflowConnectionPlanningError &&
+            error.diagnostic.stage === 'model-output')
+            checkCurrent(error.output, error);
+        throw error;
     });
+    checkCurrent(output);
     return validateConnectionProposal({
         operation,
         stage: 'contract-validation',
         code: 'WORKFLOW_GRAPH_PLANNING_FAILED',
         output,
     }, () => {
-        if (!isDeepStrictEqual(describeWorkflowConnectionStep(input), description))
-            throw new Error('Connection session or source changed during model invocation');
-        if (!isDeepStrictEqual(capabilities.map(({ name, description }) => ({ name, description })), capabilityIndex))
-            throw new Error('Available native capabilities changed during model invocation');
         const raw = output.decision;
+        const addEdges = raw.kind === 'patch'
+            ? resolveConnectionEdgeSelections(raw.addEdges, description.context.nodes)
+            : [];
         const decision = raw.kind !== 'patch'
             ? raw
             : {
                 ...raw,
-                addEdges: raw.addEdges.map((edge) => ({
-                    from: edge.source.nodeId,
-                    output: resolveConnectionPortSelection(edge.source, description.context.nodes, 'outputs'),
-                    to: edge.target.nodeId,
-                    input: resolveConnectionPortSelection(edge.target, description.context.nodes, 'inputs'),
-                })),
-                addTerminals: raw.addTerminals.map((selection) => ({
-                    nodeId: selection.nodeId,
-                    output: resolveConnectionPortSelection(selection, description.context.nodes, 'outputs'),
-                })),
-                removeTerminals: raw.removeTerminals.map((selection) => ({
-                    nodeId: selection.nodeId,
-                    output: resolveConnectionPortSelection(selection, description.context.nodes.map((node) => ({
-                        ...node,
-                        outputs: node.outputs.filter((port) => description.terminals.some((terminal) => terminal.nodeId === node.id &&
-                            terminal.output === port)),
-                    })), 'outputs'),
-                })),
+                addEdges,
+                addTerminals: resolveConnectionEndpointSelections(raw.addTerminals, description.context.nodes),
+                removeTerminals: resolveConnectionEndpointSelections(raw.removeTerminals, description.context.nodes),
             };
         return {
             expected: structuredClone(description.expected),

package/dist/workflow/connections/resolve-connection-selections.d.ts

@@ -0,0 +1,6 @@
+import type { WorkflowConnectionGoalProposal, WorkflowPlanNodeContract, WorkflowPlanEdge, WorkflowConnectionPatch } from '@openapi-flow/core';
+import type { WorkflowConnectionGoalSelection, WorkflowConnectionEdgeSelection, WorkflowConnectionEndpointSelection } from '../../types/incremental-connection-planning.js';
+export declare function resolveConnectionGoalSelections(selections: WorkflowConnectionGoalSelection[], nodes: WorkflowPlanNodeContract[]): WorkflowConnectionGoalProposal[];
+/** Endpoint intent is model-owned; a unique declared output port is code-owned. */
+export declare function resolveConnectionEndpointSelections(selections: WorkflowConnectionEndpointSelection[], nodes: WorkflowPlanNodeContract[]): WorkflowConnectionPatch['addTerminals'];
+export declare function resolveConnectionEdgeSelections(selections: WorkflowConnectionEdgeSelection[], nodes: WorkflowPlanNodeContract[]): WorkflowPlanEdge[];

package/dist/workflow/connections/resolve-connection-selections.js

@@ -0,0 +1,28 @@
+import { resolveConnectionPortSelection } from './resolve-connection-port-selection.js';
+export function resolveConnectionGoalSelections(selections, nodes) {
+    return selections.map((goal) => goal.kind !== 'route'
+        ? goal
+        : {
+            kind: goal.kind,
+            from: goal.source.nodeId,
+            to: goal.to,
+            factIds: goal.factIds,
+            reason: goal.reason,
+            output: resolveConnectionPortSelection(goal.source, nodes, 'outputs'),
+        });
+}
+/** Endpoint intent is model-owned; a unique declared output port is code-owned. */
+export function resolveConnectionEndpointSelections(selections, nodes) {
+    return selections.map((selection) => ({
+        nodeId: selection.nodeId,
+        output: resolveConnectionPortSelection(selection, nodes, 'outputs'),
+    }));
+}
+export function resolveConnectionEdgeSelections(selections, nodes) {
+    return selections.map((edge) => ({
+        from: edge.source.nodeId,
+        output: resolveConnectionPortSelection(edge.source, nodes, 'outputs'),
+        to: edge.target.nodeId,
+        input: resolveConnectionPortSelection(edge.target, nodes, 'inputs'),
+    }));
+}

package/dist/workflow/connections/review-workflow-connection-goals.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowConnectionGoalReview } from '@openapi-flow/core';
+import type { ReviewWorkflowConnectionGoalsInput } from '../../types/workflow-connection-goal-review.js';
+/** One independent judgment; the host owns whether and how to replan rejected goals/material. */
+export declare function reviewWorkflowConnectionGoals(input: ReviewWorkflowConnectionGoalsInput): Promise<WorkflowConnectionGoalReview>;

package/dist/workflow/connections/review-workflow-connection-goals.js

@@ -0,0 +1,64 @@
+import { isDeepStrictEqual } from 'node:util';
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowConnectionGoalReview, createWorkflowConnectionGoalReview, runOpenApiFlowOperation, } from '@openapi-flow/core';
+import { createWorkflowConnectionGoalReviewSchema } from '../../schemas/workflow-connection-goal-review-schema.js';
+import { modelSignalSchema } from '../../schemas/model-signal-schema.js';
+import { workflowConnectionGoalReviewPrompt } from '../../prompts/workflow-connection-goal-review-prompt.js';
+import { invokeConnectionPlanningModel } from './invoke-connection-planning-model.js';
+import { WorkflowConnectionPlanningError, validateConnectionProposal, } from './workflow-connection-planning-error.js';
+/** One independent judgment; the host owns whether and how to replan rejected goals/material. */
+export async function reviewWorkflowConnectionGoals(input) {
+    const operation = 'reviewWorkflowConnectionGoals';
+    const description = runOpenApiFlowOperation({
+        owner: 'langchain',
+        operation,
+        stage: 'input-validation',
+        code: 'PLANNING_INPUT_INVALID',
+    }, () => {
+        modelSignalSchema.parse(input.signal);
+        return describeWorkflowConnectionGoalReview(input);
+    });
+    const checkCurrent = (output) => validateConnectionProposal({
+        operation,
+        stage: 'input-validation',
+        code: 'PLANNING_INPUT_INVALID',
+        output,
+        sourceFingerprint: description.sourceFingerprint,
+    }, () => {
+        if (!isDeepStrictEqual(description, describeWorkflowConnectionGoalReview(input)))
+            throw new Error('Goal review source or candidate changed during model invocation');
+    });
+    const output = await invokeConnectionPlanningModel({
+        model: input.model,
+        operation,
+        name: 'review_workflow_connection_goals',
+        schema: createWorkflowConnectionGoalReviewSchema(description),
+        sourceFingerprint: description.sourceFingerprint,
+        messages: [
+            new SystemMessage(workflowConnectionGoalReviewPrompt),
+            new HumanMessage(JSON.stringify(description)),
+        ],
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    }).catch((error) => {
+        if (error instanceof WorkflowConnectionPlanningError &&
+            error.diagnostic.stage === 'model-output')
+            checkCurrent(error.output);
+        throw error;
+    });
+    checkCurrent(output);
+    return validateConnectionProposal({
+        operation,
+        stage: 'contract-validation',
+        code: 'WORKFLOW_GRAPH_PLANNING_FAILED',
+        output,
+        sourceFingerprint: description.sourceFingerprint,
+    }, () => createWorkflowConnectionGoalReview({
+        ...input,
+        proposal: {
+            assessments: description.requirements.map((fact) => ({
+                factId: fact.id,
+                ...output.assessments[fact.id],
+            })),
+        },
+    }));
+}

package/dist/workflow/connections/validate-workflow-goal-review-feedback.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowReviewedGoalCandidate } from '@openapi-flow/core';
+import type { ValidateWorkflowGoalReviewFeedbackInput } from '../../types/workflow-connection-goal-review.js';
+/** Verify exact negative judgments against actual current material; never turn them into user intent. */
+export declare function validateWorkflowGoalReviewFeedback(input: ValidateWorkflowGoalReviewFeedbackInput): WorkflowReviewedGoalCandidate[];

package/dist/workflow/connections/validate-workflow-goal-review-feedback.js

@@ -0,0 +1,22 @@
+import { isDeepStrictEqual } from 'node:util';
+import { validateWorkflowConnectionGoalReview, workflowReviewedGoalCandidateSchema, } from '@openapi-flow/core';
+/** Verify exact negative judgments against actual current material; never turn them into user intent. */
+export function validateWorkflowGoalReviewFeedback(input) {
+    if (input.rejectedGoalReviews === undefined)
+        return [];
+    if (!Array.isArray(input.rejectedGoalReviews))
+        throw new Error('rejectedGoalReviews must be an array when supplied');
+    for (const candidate of input.rejectedGoalReviews) {
+        const checked = workflowReviewedGoalCandidateSchema.parse(candidate);
+        if (!isDeepStrictEqual(checked, candidate))
+            throw new Error('Goal review feedback must preserve its exact candidate');
+        validateWorkflowConnectionGoalReview({
+            ...input,
+            session: candidate.session,
+            review: candidate.review,
+        });
+        if (candidate.review.accepted)
+            throw new Error('Accepted goal review is not rejection feedback');
+    }
+    return structuredClone(input.rejectedGoalReviews);
+}

package/dist/workflow/connections/workflow-connection-native-repair-error.d.ts

@@ -0,0 +1,6 @@
+import { OpenApiFlowError } from '@openapi-flow/core';
+import type { WorkflowConnectionNativeRepairFailure } from '../../types/workflow-connection-native-repair.js';
+export declare class WorkflowConnectionNativeRepairError extends OpenApiFlowError {
+    readonly failure: WorkflowConnectionNativeRepairFailure;
+    constructor(failure: WorkflowConnectionNativeRepairFailure, cause: Error);
+}

package/dist/workflow/connections/workflow-connection-native-repair-error.js

@@ -0,0 +1,18 @@
+import { OpenApiFlowError } from '@openapi-flow/core';
+export class WorkflowConnectionNativeRepairError extends OpenApiFlowError {
+    failure;
+    constructor(failure, cause) {
+        super({
+            message: cause.message,
+            diagnostic: {
+                owner: 'langchain',
+                operation: failure.operation,
+                stage: 'contract-validation',
+                code: 'NATIVE_NODE_PLANNING_FAILED',
+            },
+            cause,
+        });
+        this.name = 'WorkflowConnectionNativeRepairError';
+        this.failure = failure;
+    }
+}

package/dist/workflow/connections/workflow-connection-planning-error.d.ts

@@ -4,6 +4,7 @@ import type { WorkflowConnectionPlanningFailure } from '../../types/incremental-
 export declare class WorkflowConnectionPlanningError extends OpenApiFlowError {
     readonly output: unknown;
     readonly sourceFingerprint: string | undefined;
+    readonly requestFingerprint: string | undefined;
     constructor(failure: WorkflowConnectionPlanningFailure, cause: unknown);
 }
 export declare function validateConnectionProposal<Result>(failure: WorkflowConnectionPlanningFailure, execute: () => Result): Result;

package/dist/workflow/connections/workflow-connection-planning-error.js

@@ -3,6 +3,7 @@ import { OpenApiFlowError } from '@openapi-flow/core';
 export class WorkflowConnectionPlanningError extends OpenApiFlowError {
     output;
     sourceFingerprint;
+    requestFingerprint;
     constructor(failure, cause) {
         super({
             message: cause instanceof Error ? cause.message : failure.operation,
@@ -16,6 +17,7 @@ export class WorkflowConnectionPlanningError extends OpenApiFlowError {
         });
         this.output = failure.output;
         this.sourceFingerprint = failure.sourceFingerprint;
+        this.requestFingerprint = failure.requestFingerprint;
     }
 }
 export function validateConnectionProposal(failure, execute) {

package/dist/workflow/native-selection/create-native-planning-rejection.d.ts

@@ -0,0 +1,4 @@
+import type { CreateNativeSelectionRejectionInput, CreateNativeSelectionReviewRejectionInput, NativePlanningRejectedProposal } from '../../types/native-planning-rejection.js';
+/** Only unchanged, source-bound output failures are eligible; transport/configuration failures are not proposals. */
+export declare function createNativeSelectionRejection(input: CreateNativeSelectionRejectionInput): NativePlanningRejectedProposal | undefined;
+export declare function createNativeSelectionReviewRejection(input: CreateNativeSelectionReviewRejectionInput): NativePlanningRejectedProposal | undefined;