agentle 0.9.36__py3-none-any.whl → 0.9.38__py3-none-any.whl

agentle/agents/apis/request_hook.py

@@ -6,7 +6,6 @@ from collections.abc import Callable
 from typing import Any
 
 from rsb.models.base_model import BaseModel
-from rsb.models.field import Field
 
 
 class RequestHook(BaseModel):

agentle/agents/whatsapp/models/audio_message.py

@@ -21,9 +21,10 @@ class AudioMessage(BaseModel):
         mediaKeyTimestamp: Timestamp da chave de mídia
         streamingSidecar: Dados para streaming do áudio (opcional)
         waveform: Forma de onda do áudio em base64 (opcional)
+        base64_data: Dados do áudio em base64 (quando não há URL disponível)
     """
 
-    url: str
+    url: str | None = Field(default=None)
     mimetype: str | None = Field(default=None)
     fileSha256: str | dict[str, Any] | None = Field(default=None)
     fileLength: str | dict[str, Any] | None = Field(default=None)
@@ -35,6 +36,7 @@ class AudioMessage(BaseModel):
     mediaKeyTimestamp: str | dict[str, Any] | None = Field(default=None)
     streamingSidecar: str | dict[str, Any] | None = Field(default=None)
     waveform: str | dict[str, Any] | None = Field(default=None)
+    base64_data: str | None = Field(default=None)
 
     @field_validator(
         "fileLength",
@@ -68,6 +70,8 @@ class AudioMessage(BaseModel):
         """Converte objetos Buffer/Bytes do protobuf para string."""
         if v is None:
             return None
-        if isinstance(v, dict) and all(k.isdigit() for k in v.keys()):
-            return str(v)
-        return str(v) if not isinstance(v, str) else v
+        if isinstance(v, dict):
+            keys = [str(k) for k in v.keys()]  # pyright: ignore[reportUnknownArgumentType]
+            if all(k.isdigit() for k in keys):
+                return str(dict(v))  # pyright: ignore[reportUnknownArgumentType]
+        return str(v) if not isinstance(v, str) else v  # pyright: ignore[reportUnknownArgumentType]

agentle/agents/whatsapp/models/document_message.py

@@ -46,11 +46,11 @@ class DocumentMessage(BaseModel):
         if v is None:
             return None
         if isinstance(v, dict) and "low" in v:
-            low = v.get("low", 0)
-            high = v.get("high", 0)
-            value = (high << 32) | low
+            low: int = int(v.get("low", 0))  # type: ignore[arg-type]
+            high: int = int(v.get("high", 0))  # type: ignore[arg-type]
+            value: int = (high << 32) | low
             return str(value)
-        return str(v)
+        return str(v)  # type: ignore[return-value]
 
     @field_validator(
         "fileSha256",
@@ -63,6 +63,8 @@ class DocumentMessage(BaseModel):
         """Converte objetos Buffer/Bytes do protobuf para string."""
         if v is None:
             return None
-        if isinstance(v, dict) and all(k.isdigit() for k in v.keys()):
-            return str(v)
-        return str(v) if not isinstance(v, str) else v
+        if isinstance(v, dict):
+            keys = list(v.keys())  # type: ignore[var-annotated]
+            if all(str(k).isdigit() for k in keys):  # type: ignore[arg-type]
+                return str(v)  # type: ignore[return-value]
+        return str(v) if not isinstance(v, str) else v  # type: ignore[return-value]

agentle/agents/whatsapp/models/image_message.py

@@ -28,7 +28,7 @@ class ImageMessage(BaseModel):
         midQualityFileSha256: Hash SHA256 da versão de qualidade média (opcional)
     """
 
-    url: str
+    url: str | None = Field(default=None)
     mimetype: str | None = Field(default=None)
     caption: str | None = Field(default=None)
     fileSha256: str | dict[str, Any] | None = Field(default=None)
@@ -63,11 +63,11 @@ class ImageMessage(BaseModel):
             return None
         if isinstance(v, dict) and "low" in v:
             # Converte Long para número inteiro
-            low = v.get("low", 0)
-            high = v.get("high", 0)
-            value = (high << 32) | low
+            low: int = int(v.get("low", 0))  # type: ignore[arg-type]
+            high: int = int(v.get("high", 0))  # type: ignore[arg-type]
+            value: int = (high << 32) | low
             return str(value)
-        return str(v)
+        return str(v)  # type: ignore[return-value]
 
     @field_validator(
         "fileSha256",
@@ -88,8 +88,10 @@ class ImageMessage(BaseModel):
         """
         if v is None:
             return None
-        if isinstance(v, dict) and all(k.isdigit() for k in v.keys()):
-            # Converte dicionário de bytes para string base64 ou hex
-            # Por enquanto, apenas retorna uma representação string
-            return str(v)
-        return str(v) if not isinstance(v, str) else v
+        if isinstance(v, dict):
+            keys = list(v.keys())  # type: ignore[var-annotated]
+            if all(str(k).isdigit() for k in keys):  # type: ignore[arg-type]
+                # Converte dicionário de bytes para string base64 ou hex
+                # Por enquanto, apenas retorna uma representação string
+                return str(v)  # type: ignore[return-value]
+        return str(v) if not isinstance(v, str) else v  # type: ignore[return-value]

agentle/agents/whatsapp/models/video_message.py

@@ -58,11 +58,11 @@ class VideoMessage(BaseModel):
         if v is None:
             return None
         if isinstance(v, dict) and "low" in v:
-            low = v.get("low", 0)
-            high = v.get("high", 0)
-            value = (high << 32) | low
+            low: int = int(v.get("low", 0))  # type: ignore[arg-type]
+            high: int = int(v.get("high", 0))  # type: ignore[arg-type]
+            value: int = (high << 32) | low
             return str(value)
-        return str(v)
+        return str(v)  # type: ignore[return-value]
 
     @field_validator(
         "fileSha256",
@@ -79,6 +79,8 @@ class VideoMessage(BaseModel):
         """Converte objetos Buffer/Bytes do protobuf para string."""
         if v is None:
             return None
-        if isinstance(v, dict) and all(k.isdigit() for k in v.keys()):
-            return str(v)
-        return str(v) if not isinstance(v, str) else v
+        if isinstance(v, dict):
+            keys = list(v.keys())  # type: ignore[var-annotated]
+            if all(str(k).isdigit() for k in keys):  # type: ignore[arg-type]
+                return str(v)  # type: ignore[return-value]
+        return str(v) if not isinstance(v, str) else v  # type: ignore[return-value]

agentle/agents/whatsapp/models/whatsapp_media_message.py

@@ -9,3 +9,4 @@ class WhatsAppMediaMessage(WhatsAppMessage):
     media_size: int | None = None
     caption: str | None = None
     filename: str | None = None
+    base64_data: str | None = None  # Para quando a mídia vem em base64 ao invés de URL

agentle/agents/whatsapp/models/whatsapp_webhook_payload.py

@@ -83,8 +83,12 @@ class WhatsAppWebhookPayload(BaseModel):
 
         key = self.data.key
         if "@lid" in key.remoteJid:
-            self.phone_number_id = key.remoteJidAlt.split("@")[0]
-            self.data.key.remoteJid = key.remoteJidAlt
+            remote_jid_alt = key.remoteJidAlt
+            if remote_jid_alt is None:
+                raise ValueError("No remotejidalt was provided.")
+
+            self.phone_number_id = remote_jid_alt.split("@")[0]
+            self.data.key.remoteJid = remote_jid_alt
             return
 
         self.phone_number_id = key.remoteJid.split("@")[0]

agentle/agents/whatsapp/whatsapp_bot.py

@@ -15,6 +15,8 @@ from datetime import datetime
 from typing import TYPE_CHECKING, Any, Optional, cast
 from dataclasses import dataclass, field
 
+import mistune
+
 from rsb.coroutines.run_sync import run_sync
 from rsb.models.base_model import BaseModel
 from rsb.models.config_dict import ConfigDict
@@ -1652,6 +1654,9 @@ class WhatsAppBot[T_Schema: WhatsAppResponseBase = WhatsAppResponseBase](BaseMod
                     "media_mime_type": message.media_mime_type,
                     "caption": message.caption,
                     "filename": getattr(message, "filename", None),
+                    "base64_data": getattr(
+                        message, "base64_data", None
+                    ),  # Include base64 if available
                 }
             )
 
@@ -1706,16 +1711,36 @@ class WhatsAppBot[T_Schema: WhatsAppResponseBase = WhatsAppResponseBase](BaseMod
                 "WhatsAppVideoMessage",
             ]:
                 try:
-                    logger.debug(
-                        f"[BATCH_CONVERSION] Downloading media for message {msg_data['id']}"
-                    )
-                    media_data = await self.provider.download_media(msg_data["id"])
-                    parts.append(
-                        FilePart(data=media_data.data, mime_type=media_data.mime_type)
-                    )
-                    logger.debug(
-                        f"[BATCH_CONVERSION] Successfully downloaded media for {msg_data['id']}"
-                    )
+                    # CRITICAL FIX: Check if media has base64 data already (for audio messages)
+                    # This avoids unnecessary download attempts when media is already available
+                    base64_data = msg_data.get("base64_data")
+                    if base64_data:
+                        logger.info(
+                            f"[BATCH_CONVERSION] 🎵 Using base64 data directly for message {msg_data['id']} (no download needed)"
+                        )
+                        import base64
+
+                        media_bytes = base64.b64decode(base64_data)
+                        mime_type = msg_data.get(
+                            "media_mime_type", "application/octet-stream"
+                        )
+                        parts.append(FilePart(data=media_bytes, mime_type=mime_type))
+                        logger.debug(
+                            f"[BATCH_CONVERSION] Successfully decoded base64 media for {msg_data['id']} ({len(media_bytes)} bytes)"
+                        )
+                    else:
+                        logger.debug(
+                            f"[BATCH_CONVERSION] Downloading media for message {msg_data['id']}"
+                        )
+                        media_data = await self.provider.download_media(msg_data["id"])
+                        parts.append(
+                            FilePart(
+                                data=media_data.data, mime_type=media_data.mime_type
+                            )
+                        )
+                        logger.debug(
+                            f"[BATCH_CONVERSION] Successfully downloaded media for {msg_data['id']}"
+                        )
 
                     # Add caption if present
                     caption = msg_data.get("caption")
@@ -1828,16 +1853,32 @@ class WhatsAppBot[T_Schema: WhatsAppResponseBase = WhatsAppResponseBase](BaseMod
         # Handle media messages
         elif isinstance(message, WhatsAppMediaMessage):
             try:
-                logger.debug(
-                    f"[SINGLE_CONVERSION] Downloading media for message {message.id}"
-                )
-                media_data = await self.provider.download_media(message.id)
-                parts.append(
-                    FilePart(data=media_data.data, mime_type=media_data.mime_type)
-                )
-                logger.debug(
-                    f"[SINGLE_CONVERSION] Successfully downloaded media for {message.id}"
-                )
+                # CRITICAL FIX: Check if media has base64 data already (for audio messages)
+                # This avoids unnecessary download attempts when media is already available
+                if message.base64_data:
+                    logger.info(
+                        f"[SINGLE_CONVERSION] 🎵 Using base64 data directly for message {message.id} (no download needed)"
+                    )
+                    import base64
+
+                    media_bytes = base64.b64decode(message.base64_data)
+                    parts.append(
+                        FilePart(data=media_bytes, mime_type=message.media_mime_type)
+                    )
+                    logger.debug(
+                        f"[SINGLE_CONVERSION] Successfully decoded base64 media for {message.id} ({len(media_bytes)} bytes)"
+                    )
+                else:
+                    logger.debug(
+                        f"[SINGLE_CONVERSION] Downloading media for message {message.id}"
+                    )
+                    media_data = await self.provider.download_media(message.id)
+                    parts.append(
+                        FilePart(data=media_data.data, mime_type=media_data.mime_type)
+                    )
+                    logger.debug(
+                        f"[SINGLE_CONVERSION] Successfully downloaded media for {message.id}"
+                    )
 
                 # Add caption if present
                 if message.caption:
@@ -2028,210 +2069,123 @@ class WhatsAppBot[T_Schema: WhatsAppResponseBase = WhatsAppResponseBase](BaseMod
 
         return text
 
-    def _format_whatsapp_markdown(self, text: str) -> str:
-        """Convert standard markdown to WhatsApp-compatible formatting.
+    def _create_whatsapp_renderer(self) -> mistune.HTMLRenderer:
+        """Create a mistune renderer for WhatsApp formatting."""
 
-        WhatsApp supports:
-        - *bold* for bold text
-        - _italic_ for italic text
-        - ~strikethrough~ for strikethrough text
-        - ```code``` for monospace text
-        - No support for headers, tables, or complex markdown structures
-
-        This method converts:
-        - Headers (# ## ###) to bold text with separators
-        - Tables to formatted text
-        - Markdown lists to plain text lists (preserving line breaks)
-        - Links to "text (url)" format
-        - Images to descriptive text
-        - Blockquotes to indented text
-        """
-        if not text:
-            return text
+        class WhatsAppRenderer(mistune.HTMLRenderer):
+            """Custom renderer for WhatsApp markdown format."""
 
-        # Split text into lines for processing
-        lines = text.split("\n")
-        processed_lines: list[str] = []
-        in_code_block = False
-        in_table = False
-        table_lines: list[str] = []
-
-        i = 0
-        while i < len(lines):
-            line = lines[i]
-
-            # Track code blocks (preserve them as-is)
-            if line.strip().startswith("```"):
-                in_code_block = not in_code_block
-                processed_lines.append(line)
-                i += 1
-                continue
-
-            # If we're in a code block, don't process the line
-            if in_code_block:
-                processed_lines.append(line)
-                i += 1
-                continue
-
-            # Detect table start (header line followed by separator line)
-            if i + 1 < len(lines) and self._is_table_separator(lines[i + 1]):
-                in_table = True
-                table_lines = [line]
-                i += 1
-                continue
-
-            # Continue collecting table rows
-            if in_table:
-                if self._is_table_row(line):
-                    table_lines.append(line)
-                    i += 1
-                    continue
+            def heading(self, text: str, level: int, **attrs: Any) -> str:
+                """Render headings as bold text with separators."""
+                if level == 1:
+                    return f"\n*{text}*\n{'═' * min(len(text), 30)}\n"
+                elif level == 2:
+                    return f"\n*{text}*\n{'─' * min(len(text), 30)}\n"
                 else:
-                    # End of table, process it
-                    processed_lines.extend(self._format_table(table_lines))
-                    in_table = False
-                    table_lines = []
-                    # Don't increment i, process current line
-
-            # Process headers
-            if line.strip().startswith("#"):
-                processed_lines.append(self._format_header(line))
-                i += 1
-                continue
+                    return f"\n*{text}*\n"
 
-            # Process blockquotes
-            if line.strip().startswith(">"):
-                processed_lines.append(self._format_blockquote(line))
-                i += 1
-                continue
+            def strong(self, text: str) -> str:
+                """Render bold as WhatsApp bold."""
+                return f"*{text}*"
 
-            # Process horizontal rules
-            if re.match(r"^[\s]*(-{3,}|\*{3,}|_{3,})[\s]*$", line):
-                processed_lines.append("─" * 30)
-                i += 1
-                continue
+            def emphasis(self, text: str) -> str:
+                """Render italic as WhatsApp italic."""
+                return f"_{text}_"
 
-            # Process regular line (preserve empty lines for spacing)
-            processed_lines.append(line)
-            i += 1
+            def strikethrough(self, text: str) -> str:
+                """Render strikethrough as WhatsApp strikethrough."""
+                return f"~{text}~"
 
-        # If we ended while in a table, process it
-        if table_lines:
-            processed_lines.extend(self._format_table(table_lines))
+            def codespan(self, text: str) -> str:
+                """Render inline code as WhatsApp monospace."""
+                return f"```{text}```"
 
-        # Rejoin lines - CRITICAL: preserve all line breaks
-        text = "\n".join(processed_lines)
+            def block_code(self, code: str, info: str | None = None) -> str:
+                """Render code blocks."""
+                return f"```{code}```\n"
 
-        # Handle inline markdown elements
+            def link(self, text: str, url: str, title: str | None = None) -> str:
+                """Render links as text (url)."""
+                return f"{text} ({url})"
 
-        # Handle images ![alt](url) -> [Image: alt]
-        text = re.sub(r"!\[([^\]]*)\]\([^\)]+\)", r"[Imagem: \1]", text)
+            def image(self, text: str, url: str, title: str | None = None) -> str:
+                """Render images as descriptive text."""
+                return f"[Imagem: {text}]" if text else "[Imagem]"
 
-        # Handle links [text](url) -> text (url)
-        text = re.sub(r"\[([^\]]+)\]\(([^\)]+)\)", r"\1 (\2)", text)
+            def block_quote(self, text: str) -> str:
+                """Render blockquotes with indentation."""
+                lines = text.strip().split("\n")
+                return "\n".join(f"  ┃ {line}" for line in lines) + "\n"
 
-        # Handle **bold** -> *bold* (WhatsApp format)
-        # Use negative lookbehind and lookahead to avoid matching within code blocks
-        text = re.sub(r"(?<!`)\*\*([^*`]+)\*\*(?!`)", r"*\1*", text)
+            def list(self, text: str, ordered: bool, **attrs: Any) -> str:
+                """Render lists."""
+                return f"\n{text}"
 
-        # Handle __italic__ -> _italic_
-        text = re.sub(r"(?<!`)__([^_`]+)__(?!`)", r"_\1_", text)
+            def list_item(self, text: str, **attrs: Any) -> str:
+                """Render list items."""
+                return f"{text}\n"
 
-        # Handle ~~strikethrough~~ -> ~strikethrough~
-        text = re.sub(r"(?<!`)~~([^~`]+)~~(?!`)", r"~\1~", text)
+            def paragraph(self, text: str) -> str:
+                """Render paragraphs."""
+                return f"{text}\n\n"
 
-        # Handle single backtick `code` -> ```code``` (WhatsApp monospace)
-        # But don't convert if already part of triple backticks
-        text = re.sub(r"(?<!`)(`(?!``)([^`]+)`)(?!`)", r"```\2```", text)
+            def thematic_break(self) -> str:
+                """Render horizontal rules."""
+                return "─" * 30 + "\n"
 
-        return text
+            def linebreak(self) -> str:
+                """Render line breaks."""
+                return "\n"
 
-    def _is_table_separator(self, line: str) -> bool:
-        """Check if a line is a markdown table separator (e.g., |---|---|)."""
-        stripped = line.strip()
-        if not stripped.startswith("|") or not stripped.endswith("|"):
-            return False
-        # Remove outer pipes and split
-        content = stripped[1:-1]
-        cells = content.split("|")
-        # Check if all cells are just dashes, colons, and spaces
-        for cell in cells:
-            cell = cell.strip()
-            if cell and not re.match(r"^:?-+:?$", cell):
-                return False
-        return True
-
-    def _is_table_row(self, line: str) -> bool:
-        """Check if a line is a table row."""
-        stripped = line.strip()
-        return stripped.startswith("|") and stripped.endswith("|")
+            def text(self, text: str) -> str:
+                """Render plain text."""
+                return text
 
-    def _format_table(self, table_lines: list[str]) -> list[str]:
-        """Convert a markdown table to WhatsApp-friendly vertical list format.
+        return WhatsAppRenderer()
 
-        Uses a consistent vertical format for all tables to ensure readability
-        on all screen sizes and prevent any horizontal overflow issues.
-        """
-        if not table_lines:
-            return []
+    def _format_whatsapp_markdown(self, text: str) -> str:
+        """Convert standard markdown to WhatsApp-compatible formatting using mistune.
 
-        # Parse table rows
-        rows: list[list[str]] = []
-        for line in table_lines:
-            if self._is_table_separator(line):
-                continue  # Skip separator line
-            # Remove outer pipes and split
-            stripped = line.strip()
-            if stripped.startswith("|"):
-                stripped = stripped[1:]
-            if stripped.endswith("|"):
-                stripped = stripped[:-1]
-            cells = [cell.strip() for cell in stripped.split("|")]
-            rows.append(cells)
-
-        if not rows:
-            return []
+        WhatsApp supports:
+        - *bold* for bold text
+        - _italic_ for italic text
+        - ~strikethrough~ for strikethrough text
+        - ```code``` for monospace text
+        - No support for headers, tables, or complex markdown structures
 
-        # Use vertical list format for all tables (mobile-friendly)
-        result: list[str] = []
-        result.append("")  # Empty line before table
-
-        headers = rows[0] if rows else []
-
-        for row_idx, row in enumerate(rows[1:], start=1):
-            result.append(f"*Item {row_idx}:*")
-            for header, value in zip(headers, row):
-                result.append(f"  • {header}: {value}")
-            if row_idx < len(rows) - 1:  # Add spacing between items
-                result.append("")
-
-        result.append("")  # Empty line after table
-        return result
-
-    def _format_header(self, line: str) -> str:
-        """Convert markdown header to bold text with decorations."""
-        match = re.match(r"^(#+)\s+(.+)$", line.strip())
-        if not match:
-            return line
-
-        level = len(match.group(1))
-        text = match.group(2).strip()
-
-        if level == 1:
-            # H1: Bold text with double line separator
-            return f"\n*{text.upper()}*\n{'═' * min(len(text), 30)}"
-        elif level == 2:
-            # H2: Bold text with single line separator
-            return f"\n*{text}*\n{'─' * min(len(text), 30)}"
-        else:
-            # H3+: Just bold text
-            return f"\n*{text}*"
+        This method converts:
+        - Headers (# ## ###) to bold text with separators
+        - Tables to formatted text
+        - Markdown lists to plain text lists (preserving line breaks)
+        - Links to "text (url)" format
+        - Images to descriptive text
+        - Blockquotes to indented text
+        """
+        if not text:
+            return text
 
-    def _format_blockquote(self, line: str) -> str:
-        """Format blockquote by removing > and adding indentation."""
-        # Remove leading > and optional space
-        text = re.sub(r"^>\s?", "", line.strip())
-        return f"  ┃ {text}"
+        # Use mistune for markdown parsing
+        try:
+            renderer = self._create_whatsapp_renderer()
+            markdown = mistune.create_markdown(
+                renderer=renderer, plugins=["strikethrough", "table"]
+            )
+            result = markdown(text)
+            # Ensure result is a string
+            if isinstance(result, str):
+                # Clean up extra newlines
+                result = re.sub(r"\n{3,}", "\n\n", result)
+                return result.strip()
+            else:
+                logger.warning(
+                    f"[MARKDOWN] Mistune returned non-string result: {type(result)}"
+                )
+                return text
+        except Exception as e:
+            logger.warning(
+                f"[MARKDOWN] Mistune conversion failed, returning original text: {e}"
+            )
+            return text
 
     async def _send_response(
         self,
@@ -3596,6 +3550,8 @@ class WhatsAppBot[T_Schema: WhatsAppResponseBase = WhatsAppResponseBase](BaseMod
                 elif msg_content.imageMessage:
                     logger.debug("[PARSE_EVOLUTION] Found image message")
                     image_msg = msg_content.imageMessage
+                    audio_base64 = msg_content.base64 if msg_content.base64 else None
+
                     return WhatsAppImageMessage(
                         id=message_id,
                         from_number=from_number,
@@ -3604,13 +3560,14 @@ class WhatsAppBot[T_Schema: WhatsAppResponseBase = WhatsAppResponseBase](BaseMod
                         timestamp=datetime.fromtimestamp(
                             (data.messageTimestamp or 0) / 1000
                         ),
-                        media_url=image_msg.url if image_msg else "",
+                        media_url=image_msg.url if image_msg.url else "",
                         media_mime_type=image_msg.mimetype
                         if image_msg and image_msg.mimetype
                         else "image/jpeg",
                         caption=image_msg.caption
                         if image_msg and image_msg.caption
                         else "",
+                        base64_data=audio_base64
                     )
 
                 # Handle document messages
@@ -3639,6 +3596,25 @@ class WhatsAppBot[T_Schema: WhatsAppResponseBase = WhatsAppResponseBase](BaseMod
                 elif msg_content.audioMessage:
                     logger.debug("[PARSE_EVOLUTION] Found audio message")
                     audio_msg = msg_content.audioMessage
+
+                    # CRITICAL FIX: Check if audio comes with base64 data instead of URL
+                    # This happens when WhatsApp sends audio directly in the webhook
+                    audio_url = audio_msg.url if audio_msg else ""
+                    audio_base64 = msg_content.base64 if msg_content.base64 else None
+
+                    if not audio_url and audio_base64:
+                        logger.info(
+                            "[PARSE_EVOLUTION] 🎵 Audio message has base64 data but no URL - using base64"
+                        )
+                    elif audio_url:
+                        logger.debug(
+                            f"[PARSE_EVOLUTION] Audio message has URL: {audio_url[:50]}..."
+                        )
+                    else:
+                        logger.warning(
+                            "[PARSE_EVOLUTION] ⚠️ Audio message has neither URL nor base64 data"
+                        )
+
                     return WhatsAppAudioMessage(
                         id=message_id,
                         from_number=from_number,
@@ -3647,10 +3623,11 @@ class WhatsAppBot[T_Schema: WhatsAppResponseBase = WhatsAppResponseBase](BaseMod
                         timestamp=datetime.fromtimestamp(
                             (data.messageTimestamp or 0) / 1000
                         ),
-                        media_url=audio_msg.url if audio_msg else "",
+                        media_url=audio_url or "",
                         media_mime_type=audio_msg.mimetype
                         if audio_msg and audio_msg.mimetype
                         else "audio/ogg",
+                        base64_data=audio_base64,  # Store base64 data if available
                     )
                 elif msg_content.videoMessage:
                     logger.debug("[PARSE_EVOLUTION] Found video message")

{agentle-0.9.36.dist-info → agentle-0.9.38.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentle
-Version: 0.9.36
+Version: 0.9.38
 Summary: ...
 Author-email: Arthur Brenno <64020210+arthurbrenno@users.noreply.github.com>
 License-File: LICENSE
@@ -16,6 +16,7 @@ Requires-Dist: html-to-markdown>=2.3.4
 Requires-Dist: langfuse>=3.8.1
 Requires-Dist: markitdown>=0.1.3
 Requires-Dist: mcp[cli]>=1.6.0
+Requires-Dist: mistune>=3.1.4
 Requires-Dist: orjson>=3.11.3
 Requires-Dist: pydantic>=2.11.3
 Requires-Dist: pypdf2>=3.0.1

{agentle-0.9.36.dist-info → agentle-0.9.38.dist-info}/RECORD

@@ -94,7 +94,7 @@ agentle/agents/apis/primitive_schema.py,sha256=fmDiMrXxtixORKIDvg8dx_h7w1AqPXpFO
 agentle/agents/apis/rate_limit_error.py,sha256=9ukRInSwf6PPEg5fPLm-eq4xfgYOExraOgGCRKzVbQk,116
 agentle/agents/apis/rate_limiter.py,sha256=EZ-39YMDNeotygdvxP3B735cJexSk0-20zO0pxaGKiU,1842
 agentle/agents/apis/request_config.py,sha256=vHKtoW9uxh2lTsuuZ38B2_EMcrLmOtUvVhL8VkOxjZY,4850
-agentle/agents/apis/request_hook.py,sha256=C9p6obF0myGkHoIScWuJTMp2RZlg3eEsbn80mDlE_sw,369
+agentle/agents/apis/request_hook.py,sha256=32ePmlS-Gwq3VcgogJHluBuBcunzZSUXv8E2inMnPiA,334
 agentle/agents/apis/response_cache.py,sha256=l-Ec_YVf1phhaTKWNdAORBDWZS3pXK_BBUHGP-oQkqQ,1617
 agentle/agents/apis/retry_strategy.py,sha256=_W8ZXXmA0kPFLJ0uwwV9ZycmSnj4dsicisFrbN8FtAU,219
 agentle/agents/apis/params/__init__.py,sha256=7aXlrfQTXpGT2GxuyugnFsF74l4AszSkFgxb0keyPRE,383
@@ -137,27 +137,27 @@ agentle/agents/ui/__init__.py,sha256=IjHRV0k2DNwvFrEHebmsXiBvmITE8nQUnsR07h9tVkU
 agentle/agents/ui/streamlit.py,sha256=9afICL0cxtG1o2pWh6vH39-NdKiVfADKiXo405F2aB0,42829
 agentle/agents/whatsapp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentle/agents/whatsapp/human_delay_calculator.py,sha256=BGCDeoNTPsMn4d_QYmG0BWGCG8SiUJC6Fk295ulAsAk,18268
-agentle/agents/whatsapp/whatsapp_bot.py,sha256=tF35s2c4G9Fo0bLVmePYXWSnSNEgg-Rpi9V0MrrRCCA,164948
+agentle/agents/whatsapp/whatsapp_bot.py,sha256=3ohpjdjeeX0MPxrcllLamT8lfi6y2UjSzFxYTeVLQ-o,165392
 agentle/agents/whatsapp/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-agentle/agents/whatsapp/models/audio_message.py,sha256=kUqG1HdNW6DCYD-CqscJ6WHlAyv9ufmTSKMdjio9XWk,2705
+agentle/agents/whatsapp/models/audio_message.py,sha256=af2apMWzxKcCtXfQN6U2qfOFoiwRj0nCUrKmrBD0whE,3067
 agentle/agents/whatsapp/models/context_info.py,sha256=sk80KuNE36S6VRnLh7n6UXmzZCXIB4E4lNxnRyVizg8,563
 agentle/agents/whatsapp/models/data.py,sha256=fcq4AUKtGP7R_pze5k_GXNjEsH6FC2QCfSSHo1d3jmg,1274
 agentle/agents/whatsapp/models/device_list_metadata.py,sha256=Nki7esmgi9Zq70L2t4yjJH77clvaljStchVGrXiDlbU,808
-agentle/agents/whatsapp/models/document_message.py,sha256=aZaJCp33GwP1fP5j2DVSWBSVQ4udoE0vj21mc3zjbWQ,2502
+agentle/agents/whatsapp/models/document_message.py,sha256=1sEzoAy7e5pnP05O5B0t3J-Q1q29Xk-tUr-JFjtJW60,2777
 agentle/agents/whatsapp/models/downloaded_media.py,sha256=TAZEX2oyXp4m4Dk8eRcgoaQCjDyUTN3E6BqkA4pIB9k,204
-agentle/agents/whatsapp/models/image_message.py,sha256=9inTFNzJq-VJbUaUNzeHfrI7l6Qx7gSM5ydNF0FuRLY,3859
+agentle/agents/whatsapp/models/image_message.py,sha256=Wf2-jyf_edXzQmpZr1I-DU236WZeSSvcpZyZry4WrkA,4171
 agentle/agents/whatsapp/models/key.py,sha256=1jlaI--WYxtQjt05Azjy0DCrSeHahvcKsr2NGOgxW9I,472
 agentle/agents/whatsapp/models/message.py,sha256=HqCqra8vOn3fig53SxnxPgtph20tBEjODlXTLiSErps,1446
 agentle/agents/whatsapp/models/message_context_info.py,sha256=msCSuu8uMN3G9GDaXdP6mefmOxSjeY-7iL-gN6Q9-i8,741
 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/video_message.py,sha256=0s4ak68euff25a_tXvYscKCFn7rQj8Rj6U89rupQnO0,3697
 agentle/agents/whatsapp/models/whatsapp_audio_message.py,sha256=AAcnjzJC1O5VjyWZaSWpG_tmZFc2-CdcPn9abjyLrpc,378
 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
 agentle/agents/whatsapp/models/whatsapp_location_message.py,sha256=CJCJR1DHjrN92OloNopvUteUxUxeEpHlWQSJhj6Ive4,407
-agentle/agents/whatsapp/models/whatsapp_media_message.py,sha256=-FY15vezGILzGMiUlO5irZl2jg3SZCawsE8PXm_9A0A,296
+agentle/agents/whatsapp/models/whatsapp_media_message.py,sha256=xmYE0SVdL7UIJuYRWJTfCoGAd5-pyXBnueaxFaECuXg,386
 agentle/agents/whatsapp/models/whatsapp_message.py,sha256=QtGAJKOF1ykZycsNDld25gk-JUeg3uV7hNXx0ZXO0Rg,1217
 agentle/agents/whatsapp/models/whatsapp_message_status.py,sha256=jDWShdvSve5EhkgtDkh1jZmpRVNoXCokv4M6at1eSIU,214
 agentle/agents/whatsapp/models/whatsapp_message_type.py,sha256=GctIGOC1Bc_D_L0ehEmEwgxePFx0ioTEUoBlZEdxdG8,279
@@ -165,7 +165,7 @@ agentle/agents/whatsapp/models/whatsapp_response_base.py,sha256=IIDONx9Ipt593tAZ
 agentle/agents/whatsapp/models/whatsapp_session.py,sha256=9G1HC-A2G9jTdpwYy3w9bnYkOGK2vvA7kdYAf32oWMU,15640
 agentle/agents/whatsapp/models/whatsapp_text_message.py,sha256=GpSwFrPC4qpQlVCWKKgYjQJKNv0qvwgYfuoD3ttLzdQ,441
 agentle/agents/whatsapp/models/whatsapp_video_message.py,sha256=-d-4hnkkxyLVNoje3a1pOEAvzWqoCLFcBn70wUpnyXY,346
-agentle/agents/whatsapp/models/whatsapp_webhook_payload.py,sha256=xL8p10ICuGjyplJ42K_YLqmMf0EoThI8YPJ8c7jrFyk,4122
+agentle/agents/whatsapp/models/whatsapp_webhook_payload.py,sha256=aY9pnUt4WJdvrRsXZIkmR8hP7oV9gdOJ1wJiYzFhU8w,4270
 agentle/agents/whatsapp/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentle/agents/whatsapp/providers/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentle/agents/whatsapp/providers/base/whatsapp_provider.py,sha256=Iaywrv0xer4fhZprMttC-NP4-rRYdU_45UzIZQ7dkYA,5349
@@ -1018,7 +1018,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.36.dist-info/METADATA,sha256=hSUSyQ9vk4kdTs91_EW7Yb1tEi41flD2JGVlqugY4YA,86849
-agentle-0.9.36.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-agentle-0.9.36.dist-info/licenses/LICENSE,sha256=T90S9vqRS6qP-voULxAcvwEs558wRRo6dHuZrjgcOUI,1085
-agentle-0.9.36.dist-info/RECORD,,
+agentle-0.9.38.dist-info/METADATA,sha256=NKHAE9t1G-BjMF1bAHOidMghnkTT0kuN42jjlwn4MwM,86879
+agentle-0.9.38.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+agentle-0.9.38.dist-info/licenses/LICENSE,sha256=T90S9vqRS6qP-voULxAcvwEs558wRRo6dHuZrjgcOUI,1085
+agentle-0.9.38.dist-info/RECORD,,