@jsonstudio/llms 0.4.2 → 0.4.4

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

@@ -1,116 +0,0 @@
-/**
- * 输出节点基类
- *
- * 提供输出转换的通用功能
- */
-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

@@ -1,512 +0,0 @@
-/**
- * 输出节点基类
- *
- * 提供输出转换的通用功能
- */
-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

@@ -1,7 +0,0 @@
-/**
- * 输出节点导出
- */
-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

@@ -1,7 +0,0 @@
-/**
- * 输出节点导出
- */
-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';