monkeybot 3.3.0__tar.gz → 3.4.0__tar.gz

{monkeybot-3.3.0 → monkeybot-3.4.0}/CHANGELOG.md

@@ -6,6 +6,18 @@ the project adheres to [Semantic Versioning](https://semver.org/).
 
 ## [Unreleased]
 
+### Browser MCP
+
+#### Fixed
+
+- Empty in-app browsers report `no page target` so `browser_act` / `run_playbook` can `goto` instead of aborting. Stale sessions still fail closed when other tabs exist.
+
+## [core v3.4.0] - 2026-09-12
+
+### Added
+
+- A leading `/slug` in the user turn pins that installed skill for the turn (`## Invoked skill`) without rewriting persisted chat text.
+
 ## [browser v0.7.0] - 2026-09-10
 
 #### Added

{monkeybot-3.3.0 → monkeybot-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: monkeybot
-Version: 3.3.0
+Version: 3.4.0
 Summary: monkeybot agent harness — FastAPI SSE gateway, owned loop, SQLite, and MCP.
 License: MIT
 License-File: LICENSE

{monkeybot-3.3.0 → monkeybot-3.4.0}/integrations/browser-mcp/src/browser_mcp/app.py

@@ -151,7 +151,10 @@ def prepare_action(
         )
     except tabs.UnknownTabError as exc:
         return PreparedAction(error=results.unknown_tab_result(exc), mode=mode)
-    before_url = str(handle.page_info().get("url") or "") if capture_url else ""
+    before_url = ""
+    if capture_url:
+        info = handle.page_info()
+        before_url = str(info.get("url") or "") if isinstance(info, dict) else ""
     return PreparedAction(
         error=None, helpers=helpers, handle=handle, mode=mode, before_url=before_url
     )

{monkeybot-3.3.0 → monkeybot-3.4.0}/integrations/browser-mcp/src/browser_mcp/tabs.py

@@ -19,7 +19,9 @@ from typing import Any
 
 _ALIAS_RE = re.compile(r"^[a-z][a-z0-9_-]{0,23}$")
 _CHROME_INTERNAL = ("chrome://", "chrome-untrusted://", "devtools://", "chrome-extension://")
-_SESSION_LOST = "session with given id"
+# Chrome: "Session with given id not found". Monkeyapp's flatten CDP bridge:
+# "unknown session" when the harness still holds a detached sessionId.
+_SESSION_GONE_MARKERS = ("session with given id", "unknown session")
 logger = logging.getLogger(__name__)
 _SINGLE_TAB_MARKERS = (
     "not allowed",
@@ -96,8 +98,18 @@ def _has_helper(helpers: Any, name: str) -> bool:
     return callable(getattr(helpers, name, None))
 
 
+def _message_has_marker(exc: BaseException, markers: tuple[str, ...]) -> bool:
+    text = str(exc).lower()
+    return any(marker in text for marker in markers)
+
+
 def _session_gone(exc: BaseException) -> bool:
-    return _SESSION_LOST in str(exc).lower()
+    return _message_has_marker(exc, _SESSION_GONE_MARKERS)
+
+
+def is_missing_page_error(exc: BaseException) -> bool:
+    """True when CDP has no live page (empty tabs). Fail-closed on unknown session."""
+    return "no page target" in str(exc).lower()
 
 
 def _log_detach_failure(session_id: str, exc: BaseException) -> None:
@@ -271,19 +283,25 @@ class TabHandle:
         return self.helpers.goto_url(url, target_id=self.state.target_id)
 
     def page_info(self) -> dict[str, Any]:
-        if self.focused or self.state is None:
-            info = self.helpers.page_info()
-            return info if isinstance(info, dict) else {}
-        raw = self.evaluate(_PAGE_INFO_JS)
-        if isinstance(raw, dict):
-            return raw
-        if isinstance(raw, str):
-            try:
-                parsed = json.loads(raw)
-            except json.JSONDecodeError:
+        try:
+            if self.focused or self.state is None:
+                info = self.helpers.page_info()
+                return info if isinstance(info, dict) else {}
+            raw = self.evaluate(_PAGE_INFO_JS)
+            if isinstance(raw, dict):
+                return raw
+            if isinstance(raw, str):
+                try:
+                    parsed = json.loads(raw)
+                except json.JSONDecodeError:
+                    return {}
+                return parsed if isinstance(parsed, dict) else {}
+            return {}
+        except Exception as exc:
+            if is_missing_page_error(exc):
+                logger.debug("page_info: no live page yet", exc_info=True)
                 return {}
-            return parsed if isinstance(parsed, dict) else {}
-        return {}
+            raise
 
     def capture_screenshot(
         self, path: str | None = None, full: bool = False, max_dim: int | None = None

{monkeybot-3.3.0 → monkeybot-3.4.0}/integrations/browser-mcp/tests/test_act.py

@@ -119,6 +119,36 @@ def test_act_stop_on_error_returns_completed_and_observation() -> None:
     assert result["observation"]["mode"] in {"diff", "full"}
 
 
+def test_act_goto_opens_tab_when_page_info_has_no_page() -> None:
+    """Empty in-app browser must not abort act/goto."""
+    helpers = MagicMock()
+    helpers.list_tabs.return_value = []
+    helpers.current_tab.return_value = None
+    helpers.js.return_value = True
+
+    def page_info() -> dict[str, str]:
+        if helpers.new_tab.called:
+            return {"url": "https://a.test/", "title": "A", "w": "800", "h": "600"}
+        raise RuntimeError("no page target")
+
+    helpers.page_info.side_effect = page_info
+    with (
+        _patch_harness(helpers),
+        patch.object(dom_indexing, "settle", return_value={"quiet": True, "navigated": False}),
+        patch.object(dom_indexing, "_register_driver_for_new_documents"),
+        patch.object(dom_indexing, "get_elements") as get_elements,
+    ):
+        result = json.loads(
+            server.browser_act(
+                [{"do": "goto", "url": "https://a.test/"}],
+                observe="none",
+            )
+        )
+    assert result["ok"] is True
+    helpers.new_tab.assert_called_once_with("https://a.test/")
+    get_elements.assert_not_called()
+
+
 def test_act_observe_none_skips_snapshot() -> None:
     helpers = _helpers()
     with (

{monkeybot-3.3.0 → monkeybot-3.4.0}/integrations/browser-mcp/tests/test_playbook_flows.py

@@ -144,6 +144,46 @@ def test_list_playbooks_includes_flows() -> None:
     assert listed["flows"] == [{"host": "a.test", "name": "signup", "params": ["nickname"]}]
 
 
+def test_run_playbook_opens_tab_when_page_info_has_no_page() -> None:
+    playbooks.write_playbook("a.test", _SIGNUP)
+    helpers = MagicMock()
+    helpers.list_tabs.return_value = []
+    helpers.current_tab.return_value = None
+    helpers.js.return_value = True
+
+    def page_info() -> dict[str, str]:
+        if helpers.new_tab.called:
+            return {"url": "https://a.test/form.html", "title": "A"}
+        raise RuntimeError("no page target")
+
+    helpers.page_info.side_effect = page_info
+    with (
+        _patch_harness(helpers),
+        patch.object(dom_indexing, "settle", return_value={"quiet": True, "navigated": False}),
+        patch.object(dom_indexing, "_register_driver_for_new_documents"),
+        patch.object(
+            actions,
+            "do_fill_form",
+            return_value={
+                "ok": True,
+                "filled": [{"label": "Nickname", "index": 1, "how": "label_for"}],
+                "unresolved": [],
+                "submitted": True,
+            },
+        ),
+        patch.object(playbooks, "check_expect", return_value=None),
+    ):
+        result = json.loads(
+            server.browser_run_playbook(
+                "a.test", "signup", {"nickname": "ada"}, observe="none"
+            )
+        )
+    assert result["ok"] is True
+    helpers.new_tab.assert_called_once_with("https://a.test/form.html")
+    assert result["name"] == "signup"
+    assert len(result["completed"]) == 2
+
+
 def test_run_playbook_success_and_expect() -> None:
     playbooks.write_playbook("a.test", _SIGNUP)
     helpers = _helpers()

{monkeybot-3.3.0 → monkeybot-3.4.0}/integrations/browser-mcp/tests/test_tabs.py

@@ -208,6 +208,49 @@ def test_browser_stop_closes_agent_opened_tabs_at_cap(
     assert helpers.close_tab.call_count == 5
 
 
+def test_session_for_reattaches_on_unknown_session() -> None:
+    helpers = MagicMock()
+    helpers.cdp.side_effect = [
+        {"sessionId": "sid-1"},
+        {},
+        {},
+        RuntimeError("{'code': -32000, 'message': 'unknown session'}"),
+        {"sessionId": "sid-2"},
+        {},
+        {},
+        {"result": {"type": "string", "value": "ok"}},
+    ]
+    state = TabState(target_id="aaa", tab="t1", alias="t1")
+    tabs.reset_registry()
+    tabs.registry()._tabs["aaa"] = state
+    tabs.registry()._aliases["t1"] = "aaa"
+    handle = tabs.TabHandle(helpers, state, focused=False)
+    assert handle.evaluate("1+1") == "ok"
+    methods = [c.args[0] for c in helpers.cdp.call_args_list]
+    assert methods.count("Target.attachToTarget") == 2
+    assert state.session_id == "sid-2"
+
+
+def test_focused_page_info_returns_empty_on_no_page() -> None:
+    helpers = MagicMock()
+    helpers.page_info.side_effect = RuntimeError("no page target")
+    handle = tabs.TabHandle(helpers, None, focused=True)
+    assert handle.page_info() == {}
+    assert tabs.is_missing_page_error(RuntimeError("no page target"))
+    assert not tabs.is_missing_page_error(RuntimeError("unknown session"))
+    assert not tabs.is_missing_page_error(RuntimeError("tab sealed"))
+
+
+def test_focused_page_info_raises_on_unknown_session() -> None:
+    helpers = MagicMock()
+    helpers.page_info.side_effect = RuntimeError(
+        "{'code': -32000, 'message': 'unknown session'}"
+    )
+    handle = tabs.TabHandle(helpers, None, focused=True)
+    with pytest.raises(RuntimeError, match="unknown session"):
+        handle.page_info()
+
+
 def test_session_for_attaches_once_and_reattaches_on_lost_session() -> None:
     helpers = MagicMock()
     helpers.cdp.side_effect = [

{monkeybot-3.3.0 → monkeybot-3.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "monkeybot"
-version = "3.3.0"
+version = "3.4.0"
 description = "monkeybot agent harness — FastAPI SSE gateway, owned loop, SQLite, and MCP."
 requires-python = ">=3.11"
 readme = "README.md"

{monkeybot-3.3.0 → monkeybot-3.4.0}/src/monkeybot/core/context/__init__.py

@@ -163,6 +163,8 @@ class TurnContext:
     """Optional goal ledger (Phase 1). None when verifier.ledger is off."""
     verdict_mailbox: VerdictMailbox | None = None
     """Optional verdict mailbox (Phase 2). None when verifier.tracker is off."""
+    invoked_skill: SkillRef | None = None
+    """Installed skill the user explicitly invoked with a leading `/slug` this turn."""
 
 
 _log = logging.getLogger(__name__)

monkeybot-3.4.0/src/monkeybot/core/context/slash_skills.py

@@ -0,0 +1,29 @@
+"""Resolve a leading `/skill-slug` against the skills installed for this turn."""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Sequence
+from dataclasses import replace
+
+from monkeybot.core.context import SkillRef, TurnContext
+
+_SLASH_TOKEN = re.compile(r"(?:^|\s)/([^\s]+)")
+
+
+def resolve_invoked_skill(text: str, skills: Sequence[SkillRef]) -> SkillRef | None:
+    """Match a `/slug` token against installed skill directory names."""
+    by_name = {skill.name.lower(): skill for skill in skills}
+    for match in _SLASH_TOKEN.finditer(text):
+        skill = by_name.get(match.group(1).lower())
+        if skill is not None:
+            return skill
+    return None
+
+
+def apply_invoked_skill(ctx: TurnContext, user_text: str) -> TurnContext:
+    """Attach a turn-scoped invoked skill without rewriting persisted user text."""
+    skill = resolve_invoked_skill(user_text, ctx.skills)
+    if skill is None:
+        return ctx
+    return replace(ctx, invoked_skill=skill)

{monkeybot-3.3.0 → monkeybot-3.4.0}/src/monkeybot/core/prompts/headings.py

@@ -28,6 +28,7 @@ MEMORY_INDEX_HEADING = (
 MEMORY_NUDGE_HEADING = "\n\n## Memory\n"
 SKILLS_HEADING = "\n\n## Skills\n"
 TODO_LIST_HEADING = "\n\n## Todo list\n"
+INVOKED_SKILL_HEADING = "\n\n## Invoked skill\n"
 CURRENT_REQUEST_HEADING = "\n\n## Current request\n"
 RUNTIME_NOTES_HEADING = "\n\n## Runtime notes\n"
 SYSTEM_CONTEXT_UPDATE_HEADING = "\n\n## System context update\n"
@@ -39,6 +40,7 @@ VOLATILE_SECTION_HEADINGS = (
     MEMORY_NUDGE_HEADING,
     SKILLS_HEADING,
     TODO_LIST_HEADING,
+    INVOKED_SKILL_HEADING,
     CURRENT_REQUEST_HEADING,
     RUNTIME_NOTES_HEADING,
     SYSTEM_CONTEXT_UPDATE_HEADING,

{monkeybot-3.3.0 → monkeybot-3.4.0}/src/monkeybot/core/prompts/prompt.py

@@ -15,6 +15,7 @@ from monkeybot.core.prompts.harness_prompt import (
 from monkeybot.core.prompts.headings import (
     CURRENT_DATE_HEADING,
     CURRENT_REQUEST_HEADING,
+    INVOKED_SKILL_HEADING,
     MEMORY_INDEX_HEADING,
     SKILLS_HEADING,
     TODO_LIST_HEADING,
@@ -114,6 +115,19 @@ def _skills_section(ctx: TurnContext) -> str:
     return f"{SKILLS_HEADING}{skills_block}" if skills_block else ""
 
 
+def _invoked_skill_section(ctx: TurnContext) -> str:
+    skill = ctx.invoked_skill
+    if skill is None:
+        return ""
+    return (
+        f"{INVOKED_SKILL_HEADING}"
+        f"The user explicitly invoked `{skill.name}`. "
+        "Use `list_skills` to get the skills root, then `read_file` that skill's "
+        f"`SKILL.md` (`skills/{skill.name}/SKILL.md`) and follow it before acting. "
+        "Text after the `/` command is the instruction for this invocation."
+    )
+
+
 def _todo_list_section(ctx: TurnContext) -> str:
     store = ctx.todo_store
     if store is None:
@@ -152,7 +166,7 @@ def compose_volatile_tail(
     *,
     chat_messages: Sequence[Message] | None = None,
 ) -> str:
-    """Volatile tail: current date + memory index + skills + current-request anchor."""
+    """Volatile tail: current date + memory index + skills + invoked skill + current-request anchor."""
     return "".join(compose_volatile_tail_parts(ctx, chat_messages=chat_messages).values())
 
 
@@ -165,12 +179,13 @@ def compose_volatile_tail_parts(
 
     Lets callers (e.g. ``ContextEpochTracker``) attribute a mid-epoch volatile
     change to the specific source that moved — current date, memory, skills,
-    todo list, or the current-request anchor — instead of a catch-all "volatile" label.
+    invoked skill, todo list, or the current-request anchor — instead of a catch-all "volatile" label.
     """
     return {
         "current_date": _current_date_block(),
         "memory": _memory_block(ctx),
         "skills": _skills_section(ctx),
+        "invoked_skill": _invoked_skill_section(ctx),
         "todos": _todo_list_section(ctx),
         "current_request": _current_request_block(chat_messages),
     }
@@ -191,6 +206,7 @@ def compose_system_prompt(
 
     Skill names are always taken from ``ctx.skills`` (zero-cost discovery); use
     ``list_skills``/``read_file`` for the skills root path and full ``SKILL.md`` procedure.
+    An explicit ``/slug`` invocation is listed under ``## Invoked skill`` for this turn.
     """
     stable = compose_stable_baseline(ctx, attachment_catalog=attachment_catalog)
     volatile = compose_volatile_tail(ctx, chat_messages=chat_messages)

{monkeybot-3.3.0 → monkeybot-3.4.0}/src/monkeybot/gateway/sse/app.py

@@ -46,6 +46,8 @@ from monkeybot.core.config.snapshot import (
     get_config_store,
 )
 from monkeybot.core.context import LoopsToolRegistry, build_context
+from monkeybot.core.context.common import text_from_blocks
+from monkeybot.core.context.slash_skills import apply_invoked_skill
 from monkeybot.core.hooks import HookManager
 from monkeybot.core.knowledge import KnowledgeSubsystem, resolve_knowledge_settings
 from monkeybot.core.knowledge.config import (
@@ -937,6 +939,8 @@ class GatewayLoopPort:
                 )
                 return
 
+            ctx = apply_invoked_skill(ctx, text_from_blocks(user_content))
+
             executor = CoreToolExecutor(
                 workspace_root=workspace_root,
                 memory=getattr(serving.state, "memory", None),

monkeybot-3.4.0/tests/core/test_slash_skills.py

@@ -0,0 +1,86 @@
+"""Leading `/skill` invocation resolution and prompt injection."""
+
+from dataclasses import replace
+
+from monkeybot.core.context import SkillRef, TurnContext
+from monkeybot.core.context.slash_skills import apply_invoked_skill, resolve_invoked_skill
+from monkeybot.core.llm.provider import Message
+from monkeybot.core.prompts.prompt import compose_system_prompt, compose_volatile_tail_parts
+from monkeybot.core.types.content_blocks import Text
+from monkeybot.core.types.types_tools import ToolDef
+
+
+def _ctx(*, skills: list[SkillRef] | None = None, invoked: SkillRef | None = None) -> TurnContext:
+    return TurnContext(
+        thread_id="t1",
+        request_id="r1",
+        agent_md="You are TestBot.",
+        memory_index=[],
+        skills=skills or [],
+        tools=[ToolDef("list_skills", "List skills.", {})],
+        user_id=None,
+        parent_run_id=None,
+        model="gemini-2.5-flash",
+        invoked_skill=invoked,
+    )
+
+
+BROWSER = SkillRef(name="browser", description="Control a browser")
+IMAGE = SkillRef(name="image-generator", description="Generate images")
+SKILLS = [BROWSER, IMAGE]
+
+
+def test_resolve_matches_installed_skill_only() -> None:
+    assert resolve_invoked_skill("/browser now", SKILLS) is BROWSER
+    assert resolve_invoked_skill("/Browser now", SKILLS) is BROWSER
+    assert resolve_invoked_skill("please /browser now", SKILLS) is BROWSER
+    assert resolve_invoked_skill("/loop now", SKILLS) is None
+    assert resolve_invoked_skill("/not-a-skill", SKILLS) is None
+    assert resolve_invoked_skill("browser please", SKILLS) is None
+
+
+def test_apply_invoked_skill_is_turn_scoped() -> None:
+    ctx = _ctx(skills=SKILLS)
+    next_ctx = apply_invoked_skill(ctx, "/browser open the account page")
+    assert next_ctx.invoked_skill is BROWSER
+    assert ctx.invoked_skill is None
+    unchanged = apply_invoked_skill(ctx, "/missing do it")
+    assert unchanged is ctx
+
+
+def test_prompt_includes_invoked_skill_and_keeps_user_text() -> None:
+    user = "/browser open the account page"
+    ctx = _ctx(skills=SKILLS)
+    next_ctx = apply_invoked_skill(ctx, user)
+    out = compose_system_prompt(
+        next_ctx,
+        chat_messages=[Message(role="user", content=[Text(text=user)])],
+    )
+    assert "## Invoked skill\nThe user explicitly invoked `browser`." in out
+    assert "skills/browser/SKILL.md" in out
+    parts = compose_volatile_tail_parts(
+        next_ctx,
+        chat_messages=[Message(role="user", content=[Text(text=user)])],
+    )
+    assert "browser" in parts["invoked_skill"]
+    # History stays the original command text; only turn context is annotated.
+    assert user == "/browser open the account page"
+    assert next_ctx.agent_md == ctx.agent_md
+    assert next_ctx.skills == ctx.skills
+
+
+def test_prompt_omits_invoked_skill_without_match() -> None:
+    ctx = apply_invoked_skill(_ctx(skills=SKILLS), "/loop now")
+    out = compose_system_prompt(ctx)
+    assert "## Invoked skill" not in out
+    assert ctx.invoked_skill is None
+
+
+def test_invoked_skill_survives_tool_round_history() -> None:
+    ctx = replace(_ctx(skills=SKILLS), invoked_skill=BROWSER)
+    msgs = [
+        Message(role="user", content=[Text(text="/browser open the account page")]),
+        Message(role="assistant", content=[Text(text="calling tool")]),
+    ]
+    parts = compose_volatile_tail_parts(ctx, chat_messages=msgs)
+    assert "explicitly invoked `browser`" in parts["invoked_skill"]

{monkeybot-3.3.0 → monkeybot-3.4.0}/tests/providers/test_anthropic_cache.py

@@ -14,6 +14,7 @@ from monkeybot.core.llm.provider import Message, ProviderCallHints, UsageEvent
 from monkeybot.core.prompts.headings import (
     CURRENT_DATE_HEADING,
     CURRENT_REQUEST_HEADING,
+    INVOKED_SKILL_HEADING,
     MEMORY_INDEX_HEADING,
     MEMORY_NUDGE_HEADING,
     RUNTIME_NOTES_HEADING,
@@ -135,6 +136,7 @@ def test_volatile_markers_cover_every_heading_constant() -> None:
         MEMORY_NUDGE_HEADING,
         SKILLS_HEADING,
         TODO_LIST_HEADING,
+        INVOKED_SKILL_HEADING,
         CURRENT_REQUEST_HEADING,
         RUNTIME_NOTES_HEADING,
         SYSTEM_CONTEXT_UPDATE_HEADING,