@openapi-flow/langchain 0.4.0 → 0.4.1

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

package/dist/workflow/native-selection/create-native-planning-rejection.js

@@ -0,0 +1,45 @@
+import { isDeepStrictEqual } from 'node:util';
+import { nativePlanningRejectionSchema } from '../../schemas/native-planning-rejection-schema.js';
+import { NativeNodePlanningError } from '../native-node-planning-error.js';
+import { NativeInstanceSelectionReviewError } from './native-instance-selection-review-error.js';
+import { describeNativeSelectionRequest, fingerprintNativeSelectionReviewRequest, } from './describe-native-planning-request.js';
+/** Only unchanged, source-bound output failures are eligible; transport/configuration failures are not proposals. */
+export function createNativeSelectionRejection(input) {
+    const error = input.error;
+    if (!(error instanceof NativeNodePlanningError) ||
+        error.failure.stage !== 'instance-selection' ||
+        error.failure.requestFingerprint === undefined)
+        return undefined;
+    const current = describeNativeSelectionRequest(input);
+    if (current.requestFingerprint !== error.failure.requestFingerprint)
+        return undefined;
+    const parsed = nativePlanningRejectionSchema.safeParse({
+        stage: 'instance-selection',
+        requestFingerprint: current.requestFingerprint,
+        output: error.failure.output,
+        reason: error.message,
+    });
+    if (!parsed.success ||
+        !isDeepStrictEqual(parsed.data.output, error.failure.output))
+        return undefined;
+    return structuredClone(parsed.data);
+}
+export function createNativeSelectionReviewRejection(input) {
+    const error = input.error;
+    if (!(error instanceof NativeInstanceSelectionReviewError) ||
+        error.failure.requestFingerprint === undefined)
+        return undefined;
+    const requestFingerprint = fingerprintNativeSelectionReviewRequest(input);
+    if (requestFingerprint !== error.failure.requestFingerprint)
+        return undefined;
+    const parsed = nativePlanningRejectionSchema.safeParse({
+        stage: 'selection-review',
+        requestFingerprint,
+        output: error.failure.output,
+        reason: error.message,
+    });
+    if (!parsed.success ||
+        !isDeepStrictEqual(parsed.data.output, error.failure.output))
+        return undefined;
+    return structuredClone(parsed.data);
+}

package/dist/workflow/native-selection/describe-native-planning-request.d.ts

@@ -0,0 +1,5 @@
+import type { SelectNativeNodeInstancesInput } from '../../types/native-node-planning.js';
+import type { ReviewNativeInstanceSelectionInput } from '../../types/native-instance-selection-review.js';
+import type { NativeSelectionRequestDescription } from '../../types/native-planning-rejection.js';
+export declare function describeNativeSelectionRequest(input: SelectNativeNodeInstancesInput): NativeSelectionRequestDescription;
+export declare function fingerprintNativeSelectionReviewRequest(input: ReviewNativeInstanceSelectionInput): string;

package/dist/workflow/native-selection/describe-native-planning-request.js

@@ -0,0 +1,26 @@
+import { createHash } from 'node:crypto';
+import { describeNativeInstanceSelection, describeNativeInstanceSelectionFeedback, describeNativeInstanceSelectionReview, } from '@openapi-flow/core';
+export function describeNativeSelectionRequest(input) {
+    const { context } = describeNativeInstanceSelection(input);
+    const feedback = input.feedback === undefined
+        ? undefined
+        : describeNativeInstanceSelectionFeedback(input, input.feedback);
+    return {
+        context,
+        ...(feedback === undefined ? {} : { feedback }),
+        requestFingerprint: createHash('sha256')
+            .update(JSON.stringify([
+            input.planId,
+            input.allowRuntimeParameters,
+            input.includeExplanations,
+            context,
+            feedback,
+        ]))
+            .digest('hex'),
+    };
+}
+export function fingerprintNativeSelectionReviewRequest(input) {
+    return createHash('sha256')
+        .update(JSON.stringify(describeNativeInstanceSelectionReview(input)))
+        .digest('hex');
+}

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

@@ -6,6 +6,8 @@ import { serializeStructuredOutputSchema } from '../../schemas/serialize-structu
 import { modelSignalSchema } from '../../schemas/model-signal-schema.js';
 import { nativeInstanceSelectionReviewPrompt } from '../../prompts/native-instance-selection-review-prompt.js';
 import { NativeInstanceSelectionReviewError } from './native-instance-selection-review-error.js';
+import { fingerprintNativeSelectionReviewRequest } from './describe-native-planning-request.js';
+import { validateNativePlanningRejections } from './validate-native-planning-rejections.js';
 /** One review call only. The host owns replanning, user questions, budgets and persistence. */
 export async function reviewNativeInstanceSelection(input) {
     const operation = 'reviewNativeInstanceSelection';
@@ -19,6 +21,12 @@ export async function reviewNativeInstanceSelection(input) {
         return describeNativeInstanceSelectionReview(input);
     });
     input.signal?.throwIfAborted();
+    const requestFingerprint = fingerprintNativeSelectionReviewRequest(input);
+    const rejectedProposals = validateNativePlanningRejections({
+        stage: 'selection-review',
+        requestFingerprint,
+        rejectedProposals: input.rejectedProposals,
+    });
     if (!description.gaps.length)
         return createNativeInstanceSelectionReview({
             ...input,
@@ -43,7 +51,12 @@ export async function reviewNativeInstanceSelection(input) {
             code: 'PLANNING_INPUT_INVALID',
         }, () => {
             try {
-                if (!isDeepStrictEqual(description, describeNativeInstanceSelectionReview(input)))
+                if (!isDeepStrictEqual(description, describeNativeInstanceSelectionReview(input)) ||
+                    !isDeepStrictEqual(rejectedProposals, validateNativePlanningRejections({
+                        stage: 'selection-review',
+                        requestFingerprint,
+                        rejectedProposals: input.rejectedProposals,
+                    })))
                     throw new Error('Native selection review source changed during model invocation');
             }
             catch (error) {
@@ -62,7 +75,10 @@ export async function reviewNativeInstanceSelection(input) {
         strict: true,
         messages: [
             new SystemMessage(nativeInstanceSelectionReviewPrompt),
-            new HumanMessage(JSON.stringify(description)),
+            new HumanMessage(JSON.stringify({
+                ...description,
+                ...(rejectedProposals.length === 0 ? {} : { rejectedProposals }),
+            })),
         ],
         ...(input.signal === undefined ? {} : { signal: input.signal }),
     }).catch((error) => {
@@ -76,6 +92,6 @@ export async function reviewNativeInstanceSelection(input) {
     catch (cause) {
         if (!(cause instanceof Error))
             throw cause;
-        throw new NativeInstanceSelectionReviewError({ output }, cause);
+        throw new NativeInstanceSelectionReviewError({ output, requestFingerprint }, cause);
     }
 }

package/dist/workflow/native-selection/validate-native-planning-rejections.d.ts

@@ -0,0 +1,2 @@
+import type { NativePlanningRejectedProposal, NativePlanningRejectionValidationInput } from '../../types/native-planning-rejection.js';
+export declare function validateNativePlanningRejections(input: NativePlanningRejectionValidationInput): NativePlanningRejectedProposal[];

package/dist/workflow/native-selection/validate-native-planning-rejections.js

@@ -0,0 +1,14 @@
+import { isDeepStrictEqual } from 'node:util';
+import { nativePlanningRejectionSchema } from '../../schemas/native-planning-rejection-schema.js';
+export function validateNativePlanningRejections(input) {
+    if (input.rejectedProposals === undefined)
+        return [];
+    const parsed = nativePlanningRejectionSchema
+        .array()
+        .parse(input.rejectedProposals);
+    if (!isDeepStrictEqual(parsed, input.rejectedProposals) ||
+        parsed.some((entry) => entry.stage !== input.stage ||
+            entry.requestFingerprint !== input.requestFingerprint))
+        throw new Error('Native rejectedProposals belong to a changed source or different planning stage');
+    return structuredClone(parsed);
+}

package/dist/workflow/select-native-node-instances.js

@@ -1,24 +1,40 @@
 import { HumanMessage, SystemMessage } from '@langchain/core/messages';
 import { isDeepStrictEqual } from 'node:util';
-import { createNativeInstanceSelectionSchema, describeNativeInstanceSelection, resolveNativeInstanceSelection, describeNativeInstanceSelectionFeedback, } from '@openapi-flow/core';
+import { createNativeInstanceSelectionSchema, resolveNativeInstanceSelection, } from '@openapi-flow/core';
 import { serializeStructuredOutputSchema } from '../schemas/serialize-structured-output-schema.js';
 import { nativeInstanceSelectionPrompt } from '../prompts/native-node-planning-prompt.js';
 import { NativeNodePlanningError } from './native-node-planning-error.js';
+import { describeNativeSelectionRequest } from './native-selection/describe-native-planning-request.js';
+import { validateNativePlanningRejections } from './native-selection/validate-native-planning-rejections.js';
 /** One checkpointable role/ownership selection; parameter values are a separate public stage. */
 export async function selectNativeNodeInstances(input) {
     input.signal?.throwIfAborted();
     if (input.model !== undefined &&
         (!input.model || typeof input.model.withStructuredOutput !== 'function'))
         throw new Error('selectNativeNodeInstances.model must support structured output when supplied');
-    const { context } = describeNativeInstanceSelection(input);
-    const feedback = input.feedback === undefined
-        ? undefined
-        : describeNativeInstanceSelectionFeedback(input, input.feedback);
-    const originalOptions = JSON.stringify([
-        input.planId,
-        input.allowRuntimeParameters,
-        input.includeExplanations,
-    ]);
+    const request = describeNativeSelectionRequest(input);
+    const { context, feedback, requestFingerprint } = request;
+    const rejectedProposals = validateNativePlanningRejections({
+        stage: 'instance-selection',
+        requestFingerprint,
+        rejectedProposals: input.rejectedProposals,
+    });
+    const checkCurrent = (failure) => {
+        try {
+            if (!isDeepStrictEqual(request, describeNativeSelectionRequest(input)) ||
+                !isDeepStrictEqual(rejectedProposals, validateNativePlanningRejections({
+                    stage: 'instance-selection',
+                    requestFingerprint,
+                    rejectedProposals: input.rejectedProposals,
+                })))
+                throw new Error('Native instance source contracts changed during selection; no automatic rebase');
+        }
+        catch (cause) {
+            if (failure !== undefined)
+                throw new AggregateError([failure, cause], 'Native selection input changed while a failed model call was received', { cause });
+            throw cause;
+        }
+    };
     const schema = createNativeInstanceSelectionSchema(input);
     if (!context.capabilities.length)
         return resolveNativeInstanceSelection({
@@ -44,25 +60,27 @@ export async function selectNativeNodeInstances(input) {
         new HumanMessage(JSON.stringify({
             ...context,
             ...(feedback === undefined ? {} : { selectionFeedback: feedback }),
+            ...(rejectedProposals.length === 0 ? {} : { rejectedProposals }),
         })),
-    ], input.signal === undefined ? undefined : { signal: input.signal });
+    ], input.signal === undefined ? undefined : { signal: input.signal })
+        .catch((error) => {
+        checkCurrent(error);
+        throw error;
+    });
     input.signal?.throwIfAborted();
+    let unchanged = false;
     try {
-        if (!isDeepStrictEqual(describeNativeInstanceSelection(input).context, context) ||
-            !isDeepStrictEqual(feedback, input.feedback === undefined
-                ? undefined
-                : describeNativeInstanceSelectionFeedback(input, input.feedback)) ||
-            JSON.stringify([
-                input.planId,
-                input.allowRuntimeParameters,
-                input.includeExplanations,
-            ]) !== originalOptions)
-            throw new Error('Native instance source contracts changed during selection; no automatic rebase');
+        checkCurrent();
+        unchanged = true;
         return resolveNativeInstanceSelection({ ...input, proposal: output });
     }
     catch (cause) {
         if (!(cause instanceof Error))
             throw cause;
-        throw new NativeNodePlanningError({ stage: 'instance-selection', output }, cause);
+        throw new NativeNodePlanningError({
+            stage: 'instance-selection',
+            output,
+            ...(unchanged ? { requestFingerprint } : {}),
+        }, cause);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openapi-flow/langchain",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "license": "MIT",
   "type": "module",
   "description": "Composable LangChain planning for OpenAPI workflows",
@@ -28,7 +28,7 @@
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
-    "@openapi-flow/core": "0.4.0"
+    "@openapi-flow/core": "0.4.1"
   },
   "peerDependencies": {
     "@langchain/core": "^1.0.0",