quantalogic 0.2.15__py3-none-any.whl → 0.2.17__py3-none-any.whl

quantalogic/tools/llm_tool.py

@@ -1,9 +1,11 @@
 """LLM Tool for generating answers to questions using a language model."""
 
-import logging
+from typing import Callable
 
+from loguru import logger
 from pydantic import ConfigDict, Field
 
+from quantalogic.console_print_token import console_print_token
 from quantalogic.generative_model import GenerativeModel, Message
 from quantalogic.tools.tool import Tool, ToolArgument
 
@@ -53,15 +55,42 @@ class LLMTool(Tool):
     )
 
     model_name: str = Field(..., description="The name of the language model to use")
-    generative_model: GenerativeModel | None = Field(default=None)
     system_prompt: str | None = Field(default=None)
+    on_token: Callable | None = Field(default=None, exclude=True)
+    generative_model: GenerativeModel | None = Field(default=None, exclude=True)
+
+    def __init__(
+        self,
+        model_name: str,
+        system_prompt: str | None = None,
+        on_token: Callable | None = None,
+        name: str = "llm_tool",
+        generative_model: GenerativeModel | None = None,
+    ):
+        # Use dict to pass validated data to parent constructor
+        super().__init__(
+            **{
+                "model_name": model_name,
+                "system_prompt": system_prompt,
+                "on_token": on_token,
+                "name": name,
+                "generative_model": generative_model,
+            }
+        )
+
+        # Initialize the generative model
+        self.model_post_init(None)
 
     def model_post_init(self, __context):
         """Initialize the generative model after model initialization."""
         if self.generative_model is None:
             self.generative_model = GenerativeModel(model=self.model_name)
-            logging.debug(f"Initialized LLMTool with model: {self.model_name}")
+            logger.debug(f"Initialized LLMTool with model: {self.model_name}")
 
+        # Only set up event listener if on_token is provided
+        if self.on_token is not None:
+            logger.debug(f"Setting up event listener for LLMTool with model: {self.model_name}")
+            self.generative_model.event_emitter.on("stream_chunk", self.on_token)
 
     def execute(
         self, system_prompt: str | None = None, prompt: str | None = None, temperature: str | None = None
@@ -85,7 +114,7 @@ class LLMTool(Tool):
             if not (0.0 <= temp <= 1.0):
                 raise ValueError("Temperature must be between 0 and 1.")
         except ValueError as ve:
-            logging.error(f"Invalid temperature value: {temperature}")
+            logger.error(f"Invalid temperature value: {temperature}")
             raise ValueError(f"Invalid temperature value: {temperature}") from ve
 
         used_system_prompt = self.system_prompt if self.system_prompt else system_prompt
@@ -96,20 +125,29 @@ class LLMTool(Tool):
             Message(role="user", content=prompt),
         ]
 
+        is_streaming = self.on_token is not None
+
         # Set the model's temperature
         if self.generative_model:
             self.generative_model.temperature = temp
 
             # Generate the response using the generative model
             try:
-                response_stats = self.generative_model.generate_with_history(
-                    messages_history=messages_history, prompt=""
+                result = self.generative_model.generate_with_history(
+                    messages_history=messages_history, prompt=prompt, streaming=is_streaming
                 )
-                response = response_stats.response.strip()
-                logging.info(f"Generated response: {response}")
+
+                if is_streaming:
+                    response = ""
+                    for chunk in result:
+                        response += chunk
+                else:
+                    response = result.response
+
+                logger.debug(f"Generated response: {response}")
                 return response
             except Exception as e:
-                logging.error(f"Error generating response: {e}")
+                logger.error(f"Error generating response: {e}")
                 raise Exception(f"Error generating response: {e}") from e
         else:
             raise ValueError("Generative model not initialized")
@@ -123,6 +161,9 @@ if __name__ == "__main__":
     temperature = "0.7"
     answer = tool.execute(system_prompt=system_prompt, prompt=question, temperature=temperature)
     print(answer)
-    pirate = LLMTool(model_name="openrouter/openai/gpt-4o-mini", system_prompt="You are a pirate.")
+    pirate = LLMTool(
+        model_name="openrouter/openai/gpt-4o-mini", system_prompt="You are a pirate.", on_token=console_print_token
+    )
     pirate_answer = pirate.execute(system_prompt=system_prompt, prompt=question, temperature=temperature)
-    print(pirate_answer)
+    print("\n")
+    print(f"Anwser: {pirate_answer}")

quantalogic/tools/llm_vision_tool.py

@@ -1,8 +1,8 @@
 """LLM Vision Tool for analyzing images using a language model."""
 
-import logging
 from typing import Optional
 
+from loguru import logger
 from pydantic import ConfigDict, Field
 
 from quantalogic.generative_model import GenerativeModel, Message
@@ -65,7 +65,12 @@ class LLMVisionTool(Tool):
         """Initialize the generative model after model initialization."""
         if self.generative_model is None:
             self.generative_model = GenerativeModel(model=self.model_name)
-            logging.debug(f"Initialized LLMVisionTool with model: {self.model_name}")
+            logger.debug(f"Initialized LLMVisionTool with model: {self.model_name}")
+
+        # Only set up event listener if on_token is provided
+        if self.on_token is not None:
+            logger.debug(f"Setting up event listener for LLMVisionTool with model: {self.model_name}")
+            self.generative_model.event_emitter.on("stream_chunk", self.on_token)
 
     def execute(self, system_prompt: str, prompt: str, image_url: str, temperature: str = "0.7") -> str:
         """Execute the tool to analyze an image and generate a response.
@@ -88,7 +93,7 @@ class LLMVisionTool(Tool):
             if not (0.0 <= temp <= 1.0):
                 raise ValueError("Temperature must be between 0 and 1.")
         except ValueError as ve:
-            logging.error(f"Invalid temperature value: {temperature}")
+            logger.error(f"Invalid temperature value: {temperature}")
             raise ValueError(f"Invalid temperature value: {temperature}") from ve
 
         if not image_url.startswith(("http://", "https://")):
@@ -105,14 +110,25 @@ class LLMVisionTool(Tool):
         self.generative_model.temperature = temp
 
         try:
+            is_streaming = self.on_token is not None
             response_stats = self.generative_model.generate_with_history(
-                messages_history=messages_history, prompt=prompt, image_url=image_url
+                messages_history=messages_history,
+                prompt=prompt,
+                image_url=image_url,
+                streaming=is_streaming
             )
-            response = response_stats.response.strip()
-            logging.info(f"Generated response: {response}")
+
+            if is_streaming:
+                response = ""
+                for chunk in response_stats:
+                    response += chunk
+            else:
+                response = response_stats.response.strip()
+
+            logger.info(f"Generated response: {response}")
             return response
         except Exception as e:
-            logging.error(f"Error generating response: {e}")
+            logger.error(f"Error generating response: {e}")
             raise Exception(f"Error generating response: {e}") from e
 
 

quantalogic/xml_parser.py

@@ -7,6 +7,7 @@ with support for handling malformed XML and CDATA sections.
 import html
 import re
 from collections import defaultdict
+from functools import lru_cache
 from typing import Self
 
 from loguru import logger
@@ -51,15 +52,38 @@ class ToleranceXMLParser:
     edge cases such as incomplete tags and CDATA sections.
     """
 
+    # Default mappings for element name normalization
+    DEFAULT_NAME_MAP = {
+        "o": "output",
+        "i": "input",
+        "opt": "optional"
+    }
+
     def __init__(self: Self) -> None:
         """Initialize the parser with regex patterns for matching XML-like elements."""
-        # Pattern for matching individual XML elements, including malformed tags
-        # Modified to be more lenient with content and preserve exact formatting
-        self.element_pattern = re.compile(r"<([^/>]+?)>(.*?)(?:</\1>|<\1>)", re.DOTALL)
+        # Pattern for matching individual XML elements with better whitespace handling
+        self.element_pattern = re.compile(
+            r"<\s*([^/>]+?)\s*>(.*?)(?:</\s*\1\s*>|<\s*\1\s*>)",
+            re.DOTALL
+        )
         # Pattern for matching CDATA sections
         self.cdata_pattern = re.compile(r"<!\[CDATA\[(.*?)]]>", re.DOTALL)
         logger.debug("Initialized ToleranceXMLParser with regex patterns")
 
+    def _validate_input(self, text: str) -> None:
+        """Validate input text before processing.
+        
+        Args:
+            text: Input text to validate.
+            
+        Raises:
+            ValueError: If input text is invalid.
+        """
+        if not text or not isinstance(text, str):
+            raise ValueError("Input text must be a non-empty string")
+        if len(text.strip()) == 0:
+            raise ValueError("Input text cannot be whitespace only")
+
     def _extract_and_remove_cdata(self: Self, content: str, preserve_cdata: bool = False) -> tuple[str, list[str]]:
         """Extract CDATA sections from content.
 
@@ -96,6 +120,7 @@ class ToleranceXMLParser:
         # Only unescape HTML entities, preserve everything else exactly as is
         return html.unescape(content)
 
+    @lru_cache(maxsize=128)
     def _map_element_name(self: Self, name: str) -> str:
         """Map element names to their canonical form.
 
@@ -105,9 +130,82 @@ class ToleranceXMLParser:
         Returns:
             Canonical element name.
         """
-        # Map common element name variations
-        name_map = {"o": "output", "i": "input", "opt": "optional"}
-        return name_map.get(name.strip(), name.strip())
+        return self.DEFAULT_NAME_MAP.get(name.strip(), name.strip())
+
+    def _build_element_pattern(self, element_name: str) -> re.Pattern[str]:
+        """Build regex pattern for finding specific XML elements.
+        
+        Args:
+            element_name: Name of the element to match.
+            
+        Returns:
+            Compiled regex pattern for matching the element.
+        """
+        non_cdata = r"(?:(?!<!\[CDATA\[|]]>).)*?"
+        cdata_section = r"(?:<!\[CDATA\[.*?]]>)?"
+        content_pattern = f"({non_cdata}{cdata_section}{non_cdata})"
+        closing_pattern = "(?:</\1>|<\1>)"
+        
+        return re.compile(
+            f"<{element_name}>{content_pattern}{closing_pattern}",
+            re.DOTALL
+        )
+
+    def _find_all_elements(self, text: str) -> list[tuple[str, str]]:
+        """Find all XML elements in text.
+        
+        Args:
+            text: Input text to search.
+            
+        Returns:
+            List of tuples containing element names and their content.
+        """
+        return [(match.group(1), match.group(2) or "") 
+                for match in self.element_pattern.finditer(text)]
+
+    def _process_element_content(self, content: str, preserve_cdata: bool) -> str:
+        """Process content of a single element.
+        
+        Args:
+            content: Raw element content.
+            preserve_cdata: Whether to preserve CDATA sections.
+            
+        Returns:
+            Processed content string.
+        """
+        content, cdata_sections = self._extract_and_remove_cdata(content, preserve_cdata)
+        content = self._clean_content(content)
+        
+        # If content is empty but we have CDATA sections and we're not preserving them
+        if not content.strip() and cdata_sections and not preserve_cdata:
+            return cdata_sections[0]
+        return content
+
+    def _process_elements(
+        self, 
+        elements: list[tuple[str, str]], 
+        preserve_cdata: bool
+    ) -> dict[str, str]:
+        """Process found elements and handle CDATA sections.
+        
+        Args:
+            elements: List of element name and content tuples.
+            preserve_cdata: Whether to preserve CDATA sections.
+            
+        Returns:
+            Dictionary mapping element names to their processed content.
+        """
+        result: dict[str, str] = defaultdict(str)
+        for name, content in elements:
+            name = self._map_element_name(name)
+            result[name] = self._process_element_content(content, preserve_cdata)
+            
+            # Handle nested elements
+            nested_elements = self._find_all_elements(content)
+            nested_results = self._process_elements(nested_elements, preserve_cdata)
+            result.update(nested_results)
+            
+        return dict(result)
 
     def _extract_element_content(self: Self, text: str, preserve_cdata: bool = False) -> dict[str, str]:
         """Extract content from nested XML elements.
@@ -119,35 +217,8 @@ class ToleranceXMLParser:
         Returns:
             Dictionary mapping element names to their content values.
         """
-        elements: dict[str, str] = defaultdict(str)
-
-        # Process each match
-        for match in self.element_pattern.finditer(text):
-            name = match.group(1)
-            content = match.group(2) or ""
-
-            # Map element name to canonical form
-            name = self._map_element_name(name)
-
-            # Extract and handle CDATA sections
-            content, cdata_sections = self._extract_and_remove_cdata(content, preserve_cdata)
-
-            # Clean and normalize content
-            content = self._clean_content(content)
-
-            # If the content is empty but we have CDATA sections and we're
-            # not preserving them
-            if not content.strip() and cdata_sections and not preserve_cdata:
-                content = cdata_sections[0]
-
-            # Store the element content
-            elements[name] = content
-
-            # Extract nested elements from the content
-            nested_elements = self._extract_element_content(content, preserve_cdata)
-            elements.update(nested_elements)
-
-        return dict(elements)  # Convert defaultdict to regular dict
+        elements = self._find_all_elements(text)
+        return self._process_elements(elements, preserve_cdata)
 
     def extract_elements(
         self: Self,
@@ -172,9 +243,7 @@ class ToleranceXMLParser:
             ValueError: If the input text is invalid or contains malformed XML.
         """
         try:
-            if not text or not isinstance(text, str):
-                raise ValueError("Input text must be a non-empty string")
-
+            self._validate_input(text)
             logger.debug(f"Extracting elements: {element_names or 'all'}")
 
             # Extract all elements and their content
@@ -206,18 +275,9 @@ class ToleranceXMLParser:
             ValueError: If the input text is invalid or contains malformed XML.
         """
         try:
-            if not text or not isinstance(text, str):
-                raise ValueError("Input text must be a non-empty string")
-
+            self._validate_input(text)
             elements: list[XMLElement] = []
-            pattern = re.compile(
-                f"<{element_name}>"
-                r"((?:(?!<!\[CDATA\[|]]>).)*?"
-                r"(?:<!\[CDATA\[.*?]]>)?"
-                r"(?:(?!<!\[CDATA\[|]]>).)*?)"
-                f"(?:</\1>|<\1>)",
-                re.DOTALL,
-            )
+            pattern = self._build_element_pattern(element_name)
 
             for match in pattern.finditer(text):
                 content = match.group(1)

{quantalogic-0.2.15.dist-info → quantalogic-0.2.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.2.15
+Version: 0.2.17
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com
@@ -15,11 +15,20 @@ Requires-Dist: fastapi (>=0.115.6,<0.116.0)
 Requires-Dist: google-auth (>=2.20.0,<3.0.0)
 Requires-Dist: google-search-results (>=2.4.2,<3.0.0)
 Requires-Dist: litellm (>=1.56.4,<2.0.0)
+Requires-Dist: llmlingua (>=0.2.2,<0.3.0)
 Requires-Dist: loguru (>=0.7.3,<0.8.0)
 Requires-Dist: markitdown (>=0.0.1a3,<0.0.2)
+Requires-Dist: mkdocs-git-revision-date-localized-plugin (>=1.2.0,<2.0.0)
+Requires-Dist: mkdocs-macros-plugin (>=1.0.4,<2.0.0)
+Requires-Dist: mkdocs-material[imaging] (>=9.5.49,<10.0.0)
+Requires-Dist: mkdocs-mermaid2-plugin (>=1.1.1,<2.0.0)
+Requires-Dist: mkdocs-minify-plugin (>=0.7.1,<0.8.0)
+Requires-Dist: mkdocstrings (>=0.24.0,<0.25.0)
+Requires-Dist: mkdocstrings-python (>=1.7.0,<2.0.0)
 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: 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)
@@ -43,7 +52,7 @@ Description-Content-Type: text/markdown
 
 [![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![Python](https://img.shields.io/badge/Python-3.12+-blue.svg)](https://www.python.org/downloads/)
-[![Documentation](https://img.shields.io/badge/docs-latest-brightgreen.svg)]()
+[![Documentation](https://img.shields.io/badge/docs-latest-brightgreen.svg)](https://quantalogic.github.io/quantalogic/)
 
 QuantaLogic is a  ReAct (Reasoning & Action) framework for building advanced AI agents. 
 
@@ -51,6 +60,8 @@ It seamlessly integrates large language models (LLMs) with a robust tool system,
 
 The `cli` version include coding capabilities comparable to Aider.
 
+[📖 Documentation](https://quantalogic.github.io/quantalogic/)
+
 
 ## Why QuantaLogic?
 
@@ -80,6 +91,7 @@ We created [QuantaLogic](https://www.quantalogic.app) because we saw a significa
 - [Development](#-development)
 - [Contributing](#-contributing)
 - [License](#-license)
+- [Documentation Development](#-documentation-development)
 
 ## 📦 Installation
 
@@ -128,12 +140,13 @@ Usage: quantalogic [OPTIONS] COMMAND [ARGS]...
 Options:
   --version                       Show version information.
   --model-name TEXT               Specify the text model to use (litellm format,
-                                  e.g. "openrouter/deepseek-chat").
+                                  e.g. "openrouter/deepseek/deepseek-chat").
   --vision-model-name TEXT        Specify the vision model to use (litellm format,
-                                  e.g. "openrouter/A/gpt-4o-mini").
+                                  e.g. "openrouter/openai/gpt-4o-mini").
   --log [info|debug|warning]      Set logging level (info/debug/warning).
   --verbose                       Enable verbose output.
-  --mode [code|basic|interpreter|full|code-basic|search]
+  --max-iterations INTEGER        Maximum iterations for task solving (default: 30).
+  --mode [code|basic|interpreter|full|code-basic|search|search-full]
                                   Agent mode (code/search/full).
   --help                          Show this message and exit.
 
@@ -154,6 +167,7 @@ task    Execute a task with the QuantaLogic AI Assistant
 - interpreter: Interactive code execution agent
 - full: Full-featured agent with all capabilities
 - code-basic: Coding agent with basic reasoning
+- search: Web search agent with Wikipedia, DuckDuckGo and SERPApi integration
 
 #### Task Execution
 
@@ -249,7 +263,7 @@ from quantalogic.tools import PythonTool, ReadFileTool
 
 # Create agent with specific tools
 agent = Agent(
-    model_name="openrouter/deepseek-chat",
+    model_name="openrouter/deepseek/deepseek-chat",
     tools=[
         PythonTool(),
         ReadFileTool()
@@ -842,148 +856,7 @@ print(results)
 ```
 ```
 
-#### Creating Custom Tools
-
-```python
-from quantalogic.tools import Tool, ToolArgument
-
-class DatabaseTool(Tool):
-    name: str = "database_tool"
-    description: str = "Execute database operations"
-    need_validation: bool = True
-    
-    arguments: list[ToolArgument] = [
-        ToolArgument(
-            name="query",
-            arg_type="string",
-            description="SQL query to execute",
-            required=True
-        )
-    ]
-    
-    def execute(self, query: str) -> str:
-        # Tool implementation
-        return "Query results"
 ```
-
-
-## 🌐 Web Interface
-
-Features:
-- Real-time event visualization
-- Task submission and monitoring
-- Interactive validation dialogs
-- Model selection
-- Event filtering and search
-
-### API Endpoints
-
-| Endpoint           | Method | Description     |
-| ------------------ | ------ | --------------- |
-| `/tasks`           | POST   | Submit tasks    |
-| `/tasks/{task_id}` | GET    | Task status     |
-| `/events`          | GET    | SSE endpoint    |
-| `/validate`        | POST   | Task validation |
-
-
-## 📖 Examples
-
-### Python Tool Integration Example
-
-```python
-import os
-
-from quantalogic import Agent, console_print_events
-from quantalogic.tools import (
-    PythonTool,
-)
-
-# Verify API key is set - required for authentication with DeepSeek's API
-# This check ensures the agent won't fail during runtime due to missing credentials
-if not os.environ.get("DEEPSEEK_API_KEY"):
-    raise ValueError("DEEPSEEK_API_KEY environment variable is not set")
-
-# Initialize agent with DeepSeek model and Python tool
-agent = Agent(model_name="deepseek/deepseek-chat", tools=[PythonTool()])
-
-# Configure comprehensive event monitoring system
-# Tracks all agent activities including:
-# - Code execution steps
-# - Tool interactions
-# - Error conditions
-# Essential for debugging and performance optimization
-agent.event_emitter.on(
-    "*",
-    console_print_events,
-)
-
-# Execute a precision mathematics task demonstrating:
-# - High-precision calculations
-# - PythonTool integration
-# - Real-time monitoring capabilities
-result = agent.solve_task("1. Calculate PI with 10000 decimal places.")
-print(result)
-```
-
-### Agent with Event Monitoring
-
-```python
-import os
-
-from quantalogic import Agent, console_print_events
-from quantalogic.tools import (
-    LLMTool,
-)
-
-# Verify API key is set - required for authentication with DeepSeek's API
-# This check ensures the agent won't fail during runtime due to missing credentials
-if not os.environ.get("DEEPSEEK_API_KEY"):
-    raise ValueError("DEEPSEEK_API_KEY environment variable is not set")
-
-# Initialize agent with DeepSeek model and LLM tool
-# The LLM tool serves dual purpose:
-# 1. As a reasoning engine for the agent's cognitive processes
-# 2. As a latent space explorer, enabling the agent to:
-#    - Discover novel solution paths
-#    - Generate creative combinations of concepts
-#    - Explore alternative reasoning strategies
-# Using the same model ensures consistent behavior across both roles
-agent = Agent(model_name="deepseek/deepseek-chat", tools=[LLMTool(model_name="deepseek/deepseek-chat")])
-
-# Set up event monitoring to track agent's lifecycle
-# This helps in debugging and understanding the agent's behavior
-agent.event_emitter.on(
-    [
-        "task_complete",
-        "task_think_start",
-        "task_think_end",
-        "tool_execution_start",
-        "tool_execution_end",
-        "error_max_iterations_reached",
-        "memory_full",
-        "memory_compacted",
-        "memory_summary",
-    ],
-    console_print_events,
-)
-
-# Execute a multi-step task showcasing agent's capabilities
-# Demonstrates:
-# 1. Creative content generation
-# 2. Language translation
-# 3. Style adaptation
-# 4. Multi-step reasoning and execution
-result = agent.solve_task(
-    "1. Write a poem in English about a dog. "
-    "2. Translate the poem into French. "
-    "3. Choose 2 French authors"
-    "4. Rewrite the translated poem with the style of the chosen authors. "
-)
-print(result)
-```
-
-
-
 ### Project Documentation
 
 ```python
@@ -991,7 +864,7 @@ from quantalogic import Agent
 from quantalogic.tools import MarkitdownTool, ReadFileTool
 
 agent = Agent(
-    model_name="openrouter/deepseek-chat",
+    model_name="openrouter/deepseek/deepseek-chat",
     tools=[MarkitdownTool(), ReadFileTool()]
 )