@openapi-flow/langchain 0.3.17 → 0.4.0

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

@@ -0,0 +1,81 @@
+import { isDeepStrictEqual } from 'node:util';
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeNativeInstanceSelectionReview, createNativeInstanceSelectionReview, createNativeInstanceSelectionReviewSchema, runOpenApiFlowOperation, } from '@openapi-flow/core';
+import { invokeStructuredModel } from '../../model/invoke-structured-model.js';
+import { serializeStructuredOutputSchema } from '../../schemas/serialize-structured-output-schema.js';
+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';
+/** One review call only. The host owns replanning, user questions, budgets and persistence. */
+export async function reviewNativeInstanceSelection(input) {
+    const operation = 'reviewNativeInstanceSelection';
+    const description = runOpenApiFlowOperation({
+        owner: 'langchain',
+        operation,
+        stage: 'input-validation',
+        code: 'PLANNING_INPUT_INVALID',
+    }, () => {
+        modelSignalSchema.parse(input.signal);
+        return describeNativeInstanceSelectionReview(input);
+    });
+    input.signal?.throwIfAborted();
+    if (!description.gaps.length)
+        return createNativeInstanceSelectionReview({
+            ...input,
+            proposal: { assessments: {} },
+        });
+    const model = runOpenApiFlowOperation({
+        owner: 'langchain',
+        operation,
+        stage: 'model-configuration',
+        code: 'MODEL_CONFIGURATION_FAILED',
+    }, () => {
+        if (!input.model ||
+            typeof input.model.withStructuredOutput !== 'function')
+            throw new Error('reviewNativeInstanceSelection.model must support structured output for reported gaps');
+        return input.model;
+    });
+    const checkCurrent = (originalFailure) => {
+        runOpenApiFlowOperation({
+            owner: 'langchain',
+            operation,
+            stage: 'input-validation',
+            code: 'PLANNING_INPUT_INVALID',
+        }, () => {
+            try {
+                if (!isDeepStrictEqual(description, describeNativeInstanceSelectionReview(input)))
+                    throw new Error('Native selection review source changed during model invocation');
+            }
+            catch (error) {
+                if (originalFailure !== undefined)
+                    throw new AggregateError([originalFailure, error], 'Native review input changed while a failed model call was received', { cause: error });
+                throw error;
+            }
+        });
+    };
+    const output = await invokeStructuredModel({
+        operation,
+        model,
+        schema: serializeStructuredOutputSchema(createNativeInstanceSelectionReviewSchema(description), 'draft-2020-12'),
+        name: 'review_native_instance_selection',
+        method: 'jsonSchema',
+        strict: true,
+        messages: [
+            new SystemMessage(nativeInstanceSelectionReviewPrompt),
+            new HumanMessage(JSON.stringify(description)),
+        ],
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    }).catch((error) => {
+        checkCurrent(error);
+        throw error;
+    });
+    checkCurrent();
+    try {
+        return createNativeInstanceSelectionReview({ ...input, proposal: output });
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new NativeInstanceSelectionReviewError({ output }, cause);
+    }
+}

package/dist/workflow/resolve-native-node-planning-output.js

@@ -1,13 +1,15 @@
 import { resolveNativeNodeParameterSource } from './resolve-native-node-parameter-source.js';
 /** Structural projection only: no values, identities or unmet requirements are repaired. */
 export function resolveNativeNodePlanningOutput(output) {
-    if (!('decision' in output))
+    if ('nativeNodes' in output)
         return {
             proposal: {
                 nativeNodes: output.nativeNodes.map(resolveNativeNodeParameterSource),
                 gaps: output.gaps,
             },
         };
+    if ('gaps' in output)
+        return { proposal: { nativeNodes: [], gaps: output.gaps } };
     const { decision } = output;
     if ('additions' in decision)
         return {

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

@@ -1,6 +1,6 @@
 import { HumanMessage, SystemMessage } from '@langchain/core/messages';
 import { isDeepStrictEqual } from 'node:util';
-import { createNativeInstanceSelectionSchema, describeNativeInstanceSelection, resolveNativeInstanceSelection, } from '@openapi-flow/core';
+import { createNativeInstanceSelectionSchema, describeNativeInstanceSelection, resolveNativeInstanceSelection, describeNativeInstanceSelectionFeedback, } 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';
@@ -11,6 +11,9 @@ export async function selectNativeNodeInstances(input) {
         (!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,
@@ -38,11 +41,17 @@ export async function selectNativeNodeInstances(input) {
     })
         .invoke([
         new SystemMessage(nativeInstanceSelectionPrompt),
-        new HumanMessage(JSON.stringify(context)),
+        new HumanMessage(JSON.stringify({
+            ...context,
+            ...(feedback === undefined ? {} : { selectionFeedback: feedback }),
+        })),
     ], input.signal === undefined ? undefined : { signal: input.signal });
     input.signal?.throwIfAborted();
     try {
         if (!isDeepStrictEqual(describeNativeInstanceSelection(input).context, context) ||
+            !isDeepStrictEqual(feedback, input.feedback === undefined
+                ? undefined
+                : describeNativeInstanceSelectionFeedback(input, input.feedback)) ||
             JSON.stringify([
                 input.planId,
                 input.allowRuntimeParameters,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openapi-flow/langchain",
-  "version": "0.3.17",
+  "version": "0.4.0",
   "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.3.17"
+    "@openapi-flow/core": "0.4.0"
   },
   "peerDependencies": {
     "@langchain/core": "^1.0.0",