@openapi-flow/langchain 0.4.0 → 0.4.2

package/dist/types/api-input-answers.d.ts

@@ -1,13 +1,9 @@
-import type { ApiInputRequirement } from '@openapi-flow/core';
+import type { ApiInputAnswerContext } from '@openapi-flow/core';
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import type { z } from 'zod';
 import type { createApiInputAnswerSourceSchema } from '../schemas/api-input-answer-source-schema.js';
-export interface ExtractApiInputAnswersInput {
-    requirements: ApiInputRequirement[];
-    reply: string;
+export interface ExtractApiInputAnswersInput extends ApiInputAnswerContext {
     model: BaseChatModel;
-    selectOasEnums?: boolean;
-    purpose?: string;
     signal?: AbortSignal;
 }
 export interface AnalyzeApiInputAnswersInput extends Omit<ExtractApiInputAnswersInput, 'model'> {

package/dist/types/argument-generation.d.ts

@@ -1,8 +1,7 @@
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import type { ApiLiteralGenerationInput, ApiCallArguments, ApiArgumentProposal, ApiLiteralProposalSource, OpenApiFlowError } from '@openapi-flow/core';
+import type { ApiLiteralGenerationInput, ApiCallArguments, ApiArgumentProposal, ApiLiteralProposalSource, OpenApiFlowError, WorkflowConnectionApiRepairContext, ApiInputLiteralSource } from '@openapi-flow/core';
 import type { z } from 'zod';
 import type { apiLiteralGenerationReasonSchema } from '../schemas/api-literal-generation-output-schema.js';
-import type { apiLiteralGenerationSourcesSchema } from '../schemas/api-literal-generation-output-schema.js';
 import type { apiLiteralNotProvidedSchema } from '../schemas/api-literal-generation-output-schema.js';
 import type { createApiLiteralProvidedSchema, createApiTrackedLiteralGenerationSchema, createApiExplainedTrackedLiteralGenerationSchema } from '../schemas/api-literal-generation-output-schema.js';
 import type { apiLiteralGenerationOptionsSchema } from '../schemas/api-literal-generation-output-schema.js';
@@ -15,6 +14,12 @@ export interface GenerateApiArgumentsInput extends ApiLiteralGenerationInput {
     /** Exact, private rejection feedback for the same source; no library-owned retries. */
     rejectedProposals?: ApiArgumentRejection[];
     signal?: AbortSignal;
+    materialRepair?: WorkflowConnectionApiRepairContext;
+}
+export interface ApiLiteralGenerationSource extends ApiInputLiteralSource {
+    targetPointer: string;
+    /** Selected only when more than one original message is supplied. */
+    messageId?: string;
 }
 export type ApiArgumentRejection = z.infer<typeof apiArgumentRejectionSchema>;
 export interface CreateApiArgumentRejectionInput extends Omit<GenerateApiArgumentsInput, 'model' | 'rejectedProposals' | 'signal'> {
@@ -35,12 +40,12 @@ export type ApiLiteralProvidedDecision = z.infer<ReturnType<typeof createApiLite
 export type ApiLiteralAvailabilityDecision = z.infer<typeof apiLiteralNotProvidedSchema> | ApiLiteralProvidedDecision;
 export type ApiTrackedLiteralGenerationOutput = z.infer<ReturnType<typeof createApiTrackedLiteralGenerationSchema>> | z.infer<ReturnType<typeof createApiExplainedTrackedLiteralGenerationSchema>>;
 export interface ApiExplainedLiteralGenerationOutput extends ApiArgumentProposal {
-    explanation: z.infer<typeof apiLiteralGenerationReasonSchema>;
+    explanation?: z.infer<typeof apiLiteralGenerationReasonSchema>;
 }
 export type ApiLiteralGenerationOutput = ApiArgumentProposal | ApiExplainedLiteralGenerationOutput | ApiTrackedLiteralGenerationOutput;
 export type ApiLiteralGenerationOutputSchema = z.ZodType<ApiLiteralGenerationOutput>;
 export interface ResolvedApiLiteralGenerationOutput extends ApiArgumentProposal {
     requestedInputs?: string[];
-    literalSources?: z.infer<typeof apiLiteralGenerationSourcesSchema>;
+    literalSources?: ApiLiteralGenerationSource[];
     explanation?: z.infer<typeof apiLiteralGenerationReasonSchema>;
 }

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

@@ -61,6 +61,8 @@ export interface InvokeConnectionPlanningModelInput<Output extends object> {
     operation: string;
     name: string;
     schema: ZodType<Output>;
+    /** Optional distinct receiver validation when display-only fields must not gate execution. */
+    validationSchema?: ZodType<Output>;
     messages: BaseMessage[];
     sourceFingerprint?: string;
     requestFingerprint?: string;

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

@@ -1,9 +1,12 @@
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import type { NativeSelectedPlanningInput } from '@openapi-flow/core';
-export interface ReviewNativeInstanceSelectionInput extends NativeSelectedPlanningInput {
+import type { NativeSelectedPlanningInput, NativeInstanceSelectionReviewOptions } from '@openapi-flow/core';
+import type { NativePlanningRejectedProposal } from './native-planning-rejection.js';
+export interface ReviewNativeInstanceSelectionInput extends NativeSelectedPlanningInput, NativeInstanceSelectionReviewOptions {
     model?: BaseChatModel;
     signal?: AbortSignal;
+    rejectedProposals?: NativePlanningRejectedProposal[];
 }
 export interface NativeInstanceSelectionReviewFailure {
     output: unknown;
+    requestFingerprint?: string;
 }

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

@@ -1,5 +1,6 @@
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import type { z } from 'zod';
+import type { NativePlanningRejectedProposal } from './native-planning-rejection.js';
 import type { JsonValueObject, NativeNodePlanningInput, NativePlanningProposal, NativePlanningResult, NativePlanningAssessment, NativePlanningCapabilityMaterial, NativeNodePlanningRecord, NativeInstanceSelectionInput, NativeNodeConfigurationInput, NativeSelectedPlanningInput, NativeInstanceSelectionFeedback } from '@openapi-flow/core';
 export interface PlanNativeNodesInput extends NativeNodePlanningInput {
     model?: BaseChatModel;
@@ -59,6 +60,7 @@ export interface NativeNodePlan extends NativePlanningResult {
 export type NativeNodePlanningFailure = {
     stage: 'instance-selection' | 'dependency-plan' | 'parameter-schema' | 'parameter-validation';
     output: unknown;
+    requestFingerprint?: string;
 } | {
     stage: 'proposal-schema';
     output: unknown;
@@ -72,6 +74,8 @@ export interface SelectNativeNodeInstancesInput extends NativeInstanceSelectionI
     signal?: AbortSignal;
     /** Explicit independently reviewed rejection. Never causes a hidden retry. */
     feedback?: NativeInstanceSelectionFeedback;
+    /** Explicit same-source contract rejections. No library-owned retry is performed. */
+    rejectedProposals?: NativePlanningRejectedProposal[];
 }
 export interface GenerateNativeNodeParametersInput extends NativeNodeConfigurationInput {
     model?: BaseChatModel;

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

@@ -0,0 +1,21 @@
+import type { z } from 'zod';
+import type { NativeInstanceSelectionDescription, NativeInstanceSelectionFeedbackDescription } from '@openapi-flow/core';
+import type { nativePlanningRejectionSchema } from '../schemas/native-planning-rejection-schema.js';
+import type { SelectNativeNodeInstancesInput } from './native-node-planning.js';
+import type { ReviewNativeInstanceSelectionInput } from './native-instance-selection-review.js';
+export type NativePlanningRejectedProposal = z.infer<typeof nativePlanningRejectionSchema>;
+export interface NativeSelectionRequestDescription extends Pick<NativeInstanceSelectionDescription, 'context'> {
+    requestFingerprint: string;
+    feedback?: NativeInstanceSelectionFeedbackDescription;
+}
+export interface NativePlanningRejectionValidationInput {
+    stage: NativePlanningRejectedProposal['stage'];
+    requestFingerprint: string;
+    rejectedProposals?: NativePlanningRejectedProposal[];
+}
+export interface CreateNativeSelectionRejectionInput extends SelectNativeNodeInstancesInput {
+    error: unknown;
+}
+export interface CreateNativeSelectionReviewRejectionInput extends ReviewNativeInstanceSelectionInput {
+    error: unknown;
+}

package/dist/types/native-planning-rejection.js

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

package/dist/types/reviewable-workflow-planning.d.ts

@@ -1,6 +1,7 @@
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import type { ReviewableWorkflowGraphProposal, ReviewableWorkflowPlanningContext, WorkflowReviewGap, PlannedNativeNode, ExplainedWorkflowConnection, ExplainedWorkflowBlockedCall } from '@openapi-flow/core';
 import type { ExplainedGraphNativeNode } from './workflow-planning.js';
+import type { WorkflowConnectionSelectionOutput } from './workflow-connection-selection.js';
 export interface PlanReviewableWorkflowGraphInput extends ReviewableWorkflowPlanningContext {
     scenario: string;
     model: BaseChatModel;
@@ -13,7 +14,7 @@ export type ReviewableWorkflowGraphPlanningFailure = {
     output: unknown;
 } | {
     stage: 'graph-validation';
-    output: ReviewableWorkflowGraphModelOutput;
+    output: ReviewableWorkflowGraphModelOutput | WorkflowConnectionSelectionOutput;
 };
 export type ReviewableWorkflowGraphOutput = Omit<ReviewableWorkflowGraphProposal, 'nativeNodes' | 'blockedCalls'> & {
     additionalNativeNodes?: ReviewableWorkflowGraphProposal['nativeNodes'];

package/dist/types/workflow-connection-native-repair.d.ts

@@ -0,0 +1,16 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { WorkflowConnectionNativeRepairInput, WorkflowConnectionNativeParametersInput } from '@openapi-flow/core';
+export interface PlanWorkflowConnectionNativeDependenciesInput extends WorkflowConnectionNativeRepairInput {
+    model?: BaseChatModel;
+    signal?: AbortSignal;
+}
+export interface GenerateWorkflowConnectionNativeParametersInput extends WorkflowConnectionNativeParametersInput {
+    model?: BaseChatModel;
+    signal?: AbortSignal;
+}
+export interface WorkflowConnectionNativeRepairFailure {
+    operation: 'planWorkflowConnectionNativeDependencies' | 'generateWorkflowConnectionNativeParameters';
+    fingerprint: string;
+    /** Private original response, including malformed output; never a browser diagnostic or a repaired proposal. */
+    output: unknown;
+}

package/dist/types/workflow-connection-native-repair.js

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

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

@@ -0,0 +1,19 @@
+import type { z } from 'zod';
+import type { createWorkflowConnectionSelectionSchema } from '../schemas/workflow-connection-selection-schema.js';
+import type { WorkflowConnectionProposal, BlockedWorkflowCall, WorkflowPlanEdge } from '@openapi-flow/core';
+export type WorkflowConnectionSelectionOutput = z.infer<ReturnType<typeof createWorkflowConnectionSelectionSchema>>;
+export type WorkflowConnectionExecutionEdge = Omit<WorkflowConnectionSelectionOutput['edges'][number], 'reason'> & {
+    reason?: unknown;
+};
+export type WorkflowConnectionExecutionBlockedCall = BlockedWorkflowCall & {
+    reason?: unknown;
+};
+export interface WorkflowConnectionExecutionOutput extends Omit<WorkflowConnectionProposal, 'edges' | 'blockedCalls'> {
+    reason?: unknown;
+    edges: WorkflowConnectionExecutionEdge[];
+    blockedCalls?: WorkflowConnectionExecutionBlockedCall[];
+}
+export type ResolvedWorkflowConnectionSelectionEdge = WorkflowPlanEdge & Pick<WorkflowConnectionExecutionEdge, 'reason'>;
+export interface ResolvedWorkflowConnectionSelection extends Omit<WorkflowConnectionExecutionOutput, 'edges'> {
+    edges: ResolvedWorkflowConnectionSelectionEdge[];
+}

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

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

package/dist/types/workflow-intent.d.ts

@@ -0,0 +1,6 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { WorkflowIntentInput } from '@openapi-flow/core';
+export interface PlanWorkflowIntentInput extends WorkflowIntentInput {
+    model: BaseChatModel;
+    signal?: AbortSignal;
+}

package/dist/types/workflow-intent.js

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

package/dist/types/workflow-orchestration.d.ts

@@ -1,5 +1,5 @@
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import type { PlannedNativeNode, WorkflowConnectionPlanningInput, WorkflowConnectionDecision, WorkflowConnectionProposal, ExplainedWorkflowBlockedCall, ExplainedWorkflowConnection } from '@openapi-flow/core';
+import type { PlannedNativeNode, WorkflowConnectionPlanningInput, WorkflowConnectionDecision, WorkflowConnectionProposal, ExplainedWorkflowBlockedCall, ExplainedWorkflowConnection, WorkflowConnectionExplanationIssue } from '@openapi-flow/core';
 import type { ReviewableWorkflowGraphOutput } from './reviewable-workflow-planning.js';
 export interface PlanWorkflowConnectionsInput extends WorkflowConnectionPlanningInput {
     model: BaseChatModel;
@@ -18,4 +18,5 @@ export type WorkflowConnectionPlanningOutput = ReviewableWorkflowGraphOutput | W
 export interface ResolvedWorkflowConnectionOutput {
     proposal: WorkflowConnectionProposal;
     decision?: WorkflowConnectionDecision;
+    explanationIssues?: WorkflowConnectionExplanationIssue[];
 }

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

@@ -33,7 +33,10 @@ export async function invokeConnectionPlanningModel(input) {
             ? {}
             : { requestFingerprint: input.requestFingerprint }),
     }, () => {
-        const parsed = input.schema.parse(output);
+        const receiver = input.validationSchema === undefined
+            ? input.schema
+            : input.validationSchema;
+        const parsed = receiver.parse(output);
         if (!isDeepStrictEqual(parsed, output))
             throw new Error('Connection output schema must not default, coerce or transform model data');
         return parsed;

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/review-workflow-connection-goals.js

@@ -33,6 +33,7 @@ export async function reviewWorkflowConnectionGoals(input) {
         operation,
         name: 'review_workflow_connection_goals',
         schema: createWorkflowConnectionGoalReviewSchema(description),
+        validationSchema: createWorkflowConnectionGoalReviewSchema(description, false),
         sourceFingerprint: description.sourceFingerprint,
         messages: [
             new SystemMessage(workflowConnectionGoalReviewPrompt),

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/generate-native-node-parameters.js

@@ -1,5 +1,5 @@
 import { HumanMessage, SystemMessage } from '@langchain/core/messages';
-import { createNativeNodeParametersSchema, describeNativeNodeConfiguration, resolveNativeNodeParameters, } from '@openapi-flow/core';
+import { createNativeNodeParametersSchema, describeNativeNodeConfiguration, resolveNativeNodeParameters, resolveNativeProducerParameters, } from '@openapi-flow/core';
 import { serializeStructuredOutputSchema } from '../schemas/serialize-structured-output-schema.js';
 import { nativeNodeParametersPrompt } from '../prompts/native-node-planning-prompt.js';
 import { NativeNodePlanningError } from './native-node-planning-error.js';
@@ -9,6 +9,9 @@ export async function generateNativeNodeParameters(input) {
     if (input.model !== undefined &&
         (!input.model || typeof input.model.withStructuredOutput !== 'function'))
         throw new Error('generateNativeNodeParameters.model must support structured output when supplied');
+    const derived = resolveNativeProducerParameters(input);
+    if (derived !== undefined)
+        return derived;
     const description = describeNativeNodeConfiguration(input);
     if (!description.instance.hasLiteralParameters)
         return resolveNativeNodeParameters({
@@ -29,6 +32,7 @@ export async function generateNativeNodeParameters(input) {
     if (!input.model || typeof input.model.withStructuredOutput !== 'function')
         throw new Error('generateNativeNodeParameters.model must support structured output for remaining values');
     const schema = createNativeNodeParametersSchema(input);
+    const validationSchema = createNativeNodeParametersSchema(input, false);
     const capability = description.context.capabilities.find((entry) => entry.name === description.instance.capability);
     if (!capability)
         throw new Error('Native parameter generation has no selected capability material');
@@ -67,7 +71,7 @@ export async function generateNativeNodeParameters(input) {
     input.signal?.throwIfAborted();
     try {
         // Validate output separately so callers can distinguish a malformed reply from stale source material.
-        schema.parse(output);
+        validationSchema.parse(output);
     }
     catch (cause) {
         if (!(cause instanceof Error))

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,7 +21,13 @@ export async function reviewNativeInstanceSelection(input) {
         return describeNativeInstanceSelectionReview(input);
     });
     input.signal?.throwIfAborted();
-    if (!description.gaps.length)
+    const requestFingerprint = fingerprintNativeSelectionReviewRequest(input);
+    const rejectedProposals = validateNativePlanningRejections({
+        stage: 'selection-review',
+        requestFingerprint,
+        rejectedProposals: input.rejectedProposals,
+    });
+    if (!description.gaps.length && description.reviewInstances !== true)
         return createNativeInstanceSelectionReview({
             ...input,
             proposal: { assessments: {} },
@@ -32,7 +40,7 @@ export async function reviewNativeInstanceSelection(input) {
     }, () => {
         if (!input.model ||
             typeof input.model.withStructuredOutput !== 'function')
-            throw new Error('reviewNativeInstanceSelection.model must support structured output for reported gaps');
+            throw new Error('reviewNativeInstanceSelection.model must support structured output for the requested review');
         return input.model;
     });
     const checkCurrent = (originalFailure) => {
@@ -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[];