Update app.py

app.py

@@ -1,3 +1,4 @@
+# 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
@@ -21,123 +22,81 @@ _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
-
-
+  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
 import os
 import json
 import ssl
 import time
 import asyncio
+import logging
 import aiohttp
-import sys
-import inspect
-from loguru import logger
 from aiohttp import web
 import zstandard as zstd
+from dotenv import load_dotenv
 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')
 
-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
-        )
-
-        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}")
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(levelname)s: %(message)s'
+)
+logger = logging.getLogger(__name__)
 
-    async def request_logger(self, request):
-        caller_info = self._get_caller_info()
-        self.logger.bind(**caller_info).info(f"请求: {request.method} {request.path}", "Request")
+current_dir = os.path.dirname(os.path.abspath(__file__))
+env_path = os.path.join(current_dir, '.env')
 
-logger = Logger(level="INFO")
+load_dotenv(env_path)
 
-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 = 7860  # 默认端口，可通过环境变量覆盖
-TOKEN_EXPIRY_WARNING_MINUTES = 50
+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",7860),
+        "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"
+    }
+}
 
 highest_message_id = 0
 llm_token = None
@@ -146,47 +105,40 @@ server_peer_id = None
 active_websocket = None
 proxy_server_running = False
 
-# 从环境变量读取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",
-}
+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
+        }
 
 def decode_envelope(data):
     try:
@@ -203,11 +155,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"Unable to decode message: {e}; data preview: {hex_preview}")
-        return {"error": f"Unable to decode message: {e}"}
+        logger.error(f"无法解码消息： {e}; 数据预览： {hex_preview}")
+        return {"error": f"无法解码消息： {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
@@ -224,7 +176,7 @@ async def ping_periodically(websocket):
             await websocket.ping()
             await asyncio.sleep(1)
         except Exception as e:
-            logger.error(f"Error sending ping: {e}")
+            logger.error(f"发送ping错误: {e}")
             break
 
 async def handle_messages(websocket):
@@ -232,36 +184,36 @@ async def handle_messages(websocket):
     active_websocket = websocket
     try:
         async for message in websocket:
-            message_bytes = message.encode('utf8') if isinstance(message, str) else message
+            message_bytes = message.encode('utf-8') 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 token received at {time.ctime(token_timestamp)}")
+                logger.info(f"LLM令牌收到  {time.ctime(token_timestamp)}")
                 if not proxy_server_running:
                     asyncio.create_task(start_proxy_server())
                 asyncio.create_task(monitor_token_expiration())
-                logger.info("Closing WebSocket connection until token refresh is needed")
+                logger.info("关闭WebSocket连接，直到需要刷新令牌")
                 await websocket.close()
                 active_websocket = None
                 return
     except ConnectionClosed:
-        logger.info("Connection closed")
+        logger.info("连接已关闭")
         active_websocket = None
 
 async def request_llm_token(websocket):
     message, _ = create_message('get_llm_token')
-    logger.info("Requesting the LLM token")
+    logger.info("请求LLM令牌")
     await websocket.send(message)
 
 async def request_accept_terms_of_service(websocket):
     message, _ = create_message('accept_terms_of_service')
-    logger.info("Sending consent for the Zed Terms of Service")
+    logger.info("发送同意Zed服务条款")
     await websocket.send(message)
 
 def format_content(content):
@@ -269,129 +221,165 @@ 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': request.get('stream', False)
+  }
+
 @web.middleware
 async def auth_middleware(request, handler):
-    if PROXY_PASSWORD:
-        # 检查各种可能的密码验证方式
+    if CONFIG['API']['API_KEY']:
         auth_header = request.headers.get('Authorization')
-        password_header = request.headers.get('XPassword') or request.headers.get('Password')
+        xapi_key_header = request.headers.get('x-api-key')
 
-        # 从Authorization头获取密码（如果是Bearer格式）
         auth_password = None
         if auth_header and auth_header.startswith('Bearer '):
             auth_password = auth_header[7:]
 
-        # 检查任何来源的密码是否匹配
-        if auth_password == PROXY_PASSWORD or password_header == PROXY_PASSWORD:
+        if auth_password == CONFIG['API']['API_KEY'] or xapi_key_header == CONFIG['API']['API_KEY']:
             return await handler(request)
         else:
             return web.json_response(
-                {"error": "Unauthorized. Provide valid password in Authorization or XPassword header"},
+                {"error": "Unauthorized"},
                 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
+    return await handler(request)
 
 async def handle_models_request(request):
-    """处理/v1/models端点的请求，返回支持的模型列表"""
     return web.json_response({
         "object": "list",
-        "data": AVAILABLE_MODELS
+        "data": [
+            {
+                "id": model,
+                "object": "model",
+                "created": int(time.time()),
+                "owned_by": "zed"
+            }
+            for model in CONFIG["MODELS"].keys()
+        ]
     })
 
 async def handle_message_request(request):
     global llm_token
     if not llm_token:
-        return web.json_response({"error": "LLM token not available"}, status=500)
+        return web.json_response({"error": "LLM令牌不可用"}, status=500)
     try:
         body = await request.json()
-
-        # 转换格式（如果需要）
-        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"]])
+        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)
 
         headers = {"Content-Type": "application/json", "Authorization": f"Bearer {llm_token}"}
         payload = {
             "provider": "anthropic",
-            "model": body.get("model", "claude-3-5-sonnet-20241022"),
+            "model": body.get("model", "claude-3-5-sonnet-latest"),
             "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)
+            return await handle_streaming_request(request, headers, payload, isClaudeAI)
         else:
-            return await handle_non_streaming_request(headers, payload)
+            return await handle_non_streaming_request(headers, payload, isClaudeAI)
     except Exception as e:
-        logger.error(f"Error processing request: {e}")
+        logger.error(f"处理请求时发生错误: {e}")
         return web.json_response({"error": str(e)}, status=500)
 
-async def handle_non_streaming_request(headers, payload):
+async def handle_non_streaming_request(headers, payload, isClaudeAI=False):
     async with aiohttp.ClientSession() as session:
-        async with session.post(LLM_API_URL, headers=headers, json=payload) as r:
+        async with session.post(CONFIG['API']['LLM_API_URL'], headers=headers, json=payload) as r:
             if r.status != 200:
                 text = await r.text()
-                logger.error(f"LLM API error: {text}")
+                logger.error(f"LLM API错误: {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('utf8').strip())
+                    event = json.loads(line.decode('utf-8').strip())
                     et = event.get('type')
                     if et == "message_start":
                         message_data = event.get('message', {})
@@ -403,195 +391,108 @@ async def handle_non_streaming_request(headers, payload):
                         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)
 
-            # 构建响应
-            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):
+async def handle_streaming_request(request, headers, payload, isClaudeAI=False):
     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(LLM_API_URL, headers=headers, json=payload, timeout=60) as api_response:
+        async with session.post(CONFIG['API']['LLM_API_URL'], headers=headers, json=payload) as api_response:
             if api_response.status != 200:
                 error_text = await api_response.text()
-                logger.error(f"LLM API (stream) error: {error_text}")
+                logger.error(f"LLM API (stream)错误: {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:
-                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
-
+                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())
+                                print(data)
+                                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}")
             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("Proxy server already running, skipping startup")
+        logger.info("代理服务器已运行，跳过启动")
         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)  # 添加OpenAI兼容端点
-    app.router.add_get('/v1/models', handle_models_request)  # 添加模型列表端点
-
-    # 添加一个简单的健康检查端点
-    async def health_check(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",
-            "available_models": [model["id"] for model in AVAILABLE_MODELS]
+            "message": "Zed LLM proxy is running"
         })
 
     app.router.add_get('/', health_check)
 
     runner = web.AppRunner(app)
     await runner.setup()
-    site = web.TCPSite(runner, 'localhost', PROXY_PORT)
+    site = web.TCPSite(runner, '0.0.0.0', CONFIG['SERVER']['PORT'])
     await site.start()
-
-    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 (模型列表)")
-
+    logger.info(f"代理服务器启动 http://0.0.0.0:{CONFIG['SERVER']['PORT']}")
     while True:
         await asyncio.sleep(3600)
 
 def is_token_expiring():
     if not token_timestamp:
         return False
-    return (time.time() - token_timestamp) / 60 >= TOKEN_EXPIRY_WARNING_MINUTES
+    return (time.time() - token_timestamp) / 60 >= CONFIG['SERVER']['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 token is approaching expiration (received {elapsed} minutes ago)")
+            logger.warning(f"LLM令牌接近过期 (收到 {elapsed} 分钟前)")
             if active_websocket is None:
-                logger.info("Reconnecting WebSocket for token refresh")
+                logger.info("重新连接WebSocket以刷新令牌")
                 asyncio.create_task(reconnect_for_token_refresh())
                 return
 
 async def reconnect_for_token_refresh():
     try:
-        # 使用环境变量而不是从文件读取
-        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未设置")
+        if not CONFIG['LOGIN']['USER_ID'] or not CONFIG['LOGIN']['AUTH']:
+            logger.error("用户ID或授权令牌未设置")
             return
-
-        # 确保header格式一致
         headers = {
-            "authorization": user_id + " " + auth_token,
+            "authorization": f"{CONFIG['LOGIN']['USER_ID']} {CONFIG['LOGIN']['AUTH']}",
             "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(WS_URL, additional_headers=headers, ssl=ssl_context):
+        
+        async for websocket in connect(CONFIG['API']['WS_URL'], additional_headers=headers, ssl=ssl_context):
             try:
                 ping_task = asyncio.create_task(ping_periodically(websocket))
                 await asyncio.sleep(2)
@@ -601,7 +502,7 @@ async def reconnect_for_token_refresh():
             except ConnectionClosed:
                 continue
             except Exception as e:
-                logger.error(f"Error during token refresh: {e}")
+                logger.error(f"令牌刷新期间发生错误: {e}")
                 await asyncio.sleep(1)
                 continue
             finally:
@@ -611,31 +512,23 @@ async def reconnect_for_token_refresh():
                 except asyncio.CancelledError:
                     pass
     except Exception as e:
-        logger.error(f"Failed to reconnect for token refresh: {e}")
+        logger.error(f"令牌刷新失败: {e}")
 
 async def async_main():
-    # 从环境变量获取认证信息
-    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未设置")
-        logger.error("请先运行auth_script.py获取认证信息，然后设置环境变量")
+    if not CONFIG['LOGIN']['USER_ID'] or not CONFIG['LOGIN']['AUTH']:
+        logger.error("用户ID或授权令牌未设置")
         return
-
-    # 确保header格式一致
     headers = {
-        "authorization": user_id + " " + auth_token,
+        "authorization": f"{CONFIG['LOGIN']['USER_ID']} {CONFIG['LOGIN']['AUTH']}",
         "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):
+    logger.info("连接到Websocket服务器")
+    async for websocket in connect(CONFIG['API']['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))
@@ -644,7 +537,7 @@ async def async_main():
         except ConnectionClosed:
             continue
         except Exception as e:
-            logger.error(f"Unexpected error: {e}")
+            logger.error(f"意外错误: {e}")
             await asyncio.sleep(1)
             continue
         finally:
@@ -666,25 +559,5 @@ 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__":
-    main()
+    asyncio.run(async_main())