@openapi-flow/langchain 0.3.18 → 0.4.1

package/dist/schemas/api-input-answer-source-schema.d.ts

@@ -1,24 +1,24 @@
 import { z } from 'zod';
-import type { ApiInputRequirement, ApiInputSourceCatalog, ApiInputEnumAnswerChoice } from '@openapi-flow/core';
+import type { ApiInputRequirement, ApiInputSourceCatalog, ApiInputEnumAnswerChoice, ApiInputMessageSourceCatalog, ApiInputSourceSelection } from '@openapi-flow/core';
 export declare const apiInputAnswerExplanationOptionsSchema: z.ZodObject<{
     includeExplanations: z.ZodOptional<z.ZodBoolean>;
     selectOasEnums: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 /** Values and unanswered IDs are deliberately not model-owned output fields. */
-export declare function createApiInputAnswerSourceSchema(requirements: ApiInputRequirement[], catalog: ApiInputSourceCatalog, includeExplanations?: boolean, enumChoices?: ApiInputEnumAnswerChoice[]): z.ZodObject<{
+export declare function createApiInputAnswerSourceSchema(requirements: ApiInputRequirement[], catalog: ApiInputSourceCatalog | undefined, includeExplanations?: boolean, enumChoices?: ApiInputEnumAnswerChoice[], messageSources?: ApiInputMessageSourceCatalog[]): z.ZodObject<{
     reason?: z.ZodString | undefined;
     answers: z.ZodArray<z.ZodObject<{
         reason?: z.ZodString | undefined;
         requirementId: z.ZodEnum<{
             [x: string]: string;
         }>;
-        source: z.ZodUnion<z.ZodType<import("@openapi-flow/core").ApiInputJsonSourceSelection | import("@openapi-flow/core").ApiInputTextSourceSelection, unknown, z.core.$ZodTypeInternals<import("@openapi-flow/core").ApiInputJsonSourceSelection | import("@openapi-flow/core").ApiInputTextSourceSelection, unknown>>[]>;
+        source: z.ZodType<ApiInputSourceSelection, unknown, z.core.$ZodTypeInternals<ApiInputSourceSelection, unknown>>;
     }, z.core.$strict> | z.ZodUnion<readonly [z.ZodObject<{
         reason?: z.ZodString | undefined;
         requirementId: z.ZodEnum<{
             [x: string]: string;
         }>;
-        source: z.ZodUnion<z.ZodType<import("@openapi-flow/core").ApiInputJsonSourceSelection | import("@openapi-flow/core").ApiInputTextSourceSelection, unknown, z.core.$ZodTypeInternals<import("@openapi-flow/core").ApiInputJsonSourceSelection | import("@openapi-flow/core").ApiInputTextSourceSelection, unknown>>[]>;
+        source: z.ZodType<ApiInputSourceSelection, unknown, z.core.$ZodTypeInternals<ApiInputSourceSelection, unknown>>;
     }, z.core.$strict>, ...z.ZodObject<{
         requirementId: z.ZodLiteral<string>;
         source: z.ZodObject<{
@@ -26,7 +26,7 @@ export declare function createApiInputAnswerSourceSchema(requirements: ApiInputR
             candidateId: z.ZodEnum<{
                 [x: string]: string;
             }>;
-            intent: z.ZodUnion<z.ZodType<import("@openapi-flow/core").ApiInputJsonSourceSelection | import("@openapi-flow/core").ApiInputTextSourceSelection, unknown, z.core.$ZodTypeInternals<import("@openapi-flow/core").ApiInputJsonSourceSelection | import("@openapi-flow/core").ApiInputTextSourceSelection, unknown>>[]>;
+            intent: z.ZodType<ApiInputSourceSelection, unknown, z.core.$ZodTypeInternals<ApiInputSourceSelection, unknown>>;
         }, z.core.$strict>;
         reason: z.ZodString;
     }, z.core.$strict>[]]>>;

package/dist/schemas/api-input-answer-source-schema.js

@@ -1,23 +1,31 @@
 import { z } from 'zod';
-import { createApiInputSourceSelectionSchema } from '@openapi-flow/core';
+import { createApiInputSourceSelectionSchema, createApiInputMessageSourceSelectionSchema, } from '@openapi-flow/core';
 export const apiInputAnswerExplanationOptionsSchema = z.strictObject({
     includeExplanations: z.boolean().optional(),
     selectOasEnums: z.boolean().optional(),
 });
 /** Values and unanswered IDs are deliberately not model-owned output fields. */
-export function createApiInputAnswerSourceSchema(requirements, catalog, includeExplanations = false, enumChoices = []) {
+export function createApiInputAnswerSourceSchema(requirements, catalog, includeExplanations = false, enumChoices = [], messageSources) {
     const ids = requirements.map((item) => item.id);
     if (!ids.length || new Set(ids).size !== ids.length)
         throw new Error('Answer source schema requires distinct pending requirements');
     const reason = z
         .string()
         .min(1)
-        .describe("A brief user-facing reason in the user's language, grounded only in this reply and the supplied pending questions. Instruction/schema language does not set the user's language. Never translate input values, identifiers or original source spans. Not a hidden reasoning trace or a claim that code validation passed.");
+        .describe("A brief user-facing reason in the user's language, grounded only in the original user sources and supplied pending questions. Separate reply context is not a quotation source when explicit messages are supplied. Instruction/schema language does not set the user's language. Never translate input values, identifiers or original source spans. Not a hidden reasoning trace or a claim that code validation passed.");
+    let sourceSchema;
+    if (messageSources !== undefined)
+        sourceSchema = createApiInputMessageSourceSelectionSchema(messageSources);
+    else {
+        if (catalog === undefined)
+            throw new Error('Answer source schema requires its original source catalog');
+        sourceSchema = createApiInputSourceSelectionSchema(catalog);
+    }
     const answer = z.strictObject({
         requirementId: z
             .enum(ids)
             .describe('The offered pending question answered by this exact source span.'),
-        source: createApiInputSourceSelectionSchema(catalog),
+        source: sourceSchema,
         ...(includeExplanations ? { reason } : {}),
     });
     const enumAnswers = enumChoices.map((choice) => {
@@ -28,7 +36,7 @@ export function createApiInputAnswerSourceSchema(requirements, catalog, includeE
             source: z.strictObject({
                 kind: z.literal('oas-enum'),
                 candidateId: z.enum(choice.candidates.map((candidate) => candidate.id)),
-                intent: createApiInputSourceSelectionSchema(catalog),
+                intent: sourceSchema,
             }),
             reason,
         });
@@ -36,7 +44,7 @@ export function createApiInputAnswerSourceSchema(requirements, catalog, includeE
     return z.strictObject({
         answers: z
             .array(enumAnswers.length ? z.union([answer, ...enumAnswers]) : answer)
-            .describe('Select each answered pending question at most once. Return [] when the reply gives no complete requested value. Do not return a value field or fabricate missing inputs.'),
+            .describe('Select each answered pending question at most once. Return [] when the original sources give no complete requested value or supported enum intent. Do not return a value field or fabricate missing inputs.'),
         ...(includeExplanations ? { reason } : {}),
     });
 }

package/dist/schemas/api-literal-generation-output-schema.d.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import type { ApiArgumentGenerationContract, JsonObject } from '@openapi-flow/core';
-import type { ApiLiteralGenerationOutputSchema } from '../types/argument-generation.js';
+import type { ApiArgumentGenerationContract, JsonObject, WorkflowSourceMessage } from '@openapi-flow/core';
+import type { ApiLiteralGenerationOutputSchema, ApiLiteralGenerationSource } from '../types/argument-generation.js';
 export declare const apiLiteralGenerationOptionsSchema: z.ZodObject<{
     includeExplanations: z.ZodOptional<z.ZodBoolean>;
     selectOasEnums: z.ZodOptional<z.ZodBoolean>;
@@ -17,5 +17,36 @@ export declare const apiLiteralGenerationSourcesSchema: z.ZodArray<z.ZodObject<{
     sourceText: z.ZodString;
     targetPointer: z.ZodString;
 }, z.core.$strict>>;
-/** The core values schema is unchanged; only optional human-readable attribution is added. */
-export declare function createApiLiteralGenerationOutputSchema(contract: ApiArgumentGenerationContract, includeExplanations: boolean, requestSchema?: JsonObject): ApiLiteralGenerationOutputSchema;
+export declare const apiLiteralNotProvidedSchema: z.ZodObject<{
+    state: z.ZodLiteral<"not-provided">;
+}, z.core.$strict>;
+export declare function createApiLiteralProvidedSchema(contract: ApiArgumentGenerationContract, messages?: WorkflowSourceMessage[]): z.ZodObject<{
+    state: z.ZodLiteral<"provided">;
+    values: z.ZodType<import("@openapi-flow/core").ApiArgumentValues, unknown, z.core.$ZodTypeInternals<import("@openapi-flow/core").ApiArgumentValues, unknown>>;
+    literalSources: z.ZodType<ApiLiteralGenerationSource[], unknown, z.core.$ZodTypeInternals<ApiLiteralGenerationSource[], unknown>>;
+}, z.core.$strict>;
+export declare function createApiTrackedLiteralGenerationSchema(contract: ApiArgumentGenerationContract, requestSchema: JsonObject, messages?: WorkflowSourceMessage[]): z.ZodObject<{
+    literalInputs: z.ZodUnion<readonly [z.ZodObject<{
+        state: z.ZodLiteral<"not-provided">;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"provided">;
+        values: z.ZodType<import("@openapi-flow/core").ApiArgumentValues, unknown, z.core.$ZodTypeInternals<import("@openapi-flow/core").ApiArgumentValues, unknown>>;
+        literalSources: z.ZodType<ApiLiteralGenerationSource[], unknown, z.core.$ZodTypeInternals<ApiLiteralGenerationSource[], unknown>>;
+    }, z.core.$strict>]>;
+    requestedInputs: z.ZodArray<z.ZodString | z.ZodNever>;
+}, z.core.$strict>;
+export declare function createApiExplainedTrackedLiteralGenerationSchema(contract: ApiArgumentGenerationContract, requestSchema: JsonObject, messages?: WorkflowSourceMessage[]): z.ZodObject<{
+    literalInputs: z.ZodUnion<readonly [z.ZodObject<{
+        state: z.ZodLiteral<"not-provided">;
+    }, z.core.$strict>, z.ZodObject<{
+        state: z.ZodLiteral<"provided">;
+        values: z.ZodType<import("@openapi-flow/core").ApiArgumentValues, unknown, z.core.$ZodTypeInternals<import("@openapi-flow/core").ApiArgumentValues, unknown>>;
+        literalSources: z.ZodType<ApiLiteralGenerationSource[], unknown, z.core.$ZodTypeInternals<ApiLiteralGenerationSource[], unknown>>;
+    }, z.core.$strict>]>;
+    requestedInputs: z.ZodArray<z.ZodString | z.ZodNever>;
+    explanation: z.ZodObject<{
+        reason: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** Tracked generation separates absence from literal empty values; the OAS value contract stays unchanged. */
+export declare function createApiLiteralGenerationOutputSchema(contract: ApiArgumentGenerationContract, includeExplanations: boolean, requestSchema?: JsonObject, messages?: WorkflowSourceMessage[]): ApiLiteralGenerationOutputSchema;

package/dist/schemas/api-literal-generation-output-schema.js

@@ -15,23 +15,58 @@ export const apiLiteralGenerationReasonSchema = z.strictObject({
 export const apiLiteralGenerationSourcesSchema = z.array(apiInputLiteralSourceSchema.extend({
     targetPointer: z
         .string()
-        .describe('RFC 6901 pointer relative to values, e.g. /query/id, never /values/query/id. Cover each proposed literal leaf or an explicitly quoted whole object/array. Code verifies exact occurrence, JSON type equality and complete coverage. The original scenario is the only source; purpose and OAS values are not literal quotations.'),
+        .describe('RFC 6901 pointer relative to values, e.g. /query/id, never /values/query/id. Cover each proposed literal leaf or an explicitly quoted whole object/array. Code verifies exact occurrence, JSON type equality and complete coverage. Use literalSourceMessages when supplied; otherwise use the original scenario. Purpose, OAS and feedback are not literal quotations.'),
 }));
-/** The core values schema is unchanged; only optional human-readable attribution is added. */
-export function createApiLiteralGenerationOutputSchema(contract, includeExplanations, requestSchema) {
+function createLiteralSourcesSchema(messages) {
+    if (messages === undefined || messages.length === 1)
+        return apiLiteralGenerationSourcesSchema.min(1);
+    const ids = messages.map((message) => message.id);
+    return z
+        .array(apiLiteralGenerationSourcesSchema.element.extend({
+        messageId: z
+            .enum(ids)
+            .describe('Select the supplied original message containing this exact quotation. Never cite scenario context or feedback instead.'),
+    }))
+        .min(1);
+}
+export const apiLiteralNotProvidedSchema = z.strictObject({
+    state: z
+        .literal('not-provided')
+        .describe('No request literal was supplied by the scenario for this call. Code owns the empty values and source list. Do not supply a placeholder body, values, or literalSources in this decision.'),
+});
+export function createApiLiteralProvidedSchema(contract, messages) {
+    return z.strictObject({
+        state: z.literal('provided'),
+        values: contract.valuesSchema.refine((values) => Object.entries(values).some(([group, value]) => group === 'body' ||
+            (value !== null &&
+                typeof value === 'object' &&
+                Object.keys(value).length > 0)), 'Provided literals require an actual request value, not empty parameter-location containers.'),
+        literalSources: createLiteralSourcesSchema(messages).describe('Every provided literal, including an empty object, empty array, empty string or null, needs its original exact user source. Never use a source-free placeholder.'),
+    });
+}
+export function createApiTrackedLiteralGenerationSchema(contract, requestSchema, messages) {
+    const provided = createApiLiteralProvidedSchema(contract, messages);
+    const schema = z.strictObject({
+        literalInputs: z.union([apiLiteralNotProvidedSchema, provided]),
+        requestedInputs: z
+            .array(createApiRequestInputPointerSchema(requestSchema))
+            .refine((pointers) => new Set(pointers).size === pointers.length)
+            .describe('Exact OAS request pointers explicitly requested for this call, even when the value is not given verbatim. Include requested optional inputs. Do not select unrequested filters, OAS defaults or examples. Code validates the original OAS and missing presence. This field contains paths, never values or bindings.'),
+    });
+    return schema;
+}
+export function createApiExplainedTrackedLiteralGenerationSchema(contract, requestSchema, messages) {
+    return createApiTrackedLiteralGenerationSchema(contract, requestSchema, messages).extend({
+        explanation: apiLiteralGenerationReasonSchema,
+    });
+}
+/** Tracked generation separates absence from literal empty values; the OAS value contract stays unchanged. */
+export function createApiLiteralGenerationOutputSchema(contract, includeExplanations, requestSchema, messages) {
     z.boolean().parse(includeExplanations);
-    if (requestSchema !== undefined) {
-        const schema = contract.schema.extend({
-            literalSources: apiLiteralGenerationSourcesSchema,
-            requestedInputs: z
-                .array(createApiRequestInputPointerSchema(requestSchema))
-                .refine((pointers) => new Set(pointers).size === pointers.length)
-                .describe('Exact OAS request pointers explicitly requested for this call, even when the value is not given verbatim. Include requested optional inputs. Do not select unrequested filters, OAS defaults or examples. Code validates the original OAS and missing presence. This field contains paths, never values or bindings.'),
-        });
+    if (requestSchema !== undefined)
         return includeExplanations && contract.hasLiteralInputs
-            ? schema.extend({ explanation: apiLiteralGenerationReasonSchema })
-            : schema;
-    }
+            ? createApiExplainedTrackedLiteralGenerationSchema(contract, requestSchema, messages)
+            : createApiTrackedLiteralGenerationSchema(contract, requestSchema, messages);
     return includeExplanations && contract.hasLiteralInputs
         ? contract.schema.extend({ explanation: apiLiteralGenerationReasonSchema })
         : contract.schema;

package/dist/schemas/create-connection-material-repair-choice-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { WorkflowConnectionMaterialRepairRequest, WorkflowConnectionMaterialRepairStage } from '@openapi-flow/core';
+/** The same actual stage/identity choices serve initial goal recovery and accepted-session revision. */
+export declare function createConnectionMaterialRepairChoiceSchema(stages: WorkflowConnectionMaterialRepairStage[], factIds: string[]): z.ZodType<WorkflowConnectionMaterialRepairRequest> | undefined;

package/dist/schemas/create-connection-material-repair-choice-schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { workflowConnectionMaterialRepairTargetSchema, workflowConnectionMaterialRepairRequestSchema, } from '@openapi-flow/core';
+import { connectionChoicesSchema } from './connection-planning-field-schemas.js';
+/** The same actual stage/identity choices serve initial goal recovery and accepted-session revision. */
+export function createConnectionMaterialRepairChoiceSchema(stages, factIds) {
+    const targets = [];
+    for (const stage of stages) {
+        if (!stage.nodeIds.length)
+            continue;
+        targets.push(workflowConnectionMaterialRepairTargetSchema.extend({
+            stage: z
+                .literal(stage.stage)
+                .describe('Origin-stage ownership: api-bindings changes API producer references; api-arguments changes only API literals/requested inputs and retains bindings; native-dependencies changes native producer IDs and then regenerates its settings; native-parameters changes settings or pointers while retaining the existing producer IDs. Request native-dependencies for a producer substitution, not native-parameters alone.'),
+            nodeId: z.enum(stage.nodeIds),
+        }));
+    }
+    if (!targets.length)
+        return undefined;
+    return workflowConnectionMaterialRepairRequestSchema.extend({
+        targets: z.array(connectionChoicesSchema(targets)).min(1),
+        factIds: z.array(z.enum(factIds)).min(1),
+    });
+}

package/dist/schemas/model-signal-schema.d.ts

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+/** Runtime invocation configuration only; never included in model data or source fingerprints. */
+export declare const modelSignalSchema: z.ZodOptional<z.ZodInstanceOf<AbortSignal>>;

package/dist/schemas/model-signal-schema.js

@@ -0,0 +1,3 @@
+import { z } from 'zod';
+/** Runtime invocation configuration only; never included in model data or source fingerprints. */
+export const modelSignalSchema = z.instanceof(AbortSignal).optional();

package/dist/schemas/native-node-parameter-contract.js

@@ -10,6 +10,8 @@ export function createNativeNodeParameterContract(capability, allowRuntimeParame
     };
     const schemas = [];
     const material = createNativePlanningCapabilityMaterial(capability, allowRuntimeParameters);
+    if (material.hasProvablyEmptyParameters)
+        return { schemas: [], material };
     if (allowRuntimeParameters && capability.supportsRuntimeParameters === true) {
         schemas.push(z.strictObject({
             ...identity,

package/dist/schemas/native-node-planning-contract.js

@@ -6,37 +6,44 @@ export function createNativeNodePlanningContract(capabilities, allowRuntimeParam
         throw new Error('native planning schema requires supplied capabilities');
     const contracts = capabilities.map((capability) => createNativeNodeParameterContract(capability, allowRuntimeParameters));
     const nodes = contracts.flatMap((contract) => contract.schemas);
-    const nodeSchema = z.union([nodes[0], ...nodes.slice(1)]);
+    const [first, ...rest] = nodes;
+    const nodeSchema = first === undefined ? undefined : z.union([first, ...rest]);
     const gaps = z
         .array(z.strictObject({
         description: nativeNodePlanningReasonSchema.describe('Describe a requested native behavior that cannot be represented and the missing capability or contract. Never a reminder to generate API requests, bindings or connections later.'),
     }))
         .describe('Blocking unmet native behavior only. Return [] when requested native behavior is representable. Selected OAS API calls are implemented separately; their bindings, request arguments and connections belong to later stages, not these gaps. Never invent missing data or substitute a capability.');
+    const noAdditions = z.strictObject({
+        noAdditionalNodesReason: nativeNodePlanningReasonSchema.describe('Why no NEW native instance is proposed, including when prepared nodes suffice or only unmet native requirements remain. Do not repeat supplied nodes or generate a fixed empty node array.'),
+        gaps,
+    });
+    const explainedDecision = nodeSchema === undefined
+        ? noAdditions
+        : z.union([
+            z.strictObject({
+                additions: z
+                    .array(z.strictObject({
+                    node: nodeSchema,
+                    reason: nativeNodePlanningReasonSchema,
+                }))
+                    .min(1)
+                    .describe('Only NEW native instances required by the scenario. Code extracts node data and keeps the reason outside executable parameters.'),
+                gaps,
+            }),
+            noAdditions,
+        ]);
     const schema = includeExplanations
         ? z.strictObject({
-            decision: z.union([
-                z.strictObject({
-                    additions: z
-                        .array(z.strictObject({
-                        node: nodeSchema,
-                        reason: nativeNodePlanningReasonSchema,
-                    }))
-                        .min(1)
-                        .describe('Only NEW native instances required by the scenario. Code extracts node data and keeps the reason outside executable parameters.'),
-                    gaps,
-                }),
-                z.strictObject({
-                    noAdditionalNodesReason: nativeNodePlanningReasonSchema.describe('Why no NEW native instance is proposed, including when prepared nodes suffice or only unmet native requirements remain. Do not repeat supplied nodes or generate a fixed empty node array.'),
-                    gaps,
-                }),
-            ]),
+            decision: explainedDecision,
         })
-        : z.strictObject({
-            nativeNodes: z
-                .array(nodeSchema)
-                .describe('Only new instances required by the scenario, with values following the supplied implementation schema. No ports, output schemas, code or n8n JSON.'),
-            gaps,
-        });
+        : nodeSchema === undefined
+            ? z.strictObject({ gaps })
+            : z.strictObject({
+                nativeNodes: z
+                    .array(nodeSchema)
+                    .describe('Only new instances required by the scenario, with values following the supplied implementation schema. No ports, output schemas, code or n8n JSON.'),
+                gaps,
+            });
     return {
         schema,
         capabilities: contracts.map((contract) => contract.material),

package/dist/schemas/native-planning-rejection-schema.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+/** Private, lossless model-output feedback; not a public progress/error payload. */
+export declare const nativePlanningRejectionSchema: z.ZodObject<{
+    stage: z.ZodEnum<{
+        "instance-selection": "instance-selection";
+        "selection-review": "selection-review";
+    }>;
+    requestFingerprint: z.ZodString;
+    output: z.ZodJSONSchema;
+    reason: z.ZodString;
+}, z.core.$strict>;

package/dist/schemas/native-planning-rejection-schema.js

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+/** Private, lossless model-output feedback; not a public progress/error payload. */
+export const nativePlanningRejectionSchema = z.strictObject({
+    stage: z.enum(['instance-selection', 'selection-review']),
+    requestFingerprint: z.string().regex(/^[a-f0-9]{64}$/u),
+    output: z.json(),
+    reason: z.string().min(1),
+});

package/dist/schemas/workflow-connection-goal-recovery-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { WorkflowConnectionGoalPlanningDescription } from '@openapi-flow/core';
+import type { WorkflowConnectionGoalRecoveryModelOutput } from '../types/workflow-connection-goal-recovery.js';
+export declare function createWorkflowConnectionGoalRecoverySchema(description: WorkflowConnectionGoalPlanningDescription): z.ZodType<WorkflowConnectionGoalRecoveryModelOutput>;

package/dist/schemas/workflow-connection-goal-recovery-schema.js

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

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

@@ -8,6 +8,82 @@ export declare const workflowConnectionGoalRejectionSchema: z.ZodDiscriminatedUn
 }, z.core.$strict>, z.ZodObject<{
     stage: z.ZodLiteral<"contract-validation">;
     code: z.ZodLiteral<"WORKFLOW_GRAPH_PLANNING_FAILED">;
+    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;
     output: z.ZodJSONSchema;
     reason: z.ZodString;

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

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { workflowConnectionStepExpectationSchema } from '@openapi-flow/core';
+import { workflowConnectionStepExpectationSchema, workflowPlanningConstraintInspectionSchema, } from '@openapi-flow/core';
 /** Private planning feedback; never part of the public error JSON or progress projection. */
 const source = {
     sourceFingerprint: workflowConnectionStepExpectationSchema.shape.sourceFingerprint,
@@ -16,5 +16,6 @@ export const workflowConnectionGoalRejectionSchema = z.discriminatedUnion('stage
         ...source,
         stage: z.literal('contract-validation'),
         code: z.literal('WORKFLOW_GRAPH_PLANNING_FAILED'),
+        constraints: workflowPlanningConstraintInspectionSchema.optional(),
     }),
 ]);

package/dist/schemas/workflow-connection-goal-review-schema.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod';
+import type { WorkflowConnectionGoalReviewDescription } from '@openapi-flow/core';
+import type { WorkflowConnectionGoalReviewModelOutput } from '../types/workflow-connection-goal-review.js';
+export declare function createWorkflowConnectionGoalReviewSchema(description: WorkflowConnectionGoalReviewDescription): z.ZodType<WorkflowConnectionGoalReviewModelOutput>;

package/dist/schemas/workflow-connection-goal-review-schema.js

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+import { workflowConnectionGoalAssessmentSchema } from '@openapi-flow/core';
+export function createWorkflowConnectionGoalReviewSchema(description) {
+    const assessment = workflowConnectionGoalAssessmentSchema
+        .omit({ factId: true })
+        .extend({
+        policyIds: workflowConnectionGoalAssessmentSchema.shape.policyIds.describe('Select only supplied code-enforced policy IDs for clauses actually covered by that policy. A protected-edge policy does not prove data semantics or implementation of new connections.'),
+        goalIds: z
+            .array(z.enum(description.goals.map((goal) => goal.id)))
+            .describe('Select only actual candidate goals. An omitted requirement may have no matching goal.'),
+        sourceQuotes: z
+            .array(z.string().min(1))
+            .min(1)
+            .describe('Exact unchanged quotes from THIS original requirement, including any missing or contradicted clause.'),
+        reason: z
+            .string()
+            .min(1)
+            .describe('Brief evidence-based explanation comparing the entire original requirement with goals and actual mappings. Not private reasoning.'),
+    });
+    return z.strictObject({
+        assessments: z.strictObject(Object.fromEntries(description.requirements.map((fact) => [
+            fact.id,
+            assessment.describe(fact.text),
+        ]))),
+    });
+}

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

@@ -1,4 +1,6 @@
 import { z } from 'zod';
 import type { WorkflowConnectionGoalPlanningDescription } from '@openapi-flow/core';
-import type { WorkflowConnectionGoalsModelOutput } from '../types/incremental-connection-planning.js';
-export declare function createWorkflowConnectionGoalsSchema(description: WorkflowConnectionGoalPlanningDescription): z.ZodType<WorkflowConnectionGoalsModelOutput>;
+import type { WorkflowConnectionGoalSelection } from '../types/incremental-connection-planning.js';
+export declare function createWorkflowConnectionGoalsSchema(description: WorkflowConnectionGoalPlanningDescription): z.ZodObject<{
+    goals: z.ZodArray<z.ZodType<WorkflowConnectionGoalSelection, unknown, z.core.$ZodTypeInternals<WorkflowConnectionGoalSelection, unknown>>>;
+}, z.core.$strict>;

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

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+/** Exact private proposal feedback, never a public progress or error payload. */
+export declare const workflowConnectionOutlineRejectionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    requestFingerprint: z.ZodString;
+    expected: z.ZodObject<{
+        sessionId: z.ZodUUID;
+        sourceFingerprint: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    stage: z.ZodLiteral<"model-output">;
+    code: z.ZodLiteral<"MODEL_OUTPUT_INVALID">;
+    output: z.ZodJSONSchema;
+    reason: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    requestFingerprint: z.ZodString;
+    expected: z.ZodObject<{
+        sessionId: z.ZodUUID;
+        sourceFingerprint: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    stage: z.ZodLiteral<"contract-validation">;
+    code: z.ZodLiteral<"WORKFLOW_GRAPH_PLANNING_FAILED">;
+    output: z.ZodJSONSchema;
+    reason: z.ZodString;
+}, z.core.$strict>], "stage">;

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.'),
+    });
+}