@openapi-flow/langchain 0.2.0 → 0.3.0

package/dist/draft/generate-workflow-draft-api-call-arguments.js

@@ -0,0 +1,88 @@
+import { isDeepStrictEqual } from 'node:util';
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowDraftClarification, describeWorkflowDraftClarificationOwnership, describeWorkflowDraftApiCallArguments, createWorkflowDraftApiCallArgumentsSchema, resolveWorkflowDraftApiCallArguments, } from '@openapi-flow/core';
+import { workflowDraftApiCallArgumentsPrompt } from '../prompts/workflow-draft-api-call-planning-prompt.js';
+import { serializeStructuredOutputSchema } from '../schemas/serialize-structured-output-schema.js';
+import { parseStructuredOutput } from '../legacy/planning/parse-structured-output.js';
+import { WorkflowDraftApiCallPlanningError } from './workflow-draft-api-call-planning-error.js';
+export async function generateWorkflowDraftApiCallArguments(input) {
+    const description = describeWorkflowDraftApiCallArguments(input);
+    const schema = createWorkflowDraftApiCallArgumentsSchema(input);
+    if (!description.hasLiteralInputs)
+        return resolveWorkflowDraftApiCallArguments({
+            ...input,
+            fingerprint: description.fingerprint,
+            proposal: {
+                values: {},
+                ...(input.trackRequestedInputs === true ? { requestedInputs: [] } : {}),
+                sourceMessageIds: description.messages.map((message) => message.id),
+                ...(description.includeExplanations
+                    ? {
+                        explanation: {
+                            reason: 'The OAS input contract has no remaining literal fields after explicit bindings and confirmed inputs.',
+                            evidence: description.messages.map((message) => ({
+                                kind: 'message',
+                                messageId: message.id,
+                            })),
+                        },
+                    }
+                    : {}),
+            },
+        });
+    if (!input.model || typeof input.model.withStructuredOutput !== 'function')
+        throw new Error('generateWorkflowDraftApiCallArguments.model must support structured output when literal inputs remain');
+    const output = await input.model
+        .withStructuredOutput(serializeStructuredOutputSchema(schema, 'draft-2020-12'), {
+        name: 'generate_draft_api_call_arguments',
+        // Omitted unknown OAS values are intentional. OpenAI strict JSON Schema
+        // requires every property, so use the same primary tool transport as
+        // generateApiArguments and validate the unchanged schema locally.
+        method: 'functionCalling',
+        strict: false,
+    })
+        .invoke([
+        new SystemMessage(workflowDraftApiCallArgumentsPrompt),
+        new HumanMessage(JSON.stringify({
+            clarification: describeWorkflowDraftClarification(input.context),
+            planningClarifications: describeWorkflowDraftClarificationOwnership({
+                ...input,
+                stepId: input.stepId,
+                stage: 'api-arguments',
+            }),
+            instruction: description.instruction,
+            messages: description.messages,
+            backgroundMessages: description.backgroundMessages,
+            operation: {
+                key: description.operation.key,
+                method: description.operation.method,
+                path: description.operation.path,
+                summary: description.operation.operation.summary,
+                description: description.operation.operation.description,
+            },
+            requestMediaType: description.requestMediaType,
+            literalInputSchema: description.literalInputSchema,
+            ...(input.trackRequestedInputs === true
+                ? {
+                    trackRequestedInputs: true,
+                    requestedInputSchema: description.requestSchema,
+                }
+                : {}),
+            includeExplanations: description.includeExplanations,
+        })),
+    ]);
+    try {
+        const parsed = parseStructuredOutput(schema, output, 'draft API call arguments');
+        if (!isDeepStrictEqual(parsed, output))
+            throw new Error('API call argument output changed during validation');
+        return resolveWorkflowDraftApiCallArguments({
+            ...input,
+            fingerprint: description.fingerprint,
+            proposal: parsed,
+        });
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftApiCallPlanningError({ stage: 'arguments', output }, cause);
+    }
+}

package/dist/draft/generate-workflow-draft-api-input-edits.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDraftApiInputEditResult } from '@openapi-flow/core';
+import type { GenerateWorkflowDraftApiInputEditsInput } from '../types/workflow-draft-api-input-edit.js';
+/** Only actual selected values. Removals require zero value-generation calls. */
+export declare function generateWorkflowDraftApiInputEdits(input: GenerateWorkflowDraftApiInputEditsInput): Promise<WorkflowDraftApiInputEditResult>;

package/dist/draft/generate-workflow-draft-api-input-edits.js

@@ -0,0 +1,58 @@
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowDraftClarification, describeWorkflowDraftClarificationOwnership, createWorkflowDraftApiInputEditValuesSchema, describeWorkflowDraftApiInputEdit, resolveWorkflowDraftApiInputEdits, } from '@openapi-flow/core';
+import { workflowDraftApiInputEditValuesPrompt } from '../prompts/workflow-draft-api-input-edit-prompt.js';
+import { WorkflowDraftApiInputEditPlanningError } from './workflow-draft-api-input-edit-planning-error.js';
+import { parseStructuredOutput } from '../legacy/planning/parse-structured-output.js';
+import { serializeStructuredOutputSchema } from '../schemas/serialize-structured-output-schema.js';
+import { createWorkflowMessageEvidenceSelectionSchema } from '../schemas/create-workflow-message-evidence-selection-schema.js';
+/** Only actual selected values. Removals require zero value-generation calls. */
+export async function generateWorkflowDraftApiInputEdits(input) {
+    const described = describeWorkflowDraftApiInputEdit(input);
+    const schema = createWorkflowDraftApiInputEditValuesSchema(input, createWorkflowMessageEvidenceSelectionSchema(described.messages));
+    const contract = structuredClone(input.contract);
+    if (!contract.targets.some((target) => target.kind === 'set'))
+        return resolveWorkflowDraftApiInputEdits({
+            ...input,
+            output: { values: {} },
+        });
+    if (!input.model || typeof input.model.withStructuredOutput !== 'function')
+        throw new Error('generateWorkflowDraftApiInputEdits.model must support structured output when set-values remain');
+    const output = await input.model
+        .withStructuredOutput(serializeStructuredOutputSchema(schema, 'draft-2020-12', 'input'), {
+        name: 'generate_draft_api_input_edit_values',
+        method: 'jsonSchema',
+        strict: true,
+    })
+        .invoke([
+        new SystemMessage(workflowDraftApiInputEditValuesPrompt),
+        new HumanMessage(JSON.stringify({
+            clarification: describeWorkflowDraftClarification(input.context),
+            planningClarifications: describeWorkflowDraftClarificationOwnership({
+                ...input,
+                stepId: input.stepId,
+                stage: 'api-arguments',
+            }),
+            instruction: described.instruction,
+            messages: described.messages,
+            targets: contract.targets.filter((target) => target.kind === 'set'),
+            includeExplanations: described.includeExplanations,
+        })),
+    ]);
+    try {
+        const parsed = parseStructuredOutput(schema, output, 'draft API input edit values');
+        const result = resolveWorkflowDraftApiInputEdits({
+            ...input,
+            output: parsed,
+        });
+        if (JSON.stringify(input.contract) !== JSON.stringify(contract) ||
+            JSON.stringify(describeWorkflowDraftApiInputEdit(input)) !==
+                JSON.stringify(described))
+            throw new Error('Draft API input edit source changed during value generation; no automatic rebase');
+        return result;
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftApiInputEditPlanningError({ stage: 'values', output }, cause);
+    }
+}

package/dist/draft/generate-workflow-draft-native-node-addition.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDraftNativeNodeAdditionResult } from '@openapi-flow/core';
+import type { GenerateWorkflowDraftNativeNodeAdditionInput } from '../types/workflow-draft-native-node-addition.js';
+/** One selected instance, zero or one model call; the original draft is never adopted here. */
+export declare function generateWorkflowDraftNativeNodeAddition(input: GenerateWorkflowDraftNativeNodeAdditionInput): Promise<WorkflowDraftNativeNodeAdditionResult>;

package/dist/draft/generate-workflow-draft-native-node-addition.js

@@ -0,0 +1,137 @@
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { isDeepStrictEqual } from 'node:util';
+import { describeWorkflowDraftClarification, describeWorkflowDraftClarificationOwnership, describeWorkflowDraftNativeNodeAddition, createWorkflowDraftNativeNodeAdditionSchema, resolveWorkflowDraftNativeNodeAddition, validateWorkflowDraftNativeNodeParameterOwnershipContract, } from '@openapi-flow/core';
+import { serializeStructuredOutputSchema } from '../schemas/serialize-structured-output-schema.js';
+import { parseStructuredOutput } from '../legacy/planning/parse-structured-output.js';
+import { workflowDraftNativeNodeAdditionPrompt } from '../prompts/workflow-draft-native-node-addition-prompt.js';
+import { WorkflowDraftNativeNodeAdditionPlanningError } from './workflow-draft-native-node-addition-planning-error.js';
+/** One selected instance, zero or one model call; the original draft is never adopted here. */
+export async function generateWorkflowDraftNativeNodeAddition(input) {
+    const description = describeWorkflowDraftNativeNodeAddition(input);
+    const ownership = input.parameterOwnership === undefined
+        ? undefined
+        : validateWorkflowDraftNativeNodeParameterOwnershipContract(input);
+    const originalOwnership = JSON.stringify(input.parameterOwnership);
+    if (ownership !== undefined && !ownership.hasLiteralParameters)
+        return resolveWorkflowDraftNativeNodeAddition({
+            ...input,
+            fingerprint: description.fingerprint,
+            proposal: {
+                decision: {
+                    ...(ownership.runtimeParameters === true
+                        ? { status: 'runtime-parameters' }
+                        : { status: 'provided', parameters: {} }),
+                    sourceMessageIds: ownership.proposal.decision.sourceMessageIds,
+                    ...(ownership.proposal.decision.explanation === undefined
+                        ? {}
+                        : { explanation: ownership.proposal.decision.explanation }),
+                },
+            },
+        });
+    if (description.parameterMode === 'fixed-empty') {
+        return resolveWorkflowDraftNativeNodeAddition({
+            ...input,
+            fingerprint: description.fingerprint,
+            proposal: {
+                decision: {
+                    status: 'provided',
+                    parameters: {},
+                    sourceMessageIds: description.messages.map((message) => message.id),
+                    ...(description.includeExplanations
+                        ? {
+                            explanation: {
+                                reason: 'The registered configuration admits exactly one value: the empty object.',
+                                evidence: description.messages.map((message) => ({
+                                    kind: 'message',
+                                    messageId: message.id,
+                                })),
+                            },
+                        }
+                        : {}),
+                },
+            },
+        });
+    }
+    if (!input.model || typeof input.model.withStructuredOutput !== 'function')
+        throw new Error('generateWorkflowDraftNativeNodeAddition.model must support structured output for parameter choices');
+    const schema = createWorkflowDraftNativeNodeAdditionSchema(input);
+    const output = await input.model
+        .withStructuredOutput(serializeStructuredOutputSchema(schema, 'draft-2020-12'), {
+        name: 'generate_draft_native_node_addition',
+        method: 'jsonSchema',
+        strict: true,
+    })
+        .invoke([
+        new SystemMessage(workflowDraftNativeNodeAdditionPrompt),
+        new HumanMessage(JSON.stringify({
+            clarification: describeWorkflowDraftClarification(input.context),
+            planningClarifications: describeWorkflowDraftClarificationOwnership({
+                ...input,
+                stepId: input.stepId,
+                stage: 'native-parameters',
+            }),
+            instruction: description.instruction,
+            ...(description.plannedNativeRoles === undefined
+                ? {}
+                : {
+                    nodeId: description.nodeId,
+                    stepId: input.stepId,
+                    plannedNativeRoles: description.plannedNativeRoles,
+                }),
+            ...(description.sourceDependencies === undefined
+                ? {}
+                : { sourceDependencies: description.sourceDependencies }),
+            capability: description.capability,
+            parametersSchema: ownership === undefined
+                ? description.parametersSchema
+                : ownership.literalParametersSchema,
+            ...(ownership === undefined
+                ? {}
+                : { runtimeParameters: ownership.runtimeParameters }),
+            sourceCandidates: description.sources.values.map((source) => source.kind === 'native'
+                ? source
+                : {
+                    kind: source.kind,
+                    nodeId: source.nodeId,
+                    preparation: source.preparation,
+                    operation: {
+                        method: source.operation.method,
+                        path: source.operation.path,
+                        summary: source.operation.operation.summary,
+                        description: source.operation.operation.description,
+                        responses: source.operation.operation.responses,
+                    },
+                    responsePointerCatalog: source.responsePointerCatalog,
+                }),
+            exclusiveOutputSources: description.sources.exclusiveOutputs,
+            messages: description.messages,
+            backgroundMessages: description.backgroundMessages,
+            includeExplanations: description.includeExplanations,
+        })),
+    ]);
+    let proposal;
+    try {
+        proposal = parseStructuredOutput(schema, output, 'native node addition');
+        if (!isDeepStrictEqual(proposal, output))
+            throw new Error('Native node addition output must validate without defaults, coercion or transformation');
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftNativeNodeAdditionPlanningError({ stage: 'proposal-schema', output }, cause);
+    }
+    try {
+        if (JSON.stringify(input.parameterOwnership) !== originalOwnership)
+            throw new Error('Native addition ownership changed during value generation; no automatic rebase');
+        return resolveWorkflowDraftNativeNodeAddition({
+            ...input,
+            fingerprint: description.fingerprint,
+            proposal,
+        });
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftNativeNodeAdditionPlanningError({ stage: 'node-validation', output }, cause);
+    }
+}

package/dist/draft/generate-workflow-draft-native-parameter-edits.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowDraftNativeParameterEditResult } from '@openapi-flow/core';
+import type { GenerateWorkflowDraftNativeParameterEditsInput } from '../types/workflow-draft-native-parameter-edit.js';
+export declare function generateWorkflowDraftNativeParameterEdits(input: GenerateWorkflowDraftNativeParameterEditsInput): Promise<WorkflowDraftNativeParameterEditResult>;

package/dist/draft/generate-workflow-draft-native-parameter-edits.js

@@ -0,0 +1,71 @@
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowDraftClarification, describeWorkflowDraftClarificationOwnership, describeWorkflowDraftNativeParameterEdit, createWorkflowDraftNativeParameterEditValuesSchema, resolveWorkflowDraftNativeParameterEdits, } from '@openapi-flow/core';
+import { workflowDraftNativeParameterEditValuesPrompt } from '../prompts/workflow-draft-native-parameter-edit-prompt.js';
+import { serializeStructuredOutputSchema } from '../schemas/serialize-structured-output-schema.js';
+import { createWorkflowMessageEvidenceSelectionSchema } from '../schemas/create-workflow-message-evidence-selection-schema.js';
+import { parseStructuredOutput } from '../legacy/planning/parse-structured-output.js';
+import { WorkflowDraftNativeParameterEditPlanningError } from './workflow-draft-native-parameter-edit-planning-error.js';
+export async function generateWorkflowDraftNativeParameterEdits(input) {
+    const context = describeWorkflowDraftNativeParameterEdit(input);
+    const schema = createWorkflowDraftNativeParameterEditValuesSchema(input, createWorkflowMessageEvidenceSelectionSchema(context.messages));
+    const originalContract = JSON.stringify(input.contract);
+    if (!input.contract.targets.some((target) => target.kind === 'set'))
+        return resolveWorkflowDraftNativeParameterEdits({
+            ...input,
+            output: { values: {} },
+        });
+    if (!input.model || typeof input.model.withStructuredOutput !== 'function')
+        throw new Error('generateWorkflowDraftNativeParameterEdits.model must support structured output for set values');
+    const output = await input.model
+        .withStructuredOutput(serializeStructuredOutputSchema(schema, 'draft-2020-12', 'input'), {
+        name: 'generate_draft_native_parameter_edit_values',
+        method: 'jsonSchema',
+        strict: true,
+    })
+        .invoke([
+        new SystemMessage(workflowDraftNativeParameterEditValuesPrompt),
+        new HumanMessage(JSON.stringify({
+            clarification: describeWorkflowDraftClarification(input.context),
+            planningClarifications: describeWorkflowDraftClarificationOwnership({
+                ...input,
+                stepId: input.stepId,
+                stage: 'native-parameters',
+            }),
+            instruction: context.instruction,
+            capability: context.capability,
+            targets: input.contract.targets.filter((target) => target.kind === 'set'),
+            sourceCandidates: context.sourceCandidates.map((source) => source.kind === 'native'
+                ? source
+                : {
+                    kind: source.kind,
+                    nodeId: source.nodeId,
+                    preparation: source.preparation,
+                    operation: {
+                        method: source.operation.method,
+                        path: source.operation.path,
+                        summary: source.operation.operation.summary,
+                        description: source.operation.operation.description,
+                        responses: source.operation.operation.responses,
+                    },
+                    responsePointerCatalog: source.responsePointerCatalog,
+                }),
+            messages: context.messages,
+            exclusiveOutputSources: context.exclusiveOutputSources,
+            includeExplanations: context.includeExplanations,
+        })),
+    ]);
+    try {
+        const parsed = parseStructuredOutput(schema, output, 'draft native parameter edit values');
+        if (JSON.stringify(input.contract) !== originalContract)
+            throw new Error('Native parameter edit contract changed during generation; no automatic rebase');
+        return resolveWorkflowDraftNativeParameterEdits({
+            ...input,
+            output: parsed,
+        });
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftNativeParameterEditPlanningError({ stage: 'values', output }, cause);
+    }
+}

package/dist/draft/plan-workflow-draft-api-binding-edit.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDraftApiBindingEditResult } from '@openapi-flow/core';
+import type { PlanWorkflowDraftApiBindingEditInput } from '../types/workflow-draft-api-binding-edit.js';
+/** One bounded semantic call, usable for an unfinished step or code-derived repair. */
+export declare function planWorkflowDraftApiBindingEdit(input: PlanWorkflowDraftApiBindingEditInput): Promise<WorkflowDraftApiBindingEditResult>;

package/dist/draft/plan-workflow-draft-api-binding-edit.js

@@ -0,0 +1,103 @@
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowDraftClarification, describeWorkflowDraftClarificationOwnership, describeWorkflowDraftApiBindingEdit, createWorkflowDraftApiBindingEditProposalSchema, resolveWorkflowDraftApiBindingEdit, } from '@openapi-flow/core';
+import { workflowDraftApiBindingEditPrompt } from '../prompts/workflow-draft-api-binding-edit-prompt.js';
+import { serializeStructuredOutputSchema } from '../schemas/serialize-structured-output-schema.js';
+import { parseStructuredOutput } from '../legacy/planning/parse-structured-output.js';
+import { WorkflowDraftApiBindingEditPlanningError } from './workflow-draft-api-binding-edit-planning-error.js';
+import { createWorkflowMessageEvidenceSelectionSchema } from '../schemas/create-workflow-message-evidence-selection-schema.js';
+/** One bounded semantic call, usable for an unfinished step or code-derived repair. */
+export async function planWorkflowDraftApiBindingEdit(input) {
+    const context = describeWorkflowDraftApiBindingEdit(input);
+    if (!input.model || typeof input.model.withStructuredOutput !== 'function')
+        throw new Error('planWorkflowDraftApiBindingEdit.model must support structured output');
+    const schema = createWorkflowDraftApiBindingEditProposalSchema(context, createWorkflowMessageEvidenceSelectionSchema(context.messages));
+    const output = await input.model
+        .withStructuredOutput(serializeStructuredOutputSchema(schema, 'draft-7', 'input'), {
+        name: 'plan_draft_api_binding_edit',
+        method: 'jsonSchema',
+        strict: true,
+    })
+        .invoke([
+        new SystemMessage(workflowDraftApiBindingEditPrompt),
+        new HumanMessage(JSON.stringify({
+            clarification: describeWorkflowDraftClarification(input.context),
+            planningClarifications: context.scope.kind === 'step'
+                ? describeWorkflowDraftClarificationOwnership({
+                    ...input,
+                    stepId: context.scope.stepId,
+                    stage: 'api-bindings',
+                })
+                : [],
+            mode: context.scope.kind,
+            instruction: context.instruction,
+            target: {
+                values: context.call.values,
+                bindings: context.call.bindings,
+                requestSchema: context.requestSchema,
+                operation: {
+                    method: context.operation.method,
+                    path: context.operation.path,
+                    summary: context.operation.operation.summary,
+                    description: context.operation.operation.description,
+                    parameters: context.operation.effective.parameters,
+                    requestBody: context.operation.operation.requestBody,
+                },
+            },
+            sourceCandidates: context.sourceCandidates.map((source) => source.kind === 'native'
+                ? source
+                : {
+                    nodeId: source.nodeId,
+                    kind: source.kind,
+                    operation: {
+                        method: source.operation.method,
+                        path: source.operation.path,
+                        summary: source.operation.operation.summary,
+                        description: source.operation.operation.description,
+                        responses: source.operation.operation.responses,
+                    },
+                    responsePointerCatalog: source.responsePointerCatalog,
+                    preparation: source.preparation,
+                    requirements: source.requirements,
+                }),
+            requiredTargetPointers: context.requiredTargetPointers,
+            messages: context.messages,
+            backgroundMessages: context.backgroundMessages,
+            pendingSourceChanges: input.plan.steps.flatMap((step) => {
+                const decision = step.decision;
+                return context.stage.pendingResolutionStepIds.includes(step.id) &&
+                    'nodeId' in decision &&
+                    context.sourceCandidates.some((source) => source.nodeId === decision.nodeId)
+                    ? [
+                        {
+                            nodeId: decision.nodeId,
+                            kind: decision.kind,
+                            instruction: decision.instruction,
+                        },
+                    ]
+                    : [];
+            }),
+            includeExplanations: context.includeExplanations,
+        })),
+    ]);
+    let proposal;
+    try {
+        proposal = parseStructuredOutput(schema, output, 'draft API binding edit');
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftApiBindingEditPlanningError({ stage: 'proposal-schema', output }, cause);
+    }
+    try {
+        return resolveWorkflowDraftApiBindingEdit({
+            ...input,
+            fingerprint: context.fingerprint,
+            proposal,
+        });
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftApiBindingEditPlanningError({ stage: 'proposal-validation', output }, cause);
+    }
+}

package/dist/draft/plan-workflow-draft-api-call-bindings.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowDraftApiCallBindingResult } from '@openapi-flow/core';
+import type { PlanWorkflowDraftApiCallBindingsInput } from '../types/workflow-draft-api-call-planning.js';
+export declare function planWorkflowDraftApiCallBindings(input: PlanWorkflowDraftApiCallBindingsInput): Promise<WorkflowDraftApiCallBindingResult>;

package/dist/draft/plan-workflow-draft-api-call-bindings.js

@@ -0,0 +1,114 @@
+import { isDeepStrictEqual } from 'node:util';
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowDraftClarification, describeWorkflowDraftClarificationOwnership, describeWorkflowDraftApiCallBindings, createWorkflowDraftApiCallBindingsSchema, resolveWorkflowDraftApiCallBindings, } from '@openapi-flow/core';
+import { workflowDraftApiCallBindingsPrompt } from '../prompts/workflow-draft-api-call-planning-prompt.js';
+import { serializeStructuredOutputSchema } from '../schemas/serialize-structured-output-schema.js';
+import { parseStructuredOutput } from '../legacy/planning/parse-structured-output.js';
+import { WorkflowDraftApiCallPlanningError } from './workflow-draft-api-call-planning-error.js';
+export async function planWorkflowDraftApiCallBindings(input) {
+    const description = describeWorkflowDraftApiCallBindings(input);
+    const schema = createWorkflowDraftApiCallBindingsSchema(input);
+    const planningClarifications = describeWorkflowDraftClarificationOwnership({
+        ...input,
+        stepId: input.stepId,
+        stage: 'api-bindings',
+    });
+    const noPredecessorChoice = !description.hasOtherSelectedNodes &&
+        !description.sources.values.length &&
+        !planningClarifications.length;
+    if (!description.hasRequestInputs ||
+        description.inputIntent?.targets.length === 0 ||
+        (description.inputIntent === undefined && noPredecessorChoice))
+        return resolveWorkflowDraftApiCallBindings({
+            ...input,
+            fingerprint: description.fingerprint,
+            proposal: {
+                decision: {
+                    status: 'provided',
+                    sourceMessageIds: description.messages.map((message) => message.id),
+                    ...(description.includeExplanations
+                        ? {
+                            explanation: {
+                                reason: !description.hasRequestInputs
+                                    ? 'The selected OAS declares no request input fields, so there are no request fields to bind.'
+                                    : description.inputIntent !== undefined
+                                        ? 'The validated input intent requests no predecessor data. Unspecified optional inputs are not binding questions; required literals remain the OAS argument stage responsibility.'
+                                        : 'The selected graph has no other API/native instance and no declared binding concern. There is no predecessor choice; missing literal values remain the argument stage responsibility.',
+                                evidence: description.messages.map((message) => ({
+                                    kind: 'message',
+                                    messageId: message.id,
+                                })),
+                            },
+                        }
+                        : {}),
+                },
+            },
+        });
+    if (!input.model || typeof input.model.withStructuredOutput !== 'function')
+        throw new Error('planWorkflowDraftApiCallBindings.model must support structured output when request inputs exist');
+    const output = await input.model
+        .withStructuredOutput(serializeStructuredOutputSchema(schema, 'draft-2020-12'), {
+        name: 'plan_draft_api_call_bindings',
+        method: 'jsonSchema',
+        strict: true,
+    })
+        .invoke([
+        new SystemMessage(workflowDraftApiCallBindingsPrompt),
+        new HumanMessage(JSON.stringify({
+            clarification: describeWorkflowDraftClarification(input.context),
+            planningClarifications,
+            instruction: description.instruction,
+            messages: description.messages,
+            backgroundMessages: description.backgroundMessages,
+            operation: {
+                key: description.operation.key,
+                method: description.operation.method,
+                path: description.operation.path,
+                summary: description.operation.operation.summary,
+                description: description.operation.operation.description,
+            },
+            ...(description.bindingTargets === undefined
+                ? {
+                    requestSchema: description.requestSchema,
+                    requestInputRoots: description.requestInputRoots,
+                }
+                : { bindingTargets: description.bindingTargets }),
+            requestMediaType: description.requestMediaType,
+            sourceCandidates: description.sources.values.map((source) => source.kind === 'native'
+                ? source
+                : {
+                    kind: source.kind,
+                    nodeId: source.nodeId,
+                    preparation: source.preparation,
+                    operation: {
+                        key: source.operation.key,
+                        method: source.operation.method,
+                        path: source.operation.path,
+                        responses: source.operation.operation.responses,
+                        summary: source.operation.operation.summary,
+                        description: source.operation.operation.description,
+                    },
+                    responsePointerCatalog: source.responsePointerCatalog,
+                }),
+            ...(description.previousCall === undefined
+                ? {}
+                : { previousCall: description.previousCall }),
+            includeExplanations: description.includeExplanations,
+        })),
+    ]);
+    try {
+        const parsed = parseStructuredOutput(schema, output, 'draft API call bindings');
+        if (!isDeepStrictEqual(parsed, output))
+            throw new Error('API call binding output changed during validation');
+        return resolveWorkflowDraftApiCallBindings({
+            ...input,
+            fingerprint: description.fingerprint,
+            proposal: parsed,
+        });
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftApiCallPlanningError({ stage: 'bindings', output }, cause);
+    }
+}

package/dist/draft/plan-workflow-draft-clarification-scopes.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedWorkflowDraftClarificationScopes } from '@openapi-flow/core';
+import type { PlanWorkflowDraftClarificationScopesInput } from '../types/workflow-draft-clarification.js';
+/** One semantic scope choice. No calls when there are no requirements or only the workflow scope exists. */
+export declare function planWorkflowDraftClarificationScopes(input: PlanWorkflowDraftClarificationScopesInput): Promise<ResolvedWorkflowDraftClarificationScopes>;