@openapi-flow/langchain 0.3.17 → 0.4.0

package/dist/types/incremental-connection-planning.d.ts

@@ -2,11 +2,13 @@ import type { BaseChatModel } from '@langchain/core/language_models/chat_models'
 import type { ZodType, z } from 'zod';
 import type { workflowConnectionGoalRejectionSchema } from '../schemas/workflow-connection-goal-rejection-schema.js';
 import type { BaseMessage } from '@langchain/core/messages';
-import type { WorkflowConnectionSessionSource, WorkflowConnectionSessionInput, WorkflowConnectionGoalProposal, WorkflowConnectionStepProposal, WorkflowConnectionPatch, WorkflowConnectionPlanningDecision, WorkflowConnectionMaterialRequest, WorkflowConnectionUserDecision, WorkflowConnectionRejectedProposal, WorkflowConnectionStepExpectation } from '@openapi-flow/core';
+import type { WorkflowConnectionSessionSource, WorkflowConnectionSessionInput, WorkflowConnectionGoalProposal, WorkflowConnectionStepProposal, WorkflowConnectionPatch, WorkflowConnectionPlanningDecision, WorkflowConnectionMaterialRequest, WorkflowConnectionUserDecision, WorkflowConnectionRejectedProposal, WorkflowConnectionStepExpectation, WorkflowConnectionStepDescription, WorkflowReviewedGoalCandidate, WorkflowConnectionOutline } from '@openapi-flow/core';
 export interface PlanWorkflowConnectionGoalsInput extends WorkflowConnectionSessionSource {
     model: BaseChatModel;
     /** Exact rejected output and code-owned validation feedback for this unchanged source. */
     rejectedProposals?: WorkflowConnectionGoalRejection[];
+    /** Private independent coverage judgments, not replacement requirements or code-proven semantics. */
+    rejectedGoalReviews?: WorkflowReviewedGoalCandidate[];
     signal?: AbortSignal;
 }
 export type WorkflowConnectionGoalRejection = z.infer<typeof workflowConnectionGoalRejectionSchema>;
@@ -17,6 +19,8 @@ export interface PlanWorkflowConnectionStepInput extends WorkflowConnectionSessi
     model: BaseChatModel;
     rejectedProposals?: WorkflowConnectionRejectedProposal[];
     signal?: AbortSignal;
+    outline?: WorkflowConnectionOutline;
+    bundleId?: string;
 }
 export type WorkflowConnectionRouteGoal = Extract<WorkflowConnectionGoalProposal, {
     kind: 'route';
@@ -42,6 +46,7 @@ export interface WorkflowConnectionPatchSelection extends Omit<WorkflowConnectio
     addTerminals: WorkflowConnectionEndpointSelection[];
     removeTerminals: WorkflowConnectionEndpointSelection[];
 }
+export type WorkflowConnectionPatchContext = Pick<WorkflowConnectionStepDescription, 'context' | 'requirements' | 'edgeCatalog' | 'rootNodeIds' | 'terminals'>;
 export type WorkflowConnectionCompletionRequest = Exclude<WorkflowConnectionStepProposal, WorkflowConnectionPatch>;
 export type WorkflowConnectionStepModelDecision = WorkflowConnectionPatchSelection | WorkflowConnectionCompletionRequest | WorkflowConnectionMaterialRequest | WorkflowConnectionUserDecision;
 export interface WorkflowConnectionStepModelOutput {
@@ -58,12 +63,14 @@ export interface InvokeConnectionPlanningModelInput<Output extends object> {
     schema: ZodType<Output>;
     messages: BaseMessage[];
     sourceFingerprint?: string;
+    requestFingerprint?: string;
     signal?: AbortSignal;
 }
 export interface WorkflowConnectionPlanningFailure {
     operation: string;
-    stage: 'model-output' | 'contract-validation';
-    code: 'MODEL_OUTPUT_INVALID' | 'WORKFLOW_GRAPH_PLANNING_FAILED';
+    stage: 'input-validation' | 'model-output' | 'contract-validation';
+    code: 'PLANNING_INPUT_INVALID' | 'MODEL_OUTPUT_INVALID' | 'WORKFLOW_GRAPH_PLANNING_FAILED';
     output: unknown;
     sourceFingerprint?: string;
+    requestFingerprint?: string;
 }

package/dist/types/native-instance-selection-review.d.ts

@@ -0,0 +1,9 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { NativeSelectedPlanningInput } from '@openapi-flow/core';
+export interface ReviewNativeInstanceSelectionInput extends NativeSelectedPlanningInput {
+    model?: BaseChatModel;
+    signal?: AbortSignal;
+}
+export interface NativeInstanceSelectionReviewFailure {
+    output: unknown;
+}

package/dist/types/native-instance-selection-review.js

@@ -0,0 +1 @@
+export {};

package/dist/types/native-node-planning.d.ts

@@ -1,6 +1,6 @@
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import type { z } from 'zod';
-import type { JsonValueObject, NativeNodePlanningInput, NativePlanningProposal, NativePlanningResult, NativePlanningAssessment, NativePlanningCapabilityMaterial, NativeNodePlanningRecord, NativeInstanceSelectionInput, NativeNodeConfigurationInput, NativeSelectedPlanningInput } from '@openapi-flow/core';
+import type { JsonValueObject, NativeNodePlanningInput, NativePlanningProposal, NativePlanningResult, NativePlanningAssessment, NativePlanningCapabilityMaterial, NativeNodePlanningRecord, NativeInstanceSelectionInput, NativeNodeConfigurationInput, NativeSelectedPlanningInput, NativeInstanceSelectionFeedback } from '@openapi-flow/core';
 export interface PlanNativeNodesInput extends NativeNodePlanningInput {
     model?: BaseChatModel;
     includeExplanations?: boolean;
@@ -25,6 +25,8 @@ export interface NativeNodeModelProposal {
     nativeNodes: NativeNodeModelInstance[];
     gaps: NativePlanningProposal['gaps'];
 }
+/** Used only when code proves that no offered capability has a parameter choice in this call. */
+export type NativeNodeGapOnlyOutput = Pick<NativePlanningProposal, 'gaps'>;
 export interface ExplainedNativeNodeProposal {
     node: NativeNodeModelInstance;
     reason: string;
@@ -38,7 +40,7 @@ export interface ExplainedNativeNodePlanningOutput {
         gaps: NativePlanningProposal['gaps'];
     };
 }
-export type NativeNodePlanningOutput = NativeNodeModelProposal | ExplainedNativeNodePlanningOutput;
+export type NativeNodePlanningOutput = NativeNodeModelProposal | ExplainedNativeNodePlanningOutput | NativeNodeGapOnlyOutput;
 export interface ResolvedNativeNodePlanningOutput {
     proposal: NativeNodeProposal;
     assessment?: NativePlanningAssessment;
@@ -68,6 +70,8 @@ export type NativeNodePlanningFailure = {
 export interface SelectNativeNodeInstancesInput extends NativeInstanceSelectionInput {
     model?: BaseChatModel;
     signal?: AbortSignal;
+    /** Explicit independently reviewed rejection. Never causes a hidden retry. */
+    feedback?: NativeInstanceSelectionFeedback;
 }
 export interface GenerateNativeNodeParametersInput extends NativeNodeConfigurationInput {
     model?: BaseChatModel;

package/dist/types/workflow-connection-goal-recovery.d.ts

@@ -0,0 +1,22 @@
+import type { WorkflowConnectionSession, WorkflowConnectionSourceRepairRequest, WorkflowConnectionMaterialRepairRequest, WorkflowConnectionGoalPlanningDescription, WorkflowConnectionConflictMaterials, WorkflowReviewedGoalCandidate } from '@openapi-flow/core';
+import type { PlanWorkflowConnectionGoalsInput, WorkflowConnectionGoalRejection, WorkflowConnectionGoalSelection } from './incremental-connection-planning.js';
+export interface PlanWorkflowConnectionGoalRecoveryInput extends PlanWorkflowConnectionGoalsInput {
+    rejectedProposals: WorkflowConnectionGoalRejection[];
+}
+export interface WorkflowConnectionGoalRecoveryDescription extends WorkflowConnectionGoalPlanningDescription {
+    conflictMaterials: WorkflowConnectionConflictMaterials;
+    rejectedProposals: WorkflowConnectionGoalRejection[];
+    rejectedGoalReviews?: WorkflowReviewedGoalCandidate[];
+}
+export interface WorkflowConnectionRecoveredGoalSelection {
+    kind: 'goals';
+    goals: WorkflowConnectionGoalSelection[];
+}
+export interface WorkflowConnectionGoalRecoveryModelOutput {
+    decision: WorkflowConnectionRecoveredGoalSelection | WorkflowConnectionMaterialRepairRequest;
+}
+export interface RecoveredWorkflowConnectionGoals {
+    kind: 'goals';
+    session: WorkflowConnectionSession;
+}
+export type PlanWorkflowConnectionGoalRecoveryResult = RecoveredWorkflowConnectionGoals | WorkflowConnectionSourceRepairRequest;

package/dist/types/workflow-connection-goal-recovery.js

@@ -0,0 +1 @@
+export {};

package/dist/types/workflow-connection-goal-review.d.ts

@@ -0,0 +1,13 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { WorkflowConnectionSessionInput, WorkflowConnectionGoalReviewProposal, WorkflowConnectionSessionSource, WorkflowReviewedGoalCandidate } from '@openapi-flow/core';
+export interface ReviewWorkflowConnectionGoalsInput extends WorkflowConnectionSessionInput {
+    model: BaseChatModel;
+    signal?: AbortSignal;
+}
+export type WorkflowConnectionGoalReviewAssessment = Omit<WorkflowConnectionGoalReviewProposal['assessments'][number], 'factId'>;
+export interface WorkflowConnectionGoalReviewModelOutput {
+    assessments: Record<string, WorkflowConnectionGoalReviewAssessment>;
+}
+export interface ValidateWorkflowGoalReviewFeedbackInput extends WorkflowConnectionSessionSource {
+    rejectedGoalReviews?: WorkflowReviewedGoalCandidate[];
+}

package/dist/types/workflow-connection-goal-review.js

@@ -0,0 +1 @@
+export {};

package/dist/types/workflow-connection-outline.d.ts

@@ -0,0 +1,22 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { z } from 'zod';
+import type { workflowConnectionOutlineRejectionSchema } from '../schemas/workflow-connection-outline-rejection-schema.js';
+import type { WorkflowConnectionSessionInput, WorkflowConnectionOutline, WorkflowConnectionStepDescription } from '@openapi-flow/core';
+export interface WorkflowConnectionOutlineRequestInput extends WorkflowConnectionSessionInput {
+    /** A revisable grouping hypothesis, never replacement user requirements or execution edges. */
+    previousOutline?: WorkflowConnectionOutline;
+}
+export interface WorkflowConnectionOutlineRequestDescription {
+    description: WorkflowConnectionStepDescription;
+    previousOutline?: WorkflowConnectionOutline;
+    requestFingerprint: string;
+}
+export type WorkflowConnectionOutlineRejection = z.infer<typeof workflowConnectionOutlineRejectionSchema>;
+export interface CreateWorkflowConnectionOutlineRejectionInput extends WorkflowConnectionOutlineRequestInput {
+    error: unknown;
+}
+export interface PlanWorkflowConnectionOutlineInput extends WorkflowConnectionOutlineRequestInput {
+    model: BaseChatModel;
+    signal?: AbortSignal;
+    rejectedProposals?: WorkflowConnectionOutlineRejection[];
+}

package/dist/types/workflow-connection-outline.js

@@ -0,0 +1 @@
+export {};

package/dist/types/workflow-connection-revision.d.ts

@@ -0,0 +1,34 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { z } from 'zod';
+import type { workflowConnectionRevisionRejectionSchema } from '../schemas/workflow-connection-revision-rejection-schema.js';
+import type { WorkflowConnectionRevisionInput, WorkflowConnectionRevision, WorkflowConnectionMaterialRepairRequest, WorkflowConnectionMaterialRepairReceipt, WorkflowConnectionRejectedProposal, WorkflowConnectionGoalReview } from '@openapi-flow/core';
+import type { WorkflowConnectionGoalSelection, WorkflowConnectionPatchSelection } from './incremental-connection-planning.js';
+export interface PlanWorkflowConnectionRevisionInput extends WorkflowConnectionRevisionInput {
+    model: BaseChatModel;
+    signal?: AbortSignal;
+    rejectedProposals?: WorkflowConnectionRevisionRejection[];
+    rejectedConnections?: WorkflowConnectionRejectedProposal[];
+    rejectedGoalReviews?: WorkflowReviewedConnectionRevision[];
+}
+export interface WorkflowReviewedConnectionRevision {
+    revision: WorkflowConnectionRevision;
+    review: WorkflowConnectionGoalReview;
+}
+export type WorkflowConnectionRevisionRejection = z.infer<typeof workflowConnectionRevisionRejectionSchema>;
+export interface CreateWorkflowConnectionRevisionRejectionInput extends WorkflowConnectionRevisionInput {
+    error: unknown;
+}
+export interface WorkflowConnectionRevisionSelection {
+    kind: 'revise-connections';
+    goals: WorkflowConnectionGoalSelection[];
+    graphChange: WorkflowConnectionPatchSelection;
+}
+export type WorkflowConnectionRevisionModelDecision = WorkflowConnectionRevisionSelection | WorkflowConnectionMaterialRepairRequest;
+export interface WorkflowConnectionRevisionModelOutput {
+    decision: WorkflowConnectionRevisionModelDecision;
+}
+export interface RevisedWorkflowConnections {
+    kind: 'revised-connections';
+    revision: WorkflowConnectionRevision;
+}
+export type PlanWorkflowConnectionRevisionResult = RevisedWorkflowConnections | WorkflowConnectionMaterialRepairReceipt;

package/dist/types/workflow-connection-revision.js

@@ -0,0 +1 @@
+export {};

package/dist/workflow/connections/create-workflow-connection-goal-rejection.js

@@ -1,12 +1,15 @@
 import { isDeepStrictEqual } from 'node:util';
-import { describeWorkflowConnectionGoals } from '@openapi-flow/core';
+import { describeWorkflowConnectionGoals, WorkflowPlanningConstraintError, } from '@openapi-flow/core';
 import { workflowConnectionGoalRejectionSchema } from '../../schemas/workflow-connection-goal-rejection-schema.js';
 import { WorkflowConnectionPlanningError } from './workflow-connection-planning-error.js';
 /** Classify an unchanged-source proposal rejection. Other failures must remain failures. */
 export function createWorkflowConnectionGoalRejection(input) {
     const { error } = input;
     if (!(error instanceof WorkflowConnectionPlanningError) ||
-        error.diagnostic.operation !== 'planWorkflowConnectionGoals' ||
+        ![
+            'planWorkflowConnectionGoals',
+            'planWorkflowConnectionGoalRecovery',
+        ].includes(error.diagnostic.operation) ||
         !['model-output', 'contract-validation'].includes(error.diagnostic.stage) ||
         error.sourceFingerprint === undefined)
         return undefined;
@@ -19,6 +22,9 @@ export function createWorkflowConnectionGoalRejection(input) {
         code: error.diagnostic.code,
         output: error.output,
         reason: error.message,
+        ...(error.cause instanceof WorkflowPlanningConstraintError
+            ? { constraints: error.cause.inspection }
+            : {}),
     });
     // Non-JSON results cannot be checkpointed losslessly; never repair them to enable a retry.
     if (!parsed.success || !isDeepStrictEqual(parsed.data.output, error.output))

package/dist/workflow/connections/create-workflow-connection-outline-rejection.d.ts

@@ -0,0 +1,3 @@
+import type { CreateWorkflowConnectionOutlineRejectionInput, WorkflowConnectionOutlineRejection } from '../../types/workflow-connection-outline.js';
+/** Classify only lossless proposal failures from this unchanged outline request. */
+export declare function createWorkflowConnectionOutlineRejection(input: CreateWorkflowConnectionOutlineRejectionInput): WorkflowConnectionOutlineRejection | undefined;

package/dist/workflow/connections/create-workflow-connection-outline-rejection.js

@@ -0,0 +1,28 @@
+import { isDeepStrictEqual } from 'node:util';
+import { workflowConnectionOutlineRejectionSchema } from '../../schemas/workflow-connection-outline-rejection-schema.js';
+import { describeWorkflowConnectionOutlineRequest } from './describe-workflow-connection-outline-request.js';
+import { WorkflowConnectionPlanningError } from './workflow-connection-planning-error.js';
+/** Classify only lossless proposal failures from this unchanged outline request. */
+export function createWorkflowConnectionOutlineRejection(input) {
+    const { error } = input;
+    if (!(error instanceof WorkflowConnectionPlanningError) ||
+        error.diagnostic.operation !== 'planWorkflowConnectionOutline' ||
+        !['model-output', 'contract-validation'].includes(error.diagnostic.stage) ||
+        error.requestFingerprint === undefined)
+        return undefined;
+    const current = describeWorkflowConnectionOutlineRequest(input);
+    if (error.requestFingerprint !== current.requestFingerprint ||
+        error.sourceFingerprint !== current.description.expected.sourceFingerprint)
+        return undefined;
+    const parsed = workflowConnectionOutlineRejectionSchema.safeParse({
+        requestFingerprint: current.requestFingerprint,
+        expected: current.description.expected,
+        stage: error.diagnostic.stage,
+        code: error.diagnostic.code,
+        output: error.output,
+        reason: error.message,
+    });
+    if (!parsed.success || !isDeepStrictEqual(parsed.data.output, error.output))
+        return undefined;
+    return structuredClone(parsed.data);
+}

package/dist/workflow/connections/create-workflow-connection-revision-rejection.d.ts

@@ -0,0 +1,3 @@
+import type { CreateWorkflowConnectionRevisionRejectionInput, WorkflowConnectionRevisionRejection } from '../../types/workflow-connection-revision.js';
+/** Classify a lossless proposal rejection only. Never convert transport, cancellation or changed-source failures into retries. */
+export declare function createWorkflowConnectionRevisionRejection(input: CreateWorkflowConnectionRevisionRejectionInput): WorkflowConnectionRevisionRejection | undefined;

package/dist/workflow/connections/create-workflow-connection-revision-rejection.js

@@ -0,0 +1,32 @@
+import { isDeepStrictEqual } from 'node:util';
+import { describeWorkflowConnectionRevision, WorkflowConnectionRevisionError, WorkflowPlanningConstraintError, } from '@openapi-flow/core';
+import { workflowConnectionRevisionRejectionSchema } from '../../schemas/workflow-connection-revision-rejection-schema.js';
+import { WorkflowConnectionPlanningError } from './workflow-connection-planning-error.js';
+/** Classify a lossless proposal rejection only. Never convert transport, cancellation or changed-source failures into retries. */
+export function createWorkflowConnectionRevisionRejection(input) {
+    const { error } = input;
+    if (!(error instanceof WorkflowConnectionPlanningError) ||
+        error.diagnostic.operation !== 'planWorkflowConnectionRevision' ||
+        !['model-output', 'contract-validation'].includes(error.diagnostic.stage))
+        return undefined;
+    const current = describeWorkflowConnectionRevision(input);
+    if (error.sourceFingerprint !== current.sourceFingerprint)
+        return undefined;
+    const parsed = workflowConnectionRevisionRejectionSchema.safeParse({
+        sourceFingerprint: current.sourceFingerprint,
+        expected: current.before.expected,
+        stage: error.diagnostic.stage,
+        code: error.diagnostic.code,
+        output: error.output,
+        reason: error.message,
+        ...(error.cause instanceof WorkflowConnectionRevisionError
+            ? { violations: error.cause.violations }
+            : {}),
+        ...(error.cause instanceof WorkflowPlanningConstraintError
+            ? { constraints: error.cause.inspection }
+            : {}),
+    });
+    if (!parsed.success || !isDeepStrictEqual(parsed.data.output, error.output))
+        return undefined;
+    return structuredClone(parsed.data);
+}

package/dist/workflow/connections/describe-workflow-connection-outline-request.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowConnectionOutlineRequestInput, WorkflowConnectionOutlineRequestDescription } from '../../types/workflow-connection-outline.js';
+/** Replanning feedback belongs to this exact session revision and grouping hypothesis. */
+export declare function describeWorkflowConnectionOutlineRequest(input: WorkflowConnectionOutlineRequestInput): WorkflowConnectionOutlineRequestDescription;

package/dist/workflow/connections/describe-workflow-connection-outline-request.js

@@ -0,0 +1,30 @@
+import { createHash } from 'node:crypto';
+import { describeWorkflowConnectionStep, describeWorkflowConnectionOutline, runOpenApiFlowOperation, } from '@openapi-flow/core';
+/** Replanning feedback belongs to this exact session revision and grouping hypothesis. */
+export function describeWorkflowConnectionOutlineRequest(input) {
+    return runOpenApiFlowOperation({
+        owner: 'langchain',
+        operation: 'describeWorkflowConnectionOutlineRequest',
+        stage: 'input-validation',
+        code: 'PLANNING_INPUT_INVALID',
+    }, () => {
+        const description = describeWorkflowConnectionStep(input);
+        if (input.previousOutline !== undefined)
+            describeWorkflowConnectionOutline({
+                ...input,
+                outline: input.previousOutline,
+            });
+        const context = {
+            description,
+            ...(input.previousOutline === undefined
+                ? {}
+                : { previousOutline: structuredClone(input.previousOutline) }),
+        };
+        return {
+            ...context,
+            requestFingerprint: createHash('sha256')
+                .update(JSON.stringify(context))
+                .digest('hex'),
+        };
+    });
+}

package/dist/workflow/connections/invoke-connection-planning-model.js

@@ -29,6 +29,9 @@ export async function invokeConnectionPlanningModel(input) {
         ...(input.sourceFingerprint === undefined
             ? {}
             : { sourceFingerprint: input.sourceFingerprint }),
+        ...(input.requestFingerprint === undefined
+            ? {}
+            : { requestFingerprint: input.requestFingerprint }),
     }, () => {
         const parsed = input.schema.parse(output);
         if (!isDeepStrictEqual(parsed, output))

package/dist/workflow/connections/plan-workflow-connection-goal-recovery.d.ts

@@ -0,0 +1,3 @@
+import type { PlanWorkflowConnectionGoalRecoveryInput, PlanWorkflowConnectionGoalRecoveryResult } from '../../types/workflow-connection-goal-recovery.js';
+/** One reconsideration before any accepted session exists. The host owns originating-stage invocation and budgets. */
+export declare function planWorkflowConnectionGoalRecovery(input: PlanWorkflowConnectionGoalRecoveryInput): Promise<PlanWorkflowConnectionGoalRecoveryResult>;

package/dist/workflow/connections/plan-workflow-connection-goal-recovery.js

@@ -0,0 +1,111 @@
+import { isDeepStrictEqual } from 'node:util';
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowConnectionGoals, describeWorkflowConnectionConflictMaterials, createWorkflowConnectionSession, validateWorkflowConnectionSourceRepairRequest, runOpenApiFlowOperation, } from '@openapi-flow/core';
+import { modelSignalSchema } from '../../schemas/model-signal-schema.js';
+import { workflowConnectionGoalRejectionSchema } from '../../schemas/workflow-connection-goal-rejection-schema.js';
+import { createWorkflowConnectionGoalRecoverySchema } from '../../schemas/workflow-connection-goal-recovery-schema.js';
+import { workflowConnectionGoalRecoveryPrompt } from '../../prompts/workflow-connection-goal-recovery-prompt.js';
+import { invokeConnectionPlanningModel } from './invoke-connection-planning-model.js';
+import { resolveConnectionGoalSelections } from './resolve-connection-selections.js';
+import { validateWorkflowGoalReviewFeedback } from './validate-workflow-goal-review-feedback.js';
+import { WorkflowConnectionPlanningError, validateConnectionProposal, } from './workflow-connection-planning-error.js';
+function describeRecovery(input) {
+    modelSignalSchema.parse(input.signal);
+    const description = describeWorkflowConnectionGoals(input);
+    const reviews = validateWorkflowGoalReviewFeedback(input);
+    if (!Array.isArray(input.rejectedProposals) ||
+        (!input.rejectedProposals.length && !reviews.length))
+        throw new Error('Goal recovery requires rejectedProposals');
+    for (const value of input.rejectedProposals) {
+        const checked = workflowConnectionGoalRejectionSchema.parse(value);
+        if (!isDeepStrictEqual(value, checked) ||
+            value.sourceFingerprint !== description.sourceFingerprint)
+            throw new Error('Goal recovery requires unchanged source and lossless rejection evidence');
+    }
+    const nodes = [
+        ...new Set(input.rejectedProposals
+            .flatMap((rejection) => rejection.stage === 'contract-validation' &&
+            rejection.constraints !== undefined
+            ? rejection.constraints.conflicts.flatMap((conflict) => conflict.nodeIds)
+            : [])
+            .concat(reviews.length
+            ? description.context.nodes.map((node) => node.id)
+            : [])),
+    ];
+    if (!nodes.length && !reviews.length)
+        throw new Error('Goal recovery requires code-owned conflict evidence');
+    return {
+        ...description,
+        conflictMaterials: nodes.length === 0
+            ? { apiCalls: [], nativeNodes: [], apiResponseContracts: [] }
+            : describeWorkflowConnectionConflictMaterials({
+                source: input,
+                nodeIds: nodes,
+            }),
+        rejectedProposals: structuredClone(input.rejectedProposals),
+        ...(input.rejectedGoalReviews === undefined
+            ? {}
+            : { rejectedGoalReviews: reviews }),
+    };
+}
+/** One reconsideration before any accepted session exists. The host owns originating-stage invocation and budgets. */
+export async function planWorkflowConnectionGoalRecovery(input) {
+    const operation = 'planWorkflowConnectionGoalRecovery';
+    const description = runOpenApiFlowOperation({
+        owner: 'langchain',
+        operation,
+        stage: 'input-validation',
+        code: 'PLANNING_INPUT_INVALID',
+    }, () => describeRecovery(input));
+    const checkCurrent = (output) => validateConnectionProposal({
+        operation,
+        stage: 'input-validation',
+        code: 'PLANNING_INPUT_INVALID',
+        output,
+        sourceFingerprint: description.sourceFingerprint,
+    }, () => {
+        if (!isDeepStrictEqual(describeRecovery(input), description))
+            throw new Error('Goal recovery source or rejection evidence changed during model invocation');
+    });
+    const output = await invokeConnectionPlanningModel({
+        model: input.model,
+        operation,
+        name: 'plan_workflow_connection_goal_recovery',
+        schema: createWorkflowConnectionGoalRecoverySchema(description),
+        sourceFingerprint: description.sourceFingerprint,
+        messages: [
+            new SystemMessage(workflowConnectionGoalRecoveryPrompt),
+            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,
+    }, () => {
+        if (output.decision.kind === 'goals')
+            return {
+                kind: 'goals',
+                session: createWorkflowConnectionSession({
+                    ...input,
+                    goals: resolveConnectionGoalSelections(output.decision.goals, description.context.nodes),
+                }),
+            };
+        const request = {
+            kind: 'replan-materials',
+            sourceFingerprint: description.sourceFingerprint,
+            request: output.decision,
+        };
+        validateWorkflowConnectionSourceRepairRequest({ source: input, request });
+        return request;
+    });
+}

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

@@ -1,15 +1,17 @@
 import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { isDeepStrictEqual } from 'node:util';
 import { describeWorkflowConnectionGoals, createWorkflowConnectionSession, runOpenApiFlowOperation, } from '@openapi-flow/core';
 import { createWorkflowConnectionGoalsSchema } from '../../schemas/workflow-connection-goals-schema.js';
 import { workflowConnectionGoalRejectionSchema } from '../../schemas/workflow-connection-goal-rejection-schema.js';
 import { workflowConnectionGoalsPrompt } 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 { resolveConnectionGoalSelections } from './resolve-connection-selections.js';
+import { validateConnectionProposal, WorkflowConnectionPlanningError, } from './workflow-connection-planning-error.js';
+import { validateWorkflowGoalReviewFeedback } from './validate-workflow-goal-review-feedback.js';
 /** One semantic interpretation; code validates coverage/identities and creates the initial session. */
 export async function planWorkflowConnectionGoals(input) {
     const operation = 'planWorkflowConnectionGoals';
-    const { description, schema } = runOpenApiFlowOperation({
+    const { description, schema, rejectedGoalReviews } = runOpenApiFlowOperation({
         owner: 'langchain',
         operation,
         stage: 'input-validation',
@@ -27,9 +29,29 @@ export async function planWorkflowConnectionGoals(input) {
         }
         return {
             description,
+            rejectedGoalReviews: validateWorkflowGoalReviewFeedback(input),
             schema: createWorkflowConnectionGoalsSchema(description),
         };
     });
+    const checkCurrent = (output, originalFailure) => validateConnectionProposal({
+        operation,
+        stage: 'input-validation',
+        code: 'PLANNING_INPUT_INVALID',
+        output,
+        sourceFingerprint: description.sourceFingerprint,
+    }, () => {
+        try {
+            if (describeWorkflowConnectionGoals(input).sourceFingerprint !==
+                description.sourceFingerprint ||
+                !isDeepStrictEqual(validateWorkflowGoalReviewFeedback(input), rejectedGoalReviews))
+                throw new Error('Connection goal source or review evidence changed during model invocation');
+        }
+        catch (error) {
+            if (originalFailure === undefined)
+                throw error;
+            throw new AggregateError([originalFailure, error], 'Connection goal source or review evidence changed during malformed model output', { cause: error });
+        }
+    });
     const output = await invokeConnectionPlanningModel({
         model: input.model,
         operation,
@@ -43,10 +65,19 @@ export async function planWorkflowConnectionGoals(input) {
                 ...(input.rejectedProposals === undefined
                     ? {}
                     : { rejectedProposals: input.rejectedProposals }),
+                ...(input.rejectedGoalReviews === undefined
+                    ? {}
+                    : { rejectedGoalReviews }),
             })),
         ],
         ...(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',
@@ -54,19 +85,7 @@ export async function planWorkflowConnectionGoals(input) {
         output,
         sourceFingerprint: description.sourceFingerprint,
     }, () => {
-        if (describeWorkflowConnectionGoals(input).sourceFingerprint !==
-            description.sourceFingerprint)
-            throw new Error('Connection goal source changed during model invocation');
-        const goals = output.goals.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, description.context.nodes, 'outputs'),
-            });
+        const goals = resolveConnectionGoalSelections(output.goals, description.context.nodes);
         return createWorkflowConnectionSession({ ...input, goals });
     });
 }

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

@@ -0,0 +1,4 @@
+import type { WorkflowConnectionOutline } from '@openapi-flow/core';
+import type { PlanWorkflowConnectionOutlineInput } from '../../types/workflow-connection-outline.js';
+/** One outline proposal; the host owns selection, retry, checkpoints and adoption. */
+export declare function planWorkflowConnectionOutline(input: PlanWorkflowConnectionOutlineInput): Promise<WorkflowConnectionOutline>;