quantalogic 0.2.21__tar.gz → 0.2.23__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: quantalogic
-Version: 0.2.21
+Version: 0.2.23
 Summary: QuantaLogic ReAct Agents
 Author: Raphaël MANSUY
 Author-email: raphael.mansuy@gmail.com
@@ -8,6 +8,7 @@ Requires-Python: >=3.12,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: beautifulsoup4 (>=4.12.3,<5.0.0)
 Requires-Dist: boto3 (>=1.35.86,<2.0.0)
 Requires-Dist: click (>=8.1.8,<9.0.0)
 Requires-Dist: duckduckgo-search (>=7.2.1,<8.0.0)
@@ -18,6 +19,7 @@ Requires-Dist: jinja2 (>=3.1.5,<4.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: markdownify (>=0.14.1,<0.15.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)
@@ -66,6 +68,7 @@ The `cli` version include coding capabilities comparable to Aider.
 
 ![Video](./examples/generated_tutorials/python/quantalogic_8s.gif)
 
+
 [HowTo Guide](./docs/howto/howto.md)
 
 ## Why QuantaLogic?

{quantalogic-0.2.21 → quantalogic-0.2.23}/README.md

@@ -15,6 +15,7 @@ The `cli` version include coding capabilities comparable to Aider.
 
 ![Video](./examples/generated_tutorials/python/quantalogic_8s.gif)
 
+
 [HowTo Guide](./docs/howto/howto.md)
 
 ## Why QuantaLogic?

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "quantalogic"
-version = "0.2.21"
+version = "0.2.23"
 description = "QuantaLogic ReAct Agents"
 authors = ["Raphaël MANSUY <raphael.mansuy@gmail.com>"]
 readme = "README.md"
@@ -47,6 +47,8 @@ mkdocstrings-python = "^1.7.0"
 pymdown-extensions = "^10.3.1"
 llmlingua = "^0.2.2"
 jinja2 = "^3.1.5"
+beautifulsoup4 = "^4.12.3"
+markdownify = "^0.14.1"
 
 [tool.poetry.scripts]
 quantalogic = "quantalogic.main:cli"

{quantalogic-0.2.21 → quantalogic-0.2.23}/quantalogic/agent.py

@@ -483,7 +483,7 @@ class Agent(BaseModel):
         if len(response) > MAX_RESPONSE_LENGTH:
             response_display = response[:MAX_RESPONSE_LENGTH]
             response_display += (
-                f"... content was trunctated full content available by interpolation in variable {variable_name}"
+                f"... content was truncated full content available by interpolation in variable {variable_name}"
             )
 
         # Format the response message

{quantalogic-0.2.21 → quantalogic-0.2.23}/quantalogic/agent_config.py

@@ -3,8 +3,9 @@
 # Standard library imports
 
 # Local application imports
+from dotenv import load_dotenv
+
 from quantalogic.agent import Agent
-from quantalogic.coding_agent import create_coding_agent
 from quantalogic.console_print_token import console_print_token
 from quantalogic.tools import (
     AgentTool,
@@ -14,6 +15,7 @@ from quantalogic.tools import (
     ExecuteBashCommandTool,
     InputQuestionTool,
     ListDirectoryTool,
+    LLMImageGenerationTool,
     LLMTool,
     LLMVisionTool,
     MarkitdownTool,
@@ -21,6 +23,7 @@ from quantalogic.tools import (
     PythonTool,
     ReadFileBlockTool,
     ReadFileTool,
+    ReadHTMLTool,
     ReplaceInFileTool,
     RipgrepTool,
     SearchDefinitionNames,
@@ -29,6 +32,8 @@ from quantalogic.tools import (
     WriteFileTool,
 )
 
+load_dotenv()
+
 MODEL_NAME = "deepseek/deepseek-chat"
 
 
@@ -66,6 +71,12 @@ def create_agent(
         MarkitdownTool(),
         LLMTool(model_name=model_name, on_token=console_print_token if not no_stream else None),
         DownloadHttpFileTool(),
+        LLMImageGenerationTool(
+                provider="dall-e",
+                model_name="openai/dall-e-3",
+                on_token=console_print_token if not no_stream else None
+            ),
+        ReadHTMLTool()
     ]
 
     if vision_model_name:
@@ -115,6 +126,7 @@ def create_interpreter_agent(
         MarkitdownTool(),
         LLMTool(model_name=model_name, on_token=console_print_token if not no_stream else None),
         DownloadHttpFileTool(),
+        ReadHTMLTool(),
     ]
     return Agent(
         model_name=model_name, 
@@ -163,6 +175,7 @@ def create_full_agent(
         DownloadHttpFileTool(),
         WikipediaSearchTool(),
         DuckDuckGoSearchTool(),
+        ReadHTMLTool(),
     ]
 
     if vision_model_name:
@@ -209,8 +222,10 @@ def create_basic_agent(
         WriteFileTool(),
         EditWholeContentTool(),
         ReplaceInFileTool(),
+        InputQuestionTool(),
         ExecuteBashCommandTool(),
         LLMTool(model_name=model_name, on_token=console_print_token if not no_stream else None),
+        ReadHTMLTool(),
     ]
 
     if vision_model_name:

{quantalogic-0.2.21 → quantalogic-0.2.23}/quantalogic/coding_agent.py

@@ -11,6 +11,7 @@ from quantalogic.tools import (
     LLMVisionTool,
     ReadFileBlockTool,
     ReadFileTool,
+    ReadHTMLTool,
     ReplaceInFileTool,
     RipgrepTool,
     SearchDefinitionNames,
@@ -74,6 +75,7 @@ def create_coding_agent(
         InputQuestionTool(),
         DuckDuckGoSearchTool(),
         JinjaTool(),
+        ReadHTMLTool()
     ]
 
     if vision_model_name:

{quantalogic-0.2.21 → quantalogic-0.2.23}/quantalogic/generative_model.py

@@ -1,10 +1,12 @@
 """Generative model module for AI-powered text generation."""
 
 import functools
+from typing import Dict, Any, Optional, List
+from datetime import datetime
 
 import litellm
 import openai
-from litellm import completion, exceptions, get_max_tokens, get_model_info, token_counter
+from litellm import completion, exceptions, get_max_tokens, get_model_info, token_counter, image_generation
 from loguru import logger
 from pydantic import BaseModel, Field, field_validator
 
@@ -70,10 +72,12 @@ class ResponseStats(BaseModel):
     usage: TokenUsage
     model: str
     finish_reason: str | None = None
+    data: List[Dict[str, Any]] | None = None
+    created: str | None = None
 
 
 class GenerativeModel:
-    """Generative model for AI-powered text generation with configurable parameters."""
+    """Generative model for AI-powered text generation and image generation."""
 
     def __init__(
         self,
@@ -311,3 +315,73 @@ class GenerativeModel:
         except Exception as e:
             logger.error(f"Error getting max output tokens for {self.model}: {e}")
             return None
+
+    def generate_image(self, prompt: str, params: Dict[str, Any]) -> ResponseStats:
+        """Generate an image using the specified model and parameters.
+
+        Args:
+            prompt: Text description of the image to generate
+            params: Dictionary of parameters for image generation including:
+                   - model: Name of the image generation model
+                   - size: Size of the generated image
+                   - quality: Quality level (DALL-E only)
+                   - style: Style preference (DALL-E only)
+                   - response_format: Format of the response (url/base64)
+                   - negative_prompt: What to avoid in the image (SD only)
+                   - cfg_scale: Classifier Free Guidance scale (SD only)
+
+        Returns:
+            ResponseStats containing the image generation results
+
+        Raises:
+            Exception: If there's an error during image generation
+        """
+        try:
+            logger.debug(f"Generating image with params: {params}")
+            
+            # Ensure prompt is in params
+            generation_params = {**params}
+            generation_params["prompt"] = prompt
+            
+            # Call litellm's image generation function
+            response = image_generation(
+                model=generation_params.pop("model"),
+                **generation_params
+            )
+
+            # Convert response data to list of dictionaries with string values
+            if hasattr(response, "data"):
+                data = []
+                for img in response.data:
+                    img_data = {}
+                    if hasattr(img, "url"):
+                        img_data["url"] = str(img.url)
+                    if hasattr(img, "b64_json"):
+                        img_data["b64_json"] = str(img.b64_json)
+                    if hasattr(img, "revised_prompt"):
+                        img_data["revised_prompt"] = str(img.revised_prompt)
+                    data.append(img_data)
+            else:
+                data = [{"url": str(response.url)}]
+
+            # Convert timestamp to ISO format string
+            if hasattr(response, "created"):
+                try:
+                    created = datetime.fromtimestamp(response.created).isoformat()
+                except (TypeError, ValueError):
+                    created = str(response.created)
+            else:
+                created = None
+
+            # Convert response to our ResponseStats format
+            return ResponseStats(
+                response="",  # Empty for image generation
+                usage=TokenUsage(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+                model=str(params["model"]),
+                data=data,
+                created=created
+            )
+
+        except Exception as e:
+            logger.error(f"Error in image generation: {str(e)}")
+            raise

{quantalogic-0.2.21 → quantalogic-0.2.23}/quantalogic/main.py

@@ -28,11 +28,11 @@ from quantalogic.agent import Agent  # noqa: E402
 # Local application imports
 from quantalogic.agent_config import (  # noqa: E402
     MODEL_NAME,
-    create_coding_agent,
+    create_basic_agent,
     create_full_agent,
     create_interpreter_agent,
-    create_basic_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
 

{quantalogic-0.2.21 → quantalogic-0.2.23}/quantalogic/tools/__init__.py

@@ -1,6 +1,7 @@
 """Tools for the QuantaLogic agent."""
 
 from .agent_tool import AgentTool
+from .dalle_e import LLMImageGenerationTool
 from .download_http_file_tool import DownloadHttpFileTool
 from .duckduckgo_search_tool import DuckDuckGoSearchTool
 from .edit_whole_content_tool import EditWholeContentTool
@@ -16,6 +17,7 @@ from .nodejs_tool import NodeJsTool
 from .python_tool import PythonTool
 from .read_file_block_tool import ReadFileBlockTool
 from .read_file_tool import ReadFileTool
+from .read_html_tool import ReadHTMLTool
 from .replace_in_file_tool import ReplaceInFileTool
 from .ripgrep_tool import RipgrepTool
 from .search_definition_names import SearchDefinitionNames
@@ -53,4 +55,6 @@ __all__ = [
     "DownloadHttpFileTool",
     "EditWholeContentTool",
     "JinjaTool",
+    "LLMImageGenerationTool",
+    "ReadHTMLTool"
 ]

quantalogic-0.2.23/quantalogic/tools/dalle_e.py

@@ -0,0 +1,270 @@
+"""LLM Image Generation Tool for creating images using DALL-E or Stable Diffusion via AWS Bedrock."""
+
+import datetime
+import json
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import requests
+from loguru import logger
+from pydantic import ConfigDict, Field
+from tenacity import retry, stop_after_attempt, wait_exponential
+
+from quantalogic.generative_model import GenerativeModel
+from quantalogic.tools.tool import Tool, ToolArgument
+
+
+class ImageProvider(str, Enum):
+    """Supported image generation providers."""
+    DALLE = "dall-e"
+    STABLE_DIFFUSION = "stable-diffusion"
+
+PROVIDER_CONFIGS = {
+    ImageProvider.DALLE: {
+        "model_name": "dall-e-3",
+        "sizes": ["1024x1024", "1024x1792", "1792x1024"],
+        "qualities": ["standard", "hd"],
+        "styles": ["vivid", "natural"],
+    },
+    ImageProvider.STABLE_DIFFUSION: {
+        #"model_name": "anthropic.claude-3-sonnet-20240229",
+        "model_name": "amazon.titan-image-generator-v1",
+        "sizes": ["1024x1024"],  # Bedrock SD supported size
+        "qualities": ["standard"],  # SD quality is controlled by cfg_scale
+        "styles": ["none"],  # Style is controlled through prompting 
+    }
+}
+
+class LLMImageGenerationTool(Tool):
+    """Tool for generating images using DALL-E or Stable Diffusion."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
+
+    name: str = Field(default="llm_image_generation_tool")
+    description: str = Field(
+        default=(
+            "Generate images using DALL-E or Stable Diffusion. "
+            "Supports different sizes, styles, and quality settings."
+        )
+    )
+    arguments: list = Field(
+        default=[
+            ToolArgument(
+                name="prompt",
+                arg_type="string",
+                description="Text description of the image to generate",
+                required=True,
+                example="A serene Japanese garden with a red maple tree",
+            ),
+            ToolArgument(
+                name="provider",
+                arg_type="string",
+                description="Image generation provider (dall-e or stable-diffusion)",
+                required=False,
+                default="dall-e",
+                example="dall-e",
+            ),
+            ToolArgument(
+                name="size",
+                arg_type="string",
+                description="Size of the generated image",
+                required=False,
+                default="1024x1024",
+                example="1024x1024",
+            ),
+            ToolArgument(
+                name="quality",
+                arg_type="string",
+                description="Quality level for DALL-E",
+                required=False,
+                default="standard",
+                example="standard",
+            ),
+            ToolArgument(
+                name="style",
+                arg_type="string",
+                description="Style preference for DALL-E",
+                required=False,
+                default="vivid",
+                example="vivid",
+            ),
+            ToolArgument(
+                name="negative_prompt",
+                arg_type="string",
+                description="What to avoid in the image (Stable Diffusion only)",
+                required=False,
+                default="",
+                example="blurry, low quality",
+            ),
+            ToolArgument(
+                name="cfg_scale",
+                arg_type="string",
+                description="Classifier Free Guidance scale (Stable Diffusion only)",
+                required=False,
+                default="7.5",
+                example="7.5",
+            ),
+        ]
+    )
+
+    provider: ImageProvider = Field(default=ImageProvider.DALLE)
+    model_name: str = Field(default=PROVIDER_CONFIGS[ImageProvider.DALLE]["model_name"])
+    output_dir: Path = Field(default=Path("generated_images"))
+    generative_model: Optional[GenerativeModel] = Field(default=None)
+
+    def model_post_init(self, __context):
+        """Initialize after model creation."""
+        if self.generative_model is None:
+            self.generative_model = GenerativeModel(model=self.model_name)
+            logger.debug(f"Initialized LLMImageGenerationTool with model: {self.model_name}")
+        
+        # Create output directory if it doesn't exist
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+    def _validate_dalle_params(self, size: str, quality: str, style: str) -> None:
+        """Validate DALL-E specific parameters."""
+        if size not in PROVIDER_CONFIGS[ImageProvider.DALLE]["sizes"]:
+            raise ValueError(f"Invalid size for DALL-E. Must be one of: {PROVIDER_CONFIGS[ImageProvider.DALLE]['sizes']}")
+        if quality not in PROVIDER_CONFIGS[ImageProvider.DALLE]["qualities"]:
+            raise ValueError(f"Invalid quality for DALL-E. Must be one of: {PROVIDER_CONFIGS[ImageProvider.DALLE]['qualities']}")
+        if style not in PROVIDER_CONFIGS[ImageProvider.DALLE]["styles"]:
+            raise ValueError(f"Invalid style for DALL-E. Must be one of: {PROVIDER_CONFIGS[ImageProvider.DALLE]['styles']}")
+
+    def _validate_sd_params(self, size: str, cfg_scale: float) -> None:
+        """Validate Stable Diffusion specific parameters."""
+        if size not in PROVIDER_CONFIGS[ImageProvider.STABLE_DIFFUSION]["sizes"]:
+            raise ValueError(f"Invalid size for Stable Diffusion. Must be one of: {PROVIDER_CONFIGS[ImageProvider.STABLE_DIFFUSION]['sizes']}")
+        if not 1.0 <= cfg_scale <= 20.0:
+            raise ValueError("cfg_scale must be between 1.0 and 20.0")
+
+    @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
+    def _save_image(self, image_url: str, filename: str) -> Path:
+        """Download and save image locally with retry logic."""
+        try:
+            response = requests.get(image_url, timeout=30)
+            response.raise_for_status()
+            
+            file_path = self.output_dir / filename
+            file_path.write_bytes(response.content)
+            logger.info(f"Image saved successfully at: {file_path}")
+            return file_path
+            
+        except Exception as e:
+            logger.error(f"Error saving image: {e}")
+            raise
+
+    def _save_metadata(self, metadata: Dict[str, Any]) -> None:
+        """Save image metadata to JSON file."""
+        try:
+            metadata_path = self.output_dir / f"{metadata['filename']}.json"
+            with open(metadata_path, 'w') as f:
+                json.dump(metadata, f, indent=2)
+            logger.info(f"Metadata saved successfully at: {metadata_path}")
+        except Exception as e:
+            logger.error(f"Error saving metadata: {e}")
+            raise
+
+    def execute(
+        self,
+        prompt: str,
+        provider: str = "dall-e",
+        size: str = "1024x1024",
+        quality: str = "standard",
+        style: str = "vivid",
+        negative_prompt: str = "",
+        cfg_scale: str = "7.5",
+    ) -> str:
+        """Execute the tool to generate an image based on the prompt.
+        
+        Args:
+            prompt: Text description of the image to generate
+            provider: Provider to use (dall-e or stable-diffusion)
+            size: Size of the generated image
+            quality: Quality level for DALL-E
+            style: Style preference for DALL-E
+            negative_prompt: What to avoid in the image (Stable Diffusion only)
+            cfg_scale: Classifier Free Guidance scale (Stable Diffusion only)
+            
+        Returns:
+            Path to the locally saved image
+        """
+        try:
+            provider_enum = ImageProvider(provider.lower())
+            
+            # Convert cfg_scale to float only if it's not empty and we're using Stable Diffusion
+            cfg_scale_float = float(cfg_scale) if cfg_scale and provider_enum == ImageProvider.STABLE_DIFFUSION else None
+            
+            # Validate parameters based on provider
+            if provider_enum == ImageProvider.DALLE:
+                self._validate_dalle_params(size, quality, style)
+                params = {
+                    "model": PROVIDER_CONFIGS[provider_enum]["model_name"],
+                    "size": size,
+                    "quality": quality,
+                    "style": style,
+                    "response_format": "url"
+                }
+            else:  # Stable Diffusion
+                if cfg_scale_float is None:
+                    cfg_scale_float = 7.5  # Default value
+                self._validate_sd_params(size, cfg_scale_float)
+                params = {
+                    "model": PROVIDER_CONFIGS[provider_enum]["model_name"],
+                    "negative_prompt": negative_prompt,
+                    "cfg_scale": cfg_scale_float,
+                    "size": size,
+                    "response_format": "url"
+                }
+
+            # Generate image
+            logger.info(f"Generating image with {provider} using params: {params}")
+            response = self.generative_model.generate_image(
+                prompt=prompt,
+                params=params
+            )
+
+            # Extract image data from response
+            if not response.data:
+                raise ValueError("No image data in response")
+            
+            image_data = response.data[0]  # First image from the response
+            image_url = str(image_data.get("url", ""))
+            revised_prompt = str(image_data.get("revised_prompt", prompt))
+            
+            if not image_url:
+                raise ValueError("No image URL in response")
+
+            # Save image locally
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"{provider}_{timestamp}.png"
+            local_path = self._save_image(image_url, filename)
+
+            # Save metadata
+            metadata = {
+                "filename": str(filename),
+                "prompt": str(prompt),
+                "revised_prompt": str(revised_prompt),
+                "provider": str(provider),
+                "model": str(response.model),
+                "created": str(response.created or ""),
+                "parameters": {k: str(v) for k, v in {**params, "prompt": prompt}.items()},
+                "image_url": str(image_url),
+                "local_path": str(local_path)
+            }
+            self._save_metadata(metadata)
+
+            logger.info(f"Image generated and saved at: {local_path}")
+            return str(local_path)
+
+        except Exception as e:
+            logger.error(f"Error generating image with {provider}: {e}")
+            raise Exception(f"Error generating image with {provider}: {e}") from e
+
+
+if __name__ == "__main__":
+    # Example usage
+    tool = LLMImageGenerationTool()
+    prompt = "A serene Japanese garden with a red maple tree"
+    image_path = tool.execute(prompt=prompt)
+    print(f"Image saved at: {image_path}")

{quantalogic-0.2.21 → quantalogic-0.2.23}/quantalogic/tools/read_file_tool.py

@@ -14,7 +14,7 @@ class ReadFileTool(Tool):
 
     name: str = "read_file_tool"
     description: str = (
-        f"Reads a local file or HTTP content and returns its content."
+        f"Reads a local file content and returns its content."
         f"Cut to {MAX_LINES} first lines.\n"
         "Don't use on HTML files and large files."
         "Prefer to use read file block tool to don't fill the memory."
@@ -23,9 +23,9 @@ class ReadFileTool(Tool):
         ToolArgument(
             name="file_path",
             arg_type="string",
-            description="The path to the file or URL to read.",
+            description="The path to the file to read.",
             required=True,
-            example="/path/to/file.txt or https://example.com/data.txt",
+            example="/path/to/file.txt",
         ),
     ]
 

quantalogic-0.2.23/quantalogic/tools/read_html_tool.py

@@ -0,0 +1,303 @@
+import os
+import random
+import time
+from typing import Optional
+
+import requests
+from bs4 import BeautifulSoup
+from loguru import logger
+from pydantic import BaseModel, Field, field_validator
+
+# Ensure that markdownify is installed: pip install markdownify
+try:
+    from markdownify import markdownify as md
+except ImportError:
+    logger.error("Missing dependency: markdownify. Install it using 'pip install markdownify'")
+    raise
+
+# Assuming Tool and ToolArgument are properly defined in quantalogic.tools.tool
+from quantalogic.tools.tool import Tool, ToolArgument
+
+# User-Agent list to mimic different browsers
+USER_AGENTS = [
+    # Chrome on Windows
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)"
+    " Chrome/91.0.4472.124 Safari/537.36",
+    # Chrome on macOS
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko)"
+    " Chrome/91.0.4472.124 Safari/537.36",
+    # Firefox on Windows
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0",
+    # Firefox on macOS
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:89.0) Gecko/20100101 Firefox/89.0",
+    # Safari on macOS
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko)"
+    " Version/14.1.1 Safari/605.1.15"
+]
+
+# Additional headers to mimic real browser requests
+ADDITIONAL_HEADERS = {
+    "Accept": "text/html,application/xhtml+xml,application/xml;"
+              "q=0.9,image/webp,*/*;q=0.8",
+    "Accept-Language": "en-US,en;q=0.5",
+    "Upgrade-Insecure-Requests": "1",
+    "DNT": "1",  # Do Not Track
+    "Connection": "keep-alive",
+    "Cache-Control": "max-age=0"
+}
+
+class ReadHTMLTool(Tool):
+    """Tool for reading HTML content from files or URLs in specified line ranges."""
+
+    class Arguments(BaseModel):
+        source: str = Field(
+            ...,
+            description="The file path or URL to read HTML from",
+            example="https://example.com or ./example.html"
+        )
+        convert: Optional[str] = Field(
+            "text",
+            description="Convert input to 'text' (Markdown) or 'html' no conversion. Default is 'text'",
+            example="'text' or 'html'"
+        )
+        line_start: Optional[int] = Field(
+            1,
+            description="The starting line number (1-based index). Default: 1",
+            ge=1,
+            example="1"
+        )
+        line_end: Optional[int] = Field(
+            300,
+            description="The ending line number (1-based index). Default: 300",
+            ge=1,
+            example="300"
+        )
+
+        @field_validator('convert')
+        def validate_convert(cls, v):
+            if v not in ["text", "html"]:
+                raise ValueError("Convert must be either 'text' or 'html'")
+            return v
+
+        @field_validator('line_end')
+        def validate_line_end(cls, v, values):
+            if 'line_start' in values and v < values['line_start']:
+                raise ValueError("line_end must be greater than or equal to line_start")
+            return v
+
+    name: str = "read_html_tool"
+    description: str = (
+        "Reads HTML content from either a file path or URL in specified line ranges. "
+        "Returns parsed HTML content using BeautifulSoup or converts it to Markdown. "
+        "Allows reading specific portions of HTML files by defining start and end lines."
+    )
+    arguments: list = [
+        ToolArgument(
+            name="source",
+            arg_type="string",
+            description="The file path or URL to read HTML from",
+            required=True,
+            example="https://example.com or ./example.html"
+        ),
+        ToolArgument(
+            name="convert",
+            arg_type="string",
+            description="Convert input to 'text' (Markdown) or 'html'. Default is 'text'",
+            default='text',
+            required=False,
+            example="'text' or 'html'"
+        ),
+        ToolArgument(
+            name="line_start",
+            arg_type="int",
+            description="The starting line number (1-based index). Default: 1",
+            required=False,
+            example="1"
+        ),
+        ToolArgument(
+            name="line_end",
+            arg_type="int",
+            description="The ending line number (1-based index). Default: 300",
+            required=False,
+            example="300"
+        )
+    ]
+
+    def validate_source(self, source: str) -> bool:
+        """Validate if source is a valid file path or URL."""
+        if os.path.isfile(source):
+            return True
+        try:
+            result = requests.utils.urlparse(source)
+            return all([result.scheme, result.netloc])
+        except (requests.exceptions.RequestException, ValueError) as e:
+            # Log the specific exception for debugging
+            logger.debug(f"URL validation failed: {e}")
+            return False
+
+    def read_from_file(self, file_path: str) -> str:
+        """Read HTML content from a file."""
+        try:
+            with open(file_path, encoding='utf-8') as file:
+                return file.read()
+        except Exception as e:
+            logger.error(f"Error reading file: {e}")
+            raise ValueError(f"Error reading file: {e}")
+
+    def read_from_url(self, url: str) -> str:
+        """Read HTML content from a URL with randomized User-Agent and headers."""
+        try:
+            # Randomize User-Agent
+            headers = ADDITIONAL_HEADERS.copy()
+            headers["User-Agent"] = random.choice(USER_AGENTS)
+
+            # Add a small random delay to mimic human behavior
+            time.sleep(random.uniform(0.5, 2.0))
+
+            # Use a timeout to prevent hanging
+            response = requests.get(
+                url,
+                headers=headers,
+                timeout=10,
+                allow_redirects=True
+            )
+            response.raise_for_status()
+            return response.text
+        except requests.RequestException as e:
+            logger.error(f"Error fetching URL {url}: {e}")
+            raise ValueError(f"Error fetching URL: {e}")
+
+    def parse_html(self, html_content: str) -> BeautifulSoup:
+        """Parse HTML content using BeautifulSoup."""
+        try:
+            return BeautifulSoup(html_content, 'html.parser')
+        except Exception as e:
+            logger.error(f"Error parsing HTML: {e}")
+            raise ValueError(f"Error parsing HTML: {e}")
+
+    def read_source(self, source: str) -> str:
+        """Read entire content from source."""
+        if os.path.isfile(source):
+            return self.read_from_file(source)
+        else:
+            return self.read_from_url(source)
+
+    def _convert_content(self, content: str, convert_type: str) -> str:
+        """
+        Convert content based on the specified type.
+
+        Args:
+            content (str): The input content to convert
+            convert_type (str): The type of conversion to perform
+
+        Returns:
+            str: Converted content
+        """
+        if convert_type == "text":
+            # Convert HTML to Markdown using markdownify
+            try:
+                markdown_content = md(content, heading_style="ATX")
+                return markdown_content
+            except Exception as e:
+                logger.error(f"Error converting HTML to Markdown: {e}")
+                raise ValueError(f"Error converting HTML to Markdown: {e}")
+
+        if convert_type == "html":
+            # Ensure content is valid HTML
+            try:
+                soup = BeautifulSoup(content, 'html.parser')
+                return soup.prettify()
+            except Exception as e:
+                logger.error(f"Error prettifying HTML: {e}")
+                raise ValueError(f"Error prettifying HTML: {e}")
+
+        return content
+
+    def execute(self, source: str, convert: Optional[str] = 'text',
+                line_start: int = 1, line_end: int = 300) -> str:
+        """Execute the tool to read and parse HTML content in specified line ranges."""
+        logger.debug(f"Executing read_html_tool with source: {source}")
+
+        line_start = int(line_start)
+        line_end = int(line_end)
+
+        if not self.validate_source(source):
+            logger.warning(f"Invalid source: {source}")
+            return f"Invalid source: {source}"
+
+        try:
+            # Step 1: Read entire content from source
+            raw_content = self.read_source(source)
+
+            # Step 2: Convert content
+            converted_content = self._convert_content(raw_content, convert)
+
+            # Step 3: Split converted content into lines
+            lines = converted_content.splitlines()
+            total_lines = len(lines)
+
+            # Step 4: Adjust line_end if it exceeds total_lines
+            adjusted_end_line = min(line_end, total_lines)
+
+            # Step 5: Slice lines based on line_start and adjusted_end_line
+            sliced_lines = lines[line_start - 1: adjusted_end_line]
+            sliced_content = "\n".join(sliced_lines)
+
+            # Step 6: Calculate actual_end_line based on lines returned
+            if sliced_lines:
+                actual_end_line = line_start + len(sliced_lines) - 1
+            else:
+                actual_end_line = line_start
+
+            # Step 7: Determine if this is the last block
+            is_last_block = actual_end_line >= total_lines
+
+            # Step 8: Calculate total lines returned
+            total_lines_returned = len(sliced_lines)
+
+            # Prepare detailed output
+            result = [
+                f"==== Source: {source} ====",
+                f"==== Lines: {line_start} - {actual_end_line} of {total_lines} ====",
+                "==== Block Detail ====",
+                f"Start Line: {line_start}",
+                f"End Line: {actual_end_line}",
+                f"Total Lines Returned: {total_lines_returned}",
+                f"Is Last Block: {'Yes' if is_last_block else 'No'}",
+                "==== Content ====",
+                sliced_content,
+                "==== End of Block ===="
+            ]
+
+            return "\n".join(result)
+
+        except Exception as e:
+            logger.error(f"Unexpected error processing source {source}: {e}")
+            return f"Unexpected error: {e}"
+
+
+if __name__ == "__main__":
+    tool = ReadHTMLTool()
+
+    # Since to_markdown() is not defined, we'll comment it out.
+    # print(tool.to_markdown())
+
+    # Test with a known working URL
+    try:
+        result = tool.execute(source="https://www.quantalogic.app", line_start=1, line_end=100)
+        print("URL Test Result:")
+        print(result)
+    except Exception as e:
+        print(f"URL Test Failed: {e}")
+
+    # Test with local file (if available)
+    try:
+        local_file = os.path.join(os.path.dirname(__file__), "test.html")
+        if os.path.exists(local_file):
+            result = tool.execute(source=local_file, line_start=1, line_end=1000)
+            print("Local File Test Result:")
+            print(result)
+        else:
+            print("No local test file found.")
+    except Exception as e:
+        print(f"Local File Test Failed: {e}")