webscout 8.2.7__py3-none-any.whl → 8.2.9__py3-none-any.whl

webscout/Provider/yep.py

@@ -0,0 +1,389 @@
+import uuid
+import json
+from curl_cffi import CurlError
+from curl_cffi.requests import Session
+
+from typing import Any, Dict, Optional, Generator, Union, List, TypeVar
+
+from webscout.AIutel import Optimizers
+from webscout.AIutel import AwesomePrompts, sanitize_stream # Import sanitize_stream
+from webscout.AIbase import Provider
+from webscout import exceptions
+from webscout.litagent import LitAgent
+from webscout.conversation import Conversation, Fn
+
+T = TypeVar('T')
+
+
+class YEPCHAT(Provider):
+    """
+    YEPCHAT is a provider class for interacting with the Yep API.
+
+    Attributes:
+        AVAILABLE_MODELS (list): List of available models for the provider.
+    """
+
+    AVAILABLE_MODELS = ["DeepSeek-R1-Distill-Qwen-32B", "Mixtral-8x7B-Instruct-v0.1"]
+
+    def __init__(
+        self,
+        is_conversation: bool = True,
+        max_tokens: int = 1280,
+        timeout: int = 30,
+        intro: str = None,
+        filepath: str = None,
+        update_file: bool = True,
+        proxies: dict = {},
+        history_offset: int = 10250,
+        act: str = None,
+        model: str = "DeepSeek-R1-Distill-Qwen-32B",
+        temperature: float = 0.6,
+        top_p: float = 0.7,
+        browser: str = "chrome",
+        tools: Optional[List[Fn]] = None
+    ):
+        """
+        Initializes the YEPCHAT provider with the specified parameters.
+
+        Examples:
+            >>> ai = YEPCHAT()
+            >>> ai.ask("What's the weather today?")
+            Sends a prompt to the Yep API and returns the response.
+
+            >>> ai.chat("Tell me a joke", stream=True)
+            Initiates a chat with the Yep API using the provided prompt.
+            
+            >>> weather_tool = Fn(name="get_weather", description="Get the current weather", parameters={"location": "string"})
+            >>> ai = YEPCHAT(tools=[weather_tool])
+            >>> ai.chat("What's the weather in New York?")
+            Uses the weather tool to provide weather information.
+        """
+        if model not in self.AVAILABLE_MODELS:
+            raise ValueError(
+                f"Invalid model: {model}. Choose from: {self.AVAILABLE_MODELS}"
+            )
+
+        # Initialize curl_cffi Session instead of cloudscraper
+        self.session = Session() 
+        self.is_conversation = is_conversation
+        self.max_tokens_to_sample = max_tokens
+        self.chat_endpoint = "https://api.yep.com/v1/chat/completions"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.model = model
+        self.temperature = temperature
+        self.top_p = top_p
+
+        # Initialize LitAgent for user agent generation
+        self.agent = LitAgent()
+        # Use fingerprinting to create a consistent browser identity
+        self.fingerprint = self.agent.generate_fingerprint(browser)
+
+        # Use the fingerprint for headers
+        self.headers = {
+            "Accept": self.fingerprint["accept"],
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "Accept-Language": self.fingerprint["accept_language"],
+            "Content-Type": "application/json; charset=utf-8",
+            "DNT": "1",
+            "Origin": "https://yep.com",
+            "Referer": "https://yep.com/",
+            "Sec-CH-UA": self.fingerprint["sec_ch_ua"] or '"Not)A;Brand";v="99", "Microsoft Edge";v="127", "Chromium";v="127"',
+            "Sec-CH-UA-Mobile": "?0",
+            "Sec-CH-UA-Platform": f'"{self.fingerprint["platform"]}"',
+            "User-Agent": self.fingerprint["user_agent"],
+        }
+        
+        # Create session cookies with unique identifiers
+        self.cookies = {"__Host-session": uuid.uuid4().hex, '__cf_bm': uuid.uuid4().hex}
+
+        self.__available_optimizers = (
+            method
+            for method in dir(Optimizers)
+            if callable(getattr(Optimizers, method))
+            and not method.startswith("__")
+        )
+        Conversation.intro = (
+            AwesomePrompts().get_act(act, raise_not_found=True, default=None, case_insensitive=True)
+            if act
+            else intro or Conversation.intro
+        )
+        self.conversation = Conversation(
+            is_conversation, self.max_tokens_to_sample, filepath, update_file, tools=tools
+        )
+        self.conversation.history_offset = history_offset
+        # Set consistent headers and proxies for the curl_cffi session
+        self.session.headers.update(self.headers)
+        self.session.proxies = proxies
+        # Note: curl_cffi handles cookies differently, passed directly in requests
+
+    def refresh_identity(self, browser: str = None):
+        """
+        Refreshes the browser identity fingerprint.
+        
+        Args:
+            browser: Specific browser to use for the new fingerprint
+        """
+        browser = browser or self.fingerprint.get("browser_type", "chrome")
+        self.fingerprint = self.agent.generate_fingerprint(browser)
+        
+        # Update headers with new fingerprint
+        self.headers.update({
+            "Accept": self.fingerprint["accept"],
+            "Accept-Language": self.fingerprint["accept_language"],
+            "Sec-CH-UA": self.fingerprint["sec_ch_ua"] or self.headers["Sec-CH-UA"],
+            "Sec-CH-UA-Platform": f'"{self.fingerprint["platform"]}"',
+            "User-Agent": self.fingerprint["user_agent"],
+        })
+        
+        # Update session headers
+        self.session.headers.update(self.headers)
+        
+        # Generate new cookies (will be passed in requests)
+        self.cookies = {"__Host-session": uuid.uuid4().hex, '__cf_bm': uuid.uuid4().hex}
+        
+        return self.fingerprint
+
+    def ask(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[Dict[str, Any], Generator]:
+        """
+        Sends a prompt to the Yep API and returns the response.
+        Now supports tool calling functionality.
+
+        Examples:
+            >>> ai = YEPCHAT()
+            >>> ai.ask("What's the weather today?")
+            Returns the response from the Yep API.
+
+            >>> ai.ask("Tell me a joke", stream=True)
+            Streams the response from the Yep API.
+            
+            >>> weather_tool = Fn(name="get_weather", description="Get the current weather", parameters={"location": "string"})
+            >>> ai = YEPCHAT(tools=[weather_tool])
+            >>> ai.ask("What's the weather in New York?")
+            Will use the weather tool to provide response.
+        """
+        conversation_prompt = self.conversation.gen_complete_prompt(prompt)
+        if optimizer:
+            if optimizer in self.__available_optimizers:
+                conversation_prompt = getattr(Optimizers, optimizer)(
+                    conversation_prompt if conversationally else prompt
+                )
+            else:
+                raise Exception(
+                    f"Optimizer is not one of {self.__available_optimizers}"
+                )
+
+        data = {
+            "stream": stream,
+            "max_tokens": self.max_tokens_to_sample,
+            "top_p": self.top_p,
+            "temperature": self.temperature,
+            "messages": [{"content": conversation_prompt, "role": "user"}],
+            "model": self.model,
+        }
+
+        def for_stream():
+            try:
+                # buffer = b"" # No longer needed here
+                # Use curl_cffi session post, pass cookies explicitly
+                response = self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, stream=True, timeout=self.timeout, impersonate=self.fingerprint.get("browser_type", "chrome110"))
+                
+                if not response.ok:
+                    # If we get a non-200 response, try refreshing our identity once
+                    if response.status_code in [403, 429]:
+                        self.refresh_identity()
+                        # Retry with new identity
+                        # Use curl_cffi session post, pass cookies explicitly
+                        retry_response = self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, stream=True, timeout=self.timeout, impersonate=self.fingerprint.get("browser_type", "chrome110"))
+                        if not retry_response.ok:
+                            raise exceptions.FailedToGenerateResponseError(
+                                f"Failed to generate response after identity refresh - ({retry_response.status_code}, {retry_response.reason}) - {retry_response.text}"
+                            )
+                        response = retry_response # Use the successful retry response
+                    else:
+                        raise exceptions.FailedToGenerateResponseError(
+                            f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                        )
+
+                # --- Start of stream processing block (should be outside the 'if not response.ok' block) ---
+                streaming_text = ""
+
+                # Use sanitize_stream to process the lines
+                processed_stream = sanitize_stream(
+                    data=response.iter_content(chunk_size=None), # Pass the byte iterator directly
+                    intro_value="data:",
+                    to_json=True, # Yep sends JSON after 'data:'
+                    skip_markers=["[DONE]"], # Skip the final marker
+                    yield_raw_on_error=False, # Only process valid JSON data
+                    # --- Add the content extractor ---
+                    content_extractor=lambda chunk: chunk.get('choices', [{}])[0].get('delta', {}).get('content') if isinstance(chunk, dict) else None
+                )
+                # The loop now yields the final extracted string content directly
+                for content_chunk in processed_stream:
+                    # --- TEMPORARY DEBUG PRINT ---
+                    # print(f"\nDEBUG: Received extracted content: {content_chunk!r}\n", flush=True) # Keep or remove debug print as needed
+                    if content_chunk and isinstance(content_chunk, str): # Ensure it's a non-empty string
+                        streaming_text += content_chunk
+                        # Yield dict or raw string chunk based on 'raw' flag
+                        yield dict(text=content_chunk) if not raw else content_chunk
+                # --- End of stream processing block ---
+
+                # Check if the response contains a tool call (This should happen *after* processing the stream)
+                response_data = self.conversation.handle_tool_response(streaming_text)
+                
+                if response_data["is_tool_call"]:
+                    # Handle tool call results
+                    if response_data["success"]:
+                        for tool_call in response_data.get("tool_calls", []):
+                            tool_name = tool_call.get("name", "unknown_tool")
+                            result = response_data["result"]
+                            self.conversation.update_chat_history_with_tool(prompt, tool_name, result)
+                    else:
+                        # If tool call failed, update history with error
+                        self.conversation.update_chat_history(prompt, 
+                            f"Error executing tool call: {response_data['result']}")
+                else:
+                    # Normal response handling
+                    self.conversation.update_chat_history(prompt, streaming_text)
+                        
+            except CurlError as e: # Catch CurlError
+                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed: {e}")
+
+        def for_non_stream():
+            try:
+                # Use curl_cffi session post, pass cookies explicitly
+                response = self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, timeout=self.timeout, impersonate=self.fingerprint.get("browser_type", "chrome110"))
+                if not response.ok:
+                    if response.status_code in [403, 429]:
+                        self.refresh_identity()
+                        # Use curl_cffi session post, pass cookies explicitly
+                        response = self.session.post(self.chat_endpoint, headers=self.headers, cookies=self.cookies, json=data, timeout=self.timeout, impersonate=self.fingerprint.get("browser_type", "chrome110"))
+                        if not response.ok:
+                            raise exceptions.FailedToGenerateResponseError(
+                                f"Failed to generate response after identity refresh - ({response.status_code}, {response.reason}) - {response.text}"
+                            )
+                    else:
+                        raise exceptions.FailedToGenerateResponseError(
+                            f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                        )
+
+                # ... existing non-stream response handling code ...
+                response_data = response.json()
+                if 'choices' in response_data and len(response_data['choices']) > 0:
+                    content = response_data['choices'][0].get('message', {}).get('content', '')
+                    
+                    # Check if the response contains a tool call
+                    tool_response = self.conversation.handle_tool_response(content)
+                    
+                    if tool_response["is_tool_call"]:
+                        # Process tool call
+                        if tool_response["success"]:
+                            # Get the first tool call for simplicity
+                            if "tool_calls" in tool_response and len(tool_response["tool_calls"]) > 0:
+                                tool_call = tool_response["tool_calls"][0]
+                                tool_name = tool_call.get("name", "unknown_tool")
+                                tool_result = tool_response["result"]
+                                
+                                # Update chat history with tool call
+                                self.conversation.update_chat_history_with_tool(prompt, tool_name, tool_result)
+                                
+                                # Return tool result
+                                return {"text": tool_result, "is_tool_call": True, "tool_name": tool_name}
+                        
+                        # If tool call processing failed
+                        return {"text": tool_response["result"], "is_tool_call": True, "error": True}
+                    else:
+                        # Normal response handling
+                        self.conversation.update_chat_history(prompt, content)
+                        return {"text": content}
+                else:
+                    raise exceptions.FailedToGenerateResponseError("No response content found")
+            except CurlError as e: # Catch CurlError
+                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}")
+            except Exception as e:
+                raise exceptions.FailedToGenerateResponseError(f"Request failed: {e}")
+
+        return for_stream() if stream else for_non_stream()
+
+    def chat(
+        self,
+        prompt: str,
+        stream: bool = False,
+        optimizer: str = None,
+        conversationally: bool = False,
+    ) -> Union[str, Generator[str, None, None]]:
+        """
+        Initiates a chat with the Yep API using the provided prompt.
+
+        Examples:
+            >>> ai = YEPCHAT()
+            >>> ai.chat("Tell me a joke")
+            Returns the chat response from the Yep API.
+
+            >>> ai.chat("What's the weather today?", stream=True)
+            Streams the chat response from the Yep API.
+        """
+        def for_stream():
+            for response in self.ask(
+                prompt, True, optimizer=optimizer, conversationally=conversationally
+            ):
+                yield self.get_message(response)
+
+        def for_non_stream():
+            return self.get_message(
+                self.ask(
+                    prompt,
+                    False,
+                    optimizer=optimizer,
+                    conversationally=conversationally,
+                )
+            )
+
+        return for_stream() if stream else for_non_stream()
+
+    def get_message(self, response: dict) -> str:
+        """
+        Extracts the message content from the API response.
+
+        Examples:
+            >>> ai = YEPCHAT()
+            >>> response = ai.ask("Tell me a joke")
+            >>> ai.get_message(response)
+            Extracts and returns the message content from the response.
+        """
+        assert isinstance(response, dict)
+        return response["text"]
+
+
+if __name__ == "__main__":
+    print("-" * 80)
+    print(f"{'Model':<50} {'Status':<10} {'Response'}")
+    print("-" * 80)
+
+    for model in YEPCHAT.AVAILABLE_MODELS:
+        try:
+            test_ai = YEPCHAT(model=model, timeout=60)
+            response = test_ai.chat("Say 'Hello' in one word")
+            response_text = response
+            
+            if response_text and len(response_text.strip()) > 0:
+                status = "✓"
+                # Truncate response if too long
+                display_text = response_text.strip()[:50] + "..." if len(response_text.strip()) > 50 else response_text.strip()
+            else:
+                status = "✗"
+                display_text = "Empty or invalid response"
+            print(f"{model:<50} {status:<10} {display_text}")
+        except Exception as e:
+            print(f"{model:<50} {'✗':<10} {str(e)}")
+

webscout/__init__.py

@@ -26,9 +26,11 @@ __repo__ = "https://github.com/OE-LUCIFER/Webscout"
 # Add update checker
 from .update_checker import check_for_updates
 try:
-    check_for_updates()
+    update_message = check_for_updates()
+    if update_message:
+        print(update_message)
 except Exception:
-    pass  # Silently handle any update check errors
+    pass  # Silently handle any update check errorslently handle any update check errors
 
 import logging
 logging.getLogger("webscout").addHandler(logging.NullHandler())

webscout/cli.py

@@ -1,6 +1,6 @@
 import sys
 from .swiftcli import CLI, option
-from .webscout_search import WEBS
+from .webscout_search import WEBS  # Import the WEBS class from webscout_search
 from .DWEBS import GoogleSearch  # Import GoogleSearch from DWEBS
 from .yep_search import YepSearch  # Import YepSearch from yep_search
 from .version import __version__
@@ -48,32 +48,7 @@ def version():
     """Show the version of webscout."""
     print(f"webscout version: {__version__}")
 
-@app.command()
-@option("--proxy", help="Proxy URL to use for requests")
-@option("--model", "-m", help="AI model to use", default="gpt-4o-mini", type=str)
-@option("--timeout", "-t", help="Timeout value for requests", type=int, default=10)
-def chat(proxy: str = None, model: str = "gpt-4o-mini", timeout: int = 10):
-    """Interactive AI chat using DuckDuckGo's AI."""
-    webs = WEBS(proxy=proxy, timeout=timeout)
-    
-    print(f"Using model: {model}")
-    print("Type your message and press Enter. Press Ctrl+C or type 'exit' to quit.\n")
-    
-    try:
-        while True:
-            try:
-                user_input = input(">>> ").strip()
-                if not user_input or user_input.lower() in ['exit', 'quit']:
-                    break
-                    
-                response = webs.chat(keywords=user_input, model=model)
-                print(f"\nAI: {response}\n")
-                
-            except Exception as e:
-                print(f"Error: {str(e)}\n")
-                
-    except KeyboardInterrupt:
-        print("\nChat session interrupted. Exiting...")
+
 
 @app.command()
 @option("--keywords", "-k", help="Search keywords", required=True)
@@ -546,4 +521,4 @@ def main():
         sys.exit(1)
 
 if __name__ == "__main__":
-    main()
+    main()

webscout/client.py

@@ -0,0 +1,70 @@
+"""
+Unified client import for OpenAI-compatible providers and server utilities.
+
+This module provides a unified import interface for all OpenAI-compatible providers and exposes
+helper functions to start the OpenAI-compatible API server programmatically.
+
+Usage:
+    from webscout.client import FreeAIChat, AI4Chat, ExaChat, MultiChatAI, TwoAI, SciraChat, ChatSandbox, C4AI, Groq, TypeGPT, LLMChat, Cleeai, DeepInfra, BlackboxAI, Cloudflare, Netwrck, OIVSCode, Venice, Writecream, Wisecat, Yep, X0GPT, Sonus, Toolbaz, TextPollinations, StandardInput, Opkfc, Flowith, ExaAI, FreeGemini, GeminiAPI, Gemini, GithubChat, GizAI, Glider, HeckAI, HuggingFaceChat, Hunyuan, Jadve, Julius, Koala, LearnFast, LearnFastAI, NEMOTRON, MCPCore, PydanticImports, TeachAnything, UncovrAI, API, Base
+    client = FreeAIChat()
+    response = client.chat.completions.create(...)
+
+    # To start the server programmatically:
+    from webscout.client import start_server
+    start_server()
+
+    # For advanced server control:
+    from webscout.client import run_api
+    run_api(host="0.0.0.0", port=8000, debug=True)
+
+    # Instantly start the API server from the command line:
+    #   python -m webscout.client
+    # or, if installed as a script:
+    #   webscout-api
+
+Exports:
+    - All OpenAI-compatible provider classes
+    - start_server (function): Start the OpenAI-compatible API server with default or custom settings.
+    - run_api (function): Advanced server startup with full control over host, port, and other options.
+"""
+
+from webscout.Provider.OPENAI import *
+from webscout.Provider.OPENAI.api import start_server, run_api
+
+# ---
+# API Documentation
+#
+# start_server
+# -------------
+# def start_server(port: int = 8000, api_key: str = None, default_provider: str = None, base_url: str = None):
+#     """
+#     Start the OpenAI-compatible API server with optional configuration.
+#
+#     Parameters:
+#         port (int, optional): The port to run the server on. Defaults to 8000.
+#         api_key (str, optional): API key for authentication. If None, authentication is disabled.
+#         default_provider (str, optional): The default provider to use. If None, uses the package default.
+#         base_url (str, optional): Base URL prefix for the API (e.g., '/api/v1'). If None, no prefix is used.
+#
+#     Returns:
+#         None
+#     """
+#
+# run_api
+# -------
+# def run_api(host: str = '0.0.0.0', port: int = None, api_key: str = None, default_provider: str = None, base_url: str = None, debug: bool = False, show_available_providers: bool = True):
+#     """
+#     Advanced server startup for the OpenAI-compatible API server.
+#
+#     Parameters:
+#         host (str, optional): Host address to bind the server. Defaults to '0.0.0.0'.
+#         port (int, optional): Port to run the server on. Defaults to 8000 if not specified.
+#         api_key (str, optional): API key for authentication. If None, authentication is disabled.
+#         default_provider (str, optional): The default provider to use. If None, uses the package default.
+#         base_url (str, optional): Base URL prefix for the API (e.g., '/api/v1'). If None, no prefix is used.
+#         debug (bool, optional): Run the server in debug mode with auto-reload. Defaults to False.
+#         show_available_providers (bool, optional): Print available providers on startup. Defaults to True.
+#
+#     Returns:
+#         None
+#     """

webscout/conversation.py

@@ -1,6 +1,24 @@
+"""
+conversation.py
+
+This module provides a modern conversation manager for handling chat-based interactions, message history, tool calls, and robust error handling. It defines the Conversation class and supporting types for managing conversational state, tool integration, and message validation.
+
+Classes:
+    ConversationError: Base exception for conversation-related errors.
+    ToolCallError: Raised when there's an error with tool calls.
+    MessageValidationError: Raised when message validation fails.
+    Message: Represents a single message in the conversation.
+    FunctionCall: TypedDict for a function call.
+    ToolDefinition: TypedDict for a tool definition.
+    FunctionCallData: TypedDict for function call data.
+    Fn: Represents a function (tool) that the agent can call.
+    Conversation: Main conversation manager class.
+
+Functions:
+    tools: Decorator to mark a function as a tool.
+"""
 import os
 import json
-import logging
 from typing import Optional, Dict, List, Any, TypedDict, Callable, TypeVar, Union
 from dataclasses import dataclass
 from datetime import datetime
@@ -59,14 +77,15 @@ def tools(func: Callable[..., T]) -> Callable[..., T]:
     return func
 
 class Conversation:
-    """Modern conversation manager with enhanced features.
-    
+    """
+    Modern conversation manager with enhanced features.
+
     Key Features:
-    - Robust message handling with metadata
-    - Enhanced tool calling support
-    - Efficient history management
-    - Improved error handling
-    - Memory optimization
+        - Robust message handling with metadata
+        - Enhanced tool calling support
+        - Efficient history management
+        - Improved error handling
+        - Memory optimization
     """
 
     intro = (
@@ -95,23 +114,8 @@ class Conversation:
         self.prompt_allowance = 10
         self.tools = tools or []
         self.compression_threshold = compression_threshold
-        self.logger = self._setup_logger()
-        
         if filepath:
-            self.load_conversation(filepath, False)
-
-    def _setup_logger(self) -> logging.Logger:
-        """Set up enhanced logging."""
-        logger = logging.getLogger("conversation")
-        if not logger.handlers:
-            handler = logging.StreamHandler()
-            formatter = logging.Formatter(
-                '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-            )
-            handler.setFormatter(formatter)
-            logger.addHandler(handler)
-            logger.setLevel(logging.INFO)
-        return logger
+            self.load_conversation(filepath, True)
 
     def load_conversation(self, filepath: str, exists: bool = True) -> None:
         """Load conversation with improved error handling."""
@@ -132,7 +136,6 @@ class Conversation:
                         self.intro = file_contents[0]
                         self._process_history_from_file(file_contents[1:])
         except Exception as e:
-            self.logger.error(f"Error loading conversation: {str(e)}")
             raise ConversationError(f"Failed to load conversation: {str(e)}") from e
 
     def _process_history_from_file(self, lines: List[str]) -> None:
@@ -272,6 +275,7 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
     def add_message(self, role: str, content: str, metadata: Optional[Dict[str, Any]] = None) -> None:
         """Add a message with enhanced validation and metadata support."""
         try:
+            role = role.lower()  # Normalize role to lowercase
             if not self.validate_message(role, content):
                 raise MessageValidationError("Invalid message role or content")
 
@@ -284,7 +288,6 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
             self._compress_history()
             
         except Exception as e:
-            self.logger.error(f"Error adding message: {str(e)}")
             raise ConversationError(f"Failed to add message: {str(e)}") from e
 
     def _append_to_file(self, message: Message) -> None:
@@ -299,17 +302,17 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
                 fh.write(f"\n{role_display}: {message.content}")
                 
         except Exception as e:
-            self.logger.error(f"Error writing to file: {str(e)}")
             raise ConversationError(f"Failed to write to file: {str(e)}") from e
 
     def validate_message(self, role: str, content: str) -> bool:
         """Validate message with enhanced role checking."""
         valid_roles = {'user', 'assistant', 'tool', 'system'}
         if role not in valid_roles:
-            self.logger.error(f"Invalid role: {role}")
             return False
-        if not content or not isinstance(content, str):
-            self.logger.error("Invalid content")
+        if not isinstance(content, str):
+            return False
+        # Allow empty content for assistant (needed for streaming)
+        if not content and role != 'assistant':
             return False
         return True
 
@@ -345,7 +348,6 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
             }
             
         except Exception as e:
-            self.logger.error(f"Error handling tool response: {str(e)}")
             raise ToolCallError(f"Failed to handle tool response: {str(e)}") from e
 
     def _parse_function_call(self, response: str) -> FunctionCallData:
@@ -381,7 +383,6 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
                 raise
 
         except Exception as e:
-            self.logger.error(f"Error parsing function call: {str(e)}")
             return {"error": str(e)}
 
     def execute_function(self, function_call_data: FunctionCallData) -> str:
@@ -405,7 +406,6 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
             return "; ".join(results)
             
         except Exception as e:
-            self.logger.error(f"Error executing function: {str(e)}")
             raise ToolCallError(f"Failed to execute function: {str(e)}") from e
 
     def get_tools_description(self) -> str:
@@ -428,9 +428,9 @@ Your goal is to assist the user effectively. Analyze each query and choose one o
         This method adds both the user's prompt and the assistant's response
         to the conversation history as separate messages.
         """
-        # Add user's message
+        # Add user's message (normalize role)
         self.add_message("user", prompt)
         
-        # Add assistant's response
+        # Add assistant's response (normalize role)
         self.add_message("assistant", response)