cade-cli 0.15.5__tar.gz → 0.15.7__tar.gz

{cade_cli-0.15.5 → cade_cli-0.15.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cade-cli
-Version: 0.15.5
+Version: 0.15.7
 Summary: Cade - The CLI Agent from Arcade.dev
 Project-URL: Homepage, https://arcade.dev
 Project-URL: Documentation, https://docs.arcade.dev
@@ -43,7 +43,7 @@ Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Code Generators
 Classifier: Typing :: Typed
 Requires-Python: >=3.11
-Requires-Dist: agent-library<1.0.0,>=0.14.0
+Requires-Dist: agent-library<1.0.0,>=0.14.1
 Requires-Dist: anthropic<1.0.0,>=0.34.0
 Requires-Dist: arcade-core<5.0.0,>=4.7.0
 Requires-Dist: arcade-mcp-server<2.0.0,>=1.22.0

{cade_cli-0.15.5 → cade_cli-0.15.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cade-cli"
-version = "0.15.5"
+version = "0.15.7"
 description = "Cade - The CLI Agent from Arcade.dev"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -38,7 +38,7 @@ dependencies = [
     "prompt-toolkit>=3.0.52,<4.0.0",
     "httpx>=0.27.0,<1.0.0",
     "filelock>=3.0.0,<4.0.0",
-    "agent-library>=0.14.0,<1.0.0",
+    "agent-library>=0.14.1,<1.0.0",
     "croniter>=2.0.0,<4.0.0",
     "python-telegram-bot>=21.0,<22.0",
     "keyring>=24.0,<26.0",

{cade_cli-0.15.5 → cade_cli-0.15.7}/src/cade_mcp_local/resources.py

@@ -116,7 +116,7 @@ def register_resources(app: MCPApp, instructions: str) -> None:
         title="cade mem sources (active persona)",
         description=(
             "JSON listing of memory sources registered for the active persona "
-            "(equivalent to `cade mem list`). Read each call so the listing "
+            "(equivalent to `cade mem sources`). Read each call so the listing "
             "reflects sources added after server start."
         ),
         mime_type="application/json",

cade_cli-0.15.7/src/cade_mcp_local/web/extract.py

@@ -0,0 +1,115 @@
+"""Secondary-model extraction for WebFetch.
+
+Single non-streaming ``Provider.complete()`` call so the same code path
+works for Anthropic, OpenAI, and Ollama users alike. The extraction model is
+resolved from (in priority order) an explicit override, ``CADE_WEB_FETCH_MODEL``,
+the user's configured default model, then ``DEFAULT_EXTRACT_MODEL``. When the
+preferred model's provider isn't configured (e.g. a Claude default on an
+OpenAI-only setup), extraction falls back to whatever provider the user *did*
+configure rather than failing outright.
+"""
+
+from __future__ import annotations
+
+import os
+
+from cade_mcp_local.errors import WebFetchError
+from cade_mcp_local.web.prompts import make_secondary_model_prompt
+from cadecoder.providers import get_provider_for_model, provider_registry
+from cadecoder.providers.base import Provider, ProviderRequest, ProviderType
+
+DEFAULT_EXTRACT_MODEL = "claude-haiku-4-5-20251001"
+
+# Cheap/fast per-provider extraction models, used only as a fallback when the
+# preferred model's provider is unavailable but another provider is registered.
+# Extraction is a one-shot summarization pass, so a small model is sufficient.
+_FALLBACK_MODEL_BY_PROVIDER: dict[ProviderType, str] = {
+    ProviderType.ANTHROPIC: DEFAULT_EXTRACT_MODEL,
+    ProviderType.OPENAI: "gpt-5-mini",
+    ProviderType.OLLAMA: "llama3.1",
+}
+
+
+def _configured_default_model() -> str | None:
+    """Return the user's configured default model, or None if unavailable.
+
+    Reads the global settings directly so the extraction step honors whatever
+    provider/model the user set up during onboarding.
+    """
+    try:
+        from cadecoder.core.config import _load_global_settings
+
+        return _load_global_settings().model or None
+    except Exception:  # noqa: BLE001 - config is best-effort here; fall back to default
+        return None
+
+
+def _resolve_extraction_target(model: str | None) -> tuple[str, Provider]:
+    """Resolve the extraction model and a usable provider.
+
+    Args:
+        model: An explicit model override, if any.
+
+    Returns:
+        A ``(model, provider)`` tuple ready to run an extraction.
+
+    Raises:
+        LookupError: If no LLM provider is registered at all.
+    """
+    chosen = (
+        model
+        or os.environ.get("CADE_WEB_FETCH_MODEL")
+        or _configured_default_model()
+        or DEFAULT_EXTRACT_MODEL
+    )
+
+    provider = get_provider_for_model(chosen)
+    if provider is not None:
+        return chosen, provider
+
+    # The preferred model's provider isn't configured. Fall back to whatever
+    # provider the user did configure (the registry's default) so non-preapproved
+    # fetches still work on OpenAI/Ollama-only setups.
+    fallback = provider_registry.get_default()
+    if fallback is None:
+        raise LookupError("no LLM provider is registered")
+
+    fallback_model = _FALLBACK_MODEL_BY_PROVIDER.get(fallback.provider_type, chosen)
+    return fallback_model, fallback
+
+
+async def extract_with_model(
+    prompt: str,
+    markdown: str,
+    *,
+    model: str | None = None,
+    url: str = "",
+) -> tuple[str, str]:
+    """Run a one-shot extraction. Returns (answer, model_used).
+
+    ``url`` is only used to make the error message useful when no provider is
+    available or the provider rejects the request.
+    """
+    try:
+        chosen, provider = _resolve_extraction_target(model)
+    except LookupError:
+        raise WebFetchError(
+            url or "(no url)",
+            "no provider available for extraction; set ANTHROPIC_API_KEY/OPENAI_API_KEY, "
+            "configure a model via cade onboarding, or override CADE_WEB_FETCH_MODEL",
+        ) from None
+
+    full_prompt = make_secondary_model_prompt(prompt, markdown)
+    request = ProviderRequest(
+        messages=[{"role": "user", "content": full_prompt}],
+        model=chosen,
+        max_tokens=2048,
+        temperature=0.2,
+        stream=False,
+    )
+    try:
+        response = await provider.complete(request)
+    except Exception as e:
+        raise WebFetchError(url or "(no url)", f"extraction model failed: {e}") from e
+
+    return (response.content or "").strip(), chosen

{cade_cli-0.15.5 → cade_cli-0.15.7}/src/cadecoder/cli/commands/mem.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 import os
 from pathlib import Path
-from typing import Any
+from typing import Annotated, Any
 
 import typer
 from rich.console import Console
@@ -43,20 +43,29 @@ def _apply_memory_env() -> Path:
     os.environ["DOCUMENTS_PATH"] = str(librarian_dir / "documents")
     os.environ["SOURCES_CONFIG_PATH"] = str(librarian_dir / "sources.json")
     os.environ["HOME"] = str(persona_dir)
+    # Rebrand librarian's usage hints (e.g. "Add a source with: libr add ...")
+    # to "cade mem". Must be set before librarian.cli is imported, which only
+    # happens later via _load_librarian_app().
+    os.environ["LIBRARIAN_PROG_NAME"] = "cade mem"
     return persona_dir
 
 
 def _load_librarian_app() -> Any:
     """Import and return librarian's Typer app (lazy, after the env is set).
 
-    The app is rebranded under ``cade mem``: the low-level ``index`` group is
-    replaced by a top-level ``update`` command (the former ``index build``) and
-    a cade-native ``status`` command that reports the current agent's memory
-    under "Agent Memory" branding.
+    The app is rebranded under ``cade mem``:
+
+    * the low-level ``index`` group becomes a top-level ``update`` command (the
+      former ``index build``);
+    * a cade-native ``status`` command reports the current agent's memory under
+      "Agent Memory" branding;
+    * ``list`` shows the agent's memory **documents** (what users expect from
+      "list"), while the source-directory listing moves to ``sources``.
     """
     from librarian.cli import app
 
     _remap_index_to_update(app)
+    _remap_list_to_docs(app)
     _add_status_command(app)
     return app
 
@@ -93,6 +102,52 @@ def _remap_index_to_update(app: Any) -> None:
         )(build_callback)
 
 
+def _remap_list_to_docs(app: Any) -> None:
+    """Make ``cade mem list`` show memory *documents*, not source directories.
+
+    librarian's top-level ``list`` lists registered source directories — a
+    power-user concept. Under ``cade mem``, "list" should show what's actually
+    in the agent's memory (its indexed documents, including anything the agent
+    saved via ``Memory_*`` tools). So the source listing moves to
+    ``cade mem sources`` and ``list`` is replaced by a cade-native command that
+    renders documents with the same output (and flags) as the in-chat
+    ``/mem list``.
+
+    Power users keep librarian's ``cade mem docs list`` (``--source`` /
+    ``--format`` / ``paths``) untouched.
+
+    Idempotent: safe to call more than once on the same app singleton.
+    """
+    if "sources" in _command_names(app):
+        return  # already remapped
+
+    commands = list(app.registered_commands)
+    list_sources_callback = next(
+        (
+            rc.callback
+            for rc in commands
+            if (rc.name or getattr(rc.callback, "__name__", "")) == "list"
+        ),
+        None,
+    )
+    if list_sources_callback is None:
+        return  # librarian build without a top-level `list` — leave as-is
+
+    # Drop the original top-level `list` (sources), re-register it as `sources`,
+    # and install the cade-native document listing as `list`.
+    app.registered_commands = [
+        rc for rc in commands if (rc.name or getattr(rc.callback, "__name__", "")) != "list"
+    ]
+    app.command(
+        name="sources",
+        help="List the source directories that feed this agent's memory.",
+    )(list_sources_callback)
+    app.command(
+        name="list",
+        help="List the documents stored in this agent's memory.",
+    )(_cade_mem_list)
+
+
 def _add_status_command(app: Any) -> None:
     """Register the cade-native ``status`` command (idempotent)."""
     if "status" in _command_names(app):
@@ -157,6 +212,86 @@ def _mem_status() -> None:
     out.print(table)
 
 
+def _mem_list(*, json_output: bool = False, limit: int = 50) -> None:
+    """Render the documents stored in the current agent's memory.
+
+    The single source of truth for both ``cade mem list`` (CLI) and the in-chat
+    ``/mem list`` command, so the two surfaces always agree. Reads the agent's
+    index directly via ``Database(db_path=...)`` (no env / no HOME side effects)
+    so it never clobbers a long-lived session, mirroring ``_read_memory_stats``.
+
+    Args:
+        json_output: Emit a JSON array (id/title/path/type) to stdout instead of
+            a table — for scripting and piping.
+        limit: Maximum number of documents to display.
+    """
+    import json
+
+    from rich.console import Console as _Console
+    from rich.table import Table
+
+    runtime = get_runtime()
+    memory_dir = ensure_memory_dir(runtime.persona_name)
+    db_path = memory_dir / ".librarian" / "index.db"
+
+    out = _Console()
+
+    documents: list[Any] = []
+    if db_path.exists():
+        try:
+            from librarian.storage.database import Database
+
+            documents = Database(db_path=str(db_path)).list_documents()
+        except Exception as exc:  # noqa: BLE001
+            if json_output:
+                print("[]")
+            else:
+                out.print(f"[red]Could not read this agent's memory:[/red] {exc}")
+            return
+
+    if json_output:
+        payload = [
+            {
+                "id": doc.id,
+                "title": doc.title,
+                "path": doc.path,
+                "type": doc.asset_type.value if getattr(doc, "asset_type", None) else "text",
+            }
+            for doc in documents[:limit]
+        ]
+        print(json.dumps(payload, indent=2, default=str))
+        return
+
+    if not documents:
+        out.print(
+            "[dim]No documents in this agent's memory yet — add docs or run 'cade mem update'.[/dim]"
+        )
+        return
+
+    home = str(Path.home())
+    table = Table(
+        title=f"Agent Memory — {len(documents)} document(s)",
+        show_header=True,
+        header_style="bold cyan",
+    )
+    table.add_column("ID", style="dim", width=4)
+    table.add_column("Title", style="green", max_width=44)
+    table.add_column("Path", style="blue", overflow="fold")
+    for doc in documents[:limit]:
+        table.add_row(str(doc.id), doc.title or "Untitled", doc.path.replace(home, "~"))
+    out.print(table)
+    if len(documents) > limit:
+        out.print(f"[dim]Showing {limit} of {len(documents)}. Use --limit to see more.[/dim]")
+
+
+def _cade_mem_list(
+    json_output: Annotated[bool, typer.Option("--json", help="Output as JSON")] = False,
+    limit: Annotated[int, typer.Option("--limit", "-l", help="Max documents to show")] = 50,
+) -> None:
+    """List the documents stored in this agent's memory."""
+    _mem_list(json_output=json_output, limit=limit)
+
+
 def _run_mem(args: list[str]) -> int:
     """Run librarian's CLI in-process, branded as ``cade mem``.
 
@@ -244,7 +379,9 @@ def mem_command(ctx: typer.Context) -> None:
 __all__ = (
     "MEM_CONTEXT_SETTINGS",
     "_apply_memory_env",
+    "_cade_mem_list",
     "_load_librarian_app",
+    "_mem_list",
     "_run_mem",
     "_warm_memory",
     "mem_command",

{cade_cli-0.15.5 → cade_cli-0.15.7}/src/cadecoder/ui/display.py

@@ -465,7 +465,6 @@ _PRIMARY_ARG_KEYS: tuple[str, ...] = (
     # Generic last-resort labels.
     "name",
     "title",
-    "tool_name",
 )
 
 
@@ -811,6 +810,18 @@ def get_display_tool_name(tool_name: str, args: dict[str, Any]) -> str:
 
 def get_tool_context(tool_name: str, args: dict[str, Any]) -> str:
     """Return parenthesized context for the tool (used by session for 'Calling tool' line)."""
+    # Unwrap the Arcade meta-tools so the context describes the *inner* tool
+    # (e.g. the doc title) instead of echoing the wrapper's tool_name arg —
+    # which produced redundant headlines like
+    # ``GoogleDocs_CreateDocumentFromText("GoogleDocs_CreateDocumentFromText")``.
+    if tool_name in ("Arcade_UseTool", "Arcade_ExecuteTool"):
+        inner_name = get_display_tool_name(tool_name, args)
+        if inner_name and inner_name != tool_name:
+            inner_args = args.get("inputs")
+            if not isinstance(inner_args, dict):
+                inner_args = {}
+            return get_tool_context(inner_name, inner_args)
+
     server, tool = _parse_tool_name(tool_name)
     handler = _find_registry_handler(server, tool)
     if handler:

{cade_cli-0.15.5 → cade_cli-0.15.7}/src/cadecoder/ui/session.py

@@ -884,10 +884,10 @@ class ChatSession:
         console.print("[cyan]Switching to voice mode — keeping this conversation…[/cyan]")
 
     async def _handle_mem_command(self, cmd: str) -> None:
-        """Handle /mem (Agent Memory status) and /mem search <query>.
+        """Handle /mem (status), /mem list (documents), and /mem search <query>.
 
-        The bare/`status` view reuses the same renderer as the ``cade mem`` CLI
-        so the Agent Memory experience is identical in both surfaces.
+        The status and list views reuse the same renderers as the ``cade mem``
+        CLI so the Agent Memory experience is identical in both surfaces.
         """
         parts = cmd.split(None, 2)
         sub = parts[1] if len(parts) >= 2 else "status"
@@ -898,6 +898,12 @@ class ChatSession:
             _mem_status()
             return
 
+        if sub in ("list", "ls", "docs"):
+            from cadecoder.cli.commands.mem import _mem_list
+
+            _mem_list()
+            return
+
         if sub == "search" and len(parts) >= 3:
             query = parts[2]
             try:
@@ -913,7 +919,7 @@ class ChatSession:
                 )
             return
 
-        console.print("[dim]Usage: /mem [status] | /mem search <query>[/dim]")
+        console.print("[dim]Usage: /mem [status] | /mem list | /mem search <query>[/dim]")
 
     @staticmethod
     def _print_mem_search_results(result: object) -> None:

{cade_cli-0.15.5 → cade_cli-0.15.7}/src/cadecoder/ui/slash.py

@@ -51,7 +51,7 @@ SLASH_COMMANDS: tuple[SlashCommand, ...] = (
         ("list", "add", "remove", "enable", "disable"),
     ),
     SlashCommand("/hooks", " …", "Manage lifecycle hooks", ("list", "reload")),
-    SlashCommand("/mem", " …", "Search/manage memory", ("status", "search")),
+    SlashCommand("/mem", " …", "Search/manage memory", ("status", "list", "search")),
     SlashCommand("/notify", " <msg>", "Send a push notification"),
     SlashCommand("/pwd", "", "Show current directory", hidden=True),
     SlashCommand("/cd", " <path>", "Change directory", hidden=True),

{cade_cli-0.15.5 → cade_cli-0.15.7}/src/cadecoder/voice/audio.py

@@ -52,6 +52,34 @@ def _rms(audio: np.ndarray) -> float:
     return float(np.sqrt(np.mean(audio.astype(np.float64) ** 2)))
 
 
+# Substrings that identify a Bluetooth headset reported as an input device.
+# Such devices frequently return all-zero samples on macOS because the input
+# route fails to switch to the headset mic — a routing issue, not a permission
+# one — so the silence error gives different advice in that case.
+_BLUETOOTH_MIC_HINTS: Final[tuple[str, ...]] = (
+    "airpods",
+    "beats",
+    "bluetooth",
+    "headphones",
+    "headset",
+    "buds",
+    "powerbeats",
+)
+
+
+def _looks_like_bluetooth_mic(device_name: str) -> bool:
+    """Return True when *device_name* looks like a Bluetooth headset.
+
+    Args:
+        device_name: The human-readable input device name from PortAudio.
+
+    Returns:
+        True if the name matches a known Bluetooth-headset substring.
+    """
+    name = device_name.lower()
+    return any(hint in name for hint in _BLUETOOTH_MIC_HINTS)
+
+
 def check_mic_permission(
     device: str | int | None = None,
     sample_rate: int = DEFAULT_SAMPLE_RATE,
@@ -103,6 +131,27 @@ def check_mic_permission(
         import platform
 
         if platform.system() == "Darwin":
+            if _looks_like_bluetooth_mic(device_name):
+                # Bluetooth headsets (AirPods, Beats, etc.) commonly report
+                # silence on macOS because the input route fails to switch to
+                # the headset's mic — a routing problem, not a permission one.
+                return False, (
+                    f"Microphone '{device_name}' returns silence (all zeros).\n"
+                    "Bluetooth headsets (AirPods, Beats, etc.) often can't be "
+                    "used as a mic on macOS.\n"
+                    "\n"
+                    "Try one of these:\n"
+                    "  • Switch input to the built-in mic: System Settings > "
+                    "Sound > Input > MacBook/Built-in Microphone\n"
+                    "  • Or pin a specific device in ~/.cade/config/cade.toml "
+                    'under [voice]:  audio_input_device = "MacBook Pro Microphone"\n'
+                    "    (type /devices in the chat to list available devices)\n"
+                    "  • Or disconnect/reconnect the headset and try again\n"
+                    "\n"
+                    "If you intended to use the built-in mic, also confirm your "
+                    "terminal has mic access in System Settings > Privacy & "
+                    "Security > Microphone."
+                )
             return False, (
                 f"Microphone '{device_name}' returns silence (all zeros).\n"
                 "This usually means macOS is blocking microphone access.\n"

cade_cli-0.15.5/src/cade_mcp_local/web/extract.py

@@ -1,54 +0,0 @@
-"""Secondary-model extraction for WebFetch.
-
-Single non-streaming ``Provider.complete()`` call so the same code path
-works for Anthropic, OpenAI, and Ollama users alike. Default model is
-``claude-haiku-4-5-20251001``; override via ``CADE_WEB_FETCH_MODEL``.
-"""
-
-from __future__ import annotations
-
-import os
-
-from cade_mcp_local.errors import WebFetchError
-from cade_mcp_local.web.prompts import make_secondary_model_prompt
-from cadecoder.providers import get_provider_for_model
-from cadecoder.providers.base import ProviderRequest
-
-DEFAULT_EXTRACT_MODEL = "claude-haiku-4-5-20251001"
-
-
-async def extract_with_model(
-    prompt: str,
-    markdown: str,
-    *,
-    model: str | None = None,
-    url: str = "",
-) -> tuple[str, str]:
-    """Run a one-shot extraction. Returns (answer, model_used).
-
-    ``url`` is only used to make the error message useful when the
-    provider rejects the request.
-    """
-    chosen = model or os.environ.get("CADE_WEB_FETCH_MODEL") or DEFAULT_EXTRACT_MODEL
-    provider = get_provider_for_model(chosen)
-    if provider is None:
-        raise WebFetchError(
-            url or "(no url)",
-            f"no provider available for extraction model {chosen!r}; "
-            "set ANTHROPIC_API_KEY/OPENAI_API_KEY or CADE_WEB_FETCH_MODEL",
-        )
-
-    full_prompt = make_secondary_model_prompt(prompt, markdown)
-    request = ProviderRequest(
-        messages=[{"role": "user", "content": full_prompt}],
-        model=chosen,
-        max_tokens=2048,
-        temperature=0.2,
-        stream=False,
-    )
-    try:
-        response = await provider.complete(request)
-    except Exception as e:
-        raise WebFetchError(url or "(no url)", f"extraction model failed: {e}") from e
-
-    return (response.content or "").strip(), chosen