@jsonstudio/llms 0.4.3 → 0.4.5

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

@@ -1,29 +0,0 @@
-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

@@ -1,181 +0,0 @@
-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

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

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

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

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

@@ -1,17 +0,0 @@
-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;
-}