cade-cli 0.20.4__tar.gz → 0.20.6__tar.gz

{cade_cli-0.20.4 → cade_cli-0.20.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cade-cli
-Version: 0.20.4
+Version: 0.20.6
 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

{cade_cli-0.20.4 → cade_cli-0.20.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cade-cli"
-version = "0.20.4"
+version = "0.20.6"
 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.20.4 → cade_cli-0.20.6}/src/cade_mcp_local/server.py

@@ -65,13 +65,20 @@ is running. Use these tools when you need to:
 - WebFetch to read an external URL (Firecrawl via Arcade by default, httpx
   fallback; preapproved hosts return raw markdown, others go through a fast
   extraction model)
-- WebSearch to find pages on the open web (Arcade-hosted Google Search by
-  default; generic HTTP/JSON backend as a fallback)
 
 Do NOT use these tools for operations on remote systems, cloud resources, or
 external services. For those, use the appropriate remote/cloud tools instead.
 """
 
+# Appended only when a backend is actually configured (see
+# `web_search_backend_configured`) — otherwise the model is told a WebSearch
+# tool exists when `create_app` never registers it, and calls a tool name
+# that doesn't exist instead of getting a clean "not available" signal.
+_WEB_SEARCH_INSTRUCTIONS = """
+- WebSearch to find pages on the open web (Arcade-hosted Google Search by
+  default; generic HTTP/JSON backend as a fallback)
+"""
+
 
 def web_search_backend_configured() -> bool:
     """True if the WebSearch tool has a usable backend.
@@ -88,10 +95,12 @@ def web_search_backend_configured() -> bool:
 
 def create_app() -> MCPApp:
     """Create and configure the MCP application with all local tools."""
+    search_available = web_search_backend_configured()
+    instructions = SERVER_INSTRUCTIONS + (_WEB_SEARCH_INSTRUCTIONS if search_available else "")
     app = MCPApp(
         name="Local",
         transport="stdio",
-        instructions=SERVER_INSTRUCTIONS,
+        instructions=instructions,
         log_level="INFO",
     )
 
@@ -142,21 +151,22 @@ def create_app() -> MCPApp:
 
     # Web tools. WebFetch always works (httpx fallback + the agent's own LLM for
     # extraction). WebSearch needs a backend — an Arcade key or a SearXNG/HTTP
-    # endpoint — so only advertise it when one is configured; otherwise the model
-    # would call it and hit a confusing "no search backend configured" error on
-    # first use. With Arcade cloud tools connected, web search comes from the
-    # Arcade catalogue (Arcade_SelectTools/UseTool) instead.
+    # endpoint — so both the tool AND its instructions bullet are gated on
+    # `search_available`; otherwise the model is told the tool exists, calls
+    # it, and gets "not a registered function" instead of a clean absence.
+    # With Arcade cloud tools connected, web search comes from the Arcade
+    # catalogue (Arcade_SelectTools/UseTool) instead.
     #
     # Note: this gates the shipped (frozen) binary, which serves the local tools
     # via this create_app(). In source/dev mode the local server is run through
     # arcade_mcp_server's directory discovery, which registers every @tool and
     # bypasses this gate — developers typically have a key set anyway.
     app.add_tool(web_fetch_tool)
-    if web_search_backend_configured():
+    if search_available:
         app.add_tool(web_search_tool)
 
     # MCP resources: server instructions + memory sources for the active persona
-    register_resources(app, SERVER_INSTRUCTIONS)
+    register_resources(app, instructions)
 
     return app
 

{cade_cli-0.20.4 → cade_cli-0.20.6}/src/cadecoder/core/agent.py

@@ -122,6 +122,8 @@ class AgentConfig(BaseModel):
     temperature: float | None = None
     # Overrides the model registry's context window (tokens) for this agent.
     context_window: int | None = None
+    # Overrides the model registry's max response tokens for this agent.
+    max_output_tokens: int | None = None
 
     # Personality
     system_prompt: str | None = None

{cade_cli-0.20.4 → cade_cli-0.20.6}/src/cadecoder/core/config.py

@@ -57,6 +57,9 @@ class GlobalConfig(BaseModel):
     # Overrides the model registry's context window (tokens). Per-agent
     # ``context_window`` in ``config/agents/<name>.toml`` takes precedence.
     context_window: int | None = None
+    # Overrides the model registry's max response tokens. Per-agent
+    # ``max_output_tokens`` in ``config/agents/<name>.toml`` takes precedence.
+    max_output_tokens: int | None = None
     debug_mode: bool = False
     voice: VoiceConfig = Field(default_factory=VoiceConfig)
     ui: UIConfig = Field(default_factory=UIConfig)
@@ -200,6 +203,11 @@ def build_runtime():
         if active_agent.context_window is not None
         else global_config.context_window
     )
+    max_output_tokens = (
+        active_agent.max_output_tokens
+        if active_agent.max_output_tokens is not None
+        else global_config.max_output_tokens
+    )
     runtime = RuntimeEnvironment(
         paths=paths,
         context_name=active_agent.id,
@@ -210,6 +218,7 @@ def build_runtime():
         provider=provider,
         temperature=temperature,
         context_window=context_window,
+        max_output_tokens=max_output_tokens,
         agent=active_agent,
     )
     runtime.ensure_dirs()

{cade_cli-0.20.4 → cade_cli-0.20.6}/src/cadecoder/core/model_specs.py

@@ -138,6 +138,26 @@ def max_output_tokens(model: str) -> int:
     return _lookup(model, MODEL_MAX_OUTPUT, DEFAULT_MAX_OUTPUT)
 
 
+def has_registered_max_output(model: str) -> bool:
+    """Whether ``model`` has an explicit entry in the max-output-tokens table.
+
+    Distinguishes a real published limit from the generic ``DEFAULT_MAX_OUTPUT``
+    fallback, so callers can prefer a different default (e.g. the configured
+    context window) for models this registry doesn't recognize — a local or
+    custom OpenAI-compatible endpoint, for instance.
+
+    Args:
+        model: Model identifier.
+
+    Returns:
+        ``True`` if an exact or prefix match exists in ``MODEL_MAX_OUTPUT``.
+    """
+    normalized = _normalize(model)
+    if normalized in MODEL_MAX_OUTPUT:
+        return True
+    return any(normalized.startswith(_normalize(key)) for key in MODEL_MAX_OUTPUT)
+
+
 def supports_temperature(model: str) -> bool:
     """Return whether ``model`` accepts a custom ``temperature``.
 

{cade_cli-0.20.4 → cade_cli-0.20.6}/src/cadecoder/core/runtime.py

@@ -24,6 +24,7 @@ class RuntimeEnvironment:
     provider: str
     temperature: float | None = None
     context_window: int | None = None
+    max_output_tokens: int | None = None
     agent: object | None = None
 
     @property

{cade_cli-0.20.4 → cade_cli-0.20.6}/src/cadecoder/daemon/client.py

@@ -92,9 +92,18 @@ class GatewayClient:
                     "method": "initialize",
                     "params": {
                         "protocolVersion": _PROTOCOL,
-                        "capabilities": {
-                            "elicitation": {},
-                        },
+                        # No "elicitation" capability: `ask()` below is a single
+                        # blocking POST per turn, with no channel for the gateway
+                        # to send a server-initiated elicitation/create request
+                        # back mid-call. Declaring the capability anyway made the
+                        # gateway's McpHostElicitationSink believe it could
+                        # forward a question here, silently eating the full
+                        # elicitation timeout (up to 295s) every time an inner
+                        # tool tried to ask one, with nothing ever shown to the
+                        # user. Omitting it makes the gateway decline instead
+                        # of hanging, so the inner tool's in-band fallback (or
+                        # a fast error) surfaces right away.
+                        "capabilities": {},
                         "clientInfo": {"name": "cade-cli", "version": "attach"},
                     },
                 }

{cade_cli-0.20.4 → cade_cli-0.20.6}/src/cadecoder/execution/orchestrator.py

@@ -8,6 +8,7 @@ from typing import Any, Literal
 from pydantic import BaseModel, Field
 
 from cadecoder.ai.prompts import build_system_prompt
+from cadecoder.core import model_specs
 from cadecoder.core.constants import (
     MAX_EXECUTION_ITERATIONS,
 )
@@ -209,6 +210,17 @@ class Orchestrator:
             context_window_override=runtime.context_window,
         )
 
+        # Response-token cap sent to the provider. Explicit config wins; else
+        # prefer the model registry's published max output, falling back to
+        # this run's effective context window for models the registry doesn't
+        # recognize (a local/custom endpoint) rather than guessing a generic
+        # default that has nothing to do with that model's real capacity.
+        self.max_output_tokens = runtime.max_output_tokens or (
+            model_specs.max_output_tokens(self.default_model)
+            if model_specs.has_registered_max_output(self.default_model)
+            else self.context_manager.context_limit
+        )
+
         # Tool result store — uses CADE_TOOL_RESULT_DIR env var (set by create_orchestrator)
         self.tool_result_store = ToolResultStore()
         self.context_manager.tool_result_store = self.tool_result_store
@@ -385,7 +397,7 @@ class Orchestrator:
                 model=self.default_model,
                 tools=tools if tools else None,
                 temperature=self.temperature,
-                max_tokens=None,
+                max_tokens=self.max_output_tokens,
                 tool_choice="auto",
                 system_prompt=None,
                 stream=True,