@jsonstudio/rcc 0.89.164 → 0.89.333

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

@@ -8,6 +8,8 @@
  *
  * 各协议具体行为（OpenAI Chat、Responses、Anthropic、Gemini 等）通过子类覆写钩子实现。
  */
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
 import { BaseProvider } from './base-provider.js';
 import { HttpClient } from '../utils/http-client.js';
 import { DynamicProfileLoader, ServiceProfileValidator } from '../config/service-profiles.js';
@@ -16,83 +18,35 @@ 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 { attachProviderRuntimeMetadata } from './provider-runtime-metadata.js';
+import { fetchAntigravityProjectId } from '../../auth/antigravity-userinfo-helper.js';
+import { attachProviderSseSnapshotStream, writeProviderSnapshot } from '../utils/snapshot-writer.js';
+import { attachProviderRuntimeMetadata, extractProviderRuntimeMetadata } 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';
+const DEFAULT_USER_AGENT = 'codex_cli_rs/0.73.0 (Mac OS 15.6.1; arm64) iTerm.app/3.6.5';
 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,9 +58,10 @@ export class HttpTransportProvider extends BaseProvider {
                 const providerConfig = this.config.config;
                 const extensions = this.getConfigExtensions();
                 const auth = providerConfig.auth;
+                const usesTokenFile = this.authProvider instanceof TokenFileAuthProvider;
                 if (this.normalizeAuthMode(auth.type) === 'oauth') {
                     const oauthAuth = auth;
-                    const oauthProviderId = this.ensureOAuthProviderId(oauthAuth, extensions);
+                    const oauthProviderId = this.oauthProviderId || this.ensureOAuthProviderId(oauthAuth, extensions);
                     const forceReauthorize = false;
                     const tokenFileHint = oauthAuth.tokenFile ?? '(default)';
                     logOAuthDebug(`[OAuth] [init] provider=${oauthProviderId} type=${auth.type} tokenFile=${tokenFileHint} forceReauth=${forceReauthorize}`);
@@ -121,9 +76,13 @@ export class HttpTransportProvider extends BaseProvider {
                             openBrowser: true,
                             forceReauthorize
                         });
+                        if (this.oauthProviderId === 'antigravity') {
+                            await this.ensureAntigravityProjectMetadata(oauthAuth);
+                        }
                         logOAuthDebug('[OAuth] [init] ensureValid OK');
                         try {
                             if (this.authProvider instanceof TokenFileAuthProvider) {
+                                // 令牌文件可能在 ensureValidOAuthToken 中被创建/更新，重新加载一次
                                 await this.authProvider.initialize();
                             }
                             else {
@@ -142,17 +101,11 @@ export class HttpTransportProvider extends BaseProvider {
                         const msg = err?.message ? String(err.message) : String(error);
                         console.error(`[OAuth] [init] ensureValid ERROR: ${msg}`);
                         this.dependencies.logger?.logModule?.(this.id, 'oauth-init-error', {
-                            providerType: this.providerType,
+                            providerType: oauthProviderId,
                             error: msg
                         });
                         throw error;
                     }
-                    try {
-                        this.authProvider.getOAuthClient?.()?.loadToken?.();
-                    }
-                    catch {
-                        // ignore
-                    }
                 }
                 else {
                     try {
@@ -163,14 +116,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 +145,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,15 +238,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;
+        const resolvedOAuthProviderId = 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);
+            : undefined;
+        const serviceProfileKey = this.type === 'gemini-cli-http-provider'
+            ? 'gemini-cli'
+            : (resolvedOAuthProviderId ?? this.providerType);
+        const validation = ServiceProfileValidator.validateServiceProfile(serviceProfileKey, authMode);
         if (!validation.isValid) {
-            throw new Error(`Invalid auth configuration for ${providerIdForAuth}: ${validation.errors.join(', ')}`);
+            throw new Error(`Invalid auth configuration for ${serviceProfileKey}: ${validation.errors.join(', ')}`);
         }
         // 根据认证类型创建对应的认证提供者
         if (authMode === 'apikey') {
@@ -365,16 +255,20 @@ export class HttpTransportProvider extends BaseProvider {
         }
         else if (authMode === 'oauth') {
             const oauthAuth = auth;
+            const oauthProviderId = resolvedOAuthProviderId ?? serviceProfileKey;
+            this.oauthProviderId = oauthProviderId;
             // 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') &&
+            const useTokenFile = (oauthProviderId === 'qwen' ||
+                oauthProviderId === 'iflow' ||
+                this.type === 'gemini-cli-http-provider') &&
                 !oauthAuth.clientId &&
                 !oauthAuth.tokenUrl &&
                 !oauthAuth.deviceCodeUrl;
             if (useTokenFile) {
                 return new TokenFileAuthProvider(oauthAuth);
             }
-            return new OAuthAuthProvider(oauthAuth, providerIdForAuth);
+            return new OAuthAuthProvider(oauthAuth, oauthProviderId);
         }
         else {
             throw new Error(`Unsupported auth type: ${auth.type}`);
@@ -405,9 +299,43 @@ 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;
+        const headersFromRequest = this.normalizeClientHeaders(request?.metadata?.clientHeaders);
+        const headersFromRuntime = this.normalizeClientHeaders(runtimeMetadata?.metadata && typeof runtimeMetadata.metadata === 'object'
+            ? runtimeMetadata.metadata.clientHeaders
+            : undefined);
+        const effectiveClientHeaders = headersFromRequest ?? headersFromRuntime;
+        if (effectiveClientHeaders) {
+            if (runtimeMetadata) {
+                if (!runtimeMetadata.metadata || typeof runtimeMetadata.metadata !== 'object') {
+                    runtimeMetadata.metadata = {};
+                }
+                runtimeMetadata.metadata.clientHeaders = effectiveClientHeaders;
+            }
+        }
         const ensureRuntimeMetadata = (payload) => {
             if (!runtimeMetadata || !payload || typeof payload !== 'object') {
                 return;
@@ -433,50 +361,17 @@ export class HttpTransportProvider extends BaseProvider {
                 ...processedMetadata,
                 ...(entryEndpoint ? { entryEndpoint } : {}),
                 ...(typeof streamFlag === 'boolean' ? { stream: !!streamFlag } : {}),
+                ...(effectiveClientHeaders ? { clientHeaders: effectiveClientHeaders } : {}),
                 __origModel: inboundModel
             };
         }
         catch { /* ignore */ }
-        // 流式开关：基础 Provider 统一移除入口层的 stream 标记，
-        // 具体协议（如 Responses/Anthropic）的真实流控由各自独立 Provider 处理
-        try {
-            // 统一：所有入口均移除 stream=true（Provider 始终走非流式），SSE 由上层合成
-            const requestBody = processedRequest;
-            if (requestBody.stream === true) {
-                delete requestBody.stream;
-            }
-        }
-        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 +389,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 +431,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（默认使用配置值，可由子类覆写）
      */
@@ -793,6 +609,8 @@ export class HttpTransportProvider extends BaseProvider {
         const inboundOriginator = typeof inboundMetadata?.clientOriginator === 'string' && inboundMetadata.clientOriginator.trim()
             ? inboundMetadata.clientOriginator.trim()
             : undefined;
+        const inboundClientHeaders = this.extractClientHeaders(runtimeMetadata);
+        const normalizedClientHeaders = this.normalizeCodexClientHeaders(inboundClientHeaders);
         // 服务特定头部
         const serviceHeaders = this.serviceProfile.headers || {};
         // 配置覆盖头部
@@ -803,7 +621,7 @@ export class HttpTransportProvider extends BaseProvider {
             const auth = this.config.config.auth;
             if (this.normalizeAuthMode(auth.type) === 'oauth') {
                 const oauthAuth = auth;
-                const oauthProviderId = this.ensureOAuthProviderId(oauthAuth);
+                const oauthProviderId = this.oauthProviderId || this.ensureOAuthProviderId(oauthAuth);
                 logOAuthDebug('[OAuth] [headers] ensureValid start (openBrowser=true, forceReauth=false)');
                 try {
                     await ensureValidOAuthToken(oauthProviderId, oauthAuth, {
@@ -848,55 +666,146 @@ export class HttpTransportProvider extends BaseProvider {
             ...runtimeHeaders,
             ...authHeaders
         };
-        // 禁用上游SSE：设置 Accept 为 application/json（若未被显式覆盖）
-        if (!('Accept' in finalHeaders) && !('accept' in finalHeaders)) {
-            finalHeaders['Accept'] = 'application/json';
-        }
-        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;
-        };
+        // 保留客户端 Accept；无则默认为 application/json
+        const clientAccept = normalizedClientHeaders ? this.findHeaderValue(normalizedClientHeaders, 'Accept') : undefined;
+        if (clientAccept) {
+            this.assignHeader(finalHeaders, 'Accept', clientAccept);
+        }
+        else if (!this.findHeaderValue(finalHeaders, 'Accept')) {
+            this.assignHeader(finalHeaders, 'Accept', 'application/json');
+        }
         // 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 uaFromConfig = this.findHeaderValue({ ...overrideHeaders, ...runtimeHeaders }, 'User-Agent');
+        const uaFromService = this.findHeaderValue(serviceHeaders, 'User-Agent');
         const resolvedUa = uaFromConfig ?? inboundUserAgent ?? uaFromService ?? DEFAULT_USER_AGENT;
-        setHeader(finalHeaders, 'User-Agent', resolvedUa);
+        this.assignHeader(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 originatorFromConfig = this.findHeaderValue({ ...overrideHeaders, ...runtimeHeaders }, 'originator');
+        const originatorFromService = this.findHeaderValue(serviceHeaders, 'originator');
         const resolvedOriginator = originatorFromConfig ?? inboundOriginator ?? originatorFromService;
         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;
+            this.assignHeader(finalHeaders, 'originator', resolvedOriginator);
+        }
+        if (normalizedClientHeaders) {
+            const conversationId = this.findHeaderValue(normalizedClientHeaders, 'conversation_id');
+            if (conversationId) {
+                this.assignHeader(finalHeaders, 'conversation_id', conversationId);
+            }
+            const sessionId = this.findHeaderValue(normalizedClientHeaders, 'session_id');
+            if (sessionId) {
+                this.assignHeader(finalHeaders, 'session_id', sessionId);
+            }
+        }
+        if (this.isCodexUaMode()) {
+            this.ensureCodexSessionHeaders(finalHeaders, runtimeMetadata);
+        }
         return finalHeaders;
     }
+    isCodexUaMode() {
+        const raw = process.env.ROUTECODEX_UA_MODE ??
+            process.env.RCC_UA_MODE ??
+            '';
+        const normalized = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+        const runtime = this.getCurrentRuntimeMetadata();
+        if (!runtime) {
+            return false;
+        }
+        const providerType = runtime.providerType || this.providerType;
+        const entryEndpoint = this.getEntryEndpointFromRuntime(runtime);
+        // 显式 UA 模式（--codex / --ua codex）：对所有 provider 激活
+        if (normalized === 'codex') {
+            return true;
+        }
+        // 隐式模式：未显式设置 UA 时，仅在 responses provider 且入口不是 /v1/responses 时激活
+        if (providerType === 'responses' && entryEndpoint) {
+            const lowered = entryEndpoint.trim().toLowerCase();
+            if (!lowered.includes('/responses')) {
+                return true;
+            }
+        }
+        return false;
+    }
+    normalizeCodexClientHeaders(headers) {
+        if (!headers) {
+            return undefined;
+        }
+        if (!this.isCodexUaMode()) {
+            return headers;
+        }
+        const normalizedHeaders = { ...headers };
+        this.copyHeaderValue(normalizedHeaders, headers, 'anthropic-session-id', 'session_id');
+        this.copyHeaderValue(normalizedHeaders, headers, 'anthropic-conversation-id', 'conversation_id');
+        this.copyHeaderValue(normalizedHeaders, headers, 'anthropic-user-agent', 'User-Agent');
+        this.copyHeaderValue(normalizedHeaders, headers, 'anthropic-originator', 'originator');
+        return normalizedHeaders;
+    }
+    copyHeaderValue(target, source, from, to) {
+        if (this.findHeaderValue(target, to)) {
+            return;
+        }
+        const value = this.findHeaderValue(source, from);
+        if (value) {
+            target[to] = value;
+        }
+    }
+    findHeaderValue(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;
+    }
+    assignHeader(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;
+    }
+    ensureCodexSessionHeaders(headers, runtimeMetadata) {
+        this.setHeaderIfMissing(headers, 'session_id', this.buildCodexIdentifier('session', runtimeMetadata));
+        this.setHeaderIfMissing(headers, 'conversation_id', this.buildCodexIdentifier('conversation', runtimeMetadata));
+    }
+    setHeaderIfMissing(headers, target, value) {
+        if (this.findHeaderValue(headers, target)) {
+            return;
+        }
+        this.assignHeader(headers, target, value);
+    }
+    buildCodexIdentifier(kind, runtimeMetadata) {
+        const fallbackId = runtimeMetadata?.metadata && typeof runtimeMetadata.metadata === 'object'
+            ? runtimeMetadata.metadata.clientRequestId
+            : undefined;
+        const requestId = runtimeMetadata?.requestId ?? fallbackId;
+        const routeName = runtimeMetadata?.routeName;
+        const suffix = (requestId ?? `req-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`)
+            .toString()
+            .replace(/[^A-Za-z0-9_-]/g, '_');
+        const parts = ['codex_cli', kind, suffix];
+        if (routeName) {
+            parts.push(routeName.replace(/[^A-Za-z0-9_-]/g, '_'));
+        }
+        return this.enforceCodexIdentifierLength(parts.join('_'));
+    }
+    enforceCodexIdentifierLength(value) {
+        if (value.length <= CODEX_IDENTIFIER_MAX_LENGTH) {
+            return value;
+        }
+        const hash = createHash('sha256').update(value).digest('hex').slice(0, 10);
+        const keep = Math.max(1, CODEX_IDENTIFIER_MAX_LENGTH - hash.length - 1);
+        return `${value.slice(0, keep)}_${hash}`;
+    }
     getEffectiveBaseUrl() {
         const runtime = this.getRuntimeProfile();
         const runtimeEndpoint = this.pickRuntimeBaseUrl(runtime);
@@ -934,9 +843,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;
@@ -945,12 +851,23 @@ export class HttpTransportProvider extends BaseProvider {
             : {};
     }
     getEntryEndpointFromPayload(payload) {
-        const metadata = payload.metadata;
-        if (metadata && typeof metadata.entryEndpoint === 'string') {
+        const runtimeMeta = extractProviderRuntimeMetadata(payload);
+        const metadata = (runtimeMeta && typeof runtimeMeta.metadata === 'object')
+            ? runtimeMeta.metadata
+            : payload.metadata;
+        if (metadata && typeof metadata.entryEndpoint === 'string' && metadata.entryEndpoint.trim()) {
             return metadata.entryEndpoint;
         }
         return undefined;
     }
+    getEntryEndpointFromRuntime(runtime) {
+        if (!runtime || !runtime.metadata || typeof runtime.metadata !== 'object') {
+            return undefined;
+        }
+        const meta = runtime.metadata;
+        const value = meta.entryEndpoint;
+        return typeof value === 'string' && value.trim().length ? value : undefined;
+    }
     asResponseRecord(value) {
         if (isRecord(value)) {
             return value;
@@ -1056,5 +973,126 @@ export class HttpTransportProvider extends BaseProvider {
         }
         return providerId;
     }
+    extractClientHeaders(source) {
+        const normalize = (value) => {
+            return this.normalizeClientHeaders(value);
+        };
+        if (!source || typeof source !== 'object') {
+            return undefined;
+        }
+        const candidates = [];
+        const metadataNode = source.metadata;
+        if (metadataNode && typeof metadataNode === 'object') {
+            const headersNode = metadataNode.clientHeaders;
+            if (headersNode) {
+                candidates.push(headersNode);
+            }
+        }
+        const directNode = source.clientHeaders;
+        if (directNode) {
+            candidates.push(directNode);
+        }
+        for (const candidate of candidates) {
+            const normalized = normalize(candidate);
+            if (normalized) {
+                return normalized;
+            }
+        }
+        return undefined;
+    }
+    normalizeClientHeaders(value) {
+        if (!value || typeof value !== 'object') {
+            return undefined;
+        }
+        const normalized = {};
+        for (const [key, raw] of Object.entries(value)) {
+            if (typeof raw === 'string' && raw.trim()) {
+                normalized[key] = raw;
+            }
+        }
+        return Object.keys(normalized).length ? normalized : undefined;
+    }
+    async ensureAntigravityProjectMetadata(oauthAuth) {
+        const tokenFile = typeof oauthAuth?.tokenFile === 'string' ? oauthAuth.tokenFile.trim() : '';
+        if (!tokenFile) {
+            return;
+        }
+        const tokenPath = tokenFile.startsWith('~/')
+            ? tokenFile.replace(/^~\//, `${process.env.HOME || ''}/`)
+            : tokenFile;
+        let raw;
+        try {
+            raw = await fs.readFile(tokenPath, 'utf-8');
+        }
+        catch {
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (this.extractProjectIdFromTokenSnapshot(parsed)) {
+            return;
+        }
+        const accessToken = this.extractAccessTokenFromSnapshot(parsed);
+        if (!accessToken) {
+            return;
+        }
+        const baseOverride = oauthAuth.antigravityApiBase;
+        const apiBaseHint = baseOverride || this.getEffectiveBaseUrl();
+        const projectId = await fetchAntigravityProjectId(accessToken, apiBaseHint);
+        if (!projectId) {
+            logOAuthDebug('[OAuth] Antigravity: unable to resolve project_id for token file');
+            return;
+        }
+        parsed.project_id = projectId;
+        parsed.projectId = projectId;
+        const projectsNode = parsed.projects;
+        if (!Array.isArray(projectsNode) || !projectsNode.length) {
+            parsed.projects = [{ projectId }];
+        }
+        await fs.writeFile(tokenPath, JSON.stringify(parsed, null, 2));
+        logOAuthDebug(`[OAuth] Antigravity: persisted project_id=${projectId} for ${tokenPath}`);
+    }
+    extractAccessTokenFromSnapshot(snapshot) {
+        const lower = snapshot.access_token;
+        const upper = snapshot.AccessToken;
+        const value = typeof lower === 'string'
+            ? lower
+            : typeof upper === 'string'
+                ? upper
+                : undefined;
+        if (value && value.trim()) {
+            return value.trim();
+        }
+        return undefined;
+    }
+    extractProjectIdFromTokenSnapshot(snapshot) {
+        const directNode = snapshot.project_id;
+        const direct = typeof directNode === 'string' ? directNode : undefined;
+        if (direct && direct.trim()) {
+            return direct.trim();
+        }
+        const camelNode = snapshot.projectId;
+        const camel = typeof camelNode === 'string' ? camelNode : undefined;
+        if (camel && camel.trim()) {
+            return camel.trim();
+        }
+        if (Array.isArray(snapshot.projects)) {
+            for (const entry of snapshot.projects ?? []) {
+                if (entry && typeof entry === 'object' && typeof entry.projectId === 'string') {
+                    const candidate = String(entry.projectId);
+                    if (candidate.trim()) {
+                        return candidate.trim();
+                    }
+                }
+            }
+        }
+        return undefined;
+    }
 }
+const CODEX_IDENTIFIER_MAX_LENGTH = 64;
 //# sourceMappingURL=http-transport-provider.js.map