@openapi-flow/langchain 0.3.18 → 0.4.1

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/generate-workflow-connection-native-parameters.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowConnectionNativeParameterResult } from '@openapi-flow/core';
+import type { GenerateWorkflowConnectionNativeParametersInput } from '../../types/workflow-connection-native-repair.js';
+/** One existing instance, checked selected producers, and at most one value decision. */
+export declare function generateWorkflowConnectionNativeParameters(input: GenerateWorkflowConnectionNativeParametersInput): Promise<WorkflowConnectionNativeParameterResult>;

package/dist/workflow/connections/generate-workflow-connection-native-parameters.js

@@ -0,0 +1,80 @@
+import { isDeepStrictEqual } from 'node:util';
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowConnectionNativeParameters, createWorkflowConnectionNativeParametersSchema, resolveWorkflowConnectionNativeParameters, runOpenApiFlowOperation, } from '@openapi-flow/core';
+import { invokeStructuredModel } from '../../model/invoke-structured-model.js';
+import { workflowConnectionNativeRepairPrompt } from '../../prompts/workflow-connection-native-repair-prompt.js';
+import { modelSignalSchema } from '../../schemas/model-signal-schema.js';
+import { WorkflowConnectionNativeRepairError } from './workflow-connection-native-repair-error.js';
+/** One existing instance, checked selected producers, and at most one value decision. */
+export async function generateWorkflowConnectionNativeParameters(input) {
+    const context = runOpenApiFlowOperation({
+        owner: 'langchain',
+        operation: 'generateWorkflowConnectionNativeParameters',
+        stage: 'input-validation',
+        code: 'PLANNING_INPUT_INVALID',
+    }, () => {
+        modelSignalSchema.parse(input.signal);
+        if (input.model !== undefined &&
+            (!input.model || typeof input.model.withStructuredOutput !== 'function'))
+            throw new Error('generateWorkflowConnectionNativeParameters.model must support structured output when supplied');
+        return describeWorkflowConnectionNativeParameters(input);
+    });
+    input.signal?.throwIfAborted();
+    if (!context.hasLiteralParameters)
+        return resolveWorkflowConnectionNativeParameters({
+            ...input,
+            fingerprint: context.fingerprint,
+            proposal: {
+                decision: {
+                    status: 'provided',
+                    parameters: {},
+                    ...(input.includeExplanations === true
+                        ? {
+                            reason: 'The original ownership contract leaves no literal setting choice.',
+                        }
+                        : {}),
+                },
+            },
+        });
+    if (!input.model)
+        throw new Error('generateWorkflowConnectionNativeParameters.model is required for remaining settings');
+    const output = await invokeStructuredModel({
+        model: input.model,
+        schema: createWorkflowConnectionNativeParametersSchema(input),
+        operation: 'generateWorkflowConnectionNativeParameters',
+        name: 'repair_native_parameters',
+        method: 'functionCalling',
+        strict: true,
+        signal: input.signal,
+        messages: [
+            new SystemMessage(workflowConnectionNativeRepairPrompt),
+            new HumanMessage(JSON.stringify(context)),
+        ],
+    });
+    input.signal?.throwIfAborted();
+    return runOpenApiFlowOperation({
+        owner: 'langchain',
+        operation: 'generateWorkflowConnectionNativeParameters',
+        stage: 'contract-validation',
+        code: 'NATIVE_NODE_PLANNING_FAILED',
+    }, () => {
+        try {
+            if (!isDeepStrictEqual(context, describeWorkflowConnectionNativeParameters(input)))
+                throw new Error('Native repair source changed during parameter planning');
+            return resolveWorkflowConnectionNativeParameters({
+                ...input,
+                fingerprint: context.fingerprint,
+                proposal: output,
+            });
+        }
+        catch (cause) {
+            if (!(cause instanceof Error))
+                throw cause;
+            throw new WorkflowConnectionNativeRepairError({
+                operation: 'generateWorkflowConnectionNativeParameters',
+                fingerprint: context.fingerprint,
+                output,
+            }, cause);
+        }
+    });
+}

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-native-dependencies.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowConnectionNativeDependencies } from '@openapi-flow/core';
+import type { PlanWorkflowConnectionNativeDependenciesInput } from '../../types/workflow-connection-native-repair.js';
+/** Zero or one scoped decision. No retries or mutation of the original source. */
+export declare function planWorkflowConnectionNativeDependencies(input: PlanWorkflowConnectionNativeDependenciesInput): Promise<WorkflowConnectionNativeDependencies>;

package/dist/workflow/connections/plan-workflow-connection-native-dependencies.js

@@ -0,0 +1,73 @@
+import { isDeepStrictEqual } from 'node:util';
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowConnectionNativeDependencies, createWorkflowConnectionNativeDependenciesSchema, resolveWorkflowConnectionNativeDependencies, runOpenApiFlowOperation, } from '@openapi-flow/core';
+import { invokeStructuredModel } from '../../model/invoke-structured-model.js';
+import { workflowConnectionNativeRepairPrompt } from '../../prompts/workflow-connection-native-repair-prompt.js';
+import { modelSignalSchema } from '../../schemas/model-signal-schema.js';
+import { WorkflowConnectionNativeRepairError } from './workflow-connection-native-repair-error.js';
+/** Zero or one scoped decision. No retries or mutation of the original source. */
+export async function planWorkflowConnectionNativeDependencies(input) {
+    const context = runOpenApiFlowOperation({
+        owner: 'langchain',
+        operation: 'planWorkflowConnectionNativeDependencies',
+        stage: 'input-validation',
+        code: 'PLANNING_INPUT_INVALID',
+    }, () => {
+        modelSignalSchema.parse(input.signal);
+        if (input.model !== undefined &&
+            (!input.model || typeof input.model.withStructuredOutput !== 'function'))
+            throw new Error('planWorkflowConnectionNativeDependencies.model must support structured output when supplied');
+        return describeWorkflowConnectionNativeDependencies(input);
+    });
+    input.signal?.throwIfAborted();
+    if (context.targets.every((target) => target.sourceNodeIds.length === 0))
+        return resolveWorkflowConnectionNativeDependencies({
+            ...input,
+            proposal: {
+                sourcesByNodeId: Object.fromEntries(context.targets.map((target) => [
+                    target.nodeId,
+                    { sourceNodeIds: [] },
+                ])),
+            },
+        });
+    if (!input.model)
+        throw new Error('planWorkflowConnectionNativeDependencies.model is required for producer choices');
+    const output = await invokeStructuredModel({
+        model: input.model,
+        schema: createWorkflowConnectionNativeDependenciesSchema(input),
+        operation: 'planWorkflowConnectionNativeDependencies',
+        name: 'repair_native_dependencies',
+        method: 'functionCalling',
+        strict: true,
+        signal: input.signal,
+        messages: [
+            new SystemMessage(workflowConnectionNativeRepairPrompt),
+            new HumanMessage(JSON.stringify(context)),
+        ],
+    });
+    input.signal?.throwIfAborted();
+    return runOpenApiFlowOperation({
+        owner: 'langchain',
+        operation: 'planWorkflowConnectionNativeDependencies',
+        stage: 'contract-validation',
+        code: 'NATIVE_NODE_PLANNING_FAILED',
+    }, () => {
+        try {
+            if (!isDeepStrictEqual(context, describeWorkflowConnectionNativeDependencies(input)))
+                throw new Error('Native repair source changed during dependency planning');
+            return resolveWorkflowConnectionNativeDependencies({
+                ...input,
+                proposal: output,
+            });
+        }
+        catch (cause) {
+            if (!(cause instanceof Error))
+                throw cause;
+            throw new WorkflowConnectionNativeRepairError({
+                operation: 'planWorkflowConnectionNativeDependencies',
+                fingerprint: context.fingerprint,
+                output,
+            }, cause);
+        }
+    });
+}

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