yaicli 0.6.1__py3-none-any.whl → 0.6.3__py3-none-any.whl

pyproject.toml

@@ -1,10 +1,10 @@
 [project]
 name = "yaicli"
-version = "0.6.1"
+version = "0.6.3"
 description = "A simple CLI tool to interact with LLM"
 authors = [{ name = "belingud", email = "im.victor@qq.com" }]
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 license = { file = "LICENSE" }
 classifiers = [
     "Programming Language :: Python :: 3",
@@ -65,10 +65,16 @@ ai = "yaicli.entry:app"
 yaicli = "yaicli.entry:app"
 
 [project.optional-dependencies]
+all = [
+    "volcengine-python-sdk>=3.0.15",
+    "ollama>=0.5.1",
+    "cohere>=5.15.0",
+    "google-genai>=1.20.0",
+]
 doubao = ["volcengine-python-sdk>=3.0.15"]
 ollama = ["ollama>=0.5.1"]
 cohere = ["cohere>=5.15.0"]
-all = ["volcengine-python-sdk>=3.0.15", "ollama>=0.5.1", "cohere>=5.15.0"]
+gemini = ["google-genai>=1.20.0"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
@@ -91,6 +97,7 @@ dev = [
     "pytest>=8.3.5",
     "pytest-cov>=6.1.1",
     "ruff>=0.11.2",
+    "tox>=4.27.0",
 ]
 
 [tool.isort]

yaicli/cli.py

@@ -384,14 +384,7 @@ class CLI:
         self._check_history_len()
 
         if self.current_mode == EXEC_MODE:
-            # We need to extract the executable command from the last assistant message
-            # in case of tool use.
-            final_content = ""
-            if self.chat.history:
-                last_message = self.chat.history[-1]
-                if last_message.role == "assistant":
-                    final_content = last_message.content or ""
-            self._confirm_and_execute(final_content)
+            self._confirm_and_execute(content)
         return True
 
     def _confirm_and_execute(self, raw_content: str) -> None:

yaicli/const.py

@@ -68,7 +68,7 @@ DEFAULT_JUSTIFY: JustifyMethod = "default"
 DEFAULT_ROLE_MODIFY_WARNING: BOOL_STR = "true"
 DEFAULT_ENABLE_FUNCTIONS: BOOL_STR = "true"
 DEFAULT_SHOW_FUNCTION_OUTPUT: BOOL_STR = "true"
-DEFAULT_REASONING_EFFORT: Optional[Literal["low", "high", "medium"]] = None
+DEFAULT_REASONING_EFFORT: Optional[Literal["low", "high", "medium"]] = ""
 
 
 SHELL_PROMPT = """You are YAICLI, a shell command generator.

yaicli/llms/__init__.py

@@ -1,13 +1,4 @@
-from ..config import cfg
 from .client import LLMClient
 from .provider import Provider, ProviderFactory
 
 __all__ = ["LLMClient", "Provider", "ProviderFactory"]
-
-
-class BaseProvider:
-    def __init__(self) -> None:
-        self.api_key = cfg["API_KEY"]
-        self.model = cfg["MODEL"]
-        self.base_url = cfg["BASE_URL"]
-        self.timeout = cfg["TIMEOUT"]

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,23 +39,26 @@ 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"),
+        "gemini": (".providers.gemini_provider", "GeminiProvider"),
         "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"),
-        "minimax": (".providers.minimax_provider", "MinimaxProvider"),
+        "siliconflow": (".providers.siliconflow_provider", "SiliconFlowProvider"),
         "targon": (".providers.targon_provider", "TargonProvider"),
+        "vertexai": (".providers.vertexai_provider", "VertexAIProvider"),
+        "xai": (".providers.xai_provider", "XaiProvider"),
+        "yi": (".providers.yi_provider", "YiProvider"),
     }
 
     @classmethod

yaicli/llms/providers/ai21_provider.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Generator, Optional
+from typing import Dict, Generator, Optional
 
 from openai._streaming import Stream
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
@@ -12,10 +12,18 @@ class AI21Provider(OpenAIProvider):
 
     DEFAULT_BASE_URL = "https://api.ai21.com/studio/v1"
 
-    def get_completion_params(self) -> Dict[str, Any]:
-        params = super().get_completion_params()
-        params["max_tokens"] = params.pop("max_completion_tokens")
-        return params
+    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/llms/providers/chutes_provider.py

@@ -1,5 +1,3 @@
-from typing import Any, Dict
-
 from .openai_provider import OpenAIProvider
 
 
@@ -8,7 +6,19 @@ class ChutesProvider(OpenAIProvider):
 
     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
+    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/llms/providers/gemini_provider.py

@@ -0,0 +1,191 @@
+import json
+from functools import wraps
+from typing import Any, Callable, Dict, Generator, List
+
+import google.genai as genai
+from google.genai import types
+
+from ...config import cfg
+from ...console import get_console
+from ...schemas import ChatMessage, LLMResponse
+from ...tools import get_func_name_map
+from ..provider import Provider
+
+
+def wrap_function(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+class GeminiProvider(Provider):
+    """Gemini provider implementation based on google-genai library"""
+
+    DEFAULT_BASE_URL = "https://generativelanguage.googleapis.com/v1beta"
+
+    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 = genai.Client(**self.client_params)
+        self.console = get_console()
+
+    def get_client_params(self) -> Dict[str, Any]:
+        """Get the client parameters"""
+        # Initialize client params
+        return {
+            "api_key": self.config["API_KEY"],
+        }
+
+    def get_chat_config(self):
+        http_options_map = {
+            "timeout": self.config["TIMEOUT"] * 1000,  # Timeout for the request in milliseconds.
+            "headers": {**self.config["EXTRA_HEADERS"], "X-Client": self.APP_NAME, "Referer": self.APP_REFERER},
+        }
+        if self.config.get("BASE_URL"):
+            http_options_map["base_url"] = self.config["BASE_URL"]
+        if self.config.get("API_VERSION"):
+            # Specifies the version of the API to use.
+            http_options_map["api_version"] = self.config["API_VERSION"]
+        http_options = types.HttpOptions(**http_options_map)
+        config_map = {
+            "max_output_tokens": self.config["MAX_TOKENS"],
+            "temperature": self.config["TEMPERATURE"],
+            "top_p": self.config["TOP_P"],
+            "http_options": http_options,
+        }
+        if self.config.get("TOP_K"):
+            config_map["top_k"] = self.config["TOP_K"]
+        if self.config.get("PRESENCE_PENALTY"):
+            config_map["presence_penalty"] = self.config["PRESENCE_PENALTY"]
+        if self.config.get("FREQUENCY_PENALTY"):
+            config_map["frequency_penalty"] = self.config["FREQUENCY_PENALTY"]
+        if self.config.get("SEED"):
+            config_map["seed"] = self.config["SEED"]
+        # Indicates whether to include thoughts in the response. If true, thoughts are returned only if the model supports thought and thoughts are available.
+        thinking_config_map = {"include_thoughts": self.config.get("INCLUDE_THOUGHTS", True)}
+        if self.config.get("THINKING_BUDGET"):
+            thinking_config_map["thinking_budget"] = int(self.config["THINKING_BUDGET"])
+        config_map["thinking_config"] = types.ThinkingConfig(**thinking_config_map)
+        config = types.GenerateContentConfig(**config_map)
+        if self.enable_function:
+            # TODO: support disable automatic function calling
+            # config.automatic_function_calling = types.AutomaticFunctionCallingConfig(disable=False)
+            config.tools = self.gen_gemini_functions()
+        return config
+
+    def _convert_messages(self, messages: List[ChatMessage]) -> List[types.Content]:
+        """Convert a list of ChatMessage objects to a list of Gemini Content objects."""
+        converted_messages = []
+        for msg in messages:
+            if msg.role == "system":
+                continue
+            content = types.Content(role=self._map_role(msg.role), parts=[types.Part(text=msg.content)])
+            if msg.role == "tool":
+                content.role = "user"
+                content.parts = [types.Part.from_function_response(name=msg.name, response={"result": msg.content})]
+            converted_messages.append(content)
+        return converted_messages
+
+    def _map_role(self, role: str) -> str:
+        """Map OpenAI roles to Gemini roles"""
+        # Gemini uses "user", "model" instead of "user", "assistant"
+        if role == "assistant":
+            return "model"
+        return role
+
+    def gen_gemini_functions(self) -> List[Callable[..., Any]]:
+        """Wrap Gemini functions from OpenAI functions for automatic function calling"""
+        func_name_map = get_func_name_map()
+        if not func_name_map:
+            return []
+        funcs = []
+        for func_name, func in func_name_map.items():
+            wrapped_func = wrap_function(func.execute)
+            wrapped_func.__name__ = func_name
+            wrapped_func.__doc__ = func.__doc__
+            funcs.append(wrapped_func)
+        return funcs
+
+    def completion(
+        self,
+        messages: List[ChatMessage],
+        stream: bool = False,
+    ) -> Generator[LLMResponse, None, None]:
+        """
+        Send completion request to Gemini 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
+            APIError: If API request fails
+        """
+        gemini_messages = self._convert_messages(messages)
+        if self.verbose:
+            self.console.print("Messages:")
+            self.console.print(gemini_messages)
+        chat_config = self.get_chat_config()
+        chat_config.system_instruction = messages[0].content
+        chat = self.client.chats.create(model=self.config["MODEL"], history=gemini_messages, config=chat_config)
+        message = messages[-1].content
+
+        if stream:
+            response = chat.send_message_stream(message=message)
+            yield from self._handle_stream_response(response)
+        else:
+            response = chat.send_message(message=message)
+            yield from self._handle_normal_response(response)
+
+    def _handle_normal_response(self, response) -> Generator[LLMResponse, None, None]:
+        """Handle normal (non-streaming) response"""
+        # TODO: support disable automatic function calling
+        if not response or not response.candidates:
+            yield LLMResponse(
+                content=json.dumps(response.to_json_dict()),
+                finish_reason="stop",
+            )
+            return
+        for part in response.candidates[0].content.parts:
+            if part.thought:
+                yield LLMResponse(reasoning=part.text, content=None, finish_reason="stop")
+            else:
+                yield LLMResponse(reasoning=None, content=part.text, finish_reason="stop")
+
+    def _handle_stream_response(self, response) -> Generator[LLMResponse, None, None]:
+        """Handle streaming response from Gemini API"""
+        # Initialize tool call object to accumulate tool call data across chunks
+        # TODO: support disable automatic function calling
+        tool_call = None
+        for chunk in response:
+            if not chunk.candidates:
+                continue
+            candidate = chunk.candidates[0]
+            finish_reason = candidate.finish_reason
+            for part in chunk.candidates[0].content.parts:
+                if part.thought:
+                    reasoning = part.text
+                    content = None
+                else:
+                    content = part.text
+                    reasoning = None
+                yield LLMResponse(
+                    reasoning=reasoning,
+                    content=content,
+                    tool_call=tool_call if finish_reason == "tool_calls" else None,
+                    finish_reason=finish_reason or None,
+                )
+
+    def detect_tool_role(self) -> str:
+        """Return the role that should be used for tool responses"""
+        return "user"

yaicli/llms/providers/groq_provider.py

@@ -8,7 +8,27 @@ class GroqProvider(OpenAIProvider):
 
     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")

yaicli/llms/providers/minimax_provider.py

@@ -1,4 +1,3 @@
-from typing import Any, Dict
 from .openai_provider import OpenAIProvider
 
 
@@ -7,7 +6,16 @@ class MinimaxProvider(OpenAIProvider):
 
     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
+    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/llms/providers/openai_provider.py

@@ -18,9 +18,21 @@ class OpenAIProvider(Provider):
 
     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
 
@@ -45,22 +57,32 @@ class OpenAIProvider(Provider):
             client_params["default_headers"] = {
                 **self.config["EXTRA_HEADERS"],
                 "X-Title": self.APP_NAME,
-                "HTTP-Referer": self.APPA_REFERER,
+                "HTTP-Referer": self.APP_REFERER,
             }
         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"""
-        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"]:
-            completion_params["extra_body"] = self.config["EXTRA_BODY"]
+        """
+        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 and self.config[config_key] != "":
+                completion_params[api_key] = self.config[config_key]
         return completion_params
 
     def _convert_messages(self, messages: List[ChatMessage]) -> List[Dict[str, Any]]:
@@ -90,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:")
@@ -105,12 +140,19 @@ class OpenAIProvider(Provider):
             if tools:
                 params["tools"] = tools
 
-        if stream:
-            response = self.client.chat.completions.create(**params)
-            yield from self._handle_stream_response(response)
-        else:
-            response = self.client.chat.completions.create(**params)
-            yield from self._handle_normal_response(response)
+        try:
+            if stream:
+                response = self.client.chat.completions.create(**params)
+                yield from self._handle_stream_response(response)
+            else:
+                response = self.client.chat.completions.create(**params)
+                yield from self._handle_normal_response(response)
+        except (openai.APIStatusError, openai.APIResponseValidationError) as e:
+            try:
+                body = e.response.json()
+            except Exception:
+                body = e.response.text
+            self.console.print(f"Error Response: {body}")
 
     def _handle_normal_response(self, response: ChatCompletion) -> Generator[LLMResponse, None, None]:
         """Handle normal (non-streaming) response"""
@@ -154,9 +196,8 @@ class OpenAIProvider(Provider):
             if not chunk.choices:
                 continue
             started = True
-            choice = chunk.choices[0]
-            delta = choice.delta
-            finish_reason = choice.finish_reason
+            delta = chunk.choices[0].delta
+            finish_reason = chunk.choices[0].finish_reason
 
             # Extract content from current chunk
             content = delta.content or ""

yaicli/llms/providers/openrouter_provider.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Dict
 
 from .openai_provider import OpenAIProvider
 
@@ -8,7 +8,15 @@ class OpenRouterProvider(OpenAIProvider):
 
     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
+    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/llms/providers/sambanova_provider.py

@@ -16,15 +16,44 @@ class SambanovaProvider(OpenAIProvider):
         "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()
-        params.pop("presence_penalty", None)
-        params.pop("frequency_penalty", None)
-        if params.get("temperature") < 0 or params.get("temperature") > 1:
+
+        # 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/llms/providers/targon_provider.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Dict
 
 from .openai_provider import OpenAIProvider
 
@@ -8,7 +8,15 @@ class TargonProvider(OpenAIProvider):
 
     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
+    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/llms/providers/vertexai_provider.py

@@ -0,0 +1,18 @@
+from typing import Any, Dict
+
+from .gemini_provider import GeminiProvider
+
+
+class VertexAIProvider(GeminiProvider):
+    """Vertex AI provider implementation based on google-genai library"""
+
+    def get_client_params(self) -> Dict[str, Any]:
+        """Get the client parameters"""
+        # Initialize client params
+        if not self.config.get("PROJECT") or not self.config.get("LOCATION"):
+            raise ValueError("PROJECT and LOCATION are required for Vertex AI")
+        return {
+            "vertexai": True,
+            "project": self.config.get("PROJECT"),
+            "location": self.config.get("LOCATION"),
+        }

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/llms/providers/yi_provider.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict
+from typing import Dict
 
 from .openai_provider import OpenAIProvider
 
@@ -8,7 +8,15 @@ class YiProvider(OpenAIProvider):
 
     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
+    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.1.dist-info → yaicli-0.6.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yaicli
-Version: 0.6.1
+Version: 0.6.3
 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
@@ -212,7 +212,7 @@ Keywords: ai,ai-assistant,ai-chat,ai-interaction,anthropic,chatgpt,claude,cli,co
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Requires-Dist: click>=8.1.8
 Requires-Dist: distro>=1.9.0
 Requires-Dist: httpx>=0.28.1
@@ -225,12 +225,15 @@ Requires-Dist: socksio>=1.0.0
 Requires-Dist: typer>=0.16.0
 Provides-Extra: all
 Requires-Dist: cohere>=5.15.0; extra == 'all'
+Requires-Dist: google-genai>=1.20.0; extra == 'all'
 Requires-Dist: ollama>=0.5.1; extra == 'all'
 Requires-Dist: volcengine-python-sdk>=3.0.15; extra == 'all'
 Provides-Extra: cohere
 Requires-Dist: cohere>=5.15.0; extra == 'cohere'
 Provides-Extra: doubao
 Requires-Dist: volcengine-python-sdk>=3.0.15; extra == 'doubao'
+Provides-Extra: gemini
+Requires-Dist: google-genai>=1.20.0; extra == 'gemini'
 Provides-Extra: ollama
 Requires-Dist: ollama>=0.5.1; extra == 'ollama'
 Description-Content-Type: text/markdown
@@ -375,7 +378,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 +390,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 +521,14 @@ API_KEY=
 MODEL=llama-3.3-70b-versatile
 ```
 
+#### XAI
+
+```ini
+PROVIDER=xai
+API_KEY=
+MODEL=grok-3
+```
+
 #### Chatglm
 
 ```ini

{yaicli-0.6.1.dist-info → yaicli-0.6.3.dist-info}/RECORD

@@ -1,10 +1,10 @@
-pyproject.toml,sha256=kId8ADm-DI5ydtpa9S2__9z0qnrxI7k0e1D-LPXXsKA,2434
+pyproject.toml,sha256=BfvXPlqqvIqhYBItAj3HclRLukitrn0kdwIYxdUJBgU,2531
 yaicli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 yaicli/chat.py,sha256=_emvZEdgMBth2nQGaNWPf0P45oW2k3bpuIwqsxFcM5A,13676
-yaicli/cli.py,sha256=YUKbtvRcNbe6iTmm0dx-38QDzzrAP4cOYaOChxpJ2wg,23673
+yaicli/cli.py,sha256=Eu1CL9ZB8ElvXqpHqmoWoasC0Brc7-j_zd3RmPhdSEE,23310
 yaicli/config.py,sha256=HrWYcelLXE61XX719eVcuuo3292xxf1BNQznWdvjQFQ,6535
 yaicli/console.py,sha256=vARPJd-3lafutsQWrGntQVjLrYqaJD3qisN82pmuhjU,1973
-yaicli/const.py,sha256=jC01jLLuuYJ7K_QaekXkIN7j1bIKCoGwJeTpquJy55Q,8178
+yaicli/const.py,sha256=Uvdm1rc5zhjE2r9ioCYiSzhk8cT4mfgO2Mm4mNs71Nk,8176
 yaicli/entry.py,sha256=Q1eqLE7tcHide7ooyPO7OCJpKE2YVuxR-NNFA2Pt2Hw,8693
 yaicli/exceptions.py,sha256=WBYg8OTJJzaj7lt6HE7ZyBoe5T6A3yZRNCRfWd4iN0c,372
 yaicli/history.py,sha256=s-57X9FMsaQHF7XySq1gGH_jpd_cHHTYafYu2ECuG6M,2472
@@ -16,28 +16,31 @@ yaicli/tools.py,sha256=xw8KEs_xlSf79A2Aq1rAsUWahS6A_e5QMLt7QDXL5bs,5086
 yaicli/utils.py,sha256=bpo3Xhozpxsaci3FtEIKZ32l4ZdyWMsrHjYGX0tB4J4,4541
 yaicli/functions/__init__.py,sha256=_FJooQ9GkijG8xLwuU0cr5GBrGnC9Nc6bnCeUjrsT0k,1271
 yaicli/functions/buildin/execute_shell_command.py,sha256=unl1-F8p6QZajeHdA0u5UpURMJM0WhdWMUWCCCHVRcI,1320
-yaicli/llms/__init__.py,sha256=cN54nu-YalZipXjLW0YAAe0rRv0tXAQ8lLi1ohuTpao,363
+yaicli/llms/__init__.py,sha256=x78cJujrJkelXPnzHS6pzHkITZdgLYZqJMnrMHbptoc,134
 yaicli/llms/client.py,sha256=mkE9KHSuPcJfpNQXbzF2YXGkel3jrOW8KfQ3YYpaK4M,4453
-yaicli/llms/provider.py,sha256=u_pHF806rmKqkAuKfBi1vNAm2xdWfnqFPYMb6xf2wTQ,2959
-yaicli/llms/providers/ai21_provider.py,sha256=_RRHtj7Nopwm6t_D_jukA7VjqVhlOC_0TphRL-UxVnI,2752
+yaicli/llms/provider.py,sha256=YhX6RcMQqhac4EoQTY_AXDm-jtHYfH_K7Jikqvpc3H8,3159
+yaicli/llms/providers/ai21_provider.py,sha256=SvgGj9_87KEqmxCMLbtsSkT8J3rUD7Mb21UF7pMWsks,3035
 yaicli/llms/providers/chatglm_provider.py,sha256=1xP4KVAi6SDKZ-lMi2wdzywtDydsTf6jDzh3jBBGMfA,6437
-yaicli/llms/providers/chutes_provider.py,sha256=qaTV8863zWLUsxnjWqpOUCVtnxS4tTzFCJBo5yakvhU,431
+yaicli/llms/providers/chutes_provider.py,sha256=mtvWvRRfHPH3JFfzym87wXtPNiMpLnur3805N9acx7E,882
 yaicli/llms/providers/cohere_provider.py,sha256=hc6vQxbCHz9kM2tNKK-kGkuOf4-gkskXW9ctr9V4Cxk,10837
 yaicli/llms/providers/deepseek_provider.py,sha256=VjGes_jFin5WGYNFxYKMoHwgAQX_eYbYhQKfjeh-9eI,438
 yaicli/llms/providers/doubao_provider.py,sha256=4eOdE91ITUn3uo3mvYAzdrHsuFIIBwZWib21mtZn8OY,1938
-yaicli/llms/providers/groq_provider.py,sha256=W87b22nSILZiFXSzMrU4aL6zdtTzDDUihJhmFvGKxAc,639
+yaicli/llms/providers/gemini_provider.py,sha256=iCRDqHRBFeTD_2NQwlsAlxFU7cKK4iyjimaPSp4VySM,7923
+yaicli/llms/providers/groq_provider.py,sha256=EiS1Yxw5jbAUBFCRYsJ57KYgZPk6oH-_gD72OfW8Oik,1358
 yaicli/llms/providers/infiniai_provider.py,sha256=1dseUIZiXsxYRATRtk_obFclyXMwi4glsP7l_tVtnv8,710
-yaicli/llms/providers/minimax_provider.py,sha256=V50Rfi_ffx7tSplPuAwjlZikSpqjdjqBVP8oSRQAQy0,435
+yaicli/llms/providers/minimax_provider.py,sha256=W-j3dzrYMEv14bYt2pCPvPUxvxsUs-iMAcGB9yXakFs,744
 yaicli/llms/providers/modelscope_provider.py,sha256=BzBhYixiDEWB7gujQ0rcG__7nsv0psJRxdtYCYXBhdM,454
 yaicli/llms/providers/ollama_provider.py,sha256=pjpYjfnHWnExweZi1KGbT07JGkcxzKPhqICo8dD82D0,6967
-yaicli/llms/providers/openai_provider.py,sha256=5Oq2UEH2SVMbqy5oQZsC3zibzhKBehZyrtJyCVB8hsw,8589
-yaicli/llms/providers/openrouter_provider.py,sha256=McMBl9YWcUUWdjp9njphqCoSeHc37n-UJo8vy7EjhNg,443
-yaicli/llms/providers/sambanova_provider.py,sha256=ngYnOQFyYVjtplf_RKR-_DmlTNLKxK9kURxbprgyDJs,1227
+yaicli/llms/providers/openai_provider.py,sha256=yl1vVKt8QzbN_dbsW_9rY8S_xkXI3Bo3Of4Cf7W3mJc,10075
+yaicli/llms/providers/openrouter_provider.py,sha256=R-7FrUrCAKPZ3gbnuo0M6rPlVw1mvSBjbLGs_FtZWM0,732
+yaicli/llms/providers/sambanova_provider.py,sha256=FFLrsvARt1UPAFWWgiuB6zvGzGKdtehKL58HdE1fo_M,2254
 yaicli/llms/providers/siliconflow_provider.py,sha256=7Ir73me9jGMO5TAZDjrAbX7tbb_QBmLjTGywY0yliqc,446
-yaicli/llms/providers/targon_provider.py,sha256=Lqj2i-YydduqKpeMED06gL-0gu-8Y548icgrSsxPVUs,432
-yaicli/llms/providers/yi_provider.py,sha256=UgIOmxvyq7UxnF20NBX2oFDnhRdcAKnx_qplrsbpobM,438
-yaicli-0.6.1.dist-info/METADATA,sha256=9UTlwCBHXS9GCOj63pnfupmLwOdUkrHV1onl-N7s0RE,53514
-yaicli-0.6.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-yaicli-0.6.1.dist-info/entry_points.txt,sha256=iYVyQP0PJIm9tQnlQheqT435kK_xdGoi5j9aswGV9hA,66
-yaicli-0.6.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-yaicli-0.6.1.dist-info/RECORD,,
+yaicli/llms/providers/targon_provider.py,sha256=RQ808eS9lvsyvlzyKaQYcN0NimbpoNWgjHUzY1gLNs4,717
+yaicli/llms/providers/vertexai_provider.py,sha256=_ddrse1LfXRChTgkvxUlexyfJlfr0sVJH-Rmno3djSI,636
+yaicli/llms/providers/xai_provider.py,sha256=Q6iOvJZOXIAwRiiHMKEBgq8-W6SGVZ9QD1_532bNYfo,199
+yaicli/llms/providers/yi_provider.py,sha256=EnTm9qTxHPnzERsKqgGnzRIVhXFcAEdYqtOra65pGmY,719
+yaicli-0.6.3.dist-info/METADATA,sha256=EfU2thy5G2Ge-BaCM3RT0quP2YUPz0bBWLJjKJugf_w,53677
+yaicli-0.6.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+yaicli-0.6.3.dist-info/entry_points.txt,sha256=iYVyQP0PJIm9tQnlQheqT435kK_xdGoi5j9aswGV9hA,66
+yaicli-0.6.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+yaicli-0.6.3.dist-info/RECORD,,