@jsonstudio/rcc 0.89.164 → 0.89.168

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

@@ -16,83 +16,34 @@ 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 { attachProviderSseSnapshotStream, shouldCaptureProviderStreamSnapshots, writeProviderSnapshot } from '../utils/snapshot-writer.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';
-const ENABLE_PROVIDER_HOOKS = process.env.ROUTECODEX_ENABLE_PROVIDER_HOOKS === '1';
+import { HttpRequestExecutor } from './http-request-executor.js';
+import { extractStatusCodeFromError } from './provider-error-classifier.js';
 const isRecord = (value) => typeof value === 'object' && value !== null;
-function createNoopHookSystemIntegration() {
-    const passthrough = async (_stage, _target, data) => ({
-        data,
-        metrics: {
-            executionTime: 0,
-            hookCount: 0,
-            successCount: 0,
-            readCount: 0,
-            writeCount: 0,
-            transformCount: 0
-        }
-    });
-    return {
-        getBidirectionalHookManager: () => ({
-            registerHook: () => { },
-            unregisterHook: () => { },
-            executeHookChain: passthrough,
-            setDebugConfig: () => { }
-        }),
-        setDebugConfig: () => { },
-        initialize: async () => { },
-        getStats: () => ({ enabled: false }),
-        healthCheck: async () => ({ healthy: true }),
-        start: async () => { },
-        stop: async () => { },
-        shutdown: async () => { }
-    };
-}
-const readStatusCodeFromResponse = (error) => {
-    const response = error?.response;
-    const directStatus = typeof response?.status === 'number' ? response.status : undefined;
-    const directStatusCode = typeof response?.statusCode === 'number'
-        ? response.statusCode
-        : undefined;
-    const nestedStatus = response &&
-        typeof response === 'object' &&
-        typeof response?.data?.status === 'number'
-        ? response.data.status
-        : undefined;
-    const nestedErrorStatus = response &&
-        typeof response === 'object' &&
-        typeof response?.data?.error?.status === 'number'
-        ? response.data.error.status
-        : undefined;
-    return [directStatus, directStatusCode, nestedStatus, nestedErrorStatus].find((candidate) => typeof candidate === 'number' && Number.isFinite(candidate));
-};
 const DEFAULT_USER_AGENT = 'RouteCodex/2.0';
 export class HttpTransportProvider extends BaseProvider {
     type;
     authProvider = null;
     httpClient;
     serviceProfile;
-    hookSystemIntegration;
     protocolClient;
+    requestExecutor;
     injectedConfig = null;
-    hooksEnabled;
     constructor(config, dependencies, moduleType, protocolClient) {
         super(config, dependencies);
         this.type = moduleType;
         this.protocolClient = protocolClient ?? new OpenAIChatProtocolClient();
-        this.hooksEnabled = ENABLE_PROVIDER_HOOKS;
         // 获取服务配置档案
         this.serviceProfile = this.getServiceProfile();
         // 验证配置
         this.validateConfig();
         // 创建HTTP客户端
         this.createHttpClient();
+        this.requestExecutor = new HttpRequestExecutor(this.httpClient, this.createRequestExecutorDeps());
         // 创建认证提供者
         this.authProvider = this.createAuthProvider();
-        // 初始化Hook系统集成
-        this.hookSystemIntegration = this.initializeHookSystem();
     }
     /**
      * 确保认证提供者完成初始化（避免 ApiKeyAuthProvider 未初始化导致的报错）
@@ -104,7 +55,8 @@ 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;
@@ -163,14 +115,6 @@ export class HttpTransportProvider extends BaseProvider {
                     }
                 }
             }
-            if (this.hooksEnabled) {
-                await this.hookSystemIntegration.initialize();
-                this.configureHookDebugging();
-                this.dependencies.logger?.logModule(this.id, 'provider-hook-system-initialized', {
-                    providerType: this.providerType,
-                    integrationEnabled: true
-                });
-            }
         }
         catch (error) {
             // 暴露问题，快速失败，便于定位凭证问题
@@ -200,62 +144,6 @@ export class HttpTransportProvider extends BaseProvider {
     getConfig() {
         return this.injectedConfig ?? this.config.config ?? null;
     }
-    /**
-     * 初始化Hook系统集成
-     */
-    initializeHookSystem() {
-        if (!this.hooksEnabled) {
-            return createNoopHookSystemIntegration();
-        }
-        return createHookSystemIntegration(this.dependencies, this.id, {
-            enabled: true,
-            debugMode: true,
-            snapshotEnabled: true,
-            migrationMode: true
-        });
-    }
-    /**
-     * 配置Hook调试（保持向后兼容）
-     */
-    configureHookDebugging() {
-        if (!this.hooksEnabled) {
-            return;
-        }
-        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);
@@ -349,13 +237,17 @@ 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 选择服务档案）
-        // 对于 gemini-cli 这类变体，provider 行为归入 gemini 协议族
-        const profileKeyForValidation = providerIdForAuth === 'gemini-cli' ? 'gemini' : providerIdForAuth;
-        const validation = ServiceProfileValidator.validateServiceProfile(profileKeyForValidation, authMode);
+        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(', ')}`);
         }
@@ -405,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;
@@ -447,36 +360,12 @@ 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/兼容层
-        // Provider 层不做协议兼容改写：compatibility 由 llmswitch-core Hub Pipeline 统一处理。
         return processedRequest;
     }
     async postprocessResponse(response, context) {
         const runtime = this.getRuntimeProfile();
         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;
-        // Provider 层不做协议兼容改写：compatibility 由 llmswitch-core Hub Pipeline 统一处理。
         const originalRecord = this.asResponseRecord(response);
         const processedRecord = this.asResponseRecord(processedResponse);
         const sseStream = processedRecord.__sse_responses ||
@@ -494,221 +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;
-        const captureSse = shouldCaptureProviderStreamSnapshots();
-        try {
-            if (wantsSse) {
-                const upstreamStream = await this.httpClient.postStream(endpoint, finalBody, finalHeaders);
-                const streamForHost = captureSse
-                    ? attachProviderSseSnapshotStream(upstreamStream, {
-                        requestId: context.requestId,
-                        headers: finalHeaders,
-                        url: targetUrl,
-                        entryEndpoint,
-                        clientRequestId
-                    })
-                    : upstreamStream;
-                response = await this.wrapUpstreamSseResponse(streamForHost, context);
-                if (!captureSse) {
-                    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 upstreamStream = await this.httpClient.postStream(endpoint, finalBody, finalRetryHeaders);
-                            const streamForHost = captureSse
-                                ? attachProviderSseSnapshotStream(upstreamStream, {
-                                    requestId: context.requestId,
-                                    headers: finalRetryHeaders,
-                                    url: targetUrl,
-                                    entryEndpoint,
-                                    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: 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 responseStatus = readStatusCodeFromResponse(normalized);
-                const statusCode = Number.isFinite(normalized.statusCode)
-                    ? Number(normalized.statusCode)
-                    : Number.isFinite(normalized.status)
-                        ? Number(normalized.status)
-                        : responseStatus ?? 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;
@@ -744,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（默认使用配置值，可由子类覆写）
      */
@@ -888,13 +698,6 @@ export class HttpTransportProvider extends BaseProvider {
         if (resolvedOriginator) {
             setHeader(finalHeaders, 'originator', resolvedOriginator);
         }
-        // 获取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;
         return finalHeaders;
     }
     getEffectiveBaseUrl() {
@@ -934,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;