@jsonstudio/llms 0.4.2

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

@@ -0,0 +1,71 @@
+/**
+ * OpenAI 输出节点
+ *
+ * 负责将处理后的数据转换为 OpenAI 格式
+ */
+import { BaseOutputNode } from './base-output-node.js';
+import type { NodeContext, NodeConfig, ProcessedRequest } from '../../types/index.js';
+/**
+ * OpenAI 输出节点实现
+ *
+ * 负责将处理后的数据转换为 OpenAI Chat 格式
+ */
+export declare class OpenAIOutputNode extends BaseOutputNode {
+    constructor(config: NodeConfig);
+    /**
+     * 转换为 OpenAI 输出格式
+     */
+    protected convertToOutputFormat(processedRequest: ProcessedRequest, context: NodeContext): Promise<Record<string, unknown>>;
+    /**
+     * 生成 OpenAI 输出元数据
+     */
+    protected generateOutputMetadata(processedRequest: ProcessedRequest, context: NodeContext): Promise<Record<string, unknown>>;
+    /**
+     * 转换为 Chat Completion 格式
+     */
+    private convertToChatCompletionFormat;
+    /**
+     * 转换为流式格式
+     */
+    private convertToStreamingFormat;
+    /**
+     * 转换工具调用为 OpenAI 格式
+     */
+    private convertToolCalls;
+    /**
+     * 转换流式工具调用为 OpenAI 格式
+     */
+    private convertStreamToolCalls;
+    /**
+     * 确定结束原因
+     */
+    private determineFinishReason;
+    /**
+     * 生成使用情况
+     */
+    private generateUsage;
+    /**
+     * 生成系统指纹
+     */
+    private generateSystemFingerprint;
+    /**
+     * 验证 Chat Completion 响应
+     */
+    private validateChatCompletionResponse;
+    /**
+     * 验证流式响应
+     */
+    private validateStreamingResponse;
+    /**
+     * 生成 Chat Completion ID
+     */
+    private generateChatCompletionId;
+    /**
+     * 计算简单的 token 数量
+     */
+    private calculateTokens;
+    /**
+     * 提取工具调用信息
+     */
+    private extractToolCallInfo;
+}

package/dist/conversion/conversion-v3/nodes/output/openai-output-node.js

@@ -0,0 +1,293 @@
+/**
+ * OpenAI 输出节点
+ *
+ * 负责将处理后的数据转换为 OpenAI 格式
+ */
+import { BaseOutputNode } from './base-output-node.js';
+import { NodeType, ConversionError } from '../../types/index.js';
+import { runHubOutboundConversion, shouldUseHub } from '../../../hub/node-support.js';
+/**
+ * OpenAI 输出节点实现
+ *
+ * 负责将处理后的数据转换为 OpenAI Chat 格式
+ */
+export class OpenAIOutputNode extends BaseOutputNode {
+    constructor(config) {
+        super('openai-output', NodeType.OUTPUT, 'OpenAI Output Node', config);
+    }
+    /**
+     * 转换为 OpenAI 输出格式
+     */
+    async convertToOutputFormat(processedRequest, context) {
+        const direction = this.getPipelineDirection(context);
+        if (direction !== 'response') {
+            if (shouldUseHub('openai-chat')) {
+                return runHubOutboundConversion({
+                    protocol: 'openai-chat',
+                    request: processedRequest,
+                    nodeContext: context
+                });
+            }
+            return this.buildChatRequestPayload(processedRequest);
+        }
+        // 检查是否为流式响应
+        const isStreaming = processedRequest.processingMetadata?.streaming?.enabled === true;
+        if (isStreaming) {
+            return this.convertToStreamingFormat(processedRequest, context);
+        }
+        else {
+            return this.convertToChatCompletionFormat(processedRequest, context);
+        }
+    }
+    /**
+     * 生成 OpenAI 输出元数据
+     */
+    async generateOutputMetadata(processedRequest, context) {
+        const direction = this.getPipelineDirection(context);
+        if (direction !== 'response') {
+            return {
+                outputFormat: 'openai-chat',
+                direction: 'request',
+                model: this.resolveRequestModel(processedRequest),
+                messageCount: processedRequest.messages.length,
+                toolCount: processedRequest.tools?.length || 0
+            };
+        }
+        const metadata = {
+            outputFormat: 'openai-chat',
+            model: processedRequest.model,
+            streaming: processedRequest.processingMetadata?.streaming?.enabled === true,
+            messageCount: processedRequest.messages.length,
+            toolCount: processedRequest.tools?.length || 0,
+            processingTime: Date.now() - processedRequest.processed.timestamp
+        };
+        // 添加流式特定元数据
+        if (processedRequest.processingMetadata?.streaming?.enabled) {
+            metadata.streamingInfo = {
+                format: 'sse',
+                chunkSize: processedRequest.processingMetadata.streaming.chunkCount || 0,
+                maxTokens: processedRequest.parameters.max_tokens
+            };
+        }
+        // 添加工具调用元数据
+        const toolCallInfo = this.extractToolCallInfo(processedRequest.messages);
+        if (toolCallInfo.hasToolCalls) {
+            metadata.toolCallInfo = toolCallInfo;
+        }
+        return metadata;
+    }
+    /**
+     * 转换为 Chat Completion 格式
+     */
+    async convertToChatCompletionFormat(processedRequest, context) {
+        const assistantMessages = processedRequest.messages.filter(m => m.role === 'assistant');
+        if (assistantMessages.length === 0) {
+            throw new ConversionError('No assistant messages found for OpenAI Chat Completion response', this.id, 'message_validation');
+        }
+        // 使用最后一个助手消息作为响应
+        const lastAssistantMessage = assistantMessages[assistantMessages.length - 1];
+        const response = {
+            id: this.generateChatCompletionId(),
+            object: 'chat.completion',
+            created: Math.floor(Date.now() / 1000),
+            model: processedRequest.model,
+            choices: [
+                {
+                    index: 0,
+                    message: {
+                        role: 'assistant',
+                        content: lastAssistantMessage.content,
+                        tool_calls: this.convertToolCalls(lastAssistantMessage.tool_calls)
+                    },
+                    finish_reason: this.determineFinishReason(lastAssistantMessage)
+                }
+            ],
+            usage: this.generateUsage(processedRequest),
+            system_fingerprint: this.generateSystemFingerprint()
+        };
+        // 验证响应结构
+        this.validateChatCompletionResponse(response);
+        return response;
+    }
+    /**
+     * 转换为流式格式
+     */
+    async convertToStreamingFormat(processedRequest, context) {
+        const assistantMessages = processedRequest.messages.filter(m => m.role === 'assistant');
+        if (assistantMessages.length === 0) {
+            throw new ConversionError('No assistant messages found for OpenAI streaming response', this.id, 'message_validation');
+        }
+        const lastAssistantMessage = assistantMessages[assistantMessages.length - 1];
+        // 创建流式响应块
+        const response = {
+            id: this.generateChatCompletionId(),
+            object: 'chat.completion.chunk',
+            created: Math.floor(Date.now() / 1000),
+            model: processedRequest.model,
+            choices: [
+                {
+                    index: 0,
+                    delta: {
+                        role: 'assistant',
+                        content: lastAssistantMessage.content || undefined,
+                        tool_calls: this.convertStreamToolCalls(lastAssistantMessage.tool_calls)
+                    }
+                }
+            ]
+        };
+        // 验证流式响应结构
+        this.validateStreamingResponse(response);
+        return response;
+    }
+    /**
+     * 转换工具调用为 OpenAI 格式
+     */
+    convertToolCalls(toolCalls) {
+        if (!toolCalls || toolCalls.length === 0) {
+            return undefined;
+        }
+        return toolCalls.map((toolCall, index) => ({
+            index,
+            id: toolCall.id,
+            type: 'function',
+            function: {
+                name: toolCall.function.name,
+                arguments: toolCall.function.arguments
+            }
+        }));
+    }
+    /**
+     * 转换流式工具调用为 OpenAI 格式
+     */
+    convertStreamToolCalls(toolCalls) {
+        if (!toolCalls || toolCalls.length === 0) {
+            return undefined;
+        }
+        return toolCalls.map((toolCall, index) => ({
+            index,
+            id: toolCall.id,
+            type: 'function',
+            function: {
+                name: toolCall.function.name,
+                arguments: toolCall.function.arguments
+            }
+        }));
+    }
+    /**
+     * 确定结束原因
+     */
+    determineFinishReason(message) {
+        // 如果有工具调用，设置为 tool_calls
+        if (message.tool_calls && message.tool_calls.length > 0) {
+            return 'tool_calls';
+        }
+        // 如果内容为空，可能是停止信号
+        if (!message.content) {
+            return 'stop';
+        }
+        // 检查是否达到长度限制
+        if (message.content.length > 1000) { // 简单的长度检查
+            return 'length';
+        }
+        return 'stop';
+    }
+    /**
+     * 生成使用情况
+     */
+    generateUsage(processedRequest) {
+        // 简单的 token 计算逻辑（实际实现应该使用更精确的计算）
+        const promptTokens = this.calculateTokens(processedRequest.messages.slice(0, -1));
+        const completionTokens = this.calculateTokens(processedRequest.messages.slice(-1));
+        return {
+            prompt_tokens: Math.max(1, promptTokens),
+            completion_tokens: Math.max(1, completionTokens),
+            total_tokens: promptTokens + completionTokens
+        };
+    }
+    /**
+     * 生成系统指纹
+     */
+    generateSystemFingerprint() {
+        // 简单的系统指纹生成
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).substr(2, 5);
+        return `fp_${timestamp}_${random}`;
+    }
+    /**
+     * 验证 Chat Completion 响应
+     */
+    validateChatCompletionResponse(response) {
+        if (!response.id) {
+            throw new ConversionError('OpenAI response must have id', this.id);
+        }
+        if (!response.model) {
+            throw new ConversionError('OpenAI response must have model', this.id);
+        }
+        if (!Array.isArray(response.choices) || response.choices.length === 0) {
+            throw new ConversionError('OpenAI response must have choices array', this.id);
+        }
+        const choice = response.choices[0];
+        if (!choice.message) {
+            throw new ConversionError('OpenAI choice must have message', this.id);
+        }
+        if (choice.message.role !== 'assistant') {
+            throw new ConversionError('OpenAI message role must be assistant', this.id);
+        }
+    }
+    /**
+     * 验证流式响应
+     */
+    validateStreamingResponse(response) {
+        if (!response.id) {
+            throw new ConversionError('OpenAI streaming response must have id', this.id);
+        }
+        if (!response.model) {
+            throw new ConversionError('OpenAI streaming response must have model', this.id);
+        }
+        if (!Array.isArray(response.choices) || response.choices.length === 0) {
+            throw new ConversionError('OpenAI streaming response must have choices array', this.id);
+        }
+        const choice = response.choices[0];
+        if (!choice.delta) {
+            throw new ConversionError('OpenAI streaming choice must have delta', this.id);
+        }
+    }
+    /**
+     * 生成 Chat Completion ID
+     */
+    generateChatCompletionId() {
+        const timestamp = Math.floor(Date.now() / 1000);
+        const random = Math.random().toString(36).substr(2, 9);
+        return `chatcmpl-${timestamp}-${random}`;
+    }
+    /**
+     * 计算简单的 token 数量
+     */
+    calculateTokens(messages) {
+        // 简单的 token 估算（大约 4 字符 = 1 token）
+        const totalChars = messages.reduce((sum, msg) => {
+            const contentLength = (msg.content || '').length;
+            const toolCallLength = (msg.tool_calls || []).reduce((tcSum, tc) => {
+                return tcSum + tc.function.name.length + tc.function.arguments.length;
+            }, 0);
+            return sum + contentLength + toolCallLength;
+        }, 0);
+        return Math.ceil(totalChars / 4);
+    }
+    /**
+     * 提取工具调用信息
+     */
+    extractToolCallInfo(messages) {
+        const assistantMessages = messages.filter(m => m.role === 'assistant' && m.tool_calls);
+        if (assistantMessages.length === 0) {
+            return { hasToolCalls: false };
+        }
+        const allToolCalls = assistantMessages.flatMap(m => m.tool_calls || []);
+        return {
+            hasToolCalls: true,
+            toolCallCount: allToolCalls.length,
+            uniqueTools: new Set(allToolCalls.map(tc => tc.function.name)).size,
+            toolNames: allToolCalls.map(tc => tc.function.name)
+        };
+    }
+}

package/dist/conversion/conversion-v3/nodes/output/output-decision.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 输出节点决策器
+ *
+ * 根据 provider 类型决定输出节点类型，无需配置
+ */
+import type { ConversionRequest } from '../../types/index.js';
+/**
+ * Provider 类型定义
+ */
+export type ProviderType = 'openai' | 'anthropic' | 'responses' | 'gemini' | 'lmstudio';
+/**
+ * 输出节点决策器
+ */
+export declare class OutputNodeDecision {
+    /**
+     * 根据 provider 类型决定输出节点类型
+     */
+    static decideOutputNodeType(provider: ProviderType): string;
+    /**
+     * 根据 provider 类型获取输出格式
+     */
+    static getOutputFormat(provider: ProviderType): string;
+    /**
+     * 从请求中提取 provider 类型
+     */
+    static extractProviderType(request: ConversionRequest): ProviderType;
+    /**
+     * 从端点推断 provider 类型
+     */
+    static inferProviderFromEndpoint(endpoint: string): ProviderType | null;
+    /**
+     * 检查是否为有效的 provider 类型
+     */
+    static isValidProvider(provider: string): provider is ProviderType;
+    /**
+     * 检查是否支持该 provider
+     */
+    static isProviderSupported(provider: ProviderType): boolean;
+    /**
+     * 获取所有支持的 provider 类型
+     */
+    static getSupportedProviders(): ProviderType[];
+    /**
+     * 获取所有支持的输出节点类型
+     */
+    static getSupportedOutputNodeTypes(): string[];
+    /**
+     * 注册新的 provider 映射
+     */
+    static registerProviderMapping(provider: ProviderType, nodeType: string, format: string): void;
+    /**
+     * 批量注册 provider 映射
+     */
+    static registerProviderMappings(mappings: Array<{
+        provider: ProviderType;
+        nodeType: string;
+        format: string;
+    }>): void;
+    /**
+     * 自动决定输出节点和格式
+     */
+    static autoDecideOutput(request: ConversionRequest): {
+        nodeType: string;
+        format: string;
+        provider: ProviderType;
+    };
+    private static normalizeProvider;
+}

package/dist/conversion/conversion-v3/nodes/output/output-decision.js

@@ -0,0 +1,161 @@
+/**
+ * 输出节点决策器
+ *
+ * 根据 provider 类型决定输出节点类型，无需配置
+ */
+/**
+ * Provider 到输出节点的映射
+ */
+const PROVIDER_TO_OUTPUT_NODE = new Map([
+    ['openai', 'openai-output'],
+    ['anthropic', 'anthropic-output'],
+    ['responses', 'responses-output'],
+    ['gemini', 'anthropic-output'],
+    ['lmstudio', 'openai-output']
+]);
+/**
+ * Provider 到输出格式的映射
+ */
+const PROVIDER_TO_OUTPUT_FORMAT = new Map([
+    ['openai', 'openai-chat'],
+    ['anthropic', 'anthropic-messages'],
+    ['responses', 'openai-responses'],
+    ['gemini', 'anthropic-messages'],
+    ['lmstudio', 'openai-chat']
+]);
+/**
+ * 输出节点决策器
+ */
+export class OutputNodeDecision {
+    /**
+     * 根据 provider 类型决定输出节点类型
+     */
+    static decideOutputNodeType(provider) {
+        const nodeType = PROVIDER_TO_OUTPUT_NODE.get(provider);
+        if (!nodeType) {
+            throw new Error(`Unsupported provider type: ${provider}. No output node mapping found.`);
+        }
+        return nodeType;
+    }
+    /**
+     * 根据 provider 类型获取输出格式
+     */
+    static getOutputFormat(provider) {
+        const format = PROVIDER_TO_OUTPUT_FORMAT.get(provider);
+        if (!format) {
+            throw new Error(`Unsupported provider type: ${provider}. No format mapping found.`);
+        }
+        return format;
+    }
+    /**
+     * 从请求中提取 provider 类型
+     */
+    static extractProviderType(request) {
+        // 1. 从请求选项中获取
+        const fromOptions = this.normalizeProvider(request.options?.provider);
+        if (fromOptions)
+            return fromOptions;
+        // 2. 从请求上下文中获取
+        const contextProvider = this.normalizeProvider(request.context?.provider);
+        if (contextProvider)
+            return contextProvider;
+        const metadataProvider = this.normalizeProvider((request.context?.metadata?.providerType ??
+            request.context?.metadata?.provider));
+        if (metadataProvider)
+            return metadataProvider;
+        // 3. 从端点推断
+        const inferredProvider = this.inferProviderFromEndpoint(request.endpoint);
+        if (inferredProvider) {
+            return inferredProvider;
+        }
+        // 4. 默认使用 openai
+        return 'openai';
+    }
+    /**
+     * 从端点推断 provider 类型
+     */
+    static inferProviderFromEndpoint(endpoint) {
+        const normalizedEndpoint = endpoint.toLowerCase();
+        // Anthropic 端点特征
+        if (normalizedEndpoint.includes('anthropic') || normalizedEndpoint.includes('claude') ||
+            normalizedEndpoint.includes('/v1/messages') || normalizedEndpoint.includes('/messages')) {
+            return 'anthropic';
+        }
+        // Responses 端点特征
+        if (normalizedEndpoint.includes('responses') || normalizedEndpoint.includes('/v1/responses') ||
+            normalizedEndpoint.includes('/responses')) {
+            return 'responses';
+        }
+        if (normalizedEndpoint.includes('gemini')) {
+            return 'gemini';
+        }
+        // OpenAI 端点特征（默认）
+        if (normalizedEndpoint.includes('openai') || normalizedEndpoint.includes('chat') ||
+            normalizedEndpoint.includes('/v1/chat') || normalizedEndpoint.includes('/v1/completions')) {
+            return 'openai';
+        }
+        return null;
+    }
+    /**
+     * 检查是否为有效的 provider 类型
+     */
+    static isValidProvider(provider) {
+        return Boolean(this.normalizeProvider(provider));
+    }
+    /**
+     * 检查是否支持该 provider
+     */
+    static isProviderSupported(provider) {
+        return PROVIDER_TO_OUTPUT_NODE.has(provider);
+    }
+    /**
+     * 获取所有支持的 provider 类型
+     */
+    static getSupportedProviders() {
+        return Array.from(PROVIDER_TO_OUTPUT_NODE.keys());
+    }
+    /**
+     * 获取所有支持的输出节点类型
+     */
+    static getSupportedOutputNodeTypes() {
+        return Array.from(PROVIDER_TO_OUTPUT_NODE.values());
+    }
+    /**
+     * 注册新的 provider 映射
+     */
+    static registerProviderMapping(provider, nodeType, format) {
+        PROVIDER_TO_OUTPUT_NODE.set(provider, nodeType);
+        PROVIDER_TO_OUTPUT_FORMAT.set(provider, format);
+    }
+    /**
+     * 批量注册 provider 映射
+     */
+    static registerProviderMappings(mappings) {
+        for (const mapping of mappings) {
+            this.registerProviderMapping(mapping.provider, mapping.nodeType, mapping.format);
+        }
+    }
+    /**
+     * 自动决定输出节点和格式
+     */
+    static autoDecideOutput(request) {
+        const provider = this.extractProviderType(request);
+        const nodeType = this.decideOutputNodeType(provider);
+        const format = this.getOutputFormat(provider);
+        return { nodeType, format, provider };
+    }
+    static normalizeProvider(provider) {
+        if (typeof provider !== 'string')
+            return null;
+        const normalized = provider.trim().toLowerCase();
+        if (normalized === 'openai')
+            return 'openai';
+        if (normalized === 'anthropic')
+            return 'anthropic';
+        if (normalized === 'responses')
+            return 'responses';
+        if (normalized === 'gemini')
+            return 'gemini';
+        return null;
+    }
+}

package/dist/conversion/conversion-v3/nodes/output/responses-output-node.d.ts

@@ -0,0 +1,64 @@
+/**
+ * OpenAI Responses 输出节点
+ *
+ * 负责将处理后的数据转换为 OpenAI Responses 格式
+ */
+import { BaseOutputNode } from './base-output-node.js';
+import type { NodeContext, NodeConfig, ProcessedRequest } from '../../types/index.js';
+/**
+ * OpenAI Responses 输出节点实现
+ *
+ * 负责将处理后的数据转换为 OpenAI Responses 格式
+ */
+export declare class ResponsesOutputNode extends BaseOutputNode {
+    constructor(config: NodeConfig);
+    /**
+     * 转换为 Responses 输出格式
+     */
+    protected convertToOutputFormat(processedRequest: ProcessedRequest, context: NodeContext): Promise<Record<string, unknown>>;
+    /**
+     * 生成 Responses 输出元数据
+     */
+    protected generateOutputMetadata(processedRequest: ProcessedRequest, context: NodeContext): Promise<Record<string, unknown>>;
+    /**
+     * 转换为 Responses 格式
+     */
+    private convertToResponsesFormat;
+    /**
+     * 转换消息内容为 Responses 格式
+     */
+    private convertMessageContentToResponses;
+    /**
+     * 创建工具调用描述
+     */
+    private createToolCallDescription;
+    /**
+     * 确定 Responses 结束原因
+     */
+    private determineResponsesFinishReason;
+    /**
+     * 生成 Responses 使用情况
+     */
+    private generateResponsesUsage;
+    private buildChatCompletionFromProcessed;
+    /**
+     * 生成 Responses 系统指纹
+     */
+    private generateResponsesSystemFingerprint;
+    /**
+     * 生成 Responses ID
+     */
+    private generateResponsesId;
+    /**
+     * 验证 Responses 响应
+     */
+    private validateResponsesResponse;
+    /**
+     * 计算 Responses token 数量
+     */
+    private calculateResponsesTokens;
+    /**
+     * 提取工具调用信息
+     */
+    private extractToolCallInfo;
+}