yaicli 0.6.0__tar.gz → 0.6.2__tar.gz

{yaicli-0.6.0 → yaicli-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yaicli
-Version: 0.6.0
+Version: 0.6.2
 Summary: A simple CLI tool to interact with LLM
 Project-URL: Homepage, https://github.com/belingud/yaicli
 Project-URL: Repository, https://github.com/belingud/yaicli
@@ -375,7 +375,7 @@ settings, just as below:
 ```ini
 [core]
 PROVIDER=openai
-BASE_URL=https://api.openai.com/v1
+BASE_URL=
 API_KEY=
 MODEL=gpt-4o
 
@@ -387,7 +387,7 @@ OS_NAME=auto
 STREAM=true
 
 # LLM parameters
-TEMPERATURE=0.5
+TEMPERATURE=0.3
 TOP_P=1.0
 MAX_TOKENS=1024
 TIMEOUT=60
@@ -518,6 +518,14 @@ API_KEY=
 MODEL=llama-3.3-70b-versatile
 ```
 
+#### XAI
+
+```ini
+PROVIDER=xai
+API_KEY=
+MODEL=grok-3
+```
+
 #### Chatglm
 
 ```ini

{yaicli-0.6.0 → yaicli-0.6.2}/README.md

@@ -138,7 +138,7 @@ settings, just as below:
 ```ini
 [core]
 PROVIDER=openai
-BASE_URL=https://api.openai.com/v1
+BASE_URL=
 API_KEY=
 MODEL=gpt-4o
 
@@ -150,7 +150,7 @@ OS_NAME=auto
 STREAM=true
 
 # LLM parameters
-TEMPERATURE=0.5
+TEMPERATURE=0.3
 TOP_P=1.0
 MAX_TOKENS=1024
 TIMEOUT=60
@@ -281,6 +281,14 @@ API_KEY=
 MODEL=llama-3.3-70b-versatile
 ```
 
+#### XAI
+
+```ini
+PROVIDER=xai
+API_KEY=
+MODEL=grok-3
+```
+
 #### Chatglm
 
 ```ini

{yaicli-0.6.0 → yaicli-0.6.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yaicli"
-version = "0.6.0"
+version = "0.6.2"
 description = "A simple CLI tool to interact with LLM"
 authors = [{ name = "belingud", email = "im.victor@qq.com" }]
 readme = "README.md"

{yaicli-0.6.0 → yaicli-0.6.2}/yaicli/llms/provider.py

@@ -9,7 +9,7 @@ class Provider(ABC):
     """Base abstract class for LLM providers"""
 
     APP_NAME = "yaicli"
-    APPA_REFERER = "https://github.com/halfrost/yaicli"
+    APP_REFERER = "https://github.com/halfrost/yaicli"
 
     @abstractmethod
     def completion(
@@ -39,21 +39,24 @@ class ProviderFactory:
     """Factory to create LLM provider instances"""
 
     providers_map = {
-        "openai": (".providers.openai_provider", "OpenAIProvider"),
-        "modelscope": (".providers.modelscope_provider", "ModelScopeProvider"),
+        "ai21": (".providers.ai21_provider", "AI21Provider"),
         "chatglm": (".providers.chatglm_provider", "ChatglmProvider"),
-        "openrouter": (".providers.openrouter_provider", "OpenRouterProvider"),
-        "siliconflow": (".providers.siliconflow_provider", "SiliconFlowProvider"),
         "chutes": (".providers.chutes_provider", "ChutesProvider"),
-        "infini-ai": (".providers.infiniai_provider", "InfiniAIProvider"),
-        "yi": (".providers.yi_provider", "YiProvider"),
+        "cohere": (".providers.cohere_provider", "CohereProvider"),
         "deepseek": (".providers.deepseek_provider", "DeepSeekProvider"),
         "doubao": (".providers.doubao_provider", "DoubaoProvider"),
         "groq": (".providers.groq_provider", "GroqProvider"),
-        "ai21": (".providers.ai21_provider", "AI21Provider"),
+        "infini-ai": (".providers.infiniai_provider", "InfiniAIProvider"),
+        "minimax": (".providers.minimax_provider", "MinimaxProvider"),
+        "modelscope": (".providers.modelscope_provider", "ModelScopeProvider"),
         "ollama": (".providers.ollama_provider", "OllamaProvider"),
-        "cohere": (".providers.cohere_provider", "CohereProvider"),
+        "openai": (".providers.openai_provider", "OpenAIProvider"),
+        "openrouter": (".providers.openrouter_provider", "OpenRouterProvider"),
         "sambanova": (".providers.sambanova_provider", "SambanovaProvider"),
+        "siliconflow": (".providers.siliconflow_provider", "SiliconFlowProvider"),
+        "targon": (".providers.targon_provider", "TargonProvider"),
+        "xai": (".providers.xai_provider", "XaiProvider"),
+        "yi": (".providers.yi_provider", "YiProvider"),
     }
 
     @classmethod

{yaicli-0.6.0 → yaicli-0.6.2}/yaicli/llms/providers/ai21_provider.py

@@ -1,4 +1,4 @@
-from typing import Generator, Optional
+from typing import Dict, Generator, Optional
 
 from openai._streaming import Stream
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
@@ -12,9 +12,18 @@ class AI21Provider(OpenAIProvider):
 
     DEFAULT_BASE_URL = "https://api.ai21.com/studio/v1"
 
-    def __init__(self, config: dict = ..., **kwargs):
-        super().__init__(config, **kwargs)
-        self.completion_params["max_tokens"] = self.completion_params.pop("max_completion_tokens")
+    def get_completion_params_keys(self) -> Dict[str, str]:
+        """
+        Customize completion parameter keys for AI21 API.
+        Maps 'max_completion_tokens' to 'max_tokens' for compatibility.
+
+        Returns:
+            Dict[str, str]: Modified parameter mapping dictionary
+        """
+        keys = super().get_completion_params_keys()
+        if "max_completion_tokens" in keys:
+            keys["max_tokens"] = keys.pop("max_completion_tokens")
+        return keys
 
     def _handle_stream_response(self, response: Stream[ChatCompletionChunk]) -> Generator[LLMResponse, None, None]:
         """Handle streaming response from AI21 models

{yaicli-0.6.0 → yaicli-0.6.2}/yaicli/llms/providers/chatglm_provider.py

@@ -1,5 +1,5 @@
 import json
-from typing import Generator, Optional
+from typing import Any, Dict, Generator, Optional
 
 from openai._streaming import Stream
 from openai.types.chat.chat_completion import ChatCompletion, Choice
@@ -14,6 +14,11 @@ class ChatglmProvider(OpenAIProvider):
 
     DEFAULT_BASE_URL = "https://open.bigmodel.cn/api/paas/v4/"
 
+    def get_completion_params(self) -> Dict[str, Any]:
+        params = super().get_completion_params()
+        params["max_tokens"] = params.pop("max_completion_tokens")
+        return params
+
     def _handle_normal_response(self, response: ChatCompletion) -> Generator[LLMResponse, None, None]:
         """Handle normal (non-streaming) response
         Support both openai capabilities and chatglm

yaicli-0.6.2/yaicli/llms/providers/chutes_provider.py

@@ -0,0 +1,24 @@
+from .openai_provider import OpenAIProvider
+
+
+class ChutesProvider(OpenAIProvider):
+    """Chutes provider implementation based on openai-compatible API"""
+
+    DEFAULT_BASE_URL = "https://llm.chutes.ai/v1"
+
+    def get_completion_params_keys(self) -> dict:
+        """
+        Customize completion parameter keys for Chutes API.
+        Maps 'max_completion_tokens' to 'max_tokens' and removes 'reasoning_effort'
+        which is not supported by this provider.
+
+        Returns:
+            dict: Modified parameter mapping dictionary
+        """
+        keys = super().get_completion_params_keys()
+        # Replace max_completion_tokens with max_tokens in the API
+        if "max_completion_tokens" in keys:
+            keys["max_tokens"] = keys.pop("max_completion_tokens")
+        # Remove unsupported parameters
+        keys.pop("reasoning_effort", None)
+        return keys

yaicli-0.6.2/yaicli/llms/providers/deepseek_provider.py

@@ -0,0 +1,14 @@
+from typing import Any, Dict
+
+from .openai_provider import OpenAIProvider
+
+
+class DeepSeekProvider(OpenAIProvider):
+    """DeepSeek provider implementation based on openai-compatible API"""
+
+    DEFAULT_BASE_URL = "https://api.deepseek.com/v1"
+
+    def get_completion_params(self) -> Dict[str, Any]:
+        params = super().get_completion_params()
+        params["max_tokens"] = params.pop("max_completion_tokens")
+        return params

{yaicli-0.6.0 → yaicli-0.6.2}/yaicli/llms/providers/doubao_provider.py

@@ -1,3 +1,5 @@
+from typing import Any, Dict
+
 from volcenginesdkarkruntime import Ark
 
 from ...config import cfg
@@ -9,43 +11,43 @@ class DoubaoProvider(OpenAIProvider):
     """Doubao provider implementation based on openai-compatible API"""
 
     DEFAULT_BASE_URL = "https://ark.cn-beijing.volces.com/api/v3"
+    CLIENT_CLS = Ark
 
     def __init__(self, config: dict = cfg, **kwargs):
         self.config = config
         self.enable_function = self.config["ENABLE_FUNCTIONS"]
+        self.client_params = self.get_client_params()
+
+        # Initialize client
+        self.client = self.CLIENT_CLS(**self.client_params)
+        self.console = get_console()
+
+        # Store completion params
+        self.completion_params = self.get_completion_params()
+
+    def get_client_params(self) -> Dict[str, Any]:
         # Initialize client params
-        self.client_params = {"base_url": self.DEFAULT_BASE_URL}
+        client_params = {"base_url": self.DEFAULT_BASE_URL}
         if self.config.get("API_KEY", None):
-            self.client_params["api_key"] = self.config["API_KEY"]
+            client_params["api_key"] = self.config["API_KEY"]
         if self.config.get("BASE_URL", None):
-            self.client_params["base_url"] = self.config["BASE_URL"]
+            client_params["base_url"] = self.config["BASE_URL"]
         if self.config.get("AK", None):
-            self.client_params["ak"] = self.config["AK"]
+            client_params["ak"] = self.config["AK"]
         if self.config.get("SK", None):
-            self.client_params["sk"] = self.config["SK"]
+            client_params["sk"] = self.config["SK"]
         if self.config.get("REGION", None):
-            self.client_params["region"] = self.config["REGION"]
+            client_params["region"] = self.config["REGION"]
+        return client_params
 
-        # Initialize client
-        self.client = Ark(**self.client_params)
-        self.console = get_console()
-
-        # Store completion params
-        self.completion_params = {
+    def get_completion_params(self) -> Dict[str, Any]:
+        params = {
             "model": self.config["MODEL"],
             "temperature": self.config["TEMPERATURE"],
             "top_p": self.config["TOP_P"],
             "max_tokens": self.config["MAX_TOKENS"],
             "timeout": self.config["TIMEOUT"],
         }
-        # Add extra headers if set
-        if self.config.get("EXTRA_HEADERS", None):
-            self.completion_params["extra_headers"] = {
-                **self.config["EXTRA_HEADERS"],
-                "X-Title": self.APP_NAME,
-                "HTTP-Referer": self.APPA_REFERER,
-            }
-
-        # Add extra body params if set
         if self.config.get("EXTRA_BODY", None):
-            self.completion_params["extra_body"] = self.config["EXTRA_BODY"]
+            params["extra_body"] = self.config["EXTRA_BODY"]
+        return params

yaicli-0.6.2/yaicli/llms/providers/groq_provider.py

@@ -0,0 +1,36 @@
+from typing import Any, Dict
+
+from .openai_provider import OpenAIProvider
+
+
+class GroqProvider(OpenAIProvider):
+    """Groq provider implementation based on openai-compatible API"""
+
+    DEFAULT_BASE_URL = "https://api.groq.com/openai/v1"
+
+    def get_completion_params_keys(self) -> Dict[str, str]:
+        """
+        Customize completion parameter keys for Groq API.
+        Maps 'max_completion_tokens' to 'max_tokens' for compatibility.
+
+        Returns:
+            Dict[str, str]: Modified parameter mapping dictionary
+        """
+        keys = super().get_completion_params_keys()
+        if "max_completion_tokens" in keys:
+            keys["max_tokens"] = keys.pop("max_completion_tokens")
+        return keys
+
+    def get_completion_params(self) -> Dict[str, Any]:
+        """
+        Get completion parameters with Groq-specific adjustments.
+        Enforce N=1 as Groq doesn't support multiple completions.
+
+        Returns:
+            Dict[str, Any]: Parameters for completion API call
+        """
+        params = super().get_completion_params()
+        if self.config["EXTRA_BODY"] and "N" in self.config["EXTRA_BODY"] and self.config["EXTRA_BODY"]["N"] != 1:
+            self.console.print("Groq does not support N parameter, setting N to 1 as Groq default", style="yellow")
+            params["extra_body"]["N"] = 1
+        return params

{yaicli-0.6.0 → yaicli-0.6.2}/yaicli/llms/providers/infiniai_provider.py

@@ -1,3 +1,5 @@
+from typing import Any, Dict
+
 from .openai_provider import OpenAIProvider
 
 
@@ -11,4 +13,8 @@ class InfiniAIProvider(OpenAIProvider):
         if self.enable_function:
             self.console.print("InfiniAI does not support functions, disabled", style="yellow")
         self.enable_function = False
-        self.completion_params["max_tokens"] = self.completion_params.pop("max_completion_tokens")
+
+    def get_completion_params(self) -> Dict[str, Any]:
+        params = super().get_completion_params()
+        params["max_tokens"] = params.pop("max_completion_tokens")
+        return params

yaicli-0.6.2/yaicli/llms/providers/minimax_provider.py

@@ -0,0 +1,21 @@
+from .openai_provider import OpenAIProvider
+
+
+class MinimaxProvider(OpenAIProvider):
+    """Minimax provider implementation based on openai-compatible API"""
+
+    DEFAULT_BASE_URL = "https://api.minimaxi.com/v1"
+
+    def get_completion_params_keys(self) -> dict:
+        """
+        Customize completion parameter keys for Minimax API.
+        Maps 'max_completion_tokens' to 'max_tokens' for compatibility.
+
+        Returns:
+            dict: Modified parameter mapping dictionary
+        """
+        keys = super().get_completion_params_keys()
+        # Replace max_completion_tokens with max_tokens in the API
+        if "max_completion_tokens" in keys:
+            keys["max_tokens"] = keys.pop("max_completion_tokens")
+        return keys

{yaicli-0.6.0 → yaicli-0.6.2}/yaicli/llms/providers/modelscope_provider.py

@@ -1,3 +1,5 @@
+from typing import Any, Dict
+
 from .openai_provider import OpenAIProvider
 
 
@@ -6,6 +8,7 @@ class ModelScopeProvider(OpenAIProvider):
 
     DEFAULT_BASE_URL = "https://api-inference.modelscope.cn/v1/"
 
-    def __init__(self, config: dict = ..., **kwargs):
-        super().__init__(config, **kwargs)
-        self.completion_params["max_tokens"] = self.completion_params.pop("max_completion_tokens")
+    def get_completion_params(self) -> Dict[str, Any]:
+        params = super().get_completion_params()
+        params["max_tokens"] = params.pop("max_completion_tokens")
+        return params

{yaicli-0.6.0 → yaicli-0.6.2}/yaicli/llms/providers/openai_provider.py

@@ -1,3 +1,4 @@
+import json
 from typing import Any, Dict, Generator, List, Optional
 
 import openai
@@ -16,41 +17,73 @@ class OpenAIProvider(Provider):
     """OpenAI provider implementation based on openai library"""
 
     DEFAULT_BASE_URL = "https://api.openai.com/v1"
+    CLIENT_CLS = openai.OpenAI
+    # Base mapping between config keys and API parameter names
+    _BASE_COMPLETION_PARAMS_KEYS = {
+        "model": "MODEL",
+        "temperature": "TEMPERATURE",
+        "top_p": "TOP_P",
+        "max_completion_tokens": "MAX_TOKENS",
+        "timeout": "TIMEOUT",
+        "extra_body": "EXTRA_BODY",
+        "reasoning_effort": "REASONING_EFFORT",
+    }
 
     def __init__(self, config: dict = cfg, verbose: bool = False, **kwargs):
         self.config = config
+        if not self.config.get("API_KEY"):
+            raise ValueError("API_KEY is required")
         self.enable_function = self.config["ENABLE_FUNCTIONS"]
         self.verbose = verbose
+
+        # Initialize client
+        self.client_params = self.get_client_params()
+        self.client = self.CLIENT_CLS(**self.client_params)
+        self.console = get_console()
+
+        # Store completion params
+        self.completion_params = self.get_completion_params()
+
+    def get_client_params(self) -> Dict[str, Any]:
+        """Get the client parameters"""
         # Initialize client params
-        self.client_params = {
+        client_params = {
             "api_key": self.config["API_KEY"],
             "base_url": self.config["BASE_URL"] or self.DEFAULT_BASE_URL,
         }
 
         # Add extra headers if set
         if self.config["EXTRA_HEADERS"]:
-            self.client_params["default_headers"] = {
+            client_params["default_headers"] = {
                 **self.config["EXTRA_HEADERS"],
                 "X-Title": self.APP_NAME,
-                "HTTP-Referer": self.APPA_REFERER,
+                "HTTP-Referer": self.APP_REFERER,
             }
-
-        # Initialize client
-        self.client = openai.OpenAI(**self.client_params)
-        self.console = get_console()
-
-        # Store completion params
-        self.completion_params = {
-            "model": self.config["MODEL"],
-            "temperature": self.config["TEMPERATURE"],
-            "top_p": self.config["TOP_P"],
-            "max_completion_tokens": self.config["MAX_TOKENS"],
-            "timeout": self.config["TIMEOUT"],
-        }
-
-        # Add extra body params if set
-        if self.config["EXTRA_BODY"]:
-            self.completion_params["extra_body"] = self.config["EXTRA_BODY"]
+        return client_params
+
+    def get_completion_params_keys(self) -> Dict[str, str]:
+        """
+        Get the mapping between completion parameter keys and config keys.
+        Subclasses can override this method to customize parameter mapping.
+
+        Returns:
+            Dict[str, str]: Mapping from API parameter names to config keys
+        """
+        return self._BASE_COMPLETION_PARAMS_KEYS.copy()
+
+    def get_completion_params(self) -> Dict[str, Any]:
+        """
+        Get the completion parameters based on config and parameter mapping.
+
+        Returns:
+            Dict[str, Any]: Parameters for completion API call
+        """
+        completion_params = {}
+        params_keys = self.get_completion_params_keys()
+        for api_key, config_key in params_keys.items():
+            if self.config.get(config_key, None) is not None:
+                completion_params[api_key] = self.config[config_key]
+        return completion_params
 
     def _convert_messages(self, messages: List[ChatMessage]) -> List[Dict[str, Any]]:
         """Convert a list of ChatMessage objects to a list of OpenAI message dicts."""
@@ -79,7 +112,20 @@ class OpenAIProvider(Provider):
         messages: List[ChatMessage],
         stream: bool = False,
     ) -> Generator[LLMResponse, None, None]:
-        """Send completion request to OpenAI and return responses"""
+        """
+            Send completion request to OpenAI and return responses.
+
+        Args:
+            messages: List of chat messages to send
+            stream: Whether to stream the response
+
+        Yields:
+            LLMResponse: Response objects containing content, tool calls, etc.
+
+        Raises:
+            ValueError: If messages is empty or invalid
+            openai.APIError: If API request fails
+        """
         openai_messages = self._convert_messages(messages)
         if self.verbose:
             self.console.print("Messages:")
@@ -103,6 +149,11 @@ class OpenAIProvider(Provider):
 
     def _handle_normal_response(self, response: ChatCompletion) -> Generator[LLMResponse, None, None]:
         """Handle normal (non-streaming) response"""
+        if not response.choices:
+            yield LLMResponse(
+                content=json.dumps(getattr(response, "base_resp", None) or response.to_dict()), finish_reason="stop"
+            )
+            return
         choice = response.choices[0]
         content = choice.message.content or ""  # type: ignore
         reasoning = choice.message.reasoning_content  # type: ignore
@@ -124,15 +175,22 @@ class OpenAIProvider(Provider):
         """Handle streaming response from OpenAI API"""
         # Initialize tool call object to accumulate tool call data across chunks
         tool_call: Optional[ToolCall] = None
-
+        started = False
         # Process each chunk in the response stream
         for chunk in response:
-            if not chunk.choices:
+            if not chunk.choices and not started:
+                # Some api could return error message in the first chunk, no choices to handle, return raw response to show the message
+                yield LLMResponse(
+                    content=json.dumps(getattr(chunk, "base_resp", None) or chunk.to_dict()), finish_reason="stop"
+                )
+                started = True
                 continue
 
-            choice = chunk.choices[0]
-            delta = choice.delta
-            finish_reason = choice.finish_reason
+            if not chunk.choices:
+                continue
+            started = True
+            delta = chunk.choices[0].delta
+            finish_reason = chunk.choices[0].finish_reason
 
             # Extract content from current chunk
             content = delta.content or ""

yaicli-0.6.2/yaicli/llms/providers/openrouter_provider.py

@@ -0,0 +1,22 @@
+from typing import Dict
+
+from .openai_provider import OpenAIProvider
+
+
+class OpenRouterProvider(OpenAIProvider):
+    """OpenRouter provider implementation based on openai-compatible API"""
+
+    DEFAULT_BASE_URL = "https://openrouter.ai/api/v1"
+
+    def get_completion_params_keys(self) -> Dict[str, str]:
+        """
+        Customize completion parameter keys for OpenRouter API.
+        Maps 'max_completion_tokens' to 'max_tokens' for compatibility.
+
+        Returns:
+            Dict[str, str]: Modified parameter mapping dictionary
+        """
+        keys = super().get_completion_params_keys()
+        if "max_completion_tokens" in keys:
+            keys["max_tokens"] = keys.pop("max_completion_tokens")
+        return keys

yaicli-0.6.2/yaicli/llms/providers/sambanova_provider.py

@@ -0,0 +1,59 @@
+from typing import Any, Dict
+
+from ...const import DEFAULT_TEMPERATURE
+from .openai_provider import OpenAIProvider
+
+
+class SambanovaProvider(OpenAIProvider):
+    """Sambanova provider implementation based on OpenAI API"""
+
+    DEFAULT_BASE_URL = "https://api.sambanova.ai/v1"
+    SUPPORT_FUNCTION_CALL_MOELS = (
+        "Meta-Llama-3.1-8B-Instruct",
+        "Meta-Llama-3.1-405B-Instruct",
+        "Meta-Llama-3.3-70B-Instruct",
+        "Llama-4-Scout-17B-16E-Instruct",
+        "DeepSeek-V3-0324",
+    )
+
+    def get_completion_params_keys(self) -> Dict[str, str]:
+        """
+        Customize completion parameter keys for Sambanova API.
+        Maps 'max_completion_tokens' to 'max_tokens' for compatibility
+        and removes parameters not supported by Sambanova.
+
+        Returns:
+            Dict[str, str]: Modified parameter mapping dictionary
+        """
+        keys = super().get_completion_params_keys()
+        # Replace max_completion_tokens with max_tokens
+        if "max_completion_tokens" in keys:
+            keys["max_tokens"] = keys.pop("max_completion_tokens")
+        # Remove unsupported parameters
+        keys.pop("presence_penalty", None)
+        keys.pop("frequency_penalty", None)
+        return keys
+
+    def get_completion_params(self) -> Dict[str, Any]:
+        """
+        Get completion parameters with Sambanova-specific adjustments.
+        Validate temperature range and check for function call compatibility.
+
+        Returns:
+            Dict[str, Any]: Parameters for completion API call
+        """
+        params = super().get_completion_params()
+
+        # Validate temperature
+        if params.get("temperature") is not None and (params["temperature"] < 0 or params["temperature"] > 1):
+            self.console.print("Sambanova temperature must be between 0 and 1, setting to 0.4", style="yellow")
+            params["temperature"] = DEFAULT_TEMPERATURE
+
+        # Check function call compatibility
+        if self.enable_function and self.config["MODEL"] not in self.SUPPORT_FUNCTION_CALL_MOELS:
+            self.console.print(
+                f"Sambanova supports function call models: {', '.join(self.SUPPORT_FUNCTION_CALL_MOELS)}",
+                style="yellow",
+            )
+
+        return params

{yaicli-0.6.0 → yaicli-0.6.2}/yaicli/llms/providers/siliconflow_provider.py

@@ -1,3 +1,5 @@
+from typing import Any, Dict
+
 from .openai_provider import OpenAIProvider
 
 
@@ -6,6 +8,7 @@ class SiliconFlowProvider(OpenAIProvider):
 
     DEFAULT_BASE_URL = "https://api.siliconflow.cn/v1"
 
-    def __init__(self, config: dict = ..., **kwargs):
-        super().__init__(config, **kwargs)
-        self.completion_params["max_tokens"] = self.completion_params.pop("max_completion_tokens")
+    def get_completion_params(self) -> Dict[str, Any]:
+        params = super().get_completion_params()
+        params["max_tokens"] = params.pop("max_completion_tokens")
+        return params

yaicli-0.6.2/yaicli/llms/providers/targon_provider.py

@@ -0,0 +1,22 @@
+from typing import Dict
+
+from .openai_provider import OpenAIProvider
+
+
+class TargonProvider(OpenAIProvider):
+    """Targon provider implementation based on openai-compatible API"""
+
+    DEFAULT_BASE_URL = "https://api.targon.com/v1"
+
+    def get_completion_params_keys(self) -> Dict[str, str]:
+        """
+        Customize completion parameter keys for Targon API.
+        Maps 'max_completion_tokens' to 'max_tokens' for compatibility.
+
+        Returns:
+            Dict[str, str]: Modified parameter mapping dictionary
+        """
+        keys = super().get_completion_params_keys()
+        if "max_completion_tokens" in keys:
+            keys["max_tokens"] = keys.pop("max_completion_tokens")
+        return keys

yaicli-0.6.2/yaicli/llms/providers/xai_provider.py

@@ -0,0 +1,7 @@
+from .openai_provider import OpenAIProvider
+
+
+class XaiProvider(OpenAIProvider):
+    """Xai provider implementation based on openai-compatible API"""
+
+    DEFAULT_BASE_URL = "https://api.xai.com/v1"

yaicli-0.6.2/yaicli/llms/providers/yi_provider.py

@@ -0,0 +1,22 @@
+from typing import Dict
+
+from .openai_provider import OpenAIProvider
+
+
+class YiProvider(OpenAIProvider):
+    """Lingyiwanwu provider implementation based on openai-compatible API"""
+
+    DEFAULT_BASE_URL = "https://api.lingyiwanwu.com/v1"
+
+    def get_completion_params_keys(self) -> Dict[str, str]:
+        """
+        Customize completion parameter keys for Yi API.
+        Maps 'max_completion_tokens' to 'max_tokens' for compatibility.
+
+        Returns:
+            Dict[str, str]: Modified parameter mapping dictionary
+        """
+        keys = super().get_completion_params_keys()
+        if "max_completion_tokens" in keys:
+            keys["max_tokens"] = keys.pop("max_completion_tokens")
+        return keys

yaicli-0.6.0/yaicli/llms/providers/chutes_provider.py

@@ -1,7 +0,0 @@
-from .openai_provider import OpenAIProvider
-
-
-class ChutesProvider(OpenAIProvider):
-    """Chutes provider implementation based on openai-compatible API"""
-
-    DEFAULT_BASE_URL = "https://llm.chutes.ai/v1"

yaicli-0.6.0/yaicli/llms/providers/deepseek_provider.py

@@ -1,11 +0,0 @@
-from .openai_provider import OpenAIProvider
-
-
-class DeepSeekProvider(OpenAIProvider):
-    """DeepSeek provider implementation based on openai-compatible API"""
-
-    DEFAULT_BASE_URL = "https://api.deepseek.com/v1"
-
-    def __init__(self, config: dict = ..., **kwargs):
-        super().__init__(config, **kwargs)
-        self.completion_params["max_tokens"] = self.completion_params.pop("max_completion_tokens")

yaicli-0.6.0/yaicli/llms/providers/groq_provider.py

@@ -1,14 +0,0 @@
-from .openai_provider import OpenAIProvider
-
-
-class GroqProvider(OpenAIProvider):
-    """Groq provider implementation based on openai-compatible API"""
-
-    DEFAULT_BASE_URL = "https://api.groq.com/openai/v1"
-
-    def __init__(self, config: dict = ..., **kwargs):
-        super().__init__(config, **kwargs)
-        if self.config.get("EXTRA_BODY") and "N" in self.config["EXTRA_BODY"] and self.config["EXTRA_BODY"]["N"] != 1:
-            self.console.print("Groq does not support N parameter, setting N to 1 as Groq default", style="yellow")
-            if "extra_body" in self.completion_params:
-                self.completion_params["extra_body"]["N"] = 1

yaicli-0.6.0/yaicli/llms/providers/openrouter_provider.py

@@ -1,11 +0,0 @@
-from .openai_provider import OpenAIProvider
-
-
-class OpenRouterProvider(OpenAIProvider):
-    """OpenRouter provider implementation based on openai-compatible API"""
-
-    DEFAULT_BASE_URL = "https://openrouter.ai/api/v1"
-
-    def __init__(self, config: dict = ..., **kwargs):
-        super().__init__(config, **kwargs)
-        self.completion_params["max_tokens"] = self.completion_params.pop("max_completion_tokens")

yaicli-0.6.0/yaicli/llms/providers/sambanova_provider.py

@@ -1,28 +0,0 @@
-from ...const import DEFAULT_TEMPERATURE
-from .openai_provider import OpenAIProvider
-
-
-class SambanovaProvider(OpenAIProvider):
-    """Sambanova provider implementation based on OpenAI API"""
-
-    DEFAULT_BASE_URL = "https://api.sambanova.ai/v1"
-    SUPPORT_FUNCTION_CALL_MOELS = (
-        "Meta-Llama-3.1-8B-Instruct",
-        "Meta-Llama-3.1-405B-Instruct",
-        "Meta-Llama-3.3-70B-Instruct",
-        "Llama-4-Scout-17B-16E-Instruct",
-        "DeepSeek-V3-0324",
-    )
-
-    def __init__(self, config: dict = ..., verbose: bool = False, **kwargs):
-        super().__init__(config, verbose, **kwargs)
-        self.completion_params.pop("presence_penalty", None)
-        self.completion_params.pop("frequency_penalty", None)
-        if self.completion_params.get("temperature") < 0 or self.completion_params.get("temperature") > 1:
-            self.console.print("Sambanova temperature must be between 0 and 1, setting to 0.4", style="yellow")
-            self.completion_params["temperature"] = DEFAULT_TEMPERATURE
-        if self.enable_function and self.config["MODEL"] not in self.SUPPORT_FUNCTION_CALL_MOELS:
-            self.console.print(
-                f"Sambanova supports function call models: {', '.join(self.SUPPORT_FUNCTION_CALL_MOELS)}",
-                style="yellow",
-            )

yaicli-0.6.0/yaicli/llms/providers/yi_provider.py

@@ -1,7 +0,0 @@
-from .openai_provider import OpenAIProvider
-
-
-class YiProvider(OpenAIProvider):
-    """Yi provider implementation based on openai-compatible API"""
-
-    DEFAULT_BASE_URL = "https://api.lingyiwanwu.com/v1"