getbsquare 0.1.0__tar.gz

getbsquare-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+.venv
+dist
+*.egg-info
+__pycache__
+.pytest_cache

getbsquare-0.1.0/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: getbsquare
+Version: 0.1.0
+Summary: Backend host-action coordination for injectable AG-UI / PydanticAI agents
+License: MIT
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.110
+Provides-Extra: dev
+Requires-Dist: httpx>=0.27; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Provides-Extra: examples
+Requires-Dist: pydantic-ai; extra == 'examples'
+Requires-Dist: uvicorn[standard]; extra == 'examples'
+Description-Content-Type: text/markdown
+
+# bsquare-host
+
+Backend host-action coordination for injectable AG-UI / PydanticAI agents.
+See the repo root README for the full picture.

getbsquare-0.1.0/README.md

@@ -0,0 +1,4 @@
+# bsquare-host
+
+Backend host-action coordination for injectable AG-UI / PydanticAI agents.
+See the repo root README for the full picture.

getbsquare-0.1.0/bsquare_host/__init__.py

@@ -0,0 +1,19 @@
+"""bsquare-host: backend host-action coordination for injectable agents."""
+
+from .app import mount_agent_app
+from .host_actions import (
+    get_coordination_stats,
+    host_action_proxy,
+    setup_host_action_endpoint,
+)
+from .state import AgentState
+
+__all__ = [
+    "host_action_proxy",
+    "setup_host_action_endpoint",
+    "get_coordination_stats",
+    "mount_agent_app",
+    "AgentState",
+]
+
+__version__ = "0.1.0"

getbsquare-0.1.0/bsquare_host/app.py

@@ -0,0 +1,39 @@
+"""One-call wiring for an injectable agent backend."""
+
+from typing import Callable, Optional, Sequence
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from .host_actions import setup_host_action_endpoint
+
+
+def mount_agent_app(
+    agent,
+    app: FastAPI,
+    deps_factory: Callable[[], object],
+    *,
+    path: str = "/agent",
+    cors_origins: Optional[Sequence[str]] = None,
+) -> FastAPI:
+    """Wire an AG-UI agent, the host-action endpoint, and (optionally) CORS.
+
+    Args:
+        agent: an object exposing ``to_ag_ui(deps=...)`` (e.g. a PydanticAI Agent).
+        app: the FastAPI app to mount onto.
+        deps_factory: zero-arg callable returning the agent's deps instance.
+            Called once at mount time (not per request).
+        path: mount path for the AG-UI app (default ``/agent``).
+        cors_origins: if given, a permissive CORS middleware is added for them.
+    """
+    if cors_origins is not None:
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=list(cors_origins),
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+        )
+    setup_host_action_endpoint(app)
+    app.mount(path, agent.to_ag_ui(deps=deps_factory()))
+    return app

getbsquare-0.1.0/bsquare_host/host_actions.py

@@ -0,0 +1,317 @@
+"""
+Host action coordination system for injectable AG-UI / PydanticAI agents.
+
+This module provides the production-ready @host_action_proxy decorator and coordination
+infrastructure that lets backend tools trigger an action on the host page (via the
+injectable widget) and wait for its result, coordinated per tool_call_id.
+
+Usage in any agent:
+    from bsquare_host import host_action_proxy, setup_host_action_endpoint
+
+    @your_agent.tool
+    @host_action_proxy(timeout=3.0)
+    async def get_page_info(ctx: RunContext[YourDeps], host_result: dict = None) -> str:
+        if host_result and host_result.get('success'):
+            return f"Retrieved page information: {host_result.get('result')}"
+        return "Unable to retrieve page information at this time."
+
+    # Add to your FastAPI app:
+    setup_host_action_endpoint(app)
+
+Diagnostic messages are emitted via the ``bsquare_host`` logger at DEBUG level, so the
+library stays silent by default. Enable them with::
+
+    import logging
+    logging.getLogger("bsquare_host").setLevel(logging.DEBUG)
+"""
+
+import asyncio
+import inspect
+import logging
+import time
+import uuid
+from typing import Dict, Any, Callable
+from fastapi import FastAPI
+
+logger = logging.getLogger("bsquare_host")
+
+# Global coordination state - shared across all agents using this module
+# This is intentionally global to allow coordination between:
+# 1. Multiple decorated tools within an agent
+# 2. The /host-action-result endpoint
+# 3. Frontend widget result submissions
+host_action_results: Dict[str, Any] = {}
+pending_host_actions: Dict[str, asyncio.Event] = {}
+
+
+def host_action_proxy(timeout: float = 5.0, auto_format: bool = False):
+    """
+    Production-ready decorator for backend tools that coordinate with frontend host actions.
+
+    Features:
+    - Multi-user safe using tool_call_id coordination
+    - Automatic timeout handling and cleanup
+    - Zero race conditions between concurrent users
+    - Graceful error handling and fallback responses
+
+    Args:
+        timeout: Maximum time to wait for host action result (default: 5.0 seconds)
+        auto_format: If True, automatically handle timeout/success/error responses (default: False)
+
+    Usage Option 1 - Manual handling (existing pattern):
+        @your_agent.tool
+        @host_action_proxy(timeout=3.0)
+        async def navigate_to_page(ctx: RunContext[YourDeps], page: str, host_result: dict = None) -> str:
+            if host_result and host_result.get('timeout'):
+                return f"Navigation to {page} is taking longer than expected..."
+
+            if host_result and host_result.get('success'):
+                result = host_result.get('result', {})
+                if result.get('success'):
+                    return f"Navigation completed: {result}"
+
+            return f"Unable to navigate to {page} page at this time."
+
+    Usage Option 2 - Auto-format (eliminates boilerplate):
+        @your_agent.tool
+        @host_action_proxy(timeout=3.0, auto_format=True)
+        async def navigate_to_page(ctx: RunContext[YourDeps], page: str) -> dict:
+            '''Navigate to a specific page in the construction management system.'''
+            return {
+                "action": "navigate_to_page",
+                "params": {"page": page},
+                "timeout_message": f"Navigation to {page} is taking longer than expected...",
+                "error_message": f"Unable to navigate to {page} page at this time."
+            }
+    """
+    def decorator(func: Callable) -> Callable:
+        # The wrapper below is generic (ctx, *args, **kwargs), but agent
+        # frameworks (e.g. PydanticAI) build each tool's JSON schema by
+        # introspecting the function signature. If they see (*args, **kwargs)
+        # the model is never told the real parameters and calls the tool with
+        # none -- so the host action runs against empty params. Advertise the
+        # wrapped function's real signature instead, hiding the internal
+        # host_result coordination parameter.
+        _orig_sig = inspect.signature(func)
+        _public_params = [
+            p for name, p in _orig_sig.parameters.items() if name != "host_result"
+        ]
+        _public_sig = _orig_sig.replace(parameters=_public_params)
+        _public_annotations = {
+            k: v
+            for k, v in getattr(func, "__annotations__", {}).items()
+            if k != "host_result"
+        }
+
+        async def wrapper(ctx, *args, **kwargs):
+            action_name = func.__name__
+            logger.debug(f"Host Action: {action_name} decorator wrapper called")
+
+            # Get tool call ID from context - this is unique per tool call
+            tool_call_id = ctx.tool_call_id
+            if not tool_call_id:
+                # Fallback to generating unique ID if not available
+                tool_call_id = str(uuid.uuid4())
+
+            logger.debug(f"Host Action: Using tool_call_id: {tool_call_id}")
+
+            # Set up waiting mechanism using unique tool_call_id
+            pending_host_actions[tool_call_id] = asyncio.Event()
+
+            # Extract parameters from function signature
+            sig = _orig_sig
+            func_params = {}
+
+            # Get parameters excluding ctx and host_result
+            param_names = [p for p in sig.parameters.keys() if p not in ['ctx', 'host_result']]
+            for i, param_name in enumerate(param_names):
+                if i < len(args):
+                    func_params[param_name] = args[i]
+
+            # Only add non-host_result kwargs to func_params
+            filtered_kwargs = {k: v for k, v in kwargs.items() if k != 'host_result'}
+            func_params.update(filtered_kwargs)
+
+            # Store clean args and kwargs for function calls
+            clean_args = args[:len(param_names)]
+            clean_kwargs = filtered_kwargs
+
+            # Set pending host action in state for frontend (include tool_call_id)
+            # Handle both dict and dataclass state objects
+            if hasattr(ctx.deps.state, 'pending_host_action'):
+                # Dataclass-style state
+                ctx.deps.state.pending_host_action = {
+                    "action": action_name,
+                    "params": func_params,
+                    "tool_call_id": tool_call_id,
+                    "timestamp": time.time()
+                }
+            else:
+                # Dict-style state
+                ctx.deps.state["pending_host_action"] = {
+                    "action": action_name,
+                    "params": func_params,
+                    "tool_call_id": tool_call_id,
+                    "timestamp": time.time()
+                }
+
+            logger.debug(f"Host Action: Set pending_host_action for {action_name} with tool_call_id {tool_call_id}, waiting for result...")
+
+            # Wait for host action result with timeout
+            try:
+                await asyncio.wait_for(
+                    pending_host_actions[tool_call_id].wait(),
+                    timeout=timeout
+                )
+
+                # Get result using tool_call_id
+                action_result = host_action_results.get(tool_call_id)
+
+                if action_result:
+                    result = action_result.get('result', {})
+                    logger.debug(f"Host Action: Found {action_name} result for tool_call_id {tool_call_id}: {result}")
+
+                    # Clean up
+                    del pending_host_actions[tool_call_id]
+                    del host_action_results[tool_call_id]
+
+                    # Handle auto-format vs manual mode
+                    if auto_format:
+                        return _auto_format_response(action_result, action_name, func)
+                    else:
+                        # Call original function with host_result
+                        return await func(ctx, host_result=action_result)
+                else:
+                    logger.debug(f"Host Action: No result found for {action_name} with tool_call_id {tool_call_id}")
+                    if auto_format:
+                        # Get function metadata for error handling
+                        func_result = await func(ctx, *clean_args, **clean_kwargs)
+                        if isinstance(func_result, dict) and 'error_message' in func_result:
+                            return func_result['error_message']
+                        return f"Unable to complete {action_name} at this time."
+                    else:
+                        return await func(ctx, host_result=None)
+
+            except asyncio.TimeoutError:
+                logger.debug(f"Host Action: {action_name} timed out after {timeout}s (tool_call_id: {tool_call_id})")
+                # Clean up
+                if tool_call_id in pending_host_actions:
+                    del pending_host_actions[tool_call_id]
+
+                if auto_format:
+                    # Get function metadata for timeout handling
+                    func_result = await func(ctx, *clean_args, **clean_kwargs)
+                    if isinstance(func_result, dict) and 'timeout_message' in func_result:
+                        return func_result['timeout_message']
+                    return f"{action_name} is taking longer than expected..."
+                else:
+                    # Call function with timeout indication
+                    return await func(ctx, host_result={'timeout': True})
+
+        # Preserve original function metadata and advertise the real signature
+        # (minus host_result) so tool-schema builders see the true parameters.
+        wrapper.__name__ = func.__name__
+        wrapper.__doc__ = func.__doc__
+        wrapper.__annotations__ = _public_annotations
+        wrapper.__signature__ = _public_sig
+
+        return wrapper
+    return decorator
+
+
+def _auto_format_response(action_result: dict, action_name: str, func: Callable) -> str:
+    """
+    Auto-format host action responses based on success/failure patterns.
+
+    Args:
+        action_result: Result from host action execution
+        action_name: Name of the action that was executed
+        func: Original function for extracting custom messages
+
+    Returns:
+        Formatted response string
+    """
+    if action_result.get('success'):
+        result = action_result.get('result', {})
+        if result.get('success'):
+            # Format successful result - show data if meaningful
+            if isinstance(result, dict) and len(result) > 1:
+                return f"✅ {action_name.replace('_', ' ').title()} completed successfully: {result}"
+            else:
+                return f"✅ {action_name.replace('_', ' ').title()} completed successfully"
+        else:
+            # Host action succeeded but returned failure
+            error_msg = result.get('error', 'Unknown error')
+            return f"❌ {action_name.replace('_', ' ').title()} failed: {error_msg}"
+    else:
+        # Host action itself failed
+        error_msg = action_result.get('error', 'Host action execution failed')
+        return f"❌ {action_name.replace('_', ' ').title()} failed: {error_msg}"
+
+
+def setup_host_action_endpoint(app: FastAPI):
+    """
+    Add the /host-action-result endpoint to a FastAPI app.
+
+    This endpoint receives results from frontend host actions and coordinates
+    with waiting backend tools through the global coordination system.
+
+    Args:
+        app: FastAPI application instance
+
+    Usage:
+        from bsquare_host import setup_host_action_endpoint
+
+        app = FastAPI()
+        setup_host_action_endpoint(app)
+    """
+
+    @app.post("/host-action-result")
+    async def receive_host_action_result(request: dict):
+        """Unified endpoint for receiving host action results from frontend widgets."""
+        logger.debug(f"Host Action: Received result: {request.get('toolName')} -> {request.get('result')}")
+
+        # Extract coordination data
+        tool_call_id = request.get('toolCallId')
+        tool_name = request.get('toolName')
+        result = request.get('result')
+        success = request.get('success', False)
+
+        if not tool_call_id:
+            return {"status": "error", "detail": "toolCallId is required"}
+
+        # Store result and notify waiting tools
+        host_action_results[tool_call_id] = {
+            'result': result,
+            'success': success,
+            'toolName': tool_name
+        }
+
+        # Notify waiting tool if exists (using tool_call_id)
+        if tool_call_id in pending_host_actions:
+            logger.debug(f"Host Action: Found waiting tool for tool_call_id '{tool_call_id}', setting event!")
+            pending_host_actions[tool_call_id].set()
+        else:
+            logger.debug(f"Host Action: No waiting tool found for tool_call_id '{tool_call_id}'")
+
+        if success:
+            logger.debug(f"Host action {tool_name} completed successfully")
+        else:
+            logger.debug(f"Host action {tool_name} failed")
+
+        return {"status": "received", "toolCallId": tool_call_id}
+
+
+def get_coordination_stats() -> Dict[str, Any]:
+    """
+    Get current coordination system statistics for debugging.
+
+    Returns:
+        Dictionary with current state of coordination system
+    """
+    return {
+        "pending_actions": len(pending_host_actions),
+        "stored_results": len(host_action_results),
+        "pending_tool_call_ids": list(pending_host_actions.keys()),
+        "result_tool_call_ids": list(host_action_results.keys())
+    }

getbsquare-0.1.0/bsquare_host/state.py

@@ -0,0 +1,20 @@
+"""Base state for agents that coordinate with frontend host actions."""
+
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class AgentState:
+    """Carry the fields the host-action handshake reads and writes.
+
+    - ``pending_host_action`` is set by :func:`host_action_proxy` so the
+      frontend knows which action to run.
+    - ``host_action_result`` mirrors the frontend's reply (the canonical copy
+      lives in the coordination map keyed by ``tool_call_id``).
+    - ``api_token`` is forwarded by the widget in the AG-UI ``state`` field.
+    """
+
+    pending_host_action: Optional[Dict[str, Any]] = None
+    host_action_result: Optional[Dict[str, Any]] = None
+    api_token: Optional[str] = None

getbsquare-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "getbsquare"
+version = "0.1.0"
+description = "Backend host-action coordination for injectable AG-UI / PydanticAI agents"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+dependencies = ["fastapi>=0.110"]
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "pytest-asyncio>=0.23", "httpx>=0.27"]
+examples = ["pydantic-ai", "uvicorn[standard]"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["bsquare_host"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"

getbsquare-0.1.0/tests/test_app.py

@@ -0,0 +1,57 @@
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from bsquare_host.app import mount_agent_app
+
+
+@dataclass
+class _State:
+    pending_host_action: Optional[Dict[str, Any]] = None
+    host_action_result: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class _Deps:
+    state: _State
+
+
+class _FakeAgent:
+    """Stands in for a PydanticAI agent; mirrors the .to_ag_ui() contract."""
+
+    def __init__(self):
+        self.deps_passed = None
+
+    def to_ag_ui(self, deps=None):
+        self.deps_passed = deps
+        sub = FastAPI()
+
+        @sub.get("/")
+        def root():
+            return {"ok": True}
+
+        return sub
+
+
+def test_mount_agent_app_wires_endpoints_and_mount():
+    app = FastAPI()
+    agent = _FakeAgent()
+    mount_agent_app(agent, app, lambda: _Deps(_State()), cors_origins=["*"])
+    client = TestClient(app)
+
+    # host-action-result endpoint is present
+    r = client.post(
+        "/host-action-result",
+        json={"toolCallId": "x", "toolName": "t", "result": {}, "success": True},
+    )
+    assert r.status_code == 200
+
+    # agent is mounted at /agent
+    r2 = client.get("/agent/")
+    assert r2.status_code == 200
+    assert r2.json() == {"ok": True}
+
+    # deps factory was invoked and passed through
+    assert isinstance(agent.deps_passed, _Deps)

getbsquare-0.1.0/tests/test_host_actions.py

@@ -0,0 +1,160 @@
+import asyncio
+import inspect
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from bsquare_host.host_actions import (
+    host_action_proxy,
+    setup_host_action_endpoint,
+    pending_host_actions,
+    host_action_results,
+)
+
+
+@dataclass
+class _State:
+    pending_host_action: Optional[Dict[str, Any]] = None
+    host_action_result: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class _Deps:
+    state: _State
+
+
+class _Ctx:
+    def __init__(self, tool_call_id, deps):
+        self.tool_call_id = tool_call_id
+        self.deps = deps
+
+
+@host_action_proxy(timeout=2.0, auto_format=True)
+async def navigate_to_page(ctx, page: str) -> str:
+    return f"Navigated to {page}"
+
+
+@host_action_proxy(timeout=0.2, auto_format=True)
+async def slow_action(ctx) -> str:
+    return "done"
+
+
+@host_action_proxy(timeout=2.0)
+async def manual_action(ctx, page: str, host_result: dict = None) -> str:
+    return f"manual {page}"
+
+
+def test_decorator_exposes_wrapped_parameters_to_schema():
+    # PydanticAI (and any tool framework) builds a tool's JSON schema by
+    # introspecting the function signature. The decorator must advertise the
+    # wrapped function's real parameters -- NOT the wrapper's (ctx, *args,
+    # **kwargs) -- otherwise the model is never told the tool takes `page` and
+    # calls it with no arguments (the action then runs against empty params).
+    sig = inspect.signature(navigate_to_page)
+    assert "page" in sig.parameters, "the 'page' parameter must be visible to the schema builder"
+    assert sig.parameters["page"].annotation is str
+    kinds = {p.kind for p in sig.parameters.values()}
+    assert inspect.Parameter.VAR_POSITIONAL not in kinds, "*args must not leak into the tool schema"
+    assert inspect.Parameter.VAR_KEYWORD not in kinds, "**kwargs must not leak into the tool schema"
+
+
+def test_decorator_hides_internal_host_result_param():
+    # `host_result` is an internal coordination channel, not a model-facing
+    # argument; it must never appear in the advertised signature.
+    sig = inspect.signature(manual_action)
+    assert "page" in sig.parameters
+    assert "host_result" not in sig.parameters
+
+
+async def test_handshake_accepts_keyword_arguments():
+    # PydanticAI invokes tools with keyword arguments, so the params advertised
+    # to the frontend must be captured from kwargs, not only positional args.
+    ctx = _Ctx("call-kw", _Deps(_State()))
+    task = asyncio.create_task(navigate_to_page(ctx, page="reports"))
+    await asyncio.sleep(0.05)
+
+    assert ctx.deps.state.pending_host_action["params"] == {"page": "reports"}
+
+    host_action_results["call-kw"] = {
+        "result": {"success": True, "page": "reports"},
+        "success": True,
+        "toolName": "navigate_to_page",
+    }
+    pending_host_actions["call-kw"].set()
+
+    result = await task
+    assert "completed successfully" in result
+    assert "call-kw" not in pending_host_actions
+    assert "call-kw" not in host_action_results
+
+
+async def test_handshake_returns_formatted_success():
+    ctx = _Ctx("call-1", _Deps(_State()))
+    task = asyncio.create_task(navigate_to_page(ctx, "reports"))
+    await asyncio.sleep(0.05)  # let the decorator register the pending action
+
+    # The decorator must have advertised the pending action on state:
+    assert ctx.deps.state.pending_host_action["action"] == "navigate_to_page"
+    assert ctx.deps.state.pending_host_action["params"] == {"page": "reports"}
+
+    # Simulate the frontend posting its result (what the endpoint does):
+    host_action_results["call-1"] = {
+        "result": {"success": True, "page": "reports"},
+        "success": True,
+        "toolName": "navigate_to_page",
+    }
+    pending_host_actions["call-1"].set()
+
+    result = await task
+    assert "completed successfully" in result
+    # Coordination state is cleaned up after a successful handshake:
+    assert "call-1" not in pending_host_actions
+    assert "call-1" not in host_action_results
+
+
+async def test_timeout_returns_message():
+    ctx = _Ctx("call-2", _Deps(_State()))
+    result = await slow_action(ctx)  # nobody ever sets the event
+    assert "taking longer than expected" in result
+    assert "call-2" not in pending_host_actions
+
+
+def test_endpoint_sets_event_and_stores_result():
+    app = FastAPI()
+    setup_host_action_endpoint(app)
+    client = TestClient(app)
+
+    pending_host_actions["call-3"] = asyncio.Event()
+    resp = client.post(
+        "/host-action-result",
+        json={
+            "toolCallId": "call-3",
+            "toolName": "navigate_to_page",
+            "result": {"success": True},
+            "success": True,
+        },
+    )
+    assert resp.status_code == 200
+    assert resp.json()["toolCallId"] == "call-3"
+    assert pending_host_actions["call-3"].is_set()
+    assert host_action_results["call-3"]["success"] is True
+
+    pending_host_actions.pop("call-3", None)
+    host_action_results.pop("call-3", None)
+
+
+def test_endpoint_rejects_missing_tool_call_id():
+    app = FastAPI()
+    setup_host_action_endpoint(app)
+    client = TestClient(app)
+    resp = client.post(
+        "/host-action-result",
+        json={"toolName": "x", "result": {}, "success": True},  # no toolCallId
+    )
+    assert resp.status_code == 200
+    assert resp.json().get("status") == "error"
+    # the None key must NOT have been written
+    from bsquare_host.host_actions import host_action_results
+    assert None not in host_action_results

getbsquare-0.1.0/tests/test_public_api.py

@@ -0,0 +1,12 @@
+import bsquare_host
+
+
+def test_public_api_exports():
+    for name in (
+        "host_action_proxy",
+        "setup_host_action_endpoint",
+        "get_coordination_stats",
+        "mount_agent_app",
+        "AgentState",
+    ):
+        assert hasattr(bsquare_host, name), f"missing export: {name}"

getbsquare-0.1.0/tests/test_state.py

@@ -0,0 +1,14 @@
+from bsquare_host.state import AgentState
+
+
+def test_agent_state_defaults_are_none():
+    s = AgentState()
+    assert s.pending_host_action is None
+    assert s.host_action_result is None
+    assert s.api_token is None
+
+
+def test_agent_state_is_mutable():
+    s = AgentState()
+    s.pending_host_action = {"action": "navigate_to_page"}
+    assert s.pending_host_action["action"] == "navigate_to_page"