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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cade-cli
-Version: 0.20.0
+Version: 0.20.2
 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
@@ -78,6 +78,7 @@ Requires-Dist: mkdocs-material<10.0.0,>=9.5.0; extra == 'docs'
 Requires-Dist: mkdocs<2.0.0,>=1.6.0; extra == 'docs'
 Provides-Extra: otel
 Requires-Dist: opentelemetry-api<2.0.0,>=1.27.0; extra == 'otel'
+Requires-Dist: opentelemetry-exporter-otlp-proto-grpc<2.0.0,>=1.27.0; extra == 'otel'
 Requires-Dist: opentelemetry-exporter-otlp-proto-http<2.0.0,>=1.27.0; extra == 'otel'
 Requires-Dist: opentelemetry-sdk<2.0.0,>=1.27.0; extra == 'otel'
 Provides-Extra: training

{cade_cli-0.20.0 → cade_cli-0.20.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cade-cli"
-version = "0.20.0"
+version = "0.20.2"
 description = "Cade - The CLI Agent from Arcade.dev (install: curl -fsSL https://arcadeagent.dev/install | sh)"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -89,6 +89,7 @@ otel = [
     "opentelemetry-api>=1.27.0,<2.0.0",
     "opentelemetry-sdk>=1.27.0,<2.0.0",
     "opentelemetry-exporter-otlp-proto-http>=1.27.0,<2.0.0",
+    "opentelemetry-exporter-otlp-proto-grpc>=1.27.0,<2.0.0",
 ]
 training = [
     "torch>=2.1.0",

{cade_cli-0.20.0 → cade_cli-0.20.2}/src/cadecoder/host_plugin/assets/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cade",
   "description": "Your persistent on-device agent: notes memory, durable tasks, and connected tools via Ask.",
-  "version": "0.20.0",
+  "version": "0.20.2",
   "author": {
     "name": "Arcade.dev",
     "url": "https://docs.cade.dev"

{cade_cli-0.20.0 → cade_cli-0.20.2}/src/cadecoder/host_plugin/assets/.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "cade",
   "displayName": "Cade",
   "description": "Your persistent on-device agent: notes memory, durable tasks, and connected tools via Ask.",
-  "version": "0.20.0",
+  "version": "0.20.2",
   "author": {
     "name": "Arcade.dev",
     "email": "support@arcade.dev"

{cade_cli-0.20.0 → cade_cli-0.20.2}/src/cadecoder/providers/http_client.py

@@ -1,9 +1,11 @@
 """Shared httpx client helpers for LLM providers.
 
 Frozen/PyInstaller builds have hit ``zlib.error: Error -3 while decompressing
-data: incorrect header check`` on Anthropic SSE streams when httpx negotiates
-brotli (``br``) or otherwise mishandles ``Content-Encoding``. Pinning
-``Accept-Encoding`` to gzip/deflate avoids that path while keeping compression.
+data: incorrect header check`` on Anthropic/OpenAI-compatible SSE streams when
+httpx negotiates compression and the body is not actually compressed — common
+with local vLLM/Ollama and some proxies. Default ``Accept-Encoding: identity``
+so the client never attempts to decompress streams. Override with
+``CADE_HTTP_ACCEPT_ENCODING`` (e.g. ``gzip, deflate``) if you want compression.
 
 Also: shell profiles often export ``SSL_CERT_FILE`` / ``REQUESTS_CA_BUNDLE`` to a
 path that exists on one machine and not another. httpx then raises
@@ -20,9 +22,10 @@ from pathlib import Path
 
 import httpx
 
-# Do not advertise ``br`` / ``zstd`` — those decoders are fragile in frozen
-# binaries and have produced "incorrect header check" failures on streams.
-_SAFE_ACCEPT_ENCODING = "gzip, deflate"
+# Never advertise ``br`` / ``zstd`` / ``gzip`` by default — those decoders are
+# fragile in frozen binaries and with OpenAI-compatible SSE servers that omit
+# or mis-set Content-Encoding ("incorrect header check").
+_DEFAULT_ACCEPT_ENCODING = "identity"
 
 _SSL_ENV_KEYS = ("SSL_CERT_FILE", "REQUESTS_CA_BUNDLE", "CURL_CA_BUNDLE")
 
@@ -30,6 +33,12 @@ _SSL_ENV_KEYS = ("SSL_CERT_FILE", "REQUESTS_CA_BUNDLE", "CURL_CA_BUNDLE")
 CLEARED_SSL_ENV_KEYS: list[str] = []
 
 
+def accept_encoding_header() -> str:
+    """Return the Accept-Encoding value for provider HTTP clients."""
+    raw = os.environ.get("CADE_HTTP_ACCEPT_ENCODING", "").strip()
+    return raw or _DEFAULT_ACCEPT_ENCODING
+
+
 def scrub_broken_ssl_env() -> list[str]:
     """Unset SSL CA env vars that point at missing files.
 
@@ -94,7 +103,7 @@ def make_async_http_client(*, timeout: float = 600.0) -> httpx.AsyncClient:
     """Return an AsyncClient safe for Anthropic/OpenAI streaming in frozen apps."""
     prepare_ssl_env()
     return httpx.AsyncClient(
-        headers={"Accept-Encoding": _SAFE_ACCEPT_ENCODING},
+        headers={"Accept-Encoding": accept_encoding_header()},
         timeout=httpx.Timeout(timeout, connect=10.0),
         follow_redirects=True,
         verify=ssl_verify(),
@@ -105,7 +114,7 @@ def make_sync_http_client(*, timeout: float = 60.0) -> httpx.Client:
     """Return a sync Client with the same encoding constraints."""
     prepare_ssl_env()
     return httpx.Client(
-        headers={"Accept-Encoding": _SAFE_ACCEPT_ENCODING},
+        headers={"Accept-Encoding": accept_encoding_header()},
         timeout=httpx.Timeout(timeout, connect=10.0),
         follow_redirects=True,
         verify=ssl_verify(),
@@ -126,6 +135,7 @@ def is_decompress_error(exc: BaseException) -> bool:
 
 __all__ = [
     "CLEARED_SSL_ENV_KEYS",
+    "accept_encoding_header",
     "is_decompress_error",
     "make_async_http_client",
     "make_sync_http_client",

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

@@ -220,12 +220,18 @@ class OpenAIProvider(Provider):
         # Ask OpenAI (and compatible servers that honor it) for a final usage
         # chunk so OTEL spans can record prompt/completion tokens. Some local
         # OpenAI-compatible servers reject stream_options — fall back cleanly.
-        want_usage = os.environ.get("CADE_OTEL", "").strip().lower() in (
-            "1",
-            "true",
-            "yes",
-            "on",
-        )
+        want_usage = False
+        if os.environ.get("CADE_OTEL", "").strip().lower() in ("1", "true", "yes", "on"):
+            # Official OpenAI honors stream_options; many local OpenAI-compatible
+            # servers (vLLM, etc.) mishandle it. Opt in for custom base_url with
+            # CADE_OTEL_STREAM_USAGE=1.
+            force_usage = os.environ.get("CADE_OTEL_STREAM_USAGE", "").strip().lower() in (
+                "1",
+                "true",
+                "yes",
+                "on",
+            )
+            want_usage = force_usage or not self.base_url
         if want_usage:
             openai_request["stream_options"] = {"include_usage": True}
 

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

@@ -2,21 +2,31 @@
 
 Soft-depends on ``opentelemetry-*``: when the extra is missing or tracing is
 disabled, every public helper is a no-op so callers never need a try/except.
+
+Export defaults to OTLP HTTP at Phoenix (``http://127.0.0.1:6006/v1/traces``).
+When the optional gRPC exporter is installed and Phoenix's gRPC port is
+reachable, prefer gRPC (``127.0.0.1:4317``) — Phoenix's HTTP OTLP path is
+known to intermittently reset connections under load, which used to dump
+full SDK tracebacks into the chat TTY.
 """
 
 from __future__ import annotations
 
 import json
+import logging
 import os
 import time
-from collections.abc import Iterator
+from collections.abc import Iterator, Sequence
 from contextlib import contextmanager
 from typing import Any
+from urllib.parse import urlparse
 
 from cadecoder.core.logging import log
 
 _TRACER_NAME = "cade"
-_DEFAULT_ENDPOINT = "http://127.0.0.1:6006/v1/traces"
+_DEFAULT_HTTP_ENDPOINT = "http://127.0.0.1:6006/v1/traces"
+_DEFAULT_GRPC_ENDPOINT = "127.0.0.1:4317"
+_MAX_MESSAGE_PART_ATTRS = 40
 _initialized = False
 _enabled = False
 
@@ -30,6 +40,143 @@ def is_enabled() -> bool:
     return _enabled
 
 
+def _silence_otel_loggers() -> None:
+    """Keep OTEL SDK export failures out of the chat TTY.
+
+    Cade configures file-only logging and clears root handlers. Without a
+    handler, Python's ``lastResort`` prints WARNING+ (including the OTEL
+    exporter's ``logging.exception`` tracebacks) straight to stderr — which
+    lands in the middle of ``cade chat``.
+    """
+    for name in (
+        "opentelemetry",
+        "opentelemetry.sdk",
+        "opentelemetry.sdk.trace",
+        "opentelemetry.sdk.trace.export",
+        "opentelemetry.exporter",
+        "opentelemetry.exporter.otlp",
+        "opentelemetry.exporter.otlp.proto.http",
+        "opentelemetry.exporter.otlp.proto.http.trace_exporter",
+        "opentelemetry.exporter.otlp.proto.grpc",
+        "opentelemetry.exporter.otlp.proto.grpc.trace_exporter",
+    ):
+        logger = logging.getLogger(name)
+        logger.handlers.clear()
+        logger.addHandler(logging.NullHandler())
+        logger.propagate = False
+        logger.setLevel(logging.CRITICAL)
+
+
+class _QuietSpanExporter:
+    """Wrap an OTEL span exporter so failures stay out of the chat UI."""
+
+    def __init__(self, inner: Any, *, label: str) -> None:
+        self._inner = inner
+        self._label = label
+        self._failures = 0
+
+    def export(self, spans: Sequence[Any]) -> Any:
+        from opentelemetry.sdk.trace.export import SpanExportResult
+
+        try:
+            result = self._inner.export(spans)
+        except Exception as exc:  # noqa: BLE001
+            self._note_failure(exc)
+            return SpanExportResult.FAILURE
+        if result == SpanExportResult.FAILURE:
+            self._note_failure(RuntimeError(f"{self._label} returned FAILURE"))
+        return result
+
+    def shutdown(self) -> None:
+        shutdown = getattr(self._inner, "shutdown", None)
+        if callable(shutdown):
+            try:
+                shutdown()
+            except Exception as exc:  # noqa: BLE001
+                log.debug(f"otel exporter shutdown failed: {exc}")
+
+    def force_flush(self, timeout_millis: int = 30000) -> bool:
+        flush = getattr(self._inner, "force_flush", None)
+        if not callable(flush):
+            return True
+        try:
+            return bool(flush(timeout_millis))
+        except Exception as exc:  # noqa: BLE001
+            self._note_failure(exc)
+            return False
+
+    def _note_failure(self, exc: BaseException) -> None:
+        self._failures += 1
+        # Rate-limit: first 3, then every 25th — enough signal without spam.
+        if self._failures <= 3 or self._failures % 25 == 0:
+            log.warning(
+                f"otel export via {self._label} failed ({self._failures}x): {exc} "
+                f"— is Phoenix up? (`make otel-ui`, endpoint "
+                f"{os.environ.get('OTEL_EXPORTER_OTLP_TRACES_ENDPOINT') or _DEFAULT_HTTP_ENDPOINT})"
+            )
+
+
+def _resolve_http_endpoint() -> str:
+    endpoint = (
+        os.environ.get("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT")
+        or os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT")
+        or _DEFAULT_HTTP_ENDPOINT
+    ).rstrip("/")
+    if not endpoint.endswith("/v1/traces"):
+        endpoint = f"{endpoint}/v1/traces"
+    return endpoint
+
+
+def _resolve_grpc_endpoint(http_endpoint: str) -> str:
+    explicit = (
+        os.environ.get("OTEL_EXPORTER_OTLP_TRACES_GRPC_ENDPOINT")
+        or os.environ.get("CADE_OTEL_GRPC_ENDPOINT")
+        or ""
+    ).strip()
+    if explicit:
+        return explicit.removeprefix("http://").removeprefix("https://")
+    # When pointing at local Phoenix HTTP, use its companion gRPC port.
+    parsed = urlparse(http_endpoint)
+    host = parsed.hostname or "127.0.0.1"
+    if host in ("127.0.0.1", "localhost", "::1") and (parsed.port in (6006, None)):
+        return f"{host}:4317"
+    return _DEFAULT_GRPC_ENDPOINT
+
+
+def _build_exporter() -> tuple[Any, str]:
+    """Return ``(exporter, label)`` preferring gRPC for local Phoenix."""
+    from opentelemetry.exporter.otlp.proto.http import Compression
+    from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+
+    http_endpoint = _resolve_http_endpoint()
+    prefer_grpc = not _truthy("CADE_OTEL_HTTP_ONLY")
+
+    if prefer_grpc:
+        try:
+            from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
+                OTLPSpanExporter as GrpcOTLPSpanExporter,
+            )
+
+            grpc_endpoint = _resolve_grpc_endpoint(http_endpoint)
+            exporter = GrpcOTLPSpanExporter(endpoint=grpc_endpoint, insecure=True)
+            return exporter, f"otlp/grpc:{grpc_endpoint}"
+        except ImportError:
+            pass
+        except Exception as exc:  # noqa: BLE001
+            log.debug(f"otel gRPC exporter unavailable, falling back to HTTP: {exc}")
+
+    try:
+        exporter = OTLPSpanExporter(
+            endpoint=http_endpoint,
+            compression=Compression.Gzip,
+            timeout=5,
+        )
+    except TypeError:
+        # Older exporter builds may not accept compression=.
+        exporter = OTLPSpanExporter(endpoint=http_endpoint, timeout=5)
+    return exporter, f"otlp/http:{http_endpoint}"
+
+
 def init_telemetry(*, force: bool = False) -> bool:
     """Initialize the tracer provider when ``CADE_OTEL=1``.
 
@@ -49,7 +196,6 @@ def init_telemetry(*, force: bool = False) -> bool:
 
     try:
         from opentelemetry import trace
-        from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
         from opentelemetry.sdk.resources import Resource
         from opentelemetry.sdk.trace import TracerProvider
         from opentelemetry.sdk.trace.export import BatchSpanProcessor, SimpleSpanProcessor
@@ -61,15 +207,17 @@ def init_telemetry(*, force: bool = False) -> bool:
         _enabled = False
         return False
 
+    _silence_otel_loggers()
+
     service_name = os.environ.get("OTEL_SERVICE_NAME", "cade").strip() or "cade"
-    endpoint = (
-        os.environ.get("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT")
-        or os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT")
-        or _DEFAULT_ENDPOINT
-    ).rstrip("/")
-    if not endpoint.endswith("/v1/traces"):
-        endpoint = f"{endpoint}/v1/traces"
+    try:
+        raw_exporter, label = _build_exporter()
+    except Exception as exc:  # noqa: BLE001
+        log.warning(f"CADE_OTEL=1 but exporter setup failed: {exc}")
+        _enabled = False
+        return False
 
+    exporter = _QuietSpanExporter(raw_exporter, label=label)
     resource = Resource.create(
         {
             "service.name": service_name,
@@ -78,19 +226,26 @@ def init_telemetry(*, force: bool = False) -> bool:
         }
     )
     provider = TracerProvider(resource=resource)
-    exporter = OTLPSpanExporter(endpoint=endpoint)
-    # Simple processor in tests / when CADE_OTEL_SYNC=1 so spans flush immediately.
     if _truthy("CADE_OTEL_SYNC"):
         provider.add_span_processor(SimpleSpanProcessor(exporter))
     else:
-        provider.add_span_processor(BatchSpanProcessor(exporter))
+        # Small batches + short delay: Phoenix's HTTP OTLP path is flaky with
+        # large concurrent exports (connection resets mid-batch).
+        provider.add_span_processor(
+            BatchSpanProcessor(
+                exporter,
+                max_queue_size=2048,
+                schedule_delay_millis=500,
+                max_export_batch_size=16,
+                export_timeout_millis=5000,
+            )
+        )
     trace.set_tracer_provider(provider)
     _enabled = True
-    # Flush on process exit so short-lived CLI turns still export.
     import atexit
 
     atexit.register(shutdown_telemetry)
-    log.info(f"OpenTelemetry tracing enabled → {endpoint} (service={service_name})")
+    log.info(f"OpenTelemetry tracing enabled → {label} (service={service_name})")
     return True
 
 
@@ -220,8 +375,8 @@ def trace_tool_call(
             "openinference.span.kind": "TOOL",
             "tool.name": name,
             "tool.call_id": tool_call_id or None,
-            "tool.parameters": _truncate(arguments) if arguments is not None else None,
-            "input.value": _truncate(arguments) if arguments is not None else None,
+            "tool.parameters": _truncate(arguments, 512) if arguments is not None else None,
+            "input.value": _truncate(arguments, 512) if arguments is not None else None,
         },
     ) as span:
         started = time.perf_counter()
@@ -268,12 +423,15 @@ def record_message_parts(
     """Record per-message role + estimated tokens for the prompt sent to the LLM.
 
     Uses a cheap length heuristic so every thread message is visible in the
-    trace even when the provider does not report official usage yet.
+    trace even when the provider does not report official usage yet. Caps
+    per-message attributes so long threads (email triage, etc.) do not blow
+    up OTLP payloads.
     """
     if span is None or not messages:
         return
     by_role: dict[str, int] = {}
     parts: list[dict[str, Any]] = []
+    attributed = 0
     for index, message in enumerate(messages):
         role = str(message.get("role") or "unknown")
         content = message.get("content")
@@ -293,15 +451,18 @@ def record_message_parts(
                 "index": index,
                 "role": role,
                 "estimated_tokens": estimated,
-                "content": _truncate(text, 240),
+                "content": _truncate(text, 160),
             }
         )
-        span.set_attribute(f"cade.message.{index}.role", role)
-        span.set_attribute(f"cade.message.{index}.estimated_tokens", estimated)
-    span.set_attribute("cade.messages.count", len(parts))
+        if attributed < _MAX_MESSAGE_PART_ATTRS:
+            span.set_attribute(f"cade.message.{index}.role", role)
+            span.set_attribute(f"cade.message.{index}.estimated_tokens", estimated)
+            attributed += 1
+    span.set_attribute("cade.messages.count", len(messages))
     for role, tokens in by_role.items():
         span.set_attribute(f"cade.tokens.by_role.{role}", tokens)
-    span.set_attribute("llm.input_messages", _truncate(parts, 8192))
+    # Bounded JSON summary — enough for Phoenix, small enough for OTLP HTTP.
+    span.set_attribute("llm.input_messages", _truncate(parts[-_MAX_MESSAGE_PART_ATTRS:], 4096))
 
 
 def _record_exception(span: Any, exc: BaseException) -> None:
@@ -316,7 +477,7 @@ def _record_exception(span: Any, exc: BaseException) -> None:
         pass
 
 
-def set_span_output(span: Any, value: Any, *, limit: int = 2048) -> None:
+def set_span_output(span: Any, value: Any, *, limit: int = 1024) -> None:
     """Record a truncated output payload on the span."""
     if span is None or value is None:
         return
@@ -337,7 +498,9 @@ def set_tool_result(
     span.set_attribute("cade.tool.status", status)
     if content is not None:
         span.set_attribute("cade.tool.result_bytes", len(content.encode("utf-8", errors="replace")))
-        set_span_output(span, content)
+        # Keep tool payloads small — Gmail/list results are huge and Phoenix's
+        # HTTP OTLP path resets connections on oversized batches.
+        set_span_output(span, content, limit=512)
     if error:
         span.set_attribute("cade.tool.error", _truncate(error, 512))
         try: