@jsonstudio/rcc 0.85.9 → 0.89.164

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

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * RouteCodex Server V2 - 渐进式重构版本
  *
@@ -10,21 +9,29 @@
  */
 import express, {} from 'express';
 import { ErrorHandlingCenter } from 'rcc-errorhandling';
-import { ProviderFactory } from '../../../modules/pipeline/modules/provider/v2/core/provider-factory.js';
-import { attachProviderRuntimeMetadata } from '../../../modules/pipeline/modules/provider/v2/core/provider-runtime-metadata.js';
+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 { extractAnthropicToolAliasMap } from './anthropic-tool-alias.js';
 import { AuthFileResolver } from '../../../config/auth-file-resolver.js';
-import { emitProviderError } from '../../../modules/pipeline/modules/provider/v2/utils/provider-error-reporter.js';
+import { buildProviderProfiles } from '../../../providers/profile/provider-profile-loader.js';
+import { emitProviderError } from '../../../providers/core/utils/provider-error-reporter.js';
 import { isStageLoggingEnabled, logPipelineStage } from '../../utils/stage-logger.js';
 import { registerDefaultMiddleware } from './middleware.js';
 import { registerHttpRoutes } from './routes.js';
-import { mapProviderProtocol, normalizeProviderType, asRecord } from './provider-utils.js';
+import { mapProviderProtocol, normalizeProviderType, resolveProviderIdentity, asRecord } from './provider-utils.js';
 import { resolveRepoRoot, loadLlmswitchModule } from './llmswitch-loader.js';
 import { importCoreModule } from '../../../modules/llmswitch/core-loader.js';
-import { writeClientSnapshot } from '../../../modules/pipeline/modules/provider/v2/utils/snapshot-writer.js';
+import { enhanceProviderRequestId } from '../../utils/request-id-manager.js';
+import { rebindResponsesConversationRequestId } 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';
 let convertProviderResponseFn = null;
 async function loadConvertProviderResponse() {
-    if (convertProviderResponseFn)
+    if (convertProviderResponseFn) {
         return convertProviderResponseFn;
+    }
     const mod = await importCoreModule('conversion/hub/response/provider-response');
     if (!mod?.convertProviderResponse) {
         throw new Error('[RouteCodexHttpServer] llmswitch-core 缺少 convertProviderResponse 实现');
@@ -34,8 +41,9 @@ async function loadConvertProviderResponse() {
 }
 let createSnapshotRecorderFn = null;
 async function loadSnapshotRecorderFactory() {
-    if (createSnapshotRecorderFn)
+    if (createSnapshotRecorderFn) {
         return createSnapshotRecorderFn;
+    }
     const mod = await importCoreModule('conversion/hub/snapshot-recorder');
     if (!mod?.createSnapshotRecorder) {
         throw new Error('[RouteCodexHttpServer] llmswitch-core 缺少 createSnapshotRecorder 实现');
@@ -67,6 +75,10 @@ export class RouteCodexHttpServer {
     stageLoggingEnabled;
     repoRoot;
     currentRouterArtifacts = null;
+    providerProfileIndex = new Map();
+    errorHandlingShim = null;
+    routeErrorHub = null;
+    coloredLogger = createServerColoredLogger();
     constructor(config) {
         this.config = config;
         this.app = express();
@@ -77,6 +89,13 @@ export class RouteCodexHttpServer {
         if (config.pipeline?.useHubPipeline === false || envFlag === '0' || envFlag === 'false') {
             console.warn('[RouteCodexHttpServer] Super pipeline has been removed; falling back to Hub pipeline.');
         }
+        try {
+            this.pipelineLogger = new PipelineDebugLoggerImpl({ colored: this.coloredLogger }, { enableConsoleLogging: true });
+        }
+        catch (error) {
+            console.warn('[RouteCodexHttpServer] Failed to initialize PipelineDebugLogger; falling back to noop logger.', error);
+            this.pipelineLogger = createNoopPipelineLogger();
+        }
         console.log('[RouteCodexHttpServer] Initialized (pipeline=hub)');
     }
     resolveVirtualRouterInput(userConfig) {
@@ -88,13 +107,30 @@ export class RouteCodexHttpServer {
     getModuleDependencies() {
         if (!this.moduleDependencies) {
             this.moduleDependencies = {
-                errorHandlingCenter: this.errorHandling,
+                errorHandlingCenter: this.getErrorHandlingShim(),
                 debugCenter: this.createDebugCenterShim(),
                 logger: this.pipelineLogger
             };
         }
         return this.moduleDependencies;
     }
+    getErrorHandlingShim() {
+        if (!this.errorHandlingShim) {
+            this.errorHandlingShim = {
+                handleError: async (errorPayload, contextPayload) => {
+                    const sanitizedError = formatErrorForErrorCenter(errorPayload);
+                    const sanitizedContext = formatErrorForErrorCenter(contextPayload);
+                    await this.errorHandling.handleError({
+                        error: sanitizedError,
+                        context: sanitizedContext
+                    });
+                },
+                createContext: () => ({}),
+                getStatistics: () => ({})
+            };
+        }
+        return this.errorHandlingShim;
+    }
     createDebugCenterShim() {
         return {
             logDebug: () => { },
@@ -104,12 +140,132 @@ export class RouteCodexHttpServer {
             getLogs: () => []
         };
     }
+    updateProviderProfiles(collection, rawConfig) {
+        this.providerProfileIndex.clear();
+        const source = collection ?? this.tryBuildProfiles(rawConfig);
+        if (!source) {
+            return;
+        }
+        for (const profile of source.profiles) {
+            if (profile && typeof profile.id === 'string' && profile.id.trim()) {
+                this.providerProfileIndex.set(profile.id.trim(), profile);
+            }
+        }
+    }
+    ensureProviderProfilesFromUserConfig() {
+        if (this.providerProfileIndex.size > 0) {
+            return;
+        }
+        const fallback = this.tryBuildProfiles(this.userConfig);
+        if (!fallback) {
+            return;
+        }
+        for (const profile of fallback.profiles) {
+            if (profile && typeof profile.id === 'string' && profile.id.trim()) {
+                this.providerProfileIndex.set(profile.id.trim(), profile);
+            }
+        }
+    }
+    tryBuildProfiles(config) {
+        if (!config) {
+            return null;
+        }
+        try {
+            return buildProviderProfiles(config);
+        }
+        catch {
+            return null;
+        }
+    }
+    findProviderProfile(runtime) {
+        const candidates = new Set();
+        const pushCandidate = (value) => {
+            if (typeof value === 'string' && value.trim()) {
+                candidates.add(value.trim());
+            }
+        };
+        pushCandidate(runtime.providerId);
+        if (runtime.providerKey && runtime.providerKey.includes('.')) {
+            pushCandidate(runtime.providerKey.split('.')[0]);
+        }
+        if (runtime.runtimeKey && runtime.runtimeKey.includes('.')) {
+            pushCandidate(runtime.runtimeKey.split('.')[0]);
+        }
+        for (const candidate of candidates) {
+            const profile = this.providerProfileIndex.get(candidate);
+            if (profile) {
+                return profile;
+            }
+        }
+        return undefined;
+    }
+    applyProviderProfileOverrides(runtime) {
+        const profile = this.findProviderProfile(runtime);
+        if (!profile) {
+            return this.canonicalizeRuntimeProvider(runtime);
+        }
+        const patched = { ...runtime };
+        const originalFamily = patched.providerFamily || patched.providerType;
+        patched.providerFamily = originalFamily;
+        patched.providerType = profile.protocol;
+        if (profile.moduleType && profile.moduleType.trim()) {
+            patched.providerModule = profile.moduleType.trim();
+        }
+        if (!patched.baseUrl && profile.transport.baseUrl) {
+            patched.baseUrl = profile.transport.baseUrl;
+        }
+        if (!patched.endpoint && profile.transport.endpoint) {
+            patched.endpoint = profile.transport.endpoint;
+        }
+        if (!patched.headers && profile.transport.headers) {
+            patched.headers = profile.transport.headers;
+        }
+        if (!patched.compatibilityProfile && profile.compatibilityProfile) {
+            patched.compatibilityProfile = profile.compatibilityProfile;
+        }
+        if (!patched.defaultModel && profile.metadata?.defaultModel) {
+            patched.defaultModel = profile.metadata.defaultModel;
+        }
+        return this.canonicalizeRuntimeProvider(patched);
+    }
+    canonicalizeRuntimeProvider(runtime) {
+        const { providerType, providerFamily } = resolveProviderIdentity(runtime.providerType, runtime.providerFamily);
+        return {
+            ...runtime,
+            providerType: providerType,
+            providerFamily
+        };
+    }
     logStage(stage, requestId, details) {
         if (!this.stageLoggingEnabled) {
             return;
         }
         logPipelineStage(stage, requestId, details);
     }
+    extractProviderModel(payload) {
+        if (!payload) {
+            return undefined;
+        }
+        const source = payload.data && typeof payload.data === 'object'
+            ? payload.data
+            : payload;
+        const raw = source.model;
+        if (typeof raw === 'string' && raw.trim()) {
+            return raw.trim();
+        }
+        return undefined;
+    }
+    buildProviderLabel(providerKey, model) {
+        const key = typeof providerKey === 'string' && providerKey.trim() ? providerKey.trim() : undefined;
+        const modelId = typeof model === 'string' && model.trim() ? model.trim() : undefined;
+        if (!key && !modelId) {
+            return undefined;
+        }
+        if (key && modelId) {
+            return `${key}.${modelId}`;
+        }
+        return key || modelId;
+    }
     normalizeAuthType(input) {
         const value = typeof input === 'string' ? input.toLowerCase() : '';
         if (value.includes('oauth')) {
@@ -172,6 +328,7 @@ export class RouteCodexHttpServer {
             console.log('[RouteCodexHttpServer] Starting initialization...');
             // 初始化错误处理
             await this.errorHandling.initialize();
+            await this.initializeRouteErrorHub();
             registerDefaultMiddleware(this.app);
             registerHttpRoutes({
                 app: this.app,
@@ -260,34 +417,39 @@ export class RouteCodexHttpServer {
      * 处理错误
      */
     async handleError(error, context) {
+        const payload = {
+            code: `SERVER_${context.toUpperCase()}`,
+            message: error.message || 'RouteCodex server error',
+            source: `routecodex-server-v2.${context}`,
+            scope: 'server',
+            severity: 'medium',
+            details: {
+                name: error.name,
+                stack: error.stack,
+                version: 'v2'
+            },
+            originalError: error
+        };
         try {
-            await this.errorHandling.handleError({
-                error: error.message,
-                source: `routecodex-server-v2.${context}`,
-                severity: 'medium',
-                timestamp: Date.now(),
-                moduleId: 'routecodex-server-v2',
-                context: {
-                    stack: error.stack,
-                    name: error.name,
-                    version: 'v2'
-                },
-            });
+            await reportRouteError(payload);
         }
         catch (handlerError) {
-            console.error('[RouteCodexHttpServer] Failed to handle error:', handlerError);
+            console.error('[RouteCodexHttpServer] Failed to report error via RouteErrorHub:', handlerError);
             console.error('[RouteCodexHttpServer] Original error:', error);
         }
     }
     // --- V1 parity helpers and attach methods ---
-    async initializeWithUserConfig(userConfig) {
+    async initializeWithUserConfig(userConfig, context) {
+        this.updateProviderProfiles(context?.providerProfiles, userConfig);
         await this.setupRuntime(userConfig);
     }
-    async reloadRuntime(userConfig) {
+    async reloadRuntime(userConfig, context) {
+        this.updateProviderProfiles(context?.providerProfiles, userConfig);
         await this.setupRuntime(userConfig);
     }
     async setupRuntime(userConfig) {
         this.userConfig = asRecord(userConfig);
+        this.ensureProviderProfilesFromUserConfig();
         const routerInput = this.resolveVirtualRouterInput(this.userConfig);
         const bootstrapArtifacts = await this.bootstrapVirtualRouter(routerInput);
         this.currentRouterArtifacts = bootstrapArtifacts;
@@ -314,29 +476,33 @@ export class RouteCodexHttpServer {
         await this.disposeProviders();
         this.providerKeyToRuntimeKey.clear();
         for (const [providerKey, runtime] of Object.entries(runtimeMap)) {
-            if (!runtime)
+            if (!runtime) {
                 continue;
+            }
             const runtimeKey = runtime.runtimeKey || providerKey;
             if (!this.providerHandles.has(runtimeKey)) {
                 const resolvedRuntime = await this.materializeRuntimeProfile(runtime);
-                const handle = await this.createProviderHandle(runtimeKey, resolvedRuntime);
+                const patchedRuntime = this.applyProviderProfileOverrides(resolvedRuntime);
+                const handle = await this.createProviderHandle(runtimeKey, patchedRuntime);
                 this.providerHandles.set(runtimeKey, handle);
             }
             this.providerKeyToRuntimeKey.set(providerKey, runtimeKey);
         }
     }
     async createProviderHandle(runtimeKey, runtime) {
-        const providerType = normalizeProviderType(runtime.providerType);
+        const protocolType = normalizeProviderType(runtime.providerType);
+        const providerFamily = runtime.providerFamily || protocolType;
         const providerProtocol = (typeof runtime.outboundProfile === 'string' && runtime.outboundProfile.trim()
             ? runtime.outboundProfile.trim()
-            : undefined) ?? mapProviderProtocol(providerType);
+            : undefined) ?? mapProviderProtocol(protocolType);
         const instance = ProviderFactory.createProviderFromRuntime(runtime, this.getModuleDependencies());
         await instance.initialize();
         const providerId = runtime.providerId || runtimeKey.split('.')[0];
         return {
             runtimeKey,
             providerId,
-            providerType,
+            providerType: protocolType,
+            providerFamily,
             providerProtocol,
             runtime,
             instance
@@ -345,11 +511,12 @@ export class RouteCodexHttpServer {
     async materializeRuntimeProfile(runtime) {
         const auth = await this.resolveRuntimeAuth(runtime);
         const baseUrl = this.normalizeRuntimeBaseUrl(runtime);
-        const providerType = normalizeProviderType(runtime.providerType);
+        const identity = resolveProviderIdentity(runtime.providerType, runtime.providerFamily);
         return {
             ...runtime,
             ...(baseUrl ? { baseUrl } : {}),
-            providerType,
+            providerType: identity.providerType,
+            providerFamily: identity.providerFamily,
             auth
         };
     }
@@ -364,6 +531,7 @@ export class RouteCodexHttpServer {
     }
     async resolveRuntimeAuth(runtime) {
         const auth = runtime.auth || { type: 'apikey' };
+        const authRecord = auth;
         const authType = this.normalizeAuthType(auth.type);
         const pickString = (...candidates) => {
             for (const candidate of candidates) {
@@ -377,8 +545,9 @@ export class RouteCodexHttpServer {
             return undefined;
         };
         const pickStringArray = (value) => {
-            if (!value)
+            if (!value) {
                 return undefined;
+            }
             if (Array.isArray(value)) {
                 const normalized = value
                     .map((item) => pickString(item))
@@ -404,15 +573,15 @@ export class RouteCodexHttpServer {
             value: auth.value,
             oauthProviderId: auth.oauthProviderId,
             rawType: auth.rawType,
-            tokenFile: pickString(auth.tokenFile ?? auth.token_file),
-            tokenUrl: pickString(auth.tokenUrl ?? auth.token_url),
-            deviceCodeUrl: pickString(auth.deviceCodeUrl ?? auth.device_code_url),
-            clientId: pickString(auth.clientId ?? auth.client_id),
-            clientSecret: pickString(auth.clientSecret ?? auth.client_secret),
-            authorizationUrl: pickString(auth.authorizationUrl ?? auth.authorization_url ?? auth.authUrl),
-            userInfoUrl: pickString(auth.userInfoUrl ?? auth.user_info_url),
-            refreshUrl: pickString(auth.refreshUrl ?? auth.refresh_url),
-            scopes: pickStringArray(auth.scopes ?? auth.scope)
+            tokenFile: pickString(authRecord.tokenFile, authRecord.token_file),
+            tokenUrl: pickString(authRecord.tokenUrl, authRecord.token_url),
+            deviceCodeUrl: pickString(authRecord.deviceCodeUrl, authRecord.device_code_url),
+            clientId: pickString(authRecord.clientId, authRecord.client_id),
+            clientSecret: pickString(authRecord.clientSecret, authRecord.client_secret),
+            authorizationUrl: pickString(authRecord.authorizationUrl, authRecord.authorization_url, authRecord.authUrl),
+            userInfoUrl: pickString(authRecord.userInfoUrl, authRecord.user_info_url),
+            refreshUrl: pickString(authRecord.refreshUrl, authRecord.refresh_url),
+            scopes: pickStringArray(authRecord.scopes ?? authRecord.scope)
         };
         let tokenFile = resolved.tokenFile;
         if (!tokenFile && typeof auth.secretRef === 'string' && auth.secretRef.trim()) {
@@ -450,14 +619,20 @@ export class RouteCodexHttpServer {
         if (!this.isPipelineReady()) {
             throw new Error('Hub pipeline runtime is not initialized');
         }
-        this.logStage('request.received', input.requestId, {
+        const metadata = this.buildRequestMetadata(input);
+        const providerRequestId = input.requestId;
+        const clientRequestId = typeof metadata.clientRequestId === 'string' && metadata.clientRequestId.trim()
+            ? metadata.clientRequestId.trim()
+            : providerRequestId;
+        this.logStage('request.received', providerRequestId, {
             endpoint: input.entryEndpoint,
             stream: input.metadata?.stream === true
         });
-        const metadata = this.buildRequestMetadata(input);
         try {
             const headerUa = (typeof input.headers?.['user-agent'] === 'string' && input.headers['user-agent']) ||
                 (typeof input.headers?.['User-Agent'] === 'string' && input.headers['User-Agent']);
+            const headerOriginator = (typeof input.headers?.['originator'] === 'string' && input.headers['originator']) ||
+                (typeof input.headers?.['Originator'] === 'string' && input.headers['Originator']);
             await writeClientSnapshot({
                 entryEndpoint: input.entryEndpoint,
                 requestId: input.requestId,
@@ -465,7 +640,8 @@ export class RouteCodexHttpServer {
                 body: input.body,
                 metadata: {
                     ...metadata,
-                    userAgent: headerUa
+                    userAgent: headerUa,
+                    clientOriginator: headerOriginator
                 }
             });
         }
@@ -473,7 +649,7 @@ export class RouteCodexHttpServer {
             // snapshot failure should not block request path
         }
         const pipelineLabel = 'hub';
-        this.logStage(`${pipelineLabel}.start`, input.requestId, {
+        this.logStage(`${pipelineLabel}.start`, providerRequestId, {
             endpoint: input.entryEndpoint,
             stream: metadata.stream
         });
@@ -481,7 +657,7 @@ export class RouteCodexHttpServer {
         const pipelineResult = await this.runHubPipeline(input, metadata);
         const pipelineMetadata = pipelineResult.metadata ?? {};
         const mergedMetadata = { ...metadata, ...pipelineMetadata };
-        this.logStage(`${pipelineLabel}.completed`, input.requestId, {
+        this.logStage(`${pipelineLabel}.completed`, providerRequestId, {
             route: pipelineResult.routingDecision?.routeName,
             target: pipelineResult.target?.providerKey
         });
@@ -509,16 +685,52 @@ export class RouteCodexHttpServer {
         }
         const providerProtocol = target.outboundProfile ||
             handle.providerProtocol;
+        const metadataModel = mergedMetadata?.target && typeof mergedMetadata.target === 'object'
+            ? mergedMetadata.target.clientModelId
+            : undefined;
+        const rawModel = this.extractProviderModel(providerPayload) ||
+            (typeof metadataModel === 'string' ? metadataModel : undefined);
+        const providerIdToken = target.providerKey || handle.providerId || runtimeKey;
+        if (!providerIdToken) {
+            throw Object.assign(new Error('Provider identifier missing for request'), {
+                code: 'ERR_PROVIDER_ID_MISSING',
+                requestId: providerRequestId
+            });
+        }
+        const enhancedRequestId = enhanceProviderRequestId(providerRequestId, {
+            entryEndpoint: input.entryEndpoint,
+            providerId: providerIdToken,
+            model: rawModel
+        });
+        if (providerProtocol === 'openai-responses') {
+            try {
+                await rebindResponsesConversationRequestId(pipelineResult.requestId, enhancedRequestId);
+            }
+            catch {
+                /* ignore rebind failures */
+            }
+        }
+        if (enhancedRequestId !== input.requestId) {
+            input.requestId = enhancedRequestId;
+        }
+        mergedMetadata.clientRequestId = clientRequestId;
+        const providerModel = rawModel;
+        const providerLabel = this.buildProviderLabel(target.providerKey, providerModel);
         this.logStage('provider.prepare', input.requestId, {
             providerKey: target.providerKey,
             runtimeKey,
-            protocol: providerProtocol
+            protocol: providerProtocol,
+            providerType: handle.providerType,
+            providerFamily: handle.providerFamily,
+            model: providerModel,
+            providerLabel
         });
         attachProviderRuntimeMetadata(providerPayload, {
             requestId: input.requestId,
             providerId: handle.providerId,
             providerKey: target.providerKey,
             providerType: handle.providerType,
+            providerFamily: handle.providerFamily,
             providerProtocol,
             pipelineId: target.providerKey,
             routeName: pipelineResult.routingDecision?.routeName,
@@ -529,16 +741,22 @@ export class RouteCodexHttpServer {
         this.logStage('provider.send.start', input.requestId, {
             providerKey: target.providerKey,
             runtimeKey,
-            protocol: providerProtocol
+            protocol: providerProtocol,
+            providerType: handle.providerType,
+            providerFamily: handle.providerFamily,
+            model: providerModel,
+            providerLabel
         });
         try {
             const providerResponse = await handle.instance.processIncoming(providerPayload);
-            const responseStatus = typeof providerResponse?.status === 'number'
-                ? providerResponse.status
-                : undefined;
+            const responseStatus = this.extractResponseStatus(providerResponse);
             this.logStage('provider.send.completed', input.requestId, {
                 providerKey: target.providerKey,
-                status: responseStatus
+                status: responseStatus,
+                providerType: handle.providerType,
+                providerFamily: handle.providerFamily,
+                model: providerModel,
+                providerLabel
             });
             const normalized = this.normalizeProviderResponse(providerResponse);
             return await this.convertProviderResponseIfNeeded({
@@ -555,22 +773,28 @@ export class RouteCodexHttpServer {
         catch (error) {
             this.logStage('provider.send.error', input.requestId, {
                 providerKey: target.providerKey,
-                message: error instanceof Error ? error.message : String(error ?? 'Unknown error')
+                message: error instanceof Error ? error.message : String(error ?? 'Unknown error'),
+                providerType: handle.providerType,
+                providerFamily: handle.providerFamily,
+                model: providerModel,
+                providerLabel
             });
+            const runtimeMetadata = {
+                requestId: input.requestId,
+                providerKey: target.providerKey,
+                providerId: handle.providerId,
+                providerType: handle.providerType,
+                providerProtocol,
+                routeName: pipelineResult.routingDecision?.routeName,
+                pipelineId: target.providerKey,
+                runtimeKey,
+                target
+            };
+            runtimeMetadata.providerFamily = handle.providerFamily;
             emitProviderError({
                 error,
                 stage: 'provider.send',
-                runtime: {
-                    requestId: input.requestId,
-                    providerKey: target.providerKey,
-                    providerId: handle.providerId,
-                    providerType: handle.providerType,
-                    providerProtocol,
-                    routeName: pipelineResult.routingDecision?.routeName,
-                    pipelineId: target.providerKey,
-                    runtimeKey,
-                    target
-                },
+                runtime: runtimeMetadata,
                 dependencies: this.getModuleDependencies()
             });
             throw error;
@@ -581,12 +805,15 @@ export class RouteCodexHttpServer {
             throw new Error('Hub pipeline runtime is not initialized');
         }
         const payload = asRecord(input.body);
-        const result = await this.hubPipeline.execute({
-            endpoint: input.entryEndpoint,
-            id: input.requestId,
-            payload,
-            metadata
-        });
+        const pipelineInput = {
+            ...input,
+            metadata: {
+                ...metadata,
+                logger: this.coloredLogger
+            },
+            payload
+        };
+        const result = await this.hubPipeline.execute(pipelineInput);
         if (!result.providerPayload || !result.target?.providerKey) {
             throw Object.assign(new Error('Virtual router did not produce a provider target'), {
                 code: 'ERR_NO_PROVIDER_TARGET',
@@ -594,11 +821,17 @@ export class RouteCodexHttpServer {
             });
         }
         const processMode = result.metadata?.processMode ?? 'chat';
+        const resultRecord = result;
+        const derivedRequestId = typeof resultRecord.requestId === 'string'
+            ? resultRecord.requestId
+            : input.requestId;
         return {
+            requestId: derivedRequestId,
             providerPayload: result.providerPayload,
             target: result.target,
             routingDecision: result.routingDecision ?? undefined,
-            processMode
+            processMode,
+            metadata: result.metadata ?? {}
         };
     }
     buildRequestMetadata(input) {
@@ -625,15 +858,25 @@ export class RouteCodexHttpServer {
         }
         return undefined;
     }
+    extractResponseStatus(response) {
+        if (!response || typeof response !== 'object') {
+            return undefined;
+        }
+        const candidate = response.status;
+        return typeof candidate === 'number' ? candidate : undefined;
+    }
     normalizeProviderResponse(response) {
-        const status = typeof response?.status === 'number' ? response.status : undefined;
-        const headers = this.normalizeProviderResponseHeaders(response?.headers);
-        const body = response?.data ?? response;
+        const status = this.extractResponseStatus(response);
+        const headers = this.normalizeProviderResponseHeaders(response && typeof response === 'object' ? response.headers : undefined);
+        const body = response && typeof response === 'object' && 'data' in response
+            ? response.data
+            : response;
         return { status, headers, body };
     }
     normalizeProviderResponseHeaders(headers) {
-        if (!headers || typeof headers !== 'object')
+        if (!headers || typeof headers !== 'object') {
             return undefined;
+        }
         const normalized = {};
         for (const [key, value] of Object.entries(headers)) {
             if (typeof value === 'string') {
@@ -659,7 +902,8 @@ export class RouteCodexHttpServer {
         }
         try {
             const providerProtocol = mapProviderProtocol(options.providerType);
-            const metadataBag = options.pipelineMetadata || {};
+            const metadataBag = asRecord(options.pipelineMetadata);
+            const aliasMap = extractAnthropicToolAliasMap(metadataBag);
             const originalModelId = this.extractClientModelId(metadataBag, options.originalRequest);
             const adapterContext = {
                 requestId: options.requestId,
@@ -667,6 +911,19 @@ export class RouteCodexHttpServer {
                 providerProtocol,
                 originalModelId
             };
+            const compatProfile = metadataBag &&
+                typeof metadataBag === 'object' &&
+                metadataBag.target &&
+                typeof metadataBag.target === 'object' &&
+                typeof metadataBag.target.compatibilityProfile === 'string'
+                ? metadataBag.target.compatibilityProfile
+                : undefined;
+            if (compatProfile && compatProfile.trim()) {
+                adapterContext.compatibilityProfile = compatProfile.trim();
+            }
+            if (aliasMap) {
+                adapterContext.anthropicToolNameMap = aliasMap;
+            }
             const [convertProviderResponse, createSnapshotRecorder] = await Promise.all([
                 loadConvertProviderResponse(),
                 loadSnapshotRecorderFactory()
@@ -718,8 +975,9 @@ export class RouteCodexHttpServer {
         return undefined;
     }
     cloneRequestPayload(payload) {
-        if (!payload || typeof payload !== 'object')
+        if (!payload || typeof payload !== 'object') {
             return undefined;
+        }
         try {
             return JSON.parse(JSON.stringify(payload));
         }
@@ -727,10 +985,23 @@ export class RouteCodexHttpServer {
             return undefined;
         }
     }
+    async initializeRouteErrorHub() {
+        try {
+            this.routeErrorHub = initializeRouteErrorHub({ errorHandlingCenter: this.errorHandling });
+            await this.routeErrorHub.initialize();
+        }
+        catch (error) {
+            console.error('[RouteCodexHttpServer] Failed to initialize RouteErrorHub', error);
+        }
+    }
 }
 function createNoopPipelineLogger() {
     const noop = () => { };
-    const emptyLogs = () => ({ general: [], transformations: [], provider: [] });
+    const emptyLogs = () => ({
+        general: [],
+        transformations: [],
+        provider: []
+    });
     const emptyList = () => [];
     const emptyStats = () => ({
         totalLogs: 0,
@@ -751,13 +1022,14 @@ function createNoopPipelineLogger() {
         logProviderRequest: noop,
         getRequestLogs: emptyLogs,
         getPipelineLogs: emptyLogs,
-        getRecentLogs: emptyList,
-        getTransformationLogs: emptyList,
-        getProviderLogs: emptyList,
+        getRecentLogs: () => emptyList(),
+        getTransformationLogs: () => emptyList(),
+        getProviderLogs: () => emptyList(),
         getStatistics: emptyStats,
         clearLogs: noop,
         exportLogs: () => ([]),
         log: noop
     };
 }
+import { formatErrorForErrorCenter } from '../../../utils/error-center-payload.js';
 //# sourceMappingURL=index.js.map