agentle 0.9.35__py3-none-any.whl → 0.9.37__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

@@ -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.
-
-        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
-
-        # 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
+    def _create_whatsapp_renderer(self) -> mistune.HTMLRenderer:
+        """Create a mistune renderer for WhatsApp formatting."""
 
-            # If we're in a code block, don't process the line
-            if in_code_block:
-                processed_lines.append(line)
-                i += 1
-                continue
+        class WhatsAppRenderer(mistune.HTMLRenderer):
+            """Custom renderer for WhatsApp markdown format."""
 
-            # 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 text(self, text: str) -> str:
+                """Render plain text."""
+                return text
 
-    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("|")
+        return WhatsAppRenderer()
 
-    def _format_table(self, table_lines: list[str]) -> list[str]:
-        """Convert a markdown table to WhatsApp-friendly vertical list format.
-
-        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,
@@ -3639,6 +3593,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 +3620,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/generations/providers/openrouter/_adapters/agentle_message_to_openrouter_message_adapter.py

@@ -29,14 +29,17 @@ from agentle.generations.providers.openrouter._types import (
     OpenRouterMessage,
     OpenRouterSystemMessage,
     OpenRouterToolCall,
+    OpenRouterToolMessage,
     OpenRouterUserMessage,
 )
+from agentle.generations.tools.tool_execution_result import ToolExecutionResult
+import json
 
 
 class AgentleMessageToOpenRouterMessageAdapter(
     Adapter[
         AssistantMessage | DeveloperMessage | UserMessage,
-        OpenRouterMessage,
+        OpenRouterMessage | list[OpenRouterMessage],
     ]
 ):
     """
@@ -44,15 +47,18 @@ class AgentleMessageToOpenRouterMessageAdapter(
 
     Handles conversion of:
     - DeveloperMessage -> OpenRouterSystemMessage
-    - UserMessage -> OpenRouterUserMessage
+    - UserMessage -> OpenRouterUserMessage (or OpenRouterToolMessage if contains tool results)
     - AssistantMessage -> OpenRouterAssistantMessage (with tool calls)
+
+    Note: When a message contains ToolExecutionResult parts, they are extracted
+    and returned as separate OpenRouterToolMessage objects.
     """
 
     @override
     def adapt(
         self,
         _f: AssistantMessage | DeveloperMessage | UserMessage,
-    ) -> OpenRouterMessage:
+    ) -> OpenRouterMessage | list[OpenRouterMessage]:
         """
         Convert an Agentle message to OpenRouter format.
 
@@ -60,7 +66,9 @@ class AgentleMessageToOpenRouterMessageAdapter(
             _f: The Agentle message to convert.
 
         Returns:
-            The corresponding OpenRouter message.
+            The corresponding OpenRouter message(s). Returns a list when the message
+            contains ToolExecutionResult parts that need to be split into separate
+            tool messages.
         """
         message = _f
         part_adapter = AgentlePartToOpenRouterPartAdapter()
@@ -76,12 +84,28 @@ class AgentleMessageToOpenRouterMessageAdapter(
                 )
 
             case UserMessage():
+                # Check if this message contains tool execution results
+                tool_results = [
+                    p for p in message.parts if isinstance(p, ToolExecutionResult)
+                ]
+
+                if tool_results:
+                    # Convert each tool result to a separate tool message
+                    return [
+                        OpenRouterToolMessage(
+                            role="tool",
+                            tool_call_id=result.suggestion.id,
+                            content=self._serialize_tool_result(result.result),
+                        )
+                        for result in tool_results
+                    ]
+
                 # User messages can have multimodal content
-                # Filter out non-content parts (like tool execution suggestions)
+                # Filter out non-content parts (like tool execution suggestions and results)
                 content_parts = [
                     p
                     for p in message.parts
-                    if not isinstance(p, ToolExecutionSuggestion)
+                    if not isinstance(p, (ToolExecutionSuggestion, ToolExecutionResult))
                 ]
 
                 # If only text parts, concatenate into a string
@@ -102,6 +126,69 @@ class AgentleMessageToOpenRouterMessageAdapter(
                 )
 
             case AssistantMessage():
+                # Check if this message contains tool execution results
+                tool_results = [
+                    p for p in message.parts if isinstance(p, ToolExecutionResult)
+                ]
+
+                if tool_results:
+                    # If assistant message has tool results, we need to split it
+                    # First, create the assistant message with tool calls (if any)
+                    messages: list[OpenRouterMessage] = []
+
+                    # Separate text content from tool calls
+                    text_parts = [p for p in message.parts if isinstance(p, TextPart)]
+                    tool_suggestions = [
+                        p
+                        for p in message.parts
+                        if isinstance(p, ToolExecutionSuggestion)
+                    ]
+
+                    # Only create assistant message if there's content or tool calls
+                    if text_parts or tool_suggestions:
+                        content = (
+                            "".join(str(p) for p in text_parts) if text_parts else None
+                        )
+
+                        tool_calls: list[OpenRouterToolCall] = [
+                            OpenRouterToolCall(
+                                id=suggestion.id,
+                                type="function",
+                                function={
+                                    "name": suggestion.tool_name,
+                                    "arguments": self._serialize_tool_arguments(
+                                        suggestion.args
+                                    ),
+                                },
+                            )
+                            for suggestion in tool_suggestions
+                        ]
+
+                        assistant_msg = OpenRouterAssistantMessage(
+                            role="assistant",
+                            content=content,
+                        )
+
+                        if tool_calls:
+                            assistant_msg["tool_calls"] = tool_calls
+
+                        if hasattr(message, "reasoning") and message.reasoning:
+                            assistant_msg["reasoning"] = message.reasoning
+
+                        messages.append(assistant_msg)
+
+                    # Add tool result messages
+                    for result in tool_results:
+                        messages.append(
+                            OpenRouterToolMessage(
+                                role="tool",
+                                tool_call_id=result.suggestion.id,
+                                content=self._serialize_tool_result(result.result),
+                            )
+                        )
+
+                    return messages
+
                 # Separate text content from tool calls
                 text_parts = [p for p in message.parts if isinstance(p, TextPart)]
                 tool_suggestions = [
@@ -118,7 +205,9 @@ class AgentleMessageToOpenRouterMessageAdapter(
                         type="function",
                         function={
                             "name": suggestion.tool_name,
-                            "arguments": str(suggestion.args),  # Should be JSON string
+                            "arguments": self._serialize_tool_arguments(
+                                suggestion.args
+                            ),
                         },
                     )
                     for suggestion in tool_suggestions
@@ -137,3 +226,34 @@ class AgentleMessageToOpenRouterMessageAdapter(
                     result["reasoning"] = message.reasoning
 
                 return result
+
+    def _serialize_tool_arguments(self, args: object) -> str:
+        """
+        Serialize tool arguments to JSON string.
+
+        Args:
+            args: The arguments to serialize.
+
+        Returns:
+            JSON string representation of the arguments.
+        """
+        if isinstance(args, str):
+            return args
+        return json.dumps(args)
+
+    def _serialize_tool_result(self, result: object) -> str:
+        """
+        Serialize tool execution result to string.
+
+        Args:
+            result: The result to serialize.
+
+        returns:
+            String representation of the result.
+        """
+        if isinstance(result, str):
+            return result
+        try:
+            return json.dumps(result)
+        except (TypeError, ValueError):
+            return str(result)

agentle/generations/providers/openrouter/openrouter_generation_provider.py

@@ -71,6 +71,7 @@ from agentle.generations.providers.openrouter._types import (
     OpenRouterFileParserPlugin,
     OpenRouterModelsResponse,
     OpenRouterModel,
+    OpenRouterMessage,
 )
 from agentle.generations.providers.openrouter.error_handler import (
     parse_and_raise_openrouter_error,
@@ -1247,10 +1248,14 @@ class OpenRouterGenerationProvider(GenerationProvider):
                     ),
                 )
 
-        # Convert messages
-        openrouter_messages = [
-            self.message_adapter.adapt(message) for message in messages_list
-        ]
+        # Convert messages - adapter may return single message or list of messages
+        openrouter_messages: list[OpenRouterMessage] = []
+        for message in messages_list:
+            adapted = self.message_adapter.adapt(message)
+            if isinstance(adapted, list):
+                openrouter_messages.extend(adapted)
+            else:
+                openrouter_messages.append(adapted)
 
         # Convert tools if provided
         openrouter_tools = (
@@ -1404,10 +1409,14 @@ class OpenRouterGenerationProvider(GenerationProvider):
         """
         _generation_config = self._normalize_generation_config(generation_config)
 
-        # Convert messages
-        openrouter_messages = [
-            self.message_adapter.adapt(message) for message in messages
-        ]
+        # Convert messages - adapter may return single message or list of messages
+        openrouter_messages: list[OpenRouterMessage] = []
+        for message in messages:
+            adapted = self.message_adapter.adapt(message)
+            if isinstance(adapted, list):
+                openrouter_messages.extend(adapted)
+            else:
+                openrouter_messages.append(adapted)
 
         # Convert tools if provided
         openrouter_tools = (

{agentle-0.9.35.dist-info → agentle-0.9.37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentle
-Version: 0.9.35
+Version: 0.9.37
 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.35.dist-info → agentle-0.9.37.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=_SL-fsEmfPBQKRSV8e3aH1d9bl5Lj84pEYnLmNne06E,165252
 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=f7wOgKIaMdq8cLe0HVJS0T9NK9eNqe-gUCBMP_eQfyg,4142
 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
@@ -355,9 +355,9 @@ agentle/generations/providers/openrouter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5
 agentle/generations/providers/openrouter/_types.py,sha256=VSAf1auxopTqhYwLHPWl_Q0-okWUfLKJa0JmWlAFuGg,10557
 agentle/generations/providers/openrouter/error_handler.py,sha256=4qm8v_cjdrB-59UXyCJLnIkOxzIfmsltZY8Q137-8Qg,8075
 agentle/generations/providers/openrouter/exceptions.py,sha256=o3_-tuyhewc0v5L2cAXH0f9ixHyyDgZbHq0KX5cUyPE,23179
-agentle/generations/providers/openrouter/openrouter_generation_provider.py,sha256=c2fQMdm-xFzIR2Z3ClAXiu6BzKfrnQQTpzX2jJQSNlI,66596
+agentle/generations/providers/openrouter/openrouter_generation_provider.py,sha256=XhXU_Ix10jmWl2SzRUHwsVSPRIWq6zHnia7IMaY6Yy4,67129
 agentle/generations/providers/openrouter/_adapters/__init__.py,sha256=orgZeEBqH4X_cpyOMiClvfZHY5cLwLNqhAYLqNjGIH4,1826
-agentle/generations/providers/openrouter/_adapters/agentle_message_to_openrouter_message_adapter.py,sha256=xqLumYTs__1UHD1_WwvHsHhzpEUKOAwMAj4pvo4BWMU,4957
+agentle/generations/providers/openrouter/_adapters/agentle_message_to_openrouter_message_adapter.py,sha256=IvaovVP0ChYEreysiDyqF8SXdXxnD_Y9MjA2raEoncw,9790
 agentle/generations/providers/openrouter/_adapters/agentle_part_to_openrouter_part_adapter.py,sha256=eIfwQQ9BokHy3FQ90GJ4i_J3L46XCiSBd1RWnzu-gAo,5967
 agentle/generations/providers/openrouter/_adapters/agentle_tool_to_openrouter_tool_adapter.py,sha256=41i3B6awaTNZsdQ46Oi1e10cuNhQqWL-KBJ5V_sHkiI,9547
 agentle/generations/providers/openrouter/_adapters/openrouter_message_to_generated_assistant_message_adapter.py,sha256=uB4TYc0fuwsoYdRnEnLhbwQISyaZ2Z2RWkPFGQXUc80,5295
@@ -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.35.dist-info/METADATA,sha256=x56kvGN-I-GmLRyrLOcTFTdrVFgpI4KV6tKbFRr_2Gc,86849
-agentle-0.9.35.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-agentle-0.9.35.dist-info/licenses/LICENSE,sha256=T90S9vqRS6qP-voULxAcvwEs558wRRo6dHuZrjgcOUI,1085
-agentle-0.9.35.dist-info/RECORD,,
+agentle-0.9.37.dist-info/METADATA,sha256=ExGCJbs2vKKmRLF8LSq-9K5Xty2ggfXYhqnUJxNollM,86879
+agentle-0.9.37.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+agentle-0.9.37.dist-info/licenses/LICENSE,sha256=T90S9vqRS6qP-voULxAcvwEs558wRRo6dHuZrjgcOUI,1085
+agentle-0.9.37.dist-info/RECORD,,