aicodeswitch 1.0.0

package/dist/server/proxy-server.js

@@ -0,0 +1,889 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProxyServer = void 0;
+const axios_1 = __importDefault(require("axios"));
+const stream_1 = require("stream");
+const streaming_1 = require("./transformers/streaming");
+const chunk_collector_1 = require("./transformers/chunk-collector");
+const claude_openai_1 = require("./transformers/claude-openai");
+const openai_responses_1 = require("./transformers/openai-responses");
+class ProxyServer {
+    constructor(dbManager, app) {
+        Object.defineProperty(this, "app", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "dbManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "routes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "rules", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "services", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.dbManager = dbManager;
+        this.config = dbManager.getConfig();
+        this.app = app;
+    }
+    setupMiddleware() {
+        // Access logging middleware
+        this.app.use((req, res, next) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Capture client info
+            const clientIp = ((_a = req.headers['x-forwarded-for']) === null || _a === void 0 ? void 0 : _a.split(',')[0]) || req.socket.remoteAddress || '';
+            const userAgent = req.headers['user-agent'] || '';
+            this.dbManager.addAccessLog({
+                timestamp: Date.now(),
+                method: req.method,
+                path: req.path,
+                headers: this.normalizeHeaders(req.headers),
+                body: req.body ? JSON.stringify(req.body) : undefined,
+                clientIp,
+                userAgent,
+                statusCode: res.statusCode,
+            });
+            next();
+        }));
+        // Logging middleware (legacy RequestLog)
+        this.app.use((req, res, next) => __awaiter(this, void 0, void 0, function* () {
+            const startTime = Date.now();
+            const originalSend = res.send.bind(res);
+            res.send = (data) => {
+                var _a;
+                res.send = originalSend;
+                if (!res.locals.skipLog && ((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableLogging)) {
+                    const responseTime = Date.now() - startTime;
+                    this.dbManager.addLog({
+                        timestamp: Date.now(),
+                        method: req.method,
+                        path: req.path,
+                        headers: this.normalizeHeaders(req.headers),
+                        body: req.body ? JSON.stringify(req.body) : undefined,
+                        statusCode: res.statusCode,
+                        responseTime,
+                    });
+                }
+                return res.send(data);
+            };
+            next();
+        }));
+        // Fixed route handlers
+        this.app.use('/claude-code/', this.createFixedRouteHandler('claude-code'));
+        this.app.use('/claude-code', this.createFixedRouteHandler('claude-code'));
+        this.app.use('/codex/', this.createFixedRouteHandler('codex'));
+        this.app.use('/codex', this.createFixedRouteHandler('codex'));
+        // Dynamic proxy middleware
+        this.app.use((req, res, _next) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                const route = this.findMatchingRoute(req);
+                if (!route) {
+                    return res.status(404).json({ error: 'No matching route found' });
+                }
+                const rule = this.findMatchingRule(route.id, req);
+                if (!rule) {
+                    return res.status(404).json({ error: 'No matching rule found' });
+                }
+                const service = this.services.get(rule.targetServiceId);
+                if (!service) {
+                    return res.status(500).json({ error: 'Target service not configured' });
+                }
+                yield this.proxyRequest(req, res, route, rule, service);
+            }
+            catch (error) {
+                console.error('Proxy error:', error);
+                if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableLogging) {
+                    yield this.dbManager.addLog({
+                        timestamp: Date.now(),
+                        method: req.method,
+                        path: req.path,
+                        headers: this.normalizeHeaders(req.headers),
+                        body: req.body ? JSON.stringify(req.body) : undefined,
+                        error: error.message,
+                    });
+                }
+                // Add error log
+                yield this.dbManager.addErrorLog({
+                    timestamp: Date.now(),
+                    method: req.method,
+                    path: req.path,
+                    statusCode: 500,
+                    errorMessage: error.message,
+                    errorStack: error.stack,
+                    requestHeaders: this.normalizeHeaders(req.headers),
+                    requestBody: req.body ? JSON.stringify(req.body) : undefined,
+                });
+                res.status(500).json({ error: error.message });
+            }
+        }));
+    }
+    createFixedRouteHandler(targetType) {
+        return (req, res) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                // 检查API Key验证
+                if (this.config.apiKey) {
+                    const authHeader = req.headers.authorization;
+                    const providedKey = authHeader === null || authHeader === void 0 ? void 0 : authHeader.replace('Bearer ', '');
+                    if (!providedKey || providedKey !== this.config.apiKey) {
+                        return res.status(401).json({ error: 'Invalid API key' });
+                    }
+                }
+                const route = this.findRouteByTargetType(targetType);
+                if (!route) {
+                    return res.status(404).json({ error: `No active route found for target type: ${targetType}` });
+                }
+                const rule = this.findMatchingRule(route.id, req);
+                if (!rule) {
+                    return res.status(404).json({ error: 'No matching rule found' });
+                }
+                const service = this.services.get(rule.targetServiceId);
+                if (!service) {
+                    return res.status(500).json({ error: 'Target service not configured' });
+                }
+                yield this.proxyRequest(req, res, route, rule, service);
+            }
+            catch (error) {
+                console.error(`Fixed route error for ${targetType}:`, error);
+                if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableLogging) {
+                    yield this.dbManager.addLog({
+                        timestamp: Date.now(),
+                        method: req.method,
+                        path: req.path,
+                        headers: this.normalizeHeaders(req.headers),
+                        body: req.body ? JSON.stringify(req.body) : undefined,
+                        error: error.message,
+                    });
+                }
+                // Add error log
+                yield this.dbManager.addErrorLog({
+                    timestamp: Date.now(),
+                    method: req.method,
+                    path: req.path,
+                    statusCode: 500,
+                    errorMessage: error.message,
+                    errorStack: error.stack,
+                    requestHeaders: this.normalizeHeaders(req.headers),
+                    requestBody: req.body ? JSON.stringify(req.body) : undefined,
+                });
+                res.status(500).json({ error: error.message });
+            }
+        });
+    }
+    findMatchingRoute(_req) {
+        // Find active route based on targetType - for now, return the first active route
+        // This can be extended later based on specific routing logic
+        return this.routes.find(route => route.isActive);
+    }
+    findRouteByTargetType(targetType) {
+        return this.routes.find(route => route.targetType === targetType && route.isActive);
+    }
+    findMatchingRule(routeId, req) {
+        const rules = this.rules.get(routeId);
+        if (!rules)
+            return undefined;
+        // Determine content type from request
+        const contentType = this.determineContentType(req);
+        return rules.find(rule => rule.contentType === contentType) || rules.find(rule => rule.contentType === 'default');
+    }
+    determineContentType(req) {
+        const body = req.body;
+        if (!body)
+            return 'default';
+        const explicitType = this.getExplicitContentType(req, body);
+        if (explicitType) {
+            return explicitType;
+        }
+        for (const detector of this.getContentTypeDetectors()) {
+            if (detector.match(req, body)) {
+                return detector.type;
+            }
+        }
+        return 'default';
+    }
+    getContentTypeDetectors() {
+        return [
+            {
+                type: 'image-understanding',
+                match: (_req, body) => this.containsImageContent(body.messages) || this.containsImageContent(body.input),
+            },
+            {
+                type: 'thinking',
+                match: (_req, body) => this.hasThinkingSignal(body),
+            },
+            {
+                type: 'long-context',
+                match: (_req, body) => this.hasLongContextSignal(body),
+            },
+            {
+                type: 'background',
+                match: (_req, body) => this.hasBackgroundSignal(body),
+            },
+        ];
+    }
+    getExplicitContentType(req, body) {
+        var _a, _b, _c, _d, _e, _f;
+        const headerKeys = ['x-aicodeswitch-content-type', 'x-content-type', 'x-request-type', 'x-object-type'];
+        const queryKeys = ['contentType', 'content_type', 'requestType', 'request_type', 'objectType', 'object_type'];
+        const bodyKeys = ['contentType', 'content_type', 'requestType', 'request_type', 'objectType', 'object_type', 'mode'];
+        for (const key of headerKeys) {
+            const raw = req.headers[key];
+            if (typeof raw === 'string') {
+                const normalized = this.normalizeContentType(raw);
+                if (normalized)
+                    return normalized;
+            }
+        }
+        for (const key of queryKeys) {
+            const raw = req.query[key];
+            if (typeof raw === 'string') {
+                const normalized = this.normalizeContentType(raw);
+                if (normalized)
+                    return normalized;
+            }
+        }
+        for (const key of bodyKeys) {
+            const raw = body === null || body === void 0 ? void 0 : body[key];
+            if (typeof raw === 'string') {
+                const normalized = this.normalizeContentType(raw);
+                if (normalized)
+                    return normalized;
+            }
+        }
+        const metaCandidates = [
+            (_a = body === null || body === void 0 ? void 0 : body.metadata) === null || _a === void 0 ? void 0 : _a.contentType,
+            (_b = body === null || body === void 0 ? void 0 : body.metadata) === null || _b === void 0 ? void 0 : _b.content_type,
+            (_c = body === null || body === void 0 ? void 0 : body.metadata) === null || _c === void 0 ? void 0 : _c.requestType,
+            (_d = body === null || body === void 0 ? void 0 : body.metadata) === null || _d === void 0 ? void 0 : _d.request_type,
+            (_e = body === null || body === void 0 ? void 0 : body.meta) === null || _e === void 0 ? void 0 : _e.contentType,
+            (_f = body === null || body === void 0 ? void 0 : body.meta) === null || _f === void 0 ? void 0 : _f.content_type,
+        ];
+        for (const raw of metaCandidates) {
+            if (typeof raw === 'string') {
+                const normalized = this.normalizeContentType(raw);
+                if (normalized)
+                    return normalized;
+            }
+        }
+        return null;
+    }
+    normalizeContentType(raw) {
+        const normalized = raw.trim().toLowerCase();
+        const mapping = {
+            default: 'default',
+            background: 'background',
+            bg: 'background',
+            thinking: 'thinking',
+            reasoning: 'thinking',
+            'long-context': 'long-context',
+            long_context: 'long-context',
+            long: 'long-context',
+            image: 'image-understanding',
+            image_understanding: 'image-understanding',
+            'image-understanding': 'image-understanding',
+            vision: 'image-understanding',
+        };
+        return mapping[normalized] || null;
+    }
+    containsImageContent(payload) {
+        var _a;
+        if (!payload)
+            return false;
+        const messages = Array.isArray(payload) ? payload : [payload];
+        for (const message of messages) {
+            const content = (_a = message === null || message === void 0 ? void 0 : message.content) !== null && _a !== void 0 ? _a : message;
+            if (Array.isArray(content)) {
+                for (const block of content) {
+                    if (!block || typeof block !== 'object')
+                        continue;
+                    const type = block.type;
+                    if (type === 'image' || type === 'image_url' || type === 'input_image') {
+                        return true;
+                    }
+                    if (block.image_url) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    hasThinkingSignal(body) {
+        var _a, _b;
+        return Boolean((body === null || body === void 0 ? void 0 : body.reasoning) ||
+            (body === null || body === void 0 ? void 0 : body.thinking) ||
+            (body === null || body === void 0 ? void 0 : body.reasoning_effort) ||
+            ((_a = body === null || body === void 0 ? void 0 : body.reasoning) === null || _a === void 0 ? void 0 : _a.effort) ||
+            ((_b = body === null || body === void 0 ? void 0 : body.reasoning) === null || _b === void 0 ? void 0 : _b.enabled));
+    }
+    hasBackgroundSignal(body) {
+        var _a, _b, _c;
+        const candidates = [
+            body === null || body === void 0 ? void 0 : body.background,
+            (_a = body === null || body === void 0 ? void 0 : body.metadata) === null || _a === void 0 ? void 0 : _a.background,
+            (_b = body === null || body === void 0 ? void 0 : body.meta) === null || _b === void 0 ? void 0 : _b.background,
+            body === null || body === void 0 ? void 0 : body.priority,
+            (_c = body === null || body === void 0 ? void 0 : body.metadata) === null || _c === void 0 ? void 0 : _c.priority,
+            body === null || body === void 0 ? void 0 : body.mode,
+        ];
+        return candidates.some((value) => value === true || value === 'background');
+    }
+    hasLongContextSignal(body) {
+        var _a, _b;
+        const explicit = [
+            body === null || body === void 0 ? void 0 : body.long_context,
+            body === null || body === void 0 ? void 0 : body.longContext,
+            (_a = body === null || body === void 0 ? void 0 : body.metadata) === null || _a === void 0 ? void 0 : _a.long_context,
+            (_b = body === null || body === void 0 ? void 0 : body.metadata) === null || _b === void 0 ? void 0 : _b.longContext,
+        ];
+        if (explicit.some((value) => value === true)) {
+            return true;
+        }
+        const maxTokens = this.extractNumericField(body, [
+            'max_tokens',
+            'max_output_tokens',
+            'max_completion_tokens',
+            'max_context_tokens',
+        ]);
+        if (maxTokens !== null && maxTokens >= 8000) {
+            return true;
+        }
+        const contentLength = this.estimateTextLength(body);
+        return contentLength >= 12000;
+    }
+    extractNumericField(body, fields) {
+        for (const field of fields) {
+            const value = body === null || body === void 0 ? void 0 : body[field];
+            if (typeof value === 'number' && Number.isFinite(value)) {
+                return value;
+            }
+            if (typeof value === 'string') {
+                const parsed = Number(value);
+                if (Number.isFinite(parsed)) {
+                    return parsed;
+                }
+            }
+        }
+        return null;
+    }
+    estimateTextLength(body) {
+        var _a, _b;
+        let length = 0;
+        const addText = (value) => {
+            if (typeof value === 'string') {
+                length += value.length;
+            }
+        };
+        const addContent = (content) => {
+            if (typeof content === 'string' || content === null) {
+                addText(content);
+                return;
+            }
+            if (Array.isArray(content)) {
+                for (const part of content) {
+                    if (typeof part === 'string') {
+                        addText(part);
+                        continue;
+                    }
+                    if (part && typeof part === 'object') {
+                        if (typeof part.text === 'string') {
+                            addText(part.text);
+                        }
+                        if (typeof part.content === 'string') {
+                            addText(part.content);
+                        }
+                    }
+                }
+            }
+        };
+        if (Array.isArray(body === null || body === void 0 ? void 0 : body.messages)) {
+            for (const message of body.messages) {
+                addContent(message === null || message === void 0 ? void 0 : message.content);
+            }
+        }
+        if (body === null || body === void 0 ? void 0 : body.input) {
+            if (typeof body.input === 'string') {
+                addText(body.input);
+            }
+            else if (Array.isArray(body.input)) {
+                for (const message of body.input) {
+                    if (typeof message === 'string') {
+                        addText(message);
+                    }
+                    else if (message && typeof message === 'object') {
+                        addContent((_a = message.content) !== null && _a !== void 0 ? _a : message);
+                    }
+                }
+            }
+            else if (body.input && typeof body.input === 'object') {
+                addContent((_b = body.input.content) !== null && _b !== void 0 ? _b : body.input);
+            }
+        }
+        addContent(body === null || body === void 0 ? void 0 : body.system);
+        addText(body === null || body === void 0 ? void 0 : body.instructions);
+        addText(body === null || body === void 0 ? void 0 : body.prompt);
+        return length;
+    }
+    isClaudeSource(sourceType) {
+        return sourceType === 'claude-chat' || sourceType === 'claude-code';
+    }
+    isOpenAIChatSource(sourceType) {
+        return sourceType === 'openai-chat' || sourceType === 'openai-code' || sourceType === 'deepseek-chat';
+    }
+    isOpenAIResponsesSource(sourceType) {
+        return sourceType === 'openai-responses';
+    }
+    applyModelOverride(body, rule) {
+        if (!rule.targetModel)
+            return body;
+        if (body && typeof body === 'object') {
+            return Object.assign(Object.assign({}, body), { model: rule.targetModel });
+        }
+        return body;
+    }
+    isStreamRequested(req, body) {
+        const accept = typeof req.headers.accept === 'string' ? req.headers.accept : '';
+        return (body === null || body === void 0 ? void 0 : body.stream) === true || accept.includes('text/event-stream');
+    }
+    buildUpstreamHeaders(req, service, sourceType, streamRequested) {
+        const headers = {};
+        for (const [key, value] of Object.entries(req.headers)) {
+            if (['host', 'connection', 'content-length', 'authorization'].includes(key.toLowerCase())) {
+                continue;
+            }
+            if (typeof value === 'string') {
+                headers[key] = value;
+            }
+            else if (Array.isArray(value)) {
+                headers[key] = value.join(', ');
+            }
+        }
+        if (streamRequested) {
+            headers.accept = 'text/event-stream';
+        }
+        if (this.isClaudeSource(sourceType)) {
+            headers['x-api-key'] = service.apiKey;
+            headers['anthropic-version'] = headers['anthropic-version'] || '2023-06-01';
+        }
+        else {
+            delete headers['anthropic-version'];
+            delete headers['anthropic-beta'];
+            headers.authorization = `Bearer ${service.apiKey}`;
+        }
+        if (!headers['content-type']) {
+            headers['content-type'] = 'application/json';
+        }
+        return headers;
+    }
+    copyResponseHeaders(responseHeaders, res) {
+        Object.keys(responseHeaders).forEach((key) => {
+            if (!['content-encoding', 'transfer-encoding', 'connection', 'content-length'].includes(key.toLowerCase())) {
+                res.setHeader(key, responseHeaders[key]);
+            }
+        });
+    }
+    normalizeHeaders(headers) {
+        const normalized = {};
+        for (const [key, value] of Object.entries(headers)) {
+            if (typeof value === 'string') {
+                normalized[key] = value;
+            }
+            else if (Array.isArray(value)) {
+                normalized[key] = value.join(', ');
+            }
+        }
+        return normalized;
+    }
+    normalizeResponseHeaders(headers) {
+        const normalized = {};
+        for (const [key, value] of Object.entries(headers)) {
+            if (value !== null && value !== undefined) {
+                if (typeof value === 'string') {
+                    normalized[key] = value;
+                }
+                else if (Array.isArray(value)) {
+                    normalized[key] = value.join(', ');
+                }
+                else {
+                    normalized[key] = String(value);
+                }
+            }
+        }
+        return normalized;
+    }
+    readStreamBody(stream) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                let data = '';
+                stream.on('data', (chunk) => {
+                    data += chunk.toString();
+                });
+                stream.on('end', () => resolve(data));
+                stream.on('error', reject);
+            });
+        });
+    }
+    safeJsonParse(raw) {
+        try {
+            return JSON.parse(raw);
+        }
+        catch (_a) {
+            return null;
+        }
+    }
+    extractTokenUsage(usage) {
+        if (!usage)
+            return undefined;
+        if (typeof usage.input_tokens === 'number' && typeof usage.output_tokens === 'number' && usage.prompt_tokens === undefined) {
+            return (0, openai_responses_1.extractTokenUsageFromOpenAIResponsesUsage)(usage);
+        }
+        if (typeof usage.prompt_tokens === 'number' || typeof usage.completion_tokens === 'number') {
+            return (0, claude_openai_1.extractTokenUsageFromOpenAIUsage)(usage);
+        }
+        if (typeof usage.input_tokens === 'number' || typeof usage.output_tokens === 'number') {
+            return (0, claude_openai_1.extractTokenUsageFromClaudeUsage)(usage);
+        }
+        return undefined;
+    }
+    proxyRequest(req, res, route, rule, service) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            res.locals.skipLog = true;
+            const startTime = Date.now();
+            const sourceType = (service.sourceType || 'openai-chat');
+            const targetType = route.targetType;
+            let requestBody = req.body || {};
+            let usageForLog;
+            let logged = false;
+            // 用于收集响应数据的变量
+            let responseHeadersForLog;
+            let responseBodyForLog;
+            let streamChunksForLog;
+            const finalizeLog = (statusCode, error) => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                if (logged || !((_a = this.config) === null || _a === void 0 ? void 0 : _a.enableLogging))
+                    return;
+                logged = true;
+                yield this.dbManager.addLog({
+                    timestamp: Date.now(),
+                    method: req.method,
+                    path: req.path,
+                    headers: this.normalizeHeaders(req.headers),
+                    body: req.body ? JSON.stringify(req.body) : undefined,
+                    statusCode,
+                    responseTime: Date.now() - startTime,
+                    targetProvider: service.name,
+                    usage: usageForLog,
+                    error,
+                    // 新增字段
+                    targetType,
+                    targetServiceId: service.id,
+                    targetServiceName: service.name,
+                    targetModel: rule.targetModel,
+                    responseHeaders: responseHeadersForLog,
+                    responseBody: responseBodyForLog,
+                    streamChunks: streamChunksForLog,
+                });
+            });
+            try {
+                if (targetType === 'claude-code') {
+                    if (this.isClaudeSource(sourceType)) {
+                        requestBody = this.applyModelOverride(requestBody, rule);
+                    }
+                    else if (this.isOpenAIChatSource(sourceType)) {
+                        requestBody = (0, claude_openai_1.transformClaudeRequestToOpenAIChat)(requestBody, rule.targetModel);
+                    }
+                    else if (this.isOpenAIResponsesSource(sourceType)) {
+                        requestBody = (0, openai_responses_1.transformClaudeRequestToOpenAIResponses)(requestBody, rule.targetModel);
+                    }
+                    else {
+                        res.status(400).json({ error: 'Unsupported source type for Claude Code.' });
+                        yield finalizeLog(400, 'Unsupported source type for Claude Code');
+                        return;
+                    }
+                }
+                else if (targetType === 'codex') {
+                    if (this.isOpenAIResponsesSource(sourceType)) {
+                        requestBody = this.applyModelOverride(requestBody, rule);
+                    }
+                    else if (this.isOpenAIChatSource(sourceType)) {
+                        requestBody = (0, openai_responses_1.transformOpenAIResponsesRequestToOpenAIChat)(requestBody, rule.targetModel);
+                    }
+                    else if (this.isClaudeSource(sourceType)) {
+                        requestBody = (0, openai_responses_1.transformOpenAIResponsesRequestToClaude)(requestBody, rule.targetModel);
+                    }
+                    else {
+                        res.status(400).json({ error: 'Codex requires an OpenAI Responses compatible source.' });
+                        yield finalizeLog(400, 'Unsupported source type for Codex');
+                        return;
+                    }
+                }
+                const streamRequested = this.isStreamRequested(req, requestBody);
+                const config = {
+                    method: req.method,
+                    url: service.apiUrl,
+                    headers: this.buildUpstreamHeaders(req, service, sourceType, streamRequested),
+                    timeout: service.timeout || 30000,
+                    validateStatus: () => true,
+                    responseType: streamRequested ? 'stream' : 'json',
+                };
+                if (Object.keys(req.query).length > 0) {
+                    config.params = req.query;
+                }
+                if (['POST', 'PUT', 'PATCH'].includes(req.method.toUpperCase())) {
+                    config.data = requestBody;
+                }
+                const response = yield (0, axios_1.default)(config);
+                const responseHeaders = response.headers || {};
+                const contentType = typeof responseHeaders['content-type'] === 'string' ? responseHeaders['content-type'] : '';
+                const isEventStream = streamRequested && contentType.includes('text/event-stream');
+                if (isEventStream && response.data) {
+                    res.status(response.status);
+                    if (targetType === 'claude-code' && this.isOpenAIChatSource(sourceType)) {
+                        res.setHeader('Content-Type', 'text/event-stream');
+                        res.setHeader('Cache-Control', 'no-cache');
+                        res.setHeader('Connection', 'keep-alive');
+                        const parser = new streaming_1.SSEParserTransform();
+                        const chunkCollector = new chunk_collector_1.ChunkCollectorTransform();
+                        const converter = new streaming_1.OpenAIToClaudeEventTransform({ model: requestBody === null || requestBody === void 0 ? void 0 : requestBody.model });
+                        const serializer = new streaming_1.SSESerializerTransform();
+                        // 收集响应头
+                        responseHeadersForLog = this.normalizeResponseHeaders(responseHeaders);
+                        res.on('finish', () => {
+                            const usage = converter.getUsage();
+                            if (usage) {
+                                usageForLog = (0, claude_openai_1.extractTokenUsageFromClaudeUsage)(usage);
+                            }
+                            // 收集stream chunks
+                            streamChunksForLog = chunkCollector.getChunks();
+                            void finalizeLog(res.statusCode);
+                        });
+                        (0, stream_1.pipeline)(response.data, parser, chunkCollector, converter, serializer, res, (error) => {
+                            if (error) {
+                                void finalizeLog(500, error.message);
+                            }
+                        });
+                        return;
+                    }
+                    if (targetType === 'claude-code' && this.isOpenAIResponsesSource(sourceType)) {
+                        res.setHeader('Content-Type', 'text/event-stream');
+                        res.setHeader('Cache-Control', 'no-cache');
+                        res.setHeader('Connection', 'keep-alive');
+                        const parser = new streaming_1.SSEParserTransform();
+                        const chunkCollector = new chunk_collector_1.ChunkCollectorTransform();
+                        const converter = new streaming_1.OpenAIResponsesToClaudeEventTransform({ model: requestBody === null || requestBody === void 0 ? void 0 : requestBody.model });
+                        const serializer = new streaming_1.SSESerializerTransform();
+                        responseHeadersForLog = this.normalizeResponseHeaders(responseHeaders);
+                        res.on('finish', () => {
+                            const usage = converter.getUsage();
+                            if (usage) {
+                                usageForLog = (0, claude_openai_1.extractTokenUsageFromClaudeUsage)(usage);
+                            }
+                            streamChunksForLog = chunkCollector.getChunks();
+                            void finalizeLog(res.statusCode);
+                        });
+                        (0, stream_1.pipeline)(response.data, parser, chunkCollector, converter, serializer, res, (error) => {
+                            if (error) {
+                                void finalizeLog(500, error.message);
+                            }
+                        });
+                        return;
+                    }
+                    if (targetType === 'codex' && this.isClaudeSource(sourceType)) {
+                        res.setHeader('Content-Type', 'text/event-stream');
+                        res.setHeader('Cache-Control', 'no-cache');
+                        res.setHeader('Connection', 'keep-alive');
+                        const parser = new streaming_1.SSEParserTransform();
+                        const chunkCollector = new chunk_collector_1.ChunkCollectorTransform();
+                        const converter = new streaming_1.ClaudeToOpenAIResponsesEventTransform({ model: requestBody === null || requestBody === void 0 ? void 0 : requestBody.model });
+                        const serializer = new streaming_1.SSESerializerTransform();
+                        responseHeadersForLog = this.normalizeResponseHeaders(responseHeaders);
+                        res.on('finish', () => {
+                            const usage = converter.getUsage();
+                            if (usage) {
+                                usageForLog = (0, claude_openai_1.extractTokenUsageFromClaudeUsage)(usage);
+                            }
+                            streamChunksForLog = chunkCollector.getChunks();
+                            void finalizeLog(res.statusCode);
+                        });
+                        (0, stream_1.pipeline)(response.data, parser, chunkCollector, converter, serializer, res, (error) => {
+                            if (error) {
+                                void finalizeLog(500, error.message);
+                            }
+                        });
+                        return;
+                    }
+                    if (targetType === 'codex' && this.isOpenAIChatSource(sourceType)) {
+                        res.setHeader('Content-Type', 'text/event-stream');
+                        res.setHeader('Cache-Control', 'no-cache');
+                        res.setHeader('Connection', 'keep-alive');
+                        const parser = new streaming_1.SSEParserTransform();
+                        const chunkCollector = new chunk_collector_1.ChunkCollectorTransform();
+                        const toClaude = new streaming_1.OpenAIToClaudeEventTransform({ model: requestBody === null || requestBody === void 0 ? void 0 : requestBody.model });
+                        const toResponses = new streaming_1.ClaudeToOpenAIResponsesEventTransform({ model: requestBody === null || requestBody === void 0 ? void 0 : requestBody.model });
+                        const serializer = new streaming_1.SSESerializerTransform();
+                        responseHeadersForLog = this.normalizeResponseHeaders(responseHeaders);
+                        res.on('finish', () => {
+                            const usage = toResponses.getUsage();
+                            if (usage) {
+                                usageForLog = (0, claude_openai_1.extractTokenUsageFromClaudeUsage)(usage);
+                            }
+                            streamChunksForLog = chunkCollector.getChunks();
+                            void finalizeLog(res.statusCode);
+                        });
+                        (0, stream_1.pipeline)(response.data, parser, chunkCollector, toClaude, toResponses, serializer, res, (error) => {
+                            if (error) {
+                                void finalizeLog(500, error.message);
+                            }
+                        });
+                        return;
+                    }
+                    // 默认stream处理(无转换)
+                    const chunkCollector = new chunk_collector_1.ChunkCollectorTransform();
+                    responseHeadersForLog = this.normalizeResponseHeaders(responseHeaders);
+                    this.copyResponseHeaders(responseHeaders, res);
+                    res.on('finish', () => {
+                        streamChunksForLog = chunkCollector.getChunks();
+                        void finalizeLog(res.statusCode);
+                    });
+                    (0, stream_1.pipeline)(response.data, chunkCollector, res, (error) => {
+                        if (error) {
+                            void finalizeLog(500, error.message);
+                        }
+                    });
+                    return;
+                }
+                let responseData = response.data;
+                if (streamRequested && response.data && typeof response.data.on === 'function' && !isEventStream) {
+                    const raw = yield this.readStreamBody(response.data);
+                    responseData = (_a = this.safeJsonParse(raw)) !== null && _a !== void 0 ? _a : raw;
+                }
+                // 收集响应头
+                responseHeadersForLog = this.normalizeResponseHeaders(responseHeaders);
+                if (response.status >= 400) {
+                    usageForLog = this.extractTokenUsage(responseData === null || responseData === void 0 ? void 0 : responseData.usage);
+                    // 记录错误响应体
+                    responseBodyForLog = typeof responseData === 'string' ? responseData : JSON.stringify(responseData);
+                    this.copyResponseHeaders(responseHeaders, res);
+                    if (contentType.includes('application/json')) {
+                        res.status(response.status).json(responseData);
+                    }
+                    else {
+                        res.status(response.status).send(responseData);
+                    }
+                    yield finalizeLog(res.statusCode);
+                    return;
+                }
+                if (targetType === 'claude-code' && this.isOpenAIChatSource(sourceType)) {
+                    const converted = (0, claude_openai_1.transformOpenAIChatResponseToClaude)(responseData);
+                    usageForLog = (0, claude_openai_1.extractTokenUsageFromOpenAIUsage)(responseData === null || responseData === void 0 ? void 0 : responseData.usage);
+                    // 记录转换后的响应体
+                    responseBodyForLog = JSON.stringify(converted);
+                    res.status(response.status).json(converted);
+                }
+                else if (targetType === 'claude-code' && this.isOpenAIResponsesSource(sourceType)) {
+                    const converted = (0, openai_responses_1.transformOpenAIResponsesToClaude)(responseData);
+                    usageForLog = (0, openai_responses_1.extractTokenUsageFromOpenAIResponsesUsage)(responseData === null || responseData === void 0 ? void 0 : responseData.usage);
+                    responseBodyForLog = JSON.stringify(converted);
+                    res.status(response.status).json(converted);
+                }
+                else if (targetType === 'codex' && this.isClaudeSource(sourceType)) {
+                    const converted = (0, openai_responses_1.transformClaudeResponseToOpenAIResponses)(responseData);
+                    usageForLog = (0, claude_openai_1.extractTokenUsageFromClaudeUsage)(responseData === null || responseData === void 0 ? void 0 : responseData.usage);
+                    responseBodyForLog = JSON.stringify(converted);
+                    res.status(response.status).json(converted);
+                }
+                else if (targetType === 'codex' && this.isOpenAIChatSource(sourceType)) {
+                    const claudeResponse = (0, claude_openai_1.transformOpenAIChatResponseToClaude)(responseData);
+                    const converted = (0, openai_responses_1.transformClaudeResponseToOpenAIResponses)(claudeResponse);
+                    usageForLog = (0, claude_openai_1.extractTokenUsageFromOpenAIUsage)(responseData === null || responseData === void 0 ? void 0 : responseData.usage);
+                    responseBodyForLog = JSON.stringify(converted);
+                    res.status(response.status).json(converted);
+                }
+                else {
+                    usageForLog = this.extractTokenUsage(responseData === null || responseData === void 0 ? void 0 : responseData.usage);
+                    // 记录原始响应体
+                    responseBodyForLog = typeof responseData === 'string' ? responseData : JSON.stringify(responseData);
+                    this.copyResponseHeaders(responseHeaders, res);
+                    if (contentType.includes('application/json')) {
+                        res.status(response.status).json(responseData);
+                    }
+                    else {
+                        res.status(response.status).send(responseData);
+                    }
+                }
+                yield finalizeLog(res.statusCode);
+            }
+            catch (error) {
+                console.error('Proxy error:', error);
+                yield finalizeLog(500, error.message);
+                res.status(500).json({ error: error.message });
+            }
+        });
+    }
+    reloadRoutes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.routes = this.dbManager.getRoutes().filter((g) => g.isActive);
+            this.rules.clear();
+            for (const route of this.routes) {
+                const routeRules = this.dbManager.getRules(route.id);
+                this.rules.set(route.id, routeRules);
+            }
+            // Load all services
+            const allServices = this.dbManager.getAPIServices();
+            this.services.clear();
+            allServices.forEach((service) => {
+                this.services.set(service.id, service);
+            });
+            console.log(`Loaded ${this.routes.length} active routes and ${this.services.size} services`);
+        });
+    }
+    updateConfig(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.config = config;
+        });
+    }
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.setupMiddleware();
+            yield this.reloadRoutes();
+        });
+    }
+}
+exports.ProxyServer = ProxyServer;