Update app.py

app.py

@@ -1,4 +1,11 @@
-import json
+# 启动事件
+@app.on_event("startup")
+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:7860import json
 import time
 import asyncio
 import uvicorn
@@ -30,6 +37,10 @@ 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,
@@ -40,7 +51,7 @@ app.add_middleware(
 )
 
 # 配置
-DEEPSIDER_API_BASE = "https://api.chargpt.ai/api/v2"
+DEEPSIDER_API_BASE = "https://api.chargpt.ai/api/v1"
 TOKEN_INDEX = 0
 
 # 模型映射表
@@ -56,7 +67,6 @@ MODEL_MAPPING = {
     "claude-3.7-sonnet": "anthropic/claude-3.7-sonnet",
 }
 
-# 请求头
 def get_headers(api_key):
     global TOKEN_INDEX
     # 检查是否包含多个token（用逗号分隔）
@@ -70,21 +80,11 @@ def get_headers(api_key):
         current_token = api_key
     
     return {
-        "accept": "*/*",
-        "accept-encoding": "gzip, deflate, br, zstd",
-        "accept-language": "en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7",
+        "accept": "application/json",
         "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()}"
+        "authorization": f"Bearer {current_token.strip()}",
+        "i-version": "1.1.64"
     }
 
 # OpenAI API请求模型
@@ -169,26 +169,15 @@ def map_openai_to_deepsider_model(model: str) -> str:
 
 def format_messages_for_deepsider(messages: List[ChatMessage]) -> str:
     """格式化消息列表为DeepSider API所需的提示格式"""
-    prompt = ""
+    # 直接合并所有消息内容，无需特殊格式化
+    combined_prompt = ""
     for msg in messages:
-        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"
+        if msg.role == "system":
+            combined_prompt = msg.content + "\n\n" + combined_prompt
         else:
-            # 其他角色按用户处理
-            prompt += f"Human ({role}): {msg.content}\n\n"
-    
-    # 如果最后一个消息不是用户的 添加一个Human前缀引导模型回答
-    if messages and messages[-1].role != "user":
-        prompt += "Human: "
+            combined_prompt += msg.content + "\n\n"
     
-    return prompt.strip()
+    return combined_prompt.strip()
 
 async def generate_openai_response(full_response: str, request_id: str, model: str) -> Dict:
     """生成符合OpenAI API响应格式的完整响应"""
@@ -218,72 +207,16 @@ 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:
-        # 将DeepSider响应流转换为OpenAI流格式
-        for line in response.iter_lines():
-            if not line:
-                continue
+        # 直接传递原始响应
+        for chunk in response.iter_lines():
+            if chunk:
+                yield chunk.decode('utf-8') + "\n"
                 
-            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}",
@@ -306,7 +239,16 @@ async def stream_openai_response(response, request_id: str, model: str, api_key,
 # 路由定义
 @app.get("/")
 async def root():
-    return {"message": "OpenAI API Proxy服务已启动 连接至DeepSider API"}
+    """返回简单的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实现轮询"
+    }
 
 @app.get("/v1/models")
 async def list_models(api_key: str = Depends(verify_api_key)):
@@ -348,8 +290,7 @@ async def create_chat_completion(
     payload = {
         "model": deepsider_model,
         "prompt": prompt,
-        "webAccess": "close",  # 默认关闭网络访问
-        "timezone": "Asia/Shanghai"
+        "stream": chat_request.stream
     }
     
     # 获取请求头（包含选择的token）
@@ -359,12 +300,17 @@ 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/conversation",
+            f"{DEEPSIDER_API_BASE}/chat/completions",
             headers=headers,
             json=payload,
-            stream=True
+            stream=chat_request.stream,
+            timeout=60  # 设置60秒超时
         )
         
         # 检查响应状态
@@ -374,10 +320,19 @@ async def create_chat_completion(
                 error_data = response.json()
                 error_msg += f" - {error_data.get('message', '')}"
             except:
-                error_msg += f" - {response.text}"
+                try:
+                    error_msg += f" - {response.text[:200]}"
+                except:
+                    pass
                 
             logger.error(error_msg)
-            raise HTTPException(status_code=response.status_code, detail="API请求失败")
+            return {
+                "error": {
+                    "message": error_msg,
+                    "type": "api_error",
+                    "code": response.status_code
+                }
+            }
         
         # 处理流式或非流式响应
         if chat_request.stream:
@@ -387,26 +342,22 @@ async def create_chat_completion(
                 media_type="text/event-stream"
             )
         else:
-            # 收集完整响应
-            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)
+            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"
+                    }
+                }
             
     except HTTPException:
         raise
@@ -459,7 +410,17 @@ async def not_found_handler(request, exc):
             "type": "not_found_error",
             "code": "not_found"
         }
-    }, 404
+    }
+
+@app.exception_handler(500)
+async def server_error_handler(request, exc):
+    return {
+        "error": {
+            "message": f"服务器内部错误: {str(exc)}",
+            "type": "server_error",
+            "code": "internal_server_error"
+        }
+    }
 
 # 启动事件
 @app.on_event("startup")
@@ -467,6 +428,9 @@ 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__":