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

yaicli/llms/providers/openai_provider.py

@@ -0,0 +1,211 @@
+import json
+from typing import Any, Dict, Generator, List, Optional
+
+import openai
+from openai._streaming import Stream
+from openai.types.chat.chat_completion import ChatCompletion
+from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
+
+from ...config import cfg
+from ...console import get_console
+from ...schemas import ChatMessage, LLMResponse, ToolCall
+from ...tools import get_openai_schemas
+from ..provider import Provider
+
+
+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
+        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"]:
+            client_params["default_headers"] = {
+                **self.config["EXTRA_HEADERS"],
+                "X-Title": self.APP_NAME,
+                "HTTP-Referer": self.APPA_REFERER,
+            }
+        return client_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"]:
+            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."""
+        converted_messages = []
+        for msg in messages:
+            message = {"role": msg.role, "content": msg.content or ""}
+
+            if msg.name:
+                message["name"] = msg.name
+
+            if msg.role == "assistant" and msg.tool_calls:
+                message["tool_calls"] = [
+                    {"id": tc.id, "type": "function", "function": {"name": tc.name, "arguments": tc.arguments}}
+                    for tc in msg.tool_calls
+                ]
+
+            if msg.role == "tool" and msg.tool_call_id:
+                message["tool_call_id"] = msg.tool_call_id
+
+            converted_messages.append(message)
+
+        return converted_messages
+
+    def completion(
+        self,
+        messages: List[ChatMessage],
+        stream: bool = False,
+    ) -> Generator[LLMResponse, None, None]:
+        """Send completion request to OpenAI and return responses"""
+        openai_messages = self._convert_messages(messages)
+        if self.verbose:
+            self.console.print("Messages:")
+            self.console.print(openai_messages)
+
+        params = self.completion_params.copy()
+        params["messages"] = openai_messages
+        params["stream"] = stream
+
+        if self.enable_function:
+            tools = get_openai_schemas()
+            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)
+
+    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
+        finish_reason = choice.finish_reason
+        tool_call: Optional[ToolCall] = None
+
+        # Check if the response contains reasoning content in model_extra
+        if hasattr(choice.message, "model_extra") and choice.message.model_extra:
+            model_extra = choice.message.model_extra
+            reasoning = self._get_reasoning_content(model_extra)
+
+        if finish_reason == "tool_calls" and hasattr(choice.message, "tool_calls") and choice.message.tool_calls:
+            tool = choice.message.tool_calls[0]
+            tool_call = ToolCall(tool.id, tool.function.name or "", tool.function.arguments)
+
+        yield LLMResponse(reasoning=reasoning, content=content, finish_reason=finish_reason, tool_call=tool_call)
+
+    def _handle_stream_response(self, response: Stream[ChatCompletionChunk]) -> Generator[LLMResponse, None, None]:
+        """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 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
+
+            # Extract content from current chunk
+            content = delta.content or ""
+
+            # Extract reasoning content if available
+            reasoning = self._get_reasoning_content(getattr(delta, "model_extra", None) or delta)
+
+            # Process tool call information that may be scattered across chunks
+            if hasattr(delta, "tool_calls") and delta.tool_calls:
+                tool_call = self._process_tool_call_chunk(delta.tool_calls, tool_call)
+
+            # Generate response object with tool_call only when finish_reason indicates completion
+            yield LLMResponse(
+                reasoning=reasoning,
+                content=content,
+                tool_call=tool_call if finish_reason == "tool_calls" else None,
+                finish_reason=finish_reason,
+            )
+
+    def _process_tool_call_chunk(self, tool_calls, existing_tool_call=None):
+        """Process tool call data from a response chunk"""
+        # Initialize tool call object if this is the first chunk with tool call data
+        if existing_tool_call is None and tool_calls:
+            existing_tool_call = ToolCall(tool_calls[0].id or "", tool_calls[0].function.name or "", "")
+
+        # Accumulate arguments from multiple chunks
+        if existing_tool_call:
+            for tool in tool_calls:
+                if not tool.function:
+                    continue
+                existing_tool_call.arguments += tool.function.arguments or ""
+
+        return existing_tool_call
+
+    def _get_reasoning_content(self, delta: Any) -> Optional[str]:
+        """Extract reasoning content from delta if available based on specific keys."""
+        if not delta:
+            return None
+        if not isinstance(delta, dict):
+            delta = dict(delta)
+        # Reasoning content keys from API:
+        # reasoning_content: deepseek/infi-ai
+        # reasoning: openrouter
+        # <think> block implementation not in here
+        for key in ("reasoning_content", "reasoning"):
+            if key in delta:
+                return delta[key]
+        return None
+
+    def detect_tool_role(self) -> str:
+        """Return the role that should be used for tool responses"""
+        return "tool"

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

@@ -0,0 +1,30 @@
+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(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")
+            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/llms/providers/siliconflow_provider.py

@@ -0,0 +1,14 @@
+from typing import Any, Dict
+
+from .openai_provider import OpenAIProvider
+
+
+class SiliconFlowProvider(OpenAIProvider):
+    """SiliconFlow provider implementation based on openai-compatible API"""
+
+    DEFAULT_BASE_URL = "https://api.siliconflow.cn/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/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/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/printer.py

@@ -1,18 +1,14 @@
 import time
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Iterator, List, Tuple, Union
+from typing import Iterator, List, Tuple, Union
 
 from rich.console import Group, RenderableType
 from rich.live import Live
 
-from .client import RefreshLive
 from .config import Config, get_config
 from .console import YaiConsole, get_console
 from .render import Markdown, plain_formatter
-from .schemas import ChatMessage
-
-if TYPE_CHECKING:
-    from .schemas import LLMResponse
+from .schemas import LLMResponse, RefreshLive
 
 
 @dataclass
@@ -147,9 +143,7 @@ class Printer:
         # Use Rich Group to combine multiple renderables
         return Group(*display_elements)
 
-    def display_normal(
-        self, content_iterator: Iterator[Union["LLMResponse", RefreshLive]], messages: list["ChatMessage"]
-    ) -> tuple[str, str]:
+    def display_normal(self, content_iterator: Iterator[Union["LLMResponse", RefreshLive]]) -> tuple[str, str]:
         """Process and display non-stream LLMContent, including reasoning and content parts."""
         self._reset_state()
         full_content = full_reasoning = ""
@@ -174,13 +168,9 @@ class Printer:
                 self.console.print()
                 self.console.print(self.content_formatter(full_content))
 
-            messages.append(ChatMessage(role="assistant", content=full_content))
-
         return full_content, full_reasoning
 
-    def display_stream(
-        self, stream_iterator: Iterator[Union["LLMResponse", RefreshLive]], messages: list["ChatMessage"]
-    ) -> tuple[str, str]:
+    def display_stream(self, stream_iterator: Iterator[Union["LLMResponse", RefreshLive]]) -> tuple[str, str]:
         """Process and display LLMContent stream, including reasoning and content parts."""
         self._reset_state()
         full_content = full_reasoning = ""
@@ -191,7 +181,6 @@ class Printer:
             if isinstance(chunk, RefreshLive):
                 # Refresh live display when in next completion
                 live.stop()
-                messages.append(ChatMessage(role="assistant", content=full_content))
                 live = Live(console=self.console)
                 live.start()
                 # Initialize full_content and full_reasoning for the next completion
@@ -210,5 +199,4 @@ class Printer:
             time.sleep(self._UPDATE_INTERVAL)
 
         live.stop()
-        messages.append(ChatMessage(role="assistant", content=full_content))
         return full_content, full_reasoning

yaicli/schemas.py

@@ -1,5 +1,5 @@
-from dataclasses import dataclass
-from typing import Optional
+from dataclasses import dataclass, field
+from typing import List, Optional
 
 
 @dataclass
@@ -7,9 +7,10 @@ class ChatMessage:
     """Chat message class"""
 
     role: str
-    content: str
+    content: Optional[str] = None
     name: Optional[str] = None
     tool_call_id: Optional[str] = None
+    tool_calls: List["ToolCall"] = field(default_factory=list)
 
 
 @dataclass
@@ -29,3 +30,11 @@ class LLMResponse:
     content: str = ""
     finish_reason: Optional[str] = None
     tool_call: Optional[ToolCall] = None
+
+
+class RefreshLive:
+    """Refresh live display"""
+
+
+class StopLive:
+    """Stop live display"""

yaicli/tools.py

@@ -1,14 +1,20 @@
 import importlib.util
 import sys
-from typing import Any, Dict, List, NewType, Optional
+from typing import Any, Dict, List, NewType, Optional, Tuple, cast
 
 from instructor import OpenAISchema
+from json_repair import repair_json
+from rich.panel import Panel
 
+from .config import cfg
 from .console import get_console
 from .const import FUNCTIONS_DIR
+from .schemas import ToolCall
 
 console = get_console()
 
+FunctionName = NewType("FunctionName", str)
+
 
 class Function:
     """Function description class"""
@@ -20,8 +26,6 @@ class Function:
         self.execute = function.execute  # type: ignore
 
 
-FunctionName = NewType("FunctionName", str)
-
 _func_name_map: Optional[dict[FunctionName, Function]] = None
 
 
@@ -101,3 +105,55 @@ def get_openai_schemas() -> List[Dict[str, Any]]:
         }
         transformed_schemas.append(schema)
     return transformed_schemas
+
+
+def execute_tool_call(tool_call: ToolCall) -> Tuple[str, bool]:
+    """Execute a tool call and return the result
+
+    Args:
+        tool_call: The tool call to execute
+
+    Returns:
+        Tuple[str, bool]: (result text, success flag)
+    """
+    console.print(f"@Function call: {tool_call.name}({tool_call.arguments})", style="blue")
+
+    # 1. Get the function
+    try:
+        function = get_function(FunctionName(tool_call.name))
+    except ValueError as e:
+        error_msg = f"Function '{tool_call.name!r}' not exists: {e}"
+        console.print(error_msg, style="red")
+        return error_msg, False
+
+    # 2. Parse function arguments
+    try:
+        arguments = repair_json(tool_call.arguments, return_objects=True)
+        if not isinstance(arguments, dict):
+            error_msg = f"Invalid arguments type: {arguments!r}, should be JSON object"
+            console.print(error_msg, style="red")
+            return error_msg, False
+        arguments = cast(dict, arguments)
+    except Exception as e:
+        error_msg = f"Invalid arguments from llm: {e}\nRaw arguments: {tool_call.arguments!r}"
+        console.print(error_msg, style="red")
+        return error_msg, False
+
+    # 3. Execute the function
+    try:
+        function_result = function.execute(**arguments)
+        if cfg["SHOW_FUNCTION_OUTPUT"]:
+            panel = Panel(
+                function_result,
+                title="Function output",
+                title_align="left",
+                expand=False,
+                border_style="blue",
+                style="dim",
+            )
+            console.print(panel)
+        return function_result, True
+    except Exception as e:
+        error_msg = f"Call function error: {e}\nFunction name: {tool_call.name!r}\nArguments: {arguments!r}"
+        console.print(error_msg, style="red")
+        return error_msg, False