refactor(openai): drop SDK dependency and switch to native HTTP client

models/openai/open_ai_bot.py

@@ -2,8 +2,14 @@
 
 import time
 
-import openai
-from models.openai.openai_compat import RateLimitError, Timeout, APIConnectionError
+from models.openai.openai_compat import (
+    RateLimitError,
+    Timeout,
+    APIConnectionError,
+    APIError,
+    wrap_http_error,
+)
+from models.openai.openai_http_client import OpenAIHTTPClient, OpenAIHTTPError
 
 from models.bot import Bot
 from models.openai_compatible_bot import OpenAICompatibleBot
@@ -22,12 +28,14 @@ user_session = dict()
 class OpenAIBot(Bot, OpenAIImage, OpenAICompatibleBot):
     def __init__(self):
         super().__init__()
-        openai.api_key = conf().get("open_ai_api_key")
-        if conf().get("open_ai_api_base"):
-            openai.api_base = conf().get("open_ai_api_base")
-        proxy = conf().get("proxy")
-        if proxy:
-            openai.proxy = proxy
+        self._api_key = conf().get("open_ai_api_key")
+        self._api_base = conf().get("open_ai_api_base") or None
+        self._proxy = conf().get("proxy") or None
+        self._http_client = OpenAIHTTPClient(
+            api_key=self._api_key,
+            api_base=self._api_base,
+            proxy=self._proxy,
+        )
 
         self.sessions = SessionManager(OpenAISession, model=conf().get("model") or "text-davinci-003")
         self.args = {
@@ -54,6 +62,10 @@ class OpenAIBot(Bot, OpenAIImage, OpenAICompatibleBot):
             'default_presence_penalty': conf().get("presence_penalty", 0.0),
         }
 
+    def _get_http_client(self) -> OpenAIHTTPClient:
+        """Reuse the per-instance HTTP client for the streaming/tool path."""
+        return self._http_client
+
     def reply(self, query, context=None):
         # acquire reply content
         if context and context.type:
@@ -96,8 +108,14 @@ class OpenAIBot(Bot, OpenAIImage, OpenAICompatibleBot):
 
     def reply_text(self, session: OpenAISession, retry_count=0):
         try:
-            response = openai.Completion.create(prompt=str(session), **self.args)
-            res_content = response.choices[0]["text"].strip().replace("<|endoftext|>", "")
+            call_args = dict(self.args)
+            timeout = call_args.pop("request_timeout", None) or call_args.pop("timeout", None)
+            response = self._http_client.completions(
+                timeout=timeout,
+                prompt=str(session),
+                **call_args,
+            )
+            res_content = response["choices"][0]["text"].strip().replace("<|endoftext|>", "")
             total_tokens = response["usage"]["total_tokens"]
             completion_tokens = response["usage"]["completion_tokens"]
             logger.info("[OPEN_AI] reply={}".format(res_content))
@@ -106,125 +124,41 @@ class OpenAIBot(Bot, OpenAIImage, OpenAICompatibleBot):
                 "completion_tokens": completion_tokens,
                 "content": res_content,
             }
+        except OpenAIHTTPError as http_err:
+            return self._handle_legacy_error(wrap_http_error(http_err), session, retry_count)
         except Exception as e:
-            need_retry = retry_count < 2
-            result = {"completion_tokens": 0, "content": "我现在有点累了，等会再来吧"}
-            if isinstance(e, RateLimitError):
-                logger.warn("[OPEN_AI] RateLimitError: {}".format(e))
-                result["content"] = "提问太快啦，请休息一下再问我吧"
-                if need_retry:
-                    time.sleep(20)
-            elif isinstance(e, Timeout):
-                logger.warn("[OPEN_AI] Timeout: {}".format(e))
-                result["content"] = "我没有收到你的消息"
-                if need_retry:
-                    time.sleep(5)
-            elif isinstance(e, APIConnectionError):
-                logger.warn("[OPEN_AI] APIConnectionError: {}".format(e))
-                need_retry = False
-                result["content"] = "我连接不到你的网络"
-            else:
-                logger.warn("[OPEN_AI] Exception: {}".format(e))
-                need_retry = False
-                self.sessions.clear_session(session.session_id)
+            return self._handle_legacy_error(e, session, retry_count)
 
+    def _handle_legacy_error(self, e, session, retry_count):
+        """Map exception -> reply for the legacy /completions endpoint."""
+        need_retry = retry_count < 2
+        result = {"completion_tokens": 0, "content": "我现在有点累了，等会再来吧"}
+        if isinstance(e, RateLimitError):
+            logger.warn("[OPEN_AI] RateLimitError: {}".format(e))
+            result["content"] = "提问太快啦，请休息一下再问我吧"
             if need_retry:
-                logger.warn("[OPEN_AI] 第{}次重试".format(retry_count + 1))
-                return self.reply_text(session, retry_count + 1)
-            else:
-                return result
+                time.sleep(20)
+        elif isinstance(e, Timeout):
+            logger.warn("[OPEN_AI] Timeout: {}".format(e))
+            result["content"] = "我没有收到你的消息"
+            if need_retry:
+                time.sleep(5)
+        elif isinstance(e, APIConnectionError):
+            logger.warn("[OPEN_AI] APIConnectionError: {}".format(e))
+            need_retry = False
+            result["content"] = "我连接不到你的网络"
+        else:
+            logger.warn("[OPEN_AI] Exception: {}".format(e))
+            need_retry = False
+            self.sessions.clear_session(session.session_id)
 
-    def call_with_tools(self, messages, tools=None, stream=False, **kwargs):
-        """
-        Call OpenAI API with tool support for agent integration
-        Note: This bot uses the old Completion API which doesn't support tools.
-        For tool support, use ChatGPTBot instead.
-        
-        This method converts to ChatCompletion API when tools are provided.
-        
-        Args:
-            messages: List of messages
-            tools: List of tool definitions (OpenAI format)
-            stream: Whether to use streaming
-            **kwargs: Additional parameters
-            
-        Returns:
-            Formatted response in OpenAI format or generator for streaming
-        """
-        try:
-            # The old Completion API doesn't support tools
-            # We need to use ChatCompletion API instead
-            logger.info("[OPEN_AI] Using ChatCompletion API for tool support")
-            
-            # Build request parameters for ChatCompletion
-            request_params = {
-                "model": kwargs.get("model", conf().get("model") or "gpt-4.1"),
-                "messages": messages,
-                "temperature": kwargs.get("temperature", conf().get("temperature", 0.9)),
-                "top_p": kwargs.get("top_p", 1),
-                "frequency_penalty": kwargs.get("frequency_penalty", conf().get("frequency_penalty", 0.0)),
-                "presence_penalty": kwargs.get("presence_penalty", conf().get("presence_penalty", 0.0)),
-                "stream": stream
-            }
-            
-            # Add max_tokens if specified
-            if kwargs.get("max_tokens"):
-                request_params["max_tokens"] = kwargs["max_tokens"]
-            
-            # Add tools if provided
-            if tools:
-                request_params["tools"] = tools
-                request_params["tool_choice"] = kwargs.get("tool_choice", "auto")
-            
-            # Make API call using ChatCompletion
-            if stream:
-                return self._handle_stream_response(request_params)
-            else:
-                return self._handle_sync_response(request_params)
-                
-        except Exception as e:
-            logger.error(f"[OPEN_AI] call_with_tools error: {e}")
-            if stream:
-                def error_generator():
-                    yield {
-                        "error": True,
-                        "message": str(e),
-                        "status_code": 500
-                    }
-                return error_generator()
-            else:
-                return {
-                    "error": True,
-                    "message": str(e),
-                    "status_code": 500
-                }
-    
-    def _handle_sync_response(self, request_params):
-        """Handle synchronous OpenAI ChatCompletion API response"""
-        try:
-            response = openai.ChatCompletion.create(**request_params)
-            
-            logger.info(f"[OPEN_AI] call_with_tools reply, model={response.get('model')}, "
-                       f"total_tokens={response.get('usage', {}).get('total_tokens', 0)}")
-            
-            return response
-            
-        except Exception as e:
-            logger.error(f"[OPEN_AI] sync response error: {e}")
-            raise
-    
-    def _handle_stream_response(self, request_params):
-        """Handle streaming OpenAI ChatCompletion API response"""
-        try:
-            stream = openai.ChatCompletion.create(**request_params)
-            
-            for chunk in stream:
-                yield chunk
-                
-        except Exception as e:
-            logger.error(f"[OPEN_AI] stream response error: {e}")
-            yield {
-                "error": True,
-                "message": str(e),
-                "status_code": 500
-            }
+        if need_retry:
+            logger.warn("[OPEN_AI] 第{}次重试".format(retry_count + 1))
+            return self.reply_text(session, retry_count + 1)
+        return result
+
+    # NOTE: Tool-call routing is delegated to OpenAICompatibleBot.call_with_tools,
+    # which calls /chat/completions via our shared HTTP client. The previous
+    # bespoke implementation here bypassed Claude->OpenAI message/tool conversion
+    # and was effectively broken for agent flows; we now inherit the correct
+    # implementation from the base class.