Update app.py

app.py

@@ -1,4 +1,3 @@
-# Generated from trimmed zed.proto
 from google.protobuf import descriptor as _descriptor
 from google.protobuf import descriptor_pool as _descriptor_pool
 from google.protobuf import runtime_version as _runtime_version
@@ -22,77 +21,126 @@ _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
 _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'zed_pb2', _globals)
 if not _descriptor._USE_C_DESCRIPTORS:
-  DESCRIPTOR._loaded_options = None
-  _globals['_ERRORCODE']._serialized_start=1085
-  _globals['_ERRORCODE']._serialized_end=1452
-  _globals['_PEERID']._serialized_start=27
-  _globals['_PEERID']._serialized_end=65
-  _globals['_ENVELOPE']._serialized_start=68
-  _globals['_ENVELOPE']._serialized_end=806
-  _globals['_HELLO']._serialized_start=808
-  _globals['_HELLO']._serialized_end=854
-  _globals['_PING']._serialized_start=856
-  _globals['_PING']._serialized_end=862
-  _globals['_ACK']._serialized_start=864
-  _globals['_ACK']._serialized_end=869
-  _globals['_ERROR']._serialized_start=871
-  _globals['_ERROR']._serialized_end=948
-  _globals['_ACCEPTTERMSOFSERVICE']._serialized_start=950
-  _globals['_ACCEPTTERMSOFSERVICE']._serialized_end=972
-  _globals['_ACCEPTTERMSOFSERVICERESPONSE']._serialized_start=974
-  _globals['_ACCEPTTERMSOFSERVICERESPONSE']._serialized_end=1029
-  _globals['_GETLLMTOKEN']._serialized_start=1031
-  _globals['_GETLLMTOKEN']._serialized_end=1044
-  _globals['_GETLLMTOKENRESPONSE']._serialized_start=1046
-  _globals['_GETLLMTOKENRESPONSE']._serialized_end=1082
-
-# Start of the actual script
+    DESCRIPTOR._loaded_options = None
+    _globals['_ERRORCODE']._serialized_start=1085
+    _globals['_ERRORCODE']._serialized_end=1452
+    _globals['_PEERID']._serialized_start=27
+    _globals['_PEERID']._serialized_end=65
+    _globals['_ENVELOPE']._serialized_start=68
+    _globals['_ENVELOPE']._serialized_end=806
+    _globals['_HELLO']._serialized_start=808
+    _globals['_HELLO']._serialized_end=854
+    _globals['_PING']._serialized_start=856
+    _globals['_PING']._serialized_end=862
+    _globals['_ACK']._serialized_start=864
+    _globals['_ACK']._serialized_end=869
+    _globals['_ERROR']._serialized_start=871
+    _globals['_ERROR']._serialized_end=948
+    _globals['_ACCEPTTERMSOFSERVICE']._serialized_start=950
+    _globals['_ACCEPTTERMSOFSERVICE']._serialized_end=972
+    _globals['_ACCEPTTERMSOFSERVICERESPONSE']._serialized_start=974
+    _globals['_ACCEPTTERMSOFSERVICERESPONSE']._serialized_end=1029
+    _globals['_GETLLMTOKEN']._serialized_start=1031
+    _globals['_GETLLMTOKEN']._serialized_end=1044
+    _globals['_GETLLMTOKENRESPONSE']._serialized_start=1046
+    _globals['_GETLLMTOKENRESPONSE']._serialized_end=1082
+
+
 import os
 import json
 import ssl
 import time
 import asyncio
-import logging
 import aiohttp
+import sys
+import inspect
+from loguru import logger
+from flask import Flask, request, jsonify, Response, stream_with_context
+from flask_cors import CORS
+from dotenv import load_dotenv
 from aiohttp import web
 import zstandard as zstd
 from websockets.asyncio.client import connect
 from websockets.exceptions import ConnectionClosed
-import uuid
 
 from google.protobuf.json_format import MessageToDict
 
+# 修复
 Envelope = _sym_db.GetSymbol('zed.messages.Envelope')
 
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(levelname)s: %(message)s'
-)
-logger = logging.getLogger(__name__)
+class Logger:
+    def __init__(self, level="INFO", colorize=True, format=None):
+        logger.remove()
 
+        if format is None:
+            format = (
+                "<green>{time:YYYY-MM-DD HH:mm:ss}</green> | "
+                "<level>{level: <8}</level> | "
+                "<cyan>{extra[filename]}</cyan>:<cyan>{extra[function]}</cyan>:<cyan>{extra[lineno]}</cyan> | "
+                "<level>{message}</level>"
+            )
 
+        logger.add(
+            sys.stderr, 
+            level=level, 
+            format=format,
+            colorize=colorize,
+            backtrace=True,
+            diagnose=True
+        )
 
-CONFIG = {
-    "API":{
-        "BASE_URL": "https://zed.dev",
-        "API_KEY": os.getenv("API_KEY","sk-123456"),
-        "BASE_API_URL": "https://collab.zed.dev",
-        "WS_URL": "wss://collab.zed.dev/rpc",
-        "LLM_API_URL": "https://llm.zed.dev/completion",
-    },
-    "LOGIN":{
-        "USER_ID": os.getenv("ZED_USER_ID"),
-        "AUTH": os.getenv("ZED_AUTH_TOKEN")
-    },
-    "SERVER":{
-        "PORT": os.getenv("PORT",5200),
-        "TOKEN_EXPIRY_WARNING_MINUTES": 50  
-    },
-    "MODELS":{
-        "claude-3-5-sonnet-20241022":"claude-3-5-sonnet-latest",
-        "claude-3-7-sonnet-20250219":"claude-3-7-sonnet-20250219"
-    }
-}
+        self.logger = logger
+
+    def _get_caller_info(self):
+        frame = inspect.currentframe()
+        try:
+            caller_frame = frame.f_back.f_back
+            full_path = caller_frame.f_code.co_filename
+            function = caller_frame.f_code.co_name
+            lineno = caller_frame.f_lineno
+            
+            filename = os.path.basename(full_path)
+            
+            return {
+                'filename': filename,
+                'function': function,
+                'lineno': lineno
+            }
+        finally:
+            del frame 
+
+    def info(self, message, source="API"):
+        caller_info = self._get_caller_info()
+        self.logger.bind(**caller_info).info(f"[{source}] {message}")
+        
+    def error(self, message, source="API"):
+        caller_info = self._get_caller_info()
+        
+        if isinstance(message, Exception):
+            self.logger.bind(**caller_info).exception(f"[{source}] {str(message)}")
+        else:
+            self.logger.bind(**caller_info).error(f"[{source}] {message}")
+    
+    def warning(self, message, source="API"):
+        caller_info = self._get_caller_info()
+        self.logger.bind(**caller_info).warning(f"[{source}] {message}")
+    
+    def debug(self, message, source="API"):
+        caller_info = self._get_caller_info()
+        self.logger.bind(**caller_info).debug(f"[{source}] {message}")
+
+    async def request_logger(self, request):
+        caller_info = self._get_caller_info()
+        self.logger.bind(**caller_info).info(f"请求: {request.method} {request.path}", "Request")
+
+logger = Logger(level="INFO")
+
+BASE_URL = "https://zed.dev"
+BASE_API_URL = "https://collab.zed.dev"
+WS_URL = "wss://collab.zed.dev/rpc"
+LLM_API_URL = "https://llm.zed.dev/completion"
+DEFAULT_PROXY_PORT = 5200  # 默认端口，可通过环境变量覆盖
+TOKEN_EXPIRY_WARNING_MINUTES = 50
 
 highest_message_id = 0
 llm_token = None
@@ -101,40 +149,47 @@ server_peer_id = None
 active_websocket = None
 proxy_server_running = False
 
-class MessageProcessor:
-    @staticmethod
-    def create_chat_response(message, model, is_stream=False):
-        base_response = {
-            "id": f"chatcmpl-{uuid.uuid4()}",
-            "created": int(time.time()),
-            "model": model
-        }
-
-        if is_stream:
-            return {
-                **base_response,
-                "object": "chat.completion.chunk",
-                "choices": [{
-                    "index": 0,
-                    "delta": {
-                        "content": message
-                    }
-                }]
-            }
-
-        return {
-            **base_response,
-            "object": "chat.completion",
-            "choices": [{
-                "index": 0,
-                "message": {
-                    "role": "assistant",
-                    "content": message
-                },
-                "finish_reason": "stop"
-            }],
-            "usage": None
-        }
+# 从环境变量读取API密码和自定义端口
+PROXY_PASSWORD = os.environ.get("ZED_PROXY_PASSWORD")
+PROXY_PORT = int(os.environ.get("ZED_PROXY_PORT", DEFAULT_PROXY_PORT))
+
+# 支持的模型列表
+AVAILABLE_MODELS = [
+    {
+        "id": "claude-3-5-sonnet-20240620",
+        "object": "model",
+        "created": 1719158400,
+        "owned_by": "anthropic",
+        "permission": [],
+    },
+    {
+        "id": "claude-3-5-sonnet-20241022",
+        "object": "model",
+        "created": 1729344000,
+        "owned_by": "anthropic",
+        "permission": [],
+    },
+    {
+        "id": "claude-3-7-sonnet-20250219",
+        "object": "model",
+        "created": 1740153600,
+        "owned_by": "anthropic",
+        "permission": [],
+    }
+]
+
+# 模型映射表（从其他可能的模型名称映射到我们支持的模型）
+MODEL_MAPPING = {
+    # 默认映射到最新版本
+    "claude-3-5-sonnet": "claude-3-5-sonnet-20241022",
+    "claude-3.5-sonnet": "claude-3-5-sonnet-20241022",
+    "claude-3-7-sonnet": "claude-3-7-sonnet-20250219",
+    "claude-3.7-sonnet": "claude-3-7-sonnet-20250219",
+    # 确保标准名称也能映射到自身
+    "claude-3-5-sonnet-20240620": "claude-3-5-sonnet-20240620",
+    "claude-3-5-sonnet-20241022": "claude-3-5-sonnet-20241022",
+    "claude-3-7-sonnet-20250219": "claude-3-7-sonnet-20250219",
+}
 
 def decode_envelope(data):
     try:
@@ -151,11 +206,11 @@ def decode_envelope(data):
         return MessageToDict(envelope, preserving_proto_field_name=True)
     except Exception as e:
         hex_preview = ' '.join(f'{byte:02x}' for byte in data[:20]) + ('...' if len(data) > 20 else '')
-        logger.error(f"无法解码消息： {e}; 数据预览： {hex_preview}")
-        return {"error": f"无法解码消息： {e}"}
+        logger.error(f"Unable to decode message: {e}; data preview: {hex_preview}")
+        return {"error": f"Unable to decode message: {e}"}
 
 def compress_protobuf(data):
-    return zstd.ZstdCompressor(level=-7).compress(data)
+    return zstd.ZstdCompressor(level=7).compress(data)
 
 def create_message(message_type):
     global highest_message_id
@@ -172,7 +227,7 @@ async def ping_periodically(websocket):
             await websocket.ping()
             await asyncio.sleep(1)
         except Exception as e:
-            logger.error(f"发送ping错误: {e}")
+            logger.error(f"Error sending ping: {e}")
             break
 
 async def handle_messages(websocket):
@@ -180,36 +235,36 @@ async def handle_messages(websocket):
     active_websocket = websocket
     try:
         async for message in websocket:
-            message_bytes = message.encode('utf-8') if isinstance(message, str) else message
+            message_bytes = message.encode('utf8') if isinstance(message, str) else message
             decoded = decode_envelope(message_bytes)
             if "hello" in decoded:
                 server_peer_id = decoded.get('hello', {}).get('peer_id')
             elif "accept_terms_of_service_response" in decoded:
                 await request_llm_token(websocket)
-            elif ("get_llm_token_response" in decoded and 
+            elif ("get_llm_token_response" in decoded and
                   'token' in decoded.get('get_llm_token_response', {})):
                 llm_token = decoded['get_llm_token_response']['token']
                 token_timestamp = time.time()
-                logger.info(f"LLM令牌收到  {time.ctime(token_timestamp)}")
+                logger.info(f"LLM token received at {time.ctime(token_timestamp)}")
                 if not proxy_server_running:
                     asyncio.create_task(start_proxy_server())
                 asyncio.create_task(monitor_token_expiration())
-                logger.info("关闭WebSocket连接，直到需要刷新令牌")
+                logger.info("Closing WebSocket connection until token refresh is needed")
                 await websocket.close()
                 active_websocket = None
                 return
     except ConnectionClosed:
-        logger.info("连接已关闭")
+        logger.info("Connection closed")
         active_websocket = None
 
 async def request_llm_token(websocket):
     message, _ = create_message('get_llm_token')
-    logger.info("请求LLM令牌")
+    logger.info("Requesting the LLM token")
     await websocket.send(message)
 
 async def request_accept_terms_of_service(websocket):
     message, _ = create_message('accept_terms_of_service')
-    logger.info("发送同意Zed服务条款")
+    logger.info("Sending consent for the Zed Terms of Service")
     await websocket.send(message)
 
 def format_content(content):
@@ -217,168 +272,129 @@ def format_content(content):
         return [{"type": "text", "text": content}]
     return content
 
-
-
-async def process_message_content(content):
-  """
-  处理消息内容，将不同类型的内容转换为字符串
-  """
-  if isinstance(content, str):
-      return content
-  
-  if isinstance(content, list):
-      return '\n'.join([item.get('text', '') for item in content])
-  
-  if isinstance(content, dict):
-      return content.get('text', None)
-  
-  return None
-
-async def transform_messages(request):
-  """
-  转换消息格式，合并系统消息并处理消息结构
-  """
-  system_message = ''  # 存储系统消息的变量
-  is_collecting_system_message = False  # 是否正在收集系统消息
-  has_processed_system_messages = False  # 是否已处理初始系统消息
-
-  converted_messages = []
-
-  for current in request.get('messages', []):
-      role = current.get('role')
-      current_content = await process_message_content(current.get('content'))
-
-      if current_content is None:
-          converted_messages.append(current)
-          continue
-
-      if role == 'system' and not has_processed_system_messages:
-          if not is_collecting_system_message:
-              # 第一次遇到system，开启收集
-              system_message = current_content
-              is_collecting_system_message = True
-          else:
-              # 继续遇到system，合并system消息
-              system_message += '\n' + current_content
-          continue
-
-      # 遇到非system消息
-      if is_collecting_system_message:
-          # 结束系统消息收集
-          is_collecting_system_message = False
-          has_processed_system_messages = True
-
-      # 如果已处理初始消息序列且再次遇到system，则转换role为user
-      if has_processed_system_messages and role == 'system':
-          role = 'user'
-
-      # 检查是否可以合并消息
-      if converted_messages and converted_messages[-1].get('role') == role:
-          converted_messages[-1]['content'][0]['text'] += '\r\n' + current_content
-      else:
-          converted_messages.append({
-              'role': role,
-              'content': [{'type': 'text', 'text': current_content}]
-          })
-
-  return {
-      'messages': converted_messages,
-      'system': system_message,
-      'model': CONFIG['MODELS'].get(request.get('model'), "claude-3-5-sonnet-latest"),
-      'max_tokens': request.get('max_tokens',8192),
-      'temperature': max(0, min(request.get('temperature', 0), 1)),
-      'top_p': max(0, min(request.get('top_p', 1), 1)),
-      'top_k': max(0, min(request.get('top_k', 0), 500)),
-      'stream': True
-  }
-
+# 密码验证中间件
 @web.middleware
 async def auth_middleware(request, handler):
-    if CONFIG['API']['API_KEY']:
+    if PROXY_PASSWORD:
+        # 检查各种可能的密码验证方式
         auth_header = request.headers.get('Authorization')
-        xapi_key_header = request.headers.get('x-api-key')
+        password_header = request.headers.get('XPassword') or request.headers.get('Password')
 
+        # 从Authorization头获取密码（如果是Bearer格式）
         auth_password = None
         if auth_header and auth_header.startswith('Bearer '):
             auth_password = auth_header[7:]
 
-        if auth_password == CONFIG['API']['API_KEY'] or xapi_key_header == CONFIG['API']['API_KEY']:
+        # 检查任何来源的密码是否匹配
+        if auth_password == PROXY_PASSWORD or password_header == PROXY_PASSWORD:
             return await handler(request)
         else:
             return web.json_response(
-                {"error": "Unauthorized"},
+                {"error": "Unauthorized. Provide valid password in Authorization or XPassword header"},
                 status=401
             )
-
+    # 如果未设置密码，直接通过验证
     return await handler(request)
 
+def get_mapped_model(model_name):
+    """将各种模型名称映射到支持的模型"""
+    if not model_name:
+        return "claude-3-5-sonnet-20241022"  # 默认模型
+
+    # 如果模型名称在映射表中，返回映射的值
+    return MODEL_MAPPING.get(model_name, "claude-3-5-sonnet-20241022")
+
+def convert_openai_to_anthropic(data):
+    """将OpenAI API请求格式转换为Anthropic格式"""
+    # 如果已经是Anthropic格式，不做转换
+    if "messages" in data:
+        return data
+
+    result = {}
+
+    # 处理模型
+    if "model" in data:
+        result["model"] = get_mapped_model(data["model"])
+    else:
+        result["model"] = "claude-3-5-sonnet-20241022"
+
+    # 处理系统消息和用户消息
+    result["messages"] = []
+    if "system" in data:
+        result["system"] = data["system"]
+
+    # 处理消息数组
+    if "messages" in data:
+        result["messages"] = data["messages"]
+
+    # 复制其他参数
+    for key in ["temperature", "top_p", "max_tokens", "stream"]:
+        if key in data:
+            result[key] = data[key]
+
+    return result
+
 async def handle_models_request(request):
+    """处理/v1/models端点的请求，返回支持的模型列表"""
     return web.json_response({
         "object": "list",
-        "data": [
-            {
-                "id": model,
-                "object": "model",
-                "created": int(time.time()),
-                "owned_by": "zed"
-            }
-            for model in CONFIG["MODELS"].keys()
-        ]
+        "data": AVAILABLE_MODELS
     })
 
 async def handle_message_request(request):
     global llm_token
     if not llm_token:
-        return web.json_response({"error": "LLM令牌不可用"}, status=500)
+        return web.json_response({"error": "LLM token not available"}, status=500)
     try:
         body = await request.json()
-        isClaudeAI = False
-        if request.path == '/v1/messages':
-            isClaudeAI = True
-            if "messages" in body:
-                for msg in body["messages"]:
-                    if "content" in msg:
-                        msg["content"] = format_content(msg["content"])
-            if "system" in body:
-                if isinstance(body["system"], list):
-                    body["system"] = "\n".join([item["text"] for item in body["system"]])
-            if "model" in body:
-                body["model"] = CONFIG['MODELS'].get(body["model"], "claude-3-5-sonnet-latest")
-        else:
-            body = await transform_messages(body)
-        with open('request_payload222.json', 'w', encoding='utf-8') as f:
-            json.dump(body, f, ensure_ascii=False, indent=2)
+
+        # 转换格式（如果需要）
+        body = convert_openai_to_anthropic(body)
+
+        # 确保模型是支持的
+        if "model" in body:
+            body["model"] = get_mapped_model(body["model"])
+
+        # Zed的Anthropic API对消息内容格式有特定要求
+        if "messages" in body:
+            for msg in body["messages"]:
+                if "content" in msg:
+                    msg["content"] = format_content(msg["content"])
+
+        # 处理系统消息格式
+        if "system" in body:
+            if isinstance(body["system"], list):
+                body["system"] = "\n".join([item["text"] for item in body["system"]])
+
         headers = {"Content-Type": "application/json", "Authorization": f"Bearer {llm_token}"}
-        with open('ceshi.txt', 'w', encoding='utf-8') as f:
-            f.write(llm_token + '\n')
         payload = {
             "provider": "anthropic",
-            "model": body.get("model", "claude-3-5-sonnet-latest"),
+            "model": body.get("model", "claude-3-5-sonnet-20241022"),
             "provider_request": body
         }
-        # with open('ceshi.txt', 'w', encoding='utf-8') as f:
-        #     f.write(json.dumps(body,ensure_ascii=False) + '\n')
+        
+
         if body.get("stream", False):
-            return await handle_streaming_request(request, headers, payload, isClaudeAI)
+            return await handle_streaming_request(request, headers, payload)
         else:
-            return await handle_non_streaming_request(headers, payload, isClaudeAI)
+            return await handle_non_streaming_request(headers, payload)
     except Exception as e:
-        logger.error(f"处理请求时发生错误: {e}")
+        logger.error(f"Error processing request: {e}")
         return web.json_response({"error": str(e)}, status=500)
 
-async def handle_non_streaming_request(headers, payload, isClaudeAI=False):
+async def handle_non_streaming_request(headers, payload):
     async with aiohttp.ClientSession() as session:
-        async with session.post(CONFIG['API']['LLM_API_URL'], headers=headers, json=payload) as r:
+        async with session.post(LLM_API_URL, headers=headers, json=payload) as r:
             if r.status != 200:
                 text = await r.text()
-                logger.error(f"LLM API错误: {text}")
+                logger.error(f"LLM API error: {text}")
                 return web.json_response({"error": text}, status=r.status)
             full_content, message_data = "", {}
             async for line in r.content:
                 if not line:
                     continue
                 try:
-                    event = json.loads(line.decode('utf-8').strip())
+                    event = json.loads(line.decode('utf8').strip())
                     et = event.get('type')
                     if et == "message_start":
                         message_data = event.get('message', {})
@@ -390,107 +406,195 @@ async def handle_non_streaming_request(headers, payload, isClaudeAI=False):
                         break
                 except Exception as e:
                     logger.error(f"Error processing line: {e}")
-            if isClaudeAI:
-                message_data['content'] = [{"type": "text", "text": full_content}]
-            else:
-                message_data = MessageProcessor.create_chat_response(full_content, payload.get("model"), False)
-            return web.json_response(message_data)
 
-async def handle_streaming_request(request, headers, payload, isClaudeAI=False):
+            # 构建响应
+            message_data['content'] = [{"type": "text", "text": full_content}]
+
+            # 为OpenAI格式添加兼容字段 - 使用完整模型名称
+            model_name = payload.get("provider_request", {}).get("model", "claude-3-5-sonnet-20241022")
+            result = {
+                "id": f"chatcmpl{int(time.time()*1000)}",
+                "object": "chat.completion",
+                "created": int(time.time()),
+                "model": model_name,
+                "choices": [
+                    {
+                        "index": 0,
+                        "message": {
+                            "role": "assistant",
+                            "content": full_content
+                        },
+                        "finish_reason": "stop"
+                    }
+                ],
+            }
+
+            # 如果有usage信息，添加到结果中
+            if "usage" in message_data:
+                result["usage"] = message_data["usage"]
+
+            return web.json_response(result)
+
+async def handle_streaming_request(request, headers, payload):
     response = web.StreamResponse()
     response.headers['Content-Type'] = 'text/event-stream'
     response.headers['Cache-Control'] = 'no-cache'
     response.headers['Connection'] = 'keep-alive'
     await response.prepare(request)
-    logger.info(f"开始处理流请求")
+
     async with aiohttp.ClientSession() as session:
-        async with session.post(CONFIG['API']['LLM_API_URL'], headers=headers, json=payload) as api_response:
+        async with session.post(LLM_API_URL, headers=headers, json=payload, timeout=60) as api_response:
             if api_response.status != 200:
                 error_text = await api_response.text()
-                logger.error(f"LLM API (stream)错误: {error_text}")
+                logger.error(f"LLM API (stream) error: {error_text}")
                 await response.write(f"data: {json.dumps({'error': error_text})}\n\n".encode())
                 await response.write(b"data: [DONE]\n\n")
                 return response
+
+            # 为流式响应创建唯一ID
+            response_id = f"chatcmpl{int(time.time()*1000)}"
+            content_buffer = ""
+            # 使用完整模型名称
+            model_name = payload.get("provider_request", {}).get("model", "claude-3-5-sonnet-20241022")
+
             async for line in api_response.content:
-                try:
-                    if line:
-                        if isClaudeAI:
-                            await response.write(f"data: {line.decode('utf-8')}\n\n".encode())
-                        else:
-                            try:
-                                data = json.loads(line.decode('utf-8').strip())
-                                if data.get('type') == "content_block_delta" and data.get('delta', {}).get('type') == "text_delta":
-                                    text = data['delta'].get('text', '')
-                                    message = MessageProcessor.create_chat_response(text, payload.get("model"), True)
-                                    await response.write(f"data: {json.dumps(message)}\n\n".encode())
-                            except Exception as e:
-                                logger.error(f"Error processing line: {e}")
-                except Exception as e:
-                    logger.error(f"Error processing line: {e}")
+                if line:
+                    line_text = line.decode('utf8')
+
+                    # 直接传递原始事件
+                    await response.write(f"data: {line_text}\n\n".encode())
+
+                    # 解析事件以构建OpenAI兼容格式
+                    try:
+                        data = json.loads(line_text)
+                        if data.get('type') == 'content_block_delta' and data.get('delta', {}).get('type') == 'text_delta':
+                            delta_text = data['delta'].get('text', '')
+                            content_buffer += delta_text
+
+                            # 创建OpenAI兼容的流式响应格式
+                            openai_chunk = {
+                                "id": response_id,
+                                "object": "chat.completion.chunk",
+                                "created": int(time.time()),
+                                "model": model_name,
+                                "choices": [
+                                    {
+                                        "index": 0,
+                                        "delta": {
+                                            "content": delta_text
+                                        },
+                                        "finish_reason": None
+                                    }
+                                ]
+                            }
+                            # 发送OpenAI兼容格式
+                            await response.write(f"data: {json.dumps(openai_chunk)}\n\n".encode())
+
+                        # 消息结束时发送完成标记
+                        elif data.get('type') == 'message_stop':
+                            final_chunk = {
+                                "id": response_id,
+                                "object": "chat.completion.chunk",
+                                "created": int(time.time()),
+                                "model": model_name,
+                                "choices": [
+                                    {
+                                        "index": 0,
+                                        "delta": {},
+                                        "finish_reason": "stop"
+                                    }
+                                ]
+                            }
+                            await response.write(f"data: {json.dumps(final_chunk)}\n\n".encode())
+                    except json.JSONDecodeError:
+                        pass
+
             await response.write(b"data: [DONE]\n\n")
-    return response
 
+            return response
 
 async def start_proxy_server():
     global proxy_server_running
     if proxy_server_running:
-        logger.info("代理服务器已运行，跳过启动")
+        logger.info("Proxy server already running, skipping startup")
         return
-        
+
     proxy_server_running = True
+
+    # 创建带有中间件的应用
     app = web.Application(middlewares=[auth_middleware])
+
+    # 添加API端点
     app.router.add_post('/v1/messages', handle_message_request)
-    app.router.add_post('/v1/chat/completions', handle_message_request)
-    app.router.add_get('/v1/models', handle_models_request)
-    
-    async def health_check():
+    app.router.add_post('/v1/chat/completions', handle_message_request)  # 添加OpenAI兼容端点
+    app.router.add_get('/v1/models', handle_models_request)  # 添加模型列表端点
+
+    # 添加一个简单的健康检查端点
+    async def health_check(request):
         return web.json_response({
             "status": "ok",
-            "message": "Zed LLM proxy is running"
+            "message": "Zed LLM proxy is running",
+            "available_models": [model["id"] for model in AVAILABLE_MODELS]
         })
 
     app.router.add_get('/', health_check)
 
     runner = web.AppRunner(app)
     await runner.setup()
-    site = web.TCPSite(runner, 'localhost', CONFIG['SERVER']['PORT'])
+    site = web.TCPSite(runner, 'localhost', PROXY_PORT)
     await site.start()
-    logger.info(f"代理服务器启动 http://localhost:{CONFIG['SERVER']['PORT']}")
+
+    password_status = "启用" if PROXY_PASSWORD else "未启用"
+    logger.info(f"代理服务器启动于 http://localhost:{PROXY_PORT}")
+    logger.info(f"密码保护: {password_status}")
+    logger.info(f"支持的模型: {', '.join([model['id'] for model in AVAILABLE_MODELS])}")
+    logger.info("支持的端点:")
+    logger.info(" /v1/messages (Anthropic API)")
+    logger.info(" /v1/chat/completions (OpenAI兼容API)")
+    logger.info(" /v1/models (模型列表)")
+
     while True:
         await asyncio.sleep(3600)
 
 def is_token_expiring():
     if not token_timestamp:
         return False
-    return (time.time() - token_timestamp) / 60 >= CONFIG['SERVER']['TOKEN_EXPIRY_WARNING_MINUTES']
+    return (time.time() - token_timestamp) / 60 >= TOKEN_EXPIRY_WARNING_MINUTES
 
 async def monitor_token_expiration():
     while True:
         await asyncio.sleep(60)
         if is_token_expiring():
             elapsed = int((time.time() - token_timestamp) / 60)
-            logger.warning(f"LLM令牌接近过期 (收到 {elapsed} 分钟前)")
+            logger.warning(f"LLM token is approaching expiration (received {elapsed} minutes ago)")
             if active_websocket is None:
-                logger.info("重新连接WebSocket以刷新令牌")
+                logger.info("Reconnecting WebSocket for token refresh")
                 asyncio.create_task(reconnect_for_token_refresh())
                 return
 
 async def reconnect_for_token_refresh():
     try:
-        if not CONFIG['LOGIN']['USER_ID'] or not CONFIG['LOGIN']['AUTH']:
-            logger.error("用户ID或授权令牌未设置")
+        # 使用环境变量而不是从文件读取
+        user_id = os.environ.get("ZED_USER_ID")
+        auth_token = os.environ.get("ZED_AUTH_TOKEN").replace("\\", "")
+
+        if not user_id or not auth_token:
+            logger.error("环境变量ZED_USER_ID或ZED_AUTH_TOKEN未设置")
             return
+
+        # 确保header格式一致
         headers = {
-            "authorization": f"{CONFIG['LOGIN']['USER_ID']} {CONFIG['LOGIN']['AUTH']}",
+            "authorization": user_id + " " + auth_token,
             "x-zed-protocol-version": "68",
             "x-zed-app-version": "0.178.0",
             "x-zed-release-channel": "stable"
         }
+        print(headers)
         ssl_context = ssl.create_default_context()
         ssl_context.check_hostname = False
         ssl_context.verify_mode = ssl.CERT_NONE
-        
-        async for websocket in connect(CONFIG['API']['WS_URL'], additional_headers=headers, ssl=ssl_context):
+
+        async for websocket in connect(WS_URL, additional_headers=headers, ssl=ssl_context):
             try:
                 ping_task = asyncio.create_task(ping_periodically(websocket))
                 await asyncio.sleep(2)
@@ -500,7 +604,7 @@ async def reconnect_for_token_refresh():
             except ConnectionClosed:
                 continue
             except Exception as e:
-                logger.error(f"令牌刷新期间发生错误: {e}")
+                logger.error(f"Error during token refresh: {e}")
                 await asyncio.sleep(1)
                 continue
             finally:
@@ -510,30 +614,80 @@ async def reconnect_for_token_refresh():
                 except asyncio.CancelledError:
                     pass
     except Exception as e:
-        logger.error(f"令牌刷新失败: {e}")
+        logger.error(f"Failed to reconnect for token refresh: {e}")
 
 async def async_main():
-    app = web.Application()
-    app.router.add_post('/v1/messages', handle_message_request)
-    app.router.add_post('/v1/chat/completions', handle_message_request)
-    app.router.add_get('/v1/models', handle_models_request)
-    
-    async def health_check():
-        return web.json_response({
-            "status": "ok",
-            "message": "Zed LLM proxy is running"
-        })
+    # 从环境变量获取认证信息
+    user_id = os.environ.get("ZED_USER_ID")
+    auth_token = os.environ.get("ZED_AUTH_TOKEN").replace("\\", "")
 
-    app.router.add_get('/', health_check)
+    if not user_id or not auth_token:
+        logger.error("环境变量ZED_USER_ID或ZED_AUTH_TOKEN未设置")
+        logger.error("请先运行auth_script.py获取认证信息，然后设置环境变量")
+        return
 
-    runner = web.AppRunner(app)
-    await runner.setup()
-    site = web.TCPSite(runner, 'localhost', CONFIG['SERVER']['PORT'])
-    await site.start()
+    # 确保header格式一致
+    headers = {
+        "authorization": user_id + " " + auth_token,
+        "x-zed-protocol-version": "68",
+        "x-zed-app-version": "0.178.0",
+        "x-zed-release-channel": "stable"
+    }
+    print(headers)
+    ssl_context = ssl.create_default_context()
+    ssl_context.check_hostname = False
+    ssl_context.verify_mode = ssl.CERT_NONE
+    logger.info("Connecting to the WebSocket server")
+    async for websocket in connect(WS_URL, additional_headers=headers, ssl=ssl_context):
+        try:
+            ping_task = asyncio.create_task(ping_periodically(websocket))
+            token_request_task = asyncio.create_task(delayed_token_request(websocket, delay=2))
+            await handle_messages(websocket)
+            break
+        except ConnectionClosed:
+            continue
+        except Exception as e:
+            logger.error(f"Unexpected error: {e}")
+            await asyncio.sleep(1)
+            continue
+        finally:
+            ping_task.cancel()
+            try:
+                await ping_task
+            except asyncio.CancelledError:
+                pass
+            token_request_task.cancel()
+            try:
+                await token_request_task
+            except asyncio.CancelledError:
+                pass
+
+    while True:
+        await asyncio.sleep(3600)
 
 async def delayed_token_request(websocket, delay=2):
     await asyncio.sleep(delay)
     await request_accept_terms_of_service(websocket)
 
+def main():
+    logger.info("启动Zed LLM代理服务")
+    logger.info(f"配置端口: {PROXY_PORT}")
+    logger.info(f"密码保护: {'已启用' if PROXY_PASSWORD else '未启用'}")
+
+    # 检查必要的环境变量
+    if not os.environ.get("ZED_USER_ID") or not os.environ.get("ZED_AUTH_TOKEN"):
+        logger.error("错误: 环境变量ZED_USER_ID和ZED_AUTH_TOKEN必须设置")
+        logger.error("请先运行auth_script.py获取认证信息，然后设置环境变量")
+        return
+
+    try:
+        asyncio.run(async_main())
+    except KeyboardInterrupt:
+        logger.info("收到中断信号，正在退出...")
+    except Exception as e:
+        logger.error(f"发生错误: {e}")
+    finally:
+        logger.info("代理服务已关闭")
+
 if __name__ == "__main__":
-    asyncio.run(async_main())
+    main()