gateway/platforms/whatsapp_via_mcp_meta_business_api.py (4)

639-641: ⚖️ Poor tradeoff

Synchronous file write may block the event loop for large media.

path.write_bytes(data) is a blocking I/O operation. For large media files (videos up to 16MB per Meta docs), this could momentarily block the event loop. Consider using asyncio.to_thread() or aiofiles for non-blocking writes.

♻️ Proposed async file write

-        path = _media_cache_dir() / f"wa_{media_id}{ext}"
-        path.write_bytes(data)
-        return str(path)
+        path = _media_cache_dir() / f"wa_{media_id}{ext}"
+        await asyncio.to_thread(path.write_bytes, data)
+        return str(path)

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@gateway/platforms/whatsapp_via_mcp_meta_business_api.py` around lines 639 -
641, The path.write_bytes(data) call is a synchronous blocking I/O operation
that can block the event loop when handling large media files up to 16MB.
Convert this to a non-blocking operation by wrapping the write operation with
asyncio.to_thread() to offload the blocking I/O to a thread pool, or
alternatively use the aiofiles library for asynchronous file operations. Ensure
the function containing this write operation is marked as async and properly
awaits the non-blocking write call.

---

168-170: 💤 Low value

Port parsing may raise ValueError on invalid input.

If extra.get("port") or the environment variable contains a non-numeric string, int() will raise an unhandled ValueError, causing adapter initialization to fail with an unclear error.

🛡️ Proposed defensive parsing

-        self._port: int = int(
-            extra.get("port") or os.getenv("WHATSAPP_VIA_MCP_META_BUSINESS_API_PORT", "8643")
-        )
+        try:
+            self._port: int = int(
+                extra.get("port") or os.getenv("WHATSAPP_VIA_MCP_META_BUSINESS_API_PORT", "8643")
+            )
+        except ValueError:
+            self._port = 8643
+            logger.warning("Invalid port configured; falling back to default 8643")

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@gateway/platforms/whatsapp_via_mcp_meta_business_api.py` around lines 168 -
170, The port parsing in the initialization of self._port lacks error handling
and will raise an unhandled ValueError if extra.get("port") or the environment
variable contains non-numeric values. Wrap the int() conversion in a try-except
block to catch ValueError exceptions, and either use a sensible default port
value, raise a more descriptive error message, or log a warning when invalid
port input is detected. This will ensure the adapter initialization fails
gracefully with clear error messaging rather than an obscure ValueError.

---

421-421: 💤 Low value

Consider storing task reference for explicit lifecycle management.

The task returned by asyncio.create_task() is not stored. While running tasks are kept alive by the event loop, storing references enables graceful shutdown (awaiting pending tasks in disconnect()) and exception logging if a task fails silently.

♻️ Proposed pattern for task tracking

Add a task set to the class:

# In __init__:
self._pending_tasks: set[asyncio.Task] = set()

-        asyncio.create_task(self.handle_message(event))
+        task = asyncio.create_task(self.handle_message(event))
+        self._pending_tasks.add(task)
+        task.add_done_callback(self._pending_tasks.discard)

Optionally await pending tasks in disconnect():

if self._pending_tasks:
    await asyncio.gather(*self._pending_tasks, return_exceptions=True)

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@gateway/platforms/whatsapp_via_mcp_meta_business_api.py` at line 421, The
task created by asyncio.create_task(self.handle_message(event)) is not stored,
preventing graceful shutdown and exception handling. Add a _pending_tasks set
attribute in the class __init__ method, store the task reference returned by
asyncio.create_task() in this set, and ensure tasks are removed from the set
when they complete (using add_done_callback). Optionally, in the disconnect()
method, await any pending tasks in _pending_tasks with return_exceptions=True to
ensure clean shutdown before the connection closes.

---

510-512: 💤 Low value

Inconsistent error handling between _post_meta and _download_meta_media.

_post_meta uses assert self._http_client is not None (line 511), which raises AssertionError if the adapter isn't connected. In contrast, _download_meta_media raises RuntimeError (line 622). The assert can also be stripped in optimized bytecode (python -O). Consider using explicit checks consistently.

♻️ Proposed consistency fix

     async def _post_meta(self, payload: Dict[str, Any]) -> SendResult:
-        assert self._http_client is not None
+        if self._http_client is None:
+            return SendResult(success=False, error="adapter not connected")
         url = f"{self._meta_base_url}/{self._phone_number_id}/messages"

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@gateway/platforms/whatsapp_via_mcp_meta_business_api.py` around lines 510 -
512, Replace the assert statement in the `_post_meta` method that checks
`self._http_client is not None` with an explicit RuntimeError check to match the
error handling pattern used in `_download_meta_media`. This ensures consistent
error handling across both methods and avoids relying on assertions which can be
stripped when Python runs in optimized bytecode mode.

tests/gateway/test_whatsapp_via_mcp_role_router.py (1)

133-152: ⚡ Quick win

Async test relies on fixed sleep duration which may be flaky.

The test uses asyncio.sleep(0.02) to wait for the background task. On slow CI runners or under load, this might not be sufficient. Consider using a more robust synchronization mechanism.

♻️ Proposed fix using an Event for synchronization

 `@pytest.mark.asyncio`
 async def test_duplicate_webhook_skips_second_agent_run(monkeypatch):
     a = _adapter(ROLE_EXTRA)
     a._secret = ""  # disable secret check for the test

     calls = []
+    done_event = asyncio.Event()

     async def fake_handle(event):
         calls.append(event.message_id)
+        done_event.set()

     monkeypatch.setattr(a, "handle_message", fake_handle)
     body = json.dumps(
         {"message_id": "wamid.dup", "phone": "34600", "type": "text", "content": "hola"}
     ).encode()

     await a._handle_webhook(_FakeReq(body))
     await a._handle_webhook(_FakeReq(body))   # redelivery
-    await asyncio.sleep(0.02)                 # let the create_task run
+    await asyncio.wait_for(done_event.wait(), timeout=1.0)  # wait for task with timeout

     assert calls == ["wamid.dup"]             # second delivery deduped

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@tests/gateway/test_whatsapp_via_mcp_role_router.py` around lines 133 - 152,
The test `test_duplicate_webhook_skips_second_agent_run` uses a fixed
`asyncio.sleep(0.02)` duration to wait for background tasks, which is unreliable
and can be flaky on slow CI runners. Replace the sleep-based synchronization
with an asyncio.Event that signals when the background task completes. Create an
Event object before patching the `fake_handle` function, have `fake_handle` set
the Event after appending each call to the calls list, and then await the Event
with a reasonable timeout instead of using asyncio.sleep. This ensures the test
waits for actual task completion rather than an arbitrary duration.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes