changed proxy pool

freeplay2api.py

@@ -152,8 +152,9 @@ class FreeplayClient:
                 self.proxy_pool.remove_proxy(proxy_info['ip'], proxy_info['port'])
             return 0.0
         except Exception as e:
+            session_suffix = session_id[-4:] if session_id and len(session_id) >= 4 else session_id or "None"
             logging.warning(
-                f"Failed to check balance for session_id ending in ...{session_id[-4:]}: {e}"
+                f"Failed to check balance for session_id ending in ...{session_suffix}: {e}"
             )
             return 0.0
 
@@ -326,11 +327,14 @@ class AccountManager:
     def load_accounts(self):
         with self.lock:
             if not os.path.exists(self.filepath):
+                logging.info(f"DEBUG: Accounts file {self.filepath} does not exist, initializing empty accounts list")
                 self.accounts = []
                 return
             with open(self.filepath, "r", encoding="utf-8") as f:
                 self.accounts = [json.loads(line) for line in f if line.strip()]
             logging.info(f"Loaded {len(self.accounts)} accounts from {self.filepath}")
+            for i, acc in enumerate(self.accounts):
+                logging.info(f"DEBUG: Account {i}: email={acc.get('email')}, session_id type={type(acc.get('session_id'))}, session_id={repr(acc.get('session_id'))}")
 
     def save_accounts(self):
         # This operation is disabled to ensure the application is stateless.
@@ -380,36 +384,54 @@ class KeyMaintainer(threading.Thread):
             try:
                 logging.info("KeyMaintainer: Starting maintenance cycle.")
                 accounts = self.manager.get_all_accounts()
+                logging.info(f"DEBUG: KeyMaintainer got {len(accounts)} accounts")
 
                 # Update balances
-                for account in accounts:
-                    balance = self.client.check_balance(account["session_id"])
-                    if balance != account.get("balance"):
-                        account["balance"] = balance
-                        self.manager.update_account(account)
-                        logging.info(f"Account {account['email']} balance updated to ${balance:.4f}")
+                for i, account in enumerate(accounts):
+                    try:
+                        logging.info(f"DEBUG: Processing account {i}: {account.get('email')}")
+                        logging.info(f"DEBUG: Account structure: {list(account.keys())}")
+                        session_id = account.get("session_id")
+                        logging.info(f"DEBUG: session_id type: {type(session_id)}, value: {repr(session_id)}")
+                        
+                        balance = self.client.check_balance(session_id)
+                        if balance != account.get("balance"):
+                            account["balance"] = balance
+                            self.manager.update_account(account)
+                            logging.info(f"Account {account['email']} balance updated to ${balance:.4f}")
+                    except Exception as e:
+                        logging.error(f"DEBUG: Error processing account {i} ({account.get('email')}): {type(e).__name__}: {e}")
+                        import traceback
+                        logging.error(f"DEBUG: Account processing traceback: {traceback.format_exc()}")
 
                 # Check if new accounts are needed
-                healthy_accounts = [
-                    acc for acc in self.manager.get_all_accounts()
-                    if acc.get("balance", 0) > self.config["LOW_BALANCE_THRESHOLD"]
-                ]
-                needed = self.config["ACTIVE_KEY_THRESHOLD"] - len(healthy_accounts)
-
-                while needed > 0:
-                    logging.info(f"Healthy accounts ({len(healthy_accounts)}) below threshold. Need to register {needed} new accounts. Retrying immediately.")
-                    new_account = self.client.register()
-                    if new_account:
-                        self.manager.add_account(new_account)
-                    
+                try:
                     healthy_accounts = [
                         acc for acc in self.manager.get_all_accounts()
                         if acc.get("balance", 0) > self.config["LOW_BALANCE_THRESHOLD"]
                     ]
                     needed = self.config["ACTIVE_KEY_THRESHOLD"] - len(healthy_accounts)
 
+                    while needed > 0:
+                        logging.info(f"Healthy accounts ({len(healthy_accounts)}) below threshold. Need to register {needed} new accounts. Retrying immediately.")
+                        new_account = self.client.register()
+                        if new_account:
+                            self.manager.add_account(new_account)
+                        
+                        healthy_accounts = [
+                            acc for acc in self.manager.get_all_accounts()
+                            if acc.get("balance", 0) > self.config["LOW_BALANCE_THRESHOLD"]
+                        ]
+                        needed = self.config["ACTIVE_KEY_THRESHOLD"] - len(healthy_accounts)
+                except Exception as e:
+                    logging.error(f"DEBUG: Error in account threshold check: {type(e).__name__}: {e}")
+                    import traceback
+                    logging.error(f"DEBUG: Threshold check traceback: {traceback.format_exc()}")
+
             except Exception as e:
-                logging.error(f"Error in KeyMaintainer cycle: {e}")
+                logging.error(f"Error in KeyMaintainer cycle: {type(e).__name__}: {e}")
+                import traceback
+                logging.error(f"DEBUG: KeyMaintainer outer traceback: {traceback.format_exc()}")
 
             time.sleep(self.config["CHECK_INTERVAL_SECONDS"])
 
@@ -587,88 +609,106 @@ async def chat_completions(
             message["content"] = new_content
 
     # 账户选择和重试逻辑
-    max_retries = len(account_manager.get_all_accounts())
+    all_accounts = account_manager.get_all_accounts()
+    logging.info(f"DEBUG: chat_completions got {len(all_accounts)} total accounts")
+    max_retries = len(all_accounts)
+    
     for attempt in range(max_retries):
-        account = account_manager.get_account()
-        if not account:
-            raise HTTPException(
-                status_code=503, detail="No available accounts in the pool."
-            )
-
         try:
-            params = {
-                "max_tokens": req.max_tokens,
-                "temperature": req.temperature,
-                "top_p": req.top_p,
-            }
-            response = freeplay_client.chat(
-                account["session_id"],
-                account["project_id"],
-                model_config,
-                messages_dict,
-                params,
-            )
+            account = account_manager.get_account()
+            if not account:
+                raise HTTPException(
+                    status_code=503, detail="No available accounts in the pool."
+                )
 
-            if response.status_code == 200:
-                # 请求成功
-                if req.stream:
-                    return StreamingResponse(
-                        stream_generator(response, req.model, account),
-                        media_type="text/event-stream",
-                    )
-                else:
-                    full_content = ""
-                    for line in response.iter_lines(decode_unicode=True):
-                        if line and line.startswith("data: "):
-                            try:
-                                data = json.loads(line[6:])
-                                full_content += data.get("content", "")
-                                if data.get("cost") is not None:
-                                    break
-                            except json.JSONDecodeError:
-                                continue
-
-                    # 更新余额
-                    new_balance = freeplay_client.check_balance(account["session_id"])
-                    account["balance"] = new_balance
-                    account_manager.update_account(account)
-                    logging.info(
-                        f"Post-chat balance update for {account['email']}: ${new_balance:.4f}"
-                    )
+            logging.info(f"DEBUG: Using account {account.get('email')} for chat attempt {attempt}")
+            logging.info(f"DEBUG: Account keys: {list(account.keys())}")
+            
+            try:
+                params = {
+                    "max_tokens": req.max_tokens,
+                    "temperature": req.temperature,
+                    "top_p": req.top_p,
+                }
+                response = freeplay_client.chat(
+                    account["session_id"],
+                    account["project_id"],
+                    model_config,
+                    messages_dict,
+                    params,
+                )
 
-                    return ChatCompletionResponse(
-                        model=req.model,
-                        choices=[
-                            ChatCompletionChoice(
-                                message=ChatMessage(
-                                    role="assistant", content=full_content
+                if response.status_code == 200:
+                    # 请求成功
+                    if req.stream:
+                        return StreamingResponse(
+                            stream_generator(response, req.model, account),
+                            media_type="text/event-stream",
+                        )
+                    else:
+                        full_content = ""
+                        for line in response.iter_lines(decode_unicode=True):
+                            if line and line.startswith("data: "):
+                                try:
+                                    data = json.loads(line[6:])
+                                    content = data.get("content", "")
+                                    if content is not None:
+                                        full_content += content
+                                    if data.get("cost") is not None:
+                                        break
+                                except json.JSONDecodeError:
+                                    continue
+
+                        # 更新余额
+                        new_balance = freeplay_client.check_balance(account["session_id"])
+                        account["balance"] = new_balance
+                        account_manager.update_account(account)
+                        logging.info(
+                            f"Post-chat balance update for {account['email']}: ${new_balance:.4f}"
+                        )
+
+                        return ChatCompletionResponse(
+                            model=req.model,
+                            choices=[
+                                ChatCompletionChoice(
+                                    message=ChatMessage(
+                                        role="assistant", content=full_content
+                                    )
                                 )
-                            )
-                        ],
-                    )
+                            ],
+                        )
 
-            elif response.status_code in [401, 403, 404]:
-                logging.warning(
-                    f"Account {account['email']} failed with status {response.status_code}. Disabling it."
-                )
-                account["balance"] = 0.0  # 禁用账户
-                account_manager.update_account(account)
-                continue  # 重试下一个
-            else:
-                logging.error(
-                    f"API call failed with status {response.status_code}: {response.text}"
-                )
-                response.raise_for_status()
+                elif response.status_code in [401, 403, 404]:
+                    logging.warning(
+                        f"Account {account['email']} failed with status {response.status_code}. Disabling it."
+                    )
+                    account["balance"] = 0.0  # 禁用账户
+                    account_manager.update_account(account)
+                    continue  # 重试下一个
+                else:
+                    logging.error(
+                        f"API call failed with status {response.status_code}: {response.text}"
+                    )
+                    response.raise_for_status()
+                    
+            except Exception as e:
+                logging.error(f"DEBUG: Error in chat request: {type(e).__name__}: {e}")
+                import traceback
+                logging.error(f"DEBUG: Chat request traceback: {traceback.format_exc()}")
+                raise  # Re-raise to be caught by outer exception handler
 
         except requests.exceptions.ProxyError:
             # Proxy error was already logged and handled in FreeplayClient
             logging.warning(f"Retrying request due to proxy error.")
             # Don't disable the account, just retry with a new proxy (and potentially new account)
             continue
+                
         except Exception as e:
             logging.error(
-                f"Error with account {account['email']}: {e}. Trying next account."
+                f"Error with account {account.get('email', 'unknown')}: {type(e).__name__}: {e}. Trying next account."
             )
+            import traceback
+            logging.error(f"DEBUG: Account error traceback: {traceback.format_exc()}")
             account["balance"] = 0.0  # 发生未知异常也禁用
             account_manager.update_account(account)
             continue