quantalogic 0.2.8__py3-none-any.whl → 0.2.12__py3-none-any.whl

quantalogic/agent.py

@@ -1,7 +1,5 @@
 """Enhanced QuantaLogic agent implementing the ReAct framework."""
 
-import os
-import sys
 from collections.abc import Callable
 from datetime import datetime
 from typing import Any
@@ -64,6 +62,7 @@ class Agent(BaseModel):
     event_emitter: EventEmitter = EventEmitter()
     config: AgentConfig
     task_to_solve: str
+    task_to_solve_summary: str = ""
     ask_for_user_validation: Callable[[str], bool] = console_ask_for_user_validation
     last_tool_call: dict[str, Any] = {}  # Stores the last tool call information
     total_tokens: int = 0  # Total tokens in the conversation
@@ -137,6 +136,9 @@ class Agent(BaseModel):
         logger.debug(f"Solving task... {task}")
         self._reset_session(task_to_solve=task, max_iterations=max_iterations)
 
+        # 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))
 
@@ -166,7 +168,7 @@ class Agent(BaseModel):
                 self._update_total_tokens(message_history=self.memory.memory, prompt=current_prompt)
 
                 # Emit event: Task Think Start after updating total tokens
-                self._emit_event("task_think_start")
+                self._emit_event("task_think_start", {"prompt": current_prompt})
 
                 self._compact_memory_if_needed(current_prompt)
 
@@ -443,6 +445,10 @@ class Agent(BaseModel):
             "You must analyze this answer and evaluate what to do next to solve the task.\n"
             "If the step failed, take a step back and rethink your approach.\n"
             "\n"
+            "--- Task to solve summary ---\n"
+            "\n"
+            f"{self.task_to_solve_summary}"
+            "\n"
             "--- Format ---\n"
             "\n"
             "You MUST respond with exactly two XML blocks formatted in markdown:\n"
@@ -546,6 +552,7 @@ class Agent(BaseModel):
             "\n### Tools:\n"
             "-----------------------------\n"
             f"{self._get_tools_names_prompt()}\n"
+            "\n"
             "### Variables:\n"
             "-----------------------------\n"
             f"{self._get_variable_prompt()}\n"
@@ -575,6 +582,8 @@ class Agent(BaseModel):
             "Available variables:\n"
             "\n"
             f"{', '.join(self.variable_store.keys())}\n"
+            if len(self.variable_store.keys()) > 0
+            else "None\n"
         )
         return prompt_use_variables
 
@@ -619,6 +628,28 @@ class Agent(BaseModel):
         self.memory.memory = memory_copy
         return summary.response
 
+    def _generate_task_summary(self, content: str) -> str:
+        """Generate a concise summary of the given content using the generative model.
+
+        Args:
+            content (str): The content to summarize
+
+        Returns:
+            str: Generated summary
+        """
+        try:
+            prompt = (
+                "Rewrite this task in a precise, dense, and concise manner:\n"
+                f"{content}\n"
+                "Summary should be 2-3 sentences maximum. No extra comments should be added.\n"
+            )
+            result = self.model.generate(prompt=prompt)
+            logger.debug(f"Generated summary: {result.response}")
+            return result.response
+        except Exception as e:
+            logger.error(f"Error generating summary: {str(e)}")
+            return f"Summary generation failed: {str(e)}"
+
     def _update_session_memory(self, user_content: str, assistant_content: str) -> None:
         """
         Log session messages to memory and emit events.

quantalogic/agent_config.py

@@ -13,6 +13,7 @@ from quantalogic.tools import (
     InputQuestionTool,
     ListDirectoryTool,
     LLMTool,
+    LLMVisionTool,
     MarkitdownTool,
     NodeJsTool,
     PythonTool,
@@ -28,109 +29,141 @@ from quantalogic.tools import (
 MODEL_NAME = "deepseek/deepseek-chat"
 
 
-def create_agent(model_name) -> Agent:
+def create_agent(model_name: str, vision_model_name: str | None) -> Agent:
     """Create an agent with the specified model and tools.
 
     Args:
         model_name (str): Name of the model to use
+        vision_model_name (str | None): Name of the vision model to use
+
+    Returns:
+        Agent: An agent with the specified model and tools
     """
+    tools = [
+        TaskCompleteTool(),
+        ReadFileTool(),
+        ReadFileBlockTool(),
+        WriteFileTool(),
+        EditWholeContentTool(),
+        InputQuestionTool(),
+        ListDirectoryTool(),
+        ExecuteBashCommandTool(),
+        ReplaceInFileTool(),
+        RipgrepTool(),
+        SearchDefinitionNames(),
+        MarkitdownTool(),
+        LLMTool(model_name=model_name),
+        DownloadHttpFileTool(),
+    ]
+
+    if vision_model_name:
+        tools.append(LLMVisionTool(model_name=vision_model_name))
+
     return Agent(
         model_name=model_name,
-        tools=[
-            TaskCompleteTool(),
-            ReadFileTool(),
-            ReadFileBlockTool(),
-            WriteFileTool(),
-            EditWholeContentTool(),
-            InputQuestionTool(),
-            ListDirectoryTool(),
-            ExecuteBashCommandTool(),
-            ReplaceInFileTool(),
-            RipgrepTool(),
-            SearchDefinitionNames(),
-            MarkitdownTool(),
-            LLMTool(model_name=model_name),
-            DownloadHttpFileTool(),
-        ],
+        tools=tools,
     )
 
 
-def create_interpreter_agent(model_name: str) -> Agent:
+def create_interpreter_agent(model_name: str, vision_model_name: str | None) -> Agent:
     """Create an interpreter agent with the specified model and tools.
 
     Args:
         model_name (str): Name of the model to use
-    """
-    return Agent(
-        model_name=model_name,
-        tools=[
-            TaskCompleteTool(),
-            ReadFileTool(),
-            ReadFileBlockTool(),
-            WriteFileTool(),
-            EditWholeContentTool(),
-            InputQuestionTool(),
-            ListDirectoryTool(),
-            ExecuteBashCommandTool(),
-            ReplaceInFileTool(),
-            RipgrepTool(),
-            PythonTool(),
-            NodeJsTool(),
-            SearchDefinitionNames(),
-            DownloadHttpFileTool(),
-        ],
-    )
-
+        vision_model_name (str | None): Name of the vision model to use
 
-def create_full_agent(model_name: str) -> Agent:
+    Returns:
+        Agent: An interpreter agent with the specified model and tools
+    """
+    tools = [
+        TaskCompleteTool(),
+        ReadFileTool(),
+        ReadFileBlockTool(),
+        WriteFileTool(),
+        EditWholeContentTool(),
+        InputQuestionTool(),
+        ListDirectoryTool(),
+        ExecuteBashCommandTool(),
+        ReplaceInFileTool(),
+        RipgrepTool(),
+        PythonTool(),
+        NodeJsTool(),
+        SearchDefinitionNames(),
+        MarkitdownTool(),
+        LLMTool(model_name=model_name),
+        DownloadHttpFileTool(),
+    ]
+    return Agent(model_name=model_name, tools=tools)
+
+
+def create_full_agent(model_name: str, vision_model_name: str | None) -> Agent:
     """Create an agent with the specified model and many tools.
 
     Args:
         model_name (str): Name of the model to use
+        vision_model_name (str | None): Name of the vision model to use
+
+    Returns:
+        Agent: An agent with the specified model and tools
+
     """
+    tools = [
+        TaskCompleteTool(),
+        ReadFileTool(),
+        ReadFileBlockTool(),
+        WriteFileTool(),
+        EditWholeContentTool(),
+        InputQuestionTool(),
+        ListDirectoryTool(),
+        ExecuteBashCommandTool(),
+        ReplaceInFileTool(),
+        RipgrepTool(),
+        PythonTool(),
+        NodeJsTool(),
+        SearchDefinitionNames(),
+        MarkitdownTool(),
+        LLMTool(model_name=model_name),
+        DownloadHttpFileTool(),
+    ]
+
+    if vision_model_name:
+        tools.append(LLMVisionTool(model_name=vision_model_name))
+
     return Agent(
         model_name=model_name,
-        tools=[
-            TaskCompleteTool(),
-            ReadFileTool(),
-            ReadFileBlockTool(),
-            WriteFileTool(),
-            EditWholeContentTool(),
-            InputQuestionTool(),
-            ListDirectoryTool(),
-            ExecuteBashCommandTool(),
-            ReplaceInFileTool(),
-            RipgrepTool(),
-            PythonTool(),
-            NodeJsTool(),
-            SearchDefinitionNames(),
-            MarkitdownTool(),
-            LLMTool(model_name=model_name),
-            DownloadHttpFileTool(),
-        ],
+        tools=tools,
     )
 
 
-def create_orchestrator_agent(model_name: str) -> Agent:
+def create_orchestrator_agent(model_name: str, vision_model_name: str | None = None) -> Agent:
     """Create an agent with the specified model and tools.
 
     Args:
         model_name (str): Name of the model to use
+        vision_model_name (str | None): Name of the vision model to use
+
+    Returns:
+        Agent: An agent with the specified model and tools
     """
     # Rebuild AgentTool to resolve forward references
     AgentTool.model_rebuild()
 
     coding_agent_instance = create_coding_agent(model_name)
 
+    tools = [
+        TaskCompleteTool(),
+        ListDirectoryTool(),
+        ReadFileBlockTool(),
+        RipgrepTool(),
+        SearchDefinitionNames(),
+        LLMTool(model_name=MODEL_NAME),
+        AgentTool(agent=coding_agent_instance, agent_role="software expert", name="coder_agent_tool"),
+    ]
+
+    if vision_model_name:
+        tools.append(LLMVisionTool(model_name=vision_model_name))
+
     return Agent(
         model_name=model_name,
-        tools=[
-            TaskCompleteTool(),
-            ListDirectoryTool(),
-            ReadFileBlockTool(),
-            RipgrepTool(),
-            SearchDefinitionNames(),
-            LLMTool(model_name=MODEL_NAME),
-            AgentTool(agent=coding_agent_instance, agent_role="software expert", name="coder_agent_tool"),
-        ],
+        tools=tools,
     )

quantalogic/coding_agent.py

@@ -5,6 +5,7 @@ from quantalogic.tools import (
     InputQuestionTool,
     ListDirectoryTool,
     LLMTool,
+    LLMVisionTool,
     ReadFileBlockTool,
     ReadFileTool,
     ReplaceInFileTool,
@@ -17,11 +18,12 @@ from quantalogic.utils import get_coding_environment
 from quantalogic.utils.get_quantalogic_rules_content import get_quantalogic_rules_file_content
 
 
-def create_coding_agent(model_name: str, basic: bool = False) -> Agent:
+def create_coding_agent(model_name: str, vision_model_name: str | None = None, basic: bool = False) -> Agent:
     """Creates and configures a coding agent with a comprehensive set of tools.
 
     Args:
         model_name (str): Name of the language model to use for the agent's core capabilities
+        vision_model_name (str | None): Name of the vision model to use for the agent's core capabilities
         basic (bool, optional): If True, the agent will be configured with a basic set of tools.
 
     Returns:
@@ -59,12 +61,15 @@ def create_coding_agent(model_name: str, basic: bool = False) -> Agent:
         InputQuestionTool(),
     ]
 
+    if vision_model_name:
+        tools.append(LLMVisionTool(model_name=vision_model_name))
+
     if not basic:
         tools.append(
             LLMTool(
                 model_name=model_name,
                 system_prompt="You are a software expert, your role is to answer coding questions.",
-                name="coding_consultant",  # Handles implementation-level coding questions
+                name="coding_consultant",  # Handles implementation-level coding questions                
             )
         )
         tools.append(

quantalogic/generative_model.py

@@ -5,16 +5,17 @@ from litellm import completion, exceptions, get_max_tokens, get_model_info, toke
 from loguru import logger
 from pydantic import BaseModel, Field, field_validator
 
-MIN_RETRIES = 3
+MIN_RETRIES = 1
 
 
 class Message(BaseModel):
     """Represents a message in a conversation with a specific role and content."""
 
     role: str = Field(..., min_length=1)
-    content: str = Field(..., min_length=1)
+    content: str | dict = Field(..., min_length=1)
+    image_url: str | None = Field(default=None, pattern=r"^https?://")
 
-    @field_validator("role", "content")
+    @field_validator("role")
     @classmethod
     def validate_not_empty(cls, v: str) -> str:
         """Validate that the field is not empty or whitespace-only."""
@@ -22,6 +23,26 @@ class Message(BaseModel):
             raise ValueError("Field cannot be empty or whitespace-only")
         return v
 
+    @field_validator("content")
+    @classmethod
+    def validate_content(cls, v: str | dict) -> str | dict:
+        """Validate content based on its type."""
+        if isinstance(v, str):
+            if not v or not v.strip():
+                raise ValueError("Text content cannot be empty or whitespace-only")
+        elif isinstance(v, dict):
+            if not v.get("text") or not v.get("image_url"):
+                raise ValueError("Multimodal content must have both text and image_url")
+        return v
+
+    @field_validator("image_url")
+    @classmethod
+    def validate_image_url(cls, v: str | None) -> str | None:
+        """Validate image URL format if present."""
+        if v and not v.startswith(("http://", "https://")):
+            raise ValueError("Image URL must start with http:// or https://")
+        return v
+
 
 class TokenUsage(BaseModel):
     """Represents token usage statistics for a language model."""
@@ -59,6 +80,7 @@ class GenerativeModel:
             temperature: Sampling temperature between 0 and 1.
                 Defaults to 0.7.
         """
+        logger.debug(f"Initializing GenerativeModel with model={model}, temperature={temperature}")
         self.model = model
         self.temperature = temperature
 
@@ -85,15 +107,18 @@ class GenerativeModel:
     )
 
     # Retry on specific retriable exceptions
-    def generate_with_history(self, messages_history: list[Message], prompt: str) -> ResponseStats:
-        """Generate a response with conversation history.
+    def generate_with_history(
+        self, messages_history: list[Message], prompt: str, image_url: str | None = None
+    ) -> ResponseStats:
+        """Generate a response with conversation history and optional image.
 
-        Generates a response based on previous conversation messages
-        and a new user prompt.
+        Generates a response based on previous conversation messages,
+        a new user prompt, and an optional image URL.
 
         Args:
             messages_history: Previous conversation messages.
             prompt: Current user prompt.
+            image_url: Optional image URL for visual queries.
 
         Returns:
             Detailed response statistics.
@@ -105,7 +130,19 @@ class GenerativeModel:
             Exception: For other unexpected errors.
         """
         messages = [{"role": msg.role, "content": str(msg.content)} for msg in messages_history]
-        messages.append({"role": "user", "content": str(prompt)})
+
+        if image_url:
+            messages.append(
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": str(prompt)},
+                        {"type": "image_url", "image_url": {"url": image_url}},
+                    ],
+                }
+            )
+        else:
+            messages.append({"role": "user", "content": str(prompt)})
 
         try:
             logger.debug(f"Generating response for prompt: {prompt}")
@@ -140,9 +177,12 @@ class GenerativeModel:
             }
 
             logger.error("LLM Generation Error: {}", error_details)
+            logger.debug(f"Error details: {error_details}")
+            logger.debug(f"Model: {self.model}, Temperature: {self.temperature}")
 
             # Handle authentication and permission errors
             if isinstance(e, self.AUTH_EXCEPTIONS):
+                logger.debug("Authentication error occurred")
                 raise openai.AuthenticationError(
                     f"Authentication failed with provider {error_details['provider']}"
                 ) from e
@@ -162,7 +202,7 @@ class GenerativeModel:
             # Wrap unknown errors in APIError
             raise openai.APIError(f"Unexpected error during generation: {str(e)}") from e
 
-    def generate(self, prompt: str) -> ResponseStats:
+    def generate(self, prompt: str, image_url: str | None = None) -> ResponseStats:
         """Generate a response without conversation history.
 
         Generates a response for a single user prompt without
@@ -170,11 +210,12 @@ class GenerativeModel:
 
         Args:
             prompt: User prompt.
+            image_url: Optional image URL for visual queries.
 
         Returns:
             Detailed response statistics.
         """
-        return self.generate_with_history([], prompt)
+        return self.generate_with_history([], prompt, image_url)
 
     def get_max_tokens(self) -> int:
         """Get the maximum number of tokens that can be generated by the model."""
@@ -182,8 +223,11 @@ class GenerativeModel:
 
     def token_counter(self, messages: list[Message]) -> int:
         """Count the number of tokens in a list of messages."""
+        logger.debug(f"Counting tokens for {len(messages)} messages using model {self.model}")
         litellm_messages = [{"role": msg.role, "content": str(msg.content)} for msg in messages]
-        return token_counter(model=self.model, messages=litellm_messages)
+        token_count = token_counter(model=self.model, messages=litellm_messages)
+        logger.debug(f"Token count: {token_count}")
+        return token_count
 
     def token_counter_with_history(self, messages_history: list[Message], prompt: str) -> int:
         """Count the number of tokens in a list of messages and a prompt."""
@@ -193,12 +237,18 @@ class GenerativeModel:
 
     def get_model_info(self) -> dict | None:
         """Get information about the model."""
+        logger.debug(f"Retrieving model info for {self.model}")
         model_info = get_model_info(self.model)
 
         if not model_info:
-            # Search without prefix "openrouter/"
+            logger.debug("Model info not found, trying without openrouter/ prefix")
             model_info = get_model_info(self.model.replace("openrouter/", ""))
 
+        if model_info:
+            logger.debug(f"Model info retrieved: {model_info.keys()}")
+        else:
+            logger.debug("No model info available")
+
         return model_info
 
     def get_model_max_input_tokens(self) -> int: