@jsonstudio/llms 0.4.2 → 0.4.4

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

@@ -1,323 +0,0 @@
-/**
- * OpenAI Responses 输出节点
- *
- * 负责将处理后的数据转换为 OpenAI Responses 格式
- */
-import { BaseOutputNode } from './base-output-node.js';
-import { NodeType, ConversionError } from '../../types/index.js';
-import { buildResponsesRequestFromChat, buildResponsesPayloadFromChat } from '../../../responses/responses-openai-bridge.js';
-import { recordResponsesResponse } from '../../../shared/responses-conversation-store.js';
-import { runHubOutboundConversion, shouldUseHub } from '../../../hub/node-support.js';
-/**
- * OpenAI Responses 输出节点实现
- *
- * 负责将处理后的数据转换为 OpenAI Responses 格式
- */
-export class ResponsesOutputNode extends BaseOutputNode {
-    constructor(config) {
-        super('responses-output', NodeType.OUTPUT, 'OpenAI Responses Output Node', config);
-    }
-    /**
-     * 转换为 Responses 输出格式
-     */
-    async convertToOutputFormat(processedRequest, context) {
-        const direction = this.getPipelineDirection(context);
-        if (direction !== 'response') {
-            if (shouldUseHub('openai-responses')) {
-                return runHubOutboundConversion({
-                    protocol: 'openai-responses',
-                    request: processedRequest,
-                    nodeContext: context
-                });
-            }
-            const chatPayload = this.buildChatRequestPayload(processedRequest);
-            const responsesReq = buildResponsesRequestFromChat(chatPayload);
-            return responsesReq.request;
-        }
-        // 流式与非流式都生成完整的 Responses JSON，由下游 SSE 节点负责拆分。
-        return this.convertToResponsesFormat(processedRequest, context);
-    }
-    /**
-     * 生成 Responses 输出元数据
-     */
-    async generateOutputMetadata(processedRequest, context) {
-        const direction = this.getPipelineDirection(context);
-        if (direction !== 'response') {
-            return {
-                outputFormat: 'openai-responses',
-                direction: 'request',
-                model: this.resolveRequestModel(processedRequest),
-                messageCount: processedRequest.messages.length,
-                toolCount: processedRequest.tools?.length || 0
-            };
-        }
-        const metadata = {
-            outputFormat: 'openai-responses',
-            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;
-        }
-        // 添加 Responses 特定元数据
-        metadata.responsesInfo = {
-            apiVersion: '2024-10-01',
-            supportsStreaming: true,
-            supportedModalities: ['text', 'image', 'audio'],
-            maxTokens: processedRequest.parameters.max_tokens,
-            temperature: processedRequest.parameters.temperature,
-            modal: processedRequest.parameters.modal
-        };
-        return metadata;
-    }
-    /**
-     * 转换为 Responses 格式
-     */
-    async convertToResponsesFormat(processedRequest, context) {
-        const rawResponses = context.data?.rawResponsesPayload;
-        let bridged;
-        if (rawResponses && typeof rawResponses === 'object' && rawResponses.object === 'response') {
-            bridged = rawResponses;
-        }
-        else {
-            const chatCompletion = this.buildChatCompletionFromProcessed(processedRequest);
-            const responsesContext = {
-                metadata: processedRequest.metadata?.capturedContext
-            };
-            bridged = buildResponsesPayloadFromChat(chatCompletion, responsesContext);
-        }
-        if (!bridged || typeof bridged !== 'object') {
-            throw new ConversionError('Failed to map Chat payload to Responses format', this.id, 'response_conversion');
-        }
-        try {
-            recordResponsesResponse({
-                requestId: context.request.id,
-                response: bridged
-            });
-        }
-        catch {
-            /* recording failures should not block response */
-        }
-        return bridged;
-    }
-    /**
-     * 转换消息内容为 Responses 格式
-     */
-    convertMessageContentToResponses(message) {
-        const content = [];
-        // 处理文本内容
-        if (message.content) {
-            content.push({
-                type: 'output_text',
-                text: message.content
-            });
-        }
-        // 处理工具调用（转换为文本描述）
-        if (message.tool_calls && message.tool_calls.length > 0) {
-            for (const toolCall of message.tool_calls) {
-                try {
-                    const toolDescription = this.createToolCallDescription(toolCall);
-                    content.push({
-                        type: 'output_text',
-                        text: toolDescription
-                    });
-                }
-                catch (error) {
-                    throw new ConversionError(`Failed to convert tool call for ${toolCall.function.name}: ${error instanceof Error ? error.message : 'Unknown error'}`, this.id, 'tool_conversion', error instanceof Error ? error : undefined);
-                }
-            }
-        }
-        // 如果没有内容，创建空的文本内容
-        if (content.length === 0) {
-            content.push({
-                type: 'output_text',
-                text: ''
-            });
-        }
-        return content;
-    }
-    /**
-     * 创建工具调用描述
-     */
-    createToolCallDescription(toolCall) {
-        let description = `Tool called: ${toolCall.function.name}`;
-        if (toolCall.function.arguments) {
-            try {
-                const args = JSON.parse(toolCall.function.arguments);
-                description += ` with arguments: ${JSON.stringify(args, null, 2)}`;
-            }
-            catch {
-                description += ` with arguments: ${toolCall.function.arguments}`;
-            }
-        }
-        return description;
-    }
-    /**
-     * 确定 Responses 结束原因
-     */
-    determineResponsesFinishReason(message) {
-        // 如果有工具调用，设置为 function_call
-        if (message.tool_calls && message.tool_calls.length > 0) {
-            return 'function_call';
-        }
-        // 如果内容为空，可能是停止信号
-        if (!message.content) {
-            return 'stop';
-        }
-        // 检查是否达到长度限制
-        if (message.content.length > 1500) { // Responses 可能有不同的长度限制
-            return 'length';
-        }
-        return 'stop';
-    }
-    /**
-     * 生成 Responses 使用情况
-     */
-    generateResponsesUsage(processedRequest) {
-        // 简单的 token 计算逻辑（Responses 可能有不同的计数方式）
-        const promptTokens = this.calculateResponsesTokens(processedRequest.messages.slice(0, -1));
-        const completionTokens = this.calculateResponsesTokens(processedRequest.messages.slice(-1));
-        const usage = {
-            prompt_tokens: Math.max(1, promptTokens),
-            completion_tokens: Math.max(1, completionTokens),
-            total_tokens: promptTokens + completionTokens
-        };
-        // 添加详细信息（如果支持）
-        if (processedRequest.parameters.modal === 'audio') {
-            usage.prompt_tokens_details = {
-                audio_tokens: Math.floor(promptTokens * 0.3) // 简单估算
-            };
-        }
-        return usage;
-    }
-    buildChatCompletionFromProcessed(processedRequest) {
-        const assistantMessages = processedRequest.messages.filter(m => m.role === 'assistant');
-        if (!assistantMessages.length) {
-            throw new ConversionError('No assistant messages found for Responses response', this.id, 'message_validation');
-        }
-        const lastAssistantMessage = assistantMessages[assistantMessages.length - 1];
-        const finishReason = this.determineResponsesFinishReason(lastAssistantMessage);
-        const chatMessage = {
-            role: 'assistant',
-            content: lastAssistantMessage.content ?? ''
-        };
-        if (lastAssistantMessage.tool_calls && lastAssistantMessage.tool_calls.length > 0) {
-            chatMessage.tool_calls = lastAssistantMessage.tool_calls.map(tc => ({
-                id: tc.id,
-                type: tc.type || 'function',
-                function: {
-                    name: tc.function.name,
-                    arguments: tc.function.arguments
-                }
-            }));
-        }
-        const finishReasonForChat = finishReason === 'function_call'
-            ? 'tool_calls'
-            : finishReason;
-        return {
-            id: this.generateResponsesId().replace('resp', 'chatcmpl'),
-            object: 'chat.completion',
-            created: Math.floor(Date.now() / 1000),
-            model: processedRequest.model,
-            choices: [
-                {
-                    index: 0,
-                    finish_reason: finishReasonForChat,
-                    message: chatMessage
-                }
-            ],
-            usage: this.generateResponsesUsage(processedRequest)
-        };
-    }
-    /**
-     * 生成 Responses 系统指纹
-     */
-    generateResponsesSystemFingerprint() {
-        // 简单的系统指纹生成（Responses 格式）
-        const timestamp = Date.now().toString(36);
-        const random = Math.random().toString(36).substr(2, 6);
-        return `resp_fp_${timestamp}_${random}`;
-    }
-    /**
-     * 生成 Responses ID
-     */
-    generateResponsesId() {
-        const timestamp = Math.floor(Date.now() / 1000);
-        const random = Math.random().toString(36).substr(2, 8);
-        return `resp_${timestamp}_${random}`;
-    }
-    /**
-     * 验证 Responses 响应
-     */
-    validateResponsesResponse(response) {
-        if (!response.id) {
-            throw new ConversionError('OpenAI Responses response must have id', this.id);
-        }
-        if (response.object !== 'response') {
-            throw new ConversionError('OpenAI Responses object must be response', this.id);
-        }
-        if (!response.model) {
-            throw new ConversionError('OpenAI Responses response must have model', this.id);
-        }
-        if (!Array.isArray(response.choices) || response.choices.length === 0) {
-            throw new ConversionError('OpenAI Responses response must have choices array', this.id);
-        }
-        const choice = response.choices[0];
-        if (!choice.message) {
-            throw new ConversionError('OpenAI Responses choice must have message', this.id);
-        }
-        if (choice.message.role !== 'assistant') {
-            throw new ConversionError('OpenAI Responses message role must be assistant', this.id);
-        }
-        if (!Array.isArray(choice.message.content)) {
-            throw new ConversionError('OpenAI Responses message content must be array', this.id);
-        }
-    }
-    /**
-     * 计算 Responses token 数量
-     */
-    calculateResponsesTokens(messages) {
-        // 简单的 token 估算（Responses 可能有不同的计数方式）
-        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);
-        // Responses 可能使用不同的 token 计算方式
-        return Math.ceil(totalChars / 3.8); // 简单的调整
-    }
-    /**
-     * 提取工具调用信息
-     */
-    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),
-            // Responses 特定信息
-            convertedToText: true, // Responses 转换工具调用为文本
-            toolDescriptions: allToolCalls.map(tc => this.createToolCallDescription(tc))
-        };
-    }
-}

package/dist/conversion/conversion-v3/nodes/process/base-process-node.d.ts

@@ -1,72 +0,0 @@
-/**
- * 处理节点基类
- *
- * 提供处理节点的通用功能
- */
-import { PipelineNode, NodeContext, NodeResult, NodeConfig, NodeStatus, ValidationResult, NodeType, ProcessedRequest } from '../../types/index.js';
-import type { StandardizedRequest } from '../../types/index.js';
-/**
- * 处理节点抽象基类
- *
- * 提供核心处理逻辑和流程管理
- */
-export declare abstract class BaseProcessNode implements PipelineNode {
-    readonly id: string;
-    readonly type: NodeType.PROCESS;
-    readonly name: string;
-    config: NodeConfig;
-    status: NodeStatus;
-    constructor(id: string, type: NodeType.PROCESS, name: string, config: NodeConfig);
-    /**
-     * 主执行方法 - 实现处理节点逻辑
-     */
-    execute(context: NodeContext): Promise<NodeResult>;
-    /**
-     * 验证输入数据
-     */
-    validate(data: Record<string, unknown>): ValidationResult;
-    /**
-     * 处理 Passthrough 场景
-     */
-    private handlePassthrough;
-    /**
-     * 提取标准化请求
-     */
-    private extractStandardizedRequest;
-    /**
-     * 抽象方法：处理请求核心逻辑
-     */
-    protected abstract processRequest(standardizedRequest: StandardizedRequest, context: NodeContext): Promise<ProcessedRequest>;
-    /**
-     * 抽象方法：后置处理请求
-     */
-    protected abstract postprocessRequest(processedRequest: ProcessedRequest, context: NodeContext): Promise<ProcessedRequest>;
-    /**
-     * 创建处理摘要
-     */
-    private createProcessingSummary;
-    /**
-     * 获取失败阶段
-     */
-    private getFailureStage;
-    /**
-     * 创建错误上下文
-     */
-    private createErrorContext;
-    /**
-     * 工具方法：验证工具调用
-     */
-    protected validateToolCalls(toolCalls: unknown[]): boolean;
-    /**
-     * 工具方法：验证工具结果
-     */
-    protected validateToolResults(toolResults: unknown[]): boolean;
-    /**
-     * 工具方法：提取工具调用信息
-     */
-    protected extractToolCallsInfo(messages: any[]): Record<string, unknown>;
-    /**
-     * 工具方法：提取流式信息
-     */
-    protected extractStreamingInfo(request: StandardizedRequest): Record<string, unknown>;
-}

package/dist/conversion/conversion-v3/nodes/process/base-process-node.js

@@ -1,246 +0,0 @@
-/**
- * 处理节点基类
- *
- * 提供处理节点的通用功能
- */
-import { NodeStatus, ConversionError } from '../../types/index.js';
-/**
- * 处理节点抽象基类
- *
- * 提供核心处理逻辑和流程管理
- */
-export class BaseProcessNode {
-    id;
-    type;
-    name;
-    config;
-    status = NodeStatus.IDLE;
-    constructor(id, type, name, config) {
-        this.id = id;
-        this.type = type;
-        this.name = name;
-        this.config = config;
-    }
-    /**
-     * 主执行方法 - 实现处理节点逻辑
-     */
-    async execute(context) {
-        const startTime = Date.now();
-        try {
-            this.status = NodeStatus.RUNNING;
-            // 1. 验证输入数据
-            const validation = this.validate(context.data);
-            if (!validation.valid) {
-                throw new ConversionError(`Process node validation failed: ${validation.errors.map(e => e.message).join(', ')}`, this.id, 'validation', new Error(validation.errors[0]?.message));
-            }
-            // 2. Passthrough 检查
-            if (context.pipeline.isPassthrough) {
-                return this.handlePassthrough(context, startTime);
-            }
-            // 3. 提取标准化请求
-            const standardizedRequest = this.extractStandardizedRequest(context.data);
-            // 4. 执行核心处理逻辑
-            const processedRequest = await this.processRequest(standardizedRequest, context);
-            // 5. 后置处理和验证
-            const finalResult = await this.postprocessRequest(processedRequest, context);
-            this.status = NodeStatus.COMPLETED;
-            return {
-                success: true,
-                data: {
-                    processedRequest: finalResult,
-                    processingSummary: this.createProcessingSummary(standardizedRequest, finalResult)
-                },
-                metadata: {
-                    node: this.id,
-                    executionTime: Date.now() - startTime,
-                    startTime,
-                    endTime: Date.now(),
-                    dataProcessed: {
-                        messages: finalResult.messages.length,
-                        tools: finalResult.tools?.length || 0
-                    }
-                }
-            };
-        }
-        catch (error) {
-            this.status = NodeStatus.FAILED;
-            return {
-                success: false,
-                error: {
-                    code: 'PROCESS_NODE_ERROR',
-                    message: error instanceof Error ? error.message : 'Unknown error during processing',
-                    details: {
-                        node: this.id,
-                        stage: this.getFailureStage(error),
-                        context: this.createErrorContext(context)
-                    },
-                    cause: error instanceof Error ? error : undefined
-                },
-                metadata: {
-                    node: this.id,
-                    executionTime: Date.now() - startTime,
-                    startTime,
-                    endTime: Date.now()
-                }
-            };
-        }
-    }
-    /**
-     * 验证输入数据
-     */
-    validate(data) {
-        const errors = [];
-        // 验证是否包含标准化请求
-        if (!data.standardizedRequest) {
-            errors.push({
-                field: 'standardizedRequest',
-                message: 'Standardized request is required for processing',
-                code: 'MISSING_STANDARDIZED_REQUEST',
-                value: undefined
-            });
-        }
-        return {
-            valid: errors.length === 0,
-            errors,
-            warnings: []
-        };
-    }
-    /**
-     * 处理 Passthrough 场景
-     */
-    handlePassthrough(context, startTime) {
-        const originalData = (context.data && typeof context.data === 'object')
-            ? { ...context.data }
-            : {};
-        const passthroughResult = {
-            ...originalData,
-            passthrough: true
-        };
-        if (!passthroughResult.processedRequest && passthroughResult.standardizedRequest) {
-            passthroughResult.processedRequest = passthroughResult.standardizedRequest;
-        }
-        return {
-            success: true,
-            data: passthroughResult,
-            metadata: {
-                node: this.id,
-                executionTime: Date.now() - startTime,
-                startTime,
-                endTime: Date.now(),
-                dataProcessed: {
-                    messages: 0,
-                    tools: 0
-                }
-            }
-        };
-    }
-    /**
-     * 提取标准化请求
-     */
-    extractStandardizedRequest(data) {
-        if (!data.standardizedRequest || typeof data.standardizedRequest !== 'object') {
-            throw new ConversionError('Valid standardized request is required', this.id);
-        }
-        const standardizedRequest = data.standardizedRequest;
-        // 验证标准化请求的基本结构
-        if (!standardizedRequest.model) {
-            throw new ConversionError('Standardized request must have a model', this.id);
-        }
-        if (!Array.isArray(standardizedRequest.messages)) {
-            throw new ConversionError('Standardized request must have messages array', this.id);
-        }
-        return standardizedRequest;
-    }
-    /**
-     * 创建处理摘要
-     */
-    createProcessingSummary(standardizedRequest, processedRequest) {
-        return {
-            inputMessages: standardizedRequest.messages.length,
-            outputMessages: processedRequest.messages.length,
-            inputTools: standardizedRequest.tools?.length || 0,
-            outputTools: processedRequest.tools?.length || 0,
-            appliedRules: processedRequest.processed.appliedRules,
-            status: processedRequest.processed.status,
-            processingTime: processedRequest.processed.timestamp
-        };
-    }
-    /**
-     * 获取失败阶段
-     */
-    getFailureStage(error) {
-        if (error instanceof ConversionError) {
-            if (error.message.includes('validation'))
-                return 'validation';
-            if (error.message.includes('processing'))
-                return 'processing';
-            if (error.message.includes('standardized'))
-                return 'input_extraction';
-        }
-        return 'unknown';
-    }
-    /**
-     * 创建错误上下文
-     */
-    createErrorContext(context) {
-        return {
-            nodeId: this.id,
-            pipelineStep: context.pipeline.currentNode,
-            previousNodes: context.pipeline.previousResults.map(r => r.metadata.node),
-            isPassthrough: context.pipeline.isPassthrough,
-            pipelineStartTime: context.pipeline.startTime
-        };
-    }
-    /**
-     * 工具方法：验证工具调用
-     */
-    validateToolCalls(toolCalls) {
-        if (!Array.isArray(toolCalls))
-            return false;
-        return toolCalls.every(tc => {
-            if (!tc || typeof tc !== 'object')
-                return false;
-            const tcObj = tc;
-            return (typeof tcObj.id === 'string'
-                && tcObj.type === 'function'
-                && !!tcObj.function
-                && typeof tcObj.function === 'object');
-        });
-    }
-    /**
-     * 工具方法：验证工具结果
-     */
-    validateToolResults(toolResults) {
-        if (!Array.isArray(toolResults))
-            return false;
-        return toolResults.every(tr => {
-            if (!tr || typeof tr !== 'object')
-                return false;
-            const trObj = tr;
-            return (typeof trObj.tool_call_id === 'string'
-                && trObj.content !== undefined);
-        });
-    }
-    /**
-     * 工具方法：提取工具调用信息
-     */
-    extractToolCallsInfo(messages) {
-        const toolCallMessages = messages.filter(m => m.role === 'assistant' && m.tool_calls);
-        const toolResultMessages = messages.filter(m => m.role === 'tool');
-        return {
-            toolCallCount: toolCallMessages.reduce((sum, m) => sum + (m.tool_calls?.length || 0), 0),
-            toolResultCount: toolResultMessages.length,
-            hasToolCalls: toolCallMessages.length > 0,
-            hasToolResults: toolResultMessages.length > 0
-        };
-    }
-    /**
-     * 工具方法：提取流式信息
-     */
-    extractStreamingInfo(request) {
-        return {
-            enabled: request.metadata.stream === true,
-            originalStreaming: request.parameters.stream
-        };
-    }
-}