quantalogic 0.2.16__py3-none-any.whl → 0.2.17__py3-none-any.whl

quantalogic/generative_model.py

@@ -7,9 +7,12 @@ from litellm import completion, exceptions, get_max_tokens, get_model_info, toke
 from loguru import logger
 from pydantic import BaseModel, Field, field_validator
 
+from quantalogic.event_emitter import EventEmitter  # Importing the EventEmitter class
+
 MIN_RETRIES = 1
 
 
+# Define the Message class for conversation handling
 class Message(BaseModel):
     """Represents a message in a conversation with a specific role and content."""
 
@@ -70,21 +73,22 @@ class GenerativeModel:
         self,
         model: str = "ollama/qwen2.5-coder:14b",
         temperature: float = 0.7,
+        event_emitter: EventEmitter = None,  # EventEmitter instance
     ) -> None:
         """Initialize a generative model with configurable parameters.
 
-        Configure the generative model with specified model,
-        temperature, and maximum token settings.
-
         Args:
-            model: Model identifier.
-                Defaults to "ollama/qwen2.5-coder:14b".
-            temperature: Sampling temperature between 0 and 1.
-                Defaults to 0.7.
+            model: Model identifier. Defaults to "ollama/qwen2.5-coder:14b".
+            temperature: Temperature parameter for controlling randomness in generation. 
+                        Higher values (e.g. 0.8) make output more random, lower values (e.g. 0.2) 
+                        make it more deterministic. Defaults to 0.7.
+            event_emitter: Optional event emitter instance for handling asynchronous events 
+                          and callbacks during text generation. Defaults to None.
         """
         logger.debug(f"Initializing GenerativeModel with model={model}, temperature={temperature}")
         self.model = model
         self.temperature = temperature
+        self.event_emitter = event_emitter or EventEmitter()  # Initialize event emitter
         self._get_model_info_cached = functools.lru_cache(maxsize=32)(self._get_model_info_impl)
 
     # Define retriable exceptions based on LiteLLM's exception mapping
@@ -109,28 +113,20 @@ class GenerativeModel:
         exceptions.PermissionDeniedError,
     )
 
-    # Retry on specific retriable exceptions
+    # Generate a response with conversation history and optional streaming
     def generate_with_history(
-        self, messages_history: list[Message], prompt: str, image_url: str | None = None
+        self, messages_history: list[Message], prompt: str, image_url: str | None = None, streaming: bool = False
     ) -> ResponseStats:
         """Generate a response with conversation history and optional image.
 
-        Generates a response based on previous conversation messages,
-        a new user prompt, and an optional image URL.
-
         Args:
             messages_history: Previous conversation messages.
             prompt: Current user prompt.
             image_url: Optional image URL for visual queries.
+            streaming: Whether to stream the response.
 
         Returns:
-            Detailed response statistics.
-
-        Raises:
-            openai.AuthenticationError: If authentication fails.
-            openai.InvalidRequestError: If the request is invalid (e.g., context length exceeded).
-            openai.APIError: For content policy violations or other API errors.
-            Exception: For other unexpected errors.
+            Detailed response statistics or a generator in streaming mode.
         """
         messages = [{"role": msg.role, "content": str(msg.content)} for msg in messages_history]
 
@@ -147,6 +143,10 @@ class GenerativeModel:
         else:
             messages.append({"role": "user", "content": str(prompt)})
 
+        if streaming:
+            self.event_emitter.emit("stream_start")  # Emit stream start event
+            return self._stream_response(messages)  # Return generator
+
         try:
             logger.debug(f"Generating response for prompt: {prompt}")
 
@@ -171,54 +171,68 @@ class GenerativeModel:
             )
 
         except Exception as e:
-            error_details = {
-                "error_type": type(e).__name__,
-                "message": str(e),
-                "model": self.model,
-                "provider": getattr(e, "llm_provider", "unknown"),
-                "status_code": getattr(e, "status_code", None),
-            }
-
-            logger.error("LLM Generation Error: {}", error_details)
-            logger.debug(f"Error details: {error_details}")
-            logger.debug(f"Model: {self.model}, Temperature: {self.temperature}")
-
-            # Handle authentication and permission errors
-            if isinstance(e, self.AUTH_EXCEPTIONS):
-                logger.debug("Authentication error occurred")
-                raise openai.AuthenticationError(
-                    f"Authentication failed with provider {error_details['provider']}"
-                ) from e
-
-            # Handle context window errors
-            if isinstance(e, self.CONTEXT_EXCEPTIONS):
-                raise openai.InvalidRequestError(f"Context window exceeded or invalid request: {str(e)}") from e
-
-            # Handle content policy violations
-            if isinstance(e, self.POLICY_EXCEPTIONS):
-                raise openai.APIError(f"Content policy violation: {str(e)}") from e
-
-            # For other exceptions, preserve the original error type if it's from OpenAI
-            if isinstance(e, openai.OpenAIError):
-                raise
-
-            # Wrap unknown errors in APIError
-            raise openai.APIError(f"Unexpected error during generation: {str(e)}") from e
-
-    def generate(self, prompt: str, image_url: str | None = None) -> ResponseStats:
-        """Generate a response without conversation history.
+            self._handle_generation_exception(e)
+
+    def _stream_response(self, messages):
+        """Private method to handle streaming responses."""
+        try:
+            for chunk in completion(
+                temperature=self.temperature,
+                model=self.model,
+                messages=messages,
+                num_retries=MIN_RETRIES,
+                stream=True,  # Enable streaming
+            ):
+                if chunk.choices[0].delta.content is not None:
+                    self.event_emitter.emit("stream_chunk", chunk.choices[0].delta.content)
+                    yield chunk.choices[0].delta.content  # Yield each chunk of content
 
-        Generates a response for a single user prompt without
-        any previous conversation context.
+            self.event_emitter.emit("stream_end")  # Emit stream end event
+        except Exception as e:
+            logger.error(f"Streaming error: {str(e)}")
+            raise
+
+    def generate(self, prompt: str, image_url: str | None = None, streaming: bool = False) -> ResponseStats:
+        """Generate a response without conversation history.
 
         Args:
             prompt: User prompt.
             image_url: Optional image URL for visual queries.
+            streaming: Whether to stream the response.
 
         Returns:
-            Detailed response statistics.
+            Detailed response statistics or a generator in streaming mode.
         """
-        return self.generate_with_history([], prompt, image_url)
+        return self.generate_with_history([], prompt, image_url, streaming)
+
+    def _handle_generation_exception(self, e):
+        """Handle exceptions during generation."""
+        error_details = {
+            "error_type": type(e).__name__,
+            "message": str(e),
+            "model": self.model,
+            "provider": getattr(e, "llm_provider", "unknown"),
+            "status_code": getattr(e, "status_code", None),
+        }
+
+        logger.error("LLM Generation Error: {}", error_details)
+        logger.debug(f"Error details: {error_details}")
+        logger.debug(f"Model: {self.model}, Temperature: {self.temperature}")
+
+        if isinstance(e, self.AUTH_EXCEPTIONS):
+            logger.debug("Authentication error occurred")
+            raise openai.AuthenticationError(f"Authentication failed with provider {error_details['provider']}") from e
+
+        if isinstance(e, self.CONTEXT_EXCEPTIONS):
+            raise openai.InvalidRequestError(f"Context window exceeded or invalid request: {str(e)}") from e
+
+        if isinstance(e, self.POLICY_EXCEPTIONS):
+            raise openai.APIError(f"Content policy violation: {str(e)}") from e
+
+        if isinstance(e, openai.OpenAIError):
+            raise
+
+        raise openai.APIError(f"Unexpected error during generation: {str(e)}") from e
 
     def get_max_tokens(self) -> int:
         """Get the maximum number of tokens that can be generated by the model."""
@@ -239,17 +253,9 @@ class GenerativeModel:
         return token_counter(model=self.model, messages=litellm_messages)
 
     def _get_model_info_impl(self, model_name: str) -> dict:
-        """Get information about the model with prefix fallback logic.
-        
-        Attempts to find model info by progressively removing provider prefixes.
-        Raises ValueError if no valid model configuration is found.
-        Results are cached to improve performance.
-        
-        Example:
-            openrouter/openai/gpt-4o-mini → openai/gpt-4o-mini → gpt-4o-mini
-        """
+        """Get information about the model with prefix fallback logic."""
         original_model = model_name
-        
+
         while True:
             try:
                 logger.debug(f"Attempting to retrieve model info for: {model_name}")
@@ -259,22 +265,19 @@ class GenerativeModel:
                     return model_info
             except Exception:
                 pass
-                
+
             # Try removing one prefix level
-            parts = model_name.split('/')
+            parts = model_name.split("/")
             if len(parts) <= 1:
                 break
-            model_name = '/'.join(parts[1:])
-            
+            model_name = "/".join(parts[1:])
+
         error_msg = f"Could not find model info for {original_model} after trying: {self.model} → {model_name}"
         logger.error(error_msg)
         raise ValueError(error_msg)
 
     def get_model_info(self, model_name: str = None) -> dict:
-        """Get cached information about the model.
-        
-        If no model name is provided, uses the current model.
-        """
+        """Get cached information about the model."""
         if model_name is None:
             model_name = self.model
         return self._get_model_info_cached(model_name)

quantalogic/main.py

@@ -10,15 +10,20 @@ from typing import Optional
 import click
 from loguru import logger
 
+from quantalogic.console_print_events import console_print_events
+from quantalogic.console_print_token import console_print_token
 from quantalogic.utils.check_version import check_if_is_latest_version
 from quantalogic.version import get_version
 
 # Configure logger
 logger.remove()  # Remove default logger
 
+from threading import Lock  # noqa: E402
+
 from rich.console import Console  # noqa: E402
 from rich.panel import Panel  # noqa: E402
 from rich.prompt import Confirm  # noqa: E402
+from rich.spinner import Spinner  # noqa: E402
 
 from quantalogic.agent import Agent  # noqa: E402
 
@@ -31,30 +36,31 @@ from quantalogic.agent_config import (  # noqa: E402
     create_orchestrator_agent,
 )
 from quantalogic.interactive_text_editor import get_multiline_input  # noqa: E402
-from quantalogic.print_event import console_print_events  # noqa: E402
 from quantalogic.search_agent import create_search_agent  # noqa: E402
 
 AGENT_MODES = ["code", "basic", "interpreter", "full", "code-basic", "search", "search-full"]
 
 
-def create_agent_for_mode(mode: str, model_name: str, vision_model_name: str | None) -> Agent:
+def create_agent_for_mode(mode: str, model_name: str, vision_model_name: str | None, no_stream: bool = False) -> Agent:
     """Create an agent based on the specified mode."""
     logger.debug(f"Creating agent for mode: {mode} with model: {model_name}")
+    logger.debug(f"Using vision model: {vision_model_name}")
+    logger.debug(f"Using no_stream: {no_stream}")
     if mode == "code":
         logger.debug("Creating code agent without basic mode")
-        return create_coding_agent(model_name, vision_model_name, basic=False)
+        return create_coding_agent(model_name, vision_model_name, basic=False, no_stream=no_stream)
     if mode == "code-basic":
-        return create_coding_agent(model_name, vision_model_name, basic=True)
+        return create_coding_agent(model_name, vision_model_name, basic=True, no_stream=no_stream)
     elif mode == "basic":
-        return create_orchestrator_agent(model_name, vision_model_name)
+        return create_orchestrator_agent(model_name, vision_model_name, no_stream=no_stream)
     elif mode == "full":
-        return create_full_agent(model_name, vision_model_name)
+        return create_full_agent(model_name, vision_model_name, no_stream=no_stream)
     elif mode == "interpreter":
-        return create_interpreter_agent(model_name, vision_model_name)
+        return create_interpreter_agent(model_name, vision_model_name, no_stream=no_stream)
     elif mode == "search":
-        return create_search_agent(model_name)
+        return create_search_agent(model_name, no_stream=no_stream)
     if mode == "search-full":
-        return create_search_agent(model_name, mode_full=True)
+        return create_search_agent(model_name, mode_full=True, no_stream=no_stream)
     else:
         raise ValueError(f"Unknown agent mode: {mode}")
 
@@ -126,6 +132,27 @@ def get_task_from_file(file_path: str) -> str:
         raise Exception(f"Unexpected error reading file: {e}")
 
 
+# Spinner control
+spinner_lock = Lock()
+current_spinner = None
+
+def start_spinner(console: Console) -> None:
+    """Start the thinking spinner."""
+    global current_spinner
+    with spinner_lock:
+        if current_spinner is None:
+            current_spinner = console.status("[yellow]Thinking...", spinner="dots")
+            current_spinner.start()
+
+def stop_spinner(console: Console) -> None:
+    """Stop the thinking spinner."""
+    global current_spinner
+    with spinner_lock:
+        if current_spinner is not None:
+            current_spinner.stop()
+            current_spinner = None
+
+
 def display_welcome_message(
     console: Console, model_name: str, vision_model_name: str | None, max_iterations: int = 50
 ) -> None:
@@ -159,7 +186,7 @@ def display_welcome_message(
 @click.option(
     "--model-name",
     default=MODEL_NAME,
-    help='Specify the model to use (litellm format, e.g. "openrouter/deepseek-chat").',
+    help='Specify the model to use (litellm format, e.g. "openrouter/deepseek/deepseek-chat").',
 )
 @click.option(
     "--log",
@@ -213,7 +240,7 @@ def cli(
 @click.option(
     "--model-name",
     default=MODEL_NAME,
-    help='Specify the model to use (litellm format, e.g. "openrouter/deepseek-chat").',
+    help='Specify the model to use (litellm format, e.g. "openrouter/deepseek/deepseek-chat").',
 )
 @click.option("--verbose", is_flag=True, help="Enable verbose output.")
 @click.option("--mode", type=click.Choice(AGENT_MODES), default="code", help="Agent mode (code/search/full).")
@@ -234,6 +261,11 @@ def cli(
     default=30,
     help="Maximum number of iterations for task solving (default: 30).",
 )
+@click.option(
+    "--no-stream",
+    is_flag=True,
+    help="Disable streaming output (default: streaming enabled).",
+)
 @click.argument("task", required=False)
 def task(
     file: Optional[str],
@@ -244,6 +276,7 @@ def task(
     vision_model_name: str | None,
     task: Optional[str],
     max_iterations: int,
+    no_stream: bool,
 ) -> None:
     """Execute a task with the QuantaLogic AI Assistant."""
     console = Console()
@@ -286,9 +319,13 @@ def task(
             )
         )
 
-        logger.debug(f"Creating agent for mode: {mode} with model: {model_name}")
-        agent = create_agent_for_mode(mode, model_name, vision_model_name=vision_model_name)
-        logger.debug(f"Created agent for mode: {mode} with model: {model_name}")
+        logger.debug(
+            f"Creating agent for mode: {mode} with model: {model_name}, vision model: {vision_model_name}, no_stream: {no_stream}"
+        )
+        agent = create_agent_for_mode(mode, model_name, vision_model_name=vision_model_name, no_stream=no_stream)
+        logger.debug(
+            f"Created agent for mode: {mode} with model: {model_name}, vision model: {vision_model_name}, no_stream: {no_stream}"
+        )
 
         events = [
             "task_start",
@@ -302,16 +339,45 @@ def task(
             "memory_compacted",
             "memory_summary",
         ]
+        # Add spinner control to event handlers
+        def handle_task_think_start(*args, **kwargs):
+            start_spinner(console)
+
+        def handle_task_think_end(*args, **kwargs):
+            stop_spinner(console)
+
+        def handle_stream_chunk(event: str, data: str) -> None:
+            if current_spinner:
+                stop_spinner(console)
+            if data is not None:
+                console.print(data, end="", markup=False)
+
         agent.event_emitter.on(
             event=events,
             listener=console_print_events,
         )
+        
+        agent.event_emitter.on(
+            event="task_think_start",
+            listener=handle_task_think_start,
+        )
+        
+        agent.event_emitter.on(
+            event="task_think_end",
+            listener=handle_task_think_end,
+        )
+
+        agent.event_emitter.on(
+            event="stream_chunk",
+            listener=handle_stream_chunk,
+        )
+
         logger.debug("Registered event handlers for agent events with events: {events}")
 
         logger.debug(f"Solving task with agent: {task_content}")
         if max_iterations < 1:
             raise ValueError("max_iterations must be greater than 0")
-        result = agent.solve_task(task=task_content, max_iterations=max_iterations)
+        result = agent.solve_task(task=task_content, max_iterations=max_iterations, streaming=not no_stream)
         logger.debug(f"Task solved with result: {result} using {max_iterations} iterations")
 
         console.print(

quantalogic/server/agent_server.py

@@ -30,7 +30,7 @@ from quantalogic.agent_config import (
     create_coding_agent,  # noqa: F401
     create_orchestrator_agent,  # noqa: F401
 )
-from quantalogic.print_event import console_print_events
+from quantalogic.console_print_events import console_print_events
 
 # Configure logger
 logger.remove()
@@ -246,7 +246,7 @@ class AgentState:
     def initialize_agent_with_sse_validation(self, model_name: str = MODEL_NAME):
         """Initialize agent with SSE-based user validation."""
         try:
-            self.agent = create_agent(model_name)
+            self.agent = create_agent(model_name, None)
 
             # Comprehensive list of agent events to track
             agent_events = [

quantalogic/tools/llm_tool.py

@@ -1,9 +1,11 @@
 """LLM Tool for generating answers to questions using a language model."""
 
-import logging
+from typing import Callable
 
+from loguru import logger
 from pydantic import ConfigDict, Field
 
+from quantalogic.console_print_token import console_print_token
 from quantalogic.generative_model import GenerativeModel, Message
 from quantalogic.tools.tool import Tool, ToolArgument
 
@@ -53,15 +55,42 @@ class LLMTool(Tool):
     )
 
     model_name: str = Field(..., description="The name of the language model to use")
-    generative_model: GenerativeModel | None = Field(default=None)
     system_prompt: str | None = Field(default=None)
+    on_token: Callable | None = Field(default=None, exclude=True)
+    generative_model: GenerativeModel | None = Field(default=None, exclude=True)
+
+    def __init__(
+        self,
+        model_name: str,
+        system_prompt: str | None = None,
+        on_token: Callable | None = None,
+        name: str = "llm_tool",
+        generative_model: GenerativeModel | None = None,
+    ):
+        # Use dict to pass validated data to parent constructor
+        super().__init__(
+            **{
+                "model_name": model_name,
+                "system_prompt": system_prompt,
+                "on_token": on_token,
+                "name": name,
+                "generative_model": generative_model,
+            }
+        )
+
+        # Initialize the generative model
+        self.model_post_init(None)
 
     def model_post_init(self, __context):
         """Initialize the generative model after model initialization."""
         if self.generative_model is None:
             self.generative_model = GenerativeModel(model=self.model_name)
-            logging.debug(f"Initialized LLMTool with model: {self.model_name}")
+            logger.debug(f"Initialized LLMTool with model: {self.model_name}")
 
+        # Only set up event listener if on_token is provided
+        if self.on_token is not None:
+            logger.debug(f"Setting up event listener for LLMTool with model: {self.model_name}")
+            self.generative_model.event_emitter.on("stream_chunk", self.on_token)
 
     def execute(
         self, system_prompt: str | None = None, prompt: str | None = None, temperature: str | None = None
@@ -85,7 +114,7 @@ class LLMTool(Tool):
             if not (0.0 <= temp <= 1.0):
                 raise ValueError("Temperature must be between 0 and 1.")
         except ValueError as ve:
-            logging.error(f"Invalid temperature value: {temperature}")
+            logger.error(f"Invalid temperature value: {temperature}")
             raise ValueError(f"Invalid temperature value: {temperature}") from ve
 
         used_system_prompt = self.system_prompt if self.system_prompt else system_prompt
@@ -96,20 +125,29 @@ class LLMTool(Tool):
             Message(role="user", content=prompt),
         ]
 
+        is_streaming = self.on_token is not None
+
         # Set the model's temperature
         if self.generative_model:
             self.generative_model.temperature = temp
 
             # Generate the response using the generative model
             try:
-                response_stats = self.generative_model.generate_with_history(
-                    messages_history=messages_history, prompt=""
+                result = self.generative_model.generate_with_history(
+                    messages_history=messages_history, prompt=prompt, streaming=is_streaming
                 )
-                response = response_stats.response.strip()
-                logging.info(f"Generated response: {response}")
+
+                if is_streaming:
+                    response = ""
+                    for chunk in result:
+                        response += chunk
+                else:
+                    response = result.response
+
+                logger.debug(f"Generated response: {response}")
                 return response
             except Exception as e:
-                logging.error(f"Error generating response: {e}")
+                logger.error(f"Error generating response: {e}")
                 raise Exception(f"Error generating response: {e}") from e
         else:
             raise ValueError("Generative model not initialized")
@@ -123,6 +161,9 @@ if __name__ == "__main__":
     temperature = "0.7"
     answer = tool.execute(system_prompt=system_prompt, prompt=question, temperature=temperature)
     print(answer)
-    pirate = LLMTool(model_name="openrouter/openai/gpt-4o-mini", system_prompt="You are a pirate.")
+    pirate = LLMTool(
+        model_name="openrouter/openai/gpt-4o-mini", system_prompt="You are a pirate.", on_token=console_print_token
+    )
     pirate_answer = pirate.execute(system_prompt=system_prompt, prompt=question, temperature=temperature)
-    print(pirate_answer)
+    print("\n")
+    print(f"Anwser: {pirate_answer}")

quantalogic/tools/llm_vision_tool.py

@@ -1,8 +1,8 @@
 """LLM Vision Tool for analyzing images using a language model."""
 
-import logging
 from typing import Optional
 
+from loguru import logger
 from pydantic import ConfigDict, Field
 
 from quantalogic.generative_model import GenerativeModel, Message
@@ -65,7 +65,12 @@ class LLMVisionTool(Tool):
         """Initialize the generative model after model initialization."""
         if self.generative_model is None:
             self.generative_model = GenerativeModel(model=self.model_name)
-            logging.debug(f"Initialized LLMVisionTool with model: {self.model_name}")
+            logger.debug(f"Initialized LLMVisionTool with model: {self.model_name}")
+
+        # Only set up event listener if on_token is provided
+        if self.on_token is not None:
+            logger.debug(f"Setting up event listener for LLMVisionTool with model: {self.model_name}")
+            self.generative_model.event_emitter.on("stream_chunk", self.on_token)
 
     def execute(self, system_prompt: str, prompt: str, image_url: str, temperature: str = "0.7") -> str:
         """Execute the tool to analyze an image and generate a response.
@@ -88,7 +93,7 @@ class LLMVisionTool(Tool):
             if not (0.0 <= temp <= 1.0):
                 raise ValueError("Temperature must be between 0 and 1.")
         except ValueError as ve:
-            logging.error(f"Invalid temperature value: {temperature}")
+            logger.error(f"Invalid temperature value: {temperature}")
             raise ValueError(f"Invalid temperature value: {temperature}") from ve
 
         if not image_url.startswith(("http://", "https://")):
@@ -105,14 +110,25 @@ class LLMVisionTool(Tool):
         self.generative_model.temperature = temp
 
         try:
+            is_streaming = self.on_token is not None
             response_stats = self.generative_model.generate_with_history(
-                messages_history=messages_history, prompt=prompt, image_url=image_url
+                messages_history=messages_history,
+                prompt=prompt,
+                image_url=image_url,
+                streaming=is_streaming
             )
-            response = response_stats.response.strip()
-            logging.info(f"Generated response: {response}")
+
+            if is_streaming:
+                response = ""
+                for chunk in response_stats:
+                    response += chunk
+            else:
+                response = response_stats.response.strip()
+
+            logger.info(f"Generated response: {response}")
             return response
         except Exception as e:
-            logging.error(f"Error generating response: {e}")
+            logger.error(f"Error generating response: {e}")
             raise Exception(f"Error generating response: {e}") from e