polyrob 0.5.0__py3-none-any.whl

agents/task/templates.py

@@ -0,0 +1,98 @@
+"""Agent templates — pre-built (toolset, autonomy, persona) bundles.
+
+A template is a one-pick shortcut that drives the toolset, autonomy level,
+and a short persona / voice hint written into ~/.polyrob/.env.
+
+Design notes:
+- Every ``toolset`` value MUST be a key in ``TOOLSETS`` (tool_defaults.py).
+- No template enables ``code_execution`` or live trade execution.
+- ``trading`` maps to the ``research`` toolset (polymarket/hyperliquid are in
+  VALID_TOOL_IDS, but adding a bespoke trading toolset would only add read-only
+  ids already covered by ``research``; simpler mapping chosen over scope creep).
+- ``seeded_skills`` is populated for research, coding, social, and trading
+  templates; blank and general have no seeded skills.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class AgentTemplate:
+    """Immutable bundle of defaults for a named agent persona."""
+    name: str
+    toolset: str
+    autonomy: str
+    persona: str
+    seeded_skills: list[str] = field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# Built-in templates
+# ---------------------------------------------------------------------------
+
+TEMPLATES: dict[str, AgentTemplate] = {
+    "general": AgentTemplate(
+        name="general",
+        toolset="default",
+        autonomy="standard",
+        persona="Helpful, concise assistant. Strong generalist.",
+    ),
+    "research": AgentTemplate(
+        name="research",
+        toolset="research",
+        autonomy="standard",
+        persona="Deep researcher. Thorough, cites sources, stays factual.",
+        seeded_skills=["web-research", "market-research-brief", "lead-research"],
+    ),
+    "coding": AgentTemplate(
+        name="coding",
+        toolset="coding",
+        autonomy="standard",
+        persona="Expert software engineer. Writes clean, tested, production-quality code.",
+        seeded_skills=["coding-workflow", "skill-authoring"],
+    ),
+    "social": AgentTemplate(
+        name="social",
+        toolset="social",
+        autonomy="standard",
+        persona="Social-media and content strategist. Engaging, on-brand voice.",
+        seeded_skills=["web-scraping", "lead-research"],
+    ),
+    # trading → research toolset (reads-only; no code_execution/trade execution).
+    "trading": AgentTemplate(
+        name="trading",
+        toolset="research",
+        autonomy="standard",
+        persona="Markets researcher. Analyses price action and on-chain data. Never executes trades.",
+        seeded_skills=["market-research-brief"],
+    ),
+    "blank": AgentTemplate(
+        name="blank",
+        toolset="minimal",
+        autonomy="off",
+        persona="",
+    ),
+}
+
+
+def resolve_template(name) -> AgentTemplate:
+    """Return the template for *name*, or ``general`` for unknown names.
+
+    Never raises; accepts any input type.
+    """
+    try:
+        key = str(name or "").strip().lower()
+    except Exception:
+        key = ""
+    return TEMPLATES.get(key, TEMPLATES["general"])
+
+
+def resolve_template_persona(name: str | None) -> str:
+    """Persona text for *name* (``""`` for blank/empty)."""
+    return resolve_template(name).persona
+
+
+def seeded_skills_for(name: str | None) -> list[str]:
+    """Seeded skill ids for *name* (empty list if none)."""
+    return list(resolve_template(name).seeded_skills)

agents/task/test_aux_chain.py

@@ -0,0 +1,151 @@
+"""Per-feature aux-model slots + per-task fallback chains (B5, Hermes parity).
+
+resolve_aux_chain() wraps resolve_aux_model() to return an ORDERED list of
+provider/model candidates for an aux task (compaction/judge/reflection),
+instead of a single model string. Empty list => caller falls back to the
+main model (unchanged runtime contract).
+"""
+import pytest
+
+from agents.task.constants import resolve_aux_chain
+
+# Every env var resolve_aux_chain / resolve_aux_model can read, across all 3 slots.
+_ALL_AUX_ENV_KEYS = (
+    "AUX_AUTO",
+    "COMPACTION_AUTO_AUX",
+    "COMPACTION_MODEL",
+    "COMPACTION_PROVIDER",
+    "AUX_MODEL_JUDGE",
+    "AUX_PROVIDER",
+    "AUX_MODEL_COMPACTION",
+    "AUX_PROVIDER_COMPACTION",
+    "AUX_FALLBACK_COMPACTION",
+    "AUX_MODEL_JUDGE",
+    "AUX_PROVIDER_JUDGE",
+    "AUX_FALLBACK_JUDGE",
+    "AUX_MODEL_REFLECTION",
+    "AUX_PROVIDER_REFLECTION",
+    "AUX_FALLBACK_REFLECTION",
+)
+
+
+@pytest.fixture(autouse=True)
+def _clean_aux_env(monkeypatch):
+    """Isolate every test from whatever the dev/CI environment happens to set."""
+    for key in _ALL_AUX_ENV_KEYS:
+        monkeypatch.delenv(key, raising=False)
+    yield
+
+
+def test_primary_plus_fallbacks(monkeypatch):
+    monkeypatch.setenv("AUX_MODEL_JUDGE", "claude-haiku-4-5")
+    monkeypatch.setenv("AUX_PROVIDER_JUDGE", "anthropic")
+    monkeypatch.setenv("AUX_FALLBACK_JUDGE", "openai/gpt-5-mini,gemini/gemini-flash")
+    chain = resolve_aux_chain("judge", "openrouter")
+    assert chain[0] == {"model": "claude-haiku-4-5", "provider": "anthropic"}
+    assert chain[1] == {"model": "gpt-5-mini", "provider": "openai"}
+    assert chain[2] == {"model": "gemini-flash", "provider": "gemini"}
+
+
+def test_legacy_compaction_env_still_works(monkeypatch):
+    monkeypatch.setenv("COMPACTION_MODEL", "gpt-5-mini")
+    assert resolve_aux_chain("compaction", "openai")[0]["model"] == "gpt-5-mini"
+
+
+def test_empty_when_unset():
+    assert resolve_aux_chain("judge", "openrouter") == []
+
+
+def test_new_compaction_env_takes_precedence_over_legacy(monkeypatch):
+    monkeypatch.setenv("COMPACTION_MODEL", "gpt-5-mini")
+    monkeypatch.setenv("AUX_MODEL_COMPACTION", "claude-haiku-4-5")
+    assert resolve_aux_chain("compaction", "openai")[0]["model"] == "claude-haiku-4-5"
+
+
+def test_bare_model_fallback_keeps_default_provider(monkeypatch):
+    # A fallback token with no "/" is a bare model name; it should NOT inherit the
+    # primary candidate's provider (default_provider=None per the sketch) so the
+    # factory auto-detects it from the model registry.
+    monkeypatch.setenv("AUX_MODEL_JUDGE", "claude-haiku-4-5")
+    monkeypatch.setenv("AUX_FALLBACK_JUDGE", "gpt-5-mini")
+    chain = resolve_aux_chain("judge", "openai")
+    assert chain[1] == {"model": "gpt-5-mini", "provider": None}
+
+
+def test_reflection_inherits_compaction_model_and_provider_when_unset(monkeypatch):
+    monkeypatch.setenv("AUX_MODEL_COMPACTION", "claude-haiku-4-5")
+    monkeypatch.setenv("AUX_PROVIDER_COMPACTION", "anthropic")
+    chain = resolve_aux_chain("reflection", "openai")
+    assert chain[0] == {"model": "claude-haiku-4-5", "provider": "anthropic"}
+
+
+def test_reflection_inherits_legacy_compaction_provider_when_model_inherited(monkeypatch):
+    # Legacy knobs only (no new AUX_MODEL_COMPACTION/AUX_PROVIDER_COMPACTION set):
+    # reflection must still inherit COMPACTION_MODEL + COMPACTION_PROVIDER together,
+    # not fall through to the generic AUX_PROVIDER.
+    monkeypatch.setenv("COMPACTION_MODEL", "gpt-5-mini")
+    monkeypatch.setenv("COMPACTION_PROVIDER", "openai")
+    monkeypatch.setenv("AUX_PROVIDER", "gemini")  # decoy: must NOT win
+    chain = resolve_aux_chain("reflection", "anthropic")
+    assert chain[0] == {"model": "gpt-5-mini", "provider": "openai"}
+
+
+def test_reflection_uses_own_env_when_set(monkeypatch):
+    # Reflection has its OWN model+provider+fallback configured: compaction's config
+    # (even if also set) must NOT be consulted at all.
+    monkeypatch.setenv("AUX_MODEL_COMPACTION", "gpt-5-mini")
+    monkeypatch.setenv("AUX_PROVIDER_COMPACTION", "openai")
+    monkeypatch.setenv("AUX_MODEL_REFLECTION", "claude-haiku-4-5")
+    monkeypatch.setenv("AUX_PROVIDER_REFLECTION", "anthropic")
+    monkeypatch.setenv("AUX_FALLBACK_REFLECTION", "gemini/gemini-flash")
+    chain = resolve_aux_chain("reflection", "openai")
+    assert chain[0] == {"model": "claude-haiku-4-5", "provider": "anthropic"}
+    assert chain[1] == {"model": "gemini-flash", "provider": "gemini"}
+
+
+def test_reflection_own_model_set_own_provider_unset_does_not_leak_compaction_provider(monkeypatch):
+    # Reflection sets its OWN model but not its OWN provider, while compaction has a
+    # provider configured. Since the model did NOT come from compaction-inheritance,
+    # compaction's provider must NOT apply — falls through to the generic AUX_PROVIDER
+    # (or None).
+    monkeypatch.setenv("AUX_MODEL_COMPACTION", "gpt-5-mini")
+    monkeypatch.setenv("AUX_PROVIDER_COMPACTION", "openai")
+    monkeypatch.setenv("AUX_MODEL_REFLECTION", "claude-haiku-4-5")
+    chain = resolve_aux_chain("reflection", "anthropic")
+    assert chain[0] == {"model": "claude-haiku-4-5", "provider": None}
+
+
+def test_reflection_fallback_inherits_compaction_fallback_when_unset(monkeypatch):
+    monkeypatch.setenv("AUX_MODEL_COMPACTION", "claude-haiku-4-5")
+    monkeypatch.setenv("AUX_FALLBACK_COMPACTION", "openai/gpt-5-mini")
+    chain = resolve_aux_chain("reflection", "anthropic")
+    assert len(chain) == 2
+    assert chain[1] == {"model": "gpt-5-mini", "provider": "openai"}
+
+
+def test_reflection_aux_auto_pairs_legacy_compaction_provider(monkeypatch):
+    # Regression (B5 review): with all model envs unset, global AUX_AUTO=true and
+    # legacy COMPACTION_PROVIDER set, reflection must resolve via the COMPACTION
+    # inheritance branch (model from the cheap map + COMPACTION_PROVIDER paired) —
+    # matching pre-B5 behavior where reflection reused _provision_compaction_llm().
+    # The bug: resolve_aux_model("reflection") hit the global-AUX_AUTO early-exit
+    # first, so inherited_from_compaction stayed False and the provider was dropped.
+    monkeypatch.setenv("AUX_AUTO", "true")
+    monkeypatch.setenv("COMPACTION_PROVIDER", "anthropic")
+    chain = resolve_aux_chain("reflection", "openai")
+    assert chain[0] == {"model": "gpt-5-mini", "provider": "anthropic"}
+
+
+def test_unknown_slot_returns_empty_chain(monkeypatch):
+    # The slot set is fixed at the 3 real aux call sites (_AUX_SLOTS); an unknown
+    # task never gets a chain — even under AUX_AUTO (dead-config trap guard).
+    monkeypatch.setenv("AUX_AUTO", "true")
+    assert resolve_aux_chain("planner", "anthropic") == []
+    assert resolve_aux_chain("vision", "anthropic") == []
+
+
+def test_compaction_and_judge_do_not_cross_inherit():
+    # Sanity: compaction/judge never inherit each other (only reflection inherits
+    # from compaction).
+    assert resolve_aux_chain("compaction", "openai") == []
+    assert resolve_aux_chain("judge", "openai") == []

agents/task/test_aux_router.py

@@ -0,0 +1,41 @@
+"""Per-task aux-model resolution: explicit env wins, then auto-map, else None."""
+from agents.task.constants import resolve_aux_model, AUX_MODEL_MAP, _AUX_TASK_ENV
+
+
+def test_explicit_env_wins(monkeypatch):
+    monkeypatch.setenv("AUX_MODEL_JUDGE", "claude-haiku-4-5")
+    assert resolve_aux_model("judge", provider="openai") == "claude-haiku-4-5"
+
+
+def test_auto_map_when_enabled(monkeypatch):
+    monkeypatch.delenv("AUX_MODEL_JUDGE", raising=False)
+    monkeypatch.setenv("AUX_AUTO", "true")
+    assert resolve_aux_model("judge", provider="anthropic") == AUX_MODEL_MAP["anthropic"]
+
+
+def test_none_when_unconfigured(monkeypatch):
+    monkeypatch.delenv("AUX_MODEL_JUDGE", raising=False)
+    monkeypatch.delenv("AUX_AUTO", raising=False)
+    assert resolve_aux_model("judge", provider="openai") is None
+
+
+def test_planner_vision_rows_removed(monkeypatch):
+    # UP-10 2.1: planner/vision were dead config surface (no call sites) and were
+    # removed. With no env mapping they resolve to None regardless of AUX_AUTO.
+    assert "planner" not in _AUX_TASK_ENV
+    assert "vision" not in _AUX_TASK_ENV
+    monkeypatch.setenv("AUX_AUTO", "true")
+    monkeypatch.setenv("AUX_MODEL_PLANNER", "should-be-ignored")
+    monkeypatch.setenv("AUX_MODEL_VISION", "should-be-ignored")
+    assert resolve_aux_model("planner", provider="anthropic") == AUX_MODEL_MAP["anthropic"]
+    # ^ note: an unknown task with AUX_AUTO+provider still falls through to the auto-map;
+    # the point is the *explicit* AUX_MODEL_PLANNER/VISION envs are no longer consulted.
+    monkeypatch.delenv("AUX_AUTO", raising=False)
+    assert resolve_aux_model("planner", provider="anthropic") is None
+    assert resolve_aux_model("vision", provider="anthropic") is None
+
+
+def test_compaction_back_compat(monkeypatch):
+    # COMPACTION_MODEL must still win for the compaction task (legacy knob).
+    monkeypatch.setenv("COMPACTION_MODEL", "gpt-5-mini")
+    assert resolve_aux_model("compaction", provider="openai") == "gpt-5-mini"

agents/task/tests/test_parse_robustness.py

@@ -0,0 +1,170 @@
+"""
+Test suite for parse robustness in the task agent.
+
+Modernized 2026-06 against the current API. Three tests were REMOVED because they
+asserted behavior that has since been deleted/changed by design:
+  - TestRetryLogic.test_get_next_action_retry_on_parse_error — mocked
+    `message_manager.extract_json_from_model_output` as a METHOD; it is now a free
+    function (`agents.task.utils_json.extract_json_from_model_output`), and the old
+    `with_structured_output` retry shape no longer matches the native-tools path.
+  - TestTokenManagement.test_cut_messages_called_before_llm — `MessageManager.cut_messages`
+    no longer exists (token management was reorganized into the messages mixins).
+  - TestExponentialBackoff.test_exponential_backoff_on_parse_error — asserted deterministic,
+    no-jitter delays capped at 60s; the current LLM backoff is jittered and capped at 120s,
+    and a plain ValueError is not on the LLM-backoff path at all.
+
+This module now tests:
+1. JSON extraction from various malformed outputs (the free function)
+2. AgentOutput validation (now extra='forbid')
+3. Tool-calling method selection per provider
+"""
+import pytest
+from pydantic import ValidationError
+
+from agents.task.agent.views import AgentOutput
+from agents.task.utils_json import extract_json_from_model_output
+
+
+class TestJSONExtraction:
+    """JSON extraction robustness (utils_json.extract_json_from_model_output)."""
+
+    def test_extract_json_from_json_code_block(self):
+        content = '''Here's the response:
+```json
+{
+  "current_state": {
+    "page_summary": "Test page",
+    "evaluation_previous_goal": "Success",
+    "memory": "Test memory",
+    "next_goal": "Next test",
+    "reasoning": "Test reasoning"
+  },
+  "action": []
+}
+```
+Some additional text'''
+        result = extract_json_from_model_output(content)
+        assert result['current_state']['page_summary'] == "Test page"
+        assert result['action'] == []
+
+    def test_extract_json_from_regular_code_block(self):
+        # A regular (non-"json"-tagged) ``` fence around the full object.
+        content = '''```
+{
+  "current_state": {
+    "page_summary": "Test",
+    "evaluation_previous_goal": "Success",
+    "memory": "Memory",
+    "next_goal": "Goal",
+    "reasoning": "Reason"
+  },
+  "action": [{"test": {"param": "value"}}]
+}
+```'''
+        result = extract_json_from_model_output(content)
+        assert result['current_state']['page_summary'] == "Test"
+        assert len(result['action']) == 1
+
+    def test_extract_json_from_raw_content(self):
+        content = '''{
+  "current_state": {
+    "page_summary": "Raw test",
+    "evaluation_previous_goal": "Success",
+    "memory": "Raw memory",
+    "next_goal": "Raw goal",
+    "reasoning": "Raw reason"
+  },
+  "action": []
+}'''
+        result = extract_json_from_model_output(content)
+        assert result['current_state']['page_summary'] == "Raw test"
+
+    def test_extract_json_with_extra_text(self):
+        content = '''Let me analyze the current state:
+
+{
+  "current_state": {
+    "page_summary": "Embedded test",
+    "evaluation_previous_goal": "Success",
+    "memory": "Embedded memory",
+    "next_goal": "Embedded goal",
+    "reasoning": "Embedded reason"
+  },
+  "action": []
+}
+
+That's my analysis.'''
+        result = extract_json_from_model_output(content)
+        assert result['current_state']['page_summary'] == "Embedded test"
+
+    def test_extract_json_invalid_raises_error(self):
+        with pytest.raises(ValueError, match="Could not parse response"):
+            extract_json_from_model_output("This is not JSON at all")
+
+    def test_extract_json_empty_content_raises_error(self):
+        with pytest.raises(ValueError, match="Empty response from model"):
+            extract_json_from_model_output("")
+
+
+class TestAgentOutputValidation:
+    """AgentOutput model validation (now ConfigDict(extra='forbid'))."""
+
+    def test_agent_output_rejects_extra_fields(self):
+        """AgentOutput now FORBIDS unknown fields (was: ignore). Extra => ValidationError."""
+        data = {
+            "current_state": {
+                "page_summary": "Test",
+                "evaluation_previous_goal": "Success",
+                "memory": "Memory",
+                "next_goal": "Goal",
+                "reasoning": "Reason"
+            },
+            "action": [],
+            "extra_field": "This should now be rejected",
+            "another_extra": {"nested": "data"}
+        }
+        with pytest.raises(ValidationError):
+            AgentOutput(**data)
+
+    def test_agent_output_requires_core_fields(self):
+        """AgentOutput still requires its core fields."""
+        with pytest.raises(ValidationError):
+            AgentOutput(**{"extra_field": "This is not enough"})
+
+
+class TestToolCallingMethods:
+    """Tool-calling method selection — all modern providers use native function_calling."""
+
+    def _host(self, library):
+        import logging
+        from agents.task.agent.core.llm_provisioning import LLMProvisioningMixin
+
+        host = LLMProvisioningMixin.__new__(LLMProvisioningMixin)
+        host.chat_model_library = library
+        host.logger = logging.getLogger("test_tool_calling")
+        return host
+
+    def test_tool_calling_enabled_for_all_providers(self):
+        # Current native-tools adapters (Llama/LangChain providers were removed) plus an
+        # unknown library, which must still default to function_calling.
+        providers = [
+            'ChatOpenAI',
+            'ChatAnthropic',
+            'ChatGoogleGenerativeAI',
+            'ChatDeepSeek',
+            'DeepSeekChatAdapter',
+            'UnknownProvider',
+        ]
+        for provider in providers:
+            host = self._host(provider)
+            assert host.set_tool_calling_method('auto') == 'function_calling', (
+                f"Expected function_calling for {provider}"
+            )
+
+    def test_explicit_method_passthrough(self):
+        host = self._host('ChatOpenAI')
+        assert host.set_tool_calling_method('json_mode') == 'json_mode'
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

agents/task/tool_defaults.py

@@ -0,0 +1,110 @@
+"""Single source of truth for per-surface default tool lists.
+
+Three call sites historically hard-coded their own defaults and drifted. This
+module is the one place that answers "what tools does a session get when the
+caller didn't ask for a specific set?" — keyed by surface (server vs CLI/local).
+
+Named toolsets (TOOLSETS) provide a stable vocabulary for choosing a pre-built
+tool configuration. All ids are cross-checked against VALID_TOOL_IDS from
+skill_manager — only valid ids appear in any set.  ``code_execution`` is
+intentionally absent from every set (unsafe by default).
+
+Notes on ids that were considered but excluded:
+- ``twitter``: not in VALID_TOOL_IDS → excluded from all sets (incl. ``social``).
+- ``goal``, ``cronjob``: not in VALID_TOOL_IDS → excluded.
+- ``knowledge``: not in VALID_TOOL_IDS → excluded.
+- ``code_execution``: deliberately excluded (unsafe without a sandbox).
+"""
+
+import os
+
+# ---------------------------------------------------------------------------
+# Named toolsets registry
+# ---------------------------------------------------------------------------
+# Every id listed here is a member of VALID_TOOL_IDS (skill_manager.py:26):
+#   {'browser', 'mcp', 'filesystem', 'perplexity', 'email', 'task',
+#    'anysite', 'coding', 'code_execution', 'polymarket', 'hyperliquid'}
+# code_execution is excluded from all named sets (unsafe by default).
+
+TOOLSETS: dict[str, list[str]] = {
+    # Absolute minimum: file access + task management.
+    "minimal": ["filesystem", "task"],
+    # Equivalent to the safe/cli minimum.
+    "safe": ["filesystem", "task"],
+    # Matches the current cli_default_tools() base (without dynamic additions).
+    "default": ["filesystem", "task"],
+    # Research workflow: lightweight web read + search + any-site scraping + read-only
+    # crypto market data (no wallet).
+    "research": ["filesystem", "task", "perplexity", "anysite", "web_fetch",
+                 "polymarket_data", "hyperliquid_data"],
+    # Trading research: research base focused on the crypto read tools (no trade tools).
+    "trading_research": ["filesystem", "task", "perplexity", "anysite", "web_fetch",
+                         "polymarket_data", "hyperliquid_data"],
+    # Coding workflow: file editing + code runner tool.
+    "coding": ["filesystem", "task", "coding"],
+    # Development: coding + browser (e.g. to browse docs / test web UIs).
+    "development": ["filesystem", "task", "coding", "browser"],
+    # Browser-centric: just the browser on top of core.
+    "browser": ["filesystem", "task", "browser"],
+    # Social listening / research: any-site scraping + web search.
+    # NOTE: `twitter` is NOT in VALID_TOOL_IDS, so it is intentionally omitted;
+    # social-platform data is reached via `anysite` (which covers twitter/linkedin/etc).
+    "social": ["filesystem", "task", "anysite", "perplexity", "polymarket_data"],
+    # Full server stack (mirrors server_default_tools()).
+    "full": ["filesystem", "task", "web_fetch", "perplexity", "email", "mcp", "anysite"],
+}
+
+
+def resolve_toolset(name: str) -> list[str]:
+    """Return the tool list for *name*, or the ``default`` set for unknown names.
+
+    Never raises; always returns a non-empty list.
+    """
+    key = (name or "").strip().lower()
+    return list(TOOLSETS.get(key, TOOLSETS["default"]))
+
+
+# ---------------------------------------------------------------------------
+# Per-surface defaults
+# ---------------------------------------------------------------------------
+
+
+def server_default_tools() -> list[str]:
+    """Comprehensive default for a server-container session (web read + MCP available).
+
+    Web reading defaults to the lightweight ``web_fetch`` tool; the heavyweight Playwright
+    ``browser`` tool is opt-in (request ``tool_ids=['browser']`` or a browser-oriented toolset).
+    """
+    return ['filesystem', 'task', 'web_fetch', 'perplexity', 'email', 'mcp', 'anysite']
+
+
+def cli_default_tools() -> list[str]:
+    """Default for the lightweight CLI container.
+
+    When ``POLYROB_AGENT_TOOLSET`` is set, the tool list is driven by the named
+    toolset via ``resolve_toolset``; unset behaviour is BYTE-IDENTICAL to the
+    previous implementation.
+
+    Either way the final list is intersected through ``cli_unavailable_tools`` so
+    the agent is never advertised tools the CLI container can't register.
+    """
+    from core.bootstrap import cli_unavailable_tools
+
+    toolset_name = os.environ.get("POLYROB_AGENT_TOOLSET", "").strip()
+
+    if toolset_name:
+        # Named-toolset path: drive the list from the registry.
+        tools = resolve_toolset(toolset_name)
+    else:
+        # Legacy path: byte-identical to the original implementation.
+        from tools.coding import coding_tools_enabled
+        from tools.anysite import anysite_cli_enabled
+
+        tools = ['filesystem', 'task', 'web_fetch']
+        if coding_tools_enabled():
+            tools.append('coding')
+        if anysite_cli_enabled():
+            tools.append('anysite')
+
+    unavailable = set(cli_unavailable_tools(tools))
+    return [t for t in tools if t not in unavailable]