narada 0.2.2__tar.gz → 0.2.3__tar.gz

{narada-0.2.2 → narada-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: narada
-Version: 0.2.2
+Version: 0.2.3
 Summary: Python client SDK for Narada
 Project-URL: Homepage, https://github.com/NaradaAI/narada-python-sdk/narada
 Project-URL: Repository, https://github.com/NaradaAI/narada-python-sdk
@@ -9,7 +9,7 @@ Author-email: Narada <support@narada.ai>
 License-Expression: Apache-2.0
 Requires-Python: >=3.12
 Requires-Dist: aiohttp>=3.12.13
-Requires-Dist: narada-core==0.1.1
+Requires-Dist: narada-core==0.1.2
 Requires-Dist: packaging==24.2
 Requires-Dist: playwright>=1.53.0
 Requires-Dist: rich>=14.0.0

{narada-0.2.2 → narada-0.2.3}/pyproject.toml

@@ -1,13 +1,13 @@
 [project]
 name = "narada"
-version = "0.2.2"
+version = "0.2.3"
 description = "Python client SDK for Narada"
 license = "Apache-2.0"
 readme = "README.md"
 authors = [{ name = "Narada", email = "support@narada.ai" }]
 requires-python = ">=3.12"
 dependencies = [
-    "narada-core==0.1.1",
+    "narada-core==0.1.2",
     "aiohttp>=3.12.13",
     "playwright>=1.53.0",
     "rich>=14.0.0",

{narada-0.2.2 → narada-0.2.3}/src/narada/agent.py

@@ -28,9 +28,9 @@ from narada_core.actions.models import (
     GetUrlResponse,
     GoToUrlRequest,
     JsonValue,
-    PrintMessageRequest,
     PressKeyEventItem,
     PressKeyRequest,
+    PrintMessageRequest,
     PromptForUserInputRequest,
     PromptForUserInputResponse,
     PromptForUserInputVariable,
@@ -39,6 +39,8 @@ from narada_core.actions.models import (
     ReadGoogleSheetRequest,
     ReadGoogleSheetResponse,
     RecordedClick,
+    SavePdfFileRequest,
+    SavePdfFileResponse,
     UserApprovalRequest,
     UserApprovalResponse,
     WaitForElementRequest,
@@ -584,6 +586,14 @@ class Agent(Generic[_StructuredOutput]):
             timeout=timeout,
         )
 
+    async def save_pdf_file(self, *, timeout: int | None = None) -> SavePdfFileResponse:
+        """Saves the PDF file displayed in the current browser page."""
+        return await self._browser_environment()._run_extension_action(
+            SavePdfFileRequest(),
+            SavePdfFileResponse,
+            timeout=timeout,
+        )
+
     async def get_screenshot(
         self, *, timeout: int | None = None
     ) -> GetScreenshotResponse:

{narada-0.2.2 → narada-0.2.3}/src/narada/environment.py

@@ -6,6 +6,7 @@ import json
 import logging
 import mimetypes
 import os
+import random
 import subprocess
 import sys
 import time
@@ -1477,14 +1478,31 @@ class CloudBrowserEnvironment(BaseBrowserEnvironment):
 
     async def _initialize(self) -> None:
         """Create a cloud browser session and initialize the browser extension.
+        Retry up to 3 times on error.
 
         Calls ``POST /cloud-browser/create-cloud-browser-session``, then connects local
         Playwright over CDP, opens ``login_url``, and waits for
         ``#narada-browser-window-id`` (extension install retries apply). ``config`` controls
         interactive prompts and related behavior.
         """
-        await self._start_playwright()
+        max_attempts = 3
+        for attempt in range(max_attempts):
+            try:
+                await self._initialize_once()
+                return
+            except Exception as error:
+                await self._cleanup_failed_initialization_attempt()
+                if (
+                    attempt == max_attempts - 1
+                    or self._is_non_retryable_initialization_error(error)
+                ):
+                    raise
+
+                retry_backoff_with_jitter = 2 ** (attempt + 1) + random.uniform(0, 1)
+                await asyncio.sleep(retry_backoff_with_jitter)
 
+    async def _initialize_once(self) -> None:
+        await self._start_playwright()
         request_body = {
             "require_extension": True,
             "session_name": self._session_name,
@@ -1503,61 +1521,63 @@ class CloudBrowserEnvironment(BaseBrowserEnvironment):
             ) as resp:
                 if not resp.ok:
                     error_text = await resp.text()
-                    if resp.status == HTTPStatus.FORBIDDEN:
-                        error = ApiErrorPayload.from_error_text(error_text)
-                        err = RuntimeError(
-                            f"Failed to create cloud browser session: {resp.status} {error_text}\n"
-                            f"Endpoint URL: {endpoint_url}"
-                        )
-                        err.status_code = resp.status  # type: ignore[attr-defined]
-                        err.detail = error.detail  # type: ignore[attr-defined]
-                        raise err
-                    raise RuntimeError(
+                    err = RuntimeError(
                         f"Failed to create cloud browser session: {resp.status} {error_text}\n"
                         f"Endpoint URL: {endpoint_url}"
                     )
+                    err.status_code = resp.status  # type: ignore[attr-defined]
+                    if resp.status == HTTPStatus.FORBIDDEN:
+                        error = ApiErrorPayload.from_error_text(error_text)
+                        err.detail = error.detail  # type: ignore[attr-defined]
+                    raise err
                 response_data = await resp.json()
 
         cdp_websocket_url = response_data["cdp_websocket_url"]
         session_id = response_data["session_id"]
         login_url = response_data["login_url"]
         cdp_auth_headers = response_data["cdp_auth_headers"]
+        self._session_id = session_id
 
         # Connect to browser via CDP with authentication headers and log the user in.
-        try:
-            await self._initialize_cloud_browser_window(
-                cdp_websocket_url=cdp_websocket_url,
-                session_id=session_id,
-                login_url=login_url,
-                cdp_auth_headers=cdp_auth_headers,
-            )
-        except Exception:
-            # Clean up the session if CDP connection fails
+        await self._initialize_cloud_browser_window(
+            cdp_websocket_url=cdp_websocket_url,
+            session_id=session_id,
+            login_url=login_url,
+            cdp_auth_headers=cdp_auth_headers,
+        )
+
+    @staticmethod
+    def _is_non_retryable_initialization_error(error: Exception) -> bool:
+        status_code = getattr(error, "status_code", None)
+        return isinstance(status_code, int) and 400 <= status_code < 500
+
+    async def _cleanup_failed_initialization_attempt(self) -> None:
+        if self._session_id is not None:
             try:
-                async with aiohttp.ClientSession() as cleanup_session:
-                    async with cleanup_session.post(
-                        f"{self._base_url}/cloud-browser/stop-cloud-browser-session",
-                        headers=self._auth_headers,
-                        json={"session_id": session_id, "status": "failed"},
-                        timeout=aiohttp.ClientTimeout(total=10),
-                    ) as resp:
-                        if resp.ok:
-                            logging.info(
-                                "Cleaned up session %s after CDP connection failure",
-                                session_id,
-                            )
-                        else:
-                            logging.warning(
-                                "Failed to cleanup session %s: %s",
-                                session_id,
-                                resp.status,
-                            )
-            except Exception as cleanup_error:
-                logging.warning(
-                    "Error cleaning up session %s: %s", session_id, cleanup_error
+                await _stop_cloud_browser_session(
+                    base_url=self._base_url,
+                    auth_headers=self._auth_headers,
+                    session_id=self._session_id,
+                    status="failed",
+                    timeout=10,
                 )
-            # Re-raise the original connection error
-            raise
+            except Exception:
+                logger.exception(
+                    "Error cleaning up session %s (%s) after failed initialization",
+                    self._session_id,
+                    self._session_name,
+                )
+
+        try:
+            await self._stop_playwright()
+        except Exception:
+            logger.exception(
+                "Error stopping Playwright after failed cloud browser initialization"
+            )
+        finally:
+            self._session_id = None
+            self._browser_window_id = None
+            self._context = None
 
     async def _start_playwright(self) -> None:
         self._playwright_context_manager = async_playwright()
@@ -1874,6 +1894,7 @@ async def _stop_cloud_browser_session(
     base_url: str,
     auth_headers: dict[str, str],
     session_id: str,
+    status: Literal["complete", "terminated", "failed", "timed_out"] = "complete",
     timeout: int | None = None,
 ) -> None:
     try:
@@ -1881,7 +1902,7 @@ async def _stop_cloud_browser_session(
             async with session.post(
                 f"{base_url}/cloud-browser/stop-cloud-browser-session",
                 headers=auth_headers,
-                json={"session_id": session_id},
+                json={"session_id": session_id, "status": status},
                 timeout=aiohttp.ClientTimeout(total=timeout or 40),
             ) as resp:
                 if resp.ok:

{narada-0.2.2 → narada-0.2.3}/tests/test_window_human_interaction.py

@@ -140,3 +140,33 @@ async def test_execute_javascript_on_page_dispatches_extension_action(
         "name": "execute_javascript_on_page",
         "code": "(() => ({ title: document.title, count: 3 }))()",
     }
+
+
+@pytest.mark.asyncio
+async def test_save_pdf_file_dispatches_extension_action(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    fake_session = _FakeSession(
+        [
+            {
+                "status": "success",
+                "data": '{"base64_content":"JVBERi0xLjQ=","name":"invoice.pdf","mime_type":"application/pdf","timestamp":"2026-06-22T00:00:00.000Z"}',
+            }
+        ]
+    )
+    monkeypatch.setattr(
+        "narada.environment.aiohttp.ClientSession", lambda: fake_session
+    )
+    agent = Agent(
+        environment=RemoteBrowserEnvironment(
+            browser_window_id="bw-1", api_key="test-key"
+        )
+    )
+
+    result = await agent.save_pdf_file()
+
+    assert result.name == "invoice.pdf"
+    assert result.mime_type == "application/pdf"
+    assert result.base64_content == "JVBERi0xLjQ="
+    assert "base64_content" not in result.model_dump()
+    assert fake_session.post_bodies[0]["action"] == {"name": "save_pdf_file"}