@jsonstudio/rcc 0.89.3 → 0.89.168

package/dist/providers/core/runtime/http-transport-provider.js

@@ -13,21 +13,23 @@ 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 { logOAuthDebug } from '../../auth/oauth-logger.js';
 import { TokenFileAuthProvider } from '../../auth/tokenfile-auth.js';
 import { ensureValidOAuthToken, handleUpstreamInvalidOAuthToken } from '../../auth/oauth-lifecycle.js';
-import { createHookSystemIntegration, HookSystemIntegration } from '../hooks/hooks-integration.js';
-import { writeProviderSnapshot } from '../utils/snapshot-writer.js';
-import { ProviderComposite } from '../composite/provider-composite.js';
+import { attachProviderSseSnapshotStream, writeProviderSnapshot } from '../utils/snapshot-writer.js';
 import { attachProviderRuntimeMetadata } from './provider-runtime-metadata.js';
 import { OpenAIChatProtocolClient } from '../../../client/openai/chat-protocol-client.js';
+import { HttpRequestExecutor } from './http-request-executor.js';
+import { extractStatusCodeFromError } from './provider-error-classifier.js';
 const isRecord = (value) => typeof value === 'object' && value !== null;
+const DEFAULT_USER_AGENT = 'RouteCodex/2.0';
 export class HttpTransportProvider extends BaseProvider {
     type;
     authProvider = null;
     httpClient;
     serviceProfile;
-    hookSystemIntegration;
     protocolClient;
+    requestExecutor;
     injectedConfig = null;
     constructor(config, dependencies, moduleType, protocolClient) {
         super(config, dependencies);
@@ -39,10 +41,9 @@ export class HttpTransportProvider extends BaseProvider {
         this.validateConfig();
         // 创建HTTP客户端
         this.createHttpClient();
+        this.requestExecutor = new HttpRequestExecutor(this.httpClient, this.createRequestExecutorDeps());
         // 创建认证提供者
         this.authProvider = this.createAuthProvider();
-        // 初始化Hook系统集成
-        this.hookSystemIntegration = this.initializeHookSystem();
     }
     /**
      * 确保认证提供者完成初始化（避免 ApiKeyAuthProvider 未初始化导致的报错）
@@ -54,12 +55,13 @@ export class HttpTransportProvider extends BaseProvider {
                 const providerConfig = this.config.config;
                 const extensions = this.getConfigExtensions();
                 const auth = providerConfig.auth;
-                if (this.normalizeAuthMode(auth.type) === 'oauth') {
+                const usesTokenFile = this.authProvider instanceof TokenFileAuthProvider;
+                if (this.normalizeAuthMode(auth.type) === 'oauth' && !usesTokenFile) {
                     const oauthAuth = auth;
                     const oauthProviderId = this.ensureOAuthProviderId(oauthAuth, extensions);
                     const forceReauthorize = false;
                     const tokenFileHint = oauthAuth.tokenFile ?? '(default)';
-                    console.log(`[OAuth] [init] provider=${oauthProviderId} type=${auth.type} tokenFile=${tokenFileHint} forceReauth=${forceReauthorize}`);
+                    logOAuthDebug(`[OAuth] [init] provider=${oauthProviderId} type=${auth.type} tokenFile=${tokenFileHint} forceReauth=${forceReauthorize}`);
                     this.dependencies.logger?.logModule?.(this.id, 'oauth-init-start', {
                         providerType: oauthProviderId,
                         tokenFile: tokenFileHint,
@@ -71,7 +73,7 @@ export class HttpTransportProvider extends BaseProvider {
                             openBrowser: true,
                             forceReauthorize
                         });
-                        console.log('[OAuth] [init] ensureValid OK');
+                        logOAuthDebug('[OAuth] [init] ensureValid OK');
                         try {
                             if (this.authProvider instanceof TokenFileAuthProvider) {
                                 await this.authProvider.initialize();
@@ -113,14 +115,6 @@ export class HttpTransportProvider extends BaseProvider {
                     }
                 }
             }
-            // 初始化新的Hook系统集成
-            await this.hookSystemIntegration.initialize();
-            // 设置调试配置（向后兼容）
-            this.configureHookDebugging();
-            this.dependencies.logger?.logModule(this.id, 'provider-hook-system-initialized', {
-                providerType: this.providerType,
-                integrationEnabled: true
-            });
         }
         catch (error) {
             // 暴露问题，快速失败，便于定位凭证问题
@@ -150,83 +144,6 @@ export class HttpTransportProvider extends BaseProvider {
     getConfig() {
         return this.injectedConfig ?? this.config.config ?? null;
     }
-    /**
-     * 初始化Hook系统集成
-     */
-    initializeHookSystem() {
-        try {
-            const integration = 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
-            });
-            return integration;
-        }
-        catch (error) {
-            this.dependencies.logger?.logModule(this.id, 'hook-system-integration-failed', {
-                error: error instanceof Error ? error.message : String(error)
-            });
-            // 创建兼容的空实现，避免系统崩溃
-            return {
-                getBidirectionalHookManager: () => ({
-                    registerHook: () => { },
-                    unregisterHook: () => { },
-                    executeHookChain: async () => ({ data: {}, metrics: {} }),
-                    setDebugConfig: () => { }
-                }),
-                setDebugConfig: () => { },
-                initialize: async () => { },
-                getStats: () => ({ enabled: false }),
-                healthCheck: async () => ({ healthy: true }),
-                start: async () => { },
-                stop: async () => { },
-                shutdown: async () => { }
-            };
-        }
-    }
-    /**
-     * 配置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;
         const profileKey = this.resolveProfileKey(cfg);
@@ -320,10 +237,16 @@ export class HttpTransportProvider extends BaseProvider {
         const auth = this.config.config.auth;
         const extensions = this.getConfigExtensions();
         const authMode = this.normalizeAuthMode(auth.type);
-        const providerIdForAuth = authMode === 'oauth'
+        this.authMode = authMode;
+        let providerIdForAuth = authMode === 'oauth'
             ? this.ensureOAuthProviderId(auth, extensions)
             : this.providerType;
-        // 验证认证配置（按 providerIdForAuth 选择服务档案）
+        if (this.type === 'gemini-cli-http-provider') {
+            providerIdForAuth = 'gemini-cli';
+        }
+        if (authMode === 'oauth') {
+            this.oauthProviderId = providerIdForAuth;
+        }
         const validation = ServiceProfileValidator.validateServiceProfile(providerIdForAuth, authMode);
         if (!validation.isValid) {
             throw new Error(`Invalid auth configuration for ${providerIdForAuth}: ${validation.errors.join(', ')}`);
@@ -334,9 +257,9 @@ export class HttpTransportProvider extends BaseProvider {
         }
         else if (authMode === 'oauth') {
             const oauthAuth = auth;
-            // 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') &&
+            // For providers like Qwen/iflow/Gemini CLI where public OAuth client may not be available,
+            // allow reading tokens produced by external login tools (CLIProxyAPI) via token file.
+            const useTokenFile = (providerIdForAuth === 'qwen' || providerIdForAuth === 'iflow' || providerIdForAuth === 'gemini-cli') &&
                 !oauthAuth.clientId &&
                 !oauthAuth.tokenUrl &&
                 !oauthAuth.deviceCodeUrl;
@@ -374,6 +297,27 @@ export class HttpTransportProvider extends BaseProvider {
             }
         });
     }
+    createRequestExecutorDeps() {
+        return {
+            wantsUpstreamSse: this.wantsUpstreamSse.bind(this),
+            getEffectiveEndpoint: () => this.getEffectiveEndpoint(),
+            resolveRequestEndpoint: this.resolveRequestEndpoint.bind(this),
+            buildRequestHeaders: this.buildRequestHeaders.bind(this),
+            finalizeRequestHeaders: this.finalizeRequestHeaders.bind(this),
+            applyStreamModeHeaders: this.applyStreamModeHeaders.bind(this),
+            getEffectiveBaseUrl: () => this.getEffectiveBaseUrl(),
+            buildHttpRequestBody: this.buildHttpRequestBody.bind(this),
+            prepareSseRequestBody: this.prepareSseRequestBody.bind(this),
+            getEntryEndpointFromPayload: this.getEntryEndpointFromPayload.bind(this),
+            getClientRequestIdFromContext: this.getClientRequestIdFromContext.bind(this),
+            wrapUpstreamSseResponse: this.wrapUpstreamSseResponse.bind(this),
+            getHttpRetryLimit: () => this.getHttpRetryLimit(),
+            shouldRetryHttpError: this.shouldRetryHttpError.bind(this),
+            delayBeforeHttpRetry: this.delayBeforeHttpRetry.bind(this),
+            tryRecoverOAuthAndReplay: this.tryRecoverOAuthAndReplay.bind(this),
+            normalizeHttpError: this.normalizeHttpError.bind(this)
+        };
+    }
     async preprocessRequest(request) {
         const context = this.createProviderContext();
         const runtimeMetadata = context.runtimeMetadata;
@@ -416,89 +360,19 @@ export class HttpTransportProvider extends BaseProvider {
             }
         }
         catch { /* ignore */ }
-        // 获取Hook管理器（新的统一系统）
-        const hookManager = this.getHookManager();
-        // 🔍 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,
-                    providerFamily: runtime?.providerFamily || runtime?.providerId || runtime?.providerKey,
-                    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 responseRecord = this.asResponseRecord(response);
-            if (responseRecord.__sse_stream) {
-                return { __sse_responses: responseRecord.__sse_stream };
-            }
-            if (responseRecord.data?.__sse_stream) {
-                return { __sse_responses: responseRecord.data.__sse_stream };
-            }
-        }
-        catch {
-            // ignore
-        }
         const processingTime = Date.now() - context.startTime;
         let processedResponse = response;
-        // 获取Hook管理器（新的统一系统）
-        const hookManager = this.getHookManager();
-        // 🔍 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,
-                    providerFamily: runtime?.providerFamily || runtime?.providerId || runtime?.providerKey,
-                    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;
-        }
-        const processedRecord = this.asResponseRecord(processedResponse);
         const originalRecord = this.asResponseRecord(response);
+        const processedRecord = this.asResponseRecord(processedResponse);
+        const sseStream = processedRecord.__sse_responses ||
+            processedRecord.data?.__sse_responses;
+        if (sseStream) {
+            return { __sse_responses: sseStream };
+        }
         return {
             data: processedRecord.data || processedResponse,
             status: processedRecord.status ?? originalRecord.status,
@@ -509,195 +383,13 @@ export class HttpTransportProvider extends BaseProvider {
                 providerType: this.providerType,
                 // 对外暴露的 model 统一为入站模型
                 model: context.model ?? this.extractModel(processedRecord) ?? this.extractModel(originalRecord),
-                usage: this.extractUsage(processedRecord) ?? this.extractUsage(originalRecord),
-                hookMetrics: {
-                    httpResponse: httpResponseResult.metrics,
-                    validation: validationResult.metrics,
-                    postprocess: postprocessResult.metrics
-                }
+                usage: this.extractUsage(processedRecord) ?? this.extractUsage(originalRecord)
             }
         };
     }
     async sendRequestInternal(request) {
         const context = this.createProviderContext();
-        // 获取Hook管理器（新的统一系统）
-        const hookManager = this.getHookManager();
-        // 🔍 Hook 8: HTTP请求阶段
-        const httpRequestResult = await hookManager.executeHookChain('http_request', 'request', request, context);
-        const processedRequest = httpRequestResult.data;
-        const wantsSse = this.wantsUpstreamSse(processedRequest, context);
-        // 仅传入 endpoint，让 HttpClient 按 baseUrl 进行拼接；避免 full URL 再次拼接导致 /https:/ 重复
-        const defaultEndpoint = this.getEffectiveEndpoint();
-        const endpoint = this.resolveRequestEndpoint(processedRequest, defaultEndpoint);
-        const headers = await this.buildRequestHeaders();
-        let finalHeaders = await this.finalizeRequestHeaders(headers, processedRequest);
-        finalHeaders = this.applyStreamModeHeaders(finalHeaders, wantsSse);
-        const targetUrl = `${this.getEffectiveBaseUrl().replace(/\/$/, '')}/${endpoint.startsWith('/') ? endpoint.slice(1) : endpoint}`;
-        // Flatten request body to standard OpenAI Chat JSON
-        const finalBody = this.buildHttpRequestBody(processedRequest);
-        if (wantsSse) {
-            this.prepareSseRequestBody(finalBody, context);
-        }
-        const entryEndpoint = this.getEntryEndpointFromPayload(processedRequest);
-        const clientRequestId = this.getClientRequestIdFromContext(context);
-        // 快照：provider-request（默认开启，脱敏headers）
-        try {
-            await writeProviderSnapshot({
-                phase: 'provider-request',
-                requestId: context.requestId,
-                data: finalBody,
-                headers: finalHeaders,
-                url: targetUrl,
-                entryEndpoint,
-                clientRequestId
-            });
-        }
-        catch { /* non-blocking */ }
-        // 发送HTTP请求（根据是否需要 SSE 决定传输模式）
-        let response;
-        try {
-            if (wantsSse) {
-                const stream = await this.httpClient.postStream(endpoint, finalBody, finalHeaders);
-                response = await this.wrapUpstreamSseResponse(stream, context);
-                try {
-                    await writeProviderSnapshot({
-                        phase: 'provider-response',
-                        requestId: context.requestId,
-                        data: { mode: 'sse' },
-                        headers: finalHeaders,
-                        url: targetUrl,
-                        entryEndpoint,
-                        clientRequestId
-                    });
-                }
-                catch { /* non-blocking */ }
-            }
-            else {
-                response = await this.httpClient.post(endpoint, finalBody, finalHeaders);
-                try {
-                    await writeProviderSnapshot({
-                        phase: 'provider-response',
-                        requestId: context.requestId,
-                        data: response,
-                        headers: finalHeaders,
-                        url: targetUrl,
-                        entryEndpoint,
-                        clientRequestId
-                    });
-                }
-                catch { /* non-blocking */ }
-            }
-        }
-        catch (error) {
-            // OAuth token 失效：尝试刷新/重获并重试一次
-            try {
-                const providerAuth = this.config.config.auth;
-                if (this.normalizeAuthMode(providerAuth.type) === 'oauth') {
-                    const shouldRetry = await handleUpstreamInvalidOAuthToken(this.providerType, providerAuth, error);
-                    if (shouldRetry) {
-                        const retryHeaders = await this.buildRequestHeaders();
-                        let finalRetryHeaders = await this.finalizeRequestHeaders(retryHeaders, processedRequest);
-                        finalRetryHeaders = this.applyStreamModeHeaders(finalRetryHeaders, wantsSse);
-                        if (wantsSse) {
-                            const stream = await this.httpClient.postStream(endpoint, finalBody, finalRetryHeaders);
-                            const wrapped = await this.wrapUpstreamSseResponse(stream, context);
-                            try {
-                                await writeProviderSnapshot({
-                                    phase: 'provider-response',
-                                    requestId: context.requestId,
-                                    data: { mode: 'sse', retry: true },
-                                    headers: finalRetryHeaders,
-                                    url: targetUrl,
-                                    entryEndpoint,
-                                    clientRequestId
-                                });
-                            }
-                            catch { /* non-blocking */ }
-                            return wrapped;
-                        }
-                        response = await this.httpClient.post(endpoint, finalBody, finalRetryHeaders);
-                        try {
-                            await writeProviderSnapshot({
-                                phase: 'provider-response',
-                                requestId: context.requestId,
-                                data: response,
-                                headers: finalRetryHeaders,
-                                url: targetUrl,
-                                entryEndpoint,
-                                clientRequestId
-                            });
-                        }
-                        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: finalHeaders }, context);
-            // 如果Hook处理了错误，使用Hook的返回结果
-            const hookErrorData = errorResult.data;
-            if (hookErrorData && hookErrorData.error === false) {
-                return hookErrorData;
-            }
-            // 规范化错误：补充结构化字段，移除仅文本填充的旧做法
-            const 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: finalHeaders,
-                    url: targetUrl,
-                    entryEndpoint,
-                    clientRequestId
-                });
-            }
-            catch { /* non-blocking */ }
-            throw normalized;
-        }
-        // Provider 不处理工具修复/注入逻辑：统一收敛到 llmswitch-core 与兼容层
-        // 此处不做任何自动修复/重试，保持单次请求的幂等与可观测性
-        try { /* no-op */ }
-        catch { /* ignore */ }
-        return response;
+        return this.requestExecutor.execute(request, context);
     }
     wantsUpstreamSse(_request, _context) {
         return false;
@@ -733,6 +425,135 @@ export class HttpTransportProvider extends BaseProvider {
             return false;
         }
     }
+    getHttpRetryLimit() {
+        return 3;
+    }
+    async delayBeforeHttpRetry(attempt) {
+        const delay = Math.min(500 * attempt, 2000);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+    shouldRetryHttpError(error, attempt, maxAttempts) {
+        if (attempt >= maxAttempts) {
+            return false;
+        }
+        const normalized = error;
+        const statusCode = extractStatusCodeFromError(normalized);
+        if (statusCode && statusCode >= 500) {
+            return true;
+        }
+        return false;
+    }
+    async tryRecoverOAuthAndReplay(error, requestInfo, processedRequest, captureSse, context) {
+        try {
+            const providerAuth = this.config.config.auth;
+            if (this.normalizeAuthMode(providerAuth.type) !== 'oauth') {
+                return undefined;
+            }
+            const shouldRetry = await handleUpstreamInvalidOAuthToken(this.oauthProviderId || this.providerType, providerAuth, error);
+            if (!shouldRetry) {
+                return undefined;
+            }
+            const retryHeaders = await this.buildRequestHeaders();
+            let finalRetryHeaders = await this.finalizeRequestHeaders(retryHeaders, processedRequest);
+            finalRetryHeaders = this.applyStreamModeHeaders(finalRetryHeaders, requestInfo.wantsSse);
+            if (requestInfo.wantsSse) {
+                const upstreamStream = await this.httpClient.postStream(requestInfo.endpoint, requestInfo.body, finalRetryHeaders);
+                const streamForHost = captureSse
+                    ? attachProviderSseSnapshotStream(upstreamStream, {
+                        requestId: context.requestId,
+                        headers: finalRetryHeaders,
+                        url: requestInfo.targetUrl,
+                        entryEndpoint: requestInfo.entryEndpoint,
+                        clientRequestId: requestInfo.clientRequestId,
+                        extra: { retry: true }
+                    })
+                    : upstreamStream;
+                const wrapped = await this.wrapUpstreamSseResponse(streamForHost, context);
+                if (!captureSse) {
+                    try {
+                        await writeProviderSnapshot({
+                            phase: 'provider-response',
+                            requestId: context.requestId,
+                            data: { mode: 'sse', retry: true },
+                            headers: finalRetryHeaders,
+                            url: requestInfo.targetUrl,
+                            entryEndpoint: requestInfo.entryEndpoint,
+                            clientRequestId: requestInfo.clientRequestId
+                        });
+                    }
+                    catch { /* non-blocking */ }
+                }
+                return wrapped;
+            }
+            const response = await this.httpClient.post(requestInfo.endpoint, requestInfo.body, finalRetryHeaders);
+            try {
+                await writeProviderSnapshot({
+                    phase: 'provider-response',
+                    requestId: context.requestId,
+                    data: response,
+                    headers: finalRetryHeaders,
+                    url: requestInfo.targetUrl,
+                    entryEndpoint: requestInfo.entryEndpoint,
+                    clientRequestId: requestInfo.clientRequestId
+                });
+            }
+            catch { /* non-blocking */ }
+            return response;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async normalizeHttpError(error, processedRequest, requestInfo, context) {
+        const normalized = error;
+        try {
+            const statusCode = extractStatusCodeFromError(normalized);
+            if (statusCode && !Number.isNaN(statusCode)) {
+                normalized.statusCode = statusCode;
+                if (!normalized.status) {
+                    normalized.status = statusCode;
+                }
+                if (!normalized.code) {
+                    normalized.code = `HTTP_${statusCode}`;
+                }
+            }
+            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;
+            }
+            if (normalized.message && !normalized.response.data.error.message) {
+                normalized.response.data.error.message = normalized.message;
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        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(error || '')
+                },
+                headers: requestInfo.headers,
+                url: requestInfo.targetUrl,
+                entryEndpoint: requestInfo.entryEndpoint ?? this.getEntryEndpointFromPayload(processedRequest),
+                clientRequestId: requestInfo.clientRequestId ?? this.getClientRequestIdFromContext(context)
+            });
+        }
+        catch { /* non-blocking */ }
+        return normalized;
+    }
     /**
      * 为特定请求确定最终 endpoint（默认使用配置值，可由子类覆写）
      */
@@ -774,6 +595,14 @@ export class HttpTransportProvider extends BaseProvider {
         const baseHeaders = {
             'Content-Type': 'application/json'
         };
+        const runtimeMetadata = this.getCurrentRuntimeMetadata();
+        const inboundMetadata = runtimeMetadata?.metadata;
+        const inboundUserAgent = typeof inboundMetadata?.userAgent === 'string' && inboundMetadata.userAgent.trim()
+            ? inboundMetadata.userAgent.trim()
+            : undefined;
+        const inboundOriginator = typeof inboundMetadata?.clientOriginator === 'string' && inboundMetadata.clientOriginator.trim()
+            ? inboundMetadata.clientOriginator.trim()
+            : undefined;
         // 服务特定头部
         const serviceHeaders = this.serviceProfile.headers || {};
         // 配置覆盖头部
@@ -785,14 +614,14 @@ export class HttpTransportProvider extends BaseProvider {
             if (this.normalizeAuthMode(auth.type) === 'oauth') {
                 const oauthAuth = auth;
                 const oauthProviderId = this.ensureOAuthProviderId(oauthAuth);
-                console.log('[OAuth] [headers] ensureValid start (openBrowser=true, forceReauth=false)');
+                logOAuthDebug('[OAuth] [headers] ensureValid start (openBrowser=true, forceReauth=false)');
                 try {
                     await ensureValidOAuthToken(oauthProviderId, oauthAuth, {
                         forceReacquireIfRefreshFails: true,
                         openBrowser: true,
                         forceReauthorize: false
                     });
-                    console.log('[OAuth] [headers] ensureValid OK');
+                    logOAuthDebug('[OAuth] [headers] ensureValid OK');
                 }
                 catch (error) {
                     const err = error;
@@ -833,13 +662,42 @@ export class HttpTransportProvider extends BaseProvider {
         if (!('Accept' in finalHeaders) && !('accept' in finalHeaders)) {
             finalHeaders['Accept'] = 'application/json';
         }
-        // 获取Hook管理器（新的统一系统）
-        const hookManager = this.getHookManager();
-        // 🔍 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;
+        const getHeader = (headers, target) => {
+            const lowered = target.toLowerCase();
+            for (const [key, value] of Object.entries(headers)) {
+                if (key.toLowerCase() === lowered && typeof value === 'string' && value.trim()) {
+                    return value.trim();
+                }
+            }
+            return undefined;
+        };
+        const setHeader = (headers, target, value) => {
+            if (!value || !value.trim())
+                return;
+            const lowered = target.toLowerCase();
+            for (const key of Object.keys(headers)) {
+                if (key.toLowerCase() === lowered) {
+                    headers[key] = value;
+                    return;
+                }
+            }
+            headers[target] = value;
+        };
+        // Header priority:
+        // - user/provider config (overrides/runtime) wins
+        // - otherwise inherit from inbound client headers
+        // - otherwise fall back to defaults
+        const uaFromConfig = getHeader({ ...overrideHeaders, ...runtimeHeaders }, 'User-Agent');
+        const uaFromService = getHeader(serviceHeaders, 'User-Agent');
+        const resolvedUa = uaFromConfig ?? inboundUserAgent ?? uaFromService ?? DEFAULT_USER_AGENT;
+        setHeader(finalHeaders, 'User-Agent', resolvedUa);
+        // originator: do not invent one; only forward from config or inbound client
+        const originatorFromConfig = getHeader({ ...overrideHeaders, ...runtimeHeaders }, 'originator');
+        const originatorFromService = getHeader(serviceHeaders, 'originator');
+        const resolvedOriginator = originatorFromConfig ?? inboundOriginator ?? originatorFromService;
+        if (resolvedOriginator) {
+            setHeader(finalHeaders, 'originator', resolvedOriginator);
+        }
         return finalHeaders;
     }
     getEffectiveBaseUrl() {
@@ -879,9 +737,6 @@ export class HttpTransportProvider extends BaseProvider {
         const trimmed = value.trim();
         return /^https?:\/\//i.test(trimmed) || trimmed.startsWith('//');
     }
-    getHookManager() {
-        return this.hookSystemIntegration.getBidirectionalHookManager();
-    }
     // （工具自动修复辅助函数已删除）
     getConfigExtensions() {
         const extensions = this.config.config.extensions;