@jsonstudio/llms 0.4.3 → 0.4.5

package/dist/conversion/conversion-v3/nodes/process/virtual-router-process-node.js

@@ -1,430 +0,0 @@
-import { VirtualRouterEngine } from '../../../../router/virtual-router/engine.js';
-import { providerErrorCenter } from '../../../../router/virtual-router/error-center.js';
-import { VirtualRouterError, VirtualRouterErrorCode } from '../../../../router/virtual-router/types.js';
-import { NodeStatus, NodeType } from '../../types/index.js';
-export class VirtualRouterProcessNode {
-    id;
-    type = NodeType.PROCESS;
-    name;
-    status = NodeStatus.IDLE;
-    config;
-    engine = new VirtualRouterEngine();
-    unsubscribeFromErrors = null;
-    watchedProviders = new Set();
-    constructor(nodeId, config) {
-        this.id = nodeId;
-        this.name = config.name || 'Virtual Router Process Node';
-        this.config = config;
-        this.initialize();
-    }
-    async execute(context) {
-        const start = Date.now();
-        try {
-            this.status = NodeStatus.RUNNING;
-            const routingSubject = this.extractRoutingSubject(context.data);
-            const metadataBag = this.ensureRequestMetadata(context);
-            const routerMetadata = this.buildRouterMetadata(context, metadataBag, routingSubject);
-            const { target, decision, diagnostics } = this.engine.route(routingSubject, routerMetadata);
-            const previousModel = typeof routingSubject?.model === 'string' ? routingSubject.model : undefined;
-            this.applyTargetToMetadata(metadataBag, target, decision.routeName, previousModel);
-            this.applyTargetToSubject(routingSubject, target, previousModel);
-            const resultData = {
-                ...context.data,
-                routingDecision: decision,
-                routingDiagnostics: diagnostics
-            };
-            if (this.isProcessedRequest(routingSubject)) {
-                resultData.processedRequest = routingSubject;
-            }
-            else {
-                resultData.standardizedRequest = routingSubject;
-            }
-            this.attachDiagnostics(context, diagnostics);
-            this.status = NodeStatus.COMPLETED;
-            return {
-                success: true,
-                data: resultData,
-                metadata: {
-                    node: this.id,
-                    executionTime: Date.now() - start,
-                    startTime: start,
-                    endTime: Date.now()
-                }
-            };
-        }
-        catch (error) {
-            this.status = NodeStatus.FAILED;
-            const failure = error instanceof Error ? error : new Error('Virtual router failed');
-            return {
-                success: false,
-                error: {
-                    code: error instanceof VirtualRouterError ? error.code : 'VIRTUAL_ROUTER_FAILURE',
-                    message: failure.message,
-                    details: error instanceof VirtualRouterError
-                        ? { ...(error.details ?? {}), node: this.id }
-                        : { node: this.id, stage: 'virtual-router' },
-                    cause: failure
-                },
-                metadata: {
-                    node: this.id,
-                    executionTime: Date.now() - start,
-                    startTime: start,
-                    endTime: Date.now()
-                }
-            };
-        }
-    }
-    validate(data) {
-        const errors = [];
-        if (!data.standardizedRequest) {
-            errors.push({
-                field: 'standardizedRequest',
-                message: 'Standardized request is required for virtual routing',
-                code: VirtualRouterErrorCode.NO_STANDARDIZED_REQUEST
-            });
-        }
-        return { valid: errors.length === 0, errors, warnings: [] };
-    }
-    cleanup() {
-        this.status = NodeStatus.IDLE;
-        if (this.unsubscribeFromErrors) {
-            this.unsubscribeFromErrors();
-            this.unsubscribeFromErrors = null;
-        }
-        return Promise.resolve();
-    }
-    updateConfig(newConfig) {
-        this.engine.initialize(newConfig);
-        this.registerProviderFailureListener(Object.keys(newConfig.providers ?? {}));
-    }
-    getStatus() {
-        return {
-            node: this.id,
-            status: this.status,
-            ...this.engine.getStatus()
-        };
-    }
-    initialize() {
-        const routerConfig = this.extractRouterConfig(this.config);
-        this.engine.initialize(routerConfig);
-        this.registerProviderFailureListener(Object.keys(routerConfig.providers ?? {}));
-    }
-    extractRouterConfig(nodeConfig) {
-        const options = nodeConfig.options;
-        if (!options || typeof options !== 'object' || !('virtualRouter' in options)) {
-            throw new VirtualRouterError('virtualRouter configuration is required in node options', VirtualRouterErrorCode.CONFIG_ERROR);
-        }
-        const config = options.virtualRouter;
-        if (!config || typeof config !== 'object') {
-            throw new VirtualRouterError('Invalid virtualRouter configuration', VirtualRouterErrorCode.CONFIG_ERROR);
-        }
-        return normalizeVirtualRouterConfig(config);
-    }
-    registerProviderFailureListener(providerKeys) {
-        this.watchedProviders = new Set(providerKeys);
-        if (this.unsubscribeFromErrors) {
-            this.unsubscribeFromErrors();
-            this.unsubscribeFromErrors = null;
-        }
-        if (this.watchedProviders.size === 0) {
-            return;
-        }
-        this.unsubscribeFromErrors = providerErrorCenter.subscribe((event) => {
-            this.handleProviderErrorEvent(event);
-        });
-    }
-    handleProviderErrorEvent(event) {
-        if (!event) {
-            return;
-        }
-        const runtime = event.runtime ?? {};
-        const providerKey = runtime.providerKey ||
-            (runtime.target && typeof runtime.target === 'object' ? runtime.target.providerKey : undefined);
-        if (providerKey && !this.watchedProviders.has(providerKey)) {
-            return;
-        }
-        this.engine.handleProviderError(event);
-    }
-    extractStandardizedRequest(data) {
-        const request = data.standardizedRequest;
-        if (!request || typeof request !== 'object') {
-            throw new VirtualRouterError('Standardized request missing from node data', VirtualRouterErrorCode.NO_STANDARDIZED_REQUEST);
-        }
-        return request;
-    }
-    extractRoutingSubject(data) {
-        const processed = data.processedRequest;
-        if (processed && typeof processed === 'object') {
-            return processed;
-        }
-        const request = data.standardizedRequest;
-        if (request && typeof request === 'object') {
-            return request;
-        }
-        throw new VirtualRouterError('Standardized request missing from node data', VirtualRouterErrorCode.NO_STANDARDIZED_REQUEST);
-    }
-    ensureRequestMetadata(context) {
-        if (!context.request.context || typeof context.request.context !== 'object') {
-            context.request.context = { metadata: {} };
-        }
-        const requestContext = context.request.context;
-        if (!requestContext.metadata || typeof requestContext.metadata !== 'object') {
-            requestContext.metadata = {};
-        }
-        return requestContext.metadata;
-    }
-    buildRouterMetadata(context, metadata, subject) {
-        const requestId = context.request.id ?? `req_${Date.now()}`;
-        const entryEndpoint = (typeof metadata.entryEndpoint === 'string' && metadata.entryEndpoint.trim()
-            ? metadata.entryEndpoint
-            : resolveEntryEndpoint(context)) || '/v1/chat/completions';
-        const processMode = metadata.processMode === 'passthrough' ? 'passthrough' : 'chat';
-        const direction = metadata.direction === 'response' ? 'response' : 'request';
-        const stage = typeof metadata.stage === 'string' ? metadata.stage : undefined;
-        const providerProtocol = typeof metadata.providerProtocol === 'string'
-            ? metadata.providerProtocol
-            : typeof context.request.options?.provider === 'string'
-                ? context.request.options.provider
-                : undefined;
-        const routeHint = typeof metadata.routeHint === 'string'
-            ? metadata.routeHint
-            : typeof subject.metadata?.routeHint === 'string'
-                ? subject.metadata.routeHint
-                : undefined;
-        return {
-            requestId,
-            entryEndpoint,
-            processMode,
-            stream: metadata.stream === true,
-            direction,
-            providerProtocol,
-            stage,
-            routeHint
-        };
-    }
-    applyTargetToMetadata(metadata, target, routeName, originalModel) {
-        metadata.routeName = routeName;
-        metadata.pipelineId = target.providerKey;
-        metadata.target = target;
-        metadata.providerKey = target.providerKey;
-        metadata.providerType = target.providerType;
-        metadata.modelId = target.modelId;
-        metadata.processMode = target.processMode || 'chat';
-        if (originalModel && typeof originalModel === 'string' && originalModel.trim()) {
-            const trimmed = originalModel.trim();
-            if (typeof metadata.originalModelId !== 'string' || !metadata.originalModelId) {
-                metadata.originalModelId = trimmed;
-            }
-            if (typeof metadata.clientModelId !== 'string' || !metadata.clientModelId) {
-                metadata.clientModelId = trimmed;
-            }
-        }
-        if (typeof target.modelId === 'string' && target.modelId.trim() && metadata.assignedModelId !== target.modelId) {
-            metadata.assignedModelId = target.modelId.trim();
-        }
-    }
-    applyTargetToSubject(subject, target, originalModel) {
-        const newModel = extractModelFromProviderKey(target);
-        if (!newModel) {
-            throw new VirtualRouterError(`Routing target ${target.providerKey} is missing model identifier`, VirtualRouterErrorCode.CONFIG_ERROR, { providerKey: target.providerKey });
-        }
-        subject.model = newModel;
-        if (subject.parameters && typeof subject.parameters === 'object') {
-            subject.parameters = {
-                ...subject.parameters,
-                model: newModel
-            };
-        }
-        else {
-            subject.parameters = { model: newModel };
-        }
-        subject.metadata = {
-            ...subject.metadata,
-            providerKey: target.providerKey,
-            providerType: target.providerType,
-            processMode: target.processMode || 'chat'
-        };
-        if (!subject.metadata || typeof subject.metadata !== 'object') {
-            subject.metadata = {};
-        }
-        const subjectMeta = subject.metadata;
-        if (originalModel && typeof originalModel === 'string' && originalModel.trim()) {
-            if (typeof subjectMeta.originalModelId !== 'string' || !subjectMeta.originalModelId) {
-                subjectMeta.originalModelId = originalModel.trim();
-            }
-            if (typeof subjectMeta.clientModelId !== 'string' || !subjectMeta.clientModelId) {
-                subjectMeta.clientModelId = originalModel.trim();
-            }
-        }
-        subjectMeta.assignedModelId = newModel;
-    }
-    attachDiagnostics(context, diagnostics) {
-        if (!context.data.debug) {
-            context.data.debug = {};
-        }
-        const debug = context.data.debug;
-        const stages = debug.stages ||
-            (() => {
-                const container = {};
-                debug.stages = container;
-                return container;
-            })();
-        stages['virtual-router'] = diagnostics;
-    }
-    isProcessedRequest(subject) {
-        return typeof subject.processed === 'object';
-    }
-}
-function resolveEntryEndpoint(context) {
-    const ctx = context.request.context;
-    if (ctx && typeof ctx === 'object') {
-        const maybeEntry = ctx.entryEndpoint;
-        if (typeof maybeEntry === 'string' && maybeEntry.trim()) {
-            return maybeEntry;
-        }
-    }
-    return typeof context.request.endpoint === 'string' ? context.request.endpoint : undefined;
-}
-function extractModelFromProviderKey(target) {
-    if (!target || typeof target.providerKey !== 'string') {
-        return null;
-    }
-    if (typeof target.modelId === 'string' && target.modelId.trim()) {
-        return target.modelId.trim();
-    }
-    const providerKey = target.providerKey;
-    if (typeof target.runtimeKey === 'string' && target.runtimeKey.length) {
-        const prefix = `${target.runtimeKey}.`;
-        if (providerKey.startsWith(prefix)) {
-            const candidate = providerKey.slice(prefix.length).trim();
-            if (candidate.length) {
-                return candidate;
-            }
-        }
-    }
-    const firstDot = providerKey.indexOf('.');
-    if (firstDot <= 0 || firstDot === providerKey.length - 1) {
-        return null;
-    }
-    const fallback = providerKey.slice(firstDot + 1).trim();
-    return fallback.length ? fallback : null;
-}
-function normalizeVirtualRouterConfig(raw) {
-    if (!raw || typeof raw !== 'object') {
-        throw new VirtualRouterError('virtualRouter config cannot be empty', VirtualRouterErrorCode.CONFIG_ERROR);
-    }
-    if (isVirtualRouterConfig(raw)) {
-        return raw;
-    }
-    const source = raw;
-    const routing = normalizeRoutingTable(source.routing);
-    if (Object.keys(routing).length === 0) {
-        throw new VirtualRouterError('virtualRouter routing table cannot be empty', VirtualRouterErrorCode.CONFIG_ERROR);
-    }
-    const providersRaw = asRecord(source.providers);
-    const providers = buildProviderProfiles(providersRaw, routing);
-    return {
-        routing,
-        providers,
-        classifier: normalizeClassifierConfig(source.classifier),
-        loadBalancing: source.loadBalancing,
-        health: source.health
-    };
-}
-function isVirtualRouterConfig(value) {
-    if (!value || typeof value !== 'object')
-        return false;
-    const v = value;
-    return typeof v.routing === 'object' && typeof v.providers === 'object';
-}
-function normalizeRoutingTable(input) {
-    const table = {};
-    if (!input || typeof input !== 'object') {
-        return table;
-    }
-    for (const [route, list] of Object.entries(input)) {
-        if (Array.isArray(list)) {
-            table[route] = list.map((entry) => String(entry));
-        }
-    }
-    return table;
-}
-function buildProviderProfiles(providersSource, routing) {
-    const profiles = {};
-    const requiredKeys = new Set();
-    for (const entries of Object.values(routing)) {
-        for (const entry of entries) {
-            requiredKeys.add(String(entry));
-        }
-    }
-    for (const providerKey of requiredKeys) {
-        if (profiles[providerKey])
-            continue;
-        const [providerId, modelId] = providerKey.split('.');
-        const provider = asRecord(providersSource[providerId]);
-        profiles[providerKey] = convertProviderProfile(providerKey, providerId, modelId, provider);
-    }
-    return profiles;
-}
-function convertProviderProfile(providerKey, providerId, modelId, provider) {
-    const providerType = normalizeProviderType(provider);
-    const normalizedModel = typeof modelId === 'string' && modelId.trim() ? modelId.trim() : null;
-    if (!normalizedModel) {
-        throw new VirtualRouterError(`Routing entry ${providerKey} is missing model identifier`, VirtualRouterErrorCode.CONFIG_ERROR);
-    }
-    return {
-        providerKey,
-        providerType,
-        endpoint: String(provider.endpoint || provider.baseURL || provider.baseUrl || ''),
-        auth: buildProviderAuth(providerId, provider),
-        outboundProfile: mapProviderTypeToOutboundProfile(providerType),
-        compatibilityProfile: typeof provider.compat === 'string' ? provider.compat : 'default'
-    };
-}
-function normalizeProviderType(provider) {
-    const raw = String(provider.providerType || provider.type || '').toLowerCase();
-    if (raw.includes('responses'))
-        return 'responses';
-    if (raw.includes('anthropic'))
-        return 'anthropic';
-    if (raw.includes('gemini'))
-        return 'gemini';
-    return 'openai';
-}
-function mapProviderTypeToOutboundProfile(providerType) {
-    const value = providerType.toLowerCase();
-    if (value === 'anthropic')
-        return 'anthropic-messages';
-    if (value === 'responses')
-        return 'openai-responses';
-    if (value === 'gemini')
-        return 'gemini-chat';
-    return 'openai-chat';
-}
-function buildProviderAuth(providerId, provider) {
-    const auth = asRecord(provider.auth);
-    const baseType = typeof auth.type === 'string' ? auth.type.toLowerCase() : 'apikey';
-    const type = baseType === 'oauth' ? 'oauth' : 'apiKey';
-    const secretRef = typeof auth.secretRef === 'string'
-        ? auth.secretRef
-        : providerId;
-    return { type, secretRef };
-}
-function normalizeClassifierConfig(input) {
-    const source = asRecord(input);
-    return {
-        longContextThresholdTokens: typeof source.longContextThresholdTokens === 'number' ? source.longContextThresholdTokens : 60000,
-        thinkingKeywords: toStringArray(source.thinkingKeywords),
-        backgroundKeywords: toStringArray(source.backgroundKeywords),
-        visionKeywords: toStringArray(source.visionKeywords),
-        codingKeywords: toStringArray(source.codingKeywords)
-    };
-}
-function asRecord(value) {
-    return value && typeof value === 'object' ? value : {};
-}
-function toStringArray(value) {
-    if (!Array.isArray(value))
-        return [];
-    return value.map((entry) => String(entry));
-}

package/dist/conversion/conversion-v3/nodes/response/anthropic-response-input-node.d.ts

@@ -1,12 +0,0 @@
-import { NodeType, NodeStatus, type NodeConfig, type NodeContext, type NodeResult, type PipelineNode, type ValidationResult } from '../../types/index.js';
-export declare class AnthropicResponseInputNode implements PipelineNode {
-    readonly id: string;
-    readonly config: NodeConfig;
-    readonly type = NodeType.INPUT;
-    status: NodeStatus;
-    readonly name: string;
-    constructor(id: string, config: NodeConfig);
-    execute(context: NodeContext): Promise<NodeResult>;
-    validate(): ValidationResult;
-    cleanup(): Promise<void>;
-}

package/dist/conversion/conversion-v3/nodes/response/anthropic-response-input-node.js

@@ -1,129 +0,0 @@
-import { NodeType, NodeStatus } from '../../types/index.js';
-function toOpenAIChatResponse(raw) {
-    const content = Array.isArray(raw?.content) ? raw.content : [];
-    const textParts = [];
-    const toolCalls = [];
-    for (const part of content) {
-        if (!part || typeof part !== 'object')
-            continue;
-        const type = String(part.type || '').toLowerCase();
-        if (type === 'text' && typeof part.text === 'string') {
-            textParts.push(part.text);
-        }
-        else if (type === 'tool_use') {
-            const name = typeof part.name === 'string' ? part.name : '';
-            const id = typeof part.id === 'string' ? part.id : `call_${Math.random().toString(36).slice(2, 10)}`;
-            let args = '';
-            const input = part.input;
-            if (typeof input === 'string')
-                args = input;
-            else {
-                try {
-                    args = JSON.stringify(input ?? {});
-                }
-                catch {
-                    args = '{}';
-                }
-            }
-            if (name)
-                toolCalls.push({ id, name, args });
-        }
-    }
-    const mapFinishReason = (reason) => {
-        switch (reason) {
-            case 'tool_use': return 'tool_calls';
-            case 'max_tokens': return 'length';
-            case 'stop_sequence': return 'content_filter';
-            default: return 'stop';
-        }
-    };
-    return {
-        id: raw?.id || `chatcmpl_${Date.now()}`,
-        object: 'chat.completion',
-        created: Math.floor(Date.now() / 1000),
-        model: raw?.model || 'unknown',
-        choices: [
-            {
-                index: 0,
-                finish_reason: mapFinishReason(raw?.stop_reason),
-                message: {
-                    role: raw?.role || 'assistant',
-                    content: textParts.join('\n'),
-                    tool_calls: toolCalls.map(tc => ({
-                        id: tc.id,
-                        type: 'function',
-                        function: { name: tc.name, arguments: tc.args }
-                    }))
-                }
-            }
-        ],
-        usage: raw?.usage || {}
-    };
-}
-export class AnthropicResponseInputNode {
-    id;
-    config;
-    type = NodeType.INPUT;
-    status = NodeStatus.IDLE;
-    name;
-    constructor(id, config) {
-        this.id = id;
-        this.config = config;
-        this.name = config.name || 'Anthropic Response Input Node';
-    }
-    async execute(context) {
-        const start = Date.now();
-        this.status = NodeStatus.RUNNING;
-        try {
-            const payload = context.data?.payload ?? context.data ?? context.request.payload;
-            const messageObj = (payload && typeof payload === 'object' && 'type' in payload && payload.type === 'message')
-                ? payload
-                : ((payload && typeof payload === 'object' && 'data' in payload) ? payload.data : payload);
-            const chatShape = toOpenAIChatResponse(messageObj);
-            const responseContext = {
-                toolContext: {
-                    originalRequest: context.request.context?.metadata?.originalRequest,
-                    requestId: context.request.id,
-                    entryEndpoint: context.request.context?.entryEndpoint || context.request.endpoint
-                }
-            };
-            this.status = NodeStatus.COMPLETED;
-            return {
-                success: true,
-                data: {
-                    responsePayload: chatShape,
-                    responseContext
-                },
-                metadata: {
-                    node: this.id,
-                    executionTime: Date.now() - start,
-                    startTime: start,
-                    endTime: Date.now()
-                }
-            };
-        }
-        catch (error) {
-            this.status = NodeStatus.FAILED;
-            return {
-                success: false,
-                error: {
-                    code: 'ANTHROPIC_RESPONSE_INPUT_ERROR',
-                    message: error instanceof Error ? error.message : 'Failed to normalize Anthropic response',
-                    cause: error instanceof Error ? error : undefined
-                },
-                metadata: {
-                    node: this.id,
-                    executionTime: Date.now() - start,
-                    startTime: start,
-                    endTime: Date.now()
-                }
-            };
-        }
-    }
-    validate() {
-        return { valid: true, errors: [], warnings: [] };
-    }
-    async cleanup() {
-        this.status = NodeStatus.IDLE;
-    }
-}

package/dist/conversion/conversion-v3/nodes/response/chat-to-responses-response-node.d.ts

@@ -1,15 +0,0 @@
-import { NodeType, NodeStatus, type NodeConfig, type NodeContext, type NodeResult, type PipelineNode, type ValidationResult } from '../../types/index.js';
-/**
- * 将 OpenAI Chat 响应形状转换为 OpenAI Responses 响应形状的节点（仅形状映射，不做工具解析）。
- */
-export declare class ChatToResponsesResponseNode implements PipelineNode {
-    readonly id: string;
-    readonly config: NodeConfig;
-    readonly type = NodeType.INPUT;
-    status: NodeStatus;
-    readonly name: string;
-    constructor(id: string, config: NodeConfig);
-    execute(context: NodeContext): Promise<NodeResult>;
-    validate(): ValidationResult;
-    cleanup(): Promise<void>;
-}

package/dist/conversion/conversion-v3/nodes/response/chat-to-responses-response-node.js

@@ -1,57 +0,0 @@
-import { NodeType, NodeStatus } from '../../types/index.js';
-/**
- * 将 OpenAI Chat 响应形状转换为 OpenAI Responses 响应形状的节点（仅形状映射，不做工具解析）。
- */
-export class ChatToResponsesResponseNode {
-    id;
-    config;
-    type = NodeType.INPUT;
-    status = NodeStatus.IDLE;
-    name;
-    constructor(id, config) {
-        this.id = id;
-        this.config = config;
-        this.name = config.name || 'Chat→Responses Response Node';
-    }
-    async execute(context) {
-        const start = Date.now();
-        this.status = NodeStatus.RUNNING;
-        try {
-            const payload = context.data?.responsePayload
-                || context.data
-                || context.request.payload;
-            const { buildResponsesPayloadFromChat } = await import('../../../responses/responses-openai-bridge.js');
-            const responses = buildResponsesPayloadFromChat(payload);
-            this.status = NodeStatus.COMPLETED;
-            return {
-                success: true,
-                data: { response: responses },
-                metadata: {
-                    node: this.id,
-                    executionTime: Date.now() - start,
-                    startTime: start,
-                    endTime: Date.now()
-                }
-            };
-        }
-        catch (error) {
-            this.status = NodeStatus.FAILED;
-            return {
-                success: false,
-                error: {
-                    code: 'CHAT_TO_RESPONSES_CONVERSION_ERROR',
-                    message: error instanceof Error ? error.message : 'Unknown error converting chat response to responses shape',
-                    cause: error instanceof Error ? error : undefined
-                },
-                metadata: {
-                    node: this.id,
-                    executionTime: Date.now() - start,
-                    startTime: start,
-                    endTime: Date.now()
-                }
-            };
-        }
-    }
-    validate() { return { valid: true, errors: [], warnings: [] }; }
-    async cleanup() { this.status = NodeStatus.IDLE; }
-}

package/dist/conversion/conversion-v3/nodes/response/index.d.ts

@@ -1,4 +0,0 @@
-export { OpenAIResponseInputNode } from './openai-response-input-node.js';
-export { AnthropicResponseInputNode } from './anthropic-response-input-node.js';
-export { ChatToResponsesResponseNode } from './chat-to-responses-response-node.js';
-export { ResponsesResponseInputNode } from './responses-response-input-node.js';

package/dist/conversion/conversion-v3/nodes/response/index.js

@@ -1,4 +0,0 @@
-export { OpenAIResponseInputNode } from './openai-response-input-node.js';
-export { AnthropicResponseInputNode } from './anthropic-response-input-node.js';
-export { ChatToResponsesResponseNode } from './chat-to-responses-response-node.js';
-export { ResponsesResponseInputNode } from './responses-response-input-node.js';

package/dist/conversion/conversion-v3/nodes/response/openai-response-input-node.d.ts

@@ -1,15 +0,0 @@
-import { NodeType, NodeStatus, type NodeConfig, type NodeContext, type NodeResult, type PipelineNode, type ValidationResult } from '../../types/index.js';
-/**
- * OpenAI provider response → canonical chat response输入节点
- */
-export declare class OpenAIResponseInputNode implements PipelineNode {
-    readonly id: string;
-    readonly config: NodeConfig;
-    readonly type = NodeType.INPUT;
-    status: NodeStatus;
-    readonly name: string;
-    constructor(id: string, config: NodeConfig);
-    execute(context: NodeContext): Promise<NodeResult>;
-    validate(): ValidationResult;
-    cleanup(): Promise<void>;
-}