@jsonstudio/llms 0.4.2 → 0.4.4

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

@@ -1,71 +0,0 @@
-/**
- * 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

@@ -1,293 +0,0 @@
-/**
- * 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

@@ -1,68 +0,0 @@
-/**
- * 输出节点决策器
- *
- * 根据 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

@@ -1,161 +0,0 @@
-/**
- * 输出节点决策器
- *
- * 根据 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

@@ -1,64 +0,0 @@
-/**
- * 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;
-}