yaicli 0.3.2__py3-none-any.whl → 0.4.0__py3-none-any.whl

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yaicli"
-version = "0.3.2"
+version = "0.4.0"
 description = "A simple CLI tool to interact with LLM"
 authors = [{ name = "belingud", email = "im.victor@qq.com" }]
 readme = "README.md"
@@ -30,9 +30,10 @@ keywords = [
     "interact with llms",
 ]
 dependencies = [
+    "cohere>=5.15.0",
     "distro>=1.9.0",
     "httpx>=0.28.1",
-    "jmespath>=1.0.1",
+    "openai>=1.76.0",
     "prompt-toolkit>=3.0.50",
     "rich>=13.9.4",
     "socksio>=1.0.0",

yaicli/cli.py

@@ -16,7 +16,6 @@ from rich.padding import Padding
 from rich.panel import Panel
 from rich.prompt import Prompt
 
-from yaicli.api import ApiClient
 from yaicli.chat_manager import ChatFileInfo, ChatManager, FileChatManager
 from yaicli.config import CONFIG_PATH, Config, cfg
 from yaicli.console import get_console
@@ -40,6 +39,7 @@ from yaicli.const import (
 )
 from yaicli.history import LimitedFileHistory
 from yaicli.printer import Printer
+from yaicli.providers import BaseClient, create_api_client
 from yaicli.roles import RoleManager
 from yaicli.utils import detect_os, detect_shell, filter_command
 
@@ -51,7 +51,7 @@ class CLI:
         self,
         verbose: bool = False,
         stdin: Optional[str] = None,
-        api_client: Optional[ApiClient] = None,
+        api_client: Optional[BaseClient] = None,
         printer: Optional[Printer] = None,
         chat_manager: Optional[ChatManager] = None,
         role: Optional[str] = None,
@@ -64,9 +64,10 @@ class CLI:
         self.config: Config = cfg
         self.current_mode: str = TEMP_MODE
         self.role: str = role or DefaultRoleNames.DEFAULT.value
+        self.init_role: str = self.role  # --role can specify a role when enter interactive chat
 
         # Initialize role manager
-        self.role_manager = RoleManager()
+        self.role_manager = RoleManager()  # Singleton
 
         # Validate role
         if not self.role_manager.role_exists(self.role):
@@ -102,7 +103,7 @@ class CLI:
             self.console.print(f"Current role: {self.role}")
             self.console.print(Markdown("---", code_theme=self.config.get("CODE_THEME", DEFAULT_CODE_THEME)))
 
-        self.api_client = api_client or ApiClient(self.config, self.console, self.verbose)
+        self.api_client = api_client or create_api_client(self.config, self.console, self.verbose)
         self.printer = printer or Printer(self.config, self.console, self.verbose, markdown=True)
 
         _origin_stderr = None
@@ -344,12 +345,11 @@ class CLI:
     def get_system_prompt(self) -> str:
         """Get the system prompt based on current role and mode"""
         # Use the role manager to get the system prompt
-        self.console.print(f"Using role: {self.role}")
         return self.role_manager.get_system_prompt(self.role)
 
     def _build_messages(self, user_input: str) -> List[dict]:
         """Build message list for LLM API"""
-        # Create the message list
+        # Create the message list with system prompt
         messages = [{"role": "system", "content": self.get_system_prompt()}]
 
         # Add previous conversation if available
@@ -420,7 +420,7 @@ class CLI:
    ████   ███████ ██ ██      ██      ██
     ██    ██   ██ ██ ██      ██      ██
     ██    ██   ██ ██  ██████ ███████ ██
- """,
+""",
             style="bold cyan",
         )
         self.console.print("Welcome to YAICLI!", style="bold")
@@ -500,7 +500,7 @@ class CLI:
         @self.bindings.add(Keys.ControlI)  # TAB
         def _(event: KeyPressEvent) -> None:
             self.current_mode = EXEC_MODE if self.current_mode == CHAT_MODE else CHAT_MODE
-            self.role = DefaultRoleNames.SHELL if self.current_mode == EXEC_MODE else DefaultRoleNames.DEFAULT
+            self.role = DefaultRoleNames.SHELL if self.current_mode == EXEC_MODE else self.init_role
 
     def _run_once(self, input: str, shell: bool) -> None:
         """Run a single command (non-interactive)."""

yaicli/config.py

@@ -13,6 +13,7 @@ from yaicli.const import (
     DEFAULT_CONFIG_MAP,
     DEFAULT_JUSTIFY,
     DEFAULT_MAX_SAVED_CHATS,
+    DEFAULT_ROLE_MODIFY_WARNING,
 )
 from yaicli.utils import str2bool
 
@@ -78,6 +79,10 @@ class Config(dict):
                 f.write(f"\nMAX_SAVED_CHATS={DEFAULT_MAX_SAVED_CHATS}\n")
             if "JUSTIFY" not in config_content.strip():
                 f.write(f"\nJUSTIFY={DEFAULT_JUSTIFY}\n")
+            if "ROLE_MODIFY_WARNING" not in config_content.strip():
+                f.write(
+                    f"\n# Set to false to disable warnings about modified built-in roles\nROLE_MODIFY_WARNING={DEFAULT_ROLE_MODIFY_WARNING}\n"
+                )
 
     def _load_from_file(self) -> None:
         """Load configuration from the config file.
@@ -160,7 +165,7 @@ class Config(dict):
             self[key] = converted_value
 
 
-@lru_cache(maxsize=1)
+@lru_cache(1)
 def get_config() -> Config:
     """Get the configuration singleton"""
     return Config()

yaicli/const.py

@@ -1,10 +1,12 @@
 from enum import StrEnum
 from pathlib import Path
 from tempfile import gettempdir
-from typing import Any
+from typing import Any, Literal
 
 from rich.console import JustifyMethod
 
+BOOL_STR = Literal["true", "false", "yes", "no", "y", "n", "1", "0", "on", "off"]
+
 
 class JustifyEnum(StrEnum):
     DEFAULT = "default"
@@ -33,25 +35,24 @@ ROLES_DIR = CONFIG_PATH.parent / "roles"
 
 # Default configuration values
 DEFAULT_CODE_THEME = "monokai"
-DEFAULT_COMPLETION_PATH = "chat/completions"
-DEFAULT_ANSWER_PATH = "choices[0].message.content"
 DEFAULT_PROVIDER = "openai"
 DEFAULT_BASE_URL = "https://api.openai.com/v1"
 DEFAULT_MODEL = "gpt-4o"
 DEFAULT_SHELL_NAME = "auto"
 DEFAULT_OS_NAME = "auto"
-DEFAULT_STREAM = "true"
+DEFAULT_STREAM: BOOL_STR = "true"
 DEFAULT_TEMPERATURE: float = 0.7
 DEFAULT_TOP_P: float = 1.0
 DEFAULT_MAX_TOKENS: int = 1024
 DEFAULT_MAX_HISTORY: int = 500
-DEFAULT_AUTO_SUGGEST = "true"
-DEFAULT_SHOW_REASONING = "true"
+DEFAULT_AUTO_SUGGEST: BOOL_STR = "true"
+DEFAULT_SHOW_REASONING: BOOL_STR = "true"
 DEFAULT_TIMEOUT: int = 60
 DEFAULT_INTERACTIVE_ROUND: int = 25
-DEFAULT_CHAT_HISTORY_DIR = Path(gettempdir()) / "yaicli/chats"
+DEFAULT_CHAT_HISTORY_DIR: Path = Path(gettempdir()) / "yaicli/chats"
 DEFAULT_MAX_SAVED_CHATS = 20
 DEFAULT_JUSTIFY: JustifyMethod = "default"
+DEFAULT_ROLE_MODIFY_WARNING: BOOL_STR = "true"
 
 
 class EventTypeEnum(StrEnum):
@@ -64,12 +65,11 @@ class EventTypeEnum(StrEnum):
     FINISH = "finish"
 
 
-SHELL_PROMPT = """Your are a Shell Command Generator named YAICLI.
-Generate a command EXCLUSIVELY for {_os} OS with {_shell} shell.
-If details are missing, offer the most logical solution.
-Ensure the output is a valid shell command.
-Combine multiple steps with `&&` when possible.
-Supply plain text only, avoiding Markdown formatting."""
+SHELL_PROMPT = """You are YAICLI, a shell command generator.
+The context conversation may contain other types of messages, 
+but you should only respond with a single valid {_shell} shell command for {_os}.
+Do not include any explanations, comments, or formatting — only the command as plain text, avoiding Markdown formatting.
+"""
 
 DEFAULT_PROMPT = """
 You are YAICLI, a system management and programing assistant, 
@@ -113,9 +113,6 @@ DEFAULT_CONFIG_MAP = {
     # System detection hints
     "SHELL_NAME": {"value": DEFAULT_SHELL_NAME, "env_key": "YAI_SHELL_NAME", "type": str},
     "OS_NAME": {"value": DEFAULT_OS_NAME, "env_key": "YAI_OS_NAME", "type": str},
-    # API paths (usually no need to change for OpenAI compatible APIs)
-    "COMPLETION_PATH": {"value": DEFAULT_COMPLETION_PATH, "env_key": "YAI_COMPLETION_PATH", "type": str},
-    "ANSWER_PATH": {"value": DEFAULT_ANSWER_PATH, "env_key": "YAI_ANSWER_PATH", "type": str},
     # API call parameters
     "STREAM": {"value": DEFAULT_STREAM, "env_key": "YAI_STREAM", "type": bool},
     "TEMPERATURE": {"value": DEFAULT_TEMPERATURE, "env_key": "YAI_TEMPERATURE", "type": float},
@@ -136,6 +133,8 @@ DEFAULT_CONFIG_MAP = {
     # Chat history settings
     "CHAT_HISTORY_DIR": {"value": DEFAULT_CHAT_HISTORY_DIR, "env_key": "YAI_CHAT_HISTORY_DIR", "type": str},
     "MAX_SAVED_CHATS": {"value": DEFAULT_MAX_SAVED_CHATS, "env_key": "YAI_MAX_SAVED_CHATS", "type": int},
+    # Role settings
+    "ROLE_MODIFY_WARNING": {"value": DEFAULT_ROLE_MODIFY_WARNING, "env_key": "YAI_ROLE_MODIFY_WARNING", "type": bool},
 }
 
 DEFAULT_CONFIG_INI = f"""[core]
@@ -148,10 +147,6 @@ MODEL={DEFAULT_CONFIG_MAP["MODEL"]["value"]}
 SHELL_NAME={DEFAULT_CONFIG_MAP["SHELL_NAME"]["value"]}
 OS_NAME={DEFAULT_CONFIG_MAP["OS_NAME"]["value"]}
 
-# API paths (usually no need to change for OpenAI compatible APIs)
-COMPLETION_PATH={DEFAULT_CONFIG_MAP["COMPLETION_PATH"]["value"]}
-ANSWER_PATH={DEFAULT_CONFIG_MAP["ANSWER_PATH"]["value"]}
-
 # true: streaming response, false: non-streaming
 STREAM={DEFAULT_CONFIG_MAP["STREAM"]["value"]}
 
@@ -177,4 +172,8 @@ JUSTIFY={DEFAULT_CONFIG_MAP["JUSTIFY"]["value"]}
 # Chat history settings
 CHAT_HISTORY_DIR={DEFAULT_CONFIG_MAP["CHAT_HISTORY_DIR"]["value"]}
 MAX_SAVED_CHATS={DEFAULT_CONFIG_MAP["MAX_SAVED_CHATS"]["value"]}
+
+# Role settings
+# Set to false to disable warnings about modified built-in roles
+ROLE_MODIFY_WARNING={DEFAULT_CONFIG_MAP["ROLE_MODIFY_WARNING"]["value"]}
 """

yaicli/providers/__init__.py

@@ -0,0 +1,34 @@
+from yaicli.const import DEFAULT_PROVIDER
+from yaicli.providers.base import BaseClient
+from yaicli.providers.cohere import CohereClient
+from yaicli.providers.openai import OpenAIClient
+
+
+def create_api_client(config, console, verbose):
+    """Factory function to create the appropriate API client based on provider.
+
+    Args:
+        config: The configuration dictionary
+        console: The rich console for output
+        verbose: Whether to enable verbose output
+
+    Returns:
+        An instance of the appropriate ApiClient implementation
+    """
+    provider = config.get("PROVIDER", DEFAULT_PROVIDER).lower()
+
+    if provider == "openai":
+        return OpenAIClient(config, console, verbose)
+    elif provider == "cohere":
+        return CohereClient(config, console, verbose)
+    # elif provider == "google":
+    #     return GoogleApiClient(config, console, verbose)
+    # elif provider == "claude":
+    #     return ClaudeApiClient(config, console, verbose)
+    else:
+        # Fallback to openai client
+        console.print(f"Using generic HTTP client for provider: {provider}", style="yellow")
+        return OpenAIClient(config, console, verbose)
+
+
+__all__ = ["BaseClient", "OpenAIClient", "CohereClient", "create_api_client"]

yaicli/providers/base.py

@@ -0,0 +1,51 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Iterator, List, Optional, Tuple
+
+from rich.console import Console
+
+
+class BaseClient(ABC):
+    """Base abstract class for LLM API clients."""
+
+    def __init__(self, config: Dict[str, Any], console: Console, verbose: bool):
+        """Initialize the API client with configuration."""
+        self.config = config
+        self.console = console
+        self.verbose = verbose
+        self.timeout = self.config["TIMEOUT"]
+
+    @abstractmethod
+    def completion(self, messages: List[Dict[str, str]]) -> Tuple[Optional[str], Optional[str]]:
+        """Get a complete non-streamed response from the API."""
+        pass
+
+    @abstractmethod
+    def stream_completion(self, messages: List[Dict[str, str]]) -> Iterator[Dict[str, Any]]:
+        """Connect to the API and yield parsed stream events."""
+        pass
+
+    def _get_reasoning_content(self, delta: dict) -> Optional[str]:
+        """Extract reasoning content from delta if available based on specific keys.
+
+        This method checks for various keys that might contain reasoning content
+        in different API implementations.
+
+        Args:
+            delta: The delta dictionary from the API response
+
+        Returns:
+            The reasoning content string if found, None otherwise
+        """
+        if not delta:
+            return None
+        # Reasoning content keys from API:
+        # reasoning_content: deepseek/infi-ai
+        # reasoning: openrouter
+        # <think> block implementation not in here
+        for key in ("reasoning_content", "reasoning"):
+            # Check if the key exists and its value is a non-empty string
+            value = delta.get(key)
+            if isinstance(value, str) and value:
+                return value
+
+        return None  # Return None if no relevant key with a string value is found

yaicli/providers/cohere.py

@@ -0,0 +1,136 @@
+from typing import Any, Dict, Iterator, List, Literal, Optional, Tuple, TypeVar
+
+from cohere import ChatResponse, ClientV2, StreamedChatResponseV2
+from cohere.core.api_error import ApiError
+
+from yaicli.const import EventTypeEnum
+from yaicli.providers.base import BaseClient
+
+ChunkType = Literal[
+    "message-start",
+    "content-start",
+    "content-delta",
+    "content-end",
+    "tool-plan-delta",
+    "tool-call-start",
+    "tool-call-delta",
+    "tool-call-end",
+    "citation-start",
+    "citation-end",
+    "message-end",
+    "debug",
+]
+
+# Type variable for chunks that have delta attribute
+T = TypeVar("T", bound=StreamedChatResponseV2)
+
+
+class CohereClient(BaseClient):
+    """Cohere API client implementation using the official Cohere Python library."""
+
+    def __init__(self, config: Dict[str, Any], console, verbose: bool):
+        """Initialize the Cohere API client with configuration."""
+        super().__init__(config, console, verbose)
+        self.api_key = config["API_KEY"]
+        self.model = config["MODEL"]
+        if not config["BASE_URL"] or "cohere" not in config["BASE_URL"]:
+            # BASE_URL can be empty, in which case we use the default base_url
+            self.base_url = "https://api.cohere.com"
+        else:
+            self.base_url = config["BASE_URL"]
+        self.base_url = self.base_url.rstrip("/")
+        if self.base_url.endswith("v2") or self.base_url.endswith("v1"):
+            self.base_url = self.base_url[:-2]
+
+        # Initialize the Cohere client with our custom configuration
+        self.client = ClientV2(
+            api_key=self.api_key,
+            base_url=self.base_url,
+            client_name="Yaicli",
+            timeout=self.timeout,
+        )
+
+    def _prepare_request_params(self, messages: List[Dict[str, str]]) -> Dict[str, Any]:
+        """Prepare the common request parameters for Cohere API calls."""
+        # P value must be between 0.01 and 0.99, default to 0.75 if outside this range, also cohere api default is 0.75
+        p = 0.75 if not (0.01 < self.config["TOP_P"] < 0.99) else self.config["TOP_P"]
+        return {
+            "messages": messages,
+            "model": self.model,
+            "temperature": self.config["TEMPERATURE"],
+            "max_tokens": self.config["MAX_TOKENS"],
+            "p": p,
+        }
+
+    def _process_completion_response(self, response: ChatResponse) -> Tuple[Optional[str], Optional[str]]:
+        """Process the response from a non-streamed Cohere completion request."""
+        try:
+            content = response.message.content
+            if not content:
+                return None, None
+            text = content[0].text
+            if not text:
+                return None, None
+            return text, None
+
+        except Exception as e:
+            self.console.print(f"Error processing Cohere response: {e}", style="red")
+            if self.verbose:
+                self.console.print(f"Response: {response}")
+            return None, None
+
+    def completion(self, messages: List[Dict[str, str]]) -> Tuple[Optional[str], Optional[str]]:
+        """Get a complete non-streamed response from the Cohere API."""
+        params = self._prepare_request_params(messages)
+
+        try:
+            response: ChatResponse = self.client.chat(**params)
+            return self._process_completion_response(response)
+        except ApiError as e:
+            self.console.print(f"Cohere API error: {e}", style="red")
+            if self.verbose:
+                self.console.print(f"Response: {e.body}")
+            return None, None
+
+    def stream_completion(self, messages: List[Dict[str, str]]) -> Iterator[Dict[str, Any]]:
+        """Connect to the Cohere API and yield parsed stream events."""
+        params = self._prepare_request_params(messages)
+
+        try:
+            for chunk in self.client.v2.chat_stream(**params):
+                # Skip message start/end events
+                if chunk.type in ("message-start", "message-end", "content-end"):  # type: ignore
+                    continue
+
+                # Safe attribute checking - skip if any required attribute is missing
+                if not hasattr(chunk, "delta"):
+                    continue
+
+                # At this point we know chunk has delta attribute
+                delta = getattr(chunk, "delta")
+                if delta is None or not hasattr(delta, "message"):
+                    continue
+
+                message = getattr(delta, "message")
+                if message is None or not hasattr(message, "content"):
+                    continue
+
+                content = getattr(message, "content")
+                if content is None or not hasattr(content, "text"):
+                    continue
+
+                # Access text safely
+                text = getattr(content, "text")
+                if text:
+                    yield {"type": EventTypeEnum.CONTENT, "chunk": text}
+
+        except ApiError as e:
+            self.console.print(f"Cohere API error during streaming: {e}", style="red")
+            yield {"type": EventTypeEnum.ERROR, "message": str(e)}
+        except Exception as e:
+            self.console.print(f"Unexpected error during Cohere streaming: {e}", style="red")
+            if self.verbose:
+                import traceback
+
+                traceback.print_exc()
+            yield {"type": EventTypeEnum.ERROR, "message": f"Unexpected stream error: {e}"}

yaicli/providers/openai.py

@@ -0,0 +1,176 @@
+from typing import Any, Dict, Iterator, List, Optional, Tuple
+
+import openai
+from openai import OpenAI
+from openai.types.chat.chat_completion import ChatCompletion
+from openai.types.chat.chat_completion_chunk import Choice, ChoiceDelta
+
+from yaicli.const import EventTypeEnum
+from yaicli.providers.base import BaseClient
+
+
+class OpenAIClient(BaseClient):
+    """OpenAI API client implementation using the official OpenAI Python library."""
+
+    def __init__(self, config: Dict[str, Any], console, verbose: bool):
+        """Initialize the OpenAI API client with configuration."""
+        super().__init__(config, console, verbose)
+        self.api_key = config["API_KEY"]
+        self.model = config["MODEL"]
+        self.base_url = config["BASE_URL"]
+
+        # Initialize the OpenAI client with our custom configuration
+        self.client = OpenAI(
+            api_key=self.api_key,
+            base_url=self.base_url,
+            timeout=self.timeout,
+            default_headers={"X-Title": "Yaicli"},
+            max_retries=2,  # Add retry logic for resilience
+        )
+
+    def _prepare_request_params(self, messages: List[Dict[str, str]], stream: bool) -> Dict[str, Any]:
+        """Prepare the common request parameters for OpenAI API calls."""
+        return {
+            "messages": messages,
+            "model": self.model,
+            "stream": stream,
+            "temperature": self.config["TEMPERATURE"],
+            "top_p": self.config["TOP_P"],
+            # Openai: This value is now deprecated in favor of max_completion_tokens
+            "max_tokens": self.config["MAX_TOKENS"],
+            "max_completion_tokens": self.config["MAX_TOKENS"],
+        }
+
+    def _process_completion_response(self, conpletion: ChatCompletion) -> Tuple[Optional[str], Optional[str]]:
+        """Process the response from a non-streamed OpenAI completion request."""
+        try:
+            # OpenAI SDK returns structured objects
+            content = conpletion.choices[0].message.content
+            reasoning = None
+
+            # Check for reasoning in model_extra
+            if hasattr(conpletion.choices[0].message, "model_extra") and conpletion.choices[0].message.model_extra:
+                extra = conpletion.choices[0].message.model_extra
+                if extra and "reasoning" in extra:
+                    reasoning = extra["reasoning"]
+
+            # If no reasoning in model_extra, try extracting from <think> tags
+            if reasoning is None and isinstance(content, str):
+                content = content.lstrip()
+                if content.startswith("<think>"):
+                    think_end = content.find("</think>")
+                    if think_end != -1:
+                        reasoning = content[7:think_end].strip()  # Start after <think>
+                        # Remove the <think> block from the main content
+                        content = content[think_end + 8 :].strip()  # Start after </think>
+
+            return content, reasoning
+        except Exception as e:
+            self.console.print(f"Error processing OpenAI response: {e}", style="red")
+            if self.verbose:
+                self.console.print(f"Response: {conpletion}")
+            return None, None
+
+    def completion(self, messages: List[Dict[str, str]]) -> Tuple[Optional[str], Optional[str]]:
+        """Get a complete non-streamed response from the OpenAI API."""
+        params = self._prepare_request_params(messages, stream=False)
+
+        try:
+            # Use context manager for proper resource management
+            with self.client.with_options(timeout=self.timeout) as client:
+                response: ChatCompletion = client.chat.completions.create(**params)
+                return self._process_completion_response(response)
+        except openai.APIConnectionError as e:
+            self.console.print(f"OpenAI connection error: {e}", style="red")
+            if self.verbose:
+                self.console.print(f"Underlying error: {e.__cause__}")
+            return None, None
+        except openai.RateLimitError as e:
+            self.console.print(f"OpenAI rate limit error (429): {e}", style="red")
+            return None, None
+        except openai.APIStatusError as e:
+            self.console.print(f"OpenAI API error (status {e.status_code}): {e}", style="red")
+            if self.verbose:
+                self.console.print(f"Response: {e.response}")
+            return None, None
+        except Exception as e:
+            self.console.print(f"Unexpected error during OpenAI completion: {e}", style="red")
+            if self.verbose:
+                import traceback
+
+                traceback.print_exc()
+            return None, None
+
+    def stream_completion(self, messages: List[Dict[str, str]]) -> Iterator[Dict[str, Any]]:
+        """Connect to the OpenAI API and yield parsed stream events.
+
+        Args:
+            messages: The list of message dictionaries to send to the API
+
+        Yields:
+            Event dictionaries with the following structure:
+                - type: The event type (from EventTypeEnum)
+                - chunk/message/reason: The content of the event
+        """
+        params: Dict[str, Any] = self._prepare_request_params(messages, stream=True)
+        in_reasoning: bool = False
+
+        try:
+            # Use context manager to ensure proper cleanup
+            with self.client.chat.completions.create(**params) as stream:
+                for chunk in stream:
+                    choices: List[Choice] = chunk.choices
+                    if not choices:
+                        # Some APIs may return empty choices upon reaching the end of content.
+                        continue
+                    choice: Choice = choices[0]
+                    delta: ChoiceDelta = choice.delta
+                    finish_reason: Optional[str] = choice.finish_reason
+
+                    # Process model_extra for reasoning content
+                    if hasattr(delta, "model_extra") and delta.model_extra:
+                        reasoning: Optional[str] = self._get_reasoning_content(delta.model_extra)
+                        if reasoning:
+                            yield {"type": EventTypeEnum.REASONING, "chunk": reasoning}
+                            in_reasoning = True
+                            continue
+
+                    # Process content delta
+                    if hasattr(delta, "content") and delta.content:
+                        content_chunk = delta.content
+                        if in_reasoning and content_chunk:
+                            # Send reasoning end signal before content
+                            in_reasoning = False
+                            yield {"type": EventTypeEnum.REASONING_END, "chunk": ""}
+                            yield {"type": EventTypeEnum.CONTENT, "chunk": content_chunk}
+                        elif content_chunk:
+                            yield {"type": EventTypeEnum.CONTENT, "chunk": content_chunk}
+
+                    # Process finish reason
+                    if finish_reason:
+                        # Send reasoning end signal if still in reasoning state
+                        if in_reasoning:
+                            in_reasoning = False
+                            yield {"type": EventTypeEnum.REASONING_END, "chunk": ""}
+                        yield {"type": EventTypeEnum.FINISH, "reason": finish_reason}
+
+        except openai.APIConnectionError as e:
+            self.console.print(f"OpenAI connection error during streaming: {e}", style="red")
+            if self.verbose:
+                self.console.print(f"Underlying error: {e.__cause__}")
+            yield {"type": EventTypeEnum.ERROR, "message": str(e)}
+        except openai.RateLimitError as e:
+            self.console.print(f"OpenAI rate limit error (429) during streaming: {e}", style="red")
+            yield {"type": EventTypeEnum.ERROR, "message": str(e)}
+        except openai.APIStatusError as e:
+            self.console.print(f"OpenAI API error (status {e.status_code}) during streaming: {e}", style="red")
+            if self.verbose:
+                self.console.print(f"Response: {e.response}")
+            yield {"type": EventTypeEnum.ERROR, "message": str(e)}
+        except Exception as e:
+            self.console.print(f"Unexpected error during OpenAI streaming: {e}", style="red")
+            if self.verbose:
+                import traceback
+
+                traceback.print_exc()
+            yield {"type": EventTypeEnum.ERROR, "message": f"Unexpected stream error: {e}"}

yaicli/roles.py

@@ -19,19 +19,19 @@ class Role:
         self, name: str, prompt: str, variables: Optional[Dict[str, Any]] = None, filepath: Optional[str] = None
     ):
         self.name = name
-        self.prompt = prompt
+        self._prompt = prompt
         if not variables:
             variables = {"_os": detect_os(cfg), "_shell": detect_shell(cfg)}
         self.variables = variables
         self.filepath = filepath
 
-        self.prompt = self.prompt.format(**self.variables)
+        self.prompt = self._prompt.format(**self.variables)
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert Role to dictionary for serialization"""
         return {
             "name": self.name,
-            "prompt": self.prompt,
+            "prompt": self._prompt,
         }
 
     @classmethod
@@ -51,13 +51,23 @@ class Role:
 class RoleManager:
     roles_dir: Path = ROLES_DIR
     console: Console = get_console()
+    _roles: Optional[Dict[str, Role]] = None
 
-    def __init__(self):
-        self.roles: Dict[str, Role] = self._load_roles()
+    def __new__(cls):
+        """Singleton class for RoleManager"""
+        if not hasattr(cls, "instance"):
+            cls.instance = super().__new__(cls)
+        return cls.instance
+
+    @property
+    def roles(self) -> Dict[str, Role]:
+        if self._roles is None:
+            self._roles = self._load_roles()
+        return self._roles
 
     def _load_roles(self) -> Dict[str, Role]:
         """Load all role configurations"""
-        roles = {}
+        roles: Dict[str, Role] = {}
         self.roles_dir.mkdir(parents=True, exist_ok=True)
 
         # Check if any role files exist
@@ -87,11 +97,34 @@ class RoleManager:
         # Ensure default roles exist
         for role_id, role_config in DEFAULT_ROLES.items():
             if role_id not in roles:
+                # Default role doesn't exist locally, create it
                 role_file = self.roles_dir / f"{role_id}.json"
                 filepath = str(role_file)
                 roles[role_id] = Role.from_dict(role_id, role_config, filepath)
                 with role_file.open("w", encoding="utf-8") as f:
                     json.dump(role_config, f, indent=2)
+            else:
+                # TODO: Maybe not necessary
+                # Check if the local role's prompt differs from the built-in one
+                local_role = roles[role_id]
+                builtin_prompt = role_config.get("prompt", "")
+
+                # Only show warning if ROLE_MODIFY_WARNING is enabled
+                if cfg["ROLE_MODIFY_WARNING"]:
+                    if local_role._prompt != builtin_prompt:
+                        self.console.print(
+                            f"[yellow]Warning:[/yellow] Local role '{role_id}' has a different prompt than the built-in role.",
+                            style="yellow",
+                        )
+                        self.console.print(
+                            "To reset to the built-in version, delete the local role file with: "
+                            f'[bold]ai --delete-role "{role_id}"[/bold]',
+                            style="dim",
+                        )
+                        self.console.print(
+                            "To disable this warning, set [bold]ROLE_MODIFY_WARNING=false[/bold] in your config file.",
+                            style="dim",
+                        )
 
         return roles
 
@@ -142,12 +175,12 @@ class RoleManager:
         return self.roles.get(role_id)
 
     @classmethod
-    def check_id_ok(cls, role_id: str):
+    def check_id_ok(cls, param: typer.CallbackParam, role_id: str):
         """Check if role exists by ID.
         This method is a cli option callback.
         If role does not exist, exit with error.
         """
-        if not role_id:
+        if not role_id or role_id == param.default:
             return role_id
         self = cls()
         if not self.role_exists(role_id):
@@ -216,11 +249,6 @@ class RoleManager:
             self.console.print(f"Role '{role_id}' does not exist", style="red")
             return False
 
-        # Don't allow deleting default roles
-        if role_id in DEFAULT_ROLES:
-            self.console.print(f"Cannot delete default role: '{role_id}'", style="red")
-            return False
-
         try:
             role = self.roles[role_id]
             if role.filepath:
@@ -244,5 +272,5 @@ class RoleManager:
                 role = Role.from_dict(DefaultRoleNames.DEFAULT, default_config)
 
         # Create a copy of the role with system variables
-        system_role = Role(name=role.name, prompt=role.prompt)
+        system_role = Role(name=role.name, prompt=role._prompt)
         return system_role.prompt

{yaicli-0.3.2.dist-info → yaicli-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: yaicli
-Version: 0.3.2
+Version: 0.4.0
 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
@@ -213,9 +213,10 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.9
+Requires-Dist: cohere>=5.15.0
 Requires-Dist: distro>=1.9.0
 Requires-Dist: httpx>=0.28.1
-Requires-Dist: jmespath>=1.0.1
+Requires-Dist: openai>=1.76.0
 Requires-Dist: prompt-toolkit>=3.0.50
 Requires-Dist: rich>=13.9.4
 Requires-Dist: socksio>=1.0.0
@@ -235,9 +236,7 @@ generate and execute shell commands, or get quick answers without leaving your w
 
 **Supports both standard and deep reasoning models across all major LLM providers.**
 
-<p align="center">
-  <img src="https://vhs.charm.sh/vhs-5U1BBjJkTUBReRswsSgIVx.gif" alt="YAICLI Chat Demo" width="85%">
-</p>
+<a href="https://asciinema.org/a/vyreM0n576GjGL2asjI3QzUIY" target="_blank"><img src="https://asciinema.org/a/vyreM0n576GjGL2asjI3QzUIY.svg" width="85%"/></a>
 
 > [!NOTE]
 > YAICLI is actively developed. While core functionality is stable, some features may evolve in future releases.
@@ -329,10 +328,6 @@ MODEL = gpt-4o
 SHELL_NAME = auto
 OS_NAME = auto
 
-# API paths (usually no need to change for OpenAI compatible APIs)
-COMPLETION_PATH = chat/completions
-ANSWER_PATH = choices[0].message.content
-
 # true: streaming response, false: non-streaming
 STREAM = true
 
@@ -362,29 +357,28 @@ MAX_SAVED_CHATS = 20
 
 ### Configuration Options Reference
 
-| Option              | Description                                 | Default                      | Env Variable            |
-|---------------------|---------------------------------------------|------------------------------|-------------------------|
-| `PROVIDER`          | LLM provider (openai, claude, cohere, etc.) | `openai`                     | `YAI_PROVIDER`          |
-| `BASE_URL`          | API endpoint URL                            | `https://api.openai.com/v1`  | `YAI_BASE_URL`          |
-| `API_KEY`           | Your API key                                | -                            | `YAI_API_KEY`           |
-| `MODEL`             | LLM model to use                            | `gpt-4o`                     | `YAI_MODEL`             |
-| `SHELL_NAME`        | Shell type                                  | `auto`                       | `YAI_SHELL_NAME`        |
-| `OS_NAME`           | Operating system                            | `auto`                       | `YAI_OS_NAME`           |
-| `COMPLETION_PATH`   | API completion path                         | `chat/completions`           | `YAI_COMPLETION_PATH`   |
-| `ANSWER_PATH`       | JSON path for response                      | `choices[0].message.content` | `YAI_ANSWER_PATH`       |
-| `STREAM`            | Enable streaming                            | `true`                       | `YAI_STREAM`            |
-| `TIMEOUT`           | API timeout (seconds)                       | `60`                         | `YAI_TIMEOUT`           |
-| `INTERACTIVE_ROUND` | Interactive mode rounds                     | `25`                         | `YAI_INTERACTIVE_ROUND` |
-| `CODE_THEME`        | Syntax highlighting theme                   | `monokai`                    | `YAI_CODE_THEME`        |
-| `TEMPERATURE`       | Response randomness                         | `0.7`                        | `YAI_TEMPERATURE`       |
-| `TOP_P`             | Top-p sampling                              | `1.0`                        | `YAI_TOP_P`             |
-| `MAX_TOKENS`        | Max response tokens                         | `1024`                       | `YAI_MAX_TOKENS`        |
-| `MAX_HISTORY`       | Max history entries                         | `500`                        | `YAI_MAX_HISTORY`       |
-| `AUTO_SUGGEST`      | Enable history suggestions                  | `true`                       | `YAI_AUTO_SUGGEST`      |
-| `SHOW_REASONING`    | Enable reasoning display                    | `true`                       | `YAI_SHOW_REASONING`    |
-| `JUSTIFY`           | Text alignment                              | `default`                    | `YAI_JUSTIFY`           |
-| `CHAT_HISTORY_DIR`  | Chat history directory                      | `<tempdir>/yaicli/history`   | `YAI_CHAT_HISTORY_DIR`  |
-| `MAX_SAVED_CHATS`   | Max saved chats                             | `20`                         | `YAI_MAX_SAVED_CHATS`   |
+| Option                | Description                                 | Default                     | Env Variable              |
+| --------------------- | ------------------------------------------- | --------------------------- | ------------------------- |
+| `PROVIDER`            | LLM provider (openai, claude, cohere, etc.) | `openai`                    | `YAI_PROVIDER`            |
+| `BASE_URL`            | API endpoint URL                            | `https://api.openai.com/v1` | `YAI_BASE_URL`            |
+| `API_KEY`             | Your API key                                | -                           | `YAI_API_KEY`             |
+| `MODEL`               | LLM model to use                            | `gpt-4o`                    | `YAI_MODEL`               |
+| `SHELL_NAME`          | Shell type                                  | `auto`                      | `YAI_SHELL_NAME`          |
+| `OS_NAME`             | Operating system                            | `auto`                      | `YAI_OS_NAME`             |
+| `STREAM`              | Enable streaming                            | `true`                      | `YAI_STREAM`              |
+| `TIMEOUT`             | API timeout (seconds)                       | `60`                        | `YAI_TIMEOUT`             |
+| `INTERACTIVE_ROUND`   | Interactive mode rounds                     | `25`                        | `YAI_INTERACTIVE_ROUND`   |
+| `CODE_THEME`          | Syntax highlighting theme                   | `monokai`                   | `YAI_CODE_THEME`          |
+| `TEMPERATURE`         | Response randomness                         | `0.7`                       | `YAI_TEMPERATURE`         |
+| `TOP_P`               | Top-p sampling                              | `1.0`                       | `YAI_TOP_P`               |
+| `MAX_TOKENS`          | Max response tokens                         | `1024`                      | `YAI_MAX_TOKENS`          |
+| `MAX_HISTORY`         | Max history entries                         | `500`                       | `YAI_MAX_HISTORY`         |
+| `AUTO_SUGGEST`        | Enable history suggestions                  | `true`                      | `YAI_AUTO_SUGGEST`        |
+| `SHOW_REASONING`      | Enable reasoning display                    | `true`                      | `YAI_SHOW_REASONING`      |
+| `JUSTIFY`             | Text alignment                              | `default`                   | `YAI_JUSTIFY`             |
+| `CHAT_HISTORY_DIR`    | Chat history directory                      | `<tempdir>/yaicli/history`  | `YAI_CHAT_HISTORY_DIR`    |
+| `MAX_SAVED_CHATS`     | Max saved chats                             | `20`                        | `YAI_MAX_SAVED_CHATS`     |
+| `ROLE_MODIFY_WARNING` | Warn user when modifying role               | `true`                      | `YAI_ROLE_MODIFY_WARNING` |
 
 ### LLM Provider Configuration
 
@@ -393,52 +387,23 @@ other providers.
 
 #### Pre-configured Provider Settings
 
-| Provider                       | BASE_URL                                                  | COMPLETION_PATH    | ANSWER_PATH                  |
-|--------------------------------|-----------------------------------------------------------|--------------------|------------------------------|
-| **OpenAI** (default)           | `https://api.openai.com/v1`                               | `chat/completions` | `choices[0].message.content` |
-| **Claude** (native API)        | `https://api.anthropic.com/v1`                            | `messages`         | `content[0].text`            |
-| **Claude** (OpenAI-compatible) | `https://api.anthropic.com/v1/openai`                     | `chat/completions` | `choices[0].message.content` |
-| **Cohere**                     | `https://api.cohere.com/v2`                               | `chat`             | `message.content[0].text`    |
-| **Google Gemini**              | `https://generativelanguage.googleapis.com/v1beta/openai` | `chat/completions` | `choices[0].message.content` |
+`provider` is not case sensitive.
+
+Claude and gemini native api will support soon.
+
+| Provider                       | BASE_URL                                                  |
+| ------------------------------ | --------------------------------------------------------- |
+| **OpenAI** (default)           | `https://api.openai.com/v1`                               |
+| **Claude** (native API)        | `https://api.anthropic.com/v1`                            |
+| **Claude** (OpenAI-compatible) | `https://api.anthropic.com/v1/openai`                     |
+| **Cohere**                     | `https://api.cohere.com`                                  |
+| **Gemini**                     | `https://generativelanguage.googleapis.com/v1beta/openai` |
 
 > **Note**: Many providers offer OpenAI-compatible endpoints that work with the default settings.
 >
 > - Google Gemini: https://ai.google.dev/gemini-api/docs/openai
 > - Claude: https://docs.anthropic.com/en/api/openai-sdk
 
-#### Custom Provider Configuration Guide
-
-To configure a custom provider:
-
-1. **Find the API Endpoint**:
-
-    - Check the provider's API documentation for their chat completion endpoint
-
-2. **Identify the Response Structure**:
-
-    - Look at the JSON response format to find where the text content is located
-
-3. **Set the Path Expression**:
-    - Use jmespath syntax to specify the path to the text content
-
-**Example**: For Claude's native API, the response looks like:
-
-```json
-{
-  "content": [
-    {
-      "text": "Hi! My name is Claude.",
-      "type": "text"
-    }
-  ],
-  "id": "msg_013Zva2CMHLNnXjNJJKqJ2EF",
-  "model": "claude-3-7-sonnet-20250219",
-  "role": "assistant"
-}
-```
-
-The path to extract the text is: `content.[0].text`
-
 ### Syntax Highlighting Themes
 
 YAICLI supports all Pygments syntax highlighting themes. You can set your preferred theme in the config file:
@@ -449,7 +414,7 @@ CODE_THEME = monokai
 
 Browse available themes at: https://pygments.org/styles/
 
-![monokai theme example](artwork/monokia.png)
+![monokia theme example](artwork/monokia.png)
 
 ## 🚀 Usage
 
@@ -849,12 +814,10 @@ YAICLI is designed with a modular architecture that separates concerns and makes
 ### Dependencies
 
 | Library                                                         | Purpose                                            |
-|-----------------------------------------------------------------|----------------------------------------------------|
+| --------------------------------------------------------------- | -------------------------------------------------- |
 | [Typer](https://typer.tiangolo.com/)                            | Command-line interface with type hints             |
 | [Rich](https://rich.readthedocs.io/)                            | Terminal formatting and beautiful display          |
 | [prompt_toolkit](https://python-prompt-toolkit.readthedocs.io/) | Interactive input with history and auto-completion |
-| [httpx](https://www.python-httpx.org/)                          | Modern HTTP client with async support              |
-| [jmespath](https://jmespath.org/)                               | JSON data extraction                               |
 
 ## 👨‍💻 Contributing
 

yaicli-0.4.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+pyproject.toml,sha256=qBb73j9dLZ13fGtQDN81nxfqfpUVs5HNDq5hyfwxOtQ,1540
+yaicli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+yaicli/chat_manager.py,sha256=I7BAMz91FLYT6x69wbomtAGLx0WsoTwS4Wo0MgP6P9I,10644
+yaicli/cli.py,sha256=kqUXSDQej4lMefI2QQpM-Do01Be6CUphh65_Nu7sDck,22948
+yaicli/config.py,sha256=nfnrMz_Q78oHqDVvWSrQRGFyBl-q5MScvnYlQRWDQ_g,6515
+yaicli/console.py,sha256=291F4hGksJtxYpg_mehepCIJ-eB2MaDNIyv1JAMgJ1Y,1985
+yaicli/const.py,sha256=WjNzJAP37XizJYyd-LBTWxZAfJ2Nj7mj-eECPMOr3Do,6927
+yaicli/entry.py,sha256=Yp0Z--x-7dowrz-h8hJJ4_BoCzuDjS11NcM8YgFzUoY,7460
+yaicli/exceptions.py,sha256=ndedSdE0uaxxHrWN944BkbhMfRMSMxGDfmqmCKCGJco,924
+yaicli/history.py,sha256=s-57X9FMsaQHF7XySq1gGH_jpd_cHHTYafYu2ECuG6M,2472
+yaicli/printer.py,sha256=nXpralD5qZJQga3OTdEPhj22g7UoF-4mJbZeOtWXojo,12430
+yaicli/render.py,sha256=mB1OT9859_PTwI9f-KY802lPaeQXKRw6ls_5jN21jWc,511
+yaicli/roles.py,sha256=LdPqpdBKQr_eX7PV7iwRtFT0_trmWXVvZUmb3OMhK0w,10582
+yaicli/utils.py,sha256=MLvb-C5n19AD9Z1nW4Z3Z43ZKNH8STxQmNDnL7mq26E,4490
+yaicli/providers/__init__.py,sha256=zYXcnV8HdNeLEPRJEeSgSboNuphkdA1PrbB8MkDErAk,1243
+yaicli/providers/base.py,sha256=Q6QoxrIVqDYcUp1-FY5O-LT33rKSb1jeXGnrbd4Xlog,1870
+yaicli/providers/cohere.py,sha256=m_HIHm6NEd1VG4wCmDKYn3KHo2jzC98FsfxRzjWR8-M,5411
+yaicli/providers/openai.py,sha256=CKNN3wDsnCEOwZAMrARi43-AV65WgJ7AvHONgvpLZw8,8541
+yaicli-0.4.0.dist-info/METADATA,sha256=oeusTm4BZ1Dvow0IF_c2urp_onnV41OgE7QzwcuP09c,43917
+yaicli-0.4.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+yaicli-0.4.0.dist-info/entry_points.txt,sha256=iMhGm3btBaqrknQoF6WCg5sdx69ZyNSC73tRpCcbcLw,63
+yaicli-0.4.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+yaicli-0.4.0.dist-info/RECORD,,

yaicli/api.py

@@ -1,316 +0,0 @@
-import json
-from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
-
-import httpx
-import jmespath
-from rich.console import Console
-
-from yaicli.const import (
-    DEFAULT_BASE_URL,
-    DEFAULT_COMPLETION_PATH,
-    DEFAULT_MODEL,
-    EventTypeEnum,
-)
-
-
-def parse_stream_line(line: Union[bytes, str], console: Console, verbose: bool) -> Optional[dict]:
-    """(Helper Function) Parse a single line from the SSE stream response."""
-    if not isinstance(line, (bytes, str)):
-        if verbose:
-            console.print(f"Warning: Received non-string/bytes line: {line!r}", style="yellow")
-        return None
-    line_str: str = line.decode("utf-8") if isinstance(line, bytes) else line
-    line_str = line_str.strip()
-    if not line_str or not line_str.startswith("data: "):
-        return None
-
-    data_part = line_str[6:]
-    if data_part.lower() == "[done]":
-        return {"done": True}  # Use a specific dictionary to signal DONE
-
-    try:
-        json_data = json.loads(data_part)
-        if not isinstance(json_data, dict) or "choices" not in json_data:
-            if verbose:
-                console.print(f"Warning: Invalid stream data format (missing 'choices'): {data_part}", style="yellow")
-            return None
-        return json_data
-    except json.JSONDecodeError:
-        console.print("Error decoding response JSON", style="red")
-        if verbose:
-            console.print(f"Invalid JSON data: {data_part}", style="red")
-        return None
-
-
-class ApiClient:
-    """Handles communication with the LLM API."""
-
-    def __init__(self, config: Dict[str, Any], console: Console, verbose: bool, client: Optional[httpx.Client] = None):
-        """Initialize the API client with configuration."""
-        self.config = config
-        self.console = console
-        self.verbose = verbose
-        self.base_url = str(config.get("BASE_URL", DEFAULT_BASE_URL))
-        self.completion_path = str(config.get("COMPLETION_PATH", DEFAULT_COMPLETION_PATH))
-        self.api_key = str(config.get("API_KEY", ""))
-        self.model = str(config.get("MODEL", DEFAULT_MODEL))
-        self.timeout = self.config["TIMEOUT"]
-        self.client = client or httpx.Client(timeout=self.config["TIMEOUT"])
-
-    def _prepare_request_body(self, messages: List[Dict[str, str]], stream: bool) -> Dict[str, Any]:
-        """Prepare the common request body for API calls."""
-        return {
-            "messages": messages,
-            "model": self.model,
-            "stream": stream,
-            "temperature": self.config["TEMPERATURE"],
-            "top_p": self.config["TOP_P"],
-            "max_tokens": self.config[
-                "MAX_TOKENS"
-            ],  # Openai: This value is now deprecated in favor of max_completion_tokens
-            "max_completion_tokens": self.config["MAX_TOKENS"],
-        }
-
-    def _handle_api_error(self, e: httpx.HTTPError) -> None:
-        """Handle and print HTTP errors consistently."""
-        if isinstance(e, httpx.TimeoutException):
-            self.console.print(f"Error: API request timed out after {self.timeout} seconds. {e}", style="red")
-        elif isinstance(e, httpx.HTTPStatusError):
-            self.console.print(f"Error calling API: {e.response.status_code} {e.response.reason_phrase}", style="red")
-            if self.verbose:
-                self.console.print(f"Response Text: {e.response.text}")
-        elif isinstance(e, httpx.RequestError):
-            api_url = self.get_completion_url()
-            self.console.print(f"Error: Could not connect to API endpoint '{api_url}'. {e}", style="red")
-        else:
-            self.console.print(f"An unexpected HTTP error occurred: {e}", style="red")
-
-    def get_completion_url(self) -> str:
-        """Get the full completion URL."""
-        base_url = self.base_url.rstrip("/")
-        completion_path = self.completion_path.lstrip("/")
-        return f"{base_url}/{completion_path}"
-
-    def get_headers(self) -> Dict[str, str]:
-        """Get the request headers."""
-        return {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json",
-            "X-Title": "Yaicli",
-        }
-
-    def _process_completion_response(self, response_json: Dict[str, Any]) -> Tuple[Optional[str], Optional[str]]:
-        """Process the JSON response from a non-streamed completion request."""
-        answer_path = self.config["ANSWER_PATH"]
-        message_path = answer_path.rsplit(".", 1)[0]
-
-        # Extract content and reasoning using JMESPath
-        content = jmespath.search(answer_path, response_json)
-        message = jmespath.search(message_path, response_json)
-        reasoning = self._get_reasoning_content(
-            message
-        )  # Reuse reasoning extraction if applicable to the whole message
-
-        # Process string content and extract reasoning from <think> tags if present
-        if isinstance(content, str):
-            content = content.lstrip()
-            if content.startswith("<think>"):
-                think_end = content.find("</think>")
-                if think_end != -1:
-                    # Extract reasoning from <think> tag only if not already found via message path
-                    if reasoning is None:
-                        reasoning = content[7:think_end].strip()  # Start after <think>
-                    # Remove the <think> block from the main content
-                    content = content[think_end + 8 :].strip()  # Start after </think>
-            # If it doesn't start with <think>, or if </think> wasn't found, return content as is
-            return content, reasoning
-        elif content:
-            self.console.print(
-                f"Warning: Unexpected content type from API: {type(content)}. Path: {answer_path}", style="yellow"
-            )
-            # Attempt to convert unexpected content to string, return existing reasoning
-            return str(content), reasoning
-        else:
-            self.console.print(f"Warning: Could not extract content using JMESPath '{answer_path}'.", style="yellow")
-            if self.verbose:
-                self.console.print(f"API Response: {response_json}")
-            return None, reasoning
-
-    def completion(self, messages: List[Dict[str, str]]) -> Tuple[Optional[str], Optional[str]]:
-        """Get a complete non-streamed response from the API."""
-        url = self.get_completion_url()
-        body = self._prepare_request_body(messages, stream=False)
-        headers = self.get_headers()
-
-        try:
-            response = self.client.post(url, json=body, headers=headers)
-            response.raise_for_status()
-            response_json = response.json()
-            # Delegate processing to the helper method
-            return self._process_completion_response(response_json)
-
-        except httpx.HTTPError as e:
-            self._handle_api_error(e)
-            return None, None
-
-    def _handle_http_error(self, e: httpx.HTTPStatusError) -> Dict[str, Any]:
-        """Handle HTTP errors during streaming and return an error event.
-
-        Args:
-            e: The HTTP status error that occurred
-
-        Returns:
-            An error event dictionary to be yielded to the client
-        """
-        error_body = e.response.read()
-        self._handle_api_error(e)
-
-        try:
-            error_json = json.loads(error_body)
-            error_message = error_json.get("error", {}).get("message")
-        except (json.JSONDecodeError, AttributeError):
-            error_message = None
-
-        if not error_message:
-            error_message = error_body.decode() if error_body else str(e)
-
-        return {"type": EventTypeEnum.ERROR, "message": error_message}
-
-    def _process_stream_chunk(
-        self, parsed_data: Dict[str, Any], in_reasoning: bool
-    ) -> Iterator[Tuple[Dict[str, Any], bool]]:
-        """Process a single chunk from the stream and yield events with updated reasoning state.
-
-        Args:
-            parsed_data: The parsed JSON data from a streamline
-            in_reasoning: Whether we're currently in a reasoning state
-
-        Yields:
-            A tuple containing:
-                - An event dictionary to yield to the client
-                - The updated reasoning state
-        """
-        # Handle stream errors
-        if "error" in parsed_data:
-            error_msg = parsed_data["error"].get("message", "Unknown error in stream data")
-            self.console.print(f"Error in stream data: {error_msg}", style="red")
-            yield {"type": EventTypeEnum.ERROR, "message": error_msg}, in_reasoning
-            return
-
-        # Get and validate the choice
-        choices = parsed_data.get("choices", [])
-        if not choices or not isinstance(choices, list):
-            if self.verbose:
-                self.console.print(f"Skipping stream chunk with no choices: {parsed_data}", style="dim")
-            return
-
-        choice = choices[0]
-        if not isinstance(choice, dict):
-            if self.verbose:
-                self.console.print(f"Skipping stream chunk with invalid choice structure: {choice}", style="dim")
-            return
-
-        # Get content from delta
-        delta = choice.get("delta", {})
-        if not isinstance(delta, dict):
-            if self.verbose:
-                self.console.print(f"Skipping stream chunk with invalid delta structure: {delta}", style="dim")
-            return
-
-        # Process content
-        reason = self._get_reasoning_content(delta)
-        content_chunk = delta.get("content", "")
-        finish_reason = choice.get("finish_reason")
-
-        # Yield events based on content type
-        if reason is not None:
-            in_reasoning = True
-            yield {"type": EventTypeEnum.REASONING, "chunk": reason}, in_reasoning
-        elif in_reasoning and content_chunk and isinstance(content_chunk, str):
-            # Signal the end of reasoning before yielding content
-            in_reasoning = False
-            yield {"type": EventTypeEnum.REASONING_END, "chunk": ""}, in_reasoning
-            yield {"type": EventTypeEnum.CONTENT, "chunk": content_chunk}, in_reasoning
-        elif content_chunk and isinstance(content_chunk, str):
-            yield {"type": EventTypeEnum.CONTENT, "chunk": content_chunk}, in_reasoning
-
-        if finish_reason:
-            yield {"type": EventTypeEnum.FINISH, "reason": finish_reason}, in_reasoning
-
-    def stream_completion(self, messages: List[Dict[str, str]]) -> Iterator[Dict[str, Any]]:
-        """Connect to the API and yield parsed stream events.
-
-        This method handles the streaming API connection and processes the response,
-        yielding events that can be consumed by the client. It handles various types
-        of content including regular content and reasoning content.
-
-        Args:
-            messages: The list of message dictionaries to send to the API
-
-        Yields:
-            Event dictionaries with the following structure:
-                - type: The event type (from EventTypeEnum)
-                - chunk/message/reason: The content of the event
-        """
-        url = self.get_completion_url()
-        body = self._prepare_request_body(messages, stream=True)
-        headers = self.get_headers()
-        in_reasoning = False
-
-        try:
-            with self.client.stream("POST", url, json=body, headers=headers) as response:
-                try:
-                    response.raise_for_status()
-                except httpx.HTTPStatusError as e:
-                    yield self._handle_http_error(e)
-                    return
-
-                # Process the streamline by line
-                for line in response.iter_lines():
-                    parsed_data = parse_stream_line(line, self.console, self.verbose)
-                    if parsed_data is None:
-                        continue
-                    if parsed_data.get("done"):
-                        break
-
-                    # Process chunks and yield events
-                    for event, updated_state in self._process_stream_chunk(parsed_data, in_reasoning):
-                        in_reasoning = updated_state
-                        # event: {type: str, Optional[chunk]: str, Optional[message]: str, Optional[reason]: str}
-                        yield event
-
-        except httpx.HTTPError as e:
-            self._handle_api_error(e)
-            yield {"type": EventTypeEnum.ERROR, "message": str(e)}
-        except Exception as e:
-            self.console.print(f"An unexpected error occurred during streaming: {e}", style="red")
-            if self.verbose:
-                import traceback
-
-                traceback.print_exc()
-            yield {"type": EventTypeEnum.ERROR, "message": f"Unexpected stream error: {e}"}
-
-    def _get_reasoning_content(self, delta: dict) -> Optional[str]:
-        """Extract reasoning content from delta if available based on specific keys.
-
-        This method checks for various keys that might contain reasoning content
-        in different API implementations.
-
-        Args:
-            delta: The delta dictionary from the API response
-
-        Returns:
-            The reasoning content string if found, None otherwise
-        """
-        if not delta:
-            return None
-        # reasoning_content: deepseek/infi-ai
-        # reasoning: openrouter
-        # <think> block implementation not in here
-        for key in ("reasoning_content", "reasoning"):
-            # Check if the key exists and its value is a non-empty string
-            value = delta.get(key)
-            if isinstance(value, str) and value:
-                return value
-
-        return None  # Return None if no relevant key with a string value is found

yaicli-0.3.2.dist-info/RECORD

@@ -1,20 +0,0 @@
-pyproject.toml,sha256=C7FTGTVlazP67RAED5c9JjzINHUfFe7xcu05LrZv1mk,1519
-yaicli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-yaicli/api.py,sha256=9kRozzxBKduQsda3acnxzvOD9wRLL0cH182L4ddHY8E,13666
-yaicli/chat_manager.py,sha256=I7BAMz91FLYT6x69wbomtAGLx0WsoTwS4Wo0MgP6P9I,10644
-yaicli/cli.py,sha256=z5t4XxKcl4MRGMTaASr0bc9PiidPpoSaBsgJd6d69-Y,22850
-yaicli/config.py,sha256=xtzgXApM93zCqSUxmVSBdph0co_NKfEUU3hWtPe8qvM,6236
-yaicli/console.py,sha256=291F4hGksJtxYpg_mehepCIJ-eB2MaDNIyv1JAMgJ1Y,1985
-yaicli/const.py,sha256=iOQNG6M4EBmKgbwZdNqRsHrcQ7Od1nKOyLAqUhfMEBM,7020
-yaicli/entry.py,sha256=Yp0Z--x-7dowrz-h8hJJ4_BoCzuDjS11NcM8YgFzUoY,7460
-yaicli/exceptions.py,sha256=ndedSdE0uaxxHrWN944BkbhMfRMSMxGDfmqmCKCGJco,924
-yaicli/history.py,sha256=s-57X9FMsaQHF7XySq1gGH_jpd_cHHTYafYu2ECuG6M,2472
-yaicli/printer.py,sha256=nXpralD5qZJQga3OTdEPhj22g7UoF-4mJbZeOtWXojo,12430
-yaicli/render.py,sha256=mB1OT9859_PTwI9f-KY802lPaeQXKRw6ls_5jN21jWc,511
-yaicli/roles.py,sha256=bhXpLnGTPRZp3-K1Tt6ppTsuG2v9S0RAXikfMFhDs_U,9144
-yaicli/utils.py,sha256=MLvb-C5n19AD9Z1nW4Z3Z43ZKNH8STxQmNDnL7mq26E,4490
-yaicli-0.3.2.dist-info/METADATA,sha256=YHnAg8uWg41eBr1GwnMO4ch5S_sf1x2zdTnqlGQm-5g,45320
-yaicli-0.3.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-yaicli-0.3.2.dist-info/entry_points.txt,sha256=iMhGm3btBaqrknQoF6WCg5sdx69ZyNSC73tRpCcbcLw,63
-yaicli-0.3.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-yaicli-0.3.2.dist-info/RECORD,,