narada 0.2.0__tar.gz → 0.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: narada
-Version: 0.2.0
+Version: 0.2.2
 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.0
+Requires-Dist: narada-core==0.1.1
 Requires-Dist: packaging==24.2
 Requires-Dist: playwright>=1.53.0
 Requires-Dist: rich>=14.0.0

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

@@ -1,13 +1,13 @@
 [project]
 name = "narada"
-version = "0.2.0"
+version = "0.2.2"
 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.0",
+    "narada-core==0.1.1",
     "aiohttp>=3.12.13",
     "playwright>=1.53.0",
     "rich>=14.0.0",

{narada-0.2.0 → narada-0.2.2}/src/narada/__init__.py

@@ -1,4 +1,8 @@
-from narada_core.actions.models import ActiveInputRequest, CriticResult
+from narada_core.actions.models import (
+    ActiveInputRequest,
+    CriticResult,
+    PressKeyEventItem,
+)
 from narada_core.errors import (
     NaradaError,
     NaradaExtensionMissingError,
@@ -52,6 +56,7 @@ __all__ = [
     "NaradaInitializationError",
     "NaradaTimeoutError",
     "NaradaUnsupportedBrowserError",
+    "PressKeyEventItem",
     "ProxyConfig",
     "ReasoningEffort",
     "RemoteBrowserEnvironment",

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

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import IO, Any, Generic, Literal, Mapping, TypeVar, overload
 
-from narada_core.actions.critic import run_critic
+from narada_core.actions.critic import merge_critic_workflow_trace, run_critic
 from narada_core.actions.models import (
     DEFAULT_HITL_TIMEOUT_SECONDS,
     AgenticMatchingSelectorsFinderRequest,
@@ -16,6 +16,8 @@ from narada_core.actions.models import (
     AgentResponse,
     AgentUsage,
     CriticResult,
+    ExecuteJavaScriptOnPageRequest,
+    ExecuteJavaScriptOnPageResponse,
     GetFullHtmlRequest,
     GetFullHtmlResponse,
     GetScreenshotRequest,
@@ -25,7 +27,10 @@ from narada_core.actions.models import (
     GetUrlRequest,
     GetUrlResponse,
     GoToUrlRequest,
+    JsonValue,
     PrintMessageRequest,
+    PressKeyEventItem,
+    PressKeyRequest,
     PromptForUserInputRequest,
     PromptForUserInputResponse,
     PromptForUserInputVariable,
@@ -195,6 +200,10 @@ class Agent(Generic[_StructuredOutput]):
                 time_zone=time_zone,
                 timeout=timeout,
             )
+            workflow_trace = merge_critic_workflow_trace(
+                workflow_trace=workflow_trace,
+                critic_result=critic_result,
+            )
 
         return AgentResponse(
             request_id=remote_dispatch_response["requestId"],
@@ -352,6 +361,27 @@ class Agent(Generic[_StructuredOutput]):
         )
         return result.selectors
 
+    async def press_key(
+        self,
+        *,
+        events: list[PressKeyEventItem | Mapping[str, Any]],
+        timeout: int | None = 60,
+    ) -> None:
+        """Dispatch keyboard events on the active tab through the extension."""
+        if not events:
+            raise ValueError("press_key requires a non-empty events= list")
+
+        normalized_events = [
+            event
+            if isinstance(event, PressKeyEventItem)
+            else PressKeyEventItem.model_validate(event)
+            for event in events
+        ]
+        return await self._browser_environment()._run_extension_action(
+            PressKeyRequest(events=normalized_events),
+            timeout=timeout,
+        )
+
     async def agentic_mouse_action(
         self,
         *,
@@ -410,6 +440,17 @@ class Agent(Generic[_StructuredOutput]):
             timeout=timeout,
         )
 
+    async def execute_javascript_on_page(
+        self, *, code: str, timeout: int | None = None
+    ) -> JsonValue:
+        """Executes JavaScript on the current active page and returns its JSON result."""
+        result = await self._browser_environment()._run_extension_action(
+            ExecuteJavaScriptOnPageRequest(code=code),
+            ExecuteJavaScriptOnPageResponse,
+            timeout=timeout,
+        )
+        return result.result
+
     async def print_message(self, *, message: str, timeout: int | None = None) -> None:
         """Prints a message in the Narada extension side panel chat."""
         return await self._browser_environment()._run_extension_action(

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

@@ -100,6 +100,16 @@ _INITIALIZATION_ERROR_INDICATOR_SELECTOR = "#narada-initialization-error"
 type InputRequiredCallback = Callable[[ActiveInputRequest], Awaitable[None] | None]
 
 
+def _load_execution_trace_context_from_env() -> dict[str, Any] | None:
+    raw = os.environ.get("NARADA_EXECUTION_TRACE_CONTEXT")
+    if not raw:
+        return None
+    value = json.loads(raw)
+    if not isinstance(value, dict):
+        raise ValueError("NARADA_EXECUTION_TRACE_CONTEXT must be a JSON object")
+    return value
+
+
 async def _notify_input_required_callback(
     callback: InputRequiredCallback | None,
     response: _RemoteDispatchPollResponse,
@@ -710,6 +720,9 @@ class Environment(ABC):
         browser_window_id = self._dispatch_browser_window_id
         if browser_window_id is not None:
             body["browserWindowId"] = browser_window_id
+        execution_trace_context = _load_execution_trace_context_from_env()
+        if execution_trace_context is not None:
+            body["executionTraceContext"] = execution_trace_context
         cloud_browser_session_id = self.cloud_browser_session_id
         if cloud_browser_session_id is not None:
             body["cloudBrowserSessionId"] = cloud_browser_session_id
@@ -843,8 +856,10 @@ class Environment(ABC):
             raise NaradaError(
                 f"{type(self).__name__} does not support browser extension actions"
             )
+        action_execution_id = f"action_{uuid4().hex}"
         body = {
             "action": request.model_dump(),
+            "actionExecutionId": action_execution_id,
             "browserWindowId": browser_window_id,
         }
         remote_dispatch_request_id = os.environ.get(_REMOTE_DISPATCH_REQUEST_ID_ENV_VAR)
@@ -955,8 +970,7 @@ class BrowserEnvironment(BaseBrowserEnvironment):
         )
 
     async def _initialize(self) -> None:
-        self._playwright_context_manager = async_playwright()
-        self._playwright = await self._playwright_context_manager.__aenter__()
+        await self._start_playwright()
         if self._attach_to_existing:
             await self._initialize_in_existing_browser_window()
         else:
@@ -982,6 +996,10 @@ class BrowserEnvironment(BaseBrowserEnvironment):
         finally:
             await self._stop_playwright()
 
+    async def _start_playwright(self) -> None:
+        self._playwright_context_manager = async_playwright()
+        self._playwright = await self._playwright_context_manager.__aenter__()
+
     async def _stop_playwright(self) -> None:
         if self._playwright_context_manager is None:
             return
@@ -1465,8 +1483,7 @@ class CloudBrowserEnvironment(BaseBrowserEnvironment):
         ``#narada-browser-window-id`` (extension install retries apply). ``config`` controls
         interactive prompts and related behavior.
         """
-        self._playwright_context_manager = async_playwright()
-        self._playwright = await self._playwright_context_manager.__aenter__()
+        await self._start_playwright()
 
         request_body = {
             "require_extension": True,
@@ -1542,6 +1559,10 @@ class CloudBrowserEnvironment(BaseBrowserEnvironment):
             # Re-raise the original connection error
             raise
 
+    async def _start_playwright(self) -> None:
+        self._playwright_context_manager = async_playwright()
+        self._playwright = await self._playwright_context_manager.__aenter__()
+
     async def _stop_playwright(self) -> None:
         if self._playwright_context_manager is None:
             return
@@ -1582,6 +1603,7 @@ class CloudBrowserEnvironment(BaseBrowserEnvironment):
         session_id: str,
         login_url: str,
         cdp_auth_headers: dict[str, str],
+        expected_browser_window_id: str | None = None,
     ) -> None:
         assert self._playwright is not None
 
@@ -1593,6 +1615,23 @@ class CloudBrowserEnvironment(BaseBrowserEnvironment):
         # Navigate to login URL (provided by backend with custom token)
         context = browser.contexts[0]
         initialization_page = context.pages[0]
+        if expected_browser_window_id is not None:
+            # Put the backend-owned browser ID into sessionStorage before hydration
+            # so AgentCore sessions use the right Firestore route when needed.
+            expected_browser_window_id_json = json.dumps(expected_browser_window_id)
+            await context.add_init_script(
+                script=f"""
+                    (() => {{
+                      const expectedBrowserWindowId = {expected_browser_window_id_json};
+                      try {{
+                        sessionStorage.setItem(
+                          "naradaBrowserWindowId",
+                          expectedBrowserWindowId
+                        );
+                      }} catch (_error) {{}}
+                    }})();
+                """
+            )
         await initialization_page.goto(
             login_url, timeout=15_000, wait_until="domcontentloaded"
         )
@@ -1613,7 +1652,7 @@ class CloudBrowserEnvironment(BaseBrowserEnvironment):
                     raise
                 logging.info("Waiting for Narada extension to be installed...")
                 await asyncio.sleep(1)
-            except NaradaTimeoutError:
+            except (NaradaTimeoutError, NaradaExtensionUnauthenticatedError):
                 if attempt == max_attempts - 1:
                     raise
                 # If browser window ID is not found, reload the page and try again
@@ -1622,6 +1661,15 @@ class CloudBrowserEnvironment(BaseBrowserEnvironment):
                     login_url, timeout=15_000, wait_until="domcontentloaded"
                 )
 
+        if (
+            expected_browser_window_id is not None
+            and browser_window_id != expected_browser_window_id
+        ):
+            raise RuntimeError(
+                "Initialized cloud session reported browserWindowId "
+                f"{browser_window_id!r}, expected {expected_browser_window_id!r}."
+            )
+
         self._browser_window_id = browser_window_id
         self._session_id = session_id
         self._context = context

narada-0.2.2/tests/test_client.py

@@ -0,0 +1,186 @@
+from __future__ import annotations
+
+import narada.environment as environment_module
+import pytest
+from narada import CloudBrowserEnvironment, RemoteBrowserEnvironment
+from narada.config import BrowserConfig
+
+
+class _FakePage:
+    def __init__(self) -> None:
+        self.goto_calls: list[dict[str, object]] = []
+        self.url = "about:blank"
+
+    async def goto(self, url: str, **kwargs: object) -> None:
+        self.url = url
+        self.goto_calls.append({"url": url, **kwargs})
+
+
+class _FakeContext:
+    def __init__(self, page: _FakePage) -> None:
+        self.pages = [page]
+
+
+class _FakeBrowser:
+    def __init__(self, page: _FakePage) -> None:
+        self.contexts = [_FakeContext(page)]
+        self.close_calls = 0
+
+    async def close(self) -> None:
+        self.close_calls += 1
+
+
+class _FakeChromium:
+    def __init__(self, page: _FakePage) -> None:
+        self.browser = _FakeBrowser(page)
+
+    async def connect_over_cdp(
+        self, cdp_websocket_url: str, *, headers: dict[str, str]
+    ) -> _FakeBrowser:
+        return self.browser
+
+
+class _FakePlaywright:
+    def __init__(self, page: _FakePage) -> None:
+        self.chromium = _FakeChromium(page)
+
+
+class _FakeRemoteDispatchPostResponse:
+    ok = True
+    status = 200
+
+    async def __aenter__(self) -> _FakeRemoteDispatchPostResponse:
+        return self
+
+    async def __aexit__(self, *_args: object) -> None:
+        return None
+
+    def raise_for_status(self) -> None:
+        return None
+
+    async def json(self) -> dict[str, object]:
+        return {"requestId": "request-123"}
+
+
+class _FakeRemoteDispatchGetResponse:
+    ok = True
+    status = 200
+
+    async def __aenter__(self) -> _FakeRemoteDispatchGetResponse:
+        return self
+
+    async def __aexit__(self, *_args: object) -> None:
+        return None
+
+    def raise_for_status(self) -> None:
+        return None
+
+    async def json(self) -> dict[str, object]:
+        return {
+            "status": "success",
+            "response": {
+                "text": "done",
+                "output": None,
+                "executionTraceContext": {
+                    "type": "executionTraceContext",
+                    "executionTraceS3Key": "user-test/execution-trace/index.json",
+                },
+            },
+            "createdAt": "2026-06-03T00:00:00Z",
+            "completedAt": "2026-06-03T00:00:01Z",
+            "usage": {"actions": 1, "credits": 0.1},
+        }
+
+
+class _FakeRemoteDispatchSession:
+    post_calls: list[dict[str, object]] = []
+    get_calls: list[dict[str, object]] = []
+
+    async def __aenter__(self) -> _FakeRemoteDispatchSession:
+        return self
+
+    async def __aexit__(self, *_args: object) -> None:
+        return None
+
+    def post(self, url: str, **kwargs: object) -> _FakeRemoteDispatchPostResponse:
+        self.post_calls.append({"url": url, **kwargs})
+        return _FakeRemoteDispatchPostResponse()
+
+    def get(self, url: str, **kwargs: object) -> _FakeRemoteDispatchGetResponse:
+        self.get_calls.append({"url": url, **kwargs})
+        return _FakeRemoteDispatchGetResponse()
+
+
+@pytest.mark.asyncio
+async def test_cloud_browser_initialization_uses_domcontentloaded_navigation(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    page = _FakePage()
+    env = CloudBrowserEnvironment(
+        config=BrowserConfig(interactive=False),
+        auth_headers={"x-test": "true"},
+    )
+    env._playwright = _FakePlaywright(page)
+
+    async def wait_for_browser_window_id(*args: object, **kwargs: object) -> str:
+        return "window-123"
+
+    monkeypatch.setattr(
+        env, "_wait_for_cloud_browser_window_id", wait_for_browser_window_id
+    )
+
+    await env._initialize_cloud_browser_window(
+        cdp_websocket_url="wss://example.test/cdp",
+        session_id="session-123",
+        login_url="https://example.test/initialize",
+        cdp_auth_headers={"authorization": "Bearer test"},
+    )
+
+    assert env.browser_window_id == "window-123"
+    assert env.cloud_browser_session_id == "session-123"
+    assert page.goto_calls == [
+        {
+            "url": "https://example.test/initialize",
+            "timeout": 15_000,
+            "wait_until": "domcontentloaded",
+        }
+    ]
+
+
+@pytest.mark.asyncio
+async def test_remote_dispatch_forwards_managed_cloud_browser_request(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _FakeRemoteDispatchSession.post_calls = []
+    _FakeRemoteDispatchSession.get_calls = []
+    monkeypatch.setenv("NARADA_API_BASE_URL", "https://api.example.test/fast/v2")
+    monkeypatch.setattr(
+        environment_module.aiohttp, "ClientSession", _FakeRemoteDispatchSession
+    )
+
+    env = RemoteBrowserEnvironment(
+        browser_window_id="sdk-managed-cloud-browser",
+        cloud_browser_session_id="cloud-session-123",
+        auth_headers={"x-test": "true"},
+    )
+
+    response = await env._dispatch_request(
+        prompt="Fill the RPA challenge form.",
+        timeout=30,
+    )
+
+    assert response["response"] is not None
+    assert response["response"]["executionTraceContext"] == {
+        "type": "executionTraceContext",
+        "executionTraceS3Key": "user-test/execution-trace/index.json",
+    }
+    assert len(_FakeRemoteDispatchSession.post_calls) == 1
+    post_call = _FakeRemoteDispatchSession.post_calls[0]
+    assert post_call["url"] == "https://api.example.test/fast/v2/remote-dispatch"
+    assert post_call["headers"] == {"x-test": "true"}
+    assert post_call["json"] == {
+        "prompt": "/Operator Fill the RPA challenge form.",
+        "browserWindowId": "sdk-managed-cloud-browser",
+        "timeZone": "America/Los_Angeles",
+        "cloudBrowserSessionId": "cloud-session-123",
+    }

{narada-0.2.0 → narada-0.2.2}/tests/test_cloud_browser.py

@@ -1,3 +1,4 @@
+import json
 from types import SimpleNamespace
 from unittest.mock import AsyncMock, call
 
@@ -79,7 +80,9 @@ def _build_cloud_environment_with_page(page: AsyncMock) -> CloudBrowserEnvironme
         auth_headers={"x-api-key": "test-key"},
         config=BrowserConfig(interactive=False),
     )
-    browser = SimpleNamespace(contexts=[SimpleNamespace(pages=[page])])
+    browser = SimpleNamespace(
+        contexts=[SimpleNamespace(pages=[page], add_init_script=AsyncMock())]
+    )
     env._playwright = SimpleNamespace(
         chromium=SimpleNamespace(connect_over_cdp=AsyncMock(return_value=browser))
     )
@@ -179,6 +182,91 @@ async def test_dispatch_request_calls_input_required_callback_once_per_input_id(
     assert sleep.await_count == 3
 
 
+@pytest.mark.asyncio
+async def test_dispatch_request_includes_execution_trace_context(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import narada.environment as environment_module
+
+    trace_context = {
+        "type": "executionTraceInheritanceContext",
+        "schemaVersion": 1,
+        "traceId": "trace-parent",
+        "parentSegmentId": "segment-local",
+    }
+    monkeypatch.setenv("NARADA_EXECUTION_TRACE_CONTEXT", json.dumps(trace_context))
+    fake_session = _RemoteDispatchFakeClientSession(
+        [
+            {
+                "status": "success",
+                "response": {"text": "ok"},
+                "usage": {"actions": 1, "credits": 1},
+                "createdAt": "2026-01-01T00:00:00Z",
+                "completedAt": "2026-01-01T00:00:01Z",
+                "activeInputRequest": None,
+            }
+        ]
+    )
+    monkeypatch.setattr(
+        environment_module.aiohttp, "ClientSession", lambda: fake_session
+    )
+
+    env = RemoteBrowserEnvironment(browser_window_id="bw-1", api_key="test-key")
+    response = await env._dispatch_request(prompt="Summarize", timeout=5)
+
+    assert response["status"] == "success"
+    assert fake_session.dispatched_body is not None
+    assert fake_session.dispatched_body["executionTraceContext"] == trace_context
+
+
+@pytest.mark.asyncio
+async def test_extension_action_request_includes_action_execution_id(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import narada.environment as environment_module
+
+    fake_session = _FakeClientSession({"status": "success", "data": None})
+    monkeypatch.setattr(
+        environment_module.aiohttp, "ClientSession", lambda: fake_session
+    )
+
+    env = RemoteBrowserEnvironment(browser_window_id="bw-1", api_key="test-key")
+    await env.close()
+
+    assert fake_session.posts
+    action_execution_id = fake_session.posts[0]["json"]["actionExecutionId"]
+    assert action_execution_id.startswith("action_")
+
+
+@pytest.mark.asyncio
+async def test_remote_browser_environment_with_cloud_session_stops_session_by_default(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import narada.environment as environment_module
+
+    stop_cloud_browser_session = AsyncMock()
+    monkeypatch.setattr(
+        environment_module,
+        "_stop_cloud_browser_session",
+        stop_cloud_browser_session,
+    )
+
+    env = RemoteBrowserEnvironment(
+        browser_window_id="browser-window-123",
+        cloud_browser_session_id="session-123",
+        auth_headers={"x-api-key": "test-key"},
+    )
+
+    await env.close()
+
+    stop_cloud_browser_session.assert_awaited_once_with(
+        base_url=env._base_url,
+        auth_headers={"x-api-key": "test-key"},
+        session_id="session-123",
+        timeout=None,
+    )
+
+
 @pytest.mark.asyncio
 async def test_lambda_environment_uses_backend_initialization(
     monkeypatch: pytest.MonkeyPatch,
@@ -255,6 +343,7 @@ async def test_cloud_browser_environment_uses_domcontentloaded_for_login_navigat
 ) -> None:
     page = AsyncMock()
     env = _build_cloud_environment_with_page(page)
+    context = env._playwright.chromium.connect_over_cdp.return_value.contexts[0]
 
     wait_for_browser_window_id = AsyncMock(return_value="browser-window-123")
     monkeypatch.setattr(
@@ -278,10 +367,69 @@ async def test_cloud_browser_environment_uses_domcontentloaded_for_login_navigat
         BrowserConfig(interactive=False),
         timeout=30_000,
     )
+    context.add_init_script.assert_not_awaited()
     assert env.browser_window_id == "browser-window-123"
     assert env.cloud_browser_session_id == "session-123"
 
 
+@pytest.mark.asyncio
+async def test_cloud_browser_environment_seeds_expected_browser_window_id_before_navigation(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    page = AsyncMock()
+    env = _build_cloud_environment_with_page(page)
+    context = env._playwright.chromium.connect_over_cdp.return_value.contexts[0]
+    events: list[str] = []
+
+    async def add_init_script(*args, **kwargs) -> None:
+        events.append("seed")
+
+    async def goto(*args, **kwargs) -> None:
+        events.append("goto")
+
+    context.add_init_script.side_effect = add_init_script
+    page.goto.side_effect = goto
+    wait_for_browser_window_id = AsyncMock(return_value="backend-window-123")
+    monkeypatch.setattr(
+        env, "_wait_for_cloud_browser_window_id", wait_for_browser_window_id
+    )
+
+    await env._initialize_cloud_browser_window(
+        cdp_websocket_url="wss://agentcore.example.test/session-123",
+        session_id="session-123",
+        login_url="https://app.narada.ai/chat?customToken=test-token",
+        cdp_auth_headers={"Authorization": "signed-cdp"},
+        expected_browser_window_id="backend-window-123",
+    )
+
+    assert events[:2] == ["seed", "goto"]
+    script = context.add_init_script.await_args.kwargs["script"]
+    assert "naradaBrowserWindowId" in script
+    assert "backend-window-123" in script
+    assert env.browser_window_id == "backend-window-123"
+
+
+@pytest.mark.asyncio
+async def test_cloud_browser_environment_rejects_unexpected_seeded_browser_window_id(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    page = AsyncMock()
+    env = _build_cloud_environment_with_page(page)
+    wait_for_browser_window_id = AsyncMock(return_value="frontend-window-123")
+    monkeypatch.setattr(
+        env, "_wait_for_cloud_browser_window_id", wait_for_browser_window_id
+    )
+
+    with pytest.raises(RuntimeError, match="expected 'backend-window-123'"):
+        await env._initialize_cloud_browser_window(
+            cdp_websocket_url="wss://agentcore.example.test/session-123",
+            session_id="session-123",
+            login_url="https://app.narada.ai/chat?customToken=test-token",
+            cdp_auth_headers={"Authorization": "signed-cdp"},
+            expected_browser_window_id="backend-window-123",
+        )
+
+
 @pytest.mark.asyncio
 async def test_cloud_browser_environment_uses_domcontentloaded_for_retry_navigation(
     monkeypatch: pytest.MonkeyPatch,
@@ -355,3 +503,72 @@ async def test_agent_run_exposes_workflow_trace_alias(
 
     assert response.workflow_trace == workflow_trace
     assert response.model_dump(by_alias=True)["workflowTrace"] == workflow_trace
+
+
+@pytest.mark.asyncio
+async def test_agent_run_appends_critic_workflow_trace(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    workflow_trace = {
+        "workflowId": "main-workflow",
+        "workflowName": "Main Workflow",
+        "runtime": "gui",
+        "status": "success",
+        "startTs": 100,
+        "children": [],
+    }
+    critic_workflow_trace = {
+        "workflowId": "critic-workflow",
+        "workflowName": "Critic Workflow",
+        "runtime": "gui",
+        "status": "success",
+        "startTs": 200,
+        "children": [],
+    }
+    env = CloudBrowserEnvironment(
+        auth_headers={"x-api-key": "test-key"},
+    )
+    agent = Agent(environment=env)
+    monkeypatch.setattr(
+        agent,
+        "_dispatch_request",
+        AsyncMock(
+            side_effect=[
+                {
+                    "requestId": "request-123",
+                    "status": "success",
+                    "response": {
+                        "text": "done",
+                        "output": {"type": "text", "content": "done"},
+                        "workflowTrace": workflow_trace,
+                    },
+                    "usage": {"actions": 0, "credits": 0},
+                },
+                {
+                    "requestId": "critic-request-123",
+                    "status": "success",
+                    "response": {
+                        "text": '{"narada_validation_passed":true}',
+                        "output": {
+                            "type": "structured",
+                            "content": {"narada_validation_passed": True},
+                        },
+                        "structuredOutput": SimpleNamespace(
+                            narada_validation_passed=True
+                        ),
+                        "workflowTrace": critic_workflow_trace,
+                    },
+                    "usage": {"actions": 0, "credits": 0},
+                },
+            ]
+        ),
+    )
+
+    response = await agent.run("return a trace", critic={})
+
+    assert response.critic_result is not None
+    assert response.critic_result.workflow_trace == critic_workflow_trace
+    assert response.workflow_trace == {
+        **workflow_trace,
+        "children": [{"kind": "sub_workflow", "trace": critic_workflow_trace}],
+    }

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

@@ -108,3 +108,35 @@ async def test_user_approval_respects_explicit_timeout(
 
     assert approved is True
     assert fake_session.post_bodies[0]["timeout"] == 600
+
+
+@pytest.mark.asyncio
+async def test_execute_javascript_on_page_dispatches_extension_action(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    fake_session = _FakeSession(
+        [
+            {
+                "status": "success",
+                "data": '{"result":{"title":"Example Domain","count":3}}',
+            }
+        ]
+    )
+    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.execute_javascript_on_page(
+        code="(() => ({ title: document.title, count: 3 }))()",
+    )
+
+    assert result == {"title": "Example Domain", "count": 3}
+    assert fake_session.post_bodies[0]["action"] == {
+        "name": "execute_javascript_on_page",
+        "code": "(() => ({ title: document.title, count: 3 }))()",
+    }