quantalogic 0.30.8__py3-none-any.whl → 0.31.1__py3-none-any.whl

quantalogic/main.py

@@ -8,6 +8,7 @@ from typing import Optional
 # Third-party imports
 import click
 from dotenv import load_dotenv
+from fuzzywuzzy import process
 from loguru import logger
 
 from quantalogic.version import get_version
@@ -26,7 +27,9 @@ from rich.panel import Panel  # noqa: E402
 from quantalogic.agent_config import (  # noqa: E402
     MODEL_NAME,
 )
+from quantalogic.config import QLConfig  # noqa: E402
 from quantalogic.task_runner import task_runner  # noqa: E402
+from quantalogic.utils.get_all_models import get_all_models  # noqa: E402
 
 # Platform-specific imports
 try:
@@ -149,8 +152,7 @@ def cli(
         ctx.exit()
 
     if ctx.invoked_subcommand is None:
-        ctx.invoke(
-            task,
+        config = QLConfig(
             model_name=model_name,
             verbose=verbose,
             mode=mode,
@@ -159,6 +161,18 @@ def cli(
             max_iterations=max_iterations,
             compact_every_n_iteration=compact_every_n_iteration,
             max_tokens_working_memory=max_tokens_working_memory,
+            no_stream=False  # Default value for backward compatibility
+        )
+        ctx.invoke(
+            task,
+            model_name=config.model_name,
+            verbose=config.verbose,
+            mode=config.mode,
+            log=config.log,
+            vision_model_name=config.vision_model_name,
+            max_iterations=config.max_iterations,
+            compact_every_n_iteration=config.compact_every_n_iteration,
+            max_tokens_working_memory=config.max_tokens_working_memory,
         )
 
 
@@ -222,19 +236,23 @@ def task(
     console = Console()
 
     try:
+        config = QLConfig(
+            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,
+            no_stream=no_stream,
+        )
+        
         task_runner(
             console,
             file,
-            model_name,
-            verbose,
-            mode,
-            log,
-            vision_model_name,
+            config,
             task,
-            max_iterations,
-            compact_every_n_iteration,
-            max_tokens_working_memory,
-            no_stream,
         )
     except Exception as e:
         console.print(f"[red]{str(e)}[/red]")
@@ -242,6 +260,37 @@ def task(
         sys.exit(1)
 
 
+@cli.command()
+@click.option("--search", type=str, help="Fuzzy search for models containing the given string.")
+def list_models(search: Optional[str] = None):
+    """List supported LiteLLM models with optional fuzzy search.
+    
+    If a search term is provided, it will return models that closely match the term.
+    """
+    console = Console()
+    all_models = get_all_models()
+    
+    if search:
+        # Perform fuzzy matching
+        matched_models = process.extractBests(search, all_models, limit=None, score_cutoff=70)
+        models = [model for model, score in matched_models]
+    else:
+        models = all_models
+    
+    console.print(Panel(
+        f"Total Models: {len(models)} "
+        f"({len(all_models)} total)",
+        title="Supported LiteLLM Models"
+    ))
+    
+    if not models:
+        console.print(f"[yellow]No models found matching '[bold]{search}[/bold]'[/yellow]")
+        return
+    
+    for model in sorted(models):
+        console.print(f"- {model}")
+
+
 def main():
     """Main entry point."""
     old_settings = setup_terminal()

quantalogic/prompts.py

@@ -1,8 +1,9 @@
+
 def system_prompt(tools: str, environment: str, expertise: str = ""):
     """System prompt for the ReAct chatbot."""
     return f"""
 ### Core Identity
-You are QuantaLogic, an advanced ReAct AI Agent specialized in systematic problem-solving.
+You are QuantaLogic, an advanced ReAct AI Agent specializing in systematic problem-solving.
 
 ### Specific Expertise
 {expertise}
@@ -14,81 +15,105 @@ Tasks will be presented within XML tags:
 ### Response Protocol
 Every response must contain exactly two XML blocks:
 
-1. Analysis Block:
+1. **Analysis Block**:
 ```xml
 <thinking>
-  <!-- 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.
-    * If not previously defined, clarify detailed criteria for task completion.
+  <!-- Follow this precise format. Be concise, dense, and use abbreviations, emojis, and Unicode characters to maximize density. -->
+  <task_analysis_if_no_history>
+    <!-- Only include if no conversation history exists: -->
+    * Rewrite the <task> and its context in your own words, ensuring clarity and specificity.
+    * Define detailed criteria for task completion if not already provided.
     * Identify key components, constraints, and potential challenges.
-    * Decompose into Sub-Tasks: Break the <task> down into smaller, manageable sub-tasks if necessary.
-    * Each sub-task should have a clear objective, specific deliverables, and be sequenced logically to facilitate step-by-step progress tracking. 
+    * Break the <task> into smaller, manageable sub-tasks if necessary.
+      - Each sub-task should have a clear objective, specific deliverables, and a logical sequence for progress tracking.
   </task_analysis_if_no_history>
   <success_criteria_if_no_history>
-     If no conversation history: 
+    <!-- Only include if no conversation history exists: -->
     * Specify measurable outcomes for task completion.
     * Define explicit quality benchmarks and performance indicators.
-    * Note any constraints or limitations that may affect the task.
+    * Note any constraints or limitations affecting the task.
   </success_criteria_if_no_history>
-   <strategic_approach_if_no_history>
-      If no conversation history: 
-    * Lay out a clear, high-level strategy for solving the task.
+  <strategic_approach_if_no_history>
+    <!-- Only include if no conversation history exists: -->
+    * Outline a high-level strategy for solving the task.
     * Identify required resources, tools, or information.
-    * Anticipate possible roadblocks and outline contingency plans.
+    * Anticipate potential roadblocks and propose contingency plans.
   </strategic_approach_if_no_history>
   <last_observation>
-    <!-- if there is a conversation history -->
+    <!-- Include if conversation history exists: -->
     <variable>
-      <name> ... variable name ... </name>
-      <description> ... concise description ... </description>
+      <name>...variable name...</name>
+      <description>...concise description...</description>
     </variable>
     <result>
-      ... concise description ...
-      How this result help to the progress of the task or the problem?
+      ...concise description of the result...
+      How does this result contribute to task progress?
     </result>
   </last_observation>
-  <progess_analysis>
-     <!-- if there is a conversation history -->
-    * 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.
-  </progess_analysis>
+  <progress_analysis>
+    <!-- Include if conversation history exists: -->
+    * Summarize completed and failed steps concisely.
+    * Identify and evaluate blockers or challenges.
+    * Highlight repetitions and suggest reevaluating the approach if necessary.
+    * Propose potential solutions or alternative strategies.
+  </progress_analysis>
   <variables>
-      <!-- if there is a conversation history -->
-    * List all variable names and concisely describe their current values.
+    <!-- Include if conversation history exists: -->
+    * List all variable names and their current values concisely.
   </variables>
   <next_steps>
     * Outline immediate actions required.
     * Justify tool selection and parameter choices.
-    * Prefer variable interpolation if possible, to minimize generation of tokens.
-    * Consider alternatives, take a step back if previous attempts were unsuccessful to review the plan.
+    * Use variable interpolation (e.g., `$var1$`) to minimize token generation.
+    * Consider alternatives or reevaluate the plan if previous attempts failed.
+    * Use the `task_complete` tool to confirm task completion.
   </next_steps>
   <taskpad>
-    <!-- optional -->
-    <note>Use this to record notes about intermediate steps.</note>
+    <!-- Optional: Use for notes about intermediate steps. -->
+    <note>...</note>
   </taskpad>
 </thinking>
 ```
 
-2. Action Block:
+2. **Action Block**:
 ```xml
 <tool_name>
-    <!-- tool_name is the name of the tool from available tools -->
-    <parameter1>
-      <!-- Use variable interpolation to pass context to minimize generation of tokens, example: <content>$var1$<</content> -->
-      value1
-    </parameter1>
-    <parameter2>value2</parameter2>
+  <!-- Replace `tool_name` with the name of the tool from the available tools. -->
+  <parameter1>
+    <!-- Use variable interpolation (e.g., `$var1$`) to pass context and minimize token generation. -->
+    value1
+  </parameter1>
+  <parameter2>value2</parameter2>
 </tool_name>
 ```
 
+### Examples of Action Blocks
+- **New Task Example**:
+```xml
+<data_analyzer>
+  <file_path>$input_file$</file_path>
+  <operation>validate_structure</operation>
+</data_analyzer>
+```
+
+- **Continuing Task Example**:
+```xml
+<memory_optimizer>
+  <process_id>$current_process$</process_id>
+  <target_utilization>75%</target_utilization>
+</memory_optimizer>
+```
+
+- **Task Completion Example / When a task is completed**:
+```xml
+<task_complete>
+  <answer>Task completed successfully</answer>
+</task_complete>
+```
+
 ### Available Tools
 {tools}
 
 ### Environment Details
 {environment}
-
 """

quantalogic/task_runner.py

@@ -9,7 +9,8 @@ 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.agent_factory import AgentRegistry, create_agent_for_mode
+from quantalogic.config import QLConfig
 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
@@ -144,52 +145,38 @@ def interactive_task_runner(
 def task_runner(
     console: Console,
     file: Optional[str],
-    model_name: str,
-    verbose: bool,
-    mode: str,
-    log: str,
-    vision_model_name: str | None,
+    config: QLConfig,
     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
+        config: QuantaLogic configuration object
         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)
+    switch_verbose(config.verbose, config.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
+        mode=config.mode,
+        model_name=config.model_name,
+        vision_model_name=config.vision_model_name,
+        compact_every_n_iteration=config.compact_every_n_iteration,
+        max_tokens_working_memory=config.max_tokens_working_memory
     )
 
+    AgentRegistry.register_agent("main_agent", agent)
+
     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:
+        if config.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")
+        result = agent.solve_task(task=task_content, max_iterations=config.max_iterations, streaming=not config.no_stream)
+        logger.debug(f"Task solved with result: {result} using {config.max_iterations} iterations")
 
         console.print(
             Panel.fit(
@@ -204,10 +191,10 @@ def task_runner(
             task_content = task
             # Execute single task from command line
             logger.debug(f"Solving task with agent: {task_content}")
-            if max_iterations < 1:
+            if config.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")
+            result = agent.solve_task(task=task_content, max_iterations=config.max_iterations, streaming=not config.no_stream)
+            logger.debug(f"Task solved with result: {result} using {config.max_iterations} iterations")
 
             console.print(
                 Panel.fit(
@@ -220,17 +207,17 @@ def task_runner(
             # Interactive mode
             display_welcome_message(
                 console=console,
-                model_name=model_name,
+                model_name=config.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,
+                vision_model_name=config.vision_model_name,
+                max_iterations=config.max_iterations,
+                compact_every_n_iteration=config.compact_every_n_iteration,
+                max_tokens_working_memory=config.max_tokens_working_memory,
+                mode=config.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}"
+                f"Created agent for mode: {config.mode} with model: {config.model_name}, vision model: {config.vision_model_name}, no_stream: {config.no_stream}"
             )
 
             events = [
@@ -281,4 +268,4 @@ def task_runner(
 
             logger.debug("Registered event handlers for agent events with events: {events}")
 
-            interactive_task_runner(agent, console, max_iterations, no_stream)
+            interactive_task_runner(agent, console, config.max_iterations, config.no_stream)

quantalogic/tool_manager.py

@@ -91,6 +91,72 @@ class ToolManager(BaseModel):
             "bool": lambda x: str(x).lower() in ['true', '1', 'yes']
         }
 
+        for arg_def in tool.arguments:
+            arg_name = arg_def.name
+            arg_type = arg_def.arg_type
+            required = arg_def.required
+            default = arg_def.default
+
+            # Handle missing arguments
+            if arg_name not in provided_args:
+                if required:
+                    raise ValueError(f"Missing required argument: {arg_name}")
+                if default is None:
+                    continue  # Skip optional args with no default
+                provided_args[arg_name] = default
+
+            value = provided_args[arg_name]
+
+            # Handle empty string for non-string types by replacing with default if available
+            if (
+                arg_type != "string"
+                and isinstance(value, str)
+                and value.strip() == ""
+                and default is not None
+            ):
+                logger.debug(f"Replaced empty string for argument {arg_name} with default value {default}")
+                value = default
+                provided_args[arg_name] = value  # Update to ensure validation uses the default
+
+            # Type conversion
+            if arg_type in type_conversion:
+                try:
+                    converted = type_conversion[arg_type](value)
+                except (ValueError, TypeError) as e:
+                    raise ValueError(
+                        f"Invalid value '{value}' for {arg_name} ({arg_type}): {str(e)}"
+                    )
+                converted_args[arg_name] = converted
+            else:
+                converted_args[arg_name] = value  # Unknown type, pass through
+
+        # Validate extra arguments
+        extra_args = set(provided_args.keys()) - {a.name for a in tool.arguments}
+        if extra_args:
+            raise ValueError(f"Unexpected arguments: {', '.join(extra_args)}")
+
+        return converted_args
+        """Validates and converts arguments based on tool definition.
+        
+        Args:
+            tool_name: Name of the tool to validate against
+            provided_args: Dictionary of arguments to validate
+            
+        Returns:
+            Dictionary of converted arguments with proper types
+            
+        Raises:
+            ValueError: For missing/invalid arguments or conversion errors
+        """
+        tool = self.get(tool_name)
+        converted_args = {}
+        type_conversion = {
+            "string": lambda x: str(x),
+            "int": lambda x: int(x),
+            "float": lambda x: float(x),
+            "bool": lambda x: str(x).lower() in ['true', '1', 'yes']
+        }
+
         for arg_def in tool.arguments:
             arg_name = arg_def.name
             arg_type = arg_def.arg_type

quantalogic/tools/execute_bash_command_tool.py

@@ -11,7 +11,7 @@ from loguru import logger
 
 # Platform-specific imports
 try:
-    if sys.platform != 'win32':
+    if sys.platform != "win32":
         import pty
 except ImportError as e:
     logger.warning(f"Could not import platform-specific module: {e}")
@@ -40,6 +40,7 @@ class ExecuteBashCommandTool(Tool):
             description="The working directory where the command will be executed. Defaults to the current directory.",
             required=False,
             example="/path/to/directory",
+            default=os.getcwd(),
         ),
         ToolArgument(
             name="timeout",
@@ -47,6 +48,7 @@ class ExecuteBashCommandTool(Tool):
             description="Maximum time in seconds to wait for the command to complete. Defaults to 60 seconds.",
             required=False,
             example="60",
+            default="60",
         ),
     ]
 
@@ -69,16 +71,16 @@ class ExecuteBashCommandTool(Tool):
                 cwd=cwd,
                 env=env_vars,
                 text=True,
-                encoding='utf-8'
+                encoding="utf-8",
             )
 
             try:
                 stdout, stderr = process.communicate(timeout=timeout_seconds)
                 return_code = process.returncode
-                
+
                 if return_code != 0 and stderr:
                     logger.warning(f"Command failed with error: {stderr}")
-                
+
                 formatted_result = (
                     "<command_output>"
                     f" <stdout>{stdout.strip()}</stdout>"
@@ -86,11 +88,11 @@ class ExecuteBashCommandTool(Tool):
                     f"</command_output>"
                 )
                 return formatted_result
-            
+
             except subprocess.TimeoutExpired:
                 process.kill()
                 return f"Command timed out after {timeout_seconds} seconds."
-                
+
         except Exception as e:
             return f"Unexpected error executing command: {str(e)}"
 
@@ -127,7 +129,7 @@ class ExecuteBashCommandTool(Tool):
                         if proc.poll() is not None:
                             break  # Process completed but select timed out
                         raise subprocess.TimeoutExpired(command, timeout_seconds)
-                    
+
                     for fd in rlist:
                         if fd == master:
                             data = os.read(master, 1024).decode()
@@ -140,7 +142,7 @@ class ExecuteBashCommandTool(Tool):
                         elif fd == sys.stdin:
                             user_input = os.read(sys.stdin.fileno(), 1024)
                             os.write(master, user_input)
-                    
+
                     if break_loop or proc.poll() is not None:
                         while True:
                             data = os.read(master, 1024).decode()
@@ -160,7 +162,7 @@ class ExecuteBashCommandTool(Tool):
                 os.close(master)
                 proc.wait()
 
-            stdout_content = ''.join(stdout_buffer)
+            stdout_content = "".join(stdout_buffer)
             return_code = proc.returncode
             formatted_result = (
                 "<command_output>"
@@ -186,7 +188,7 @@ class ExecuteBashCommandTool(Tool):
         if env:
             env_vars.update(env)
 
-        if sys.platform == 'win32':
+        if sys.platform == "win32":
             return self._execute_windows(command, cwd, timeout_seconds, env_vars)
         else:
             if not pty:
@@ -197,4 +199,4 @@ class ExecuteBashCommandTool(Tool):
 
 if __name__ == "__main__":
     tool = ExecuteBashCommandTool()
-    print(tool.to_markdown())
+    print(tool.to_markdown())

quantalogic/tools/replace_in_file_tool.py

@@ -35,7 +35,7 @@ class SearchReplaceBlock(BaseModel):
 
     search: str = Field(
         ...,
-        description="Exact content to search for in the file.",
+        description="Exact content to search for in the file. Space and tab characters are VERY important.",
         example="def old_function():\n    pass",
     )
     replace: str = Field(

quantalogic/tools/search_definition_names.py

@@ -69,6 +69,7 @@ class SearchDefinitionNames(Tool):
             description="The page number to retrieve (1-based index).",
             required=False,
             example="1",
+            default="1"
         ),
         ToolArgument(
             name="page_size",
@@ -76,6 +77,7 @@ class SearchDefinitionNames(Tool):
             description="The number of results per page (default: 10).",
             required=False,
             example="10",
+            default="10"
         ),
     ]
 

quantalogic/tools/sql_query_tool.py

@@ -30,14 +30,16 @@ class SQLQueryTool(Tool):
             arg_type="int",
             description="1-based starting row number for results",
             required=True,
-            example="1"
+            example="1",
+            default="1"
         ),
         ToolArgument(
             name="end_row",
             arg_type="int",
             description="1-based ending row number for results",
             required=True,
-            example="100"
+            example="100",
+            default="100"
         ),
     ]
     connection_string: str = Field(

quantalogic/utils/get_all_models.py

@@ -0,0 +1,20 @@
+import litellm
+
+
+from quantalogic.get_model_info import model_info
+
+def get_all_models() -> list[str]:
+    """
+    Retrieves a unified list of all model names supported by LiteLLM and Quantalogic.
+
+    Returns:
+        list: A list of strings representing the model names.
+    """
+    litellm_models = set(litellm.model_list)
+    quantalogic_models = set(model_info.keys())
+    return list(litellm_models.union(quantalogic_models))
+
+# Example usage
+if __name__ == "__main__":
+    models = get_all_models()
+    print("Supported models:", models)

quantalogic/xml_parser.py

@@ -298,5 +298,6 @@ class ToleranceXMLParser:
 
         except Exception as e:
             error_msg = f"Error extracting XML elements: {str(e)}"
+            error_msg = error_msg + f"\n{text}\n"
             logger.error(error_msg)
             raise ValueError(error_msg)