quantalogic 0.2.15__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,31 +36,35 @@ 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
+from quantalogic.search_agent import create_search_agent  # noqa: E402
 
-AGENT_MODES = ["code", "basic", "interpreter", "full", "code-basic","search"]
+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, no_stream=no_stream)
     else:
         raise ValueError(f"Unknown agent mode: {mode}")
 
+
 def check_new_version():
     # Randomly check for updates (1 in 10 chance)
     if random.randint(1, 10) == 1:
@@ -81,6 +90,7 @@ def check_new_version():
         except Exception:
             return
 
+
 def configure_logger(log_level: str) -> None:
     """Configure the logger with the specified log level and format."""
     logger.remove()
@@ -122,7 +132,30 @@ def get_task_from_file(file_path: str) -> str:
         raise Exception(f"Unexpected error reading file: {e}")
 
 
-def display_welcome_message(console: Console, model_name: str, vision_model_name: str | None) -> None:
+# 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:
     """Display the welcome message and instructions."""
     version = get_version()
     console.print(
@@ -135,7 +168,8 @@ def display_welcome_message(console: Console, model_name: str, vision_model_name
             f"[yellow] 🤖 System Info:[/yellow]\n\n"
             "\n"
             f"- Model: {model_name}\n"
-            f"- Vision Model: {vision_model_name}\n\n"
+            f"- Vision Model: {vision_model_name}\n"
+            f"- Max Iterations: {max_iterations}\n\n"
             "[bold magenta]💡 Pro Tips:[/bold magenta]\n\n"
             "- Be as specific as possible in your task description to get the best results!\n"
             "- Use clear and concise language when describing your task\n"
@@ -152,7 +186,7 @@ def display_welcome_message(console: Console, model_name: str, vision_model_name
 @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",
@@ -167,6 +201,12 @@ def display_welcome_message(console: Console, model_name: str, vision_model_name
     default=None,
     help='Specify the vision model to use (litellm format, e.g. "openrouter/A/gpt-4o-mini").',
 )
+@click.option(
+    "--max-iterations",
+    type=int,
+    default=30,
+    help="Maximum number of iterations for task solving (default: 30).",
+)
 @click.pass_context
 def cli(
     ctx: click.Context,
@@ -176,6 +216,7 @@ def cli(
     mode: str,
     log: str,
     vision_model_name: str | None,
+    max_iterations: int,
 ) -> None:
     """QuantaLogic AI Assistant - A powerful AI tool for various tasks."""
     if version:
@@ -184,7 +225,13 @@ def cli(
         sys.exit(0)
     if ctx.invoked_subcommand is None:
         ctx.invoke(
-            task, model_name=model_name, verbose=verbose, mode=mode, log=log, vision_model_name=vision_model_name
+            task,
+            model_name=model_name,
+            verbose=verbose,
+            mode=mode,
+            log=log,
+            vision_model_name=vision_model_name,
+            max_iterations=max_iterations,
         )
 
 
@@ -193,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).")
@@ -208,6 +255,17 @@ def cli(
     default=None,
     help='Specify the vision model to use (litellm format, e.g. "openrouter/openai/gpt-4o-mini").',
 )
+@click.option(
+    "--max-iterations",
+    type=int,
+    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],
@@ -217,12 +275,13 @@ def task(
     log: str,
     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()
     switch_verbose(verbose, log)
 
-
     try:
         if file:
             task_content = get_task_from_file(file)
@@ -231,7 +290,7 @@ def task(
                 check_new_version()
                 task_content = task
             else:
-                display_welcome_message(console, model_name, vision_model_name)
+                display_welcome_message(console, model_name, vision_model_name, max_iterations=max_iterations)
                 check_new_version()
                 logger.debug("Waiting for user input...")
                 task_content = get_multiline_input(console).strip()
@@ -241,14 +300,13 @@ def task(
                     console.print("[yellow]No task provided. Exiting...[/yellow]")
                     sys.exit(2)
 
-        if model_name != MODEL_NAME:
-            console.print(
-                Panel.fit(
-                    f"[bold]Task to be submitted:[/bold]\n{task_content}",
-                    title="[bold]Task Preview[/bold]",
-                    border_style="blue",
-                )
+        console.print(
+            Panel.fit(
+                f"[bold]Task to be submitted:[/bold]\n{task_content}",
+                title="[bold]Task Preview[/bold]",
+                border_style="blue",
             )
+        )
         if not Confirm.ask("[bold]Are you sure you want to submit this task?[/bold]"):
             console.print("[yellow]Task submission cancelled. Exiting...[/yellow]")
             sys.exit(0)
@@ -261,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",
@@ -277,15 +339,46 @@ 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}")
-        result = agent.solve_task(task=task_content, max_iterations=300)
-        logger.debug(f"Task solved with result: {result}")
+        if max_iterations < 1:
+            raise ValueError("max_iterations must be greater than 0")
+        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(
             Panel.fit(

quantalogic/prompts.py

@@ -90,4 +90,5 @@ Every response must contain exactly two XML blocks:
 
 ### Environment Details
 {environment}
+
 """

quantalogic/search_agent.py

@@ -1,22 +1,23 @@
 from quantalogic.agent import Agent
 from quantalogic.tools import (
+    DuckDuckGoSearchTool,
     InputQuestionTool,
+    MarkitdownTool,
+    ReadFileBlockTool,
+    ReadFileTool,
+    RipgrepTool,
     SerpApiSearchTool,
-    DuckDuckGoSearchTool,
     TaskCompleteTool,
     WikipediaSearchTool,
-    ReadFileBlockTool,
-    ReadFileTool,
-    MarkitdownTool,
-    RipgrepTool
 )
 
 
-def create_search_agent(model_name: str) -> Agent:
+def create_search_agent(model_name: str, mode_full: bool = False) -> Agent:
     """Creates and configures a search agent with web, knowledge, and privacy-focused search tools.
 
     Args:
         model_name (str): Name of the language model to use for the agent's core capabilities
+        mode_full (bool, optional): If True, the agent will be configured with a full set of tools.
 
     Returns:
         Agent: A fully configured search agent instance with:
@@ -31,7 +32,6 @@ def create_search_agent(model_name: str) -> Agent:
 
     tools = [
         # Search tools
-        SerpApiSearchTool(),  # Web search capabilities
         DuckDuckGoSearchTool(),  # Privacy-focused web search
         WikipediaSearchTool(),  # Knowledge search capabilities
         # Basic interaction tools
@@ -45,6 +45,14 @@ def create_search_agent(model_name: str) -> Agent:
         RipgrepTool(),  # Code search capabilities
     ]
 
+    if mode_full:
+        tools.extend(
+            [
+                # Search tools
+                SerpApiSearchTool(),  # Web search capabilities
+            ]
+        )
+
     return Agent(
         model_name=model_name,
         tools=tools,

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 = [