delegate_task per-call model and provider overrides

Fixes on record

Merged to main. A stamp counts the issues a fix is linked to.

• #7360 fix(delegate): salvage delegate PRs #6933 #6881

  merged to main

  files: run_agent.py, tests/run_agent/test_agent_guardrails.py, tests/tools/test_delegate.py, tools/delegate_tool.py

• #16894 fix(delegate): clear acp_command when override_provider is set

  merged to main

  files: tools/delegate_tool.py

• #19744 fix(delegation): clear parent OpenRouter filters when delegation.provider override is set

  merged to main

  files: tests/tools/test_delegate.py, tools/delegate_tool.py

  Show the diff

  • tests/tools/test_delegate.py

    @@ -980,6 +980,48 @@ def test_cross_provider_delegation(self, mock_creds, mock_cfg):
                 self.assertNotEqual(kwargs["base_url"], parent.base_url)
                 self.assertNotEqual(kwargs["api_key"], parent.api_key)
     
    +    @patch("tools.delegate_tool._load_config")
    +    @patch("tools.delegate_tool._resolve_delegation_credentials")
    +    def test_provider_override_clears_parent_openrouter_filters(
    +        self, mock_creds, mock_cfg
    +    ):
    +        """Delegated provider should not inherit parent provider-preference filters."""
    +        mock_cfg.return_value = {
    +            "max_iterations": 45,
    +            "model": "google/gemini-3-flash-preview",
    +            "provider": "openrouter",
    +        }
    +        mock_creds.return_value = {
    +            "model": "google/gemini-3-flash-preview",
    +            "provider": "openrouter",
    +            "base_url": "https://openrouter.ai/api/v1",
    +            "api_key": "sk-or-key",
    +            "api_mode": "chat_completions",
    +        }
    +        parent = _make_mock_parent(depth=0)
    +        parent.providers_allowed = ["anthropic/claude-3.5-sonnet"]
    +        parent.providers_ignored = ["openai/gpt-4o-mini"]
    +        parent.providers_order = ["google/gemini-2.5-pro"]
    +        parent.provider_sort = "price"
    +
    +        with patch("run_agent.AIAgent") as MockAgent:
    +            mock_child = MagicMock()
    +            mock_child.run_conversation.return_value = {
    +                "final_response": "done",
    +                "completed": True,
    +                "api_calls": 1,
    +            }
    +            MockAgent.return_value = mock_child
    +
    +            delegate_task(goal="Cross-provider test", parent_agent=parent)
    +
    +            _, kwargs = MockAgent.call_args
    +            self.assertEqual(kwargs["provider"], "openrouter")
    +            self.assertIsNone(kwargs["providers_allowed"])
    +            self.assertIsNone(kwargs["providers_ignored"])
    +            self.assertIsNone(kwargs["providers_order"])
    +            self.assertIsNone(kwargs["provider_sort"])
    +
         @patch("tools.delegate_tool._load_config")
         @patch("tools.delegate_tool._resolve_delegation_credentials")
         def test_direct_endpoint_credentials_reach_child_agent(self, mock_creds, mock_cfg):

  • tools/delegate_tool.py

    @@ -1032,6 +1032,23 @@ def _child_thinking(text: str) -> None:
         # fallback_model parameter (which handles both list and dict forms).
         parent_fallback = getattr(parent_agent, "_fallback_chain", None) or None
     
    +    # Inherit the parent's OpenRouter provider-preference filters by default
    +    # (so subagents routed to the same provider honour the same routing
    +    # constraints).  BUT: when `delegation.provider` is set the user is
    +    # explicitly asking the child to run on a different provider, and
    +    # parent-level OpenRouter filters (e.g. `only=["Anthropic"]`) would
    +    # silently force the child back onto the parent's provider. Clear the
    +    # filters in that case so the delegated provider is honoured.
    +    child_providers_allowed = getattr(parent_agent, "providers_allowed", None)
    +    child_providers_ignored = getattr(parent_agent, "providers_ignored", None)
    +    child_providers_order = getattr(parent_agent, "providers_order", None)
    +    child_provider_sort = getattr(parent_agent, "provider_sort", None)
    +    if override_provider:
    +        child_providers_allowed = None
    +        child_providers_ignored = None
    +        child_providers_order = None
    +        child_provider_sort = None
    +
         child = AIAgent(
             base_url=effective_base_url,
             api_key=[redacted:secret-assignment]
    @@ -1056,10 +1073,10 @@ def _child_thinking(text: str) -> None:
             thinking_callback=child_thinking_cb,
             session_db=getattr(parent_agent, "_session_db", None),
             parent_session_id=getattr(parent_agent, "session_id", None),
    -        providers_allowed=parent_agent.providers_allowed,
    -        providers_ignored=parent_agent.providers_ignored,
    -        providers_order=parent_agent.providers_order,
    -        provider_sort=parent_agent.provider_sort,
    +        providers_allowed=child_providers_allowed,
    +        providers_ignored=child_providers_ignored,
    +        providers_order=child_providers_order,
    +        provider_sort=child_provider_sort,
             tool_progress_callback=child_progress_cb,
             iteration_budget=None,  # fresh budget per subagent
         )

• #41730 fix(delegate): resolve custom-endpoint subagent pools by endpoint identity

  merged to main

  files: agent/credential_pool.py, tests/tools/test_delegate.py, tools/delegate_tool.py

  Show the diff

  • agent/credential_pool.py

    @@ -374,7 +374,7 @@ def _iter_custom_providers(config: Optional[dict] = None):
             yield _normalize_custom_pool_name(name), entry
     
     
    -def get_custom_provider_pool_key(base_url: str, provider_name: Optional[str] = None) -> Optional[str]:
    +def get_custom_provider_pool_key(base_url: Optional[str], provider_name: Optional[str] = None) -> Optional[str]:
         """Look up the custom_providers list in config.yaml and return 'custom:<name>' for a matching base_url.
     
         When provider_name is given, prefer matching by name first (solving the case where

  • tests/tools/test_delegate.py

    @@ -1518,6 +1518,73 @@ def test_different_provider_load_failure_returns_none(self):
     
             self.assertIsNone(result)
     
    +    # --- Custom-endpoint identity resolution (issue #7833) ---
    +
    +    def test_custom_different_endpoint_does_not_inherit_parent_pool(self):
    +        """A child on custom endpoint B must not inherit the parent's custom
    +        endpoint A pool just because both normalize to provider='custom'."""
    +        parent = _make_mock_parent()
    +        parent.provider = "custom"
    +        parent.base_url = "https://endpoint-a.example.com/v1"
    +        parent._credential_pool = [redacted:secret-assignment]"parent_custom_a_pool")
    +
    +        child_pool = MagicMock(name="endpoint_b_pool")
    +        child_pool.has_credentials.return_value = True
    +
    +        def fake_key(base_url, provider_name=None):
    +            return {
    +                "https://endpoint-a.example.com/v1": "custom:endpoint-a",
    +                "https://endpoint-b.example.com/v1": "custom:endpoint-b",
    +            }.get(base_url)
    +
    +        with patch("agent.credential_pool.get_custom_provider_pool_key", side_effect=fake_key), \
    +             patch("agent.credential_pool.load_pool", return_value=child_pool) as load_mock:
    +            result = _resolve_child_credential_pool(
    +                "custom", parent, "https://endpoint-b.example.com/v1"
    +            )
    +
    +        # Loaded the child's OWN endpoint pool, not the parent's.
    +        load_mock.assert_called_once_with("custom:endpoint-b")
    +        self.assertIs(result, child_pool)
    +        self.assertIsNot(result, parent._credential_pool)
    +
    +    def test_custom_same_endpoint_shares_parent_pool(self):
    +        """A child on the SAME custom endpoint as the parent reuses the parent's
    +        pool so rotation/cooldown state stays synchronized."""
    +        parent = _make_mock_parent()
    +        parent.provider = "custom"
    +        parent.base_url = "https://endpoint-a.example.com/v1"
    +        parent._credential_pool = [redacted:secret-assignment]"parent_custom_a_pool")
    +
    +        with patch(
    +            "agent.credential_pool.get_custom_provider_pool_key",
    +            return_value="custom:endpoint-a",
    +        ):
    +            result = _resolve_child_credential_pool(
    +                "custom", parent, "https://endpoint-a.example.com/v1"
    +            )
    +
    +        self.assertIs(result, parent._credential_pool)
    +
    +    def test_custom_unregistered_endpoint_returns_none(self):
    +        """A raw delegation.base_url with no matching custom_providers entry
    +        must NOT inherit the parent's pool — return None so the child keeps its
    +        fixed delegated credential."""
    +        parent = _make_mock_parent()
    +        parent.provider = "custom"
    +        parent.base_url = "https://endpoint-a.example.com/v1"
    +        parent._credential_pool = [redacted:secret-assignment]"parent_custom_a_pool")
    +
    +        with patch(
    +            "agent.credential_pool.get_custom_provider_pool_key",
    +            return_value=None,
    +        ):
    +            result = _resolve_child_credential_pool(
    +                "custom", parent, "https://raw-unregistered.example.com/v1"
    +            )
    +
    +        self.assertIsNone(result)
    +
         def test_build_child_agent_assigns_parent_pool_when_shared(self):
             parent = _make_mock_parent()
             mock_pool = MagicMock()

  • tools/delegate_tool.py

    @@ -1184,7 +1184,9 @@ def _child_thinking(text: str) -> None:
     
         # Share a credential pool with the child when possible so subagents can
         # rotate credentials on rate limits instead of getting pinned to one key.
    -    child_pool = _resolve_child_credential_pool(effective_provider, parent_agent)
    +    child_pool = _resolve_child_credential_pool(
    +        effective_provider, parent_agent, effective_base_url
    +    )
         if child_pool is not None:
             child._credential_pool = [redacted:secret-assignment]
     
    @@ -2368,7 +2370,11 @@ def delegate_task(
         )
     
     
    -def _resolve_child_credential_pool(effective_provider: Optional[str], parent_agent):
    +def _resolve_child_credential_pool(
    +    effective_provider: Optional[str],
    +    parent_agent,
    +    effective_base_url: Optional[str] = None,
    +):
         """Resolve a credential pool for the child agent.
     
         Rules:
    @@ -2377,12 +2383,60 @@ def _resolve_child_credential_pool(effective_provider: Optional[str], parent_age
         2. Different provider -> try to load that provider's own pool.
         3. No pool available -> return None and let the child keep the inherited
            fixed credential behavior.
    +
    +    Custom endpoints are a special case: every direct ``delegation.base_url``
    +    runtime collapses to ``provider="custom"``, so bare provider equality would
    +    treat two *different* custom endpoints as interchangeable and let the child
    +    inherit the parent's pool. Leasing from that pool then overwrites the
    +    child's delegated ``base_url`` with the parent's endpoint (issue #7833).
    +    We therefore resolve custom runtimes by endpoint identity (the
    +    ``custom:<name>`` pool key derived from the base_url) and only share the
    +    parent's pool when both resolve to the *same* custom endpoint.
         """
         if not effective_provider:
             return getattr(parent_agent, "_credential_pool", None)
     
         parent_provider = getattr(parent_agent, "provider", None) or ""
         parent_pool = getattr(parent_agent, "_credential_pool", None)
    +
    +    # Custom endpoints: distinguish by endpoint identity, not the bare "custom"
    +    # provider string. Two custom runtimes are only interchangeable when they
    +    # resolve to the same custom:<name> pool key.
    +    if effective_provider == "custom":
    +        try:
    +            from agent.credential_pool import get_custom_provider_pool_key, load_pool
    +
    +            child_key = get_custom_provider_pool_key(effective_base_url)
    +            if child_key is None:
    +                # Unregistered endpoint (raw delegation.base_url with no
    +                # matching custom_providers entry) -> no shared pool exists.
    +                # Keep the child's fixed delegated credential rather than
    +                # risk inheriting the parent's custom endpoint.
    +                return None
    +
    +            # Reuse the parent's pool only when it is the same custom endpoint.
    +            parent_key = get_custom_provider_pool_key(
    +                getattr(parent_agent, "base_url", None)
    +            )
    +            if (
    +                parent_pool is not None
    +                and parent_provider == "custom"
    +                and parent_key is not None
    +                and parent_key == child_key
    +            ):
    +                return parent_pool
    +
    +            pool = load_pool(child_key)
    +            if pool is not None and pool.has_credentials():
    +                return pool
    +        except Exception as exc:
    +            logger.debug(
    +                "Could not resolve custom credential pool for child endpoint '%s': %s",
    +                effective_base_url,
    +                exc,
    +            )
    +        return None
    +
         if parent_pool is not None and effective_provider == parent_provider:
             return parent_pool
     

• #60577 fix(delegation): make active config authoritative for delegation limits

  merged to main

  files: tests/tools/test_delegate.py, tools/delegate_tool.py

  Show the diff

  • tests/tools/test_delegate.py

    @@ -13,6 +13,7 @@
     import os
     import threading
     import time
    +import types
     import unittest
     from unittest.mock import MagicMock, patch
     
    @@ -21,6 +22,7 @@
         DELEGATE_TASK_SCHEMA,
         DelegateEvent,
         _get_max_concurrent_children,
    +    _load_config,
         _LEGACY_EVENT_MAP,
         MAX_DEPTH,
         check_delegate_requirements,
    @@ -2390,6 +2392,71 @@ def test_progress_callback_task_progress_not_misrendered(self):
     class TestConcurrencyDefaults(unittest.TestCase):
         """Tests for the concurrency default and no hard ceiling."""
     
    +    def test_load_config_prefers_active_persistent_config_over_cli_defaults(self):
    +        stale_cli = types.ModuleType("cli")
    +        stale_cli.CLI_CONFIG = {
    +            "delegation": {
    +                "max_iterations": 45,
    +                "model": "",
    +                "provider": "",
    +                "base_url": "",
    +                "api_key": "",
    +            }
    +        }
    +        active_config = {
    +            "delegation": {
    +                "max_iterations": 50,
    +                "max_concurrent_children": 50,
    +                "max_spawn_depth": 10,
    +            }
    +        }
    +
    +        with patch.dict("sys.modules", {"cli": stale_cli}):
    +            with patch(
    +                "hermes_cli.config.load_config_readonly", return_value=active_config
    +            ):
    +                self.assertEqual(_load_config()["max_concurrent_children"], 50)
    +                self.assertEqual(_get_max_concurrent_children(), 50)
    +
    +    def test_load_config_falls_back_to_cli_config_when_persistent_load_fails(self):
    +        fallback_cli = types.ModuleType("cli")
    +        fallback_cli.CLI_CONFIG = {
    +            "delegation": {
    +                "max_iterations": 45,
    +                "max_concurrent_children": 8,
    +            }
    +        }
    +
    +        with patch.dict("sys.modules", {"cli": fallback_cli}):
    +            with patch(
    +                "hermes_cli.config.load_config_readonly",
    +                side_effect=RuntimeError("boom"),
    +            ):
    +                self.assertEqual(_load_config()["max_concurrent_children"], 8)
    +
    +    def test_load_config_prefers_cli_config_when_user_config_ignored(self):
    +        # `hermes chat --ignore-user-config` sets HERMES_IGNORE_USER_CONFIG=1,
    +        # which only load_cli_config() honors. The delegation loader must keep
    +        # CLI_CONFIG authoritative under the flag so user config.yaml
    +        # delegation keys stay suppressed.
    +        ignoring_cli = types.ModuleType("cli")
    +        ignoring_cli.CLI_CONFIG = {
    +            "delegation": {
    +                "max_iterations": 45,
    +                "max_concurrent_children": 4,
    +            }
    +        }
    +        user_config = {"delegation": {"max_concurrent_children": 50}}
    +
    +        with patch.dict("sys.modules", {"cli": ignoring_cli}):
    +            with patch.dict(os.environ, {"HERMES_IGNORE_USER_CONFIG": "1"}):
    +                with patch(
    +                    "hermes_cli.config.load_config_readonly",
    +                    return_value=user_config,
    +                ) as mock_loader:
    +                    self.assertEqual(_load_config()["max_concurrent_children"], 4)
    +                    mock_loader.assert_not_called()
    +
         @patch("tools.delegate_tool._load_config", return_value={})
         def test_default_is_three(self, mock_cfg):
             # Clear env var if set

  • tools/delegate_tool.py

    @@ -3098,26 +3098,40 @@ def _resolve_delegation_credentials(cfg: dict, parent_agent) -> dict:
     
     
     def _load_config() -> dict:
    -    """Load delegation config from CLI_CONFIG or persistent config.
    -
    -    Checks the runtime config (cli.py CLI_CONFIG) first, then falls back
    -    to the persistent config (hermes_cli/config.py load_config()) so that
    -    ``delegation.model`` / ``delegation.provider`` are picked up regardless
    -    of the entry point (CLI, gateway, cron).
    +    """Load delegation config from the active Hermes config.
    +
    +    Prefer the shared persistent loader because it follows the active
    +    HERMES_HOME/profile. ``cli.CLI_CONFIG`` is a legacy fallback for entry
    +    points that cannot import the shared loader; importing it first can return
    +    an old default ``delegation`` block and hide user-set keys such as
    +    ``max_concurrent_children``.
    +
    +    Uses ``load_config_readonly()``: every consumer of this dict is read-only
    +    (``.get()`` lookups), and this runs on each ``get_definitions()`` schema
    +    rebuild via ``_get_max_concurrent_children``, so skipping the defensive
    +    deepcopy matters. Do NOT mutate the returned dict.
    +
    +    ``HERMES_IGNORE_USER_CONFIG=1`` (``hermes chat --ignore-user-config``) is
    +    only honored by the legacy ``cli`` loader, not the shared one, so when the
    +    flag is set we keep ``cli.CLI_CONFIG`` authoritative to preserve the
    +    flag's contract of suppressing user config.yaml settings.
         """
    +    prefer_legacy = os.environ.get("HERMES_IGNORE_USER_CONFIG") == "1"
    +    if not prefer_legacy:
    +        try:
    +            from hermes_cli.config import load_config_readonly
    +
    +            full = load_config_readonly()
    +            cfg = full.get("delegation") or {}
    +            if isinstance(cfg, dict):
    +                return cfg
    +        except Exception:
    +            pass
         try:
             from cli import CLI_CONFIG
     
             cfg = CLI_CONFIG.get("delegation") or {}
    -        if cfg:
    -            return cfg
    -    except Exception:
    -        pass
    -    try:
    -        from hermes_cli.config import load_config
    -
    -        full = load_config()
    -        return full.get("delegation") or {}
    +        return cfg if isinstance(cfg, dict) else {}
         except Exception:
             return {}