(function() {
    'use strict';
    
    // ==================== 配置区域 ====================
    const CONFIG = {
        // 捕获模式：'strict'(严格) 或 'loose'(宽松)
        mode: 'loose',
        
        // 宽松模式：捕获这些方法
        looseMethods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
        
        // 严格模式：只捕获这些方法
        strictMethods: ['POST', 'PUT', 'PATCH'],
        
        // 高优先级关键词（这些一定会被捕获）
        highPriorityKeywords: [
            // AI服务
            'chat', 'message', 'conversation', 'completion', 'generate', 'stream',
            'claude', 'anthropic', 'openai', 'gpt', 'gemini', 'bard', 'copilot',
            'llama', 'mistral', 'perplexity',
            // 文件相关
            'upload', 'presign', 'signed-url', 'attachment', 'file', 'image',
            'media', 'blob', 'asset', 's3', 'r2', 'storage', 'cloudflare',
            // 评估相关
            'evaluation', 'arena', 'vote', 'feedback'
        ],
        
        // 中优先级关键词
        mediumPriorityKeywords: [
            'api', '/v1/', '/v2/', '/v3/', '/v4/',
            'nextjs-api', 'graphql', 'query', 'mutation',
            'session', 'auth', 'token'
        ],
        
        // 一定排除的关键词（静态资源等）
        alwaysExclude: [
            '.css', '.js', '.woff', '.woff2', '.ttf', '.eot',
            '.ico', 'favicon', 'manifest.json',
            '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', // 静态图片
            'google-analytics', 'googletagmanager', 'doubleclick',
            'facebook.com/tr', 'analytics.js', 'gtag'
        ],
        
        // 可选排除的关键词（宽松模式下也会捕获）
        optionalExclude: [
            'analytics', 'tracking', 'telemetry', 'beacon', 'pixel',
            'logging', 'metrics', 'heartbeat', 'ping', 'health'
        ],
        
        // 请求体中要清理的字段
        cleanBodyFields: [
            { pattern: /^recaptcha.*token$/i, replacement: '[RECAPTCHA]' },
            { pattern: /^.*captcha.*$/i, replacement: '[CAPTCHA]' },
            { pattern: /^g-recaptcha-response$/i, replacement: '[CAPTCHA]' },
            { pattern: /^cf[_-]?turnstile$/i, replacement: '[TURNSTILE]' }
        ],
        
        // 保留所有headers，但这些会被部分隐藏
        hideHeaderPatterns: [
            /^cookie$/i,
            /^authorization$/i,
            /^.*api[_-]?key.*$/i,
            /^.*secret.*$/i
        ],
        
        // 字符串处理
        maxStringLength: 50000,  // 增加限制
        tokenDetectLength: 1000,  // token检测阈值
        base64PreviewLength: 100,  // base64预览长度
        
        // === 新增配置 ===
        maxRequests: 1000,           // 最大保留请求数（防止内存溢出）
        captureResponse: true,       // 是否捕获响应体
        maxResponseLength: 100000,   // 响应体最大长度
        recordTiming: true,          // 是否记录请求耗时
        
        // 响应体排除的 Content-Type（二进制文件等）
        excludeResponseTypes: [
            'image/', 'video/', 'audio/', 'font/',
            'application/octet-stream', 'application/zip',
            'application/pdf', 'application/wasm'
        ]
    };

        // ==================== 预编译关键词（性能优化）====================
    const COMPILED = {
        highPriority: CONFIG.highPriorityKeywords.map(k => k.toLowerCase()),
        mediumPriority: CONFIG.mediumPriorityKeywords.map(k => k.toLowerCase()),
        alwaysExclude: CONFIG.alwaysExclude.map(k => k.toLowerCase()),
        optionalExclude: CONFIG.optionalExclude.map(k => k.toLowerCase())
    };
    
    // ==================== 存储 ====================
    const capturedRequests = [];
    let isCapturing = true;
    let requestCounter = 0;
    
     // ==================== 统一捕获判断（合并优先级计算，避免重复遍历）====================
    function analyzeRequest(url, method) {
        if (!isCapturing) return { shouldCapture: false, priority: null };
        
        const urlLower = url.toLowerCase();
        const methodUpper = method.toUpperCase();
        
        // 1. 一定排除的检查
        for (const keyword of COMPILED.alwaysExclude) {
            if (urlLower.includes(keyword)) {
                return { shouldCapture: false, priority: null };
            }
        }
        
        // 2. 方法过滤
        const methods = CONFIG.mode === 'loose' ? CONFIG.looseMethods : CONFIG.strictMethods;
        if (!methods.includes(methodUpper)) {
            return { shouldCapture: false, priority: null };
        }
        
        // 3. 严格模式下检查可选排除
        if (CONFIG.mode === 'strict') {
            for (const keyword of COMPILED.optionalExclude) {
                if (urlLower.includes(keyword)) {
                    return { shouldCapture: false, priority: null };
                }
            }
        }
        
        // 4. 检查高优先级
        for (const keyword of COMPILED.highPriority) {
            if (urlLower.includes(keyword)) {
                return { shouldCapture: true, priority: 'HIGH' };
            }
        }
        
        // 5. 检查中优先级
        for (const keyword of COMPILED.mediumPriority) {
            if (urlLower.includes(keyword)) {
                return { shouldCapture: true, priority: 'MEDIUM' };
            }
        }
        
        // 6. POST/PUT/PATCH 默认中优先级
        if (['POST', 'PUT', 'PATCH'].includes(methodUpper)) {
            return { shouldCapture: true, priority: 'MEDIUM' };
        }
        
        // 7. 宽松模式额外规则
        if (CONFIG.mode === 'loose') {
            if (urlLower.includes('api') || urlLower.match(/\/v\d+\//)) {
                return { shouldCapture: true, priority: 'LOW' };
            }
            if (methodUpper !== 'GET') {
                return { shouldCapture: true, priority: 'LOW' };
            }
        }
        
        return { shouldCapture: false, priority: 'LOW' };
    }
    
    // 兼容旧调用（保留原有函数名）
    function shouldCapture(url, method) {
        return analyzeRequest(url, method).shouldCapture;
    }
    
    function getPriority(url, method) {
        return analyzeRequest(url, method).priority || 'LOW';
    }
    
        // ==================== 处理Headers ====================
    function processHeaders(headers) {
        if (!headers) return null;
        
        const result = {};
        let headerObj;
        
        if (headers instanceof Headers) {
            headerObj = Object.fromEntries(headers.entries());
        } else if (typeof headers === 'object') {
            headerObj = headers;
        } else {
            return null;
        }
        
        for (const [key, value] of Object.entries(headerObj)) {
            let shouldHide = false;
            for (const pattern of CONFIG.hideHeaderPatterns) {
                if (pattern.test(key)) {
                    shouldHide = true;
                    break;
                }
            }
            
            if (shouldHide) {
                if (value.length > 30) {
                    result[key] = value.substring(0, 15) + '...[HIDDEN]...' + value.substring(value.length - 10);
                } else if (value.length > 10) {
                    result[key] = value.substring(0, 5) + '...[HIDDEN]';
                } else {
                    result[key] = '[HIDDEN]';
                }
            } else {
                result[key] = value;
            }
        }
        
        return Object.keys(result).length > 0 ? result : null;
    }
    
    // ==================== 智能字符串处理 ====================
    function smartProcessString(str, fieldName = '') {
        if (typeof str !== 'string') return str;
        
        const fieldLower = fieldName.toLowerCase();
        
        // 检查是否应该清理该字段
        for (const rule of CONFIG.cleanBodyFields) {
            if (rule.pattern.test(fieldName)) {
                return rule.replacement;
            }
        }
        
        // data:image base64
        if (str.startsWith('data:image/')) {
            const match = str.match(/^(data:image\/[^;]+;base64,)(.+)$/);
            if (match) {
                const [, prefix, data] = match;
                const preview = data.substring(0, CONFIG.base64PreviewLength);
                return `${prefix}${preview}...[BASE64_${data.length}_CHARS]`;
            }
        }
        
        // 纯base64 (长字符串)
        if (str.length > CONFIG.tokenDetectLength && /^[A-Za-z0-9+/]+=*$/.test(str)) {
            const preview = str.substring(0, CONFIG.base64PreviewLength);
            return `${preview}...[BASE64_${str.length}_CHARS]`;
        }
        
        // URL安全base64
        if (str.length > CONFIG.tokenDetectLength && /^[A-Za-z0-9_-]+$/.test(str)) {
            const preview = str.substring(0, CONFIG.base64PreviewLength);
            return `${preview}...[TOKEN_${str.length}_CHARS]`;
        }
        
        // 普通长字符串
        if (str.length > CONFIG.maxStringLength) {
            return str.substring(0, CONFIG.maxStringLength) + `...[TRUNCATED_${str.length - CONFIG.maxStringLength}_MORE]`;
        }
        
        return str;
    }
    
    // ==================== 处理Body ====================
    function processBody(body, depth = 0) {
        if (depth > 20) return '[MAX_DEPTH]';
        if (body === null || body === undefined) return null;
        
        // FormData
        if (body instanceof FormData) {
            const result = { _type: 'FormData', fields: {} };
            for (const [key, value] of body.entries()) {
                if (value instanceof File) {
                    result.fields[key] = {
                        _type: 'File',
                        name: value.name,
                        size: value.size,
                        sizeKB: (value.size / 1024).toFixed(2) + ' KB',
                        mimeType: value.type,
                        lastModified: new Date(value.lastModified).toISOString()
                    };
                } else if (value instanceof Blob) {
                    result.fields[key] = {
                        _type: 'Blob',
                        size: value.size,
                        sizeKB: (value.size / 1024).toFixed(2) + ' KB',
                        mimeType: value.type
                    };
                } else {
                    result.fields[key] = smartProcessString(value, key);
                }
            }
            return result;
        }
        
        // Blob
        if (body instanceof Blob) {
            return {
                _type: 'Blob',
                size: body.size,
                sizeKB: (body.size / 1024).toFixed(2) + ' KB',
                mimeType: body.type
            };
        }
        
        // ArrayBuffer
        if (body instanceof ArrayBuffer) {
            return {
                _type: 'ArrayBuffer',
                byteLength: body.byteLength
            };
        }
        
        // String
        if (typeof body === 'string') {
            try {
                const parsed = JSON.parse(body);
                return processBodyRecursive(parsed, depth + 1, '');  // 🔧 传递空字段名作为根
            } catch {
                return smartProcessString(body);
            }
        }
        
        // Object/Array
        if (typeof body === 'object') {
            return processBodyRecursive(body, depth);
        }
        
        return body;
    }
    
    function processBodyRecursive(obj, depth = 0, fieldName = '') {
        if (depth > 20) return '[MAX_DEPTH]';
        if (obj === null || obj === undefined) return obj;
        
        if (Array.isArray(obj)) {
            return obj.map((item, index) => processBodyRecursive(item, depth + 1, `${fieldName}[${index}]`));
        }
        
        if (typeof obj === 'string') {
            return smartProcessString(obj, fieldName);  // 🔧 修复：传递字段名
        }
        
        if (typeof obj === 'object') {
            const result = {};
            for (const [key, value] of Object.entries(obj)) {
                result[key] = processBodyRecursive(value, depth + 1, key);  // 🔧 修复：传递字段名
            }
            return result;
        }
        
        return obj;
    }
    
    // ==================== 响应处理 ====================
    function shouldCaptureResponse(contentType) {
        if (!contentType) return true;
        const typeLower = contentType.toLowerCase();
        return !CONFIG.excludeResponseTypes.some(excluded => typeLower.includes(excluded));
    }
    
    async function processResponse(response, requestId) {
        if (!CONFIG.captureResponse) return null;
        
        const record = capturedRequests.find(r => r._id === requestId);
        if (!record) return null;
        
        try {
            const contentType = response.headers.get('content-type') || '';
            
            const responseData = {
                status: response.status,
                statusText: response.statusText,
                headers: processHeaders(response.headers),
                contentType: contentType,
                body: null,
                bodyTruncated: false
            };
            
            // 检查是否应该捕获响应体
            if (shouldCaptureResponse(contentType)) {
                const cloned = response.clone();
                let bodyText = await cloned.text();
                
                if (bodyText.length > CONFIG.maxResponseLength) {
                    responseData.body = bodyText.substring(0, CONFIG.maxResponseLength);
                    responseData.bodyTruncated = true;
                    responseData.bodyOriginalLength = bodyText.length;
                } else {
                    // 尝试解析 JSON
                    try {
                        responseData.body = JSON.parse(bodyText);
                        responseData.bodyType = 'json';
                    } catch {
                        responseData.body = bodyText;
                        responseData.bodyType = 'text';
                    }
                }
            } else {
                responseData.body = `[BINARY: ${contentType}]`;
                responseData.bodyType = 'binary';
            }
            
            record._response = responseData;
        } catch (e) {
            record._response = { error: e.message };
        }
        
        return record._response;
    }
    
    function updateRequestTiming(requestId, error = null) {
        const record = capturedRequests.find(r => r._id === requestId);
        if (record && record._timing) {
            record._timing.endTime = Date.now();
            record._timing.duration = record._timing.endTime - record._timing.startTime;
            if (error) {
                record._error = {
                    message: error.message || String(error),
                    name: error.name,
                    stack: error.stack?.split('\n').slice(0, 3).join('\n')
                };
            }
        }
    }
    

    // ==================== URL处理 ====================
    function parseUrl(url) {
        try {
            const urlObj = new URL(url);
            return {
                full: url,
                protocol: urlObj.protocol,
                host: urlObj.host,
                hostname: urlObj.hostname,
                port: urlObj.port,
                pathname: urlObj.pathname,
                search: urlObj.search,
                hash: urlObj.hash,
                origin: urlObj.origin
            };
        } catch {
            try {
                const urlObj = new URL(url, window.location.origin);
                return {
                    full: url,
                    protocol: urlObj.protocol,
                    host: urlObj.host,
                    hostname: urlObj.hostname,
                    port: urlObj.port,
                    pathname: urlObj.pathname,
                    search: urlObj.search,
                    hash: urlObj.hash,
                    origin: urlObj.origin,
                    _relative: true
                };
            } catch {
                return { full: url, pathname: url };
            }
        }
    }
    
    // ==================== 添加请求 ====================
    function addCapturedRequest(data) {
        requestCounter++;
        
        // 🔧 使用合并后的分析函数（避免重复计算）
        const analysis = analyzeRequest(data.url.full || data.url.pathname, data.method);
        const priority = analysis.priority || 'LOW';
        
        const record = {
            _id: requestCounter,
            _capturedAt: new Date().toISOString(),
            _priority: priority,
            _timing: {
                startTime: Date.now(),
                duration: null,
                endTime: null
            },
            _response: null,  // 响应占位，稍后填充
            _error: null,     // 错误占位
            ...data
        };
        
        capturedRequests.push(record);
        
        // 🔧 内存保护：超过最大限制时移除最旧的低优先级请求
        if (capturedRequests.length > CONFIG.maxRequests) {
            // 优先删除 LOW 优先级，其次 MEDIUM
            const indexToRemove = capturedRequests.findIndex(r => r._priority === 'LOW') 
                ?? capturedRequests.findIndex(r => r._priority === 'MEDIUM')
                ?? 0;
            const removed = capturedRequests.splice(indexToRemove, 1)[0];
            console.warn(`%c⚠️ Memory limit reached, removed request #${removed._id}`, 'color: #FF9800;');
        }
        
        const colors = {
            HIGH: '#FF5722',
            MEDIUM: '#4CAF50',
            LOW: '#9E9E9E'
        };
        
        const emoji = {
            HIGH: '🔴',
            MEDIUM: '🟢',
            LOW: '⚪'
        };
        
        console.log(
            `%c${emoji[priority]} [#${requestCounter}] ${data.method} ${data.url.pathname || data.url.full}`,
            `color: ${colors[priority]}; font-weight: ${priority === 'HIGH' ? 'bold' : 'normal'};`
        );
        
        return record;
    }
    
    // ==================== 拦截Fetch ====================
    const originalFetch = window.fetch;
    window.fetch = async function(input, init = {}) {
        const url = input instanceof Request ? input.url : String(input);
        const method = init.method || (input instanceof Request ? input.method : 'GET');
        
        const analysis = analyzeRequest(url, method);
        
        if (!analysis.shouldCapture) {
            return originalFetch.apply(this, arguments);
        }
        
        let capturedRecord = null;
        
        try {
            let bodyData = init.body;
            if (input instanceof Request && !init.body) {
                try {
                    bodyData = await input.clone().text();
                } catch (e) {
                    bodyData = { _error: 'Failed to read Request body', _reason: e.message };
                }
            }
            
            capturedRecord = addCapturedRequest({
                type: 'fetch',
                method: method.toUpperCase(),
                url: parseUrl(url),
                headers: processHeaders(init.headers || (input instanceof Request ? input.headers : null)),
                body: processBody(bodyData),
                credentials: init.credentials || 'same-origin',
                mode: init.mode || 'cors'
            });
        } catch (e) {
            console.warn('❌ Capture error:', e);
        }
        
        try {
            const response = await originalFetch.apply(this, arguments);
            
            // 捕获响应
            if (capturedRecord) {
                updateRequestTiming(capturedRecord._id);
                await processResponse(response, capturedRecord._id);
                
                // 标记失败的请求
                if (!response.ok) {
                    capturedRecord._httpError = {
                        status: response.status,
                        statusText: response.statusText
                    };
                }
            }
            
            return response;
        } catch (e) {
            // 网络错误等
            if (capturedRecord) {
                updateRequestTiming(capturedRecord._id, e);
            }
            throw e;
        }
    };
    
    // ==================== 拦截XHR ====================
    const originalXHROpen = XMLHttpRequest.prototype.open;
    const originalXHRSend = XMLHttpRequest.prototype.send;
    const originalXHRSetHeader = XMLHttpRequest.prototype.setRequestHeader;
    
    XMLHttpRequest.prototype.open = function(method, url, ...args) {
        this._captureInfo = {
            method: method.toUpperCase(),
            url: String(url),
            headers: {}
        };
        return originalXHROpen.apply(this, [method, url, ...args]);
    };
    
    XMLHttpRequest.prototype.setRequestHeader = function(name, value) {
        if (this._captureInfo) {
            this._captureInfo.headers[name] = value;
        }
        return originalXHRSetHeader.apply(this, arguments);
    };
    
    XMLHttpRequest.prototype.send = function(body) {
        const self = this;
        let capturedRecord = null;
        
        if (this._captureInfo && shouldCapture(this._captureInfo.url, this._captureInfo.method)) {
            try {
                capturedRecord = addCapturedRequest({
                    type: 'xhr',
                    method: this._captureInfo.method,
                    url: parseUrl(this._captureInfo.url),
                    headers: processHeaders(this._captureInfo.headers),
                    body: processBody(body)
                });
                
                // 保存引用以便在回调中使用
                this._capturedRecordId = capturedRecord._id;
            } catch (e) {
                console.warn('❌ XHR capture error:', e);
            }
        }
        
        // 监听响应
        if (capturedRecord && CONFIG.captureResponse) {
            const originalOnReadyStateChange = this.onreadystatechange;
            
            this.onreadystatechange = function() {
                if (self.readyState === 4 && self._capturedRecordId) {
                    const record = capturedRequests.find(r => r._id === self._capturedRecordId);
                    if (record) {
                        updateRequestTiming(record._id);
                        
                        const contentType = self.getResponseHeader('content-type') || '';
                        
                        record._response = {
                            status: self.status,
                            statusText: self.statusText,
                            contentType: contentType,
                            headers: null,  // XHR 无法方便获取所有响应头
                            body: null
                        };
                        
                        // 捕获响应体
                        if (shouldCaptureResponse(contentType)) {
                            try {
                                let responseBody = self.responseText;
                                
                                if (responseBody.length > CONFIG.maxResponseLength) {
                                    record._response.body = responseBody.substring(0, CONFIG.maxResponseLength);
                                    record._response.bodyTruncated = true;
                                    record._response.bodyOriginalLength = responseBody.length;
                                } else {
                                    try {
                                        record._response.body = JSON.parse(responseBody);
                                        record._response.bodyType = 'json';
                                    } catch {
                                        record._response.body = responseBody;
                                        record._response.bodyType = 'text';
                                    }
                                }
                            } catch (e) {
                                record._response.body = { _error: 'Failed to read response', _reason: e.message };
                            }
                        } else {
                            record._response.body = `[BINARY: ${contentType}]`;
                            record._response.bodyType = 'binary';
                        }
                        
                        // 标记失败
                        if (self.status >= 400) {
                            record._httpError = {
                                status: self.status,
                                statusText: self.statusText
                            };
                        }
                    }
                }
                
                if (originalOnReadyStateChange) {
                    originalOnReadyStateChange.apply(self, arguments);
                }
            };
            
            // 监听错误
            const originalOnError = this.onerror;
            this.onerror = function(e) {
                if (self._capturedRecordId) {
                    updateRequestTiming(self._capturedRecordId, { message: 'Network error', name: 'NetworkError' });
                }
                if (originalOnError) {
                    originalOnError.apply(self, arguments);
                }
            };
        }
        
        return originalXHRSend.apply(this, arguments);
    };
    
    // ==================== 导出命令 ====================
    
    // 导出（可选优先级过滤）
    window.exportRequests = function(options = {}) {
        const {
            filename = `requests-${Date.now()}.json`,
            priority = null,  // 'HIGH', 'MEDIUM', 'LOW' 或 null(全部)
            minPriority = null  // 'MEDIUM'(包含HIGH和MEDIUM), 'LOW'(全部)
        } = typeof options === 'string' ? { filename: options } : options;
        
        let filtered = capturedRequests;
        
        if (priority) {
            filtered = filtered.filter(r => r._priority === priority);
        } else if (minPriority === 'MEDIUM') {
            filtered = filtered.filter(r => ['HIGH', 'MEDIUM'].includes(r._priority));
        } else if (minPriority === 'HIGH') {
            filtered = filtered.filter(r => r._priority === 'HIGH');
        }
        
        if (filtered.length === 0) {
            console.warn('⚠️ No requests to export!');
            return;
        }
        
        const exportData = {
            _exportedAt: new Date().toISOString(),
            _totalRequests: filtered.length,
            _source: window.location.href,
            _captureMode: CONFIG.mode,
            requests: filtered
        };
        
        const json = JSON.stringify(exportData, null, 2);
        const blob = new Blob([json], { type: 'application/json' });
        const url = URL.createObjectURL(blob);
        
        const a = document.createElement('a');
        a.href = url;
        a.download = filename;
        document.body.appendChild(a);
        a.click();
        document.body.removeChild(a);
        URL.revokeObjectURL(url);
        
        console.log(`%c✅ Exported ${filtered.length} requests to ${filename}`, 'color: #4CAF50; font-weight: bold;');
        return exportData;
    };
    
    // 查看列表
    window.viewRequests = function(priority = null) {
        let filtered = capturedRequests;
        if (priority) {
            filtered = filtered.filter(r => r._priority === priority);
        }
        
        if (filtered.length === 0) {
            console.log('📭 No requests');
            return [];
        }
        
        console.table(filtered.map(r => ({
            ID: r._id,
            Priority: r._priority,
            Time: r._capturedAt.split('T')[1].split('.')[0],
            Type: r.type,
            Method: r.method,
            Path: (r.url.pathname || r.url.full || '').substring(0, 60)
        })));
        
        return filtered;
    };
    
    // 查看单个
    window.viewRequest = function(id) {
        const r = capturedRequests.find(r => r._id === id);
        if (!r) {
            console.warn(`⚠️ Request #${id} not found`);
            return null;
        }
        console.log(JSON.stringify(r, null, 2));
        return r;
    };
    
    // 搜索
    window.searchRequests = function(keyword) {
        const keywordLower = keyword.toLowerCase();
        const results = capturedRequests.filter(r => {
            const json = JSON.stringify(r).toLowerCase();
            return json.includes(keywordLower);
        });
        
        console.log(`%c🔍 Found ${results.length} requests containing "${keyword}"`, 'color: #2196F3;');
        console.table(results.map(r => ({
            ID: r._id,
            Priority: r._priority,
            Method: r.method,
            Path: (r.url.pathname || r.url.full || '').substring(0, 60)
        })));
        
        return results;
    };
    
    // 统计
    window.requestStats = function() {
        const stats = {
            total: capturedRequests.length,
            byPriority: {},
            byMethod: {},
            byType: {},
            isCapturing,
            mode: CONFIG.mode
        };
        
        capturedRequests.forEach(r => {
            stats.byPriority[r._priority] = (stats.byPriority[r._priority] || 0) + 1;
            stats.byMethod[r.method] = (stats.byMethod[r.method] || 0) + 1;
            stats.byType[r.type] = (stats.byType[r.type] || 0) + 1;
        });
        
        console.log('%c📊 Request Statistics', 'color: #2196F3; font-size: 14px; font-weight: bold;');
        console.table(stats);
        return stats;
    };
    
    // 清空
    window.clearRequests = function() {
        const count = capturedRequests.length;
        capturedRequests.length = 0;
        requestCounter = 0;
        console.log(`%c🗑️ Cleared ${count} requests`, 'color: #FF9800;');
    };
    
    // 暂停/恢复
    window.toggleCapture = function() {
        isCapturing = !isCapturing;
        console.log(
            `%c${isCapturing ? '▶️ Capturing RESUMED' : '⏸️ Capturing PAUSED'}`,
            `color: ${isCapturing ? '#4CAF50' : '#FF9800'}; font-weight: bold;`
        );
        return isCapturing;
    };
     // 复制到剪贴板
    window.copyRequests = async function(options = {}) {
        const {
            priority = null,
            minPriority = null,
            format = 'json'  // 'json' 或 'curl'
        } = typeof options === 'string' ? { priority: options } : options;
        
        let filtered = capturedRequests;
        
        if (priority) {
            filtered = filtered.filter(r => r._priority === priority);
        } else if (minPriority === 'MEDIUM') {
            filtered = filtered.filter(r => ['HIGH', 'MEDIUM'].includes(r._priority));
        } else if (minPriority === 'HIGH') {
            filtered = filtered.filter(r => r._priority === 'HIGH');
        }
        
        if (filtered.length === 0) {
            console.warn('⚠️ No requests to copy!');
            return;
        }
        
        let text;
        if (format === 'curl') {
            text = filtered.map(r => {
                let curl = `curl -X ${r.method} '${r.url.full}'`;
                if (r.headers) {
                    for (const [key, value] of Object.entries(r.headers)) {
                        if (!value.includes('[HIDDEN]')) {
                            curl += ` \\\n  -H '${key}: ${value}'`;
                        }
                    }
                }
                if (r.body && typeof r.body === 'object') {
                    curl += ` \\\n  -d '${JSON.stringify(r.body)}'`;
                } else if (r.body) {
                    curl += ` \\\n  -d '${r.body}'`;
                }
                return curl;
            }).join('\n\n---\n\n');
        } else {
            text = JSON.stringify(filtered, null, 2);
        }
        
        try {
            await navigator.clipboard.writeText(text);
            console.log(`%c📋 Copied ${filtered.length} requests to clipboard (${format} format)`, 'color: #4CAF50; font-weight: bold;');
        } catch (e) {
            // 降级方案
            console.log('📋 Clipboard API failed, printing to console:');
            console.log(text);
        }
        
        return text;
    };
    
    // 查看失败的请求
    window.viewErrors = function() {
        const errors = capturedRequests.filter(r => r._error || r._httpError);
        if (errors.length === 0) {
            console.log('✅ No errors captured');
            return [];
        }
        
        console.log(`%c❌ Found ${errors.length} requests with errors`, 'color: #f44336; font-weight: bold;');
        console.table(errors.map(r => ({
            ID: r._id,
            Method: r.method,
            Path: (r.url.pathname || '').substring(0, 40),
            Status: r._httpError?.status || 'N/A',
            Error: r._error?.message || r._httpError?.statusText || 'Unknown'
        })));
        
        return errors;
    };
    
    // 查看慢请求
    window.viewSlow = function(thresholdMs = 1000) {
        const slow = capturedRequests.filter(r => r._timing?.duration > thresholdMs);
        if (slow.length === 0) {
            console.log(`✅ No requests slower than ${thresholdMs}ms`);
            return [];
        }
        
        slow.sort((a, b) => (b._timing?.duration || 0) - (a._timing?.duration || 0));
        
        console.log(`%c🐌 Found ${slow.length} requests slower than ${thresholdMs}ms`, 'color: #FF9800; font-weight: bold;');
        console.table(slow.map(r => ({
            ID: r._id,
            Method: r.method,
            Path: (r.url.pathname || '').substring(0, 40),
            Duration: r._timing?.duration + 'ms',
            Status: r._response?.status || 'N/A'
        })));
        
        return slow;
    };
       
    // 切换模式
    window.setCaptureMode = function(mode) {
        if (!['strict', 'loose'].includes(mode)) {
            console.error('❌ Mode must be "strict" or "loose"');
            return;
        }
        CONFIG.mode = mode;
        console.log(`%c🔧 Capture mode set to: ${mode.toUpperCase()}`, 'color: #2196F3; font-weight: bold;');
        return mode;
    };
    
    // ==================== 启动信息 ====================
    console.log(
`%c🔍 AI Request Monitor Pro v4.0 (Enhanced)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Mode: ${CONFIG.mode.toUpperCase()} | Priority: 🔴HIGH 🟢MEDIUM ⚪LOW
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Commands:
  exportRequests(options)     - Export all or filtered
  viewRequests(priority)      - View list (optional filter)
  viewRequest(id)             - View single request
  searchRequests(keyword)     - Search in all requests
  requestStats()              - Show statistics
  clearRequests()             - Clear all
  toggleCapture()             - Pause/Resume
  setCaptureMode(mode)        - Switch 'strict'/'loose'

📦 NEW in v4.0:
  copyRequests(options)       - Copy to clipboard (format: 'json'/'curl')
  viewErrors()                - View failed requests
  viewSlow(ms)                - View slow requests (default: >1000ms)

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
        'color: #2196F3; font-size: 14px;'
    );
    
})(); 