quantalogic 0.2.23__tar.gz → 0.2.25__tar.gz

{quantalogic-0.2.23 → quantalogic-0.2.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.2.23
+Version: 0.2.25
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com
@@ -32,6 +32,7 @@ Requires-Dist: pathspec (>=0.12.1,<0.13.0)
 Requires-Dist: prompt-toolkit (>=3.0.48,<4.0.0)
 Requires-Dist: pydantic (>=2.10.4,<3.0.0)
 Requires-Dist: pymdown-extensions (>=10.3.1,<11.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
 Requires-Dist: rich (>=13.9.4,<14.0.0)
 Requires-Dist: serpapi (>=0.1.5,<0.2.0)
 Requires-Dist: tenacity (>=9.0.0,<10.0.0)

{quantalogic-0.2.23 → quantalogic-0.2.25}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "quantalogic"
-version = "0.2.23"
+version = "0.2.25"
 description = "QuantaLogic ReAct Agents"
 authors = ["Raphaël MANSUY <raphael.mansuy@gmail.com>"]
 readme = "README.md"
@@ -49,6 +49,7 @@ llmlingua = "^0.2.2"
 jinja2 = "^3.1.5"
 beautifulsoup4 = "^4.12.3"
 markdownify = "^0.14.1"
+requests = "^2.32.3"
 
 [tool.poetry.scripts]
 quantalogic = "quantalogic.main:cli"

{quantalogic-0.2.23 → quantalogic-0.2.25}/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,12 +152,13 @@ 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)
@@ -263,13 +268,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-0.2.25/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-0.2.23 → quantalogic-0.2.25}/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-0.2.25/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-0.2.23 → quantalogic-0.2.25}/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-0.2.25/quantalogic/main.py

@@ -0,0 +1,189 @@
+#!/usr/bin/env python
+"""Main module for the QuantaLogic agent."""
+
+# Standard library imports
+import sys
+from typing import Optional
+
+# Third-party imports
+import click
+from loguru import logger
+
+from quantalogic.version import get_version
+
+# Configure logger
+logger.remove()
+
+from rich.console import Console  # noqa: E402
+from rich.panel import Panel  # noqa: E402
+
+# Local application imports
+from quantalogic.agent_config import (  # noqa: E402
+    MODEL_NAME,
+)
+from quantalogic.task_runner import task_runner  # noqa: E402
+
+AGENT_MODES = ["code", "basic", "interpreter", "full", "code-basic", "search", "search-full"]
+
+
+@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/deepseek-chat").',
+)
+@click.option(
+    "--log",
+    type=click.Choice(["info", "debug", "warning"]),
+    default="info",
+    help="Set logging level (info/debug/warning).",
+)
+@click.option("--verbose", is_flag=True, help="Enable verbose output.")
+@click.option("--mode", type=click.Choice(AGENT_MODES), default="basic", help="Agent mode (code/search/full).")
+@click.option(
+    "--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.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,
+    version: bool,
+    model_name: str,
+    verbose: bool,
+    mode: str,
+    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:
+        console = Console()
+        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,
+            model_name=model_name,
+            verbose=verbose,
+            mode=mode,
+            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,
+        )
+
+
+@cli.command()
+@click.option("--file", type=str, help="Path to task file or URL.")
+@click.option(
+    "--model-name",
+    default=MODEL_NAME,
+    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="basic", help="Agent mode (code/search/full).")
+@click.option(
+    "--log",
+    type=click.Choice(["info", "debug", "warning"]),
+    default="info",
+    help="Set logging level (info/debug/warning).",
+)
+@click.option(
+    "--vision-model-name",
+    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(
+    "--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],
+    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:
+    console = Console()
+
+    try:
+        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)
+        sys.exit(1)
+
+
+def main():
+    """Main Entry point"""
+    cli()
+
+
+if __name__ == "__main__":
+    main()

quantalogic-0.2.25/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}")