@jsonstudio/llms 0.4.2

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

@@ -0,0 +1,430 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,129 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,15 @@
+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>;
+}