Delete fairies_proxy.py

fairies_proxy.py

@@ -1,713 +0,0 @@
-#!/usr/bin/env python3
-"""
-Fairies AI to OpenAI API Proxy v2.0
-支持本地API密钥验证、模型列表、WebSocket连接池和流式响应
-"""
-
-import asyncio
-import json
-import os
-import signal
-import time
-import uuid
-import websockets
-import requests
-from flask import Flask, request, jsonify, Response
-from waitress import serve
-from datetime import datetime
-from typing import Dict, List, Optional, Any
-import threading
-
-# 配置信息
-FAIRIES_COOKIE_STRING = os.getenv('FAIRIES_COOKIE_STRING', '')
-LOCAL_API_KEY = os.getenv('FAIRIES_API_KEY', 'sk-fairies-proxy-2025-v2')
-
-# 支持的模型列表
-AVAILABLE_MODELS = [
-    {"id": "claude-sonnet-4-20250514", "object": "model", "created": int(time.time()), "owned_by": "anthropic"},
-    {"id": "gpt-4.1", "object": "model", "created": int(time.time()), "owned_by": "openai"},
-    {"id": "gemini-2.5-flash", "object": "model", "created": int(time.time()), "owned_by": "google"},
-    {"id": "gemini-2.5-pro", "object": "model", "created": int(time.time()), "owned_by": "google"},
-    {"id": "gpt-4.1-mini", "object": "model", "created": int(time.time()), "owned_by": "openai"},
-    {"id": "x-ai/grok-3-mini", "object": "model", "created": int(time.time()), "owned_by": "x-ai"}
-]
-
-PORT = int(os.getenv('PORT', 7001))
-app = Flask(__name__)
-
-# 验证必要的环境变量
-if not FAIRIES_COOKIE_STRING:
-    print("⚠️  警告: FAIRIES_COOKIE_STRING 环境变量未设置!")
-    print("   请设置: export FAIRIES_COOKIE_STRING='your_cookie_string'")
-
-print(f"🔧 配置信息:")
-print(f"   API密钥: {LOCAL_API_KEY}")
-print(f"   端口: {PORT}")
-print(f"   Cookie状态: {'✅ 已设置' if FAIRIES_COOKIE_STRING else '❌ 未设置'}")
-print()
-
-class FairiesAIClient:
-    def __init__(self, cookie_string):
-        self.cookie_string = cookie_string
-        self.api_base = "https://fairies.ai/api"
-        self.websocket_url = "wss://fairies.ai/api/agent/ws"
-        
-        # 预配置的Agent ID（固定不变）
-        self.PREDEFINED_AGENTS = {
-            "MAIN": "4f18843d-8823-4151-99e2-00fa87eec890",
-            "DEEPRESEARCH": "5b84e999-08e5-431f-a188-af22c1a8db2c", 
-            "PERCEPTOR": "69611193-859e-4b5c-b1ee-2d2ea6ab25b2",
-            "AUTOMATOR": "fc59b81a-5e0a-48e9-b78f-be2b66949d37"
-        }
-        
-        self.headers = {
-            "Content-Type": "application/json",
-            "Cookie": cookie_string,
-            "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36"
-        }
-        
-        print(f"🔧 初始化FairiesAI客户端")
-        print(f"   预配置Agent数量: {len(self.PREDEFINED_AGENTS)}")
-
-    def get_agent_id(self, agent_type="MAIN"):
-        """获取预配置的Agent ID"""
-        agent_id = self.PREDEFINED_AGENTS.get(agent_type.upper())
-        if agent_id:
-            print(f"✅ 使用预配置Agent: {agent_type} -> {agent_id}")
-            return agent_id
-        else:
-            print(f"⚠️ 未知的Agent类型: {agent_type}，使用默认MAIN")
-            return self.PREDEFINED_AGENTS["MAIN"]
-
-    async def create_websocket_connection(self):
-        """为每个请求创建独立的WebSocket连接"""
-        session_token = None
-        for cookie_part in self.cookie_string.split(';'):
-            if 'session=' in cookie_part:
-                session_token = cookie_part.split('session=')[1].strip()
-                break
-        
-        if not session_token:
-            raise Exception("No session token found in cookies")
-        
-        print(f"🔗 创建独立WebSocket连接")
-        
-        ws_headers = {
-            "session-token": session_token,
-            "Cookie": f"session={session_token}",
-            "User-Agent": "Altera-Agent/1.0"
-        }
-        
-        try:
-            # 兼容不同版本的websockets库
-            try:
-                # 新版本使用extra_headers
-                websocket = await asyncio.wait_for(
-                    websockets.connect(
-                        self.websocket_url, 
-                        extra_headers=ws_headers,
-                        ping_interval=30,  # 30秒ping间隔
-                        ping_timeout=10,   # 10秒ping超时
-                        close_timeout=10   # 10秒关闭超时
-                    ),
-                    timeout=30.0  # 连接超时30秒
-                )
-            except TypeError:
-                # 旧版本使用additional_headers
-                websocket = await asyncio.wait_for(
-                    websockets.connect(
-                        self.websocket_url, 
-                        additional_headers=ws_headers,
-                        ping_interval=30,  # 30秒ping间隔
-                        ping_timeout=10,   # 10秒ping超时
-                        close_timeout=10   # 10秒关闭超时
-                    ),
-                    timeout=30.0  # 连接超时30秒
-                )
-            
-            print("✅ WebSocket连接成功")
-            return websocket
-        except asyncio.TimeoutError:
-            print(f"❌ WebSocket连接超时")
-            raise Exception("WebSocket connection timeout")
-        except websockets.exceptions.InvalidStatusCode as e:
-            if e.status_code in [401, 403]:
-                print(f"❌ WebSocket认证失败: {e.status_code}")
-                print("💡 提示: 请检查FAIRIES_COOKIE_STRING是否有效")
-                raise Exception(f"Authentication failed: {e.status_code}")
-            elif e.status_code == 429:
-                print(f"❌ WebSocket连接频率限制: {e.status_code}")
-                raise Exception(f"Rate limit exceeded: {e.status_code}")
-            elif e.status_code >= 500:
-                print(f"❌ WebSocket服务器错误: {e.status_code}")
-                raise Exception(f"Server error: {e.status_code}")
-            else:
-                print(f"❌ WebSocket连接失败，状态码: {e.status_code}")
-                raise Exception(f"WebSocket connection failed: {e.status_code}")
-        except Exception as e:
-            print(f"❌ WebSocket连接失败: {str(e)}")
-            raise
-
-    async def chat_stream(self, agent_id, query, model="claude-sonnet-4-20250514"):
-        """异步流式聊天方法 - 每个请求使用独立连接"""
-        websocket = None
-        try:
-            websocket = await self.create_websocket_connection()
-            
-            # 使用昨天能工作的消息格式
-            user_message = {
-                "type": "USER_MESSAGE",
-                "agent_id": agent_id,
-                "observation": {
-                    "message": {
-                        "user_query": query,
-                        "mode": "main",
-                        "files": [],
-                        "memories": [],
-                        "model": model,
-                        "task_id": None,
-                        "workspace_path": "/"
-                    }
-                }
-            }
-            
-            await websocket.send(json.dumps(user_message))
-            print("📤 消息已发送")
-            
-            is_assistant_turn = False
-            delta_count = 0
-            response_completed = False
-            
-            try:
-                # 使用昨天能工作的消息处理逻辑
-                async for message in websocket:
-                    try:
-                        try:
-                            inner_json_string = json.loads(message)
-                            parsed_message = json.loads(inner_json_string)
-                        except (json.JSONDecodeError, TypeError):
-                            parsed_message = json.loads(message)
-                        
-                        msg_type = parsed_message.get("type")
-                        
-                        if msg_type == "CHAT_MESSAGE":
-                            inner_msg = parsed_message.get("message", {}).get("message", {})
-                            inner_type = inner_msg.get("type")
-                            role = inner_msg.get("item", {}).get("role")
-                            
-                            if inner_type == "response.output_item.added" and role == "assistant":
-                                is_assistant_turn = True
-                                print("🤖 AI开始回复...")
-                            
-                            elif is_assistant_turn and inner_type == "response.output_text.delta":
-                                delta_text = inner_msg.get("delta", "")
-                                if delta_text:
-                                    delta_count += 1
-                                    yield {"delta": delta_text}
-                            
-                            elif inner_type == "response.output_item.done" and role == "assistant":
-                                is_assistant_turn = False
-                                response_completed = True
-                                print(f"✅ AI回复完成，共收到 {delta_count} 个delta")
-                                yield {"done": True}
-                                break
-                        
-                        # 处理任务相关消息
-                        elif msg_type == "TASK_UPDATE":
-                            task_data = parsed_message.get("task", {})
-                            print(f"📋 任务更新: {task_data.get('status', 'unknown')}")
-                            
-                    except Exception as e:
-                        print(f"⚠️ 处理消息时出错: {e}")
-                        continue
-                        
-            except asyncio.TimeoutError:
-                print("⚠️ WebSocket消息接收超时")
-                yield {"error": "Message receive timeout"}
-            except websockets.exceptions.ConnectionClosed:
-                if not response_completed:
-                    print("⚠️ WebSocket连接意外关闭")
-                    yield {"error": "Connection closed unexpectedly"}
-                else:
-                    print("✅ WebSocket连接正常关闭")
-                    
-        except Exception as e:
-            print(f"❌ WebSocket通信失败: {str(e)}")
-            yield {"error": str(e)}
-        finally:
-            # 确保WebSocket连接正确关闭
-            if websocket:
-                try:
-                    await websocket.close()
-                    print("🔒 WebSocket连接已关闭")
-                except Exception as e:
-                    print(f"⚠️ 关闭WebSocket连接时出错: {e}")
-    
-    async def close_websocket_pool(self):
-        """关闭所有WebSocket连接"""
-        # 移除WebSocket连接池的清理逻辑
-        print("🔒 移除WebSocket连接池的清理逻辑")
-    
-    def list_tasks(self):
-        """获取任务列表"""
-        try:
-            response = requests.get(f"{self.api_base}/workflow/tasks", headers=self.headers, timeout=10)
-            response.raise_for_status()
-            tasks = response.json()
-            print(f"📋 获取到 {len(tasks)} 个任务")
-            return tasks
-        except Exception as e:
-            print(f"❌ 获取任务列表失败: {e}")
-            return []
-    
-    def update_task_status(self, task_id, status):
-        """更新任务状态"""
-        try:
-            payload = {"status": status}
-            response = requests.put(f"{self.api_base}/workflow/tasks/{task_id}", 
-                                  headers=self.headers, json=payload)
-            response.raise_for_status()
-            print(f"✅ 任务 {task_id} 状态更新为: {status}")
-            return True
-        except Exception as e:
-            print(f"❌ 更新任务状态失败: {e}")
-            return False
-    
-    def delete_task(self, task_id):
-        """删除任务"""
-        try:
-            response = requests.delete(f"{self.api_base}/workflow/tasks/{task_id}", headers=self.headers)
-            response.raise_for_status()
-            print(f"🗑️ 任务 {task_id} 已删除")
-            return True
-        except Exception as e:
-            print(f"❌ 删除任务失败: {e}")
-            return False
-    
-    def validate_connection(self):
-        """验证连接配置"""
-        issues = []
-        
-        # 检查Cookie
-        if not self.cookie_string:
-            issues.append("FAIRIES_COOKIE_STRING未设置")
-        else:
-            # 检查session token
-            session_token = None
-            for cookie_part in self.cookie_string.split(';'):
-                if 'session=' in cookie_part:
-                    session_token = cookie_part.split('session=')[1].strip()
-                    break
-            if not session_token:
-                issues.append("Cookie中未找到有效的session token")
-        
-        if issues:
-            print("⚠️ 连接配置问题:")
-            for issue in issues:
-                print(f"   - {issue}")
-            return False
-        else:
-            print("✅ 连接配置验证通过")
-            return True
-    
-    async def health_check(self):
-        """健康检查"""
-        try:
-            # 测试WebSocket连接
-            websocket = await self.create_websocket_connection()
-            await websocket.ping()
-            await websocket.close()  # 立即关闭测试连接
-            print("✅ WebSocket连接健康")
-            return {"websocket": "healthy", "status": "ok"}
-        except Exception as e:
-            print(f"❌ WebSocket连接不健康: {e}")
-            return {"websocket": "unhealthy", "status": "error", "error": str(e)}
-
-# 全局客户端实例
-fairies_client = FairiesAIClient(FAIRIES_COOKIE_STRING)
-
-def verify_api_key():
-    """验证API密钥"""
-    auth_header = request.headers.get('Authorization')
-    if not auth_header:
-        return False, jsonify({"error": {"message": "Authorization header is required", "type": "invalid_request_error"}}), 401
-    
-    if not auth_header.startswith('Bearer '):
-        return False, jsonify({"error": {"message": "Invalid authorization header format", "type": "invalid_request_error"}}), 401
-    
-    api_key = auth_header.split(' ')[1]
-    if api_key != LOCAL_API_KEY:
-        return False, jsonify({"error": {"message": "Invalid API key", "type": "invalid_request_error"}}), 401
-    
-    return True, None, None
-
-@app.route('/v1/models', methods=['GET'])
-def list_models():
-    """返回可用模型列表"""
-    is_valid, error_response, status_code = verify_api_key()
-    if not is_valid:
-        return error_response, status_code
-    
-    return jsonify({
-        "object": "list",
-        "data": AVAILABLE_MODELS
-    })
-
-@app.route('/v1/chat/completions', methods=['POST'])
-def chat_completions():
-    """OpenAI兼容的聊天完成接口"""
-    is_valid, error_response, status_code = verify_api_key()
-    if not is_valid:
-        return error_response, status_code
-    
-    data = request.get_json()
-    if not data:
-        return jsonify({"error": {"message": "Request body is required", "type": "invalid_request_error"}}), 400
-    
-    messages = data.get('messages', [])
-    stream = data.get('stream', False)
-    model = data.get('model', 'claude-sonnet-4-20250514')
-    
-    if not messages:
-        return jsonify({"error": {"message": "messages field is required", "type": "invalid_request_error"}}), 400
-    
-    # 提取最后一条用户消息
-    user_message = None
-    for msg in reversed(messages):
-        if msg.get('role') == 'user':
-            user_message = msg.get('content')
-            break
-    
-    if not user_message:
-        return jsonify({"error": {"message": "No user message found", "type": "invalid_request_error"}}), 400
-    
-    print(f"👤 用户消息: {user_message}")
-    print(f"📡 流式模式: {stream}")
-    print(f"🎯 模型: {model}")
-    
-    try:
-        agent_id = fairies_client.get_agent_id()
-        
-        if not agent_id:
-            return jsonify({"error": {"message": "Failed to get agent ID", "type": "internal_server_error"}}), 500
-        
-        if stream:
-            def generate_stream():
-                loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(loop)
-                
-                try:
-                    async def stream_generator():
-                        async_gen = fairies_client.chat_stream(agent_id, user_message, model)
-                        try:
-                            async for chunk in async_gen:
-                                if "error" in chunk:
-                                    yield f"data: {json.dumps({'error': chunk['error']})}\n\n"
-                                    return
-                                elif "delta" in chunk:
-                                    delta_response = {
-                                        "id": f"chatcmpl-{str(uuid.uuid4())}",
-                                        "object": "chat.completion.chunk",
-                                        "created": int(time.time()),
-                                        "model": model,
-                                        "choices": [{
-                                            "index": 0,
-                                            "delta": {"content": chunk["delta"]},
-                                            "finish_reason": None
-                                        }]
-                                    }
-                                    yield f"data: {json.dumps(delta_response)}\n\n"
-                                elif chunk.get("done"):
-                                    final_response = {
-                                        "id": f"chatcmpl-{str(uuid.uuid4())}",
-                                        "object": "chat.completion.chunk",
-                                        "created": int(time.time()),
-                                        "model": model,
-                                        "choices": [{
-                                            "index": 0,
-                                            "delta": {},
-                                            "finish_reason": "stop"
-                                        }]
-                                    }
-                                    yield f"data: {json.dumps(final_response)}\n\n"
-                                    yield "data: [DONE]\n\n"
-                                    return
-                        except asyncio.CancelledError:
-                            print("⚠️ 流式传输被取消")
-                            raise
-                        except Exception as stream_error:
-                            print(f"⚠️ 流式传输出错: {stream_error}")
-                            yield f"data: {json.dumps({'error': str(stream_error)})}\n\n"
-                        finally:
-                            # 确保异步生成器正确关闭
-                            if hasattr(async_gen, 'aclose'):
-                                await async_gen.aclose()
-                    
-                    # 改进的流式处理
-                    async_gen = stream_generator()
-                    try:
-                        while True:
-                            try:
-                                chunk = loop.run_until_complete(async_gen.__anext__())
-                                yield chunk
-                            except StopAsyncIteration:
-                                break
-                    finally:
-                        # 确保生成器正确关闭
-                        try:
-                            loop.run_until_complete(async_gen.aclose())
-                        except Exception as gen_close_error:
-                            print(f"⚠️ 关闭流生成器时出错: {gen_close_error}")
-                            
-                finally:
-                    loop.close()
-            
-            return Response(generate_stream(), mimetype='text/plain; charset=utf-8')
-        else:
-            # 非流式响应
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-            
-            response_content = ""
-            async def collect_response():
-                nonlocal response_content
-                async_gen = fairies_client.chat_stream(agent_id, user_message, model)
-                try:
-                    async for chunk in async_gen:
-                        if "error" in chunk:
-                            return {"error": chunk["error"]}
-                        elif "delta" in chunk:
-                            response_content += chunk["delta"]
-                        elif chunk.get("done"):
-                            break
-                finally:
-                    # 确保异步生成器正确关闭
-                    if hasattr(async_gen, 'aclose'):
-                        await async_gen.aclose()
-                return {"response": response_content}
-            
-            result = loop.run_until_complete(collect_response())
-            loop.close()
-            
-            if "error" in result:
-                return jsonify({"error": {"message": result["error"], "type": "internal_server_error"}}), 500
-            
-            response = {
-                "id": f"chatcmpl-{str(uuid.uuid4())}",
-                "object": "chat.completion",
-                "created": int(time.time()),
-                "model": model,
-                "choices": [{
-                    "index": 0,
-                    "message": {
-                        "role": "assistant",
-                        "content": response_content
-                    },
-                    "finish_reason": "stop"
-                }],
-                "usage": {
-                    "prompt_tokens": len(user_message.split()),
-                    "completion_tokens": len(response_content.split()),
-                    "total_tokens": len(user_message.split()) + len(response_content.split())
-                }
-            }
-            
-            return jsonify(response)
-        
-    except Exception as e:
-        print(f"❌ 处理请求时出错: {e}")
-        return jsonify({"error": {"message": str(e), "type": "internal_server_error"}}), 500
-
-@app.route('/v1/tasks', methods=['GET'])
-def get_tasks():
-    """获取任务列表"""
-    is_valid, error_response, status_code = verify_api_key()
-    if not is_valid:
-        return error_response, status_code
-    
-    try:
-        tasks = fairies_client.list_tasks()
-        return jsonify({"tasks": tasks})
-    except Exception as e:
-        return jsonify({"error": {"message": str(e), "type": "internal_server_error"}}), 500
-
-@app.route('/v1/tasks/<task_id>/status', methods=['PUT'])
-def set_task_status(task_id):
-    """更新任务状态"""
-    is_valid, error_response, status_code = verify_api_key()
-    if not is_valid:
-        return error_response, status_code
-    
-    data = request.get_json()
-    if not data or 'status' not in data:
-        return jsonify({"error": {"message": "status field is required", "type": "invalid_request_error"}}), 400
-    
-    try:
-        success = fairies_client.update_task_status(task_id, data['status'])
-        if success:
-            return jsonify({"success": True, "message": f"Task {task_id} status updated"})
-        else:
-            return jsonify({"error": {"message": "Failed to update task status", "type": "internal_server_error"}}), 500
-    except Exception as e:
-        return jsonify({"error": {"message": str(e), "type": "internal_server_error"}}), 500
-
-@app.route('/v1/tasks/<task_id>', methods=['DELETE'])
-def remove_task(task_id):
-    """删除任务"""
-    is_valid, error_response, status_code = verify_api_key()
-    if not is_valid:
-        return error_response, status_code
-    
-    try:
-        success = fairies_client.delete_task(task_id)
-        if success:
-            return jsonify({"success": True, "message": f"Task {task_id} deleted"})
-        else:
-            return jsonify({"error": {"message": "Failed to delete task", "type": "internal_server_error"}}), 500
-    except Exception as e:
-        return jsonify({"error": {"message": str(e), "type": "internal_server_error"}}), 500
-
-@app.route('/v1/pool/status', methods=['GET'])
-def pool_status():
-    """获取连接池状态"""
-    is_valid, error_response, status_code = verify_api_key()
-    if not is_valid:
-        return error_response, status_code
-    
-    # 移除WebSocket连接池的清理逻辑
-    pool_info = {
-        "active_connections": 0,
-        "last_cleanup": 0,
-        "cleanup_interval": 0,
-        "next_cleanup_in": 0,
-        "connections": []
-    }
-    
-    return jsonify(pool_info)
-
-@app.route('/v1/pool/cleanup', methods=['POST'])
-def manual_cleanup():
-    """手动清理连接池"""
-    is_valid, error_response, status_code = verify_api_key()
-    if not is_valid:
-        return error_response, status_code
-    
-    try:
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        # 移除WebSocket连接池的清理逻��
-        loop.close()
-        return jsonify({"success": True, "message": "Connection pool cleanup completed"})
-    except Exception as e:
-        return jsonify({"error": {"message": str(e), "type": "internal_server_error"}}), 500
-
-@app.route('/health', methods=['GET'])
-def health_check():
-    """健康检查"""
-    try:
-        # 检查连接池状态
-        # 移除WebSocket连接池的清理逻辑
-        pool_size = 0
-        
-        # 检查Cookie配置
-        cookie_status = "✅ 已设置" if FAIRIES_COOKIE_STRING else "❌ 未设置"
-        
-        health_info = {
-            "status": "healthy",
-            "service": "Fairies AI OpenAI-Compatible Proxy",
-            "version": "2.0",
-            "websocket_pool_size": pool_size,
-            "cookie_status": cookie_status,
-            "timestamp": datetime.now().isoformat()
-        }
-        return jsonify(health_info)
-    except Exception as e:
-        return jsonify({
-            "status": "unhealthy",
-            "error": str(e),
-            "timestamp": datetime.now().isoformat()
-        }), 500
-
-@app.route('/', methods=['GET'])
-def api_info():
-    return jsonify({
-        "service": "Fairies AI OpenAI-Compatible Proxy v2.0",
-        "base_url": f"http://localhost:{PORT}",
-        "endpoints": [
-            "/v1/chat/completions", 
-            "/v1/models", 
-            "/v1/tasks",
-            "/health"
-        ],
-        "features": [
-            "OpenAI兼容的聊天接口",
-            "智能WebSocket连接池管理",
-            "流式响应支持",
-            "预配置Agent ID",
-            "完善的错误处理机制"
-        ]
-    })
-
-def cleanup_on_exit():
-    """程序退出时的清理函数"""
-    print("\n🔧 正在清理资源...")
-    try:
-        # 移除WebSocket连接池的清理逻辑
-        print("✅ 资源清理完成 (无WebSocket连接池需要清理)")
-    except Exception as e:
-        print(f"⚠️ 清理资源时出错: {e}")
-
-def signal_handler(signum, frame):
-    """信号处理函数"""
-    print(f"\n📡 收到信号 {signum}，正在关闭服务...")
-    cleanup_on_exit()
-    import sys
-    sys.exit(0)
-
-if __name__ == '__main__':
-    # 注册清理函数和信号处理
-    import atexit
-    atexit.register(cleanup_on_exit)
-    signal.signal(signal.SIGINT, signal_handler)
-    signal.signal(signal.SIGTERM, signal_handler)
-    
-    print("🚀 Fairies AI OpenAI-Compatible Proxy v2.0 启动中...")
-    print(f"📋 服务地址: http://localhost:{PORT}")
-    print(f"🔑 API密钥: {LOCAL_API_KEY}")
-    print(f"📦 支持模型: {len(AVAILABLE_MODELS)} 个")
-    print()
-    
-    # 验证连接配置
-    print("🔍 验证连接配置...")
-    if not fairies_client.validate_connection():
-        print("⚠️ 配置验证失败，服务可能无法正常工作")
-        print("💡 请设置正确的环境变量后重启服务")
-    print()
-    
-    print("🔧 测试命令:")
-    print(f"curl -X POST http://localhost:{PORT}/v1/chat/completions \\")
-    print(f"  -H 'Authorization: Bearer {LOCAL_API_KEY}' \\")
-    print("  -H 'Content-Type: application/json' \\")
-    print("  -d '{\"messages\": [{\"role\": \"user\", \"content\": \"你好\"}]}'")
-    print()
-    print("📋 任务管理:")
-    print(f"curl -X GET http://localhost:{PORT}/v1/tasks \\")
-    print(f"  -H 'Authorization: Bearer {LOCAL_API_KEY}'")
-    print()
-    print("🏥 健康检查:")
-    print(f"curl -X GET http://localhost:{PORT}/health")
-    print()
-    
-    try:
-        print("🚀 使用Waitress服务器启动...")
-        serve(app, host='0.0.0.0', port=PORT)
-    except ImportError:
-        # 如果没有安装waitress，回退到Flask开发服务器
-        print("⚠️ 未找到Waitress，使用Flask开发服务器启动...")
-        app.run(host='0.0.0.0', port=PORT, debug=False)
-    except KeyboardInterrupt:
-        print("\n👋 服务被用户中断")
-    except Exception as e:
-        print(f"\n❌ 服务运行出错: {e}")
-    finally:
-        cleanup_on_exit()