@jsonstudio/rcc 0.89.1803 → 0.89.1959

package/dist/server/runtime/http-server/index.js

@@ -8,12 +8,15 @@
  * - 保持API兼容性
  */
 import express, {} from 'express';
+import * as fs from 'node:fs/promises';
+import path from 'node:path';
 import { ErrorHandlingCenter } from 'rcc-errorhandling';
 import { ProviderFactory } from '../../../providers/core/runtime/provider-factory.js';
 import { PipelineDebugLogger as PipelineDebugLoggerImpl } from '../../../modules/pipeline/utils/debug-logger.js';
 import { attachProviderRuntimeMetadata } from '../../../providers/core/runtime/provider-runtime-metadata.js';
 import { preloadAntigravityAliasUserAgents, primeAntigravityUserAgentVersion } from '../../../providers/auth/antigravity-user-agent.js';
 import { getAntigravityWarmupBlacklistDurationMs, isAntigravityWarmupEnabled, warmupCheckAntigravityAlias } from '../../../providers/auth/antigravity-warmup.js';
+import { shutdownCamoufoxLaunchers } from '../../../providers/core/config/camoufox-launcher.js';
 import { AuthFileResolver } from '../../../config/auth-file-resolver.js';
 import { buildProviderProfiles } from '../../../providers/profile/provider-profile-loader.js';
 import { isStageLoggingEnabled, logPipelineStage } from '../../utils/stage-logger.js';
@@ -22,7 +25,7 @@ import { registerHttpRoutes, registerOAuthPortalRoute } from './routes.js';
 import { mapProviderProtocol, normalizeProviderType, resolveProviderIdentity, asRecord } from './provider-utils.js';
 import { resolveRepoRoot } from './llmswitch-loader.js';
 import { enhanceProviderRequestId } from '../../utils/request-id-manager.js';
-import { convertProviderResponse as bridgeConvertProviderResponse, createSnapshotRecorder as bridgeCreateSnapshotRecorder, rebindResponsesConversationRequestId, extractSessionIdentifiersFromMetadata, bootstrapVirtualRouterConfig, getProviderSuccessCenter, getHubPipelineCtor } from '../../../modules/llmswitch/bridge.js';
+import { convertProviderResponse as bridgeConvertProviderResponse, createSnapshotRecorder as bridgeCreateSnapshotRecorder, rebindResponsesConversationRequestId, extractSessionIdentifiersFromMetadata, bootstrapVirtualRouterConfig, getProviderSuccessCenter, getHubPipelineCtor, resolveClockConfigSnapshot, reserveClockDueTasks, commitClockDueReservation, clearClockTasksSnapshot } from '../../../modules/llmswitch/bridge.js';
 import { initializeRouteErrorHub, reportRouteError } from '../../../error-handling/route-error-hub.js';
 import { writeClientSnapshot } from '../../../providers/core/utils/snapshot-writer.js';
 import { createServerColoredLogger } from './colored-logger.js';
@@ -38,11 +41,71 @@ import { canonicalizeServerId } from './server-id.js';
 import { StatsManager } from './stats-manager.js';
 import { loadRouteCodexConfig } from '../../../config/routecodex-config-loader.js';
 import { buildInfo } from '../../../build-info.js';
+import { getClockClientRegistry } from './clock-client-registry.js';
+import { toExactMatchClockConfig } from './clock-daemon-inject-config.js';
+import { isTmuxSessionAlive, killManagedTmuxSession } from './tmux-session-probe.js';
+import { terminateManagedClientProcess } from './managed-process-probe.js';
 import { recordHubShadowCompareDiff, resolveHubShadowCompareConfig, shouldRunHubShadowCompare } from './hub-shadow-compare.js';
 import { recordLlmsEngineShadowDiff, isLlmsEngineShadowEnabledForSubpath, resolveLlmsEngineShadowConfig, shouldRunLlmsEngineShadowForSubpath } from '../../../utils/llms-engine-shadow.js';
 import { resolveLlmswitchCoreVersion } from '../../../utils/runtime-versions.js';
 const DEFAULT_MAX_PROVIDER_ATTEMPTS = 6;
 const DEFAULT_ANTIGRAVITY_MAX_PROVIDER_ATTEMPTS = 20;
+const RETRYABLE_SSE_ERROR_CODE_HINTS = [
+    'internal_network_failure',
+    'network_error',
+    'api_connection_error',
+    'service_unavailable',
+    'internal_server_error',
+    'overloaded_error',
+    'rate_limit_error',
+    'request_timeout',
+    'timeout'
+];
+const RETRYABLE_SSE_MESSAGE_HINTS = [
+    'internal network failure',
+    'network failure',
+    'network error',
+    'temporarily unavailable',
+    'temporarily unreachable',
+    'upstream disconnected',
+    'connection reset',
+    'connection closed',
+    'timed out',
+    'timeout'
+];
+function firstNonEmptyString(candidates) {
+    for (const candidate of candidates) {
+        if (typeof candidate !== 'string') {
+            continue;
+        }
+        const trimmed = candidate.trim();
+        if (trimmed) {
+            return trimmed;
+        }
+    }
+    return undefined;
+}
+function firstFiniteNumber(candidates) {
+    for (const candidate of candidates) {
+        if (typeof candidate === 'number' && Number.isFinite(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function isRetryableSseWrapperError(message, errorCode, status) {
+    if (typeof status === 'number' && Number.isFinite(status)) {
+        if (status === 408 || status === 425 || status === 429 || status >= 500) {
+            return true;
+        }
+    }
+    const normalizedCode = typeof errorCode === 'string' ? errorCode.trim().toLowerCase() : '';
+    if (normalizedCode && RETRYABLE_SSE_ERROR_CODE_HINTS.some((hint) => normalizedCode.includes(hint))) {
+        return true;
+    }
+    const loweredMessage = message.toLowerCase();
+    return RETRYABLE_SSE_MESSAGE_HINTS.some((hint) => loweredMessage.includes(hint));
+}
 function resolveMaxProviderAttempts() {
     const raw = String(process.env.ROUTECODEX_MAX_PROVIDER_ATTEMPTS || process.env.RCC_MAX_PROVIDER_ATTEMPTS || '')
         .trim()
@@ -116,6 +179,10 @@ export class RouteCodexHttpServer {
     hubPolicyMode = null;
     hubPipelineEngineShadow = null;
     hubPipelineConfigForShadow = null;
+    clockDaemonInjectTimer = null;
+    clockDaemonInjectTickInFlight = false;
+    lastClockDaemonInjectErrorAtMs = 0;
+    lastClockDaemonCleanupAtMs = 0;
     constructor(config) {
         this.config = config;
         this.app = express();
@@ -318,6 +385,9 @@ export class RouteCodexHttpServer {
         if (!patched.defaultModel && profile.metadata?.defaultModel) {
             patched.defaultModel = profile.metadata.defaultModel;
         }
+        if (!patched.deepseek && profile.metadata?.deepseek) {
+            patched.deepseek = profile.metadata.deepseek;
+        }
         return this.canonicalizeRuntimeProvider(patched);
     }
     canonicalizeRuntimeProvider(runtime) {
@@ -499,6 +569,200 @@ export class RouteCodexHttpServer {
         }
         return true;
     }
+    shouldEnableClockDaemonInjectLoop() {
+        const raw = String(process.env.ROUTECODEX_CLOCK_DAEMON_INJECT_ENABLE || process.env.RCC_CLOCK_DAEMON_INJECT_ENABLE || '').trim().toLowerCase();
+        if (raw === '0' || raw === 'false' || raw === 'off' || raw === 'no') {
+            return false;
+        }
+        if (raw === '1' || raw === 'true' || raw === 'on' || raw === 'yes') {
+            return true;
+        }
+        if (process.env.JEST_WORKER_ID || process.env.NODE_ENV === 'test') {
+            return false;
+        }
+        return true;
+    }
+    resolveRawClockConfig() {
+        const user = this.userConfig && typeof this.userConfig === 'object' ? this.userConfig : {};
+        const vr = user.virtualrouter && typeof user.virtualrouter === 'object' ? user.virtualrouter : null;
+        if (vr && Object.prototype.hasOwnProperty.call(vr, 'clock')) {
+            return vr.clock;
+        }
+        if (Object.prototype.hasOwnProperty.call(user, 'clock')) {
+            return user.clock;
+        }
+        const artCfg = this.currentRouterArtifacts &&
+            this.currentRouterArtifacts.config &&
+            typeof this.currentRouterArtifacts.config === 'object'
+            ? this.currentRouterArtifacts.config
+            : null;
+        if (artCfg && Object.prototype.hasOwnProperty.call(artCfg, 'clock')) {
+            return artCfg.clock;
+        }
+        return undefined;
+    }
+    stopClockDaemonInjectLoop() {
+        if (this.clockDaemonInjectTimer) {
+            clearInterval(this.clockDaemonInjectTimer);
+            this.clockDaemonInjectTimer = null;
+        }
+    }
+    startClockDaemonInjectLoop() {
+        this.stopClockDaemonInjectLoop();
+        if (!this.shouldEnableClockDaemonInjectLoop()) {
+            return;
+        }
+        const rawTick = String(process.env.ROUTECODEX_CLOCK_DAEMON_INJECT_TICK_MS || process.env.RCC_CLOCK_DAEMON_INJECT_TICK_MS || '').trim();
+        const parsedTick = rawTick ? Number.parseInt(rawTick, 10) : NaN;
+        const tickMs = Number.isFinite(parsedTick) && parsedTick >= 200 ? Math.floor(parsedTick) : 1500;
+        this.clockDaemonInjectTimer = setInterval(() => {
+            void this.tickClockDaemonInjectLoop();
+        }, tickMs);
+        this.clockDaemonInjectTimer.unref?.();
+        void this.tickClockDaemonInjectLoop();
+    }
+    async tickClockDaemonInjectLoop() {
+        if (this.clockDaemonInjectTickInFlight) {
+            return;
+        }
+        this.clockDaemonInjectTickInFlight = true;
+        try {
+            const rawClockConfig = this.resolveRawClockConfig();
+            const resolvedClockConfig = await resolveClockConfigSnapshot(rawClockConfig);
+            if (!resolvedClockConfig) {
+                return;
+            }
+            const clockConfig = toExactMatchClockConfig(resolvedClockConfig);
+            const sessionDir = String(process.env.ROUTECODEX_SESSION_DIR || '').trim();
+            const clockDir = sessionDir ? path.join(sessionDir, 'clock') : '';
+            const entries = clockDir
+                ? await fs.readdir(clockDir, { withFileTypes: true }).catch(() => [])
+                : [];
+            const registry = getClockClientRegistry();
+            const now = Date.now();
+            const cleanupRequestId = `clock_cleanup_${now}_${Math.random().toString(16).slice(2, 8)}`;
+            const staleCleanup = registry.cleanupStaleHeartbeats({
+                nowMs: now,
+                terminateManagedTmuxSession: (tmuxSessionId) => killManagedTmuxSession(tmuxSessionId),
+                terminateManagedClientProcess: (processInfo) => terminateManagedClientProcess(processInfo)
+            });
+            const deadTmuxCleanup = registry.cleanupDeadTmuxSessions({
+                isTmuxSessionAlive,
+                terminateManagedTmuxSession: (tmuxSessionId) => killManagedTmuxSession(tmuxSessionId),
+                terminateManagedClientProcess: (processInfo) => terminateManagedClientProcess(processInfo)
+            });
+            const removedConversationSessionIds = Array.from(new Set([
+                ...staleCleanup.removedConversationSessionIds,
+                ...deadTmuxCleanup.removedConversationSessionIds
+            ]));
+            if (removedConversationSessionIds.length > 0) {
+                for (const removedConversationSessionId of removedConversationSessionIds) {
+                    await clearClockTasksSnapshot({
+                        sessionId: removedConversationSessionId,
+                        config: clockConfig
+                    });
+                }
+            }
+            const hasCleanupActions = staleCleanup.removedDaemonIds.length > 0
+                || deadTmuxCleanup.removedDaemonIds.length > 0;
+            if (hasCleanupActions && Date.now() - this.lastClockDaemonCleanupAtMs > 2000) {
+                this.lastClockDaemonCleanupAtMs = Date.now();
+                console.log('[RouteCodexHttpServer] clock daemon cleanup audit:', {
+                    requestId: cleanupRequestId,
+                    staleHeartbeat: {
+                        reason: 'heartbeat_timeout',
+                        staleAfterMs: staleCleanup.staleAfterMs,
+                        removedDaemonIds: staleCleanup.removedDaemonIds,
+                        removedTmuxSessionIds: staleCleanup.removedTmuxSessionIds,
+                        removedConversationSessionIds: staleCleanup.removedConversationSessionIds,
+                        killedTmuxSessionIds: staleCleanup.killedTmuxSessionIds,
+                        failedKillTmuxSessionIds: staleCleanup.failedKillTmuxSessionIds,
+                        skippedKillTmuxSessionIds: staleCleanup.skippedKillTmuxSessionIds,
+                        killedManagedClientPids: staleCleanup.killedManagedClientPids,
+                        failedKillManagedClientPids: staleCleanup.failedKillManagedClientPids,
+                        skippedKillManagedClientPids: staleCleanup.skippedKillManagedClientPids
+                    },
+                    deadTmux: {
+                        reason: 'tmux_not_alive',
+                        removedDaemonIds: deadTmuxCleanup.removedDaemonIds,
+                        removedTmuxSessionIds: deadTmuxCleanup.removedTmuxSessionIds,
+                        removedConversationSessionIds: deadTmuxCleanup.removedConversationSessionIds,
+                        killedTmuxSessionIds: deadTmuxCleanup.killedTmuxSessionIds,
+                        failedKillTmuxSessionIds: deadTmuxCleanup.failedKillTmuxSessionIds,
+                        skippedKillTmuxSessionIds: deadTmuxCleanup.skippedKillTmuxSessionIds,
+                        killedManagedClientPids: deadTmuxCleanup.killedManagedClientPids,
+                        failedKillManagedClientPids: deadTmuxCleanup.failedKillManagedClientPids,
+                        skippedKillManagedClientPids: deadTmuxCleanup.skippedKillManagedClientPids
+                    }
+                });
+            }
+            for (const entry of entries) {
+                if (!entry || typeof entry.name !== 'string') {
+                    continue;
+                }
+                if (!entry.name.endsWith('.json')) {
+                    continue;
+                }
+                if (typeof entry.isFile === 'function' && !entry.isFile()) {
+                    continue;
+                }
+                const sessionId = entry.name.slice(0, -'.json'.length).trim();
+                if (!sessionId) {
+                    continue;
+                }
+                const reservationId = 'clockd_inject_' + now + '_' + Math.random().toString(16).slice(2, 8);
+                const reserved = await reserveClockDueTasks({
+                    reservationId,
+                    sessionId,
+                    config: clockConfig,
+                    requestId: reservationId
+                });
+                if (!reserved || !reserved.reservation || typeof reserved.injectText !== 'string' || !reserved.injectText.trim()) {
+                    continue;
+                }
+                const bind = registry.bindConversationSession({ conversationSessionId: sessionId });
+                const text = [
+                    '[Clock Reminder]: scheduled tasks are due.',
+                    reserved.injectText.trim(),
+                    'You may call tools to complete these tasks.',
+                    'MANDATORY: if waiting is needed, use the clock tool to schedule wake-up (clock.schedule) now; do not only promise to wait.'
+                ].join('\n');
+                const injected = await registry.inject({
+                    sessionId,
+                    text,
+                    requestId: reservationId,
+                    source: 'clock.daemon.inject'
+                });
+                if (!injected.ok) {
+                    const nowWarn = Date.now();
+                    if (nowWarn - this.lastClockDaemonInjectErrorAtMs > 5000) {
+                        this.lastClockDaemonInjectErrorAtMs = nowWarn;
+                        console.warn('[RouteCodexHttpServer] clock daemon inject skipped:', {
+                            sessionId,
+                            injectReason: injected.reason,
+                            bindOk: bind.ok,
+                            bindReason: bind.reason
+                        });
+                    }
+                    continue;
+                }
+                await commitClockDueReservation({
+                    reservation: reserved.reservation,
+                    config: clockConfig
+                });
+            }
+        }
+        catch (error) {
+            const now = Date.now();
+            if (now - this.lastClockDaemonInjectErrorAtMs > 5000) {
+                this.lastClockDaemonInjectErrorAtMs = now;
+                console.warn('[RouteCodexHttpServer] clock daemon inject loop tick failed:', error);
+            }
+        }
+        finally {
+            this.clockDaemonInjectTickInFlight = false;
+        }
+    }
     /**
      * 初始化服务器
      */
@@ -610,7 +874,12 @@ export class RouteCodexHttpServer {
         return new Promise((resolve, reject) => {
             this.server = this.app.listen(this.config.server.port, this.config.server.host, () => {
                 this._isRunning = true;
-                console.log(`[RouteCodexHttpServer] Server started on ${this.config.server.host}:${this.config.server.port}`);
+                const boundAddress = this.server?.address();
+                const resolvedPort = boundAddress && typeof boundAddress === 'object' && typeof boundAddress.port === 'number'
+                    ? boundAddress.port
+                    : this.config.server.port;
+                process.env.ROUTECODEX_SERVER_PORT = String(resolvedPort);
+                console.log(`[RouteCodexHttpServer] Server started on ${this.config.server.host}:${resolvedPort}`);
                 resolve();
             });
             // In test runners (Jest), prevent the listen handle from keeping the process alive
@@ -639,6 +908,16 @@ export class RouteCodexHttpServer {
      * 停止服务器
      */
     async stop() {
+        this.stopClockDaemonInjectLoop();
+        try {
+            await shutdownCamoufoxLaunchers();
+        }
+        catch {
+            // ignore launcher cleanup errors
+        }
+        if (!this.server) {
+            return;
+        }
         if (this.server) {
             // Best-effort: close any open keep-alive sockets so server.close can finish.
             for (const socket of this.activeSockets) {
@@ -879,6 +1158,7 @@ export class RouteCodexHttpServer {
         this.hubPipelineConfigForShadow = hubConfig;
         this.hubPipelineEngineShadow = null;
         await this.initializeProviderRuntimes(bootstrapArtifacts);
+        this.startClockDaemonInjectLoop();
     }
     buildHandlerContext() {
         return {
@@ -1177,6 +1457,21 @@ export class RouteCodexHttpServer {
             if (rawType === 'iflow-cookie') {
                 return { ...auth, type: 'apikey', rawType: auth.rawType ?? 'iflow-cookie' };
             }
+            if (rawType === 'deepseek-account') {
+                // Compatibility note:
+                // legacy deepseek configs may still carry value/secretRef/mobile/password/clientId/clientSecret.
+                // Runtime auth for deepseek-account is tokenFile(+alias)-only; we strip legacy fields instead of
+                // failing init so existing deployments can migrate without downtime.
+                const tokenFile = pickString(authRecord.tokenFile, authRecord.token_file);
+                const accountAlias = pickString(authRecord.accountAlias, authRecord.account_alias, runtime.keyAlias);
+                return {
+                    type: 'apikey',
+                    rawType: auth.rawType ?? 'deepseek-account',
+                    value: '',
+                    ...(accountAlias ? { accountAlias } : {}),
+                    ...(tokenFile ? { tokenFile } : {})
+                };
+            }
             const value = await this.resolveApiKeyValue(runtime, auth);
             return { ...auth, type: 'apikey', value };
         }
@@ -1267,6 +1562,7 @@ export class RouteCodexHttpServer {
             }
         }));
         this.providerHandles.clear();
+        ProviderFactory.clearInstanceCache?.();
     }
     async executePipeline(input) {
         if (!this.isPipelineReady()) {
@@ -1337,7 +1633,26 @@ export class RouteCodexHttpServer {
                 stream: metadataForIteration.stream
             });
             const originalRequestSnapshot = this.cloneRequestPayload(input.body);
-            const pipelineResult = await this.runHubPipeline(input, metadataForIteration);
+            let pipelineResult;
+            try {
+                pipelineResult = await this.runHubPipeline(input, metadataForIteration);
+            }
+            catch (pipelineError) {
+                const pipelineErrorCode = typeof pipelineError.code === 'string'
+                    ? String(pipelineError.code).trim()
+                    : '';
+                const pipelineErrorMessage = pipelineError instanceof Error
+                    ? pipelineError.message
+                    : String(pipelineError ?? 'Unknown error');
+                const isPoolExhaustedError = pipelineErrorCode === 'PROVIDER_NOT_AVAILABLE' ||
+                    pipelineErrorCode === 'ERR_NO_PROVIDER_TARGET' ||
+                    /all providers unavailable/i.test(pipelineErrorMessage) ||
+                    /virtual router did not produce a provider target/i.test(pipelineErrorMessage);
+                if (firstError && isPoolExhaustedError) {
+                    throw firstError;
+                }
+                throw pipelineError;
+            }
             const pipelineMetadata = pipelineResult.metadata ?? {};
             const mergedMetadata = { ...metadataForIteration, ...pipelineMetadata };
             this.logStage(`${pipelineLabel}.completed`, providerRequestId, {
@@ -1370,6 +1685,33 @@ export class RouteCodexHttpServer {
                     requestId: input.requestId,
                     retryable: true
                 });
+                try {
+                    const { emitProviderError } = await import('../../../providers/core/utils/provider-error-reporter.js');
+                    emitProviderError({
+                        error,
+                        stage: 'provider.runtime.resolve',
+                        runtime: {
+                            requestId: input.requestId,
+                            providerKey: target.providerKey,
+                            providerId: target.providerKey.split('.')[0],
+                            providerType: String(target.providerType || 'unknown'),
+                            providerProtocol: String(target.outboundProfile || ''),
+                            routeName: pipelineResult.routingDecision?.routeName,
+                            pipelineId: target.providerKey,
+                            target
+                        },
+                        dependencies: this.getModuleDependencies(),
+                        recoverable: false,
+                        affectsHealth: true,
+                        details: {
+                            reason: 'runtime_not_initialized',
+                            providerKey: target.providerKey
+                        }
+                    });
+                }
+                catch {
+                    // best-effort
+                }
                 if (!firstError) {
                     firstError = error;
                 }
@@ -1393,6 +1735,35 @@ export class RouteCodexHttpServer {
                     requestId: input.requestId,
                     retryable: true
                 });
+                try {
+                    const { emitProviderError } = await import('../../../providers/core/utils/provider-error-reporter.js');
+                    emitProviderError({
+                        error: initError ?? error,
+                        stage: 'provider.runtime.resolve',
+                        runtime: {
+                            requestId: input.requestId,
+                            providerKey: target.providerKey,
+                            providerId: target.providerKey.split('.')[0],
+                            providerType: String(target.providerType || 'unknown'),
+                            providerProtocol: String(target.outboundProfile || ''),
+                            routeName: pipelineResult.routingDecision?.routeName,
+                            pipelineId: target.providerKey,
+                            runtimeKey,
+                            target
+                        },
+                        dependencies: this.getModuleDependencies(),
+                        recoverable: false,
+                        affectsHealth: true,
+                        details: {
+                            reason: 'runtime_handle_missing',
+                            providerKey: target.providerKey,
+                            runtimeKey
+                        }
+                    });
+                }
+                catch {
+                    // best-effort
+                }
                 if (!firstError) {
                     firstError = error;
                 }
@@ -1511,6 +1882,61 @@ export class RouteCodexHttpServer {
                     response: normalized,
                     pipelineMetadata: mergedMetadata
                 });
+                // Treat upstream 429 as provider failure across protocols to avoid
+                // silently returning success and to let Virtual Router failover to other candidates.
+                // Keep existing Gemini compatibility behavior for 400/4xx thoughtSignature-like failures.
+                const convertedStatus = typeof converted.status === 'number' ? converted.status : undefined;
+                const isGlobalRetryable429 = convertedStatus === 429;
+                const isGeminiCompatFailure = typeof convertedStatus === 'number' &&
+                    convertedStatus >= 400 &&
+                    (isAntigravityProviderKey(target.providerKey) ||
+                        (typeof target.providerKey === 'string' && target.providerKey.startsWith('gemini-cli.'))) &&
+                    providerProtocol === 'gemini-chat';
+                if (isGlobalRetryable429 || isGeminiCompatFailure) {
+                    const bodyForError = converted.body && typeof converted.body === 'object'
+                        ? converted.body
+                        : undefined;
+                    const errMsg = bodyForError && bodyForError.error && typeof bodyForError.error === 'object'
+                        ? String(bodyForError.error.message || bodyForError.error || '')
+                        : '';
+                    const statusCode = typeof convertedStatus === 'number' ? convertedStatus : 500;
+                    const errorToThrow = new Error(errMsg && errMsg.trim().length ? errMsg : `HTTP ${statusCode}`);
+                    errorToThrow.statusCode = statusCode;
+                    errorToThrow.status = statusCode;
+                    errorToThrow.response = { data: bodyForError };
+                    try {
+                        const { emitProviderError } = await import('../../../providers/core/utils/provider-error-reporter.js');
+                        emitProviderError({
+                            error: errorToThrow,
+                            stage: 'provider.http',
+                            runtime: {
+                                requestId: input.requestId,
+                                providerKey: target.providerKey,
+                                providerId: handle.providerId,
+                                providerType: handle.providerType,
+                                providerFamily: handle.providerFamily,
+                                providerProtocol,
+                                routeName: pipelineResult.routingDecision?.routeName,
+                                pipelineId: target.providerKey,
+                                target,
+                                runtimeKey
+                            },
+                            dependencies: this.getModuleDependencies(),
+                            statusCode,
+                            recoverable: statusCode === 429,
+                            affectsHealth: true,
+                            details: {
+                                source: 'converted_response_status',
+                                convertedStatus: statusCode,
+                                wrappedErrorResponse: true
+                            }
+                        });
+                    }
+                    catch {
+                        // best-effort; never block retry/failover path
+                    }
+                    throw errorToThrow;
+                }
                 const usage = this.extractUsageFromResult(converted, mergedMetadata);
                 // QuotaManager listens to provider error/success events; avoid duplicating accounting here.
                 this.stats.recordCompletion(statsRequestId, { usage, error: false });
@@ -2000,12 +2426,21 @@ export class RouteCodexHttpServer {
         if (body && typeof body === 'object') {
             const wrapperError = this.extractSseWrapperError(body);
             if (wrapperError) {
-                const error = new Error(`[RouteCodexHttpServer] Upstream SSE terminated: ${wrapperError}`);
+                const codeSuffix = wrapperError.errorCode ? ` [${wrapperError.errorCode}]` : '';
+                const error = new Error(`Upstream SSE error event${codeSuffix}: ${wrapperError.message}`);
                 error.code = 'SSE_DECODE_ERROR';
+                if (wrapperError.errorCode) {
+                    error.upstreamCode = wrapperError.errorCode;
+                }
+                error.retryable = wrapperError.retryable;
+                if (wrapperError.retryable) {
+                    error.status = 503;
+                    error.statusCode = 503;
+                }
                 throw error;
             }
         }
-        if (options.processMode === 'passthrough') {
+        if (options.processMode === 'passthrough' && !options.wantsStream) {
             return options.response;
         }
         const entry = (options.entryEndpoint || '').toLowerCase();
@@ -2039,6 +2474,12 @@ export class RouteCodexHttpServer {
             const baseContext = {
                 ...(metadataBag ?? {})
             };
+            if (baseContext.capturedChatRequest === undefined &&
+                options.originalRequest &&
+                typeof options.originalRequest === 'object' &&
+                !Array.isArray(options.originalRequest)) {
+                baseContext.capturedChatRequest = options.originalRequest;
+            }
             // 将 HubPipeline metadata.routeName 映射为 AdapterContext.routeId，
             // 便于 llmswitch-core 在第三跳中使用 routeHint 复用首次路由决策。
             if (typeof metadataBag?.routeName === 'string') {
@@ -2181,10 +2622,11 @@ export class RouteCodexHttpServer {
         if (!record || typeof record !== 'object' || depth < 0) {
             return undefined;
         }
-        const mode = record.mode;
-        const errVal = record.error;
-        if (mode === 'sse' && typeof errVal === 'string' && errVal.trim()) {
-            return errVal.trim();
+        if (record.mode === 'sse') {
+            const normalized = this.normalizeSseWrapperErrorValue(record.error, depth);
+            if (normalized) {
+                return normalized;
+            }
         }
         const nestedKeys = ['body', 'data', 'payload', 'response'];
         for (const key of nestedKeys) {
@@ -2199,6 +2641,89 @@ export class RouteCodexHttpServer {
         }
         return undefined;
     }
+    normalizeSseWrapperErrorValue(value, depth) {
+        if (value === undefined || value === null || depth < 0) {
+            return undefined;
+        }
+        if (typeof value === 'string') {
+            const trimmed = value.trim();
+            if (!trimmed) {
+                return undefined;
+            }
+            if (depth > 0 && (trimmed.startsWith('{') || trimmed.startsWith('['))) {
+                try {
+                    const parsed = JSON.parse(trimmed);
+                    const parsedInfo = this.normalizeSseWrapperErrorValue(parsed, depth - 1);
+                    if (parsedInfo) {
+                        return parsedInfo;
+                    }
+                }
+                catch {
+                    // fallback to raw string
+                }
+            }
+            return {
+                message: trimmed,
+                retryable: isRetryableSseWrapperError(trimmed)
+            };
+        }
+        if (typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const record = value;
+        const directMessage = firstNonEmptyString([
+            record.message,
+            record.error_message,
+            record.errorMessage
+        ]);
+        const directCode = firstNonEmptyString([
+            record.code,
+            record.error_code,
+            record.errorCode,
+            record.type
+        ]);
+        const directStatus = firstFiniteNumber([
+            record.status,
+            record.statusCode,
+            record.status_code,
+            record.http_status
+        ]);
+        if (depth > 0) {
+            for (const key of ['error', 'data', 'payload', 'details', 'body', 'response']) {
+                const nestedInfo = this.normalizeSseWrapperErrorValue(record[key], depth - 1);
+                if (nestedInfo) {
+                    const mergedCode = nestedInfo.errorCode ?? directCode;
+                    const retryable = nestedInfo.retryable || isRetryableSseWrapperError(nestedInfo.message, mergedCode, directStatus);
+                    return {
+                        message: nestedInfo.message,
+                        ...(mergedCode ? { errorCode: mergedCode } : {}),
+                        retryable
+                    };
+                }
+            }
+        }
+        if (directMessage) {
+            return {
+                message: directMessage,
+                ...(directCode ? { errorCode: directCode } : {}),
+                retryable: isRetryableSseWrapperError(directMessage, directCode, directStatus)
+            };
+        }
+        try {
+            const serialized = JSON.stringify(record);
+            if (serialized && serialized !== '{}') {
+                return {
+                    message: serialized,
+                    ...(directCode ? { errorCode: directCode } : {}),
+                    retryable: isRetryableSseWrapperError(serialized, directCode, directStatus)
+                };
+            }
+        }
+        catch {
+            // ignore stringify failures
+        }
+        return undefined;
+    }
     extractClientModelId(metadata, originalRequest) {
         const candidates = [
             metadata.clientModelId,