cade-cli 0.21.0__tar.gz → 0.22.0__tar.gz

{cade_cli-0.21.0 → cade_cli-0.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cade-cli
-Version: 0.21.0
+Version: 0.22.0
 Summary: Cade - The CLI Agent from Arcade.dev (install: curl -fsSL https://arcadeagent.dev/install | sh)
 Project-URL: Homepage, https://arcade.dev
 Project-URL: Documentation, https://arcadeagent.dev/docs
@@ -352,7 +352,7 @@ Full layout, env vars, and TOML schema in [`docs/configuration.md`](./docs/confi
 | Variable | Purpose |
 |---|---|
 | `OPENAI_API_KEY` / `ANTHROPIC_API_KEY` | LLM provider keys |
-| `OPENAI_BASE_URL` | Custom OpenAI-compatible endpoint |
+| `OPENAI_BASE_URL` / `ANTHROPIC_BASE_URL` | Custom provider endpoint (gateway, proxy, compatible server); per agent: `cade agent edit <agent> --base-url <url>` |
 | `ARCADE_API_KEY`, `ARCADE_BASE_URL` | Arcade Cloud (alternative to OAuth) |
 | `CADE_LOCAL_ONLY=1` | Skip remote tools entirely |
 | `CADE_HOME` | Override config directory |

{cade_cli-0.21.0 → cade_cli-0.22.0}/README.md

@@ -256,7 +256,7 @@ Full layout, env vars, and TOML schema in [`docs/configuration.md`](./docs/confi
 | Variable | Purpose |
 |---|---|
 | `OPENAI_API_KEY` / `ANTHROPIC_API_KEY` | LLM provider keys |
-| `OPENAI_BASE_URL` | Custom OpenAI-compatible endpoint |
+| `OPENAI_BASE_URL` / `ANTHROPIC_BASE_URL` | Custom provider endpoint (gateway, proxy, compatible server); per agent: `cade agent edit <agent> --base-url <url>` |
 | `ARCADE_API_KEY`, `ARCADE_BASE_URL` | Arcade Cloud (alternative to OAuth) |
 | `CADE_LOCAL_ONLY=1` | Skip remote tools entirely |
 | `CADE_HOME` | Override config directory |

{cade_cli-0.21.0 → cade_cli-0.22.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cade-cli"
-version = "0.21.0"
+version = "0.22.0"
 description = "Cade - The CLI Agent from Arcade.dev (install: curl -fsSL https://arcadeagent.dev/install | sh)"
 readme = "README.md"
 requires-python = ">=3.11"

{cade_cli-0.21.0 → cade_cli-0.22.0}/src/cade_mcp_local/tools/agents.py

@@ -4,7 +4,7 @@ One ``Agent`` tool with an ``action`` (send | list | spawn), replacing the
 former AgentSend / AgentList / AgentSpawn tools; the host's composite tool
 manager rewrites calls to those legacy names, and trims the ``action`` enum
 to the actions this agent can actually use (see
-``cadecoder.tools.manager.surface``).
+``cadecoder.tools.manager.gating``).
 
 Lets the model address other agents the user has explicitly linked. Delivery
 rides the durable per-agent inbox (so the message survives until the target

{cade_cli-0.21.0 → cade_cli-0.22.0}/src/cadecoder/cli/commands/agents.py

@@ -17,7 +17,9 @@ from cadecoder.core import agent as agent_mod
 from cadecoder.core import comms as comms_mod
 from cadecoder.core.agent import AgentConfig
 from cadecoder.core.errors import ConfigError
-from cadecoder.tools.profiles import DEFAULT_PROFILE, PROFILE_NAMES
+from cadecoder.tools.manager.profiles import DEFAULT_PROFILE, PROFILES
+
+PROFILE_NAMES = tuple(PROFILES)
 
 channel_app = typer.Typer(
     name="channel",
@@ -29,6 +31,39 @@ channel_app = typer.Typer(
 help_on_empty(channel_app)
 
 
+_BASE_URL_HELP = (
+    "Model-provider endpoint for this agent (gateway, proxy, or compatible server). "
+    'Pass "" to clear and use the default endpoint.'
+)
+
+
+def _checked_base_url(value: str | None) -> str | None:
+    """Validate a ``--base-url`` value; ``""`` clears it (returns ``None``).
+
+    Fails the command on a malformed URL so a bad value never reaches the
+    agent file, and warns when the API key would cross the network in clear.
+    """
+    from cadecoder.providers.endpoint import normalize_base_url, sends_key_in_cleartext
+
+    if value is None or not value.strip():
+        return None
+    try:
+        url = normalize_base_url(value)
+    except ValueError as e:
+        fail(f"Invalid --base-url: {e}")
+    if sends_key_in_cleartext(url):
+        console.print(
+            f"[yellow]Warning: {url} is plain http to a non-local host — the API key "
+            "will be sent unencrypted.[/yellow]"
+        )
+    return url
+
+
+def _endpoint_label(agent: agent_mod.AgentConfig) -> str:
+    """How to show an agent's endpoint: its own URL, or that it uses the default."""
+    return agent.base_url or "[dim](default)[/dim]"
+
+
 def new_agent(
     name: Annotated[str, typer.Argument(help="Unique name for the new agent")],
     model: Annotated[str | None, typer.Option("--model", help="Model id")] = None,
@@ -45,10 +80,12 @@ def new_agent(
     allow_spawn: Annotated[
         bool, typer.Option("--allow-spawn", help="Permit this agent to spawn task-agents")
     ] = False,
+    base_url: Annotated[str | None, typer.Option("--base-url", help=_BASE_URL_HELP)] = None,
 ) -> None:
     """Create a new agent and switch to it."""
     if prompt and prompt_file:
         fail("Use either --prompt or --prompt-file, not both.")
+    endpoint = _checked_base_url(base_url)
     try:
         agent = agent_mod.new_agent(
             name,
@@ -58,6 +95,7 @@ def new_agent(
             description=description,
             workspace=workspace,
             allow_spawn=allow_spawn,
+            base_url=endpoint,
         )
     except ConfigError as e:
         fail(str(e))
@@ -65,6 +103,8 @@ def new_agent(
     agent_mod.set_active_agent(agent.name)
     console.print(f"[green]Created agent '{agent.name}'[/green] [dim]({agent.id})[/dim]")
     console.print(f"[dim]Model: {agent.model} · now the current agent[/dim]")
+    if agent.base_url:
+        console.print(f"[dim]Endpoint: {agent.base_url}[/dim]")
     # Provider keys and the Arcade login are global, but a loadout is not: a new
     # agent starts with no tool servers even when the first one is fully set up.
     if not agent.mcp:
@@ -157,6 +197,7 @@ def agent_info(
         return
     console.print(f"[bold cyan]Agent:[/bold cyan] {agent.name}  [dim]{agent.id}[/dim]")
     console.print(f"  [bold]Model:[/bold] {agent.model}")
+    console.print(f"  [bold]Endpoint:[/bold] {_endpoint_label(agent)}")
     if agent.description:
         console.print(f"  [bold]Description:[/bold] {agent.description}")
     prompt_src = agent.prompt_file or ("(inline)" if agent.system_prompt else "(base prompt)")
@@ -198,6 +239,7 @@ def agent_status() -> None:
 
     console.print(f"[bold cyan]Agent:[/bold cyan] {agent.name}  [dim]{agent.id}[/dim]")
     console.print(f"  [bold]Model:[/bold] {agent.model}")
+    console.print(f"  [bold]Endpoint:[/bold] {_endpoint_label(agent)}")
 
     pid = read_running_pid(get_paths().daemon_pidfile)
     if pid is not None:
@@ -250,6 +292,7 @@ def edit_agent(
     allow_spawn: Annotated[
         bool | None, typer.Option("--allow-spawn/--no-allow-spawn", help="Toggle spawn")
     ] = None,
+    base_url: Annotated[str | None, typer.Option("--base-url", help=_BASE_URL_HELP)] = None,
     tools_profile: Annotated[
         str | None,
         typer.Option(
@@ -268,7 +311,16 @@ def edit_agent(
         return
     if tools_profile is not None and tools_profile not in PROFILE_NAMES:
         fail(f"Unknown tools profile '{tools_profile}'. Choose one of: {', '.join(PROFILE_NAMES)}.")
-    edits = (model, prompt, prompt_file, description, workspace, allow_spawn, tools_profile)
+    edits = (
+        model,
+        prompt,
+        prompt_file,
+        description,
+        workspace,
+        allow_spawn,
+        tools_profile,
+        base_url,
+    )
     if all(v is None for v in edits):
         console.print("[yellow]No changes specified.[/yellow]")
         raise typer.Exit(0)
@@ -286,11 +338,16 @@ def edit_agent(
         agent.workspace = workspace
     if allow_spawn is not None:
         agent.allow_spawn = allow_spawn
+    if base_url is not None:
+        # "" clears the override; anything else must be a usable URL.
+        agent.base_url = _checked_base_url(base_url)
     if tools_profile is not None:
         # "full" is the default; store it as unset so the file stays minimal.
         agent.tools.profile = None if tools_profile == DEFAULT_PROFILE else tools_profile
     agent_mod.save_agent(agent)
     console.print(f"[green]Updated agent '{agent.name}'[/green]")
+    if base_url is not None:
+        console.print(f"[dim]Endpoint: {_endpoint_label(agent)}[/dim]")
 
 
 def remove_agent(
@@ -413,7 +470,7 @@ def list_models(
     ] = None,
 ) -> None:
     """List models you can assign to an agent (catalog of configured providers)."""
-    from cadecoder.providers import provider_registry
+    from cadecoder.providers import provider_for_model, provider_registry
     from cadecoder.providers.base import ProviderType
 
     current_model: str | None = None
@@ -421,6 +478,15 @@ def list_models(
     if current is not None:
         current_model = current.model
 
+    # An agent with its own endpoint should see what that endpoint serves —
+    # a gateway's catalogue can differ from the provider's own.
+    endpoint_provider = None
+    if current is not None and current.base_url:
+        try:
+            endpoint_provider = provider_for_model(current.model, current.base_url)
+        except ValueError as e:
+            console.print(f"[yellow]Agent '{current.name}' has an unusable base_url: {e}[/yellow]")
+
     wanted = provider or "all"
     table = Table(title="Available models", show_header=True, header_style="bold cyan")
     table.add_column("Model", style="cyan")
@@ -432,6 +498,8 @@ def list_models(
         if wanted not in ("all", ptype.value):
             continue
         prov = provider_registry.get(ptype)
+        if endpoint_provider is not None and endpoint_provider.provider_type == ptype:
+            prov = endpoint_provider
         if prov is None:
             continue
         try:
@@ -453,6 +521,11 @@ def list_models(
     console.print(table)
     if current_model:
         console.print(f"\n[dim]Current agent model: {current_model}[/dim]")
+    if endpoint_provider is not None:
+        console.print(
+            f"[dim]{endpoint_provider.provider_type.value} models listed from "
+            f"{endpoint_provider.base_url} (this agent's endpoint)[/dim]"
+        )
     console.print(
         "[dim]Assign with: cade agent new <name> --model <model> · "
         "cade agent edit <name> --model[/dim]"

{cade_cli-0.21.0 → cade_cli-0.22.0}/src/cadecoder/cli/commands/tools.py

@@ -1,6 +1,7 @@
 """CLI commands for viewing and managing tools."""
 
 import asyncio
+from dataclasses import dataclass, field
 from typing import Annotated
 
 import typer
@@ -35,31 +36,57 @@ def _get_tool_description(tool: dict) -> str:
     return desc
 
 
-async def _load_tools() -> tuple[
-    list[dict], dict[str, str], dict[str, str], list[tuple[str, str | None]]
-]:
-    """Load tools from the composite manager.
+@dataclass
+class _LoadedTools:
+    """One load of the tool surface, plus everything left out of it.
 
-    Returns:
-        ``(tools, source_map, hidden, auth_warnings)`` where ``hidden`` maps each
-        registered tool the session does not advertise (and each hidden action,
-        keyed ``Tool(action=x)``) to the reason.
+    Three different filters can remove a tool from the advertised list, and a
+    user asking "where did my tool go?" needs to know which one did it — so
+    each is reported separately rather than folded into one bucket.
     """
+
+    tools: list[dict] = field(default_factory=list)
+    source_map: dict[str, str] = field(default_factory=dict)
+    server_map: dict[str, str] = field(default_factory=dict)
+    auth_warnings: list[tuple[str, str | None]] = field(default_factory=list)
+    #: Capability gate — the tool could not work here. Still callable.
+    suppressed: dict[str, str] = field(default_factory=dict)
+    #: Tool policy (profile + allow/deny) — the user excluded it. Not callable.
+    policy_filtered: list[str] = field(default_factory=list)
+    #: CADE_TOOL_SURFACE=minimal — reachable via Local_ToolSchema.
+    withheld_by_surface: list[str] = field(default_factory=list)
+    surface_mode: str = "full"
+    #: Merged tools advertised with some actions removed: tool -> {action: why}.
+    trimmed_actions: dict[str, dict[str, str]] = field(default_factory=dict)
+
+
+async def _load_tools() -> _LoadedTools:
+    """Load tools from the composite manager."""
     tool_manager = CompositeToolManager(enable_mcp=True, local_only=False)
     tools = await tool_manager.get_tools()
 
     source_map: dict[str, str] = {}
-    for info in tool_manager.get_all_tool_info():
-        source_map[info["name"]] = info["source"]
+    server_map: dict[str, str] = {}
 
-    hidden = tool_manager.get_suppressed_tools()
-    for name, actions in tool_manager.get_hidden_actions().items():
-        for action, reason in actions.items():
-            hidden[f"{name}(action={action})"] = reason
-    auth_warnings = getattr(tool_manager, "_auth_warnings", [])
+    for info in tool_manager.get_all_tool_info():
+        tool_name = info["name"]
+        source_map[tool_name] = info["source"]
+        server_map[tool_name] = info.get("server", "")
+
+    loaded = _LoadedTools(
+        tools=tools,
+        source_map=source_map,
+        server_map=server_map,
+        auth_warnings=getattr(tool_manager, "_auth_warnings", []),
+        suppressed=tool_manager.suppressed_tools(),
+        policy_filtered=tool_manager.policy_filtered_tools(),
+        withheld_by_surface=tool_manager.withheld_by_surface(),
+        trimmed_actions=tool_manager.trimmed_actions(),
+        surface_mode=tool_manager.surface_mode(),
+    )
 
     await tool_manager.close()
-    return tools, source_map, hidden, auth_warnings
+    return loaded
 
 
 def _serve_status(name: str, policy: dict[str, bool] | None) -> str:
@@ -170,48 +197,6 @@ def _display_tools(
         console.print(f"\n[dim]Total: {total_count} tools[/dim]")
 
 
-def _display_hidden_tools(
-    hidden: dict[str, str],
-    source_map: dict[str, str],
-    source_filter: str | None,
-    server: str | None,
-    search: str | None,
-) -> None:
-    """List registered tools this session does not advertise, with the reason.
-
-    A tool can be hidden by a capability gate (e.g. ``Local_Git`` outside a git
-    work tree) or by the agent's ``[tools]`` policy; a single action can be
-    hidden too (``Local_Agent(action=spawn)`` for an agent without
-    ``allow_spawn``). Shown so an absence is explainable rather than mysterious.
-    """
-    rows = sorted(hidden.items())
-    if source_filter is not None:
-        # Hidden actions are keyed "Tool(action=x)"; their source is the tool's.
-        rows = [
-            (n, r)
-            for n, r in rows
-            if source_map.get(n.split("(", 1)[0], "").lower() == source_filter
-        ]
-    if server:
-        rows = [(n, r) for n, r in rows if n.startswith(f"{server}_")]
-    if search:
-        query = search.lower()
-        rows = [(n, r) for n, r in rows if query in n.lower()]
-    if not rows:
-        return
-
-    table = Table(title="Hidden this session", show_lines=False, box=None)
-    table.add_column("Name", style="dim", no_wrap=True, width=45)
-    table.add_column("Why", style="dim", max_width=70)
-    for name, reason in rows:
-        table.add_row(name, reason)
-    console.print()
-    console.print(table)
-    console.print(
-        "[dim]Capability gates can be lifted for debugging with CADE_DISABLE_TOOL_GATING=1.[/dim]"
-    )
-
-
 def _display_discovered_tools(
     show_all: bool, search: str | None = None, server: str | None = None
 ) -> None:
@@ -275,6 +260,45 @@ def _display_discovered_tools(
     )
 
 
+def _display_omissions(loaded: _LoadedTools) -> None:
+    """Report every tool left out of the advertised list, and which filter did it.
+
+    A tool that silently vanished is harder to debug than one that fails, so
+    each omission is printed with its reason and the way to undo it.
+    """
+    if loaded.suppressed:
+        console.print(
+            f"\n[dim]{len(loaded.suppressed)} built-in tool(s) not advertised "
+            "(capability unavailable; still callable):[/dim]"
+        )
+        for name, reason in sorted(loaded.suppressed.items()):
+            console.print(f"  [dim]{name} — {reason}[/dim]")
+        console.print("  [dim]Set CADE_DISABLE_TOOL_GATING=1 to advertise them anyway.[/dim]")
+
+    if loaded.policy_filtered:
+        console.print(
+            f"\n[dim]{len(loaded.policy_filtered)} tool(s) excluded by this agent's "
+            "tool policy (not callable):[/dim]"
+        )
+        console.print(f"  [dim]{', '.join(sorted(loaded.policy_filtered))}[/dim]")
+        # Escape the literal table name: Rich reads a bare [tools] as markup.
+        console.print(r"  [dim]Edit the \[tools] profile/allow/deny in the agent's config.[/dim]")
+
+    if loaded.trimmed_actions:
+        console.print("\n[dim]Actions not offered on merged tools (the rest remain):[/dim]")
+        for tool, actions in sorted(loaded.trimmed_actions.items()):
+            detail = ", ".join(f"{a} — {why}" for a, why in sorted(actions.items()))
+            console.print(f"  [dim]{tool}: {detail}[/dim]")
+
+    if loaded.withheld_by_surface:
+        console.print(
+            f"\n[dim]{len(loaded.withheld_by_surface)} built-in(s) withheld by "
+            f"CADE_TOOL_SURFACE={loaded.surface_mode} "
+            "(the model loads them on demand via Local_ToolSchema):[/dim]"
+        )
+        console.print(f"  [dim]{', '.join(sorted(loaded.withheld_by_surface))}[/dim]")
+
+
 def _display_auth_warnings(auth_warnings: list[tuple[str, str | None]]) -> None:
     """Display authorization warnings for servers that need OAuth."""
     for server_name, auth_url in auth_warnings:
@@ -286,13 +310,19 @@ def _display_auth_warnings(auth_warnings: list[tuple[str, str | None]]) -> None:
 
 
 def _resolve_serve_policy() -> tuple[str, list[str], list[str]]:
-    """Return (agent_name, allow, deny) for the current agent's serve tool policy."""
+    """Return (agent_name, allow, deny) for the current agent's serve tool policy.
+
+    Resolves the profile the same way the hook and the composite manager do,
+    so the annotation shown here matches what actually runs.
+    """
     from cadecoder.core import agent as agent_mod
+    from cadecoder.daemon.allowlist import resolve_settings
     from cadecoder.daemon.config import load_config
 
     cfg = load_config()
     agent_name = agent_mod.get_active_agent().name
-    return agent_name, list(cfg.tools.allow or []), list(cfg.tools.deny or [])
+    allow, deny = resolve_settings(cfg.tools)
+    return agent_name, allow, deny
 
 
 def _list_tools_impl(
@@ -324,10 +354,14 @@ def _list_tools_impl(
         pass
     if is_verbose():
         console.print("[cyan]Loading tools (verbose)...[/cyan]")
-        tools, source_map, hidden, auth_warnings = asyncio.run(_load_tools())
+        loaded = asyncio.run(_load_tools())
     else:
         with console.status("[cyan]Loading tools...", spinner="dots"):
-            tools, source_map, hidden, auth_warnings = asyncio.run(_load_tools())
+            loaded = asyncio.run(_load_tools())
+
+    tools = loaded.tools
+    source_map = loaded.source_map
+    auth_warnings = loaded.auth_warnings
 
     # Resolve the serve allow/deny policy when requested.
     policy: dict[str, bool] | None = None
@@ -336,8 +370,8 @@ def _list_tools_impl(
         from cadecoder.daemon.allowlist import is_tool_reachable
 
         agent_name, allow, deny = _resolve_serve_policy()
-        # Reachable, not just allowed by name: a merged tool permitted only via
-        # a former name (allow = ["Local_TaskList"]) is listed with those actions.
+        # Reachable, not allowed-by-name: Local_Task under allow = ["Local_TaskList"]
+        # is usable (list/get) even though its own name matches nothing.
         policy = {
             _get_tool_name(t): is_tool_reachable(_get_tool_name(t), allow, deny) for t in tools
         }
@@ -382,15 +416,15 @@ def _list_tools_impl(
     effective_show_all = show_all or source_filter is not None
     _display_tools(tools, source_map, server, effective_show_all, policy=policy, search=search)
 
-    if show_all or source_filter is not None or apply_policy:
-        _display_hidden_tools(hidden, source_map, source_filter, server, search)
-
     # Append discovered tools (cached SelectTools schemas), filtered by the same
     # search/server query so a search reaches the whole Arcade catalog cache.
     # Skip when filtering to local-only — discovered Arcade tools are MCP.
     if not server and source_filter != "local":
         _display_discovered_tools(show_all=show_all, search=search)
 
+    if show_all or source_filter == "local":
+        _display_omissions(loaded)
+
     if auth_warnings:
         _display_auth_warnings(auth_warnings)
 
@@ -458,9 +492,7 @@ def tool_info(
 ) -> None:
     """Show detailed information about a tool."""
 
-    async def get_tool_details() -> tuple[
-        dict | None, str | None, list[tuple[str, str | None]], str | None
-    ]:
+    async def get_tool_details() -> tuple[dict | None, str | None, list[tuple[str, str | None]]]:
         tool_manager = CompositeToolManager(enable_mcp=True, local_only=False)
         tools = await tool_manager.get_tools()
 
@@ -473,26 +505,19 @@ def tool_info(
         actual_name = tool.get("function", {}).get("name", name) if tool else name
         source = tool_manager.get_tool_source(actual_name)
         auth_warnings = getattr(tool_manager, "_auth_warnings", [])
-        hidden_reason = next(
-            (r for n, r in tool_manager.get_suppressed_tools().items() if n.lower() == name_lower),
-            None,
-        )
 
         await tool_manager.close()
-        return tool, source, auth_warnings, hidden_reason
+        return tool, source, auth_warnings
 
     if is_verbose():
         console.print("[cyan]Loading tool info (verbose)...[/cyan]")
-        tool, source, auth_warnings, hidden_reason = asyncio.run(get_tool_details())
+        tool, source, auth_warnings = asyncio.run(get_tool_details())
     else:
         with console.status("[cyan]Loading tool info...", spinner="dots"):
-            tool, source, auth_warnings, hidden_reason = asyncio.run(get_tool_details())
+            tool, source, auth_warnings = asyncio.run(get_tool_details())
 
     if not tool:
-        if hidden_reason:
-            console.print(f"[yellow]Tool '{name}' is hidden this session: {hidden_reason}[/yellow]")
-        else:
-            console.print(f"[red]Tool '{name}' not found.[/red]")
+        console.print(f"[red]Tool '{name}' not found.[/red]")
         raise typer.Exit(1)
 
     func = tool.get("function", {})

{cade_cli-0.21.0 → cade_cli-0.22.0}/src/cadecoder/core/agent.py

@@ -38,20 +38,28 @@ class AgentKind(str, Enum):
 
 
 class ToolPolicy(BaseModel):
-    """Allow/deny patterns gating which tools an agent may call.
+    """Which tools an agent may see and call.
 
     ``None`` means "no policy was ever written for this agent", which is not the
     same as an explicit empty list. An empty list is a deliberate choice to
     impose no restriction on that side, and seeding code must leave it alone.
     Agent files written before this distinction existed simply have no
     ``[tools]`` table, which loads as unset — the seeding behaviour they had.
+
+    ``profile`` names a preset bundle of allow patterns (``coding``,
+    ``research``, ``agentic``, ``full``; see
+    :mod:`cadecoder.tools.manager.profiles`). It is a floor rather than a
+    ceiling: ``allow`` is unioned on top of it and ``deny`` still wins over
+    both. Unset, or ``full``, imposes no restriction.
+
+    The policy governs the advertised tool list as well as execution — a tool
+    the agent may not run is not shown to the model in the first place.
     """
 
     model_config = ConfigDict(extra="ignore")
+    profile: str | None = None
     allow: list[str] | None = None
     deny: list[str] | None = None
-    # Named built-in tool preset (see cadecoder.tools.profiles); None = "full".
-    profile: str | None = None
 
     def is_configured(self) -> bool:
         """Return whether a tool policy has ever been set on this agent."""
@@ -121,6 +129,13 @@ class AgentConfig(BaseModel):
     # Brain
     model: str = constants.DEFAULT_AI_MODEL
     provider: str | None = None
+    # Endpoint for this agent's model provider — a gateway, proxy, or
+    # compatible server. Unset uses the process-wide endpoint (env or
+    # cade.toml [model_settings] host), which for most agents is the provider's
+    # own API. Validated when the provider is built, not here: a typo in a
+    # hand-edited agent file should fail that agent's turns with a clear
+    # message, not make the file unloadable.
+    base_url: str | None = None
     temperature: float | None = None
     # Overrides the model registry's context window (tokens) for this agent.
     context_window: int | None = None
@@ -375,6 +390,7 @@ def new_agent(
     workspace: str | None = None,
     allow_spawn: bool = False,
     tools: ToolPolicy | None = None,
+    base_url: str | None = None,
     kind: AgentKind = AgentKind.TOP_LEVEL,
     parent_id: str | None = None,
     root_id: str | None = None,
@@ -391,6 +407,8 @@ def new_agent(
         replace_base: Replace the base prompt entirely vs. prepend.
         workspace: File-tool sandbox root.
         allow_spawn: Whether this agent may spawn task-agents.
+        base_url: Model-provider endpoint for this agent; ``None`` uses the
+            process-wide default.
         tools: Tool allow/deny policy.
         kind: Top-level (user) or task-agent (spawned).
         parent_id: Parent agent id (task-agents).
@@ -419,6 +437,7 @@ def new_agent(
         replace_base=replace_base,
         workspace=workspace,
         allow_spawn=allow_spawn,
+        base_url=base_url,
         tools=tools or ToolPolicy(),
         kind=kind,
         parent_id=parent_id,

{cade_cli-0.21.0 → cade_cli-0.22.0}/src/cadecoder/core/spawn.py

@@ -195,6 +195,9 @@ async def spawn_task_agent(
     child = agent_mod.new_agent(
         name or _auto_name(),
         model=parent.model,
+        # Same endpoint as the parent: a child silently falling back to the
+        # default endpoint would send the parent's task somewhere it chose not to.
+        base_url=parent.base_url,
         description=f"Task-agent spawned by {parent.name}",
         tools=parent.tools,
         kind=AgentKind.TASK_AGENT,