@openapi-flow/langchain 0.3.18 → 0.4.0

package/dist/schemas/workflow-connection-outline-rejection-schema.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { workflowConnectionStepExpectationSchema } from '@openapi-flow/core';
+/** Exact private proposal feedback, never a public progress or error payload. */
+export const workflowConnectionOutlineRejectionSchema = z.discriminatedUnion('stage', [
+    z.strictObject({
+        requestFingerprint: z.string().regex(/^[a-f0-9]{64}$/),
+        expected: workflowConnectionStepExpectationSchema,
+        stage: z.literal('model-output'),
+        code: z.literal('MODEL_OUTPUT_INVALID'),
+        output: z.json(),
+        reason: z.string().min(1),
+    }),
+    z.strictObject({
+        requestFingerprint: z.string().regex(/^[a-f0-9]{64}$/),
+        expected: workflowConnectionStepExpectationSchema,
+        stage: z.literal('contract-validation'),
+        code: z.literal('WORKFLOW_GRAPH_PLANNING_FAILED'),
+        output: z.json(),
+        reason: z.string().min(1),
+    }),
+]);

package/dist/schemas/workflow-connection-outline-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+import type { WorkflowConnectionStepDescription, WorkflowConnectionOutlineProposal } from '@openapi-flow/core';
+export declare function createWorkflowConnectionOutlineSchema(description: WorkflowConnectionStepDescription): z.ZodType<WorkflowConnectionOutlineProposal>;

package/dist/schemas/workflow-connection-outline-schema.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+import { workflowConnectionOutlineBundleProposalSchema, workflowConnectionOutlineProposalSchema, } from '@openapi-flow/core';
+import { connectionIdListSchema } from './connection-planning-field-schemas.js';
+export function createWorkflowConnectionOutlineSchema(description) {
+    const ids = description.context.nodes.map((node) => node.id);
+    if (!ids.length)
+        throw new Error('Outline planning requires actual supplied nodes');
+    const bundle = workflowConnectionOutlineBundleProposalSchema.extend({
+        nodeIds: z
+            .array(z.enum(ids))
+            .min(1)
+            .describe('Choose actual node anchors for a coherent planning task. Shared boundary nodes may appear in several tasks.'),
+        goalIds: connectionIdListSchema(description.goals.map((goal) => goal.id)).describe('Select actual current goals addressed by this task; all goals must appear somewhere in the outline.'),
+        factIds: z
+            .array(z.enum(description.requirements.map((fact) => fact.id)))
+            .min(1)
+            .describe('Select unchanged original requirement IDs supporting this task; never create replacement requirements.'),
+    });
+    return workflowConnectionOutlineProposalSchema.extend({
+        bundles: z
+            .array(bundle)
+            .min(1)
+            .describe('Cover all supplied node, goal and fact identities with planning tasks. Array order is not execution order.'),
+    });
+}

package/dist/schemas/workflow-connection-revision-rejection-schema.d.ts

@@ -0,0 +1,113 @@
+import { z } from 'zod';
+/** Private feedback for the exact two source epochs and original session, not user input or browser data. */
+export declare const workflowConnectionRevisionRejectionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    stage: z.ZodLiteral<"model-output">;
+    code: z.ZodLiteral<"MODEL_OUTPUT_INVALID">;
+    sourceFingerprint: z.ZodString;
+    expected: z.ZodObject<{
+        sessionId: z.ZodUUID;
+        sourceFingerprint: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    output: z.ZodJSONSchema;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    stage: z.ZodLiteral<"contract-validation">;
+    code: z.ZodLiteral<"WORKFLOW_GRAPH_PLANNING_FAILED">;
+    violations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodEnum<{
+            INVALID_PROPOSAL: "INVALID_PROPOSAL";
+            INVALID_EDGE: "INVALID_EDGE";
+            CYCLE: "CYCLE";
+            INVALID_BOUNDARY: "INVALID_BOUNDARY";
+            CLOSED_REGION_INVALID: "CLOSED_REGION_INVALID";
+            PROTECTED_EDGE: "PROTECTED_EDGE";
+            NO_PROGRESS: "NO_PROGRESS";
+        }>;
+        message: z.ZodString;
+    }, z.core.$strict>>>;
+    constraints: z.ZodOptional<z.ZodObject<{
+        checkedScope: z.ZodLiteral<"necessary-node-order">;
+        dependencies: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            scope: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"node">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"input-port">;
+                port: z.ZodString;
+            }, z.core.$strict>], "kind">;
+            origin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"value-reference">;
+                source: z.ZodEnum<{
+                    response: "response";
+                    "node-output": "node-output";
+                }>;
+                pointer: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"native-dependency">;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"protected-connection">;
+                edgeId: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"goal">;
+                goalIndex: z.ZodNumber;
+                factIds: z.ZodArray<z.ZodString>;
+                goalKind: z.ZodEnum<{
+                    join: "join";
+                    precedence: "precedence";
+                    route: "route";
+                }>;
+            }, z.core.$strict>], "kind">;
+        }, z.core.$strict>>;
+        conflicts: z.ZodArray<z.ZodObject<{
+            code: z.ZodEnum<{
+                DEPENDENCY_CYCLE: "DEPENDENCY_CYCLE";
+                INDEPENDENCE_CONFLICT: "INDEPENDENCE_CONFLICT";
+            }>;
+            message: z.ZodString;
+            nodeIds: z.ZodArray<z.ZodString>;
+            goalIndexes: z.ZodArray<z.ZodNumber>;
+            dependencies: z.ZodArray<z.ZodObject<{
+                from: z.ZodString;
+                to: z.ZodString;
+                scope: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"node">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"input-port">;
+                    port: z.ZodString;
+                }, z.core.$strict>], "kind">;
+                origin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"value-reference">;
+                    source: z.ZodEnum<{
+                        response: "response";
+                        "node-output": "node-output";
+                    }>;
+                    pointer: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"native-dependency">;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"protected-connection">;
+                    edgeId: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    kind: z.ZodLiteral<"goal">;
+                    goalIndex: z.ZodNumber;
+                    factIds: z.ZodArray<z.ZodString>;
+                    goalKind: z.ZodEnum<{
+                        join: "join";
+                        precedence: "precedence";
+                        route: "route";
+                    }>;
+                }, z.core.$strict>], "kind">;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    sourceFingerprint: z.ZodString;
+    expected: z.ZodObject<{
+        sessionId: z.ZodUUID;
+        sourceFingerprint: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    output: z.ZodJSONSchema;
+    reason: z.ZodString;
+}, z.core.$strict>], "stage">;

package/dist/schemas/workflow-connection-revision-rejection-schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { workflowConnectionStepExpectationSchema, workflowConnectionRevisionViolationsSchema, workflowPlanningConstraintInspectionSchema, } from '@openapi-flow/core';
+const source = {
+    sourceFingerprint: workflowConnectionStepExpectationSchema.shape.sourceFingerprint,
+    expected: workflowConnectionStepExpectationSchema,
+    output: z.json(),
+    reason: z.string().min(1),
+};
+/** Private feedback for the exact two source epochs and original session, not user input or browser data. */
+export const workflowConnectionRevisionRejectionSchema = z.discriminatedUnion('stage', [
+    z.strictObject({
+        ...source,
+        stage: z.literal('model-output'),
+        code: z.literal('MODEL_OUTPUT_INVALID'),
+    }),
+    z.strictObject({
+        ...source,
+        stage: z.literal('contract-validation'),
+        code: z.literal('WORKFLOW_GRAPH_PLANNING_FAILED'),
+        violations: workflowConnectionRevisionViolationsSchema.optional(),
+        constraints: workflowPlanningConstraintInspectionSchema.optional(),
+    }),
+]);

package/dist/schemas/workflow-connection-revision-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { WorkflowConnectionRevisionDescription } from '@openapi-flow/core';
+import type { WorkflowConnectionRevisionModelOutput } from '../types/workflow-connection-revision.js';
+export declare function createWorkflowConnectionRevisionSchema(description: WorkflowConnectionRevisionDescription): z.ZodType<WorkflowConnectionRevisionModelOutput>;

package/dist/schemas/workflow-connection-revision-schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { createWorkflowConnectionGoalsSchema } from './workflow-connection-goals-schema.js';
+import { createWorkflowConnectionPatchSelectionSchema } from './workflow-connection-step-schema.js';
+import { connectionChoicesSchema } from './connection-planning-field-schemas.js';
+import { createConnectionMaterialRepairChoiceSchema } from './create-connection-material-repair-choice-schema.js';
+export function createWorkflowConnectionRevisionSchema(description) {
+    const context = {
+        ...description.before,
+        context: description.after.context,
+        requirements: description.after.requirements,
+    };
+    const choices = [
+        z.strictObject({
+            kind: z.literal('revise-connections'),
+            goals: createWorkflowConnectionGoalsSchema(description.after).shape.goals,
+            graphChange: createWorkflowConnectionPatchSelectionSchema(context, description.before.context.nodes),
+        }),
+    ];
+    const material = createConnectionMaterialRepairChoiceSchema(description.after.materialRepairStages, description.after.requirements.map((fact) => fact.id));
+    if (material)
+        choices.push(material);
+    return z.strictObject({ decision: connectionChoicesSchema(choices) });
+}

package/dist/schemas/workflow-connection-step-schema.d.ts

@@ -1,4 +1,6 @@
 import { z } from 'zod';
-import type { WorkflowConnectionStepDescription, WorkflowCapability } from '@openapi-flow/core';
-import type { WorkflowConnectionStepModelOutput } from '../types/incremental-connection-planning.js';
-export declare function createWorkflowConnectionStepSchema(description: WorkflowConnectionStepDescription, capabilities: WorkflowCapability[]): z.ZodType<WorkflowConnectionStepModelOutput>;
+import type { WorkflowConnectionStepDescription, WorkflowCapability, WorkflowPlanNodeContract } from '@openapi-flow/core';
+import type { WorkflowConnectionStepModelOutput, WorkflowConnectionPatchContext, WorkflowConnectionPatchSelection } from '../types/incremental-connection-planning.js';
+import type { WorkflowConnectionOutlineBundleDescription } from '@openapi-flow/core';
+export declare function createWorkflowConnectionPatchSelectionSchema(description: WorkflowConnectionPatchContext, removalNodes: WorkflowPlanNodeContract[], outline?: WorkflowConnectionOutlineBundleDescription): z.ZodType<WorkflowConnectionPatchSelection>;
+export declare function createWorkflowConnectionStepSchema(description: WorkflowConnectionStepDescription, capabilities: WorkflowCapability[], outline?: WorkflowConnectionOutlineBundleDescription): z.ZodType<WorkflowConnectionStepModelOutput>;

package/dist/schemas/workflow-connection-step-schema.js

@@ -1,33 +1,76 @@
 import { z } from 'zod';
 import { workflowConnectionAssessmentSchema, workflowConnectionMaterialRequestSchema, workflowConnectionUserDecisionSchema, } from '@openapi-flow/core';
 import { connectionChoicesSchema, connectionDecisionTextSchema as text, connectionIdListSchema, connectionPortSelectionListSchema, } from './connection-planning-field-schemas.js';
-export function createWorkflowConnectionStepSchema(description, capabilities) {
+export function createWorkflowConnectionPatchSelectionSchema(description, removalNodes, outline) {
     const nodes = description.context.nodes;
-    const ids = nodes.map((node) => node.id);
-    if (!ids.length)
-        throw new Error('Connection steps require supplied nodes');
-    const factIds = z
-        .array(z.enum(description.requirements.map((fact) => fact.id)))
-        .min(1);
-    const sources = connectionPortSelectionListSchema(nodes, 'outputs');
-    const targets = connectionPortSelectionListSchema(nodes, 'inputs');
-    const edge = z.strictObject({
-        source: sources.element,
-        target: targets.element,
-    });
     const canConnect = nodes.some((node) => node.outputs.length) &&
         nodes.some((node) => node.inputs.length);
-    const roots = nodes
-        .filter((node) => !node.waitsForAllInputs &&
+    const edge = z.strictObject({
+        source: connectionPortSelectionListSchema(nodes, 'outputs').element,
+        target: connectionPortSelectionListSchema(nodes, 'inputs').element,
+    });
+    const scoped = outline === undefined
+        ? []
+        : [
+            {
+                sources: nodes.filter((node) => outline.bundle.nodeIds.includes(node.id)),
+                targets: nodes,
+            },
+            {
+                sources: nodes,
+                targets: nodes.filter((node) => outline.bundle.nodeIds.includes(node.id)),
+            },
+        ]
+            .filter(({ sources, targets }) => sources.some((node) => node.outputs.length) &&
+            targets.some((node) => node.inputs.length))
+            .map(({ sources, targets }) => z.strictObject({
+            source: connectionPortSelectionListSchema(sources, 'outputs')
+                .element,
+            target: connectionPortSelectionListSchema(targets, 'inputs')
+                .element,
+        }));
+    const roots = nodes.filter((node) => !node.waitsForAllInputs &&
         node.rejoinsExclusiveOutputs === undefined &&
         !node.references.length &&
         !node.dependencyNodeIds.length &&
-        !Object.values(node.inputReferences ?? {}).some((references) => references.length))
-        .map((node) => node.id);
-    const terminalNodes = nodes.map((node) => ({
+        !Object.values(node.inputReferences ?? {}).some((references) => references.length));
+    const currentTerminalNodes = removalNodes.map((node) => ({
         ...node,
         outputs: node.outputs.filter((output) => description.terminals.some((terminal) => terminal.nodeId === node.id && terminal.output === output)),
     }));
+    return z.strictObject({
+        kind: z.literal('patch'),
+        addEdges: (outline !== undefined
+            ? scoped.length
+                ? z.array(connectionChoicesSchema(scoped))
+                : z.array(edge).max(0)
+            : canConnect
+                ? z.array(edge)
+                : z.array(edge).max(0)).describe('One atomic semantic bundle or repair, not a full graph replacement.'),
+        removeEdgeIds: connectionIdListSchema(description.edgeCatalog
+            .filter((item) => item.editable &&
+            (outline === undefined ||
+                outline.bundle.nodeIds.includes(item.edge.from) ||
+                outline.bundle.nodeIds.includes(item.edge.to)))
+            .map((item) => item.id)),
+        addRootNodeIds: connectionIdListSchema(roots.map((node) => node.id)).describe('Only explicitly intended independent starts in this patch. An unconnected node is not automatically a start.'),
+        removeRootNodeIds: connectionIdListSchema(description.rootNodeIds),
+        addTerminals: connectionPortSelectionListSchema(nodes, 'outputs').describe('Only outputs explicitly intended to finish here. Leave unfinished paths open.'),
+        removeTerminals: connectionPortSelectionListSchema(currentTerminalNodes, 'outputs').describe('Explicitly reopen a previously accepted terminal before continuing its path.'),
+        factIds: z
+            .array(z.enum(description.requirements.map((fact) => fact.id)))
+            .min(1),
+        reason: text,
+    });
+}
+export function createWorkflowConnectionStepSchema(description, capabilities, outline) {
+    const nodes = description.context.nodes;
+    const ids = nodes.map((node) => node.id);
+    if (!ids.length)
+        throw new Error('Connection steps require supplied nodes');
+    const factIds = z
+        .array(z.enum(description.requirements.map((fact) => fact.id)))
+        .min(1);
     const semanticGoalIds = description.goals
         .filter((goal) => goal.decision.kind === 'semantic')
         .map((goal) => goal.id);
@@ -38,19 +81,7 @@ export function createWorkflowConnectionStepSchema(description, capabilities) {
         }))
         : z.array(workflowConnectionAssessmentSchema).max(0);
     const choices = [
-        z.strictObject({
-            kind: z.literal('patch'),
-            addEdges: (canConnect ? z.array(edge) : z.array(edge).max(0)).describe('One complete connection bundle, including both conditional branches or the intended fan-out/join where needed. Not a full graph replacement.'),
-            removeEdgeIds: connectionIdListSchema(description.edgeCatalog
-                .filter((item) => item.editable)
-                .map((item) => item.id)),
-            addRootNodeIds: connectionIdListSchema(roots).describe('Explicit independent roots. Unconnected nodes are not automatic roots.'),
-            removeRootNodeIds: connectionIdListSchema(description.rootNodeIds),
-            addTerminals: sources,
-            removeTerminals: connectionPortSelectionListSchema(terminalNodes, 'outputs'),
-            factIds,
-            reason: text,
-        }),
+        createWorkflowConnectionPatchSelectionSchema(description, nodes, outline),
         z.strictObject({
             kind: z.literal('request-completion'),
             assessments,

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

@@ -8,6 +8,7 @@ export interface ExtractApiInputAnswersInput {
     model: BaseChatModel;
     selectOasEnums?: boolean;
     purpose?: string;
+    signal?: AbortSignal;
 }
 export interface AnalyzeApiInputAnswersInput extends Omit<ExtractApiInputAnswersInput, 'model'> {
     /** Required only when pending questions and a nonempty reply need interpretation. */

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

@@ -1,26 +1,46 @@
 import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import type { ApiLiteralGenerationInput, ApiCallArguments, ApiArgumentProposal, ApiArgumentGenerationContract, ApiArgumentProposalSchemaShape, createApiRequestInputPointerSchema, ApiLiteralProposalSource } from '@openapi-flow/core';
+import type { ApiLiteralGenerationInput, ApiCallArguments, ApiArgumentProposal, ApiLiteralProposalSource, OpenApiFlowError } from '@openapi-flow/core';
 import type { z } from 'zod';
-import type { createApiLiteralGenerationOutputSchema } from '../schemas/api-literal-generation-output-schema.js';
 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';
+import type { apiArgumentRejectionSchema } from '../schemas/api-argument-rejection-schema.js';
 export interface GenerateApiArgumentsInput extends ApiLiteralGenerationInput {
     model?: BaseChatModel;
     includeExplanations?: boolean;
     selectOasEnums?: boolean;
     trackRequestedInputs?: boolean;
+    /** Exact, private rejection feedback for the same source; no library-owned retries. */
+    rejectedProposals?: ApiArgumentRejection[];
+    signal?: AbortSignal;
+}
+export type ApiArgumentRejection = z.infer<typeof apiArgumentRejectionSchema>;
+export interface CreateApiArgumentRejectionInput extends Omit<GenerateApiArgumentsInput, 'model' | 'rejectedProposals' | 'signal'> {
+    error: unknown;
+}
+export type ApiLiteralGenerationOptions = z.infer<typeof apiLiteralGenerationOptionsSchema>;
+export interface ApiArgumentPlanningFailure {
+    error: OpenApiFlowError;
+    sourceFingerprint: string;
+    output: unknown;
 }
 export interface InterpretApiArgumentEnumsInput extends GenerateApiArgumentsInput {
     arguments: ApiCallArguments;
     proposal: ApiArgumentProposal;
     literalSources: ApiLiteralProposalSource[];
 }
-export type ApiLiteralGenerationOutput = z.infer<ReturnType<typeof createApiLiteralGenerationOutputSchema>>;
-export type ApiLiteralGenerationRequestedShape = {
-    requestedInputs: z.ZodArray<ReturnType<typeof createApiRequestInputPointerSchema>>;
-    literalSources: typeof apiLiteralGenerationSourcesSchema;
-};
-export type ApiLiteralGenerationExplanationShape = {
-    explanation: typeof apiLiteralGenerationReasonSchema;
-};
-export type ApiLiteralGenerationOutputSchema = ApiArgumentGenerationContract['schema'] | z.ZodObject<ApiArgumentProposalSchemaShape & ApiLiteralGenerationRequestedShape, z.core.$strict> | z.ZodObject<ApiArgumentProposalSchemaShape & ApiLiteralGenerationExplanationShape, z.core.$strict> | z.ZodObject<ApiArgumentProposalSchemaShape & ApiLiteralGenerationRequestedShape & ApiLiteralGenerationExplanationShape, z.core.$strict>;
+export type ApiLiteralProvidedDecision = z.infer<ReturnType<typeof createApiLiteralProvidedSchema>>;
+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>;
+}
+export type ApiLiteralGenerationOutput = ApiArgumentProposal | ApiExplainedLiteralGenerationOutput | ApiTrackedLiteralGenerationOutput;
+export type ApiLiteralGenerationOutputSchema = z.ZodType<ApiLiteralGenerationOutput>;
+export interface ResolvedApiLiteralGenerationOutput extends ApiArgumentProposal {
+    requestedInputs?: string[];
+    literalSources?: z.infer<typeof apiLiteralGenerationSourcesSchema>;
+    explanation?: z.infer<typeof apiLiteralGenerationReasonSchema>;
+}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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