@openapi-flow/langchain 0.0.0-stage → 0.3.0

package/dist/draft/plan-workflow-draft-clarification-scopes.js

@@ -0,0 +1,77 @@
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowDraftClarificationScopes, createWorkflowDraftClarificationScopeSchema, resolveWorkflowDraftClarificationScopes, } from '@openapi-flow/core';
+import { workflowDraftClarificationScopePrompt } from '../prompts/workflow-draft-clarification-scope-prompt.js';
+import { serializeStructuredOutputSchema } from '../schemas/serialize-structured-output-schema.js';
+import { parseStructuredOutput } from '../legacy/planning/parse-structured-output.js';
+import { WorkflowDraftClarificationScopePlanningError } from './workflow-draft-clarification-scope-planning-error.js';
+import { createWorkflowMessageEvidenceSelectionSchema } from '../schemas/create-workflow-message-evidence-selection-schema.js';
+/** One semantic scope choice. No calls when there are no requirements or only the workflow scope exists. */
+export async function planWorkflowDraftClarificationScopes(input) {
+    const description = describeWorkflowDraftClarificationScopes(input);
+    if (!description.requirements.length ||
+        (!description.nodes.length &&
+            description.requirements.every((requirement) => requirement.origin?.kind !== 'clarification-question')))
+        return resolveWorkflowDraftClarificationScopes({
+            ...input,
+            fingerprint: description.fingerprint,
+            proposal: {
+                scopes: Object.fromEntries(description.requirements.map((requirement) => [
+                    requirement.id,
+                    {
+                        scope: { kind: 'workflow' },
+                        ...(description.includeExplanations
+                            ? {
+                                explanation: {
+                                    reason: 'No workflow nodes are selected; workflow is the only available scope.',
+                                    evidence: description.messages.map((message) => ({
+                                        kind: 'message',
+                                        messageId: message.id,
+                                        quote: message.text,
+                                    })),
+                                },
+                            }
+                            : {}),
+                    },
+                ])),
+            },
+        });
+    if (!input.model || typeof input.model.withStructuredOutput !== 'function')
+        throw new Error('planWorkflowDraftClarificationScopes.model must support structured output when multiple scopes exist');
+    const schema = createWorkflowDraftClarificationScopeSchema(input, createWorkflowMessageEvidenceSelectionSchema(description.messages));
+    const output = await input.model
+        .withStructuredOutput(serializeStructuredOutputSchema(schema, 'draft-2020-12', 'input'), {
+        name: 'scope_workflow_draft_clarification',
+        method: 'jsonSchema',
+        strict: true,
+    })
+        .invoke([
+        new SystemMessage(workflowDraftClarificationScopePrompt),
+        new HumanMessage(JSON.stringify({
+            requirements: description.requirements,
+            nodes: description.nodes,
+            messages: description.messages,
+            includeExplanations: description.includeExplanations,
+        })),
+    ]);
+    let proposal;
+    try {
+        proposal = parseStructuredOutput(schema, output, 'workflow draft clarification scopes');
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftClarificationScopePlanningError({ stage: 'scope-schema', output }, cause);
+    }
+    try {
+        return resolveWorkflowDraftClarificationScopes({
+            ...input,
+            fingerprint: description.fingerprint,
+            proposal,
+        });
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftClarificationScopePlanningError({ stage: 'scope-resolution', output }, cause);
+    }
+}

package/dist/draft/plan-workflow-draft-connection-edit.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDraftConnectionEditResult } from '@openapi-flow/core';
+import type { PlanWorkflowDraftConnectionEditInput } from '../types/workflow-draft-connection-edit.js';
+/** One final topology delta call, after actual material/consumer decisions have resolved. */
+export declare function planWorkflowDraftConnectionEdit(input: PlanWorkflowDraftConnectionEditInput): Promise<WorkflowDraftConnectionEditResult>;

package/dist/draft/plan-workflow-draft-connection-edit.js

@@ -0,0 +1,79 @@
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowDraftClarification, describeWorkflowDraftClarificationOwnership, describeWorkflowDraftConnectionEdit, createWorkflowDraftConnectionEditProposalSchema, resolveWorkflowDraftConnectionEdit, } from '@openapi-flow/core';
+import { workflowDraftConnectionEditPrompt } from '../prompts/workflow-draft-connection-edit-prompt.js';
+import { serializeStructuredOutputSchema } from '../schemas/serialize-structured-output-schema.js';
+import { parseStructuredOutput } from '../legacy/planning/parse-structured-output.js';
+import { WorkflowDraftConnectionEditPlanningError } from './workflow-draft-connection-edit-planning-error.js';
+import { createWorkflowMessageEvidenceSelectionSchema } from '../schemas/create-workflow-message-evidence-selection-schema.js';
+/** One final topology delta call, after actual material/consumer decisions have resolved. */
+export async function planWorkflowDraftConnectionEdit(input) {
+    const context = describeWorkflowDraftConnectionEdit(input);
+    if (context.status !== 'ready')
+        return { status: context.status, description: context };
+    if (!input.model || typeof input.model.withStructuredOutput !== 'function')
+        throw new Error('planWorkflowDraftConnectionEdit.model must support structured output');
+    const schema = createWorkflowDraftConnectionEditProposalSchema(context, createWorkflowMessageEvidenceSelectionSchema(context.messages));
+    const output = await input.model
+        .withStructuredOutput(serializeStructuredOutputSchema(schema, 'draft-7', 'input'), {
+        name: 'plan_draft_connection_edit',
+        method: 'jsonSchema',
+        strict: true,
+    })
+        .invoke([
+        new SystemMessage(workflowDraftConnectionEditPrompt),
+        new HumanMessage(JSON.stringify({
+            clarification: describeWorkflowDraftClarification(input.context),
+            planningClarifications: describeWorkflowDraftClarificationOwnership({
+                ...input,
+                stage: 'connections',
+            }),
+            instructions: context.steps.map((step) => ({
+                kind: step.decision.kind,
+                ...('nodeId' in step.decision
+                    ? { nodeId: step.decision.nodeId }
+                    : {}),
+                instruction: step.decision.instruction,
+            })),
+            affectedNodeIds: context.affectedNodeIds,
+            contracts: context.contracts,
+            existingEdges: context.existingEdges,
+            removedIncidentEdges: context.stage.nodeRemovalConnections.map((change) => change.edge),
+            apiInstances: context.apiInstances,
+            nativeNodes: context.stage.content.nativeNodes,
+            ...(context.stage.content.gapNodes === undefined
+                ? {}
+                : {
+                    gapNodes: context.stage.content.gapNodes.map((gap) => ({
+                        id: gap.id,
+                        requestedBehavior: gap.requestedBehavior,
+                        finding: gap.finding,
+                    })),
+                }),
+            requirements: context.stage.content.requirements,
+            messages: context.messages,
+            backgroundMessages: context.backgroundMessages,
+            includeExplanations: context.includeExplanations,
+        })),
+    ]);
+    let proposal;
+    try {
+        proposal = parseStructuredOutput(schema, output, 'draft connection edit');
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftConnectionEditPlanningError({ stage: 'proposal-schema', output }, cause);
+    }
+    try {
+        return resolveWorkflowDraftConnectionEdit({
+            ...input,
+            fingerprint: context.fingerprint,
+            proposal,
+        });
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftConnectionEditPlanningError({ stage: 'proposal-validation', output }, cause);
+    }
+}

package/dist/draft/plan-workflow-draft-native-dependencies.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDraftNativeDependencies } from '@openapi-flow/core';
+import type { PlanWorkflowDraftNativeDependenciesInput } from '../types/workflow-draft-native-node-addition.js';
+/** Separate checkpointable choice stage. No model call when no producer choice exists. */
+export declare function planWorkflowDraftNativeDependencies(input: PlanWorkflowDraftNativeDependenciesInput): Promise<WorkflowDraftNativeDependencies>;

package/dist/draft/plan-workflow-draft-native-dependencies.js

@@ -0,0 +1,45 @@
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { isDeepStrictEqual } from 'node:util';
+import { describeWorkflowDraftNativeDependencies, createWorkflowDraftNativeDependenciesSchema, resolveWorkflowDraftNativeDependencies, } from '@openapi-flow/core';
+import { serializeStructuredOutputSchema } from '../schemas/serialize-structured-output-schema.js';
+import { workflowDraftNativeDependenciesPrompt } from '../prompts/workflow-draft-native-dependencies-prompt.js';
+import { WorkflowDraftNativeNodeAdditionPlanningError } from './workflow-draft-native-node-addition-planning-error.js';
+/** Separate checkpointable choice stage. No model call when no producer choice exists. */
+export async function planWorkflowDraftNativeDependencies(input) {
+    if (input.model !== undefined &&
+        (!input.model || typeof input.model.withStructuredOutput !== 'function'))
+        throw new Error('planWorkflowDraftNativeDependencies.model must support structured output when supplied');
+    const context = describeWorkflowDraftNativeDependencies(input);
+    if (Object.values(context.sourceCandidatesByNodeId).every((ids) => ids.length === 0))
+        return resolveWorkflowDraftNativeDependencies({
+            ...input,
+            proposal: {
+                sourcesByNodeId: Object.fromEntries(context.roles.map((role) => [role.nodeId, { sourceNodeIds: [] }])),
+            },
+        });
+    if (!input.model || typeof input.model.withStructuredOutput !== 'function')
+        throw new Error('planWorkflowDraftNativeDependencies.model must support structured output for producer choices');
+    const output = await input.model
+        .withStructuredOutput(serializeStructuredOutputSchema(createWorkflowDraftNativeDependenciesSchema(input), 'draft-2020-12'), {
+        name: 'plan_draft_native_dependencies',
+        method: 'jsonSchema',
+        strict: true,
+    })
+        .invoke([
+        new SystemMessage(workflowDraftNativeDependenciesPrompt),
+        new HumanMessage(JSON.stringify(context)),
+    ]);
+    try {
+        if (!isDeepStrictEqual(describeWorkflowDraftNativeDependencies(input), context))
+            throw new Error('Draft native producer source contracts changed during planning; no automatic rebase');
+        return resolveWorkflowDraftNativeDependencies({
+            ...input,
+            proposal: output,
+        });
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftNativeNodeAdditionPlanningError({ stage: 'producer-dependencies', output }, cause);
+    }
+}

package/dist/draft/plan-workflow-draft-native-reference-repair.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDraftNativeReferenceRepairResult } from '@openapi-flow/core';
+import type { PlanWorkflowDraftNativeReferenceRepairInput } from '../types/workflow-draft-native-reference-repair.js';
+/** One model call proposes only source choices for implementation-declared reference locations. */
+export declare function planWorkflowDraftNativeReferenceRepair(input: PlanWorkflowDraftNativeReferenceRepairInput): Promise<WorkflowDraftNativeReferenceRepairResult>;

package/dist/draft/plan-workflow-draft-native-reference-repair.js

@@ -0,0 +1,68 @@
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowDraftClarification, describeWorkflowDraftNativeReferenceRepair, createWorkflowDraftNativeReferenceRepairSchema, resolveWorkflowDraftNativeReferenceRepair, } from '@openapi-flow/core';
+import { workflowDraftNativeReferenceRepairPrompt } from '../prompts/workflow-draft-native-reference-repair-prompt.js';
+import { serializeStructuredOutputSchema } from '../schemas/serialize-structured-output-schema.js';
+import { parseStructuredOutput } from '../legacy/planning/parse-structured-output.js';
+import { WorkflowDraftNativeReferenceRepairPlanningError } from './workflow-draft-native-reference-repair-planning-error.js';
+/** One model call proposes only source choices for implementation-declared reference locations. */
+export async function planWorkflowDraftNativeReferenceRepair(input) {
+    const context = describeWorkflowDraftNativeReferenceRepair(input);
+    if (!input.model || typeof input.model.withStructuredOutput !== 'function')
+        throw new Error('planWorkflowDraftNativeReferenceRepair.model must support structured output');
+    const schema = createWorkflowDraftNativeReferenceRepairSchema(context);
+    const output = await input.model
+        .withStructuredOutput(serializeStructuredOutputSchema(schema, 'draft-7'), {
+        name: 'plan_draft_native_reference_repair',
+        method: 'jsonSchema',
+        strict: true,
+    })
+        .invoke([
+        new SystemMessage(workflowDraftNativeReferenceRepairPrompt),
+        new HumanMessage(JSON.stringify({
+            clarification: describeWorkflowDraftClarification(input.context),
+            instructions: context.instructions,
+            target: { node: context.node, references: context.bindings },
+            sourceChanges: context.task.sourceNodeIds,
+            sourceCandidates: context.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: context.sources.exclusiveOutputs,
+            messages: context.messages,
+            backgroundMessages: context.backgroundMessages,
+            includeExplanations: context.includeExplanations,
+        })),
+    ]);
+    let proposal;
+    try {
+        proposal = parseStructuredOutput(schema, output, 'draft native reference repair');
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftNativeReferenceRepairPlanningError({ stage: 'proposal-schema', output }, cause);
+    }
+    try {
+        return resolveWorkflowDraftNativeReferenceRepair({
+            ...input,
+            fingerprint: context.fingerprint,
+            proposal,
+        });
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftNativeReferenceRepairPlanningError({ stage: 'proposal-validation', output }, cause);
+    }
+}

package/dist/draft/resolve-workflow-draft-edit-proposal.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowDraftEditProposal } from '@openapi-flow/core';
+import type { WorkflowDraftEditModelOutput, WorkflowDraftEditOperationCandidate } from '../types/workflow-draft-edit.js';
+export declare function resolveWorkflowDraftEditProposal(proposed: WorkflowDraftEditModelOutput, candidates: WorkflowDraftEditOperationCandidate[]): WorkflowDraftEditProposal;

package/dist/draft/resolve-workflow-draft-edit-proposal.js

@@ -0,0 +1,39 @@
+export function resolveWorkflowDraftEditProposal(proposed, candidates) {
+    function operation(candidateId) {
+        const candidate = candidates.find((candidate) => candidate.candidateId === candidateId);
+        if (!candidate)
+            throw new Error(`Unknown draft edit operation candidate ${candidateId}`);
+        return structuredClone(candidate.operation.key);
+    }
+    function evidence(item) {
+        return item.kind === 'oas'
+            ? { kind: 'oas', operation: operation(item.candidateId), pointer: '' }
+            : structuredClone(item);
+    }
+    return {
+        decisions: proposed.decisions.map((decision) => {
+            const { explanation, ...original } = decision;
+            const fields = explanation === undefined
+                ? {}
+                : {
+                    explanation: {
+                        reason: explanation.reason,
+                        evidence: explanation.evidence.map(evidence),
+                    },
+                };
+            if (original.kind === 'report-capability-gap') {
+                const finding = original.finding;
+                return {
+                    ...original,
+                    finding: finding.kind === 'api-contract-gap'
+                        ? { ...finding, operation: operation(finding.operation) }
+                        : finding,
+                    ...fields,
+                };
+            }
+            return 'operation' in original
+                ? { ...original, operation: operation(original.operation), ...fields }
+                : { ...original, ...fields };
+        }),
+    };
+}

package/dist/draft/select-workflow-draft-api-binding-inputs.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDraftApiBindingIntent } from '@openapi-flow/core';
+import type { SelectWorkflowDraftApiBindingInputsInput } from '../types/workflow-draft-api-call-planning.js';
+/** Select dependency intent before exposing producer schemas or permitting binding questions. */
+export declare function selectWorkflowDraftApiBindingInputs(input: SelectWorkflowDraftApiBindingInputsInput): Promise<WorkflowDraftApiBindingIntent>;

package/dist/draft/select-workflow-draft-api-binding-inputs.js

@@ -0,0 +1,83 @@
+import { isDeepStrictEqual } from 'node:util';
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowDraftApiBindingIntent, describeWorkflowDraftClarificationOwnership, createWorkflowDraftApiBindingIntentSchema, resolveWorkflowDraftApiBindingIntent, } from '@openapi-flow/core';
+import { workflowDraftApiBindingIntentPrompt } 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';
+/** Select dependency intent before exposing producer schemas or permitting binding questions. */
+export async function selectWorkflowDraftApiBindingInputs(input) {
+    const description = describeWorkflowDraftApiBindingIntent(input);
+    const schema = createWorkflowDraftApiBindingIntentSchema(input);
+    const planningClarifications = describeWorkflowDraftClarificationOwnership({
+        ...input,
+        stepId: input.stepId,
+        stage: 'api-bindings',
+    });
+    if (!description.hasRequestInputs ||
+        (!description.hasPotentialPredecessors && !planningClarifications.length))
+        return resolveWorkflowDraftApiBindingIntent({
+            ...input,
+            fingerprint: description.fingerprint,
+            proposal: {
+                targets: [],
+                sourceMessageIds: description.messages.map((message) => message.id),
+                ...(description.includeExplanations
+                    ? {
+                        explanation: {
+                            reason: !description.hasRequestInputs
+                                ? 'The selected OAS has no request fields for predecessor bindings.'
+                                : 'There is no other selected instance or declared predecessor contract and no explicit binding concern. Missing literals remain the OAS argument stage responsibility.',
+                            evidence: description.messages.map((message) => ({
+                                kind: 'message',
+                                messageId: message.id,
+                            })),
+                        },
+                    }
+                    : {}),
+            },
+        });
+    if (!input.model || typeof input.model.withStructuredOutput !== 'function')
+        throw new Error('selectWorkflowDraftApiBindingInputs.model must support structured output when dependency intent is unresolved');
+    const output = await input.model
+        .withStructuredOutput(serializeStructuredOutputSchema(schema, 'draft-2020-12'), {
+        name: 'select_draft_api_binding_inputs',
+        method: 'jsonSchema',
+        strict: true,
+    })
+        .invoke([
+        new SystemMessage(workflowDraftApiBindingIntentPrompt),
+        new HumanMessage(JSON.stringify({
+            instruction: description.instruction,
+            messages: description.messages,
+            backgroundMessages: description.backgroundMessages,
+            planningClarifications,
+            operation: {
+                key: description.operation.key,
+                method: description.operation.method,
+                path: description.operation.path,
+                summary: description.operation.operation.summary,
+                description: description.operation.operation.description,
+                parameters: description.operation.effective.parameters,
+            },
+            requestSchema: description.requestSchema,
+            requestMediaType: description.requestMediaType,
+            includeExplanations: description.includeExplanations,
+        })),
+    ]);
+    try {
+        const proposal = parseStructuredOutput(schema, output, 'draft API binding input intent');
+        if (!isDeepStrictEqual(proposal, output))
+            throw new Error('API binding input intent output changed during validation');
+        return resolveWorkflowDraftApiBindingIntent({
+            ...input,
+            fingerprint: description.fingerprint,
+            proposal,
+        });
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftApiCallPlanningError({ stage: 'binding-inputs', output }, cause);
+    }
+}

package/dist/draft/select-workflow-draft-api-input-edit-targets.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDraftApiInputEditContract } from '@openapi-flow/core';
+import type { SelectWorkflowDraftApiInputEditTargetsInput } from '../types/workflow-draft-api-input-edit.js';
+/** One bounded field-selection call; caller may review before value generation. */
+export declare function selectWorkflowDraftApiInputEditTargets(input: SelectWorkflowDraftApiInputEditTargetsInput): Promise<WorkflowDraftApiInputEditContract>;

package/dist/draft/select-workflow-draft-api-input-edit-targets.js

@@ -0,0 +1,55 @@
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowDraftClarification, describeWorkflowDraftClarificationOwnership, describeWorkflowDraftApiInputEdit, createWorkflowDraftApiInputEditProposalSchema, createWorkflowDraftApiInputEditContract, } from '@openapi-flow/core';
+import { workflowDraftApiInputEditTargetsPrompt } 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';
+/** One bounded field-selection call; caller may review before value generation. */
+export async function selectWorkflowDraftApiInputEditTargets(input) {
+    const described = describeWorkflowDraftApiInputEdit(input);
+    if (!input.model || typeof input.model.withStructuredOutput !== 'function')
+        throw new Error('selectWorkflowDraftApiInputEditTargets.model must support structured output');
+    const planId = input.plan.id;
+    const schema = createWorkflowDraftApiInputEditProposalSchema(input.requestMessageIds, described.includeExplanations, createWorkflowMessageEvidenceSelectionSchema(described.messages));
+    const output = await input.model
+        .withStructuredOutput(serializeStructuredOutputSchema(schema, 'draft-7', 'input'), {
+        name: 'select_draft_api_input_edit_targets',
+        method: 'jsonSchema',
+        strict: true,
+    })
+        .invoke([
+        new SystemMessage(workflowDraftApiInputEditTargetsPrompt),
+        new HumanMessage(JSON.stringify({
+            clarification: describeWorkflowDraftClarification(input.context),
+            planningClarifications: describeWorkflowDraftClarificationOwnership({
+                ...input,
+                stepId: input.stepId,
+                stage: 'api-arguments',
+            }),
+            instruction: described.instruction,
+            values: described.call.values,
+            bindings: described.call.bindings,
+            requestSchema: described.requestSchema,
+            messages: described.messages,
+            includeExplanations: described.includeExplanations,
+        })),
+    ]);
+    try {
+        const proposal = parseStructuredOutput(schema, output, 'draft API input edit targets');
+        const contract = createWorkflowDraftApiInputEditContract({
+            ...input,
+            proposal,
+        });
+        if (input.plan.id !== planId ||
+            JSON.stringify(describeWorkflowDraftApiInputEdit(input)) !==
+                JSON.stringify(described))
+            throw new Error('Draft API input edit source changed during target selection; no automatic rebase');
+        return contract;
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftApiInputEditPlanningError({ stage: 'targets', output }, cause);
+    }
+}

package/dist/draft/select-workflow-draft-native-node-parameter-ownership.d.ts

@@ -0,0 +1,4 @@
+import type { WorkflowDraftNativeNodeParameterOwnershipResult } from '@openapi-flow/core';
+import type { SelectWorkflowDraftNativeNodeParameterOwnershipInput } from '../types/workflow-draft-native-node-addition.js';
+/** One separately checkpointable ownership choice; never a hidden value-generation call. */
+export declare function selectWorkflowDraftNativeNodeParameterOwnership(input: SelectWorkflowDraftNativeNodeParameterOwnershipInput): Promise<WorkflowDraftNativeNodeParameterOwnershipResult>;

package/dist/draft/select-workflow-draft-native-node-parameter-ownership.js

@@ -0,0 +1,81 @@
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowDraftNativeNodeAddition, createWorkflowDraftNativeNodeParameterOwnershipSchema, resolveWorkflowDraftNativeNodeParameterOwnership, describeWorkflowDraftClarification, describeWorkflowDraftClarificationOwnership, } from '@openapi-flow/core';
+import { serializeStructuredOutputSchema } from '../schemas/serialize-structured-output-schema.js';
+import { parseStructuredOutput } from '../legacy/planning/parse-structured-output.js';
+import { workflowDraftNativeNodeParameterOwnershipPrompt } from '../prompts/workflow-draft-native-node-addition-prompt.js';
+import { WorkflowDraftNativeNodeAdditionPlanningError } from './workflow-draft-native-node-addition-planning-error.js';
+/** One separately checkpointable ownership choice; never a hidden value-generation call. */
+export async function selectWorkflowDraftNativeNodeParameterOwnership(input) {
+    if (input.parameterOwnership !== undefined)
+        throw new Error('Native addition already has explicit ownership; remove it before selecting again');
+    const description = describeWorkflowDraftNativeNodeAddition(input);
+    if (!description.allowRuntimeParameters ||
+        !description.capability.supportsRuntimeParameters ||
+        description.parameterMode === 'fixed-empty')
+        return resolveWorkflowDraftNativeNodeParameterOwnership({
+            ...input,
+            fingerprint: description.fingerprint,
+            proposal: {
+                decision: {
+                    status: 'literal',
+                    sourceMessageIds: description.messages.map((message) => message.id),
+                    ...(description.includeExplanations
+                        ? {
+                            explanation: {
+                                reason: 'The supplied policy and registered implementation require no runtime ownership choice.',
+                                evidence: description.messages.map((message) => ({
+                                    kind: 'message',
+                                    messageId: message.id,
+                                })),
+                            },
+                        }
+                        : {}),
+                },
+            },
+        });
+    if (!input.model || typeof input.model.withStructuredOutput !== 'function')
+        throw new Error('selectWorkflowDraftNativeNodeParameterOwnership.model must support structured output when ownership is selectable');
+    const schema = createWorkflowDraftNativeNodeParameterOwnershipSchema(input);
+    const output = await input.model
+        .withStructuredOutput(serializeStructuredOutputSchema(schema, 'draft-2020-12'), {
+        name: 'select_draft_native_node_parameter_ownership',
+        method: 'jsonSchema',
+        strict: true,
+    })
+        .invoke([
+        new SystemMessage(workflowDraftNativeNodeParameterOwnershipPrompt),
+        new HumanMessage(JSON.stringify({
+            clarification: describeWorkflowDraftClarification(input.context),
+            planningClarifications: describeWorkflowDraftClarificationOwnership({
+                ...input,
+                stepId: input.stepId,
+                stage: 'native-parameters',
+            }),
+            instruction: description.instruction,
+            ...(description.sourceDependencies === undefined
+                ? {}
+                : { sourceDependencies: description.sourceDependencies }),
+            capability: description.capability,
+            parametersSchema: description.parametersSchema,
+            messages: description.messages,
+            backgroundMessages: description.backgroundMessages,
+            sourceCandidates: description.sources.values.map((source) => ({
+                kind: source.kind,
+                nodeId: source.nodeId,
+            })),
+            includeExplanations: description.includeExplanations,
+        })),
+    ]);
+    try {
+        return resolveWorkflowDraftNativeNodeParameterOwnership({
+            ...input,
+            fingerprint: description.fingerprint,
+            proposal: parseStructuredOutput(schema, output, 'native addition parameter ownership'),
+        });
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftNativeNodeAdditionPlanningError({ stage: 'ownership', output }, cause);
+    }
+}

package/dist/draft/select-workflow-draft-native-parameter-edit-targets.d.ts

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

package/dist/draft/select-workflow-draft-native-parameter-edit-targets.js

@@ -0,0 +1,51 @@
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeWorkflowDraftClarification, describeWorkflowDraftClarificationOwnership, describeWorkflowDraftNativeParameterEdit, createWorkflowDraftNativeParameterEditProposalSchema, resolveWorkflowDraftNativeParameterEditTargets, } from '@openapi-flow/core';
+import { workflowDraftNativeParameterEditTargetsPrompt } 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 selectWorkflowDraftNativeParameterEditTargets(input) {
+    const context = describeWorkflowDraftNativeParameterEdit(input);
+    if (!input.model || typeof input.model.withStructuredOutput !== 'function')
+        throw new Error('selectWorkflowDraftNativeParameterEditTargets.model must support structured output');
+    const schema = createWorkflowDraftNativeParameterEditProposalSchema(context, createWorkflowMessageEvidenceSelectionSchema(context.messages));
+    const output = await input.model
+        .withStructuredOutput(serializeStructuredOutputSchema(schema, 'draft-7', 'input'), {
+        name: 'select_draft_native_parameter_edit_targets',
+        method: 'jsonSchema',
+        strict: true,
+    })
+        .invoke([
+        new SystemMessage(workflowDraftNativeParameterEditTargetsPrompt),
+        new HumanMessage(JSON.stringify({
+            clarification: describeWorkflowDraftClarification(input.context),
+            planningClarifications: describeWorkflowDraftClarificationOwnership({
+                ...input,
+                stepId: input.stepId,
+                stage: 'native-parameters',
+            }),
+            instruction: context.instruction,
+            capability: context.capability,
+            parameters: context.node.parameters,
+            runtimeParameters: context.node.runtimeParameters,
+            parametersSchema: context.parametersSchema,
+            messages: context.messages,
+            backgroundMessages: context.backgroundMessages,
+            includeExplanations: context.includeExplanations,
+        })),
+    ]);
+    try {
+        const proposal = parseStructuredOutput(schema, output, 'draft native parameter edit targets');
+        return resolveWorkflowDraftNativeParameterEditTargets({
+            ...input,
+            fingerprint: context.fingerprint,
+            proposal,
+        });
+    }
+    catch (cause) {
+        if (!(cause instanceof Error))
+            throw cause;
+        throw new WorkflowDraftNativeParameterEditPlanningError({ stage: 'targets', output }, cause);
+    }
+}

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

@@ -0,0 +1,5 @@
+import type { WorkflowDraftApiBindingEditPlanningFailure } from '../types/workflow-draft-api-binding-edit.js';
+export declare class WorkflowDraftApiBindingEditPlanningError extends Error {
+    readonly failure: WorkflowDraftApiBindingEditPlanningFailure;
+    constructor(failure: WorkflowDraftApiBindingEditPlanningFailure, cause: Error);
+}