@jsonstudio/rcc 0.85.9

package/dist/modules/pipeline/modules/provider/v2/core/chat-http-provider.js

@@ -0,0 +1,856 @@
+/**
+ * OpenAI Standard - 统一OpenAI标准实现
+ *
+ * 提供统一的OpenAI API标准兼容实现，支持多种OpenAI兼容服务
+ */
+import { BaseProvider } from './base-provider.js';
+import { HttpClient } from '../utils/http-client.js';
+import { DynamicProfileLoader, ServiceProfileValidator } from '../config/service-profiles.js';
+import { ApiKeyAuthProvider } from '../auth/apikey-auth.js';
+import { OAuthAuthProvider } from '../auth/oauth-auth.js';
+import { TokenFileAuthProvider } from '../auth/tokenfile-auth.js';
+import { ensureValidOAuthToken, handleUpstreamInvalidOAuthToken } from '../auth/oauth-lifecycle.js';
+import { createHookSystemIntegration } from '../hooks/hooks-integration.js';
+import { writeProviderSnapshot } from '../utils/snapshot-writer.js';
+import { ProviderComposite } from '../composite/provider-composite.js';
+import { attachProviderRuntimeMetadata } from './provider-runtime-metadata.js';
+/**
+ * Chat 协议 Provider 实现
+ *
+ * 统一处理所有 OpenAI Chat 兼容的服务，通过配置区分不同服务类型
+ */
+export class ChatHttpProvider extends BaseProvider {
+    type = 'openai-standard';
+    authProvider = null;
+    httpClient;
+    serviceProfile;
+    hookSystemIntegration; // Hook系统集成实例
+    injectedConfig = null;
+    constructor(config, dependencies) {
+        super(config, dependencies);
+        // 获取服务配置档案
+        this.serviceProfile = this.getServiceProfile();
+        // 验证配置
+        this.validateConfig();
+        // 创建HTTP客户端
+        this.createHttpClient();
+        // 创建认证提供者
+        this.authProvider = this.createAuthProvider();
+        // 初始化Hook系统集成
+        this.initializeHookSystem();
+    }
+    /**
+     * 确保认证提供者完成初始化（避免 ApiKeyAuthProvider 未初始化导致的报错）
+     */
+    async onInitialize() {
+        // 先调用父类可能的初始化逻辑（当前为空实现，保留可读性）
+        try {
+            if (this.authProvider && typeof this.authProvider.initialize === 'function') {
+                await this.authProvider.initialize();
+                try {
+                    const cfgAny = this.config ?? {};
+                    const auth = cfgAny?.config?.auth;
+                    const extensions = (cfgAny.config && typeof cfgAny.config.extensions === 'object')
+                        ? cfgAny.config.extensions
+                        : {};
+                    if (auth && this.normalizeAuthMode(auth.type) === 'oauth') {
+                        const oauthProviderId = this.ensureOAuthProviderId(auth, extensions);
+                        const forceReauthorize = false; // 初始化阶段：读取→必要时刷新；不强制重授权
+                        const tokenFileHint = auth?.tokenFile || '(default)';
+                        // 明确打印初始化 OAuth 日志（不依赖 Hook 系统）
+                        console.log(`[OAuth] [init] provider=${oauthProviderId} type=${auth.type} tokenFile=${tokenFileHint} forceReauth=${forceReauthorize}`);
+                        this.dependencies.logger?.logModule?.(this.id, 'oauth-init-start', {
+                            providerType: oauthProviderId,
+                            tokenFile: tokenFileHint,
+                            forceReauthorize
+                        });
+                        try {
+                            await ensureValidOAuthToken(oauthProviderId, auth, {
+                                forceReacquireIfRefreshFails: true,
+                                openBrowser: true,
+                                forceReauthorize
+                            });
+                            console.log('[OAuth] [init] ensureValid OK');
+                            // If we used TokenFileAuthProvider, re-initialize to pick up freshly created token file
+                            try {
+                                if (this.authProvider?.constructor?.name === 'TokenFileAuthProvider') {
+                                    await this.authProvider.initialize();
+                                }
+                                else {
+                                    this.authProvider?.getOAuthClient?.()?.loadToken?.();
+                                }
+                            }
+                            catch { /* ignore */ }
+                            this.dependencies.logger?.logModule?.(this.id, 'oauth-init-success', {
+                                providerType: oauthProviderId
+                            });
+                        }
+                        catch (e) {
+                            const msg = e?.message ? String(e.message) : String(e || 'unknown error');
+                            console.error(`[OAuth] [init] ensureValid ERROR: ${msg}`);
+                            this.dependencies.logger?.logModule?.(this.id, 'oauth-init-error', {
+                                providerType: this.providerType,
+                                error: msg
+                            });
+                            throw e;
+                        }
+                        // 确保 authProvider 内部 OAuth 客户端拿到最新 token
+                        try {
+                            this.authProvider?.getOAuthClient?.()?.loadToken?.();
+                        }
+                        catch { /* ignore */ }
+                    }
+                    else if (typeof this.authProvider.validateCredentials === 'function') {
+                        // apikey 路径：可选的快速校验（不阻塞主流程）
+                        try {
+                            await this.authProvider.validateCredentials();
+                        }
+                        catch { /* ignore */ }
+                    }
+                }
+                catch { /* ignore */ }
+            }
+            // 初始化新的Hook系统集成
+            await this.hookSystemIntegration.initialize();
+            // 设置调试配置（向后兼容）
+            this.configureHookDebugging();
+            this.dependencies.logger?.logModule(this.id, 'provider-hook-system-initialized', {
+                providerType: this.providerType,
+                integrationEnabled: true
+            });
+        }
+        catch (error) {
+            // 暴露问题，快速失败，便于定位凭证问题
+            this.dependencies.logger?.logModule(this.id, 'provider-initialization-error', {
+                providerType: this.providerType,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    // V2 注入（V1 不调用）
+    setConfig(cfg) {
+        try {
+            if (!cfg || typeof cfg !== 'object')
+                return;
+            this.injectedConfig = cfg;
+            const c = this.config || {};
+            c.config = { ...(c.config || {}), ...cfg };
+            // 替换 serviceProfile 以反映新的 providerType/baseUrl
+            try {
+                this.serviceProfile = this.getServiceProfile();
+            }
+            catch { /* ignore */ }
+        }
+        catch { /* ignore */ }
+    }
+    getConfig() {
+        return this.injectedConfig ?? this.config?.config ?? null;
+    }
+    /**
+     * 初始化Hook系统集成
+     */
+    initializeHookSystem() {
+        try {
+            this.hookSystemIntegration = createHookSystemIntegration(this.dependencies, this.id, {
+                enabled: true,
+                debugMode: true, // Provider v2默认启用调试模式
+                snapshotEnabled: true,
+                migrationMode: true // 迁移现有Hooks
+            });
+            this.dependencies.logger?.logModule(this.id, 'hook-system-integration-created', {
+                providerId: this.id
+            });
+        }
+        catch (error) {
+            this.dependencies.logger?.logModule(this.id, 'hook-system-integration-failed', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            // 创建兼容的空实现，避免系统崩溃
+            this.hookSystemIntegration = {
+                getBidirectionalHookManager: () => ({
+                    registerHook: () => { },
+                    unregisterHook: () => { },
+                    executeHookChain: async () => ({ data: {}, metrics: {} }),
+                    setDebugConfig: () => { }
+                }),
+                setDebugConfig: () => { }
+            };
+        }
+    }
+    /**
+     * 配置Hook调试（保持向后兼容）
+     */
+    configureHookDebugging() {
+        try {
+            // 设置调试配置（使用统一Hook系统的阶段字符串）
+            const debugConfig = {
+                enabled: true,
+                level: 'verbose',
+                maxDataSize: 1024 * 64, // 64KB 单次输出上限，避免过大控制台噪声
+                stages: [
+                    'request_preprocessing',
+                    'request_validation',
+                    'authentication',
+                    'http_request',
+                    'http_response',
+                    'response_validation',
+                    'response_postprocessing',
+                    'error_handling'
+                ],
+                outputFormat: 'structured',
+                outputTargets: ['console'],
+                performanceThresholds: {
+                    maxHookExecutionTime: 500, // 单个Hook 500ms告警
+                    maxTotalExecutionTime: 5000, // 阶段总时长 5s 告警
+                    maxDataSize: 1024 * 256 // 256KB 数据告警
+                }
+            };
+            this.hookSystemIntegration.setDebugConfig(debugConfig);
+            this.dependencies.logger?.logModule(this.id, 'provider-debug-hooks-configured', {
+                providerType: this.providerType
+            });
+        }
+        catch (error) {
+            this.dependencies.logger?.logModule(this.id, 'provider-debug-hooks-error', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    getServiceProfile() {
+        const cfg = this.config?.config || {};
+        // Feature flag: 优先/强制使用 config-core 输出的 provider 行为字段
+        const useConfigCoreEnv = String(process.env.ROUTECODEX_USE_CONFIG_CORE_PROVIDER_DEFAULTS ||
+            process.env.RCC_USE_CONFIG_CORE_PROVIDER_DEFAULTS ||
+            '').trim().toLowerCase();
+        const forceConfigCoreDefaults = useConfigCoreEnv === '1' ||
+            useConfigCoreEnv === 'true' ||
+            useConfigCoreEnv === 'yes' ||
+            useConfigCoreEnv === 'on';
+        const baseFromCfg = (cfg.baseUrl || cfg.overrides?.baseUrl || '').trim();
+        const endpointFromCfg = (cfg.overrides?.endpoint || cfg.endpoint || '').trim();
+        const defaultModelFromCfg = (cfg.overrides?.defaultModel || cfg.defaultModel || '').trim();
+        const timeoutFromCfg = cfg.overrides?.timeout ?? cfg.timeout;
+        const maxRetriesFromCfg = cfg.overrides?.maxRetries ?? cfg.maxRetries;
+        const headersFromCfg = (cfg.overrides?.headers || cfg.headers);
+        const authCapsFromCfg = cfg.authCapabilities;
+        const hasConfigCoreProfile = !!baseFromCfg ||
+            !!endpointFromCfg ||
+            !!defaultModelFromCfg ||
+            typeof timeoutFromCfg === 'number' ||
+            typeof maxRetriesFromCfg === 'number' ||
+            !!authCapsFromCfg ||
+            !!headersFromCfg;
+        // 先从 service-profiles 取出基础 profile（用于补全缺失字段/校验）
+        const baseProfile = DynamicProfileLoader.buildServiceProfile(this.providerType);
+        // 如果 config-core 已提供字段，或强制要求使用 config-core，则以 config-core 为主
+        if (hasConfigCoreProfile || forceConfigCoreDefaults) {
+            if (forceConfigCoreDefaults) {
+                // 严格模式下，关键字段缺失直接 Fail Fast
+                if (!baseFromCfg) {
+                    throw new Error(`Provider config-core defaults missing baseUrl for providerType=${this.providerType}`);
+                }
+                if (!endpointFromCfg && !baseProfile?.defaultEndpoint) {
+                    throw new Error(`Provider config-core defaults missing endpoint for providerType=${this.providerType}`);
+                }
+            }
+            const defaultBaseUrl = baseFromCfg ||
+                baseProfile?.defaultBaseUrl ||
+                'https://api.openai.com/v1';
+            const defaultEndpoint = endpointFromCfg ||
+                baseProfile?.defaultEndpoint ||
+                '/chat/completions';
+            const defaultModel = (defaultModelFromCfg && defaultModelFromCfg.length > 0)
+                ? defaultModelFromCfg
+                : (baseProfile?.defaultModel ?? '');
+            const genericRequiredAuth = [];
+            const genericOptionalAuth = ['apikey', 'oauth'];
+            const requiredAuth = authCapsFromCfg?.required && authCapsFromCfg.required.length
+                ? authCapsFromCfg.required
+                : (baseProfile?.requiredAuth ?? genericRequiredAuth);
+            const optionalAuth = authCapsFromCfg?.optional && authCapsFromCfg.optional.length
+                ? authCapsFromCfg.optional
+                : (baseProfile?.optionalAuth ?? genericOptionalAuth);
+            const mergedHeaders = {
+                ...(baseProfile?.headers || {}),
+                ...(headersFromCfg || {})
+            };
+            const timeout = typeof timeoutFromCfg === 'number'
+                ? timeoutFromCfg
+                : (baseProfile?.timeout ?? 300000);
+            const maxRetries = typeof maxRetriesFromCfg === 'number'
+                ? maxRetriesFromCfg
+                : (baseProfile?.maxRetries ?? 3);
+            return {
+                defaultBaseUrl,
+                defaultEndpoint,
+                defaultModel,
+                requiredAuth,
+                optionalAuth,
+                headers: mergedHeaders,
+                timeout,
+                maxRetries,
+                hooks: baseProfile?.hooks,
+                features: baseProfile?.features,
+                extensions: {
+                    ...(baseProfile?.extensions || {}),
+                    // 透传 config-core 的协议信息，方便调试
+                    protocol: cfg.protocol || baseProfile?.extensions?.protocol
+                }
+            };
+        }
+        // 未提供 config-core provider 行为字段时，保持原有 service-profiles 行为
+        if (baseProfile) {
+            return baseProfile;
+        }
+        throw new Error(`Unknown providerType='${this.providerType}' (no service profile registered)`);
+    }
+    createAuthProvider() {
+        const auth = this.config.config.auth;
+        const cfgAny = this.config ?? {};
+        const extensions = (cfgAny.config && typeof cfgAny.config.extensions === 'object')
+            ? cfgAny.config.extensions
+            : {};
+        const authMode = this.normalizeAuthMode(auth.type);
+        const providerIdForAuth = authMode === 'oauth'
+            ? this.ensureOAuthProviderId(auth, extensions)
+            : this.providerType;
+        // 验证认证配置（按 providerIdForAuth 选择服务档案）
+        const validation = ServiceProfileValidator.validateServiceProfile(providerIdForAuth, authMode);
+        if (!validation.isValid) {
+            throw new Error(`Invalid auth configuration for ${providerIdForAuth}: ${validation.errors.join(', ')}`);
+        }
+        // 根据认证类型创建对应的认证提供者
+        if (authMode === 'apikey') {
+            return new ApiKeyAuthProvider(auth);
+        }
+        else if (authMode === 'oauth') {
+            // For providers like Qwen where public OAuth client may not be available,
+            // allow reading tokens produced by external login tools (CLIProxyAPI)
+            const useTokenFile = (providerIdForAuth === 'qwen' || providerIdForAuth === 'iflow') &&
+                !auth.clientId &&
+                !auth.tokenUrl &&
+                !auth.deviceCodeUrl;
+            if (useTokenFile) {
+                return new TokenFileAuthProvider(auth);
+            }
+            return new OAuthAuthProvider(auth, providerIdForAuth);
+        }
+        else {
+            throw new Error(`Unsupported auth type: ${auth.type}`);
+        }
+    }
+    createHttpClient() {
+        const profile = this.serviceProfile;
+        const effectiveBase = this.getEffectiveBaseUrl();
+        const envTimeout = Number(process.env.ROUTECODEX_PROVIDER_TIMEOUT_MS || process.env.RCC_PROVIDER_TIMEOUT_MS || NaN);
+        const effectiveTimeout = Number.isFinite(envTimeout) && envTimeout > 0
+            ? envTimeout
+            : (this.config.config.overrides?.timeout ?? profile.timeout ?? 300000);
+        const envRetries = Number(process.env.ROUTECODEX_PROVIDER_RETRIES || process.env.RCC_PROVIDER_RETRIES || NaN);
+        const effectiveRetries = Number.isFinite(envRetries) && envRetries >= 0
+            ? envRetries
+            : (this.config.config.overrides?.maxRetries ?? profile.maxRetries ?? 3);
+        const overrideHeaders = this.config.config?.overrides?.headers || this.config.config?.headers || undefined;
+        this.httpClient = new HttpClient({
+            baseUrl: effectiveBase,
+            timeout: effectiveTimeout,
+            maxRetries: effectiveRetries,
+            defaultHeaders: {
+                'Content-Type': 'application/json',
+                ...(profile.headers || {}),
+                ...(overrideHeaders || {}),
+            }
+        });
+    }
+    async preprocessRequest(request) {
+        const context = this.createProviderContext();
+        const runtimeMetadata = context.runtimeMetadata;
+        const ensureRuntimeMetadata = (payload) => {
+            if (!runtimeMetadata || !payload || typeof payload !== 'object')
+                return;
+            attachProviderRuntimeMetadata(payload, runtimeMetadata);
+        };
+        // 初始请求预处理
+        const runtime = this.getRuntimeProfile();
+        let processedRequest = { ...request };
+        ensureRuntimeMetadata(processedRequest);
+        // 记录入站原始模型，便于响应阶段还原（不影响上游请求体）
+        try {
+            const inboundModel = request?.model;
+            const entryEndpoint = request?.metadata?.entryEndpoint || request?.entryEndpoint;
+            const streamFlag = request?.metadata?.stream ?? request?.stream;
+            processedRequest.metadata = {
+                ...processedRequest.metadata,
+                ...(entryEndpoint ? { entryEndpoint } : {}),
+                ...(typeof streamFlag === 'boolean' ? { stream: !!streamFlag } : {}),
+                __origModel: inboundModel
+            };
+        }
+        catch { /* ignore */ }
+        // 流式开关：基础 Provider 统一移除入口层的 stream 标记，
+        // 具体协议（如 Responses/Anthropic）的真实流控由各自独立 Provider 处理
+        try {
+            // 统一：所有入口均移除 stream=true（Provider 始终走非流式），SSE 由上层合成
+            if (processedRequest.stream === true) {
+                delete processedRequest.stream;
+            }
+        }
+        catch { /* ignore */ }
+        // 获取Hook管理器（新的统一系统）
+        const hookManager = this.hookSystemIntegration.getBidirectionalHookManager();
+        // 🔍 Hook 1: 请求预处理阶段
+        const preprocessResult = await hookManager.executeHookChain('request_preprocessing', 'request', processedRequest, context);
+        processedRequest = preprocessResult.data;
+        ensureRuntimeMetadata(processedRequest);
+        // 🔍 Hook 2: 请求验证阶段
+        const validationResult = await hookManager.executeHookChain('request_validation', 'request', processedRequest, context);
+        processedRequest = validationResult.data;
+        ensureRuntimeMetadata(processedRequest);
+        // Provider 层不再修改工具 schema；统一入口在 llmswitch-core/兼容层
+        // 新增：ProviderComposite.compat.request（协议敏感；Fail Fast）
+        try {
+            const compatProfile = (runtime?.compatibilityProfile || '').toLowerCase();
+            const shouldRunCompat = compatProfile !== 'none';
+            if (shouldRunCompat) {
+                ensureRuntimeMetadata(processedRequest);
+                processedRequest = await ProviderComposite.applyRequest(processedRequest, {
+                    providerType: runtime?.providerType || this.providerType,
+                    dependencies: this.dependencies
+                });
+                ensureRuntimeMetadata(processedRequest);
+            }
+        }
+        catch (e) {
+            // 暴露问题，不兜底
+            this.dependencies.logger?.logModule?.(this.id, 'compat-request-error', {
+                error: e instanceof Error ? e.message : String(e)
+            });
+            throw e;
+        }
+        return processedRequest;
+    }
+    async postprocessResponse(response, context) {
+        const runtime = this.getRuntimeProfile();
+        // 流式短路：若上游仍返回 SSE，则统一包装为 __sse_responses，交由 HTTP 层原样透传
+        try {
+            const r = response;
+            if (r && typeof r === 'object') {
+                if (r.__sse_stream) {
+                    return { __sse_responses: r.__sse_stream };
+                }
+                if (r.data && typeof r.data === 'object' && r.data.__sse_stream) {
+                    return { __sse_responses: r.data.__sse_stream };
+                }
+            }
+        }
+        catch { /* ignore */ }
+        const processingTime = Date.now() - context.startTime;
+        let processedResponse = response;
+        // 获取Hook管理器（新的统一系统）
+        const hookManager = this.hookSystemIntegration.getBidirectionalHookManager();
+        // 🔍 Hook 3: HTTP响应阶段
+        const httpResponseResult = await hookManager.executeHookChain('http_response', 'response', processedResponse, context);
+        processedResponse = httpResponseResult.data;
+        // 🔍 Hook 4: 响应验证阶段
+        const validationResult = await hookManager.executeHookChain('response_validation', 'response', processedResponse, context);
+        processedResponse = validationResult.data;
+        // 🔍 Hook 5: 响应后处理阶段
+        const postprocessResult = await hookManager.executeHookChain('response_postprocessing', 'response', processedResponse, context);
+        processedResponse = postprocessResult.data;
+        // 新增：ProviderComposite.compat.response（在封装/模型名还原之前）
+        try {
+            const compatProfile = (runtime?.compatibilityProfile || '').toLowerCase();
+            const shouldRunCompat = compatProfile !== 'none';
+            if (shouldRunCompat) {
+                processedResponse = await ProviderComposite.applyResponse(processedResponse, undefined, {
+                    providerType: runtime?.providerType || this.providerType,
+                    dependencies: this.dependencies,
+                    runtime: context?.runtimeMetadata
+                });
+            }
+        }
+        catch (e) {
+            this.dependencies.logger?.logModule?.(this.id, 'compat-response-error', {
+                error: e instanceof Error ? e.message : String(e)
+            });
+            throw e;
+        }
+        return {
+            data: processedResponse.data || processedResponse,
+            status: processedResponse.status || response.status,
+            headers: processedResponse.headers || response.headers,
+            metadata: {
+                requestId: context.requestId,
+                processingTime,
+                providerType: this.providerType,
+                // 对外暴露的 model 统一为入站模型
+                model: context?.model || processedResponse.data?.model || response.data?.model,
+                usage: processedResponse.data?.usage || response.data?.usage,
+                hookMetrics: {
+                    httpResponse: httpResponseResult.metrics,
+                    validation: validationResult.metrics,
+                    postprocess: postprocessResult.metrics
+                }
+            }
+        };
+    }
+    async sendRequestInternal(request) {
+        // 仅传入 endpoint，让 HttpClient 按 baseUrl 进行拼接；避免 full URL 再次拼接导致 /https:/ 重复
+        const endpoint = this.getEffectiveEndpoint();
+        const headers = await this.buildRequestHeaders();
+        const context = this.createProviderContext();
+        const targetUrl = `${this.getEffectiveBaseUrl().replace(/\/$/, '')}/${endpoint.startsWith('/') ? endpoint.slice(1) : endpoint}`;
+        // 获取Hook管理器（新的统一系统）
+        const hookManager = this.hookSystemIntegration.getBidirectionalHookManager();
+        // 🔍 Hook 8: HTTP请求阶段
+        const httpRequestResult = await hookManager.executeHookChain('http_request', 'request', request, context);
+        const processedRequest = httpRequestResult.data;
+        // Flatten request body to standard OpenAI Chat JSON
+        let finalBody = (() => {
+            const r = processedRequest || {};
+            const dataObj = (r && typeof r === 'object' && 'data' in r && typeof r.data === 'object') ? r.data : r;
+            const body = { ...dataObj };
+            // Require model: 只接受虚拟路由器写入的模型，不再回退配置
+            const inboundModel = typeof body.model === 'string' ? body.model.trim() : '';
+            if (!inboundModel) {
+                throw new Error('provider-runtime-error: missing model from virtual router');
+            }
+            body.model = inboundModel;
+            // Resolve max_tokens according to priority:
+            // 1) request.max_tokens (number > 0) or request.maxTokens (camelCase)
+            // 2) provider overrides (config.config.overrides.maxTokens) if provided and > 0
+            // 3) default 8192
+            try {
+                const reqMt = Number(dataObj?.max_tokens ?? dataObj?.maxTokens ?? NaN);
+                const cfgMt = Number(this.config?.config?.overrides?.maxTokens ?? NaN);
+                const envMt = Number(process.env.ROUTECODEX_DEFAULT_MAX_TOKENS || process.env.RCC_DEFAULT_MAX_TOKENS || NaN);
+                const fallback = Number.isFinite(cfgMt) && cfgMt > 0
+                    ? cfgMt
+                    : (Number.isFinite(envMt) && envMt > 0 ? envMt : 8192);
+                const effective = Number.isFinite(reqMt) && reqMt > 0 ? reqMt : fallback;
+                // 写入 snake_case，兼容 OpenAI/Anthropic 端点
+                body.max_tokens = effective;
+                // 删除 camelCase 以避免上游拒绝
+                if ('maxTokens' in body)
+                    delete body.maxTokens;
+            }
+            catch { /* ignore max_tokens resolution errors */ }
+            // Remove metadata/envelope fields that upstream doesn't accept
+            try {
+                if ('metadata' in body) {
+                    delete body.metadata;
+                }
+            }
+            catch { /* ignore */ }
+            // 统一非流：强制移除 body.stream，以避免上游返回 SSE
+            try {
+                if (body && typeof body === 'object' && body.stream === true) {
+                    delete body.stream;
+                }
+            }
+            catch { /* ignore */ }
+            // Provider 不再按入口端点做流控或形状处理；上层已统一非流式
+            return body;
+        })();
+        const entryEndpoint = processedRequest?.metadata?.entryEndpoint;
+        // 快照：provider-request（默认开启，脱敏headers）
+        try {
+            await writeProviderSnapshot({
+                phase: 'provider-request',
+                requestId: context.requestId,
+                data: finalBody,
+                headers,
+                url: targetUrl,
+                entryEndpoint
+            });
+        }
+        catch { /* non-blocking */ }
+        // 发送HTTP请求（统一非流式）
+        let response;
+        try {
+            response = await this.httpClient.post(endpoint, finalBody, headers);
+            // 快照：provider-response
+            try {
+                await writeProviderSnapshot({
+                    phase: 'provider-response',
+                    requestId: context.requestId,
+                    data: response,
+                    headers,
+                    url: targetUrl,
+                    entryEndpoint
+                });
+            }
+            catch { /* non-blocking */ }
+        }
+        catch (error) {
+            // OAuth token 失效：尝试刷新/重获并重试一次
+            try {
+                const auth = this.config?.config?.auth;
+                if (auth && this.normalizeAuthMode(auth.type) === 'oauth') {
+                    const shouldRetry = await handleUpstreamInvalidOAuthToken(this.providerType, auth, error);
+                    if (shouldRetry) {
+                        const retryHeaders = await this.buildRequestHeaders();
+                        response = await this.httpClient.post(endpoint, finalBody, retryHeaders);
+                        try {
+                            await writeProviderSnapshot({
+                                phase: 'provider-response',
+                                requestId: context.requestId,
+                                data: response,
+                                headers: retryHeaders,
+                                url: targetUrl,
+                                entryEndpoint
+                            });
+                        }
+                        catch { /* non-blocking */ }
+                        return response;
+                    }
+                }
+            }
+            catch { /* ignore and fallthrough */ }
+            // 🔍 Hook 9: 错误处理阶段
+            const errorResult = await hookManager.executeHookChain('error_handling', 'error', { error, request: processedRequest, url: targetUrl, headers }, context);
+            // 如果Hook处理了错误，使用Hook的返回结果
+            if (errorResult.data && errorResult.data.error === false) {
+                return errorResult.data;
+            }
+            // 规范化错误：补充结构化字段，移除仅文本填充的旧做法
+            let normalized = error;
+            try {
+                // 提取状态码
+                const msg = typeof normalized?.message === 'string' ? normalized.message : String(normalized || '');
+                const m = msg.match(/HTTP\s+(\d{3})/i);
+                const parsedStatus = m ? parseInt(m[1], 10) : undefined;
+                const statusCode = Number.isFinite(normalized?.statusCode) ? Number(normalized.statusCode) : (Number.isFinite(normalized?.status) ? Number(normalized.status) : (parsedStatus || undefined));
+                if (statusCode && !Number.isNaN(statusCode)) {
+                    normalized.statusCode = statusCode;
+                    if (!normalized.status)
+                        normalized.status = statusCode;
+                    if (!normalized.code)
+                        normalized.code = `HTTP_${statusCode}`;
+                }
+                // 兼容 Manager 的 code 路径（response.data.error.code）
+                if (!normalized.response)
+                    normalized.response = {};
+                if (!normalized.response.data)
+                    normalized.response.data = {};
+                if (!normalized.response.data.error)
+                    normalized.response.data.error = {};
+                if (normalized.code && !normalized.response.data.error.code) {
+                    normalized.response.data.error.code = normalized.code;
+                }
+            }
+            catch { /* keep original */ }
+            // 快照：provider-error（结构化写入）
+            try {
+                await writeProviderSnapshot({
+                    phase: 'provider-error',
+                    requestId: context.requestId,
+                    data: {
+                        status: normalized?.statusCode ?? normalized?.status ?? null,
+                        code: normalized?.code ?? null,
+                        error: typeof normalized?.message === 'string' ? normalized.message : String(normalized || '')
+                    },
+                    headers,
+                    url: targetUrl,
+                    entryEndpoint
+                });
+            }
+            catch { /* non-blocking */ }
+            throw normalized;
+        }
+        // Provider 不处理工具修复/注入逻辑：统一收敛到 llmswitch-core 与兼容层
+        // 此处不做任何自动修复/重试，保持单次请求的幂等与可观测性
+        try { /* no-op */ }
+        catch { /* ignore */ }
+        return response;
+    }
+    async performHealthCheck(url) {
+        try {
+            const headers = await this.buildRequestHeaders();
+            const response = await this.httpClient.get(url, headers);
+            return response.status === 200 || response.status === 404;
+        }
+        catch {
+            return false;
+        }
+    }
+    // 私有方法
+    validateConfig() {
+        const profile = this.serviceProfile;
+        const auth = this.config.config.auth;
+        const authMode = this.normalizeAuthMode(auth.type);
+        // 验证认证类型
+        const supportedAuthTypes = [...profile.requiredAuth, ...profile.optionalAuth];
+        if (!supportedAuthTypes.includes(authMode)) {
+            throw new Error(`Auth type '${auth.type}' not supported for provider '${this.providerType}'. ` +
+                `Supported types: ${supportedAuthTypes.join(', ')}`);
+        }
+    }
+    buildRequestUrl() {
+        const baseUrl = this.getEffectiveBaseUrl();
+        const endpoint = this.getEffectiveEndpoint();
+        return `${baseUrl}${endpoint}`;
+    }
+    async buildRequestHeaders() {
+        const baseHeaders = {
+            'Content-Type': 'application/json'
+        };
+        // 服务特定头部
+        const serviceHeaders = this.serviceProfile.headers || {};
+        // 配置覆盖头部
+        const overrideHeaders = this.config.config.overrides?.headers || {};
+        const runtimeHeaders = this.getRuntimeProfile()?.headers || {};
+        // OAuth：请求前确保令牌有效（提前刷新）
+        try {
+            const cfgAny = this.config ?? {};
+            const auth = cfgAny?.config?.auth;
+            if (auth && this.normalizeAuthMode(auth.type) === 'oauth') {
+                const oauthProviderId = this.ensureOAuthProviderId(auth.type);
+                console.log('[OAuth] [headers] ensureValid start (openBrowser=true, forceReauth=false)');
+                try {
+                    await ensureValidOAuthToken(oauthProviderId, auth, {
+                        forceReacquireIfRefreshFails: true,
+                        openBrowser: true,
+                        forceReauthorize: false
+                    });
+                    console.log('[OAuth] [headers] ensureValid OK');
+                }
+                catch (e) {
+                    const msg = e?.message ? String(e.message) : String(e || 'unknown error');
+                    console.error(`[OAuth] [headers] ensureValid ERROR: ${msg}`);
+                    // 继续抛出，让上层逻辑按 Fail Fast 处理
+                    throw e;
+                }
+                try {
+                    this.authProvider?.getOAuthClient?.()?.loadToken?.();
+                }
+                catch { /* ignore */ }
+            }
+        }
+        catch (e) { /* bubble up in authHeaders build below */ }
+        // 认证头部（如为 OAuth，若当前无有效 token 则尝试拉取/刷新一次再取 headers）
+        let authHeaders = {};
+        try {
+            authHeaders = this.authProvider?.buildHeaders() || {};
+        }
+        catch (e) {
+            // 不重复刷新/授权：一次 ensureValid 已在上方执行，失败则直接抛出
+            const msg = e?.message ? String(e.message) : String(e || '');
+            console.error(`[OAuth] [headers] buildHeaders() failed after single ensureValid: ${msg}`);
+            throw e;
+        }
+        let finalHeaders = {
+            ...baseHeaders,
+            ...serviceHeaders,
+            ...overrideHeaders,
+            ...runtimeHeaders,
+            ...authHeaders
+        };
+        // 禁用上游SSE：设置 Accept 为 application/json（若未被显式覆盖）
+        if (!('Accept' in finalHeaders) && !('accept' in finalHeaders)) {
+            finalHeaders['Accept'] = 'application/json';
+        }
+        // 获取Hook管理器（新的统一系统）
+        const hookManager = this.hookSystemIntegration.getBidirectionalHookManager();
+        // 🔍 Hook 6: 认证阶段
+        await hookManager.executeHookChain('authentication', 'auth', authHeaders, this.createProviderContext());
+        // 🔍 Hook 7: Headers处理阶段
+        const headersResult = await hookManager.executeHookChain('request_preprocessing', 'headers', finalHeaders, this.createProviderContext());
+        finalHeaders = headersResult.data;
+        return finalHeaders;
+    }
+    getEffectiveBaseUrl() {
+        const runtime = this.getRuntimeProfile();
+        const runtimeEndpoint = this.pickRuntimeBaseUrl(runtime);
+        return (runtimeEndpoint ||
+            runtime?.baseUrl ||
+            this.config.config.overrides?.baseUrl ||
+            this.config.config.baseUrl ||
+            this.serviceProfile.defaultBaseUrl);
+    }
+    getEffectiveEndpoint() {
+        const runtime = this.getRuntimeProfile();
+        const runtimeEndpoint = runtime?.endpoint && !this.looksLikeAbsoluteUrl(runtime.endpoint)
+            ? runtime.endpoint
+            : undefined;
+        return (runtimeEndpoint ||
+            this.config.config.overrides?.endpoint ||
+            this.serviceProfile.defaultEndpoint);
+    }
+    pickRuntimeBaseUrl(runtime) {
+        if (!runtime)
+            return undefined;
+        if (typeof runtime.baseUrl === 'string' && runtime.baseUrl.trim()) {
+            return runtime.baseUrl.trim();
+        }
+        if (typeof runtime.endpoint === 'string' && this.looksLikeAbsoluteUrl(runtime.endpoint)) {
+            return runtime.endpoint.trim();
+        }
+        return undefined;
+    }
+    looksLikeAbsoluteUrl(value) {
+        if (!value)
+            return false;
+        const trimmed = value.trim();
+        return /^https?:\/\//i.test(trimmed) || trimmed.startsWith('//');
+    }
+    // （工具自动修复辅助函数已删除）
+    createProviderContext() {
+        const runtime = this.getCurrentRuntimeMetadata();
+        return {
+            requestId: runtime?.requestId || `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+            providerType: runtime?.providerType || this.providerType,
+            startTime: Date.now(),
+            profile: this.serviceProfile,
+            routeName: runtime?.routeName,
+            providerId: runtime?.providerId,
+            providerKey: runtime?.providerKey,
+            providerProtocol: runtime?.providerProtocol,
+            metadata: runtime?.metadata,
+            target: runtime?.target,
+            runtimeMetadata: runtime,
+            pipelineId: runtime?.pipelineId
+        };
+    }
+    normalizeAuthMode(type) {
+        return typeof type === 'string' && type.toLowerCase().includes('oauth') ? 'oauth' : 'apikey';
+    }
+    resolveOAuthProviderId(type) {
+        if (typeof type !== 'string')
+            return undefined;
+        const match = type.toLowerCase().match(/^([a-z0-9._-]+)-oauth$/);
+        return match ? match[1] : undefined;
+    }
+    ensureOAuthProviderId(auth, extensions) {
+        const fromExtension = typeof extensions?.oauthProviderId === 'string' && extensions.oauthProviderId.trim()
+            ? extensions.oauthProviderId.trim()
+            : undefined;
+        if (fromExtension) {
+            return fromExtension;
+        }
+        const fromAuthField = typeof auth?.oauthProviderId === 'string' && auth.oauthProviderId.trim()
+            ? auth.oauthProviderId.trim()
+            : undefined;
+        if (fromAuthField) {
+            return fromAuthField;
+        }
+        const providerId = this.resolveOAuthProviderId(auth?.rawType ?? auth?.type);
+        if (providerId) {
+            return providerId;
+        }
+        const fallback = this.resolveOAuthProviderId(auth?.type);
+        if (fallback) {
+            return fallback;
+        }
+        throw new Error(`OAuth auth.type must be declared as "<provider>-oauth" (received ${typeof auth?.rawType === 'string' ? auth.rawType : auth?.type ?? 'unknown'})`);
+    }
+    ensureOAuthProviderIdLegacy(type) {
+        const providerId = this.resolveOAuthProviderId(type);
+        if (!providerId) {
+            throw new Error(`OAuth auth.type must be declared as "<provider>-oauth" (received ${typeof type === 'string' ? type : 'unknown'})`);
+        }
+        return providerId;
+    }
+}
+//# sourceMappingURL=chat-http-provider.js.map