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

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: cade-cli
-Version: 0.20.2
+Version: 0.20.4
 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.2 → cade_cli-0.20.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cade-cli"
-version = "0.20.2"
+version = "0.20.4"
 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.2 → cade_cli-0.20.4}/src/cadecoder/core/agent.py

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

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

@@ -54,6 +54,9 @@ class GlobalConfig(BaseModel):
     provider: str = "anthropic"
     model: str = constants.DEFAULT_AI_MODEL
     temperature: float | None = None
+    # Overrides the model registry's context window (tokens). Per-agent
+    # ``context_window`` in ``config/agents/<name>.toml`` takes precedence.
+    context_window: int | None = None
     debug_mode: bool = False
     voice: VoiceConfig = Field(default_factory=VoiceConfig)
     ui: UIConfig = Field(default_factory=UIConfig)
@@ -192,6 +195,11 @@ def build_runtime():
         if active_agent.temperature is not None
         else global_config.temperature
     )
+    context_window = (
+        active_agent.context_window
+        if active_agent.context_window is not None
+        else global_config.context_window
+    )
     runtime = RuntimeEnvironment(
         paths=paths,
         context_name=active_agent.id,
@@ -201,6 +209,7 @@ def build_runtime():
         model=model,
         provider=provider,
         temperature=temperature,
+        context_window=context_window,
         agent=active_agent,
     )
     runtime.ensure_dirs()

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

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

{cade_cli-0.20.2 → cade_cli-0.20.4}/src/cadecoder/daemon/gateway/app.py

@@ -24,6 +24,7 @@ from cadecoder.daemon.gateway.exposure import LOCAL_GROUPS, ExposurePolicy
 from cadecoder.daemon.gateway.host_agent import get_host_agent
 from cadecoder.daemon.gateway.limits import PrincipalLimits
 from cadecoder.daemon.gateway.middleware import ExposureMiddleware, HostAgentMiddleware
+from cadecoder.daemon.gateway.principal import local_principal
 from cadecoder.daemon.gateway.resources import register_gateway_resources
 from cadecoder.daemon.gateway.turn_bridge import TurnBridge, TurnBridgeError
 from cadecoder.daemon.supervisor import Supervisor
@@ -56,9 +57,11 @@ def _principal_and_policy(context: Context) -> tuple[str, list[str], list[str]]:
     """
     owner = getattr(context, "_resource_owner", None)
     if owner is None:
-        return "local", [], list(LOCAL_GROUPS)
+        return local_principal(context), [], list(LOCAL_GROUPS)
     claims = getattr(owner, "claims", {}) or {}
-    principal = str(claims.get("cade_principal") or getattr(context, "user_id", "") or "local")
+    principal = str(
+        claims.get("cade_principal") or getattr(context, "user_id", "") or local_principal(context)
+    )
     agents = claims.get("cade_agents")
     expose = claims.get("cade_expose")
     return (

cade_cli-0.20.4/src/cadecoder/daemon/gateway/principal.py

@@ -0,0 +1,40 @@
+"""Shared principal fallback for unauthenticated (loopback/local) MCP callers.
+
+Used by both the ``Cade_Ask`` tool (``app.py``) and the ``threads://``
+resource listing (``resources.py``) so a thread written under one is found
+under the other.
+"""
+
+from __future__ import annotations
+
+import re
+
+from arcade_mcp_server import Context
+
+
+def client_app_name(context: Context | None) -> str | None:
+    """Best-effort slug of the connecting MCP client (e.g. ``claude``, ``cursor``).
+
+    Read from the ``clientInfo.name`` negotiated during MCP ``initialize``.
+    Returns ``None`` when unavailable, so the caller can fall back to a flat
+    ``"local"`` principal.
+    """
+    session = getattr(context, "_session", None)
+    params = getattr(session, "client_params", None)
+    client_info = getattr(params, "clientInfo", None)
+    name = getattr(client_info, "name", None)
+    if not name:
+        return None
+    slug = re.sub(r"[^a-z0-9]+", "-", name.strip().lower()).strip("-")
+    return slug or None
+
+
+def local_principal(context: Context | None) -> str:
+    """Principal for an unauthenticated (loopback/local) caller.
+
+    Scoped per connecting app when its ``clientInfo.name`` is known, so e.g.
+    Claude Desktop and Cursor each keep their own default thread rather than
+    sharing one ``local:default`` conversation across every local MCP client.
+    """
+    app_name = client_app_name(context)
+    return f"local:{app_name}" if app_name else "local"

{cade_cli-0.20.2 → cade_cli-0.20.4}/src/cadecoder/daemon/gateway/resources.py

@@ -30,6 +30,7 @@ from cadecoder.daemon.gateway.constants import (
     THREADS_URI,
 )
 from cadecoder.daemon.gateway.host_agent import active_agent_name, get_host_agent
+from cadecoder.daemon.gateway.principal import local_principal
 from cadecoder.storage.threads import BaseThreadHistory, get_thread_history
 
 if TYPE_CHECKING:
@@ -37,13 +38,15 @@ if TYPE_CHECKING:
 
 
 def _current_principal() -> str:
-    """Principal name from the active model context; 'local' when unauthenticated."""
+    """Principal name from the active model context; scoped per local app when unauthenticated."""
     context = get_current_model_context()
     owner = getattr(context, "_resource_owner", None) if context else None
     if owner is None:
-        return "local"
+        return local_principal(context)
     claims = getattr(owner, "claims", {}) or {}
-    return str(claims.get("cade_principal") or getattr(owner, "user_id", "") or "local")
+    return str(
+        claims.get("cade_principal") or getattr(owner, "user_id", "") or local_principal(context)
+    )
 
 
 def _active_agent_name() -> str:

{cade_cli-0.20.2 → cade_cli-0.20.4}/src/cadecoder/daemon/install.py

@@ -199,6 +199,22 @@ def _log_path() -> str:
 
 
 def _common_vars() -> dict[str, str]:
+    """Template substitutions for launchd/systemd unit files.
+
+    ``CADE_OTEL`` is ``1`` when the env is already set or
+    ``~/.cade/config/otel.enable`` exists, so a service reinstall picks up
+    tracing without hand-editing the unit.
+    """
+    otel_on = (
+        os.environ.get("CADE_OTEL", "").strip().lower()
+        in (
+            "1",
+            "true",
+            "yes",
+            "on",
+        )
+        or (get_runtime().paths.config_dir / "otel.enable").is_file()
+    )
     return {
         "LABEL": _LABEL,
         "CADE_BIN": _cade_binary(),
@@ -207,6 +223,7 @@ def _common_vars() -> dict[str, str]:
         "HOME": str(Path.home()),
         "PATH": os.environ.get("PATH", "/usr/local/bin:/usr/bin:/bin"),
         "LOG_PATH": _log_path(),
+        "CADE_OTEL": "1" if otel_on else "0",
     }
 
 

{cade_cli-0.20.2 → cade_cli-0.20.4}/src/cadecoder/daemon/runner.py

@@ -74,6 +74,7 @@ class InProcessRunner:
         defer_user_mcp_schemas: str = "auto",
     ) -> None:
         self.agent_name = agent_name
+        self.model = model
         self._orchestrator = orchestrator or create_orchestrator(
             default_model=model,
             persona=persona or agent_name,
@@ -84,6 +85,7 @@ class InProcessRunner:
         # threads proceed concurrently (subject to TurnRunner's global gate).
         self._thread_locks: dict[str, asyncio.Lock] = {}
         self.last_active_at = time.monotonic()
+        log.info(f"InProcessRunner ready agent={agent_name!r} model={model}")
 
     def _lock_for(self, thread_id: str) -> asyncio.Lock:
         lock = self._thread_locks.get(thread_id)
@@ -146,6 +148,15 @@ class SubprocessRunner:
         writer: asyncio.StreamWriter | None = None,
     ) -> None:
         self.agent_name = agent_name
+        # Mirror the agent's configured model so the supervisor can detect
+        # stale subprocess runners after ``cade account init``.
+        try:
+            from cadecoder.core import agent as agent_mod
+
+            agent = agent_mod.resolve(agent_name)
+            self.model = agent.model if agent is not None else ""
+        except Exception:  # noqa: BLE001
+            self.model = ""
         self.last_active_at = time.monotonic()
         self._reader = reader
         self._writer = writer

{cade_cli-0.20.2 → cade_cli-0.20.4}/src/cadecoder/daemon/supervisor.py

@@ -81,9 +81,13 @@ class Supervisor:
 
         Concurrent callers for the same agent share one start via a per-agent
         lock, so a burst of gateway calls never spawns duplicate runners.
+
+        If the agent's configured model changed since the runner was created
+        (e.g. after ``cade account init``), the stale runner is replaced so
+        chat does not keep calling the previous provider until idle eviction.
         """
         existing = self._runners.get(agent_name)
-        if existing is not None:
+        if existing is not None and not self._runner_is_stale(agent_name, existing):
             return existing
 
         async with self._lock:
@@ -94,14 +98,45 @@ class Supervisor:
 
         async with start_lock:
             existing = self._runners.get(agent_name)
-            if existing is not None:
+            if existing is not None and not self._runner_is_stale(agent_name, existing):
                 return existing
+            if existing is not None:
+                log.info(
+                    f"recycling runner for agent {agent_name!r} (config model changed since start)"
+                )
+                self._runners.pop(agent_name, None)
+                try:
+                    await existing.aclose()
+                except Exception as exc:  # noqa: BLE001
+                    log.debug(f"stale runner close failed for {agent_name!r}: {exc}")
             created = self._factory(agent_name)
             runner: RunnerHandle = await created if asyncio.iscoroutine(created) else created
             self._runners[agent_name] = runner
             log.info(f"started runner for agent {agent_name!r}")
             return runner
 
+    def _runner_is_stale(self, agent_name: str, runner: RunnerHandle) -> bool:
+        """True when the cached runner's model no longer matches agent config."""
+        try:
+            agent = agent_mod.resolve(agent_name)
+        except Exception:  # noqa: BLE001
+            return False
+        if agent is None:
+            return False
+        runner_model = getattr(runner, "model", None)
+        if runner_model is None:
+            orch = getattr(runner, "_orchestrator", None)
+            runner_model = getattr(orch, "default_model", None)
+        if not runner_model:
+            return False
+        if runner_model == agent.model:
+            return False
+        log.warning(
+            f"agent {agent_name!r} model is {agent.model!r} but runner still has "
+            f"{runner_model!r} — will recreate"
+        )
+        return True
+
     def running_agents(self) -> list[str]:
         return sorted(self._runners)
 

{cade_cli-0.20.2 → cade_cli-0.20.4}/src/cadecoder/execution/context_window.py

@@ -191,6 +191,7 @@ class ContextWindowManager:
         model: str = DEFAULT_AI_MODEL,
         backup_dir: Path | None = None,
         chars_per_token: float = 4.0,
+        context_window_override: int | None = None,
     ) -> None:
         """Initialize context window manager.
 
@@ -198,12 +199,15 @@ class ContextWindowManager:
             model: Model name for context limit lookup
             backup_dir: Directory for storing context backups
             chars_per_token: Character to token ratio for estimation
+            context_window_override: User-configured context window (tokens)
+                that takes precedence over the model registry's value
         """
         self.model = model
         self.chars_per_token = chars_per_token
 
-        # Context window and response reserve come from the central model registry.
-        self.context_limit = model_specs.context_window(model)
+        # Context window and response reserve come from the central model
+        # registry, unless the user has overridden the window size in config.
+        self.context_limit = context_window_override or model_specs.context_window(model)
         self.response_reserve = model_specs.max_output_tokens(model)
         self.effective_limit = self.context_limit - self.response_reserve
 
@@ -888,17 +892,22 @@ class ContextWindowManager:
 def create_context_manager(
     model: str = DEFAULT_AI_MODEL,
     backup_dir: Path | None = None,
+    context_window_override: int | None = None,
 ) -> ContextWindowManager:
     """Factory function to create a context window manager.
 
     Args:
         model: Model name for context limit lookup
         backup_dir: Directory for storing context backups
+        context_window_override: User-configured context window (tokens)
+            that takes precedence over the model registry's value
 
     Returns:
         Configured ContextWindowManager instance
     """
-    return ContextWindowManager(model=model, backup_dir=backup_dir)
+    return ContextWindowManager(
+        model=model, backup_dir=backup_dir, context_window_override=context_window_override
+    )
 
 
 __all__ = [

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

@@ -204,7 +204,9 @@ class Orchestrator:
         # Context window backups are scoped to the active context.
         backup_dir = runtime.context_backups_dir
         self.context_manager = context_manager or create_context_manager(
-            model=self.default_model, backup_dir=backup_dir
+            model=self.default_model,
+            backup_dir=backup_dir,
+            context_window_override=runtime.context_window,
         )
 
         # Tool result store — uses CADE_TOOL_RESULT_DIR env var (set by create_orchestrator)
@@ -295,6 +297,20 @@ class Orchestrator:
         while should_continue and iteration < MAX_EXECUTION_ITERATIONS:
             iteration += 1
             log.info(f"Execution iteration {iteration}")
+            provider_label = ""
+            try:
+                provider_label = str(
+                    getattr(getattr(self.provider, "provider_type", None), "value", "")
+                    or getattr(self.provider, "provider_type", "")
+                    or ""
+                )
+            except Exception:  # noqa: BLE001
+                provider_label = type(self.provider).__name__
+            base_url = getattr(self.provider, "base_url", None) or ""
+            log.info(
+                f"LLM call model={self.default_model} provider={provider_label or '?'} "
+                f"base_url={base_url or 'default'} tools={len(tools) if tools else 0}"
+            )
 
             # Drain task/notification queue as system messages so the LLM
             # sees pending task completions before the next provider call.

{cade_cli-0.20.2 → cade_cli-0.20.4}/src/cadecoder/providers/anthropic.py

@@ -414,7 +414,7 @@ class AnthropicProvider(Provider):
         # Convert tools from OpenAI format to Anthropic format
         if request.tools:
             anthropic_request["tools"] = self._convert_tools_to_anthropic(request.tools)
-            log.info(f"Anthropic request includes {len(request.tools)} tools")
+            log.info(f"Anthropic request model={request.model} tools={len(request.tools)}")
             tool_names = [t.get("function", {}).get("name", "unknown") for t in request.tools[:5]]
             log.debug(f"First few tools: {tool_names}")
 

{cade_cli-0.20.2 → cade_cli-0.20.4}/src/cadecoder/providers/base.py

@@ -238,7 +238,9 @@ async def stream_with_retry(
             await asyncio.sleep(delay)
 
     assert last_exc is not None
-    log.error(f"{provider.provider_type.value} streaming failed: {last_exc}")
+    log.error(
+        f"{provider.provider_type.value} streaming failed: {type(last_exc).__name__}: {last_exc!r}"
+    )
     yield StreamEvent(
         type="error",
         content=provider.format_error_for_user(last_exc),

{cade_cli-0.20.2 → cade_cli-0.20.4}/src/cadecoder/providers/openai.py

@@ -353,7 +353,10 @@ class OpenAIProvider(Provider):
 
         if request.tools:
             openai_request["tools"] = request.tools
-            log.info(f"OpenAI request includes {len(request.tools)} tools")
+            log.info(
+                f"OpenAI request model={request.model} tools={len(request.tools)} "
+                f"base_url={self.base_url or 'api.openai.com'}"
+            )
             # Log first few tool names for debugging
             tool_names = [t.get("function", {}).get("name", "unknown") for t in request.tools[:5]]
             log.debug(f"First few tools: {tool_names}")

{cade_cli-0.20.2 → cade_cli-0.20.4}/src/cadecoder/telemetry/otel.py

@@ -177,9 +177,22 @@ def _build_exporter() -> tuple[Any, str]:
     return exporter, f"otlp/http:{http_endpoint}"
 
 
+def _otel_enable_file() -> bool:
+    """True when ``~/.cade/config/otel.enable`` exists (daemon-friendly toggle)."""
+    try:
+        from cadecoder.core.paths import get_paths
+
+        return (get_paths().config_dir / "otel.enable").is_file()
+    except Exception:  # noqa: BLE001
+        return False
+
+
 def init_telemetry(*, force: bool = False) -> bool:
     """Initialize the tracer provider when ``CADE_OTEL=1``.
 
+    Also enabled when ``~/.cade/config/otel.enable`` exists so the launchd
+    daemon can emit spans without inheriting the chat process env.
+
     Safe to call multiple times. Returns True when tracing is live.
 
     Args:
@@ -190,9 +203,12 @@ def init_telemetry(*, force: bool = False) -> bool:
         return _enabled
     _initialized = True
 
-    if not _truthy("CADE_OTEL"):
+    if not _truthy("CADE_OTEL") and not _otel_enable_file():
         _enabled = False
         return False
+    # Normalize so child helpers that re-check the env see the same gate.
+    if not _truthy("CADE_OTEL"):
+        os.environ["CADE_OTEL"] = "1"
 
     try:
         from opentelemetry import trace

{cade_cli-0.20.2 → cade_cli-0.20.4}/src/cadecoder/templates/serve/launchd.plist.tmpl

@@ -30,6 +30,8 @@
         <string>{CADE_HOME}</string>
         <key>CADE_CONTEXT</key>
         <string>{CADE_CONTEXT}</string>
+        <key>CADE_OTEL</key>
+        <string>{CADE_OTEL}</string>
     </dict>
 </dict>
 </plist>

{cade_cli-0.20.2 → cade_cli-0.20.4}/src/cadecoder/templates/serve/systemd.service.tmpl

@@ -14,6 +14,7 @@ StandardError=append:{LOG_PATH}
 Environment=PATH={PATH}
 Environment=CADE_HOME={CADE_HOME}
 Environment=CADE_CONTEXT={CADE_CONTEXT}
+Environment=CADE_OTEL={CADE_OTEL}
 
 [Install]
 WantedBy=default.target

{cade_cli-0.20.2 → cade_cli-0.20.4}/src/cadecoder/ui/session.py

@@ -108,6 +108,12 @@ def _try_attach_gateway(session: "ChatSession") -> bool:
         # Probe the session so cold failures fall back before the first turn.
         session._gateway._ensure_session()
         log.info("chat session attached to cade daemon gateway")
+        if os.environ.get("CADE_OTEL", "").strip().lower() in ("1", "true", "yes", "on"):
+            log.warning(
+                "CADE_OTEL=1 is set on this chat process, but turns run inside the "
+                "daemon — export CADE_OTEL=1 for the daemon and restart it "
+                "(`cade daemon restart`), or touch ~/.cade/config/otel.enable"
+            )
         return True
     except Exception as e:  # noqa: BLE001
         # Warning (not debug): autostart is on by default; a silent fallback