@jsonstudio/rcc 0.85.9

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

@@ -0,0 +1,763 @@
+// @ts-nocheck
+/**
+ * RouteCodex Server V2 - 渐进式重构版本
+ *
+ * 核心特性：
+ * - 与现有V1服务器完全并行
+ * - 集成系统hooks模块
+ * - 模块化设计，职责分离
+ * - 保持API兼容性
+ */
+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 { AuthFileResolver } from '../../../config/auth-file-resolver.js';
+import { emitProviderError } from '../../../modules/pipeline/modules/provider/v2/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 { 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';
+let convertProviderResponseFn = null;
+async function loadConvertProviderResponse() {
+    if (convertProviderResponseFn)
+        return convertProviderResponseFn;
+    const mod = await importCoreModule('conversion/hub/response/provider-response');
+    if (!mod?.convertProviderResponse) {
+        throw new Error('[RouteCodexHttpServer] llmswitch-core 缺少 convertProviderResponse 实现');
+    }
+    convertProviderResponseFn = mod.convertProviderResponse;
+    return convertProviderResponseFn;
+}
+let createSnapshotRecorderFn = null;
+async function loadSnapshotRecorderFactory() {
+    if (createSnapshotRecorderFn)
+        return createSnapshotRecorderFn;
+    const mod = await importCoreModule('conversion/hub/snapshot-recorder');
+    if (!mod?.createSnapshotRecorder) {
+        throw new Error('[RouteCodexHttpServer] llmswitch-core 缺少 createSnapshotRecorder 实现');
+    }
+    createSnapshotRecorderFn = mod.createSnapshotRecorder;
+    return createSnapshotRecorderFn;
+}
+/**
+ * RouteCodex Server V2
+ *
+ * 与V1完全并行实现，集成系统hooks
+ */
+export class RouteCodexHttpServer {
+    app;
+    server;
+    config;
+    errorHandling;
+    _isInitialized = false;
+    _isRunning = false;
+    // Runtime state
+    hubPipeline = null;
+    providerHandles = new Map();
+    providerKeyToRuntimeKey = new Map();
+    pipelineLogger = createNoopPipelineLogger();
+    authResolver = new AuthFileResolver();
+    userConfig = {};
+    moduleDependencies = null;
+    hubPipelineCtor = null;
+    stageLoggingEnabled;
+    repoRoot;
+    currentRouterArtifacts = null;
+    constructor(config) {
+        this.config = config;
+        this.app = express();
+        this.errorHandling = new ErrorHandlingCenter();
+        this.stageLoggingEnabled = isStageLoggingEnabled();
+        this.repoRoot = resolveRepoRoot(import.meta.url);
+        const envFlag = (process.env.ROUTECODEX_USE_HUB_PIPELINE || '').trim().toLowerCase();
+        if (config.pipeline?.useHubPipeline === false || envFlag === '0' || envFlag === 'false') {
+            console.warn('[RouteCodexHttpServer] Super pipeline has been removed; falling back to Hub pipeline.');
+        }
+        console.log('[RouteCodexHttpServer] Initialized (pipeline=hub)');
+    }
+    resolveVirtualRouterInput(userConfig) {
+        if (userConfig?.virtualrouter && typeof userConfig.virtualrouter === 'object') {
+            return userConfig.virtualrouter;
+        }
+        return userConfig;
+    }
+    getModuleDependencies() {
+        if (!this.moduleDependencies) {
+            this.moduleDependencies = {
+                errorHandlingCenter: this.errorHandling,
+                debugCenter: this.createDebugCenterShim(),
+                logger: this.pipelineLogger
+            };
+        }
+        return this.moduleDependencies;
+    }
+    createDebugCenterShim() {
+        return {
+            logDebug: () => { },
+            logError: () => { },
+            logModule: () => { },
+            processDebugEvent: () => { },
+            getLogs: () => []
+        };
+    }
+    logStage(stage, requestId, details) {
+        if (!this.stageLoggingEnabled) {
+            return;
+        }
+        logPipelineStage(stage, requestId, details);
+    }
+    normalizeAuthType(input) {
+        const value = typeof input === 'string' ? input.toLowerCase() : '';
+        if (value.includes('oauth')) {
+            return 'oauth';
+        }
+        return 'apikey';
+    }
+    async resolveSecretValue(raw) {
+        if (!raw) {
+            throw new Error('Secret reference is required but missing');
+        }
+        const trimmed = raw.trim();
+        const envMatch = trimmed.match(/^\$\{([A-Z0-9_]+)\}$/i);
+        if (envMatch) {
+            const envValue = process.env[envMatch[1]];
+            if (!envValue) {
+                throw new Error(`Environment variable ${envMatch[1]} is not defined`);
+            }
+            return envValue;
+        }
+        if (/^[A-Z][A-Z0-9_]+$/.test(trimmed)) {
+            const envValue = process.env[trimmed];
+            if (!envValue) {
+                throw new Error(`Environment variable ${trimmed} is not defined`);
+            }
+            return envValue;
+        }
+        if (trimmed.startsWith('authfile-')) {
+            return await this.authResolver.resolveKey(trimmed);
+        }
+        return trimmed;
+    }
+    async bootstrapVirtualRouter(input) {
+        const mod = await loadLlmswitchModule(this.repoRoot, 'router/virtual-router/bootstrap.js');
+        const fn = mod?.bootstrapVirtualRouterConfig;
+        if (typeof fn !== 'function') {
+            throw new Error('llmswitch-core missing bootstrapVirtualRouterConfig');
+        }
+        return fn(input);
+    }
+    async ensureHubPipelineCtor() {
+        if (this.hubPipelineCtor) {
+            return this.hubPipelineCtor;
+        }
+        const mod = await loadLlmswitchModule(this.repoRoot, 'conversion/hub/pipeline/hub-pipeline.js');
+        if (!mod?.HubPipeline) {
+            throw new Error('Unable to load HubPipeline implementation from llmswitch-core');
+        }
+        this.hubPipelineCtor = mod.HubPipeline;
+        return this.hubPipelineCtor;
+    }
+    isPipelineReady() {
+        return Boolean(this.hubPipeline);
+    }
+    /**
+     * 初始化服务器
+     */
+    async initialize() {
+        try {
+            console.log('[RouteCodexHttpServer] Starting initialization...');
+            // 初始化错误处理
+            await this.errorHandling.initialize();
+            registerDefaultMiddleware(this.app);
+            registerHttpRoutes({
+                app: this.app,
+                config: this.config,
+                buildHandlerContext: () => this.buildHandlerContext(),
+                getPipelineReady: () => this.isPipelineReady(),
+                handleError: (error, context) => this.handleError(error, context)
+            });
+            this._isInitialized = true;
+            console.log('[RouteCodexHttpServer] Initialization completed successfully');
+        }
+        catch (error) {
+            await this.handleError(error, 'initialization');
+            throw error;
+        }
+    }
+    /**
+     * 启动服务器
+     */
+    async start() {
+        if (!this._isInitialized) {
+            await this.initialize();
+        }
+        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}`);
+                resolve();
+            });
+            this.server.on('error', async (error) => {
+                await this.handleError(error, 'server_start');
+                reject(error);
+            });
+        });
+    }
+    /**
+     * 停止服务器
+     */
+    async stop() {
+        if (this.server) {
+            return new Promise(resolve => {
+                this.server?.close(async () => {
+                    this._isRunning = false;
+                    try {
+                        await this.disposeProviders();
+                    }
+                    catch { /* ignore */ }
+                    await this.errorHandling.destroy();
+                    console.log('[RouteCodexHttpServer] Server stopped');
+                    resolve();
+                });
+            });
+        }
+    }
+    /**
+     * 获取服务器状态
+     */
+    getStatus() {
+        return {
+            initialized: this._isInitialized,
+            running: this._isRunning,
+            port: this.config.server.port,
+            host: this.config.server.host,
+            uptime: process.uptime(),
+            memory: process.memoryUsage(),
+            version: 'v2'
+        };
+    }
+    // Non-standard helper used by index.ts for logging URL
+    getServerConfig() {
+        return { host: this.config.server.host, port: this.config.server.port };
+    }
+    /**
+     * V1兼容接口：检查是否已初始化
+     */
+    isInitialized() {
+        return this._isInitialized;
+    }
+    /**
+     * V1兼容接口：检查是否正在运行
+     */
+    isRunning() {
+        return this._isRunning;
+    }
+    /**
+     * 处理错误
+     */
+    async handleError(error, context) {
+        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'
+                },
+            });
+        }
+        catch (handlerError) {
+            console.error('[RouteCodexHttpServer] Failed to handle error:', handlerError);
+            console.error('[RouteCodexHttpServer] Original error:', error);
+        }
+    }
+    // --- V1 parity helpers and attach methods ---
+    async initializeWithUserConfig(userConfig) {
+        await this.setupRuntime(userConfig);
+    }
+    async reloadRuntime(userConfig) {
+        await this.setupRuntime(userConfig);
+    }
+    async setupRuntime(userConfig) {
+        this.userConfig = asRecord(userConfig);
+        const routerInput = this.resolveVirtualRouterInput(this.userConfig);
+        const bootstrapArtifacts = await this.bootstrapVirtualRouter(routerInput);
+        this.currentRouterArtifacts = bootstrapArtifacts;
+        const hubCtor = await this.ensureHubPipelineCtor();
+        if (!this.hubPipeline) {
+            this.hubPipeline = new hubCtor({ virtualRouter: bootstrapArtifacts.config });
+        }
+        else {
+            this.hubPipeline.updateVirtualRouterConfig(bootstrapArtifacts.config);
+        }
+        await this.initializeProviderRuntimes(bootstrapArtifacts);
+    }
+    buildHandlerContext() {
+        return {
+            executePipeline: this.executePipeline.bind(this),
+            errorHandling: this.errorHandling
+        };
+    }
+    async initializeProviderRuntimes(artifacts) {
+        const runtimeMap = artifacts?.targetRuntime ?? this.currentRouterArtifacts?.targetRuntime ?? undefined;
+        if (!runtimeMap) {
+            return;
+        }
+        await this.disposeProviders();
+        this.providerKeyToRuntimeKey.clear();
+        for (const [providerKey, runtime] of Object.entries(runtimeMap)) {
+            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);
+                this.providerHandles.set(runtimeKey, handle);
+            }
+            this.providerKeyToRuntimeKey.set(providerKey, runtimeKey);
+        }
+    }
+    async createProviderHandle(runtimeKey, runtime) {
+        const providerType = normalizeProviderType(runtime.providerType);
+        const providerProtocol = (typeof runtime.outboundProfile === 'string' && runtime.outboundProfile.trim()
+            ? runtime.outboundProfile.trim()
+            : undefined) ?? mapProviderProtocol(providerType);
+        const instance = ProviderFactory.createProviderFromRuntime(runtime, this.getModuleDependencies());
+        await instance.initialize();
+        const providerId = runtime.providerId || runtimeKey.split('.')[0];
+        return {
+            runtimeKey,
+            providerId,
+            providerType,
+            providerProtocol,
+            runtime,
+            instance
+        };
+    }
+    async materializeRuntimeProfile(runtime) {
+        const auth = await this.resolveRuntimeAuth(runtime);
+        const baseUrl = this.normalizeRuntimeBaseUrl(runtime);
+        const providerType = normalizeProviderType(runtime.providerType);
+        return {
+            ...runtime,
+            ...(baseUrl ? { baseUrl } : {}),
+            providerType,
+            auth
+        };
+    }
+    normalizeRuntimeBaseUrl(runtime) {
+        const candidates = [runtime.baseUrl, runtime.endpoint];
+        for (const candidate of candidates) {
+            if (typeof candidate === 'string' && candidate.trim()) {
+                return candidate.trim();
+            }
+        }
+        return undefined;
+    }
+    async resolveRuntimeAuth(runtime) {
+        const auth = runtime.auth || { type: 'apikey' };
+        const authType = this.normalizeAuthType(auth.type);
+        const pickString = (...candidates) => {
+            for (const candidate of candidates) {
+                if (typeof candidate === 'string') {
+                    const trimmed = candidate.trim();
+                    if (trimmed) {
+                        return trimmed;
+                    }
+                }
+            }
+            return undefined;
+        };
+        const pickStringArray = (value) => {
+            if (!value)
+                return undefined;
+            if (Array.isArray(value)) {
+                const normalized = value
+                    .map((item) => pickString(item))
+                    .filter((item) => typeof item === 'string');
+                return normalized.length ? normalized : undefined;
+            }
+            if (typeof value === 'string' && value.trim()) {
+                const normalized = value
+                    .split(/[,\s]+/)
+                    .map((item) => item.trim())
+                    .filter(Boolean);
+                return normalized.length ? normalized : undefined;
+            }
+            return undefined;
+        };
+        if (authType === 'apikey') {
+            const value = await this.resolveApiKeyValue(runtime, auth);
+            return { ...auth, type: 'apikey', value };
+        }
+        const resolved = {
+            type: 'oauth',
+            secretRef: auth.secretRef,
+            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)
+        };
+        let tokenFile = resolved.tokenFile;
+        if (!tokenFile && typeof auth.secretRef === 'string' && auth.secretRef.trim()) {
+            tokenFile = await this.resolveSecretValue(auth.secretRef.trim());
+        }
+        resolved.tokenFile = tokenFile;
+        return resolved;
+    }
+    async resolveApiKeyValue(runtime, auth) {
+        const inline = typeof auth?.value === 'string' ? auth.value.trim() : '';
+        if (inline) {
+            return inline;
+        }
+        const resolved = typeof auth?.secretRef === 'string' && auth.secretRef.trim()
+            ? await this.resolveSecretValue(auth.secretRef.trim())
+            : undefined;
+        if (resolved) {
+            return resolved;
+        }
+        throw new Error(`Provider runtime "${runtime.runtimeKey || runtime.providerId}" missing API key`);
+    }
+    async disposeProviders() {
+        const handles = Array.from(this.providerHandles.values());
+        await Promise.all(handles.map(async (handle) => {
+            try {
+                await handle.instance.cleanup();
+            }
+            catch {
+                // ignore cleanup errors
+            }
+        }));
+        this.providerHandles.clear();
+    }
+    async executePipeline(input) {
+        if (!this.isPipelineReady()) {
+            throw new Error('Hub pipeline runtime is not initialized');
+        }
+        this.logStage('request.received', input.requestId, {
+            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']);
+            await writeClientSnapshot({
+                entryEndpoint: input.entryEndpoint,
+                requestId: input.requestId,
+                headers: asRecord(input.headers),
+                body: input.body,
+                metadata: {
+                    ...metadata,
+                    userAgent: headerUa
+                }
+            });
+        }
+        catch {
+            // snapshot failure should not block request path
+        }
+        const pipelineLabel = 'hub';
+        this.logStage(`${pipelineLabel}.start`, input.requestId, {
+            endpoint: input.entryEndpoint,
+            stream: metadata.stream
+        });
+        const originalRequestSnapshot = this.cloneRequestPayload(input.body);
+        const pipelineResult = await this.runHubPipeline(input, metadata);
+        const pipelineMetadata = pipelineResult.metadata ?? {};
+        const mergedMetadata = { ...metadata, ...pipelineMetadata };
+        this.logStage(`${pipelineLabel}.completed`, input.requestId, {
+            route: pipelineResult.routingDecision?.routeName,
+            target: pipelineResult.target?.providerKey
+        });
+        const providerPayload = pipelineResult.providerPayload;
+        const target = pipelineResult.target;
+        if (!providerPayload || !target?.providerKey) {
+            throw Object.assign(new Error('Virtual router did not produce a provider target'), {
+                code: 'ERR_NO_PROVIDER_TARGET',
+                requestId: input.requestId
+            });
+        }
+        const runtimeKey = target.runtimeKey || this.providerKeyToRuntimeKey.get(target.providerKey);
+        if (!runtimeKey) {
+            throw Object.assign(new Error(`Runtime for provider ${target.providerKey} not initialized`), {
+                code: 'ERR_RUNTIME_NOT_FOUND',
+                requestId: input.requestId
+            });
+        }
+        const handle = this.providerHandles.get(runtimeKey);
+        if (!handle) {
+            throw Object.assign(new Error(`Provider runtime ${runtimeKey} not found`), {
+                code: 'ERR_PROVIDER_NOT_FOUND',
+                requestId: input.requestId
+            });
+        }
+        const providerProtocol = target.outboundProfile ||
+            handle.providerProtocol;
+        this.logStage('provider.prepare', input.requestId, {
+            providerKey: target.providerKey,
+            runtimeKey,
+            protocol: providerProtocol
+        });
+        attachProviderRuntimeMetadata(providerPayload, {
+            requestId: input.requestId,
+            providerId: handle.providerId,
+            providerKey: target.providerKey,
+            providerType: handle.providerType,
+            providerProtocol,
+            pipelineId: target.providerKey,
+            routeName: pipelineResult.routingDecision?.routeName,
+            runtimeKey,
+            target,
+            metadata: mergedMetadata
+        });
+        this.logStage('provider.send.start', input.requestId, {
+            providerKey: target.providerKey,
+            runtimeKey,
+            protocol: providerProtocol
+        });
+        try {
+            const providerResponse = await handle.instance.processIncoming(providerPayload);
+            const responseStatus = typeof providerResponse?.status === 'number'
+                ? providerResponse.status
+                : undefined;
+            this.logStage('provider.send.completed', input.requestId, {
+                providerKey: target.providerKey,
+                status: responseStatus
+            });
+            const normalized = this.normalizeProviderResponse(providerResponse);
+            return await this.convertProviderResponseIfNeeded({
+                entryEndpoint: input.entryEndpoint,
+                providerType: handle.providerType,
+                requestId: input.requestId,
+                wantsStream: Boolean(input.metadata?.inboundStream ?? input.metadata?.stream),
+                originalRequest: originalRequestSnapshot,
+                processMode: pipelineResult.processMode,
+                response: normalized,
+                pipelineMetadata: mergedMetadata
+            });
+        }
+        catch (error) {
+            this.logStage('provider.send.error', input.requestId, {
+                providerKey: target.providerKey,
+                message: error instanceof Error ? error.message : String(error ?? 'Unknown error')
+            });
+            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
+                },
+                dependencies: this.getModuleDependencies()
+            });
+            throw error;
+        }
+    }
+    async runHubPipeline(input, metadata) {
+        if (!this.hubPipeline) {
+            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
+        });
+        if (!result.providerPayload || !result.target?.providerKey) {
+            throw Object.assign(new Error('Virtual router did not produce a provider target'), {
+                code: 'ERR_NO_PROVIDER_TARGET',
+                requestId: input.requestId
+            });
+        }
+        const processMode = result.metadata?.processMode ?? 'chat';
+        return {
+            providerPayload: result.providerPayload,
+            target: result.target,
+            routingDecision: result.routingDecision ?? undefined,
+            processMode
+        };
+    }
+    buildRequestMetadata(input) {
+        const userMeta = asRecord(input.metadata);
+        const routeHint = this.extractRouteHint(input) ?? userMeta.routeHint;
+        const processMode = userMeta.processMode || 'chat';
+        return {
+            ...userMeta,
+            entryEndpoint: input.entryEndpoint,
+            processMode,
+            direction: 'request',
+            stage: 'inbound',
+            routeHint,
+            stream: userMeta.stream === true
+        };
+    }
+    extractRouteHint(input) {
+        const header = input.headers['x-route-hint'];
+        if (typeof header === 'string' && header.trim()) {
+            return header.trim();
+        }
+        if (Array.isArray(header) && header[0]) {
+            return String(header[0]);
+        }
+        return undefined;
+    }
+    normalizeProviderResponse(response) {
+        const status = typeof response?.status === 'number' ? response.status : undefined;
+        const headers = this.normalizeProviderResponseHeaders(response?.headers);
+        const body = response?.data ?? response;
+        return { status, headers, body };
+    }
+    normalizeProviderResponseHeaders(headers) {
+        if (!headers || typeof headers !== 'object')
+            return undefined;
+        const normalized = {};
+        for (const [key, value] of Object.entries(headers)) {
+            if (typeof value === 'string') {
+                normalized[key.toLowerCase()] = value;
+            }
+        }
+        return Object.keys(normalized).length ? normalized : undefined;
+    }
+    async convertProviderResponseIfNeeded(options) {
+        if (options.processMode === 'passthrough') {
+            return options.response;
+        }
+        const entry = (options.entryEndpoint || '').toLowerCase();
+        const needsAnthropicConversion = entry.includes('/v1/messages');
+        const needsResponsesConversion = entry.includes('/v1/responses');
+        const needsChatConversion = entry.includes('/v1/chat/completions');
+        if (!needsAnthropicConversion && !needsResponsesConversion && !needsChatConversion) {
+            return options.response;
+        }
+        const body = options.response.body;
+        if (!body || typeof body !== 'object') {
+            return options.response;
+        }
+        try {
+            const providerProtocol = mapProviderProtocol(options.providerType);
+            const metadataBag = options.pipelineMetadata || {};
+            const originalModelId = this.extractClientModelId(metadataBag, options.originalRequest);
+            const adapterContext = {
+                requestId: options.requestId,
+                entryEndpoint: options.entryEndpoint || entry,
+                providerProtocol,
+                originalModelId
+            };
+            const [convertProviderResponse, createSnapshotRecorder] = await Promise.all([
+                loadConvertProviderResponse(),
+                loadSnapshotRecorderFactory()
+            ]);
+            const stageRecorder = createSnapshotRecorder(adapterContext, adapterContext.entryEndpoint);
+            const converted = await convertProviderResponse({
+                providerProtocol,
+                providerResponse: body,
+                context: adapterContext,
+                entryEndpoint: options.entryEndpoint || entry,
+                wantsStream: options.wantsStream,
+                stageRecorder
+            });
+            if (converted.__sse_responses) {
+                return {
+                    ...options.response,
+                    body: { __sse_responses: converted.__sse_responses }
+                };
+            }
+            return {
+                ...options.response,
+                body: converted.body ?? body
+            };
+        }
+        catch (error) {
+            console.error('[RouteCodexHttpServer] Failed to convert provider response via llmswitch-core', error);
+            return options.response;
+        }
+    }
+    extractClientModelId(metadata, originalRequest) {
+        const candidates = [
+            metadata.clientModelId,
+            metadata.originalModelId,
+            (metadata.target && typeof metadata.target === 'object'
+                ? metadata.target.clientModelId
+                : undefined),
+            originalRequest && typeof originalRequest === 'object'
+                ? originalRequest.model
+                : undefined,
+            originalRequest && typeof originalRequest === 'object'
+                ? originalRequest.originalModelId
+                : undefined
+        ];
+        for (const candidate of candidates) {
+            if (typeof candidate === 'string' && candidate.trim()) {
+                return candidate.trim();
+            }
+        }
+        return undefined;
+    }
+    cloneRequestPayload(payload) {
+        if (!payload || typeof payload !== 'object')
+            return undefined;
+        try {
+            return JSON.parse(JSON.stringify(payload));
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+function createNoopPipelineLogger() {
+    const noop = () => { };
+    const emptyLogs = () => ({ general: [], transformations: [], provider: [] });
+    const emptyList = () => [];
+    const emptyStats = () => ({
+        totalLogs: 0,
+        logsByLevel: {},
+        logsByCategory: {},
+        logsByPipeline: {},
+        transformationCount: 0,
+        providerRequestCount: 0
+    });
+    return {
+        logModule: noop,
+        logError: noop,
+        logDebug: noop,
+        logPipeline: noop,
+        logRequest: noop,
+        logResponse: noop,
+        logTransformation: noop,
+        logProviderRequest: noop,
+        getRequestLogs: emptyLogs,
+        getPipelineLogs: emptyLogs,
+        getRecentLogs: emptyList,
+        getTransformationLogs: emptyList,
+        getProviderLogs: emptyList,
+        getStatistics: emptyStats,
+        clearLogs: noop,
+        exportLogs: () => ([]),
+        log: noop
+    };
+}
+//# sourceMappingURL=index.js.map