agentle 0.9.25__py3-none-any.whl → 0.9.26__py3-none-any.whl

agentle/agents/apis/api.py

@@ -14,6 +14,7 @@ Provides advanced features for managing collections of related endpoints with:
 from __future__ import annotations
 
 import logging
+import re
 from collections.abc import (
     Coroutine,
     Mapping,
@@ -513,13 +514,30 @@ class API(BaseModel):
                     continue
 
                 # Create endpoint
-                endpoint_name: str = cast(
-                    str,
-                    (
-                        operation_id
-                        or f"{method}_{path.replace('/', '_').replace('{', '').replace('}', '')}"
-                    ),
-                )
+                # Generate a valid function name from the path
+                if operation_id:
+                    endpoint_name = operation_id
+                else:
+                    # Clean the path to create a valid function name
+                    # Remove leading/trailing slashes and replace special chars
+                    clean_path = (
+                        path.strip("/")
+                        .replace("/", "_")
+                        .replace("{", "")
+                        .replace("}", "")
+                        .replace("-", "_")
+                    )
+                    # Remove any consecutive underscores
+                    clean_path = re.sub(r"_+", "_", clean_path)
+                    # Ensure it doesn't start with a number
+                    if clean_path and clean_path[0].isdigit():
+                        clean_path = f"n{clean_path}"
+                    # If empty after cleaning, use a generic name
+                    if not clean_path:
+                        clean_path = "root"
+                    endpoint_name = f"{method.lower()}_{clean_path}"
+
+                endpoint_name = cast(str, endpoint_name)
 
                 endpoint_description: str = cast(
                     str,

agentle/agents/apis/endpoint.py

@@ -359,7 +359,7 @@ class Endpoint(BaseModel):
             await self._auth_handler.refresh_if_needed()
             await self._auth_handler.apply_auth(None, url, headers, query_params)  # type: ignore
 
-        # Prepare connector
+        # Prepare connector kwargs (will be used to create fresh connector for each attempt)
         connector_kwargs: dict[str, Any] = {
             "limit": 10,
             "limit_per_host": 5,
@@ -369,8 +369,6 @@ class Endpoint(BaseModel):
         if not self.request_config.verify_ssl:
             connector_kwargs["ssl"] = False
 
-        connector = aiohttp.TCPConnector(**connector_kwargs)
-
         # Prepare timeout
         timeout = aiohttp.ClientTimeout(
             total=self.request_config.timeout,
@@ -381,9 +379,11 @@ class Endpoint(BaseModel):
         # Define the request function for circuit breaker
         async def make_single_request() -> Any:
             """Make a single request attempt."""
-            async with aiohttp.ClientSession(
-                connector=connector, timeout=timeout
-            ) as session:
+            # Create a fresh connector for each request attempt to avoid "Session is closed" errors on retries
+            connector = aiohttp.TCPConnector(**connector_kwargs)
+            session = None
+            try:
+                session = aiohttp.ClientSession(connector=connector, timeout=timeout)
                 # Prepare request kwargs
                 request_kwargs: dict[str, Any] = {
                     "headers": headers,
@@ -486,6 +486,12 @@ class Endpoint(BaseModel):
                         await self._response_cache.set(url, kwargs, result)
 
                     return result
+            finally:
+                # Always close the session to prevent "Session is closed" errors on retries
+                if session is not None:
+                    await session.close()
+                    # Give the connector time to close properly
+                    await asyncio.sleep(0.01)
 
         # Execute with retries
         last_exception = None
@@ -569,11 +575,11 @@ class Endpoint(BaseModel):
 
                 if hasattr(param, "enum") and param.enum:
                     param_info["enum"] = list(param.enum)
-                
+
                 # Add constraints for number/primitive types
                 if hasattr(param, "parameter_schema") and param.parameter_schema:
                     from agentle.agents.apis.primitive_schema import PrimitiveSchema
-                    
+
                     schema = param.parameter_schema
                     # Only PrimitiveSchema has minimum, maximum, format
                     if isinstance(schema, PrimitiveSchema):

agentle/web/extractor.py

@@ -1,8 +1,11 @@
+from __future__ import annotations
+
+import asyncio
 from collections.abc import Sequence
 from textwrap import dedent
+from typing import TYPE_CHECKING
 
 from html_to_markdown import convert
-from playwright.async_api import Geolocation, ViewportSize
 from rsb.coroutines.run_sync import run_sync
 from rsb.models import Field
 from rsb.models.base_model import BaseModel
@@ -18,6 +21,10 @@ from agentle.web.actions.action import Action
 from agentle.web.extraction_preferences import ExtractionPreferences
 from agentle.web.extraction_result import ExtractionResult
 
+if TYPE_CHECKING:
+    from playwright.async_api import Browser, Geolocation, ViewportSize
+
+
 _INSTRUCTIONS = Prompt.from_text(
     dedent("""\
     <character>
@@ -64,31 +71,28 @@ class Extractor(BaseModel):
 
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    def extract[T: BaseModel](
+    def extract_markdown(
         self,
+        browser: Browser,
         urls: Sequence[str],
-        output: type[T],
-        prompt: str | None = None,
         extraction_preferences: ExtractionPreferences | None = None,
         ignore_invalid_urls: bool = True,
-    ) -> ExtractionResult[T]:
+    ) -> tuple[str, str]:
         return run_sync(
-            self.extract_async(
-                urls, output, prompt, extraction_preferences, ignore_invalid_urls
-            )
+            self.extract_markdown_async,
+            browser=browser,
+            urls=urls,
+            extraction_preferences=extraction_preferences,
+            ignore_invalid_urls=ignore_invalid_urls,
         )
 
-    @needs("playwright")
-    async def extract_async[T: BaseModel](
+    async def extract_markdown_async(
         self,
+        browser: Browser,
         urls: Sequence[str],
-        output: type[T],
-        prompt: str | None = None,
         extraction_preferences: ExtractionPreferences | None = None,
         ignore_invalid_urls: bool = True,
-    ) -> ExtractionResult[T]:
-        from playwright import async_api
-
+    ) -> tuple[str, str]:
         _preferences = extraction_preferences or ExtractionPreferences()
         _actions: Sequence[Action] = _preferences.actions or []
 
@@ -98,171 +102,272 @@ class Extractor(BaseModel):
             # This is a placeholder for proxy configuration
             pass
 
-        async with async_api.async_playwright() as p:
-            browser = await p.chromium.launch(headless=True)
-
-            # Build context options properly based on preferences
-            if _preferences.mobile:
-                viewport: ViewportSize | None = ViewportSize(width=375, height=667)
-                user_agent = "Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) AppleWebKit/605.1.15"
-                is_mobile = True
-            else:
-                viewport = None
-                user_agent = None
-                is_mobile = None
-
-            # Handle geolocation
-            geolocation: Geolocation | None = None
-            permissions = None
-            if _preferences.location:
-                geolocation = Geolocation(
-                    latitude=getattr(_preferences.location, "latitude", 0),
-                    longitude=getattr(_preferences.location, "longitude", 0),
-                )
-                permissions = ["geolocation"]
-
-            context = await browser.new_context(
-                viewport=viewport,
-                user_agent=user_agent,
-                is_mobile=is_mobile,
-                extra_http_headers=_preferences.headers,
-                ignore_https_errors=_preferences.skip_tls_verification,
-                geolocation=geolocation,
-                permissions=permissions,
+        # Build context options properly based on preferences
+        if _preferences.mobile:
+            viewport: ViewportSize | None = ViewportSize(width=375, height=667)
+            user_agent = "Mozilla/5.0 (iPhone; CPU iPhone OS 14_0 like Mac OS X) AppleWebKit/605.1.15"
+            is_mobile = True
+        else:
+            viewport = None
+            user_agent = None
+            is_mobile = None
+
+        # Handle geolocation
+        geolocation: Geolocation | None = None
+        permissions = None
+        if _preferences.location:
+            geolocation = Geolocation(
+                latitude=getattr(_preferences.location, "latitude", 0),
+                longitude=getattr(_preferences.location, "longitude", 0),
             )
+            permissions = ["geolocation"]
+
+        context = await browser.new_context(
+            viewport=viewport,
+            user_agent=user_agent,
+            is_mobile=is_mobile,
+            extra_http_headers=_preferences.headers,
+            ignore_https_errors=_preferences.skip_tls_verification,
+            geolocation=geolocation,
+            permissions=permissions,
+        )
 
-            # Block ads if specified
-            if _preferences.block_ads:
-                await context.route(
-                    "**/*",
-                    lambda route: route.abort()
-                    if route.request.resource_type in ["image", "media", "font"]
-                    and any(
-                        ad_domain in route.request.url
-                        for ad_domain in [
-                            "doubleclick.net",
-                            "googlesyndication.com",
-                            "adservice.google.com",
-                            "ads",
-                            "analytics",
-                            "tracking",
-                        ]
-                    )
-                    else route.continue_(),
+        # Block ads if specified
+        if _preferences.block_ads:
+            await context.route(
+                "**/*",
+                lambda route: route.abort()
+                if route.request.resource_type in ["image", "media", "font"]
+                and any(
+                    ad_domain in route.request.url
+                    for ad_domain in [
+                        "doubleclick.net",
+                        "googlesyndication.com",
+                        "adservice.google.com",
+                        "ads",
+                        "analytics",
+                        "tracking",
+                    ]
                 )
+                else route.continue_(),
+            )
+
+        page = await context.new_page()
+
+        for url in urls:
+            # Set timeout if specified
+            timeout = _preferences.timeout_ms if _preferences.timeout_ms else 30000
 
-            page = await context.new_page()
+            try:
+                await page.goto(url, timeout=timeout)
 
-            for url in urls:
-                # Set timeout if specified
-                timeout = _preferences.timeout_ms if _preferences.timeout_ms else 30000
+                # Wait for specified time if configured
+                if _preferences.wait_for_ms:
+                    await page.wait_for_timeout(_preferences.wait_for_ms)
 
-                try:
-                    await page.goto(url, timeout=timeout)
+                # Execute actions
+                for action in _actions:
+                    await action.execute(page)
 
-                    # Wait for specified time if configured
-                    if _preferences.wait_for_ms:
-                        await page.wait_for_timeout(_preferences.wait_for_ms)
+            except Exception as e:
+                if ignore_invalid_urls:
+                    print(f"Warning: Failed to load {url}: {e}")
+                    continue
+                else:
+                    raise
 
-                    # Execute actions
-                    for action in _actions:
-                        await action.execute(page)
+        html = await page.content()
 
-                except Exception as e:
-                    if ignore_invalid_urls:
-                        print(f"Warning: Failed to load {url}: {e}")
-                        continue
-                    else:
-                        raise
+        # Process HTML based on preferences - consolidate all BeautifulSoup operations
+        if (
+            _preferences.remove_base_64_images
+            or _preferences.include_tags
+            or _preferences.exclude_tags
+            or _preferences.only_main_content
+        ):
+            from bs4 import BeautifulSoup
 
-            html = await page.content()
+            soup = BeautifulSoup(html, "html.parser")
 
-            # Process HTML based on preferences
+            # Remove base64 images first
             if _preferences.remove_base_64_images:
                 import re
 
-                html = re.sub(
-                    r'<img[^>]+src="data:image/[^"]+"[^>]*>',
-                    "",
-                    html,
-                    flags=re.IGNORECASE,
+                # Debug: Check what we have before processing
+                all_imgs = soup.find_all("img")
+                print(f"DEBUG: Found {len(all_imgs)} img tags total")
+                base64_count = 0
+                for img in all_imgs:
+                    src = img.attrs.get("src") if hasattr(img, "attrs") else None  # type: ignore[union-attr]
+                    if isinstance(src, str) and "data:image/" in src:
+                        base64_count += 1
+                        print(f"DEBUG: Found base64 img: {src[:100]}...")
+                print(f"DEBUG: {base64_count} images have base64 data")
+
+                # First, remove any anchor tags that contain img children with base64
+                # (must be done before removing img tags themselves)
+                removed_anchors = 0
+                for a_tag in soup.find_all("a"):
+                    imgs = a_tag.find_all("img")  # type: ignore[union-attr]
+                    for img in imgs:
+                        src = img.attrs.get("src") if hasattr(img, "attrs") else None  # type: ignore[union-attr]
+                        if isinstance(src, str) and src.startswith("data:image/"):
+                            # Remove the entire anchor tag if it contains base64 image
+                            a_tag.decompose()
+                            removed_anchors += 1
+                            break
+                print(
+                    f"DEBUG: Removed {removed_anchors} anchor tags with base64 images"
                 )
 
-            # Filter HTML by tags if specified
-            if _preferences.include_tags or _preferences.exclude_tags:
-                from bs4 import BeautifulSoup
-
-                soup = BeautifulSoup(html, "html.parser")
-
-                if _preferences.only_main_content:
-                    # Try to find main content area
-                    main_content = (
-                        soup.find("main")
-                        or soup.find("article")
-                        or soup.find("div", {"id": "content"})
-                        or soup.find("div", {"class": "content"})
-                    )
-                    if main_content:
-                        soup = BeautifulSoup(str(main_content), "html.parser")
-
-                if _preferences.exclude_tags:
-                    for tag in _preferences.exclude_tags:
-                        for element in soup.find_all(tag):
-                            element.decompose()
-
-                if _preferences.include_tags:
-                    # Keep only specified tags
-                    new_soup = BeautifulSoup("", "html.parser")
-                    for tag in _preferences.include_tags:
-                        for element in soup.find_all(tag):
-                            new_soup.append(element)
-                    soup = new_soup
-
-                html = str(soup)
-
-            # Convert to markdown
-            markdown = convert(html)
-
-            # Prepare and send prompt
-            _prompt = _PROMPT.compile(
-                user_instructions=prompt or "Not provided.", markdown=markdown
-            )
-
-            if isinstance(self.llm, GenerationProvider):
-                response = await self.llm.generate_by_prompt_async(
-                    prompt=_prompt,
-                    model=self.model,
-                    developer_prompt=_INSTRUCTIONS,
-                    response_schema=output,
+                # Remove standalone img tags with base64 src
+                removed_imgs = 0
+                for img in soup.find_all("img"):
+                    src = img.attrs.get("src") if hasattr(img, "attrs") else None  # type: ignore[union-attr]
+                    if isinstance(src, str) and src.startswith("data:image/"):
+                        img.decompose()
+                        removed_imgs += 1
+                print(f"DEBUG: Removed {removed_imgs} standalone img tags")
+
+                # Remove any element with base64 in href (like anchor tags with image data)
+                for elem in soup.find_all(attrs={"href": True}):
+                    href = elem.attrs.get("href") if hasattr(elem, "attrs") else None  # type: ignore[union-attr]
+                    if isinstance(href, str) and href.startswith("data:image/"):
+                        elem.decompose()
+
+                # Remove any element with base64 in style attribute
+                for elem in soup.find_all(attrs={"style": True}):
+                    style = elem.attrs.get("style") if hasattr(elem, "attrs") else None  # type: ignore[union-attr]
+                    if isinstance(style, str) and "data:image/" in style:
+                        elem.decompose()
+
+                # Remove SVG tags (they often contain base64 or are converted to base64 by markdown)
+                for svg in soup.find_all("svg"):
+                    svg.decompose()
+
+                # Remove any anchor tags that contain SVG children
+                for a_tag in soup.find_all("a"):
+                    if a_tag.find("svg"):  # type: ignore[union-attr]
+                        a_tag.decompose()
+
+                # Final check: see if any base64 remains in the HTML string
+                html_str = str(soup)
+                remaining = len(re.findall(r'data:image/[^"\')\s]+', html_str))
+                print(
+                    f"DEBUG: After processing, {remaining} base64 data URIs remain in HTML"
                 )
-            else:
-                response = await self.llm.respond_async(
-                    input=_prompt,
-                    model=self.model,
-                    instructions=_INSTRUCTIONS,
-                    reasoning=self.reasoning,
-                    text_format=output,
+
+            # Extract main content if requested
+            if _preferences.only_main_content:
+                main_content = (
+                    soup.find("main")
+                    or soup.find("article")
+                    or soup.find("div", {"id": "content"})
+                    or soup.find("div", {"class": "content"})
                 )
+                if main_content:
+                    soup = main_content  # type: ignore[assignment]
 
-            output_parsed = (
-                response.parsed
-                if isinstance(response, Generation)
-                else response.output_parsed
-            )
+            # Exclude specific tags
+            if _preferences.exclude_tags:
+                for tag in _preferences.exclude_tags:
+                    for element in soup.find_all(tag):  # type: ignore[union-attr]
+                        element.decompose()
+
+            # Include only specific tags
+            if _preferences.include_tags:
+                new_soup = BeautifulSoup("", "html.parser")
+                for tag in _preferences.include_tags:
+                    for element in soup.find_all(tag):  # type: ignore[union-attr]
+                        new_soup.append(element)  # type: ignore[arg-type]
+                soup = new_soup
+
+            html = str(soup)
 
-            await browser.close()
+        # Convert to markdown
+        markdown = convert(html)
+        return html, markdown
 
-            return ExtractionResult[T](
+    def extract[T: BaseModel](
+        self,
+        browser: Browser,
+        urls: Sequence[str],
+        output: type[T],
+        prompt: str | None = None,
+        extraction_preferences: ExtractionPreferences | None = None,
+        ignore_invalid_urls: bool = True,
+    ) -> ExtractionResult[T]:
+        return run_sync(
+            self.extract_async(
+                browser=browser,
                 urls=urls,
-                html=html,
-                markdown=markdown,
-                extraction_preferences=_preferences,
-                output_parsed=output_parsed,
+                output=output,
+                prompt=prompt,
+                extraction_preferences=extraction_preferences,
+                ignore_invalid_urls=ignore_invalid_urls,
             )
+        )
 
+    @needs("playwright")
+    async def extract_async[T: BaseModel](
+        self,
+        browser: Browser,
+        urls: Sequence[str],
+        output: type[T],
+        prompt: str | None = None,
+        extraction_preferences: ExtractionPreferences | None = None,
+        ignore_invalid_urls: bool = True,
+    ) -> ExtractionResult[T]:
+        _preferences = extraction_preferences or ExtractionPreferences()
 
-if __name__ == "__main__":
+        html, markdown = await self.extract_markdown_async(
+            browser=browser,
+            urls=urls,
+            extraction_preferences=_preferences,
+            ignore_invalid_urls=ignore_invalid_urls,
+        )
+
+        # Prepare and send prompt
+        _prompt = _PROMPT.compile(
+            user_instructions=prompt or "Not provided.", markdown=markdown
+        )
+
+        if isinstance(self.llm, GenerationProvider):
+            response = await self.llm.generate_by_prompt_async(
+                prompt=_prompt,
+                model=self.model,
+                developer_prompt=_INSTRUCTIONS,
+                response_schema=output,
+            )
+        else:
+            response = await self.llm.respond_async(
+                input=_prompt,
+                model=self.model,
+                instructions=_INSTRUCTIONS,
+                reasoning=self.reasoning,
+                text_format=output,
+            )
+
+        output_parsed = (
+            response.parsed
+            if isinstance(response, Generation)
+            else response.output_parsed
+        )
+
+        await browser.close()
+
+        return ExtractionResult[T](
+            urls=urls,
+            html=html,
+            markdown=markdown,
+            extraction_preferences=_preferences,
+            output_parsed=output_parsed,
+        )
+
+
+async def test() -> None:
     from dotenv import load_dotenv
+    from playwright import async_api
 
     load_dotenv()
 
@@ -272,8 +377,8 @@ if __name__ == "__main__":
         possiveis_redirecionamentos: list[str]
 
     extractor = Extractor(
-        llm=Responder.openai(),
-        model="gpt-5-nano",
+        llm=Responder.openrouter(),
+        model="google/gemini-2.5-flash",
     )
 
     # Example with custom extraction preferences
@@ -285,12 +390,20 @@ if __name__ == "__main__":
         timeout_ms=15000,
     )
 
-    result = extractor.extract(
-        urls=[site_uniube],
-        output=PossiveisRedirecionamentos,
-        prompt="Extract the possible redirects from the page.",
-        extraction_preferences=preferences,
-    )
+    async with async_api.async_playwright() as p:
+        browser = await p.chromium.launch(headless=True)
+
+        result = await extractor.extract_async(
+            browser=browser,
+            urls=[site_uniube],
+            output=PossiveisRedirecionamentos,
+            prompt="Extract the possible redirects from the page.",
+            extraction_preferences=preferences,
+        )
+
+        for link in result.output_parsed.possiveis_redirecionamentos:
+            print(f"Link: {link}")
 
-    for link in result.output_parsed.possiveis_redirecionamentos:
-        print(f"Link: {link}")
+
+if __name__ == "__main__":
+    asyncio.run(test())

{agentle-0.9.25.dist-info → agentle-0.9.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentle
-Version: 0.9.25
+Version: 0.9.26
 Summary: ...
 Author-email: Arthur Brenno <64020210+arthurbrenno@users.noreply.github.com>
 License-File: LICENSE

{agentle-0.9.25.dist-info → agentle-0.9.26.dist-info}/RECORD

@@ -63,7 +63,7 @@ agentle/agents/a2a/tasks/managment/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQe
 agentle/agents/a2a/tasks/managment/in_memory.py,sha256=_G5VuXqEPBMtE6XJg1d7WmqFr1qzd0-99FoqM_qMwAE,23841
 agentle/agents/a2a/tasks/managment/task_manager.py,sha256=rBCuzu4DqIs55xDnwXY0w5Rs9ybv6OJpgpugAQLhtoU,3112
 agentle/agents/apis/__init__.py,sha256=PX7oAe0hRGvyLB295DrBF1VBsqgp5ZmGI4BCZvLUozo,2811
-agentle/agents/apis/api.py,sha256=dl146HQwawq4ll8lEcWl7ZM46-FBBgmX_TXEopY-Le8,25709
+agentle/agents/apis/api.py,sha256=PyYcZJJR0f8c7VceQMLzUfnvj3belNbCJJNmVdXfdXo,26610
 agentle/agents/apis/api_key_authentication.py,sha256=MtMA4qkCjM3ou42a1fDgKI4u3NQkB_Zr-gEA5_oysZ0,1311
 agentle/agents/apis/api_key_location.py,sha256=0pj_8rTkd0pkUJ2eP_Kur3AvT3JD8JpFIxQsWDzeg_c,188
 agentle/agents/apis/api_metrics.py,sha256=SyvJdvEMKp7rGij-tDZ6vxjwc26MIFrKrcckMc4Q1Zg,380
@@ -78,7 +78,7 @@ agentle/agents/apis/cache_strategy.py,sha256=uoAvmUm1EE8426anuLR4PoygLgO4SPN1Qm_
 agentle/agents/apis/circuit_breaker.py,sha256=9yopLPoZ6WMlPMWPoacayORoGN1CZq2EGWB0gCu3GOY,2371
 agentle/agents/apis/circuit_breaker_error.py,sha256=I5XyCWwFCXTDzhvS7CpMZwBRxMyCk96g7MfBLBqAvhg,127
 agentle/agents/apis/circuit_breaker_state.py,sha256=6IwcWWKNmE0cnpogcfsnhpy_EVIk7crQ7WiDN9YkkbE,277
-agentle/agents/apis/endpoint.py,sha256=CIcGzzQmvT1WVgpmFgUOvrF5DTQ4r0V0oOE6NPST6nc,22147
+agentle/agents/apis/endpoint.py,sha256=4skIMje2oEbc6ONb-Ww66wh8VGP5tj1JZACE3p7U62E,22600
 agentle/agents/apis/endpoint_parameter.py,sha256=A_SVje6AyNeeJNDxWL__uGc4ZNZ2se6GvawS--kUYEU,20230
 agentle/agents/apis/endpoints_to_tools.py,sha256=5KzxRLjfUYx7MGKHe65NMPHyTKOcd8tdK0uYzfGnO5g,999
 agentle/agents/apis/file_upload.py,sha256=PzJ1197EKLCdBHrLDztgifM3WWFQZ8K2CKkTeeYpJas,587
@@ -1003,7 +1003,7 @@ agentle/voice_cloning/voice_cloner.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 agentle/web/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentle/web/extraction_preferences.py,sha256=Xb4X6ZgnbDuu4Pp7cI0sdPcv6LaR1Q94FPTNEoHVTGg,985
 agentle/web/extraction_result.py,sha256=IsbRdT_wA9RVYGToCiz17XRoWMTtiFzxky96Zwqa4ZY,318
-agentle/web/extractor.py,sha256=x3KlbJkKSnTaUD9vAx3n2jev-PKgcAlnGJxBPOdwFoM,10997
+agentle/web/extractor.py,sha256=ISNYVoofry47HtB0oDhmb2Eof15ZhTL-qdyes1mYSbQ,15585
 agentle/web/location.py,sha256=RZgqb2rW7wUdcbw3PnmDtfr4FkTSSovW0j70ZOvoRiw,64
 agentle/web/actions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentle/web/actions/action.py,sha256=krxW5vXaqB1_JfnPpuo5cVJyANrlElu9P0B0TrF_aZs,723
@@ -1017,7 +1017,7 @@ agentle/web/actions/scroll.py,sha256=WqVVAORNDK3BL1oASZBPmXJYeSVkPgAOmWA8ibYO82I
 agentle/web/actions/viewport.py,sha256=KCwm88Pri19Qc6GLHC69HsRxmdJz1gEEAODfggC_fHo,287
 agentle/web/actions/wait.py,sha256=IKEywjf-KC4ni9Gkkv4wgc7bY-hk7HwD4F-OFWlyf2w,571
 agentle/web/actions/write_text.py,sha256=9mxfHcpKs_L7BsDnJvOYHQwG8M0GWe61SRJAsKk3xQ8,748
-agentle-0.9.25.dist-info/METADATA,sha256=FQFBCmIzX4o197z2k9UyswQwuTBJOuAfRqEQelGDtwo,86849
-agentle-0.9.25.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-agentle-0.9.25.dist-info/licenses/LICENSE,sha256=T90S9vqRS6qP-voULxAcvwEs558wRRo6dHuZrjgcOUI,1085
-agentle-0.9.25.dist-info/RECORD,,
+agentle-0.9.26.dist-info/METADATA,sha256=ZCnSN_aDQlrUPevRNIgjpDU64lRUcusv_5bx3ZcDFP0,86849
+agentle-0.9.26.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+agentle-0.9.26.dist-info/licenses/LICENSE,sha256=T90S9vqRS6qP-voULxAcvwEs558wRRo6dHuZrjgcOUI,1085
+agentle-0.9.26.dist-info/RECORD,,