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

agentle/web/extractor.py

@@ -1,11 +1,16 @@
-from rsb.coroutines.run_sync import run_sync
+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
+from rsb.models.config_dict import ConfigDict
+
 from agentle.generations.models.generation.generation import Generation
 from agentle.generations.providers.base.generation_provider import GenerationProvider
 from agentle.prompts.models.prompt import Prompt
@@ -16,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>
@@ -60,31 +69,30 @@ class Extractor(BaseModel):
     model: str | None = Field(default=None)
     max_output_tokens: int | None = Field(default=None)
 
-    def extract[T: BaseModel](
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    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 []
 
@@ -94,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()
 
-            page = await context.new_page()
+        for url in urls:
+            # Set timeout if specified
+            timeout = _preferences.timeout_ms if _preferences.timeout_ms else 30000
 
-            for url in urls:
-                # Set timeout if specified
-                timeout = _preferences.timeout_ms if _preferences.timeout_ms else 30000
+            try:
+                await page.goto(url, timeout=timeout)
 
-                try:
-                    await page.goto(url, timeout=timeout)
+                # Wait for specified time if configured
+                if _preferences.wait_for_ms:
+                    await page.wait_for_timeout(_preferences.wait_for_ms)
 
-                    # Wait for specified time if configured
-                    if _preferences.wait_for_ms:
-                        await page.wait_for_timeout(_preferences.wait_for_ms)
+                # Execute actions
+                for action in _actions:
+                    await action.execute(page)
 
-                    # Execute actions
-                    for action in _actions:
-                        await action.execute(page)
+            except Exception as e:
+                if ignore_invalid_urls:
+                    print(f"Warning: Failed to load {url}: {e}")
+                    continue
+                else:
+                    raise
 
-                except Exception as e:
-                    if ignore_invalid_urls:
-                        print(f"Warning: Failed to load {url}: {e}")
-                        continue
-                    else:
-                        raise
+        html = await page.content()
 
-            html = await page.content()
+        # 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
 
-            # Process HTML based on preferences
+            soup = BeautifulSoup(html, "html.parser")
+
+            # 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()
 
+        html, markdown = await self.extract_markdown_async(
+            browser=browser,
+            urls=urls,
+            extraction_preferences=_preferences,
+            ignore_invalid_urls=ignore_invalid_urls,
+        )
 
-if __name__ == "__main__":
+        # 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()
 
@@ -268,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
@@ -281,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.24.dist-info → agentle-0.9.26.dist-info}/METADATA

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

{agentle-0.9.24.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
@@ -136,9 +136,10 @@ agentle/agents/templates/data_collection/progressive_profilling_agent.py,sha256=
 agentle/agents/ui/__init__.py,sha256=IjHRV0k2DNwvFrEHebmsXiBvmITE8nQUnsR07h9tVkU,7
 agentle/agents/ui/streamlit.py,sha256=9afICL0cxtG1o2pWh6vH39-NdKiVfADKiXo405F2aB0,42829
 agentle/agents/whatsapp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-agentle/agents/whatsapp/whatsapp_bot.py,sha256=qaL-PDisEWQOKKf8TmbAnQlIxbnZo4Bq8hgyjFUy-g0,135345
+agentle/agents/whatsapp/human_delay_calculator.py,sha256=BGCDeoNTPsMn4d_QYmG0BWGCG8SiUJC6Fk295ulAsAk,18268
+agentle/agents/whatsapp/whatsapp_bot.py,sha256=D51UD2Wbi47RKgxUU8J7iWsxNMqV99Rzujz6TV1DjGw,160179
 agentle/agents/whatsapp/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-agentle/agents/whatsapp/models/audio_message.py,sha256=Cb4uYi4O4ANam8NGZkKVjwsrl8nCeuaHVwV9RvqvE8M,2656
+agentle/agents/whatsapp/models/audio_message.py,sha256=kUqG1HdNW6DCYD-CqscJ6WHlAyv9ufmTSKMdjio9XWk,2705
 agentle/agents/whatsapp/models/context_info.py,sha256=sk80KuNE36S6VRnLh7n6UXmzZCXIB4E4lNxnRyVizg8,563
 agentle/agents/whatsapp/models/data.py,sha256=iertlmc2zbzjuIdTubkO-4RuwB0ni1qx7UvvW7Dlhuo,1245
 agentle/agents/whatsapp/models/device_list_metadata.py,sha256=Nki7esmgi9Zq70L2t4yjJH77clvaljStchVGrXiDlbU,808
@@ -151,7 +152,7 @@ agentle/agents/whatsapp/models/message_context_info.py,sha256=msCSuu8uMN3G9GDaXd
 agentle/agents/whatsapp/models/quoted_message.py,sha256=QC4sp7eLPE9g9i-_f3avb0sDO7gKpkzZR2qkbxqptts,1073
 agentle/agents/whatsapp/models/video_message.py,sha256=-wujSwdYaE3tst7K_rUYCvx6v4lySTW1JZ5burF6slg,3422
 agentle/agents/whatsapp/models/whatsapp_audio_message.py,sha256=AAcnjzJC1O5VjyWZaSWpG_tmZFc2-CdcPn9abjyLrpc,378
-agentle/agents/whatsapp/models/whatsapp_bot_config.py,sha256=yLRGwu8pE5PVQmWH0VSjOoCteKfURKdyeNnPlYhniOs,20945
+agentle/agents/whatsapp/models/whatsapp_bot_config.py,sha256=hkbOAdSZbSt634mZEARuPQSer7wf3biL7dL9TFW-a7o,37164
 agentle/agents/whatsapp/models/whatsapp_contact.py,sha256=6iO6xmFs7z9hd1N9kZzGyNHYvCaUoCHn3Yi1DAJN4YU,240
 agentle/agents/whatsapp/models/whatsapp_document_message.py,sha256=ECM_hXF-3IbC9itbtZI0eA_XRNXFVefw9Mr-Lo_lrH0,323
 agentle/agents/whatsapp/models/whatsapp_image_message.py,sha256=xOAPRRSgqj9gQ2ZZOGdFWfOgtmNpE1W8mIUAmB5YTpo,314
@@ -177,6 +178,15 @@ agentle/agents/whatsapp/providers/twilio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5
 agentle/agents/whatsapp/providers/twilio/twilio_api_config.py,sha256=Xd9Ui5w3eAMfB12zJb_uQfzMFN5Gbx1Dgz7OIlUk0Yo,1580
 agentle/agents/whatsapp/providers/twilio/twilio_api_provider.py,sha256=7QbHEuQGozNVTf8xpxOR5RkYeA3om60nUlYbB4zmn5Y,29250
 agentle/agents/whatsapp/providers/twilio/twilio_webhook_parser.py,sha256=j9KCOZlbv9horcaFeQJ9fM9bGOr1YWsGqBWGuIhkFqY,10274
+agentle/agents/whatsapp/v2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentle/agents/whatsapp/v2/batch_processor_manager.py,sha256=2cwnFSstbfgIVdlHeMyf5qAr4fEQx_V7Jlt_4O5scWA,55
+agentle/agents/whatsapp/v2/bot_config.py,sha256=eRuDZgrb5EvnRUh8qWSOcyoWZfjOZ2dTEAWZtdHCYVc,7705
+agentle/agents/whatsapp/v2/in_memory_batch_processor_manager.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentle/agents/whatsapp/v2/message_limit.py,sha256=ea-ISLPNtm-jGsMLKF-gr0hQPDpB7HLqX7N5mh1WN28,199
+agentle/agents/whatsapp/v2/payload.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentle/agents/whatsapp/v2/whatsapp_bot.py,sha256=B6wrsv7oJswATxsjvwgBLJxCpFjpgf9crzuhcLmmz8g,413
+agentle/agents/whatsapp/v2/whatsapp_cloud_api_provider.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agentle/agents/whatsapp/v2/whatsapp_provider.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentle/autonomous_systems/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentle/autonomous_systems/agent.py,sha256=tGrYTD4Rs4hgCF4mfHhjgMLPM0rNQZ5JACU_kA2cXe8,5078
 agentle/autonomous_systems/agent_input_type.py,sha256=mnzELBiKwgj0EYYM4U8GE50XRkys3m6ds_VR7aS-SGA,201
@@ -993,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=HIqag1SEfWoQ97iwn2fYOfhEpjC4OJXnkn_WSAUsMs0,10889
+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
@@ -1007,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.24.dist-info/METADATA,sha256=AiMToA7H-QGVxwlLP3F5mPygDmgFdS0R0_KcSX83NHo,86849
-agentle-0.9.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-agentle-0.9.24.dist-info/licenses/LICENSE,sha256=T90S9vqRS6qP-voULxAcvwEs558wRRo6dHuZrjgcOUI,1085
-agentle-0.9.24.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,,