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

yaicli/chat_manager.py

@@ -1,290 +0,0 @@
-import json
-import time
-from abc import ABC, abstractmethod
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, List, Optional, TypedDict, Union
-
-from rich.console import Console
-
-from yaicli.config import Config, cfg
-from yaicli.console import get_console
-from yaicli.utils import option_callback
-
-
-class ChatFileInfo(TypedDict):
-    """Chat info, parse chat filename and store metadata"""
-
-    index: int
-    path: str
-    title: str
-    date: str
-    timestamp: int
-
-
-class ChatsMap(TypedDict):
-    """Chat info cache for chat manager"""
-
-    title: Dict[str, ChatFileInfo]
-    index: Dict[int, ChatFileInfo]
-
-
-class ChatManager(ABC):
-    """Abstract base class that defines the chat manager interface"""
-
-    @abstractmethod
-    def make_chat_title(self, prompt: Optional[str] = None) -> str:
-        """Make a chat title from a given full prompt"""
-        pass
-
-    @abstractmethod
-    def save_chat(self, history: List[Dict[str, Any]], title: Optional[str] = None) -> str:
-        """Save a chat and return the chat title"""
-        pass
-
-    @abstractmethod
-    def list_chats(self) -> List[ChatFileInfo]:
-        """List all saved chats and return the chat list"""
-        pass
-
-    @abstractmethod
-    def refresh_chats(self) -> None:
-        """Force refresh the chat list"""
-        pass
-
-    @abstractmethod
-    def load_chat_by_index(self, index: int) -> Union[ChatFileInfo, Dict]:
-        """Load a chat by index and return the chat data"""
-        pass
-
-    @abstractmethod
-    def load_chat_by_title(self, title: str) -> Union[ChatFileInfo, Dict]:
-        """Load a chat by title and return the chat data"""
-        pass
-
-    @abstractmethod
-    def delete_chat(self, index: int) -> bool:
-        """Delete a chat by index and return success status"""
-        pass
-
-    @abstractmethod
-    def validate_chat_index(self, index: int) -> bool:
-        """Validate a chat index and return success status"""
-        pass
-
-
-class FileChatManager(ChatManager):
-    """File system based chat manager implementation"""
-
-    console: Console = get_console()
-    config: Config = cfg
-    chat_dir = Path(config["CHAT_HISTORY_DIR"])
-    max_saved_chats = config["MAX_SAVED_CHATS"]
-    chat_dir.mkdir(parents=True, exist_ok=True)
-
-    def __init__(self):
-        self._chats_map: Optional[ChatsMap] = None  # Cache for chat map
-
-    @property
-    def chats_map(self) -> ChatsMap:
-        """Get the map of chats, loading from disk only when needed"""
-        if self._chats_map is None:
-            self._load_chats()
-        return self._chats_map or {"index": {}, "title": {}}
-
-    @classmethod
-    @option_callback
-    def print_list_option(cls, _: Any):
-        """Print the list of chats"""
-        cls.console.print("Finding Chats...")
-        c = -1
-        for c, file in enumerate(sorted(cls.chat_dir.glob("*.json"), key=lambda f: f.stat().st_mtime)):
-            info: ChatFileInfo = cls._parse_filename(file, c + 1)
-            cls.console.print(f"{c + 1}. {info['title']} ({info['date']})")
-        if c == -1:
-            cls.console.print("No chats found", style="dim")
-
-    def make_chat_title(self, prompt: Optional[str] = None) -> str:
-        """Make a chat title from a given full prompt"""
-        if prompt:
-            return prompt[:100]
-        else:
-            return f"Chat-{int(time.time())}"
-
-    def validate_chat_index(self, index: int) -> bool:
-        """Validate a chat index and return success status"""
-        return index > 0 and index in self.chats_map["index"]
-
-    def refresh_chats(self) -> None:
-        """Force refresh the chat list from disk"""
-        self._load_chats()
-
-    @staticmethod
-    def _parse_filename(chat_file: Path, index: int) -> ChatFileInfo:
-        """Parse a chat filename and extract metadata"""
-        # filename: "20250421-214005-title-meaning of life"
-        filename = chat_file.stem
-        parts = filename.split("-")
-        title_str_len = 6  # "title-" marker length
-
-        # Check if the filename has the expected format
-        if len(parts) >= 4 and "title" in parts:
-            str_title_index = filename.find("title")
-            if str_title_index == -1:
-                # If "title" is not found, use full filename as the title
-                # Just in case, fallback to use fullname, but this should never happen when `len(parts) >= 4 and "title" in parts`
-                str_title_index = 0
-                title_str_len = 0
-
-            # "20250421-214005-title-meaning of life" ==> "meaning of life"
-            title = filename[str_title_index + title_str_len :]
-            date_ = parts[0]
-            time_ = parts[1]
-            # Format date
-            date_str = f"{date_[:4]}-{date_[4:6]}-{date_[6:]} {time_[:2]}:{time_[2:4]}"
-
-            # Calculate timestamp from date parts
-            try:
-                date_time_str = f"{date_}{time_}"
-                timestamp = int(datetime.strptime(date_time_str, "%Y%m%d%H%M%S").timestamp())
-            except ValueError:
-                timestamp = 0
-        else:
-            # Fallback for files that don't match expected format
-            title = filename
-            date_str = ""
-            timestamp = 0
-
-        # The actual title is stored in the JSON file, so we'll use that when loading
-        # This is just for the initial listing before the file is opened
-        return {
-            "index": index,
-            "path": str(chat_file),
-            "title": title,
-            "date": date_str,
-            "timestamp": timestamp,
-        }
-
-    def _load_chats(self) -> None:
-        """Load chats from disk into memory"""
-        chat_files = sorted(list(self.chat_dir.glob("*.json")), reverse=True)
-        chats_map: ChatsMap = {"title": {}, "index": {}}
-
-        for i, chat_file in enumerate(chat_files[: self.max_saved_chats]):
-            try:
-                info = self._parse_filename(chat_file, i + 1)
-                chats_map["title"][info["title"]] = info
-                chats_map["index"][i + 1] = info
-            except Exception as e:
-                # Log the error but continue processing other files
-                self.console.print(f"Error parsing session file {chat_file}: {e}", style="dim")
-                continue
-
-        self._chats_map = chats_map
-
-    def list_chats(self) -> List[ChatFileInfo]:
-        """List all saved chats and return the chat list"""
-        return list(self.chats_map["index"].values())
-
-    def save_chat(self, history: List[Dict[str, Any]], title: Optional[str] = None) -> str:
-        """Save chat history to the file system, overwriting existing chats with the same title.
-
-        If no title is provided, the chat will be saved with a default title.
-        The default title is "Chat-{current timestamp}".
-
-        Args:
-            history (List[Dict[str, Any]]): The chat history to save
-            title (Optional[str]): The title of the chat provided by the user
-
-        Returns:
-            str: The title of the saved chat
-        """
-        history = history or []
-
-        save_title = title or f"Chat-{int(time.time())}"
-        save_title = self.make_chat_title(save_title)
-
-        # Check for existing session with the same title and delete it
-        existing_chat = self.chats_map["title"].get(save_title)
-        if existing_chat:
-            try:
-                existing_path = Path(existing_chat["path"])
-                existing_path.unlink()
-            except OSError as e:
-                self.console.print(
-                    f"Warning: Could not delete existing chat file {existing_chat['path']}: {e}",
-                    style="dim",
-                )
-
-        timestamp = datetime.now().astimezone().strftime("%Y%m%d-%H%M%S")
-        filename = f"{timestamp}-title-{save_title}.json"
-        filepath = self.chat_dir / filename
-
-        try:
-            with open(filepath, "w", encoding="utf-8") as f:
-                json.dump({"history": history, "title": save_title}, f, ensure_ascii=False, indent=2)
-            # Force refresh the chat list after saving
-            self.refresh_chats()
-            return save_title
-        except Exception as e:
-            self.console.print(f"Error saving chat '{save_title}': {e}", style="dim")
-            return ""
-
-    def _load_chat_data(self, chat_info: Optional[ChatFileInfo]) -> Union[ChatFileInfo, Dict]:
-        """Common method to load chat data from a chat info dict"""
-        if not chat_info:
-            return {}
-
-        try:
-            chat_file = Path(chat_info["path"])
-            with open(chat_file, "r", encoding="utf-8") as f:
-                chat_data = json.load(f)
-
-            return {
-                "title": chat_data.get("title", chat_info["title"]),
-                "timestamp": chat_info["timestamp"],
-                "history": chat_data.get("history", []),
-            }
-        except FileNotFoundError:
-            self.console.print(f"Chat file not found: {chat_info['path']}", style="dim")
-            return {}
-        except json.JSONDecodeError as e:
-            self.console.print(f"Invalid JSON in chat file {chat_info['path']}: {e}", style="dim")
-            return {}
-        except Exception as e:
-            self.console.print(f"Error loading chat from {chat_info['path']}: {e}", style="dim")
-            return {}
-
-    def load_chat_by_index(self, index: int) -> Union[ChatFileInfo, Dict]:
-        """Load a chat by index and return the chat data"""
-        if not self.validate_chat_index(index):
-            return {}
-        chat_info = self.chats_map.get("index", {}).get(index)
-        return self._load_chat_data(chat_info)
-
-    def load_chat_by_title(self, title: str) -> Union[ChatFileInfo, Dict]:
-        """Load a chat by title and return the chat data"""
-        chat_info = self.chats_map.get("title", {}).get(title)
-        return self._load_chat_data(chat_info)
-
-    def delete_chat(self, index: int) -> bool:
-        """Delete a chat by index and return success status"""
-        if not self.validate_chat_index(index):
-            return False
-
-        chat_info = self.chats_map["index"].get(index)
-        if not chat_info:
-            return False
-
-        try:
-            chat_file = Path(chat_info["path"])
-            chat_file.unlink()
-            # Force refresh the chat list
-            self.refresh_chats()
-            return True
-        except FileNotFoundError:
-            self.console.print(f"Chat file not found: {chat_info['path']}", style="dim")
-            return False
-        except Exception as e:
-            self.console.print(f"Error deleting chat {index}: {e}", style="dim")
-            return False

yaicli/providers/__init__.py

@@ -1,34 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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

@@ -1,176 +0,0 @@
-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}"}