@jsonstudio/llms 0.4.2

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

@@ -0,0 +1,116 @@
+/**
+ * 输出节点基类
+ *
+ * 提供输出转换的通用功能
+ */
+import { PipelineNode, NodeContext, NodeResult, NodeConfig, NodeStatus, ValidationResult, NodeType } from '../../types/index.js';
+import type { ProcessedRequest, StandardizedMessage, StandardizedTool, ToolCall } from '../../types/index.js';
+/**
+ * 输出节点抽象基类
+ *
+ * 提供统一的输出转换流程和接口
+ */
+export declare abstract class BaseOutputNode implements PipelineNode {
+    readonly id: string;
+    readonly type: NodeType.OUTPUT;
+    readonly name: string;
+    config: NodeConfig;
+    status: NodeStatus;
+    constructor(id: string, type: NodeType.OUTPUT, name: string, config: NodeConfig);
+    /**
+     * 主执行方法 - 实现统一的输出转换流水线
+     */
+    execute(context: NodeContext): Promise<NodeResult>;
+    /**
+     * 验证输入数据
+     */
+    validate(data: Record<string, unknown>): ValidationResult;
+    /**
+     * 处理 Passthrough 场景
+     */
+    private handlePassthrough;
+    /**
+     * 提取处理后的请求
+     */
+    private extractProcessedRequest;
+    /**
+     * 前置验证
+     */
+    private validateProcessedRequest;
+    /**
+     * 后置验证
+     */
+    private validateOutputResponse;
+    /**
+     * 构建转换响应
+     */
+    private buildConversionResponse;
+    /**
+     * 抽象方法：转换为输出格式
+     */
+    protected abstract convertToOutputFormat(processedRequest: ProcessedRequest, context: NodeContext): Promise<Record<string, unknown>>;
+    /**
+     * 抽象方法：生成输出元数据
+     */
+    protected abstract generateOutputMetadata(processedRequest: ProcessedRequest, context: NodeContext): Promise<Record<string, unknown>>;
+    /**
+     * 工具方法：生成响应ID
+     */
+    private generateResponseId;
+    /**
+     * 工具方法：计算响应大小
+     */
+    private calculateResponseSize;
+    /**
+     * 工具方法：获取失败阶段
+     */
+    private getFailureStage;
+    /**
+     * 工具方法：提取字符串字段
+     */
+    protected extractStringField(obj: Record<string, unknown>, field: string): string;
+    /**
+     * 工具方法：提取可选字符串字段
+     */
+    protected extractOptionalStringField(obj: Record<string, unknown>, field: string): string | undefined;
+    /**
+     * 工具方法：提取数组字段
+     */
+    protected extractArrayField(obj: Record<string, unknown>, field: string): unknown[];
+    /**
+     * 工具方法：提取可选数组字段
+     */
+    protected extractOptionalArrayField(obj: Record<string, unknown>, field: string): unknown[] | undefined;
+    /**
+     * 工具方法：提取对象字段
+     */
+    protected extractObjectField(obj: Record<string, unknown>, field: string): Record<string, unknown>;
+    /**
+     * 工具方法：提取可选对象字段
+     */
+    protected extractOptionalObjectField(obj: Record<string, unknown>, field: string): Record<string, unknown> | undefined;
+    /**
+     * 工具方法：安全类型转换
+     */
+    protected safeCast<T>(value: unknown, expectedType: 'string' | 'number' | 'boolean'): T | undefined;
+    /**
+     * 工具方法：安全序列化 JSON
+     */
+    protected safeStringifyJson(value: unknown): string;
+    /**
+     * 工具方法：安全解析 JSON
+     */
+    protected safeParseJson(value: unknown): unknown;
+    /**
+     * 获取当前流水线方向（request/response）
+     */
+    protected getPipelineDirection(context: NodeContext): 'request' | 'response';
+    /**
+     * 构造标准 OpenAI Chat 请求（供请求方向节点复用）
+     */
+    protected buildChatRequestPayload(processedRequest: ProcessedRequest): Record<string, unknown>;
+    protected resolveRequestModel(processedRequest: ProcessedRequest): string;
+    protected mapStandardizedMessageToChat(message: StandardizedMessage): Record<string, unknown>;
+    protected convertToolCallsForChat(toolCalls?: ToolCall[]): Record<string, unknown>[] | undefined;
+    protected cloneToolDefinition(tool: StandardizedTool): Record<string, unknown>;
+}

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

@@ -0,0 +1,512 @@
+/**
+ * 输出节点基类
+ *
+ * 提供输出转换的通用功能
+ */
+import { NodeStatus, ConversionError } from '../../types/index.js';
+/**
+ * 输出节点抽象基类
+ *
+ * 提供统一的输出转换流程和接口
+ */
+export class BaseOutputNode {
+    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(`Output 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 processedRequest = this.extractProcessedRequest(context.data);
+            // 4. 前置验证
+            this.validateProcessedRequest(processedRequest);
+            const direction = this.getPipelineDirection(context);
+            // 5. 并行执行各项转换
+            const [responseData, outputMetadata] = await Promise.all([
+                this.convertToOutputFormat(processedRequest, context),
+                this.generateOutputMetadata(processedRequest, context)
+            ]);
+            if (direction !== 'response') {
+                this.status = NodeStatus.COMPLETED;
+                return {
+                    success: true,
+                    data: responseData,
+                    metadata: {
+                        node: this.id,
+                        executionTime: Date.now() - startTime,
+                        startTime,
+                        endTime: Date.now(),
+                        dataProcessed: {
+                            messages: processedRequest.messages.length,
+                            tools: processedRequest.tools?.length || 0
+                        }
+                    }
+                };
+            }
+            // 6. 后置验证
+            this.validateOutputResponse(responseData);
+            // 7. 构建转换响应
+            const conversionResponse = this.buildConversionResponse(responseData, outputMetadata, context);
+            this.status = NodeStatus.COMPLETED;
+            return {
+                success: true,
+                data: {
+                    conversionResponse,
+                    outputFormat: this.config.outputFormat,
+                    outputData: responseData
+                },
+                metadata: {
+                    node: this.id,
+                    executionTime: Date.now() - startTime,
+                    startTime,
+                    endTime: Date.now(),
+                    dataProcessed: {
+                        messages: processedRequest.messages.length,
+                        tools: processedRequest.tools?.length || 0,
+                        responseSize: this.calculateResponseSize(responseData)
+                    }
+                }
+            };
+        }
+        catch (error) {
+            this.status = NodeStatus.FAILED;
+            return {
+                success: false,
+                error: {
+                    code: 'OUTPUT_CONVERSION_ERROR',
+                    message: error instanceof Error ? error.message : 'Unknown error during output conversion',
+                    details: {
+                        node: this.id,
+                        outputFormat: this.config.outputFormat,
+                        inputFormat: this.config.inputFormat,
+                        stage: this.getFailureStage(error)
+                    },
+                    cause: error instanceof Error ? error : undefined
+                },
+                metadata: {
+                    node: this.id,
+                    executionTime: Date.now() - startTime,
+                    startTime,
+                    endTime: Date.now()
+                }
+            };
+        }
+    }
+    /**
+     * 验证输入数据
+     */
+    validate(data) {
+        const errors = [];
+        // 验证必要字段
+        if (this.config.validation.required) {
+            for (const field of this.config.validation.required) {
+                if (!(field in data) || data[field] === undefined || data[field] === null) {
+                    errors.push({
+                        field,
+                        message: `Required field '${field}' is missing for output conversion`,
+                        code: 'MISSING_REQUIRED_FIELD',
+                        value: data[field]
+                    });
+                }
+            }
+        }
+        // 验证处理后的请求是否存在
+        if (!data.processedRequest && !data.conversionResponse) {
+            errors.push({
+                field: 'processedRequest',
+                message: 'Either processedRequest or conversionResponse is required',
+                code: 'MISSING_INPUT_DATA',
+                value: undefined
+            });
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings: []
+        };
+    }
+    /**
+     * 处理 Passthrough 场景
+     */
+    handlePassthrough(context, startTime) {
+        return {
+            success: true,
+            data: {
+                passthrough: true,
+                originalData: context.data,
+                outputFormat: this.config.outputFormat
+            },
+            metadata: {
+                node: this.id,
+                executionTime: Date.now() - startTime,
+                startTime,
+                endTime: Date.now(),
+                dataProcessed: {
+                    messages: 0,
+                    tools: 0,
+                    responseSize: 0
+                }
+            }
+        };
+    }
+    /**
+     * 提取处理后的请求
+     */
+    extractProcessedRequest(data) {
+        // 优先使用处理后的请求
+        if (data.processedRequest && typeof data.processedRequest === 'object') {
+            const processedRequest = data.processedRequest;
+            // 验证基本结构
+            if (!processedRequest.model) {
+                throw new ConversionError('Processed request must have a model', this.id);
+            }
+            if (!Array.isArray(processedRequest.messages)) {
+                throw new ConversionError('Processed request must have messages array', this.id);
+            }
+            return processedRequest;
+        }
+        // 如果没有处理后的请求，尝试从标准化请求构建
+        if (data.standardizedRequest && typeof data.standardizedRequest === 'object') {
+            const standardizedRequest = data.standardizedRequest;
+            return {
+                model: standardizedRequest.model,
+                messages: standardizedRequest.messages || [],
+                tools: standardizedRequest.tools,
+                parameters: standardizedRequest.parameters || {},
+                metadata: standardizedRequest.metadata || {},
+                processed: {
+                    timestamp: Date.now(),
+                    appliedRules: ['basic-output-conversion'],
+                    status: 'success'
+                },
+                processingMetadata: {
+                    streaming: {
+                        enabled: standardizedRequest.metadata?.stream === true,
+                        chunkCount: 0,
+                        totalTokens: 0
+                    },
+                    context: {
+                        systemPrompt: undefined,
+                        conversationHistory: [],
+                        relevantContext: {}
+                    }
+                }
+            };
+        }
+        throw new ConversionError('Valid processedRequest or standardizedRequest is required for output conversion', this.id);
+    }
+    /**
+     * 前置验证
+     */
+    validateProcessedRequest(request) {
+        if (!request.model) {
+            throw new ConversionError('Model is required in processed request', this.id);
+        }
+        if (!Array.isArray(request.messages)) {
+            throw new ConversionError('Messages must be a valid array', this.id);
+        }
+        if (request.messages.length === 0) {
+            throw new ConversionError('Messages array cannot be empty', this.id);
+        }
+    }
+    /**
+     * 后置验证
+     */
+    validateOutputResponse(responseData) {
+        if (!responseData || typeof responseData !== 'object') {
+            throw new ConversionError('Output response must be an object', this.id);
+        }
+        const response = responseData;
+        // 基本结构验证（子类可以覆盖）
+        if (!response.id && !response.object) {
+            throw new ConversionError('Output response must have id or object field', this.id);
+        }
+    }
+    /**
+     * 构建转换响应
+     */
+    buildConversionResponse(responseData, outputMetadata, context) {
+        const conversionResponse = {
+            id: this.generateResponseId(context),
+            requestId: context.request.id,
+            timestamp: Date.now(),
+            data: responseData,
+            format: this.config.outputFormat,
+            metadata: {
+                conversionTime: Date.now() - context.pipeline.startTime,
+                isPassthrough: context.pipeline.isPassthrough,
+                originalFormat: this.config.inputFormat,
+                targetFormat: this.config.outputFormat,
+                pipeline: {
+                    id: `pipeline-${this.config.inputFormat}-${this.config.outputFormat}`,
+                    nodes: context.pipeline.previousResults.map(r => r.metadata.node),
+                    mode: context.pipeline.isPassthrough ? 'passthrough' : 'standard'
+                }
+            }
+        };
+        // 添加输出特定元数据
+        conversionResponse.metadata = {
+            ...conversionResponse.metadata,
+            ...outputMetadata
+        };
+        return conversionResponse;
+    }
+    /**
+     * 工具方法：生成响应ID
+     */
+    generateResponseId(context) {
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).substr(2, 9);
+        return `resp-${timestamp}-${random}`;
+    }
+    /**
+     * 工具方法：计算响应大小
+     */
+    calculateResponseSize(responseData) {
+        try {
+            return JSON.stringify(responseData).length;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * 工具方法：获取失败阶段
+     */
+    getFailureStage(error) {
+        if (error instanceof ConversionError) {
+            if (error.message.includes('validation'))
+                return 'validation';
+            if (error.message.includes('conversion'))
+                return 'conversion';
+            if (error.message.includes('processedRequest'))
+                return 'input_extraction';
+        }
+        return 'unknown';
+    }
+    /**
+     * 工具方法：提取字符串字段
+     */
+    extractStringField(obj, field) {
+        if (!(field in obj)) {
+            throw new ConversionError(`Required field '${field}' is missing`, this.id);
+        }
+        const value = obj[field];
+        if (typeof value !== 'string') {
+            throw new ConversionError(`Field '${field}' must be a string`, this.id);
+        }
+        if (!value.trim()) {
+            throw new ConversionError(`Field '${field}' cannot be empty`, this.id);
+        }
+        return value.trim();
+    }
+    /**
+     * 工具方法：提取可选字符串字段
+     */
+    extractOptionalStringField(obj, field) {
+        if (!(field in obj))
+            return undefined;
+        const value = obj[field];
+        if (typeof value !== 'string')
+            return undefined;
+        const trimmed = value.trim();
+        return trimmed || undefined;
+    }
+    /**
+     * 工具方法：提取数组字段
+     */
+    extractArrayField(obj, field) {
+        if (!(field in obj)) {
+            throw new ConversionError(`Required field '${field}' is missing`, this.id);
+        }
+        const value = obj[field];
+        if (!Array.isArray(value)) {
+            throw new ConversionError(`Field '${field}' must be an array`, this.id);
+        }
+        return value;
+    }
+    /**
+     * 工具方法：提取可选数组字段
+     */
+    extractOptionalArrayField(obj, field) {
+        if (!(field in obj))
+            return undefined;
+        const value = obj[field];
+        if (!Array.isArray(value))
+            return undefined;
+        return value;
+    }
+    /**
+     * 工具方法：提取对象字段
+     */
+    extractObjectField(obj, field) {
+        if (!(field in obj)) {
+            throw new ConversionError(`Required field '${field}' is missing`, this.id);
+        }
+        const value = obj[field];
+        if (!value || typeof value !== 'object') {
+            throw new ConversionError(`Field '${field}' must be an object`, this.id);
+        }
+        return value;
+    }
+    /**
+     * 工具方法：提取可选对象字段
+     */
+    extractOptionalObjectField(obj, field) {
+        if (!(field in obj))
+            return undefined;
+        const value = obj[field];
+        if (!value || typeof value !== 'object')
+            return undefined;
+        return value;
+    }
+    /**
+     * 工具方法：安全类型转换
+     */
+    safeCast(value, expectedType) {
+        switch (expectedType) {
+            case 'string':
+                return typeof value === 'string' ? value : undefined;
+            case 'number':
+                return typeof value === 'number' ? value : undefined;
+            case 'boolean':
+                return typeof value === 'boolean' ? value : undefined;
+            default:
+                return undefined;
+        }
+    }
+    /**
+     * 工具方法：安全序列化 JSON
+     */
+    safeStringifyJson(value) {
+        try {
+            return JSON.stringify(value ?? {});
+        }
+        catch {
+            return '{}';
+        }
+    }
+    /**
+     * 工具方法：安全解析 JSON
+     */
+    safeParseJson(value) {
+        if (typeof value === 'object' && value !== null)
+            return value;
+        if (typeof value !== 'string')
+            return null;
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * 获取当前流水线方向（request/response）
+     */
+    getPipelineDirection(context) {
+        const metadata = context.request.context?.metadata;
+        const direction = typeof metadata?.direction === 'string' ? metadata.direction.toLowerCase() : '';
+        return direction === 'response' ? 'response' : 'request';
+    }
+    /**
+     * 构造标准 OpenAI Chat 请求（供请求方向节点复用）
+     */
+    buildChatRequestPayload(processedRequest) {
+        const payload = {
+            model: this.resolveRequestModel(processedRequest),
+            messages: processedRequest.messages.map(msg => this.mapStandardizedMessageToChat(msg))
+        };
+        if (processedRequest.tools && processedRequest.tools.length > 0) {
+            payload.tools = processedRequest.tools.map(tool => this.cloneToolDefinition(tool));
+        }
+        const params = processedRequest.parameters || {};
+        for (const [key, value] of Object.entries(params)) {
+            if (value === undefined)
+                continue;
+            if (key === 'model')
+                continue;
+            payload[key] = value;
+        }
+        const toolChoice = processedRequest.metadata?.toolChoice;
+        if (toolChoice)
+            payload.tool_choice = toolChoice;
+        return payload;
+    }
+    resolveRequestModel(processedRequest) {
+        const paramModel = processedRequest.parameters?.model;
+        if (typeof paramModel === 'string' && paramModel.trim())
+            return paramModel.trim();
+        return processedRequest.model;
+    }
+    mapStandardizedMessageToChat(message) {
+        const normalized = {
+            role: message.role
+        };
+        if (message.name)
+            normalized.name = message.name;
+        if (message.role === 'tool') {
+            if (message.tool_call_id)
+                normalized.tool_call_id = message.tool_call_id;
+            normalized.content = message.content ?? '';
+        }
+        else {
+            normalized.content = message.content;
+            const toolCalls = this.convertToolCallsForChat(message.tool_calls);
+            if (toolCalls)
+                normalized.tool_calls = toolCalls;
+        }
+        if (message.metadata && Object.keys(message.metadata).length > 0) {
+            normalized.metadata = message.metadata;
+        }
+        return normalized;
+    }
+    convertToolCallsForChat(toolCalls) {
+        if (!toolCalls || toolCalls.length === 0)
+            return undefined;
+        return toolCalls.map((toolCall, index) => ({
+            index,
+            id: toolCall.id,
+            type: toolCall.type,
+            function: {
+                name: toolCall.function.name,
+                arguments: toolCall.function.arguments
+            }
+        }));
+    }
+    cloneToolDefinition(tool) {
+        const fnDef = {
+            name: tool.function.name,
+            parameters: tool.function.parameters
+        };
+        if (tool.function.description)
+            fnDef.description = tool.function.description;
+        if (typeof tool.function.strict === 'boolean')
+            fnDef.strict = tool.function.strict;
+        return {
+            type: tool.type,
+            function: fnDef
+        };
+    }
+}

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

@@ -0,0 +1,7 @@
+/**
+ * 输出节点导出
+ */
+export { BaseOutputNode } from './base-output-node.js';
+export { OpenAIOutputNode } from './openai-output-node.js';
+export { AnthropicOutputNode } from './anthropic-output-node.js';
+export { ResponsesOutputNode } from './responses-output-node.js';

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

@@ -0,0 +1,7 @@
+/**
+ * 输出节点导出
+ */
+export { BaseOutputNode } from './base-output-node.js';
+export { OpenAIOutputNode } from './openai-output-node.js';
+export { AnthropicOutputNode } from './anthropic-output-node.js';
+export { ResponsesOutputNode } from './responses-output-node.js';