quantalogic 0.2.24__py3-none-any.whl → 0.2.26__py3-none-any.whl

quantalogic/agent.py

@@ -140,7 +140,11 @@ class Agent(BaseModel):
             logger.error(f"Failed to initialize agent: {str(e)}")
             raise
 
-    def solve_task(self, task: str, max_iterations: int = 30, streaming: bool = False) -> str:
+    def clear_memory(self):
+        """Clear the memory and reset the session."""
+        self._reset_session(clear_memory=True)
+
+    def solve_task(self, task: str, max_iterations: int = 30, streaming: bool = False, clear_memory: bool = True) -> str:
         """Solve the given task using the ReAct framework.
 
         Args:
@@ -148,18 +152,23 @@ class Agent(BaseModel):
             max_iterations (int, optional): Maximum number of iterations to attempt solving the task.
                 Defaults to 30 to prevent infinite loops and ensure timely task completion.
             streaming (bool, optional): Whether to use streaming mode for generating responses.
+            clear_memory (bool, optional): Whether to clear the memory before solving the task.
 
         Returns:
             str: The final response after task completion.
         """
         logger.debug(f"Solving task... {task}")
-        self._reset_session(task_to_solve=task, max_iterations=max_iterations)
+        self._reset_session(task_to_solve=task, max_iterations=max_iterations,clear_memory=clear_memory)
 
         # Generate task summary
         self.task_to_solve_summary = self._generate_task_summary(task)
 
         # Add system prompt to memory
-        self.memory.add(Message(role="system", content=self.config.system_prompt))
+        # Check if system prompt is already in memory
+        # if not add it
+        # The system message is always the first message in memory
+        if not self.memory.memory or self.memory.memory[0].role != "system":
+            self.memory.add(Message(role="system", content=self.config.system_prompt))
 
         self._emit_event(
             "session_start",
@@ -263,13 +272,15 @@ class Agent(BaseModel):
 
         return answer
 
-    def _reset_session(self, task_to_solve: str = "", max_iterations: int = 30):
+    def _reset_session(self, task_to_solve: str = "", max_iterations: int = 30,clear_memory: bool = True):
         """Reset the agent's session."""
         logger.debug("Resetting session...")
         self.task_to_solve = task_to_solve
-        self.memory.reset()
-        self.variable_store.reset()
-        self.total_tokens = 0
+        if clear_memory:
+            logger.debug("Clearing memory...")
+            self.memory.reset()
+            self.variable_store.reset()
+            self.total_tokens = 0
         self.current_iteration = 0
         self.max_output_tokens = self.model.get_model_max_output_tokens() or DEFAULT_MAX_OUTPUT_TOKENS
         self.max_input_tokens = self.model.get_model_max_input_tokens() or DEFAULT_MAX_INPUT_TOKENS

quantalogic/agent_factory.py

@@ -0,0 +1,106 @@
+"""Agent factory module for creating different types of agents."""
+
+from typing import Optional
+
+from loguru import logger
+
+from quantalogic.agent import Agent
+from quantalogic.agent_config import (
+    create_basic_agent,
+    create_full_agent,
+    create_interpreter_agent,
+)
+from quantalogic.coding_agent import create_coding_agent
+from quantalogic.search_agent import create_search_agent
+
+
+def create_agent_for_mode(
+    mode: str,
+    model_name: str,
+    vision_model_name: Optional[str],
+    no_stream: bool = False,
+    compact_every_n_iteration: Optional[int] = None,
+    max_tokens_working_memory: Optional[int] = None
+) -> Agent:
+    """Create an agent based on the specified mode.
+    
+    Args:
+        mode: The mode of operation for the agent
+        model_name: The name of the language model to use
+        vision_model_name: Optional name of the vision model
+        no_stream: Whether to disable streaming mode
+        compact_every_n_iteration: Optional number of iterations before compacting memory
+        max_tokens_working_memory: Optional maximum tokens for working memory
+        
+    Returns:
+        Agent: The created agent instance
+        
+    Raises:
+        ValueError: If an unknown agent mode is specified
+    """
+    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,
+            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,
+            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_basic_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,
+            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,
+            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,
+            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,
+            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}")

quantalogic/generative_model.py

@@ -1,16 +1,17 @@
 """Generative model module for AI-powered text generation."""
 
 import functools
-from typing import Dict, Any, Optional, List
 from datetime import datetime
+from typing import Any, Dict, List
 
 import litellm
 import openai
-from litellm import completion, exceptions, get_max_tokens, get_model_info, token_counter, image_generation
+from litellm import completion, exceptions, get_max_tokens, get_model_info, image_generation, token_counter
 from loguru import logger
 from pydantic import BaseModel, Field, field_validator
 
 from quantalogic.event_emitter import EventEmitter  # Importing the EventEmitter class
+from quantalogic.get_model_info import get_max_input_tokens, get_max_output_tokens, model_info
 
 MIN_RETRIES = 1
 
@@ -265,15 +266,23 @@ class GenerativeModel:
     def _get_model_info_impl(self, model_name: str) -> dict:
         """Get information about the model with prefix fallback logic."""
         original_model = model_name
-
+        tried_models = [model_name]
+        
         while True:
             try:
                 logger.debug(f"Attempting to retrieve model info for: {model_name}")
-                model_info = get_model_info(model_name)
-                if model_info:
-                    logger.debug(f"Found model info for {model_name}: {model_info}")
-                    return model_info
-            except Exception:
+                # Try direct lookup from model_info dictionary first
+                if model_name in model_info:
+                    logger.debug(f"Found model info for {model_name} in model_info")
+                    return model_info[model_name]
+                    
+                # Try get_model_info as fallback
+                info = get_model_info(model_name)
+                if info:
+                    logger.debug(f"Found model info for {model_name} via get_model_info")
+                    return info
+            except Exception as e:
+                logger.debug(f"Failed to get model info for {model_name}: {str(e)}")
                 pass
 
             # Try removing one prefix level
@@ -281,8 +290,9 @@ class GenerativeModel:
             if len(parts) <= 1:
                 break
             model_name = "/".join(parts[1:])
+            tried_models.append(model_name)
 
-        error_msg = f"Could not find model info for {original_model} after trying: {self.model} → {model_name}"
+        error_msg = f"Could not find model info for {original_model} after trying: {' → '.join(tried_models)}"
         logger.error(error_msg)
         raise ValueError(error_msg)
 
@@ -292,12 +302,23 @@ class GenerativeModel:
             model_name = self.model
         return self._get_model_info_cached(model_name)
 
-    def get_model_max_input_tokens(self) -> int:
+    def get_model_max_input_tokens(self) -> int | None:
         """Get the maximum number of input tokens for the model."""
         try:
+            # First try direct lookup
+            max_tokens = get_max_input_tokens(self.model)
+            if max_tokens is not None:
+                return max_tokens
+            
+            # If not found, try getting from model info
             model_info = self.get_model_info()
-            max_tokens = model_info.get("max_input_tokens") if model_info else None
-            return max_tokens
+            if model_info:
+                return model_info.get("max_input_tokens")
+            
+            # If still not found, log warning and return default
+            logger.warning(f"No max input tokens found for {self.model}. Using default.")
+            return 8192  # A reasonable default for many models
+            
         except Exception as e:
             logger.error(f"Error getting max input tokens for {self.model}: {e}")
             return None
@@ -305,13 +326,20 @@ class GenerativeModel:
     def get_model_max_output_tokens(self) -> int | None:
         """Get the maximum number of output tokens for the model."""
         try:
+            # First try direct lookup
+            max_tokens = get_max_output_tokens(self.model)
+            if max_tokens is not None:
+                return max_tokens
+            
+            # If not found, try getting from model info
             model_info = self.get_model_info()
             if model_info:
                 return model_info.get("max_output_tokens")
-
-            # Fallback for unmapped models
+            
+            # If still not found, log warning and return default
             logger.warning(f"No max output tokens found for {self.model}. Using default.")
-            return 4096  # A reasonable default for many chat models
+            return 4096  # A reasonable default for many models
+            
         except Exception as e:
             logger.error(f"Error getting max output tokens for {self.model}: {e}")
             return None

quantalogic/get_model_info.py

@@ -0,0 +1,14 @@
+model_info = {
+    "deepseek-reasoner": {"max_output_tokens": 8 * 1024, "max_input_tokens": 1024 * 128},
+    "openrouter/deepseek/deepseek-r1": {"max_output_tokens": 8 * 1024, "max_input_tokens": 1024 * 128},
+}
+
+
+def get_max_output_tokens(model_name: str) -> int | None:
+    """Get the maximum output tokens for a given model name."""
+    return model_info.get(model_name, {}).get("max_output_tokens", None)
+
+
+def get_max_input_tokens(model_name: str) -> int | None:
+    """Get the maximum input tokens for a given model name."""
+    return model_info.get(model_name, {}).get("max_input_tokens", None)

quantalogic/interactive_text_editor.py

@@ -171,6 +171,10 @@ def get_multiline_input(console: Console) -> str:
             prompt_text = f"{line_number:>3}: "
             line = session.prompt(prompt_text, rprompt="Press Enter twice to submit")
 
+            # Handle commands with single return
+            if line.strip().startswith('/'):
+                return line.strip()
+
             if line.strip() == "":
                 blank_lines += 1
                 if blank_lines == 2:

quantalogic/main.py

@@ -2,211 +2,36 @@
 """Main module for the QuantaLogic agent."""
 
 # Standard library imports
-import random
 import sys
 from typing import Optional
 
 # Third-party imports
 import click
-import requests
 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
+logger.remove()
 
 from rich.console import Console  # noqa: E402
 from rich.panel import Panel  # noqa: E402
-from rich.prompt import Confirm  # noqa: E402
-
-from quantalogic.agent import Agent  # noqa: E402
 
 # Local application imports
 from quantalogic.agent_config import (  # noqa: E402
     MODEL_NAME,
-    create_basic_agent,
-    create_full_agent,
-    create_interpreter_agent,
 )
-from quantalogic.coding_agent import create_coding_agent  # noqa: E402
-from quantalogic.interactive_text_editor import get_multiline_input  # noqa: E402
-from quantalogic.search_agent import create_search_agent  # noqa: E402
+from quantalogic.task_runner import task_runner  # 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, 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, 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, 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_basic_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, 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, 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, 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, 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}")
-
-
-def check_new_version():
-    # Randomly check for updates (1 in 10 chance)
-    if random.randint(1, 10) == 1:
-        try:
-            current_version = get_version()
-            has_new_version, latest_version = check_if_is_latest_version()
-
-            if has_new_version:
-                console = Console()
-                console.print(
-                    Panel.fit(
-                        f"[yellow]⚠️  Update Available![/yellow]\n\n"
-                        f"Current version: [bold]{current_version}[/bold]\n"
-                        f"Latest version: [bold]{latest_version}[/bold]\n\n"
-                        "To update, run:\n"
-                        "[bold]pip install --upgrade quantalogic[/bold]\n"
-                        "or if using pipx:\n"
-                        "[bold]pipx upgrade quantalogic[/bold]",
-                        title="[bold]Update Available[/bold]",
-                        border_style="yellow",
-                    )
-                )
-        except Exception:
-            return
-
-
-def configure_logger(log_level: str) -> None:
-    """Configure the logger with the specified log level and format."""
-    logger.remove()
-    logger.add(
-        sys.stderr,
-        level=log_level.upper(),
-        format="<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{process}</cyan> | <magenta>{file}:{line}</magenta> | {message}",
-    )
-    logger.debug(f"Log level set to: {log_level}")
-
-
-def set_litellm_verbose(verbose_mode: bool) -> None:
-    """Set the verbosity of the litellm library."""
-    import litellm
-
-    litellm.set_verbose = verbose_mode
-
-
-def switch_verbose(verbose_mode: bool, log_level: str = "info") -> None:
-    """Switch verbose mode and configure logger and litellm verbosity."""
-    if log_level == "debug":
-        configure_logger("DEBUG")
-    else:
-        configure_logger(log_level)
-
-    set_litellm_verbose(verbose_mode)
-
-
-def get_task_from_file(source: str):
-    """Get task content from specified file path or URL."""
-    try:
-        # Check if source is a URL
-        if source.startswith(('http://', 'https://')):
-            import requests
-            response = requests.get(source, timeout=10)
-            response.raise_for_status()  # Raise an exception for bad status codes
-            return response.text.strip()
-        
-        # If not a URL, treat as a local file path
-        with open(source, encoding="utf-8") as f:
-            return f.read().strip()
-    except FileNotFoundError:
-        raise FileNotFoundError(f"Error: File '{source}' not found.")
-    except PermissionError:
-        raise PermissionError(f"Error: Permission denied when reading '{source}'.")
-    except requests.exceptions.RequestException as e:
-        raise Exception(f"Error retrieving URL content: {e}")
-    except Exception as e:
-        raise Exception(f"Unexpected error: {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, 
-    compact_every_n_iteration: int | None = None,
-    max_tokens_working_memory: int | None = None,
-    mode: str = "basic"
-) -> None:
-    """Display the welcome message and instructions."""
-    version = get_version()
-    console.print(
-        Panel.fit(
-            f"[bold cyan]🌟 Welcome to QuantaLogic AI Assistant v{version} ! 🌟[/bold cyan]\n\n"
-            "[green]🎯 How to Use:[/green]\n\n"
-            "1. [bold]Describe your task[/bold]: Tell the AI what you need help with.\n"
-            "2. [bold]Submit your task[/bold]: Press [bold]Enter[/bold] twice to send your request.\n\n"
-            "3. [bold]Exit the app[/bold]: Leave the input blank and press [bold]Enter[/bold] twice to close the assistant.\n\n"
-            f"[yellow] 🤖 System Info:[/yellow]\n\n"
-            "\n"
-            f"- Model: {model_name}\n"
-            f"- Vision Model: {vision_model_name}\n"
-            f"- Mode: {mode}\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"
-            "- For coding tasks, include relevant context and requirements\n"
-            "- The coding agent mode can handle complex tasks - don't hesitate to ask challenging questions!",
-            title="[bold]Instructions[/bold]",
-            border_style="blue",
-        )
-    )
-
-
 @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)."
+    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(
@@ -237,7 +62,7 @@ def display_welcome_message(
     "--max-tokens-working-memory",
     type=int,
     default=None,
-    help="Set the maximum number of tokens allowed in the working memory."
+    help="Set the maximum number of tokens allowed in the working memory.",
 )
 @click.pass_context
 def cli(
@@ -255,8 +80,12 @@ def cli(
     """QuantaLogic AI Assistant - A powerful AI tool for various tasks."""
     if version:
         console = Console()
-        console.print(f"QuantaLogic version: {get_version()}")
-        sys.exit(0)
+        current_version = get_version()
+        console.print(
+            Panel(f"QuantaLogic Version: [bold green]{current_version}[/bold green]", title="Version Information")
+        )
+        ctx.exit()
+
     if ctx.invoked_subcommand is None:
         ctx.invoke(
             task,
@@ -301,13 +130,13 @@ def cli(
     "--compact-every-n-iteration",
     type=int,
     default=None,
-    help="Set the frequency of memory compaction for the agent (default: max_iterations)."
+    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."
+    help="Set the maximum number of tokens allowed in the working memory.",
 )
 @click.option(
     "--no-stream",
@@ -328,122 +157,23 @@ def task(
     max_tokens_working_memory: int | None,
     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)
-        else:
-            if task:
-                check_new_version()
-                task_content = task
-            else:
-                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,
-                    mode=mode
-                )
-                check_new_version()
-                logger.debug("Waiting for user input...")
-                task_content = get_multiline_input(console).strip()
-                logger.debug(f"User input received. Task content: {task_content}")
-                if not task_content:
-                    logger.info("No task provided. Exiting...")
-                    console.print("[yellow]No task provided. Exiting...[/yellow]")
-                    sys.exit(2)
-
-        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)
-
-        console.print(
-            Panel.fit(
-                "[green]✓ Task successfully submitted! Processing...[/green]",
-                title="[bold]Status[/bold]",
-                border_style="green",
-            )
-        )
-
-        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",
-            "task_think_start",
-            "task_think_end",
-            "task_complete",
-            "tool_execution_start",
-            "tool_execution_end",
-            "error_max_iterations_reached",
-            "memory_full",
-            "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, streaming=not no_stream)
-        logger.debug(f"Task solved with result: {result} using {max_iterations} iterations")
-
-        console.print(
-            Panel.fit(
-                f"[bold]Task Result:[/bold]\n{result}", title="[bold]Execution Output[/bold]", border_style="green"
-            )
+        task_runner(
+            console,
+            file,
+            model_name,
+            verbose,
+            mode,
+            log,
+            vision_model_name,
+            task,
+            max_iterations,
+            compact_every_n_iteration,
+            max_tokens_working_memory,
+            no_stream,
         )
-
     except Exception as e:
         console.print(f"[red]{str(e)}[/red]")
         logger.error(f"Error in task execution: {e}", exc_info=True)

quantalogic/task_file_reader.py

@@ -0,0 +1,38 @@
+"""Module for reading task content from files or URLs."""
+
+import requests
+
+
+def get_task_from_file(source: str) -> str:
+    """Get task content from specified file path or URL.
+    
+    Args:
+        source (str): File path or URL to read task content from
+    
+    Returns:
+        str: Stripped task content from the file or URL
+    
+    Raises:
+        FileNotFoundError: If the local file does not exist
+        PermissionError: If there are permission issues reading the file
+        requests.exceptions.RequestException: If there are issues retrieving URL content
+        Exception: For any other unexpected errors
+    """
+    try:
+        # Check if source is a URL
+        if source.startswith(('http://', 'https://')):
+            response = requests.get(source, timeout=10)
+            response.raise_for_status()  # Raise an exception for bad status codes
+            return response.text.strip()
+        
+        # If not a URL, treat as a local file path
+        with open(source, encoding="utf-8") as f:
+            return f.read().strip()
+    except FileNotFoundError:
+        raise FileNotFoundError(f"Error: File '{source}' not found.")
+    except PermissionError:
+        raise PermissionError(f"Error: Permission denied when reading '{source}'.")
+    except requests.exceptions.RequestException as e:
+        raise Exception(f"Error retrieving URL content: {e}")
+    except Exception as e:
+        raise Exception(f"Unexpected error: {e}")

quantalogic/task_runner.py

@@ -0,0 +1,284 @@
+"""Task runner module for executing tasks with the QuantaLogic AI Assistant."""
+
+import sys
+from threading import Lock
+from typing import Optional
+
+from loguru import logger
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm
+
+from quantalogic.agent_factory import create_agent_for_mode
+from quantalogic.console_print_events import console_print_events
+from quantalogic.interactive_text_editor import get_multiline_input
+from quantalogic.task_file_reader import get_task_from_file
+from quantalogic.version_check import check_new_version, get_version
+from quantalogic.welcome_message import display_welcome_message
+
+# Spinner control
+spinner_lock = Lock()
+current_spinner = None
+
+
+def configure_logger(log_level: str) -> None:
+    """Configure the logger with the specified log level and format."""
+    logger.add(
+        sys.stderr,
+        level=log_level.upper(),
+        format="<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{process}</cyan> | <magenta>{file}:{line}</magenta> | {message}",
+    )
+    logger.debug(f"Log level set to: {log_level}")
+
+
+def set_litellm_verbose(verbose_mode: bool) -> None:
+    """Set the verbosity of the litellm library."""
+    import litellm
+
+    litellm.set_verbose = verbose_mode
+
+
+def switch_verbose(verbose_mode: bool, log_level: str = "info") -> None:
+    """Switch verbose mode and configure logger and litellm verbosity."""
+    if log_level == "debug":
+        configure_logger("DEBUG")
+    else:
+        configure_logger(log_level)
+
+    set_litellm_verbose(verbose_mode)
+
+
+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 interactive_task_runner(
+    agent,
+    console: Console,
+    max_iterations: int,
+    no_stream: bool,
+) -> None:
+    """Run tasks interactively, asking the user if they want to continue after each task.
+
+    Args:
+        agent: The agent instance to use for solving tasks
+        console: Rich console instance for output
+        max_iterations: Maximum number of iterations per task
+        no_stream: Disable streaming output
+    """
+    while True:
+        logger.debug("Waiting for user input...")
+        task_content = get_multiline_input(console).strip()
+        
+        if not task_content:
+            logger.info("No task provided. Exiting...")
+            console.print("[yellow]No task provided. Exiting...[/yellow]")
+            break
+
+        # Handle commands with single return
+        if task_content.startswith('/'):
+            command = task_content.lower()
+            if command == '/clear':
+                logger.info("Clearing agent memory...")
+                console.print("[yellow]Clearing agent memory...[/yellow]")
+                agent.clear_memory()
+                console.print("[green]Memory cleared successfully![/green]")
+                continue
+            else:
+                console.print(f"[red]Unknown command: {command}[/red]")
+                continue
+
+        # For non-commands, ask for confirmation
+        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.[/yellow]")
+            if not Confirm.ask("[bold]Would you like to ask another question?[/bold]"):
+                break
+            continue
+
+        console.print(
+            Panel.fit(
+                "[green]✓ Task successfully submitted! Processing...[/green]",
+                title="[bold]Status[/bold]",
+                border_style="green",
+            )
+        )
+
+        logger.debug(f"Solving task with agent: {task_content}")
+        result = agent.solve_task(task=task_content, max_iterations=max_iterations, streaming=not no_stream,clear_memory=False)
+        logger.debug(f"Task solved with result: {result} using {max_iterations} iterations")
+
+        console.print(
+            Panel.fit(
+                f"[bold]Task Result:[/bold]\n{result}",
+                title="[bold]Execution Output[/bold]",
+                border_style="green"
+            )
+        )
+
+        if not Confirm.ask("[bold]Would you like to ask another question?[/bold]"):
+            break
+
+
+def task_runner(
+    console: Console,
+    file: Optional[str],
+    model_name: str,
+    verbose: bool,
+    mode: str,
+    log: str,
+    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.
+
+    Args:
+        console: Rich console instance for output
+        file: Optional path to task file
+        model_name: Name of the model to use
+        verbose: Enable verbose logging
+        mode: Operation mode
+        log: Log level
+        vision_model_name: Optional vision model name
+        task: Optional task string
+        max_iterations: Maximum number of iterations
+        compact_every_n_iteration: Optional number of iterations before memory compaction
+        max_tokens_working_memory: Optional maximum tokens for working memory
+        no_stream: Disable streaming output
+    """
+    switch_verbose(verbose, log)
+
+    # Create the agent instance with the specified configuration
+    agent = create_agent_for_mode(
+        mode=mode,
+        model_name=model_name,
+        vision_model_name=vision_model_name,
+        compact_every_n_iteration=compact_every_n_iteration,
+        max_tokens_working_memory=max_tokens_working_memory
+    )
+
+    if file:
+        task_content = get_task_from_file(file)
+        # Execute single task from file
+        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, streaming=not no_stream)
+        logger.debug(f"Task solved with result: {result} using {max_iterations} iterations")
+
+        console.print(
+            Panel.fit(
+                f"[bold]Task Result:[/bold]\n{result}",
+                title="[bold]Execution Output[/bold]",
+                border_style="green"
+            )
+        )
+    else:
+        if task:
+            check_new_version()
+            task_content = task
+            # Execute single task from command line
+            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, streaming=not no_stream)
+            logger.debug(f"Task solved with result: {result} using {max_iterations} iterations")
+
+            console.print(
+                Panel.fit(
+                    f"[bold]Task Result:[/bold]\n{result}",
+                    title="[bold]Execution Output[/bold]",
+                    border_style="green"
+                )
+            )
+        else:
+            # Interactive mode
+            display_welcome_message(
+                console=console,
+                model_name=model_name,
+                version=get_version(),
+                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,
+                mode=mode,
+            )
+            check_new_version()
+            logger.debug(
+                f"Created agent for mode: {mode} with model: {model_name}, vision model: {vision_model_name}, no_stream: {no_stream}"
+            )
+
+            events = [
+                "task_start",
+                "task_think_start",
+                "task_think_end",
+                "task_complete",
+                "tool_execution_start",
+                "tool_execution_end",
+                "error_max_iterations_reached",
+                "memory_full",
+                "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}")
+
+            interactive_task_runner(agent, console, max_iterations, no_stream)

quantalogic/tools/llm_tool.py

@@ -122,7 +122,6 @@ class LLMTool(Tool):
         # Prepare the messages history
         messages_history = [
             Message(role="system", content=used_system_prompt),
-            Message(role="user", content=prompt),
         ]
 
         is_streaming = self.on_token is not None

quantalogic/version_check.py

@@ -0,0 +1,41 @@
+"""Module for checking and displaying version updates."""
+
+import random
+
+from rich.console import Console
+from rich.panel import Panel
+
+from quantalogic.utils.check_version import check_if_is_latest_version
+from quantalogic.version import get_version
+
+
+def check_new_version() -> None:
+    """Randomly check for updates and display a notification if a new version is available.
+    
+    This function has a 1 in 10 chance of running when called. When it runs, it checks
+    if there's a newer version of the package available and displays an update panel
+    with installation instructions if a new version is found.
+    """
+    # Randomly check for updates (1 in 10 chance)
+    if random.randint(1, 10) == 1:
+        try:
+            current_version = get_version()
+            has_new_version, latest_version = check_if_is_latest_version()
+
+            if has_new_version:
+                console = Console()
+                console.print(
+                    Panel.fit(
+                        f"[yellow]⚠️  Update Available![/yellow]\n\n"
+                        f"Current version: [bold]{current_version}[/bold]\n"
+                        f"Latest version: [bold]{latest_version}[/bold]\n\n"
+                        "To update, run:\n"
+                        "[bold]pip install --upgrade quantalogic[/bold]\n"
+                        "or if using pipx:\n"
+                        "[bold]pipx upgrade quantalogic[/bold]",
+                        title="[bold]Update Available[/bold]",
+                        border_style="yellow",
+                    )
+                )
+        except Exception:
+            return

quantalogic/welcome_message.py

@@ -0,0 +1,86 @@
+"""Module for displaying welcome messages and instructions."""
+
+from rich.console import Console
+from rich.panel import Panel
+
+
+def create_config_table(
+    mode: str,
+    model_name: str,
+    vision_model_name: str | None,
+    max_iterations: int,
+    compact_every_n_iteration: int | None,
+    max_tokens_working_memory: int | None,
+) -> str:
+    """Create a formatted string representation of the configuration table."""
+    return (
+        f"• Mode              [cyan]{mode}[/cyan]\n"
+        f"• Language Model    [cyan]{model_name}[/cyan]\n"
+        f"• Vision Model      {vision_model_name or '[dim]Not Configured[/dim]'}\n"
+        f"• Max Iterations    {max_iterations}\n"
+        f"• Memory Compaction {compact_every_n_iteration or '[dim]Default[/dim]'}\n"
+        f"• Max Memory Tokens {max_tokens_working_memory or '[dim]Default[/dim]'}"
+    )
+
+
+def create_tips_section() -> str:
+    """Create a formatted string representation of the tips section."""
+    return (
+        "💡 [bold cyan]Be specific[/bold cyan] in your task descriptions\n"
+        "💭 Use [bold cyan]clear and concise[/bold cyan] language\n"
+        "✨ Include [bold cyan]relevant context[/bold cyan] for coding tasks\n"
+        "🚀 Don't hesitate to ask [bold cyan]challenging questions[/bold cyan]!"
+    )
+
+
+def display_welcome_message(
+    console: Console,
+    model_name: str, 
+    version: str,
+    vision_model_name: str | None = None, 
+    max_iterations: int = 50, 
+    compact_every_n_iteration: int | None = None,
+    max_tokens_working_memory: int | None = None,
+    mode: str = "basic",
+) -> None:
+    """Display a welcome message and instructions for the QuantaLogic AI Assistant.
+    
+    Args:
+        console: Rich Console instance for rendering output
+        model_name: Name of the language model being used
+        version: Version of the QuantaLogic AI Assistant
+        vision_model_name: Optional name of the vision model
+        max_iterations: Maximum number of iterations for task solving
+        compact_every_n_iteration: Frequency of memory compaction
+        max_tokens_working_memory: Maximum tokens allowed in working memory
+        mode: Current agent mode of operation
+    """
+    config_section = create_config_table(
+        mode,
+        model_name,
+        vision_model_name,
+        max_iterations,
+        compact_every_n_iteration,
+        max_tokens_working_memory,
+    )
+    
+    tips_section = create_tips_section()
+
+    welcome_content = (
+        "\n[bold violet]Welcome to QuantaLogic AI Assistant[/bold violet]  "
+        f"[bold blue]v{version}[/bold blue]\n\n"
+        "[bold]System Configuration[/bold]\n"
+        f"{config_section}\n\n"
+        "[bold magenta]Pro Tips[/bold magenta]\n"
+        f"{tips_section}\n"
+    )
+    
+    welcome_panel = Panel(
+        welcome_content,
+        border_style="blue",
+        title="[bold]🤖 QuantaLogic[/bold]",
+        subtitle="[bold cyan]Ready to assist you[/bold cyan]",
+        padding=(1, 2),
+    )
+    
+    console.print(welcome_panel)

{quantalogic-0.2.24.dist-info → quantalogic-0.2.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.2.24
+Version: 0.2.26
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com

{quantalogic-0.2.24.dist-info → quantalogic-0.2.26.dist-info}/RECORD

@@ -1,14 +1,17 @@
+quantalogic/.DS_Store,sha256=eca-id755LHcqhOPlLg84Op_uvWhoJGFTR_i_r8G2K8,6148
 quantalogic/__init__.py,sha256=kX0c_xmD9OslWnAE92YHMGuD7xZcTo8ZOF_5R64HKps,784
-quantalogic/agent.py,sha256=4Z3ImHbLs3wThspoSYR-mR_zSExMf1nwcLGxZjTQLXY,31226
+quantalogic/agent.py,sha256=r6MbnVaBv9tYNk8WR7YJAjXlEGgko8GSYitWzr7uNMY,31841
 quantalogic/agent_config.py,sha256=9sjDnCPlAqVM45oguB_D509WSCaXZmuaVUtLcOvDlPg,7572
+quantalogic/agent_factory.py,sha256=ODVGuGtugSzmSdP6jiWlT8WyC5onANc6BIs83FC90Bg,3782
 quantalogic/coding_agent.py,sha256=UJ0fdKKA8XSB2py0NW4-e-orozo78ZAprXWuortYBiA,4935
 quantalogic/console_print_events.py,sha256=KB-DGi52As8M96eUs1N_vgNqKIFtqv_H8NTOd3TLTgQ,2163
 quantalogic/console_print_token.py,sha256=qSU-3kmoZk4T5-1ybrEBi8tIXDPcz7eyWKhGh3E8uIg,395
 quantalogic/docs_cli.py,sha256=3giVbUpespB9ZdTSJ955A3BhcOaBl5Lwsn1AVy9XAeY,1663
 quantalogic/event_emitter.py,sha256=jqot2g4JRXc88K6PW837Oqxbf7shZfO-xdPaUWmzupk,7901
-quantalogic/generative_model.py,sha256=vv7fvkZz3GRvtuhYGeq64bJUhxyjmhbz-G5mDbsvCiE,15451
-quantalogic/interactive_text_editor.py,sha256=kYeTA2qej5kxtPvAUHy_Dr2MhrGQAyenLFpW9mU9Rmw,6855
-quantalogic/main.py,sha256=aD9x-UEutcjOUou_r4pJUZZ4VxP-0J3-NC6eCZxK4og,17234
+quantalogic/generative_model.py,sha256=az_kqWdEBQRROvvYZu6d68JQ4nzDbQG23gADeHLMypc,16761
+quantalogic/get_model_info.py,sha256=YCBZ8qynlq_iLUc--xBrQxacFZL9RHZPv5cdVwjukcw,602
+quantalogic/interactive_text_editor.py,sha256=_pNPnUG3Y3_YX0R9-kx0vcaUWU0AAC350jpJ5UjrTuE,6986
+quantalogic/main.py,sha256=YYP0DSnzlLpbyQPlQxbq-ZKIoA5ezv0kjy5LsQlT6bI,5227
 quantalogic/memory.py,sha256=zbtRuM05jaS2lJll-92dt5JfYVLERnF_m_9xqp2x-k0,6304
 quantalogic/model_names.py,sha256=UZlz25zG9B2dpfwdw_e1Gw5qFsKQ7iME9FJh9Ts4u6s,938
 quantalogic/prompts.py,sha256=CW4CRgW1hTpXeWdeJNbPaRPUeUm-xKuGHJrT8mOtvkw,3602
@@ -21,6 +24,8 @@ quantalogic/server/state.py,sha256=TwtL0BTp_LT-fynF1IR4k8WVXuxXWtSv3NgWG9fuUME,7
 quantalogic/server/static/js/event_visualizer.js,sha256=eFkkWyNZw3zOZlF18kxbfsWql8a2C13qBFEOAPzrj88,19646
 quantalogic/server/static/js/quantalogic.js,sha256=x7TrlZGR1Y0WLK2DWl1xY847BhEWMPnL0Ua7KtOldUc,22311
 quantalogic/server/templates/index.html,sha256=nDnXJoQEm1vXbhXtgaYk0G5VXj0wwzE6KrqEDhHFpj4,7773
+quantalogic/task_file_reader.py,sha256=AMIJoeVY9Hhu0dBJ-C5EyaOFsXLkhn2oBhVs-WTnnLk,1460
+quantalogic/task_runner.py,sha256=FtxfZs2dxdsSZoiW92K3dpfegFe0dyKx9ZP5CCyEAzo,9965
 quantalogic/tool_manager.py,sha256=JAC5E5kLfYzYJx0QRIWbG14q1hlkOcwJFBG7HE8twpU,2425
 quantalogic/tools/__init__.py,sha256=GcYjE1r6aNQ_JZ8uwk0yaCCCMBz6zrD_PjkRtZiUhSk,1923
 quantalogic/tools/agent_tool.py,sha256=MXCXxWHRch7VK4UWhtRP1jeI8Np9Ne2CUGo8vm1oZiM,3064
@@ -43,7 +48,7 @@ quantalogic/tools/language_handlers/rust_handler.py,sha256=t_AqKVa3KVk6SVkq_UjUU
 quantalogic/tools/language_handlers/scala_handler.py,sha256=wr-cWOIFOc0UYwODmEtT6rV63Qf1NyNB_BLo23GLrvk,1281
 quantalogic/tools/language_handlers/typescript_handler.py,sha256=L4vuJMYxKO3_83dQhdwZ9fogauIV7rwoicRT0xLGfkQ,1738
 quantalogic/tools/list_directory_tool.py,sha256=8Hy38DelSh-mRqS_uDLpeBYoHLtEy5ji77xI-TJu3Ms,4176
-quantalogic/tools/llm_tool.py,sha256=6OSfEyV-VDlJjoQrRusXgeM-CPbTLZv1Yr1aRaXndVI,7064
+quantalogic/tools/llm_tool.py,sha256=CFTvr-RTFiuGWlOLtvw4zv93s_CLUHuHfNmvK6QpQiQ,7014
 quantalogic/tools/llm_vision_tool.py,sha256=eVDIrANxxZCHxYp9xaAN8hLdFhlYm7bUu2tX9-1xUbI,5496
 quantalogic/tools/markitdown_tool.py,sha256=lpbJBLx43_x2DjiZAV1HSidkHeqkkV0KvgeLG2fphK4,4339
 quantalogic/tools/nodejs_tool.py,sha256=zdnE0VFj_5786uR2L0o-SKR0Gk8L-U7rdj7xGHJYIq0,19905
@@ -71,10 +76,12 @@ quantalogic/utils/git_ls.py,sha256=_k6QIQtc0aM1bsG340jBp4VrdevbcH8Pg2CV4r9oHok,5
 quantalogic/utils/read_file.py,sha256=tSRVHk8dIP4nNLL89v5kRki4hOTjVyjbmuEb2zwvwCY,2077
 quantalogic/utils/read_http_text_content.py,sha256=n3IayT5KcqctIVVF2gOQQAMf3Ow6eenlVgfXTpLcQbw,4410
 quantalogic/version.py,sha256=ea_cRutaQk5_lwlLbUUvPFuOT7Of7-gAsDl7wdveS-g,107
+quantalogic/version_check.py,sha256=cttR1lR3OienGLl7NrK1Te1fhDkqSjCci7HC1vFUTSY,1627
+quantalogic/welcome_message.py,sha256=IXMhem8h7srzNUwvw8G_lmEkHU8PFfote021E_BXmVk,3039
 quantalogic/xml_parser.py,sha256=uMLQNHTRCg116FwcjRoquZmSwVtE4LEH-6V2E3RD-dA,11466
 quantalogic/xml_tool_parser.py,sha256=Vz4LEgDbelJynD1siLOVkJ3gLlfHsUk65_gCwbYJyGc,3784
-quantalogic-0.2.24.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-quantalogic-0.2.24.dist-info/METADATA,sha256=7KW6YE5DLHVHhxJDT240XjpJIBe0mhdlIC6lIx58kt8,20216
-quantalogic-0.2.24.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-quantalogic-0.2.24.dist-info/entry_points.txt,sha256=h74O_Q3qBRCrDR99qvwB4BpBGzASPUIjCfxHq6Qnups,183
-quantalogic-0.2.24.dist-info/RECORD,,
+quantalogic-0.2.26.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+quantalogic-0.2.26.dist-info/METADATA,sha256=jb0PIHKkAGlfW5x3GPQvcbzJNbG-79nxJm-t8zCN7hA,20216
+quantalogic-0.2.26.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+quantalogic-0.2.26.dist-info/entry_points.txt,sha256=h74O_Q3qBRCrDR99qvwB4BpBGzASPUIjCfxHq6Qnups,183
+quantalogic-0.2.26.dist-info/RECORD,,