@jsonstudio/llms 0.4.2

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

@@ -0,0 +1,1083 @@
+/**
+ * 默认配置文件
+ *
+ * 提供开箱即用的默认配置，无需用户配置即可使用
+ */
+/**
+ * 默认节点配置
+ */
+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'],
+            processMode: 'chat',
+            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: 'passthrough-process' },
+                { id: 'responses-output', kind: 'output', implementation: 'responses-output' },
+                { id: 'responses-sse-output', kind: 'sse-output', implementation: 'sse-output' }
+            ]
+        },
+        {
+            id: 'pipeline-responses-passthrough',
+            name: 'OpenAI Responses Passthrough Pipeline',
+            entryEndpoints: ['/v1/responses', '/responses'],
+            providerProtocols: ['openai-responses'],
+            processMode: 'passthrough',
+            mode: 'passthrough',
+            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' }
+            ]
+        },
+        {
+            id: 'pipeline-responses-openai-chat',
+            name: 'OpenAI Responses Pipeline (Chat Provider)',
+            entryEndpoints: ['/v1/responses', '/responses'],
+            providerProtocols: ['openai'],
+            processMode: 'chat',
+            streaming: 'always',
+            nodes: [
+                { id: 'responses-openai-sse-input', kind: 'sse-input', implementation: 'sse-input' },
+                { id: 'responses-openai-input', kind: 'input', implementation: 'responses-input' },
+                { 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',
+            name: 'OpenAI Responses Pipeline (Chat Provider Passthrough)',
+            entryEndpoints: ['/v1/responses', '/responses'],
+            providerProtocols: ['openai'],
+            processMode: 'passthrough',
+            mode: 'passthrough',
+            streaming: 'never',
+            nodes: [
+                { id: 'responses-openai-sse-input', kind: 'sse-input', implementation: 'sse-input' },
+                { id: 'responses-openai-input', kind: 'input', implementation: 'responses-input' },
+                { 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-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'],
+            processMode: 'chat',
+            streaming: 'always',
+            nodes: [
+                { id: 'responses-response-input', kind: 'input', implementation: 'responses-response-input' },
+                { 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',
+            name: 'OpenAI Responses Response Pipeline (Passthrough)',
+            entryEndpoints: ['/v1/responses#response', '/responses#response'],
+            processMode: 'passthrough',
+            mode: 'passthrough',
+            streaming: 'never',
+            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'],
+            processMode: 'chat',
+            streaming: 'never',
+            nodes: [
+                { id: 'responses-openai-response-input', kind: 'input', implementation: 'openai-response-input' },
+                { 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',
+            name: 'OpenAI Responses Response Pipeline (Chat Provider Passthrough)',
+            entryEndpoints: ['/v1/responses#response', '/responses#response'],
+            providerProtocols: ['openai'],
+            processMode: 'passthrough',
+            mode: 'passthrough',
+            streaming: 'auto',
+            nodes: [
+                { id: 'responses-openai-response-input', kind: 'input', implementation: 'openai-response-input' },
+                { 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',
+            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
+    };
+}