yaicli 0.6.0__tar.gz → 0.6.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yaicli
-Version: 0.6.0
+Version: 0.6.1
 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

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

@@ -1,6 +1,6 @@
 [project]
 name = "yaicli"
-version = "0.6.0"
+version = "0.6.1"
 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.1}/yaicli/llms/provider.py

@@ -54,6 +54,8 @@ class ProviderFactory:
         "ollama": (".providers.ollama_provider", "OllamaProvider"),
         "cohere": (".providers.cohere_provider", "CohereProvider"),
         "sambanova": (".providers.sambanova_provider", "SambanovaProvider"),
+        "minimax": (".providers.minimax_provider", "MinimaxProvider"),
+        "targon": (".providers.targon_provider", "TargonProvider"),
     }
 
     @classmethod

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

@@ -1,4 +1,4 @@
-from typing import Generator, Optional
+from typing import Any, Dict, Generator, Optional
 
 from openai._streaming import Stream
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
@@ -12,9 +12,10 @@ 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(self) -> Dict[str, Any]:
+        params = super().get_completion_params()
+        params["max_tokens"] = params.pop("max_completion_tokens")
+        return params
 
     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.1}/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.1/yaicli/llms/providers/chutes_provider.py

@@ -0,0 +1,14 @@
+from typing import Any, Dict
+
+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(self) -> Dict[str, Any]:
+        params = super().get_completion_params()
+        params["max_tokens"] = params.pop("max_completion_tokens")
+        return params

yaicli-0.6.1/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.1}/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.1/yaicli/llms/providers/groq_provider.py

@@ -0,0 +1,16 @@
+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(self) -> Dict[str, Any]:
+        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.1}/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.1/yaicli/llms/providers/minimax_provider.py

@@ -0,0 +1,13 @@
+from typing import Any, Dict
+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(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.1}/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.1}/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,51 @@ class OpenAIProvider(Provider):
     """OpenAI provider implementation based on openai library"""
 
     DEFAULT_BASE_URL = "https://api.openai.com/v1"
+    CLIENT_CLS = openai.OpenAI
 
     def __init__(self, config: dict = cfg, verbose: bool = False, **kwargs):
         self.config = config
         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,
             }
+        return client_params
 
-        # Initialize client
-        self.client = openai.OpenAI(**self.client_params)
-        self.console = get_console()
-
-        # Store completion params
-        self.completion_params = {
+    def get_completion_params(self) -> Dict[str, Any]:
+        """Get the completion parameters"""
+        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"]
+            completion_params["extra_body"] = self.config["EXTRA_BODY"]
+        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."""
@@ -103,6 +114,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,12 +140,20 @@ 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
 
+            if not chunk.choices:
+                continue
+            started = True
             choice = chunk.choices[0]
             delta = choice.delta
             finish_reason = choice.finish_reason

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

@@ -0,0 +1,14 @@
+from typing import Any, 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(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.1}/yaicli/llms/providers/sambanova_provider.py

@@ -1,3 +1,5 @@
+from typing import Any, Dict
+
 from ...const import DEFAULT_TEMPERATURE
 from .openai_provider import OpenAIProvider
 
@@ -14,13 +16,13 @@ class SambanovaProvider(OpenAIProvider):
         "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:
+    def get_completion_params(self) -> Dict[str, Any]:
+        params = super().get_completion_params()
+        params.pop("presence_penalty", None)
+        params.pop("frequency_penalty", None)
+        if params.get("temperature") < 0 or 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
+            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)}",

{yaicli-0.6.0 → yaicli-0.6.1}/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.1/yaicli/llms/providers/targon_provider.py

@@ -0,0 +1,14 @@
+from typing import Any, 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(self) -> Dict[str, Any]:
+        params = super().get_completion_params()
+        params["max_tokens"] = params.pop("max_completion_tokens")
+        return params

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

@@ -0,0 +1,14 @@
+from typing import Any, 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(self) -> Dict[str, Any]:
+        params = super().get_completion_params()
+        params["max_tokens"] = params.pop("max_completion_tokens")
+        return params

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/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"