agentenv-framework-protocol 0.1.472__tar.gz → 0.1.473__tar.gz

{agentenv_framework_protocol-0.1.472 → agentenv_framework_protocol-0.1.473}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentenv-framework-protocol
-Version: 0.1.472
+Version: 0.1.473
 Summary: Open data-plane protocol and server SDK for agent environments.
 Project-URL: Homepage, https://www.agentenvframework.com
 Project-URL: Documentation, https://www.agentenvframework.com/docs
@@ -1000,8 +1000,9 @@ are the profile's template. The base class adds:
   `Input.dispatchKeyEvent`, `Input.insertText`), sent to it in order. Also framework-only, for page
   drivers and agentenv's own steps alike:
   - `navigate {url}` and `history {direction}` (`back`, `forward` or `reload`), in the active tab;
-  - `tabs/list`, `tabs/open {url?}`, `tabs/activate {tab}` and `tabs/close {tab}`, by the browser's own tab
-    ids. The active tab is the one a dialog is open on, else the visible one whose page has focus (a hidden
+  - `tabs/list`, `tabs/open {url?, background?}`, `tabs/activate {tab}` and `tabs/close {tab}`, by the browser's
+    own tab ids. A tab opened with `background` opens behind the active tab, which stays active; otherwise it comes
+    to the front. The active tab is the one a dialog is open on, else the visible one whose page has focus (a hidden
     tab's page that had input still says it has focus), else the one agentenv last brought to the front.
     Headless, a tab opened at a URL opens blank and goes there once it's held to the window's size;
   - `dialog/answer {accept, text?}`, the agent's answer to the dialog open on the active tab;

{agentenv_framework_protocol-0.1.472 → agentenv_framework_protocol-0.1.473}/README.md

@@ -935,8 +935,9 @@ are the profile's template. The base class adds:
   `Input.dispatchKeyEvent`, `Input.insertText`), sent to it in order. Also framework-only, for page
   drivers and agentenv's own steps alike:
   - `navigate {url}` and `history {direction}` (`back`, `forward` or `reload`), in the active tab;
-  - `tabs/list`, `tabs/open {url?}`, `tabs/activate {tab}` and `tabs/close {tab}`, by the browser's own tab
-    ids. The active tab is the one a dialog is open on, else the visible one whose page has focus (a hidden
+  - `tabs/list`, `tabs/open {url?, background?}`, `tabs/activate {tab}` and `tabs/close {tab}`, by the browser's
+    own tab ids. A tab opened with `background` opens behind the active tab, which stays active; otherwise it comes
+    to the front. The active tab is the one a dialog is open on, else the visible one whose page has focus (a hidden
     tab's page that had input still says it has focus), else the one agentenv last brought to the front.
     Headless, a tab opened at a URL opens blank and goes there once it's held to the window's size;
   - `dialog/answer {accept, text?}`, the agent's answer to the dialog open on the active tab;

{agentenv_framework_protocol-0.1.472 → agentenv_framework_protocol-0.1.473}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentenv-framework-protocol"
-version = "0.1.472"
+version = "0.1.473"
 description = "Open data-plane protocol and server SDK for agent environments."
 readme = "README.md"
 license = "Apache-2.0"

{agentenv_framework_protocol-0.1.472 → agentenv_framework_protocol-0.1.473}/src/agentenv_protocol/website_browser/control.py

@@ -120,17 +120,22 @@ class BrowserControl:
         active = await self.active_tab()
         return [OpenTab(**tab, active=tab["id"] == active).model_dump() for tab in self.tabs.values()]
 
-    async def open_tab(self, url: Optional[str] = None) -> str:
-        """A new tab at ``url``, else blank, brought to the front; its id. Headless, it opens blank and goes to ``url``
-        once it's held to the window's size, so its page loads at that size."""
+    async def open_tab(self, url: Optional[str] = None, background: bool = False) -> str:
+        """A new tab at ``url``, else blank, brought to the front, or with ``background`` behind the active tab, which
+        stays active, brought back only if the new tab took its place; its id. Headless, it opens blank and goes to
+        ``url`` once it's held to the window's size, so its page loads at that size."""
+        active = await self.active_tab() if background else None
         held = self.viewport is not None and url
         start = "about:blank" if held else url or "about:blank"
-        target = (await self.devtools.call("Target.createTarget", {"url": start}))["targetId"]
+        target = (await self.devtools.call("Target.createTarget", {"url": start, "background": background}))["targetId"]
         if held:
             await asyncio.wait_for(self._pinned.setdefault(target, asyncio.Event()).wait(), PIN_TIMEOUT_S)
             session = next(s for s, t in self._sessions.items() if t == target)
             await self.devtools.call("Page.navigate", {"url": url}, session_id=session)
-        await self._bring_to_front(target)
+        if not background:
+            await self._bring_to_front(target)
+        elif active is not None and active in self.tabs and await self.active_tab() == target:
+            await self._bring_to_front(active)
         return target
 
     async def reopen_start_tabs(self, urls: list[str]) -> None:

{agentenv_framework_protocol-0.1.472 → agentenv_framework_protocol-0.1.473}/src/agentenv_protocol/website_browser/environment.py

@@ -376,8 +376,8 @@ class WebsiteBrowserEnvironment(ComputerAppEnvironment):
         return {"tabs": await self.control.tab_list()}
 
     @extension(BROWSER, op="tabs/open")
-    async def browser_tabs_open(self, url: Optional[str] = None) -> dict:
-        return {"tab": await self.control.open_tab(url)}
+    async def browser_tabs_open(self, url: Optional[str] = None, background: bool = False) -> dict:
+        return {"tab": await self.control.open_tab(url, background)}
 
     @extension(BROWSER, op="tabs/activate")
     async def browser_tabs_activate(self, tab: str) -> dict:

{agentenv_framework_protocol-0.1.472 → agentenv_framework_protocol-0.1.473}/tests/test_website_browser.py

@@ -654,7 +654,8 @@ async def test_a_tab_it_opens_loads_once_held_to_the_window_comes_to_the_front_a
     devtools.send("Target.targetDestroyed", {"targetId": "b"})
 
     on_b = [name for name, _, session in devtools.calls if session == "s-b"]
-    assert opened == "b" and _sent(devtools, "Target.createTarget") == [({"url": "about:blank"}, None)]
+    assert opened == "b" and _sent(devtools, "Target.createTarget") == [({"url": "about:blank", "background": False},
+                                                                         None)]
     assert ({"url": "https://mail.test/b"}, "s-b") in _sent(devtools, "Page.navigate")
     assert on_b.index("Emulation.setDeviceMetricsOverride") < on_b.index("Page.navigate")
     assert [(tab["id"], tab["active"]) for tab in after_open] == [("a", False), ("b", True)]
@@ -663,6 +664,49 @@ async def test_a_tab_it_opens_loads_once_held_to_the_window_comes_to_the_front_a
     assert [(tab["id"], tab["closed_by"]) for tab in control.closed_tabs] == [("b", "agentenv")]
 
 
+@pytest.mark.asyncio
+@pytest.mark.parametrize("focus_moves", [False, True])
+async def test_a_tab_opened_in_the_background_opens_behind_the_active_one_which_stays_in_front(focus_moves):
+    focus = {"s-a": True}
+    devtools = Tabbed({"Runtime.evaluate": lambda params, session: {
+        "result": {"value": ["visible", focus.get(session, False)]}}})
+    control = await _tabs(devtools, "a")
+
+    opening = asyncio.ensure_future(control.open_tab("https://mail.test/b", background=True))
+    await asyncio.sleep(0)
+    devtools.send("Target.targetCreated", _page("b", "https://mail.test/b", "Mail b"))
+    devtools.send("Target.attachedToTarget", {"sessionId": "s-b", **_page("b")})
+    if focus_moves:
+        focus.update({"s-a": False, "s-b": True})
+    opened = await opening
+
+    assert opened == "b" and _sent(devtools, "Target.createTarget") == [({"url": "about:blank", "background": True},
+                                                                         None)]
+    assert ({"url": "https://mail.test/b"}, "s-b") in _sent(devtools, "Page.navigate")
+    assert ({}, "s-b") not in _sent(devtools, "Page.bringToFront")
+    assert _sent(devtools, "Target.activateTarget") == ([({"targetId": "a"}, None)] if focus_moves else [])
+    if not focus_moves:
+        assert [(tab["id"], tab["active"]) for tab in await control.tab_list()] == [("a", True), ("b", False)]
+
+
+@pytest.mark.asyncio
+async def test_a_background_open_leaves_a_tab_another_call_switched_to_meanwhile_in_front():
+    focus = {"s-a": True}
+    devtools = Tabbed({"Runtime.evaluate": lambda params, session: {
+        "result": {"value": ["visible", focus.get(session, False)]}}})
+    control = await _tabs(devtools, "a", "c")
+
+    opening = asyncio.ensure_future(control.open_tab("https://mail.test/b", background=True))
+    await asyncio.sleep(0)
+    focus.update({"s-a": False, "s-c": True})
+    devtools.send("Target.targetCreated", _page("b", "https://mail.test/b", "Mail b"))
+    devtools.send("Target.attachedToTarget", {"sessionId": "s-b", **_page("b")})
+    await opening
+
+    assert _sent(devtools, "Target.activateTarget") == []
+    assert [(tab["id"], tab["active"]) for tab in await control.tab_list()] == [("a", False), ("c", True), ("b", False)]
+
+
 @pytest.mark.asyncio
 async def test_a_hidden_tab_whose_page_still_says_it_has_focus_isnt_the_active_one():
     states = {"s-a": ["hidden", True], "s-b": ["visible", True]}