@jsonstudio/llms 0.4.2

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

@@ -0,0 +1,29 @@
+import { NodeType, NodeStatus, type NodeConfig, type NodeContext, type NodeResult } from '../../types/index.js';
+export declare class CompatibilityProcessNode {
+    readonly id: string;
+    config: NodeConfig;
+    readonly type = NodeType.PROCESS;
+    readonly name: string;
+    status: NodeStatus;
+    constructor(id: string, config: NodeConfig);
+    execute(context: NodeContext): Promise<NodeResult>;
+    validate(data: Record<string, unknown>): {
+        valid: boolean;
+        errors: {
+            field: string;
+            message: string;
+            code: string;
+            value: any;
+        }[];
+        warnings: any[];
+    };
+    private extractProcessedRequest;
+    private resolveDirection;
+    private resolveStages;
+    private getCompatibilityOptions;
+    private shouldExecuteCompatibility;
+    private extractProviderMetadata;
+    private matchesFilter;
+    private buildStageContext;
+    private createMetadata;
+}

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

@@ -0,0 +1,181 @@
+import { NodeType, NodeStatus, ConversionError } from '../../types/index.js';
+import { getCompatibilityProfile } from '../../compatibility/compatibility-profiles.js';
+import { getCompatibilityStage } from '../../compatibility/compatibility-stages.js';
+export class CompatibilityProcessNode {
+    id;
+    config;
+    type = NodeType.PROCESS;
+    name;
+    status = NodeStatus.IDLE;
+    constructor(id, config) {
+        this.id = id;
+        this.config = config;
+        this.name = config.name || 'Compatibility Filter Node';
+    }
+    async execute(context) {
+        const start = Date.now();
+        try {
+            this.status = NodeStatus.RUNNING;
+            const processedRequest = this.extractProcessedRequest(context.data);
+            const compatOptions = this.getCompatibilityOptions();
+            if (!compatOptions || !this.shouldExecuteCompatibility(compatOptions)) {
+                this.status = NodeStatus.COMPLETED;
+                return {
+                    success: true,
+                    data: { processedRequest },
+                    metadata: this.createMetadata(start)
+                };
+            }
+            const direction = this.resolveDirection(context, compatOptions);
+            const meta = this.extractProviderMetadata(context);
+            if (!this.matchesFilter(meta.providerId, compatOptions.providerMatch) ||
+                !this.matchesFilter(meta.providerType, compatOptions.providerTypeMatch) ||
+                !this.matchesFilter(meta.providerProtocol, compatOptions.protocolMatch)) {
+                this.status = NodeStatus.COMPLETED;
+                return {
+                    success: true,
+                    data: { processedRequest },
+                    metadata: this.createMetadata(start)
+                };
+            }
+            const stages = this.resolveStages(direction, compatOptions);
+            if (!stages.length) {
+                this.status = NodeStatus.COMPLETED;
+                return {
+                    success: true,
+                    data: { processedRequest },
+                    metadata: this.createMetadata(start)
+                };
+            }
+            let current = processedRequest;
+            const stageContext = this.buildStageContext(direction, context, compatOptions, meta);
+            for (const stageName of stages) {
+                const handler = getCompatibilityStage(stageName);
+                if (!handler)
+                    continue;
+                current = await handler(current, stageContext);
+            }
+            this.status = NodeStatus.COMPLETED;
+            return {
+                success: true,
+                data: { processedRequest: current },
+                metadata: this.createMetadata(start)
+            };
+        }
+        catch (error) {
+            this.status = NodeStatus.FAILED;
+            return {
+                success: false,
+                error: {
+                    code: 'COMPATIBILITY_FILTER_ERROR',
+                    message: error instanceof Error ? error.message : 'Unknown compatibility error',
+                    cause: error instanceof Error ? error : undefined,
+                    details: { node: this.id }
+                },
+                metadata: this.createMetadata(start)
+            };
+        }
+    }
+    validate(data) {
+        const hasProcessed = Boolean(data && typeof data === 'object' && data.processedRequest);
+        return {
+            valid: hasProcessed,
+            errors: hasProcessed
+                ? []
+                : [{ field: 'processedRequest', message: 'Processed request is required', code: 'MISSING_PROCESSED_REQUEST', value: undefined }],
+            warnings: []
+        };
+    }
+    extractProcessedRequest(data) {
+        if (!data || typeof data !== 'object' || !data.processedRequest) {
+            throw new ConversionError('Compatibility node requires processedRequest input', this.id, 'validation');
+        }
+        return data.processedRequest;
+    }
+    resolveDirection(context, options) {
+        if (options.direction === 'response')
+            return 'response';
+        if (options.direction === 'request')
+            return 'request';
+        const directionMeta = context.request.context?.metadata?.direction;
+        return directionMeta === 'response' ? 'response' : 'request';
+    }
+    resolveStages(direction, options) {
+        const profileName = typeof options.profile === 'string' ? options.profile : 'default';
+        const profile = getCompatibilityProfile(profileName) || getCompatibilityProfile('default') || { requestStages: [], responseStages: [] };
+        if (direction === 'response') {
+            if (Array.isArray(options.responseStages))
+                return options.responseStages;
+            return profile.responseStages ? [...profile.responseStages] : [];
+        }
+        if (Array.isArray(options.requestStages))
+            return options.requestStages;
+        return profile.requestStages ? [...profile.requestStages] : [];
+    }
+    getCompatibilityOptions() {
+        const raw = this.config.options?.compatibility;
+        if (!raw || typeof raw !== 'object')
+            return null;
+        return raw;
+    }
+    shouldExecuteCompatibility(options) {
+        // Compatibility is now host-owned; only run when explicitly flagged for core execution.
+        const mode = typeof options.executionMode === 'string'
+            ? options.executionMode.trim().toLowerCase()
+            : '';
+        if (mode) {
+            return mode === 'core';
+        }
+        return false;
+    }
+    extractProviderMetadata(context) {
+        const metadata = (context.request.context?.metadata || {});
+        const providerId = (metadata.providerId || metadata.provider || metadata.providerName);
+        const providerType = (metadata.providerType || metadata.provider_type);
+        const providerProtocol = (metadata.providerProtocol || metadata.provider || metadata.protocol);
+        return {
+            providerId: providerId ? providerId.toString() : undefined,
+            providerType: providerType ? providerType.toString() : undefined,
+            providerProtocol: providerProtocol ? providerProtocol.toString() : undefined,
+            metadata
+        };
+    }
+    matchesFilter(actual, expected) {
+        if (!expected)
+            return true;
+        const values = Array.isArray(expected) ? expected : [expected];
+        if (!values.length)
+            return true;
+        const normalizedActual = (actual || '').trim().toLowerCase();
+        return values.some(value => {
+            const normalized = (value || '').trim().toLowerCase();
+            if (!normalized || normalized === '*' || normalized === 'any') {
+                return true;
+            }
+            if (!normalizedActual)
+                return false;
+            return normalizedActual === normalized;
+        });
+    }
+    buildStageContext(direction, context, options, meta) {
+        return {
+            direction,
+            requestId: context.request.id,
+            endpoint: context.request.endpoint,
+            profile: options.profile,
+            provider: meta.providerId,
+            providerType: meta.providerType,
+            providerProtocol: meta.providerProtocol,
+            metadata: meta.metadata
+        };
+    }
+    createMetadata(start) {
+        const end = Date.now();
+        return {
+            node: this.id,
+            executionTime: end - start,
+            startTime: start,
+            endTime: end
+        };
+    }
+}

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

@@ -0,0 +1,10 @@
+/**
+ * 处理节点导出
+ */
+export { BaseProcessNode } from './base-process-node.js';
+export { ChatProcessNode } from './chat-process-node.js';
+export { PassthroughProcessNode } from './passthrough-process-node.js';
+export { ResponseProcessNode } from './response-process-node.js';
+export { CompatibilityProcessNode } from './compatibility-process-node.js';
+export { ToolProcessNode } from './tool-process-node.js';
+export { VirtualRouterProcessNode } from './virtual-router-process-node.js';

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

@@ -0,0 +1,10 @@
+/**
+ * 处理节点导出
+ */
+export { BaseProcessNode } from './base-process-node.js';
+export { ChatProcessNode } from './chat-process-node.js';
+export { PassthroughProcessNode } from './passthrough-process-node.js';
+export { ResponseProcessNode } from './response-process-node.js';
+export { CompatibilityProcessNode } from './compatibility-process-node.js';
+export { ToolProcessNode } from './tool-process-node.js';
+export { VirtualRouterProcessNode } from './virtual-router-process-node.js';

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

@@ -0,0 +1,59 @@
+/**
+ * Passthrough 处理节点
+ *
+ * 专门用于不需要转换的场景，提供零开销的直通处理
+ */
+import { BaseProcessNode } from './base-process-node.js';
+import type { NodeContext, NodeConfig, ProcessedRequest } from '../../types/index.js';
+/**
+ * Passthrough 处理节点实现
+ *
+ * 用于无需转换的场景，提供零开销的直通处理
+ */
+export declare class PassthroughProcessNode extends BaseProcessNode {
+    constructor(config: NodeConfig);
+    /**
+     * 处理请求核心逻辑 - Passthrough 模式
+     */
+    protected processRequest(standardizedRequest: any, context: NodeContext): Promise<ProcessedRequest>;
+    /**
+     * 后置处理请求 - Passthrough 模式
+     */
+    protected postprocessRequest(processedRequest: ProcessedRequest, context: NodeContext): Promise<ProcessedRequest>;
+    /**
+     * 提取 Passthrough 数据
+     */
+    private extractPassthroughData;
+    /**
+     * 验证 Passthrough 条件
+     */
+    private validatePassthroughConditions;
+    /**
+     * 从 Passthrough 数据提取模型
+     */
+    private extractModelFromPassthrough;
+    /**
+     * 从 Passthrough 数据提取消息
+     */
+    private extractMessagesFromPassthrough;
+    /**
+     * 从 Passthrough 数据提取工具
+     */
+    private extractToolsFromPassthrough;
+    /**
+     * 从 Passthrough 数据提取参数
+     */
+    private extractParametersFromPassthrough;
+    /**
+     * 验证 Passthrough 结果
+     */
+    private validatePassthroughResult;
+    /**
+     * 工具方法：提取字符串字段
+     */
+    private extractStringField;
+    /**
+     * 工具方法：提取对象字段
+     */
+    private extractObjectField;
+}

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

@@ -0,0 +1,243 @@
+/**
+ * Passthrough 处理节点
+ *
+ * 专门用于不需要转换的场景，提供零开销的直通处理
+ */
+import { BaseProcessNode } from './base-process-node.js';
+import { NodeType, ConversionError } from '../../types/index.js';
+/**
+ * Passthrough 处理节点实现
+ *
+ * 用于无需转换的场景，提供零开销的直通处理
+ */
+export class PassthroughProcessNode extends BaseProcessNode {
+    constructor(config) {
+        super('passthrough-process', NodeType.PROCESS, 'Passthrough Process Node', config);
+    }
+    /**
+     * 处理请求核心逻辑 - Passthrough 模式
+     */
+    async processRequest(standardizedRequest, context) {
+        const processingStartTime = Date.now();
+        // Passthrough 模式：直接传递数据，不做处理
+        if (!context.pipeline.isPassthrough) {
+            throw new ConversionError('PassthroughProcessNode requires isPassthrough=true', this.id, 'configuration');
+        }
+        // 提取原始数据
+        const passthroughData = this.extractPassthroughData(context.data);
+        // 验证 Passthrough 条件
+        this.validatePassthroughConditions(passthroughData, context);
+        // 创建处理后的请求（实际上没有处理）
+        const processedRequest = {
+            model: this.extractModelFromPassthrough(passthroughData),
+            messages: this.extractMessagesFromPassthrough(passthroughData),
+            tools: this.extractToolsFromPassthrough(passthroughData),
+            parameters: this.extractParametersFromPassthrough(passthroughData),
+            metadata: {
+                originalEndpoint: typeof passthroughData.metadata.originalEndpoint === 'string'
+                    ? passthroughData.metadata.originalEndpoint
+                    : 'unknown',
+                capturedContext: passthroughData.metadata
+                    .capturedContext ?? {},
+                requestId: typeof passthroughData.metadata.requestId === 'string'
+                    ? passthroughData.metadata.requestId
+                    : undefined,
+                stream: typeof passthroughData.metadata.stream === 'boolean'
+                    ? passthroughData.metadata.stream
+                    : undefined
+            },
+            processed: {
+                timestamp: processingStartTime,
+                appliedRules: ['passthrough-only'],
+                status: 'success'
+            },
+            processingMetadata: {
+                streaming: {
+                    enabled: passthroughData.metadata.stream === true,
+                    chunkCount: 0,
+                    totalTokens: 0
+                },
+                context: {
+                    systemPrompt: undefined,
+                    conversationHistory: [],
+                    relevantContext: {}
+                }
+            }
+        };
+        return processedRequest;
+    }
+    /**
+     * 后置处理请求 - Passthrough 模式
+     */
+    async postprocessRequest(processedRequest, context) {
+        // Passthrough 模式下，后置处理也很简单
+        // 1. 验证基本结构
+        this.validatePassthroughResult(processedRequest);
+        // 2. 添加 Passthrough 元数据（保持简单标记，详细信息可以通过日志/监控获取）
+        processedRequest.processingMetadata = {
+            ...processedRequest.processingMetadata,
+            passthrough: true
+        };
+        return processedRequest;
+    }
+    /**
+     * 提取 Passthrough 数据
+     */
+    extractPassthroughData(data) {
+        // 从上下文中提取原始数据
+        const originalFormat = this.extractStringField(data, 'originalFormat');
+        const targetFormat = this.extractStringField(data, 'targetFormat');
+        const originalData = this.extractObjectField(data, 'originalData');
+        const metadata = this.extractObjectField(data, 'metadata');
+        if (originalFormat !== targetFormat) {
+            throw new ConversionError(`Passthrough requires same format: ${originalFormat} != ${targetFormat}`, this.id, 'format_mismatch');
+        }
+        return {
+            originalFormat,
+            targetFormat,
+            originalData,
+            metadata
+        };
+    }
+    /**
+     * 验证 Passthrough 条件
+     */
+    validatePassthroughConditions(data, context) {
+        // 1. 格式一致性检查
+        if (data.originalFormat !== data.targetFormat) {
+            throw new ConversionError(`Passthrough requires identical formats: ${data.originalFormat} != ${data.targetFormat}`, this.id, 'format_validation');
+        }
+        // 2. 数据完整性检查
+        if (!data.originalData || typeof data.originalData !== 'object') {
+            throw new ConversionError('Passthrough requires valid original data object', this.id, 'data_validation');
+        }
+        // 3. 上下文一致性检查
+        if (!context.pipeline.isPassthrough) {
+            throw new ConversionError('PassthroughProcessNode requires pipeline isPassthrough=true', this.id, 'context_validation');
+        }
+        // 4. 端点兼容性检查
+        const supportedFormats = [
+            'openai-chat',
+            'anthropic-messages',
+            'openai-responses'
+        ];
+        if (!supportedFormats.includes(data.originalFormat)) {
+            throw new ConversionError(`Passthrough not supported for format: ${data.originalFormat}`, this.id, 'format_support');
+        }
+    }
+    /**
+     * 从 Passthrough 数据提取模型
+     */
+    extractModelFromPassthrough(data) {
+        const model = data.originalData.model;
+        if (!model || typeof model !== 'string') {
+            throw new ConversionError('Passthrough requires valid model in original data', this.id, 'model_extraction');
+        }
+        if (!model.trim()) {
+            throw new ConversionError('Passthrough requires non-empty model string', this.id, 'model_validation');
+        }
+        return model.trim();
+    }
+    /**
+     * 从 Passthrough 数据提取消息
+     */
+    extractMessagesFromPassthrough(data) {
+        const messages = data.originalData.messages;
+        if (!messages) {
+            throw new ConversionError('Passthrough requires messages in original data', this.id, 'messages_extraction');
+        }
+        if (!Array.isArray(messages)) {
+            throw new ConversionError('Passthrough requires messages to be an array', this.id, 'messages_validation');
+        }
+        if (messages.length === 0) {
+            throw new ConversionError('Passthrough requires non-empty messages array', this.id, 'messages_validation');
+        }
+        return messages;
+    }
+    /**
+     * 从 Passthrough 数据提取工具
+     */
+    extractToolsFromPassthrough(data) {
+        const tools = data.originalData.tools;
+        if (!tools) {
+            return undefined;
+        }
+        if (!Array.isArray(tools)) {
+            throw new ConversionError('Passthrough requires tools to be an array if present', this.id, 'tools_validation');
+        }
+        return tools.length > 0 ? tools : undefined;
+    }
+    /**
+     * 从 Passthrough 数据提取参数
+     */
+    extractParametersFromPassthrough(data) {
+        const parameters = {};
+        // 提取所有参数（保持原始状态）
+        const standardParams = [
+            'temperature',
+            'max_tokens',
+            'top_p',
+            'frequency_penalty',
+            'presence_penalty',
+            'stop',
+            'stream',
+            'n',
+            'seed',
+            'tool_choice'
+        ];
+        for (const param of standardParams) {
+            if (param in data.originalData) {
+                const value = data.originalData[param];
+                if (value !== undefined && value !== null) {
+                    parameters[param] = value;
+                }
+            }
+        }
+        // 确保包含 model
+        parameters.model = data.originalData.model;
+        return parameters;
+    }
+    /**
+     * 验证 Passthrough 结果
+     */
+    validatePassthroughResult(request) {
+        if (!request.model) {
+            throw new ConversionError('Passthrough result must have model', this.id, 'result_validation');
+        }
+        if (!request.messages || !Array.isArray(request.messages)) {
+            throw new ConversionError('Passthrough result must have messages array', this.id, 'result_validation');
+        }
+        if (request.messages.length === 0) {
+            throw new ConversionError('Passthrough result messages array cannot be empty', this.id, 'result_validation');
+        }
+    }
+    /**
+     * 工具方法：提取字符串字段
+     */
+    extractStringField(obj, field) {
+        if (!(field in obj)) {
+            throw new ConversionError(`Required field '${field}' is missing from passthrough data`, this.id, 'field_extraction');
+        }
+        const value = obj[field];
+        if (typeof value !== 'string') {
+            throw new ConversionError(`Field '${field}' must be a string in passthrough data`, this.id, 'field_validation');
+        }
+        if (!value.trim()) {
+            throw new ConversionError(`Field '${field}' cannot be empty in passthrough data`, this.id, 'field_validation');
+        }
+        return value.trim();
+    }
+    /**
+     * 工具方法：提取对象字段
+     */
+    extractObjectField(obj, field) {
+        if (!(field in obj)) {
+            throw new ConversionError(`Required field '${field}' is missing from passthrough data`, this.id, 'field_extraction');
+        }
+        const value = obj[field];
+        if (!value || typeof value !== 'object') {
+            throw new ConversionError(`Field '${field}' must be an object in passthrough data`, this.id, 'field_validation');
+        }
+        return value;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { NodeStatus, NodeType, type NodeConfig, type NodeContext, type NodeResult, type PipelineNode, type ValidationResult } from '../../types/index.js';
+export declare class ResponseProcessNode implements PipelineNode {
+    readonly id: string;
+    readonly config: NodeConfig;
+    readonly type = NodeType.PROCESS;
+    status: NodeStatus;
+    readonly name: string;
+    constructor(id: string, config: NodeConfig);
+    execute(context: NodeContext): Promise<NodeResult>;
+    validate(): ValidationResult;
+    cleanup(): Promise<void>;
+    private extractPayload;
+    private buildToolContext;
+    private detectStreamingIntent;
+    private extractDirectMetadata;
+    private extractRequestMetadata;
+}