Update app.py

app.py

@@ -30,10 +30,6 @@ app = FastAPI(
     version="1.0.0"
 )
 
-# 增加日志输出级别
-if os.getenv("DEBUG", "false").lower() == "true":
-    logging.getLogger("openai-proxy").setLevel(logging.DEBUG)
-
 # 添加CORS中间件
 app.add_middleware(
     CORSMiddleware,
@@ -44,7 +40,7 @@ app.add_middleware(
 )
 
 # 配置
-DEEPSIDER_API_BASE = "https://api.chargpt.ai/api/v1"
+DEEPSIDER_API_BASE = "https://api.chargpt.ai/api/v2"
 TOKEN_INDEX = 0
 
 # 模型映射表
@@ -60,6 +56,7 @@ MODEL_MAPPING = {
     "claude-3.7-sonnet": "anthropic/claude-3.7-sonnet",
 }
 
+# 请求头
 def get_headers(api_key):
     global TOKEN_INDEX
     # 检查是否包含多个token（用逗号分隔）
@@ -73,11 +70,21 @@ def get_headers(api_key):
         current_token = api_key
     
     return {
-        "accept": "application/json",
+        "accept": "*/*",
+        "accept-encoding": "gzip, deflate, br, zstd",
+        "accept-language": "en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7",
         "content-type": "application/json",
+        "origin": "chrome-extension://client",
+        "i-lang": "zh-CN",
+        "i-version": "1.1.64",
+        "sec-ch-ua": '"Chromium";v="134", "Not:A-Brand";v="24"',
+        "sec-ch-ua-mobile": "?0",
+        "sec-ch-ua-platform": "Windows",
+        "sec-fetch-dest": "empty",
+        "sec-fetch-mode": "cors",
+        "sec-fetch-site": "cross-site",
         "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36",
-        "authorization": f"Bearer {current_token.strip()}",
-        "i-version": "1.1.64"
+        "authorization": f"Bearer {current_token.strip()}"
     }
 
 # OpenAI API请求模型
@@ -120,7 +127,7 @@ async def check_account_balance(api_key, token_index=None):
     try:
         # 获取账户余额信息
         response = requests.get(
-            f"{DEEPSIDER_API_BASE.replace('/v1', '')}/quota/retrieve",
+            f"{DEEPSIDER_API_BASE.replace('/v2', '')}/quota/retrieve",
             headers=headers
         )
         
@@ -162,15 +169,26 @@ def map_openai_to_deepsider_model(model: str) -> str:
 
 def format_messages_for_deepsider(messages: List[ChatMessage]) -> str:
     """格式化消息列表为DeepSider API所需的提示格式"""
-    # 直接合并所有消息内容，无需特殊格式化
-    combined_prompt = ""
+    prompt = ""
     for msg in messages:
-        if msg.role == "system":
-            combined_prompt = msg.content + "\n\n" + combined_prompt
+        role = msg.role
+        # 将OpenAI的角色映射到DeepSider能理解的格式
+        if role == "system":
+            # 系统消息放在开头 作为指导
+            prompt = f"{msg.content}\n\n" + prompt
+        elif role == "user":
+            prompt += f"Human: {msg.content}\n\n"
+        elif role == "assistant":
+            prompt += f"Assistant: {msg.content}\n\n"
         else:
-            combined_prompt += msg.content + "\n\n"
+            # 其他角色按用户处理
+            prompt += f"Human ({role}): {msg.content}\n\n"
     
-    return combined_prompt.strip()
+    # 如果最后一个消息不是用户的 添加一个Human前缀引导模型回答
+    if messages and messages[-1].role != "user":
+        prompt += "Human: "
+    
+    return prompt.strip()
 
 async def generate_openai_response(full_response: str, request_id: str, model: str) -> Dict:
     """生成符合OpenAI API响应格式的完整响应"""
@@ -200,16 +218,72 @@ async def generate_openai_response(full_response: str, request_id: str, model: s
 async def stream_openai_response(response, request_id: str, model: str, api_key, token_index):
     """流式返回OpenAI API格式的响应"""
     timestamp = int(time.time())
+    full_response = ""
     
     try:
-        # 直接传递原始响应
-        for chunk in response.iter_lines():
-            if chunk:
-                yield chunk.decode('utf-8') + "\n"
+        # 将DeepSider响应流转换为OpenAI流格式
+        for line in response.iter_lines():
+            if not line:
+                continue
                 
+            if line.startswith(b'data: '):
+                try:
+                    data = json.loads(line[6:].decode('utf-8'))
+                    
+                    if data.get('code') == 202 and data.get('data', {}).get('type') == "chat":
+                        # 获取正文内容
+                        content = data.get('data', {}).get('content', '')
+                        if content:
+                            full_response += content
+                            
+                            # 生成OpenAI格式的流式响应
+                            chunk = {
+                                "id": f"chatcmpl-{request_id}",
+                                "object": "chat.completion.chunk",
+                                "created": timestamp,
+                                "model": model,
+                                "choices": [
+                                    {
+                                        "index": 0,
+                                        "delta": {
+                                            "content": content
+                                        },
+                                        "finish_reason": None
+                                    }
+                                ]
+                            }
+                            yield f"data: {json.dumps(chunk)}\n\n"
+                    
+                    elif data.get('code') == 203:
+                        # 生成完成信号
+                        chunk = {
+                            "id": f"chatcmpl-{request_id}",
+                            "object": "chat.completion.chunk",
+                            "created": timestamp,
+                            "model": model,
+                            "choices": [
+                                {
+                                    "index": 0,
+                                    "delta": {},
+                                    "finish_reason": "stop"
+                                }
+                            ]
+                        }
+                        yield f"data: {json.dumps(chunk)}\n\n"
+                        yield "data: [DONE]\n\n"
+                        
+                except json.JSONDecodeError:
+                    logger.warning(f"无法解析响应: {line}")
+                    
     except Exception as e:
         logger.error(f"流式响应处理出错: {str(e)}")
         
+        # 尝试使用下一个Token
+        tokens = api_key.split(',')
+        if len(tokens) > 1:
+            logger.info(f"尝试使用下一个Token重试请求")
+            # 目前我们不在这里实现自动重试，只记录错误
+        
         # 返回错误信息
         error_chunk = {
             "id": f"chatcmpl-{request_id}",
@@ -232,16 +306,7 @@ async def stream_openai_response(response, request_id: str, model: str, api_key,
 # 路由定义
 @app.get("/")
 async def root():
-    """返回简单的HTML页面，展示使用说明"""
-    return {
-        "message": "OpenAI API Proxy服务已启动 连接至DeepSider API",
-        "usage": {
-            "模型列表": "GET /v1/models",
-            "聊天完成": "POST /v1/chat/completions",
-            "账户余额": "GET /admin/balance (需要X-Admin-Key头)"
-        },
-        "说明": "请在Authorization头中使用Bearer token格式，支持使用英文逗号分隔多个token实现轮询"
-    }
+    return {"message": "OpenAI API Proxy服务已启动 连接至DeepSider API"}
 
 @app.get("/v1/models")
 async def list_models(api_key: str = Depends(verify_api_key)):
@@ -283,7 +348,8 @@ async def create_chat_completion(
     payload = {
         "model": deepsider_model,
         "prompt": prompt,
-        "stream": chat_request.stream
+        "webAccess": "close",  # 默认关闭网络访问
+        "timezone": "Asia/Shanghai"
     }
     
     # 获取请求头（包含选择的token）
@@ -293,17 +359,12 @@ async def create_chat_completion(
     current_token_index = (TOKEN_INDEX - 1) % len(tokens) if len(tokens) > 0 else 0
     
     try:
-        # 记录请求信息
-        logger.info(f"发送请求到DeepSider API - 模型: {deepsider_model}, Prompt长度: {len(prompt)}")
-        logger.debug(f"请求正文: {json.dumps(payload)}")
-        
         # 发送请求到DeepSider API
         response = requests.post(
-            f"{DEEPSIDER_API_BASE}/chat/completions",
+            f"{DEEPSIDER_API_BASE}/chat/conversation",
             headers=headers,
             json=payload,
-            stream=chat_request.stream,
-            timeout=60  # 设置60秒超时
+            stream=True
         )
         
         # 检查响应状态
@@ -313,19 +374,10 @@ async def create_chat_completion(
                 error_data = response.json()
                 error_msg += f" - {error_data.get('message', '')}"
             except:
-                try:
-                    error_msg += f" - {response.text[:200]}"
-                except:
-                    pass
+                error_msg += f" - {response.text}"
                 
             logger.error(error_msg)
-            return {
-                "error": {
-                    "message": error_msg,
-                    "type": "api_error",
-                    "code": response.status_code
-                }
-            }
+            raise HTTPException(status_code=response.status_code, detail="API请求失败")
         
         # 处理流式或非流式响应
         if chat_request.stream:
@@ -335,22 +387,26 @@ async def create_chat_completion(
                 media_type="text/event-stream"
             )
         else:
-            try:
-                # 非流式请求，直接返回响应
-                json_response = response.json()
-                # 记录响应，有助于调试
-                logger.debug(f"非流式响应: {json.dumps(json_response)}")
-                return json_response
-                
-            except Exception as e:
-                logger.exception(f"非流式响应处理出错: {str(e)}")
-                return {
-                    "error": {
-                        "message": f"处理响应时出错: {str(e)}",
-                        "type": "processing_error",
-                        "code": "internal_error"
-                    }
-                }
+            # 收集完整响应
+            full_response = ""
+            for line in response.iter_lines():
+                if not line:
+                    continue
+                    
+                if line.startswith(b'data: '):
+                    try:
+                        data = json.loads(line[6:].decode('utf-8'))
+                        
+                        if data.get('code') == 202 and data.get('data', {}).get('type') == "chat":
+                            content = data.get('data', {}).get('content', '')
+                            if content:
+                                full_response += content
+                                
+                    except json.JSONDecodeError:
+                        pass
+            
+            # 返回OpenAI格式的完整响应
+            return await generate_openai_response(full_response, request_id, chat_request.model)
             
     except HTTPException:
         raise
@@ -394,13 +450,6 @@ async def get_account_balance(request: Request, admin_key: str = Header(None, al
     
     return result
 
-# 模拟模型的路由
-@app.get("/v1/engines")
-@app.get("/v1/engines/{engine_id}")
-async def engines_handler():
-    """兼容旧的引擎API"""
-    raise HTTPException(status_code=404, detail="引擎API已被弃用 请使用模型API")
-
 # 错误处理器
 @app.exception_handler(404)
 async def not_found_handler(request, exc):
@@ -410,17 +459,7 @@ async def not_found_handler(request, exc):
             "type": "not_found_error",
             "code": "not_found"
         }
-    }
-
-@app.exception_handler(500)
-async def server_error_handler(request, exc):
-    return {
-        "error": {
-            "message": f"服务器内部错误: {str(exc)}",
-            "type": "server_error",
-            "code": "internal_server_error"
-        }
-    }
+    }, 404
 
 # 启动事件
 @app.on_event("startup")
@@ -428,9 +467,6 @@ async def startup_event():
     """服务启动时初始化"""
     logger.info(f"OpenAI API代理服务已启动，可以接受请求")
     logger.info(f"支持多token轮询，请在Authorization头中使用英文逗号分隔多个token")
-    logger.info(f"服务地址: http://127.0.0.1:7860")
-    logger.info(f"OpenAI API格式请求示例: POST http://127.0.0.1:7860/v1/chat/completions")
-    logger.info(f"可用模型查询: GET http://127.0.0.1:7860/v1/models")
 
 # 主程序
 if __name__ == "__main__":