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

quantalogic/generative_model.py

@@ -2,14 +2,23 @@
 
 import functools
 
+import litellm
 import openai
 from litellm import completion, exceptions, get_max_tokens, get_model_info, token_counter
 from loguru import logger
 from pydantic import BaseModel, Field, field_validator
 
+from quantalogic.event_emitter import EventEmitter  # Importing the EventEmitter class
+
 MIN_RETRIES = 1
 
 
+
+litellm.suppress_debug_info = True # Very important to suppress prints don't remove
+
+
+
+# Define the Message class for conversation handling
 class Message(BaseModel):
     """Represents a message in a conversation with a specific role and content."""
 
@@ -70,21 +79,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 +119,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 +149,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 +177,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)
 
-        Generates a response for a single user prompt without
-        any previous conversation context.
+    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
+
+            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 +259,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 +271,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,12 +10,15 @@ from typing import Optional
 import click
 from loguru import logger
 
+from quantalogic.console_print_events import console_print_events
 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
@@ -31,30 +34,33 @@ 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, compact_every_n_iteration: int | None = None, max_tokens_working_memory: int | None = None) -> 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}")
+    logger.debug(f"Using compact_every_n_iteration: {compact_every_n_iteration}")
+    logger.debug(f"Using max_tokens_working_memory: {max_tokens_working_memory}")
     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, compact_every_n_iteration=compact_every_n_iteration, max_tokens_working_memory=max_tokens_working_memory)
     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, compact_every_n_iteration=compact_every_n_iteration, max_tokens_working_memory=max_tokens_working_memory)
     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, compact_every_n_iteration=compact_every_n_iteration, max_tokens_working_memory=max_tokens_working_memory)
     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, compact_every_n_iteration=compact_every_n_iteration, max_tokens_working_memory=max_tokens_working_memory)
     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, compact_every_n_iteration=compact_every_n_iteration, max_tokens_working_memory=max_tokens_working_memory)
     elif mode == "search":
-        return create_search_agent(model_name)
+        return create_search_agent(model_name, no_stream=no_stream, compact_every_n_iteration=compact_every_n_iteration, max_tokens_working_memory=max_tokens_working_memory)
     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, compact_every_n_iteration=compact_every_n_iteration, max_tokens_working_memory=max_tokens_working_memory)
     else:
         raise ValueError(f"Unknown agent mode: {mode}")
 
@@ -126,8 +132,34 @@ 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
+    console: Console, 
+    model_name: str, 
+    vision_model_name: str | None, 
+    max_iterations: int = 50, 
+    compact_every_n_iteration: int | None = None,
+    max_tokens_working_memory: int | None = None
 ) -> None:
     """Display the welcome message and instructions."""
     version = get_version()
@@ -142,7 +174,9 @@ def display_welcome_message(
             "\n"
             f"- Model: {model_name}\n"
             f"- Vision Model: {vision_model_name}\n"
-            f"- Max Iterations: {max_iterations}\n\n"
+            f"- Max Iterations: {max_iterations}\n"
+            f"- Memory Compact Frequency: {compact_every_n_iteration or 'Default (Max Iterations)'}\n"
+            f"- Max Working Memory Tokens: {max_tokens_working_memory or 'Default'}\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"
@@ -155,11 +189,17 @@ def display_welcome_message(
 
 
 @click.group(invoke_without_command=True)
+@click.option(
+    "--compact-every-n-iteration",
+    type=int,
+    default=None,
+    help="Set the frequency of memory compaction for the agent (default: max_iterations)."
+)
 @click.option("--version", is_flag=True, help="Show version information.")
 @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",
@@ -180,6 +220,12 @@ def display_welcome_message(
     default=30,
     help="Maximum number of iterations for task solving (default: 30).",
 )
+@click.option(
+    "--max-tokens-working-memory",
+    type=int,
+    default=None,
+    help="Set the maximum number of tokens allowed in the working memory."
+)
 @click.pass_context
 def cli(
     ctx: click.Context,
@@ -190,6 +236,8 @@ def cli(
     log: str,
     vision_model_name: str | None,
     max_iterations: int,
+    compact_every_n_iteration: int | None,
+    max_tokens_working_memory: int | None,
 ) -> None:
     """QuantaLogic AI Assistant - A powerful AI tool for various tasks."""
     if version:
@@ -205,6 +253,8 @@ def cli(
             log=log,
             vision_model_name=vision_model_name,
             max_iterations=max_iterations,
+            compact_every_n_iteration=compact_every_n_iteration,
+            max_tokens_working_memory=max_tokens_working_memory,
         )
 
 
@@ -213,7 +263,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 +284,23 @@ def cli(
     default=30,
     help="Maximum number of iterations for task solving (default: 30).",
 )
+@click.option(
+    "--compact-every-n-iteration",
+    type=int,
+    default=None,
+    help="Set the frequency of memory compaction for the agent (default: max_iterations)."
+)
+@click.option(
+    "--max-tokens-working-memory",
+    type=int,
+    default=None,
+    help="Set the maximum number of tokens allowed in the working memory."
+)
+@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 +311,9 @@ def task(
     vision_model_name: str | None,
     task: Optional[str],
     max_iterations: int,
+    compact_every_n_iteration: int | None,
+    max_tokens_working_memory: int | None,
+    no_stream: bool,
 ) -> None:
     """Execute a task with the QuantaLogic AI Assistant."""
     console = Console()
@@ -257,7 +327,14 @@ def task(
                 check_new_version()
                 task_content = task
             else:
-                display_welcome_message(console, model_name, vision_model_name, max_iterations=max_iterations)
+                display_welcome_message(
+                    console, 
+                    model_name, 
+                    vision_model_name, 
+                    max_iterations=max_iterations, 
+                    compact_every_n_iteration=compact_every_n_iteration,
+                    max_tokens_working_memory=max_tokens_working_memory
+                )
                 check_new_version()
                 logger.debug("Waiting for user input...")
                 task_content = get_multiline_input(console).strip()
@@ -286,9 +363,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, compact_every_n_iteration=compact_every_n_iteration, max_tokens_working_memory=max_tokens_working_memory)
+        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 +383,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/prompts.py

@@ -17,7 +17,7 @@ Every response must contain exactly two XML blocks:
 1. Analysis Block:
 ```xml
 <thinking>
-  <!-- You must follow this precise format, be very concise and very precise -->
+  <!-- Must follow this precise format, concise, dense, use abreviations, emojis, unicode characters to make it denser -->
  <task_analysis_if_no_history> 
    Only if no conversation history:
     * Rewrite the <task> and its context with your own words in detailed, clear, and specific manner.
@@ -51,7 +51,7 @@ Every response must contain exactly two XML blocks:
   </last_observation>
   <progess_analysis>
      <!-- if there is a conversation history -->
-    * Detail each step failed and completed so far.
+    * Detail each step failed and completed so far, be concise.
     * Identify and evaluate any blockers or challenges to the progress of global task.
     * Identify repetitions: if repeated steps, take a step back and rethink your approach.
     * Provide potential solutions, and if needed, suggest reevaluating the approach and the plan.

quantalogic/search_agent.py

@@ -12,12 +12,21 @@ from quantalogic.tools import (
 )
 
 
-def create_search_agent(model_name: str, mode_full: bool = False) -> Agent:
+def create_search_agent(
+    model_name: str, 
+    mode_full: bool = False, 
+    no_stream: bool = False, 
+    compact_every_n_iteration: int | None = None,
+    max_tokens_working_memory: int | None = None
+) -> 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.
+        no_stream (bool, optional): If True, the agent will not stream results.
+        compact_every_n_iteration (int | None, optional): Frequency of memory compaction.
+        max_tokens_working_memory (int | None, optional): Maximum tokens for working memory.
 
     Returns:
         Agent: A fully configured search agent instance with:
@@ -57,4 +66,6 @@ def create_search_agent(model_name: str, mode_full: bool = False) -> Agent:
         model_name=model_name,
         tools=tools,
         specific_expertise=specific_expertise,
+        compact_every_n_iterations=compact_every_n_iteration,
+        max_tokens_working_memory=max_tokens_working_memory,
     )

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