@jsonstudio/llms 0.4.3 → 0.4.5

package/dist/conversion/conversion-v3/config/default-configs.js

@@ -1,1007 +0,0 @@
-/**
- * 默认配置文件
- *
- * 提供开箱即用的默认配置，无需用户配置即可使用
- */
-/**
- * 默认节点配置
- */
-export const DEFAULT_NODE_CONFIGS = {
-    // ====================
-    // 输入节点配置
-    // ====================
-    'chat-input': {
-        id: 'chat-input',
-        type: 'input',
-        name: 'OpenAI Chat Input Node',
-        description: 'Convert OpenAI Chat requests to standardized format',
-        inputFormat: 'openai-chat',
-        outputFormat: 'standardized-chat',
-        rules: [
-            'chat-message-rule',
-            'chat-tool-rule',
-            'chat-parameter-rule',
-            'streaming-rule'
-        ],
-        validation: {
-            strict: true,
-            required: ['model', 'messages'],
-            optional: ['tools', 'tool_choice', 'temperature', 'max_tokens', 'stream']
-        },
-        timeout: 10000,
-        retry: {
-            maxRetries: 2,
-            retryDelay: 1000,
-            exponentialBackoff: true,
-            retryableErrors: ['timeout', 'network', 'temporary']
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: false,
-            performanceSampling: 0.1,
-            customMetrics: ['message-count', 'tool-count']
-        }
-    },
-    'sse-input': {
-        id: 'sse-input',
-        type: 'input',
-        name: 'SSE Input Node',
-        description: 'Normalize SSE payloads into JSON envelopes',
-        inputFormat: 'sse',
-        outputFormat: 'json',
-        rules: ['sse-normalize'],
-        validation: {
-            strict: false,
-            required: [],
-            optional: ['*']
-        },
-        timeout: 2000,
-        retry: {
-            maxRetries: 0,
-            retryDelay: 0,
-            exponentialBackoff: false,
-            retryableErrors: []
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: false,
-            performanceSampling: 0.05,
-            customMetrics: ['sse-chunk-count']
-        }
-    },
-    'sse-output': {
-        id: 'sse-output',
-        type: 'output',
-        name: 'SSE Output Node',
-        description: 'Serialize JSON envelopes into SSE stream events',
-        inputFormat: 'json',
-        outputFormat: 'sse',
-        rules: ['sse-serialize'],
-        validation: {
-            strict: false,
-            required: [],
-            optional: ['*']
-        },
-        timeout: 2000,
-        retry: {
-            maxRetries: 0,
-            retryDelay: 0,
-            exponentialBackoff: false,
-            retryableErrors: []
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: false,
-            performanceSampling: 0.05,
-            customMetrics: ['sse-event-count']
-        }
-    },
-    'sse-passthrough': {
-        id: 'sse-passthrough',
-        type: 'process',
-        name: 'SSE Passthrough Node',
-        description: 'Keep SSE payload untouched while tracking metadata',
-        inputFormat: 'sse',
-        outputFormat: 'sse',
-        rules: ['sse-passthrough'],
-        validation: {
-            strict: false,
-            required: [],
-            optional: ['*']
-        },
-        timeout: 500,
-        retry: {
-            maxRetries: 0,
-            retryDelay: 0,
-            exponentialBackoff: false,
-            retryableErrors: []
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: false,
-            performanceSampling: 0.05,
-            customMetrics: ['sse-passthrough']
-        }
-    },
-    'openai-response-input': {
-        id: 'openai-response-input',
-        type: 'input',
-        name: 'OpenAI Response Input Node',
-        description: 'Convert OpenAI provider responses into canonical format',
-        inputFormat: 'openai-chat-response',
-        outputFormat: 'standardized-response',
-        rules: ['openai-response-normalize'],
-        validation: {
-            strict: false,
-            required: [],
-            optional: ['*']
-        },
-        timeout: 5000,
-        retry: {
-            maxRetries: 0,
-            retryDelay: 0,
-            exponentialBackoff: false,
-            retryableErrors: []
-        }
-    },
-    'anthropic-response-input': {
-        id: 'anthropic-response-input',
-        type: 'input',
-        name: 'Anthropic Response Input Node',
-        description: 'Convert Anthropic provider responses into canonical format',
-        inputFormat: 'anthropic-response',
-        outputFormat: 'standardized-response',
-        rules: ['anthropic-response-normalize'],
-        validation: {
-            strict: false,
-            required: [],
-            optional: ['*']
-        },
-        timeout: 5000,
-        retry: {
-            maxRetries: 0,
-            retryDelay: 0,
-            exponentialBackoff: false,
-            retryableErrors: []
-        }
-    },
-    'responses-response-input': {
-        id: 'responses-response-input',
-        type: 'input',
-        name: 'OpenAI Responses Response Input Node',
-        description: 'Convert OpenAI Responses provider outputs into canonical format',
-        inputFormat: 'openai-responses-response',
-        outputFormat: 'standardized-response',
-        rules: ['responses-response-normalize'],
-        validation: {
-            strict: false,
-            required: [],
-            optional: ['*']
-        },
-        timeout: 5000,
-        retry: {
-            maxRetries: 0,
-            retryDelay: 0,
-            exponentialBackoff: false,
-            retryableErrors: []
-        }
-    },
-    'anthropic-input': {
-        id: 'anthropic-input',
-        type: 'input',
-        name: 'Anthropic Input Node',
-        description: 'Convert Anthropic requests to standardized format',
-        inputFormat: 'anthropic-messages',
-        outputFormat: 'standardized-chat',
-        rules: [
-            'anthropic-message-rule',
-            'anthropic-tool-rule',
-            'anthropic-parameter-rule',
-            'claude-formatting-rule'
-        ],
-        validation: {
-            strict: true,
-            required: ['model', 'messages'],
-            optional: ['tools', 'tool_choice', 'temperature', 'max_tokens', 'stream']
-        },
-        timeout: 10000,
-        retry: {
-            maxRetries: 2,
-            retryDelay: 1000,
-            exponentialBackoff: true,
-            retryableErrors: ['timeout', 'network', 'temporary']
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: false,
-            performanceSampling: 0.1,
-            customMetrics: ['claude-context', 'tool-use-count']
-        }
-    },
-    'responses-input': {
-        id: 'responses-input',
-        type: 'input',
-        name: 'OpenAI Responses Input Node',
-        description: 'Convert OpenAI Responses requests to standardized format',
-        inputFormat: 'openai-responses',
-        outputFormat: 'standardized-chat',
-        rules: [
-            'responses-message-rule',
-            'responses-tool-rule',
-            'responses-parameter-rule',
-            'responses-format-rule'
-        ],
-        validation: {
-            strict: true,
-            required: ['model', 'input'],
-            optional: ['temperature', 'max_tokens', 'tools', 'tool_choice']
-        },
-        timeout: 10000,
-        retry: {
-            maxRetries: 2,
-            retryDelay: 1000,
-            exponentialBackoff: true,
-            retryableErrors: ['timeout', 'network', 'temporary']
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: false,
-            performanceSampling: 0.1,
-            customMetrics: ['response-format', 'modal-type']
-        }
-    },
-    // ====================
-    // 处理节点配置
-    // ====================
-    'chat-process': {
-        id: 'chat-process',
-        type: 'process',
-        name: 'Chat Process Node',
-        description: 'Core processing node for chat requests',
-        inputFormat: 'standardized-chat',
-        outputFormat: 'processed-chat',
-        rules: [
-            'tool-call-processing',
-            'context-management',
-            'streaming-handling',
-            'error-handling'
-        ],
-        validation: {
-            strict: false, // Processing node is more lenient
-            required: ['messages'],
-            optional: ['tools', 'tool_calls', 'context']
-        },
-        timeout: 30000, // Processing may take longer
-        retry: {
-            maxRetries: 1,
-            retryDelay: 2000,
-            exponentialBackoff: false,
-            retryableErrors: ['timeout', 'temporary']
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: true,
-            performanceSampling: 0.2,
-            customMetrics: ['processing-time', 'tool-execution', 'context-usage']
-        }
-    },
-    'response-process': {
-        id: 'response-process',
-        type: 'process',
-        name: 'Response Process Node',
-        description: 'Standardized governance for provider responses',
-        inputFormat: 'standardized-response',
-        outputFormat: 'processed-response',
-        rules: [
-            'response-tool-processing',
-            'response-finalization',
-            'response-context-handling'
-        ],
-        validation: {
-            strict: false,
-            required: ['responsePayload'],
-            optional: ['responseContext']
-        },
-        timeout: 30000,
-        retry: {
-            maxRetries: 1,
-            retryDelay: 2000,
-            exponentialBackoff: false,
-            retryableErrors: ['timeout', 'temporary']
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: true,
-            performanceSampling: 0.2,
-            customMetrics: ['response-processing-time', 'response-tool-usage']
-        }
-    },
-    'compatibility-process': {
-        id: 'compatibility-process',
-        type: 'process',
-        name: 'Compatibility Filter Node',
-        description: 'Applies provider-aware compatibility filters to processed requests',
-        inputFormat: 'processed-chat',
-        outputFormat: 'processed-chat',
-        rules: ['compatibility-filtering'],
-        options: {
-            compatibility: {
-                profile: 'default', // Will be overridden by pipeline config
-                providerMatch: ['*'],
-                protocolMatch: ['*']
-            }
-        },
-        validation: {
-            strict: false,
-            required: ['processedRequest'],
-            optional: ['*']
-        },
-        timeout: 5000,
-        retry: {
-            maxRetries: 0,
-            retryDelay: 0,
-            exponentialBackoff: false,
-            retryableErrors: []
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: false,
-            performanceSampling: 0.1,
-            customMetrics: ['compat-stages']
-        }
-    },
-    'passthrough-process': {
-        id: 'passthrough-process',
-        type: 'process',
-        name: 'Passthrough Process Node',
-        description: 'Pass-through node for direct data routing',
-        inputFormat: 'any',
-        outputFormat: 'any',
-        rules: ['passthrough-rule'],
-        validation: {
-            strict: false,
-            required: [],
-            optional: ['*'] // Accept anything
-        },
-        timeout: 1000, // Very fast for passthrough
-        retry: {
-            maxRetries: 0, // No retry for passthrough
-            retryDelay: 0,
-            exponentialBackoff: false,
-            retryableErrors: []
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: false,
-            performanceSampling: 0.05,
-            customMetrics: ['passthrough-count']
-        }
-    },
-    // ====================
-    // 输出节点配置
-    // ====================
-    'openai-output': {
-        id: 'openai-output',
-        type: 'output',
-        name: 'OpenAI Output Node',
-        description: 'Convert processed data to OpenAI format',
-        inputFormat: 'processed-chat',
-        outputFormat: 'openai-chat',
-        rules: [
-            'openai-response-rule',
-            'openai-formatting-rule',
-            'openai-error-handling',
-            'openai-streaming-rule'
-        ],
-        validation: {
-            strict: true,
-            required: ['processedRequest'],
-            optional: ['standardizedRequest', 'conversionResponse']
-        },
-        timeout: 5000,
-        retry: {
-            maxRetries: 2,
-            retryDelay: 500,
-            exponentialBackoff: false,
-            retryableErrors: ['format', 'structure']
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: false,
-            performanceSampling: 0.1,
-            customMetrics: ['response-size', 'token-count', 'format-validation']
-        }
-    },
-    'anthropic-output': {
-        id: 'anthropic-output',
-        type: 'output',
-        name: 'Anthropic Output Node',
-        description: 'Convert processed data to Anthropic format',
-        inputFormat: 'processed-chat',
-        outputFormat: 'anthropic-messages',
-        rules: [
-            'anthropic-response-rule',
-            'anthropic-formatting-rule',
-            'anthropic-error-handling',
-            'claude-content-rules'
-        ],
-        validation: {
-            strict: true,
-            required: ['processedRequest'],
-            optional: ['standardizedRequest', 'conversionResponse']
-        },
-        timeout: 5000,
-        retry: {
-            maxRetries: 2,
-            retryDelay: 500,
-            exponentialBackoff: false,
-            retryableErrors: ['format', 'structure']
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: false,
-            performanceSampling: 0.1,
-            customMetrics: ['claude-response', 'content-blocks', 'token-usage']
-        }
-    },
-    'responses-output': {
-        id: 'responses-output',
-        type: 'output',
-        name: 'OpenAI Responses Output Node',
-        description: 'Convert processed data to Responses format',
-        inputFormat: 'processed-chat',
-        outputFormat: 'openai-responses',
-        rules: [
-            'responses-response-rule',
-            'responses-formatting-rule',
-            'responses-error-handling',
-            'responses-modal-rules'
-        ],
-        validation: {
-            strict: true,
-            required: ['processedRequest'],
-            optional: ['standardizedRequest', 'conversionResponse']
-        },
-        timeout: 5000,
-        retry: {
-            maxRetries: 2,
-            retryDelay: 500,
-            exponentialBackoff: false,
-            retryableErrors: ['format', 'structure']
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: false,
-            performanceSampling: 0.1,
-            customMetrics: ['responses-format', 'modal-types', 'usage-stats']
-        }
-    }
-};
-/**
- * 默认流水线配置
- */
-export const DEFAULT_PIPELINE_CONFIGS = {
-    // ====================
-    // 标准流水线
-    // ====================
-    'openai-chat-standard': {
-        id: 'openai-chat-standard',
-        name: 'OpenAI Chat Standard Pipeline',
-        description: 'Standard pipeline for OpenAI Chat completions',
-        nodes: [
-            DEFAULT_NODE_CONFIGS['chat-input'],
-            DEFAULT_NODE_CONFIGS['chat-process'],
-            DEFAULT_NODE_CONFIGS['openai-output']
-        ],
-        mode: 'standard',
-        timeout: 60000,
-        retry: {
-            maxRetries: 1,
-            retryDelay: 1000,
-            exponentialBackoff: true,
-            retryableErrors: ['timeout', 'network', 'temporary']
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: false,
-            performanceSampling: 0.1,
-            customMetrics: ['pipeline-performance', 'end-to-end-latency']
-        },
-        options: {
-            features: ['tool-calls', 'streaming', 'function-calling', 'parallel-processing'],
-            optimizations: ['input-validation', 'output-caching', 'error-recovery']
-        }
-    },
-    'anthropic-standard': {
-        id: 'anthropic-standard',
-        name: 'Anthropic Standard Pipeline',
-        description: 'Standard pipeline for Anthropic Claude requests',
-        nodes: [
-            DEFAULT_NODE_CONFIGS['anthropic-input'],
-            DEFAULT_NODE_CONFIGS['chat-process'],
-            DEFAULT_NODE_CONFIGS['anthropic-output']
-        ],
-        mode: 'standard',
-        timeout: 60000,
-        retry: {
-            maxRetries: 1,
-            retryDelay: 1000,
-            exponentialBackoff: true,
-            retryableErrors: ['timeout', 'network', 'temporary']
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: false,
-            performanceSampling: 0.1,
-            customMetrics: ['claude-performance', 'context-window-usage']
-        },
-        options: {
-            features: ['tool-use', 'streaming', 'claude-formatting', 'context-management'],
-            optimizations: ['claude-context', 'tool-optimization', 'format-normalization']
-        }
-    },
-    'responses-standard': {
-        id: 'responses-standard',
-        name: 'OpenAI Responses Standard Pipeline',
-        description: 'Standard pipeline for OpenAI Responses requests',
-        nodes: [
-            DEFAULT_NODE_CONFIGS['responses-input'],
-            DEFAULT_NODE_CONFIGS['chat-process'],
-            DEFAULT_NODE_CONFIGS['responses-output']
-        ],
-        mode: 'standard',
-        timeout: 60000,
-        retry: {
-            maxRetries: 1,
-            retryDelay: 1000,
-            exponentialBackoff: true,
-            retryableErrors: ['timeout', 'network', 'temporary']
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: false,
-            performanceSampling: 0.1,
-            customMetrics: ['responses-performance', 'modal-handling']
-        },
-        options: {
-            features: ['modal-types', 'tool-integration', 'response-formatting'],
-            optimizations: ['modal-optimization', 'format-handling', 'error-mapping']
-        }
-    },
-    // ====================
-    // Passthrough 流水线
-    // ====================
-    'passthrough': {
-        id: 'passthrough',
-        name: 'Passthrough Pipeline',
-        description: 'Direct passthrough pipeline for format-compatible requests',
-        nodes: [DEFAULT_NODE_CONFIGS['passthrough-process']],
-        mode: 'passthrough',
-        timeout: 5000,
-        retry: {
-            maxRetries: 0,
-            retryDelay: 0,
-            exponentialBackoff: false,
-            retryableErrors: []
-        },
-        monitoring: {
-            enabled: true,
-            detailedLogging: false,
-            performanceSampling: 0.05,
-            customMetrics: ['passthrough-performance']
-        },
-        options: {
-            condition: 'same-format',
-            fallback: 'standard',
-            zeroLatency: true
-        }
-    }
-};
-/**
- * 端点到流水线的默认映射
- */
-export const DEFAULT_ENDPOINT_MAPPINGS = {
-    '/v1/chat/completions': 'openai-chat-standard',
-    '/v1/messages': 'anthropic-standard',
-    '/v1/responses': 'responses-standard',
-    '/v1/completions': 'openai-chat-standard', // Legacy support
-    '/chat/completions': 'openai-chat-standard', // Alternative path
-    '/messages': 'anthropic-standard', // Alternative path
-    '/responses': 'responses-standard' // Alternative path
-};
-/**
- * JSON-schema 驱动的默认流水线配置
- */
-export const DEFAULT_PIPELINE_DOCUMENT = {
-    pipelines: [
-        {
-            id: 'pipeline-openai-chat',
-            name: 'OpenAI Chat Pipeline',
-            entryEndpoints: ['/v1/chat/completions', '/chat/completions', '/v1/completions'],
-            streaming: 'always',
-            nodes: [
-                { id: 'chat-sse-input', kind: 'sse-input', implementation: 'sse-input' },
-                { id: 'chat-input', kind: 'input', implementation: 'chat-input' },
-                { id: 'chat-process-node', kind: 'process', implementation: 'chat-process' },
-                { id: 'chat-openai-output', kind: 'output', implementation: 'openai-output' },
-                { id: 'chat-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-anthropic',
-            name: 'Anthropic Messages Pipeline',
-            entryEndpoints: ['/v1/messages', '/messages'],
-            streaming: 'always',
-            nodes: [
-                { id: 'anthropic-sse-input', kind: 'sse-input', implementation: 'sse-input' },
-                { id: 'anthropic-input', kind: 'input', implementation: 'anthropic-input' },
-                { id: 'anthropic-process', kind: 'process', implementation: 'chat-process' },
-                { id: 'anthropic-output', kind: 'output', implementation: 'anthropic-output' },
-                { id: 'anthropic-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-responses',
-            name: 'OpenAI Responses Pipeline',
-            entryEndpoints: ['/v1/responses', '/responses'],
-            streaming: 'always',
-            nodes: [
-                { id: 'responses-sse-input', kind: 'sse-input', implementation: 'sse-input' },
-                { id: 'responses-input', kind: 'input', implementation: 'responses-input' },
-                { id: 'responses-process', kind: 'process', implementation: 'chat-process' },
-                { id: 'responses-output', kind: 'output', implementation: 'responses-output' },
-                { id: 'responses-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        // Chat providers (openai-compatible) reuse the default response pipeline above.
-        {
-            id: 'pipeline-openai-chat-response',
-            name: 'OpenAI Chat Response Pipeline',
-            entryEndpoints: ['/v1/chat/completions#response', '/chat/completions#response', '/v1/completions#response'],
-            streaming: 'always',
-            nodes: [
-                { id: 'openai-response-input', kind: 'input', implementation: 'openai-response-input' },
-                { id: 'openai-response-process', kind: 'process', implementation: 'response-process' },
-                { id: 'openai-response-output', kind: 'output', implementation: 'openai-output' },
-                { id: 'openai-response-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-anthropic-response',
-            name: 'Anthropic Messages Response Pipeline',
-            entryEndpoints: ['/v1/messages#response', '/messages#response'],
-            streaming: 'always',
-            nodes: [
-                { id: 'anthropic-response-input', kind: 'input', implementation: 'anthropic-response-input' },
-                { id: 'anthropic-response-process', kind: 'process', implementation: 'response-process' },
-                { id: 'anthropic-response-output', kind: 'output', implementation: 'anthropic-output' },
-                { id: 'anthropic-response-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-responses-response',
-            name: 'OpenAI Responses Response Pipeline',
-            entryEndpoints: ['/v1/responses#response', '/responses#response'],
-            streaming: 'always',
-            nodes: [
-                { id: 'responses-response-input', kind: 'input', implementation: 'responses-response-input' },
-                { id: 'responses-response-process', kind: 'process', implementation: 'response-process' },
-                { id: 'responses-response-output', kind: 'output', implementation: 'responses-output' },
-                { id: 'responses-response-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-responses-openai-chat-response',
-            name: 'OpenAI Responses Response Pipeline (Chat Provider)',
-            entryEndpoints: ['/v1/responses#response', '/responses#response'],
-            providerProtocols: ['openai'],
-            streaming: 'always',
-            nodes: [
-                { id: 'responses-openai-response-input', kind: 'input', implementation: 'openai-response-input' },
-                { id: 'responses-openai-response-process', kind: 'process', implementation: 'response-process' },
-                { id: 'responses-openai-response-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-lmstudio-chat',
-            name: 'LM Studio Chat Pipeline',
-            entryEndpoints: ['/v1/chat/completions'],
-            providerProtocols: ['lmstudio'],
-            streaming: 'always',
-            nodes: [
-                { id: 'lmstudio-chat-input', kind: 'input', implementation: 'chat-input' },
-                { id: 'lmstudio-chat-process', kind: 'process', implementation: 'chat-process' },
-                { id: 'lmstudio-chat-output', kind: 'output', implementation: 'openai-output' },
-                { id: 'lmstudio-chat-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-openai-chat-inbound',
-            stage: 'inbound',
-            name: 'OpenAI Chat Inbound',
-            entryEndpoints: ['/v1/chat/completions', '/chat/completions', '/v1/completions'],
-            streaming: 'never',
-            nodes: [
-                { id: 'chat-sse-input', kind: 'sse-input', implementation: 'sse-input' },
-                { id: 'chat-input', kind: 'input', implementation: 'chat-input' }
-            ]
-        },
-        {
-            id: 'pipeline-openai-chat-outbound',
-            stage: 'outbound',
-            name: 'OpenAI Chat Outbound',
-            entryEndpoints: ['/v1/chat/completions', '/chat/completions', '/v1/completions'],
-            providerProtocols: ['openai-chat'],
-            processMode: 'chat',
-            streaming: 'never',
-            nodes: [
-                { id: 'chat-process-node', kind: 'process', implementation: 'chat-process' },
-                { id: 'chat-openai-output', kind: 'output', implementation: 'openai-output' },
-                { id: 'chat-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-anthropic-inbound',
-            stage: 'inbound',
-            name: 'Anthropic Messages Inbound',
-            entryEndpoints: ['/v1/messages', '/messages'],
-            streaming: 'never',
-            nodes: [
-                { id: 'anthropic-sse-input', kind: 'sse-input', implementation: 'sse-input' },
-                { id: 'anthropic-input', kind: 'input', implementation: 'anthropic-input' }
-            ]
-        },
-        {
-            id: 'pipeline-anthropic-outbound',
-            stage: 'outbound',
-            name: 'Anthropic Messages Outbound',
-            entryEndpoints: ['/v1/messages', '/messages'],
-            providerProtocols: ['anthropic-messages'],
-            processMode: 'chat',
-            streaming: 'never',
-            nodes: [
-                { id: 'anthropic-process', kind: 'process', implementation: 'chat-process' },
-                { id: 'anthropic-output', kind: 'output', implementation: 'anthropic-output' },
-                { id: 'anthropic-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-responses-inbound',
-            stage: 'inbound',
-            name: 'OpenAI Responses Inbound',
-            entryEndpoints: ['/v1/responses', '/responses'],
-            streaming: 'always',
-            nodes: [
-                { id: 'responses-sse-input', kind: 'sse-input', implementation: 'sse-input' },
-                { id: 'responses-input', kind: 'input', implementation: 'responses-input' }
-            ]
-        },
-        {
-            id: 'pipeline-responses-outbound',
-            stage: 'outbound',
-            name: 'OpenAI Responses Outbound',
-            entryEndpoints: ['/v1/responses', '/responses'],
-            providerProtocols: ['openai-responses'],
-            processMode: 'passthrough',
-            mode: 'passthrough',
-            streaming: 'always',
-            nodes: [
-                { id: 'responses-process', kind: 'process', implementation: 'passthrough-process' },
-                { id: 'responses-output', kind: 'output', implementation: 'responses-output' },
-                { id: 'responses-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-responses-openai-chat-outbound',
-            stage: 'outbound',
-            name: 'Responses → OpenAI Chat Outbound',
-            entryEndpoints: ['/v1/responses', '/responses'],
-            providerProtocols: ['openai-chat'],
-            processMode: 'chat',
-            streaming: 'always',
-            nodes: [
-                { id: 'responses-openai-process', kind: 'process', implementation: 'chat-process' },
-                { id: 'responses-openai-output', kind: 'output', implementation: 'openai-output' },
-                { id: 'responses-openai-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-responses-openai-chat-passthrough-outbound',
-            stage: 'outbound',
-            name: 'Responses → OpenAI Chat Outbound (Passthrough)',
-            entryEndpoints: ['/v1/responses', '/responses'],
-            providerProtocols: ['openai-chat'],
-            processMode: 'passthrough',
-            mode: 'passthrough',
-            streaming: 'never',
-            nodes: [
-                { id: 'responses-openai-process', kind: 'process', implementation: 'passthrough-process' },
-                { id: 'responses-openai-output', kind: 'output', implementation: 'openai-output' },
-                { id: 'responses-openai-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-openai-chat-response-inbound',
-            stage: 'inbound',
-            name: 'OpenAI Chat Provider Response Inbound',
-            entryEndpoints: ['/v1/chat/completions#response', '/chat/completions#response', '/v1/completions#response'],
-            streaming: 'always',
-            nodes: [
-                { id: 'openai-response-input', kind: 'input', implementation: 'openai-response-input' }
-            ]
-        },
-        {
-            id: 'pipeline-openai-chat-response-outbound',
-            stage: 'outbound',
-            name: 'OpenAI Chat Provider Response Outbound',
-            entryEndpoints: ['/v1/chat/completions#response', '/chat/completions#response', '/v1/completions#response'],
-            providerProtocols: ['openai-chat'],
-            streaming: 'always',
-            nodes: [
-                { id: 'openai-response-process', kind: 'process', implementation: 'response-process' },
-                { id: 'openai-response-output', kind: 'output', implementation: 'openai-output' },
-                { id: 'openai-response-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-anthropic-response-inbound',
-            stage: 'inbound',
-            name: 'Anthropic Response Inbound',
-            entryEndpoints: ['/v1/messages#response', '/messages#response'],
-            streaming: 'always',
-            nodes: [
-                { id: 'anthropic-response-input', kind: 'input', implementation: 'anthropic-response-input' }
-            ]
-        },
-        {
-            id: 'pipeline-anthropic-response-outbound',
-            stage: 'outbound',
-            name: 'Anthropic Response Outbound',
-            entryEndpoints: ['/v1/messages#response', '/messages#response'],
-            providerProtocols: ['anthropic-messages'],
-            streaming: 'always',
-            nodes: [
-                { id: 'anthropic-response-process', kind: 'process', implementation: 'response-process' },
-                { id: 'anthropic-response-output', kind: 'output', implementation: 'anthropic-output' },
-                { id: 'anthropic-response-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-responses-response-inbound',
-            stage: 'inbound',
-            name: 'OpenAI Responses Provider Response Inbound',
-            entryEndpoints: ['/v1/responses#response', '/responses#response'],
-            streaming: 'always',
-            nodes: [
-                { id: 'responses-response-input', kind: 'input', implementation: 'responses-response-input' }
-            ]
-        },
-        {
-            id: 'pipeline-responses-response-outbound',
-            stage: 'outbound',
-            name: 'OpenAI Responses Provider Response Outbound',
-            entryEndpoints: ['/v1/responses#response', '/responses#response'],
-            providerProtocols: ['openai-responses'],
-            processMode: 'passthrough',
-            streaming: 'always',
-            nodes: [
-                { id: 'responses-response-sse-pass', kind: 'process', implementation: 'sse-passthrough' },
-                { id: 'responses-response-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-responses-response-passthrough-outbound',
-            stage: 'outbound',
-            name: 'OpenAI Responses Provider Response Outbound (Passthrough)',
-            entryEndpoints: ['/v1/responses#response', '/responses#response'],
-            providerProtocols: ['openai-responses'],
-            processMode: 'chat',
-            streaming: 'never',
-            nodes: [
-                { id: 'responses-response-process', kind: 'process', implementation: 'response-process' },
-                { id: 'responses-response-output', kind: 'output', implementation: 'responses-output' },
-                { id: 'responses-response-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-responses-openai-chat-response-inbound',
-            stage: 'inbound',
-            name: 'Responses → OpenAI Chat Provider Response Inbound',
-            entryEndpoints: ['/v1/responses#response', '/responses#response'],
-            streaming: 'never',
-            nodes: [
-                { id: 'responses-openai-response-input', kind: 'input', implementation: 'openai-response-input' }
-            ]
-        },
-        {
-            id: 'pipeline-responses-openai-chat-response-outbound',
-            stage: 'outbound',
-            name: 'Responses → OpenAI Chat Provider Response Outbound',
-            entryEndpoints: ['/v1/responses#response', '/responses#response'],
-            providerProtocols: ['openai'],
-            processMode: 'passthrough',
-            streaming: 'never',
-            nodes: [
-                { id: 'responses-openai-response-sse-pass', kind: 'process', implementation: 'sse-passthrough' },
-                { id: 'responses-openai-response-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-responses-openai-chat-response-passthrough-outbound',
-            stage: 'outbound',
-            name: 'Responses → OpenAI Chat Provider Response Outbound (Passthrough)',
-            entryEndpoints: ['/v1/responses#response', '/responses#response'],
-            providerProtocols: ['openai'],
-            processMode: 'passthrough',
-            mode: 'passthrough',
-            streaming: 'auto',
-            nodes: [
-                { id: 'responses-openai-response-sse-pass', kind: 'process', implementation: 'sse-passthrough' },
-                { id: 'responses-openai-response-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        },
-        {
-            id: 'pipeline-lmstudio-chat-inbound',
-            stage: 'inbound',
-            name: 'LM Studio Chat Inbound',
-            entryEndpoints: ['/v1/chat/completions'],
-            streaming: 'auto',
-            nodes: [
-                { id: 'lmstudio-chat-input', kind: 'input', implementation: 'chat-input' }
-            ]
-        },
-        {
-            id: 'pipeline-lmstudio-chat-outbound',
-            stage: 'outbound',
-            name: 'LM Studio Chat Outbound',
-            entryEndpoints: ['/v1/chat/completions'],
-            providerProtocols: ['lmstudio'],
-            streaming: 'auto',
-            nodes: [
-                { id: 'lmstudio-chat-compat', kind: 'process', implementation: 'compatibility-process',
-                    options: {
-                        compatibility: {
-                            profile: 'lmstudio',
-                            providerMatch: ['lmstudio'],
-                            protocolMatch: ['lmstudio', 'openai']
-                        }
-                    }
-                },
-                { id: 'lmstudio-chat-process', kind: 'process', implementation: 'chat-process' },
-                { id: 'lmstudio-chat-output', kind: 'output', implementation: 'openai-output' },
-                { id: 'lmstudio-chat-sse-output', kind: 'sse-output', implementation: 'sse-output' }
-            ]
-        }
-    ]
-};
-/**
- * 获取默认节点配置
- *
- * @param nodeId 节点ID
- * @returns 节点配置
- */
-export function getDefaultNodeConfig(nodeId) {
-    return DEFAULT_NODE_CONFIGS[nodeId];
-}
-/**
- * 获取默认流水线配置
- *
- * @param pipelineId 流水线ID
- * @returns 流水线配置
- */
-export function getDefaultPipelineConfig(pipelineId) {
-    return DEFAULT_PIPELINE_CONFIGS[pipelineId];
-}
-/**
- * 根据端点获取默认流水线配置
- *
- * @param endpoint 端点路径
- * @returns 流水线配置
- */
-export function getAllDefaultConfigs() {
-    return {
-        nodes: DEFAULT_NODE_CONFIGS,
-        pipelines: DEFAULT_PIPELINE_CONFIGS,
-        endpointMappings: DEFAULT_ENDPOINT_MAPPINGS
-    };
-}