@openapi-flow/langchain 0.0.0-stage → 0.3.0

package/dist/selection/analyze-api-selection.js

@@ -0,0 +1,117 @@
+import { createHash } from 'node:crypto';
+import { HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { describeApiSelectionContext, createApiSelectionExplanation, } from '@openapi-flow/core';
+import { createApiSelectionAnalysisSchema } from '../schemas/api-selection-analysis-schema.js';
+import { apiSelectionAnalysisPrompt } from '../prompts/api-selection-analysis-prompt.js';
+import { parseStructuredOutput } from '../legacy/planning/parse-structured-output.js';
+import { assertSelectionInput } from '../legacy/planning/select-operation.js';
+import { selectApiOperations } from './select-api-operations.js';
+import { resolveApiSelectionOptions } from './resolve-api-selection-options.js';
+import { apiSelectionExplanationPrompt } from '../prompts/api-selection-explanation-prompt.js';
+/** Additive clarification boundary; the existing selector keeps its output contract. */
+export async function analyzeApiSelection(input) {
+    assertSelectionInput(input.scenario, input.model);
+    if (!Array.isArray(input.operations))
+        throw new Error('operations must be an array');
+    const includeExplanations = resolveApiSelectionOptions({
+        includeExplanations: input.includeExplanations,
+    });
+    const context = describeApiSelectionContext({
+        scenario: input.scenario,
+        operations: input.operations,
+    });
+    if (!input.operations.length)
+        return { selection: await selectApiOperations(input), questions: [] };
+    const candidates = context.operations.map((operation, index) => ({
+        ...operation,
+        candidateId: `candidate-${index + 1}`,
+    }));
+    const schema = createApiSelectionAnalysisSchema(candidates.map((item) => item.candidateId), includeExplanations);
+    const proposed = await input.model
+        .withStructuredOutput(schema, {
+        name: 'analyze_api_selection',
+        method: 'jsonSchema',
+        strict: true,
+    })
+        .invoke([
+        new SystemMessage(`${apiSelectionAnalysisPrompt}\n${apiSelectionExplanationPrompt}`),
+        new HumanMessage(JSON.stringify({ scenario: context.scenario, candidates })),
+    ]);
+    const parsed = parseStructuredOutput(schema, proposed, 'model API selection analysis');
+    const byId = new Map(candidates.map((item) => [item.candidateId, item]));
+    const selected = parsed.operations.map((item) => {
+        const candidate = byId.get(item.candidateId);
+        if (!candidate)
+            throw new Error(`Unknown API candidate ${item.candidateId}`);
+        return {
+            key: structuredClone(candidate.key),
+            purpose: item.purpose,
+            ...('explanation' in item
+                ? {
+                    explanation: createApiSelectionExplanation({
+                        context,
+                        basis: { kind: 'candidates', operations: [candidate.key] },
+                        reason: item.explanation.reason,
+                    }),
+                }
+                : {}),
+        };
+    });
+    const questions = parsed.questions.map((question, index) => {
+        if (new Set(question.candidateIds).size !== question.candidateIds.length)
+            throw new Error('API alternatives must be distinct');
+        const alternatives = question.candidateIds.map((id) => {
+            const candidate = byId.get(id);
+            if (!candidate)
+                throw new Error(`Unknown API alternative ${id}`);
+            return structuredClone(context.operations[candidates.indexOf(candidate)]);
+        });
+        return {
+            kind: 'operation-choice',
+            id: createHash('sha256')
+                .update(JSON.stringify([
+                context.scenario,
+                index,
+                question.purpose,
+                alternatives.map((item) => item.key),
+            ]))
+                .digest('hex'),
+            message: question.message,
+            purpose: question.purpose,
+            candidates: alternatives,
+            ...('explanation' in question
+                ? {
+                    explanation: createApiSelectionExplanation({
+                        context,
+                        basis: {
+                            kind: 'candidates',
+                            operations: alternatives.map((candidate) => candidate.key),
+                        },
+                        reason: question.explanation.reason,
+                    }),
+                }
+                : {}),
+        };
+    });
+    if (!selected.length && !questions.length && !parsed.gaps.length)
+        throw new Error('API analysis must contain operations, questions or gaps');
+    return {
+        selection: {
+            operations: selected,
+            gaps: parsed.gaps.map((gap) => ({
+                kind: 'missing_operation',
+                description: gap.description,
+                ...('explanation' in gap
+                    ? {
+                        explanation: createApiSelectionExplanation({
+                            context,
+                            basis: { kind: 'catalog' },
+                            reason: gap.explanation.reason,
+                        }),
+                    }
+                    : {}),
+            })),
+        },
+        questions,
+    };
+}

package/dist/selection/resolve-api-selection-options.d.ts

@@ -0,0 +1,3 @@
+import type { ApiSelectionModelOptions } from '../types/operation-selection.js';
+/** Optional standalone selector feature; absence preserves the non-explanation API. */
+export declare function resolveApiSelectionOptions(input: ApiSelectionModelOptions): boolean;

package/dist/selection/resolve-api-selection-options.js

@@ -0,0 +1,6 @@
+import { apiSelectionOptionsSchema } from '../schemas/api-selection-options-schema.js';
+/** Optional standalone selector feature; absence preserves the non-explanation API. */
+export function resolveApiSelectionOptions(input) {
+    const options = apiSelectionOptionsSchema.parse(input);
+    return options.includeExplanations === true;
+}

package/dist/selection/select-api-operations.d.ts

@@ -0,0 +1,3 @@
+import type { ApiSelection } from '@openapi-flow/core';
+import type { SelectApiOperationsInput } from '../types/operation-selection.js';
+export declare function selectApiOperations(input: SelectApiOperationsInput): Promise<ApiSelection>;

package/dist/selection/select-api-operations.js

@@ -0,0 +1,84 @@
+import { SystemMessage, HumanMessage } from '@langchain/core/messages';
+import { describeApiSelectionContext, createApiSelectionExplanation, } from '@openapi-flow/core';
+import { createApiSelectionSchema } from '../schemas/api-selection-schema.js';
+import { operationSelectionPrompt } from '../prompts/operation-selection-prompt.js';
+import { assertSelectionInput } from '../legacy/planning/select-operation.js';
+import { parseStructuredOutput } from '../legacy/planning/parse-structured-output.js';
+import { resolveApiSelectionOptions } from './resolve-api-selection-options.js';
+import { apiSelectionExplanationPrompt } from '../prompts/api-selection-explanation-prompt.js';
+export async function selectApiOperations(input) {
+    const { scenario, model } = input;
+    assertSelectionInput(scenario, model);
+    if (!Array.isArray(input.operations))
+        throw new Error('operations must be an array');
+    const includeExplanations = resolveApiSelectionOptions({
+        includeExplanations: input.includeExplanations,
+    });
+    const context = describeApiSelectionContext({
+        scenario,
+        operations: input.operations,
+    });
+    const { operations } = context;
+    if (operations.length === 0)
+        return {
+            operations: [],
+            gaps: [
+                {
+                    kind: 'missing_operation',
+                    description: 'Supplied documents contain no REST operation candidates.',
+                },
+            ],
+        };
+    const candidates = operations.map((operation, index) => ({
+        ...operation,
+        candidateId: `candidate-${index + 1}`,
+    }));
+    const schema = createApiSelectionSchema(candidates.map((candidate) => candidate.candidateId), includeExplanations);
+    const proposed = await model
+        .withStructuredOutput(schema, {
+        name: 'select_api_operations',
+        method: 'jsonSchema',
+        strict: true,
+    })
+        .invoke([
+        new SystemMessage(`${operationSelectionPrompt}\n${apiSelectionExplanationPrompt}`),
+        new HumanMessage(JSON.stringify({ scenario, candidates })),
+    ]);
+    const selection = parseStructuredOutput(schema, proposed, 'model API selection');
+    if (selection.operations.length === 0 && selection.gaps.length === 0)
+        throw new Error('model API selection must contain operations or gaps');
+    const byId = new Map(candidates.map((candidate) => [candidate.candidateId, candidate]));
+    return {
+        operations: selection.operations.map((item) => {
+            const candidate = byId.get(item.candidateId);
+            if (!candidate)
+                throw new Error(`model API selection references unknown ${item.candidateId}`);
+            return {
+                key: { ...candidate.key },
+                purpose: item.purpose,
+                ...('explanation' in item
+                    ? {
+                        explanation: createApiSelectionExplanation({
+                            context,
+                            basis: { kind: 'candidates', operations: [candidate.key] },
+                            reason: item.explanation.reason,
+                        }),
+                    }
+                    : {}),
+            };
+        }),
+        gaps: selection.gaps.map((gap) => ({
+            kind: 'missing_operation',
+            description: gap.description,
+            ...('explanation' in gap
+                ? {
+                    explanation: createApiSelectionExplanation({
+                        context,
+                        basis: { kind: 'catalog' },
+                        reason: gap.explanation.reason,
+                    }),
+                }
+                : {}),
+        })),
+    };
+}

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

@@ -0,0 +1,16 @@
+import type { ApiInputRequirement } from '@openapi-flow/core';
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { z } from 'zod';
+import type { createApiInputAnswerSourceSchema } from '../schemas/api-input-answer-source-schema.js';
+export interface ExtractApiInputAnswersInput {
+    requirements: ApiInputRequirement[];
+    reply: string;
+    model: BaseChatModel;
+}
+export interface AnalyzeApiInputAnswersInput extends Omit<ExtractApiInputAnswersInput, 'model'> {
+    /** Required only when pending questions and a nonempty reply need interpretation. */
+    model?: BaseChatModel;
+    includeExplanations?: boolean;
+}
+export type ApiInputAnswersOutput = z.infer<ReturnType<typeof createApiInputAnswerSourceSchema>>;
+export type ApiInputAnswerProposal = ApiInputAnswersOutput['answers'][number];

package/dist/types/api-input-answers.js

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

package/dist/types/api-selection-analysis.d.ts

@@ -0,0 +1,3 @@
+import type { z } from 'zod';
+import type { createApiSelectionAnalysisSchema } from '../schemas/api-selection-analysis-schema.js';
+export type ApiSelectionAnalysisOutput = z.infer<ReturnType<typeof createApiSelectionAnalysisSchema>>;

package/dist/types/api-selection-analysis.js

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

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

@@ -0,0 +1,13 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { ApiLiteralGenerationInput, ApiArgumentGenerationContract, ApiArgumentProposalSchemaShape } from '@openapi-flow/core';
+import type { z } from 'zod';
+import type { createApiLiteralGenerationOutputSchema } from '../schemas/api-literal-generation-output-schema.js';
+import type { apiLiteralGenerationReasonSchema } from '../schemas/api-literal-generation-output-schema.js';
+export interface GenerateApiArgumentsInput extends ApiLiteralGenerationInput {
+    model?: BaseChatModel;
+    includeExplanations?: boolean;
+}
+export type ApiLiteralGenerationOutput = z.infer<ReturnType<typeof createApiLiteralGenerationOutputSchema>>;
+export type ApiLiteralGenerationOutputSchema = ApiArgumentGenerationContract['schema'] | z.ZodObject<ApiArgumentProposalSchemaShape & {
+    explanation: typeof apiLiteralGenerationReasonSchema;
+}, z.core.$strict>;

package/dist/types/argument-generation.js

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

package/dist/types/binding-planning.d.ts

@@ -0,0 +1,10 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { ApiBindingPlanningInput, ApiBindingPlanProposal, ExplainedApiBindingCall } from '@openapi-flow/core';
+export interface PlanApiBindingsInput extends ApiBindingPlanningInput {
+    model: BaseChatModel;
+    includeExplanations?: boolean;
+}
+export interface ExplainedApiBindingPlanOutput extends Omit<ApiBindingPlanProposal, 'calls'> {
+    calls: ExplainedApiBindingCall[];
+}
+export type ApiBindingPlanOutput = ApiBindingPlanProposal | ExplainedApiBindingPlanOutput;

package/dist/types/binding-planning.js

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

package/dist/types/legacy/catalog-planning.d.ts

@@ -0,0 +1,16 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { z } from 'zod';
+import type { CatalogSource } from '@openapi-flow/core/internal';
+import type { createCatalogSelectionSchema } from '../../legacy/schemas/catalog-selection-schema.js';
+import type { createCatalogStepSchema } from '../../legacy/schemas/catalog-step-schema.js';
+export type CatalogSelectionOutput = z.infer<ReturnType<typeof createCatalogSelectionSchema>>;
+export type CatalogStepOutput = z.infer<ReturnType<typeof createCatalogStepSchema>>;
+export interface PriorStepSummary {
+    id: string;
+    responseFields: string[];
+}
+export interface ProposeCatalogScenarioInput {
+    sources: CatalogSource[];
+    scenario: string;
+    model: BaseChatModel;
+}

package/dist/types/legacy/catalog-planning.js

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

package/dist/types/legacy/planning.d.ts

@@ -0,0 +1,5 @@
+import type { z } from 'zod';
+import type { createOperationPlanSchema } from '@openapi-flow/core/internal';
+import type { createOperationSelectionSchema } from '../../legacy/schemas/operation-selection-schema.js';
+export type OperationSelectionOutput = z.infer<ReturnType<typeof createOperationSelectionSchema>>;
+export type OperationPlanOutput = z.infer<ReturnType<typeof createOperationPlanSchema>>;

package/dist/types/legacy/planning.js

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

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

@@ -0,0 +1,76 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { z } from 'zod';
+import type { JsonValueObject, NativeNodePlanningInput, NativePlanningProposal, NativePlanningResult, NativePlanningAssessment, NativePlanningCapabilityMaterial, NativeNodePlanningRecord, NativeInstanceSelectionInput, NativeNodeConfigurationInput, NativeSelectedPlanningInput } from '@openapi-flow/core';
+export interface PlanNativeNodesInput extends NativeNodePlanningInput {
+    model?: BaseChatModel;
+    includeExplanations?: boolean;
+}
+export type NativeNodeProposal = NativePlanningProposal;
+export type { NativePlanningCapabilityMaterial } from '@openapi-flow/core';
+export interface NativeLiteralNodeOutput {
+    id: string;
+    capability: string;
+    parameters: JsonValueObject;
+}
+export interface NativeOwnedLiteralNodeOutput extends NativeLiteralNodeOutput {
+    parameterSource: 'literal';
+}
+export interface NativeRuntimeNodeOutput {
+    id: string;
+    capability: string;
+    parameterSource: 'workflow-input';
+}
+export type NativeNodeModelInstance = NativeLiteralNodeOutput | NativeOwnedLiteralNodeOutput | NativeRuntimeNodeOutput;
+export interface NativeNodeModelProposal {
+    nativeNodes: NativeNodeModelInstance[];
+    gaps: NativePlanningProposal['gaps'];
+}
+export interface ExplainedNativeNodeProposal {
+    node: NativeNodeModelInstance;
+    reason: string;
+}
+export interface ExplainedNativeNodePlanningOutput {
+    decision: {
+        additions: ExplainedNativeNodeProposal[];
+        gaps: NativePlanningProposal['gaps'];
+    } | {
+        noAdditionalNodesReason: string;
+        gaps: NativePlanningProposal['gaps'];
+    };
+}
+export type NativeNodePlanningOutput = NativeNodeModelProposal | ExplainedNativeNodePlanningOutput;
+export interface ResolvedNativeNodePlanningOutput {
+    proposal: NativeNodeProposal;
+    assessment?: NativePlanningAssessment;
+}
+export interface NativeNodeParameterContract {
+    schemas: z.ZodType<NativeNodeModelInstance>[];
+    material: NativePlanningCapabilityMaterial;
+}
+export interface NativeNodePlanningContract {
+    schema: z.ZodType<NativeNodePlanningOutput>;
+    capabilities: NativePlanningCapabilityMaterial[];
+}
+export interface NativeNodePlan extends NativePlanningResult {
+    nativePlanning?: NativeNodePlanningRecord;
+}
+export type NativeNodePlanningFailure = {
+    stage: 'instance-selection' | 'dependency-plan' | 'parameter-schema' | 'parameter-validation';
+    output: unknown;
+} | {
+    stage: 'proposal-schema';
+    output: unknown;
+} | {
+    stage: 'node-validation';
+    output: NativeNodeProposal;
+    sourceOutput?: NativeNodePlanningOutput;
+};
+export interface SelectNativeNodeInstancesInput extends NativeInstanceSelectionInput {
+    model?: BaseChatModel;
+}
+export interface GenerateNativeNodeParametersInput extends NativeNodeConfigurationInput {
+    model?: BaseChatModel;
+}
+export interface PlanNativeInstanceDependenciesInput extends NativeSelectedPlanningInput {
+    model?: BaseChatModel;
+}

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

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

package/dist/types/operation-selection.d.ts

@@ -0,0 +1,14 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { ApiOperationCandidate } from '@openapi-flow/core';
+import type { z } from 'zod';
+import type { createApiSelectionSchema } from '../schemas/api-selection-schema.js';
+export interface ApiSelectionModelOptions {
+    /** Opt in to reasons in the same call and code-owned discovery evidence. */
+    includeExplanations?: boolean;
+}
+export interface SelectApiOperationsInput extends ApiSelectionModelOptions {
+    operations: ApiOperationCandidate[];
+    scenario: string;
+    model: BaseChatModel;
+}
+export type ApiSelectionOutput = z.infer<ReturnType<typeof createApiSelectionSchema>>;

package/dist/types/operation-selection.js

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

package/dist/types/request-media-selection.d.ts

@@ -0,0 +1,15 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { ApiOperationContract } from '@openapi-flow/core';
+import type { z } from 'zod';
+import type { createApiRequestMediaTypeSchema } from '../schemas/api-request-media-type-schema.js';
+export interface SelectApiRequestMediaTypeInput {
+    operation: ApiOperationContract;
+    scenario: string;
+    purpose?: string;
+    model: BaseChatModel;
+}
+export interface AnalyzeApiRequestMediaTypeInput extends SelectApiRequestMediaTypeInput {
+    /** Optional same-call model reason; code attaches unchanged request-body sources. */
+    includeExplanations?: boolean;
+}
+export type ApiRequestMediaTypeOutput = z.infer<ReturnType<typeof createApiRequestMediaTypeSchema>>;

package/dist/types/request-media-selection.js

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

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

@@ -0,0 +1,28 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { ReviewableWorkflowGraphProposal, ReviewableWorkflowPlanningContext, WorkflowReviewGap, PlannedNativeNode, ExplainedWorkflowConnection, ExplainedWorkflowBlockedCall } from '@openapi-flow/core';
+import type { ExplainedGraphNativeNode } from './workflow-planning.js';
+export interface PlanReviewableWorkflowGraphInput extends ReviewableWorkflowPlanningContext {
+    scenario: string;
+    model: BaseChatModel;
+    gaps: WorkflowReviewGap[];
+    preparedNativeNodes?: PlannedNativeNode[];
+    includeExplanations?: boolean;
+}
+export type ReviewableWorkflowGraphPlanningFailure = {
+    stage: 'proposal-schema';
+    output: unknown;
+} | {
+    stage: 'graph-validation';
+    output: ReviewableWorkflowGraphModelOutput;
+};
+export type ReviewableWorkflowGraphOutput = Omit<ReviewableWorkflowGraphProposal, 'nativeNodes' | 'blockedCalls'> & {
+    additionalNativeNodes?: ReviewableWorkflowGraphProposal['nativeNodes'];
+    blockedCalls?: ReviewableWorkflowGraphProposal['blockedCalls'];
+};
+export interface ExplainedReviewableWorkflowGraphOutput extends ReviewableWorkflowGraphOutput {
+    reason: string;
+    additionalNativeNodes?: ExplainedGraphNativeNode[];
+    edges: ExplainedWorkflowConnection[];
+    blockedCalls?: ExplainedWorkflowBlockedCall[];
+}
+export type ReviewableWorkflowGraphModelOutput = ReviewableWorkflowGraphOutput | ExplainedReviewableWorkflowGraphOutput;

package/dist/types/reviewable-workflow-planning.js

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

package/dist/types/structured-output-schema.d.ts

@@ -0,0 +1,3 @@
+export type StructuredOutputSchemaDialect = 'draft-7' | 'draft-2020-12';
+export type StructuredOutputSchemaDirection = 'input' | 'output';
+export type StructuredOutputSchemaReuse = 'inline' | 'ref';

package/dist/types/structured-output-schema.js

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

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

@@ -0,0 +1,23 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { ApiOperationContract, ClarificationQuestionLimits, WorkflowClarificationOptions, WorkflowDecisionExplanation, WorkflowMessageEvidence, WorkflowNativeEvidence, WorkflowEntryPointEvidence, WorkflowPlanningContext, WorkflowRequirementsProposal, WorkflowSourceMessage } from '@openapi-flow/core';
+export interface ClarifyWorkflowRequirementsInput {
+    context: WorkflowPlanningContext;
+    limits: ClarificationQuestionLimits;
+    options?: WorkflowClarificationOptions;
+    model: BaseChatModel;
+    /** Earlier intent, not authority for a new statement or answer. */
+    backgroundMessages?: WorkflowSourceMessage[];
+}
+export interface WorkflowClarificationOasCandidate {
+    candidateId: string;
+    operation: ApiOperationContract;
+}
+export interface ProposedWorkflowOasEvidence {
+    kind: 'oas';
+    candidateId: string;
+}
+export type ProposedWorkflowPlanningEvidence = WorkflowMessageEvidence | WorkflowNativeEvidence | WorkflowEntryPointEvidence | ProposedWorkflowOasEvidence;
+export type WorkflowRequirementsModelOutput = WorkflowRequirementsProposal<ProposedWorkflowPlanningEvidence>;
+export interface CanonicalWorkflowExplanationFields {
+    explanation?: WorkflowDecisionExplanation;
+}

package/dist/types/workflow-clarification.js

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

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

@@ -0,0 +1,9 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { WorkflowDraftApiBindingEditInput } from '@openapi-flow/core';
+export interface PlanWorkflowDraftApiBindingEditInput extends WorkflowDraftApiBindingEditInput {
+    model: BaseChatModel;
+}
+export interface WorkflowDraftApiBindingEditPlanningFailure {
+    stage: 'proposal-schema' | 'proposal-validation';
+    output: unknown;
+}

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

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

package/dist/types/workflow-draft-api-call-planning.d.ts

@@ -0,0 +1,15 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { WorkflowDraftApiCallPlanningInput, WorkflowDraftApiCallBindingsInput, WorkflowDraftApiCallArgumentsInput } from '@openapi-flow/core';
+export interface SelectWorkflowDraftApiBindingInputsInput extends WorkflowDraftApiCallPlanningInput {
+    model?: BaseChatModel;
+}
+export interface PlanWorkflowDraftApiCallBindingsInput extends WorkflowDraftApiCallBindingsInput {
+    model?: BaseChatModel;
+}
+export interface GenerateWorkflowDraftApiCallArgumentsInput extends WorkflowDraftApiCallArgumentsInput {
+    model?: BaseChatModel;
+}
+export interface WorkflowDraftApiCallPlanningFailure {
+    stage: 'binding-inputs' | 'bindings' | 'arguments';
+    output: unknown;
+}

package/dist/types/workflow-draft-api-call-planning.js

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

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

@@ -0,0 +1,13 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { WorkflowDraftApiInputEditInput, WorkflowDraftApiInputEditContractInput } from '@openapi-flow/core';
+export interface SelectWorkflowDraftApiInputEditTargetsInput extends WorkflowDraftApiInputEditInput {
+    model: BaseChatModel;
+}
+export interface GenerateWorkflowDraftApiInputEditsInput extends WorkflowDraftApiInputEditContractInput {
+    /** Not needed when the explicit contract contains removals only. */
+    model?: BaseChatModel;
+}
+export interface WorkflowDraftApiInputEditPlanningFailure {
+    stage: 'targets' | 'values';
+    output: unknown;
+}

package/dist/types/workflow-draft-api-input-edit.js

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

package/dist/types/workflow-draft-clarification.d.ts

@@ -0,0 +1,9 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { WorkflowDraftClarificationScopeInput } from '@openapi-flow/core';
+export interface PlanWorkflowDraftClarificationScopesInput extends WorkflowDraftClarificationScopeInput {
+    model: BaseChatModel;
+}
+export interface WorkflowDraftClarificationScopePlanningFailure {
+    stage: 'scope-schema' | 'scope-resolution';
+    output: unknown;
+}

package/dist/types/workflow-draft-clarification.js

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

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

@@ -0,0 +1,9 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { WorkflowDraftConnectionEditInput } from '@openapi-flow/core';
+export interface PlanWorkflowDraftConnectionEditInput extends WorkflowDraftConnectionEditInput {
+    model: BaseChatModel;
+}
+export interface WorkflowDraftConnectionEditPlanningFailure {
+    stage: 'proposal-schema' | 'proposal-validation';
+    output: unknown;
+}

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

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

package/dist/types/workflow-draft-edit.d.ts

@@ -0,0 +1,16 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { WorkflowDraftEditInput, WorkflowDraftEditOptions, WorkflowDraftEditProposal, ApiOperationContract } from '@openapi-flow/core';
+import type { ProposedWorkflowPlanningEvidence } from './workflow-clarification.js';
+export interface AnalyzeWorkflowDraftEditInput extends WorkflowDraftEditInput {
+    options?: WorkflowDraftEditOptions;
+    model: BaseChatModel;
+}
+export type WorkflowDraftEditModelOutput = WorkflowDraftEditProposal<string, ProposedWorkflowPlanningEvidence>;
+export interface WorkflowDraftEditOperationCandidate {
+    candidateId: string;
+    operation: ApiOperationContract;
+}
+export interface WorkflowDraftEditPlanningFailure {
+    stage: 'proposal-schema' | 'proposal-validation';
+    proposal: unknown;
+}

package/dist/types/workflow-draft-edit.js

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

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

@@ -0,0 +1,18 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { WorkflowDraftNativeNodeAdditionInput, WorkflowDraftNativeDependenciesInput } from '@openapi-flow/core';
+export interface PlanWorkflowDraftNativeDependenciesInput extends WorkflowDraftNativeDependenciesInput {
+    /** Required only when the original plan offers a producer choice. */
+    model?: BaseChatModel;
+}
+export interface GenerateWorkflowDraftNativeNodeAdditionInput extends WorkflowDraftNativeNodeAdditionInput {
+    /** Not required when the implementation proves the sole valid setting is {}. */
+    model?: BaseChatModel;
+}
+export interface SelectWorkflowDraftNativeNodeParameterOwnershipInput extends WorkflowDraftNativeNodeAdditionInput {
+    /** No model is needed when policy or the implementation permits only literals. */
+    model?: BaseChatModel;
+}
+export interface WorkflowDraftNativeNodeAdditionPlanningFailure {
+    stage: 'proposal-schema' | 'node-validation' | 'ownership' | 'producer-dependencies';
+    output: unknown;
+}

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

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

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

@@ -0,0 +1,13 @@
+import type { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import type { WorkflowDraftNativeParameterEditInput, WorkflowDraftNativeParameterEditContractInput } from '@openapi-flow/core';
+export interface SelectWorkflowDraftNativeParameterEditTargetsInput extends WorkflowDraftNativeParameterEditInput {
+    model: BaseChatModel;
+}
+export interface GenerateWorkflowDraftNativeParameterEditsInput extends WorkflowDraftNativeParameterEditContractInput {
+    /** Required only when selected set targets contain actual values to generate. */
+    model?: BaseChatModel;
+}
+export interface WorkflowDraftNativeParameterEditPlanningFailure {
+    stage: 'targets' | 'values';
+    output: unknown;
+}