Change baseclient to custom_openai_client

base_client.py

@@ -1,54 +0,0 @@
-from openai import OpenAI
-import requests
-from typing import List, Dict, Optional
-
-class BaseClient(OpenAI):
-    def __init__(self, api_key, **kwargs):
-        super().__init__(api_key=api_key, **kwargs)
-
-    def openai_chat(self, messages, model="gpt-3.5-turbo", **kwargs):
-        try:
-            response = self.chat.completions.create(
-                model=model,
-                messages=messages,
-                **kwargs
-            )
-            return response.choices[0].message.content
-        except Exception as e:
-            print(f"OpenAI Chat API Error: {e}")
-            return None
-
-    def deepseek_chat(self, messages: List[Dict[str, str]], model: str = "deepseek-chat", **kwargs) -> Optional[str]:
-        try:
-            headers = {
-                "Content-Type": "application/json",
-                "Authorization": f"Bearer {self.api_key}"
-            }
-            
-            data = {
-                "model": model,
-                "messages": messages,
-                "temperature": kwargs.get("temperature", 0.7),
-                "max_tokens": kwargs.get("max_tokens", 1000),
-                "stream": False
-            }
-            
-            response = requests.post(
-                "https://api.deepseek.com/v1/chat/completions",
-                headers=headers,
-                json=data
-            )
-            
-            if response.status_code != 200:
-                raise ValueError(f"Deepseek API request failed with status {response.status_code}")
-            
-            response_data = response.json()
-            
-            if not response_data.get("choices"):
-                raise ValueError("No choices in Deepseek API response")
-
-            return response_data["choices"][0]["message"]["content"]
-
-        except Exception as e:
-            print(f"Deepseek Chat API Error: {e}")
-            return None

custom_openai_client.py

@@ -0,0 +1,220 @@
+from typing import List, Dict, Optional, Union
+from openai import OpenAI
+from openai.types.chat import ChatCompletion
+from openai._types import NotGiven, NOT_GIVEN
+import openai
+import requests
+from dataclasses import dataclass
+from enum import Enum
+
+class ModelProvider(Enum):
+    OPENAI = "openai"
+    DEEPSEEK = "deepseek"
+
+@dataclass
+class ApiConfig:
+    base_url: str
+    api_version: str = "v1"
+
+    @property
+    def chat_endpoint(self) -> str:
+        return f"{self.base_url}/{self.api_version}/chat/completions"
+
+class CustomOpenAI(OpenAI):
+    # API Configuration for different providers
+    API_CONFIGS = {
+        ModelProvider.OPENAI: ApiConfig("https://api.openai.com"),
+        ModelProvider.DEEPSEEK: ApiConfig("https://api.deepseek.ai")
+    }
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        organization: Optional[str] = None,
+        deepseek_api_key: Optional[str] = None,
+        **kwargs
+    ):
+        """
+        Initialize CustomOpenAI client with enhanced chat functionality.
+        
+        Args:
+            api_key: OpenAI API key
+            organization: Organization ID (optional)
+            deepseek_api_key: DeepSeek API key (optional)
+            **kwargs: Additional client configuration parameters
+        """
+        super().__init__(
+            api_key=api_key,
+            organization=organization,
+            **kwargs
+        )
+        self.deepseek_api_key = deepseek_api_key
+
+    def simple_chat(
+        self,
+        messages: List[Dict[str, str]],
+        model: str = "gpt-3.5-turbo",
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        **kwargs
+    ) -> Optional[str]:
+        """
+        Simplified chat completion method that returns just the message content.
+        
+        Args:
+            messages: List of message dictionaries with 'role' and 'content'
+            model: Model identifier to use
+            temperature: Sampling temperature (0-2)
+            max_tokens: Maximum number of tokens to generate
+            **kwargs: Additional parameters to pass to the API
+        
+        Returns:
+            Generated message content or None if an error occurs
+        """
+        try:
+            # Prepare parameters
+            params = {
+                "model": model,
+                "messages": messages,
+                "temperature": temperature,
+            }
+            
+            # Add max_tokens only if specified
+            if max_tokens is not None:
+                params["max_tokens"] = max_tokens
+                
+            # Add any additional kwargs
+            params.update(kwargs)
+            
+            # Make the API call using the inherited chat completions method
+            response: ChatCompletion = self.chat.completions.create(**params)
+            
+            # Extract the message content from the first choice
+            if response.choices and len(response.choices) > 0:
+                return response.choices[0].message.content
+            
+            return None
+
+        except openai.APIError as e:
+            print(f"OpenAI API Error: {str(e)}")
+            return None
+        except Exception as e:
+            print(f"Unexpected error: {str(e)}")
+            return None
+
+    def deepseek_chat(
+        self,
+        messages: List[Dict[str, str]],
+        model: str = "deepseek-chat",
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        **kwargs
+    ) -> Optional[str]:
+        """
+        Chat completion method for DeepSeek models.
+        
+        Args:
+            messages: List of message dictionaries with 'role' and 'content'
+            model: DeepSeek model identifier
+            temperature: Sampling temperature (0-2)
+            max_tokens: Maximum number of tokens to generate
+            **kwargs: Additional parameters to pass to the API
+        
+        Returns:
+            Generated message content or None if an error occurs
+        """
+        if not self.deepseek_api_key:
+            raise ValueError("DeepSeek API key is required for deepseek_chat")
+
+        try:
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {self.deepseek_api_key}",
+                "User-Agent": "DeepseekClient/1.0"
+            }
+            
+            data = {
+                "model": model,
+                "messages": messages,
+                "temperature": temperature,
+                "stream": False
+            }
+            
+            if max_tokens is not None:
+                data["max_tokens"] = max_tokens
+            
+            # Add any additional kwargs to the request data
+            data.update(kwargs)
+            
+            config = self.API_CONFIGS[ModelProvider.DEEPSEEK]
+            response = requests.post(
+                config.chat_endpoint,
+                headers=headers,
+                json=data,
+                verify=False,  # SSL検証を無効化（開発環境のみ）
+                timeout=(10, 60)  # 接続タイムアウト10秒、読み取りタイムアウト60秒に延長
+            )
+            # SSL検証を無効にした警告を抑制
+            import urllib3
+            urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+            
+            if response.status_code != 200:
+                error_msg = f"DeepSeek API request failed with status {response.status_code}"
+                try:
+                    error_data = response.json()
+                    print(f"[DEBUG] Error response: {error_data}")
+                    if "error" in error_data:
+                        error_msg += f": {error_data['error']}"
+                except Exception as e:
+                    print(f"[DEBUG] Failed to parse error response: {str(e)}")
+                raise ValueError(error_msg)
+            
+            response_data = response.json()
+            
+            if not response_data.get("choices"):
+                raise ValueError("No choices in DeepSeek API response")
+
+            return response_data["choices"][0]["message"]["content"]
+
+        except requests.exceptions.RequestException as e:
+            print(f"Network error during DeepSeek API call: {str(e)}")
+            return None
+        except ValueError as e:
+            print(f"DeepSeek API Error: {str(e)}")
+            return None
+        except Exception as e:
+            print(f"Unexpected error in DeepSeek chat: {str(e)}")
+            return None
+
+    def chat_with_retry(
+        self,
+        messages: List[Dict[str, str]],
+        provider: ModelProvider = ModelProvider.OPENAI,
+        max_retries: int = 3,
+        **kwargs
+    ) -> Optional[str]:
+        """
+        Chat completion with automatic retry on failure.
+        
+        Args:
+            messages: List of message dictionaries
+            provider: Model provider (OPENAI or DEEPSEEK)
+            max_retries: Maximum number of retry attempts
+            **kwargs: Additional parameters for chat methods
+        
+        Returns:
+            Generated message content or None if all retries fail
+        """
+        chat_method = self.simple_chat if provider == ModelProvider.OPENAI else self.deepseek_chat
+        
+        for attempt in range(max_retries):
+            try:
+                result = chat_method(messages, **kwargs)
+                if result is not None:
+                    return result
+            except Exception as e:
+                if attempt == max_retries - 1:
+                    print(f"Failed after {max_retries} attempts: {str(e)}")
+                    return None
+                print(f"Attempt {attempt + 1} failed, retrying...")
+        return None

deepseek_client.py

@@ -1,28 +1,36 @@
 import os
 from typing import List, Dict
 from config import Config
-from base_client import BaseClient
+from custom_openai_client import CustomOpenAI
 
-class DeepseekClient(BaseClient):
+class DeepseekClient(CustomOpenAI):
     def __init__(self, api_key=None, **kwargs):
         print(f"[DEBUG] Starting DeepseekClient")
-        super().__init__(
-            api_key=api_key or Config.get_deepseek_key(),
-            **kwargs
-        )
-        print(f"[DEBUG] API key configured")
+        try:
+            api_key = api_key or Config.get_deepseek_key()
+            print(f"[DEBUG] Using API key: {api_key[:4]}...")  # 最初の4文字のみ表示
+            super().__init__(
+                deepseek_api_key=api_key,
+                **kwargs
+            )
+            print(f"[DEBUG] API client initialized successfully")
+        except Exception as e:
+            print(f"[DEBUG] Initialization error: {str(e)}")
+            raise
 
     def create(self, messages: List[Dict[str, str]], model: str = None, **kwargs) -> str:
         print(f"[DEBUG] Starting DeepseekClient::create")
         print(f"[DEBUG] Model: {model or 'deepseek-chat'}")
-        print(f"[DEBUG] Messages: {messages}")
+        print(f"[DEBUG] Messages: {[{k: v for k, v in m.items()} for m in messages]}")
         
         try:
             result = self.deepseek_chat(messages=messages, model=model, **kwargs)
             if result:
                 print(f"[DEBUG] API request successful")
                 print(f"[DEBUG] Response: {result[:100]}...")  # Show first 100 chars of response
-            return result
+                return result
+            else:
+                raise Exception("No response from DeepSeek API")
         except Exception as e:
             print(f"[DEBUG] Error in create: {str(e)}")
             raise

test_deepseek.py

@@ -0,0 +1,27 @@
+from deepseek_client import DeepseekClient
+
+def test_deepseek():
+    try:
+        print("Creating DeepseekClient...")
+        client = DeepseekClient()
+        
+        messages = [
+            {
+                "role": "user",
+                "content": "こんにちは。あなたのモデルは何でしょうか？"
+            }
+        ]
+        print("\nSending test message...")
+        response = client.create(
+            messages=messages,
+            model="deepseek-chat-67b-alpha"
+        )
+        
+        print("\nResponse received:")
+        print(response)
+        
+    except Exception as e:
+        print(f"\nError occurred: {str(e)}")
+
+if __name__ == "__main__":
+    test_deepseek()