fix validate_api_key (#790)

Co-authored-by: sundebiao <[email protected]>

Author: suncade

lazyllm/module/llms/onlinemodule/supplier/deepseek.py

@@ -1,4 +1,5 @@
 from urllib.parse import urljoin
+import requests
 import lazyllm
 from ..base import OnlineChatModuleBase
 
@@ -14,3 +15,15 @@ def _get_system_prompt(self):
 
     def _set_chat_url(self):
         self._url = urljoin(self._base_url, 'chat/completions')
+
+    def _validate_api_key(self):
+        try:
+            models_url = urljoin(self._base_url, 'models')
+            headers = {
+                'Authorization': f'Bearer {self._api_key}',
+                'Content-Type': 'application/json'
+            }
+            response = requests.get(models_url, headers=headers, timeout=10)
+            return response.status_code == 200
+        except Exception:
+            return False

lazyllm/module/llms/onlinemodule/supplier/doubao.py

@@ -24,6 +24,24 @@ def _get_system_prompt(self):
     def _set_chat_url(self):
         self._url = urljoin(self._base_url, 'chat/completions')
 
+    def _validate_api_key(self):
+        '''Validate API Key by sending a minimal request'''
+        try:
+            # Doubao (Volcano Engine) validates API key using a minimal chat request
+            chat_url = urljoin(self._base_url, 'chat/completions')
+            headers = {
+                'Authorization': f'Bearer {self._api_key}',
+                'Content-Type': 'application/json'
+            }
+            data = {
+                'model': self._model_name,
+                'messages': [{'role': 'user', 'content': 'hi'}],
+                'max_tokens': 1  # Only generate 1 token for validation
+            }
+            response = requests.post(chat_url, headers=headers, json=data, timeout=10)
+            return response.status_code == 200
+        except Exception:
+            return False
 
 class DoubaoEmbedding(OnlineEmbeddingModuleBase):
     def __init__(self,
@@ -47,7 +65,7 @@ def _encapsulated_data(self, input: Union[List, str], **kwargs) -> Dict[str, str
         if isinstance(input, str):
             input = [{'text': input}]
         elif isinstance(input, list):
-            # 验证输入格式，最多为1段文本+1张图片
+            # Validate input format, at most 1 text segment + 1 image
             if len(input) == 0:
                 raise ValueError('Input list cannot be empty')
             if len(input) > 2:
@@ -65,7 +83,7 @@ def _encapsulated_data(self, input: Union[List, str], **kwargs) -> Dict[str, str
         return json_data
 
     def _parse_response(self, response: Dict, input: Union[List, str]) -> List[float]:
-        # 豆包多模态Embedding返回融合的单个embedding
+        # Doubao multimodal embedding returns a single fused embedding
         return response['data']['embedding']
 
 

lazyllm/module/llms/onlinemodule/supplier/kimi.py

@@ -1,5 +1,6 @@
 import lazyllm
 from urllib.parse import urljoin
+import requests
 from ..base import OnlineChatModuleBase
 
 class KimiModule(OnlineChatModuleBase):
@@ -28,3 +29,15 @@ def _format_vl_chat_image_url(self, image_url, mime):
 
     def _format_vl_chat_query(self, query: str):
         return query
+
+    def _validate_api_key(self):
+        try:
+            models_url = urljoin(self._base_url, 'v1/models')
+            headers = {
+                'Authorization': f'Bearer {self._api_key}',
+                'Content-Type': 'application/json'
+            }
+            response = requests.get(models_url, headers=headers, timeout=10)
+            return response.status_code == 200
+        except Exception:
+            return False

tests/charge_tests/test_validate_api_key.py

@@ -0,0 +1,148 @@
+import pytest
+import os
+from lazyllm.module.llms.onlinemodule.supplier.deepseek import DeepSeekModule
+from lazyllm.module.llms.onlinemodule.supplier.doubao import DoubaoModule
+from lazyllm.module.llms.onlinemodule.supplier.kimi import KimiModule
+from lazyllm.module.llms.onlinemodule.supplier.openai import OpenAIModule
+from lazyllm.module.llms.onlinemodule.supplier.glm import GLMModule
+from lazyllm.module.llms.onlinemodule.supplier.qwen import QwenModule
+from lazyllm.module.llms.onlinemodule.supplier.sensenova import SenseNovaModule
+
+
+class TestValidateApiKey:
+    '''Test online model API Key validation functionality'''
+
+    def setup_method(self):
+        '''Initialize test environment, get API Keys from environment variables'''
+        self.api_keys = {
+            'deepseek': os.getenv('LAZYLLM_DEEPSEEK_API_KEY'),
+            'doubao': os.getenv('LAZYLLM_DOUBAO_API_KEY'),
+            'kimi': os.getenv('LAZYLLM_KIMI_API_KEY'),
+            'openai': os.getenv('LAZYLLM_OPENAI_API_KEY'),
+            'glm': os.getenv('LAZYLLM_GLM_API_KEY'),
+            'qwen': os.getenv('LAZYLLM_QWEN_API_KEY'),
+            'sensenova': os.getenv('LAZYLLM_SENSENOVA_API_KEY'),
+        }
+        # Get sensenova secret key
+        self.sensenova_secret_key = os.getenv('LAZYLLM_SENSENOVA_SECRET_KEY')
+        # Get doubao model name (if set in environment variables)
+        self.doubao_model_name = os.getenv('LAZYLLM_DOUBAO_MODEL_NAME')
+
+    def test_deepseek_validate_valid_api_key(self):
+        '''Test DeepSeek valid API Key validation'''
+        if not self.api_keys['deepseek']:
+            pytest.skip('LAZYLLM_DEEPSEEK_API_KEY environment variable is not set')
+
+        module = DeepSeekModule(api_key=self.api_keys['deepseek'])
+        result = module._validate_api_key()
+        assert result is True, 'DeepSeek valid API Key should pass validation'
+
+    def test_deepseek_validate_invalid_api_key(self):
+        '''Test DeepSeek invalid API Key validation'''
+        module = DeepSeekModule(api_key='invalid_api_key_12345')
+        result = module._validate_api_key()
+        assert result is False, 'DeepSeek invalid API Key should fail validation'
+
+    def test_doubao_validate_valid_api_key(self):
+        '''Test Doubao valid API Key validation'''
+        if not self.api_keys['doubao']:
+            pytest.skip('LAZYLLM_DOUBAO_API_KEY environment variable is not set')
+
+        # If model name is set in environment variables, use it; otherwise use default
+        if self.doubao_model_name:
+            module = DoubaoModule(
+                api_key=self.api_keys['doubao'],
+                model=self.doubao_model_name
+            )
+        else:
+            module = DoubaoModule(api_key=self.api_keys['doubao'])
+
+        result = module._validate_api_key()
+        assert result is True, 'Doubao valid API Key should pass validation'
+
+    def test_doubao_validate_invalid_api_key(self):
+        '''Test Doubao invalid API Key validation'''
+        module = DoubaoModule(api_key='invalid_api_key_12345')
+        result = module._validate_api_key()
+        assert result is False, 'Doubao invalid API Key should fail validation'
+
+    def test_kimi_validate_valid_api_key(self):
+        '''Test Kimi valid API Key validation'''
+        if not self.api_keys['kimi']:
+            pytest.skip('LAZYLLM_KIMI_API_KEY environment variable is not set')
+
+        module = KimiModule(api_key=self.api_keys['kimi'])
+        result = module._validate_api_key()
+        assert result is True, 'Kimi valid API Key should pass validation'
+
+    def test_kimi_validate_invalid_api_key(self):
+        '''Test Kimi invalid API Key validation'''
+        module = KimiModule(api_key='invalid_api_key_12345')
+        result = module._validate_api_key()
+        assert result is False, 'Kimi invalid API Key should fail validation'
+
+    def test_openai_validate_valid_api_key(self):
+        '''Test OpenAI valid API Key validation'''
+        if not self.api_keys['openai']:
+            pytest.skip('LAZYLLM_OPENAI_API_KEY environment variable is not set')
+
+        module = OpenAIModule(api_key=self.api_keys['openai'])
+        result = module._validate_api_key()
+        assert result is True, 'OpenAI valid API Key should pass validation'
+
+    def test_openai_validate_invalid_api_key(self):
+        '''Test OpenAI invalid API Key validation'''
+        module = OpenAIModule(api_key='invalid_api_key_12345')
+        result = module._validate_api_key()
+        assert result is False, 'OpenAI invalid API Key should fail validation'
+
+    def test_glm_validate_valid_api_key(self):
+        '''Test GLM valid API Key validation'''
+        if not self.api_keys['glm']:
+            pytest.skip('LAZYLLM_GLM_API_KEY environment variable is not set')
+
+        module = GLMModule(api_key=self.api_keys['glm'])
+        result = module._validate_api_key()
+        assert result is True, 'GLM valid API Key should pass validation'
+
+    def test_glm_validate_invalid_api_key(self):
+        '''Test GLM invalid API Key validation'''
+        module = GLMModule(api_key='invalid_api_key_12345')
+        result = module._validate_api_key()
+        assert result is False, 'GLM invalid API Key should fail validation'
+
+    def test_qwen_validate_valid_api_key(self):
+        '''Test Qwen valid API Key validation'''
+        if not self.api_keys['qwen']:
+            pytest.skip('LAZYLLM_QWEN_API_KEY environment variable is not set')
+
+        module = QwenModule(api_key=self.api_keys['qwen'])
+        result = module._validate_api_key()
+        assert result is True, 'Qwen valid API Key should pass validation'
+
+    def test_qwen_validate_invalid_api_key(self):
+        '''Test Qwen invalid API Key validation'''
+        module = QwenModule(api_key='invalid_api_key_12345')
+        result = module._validate_api_key()
+        assert result is False, 'Qwen invalid API Key should fail validation'
+
+    def test_sensenova_validate_valid_api_key(self):
+        '''Test SenseNova valid API Key validation'''
+        if not self.api_keys['sensenova'] or not self.sensenova_secret_key:
+            pytest.skip('LAZYLLM_SENSENOVA_API_KEY or LAZYLLM_SENSENOVA_SECRET_KEY environment variable is not set')
+
+        module = SenseNovaModule(
+            api_key=self.api_keys['sensenova'],
+            secret_key=self.sensenova_secret_key
+        )
+        result = module._validate_api_key()
+        assert result is True, 'SenseNova valid API Key should pass validation'
+
+    def test_sensenova_validate_invalid_api_key(self):
+        '''Test SenseNova invalid API Key validation'''
+        module = SenseNovaModule(
+            api_key='invalid_api_key_12345',
+            secret_key='invalid_secret_key_12345'
+        )
+        result = module._validate_api_key()
+        assert result is False, 'SenseNova invalid API Key should fail validation'