@jsonstudio/llms 0.4.2

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

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

@@ -0,0 +1,72 @@
+/**
+ * 处理节点基类
+ *
+ * 提供处理节点的通用功能
+ */
+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

@@ -0,0 +1,246 @@
+/**
+ * 处理节点基类
+ *
+ * 提供处理节点的通用功能
+ */
+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
+        };
+    }
+}