scootcli 0.1.0__tar.gz → 0.2.0__tar.gz

{scootcli-0.1.0 → scootcli-0.2.0}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Sergey Neskoromny
+Copyright (c) 2026 Sergey Nes
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{scootcli-0.1.0/src/scootcli.egg-info → scootcli-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scootcli
-Version: 0.1.0
+Version: 0.2.0
 Summary: A tiny coding agent that goes where you point it
 Author: Sergey Nes
 License-Expression: MIT
@@ -25,6 +25,14 @@ Dynamic: license-file
 
 # scoot
 
+[![PyPI](https://img.shields.io/pypi/v/scootcli.svg?label=PyPI)](https://pypi.org/project/scootcli/)
+[![tests](https://github.com/sergenes/scootcli/actions/workflows/tests.yml/badge.svg)](https://github.com/sergenes/scootcli/actions/workflows/tests.yml)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9%2B-blue.svg)](https://www.python.org/downloads/)
+[![Dependencies: none](https://img.shields.io/badge/dependencies-none-brightgreen.svg)](#install-options)
+[![Platform](https://img.shields.io/badge/platform-macOS%20%7C%20Linux-lightgrey.svg)](#install-options)
+[![Providers](https://img.shields.io/badge/providers-OpenAI%20%7C%20Ollama%20%7C%20Anthropic-orange.svg)](#providers-and-models)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
+
 ```
        ╭───╮      scoot: a tiny coding agent that goes where you point it.
        │o o│
@@ -35,7 +43,7 @@ Dynamic: license-file
 
 `scoot` is a terminal coding agent in plain Python.
 You type what you want in natural language; it reads, searches, edits, and runs things in your repo, asking before anything risky.
-It talks to official model APIs (OpenAI today, a local Ollama for free, Anthropic next) and has **zero third-party dependencies**: the whole tool is the Python standard library, and it ships as a single-file zipapp as well as a wheel.
+It talks to official model APIs (OpenAI, Anthropic, and a local Ollama for free) and has **zero third-party dependencies**: the whole tool is the Python standard library, and it ships as a single-file zipapp as well as a wheel.
 
 ## Where this comes from
 
@@ -88,7 +96,7 @@ A bare name means the default provider, which is the first provider that has a k
 |---|---|---|---|
 | `openai` | OpenAI Responses API | `OPENAI_API_KEY` | `gpt-5.3-codex` |
 | `ollama` | local Ollama, Responses API | none | `llama3.2` |
-| `anthropic` | Messages API | `ANTHROPIC_API_KEY` | arrives in 0.2.0 |
+| `anthropic` | Anthropic Messages API | `ANTHROPIC_API_KEY` | `claude-opus-5` |
 
 ```bash
 scoot models                         # every configured provider, grouped
@@ -98,7 +106,8 @@ scoot --model auto "..."             # pick a model per prompt from the live lis
 ```
 
 Inside the REPL, `/model <provider/model>` switches and is remembered for the next launch; `/model default` goes back to the provider's preferred model.
-`SCOOT_EFFORT` (`low` | `medium` | `high` | `xhigh`, default `medium`) sets the reasoning effort for models that take it.
+`SCOOT_EFFORT` (`low` | `medium` | `high` | `xhigh`, default `medium`) sets the reasoning effort for models that take it, on both OpenAI and Anthropic.
+On Claude Opus 5 the server-side refusal fallback is requested by default, so a declined request is retried on another Claude model inside the same call; `SCOOT_ANTHROPIC_FALLBACKS=0` turns that off.
 
 A note on how this is built: scoot speaks the OpenAI chat format internally and translates at the edge.
 Adding a provider that speaks that format is one registry row; a different wire format is one small adapter (`src/scootcli/providers/`).
@@ -173,7 +182,7 @@ Without a TTY, scoot falls back to a plain prompt with no bar and no dock.
 
 ### Tools and approvals
 
-The agent has seven tools: `read_file`, `list_dir`, `search`, `write_file`, `edit_file`, `run_shell`, and `update_plan` (a progress checklist for multi-step work).
+The agent has eight tools: `read_file`, `list_dir`, `search`, `write_file`, `edit_file`, `run_shell`, `open_editor` (hands a file to IntelliJ IDEA's `idea -e` or to VS Code, `SCOOT_EDITOR` picks), and `update_plan` (a progress checklist for multi-step work).
 Every tool is sandboxed to the workspace root.
 
 When a call needs approval you can approve once `[a]`, trust that tool for the session `[t]`, approve everything this session `[A]`, edit the arguments `[e]`, skip `[s]`, or quit `[q]`.

{scootcli-0.1.0 → scootcli-0.2.0}/README.md

@@ -1,5 +1,13 @@
 # scoot
 
+[![PyPI](https://img.shields.io/pypi/v/scootcli.svg?label=PyPI)](https://pypi.org/project/scootcli/)
+[![tests](https://github.com/sergenes/scootcli/actions/workflows/tests.yml/badge.svg)](https://github.com/sergenes/scootcli/actions/workflows/tests.yml)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9%2B-blue.svg)](https://www.python.org/downloads/)
+[![Dependencies: none](https://img.shields.io/badge/dependencies-none-brightgreen.svg)](#install-options)
+[![Platform](https://img.shields.io/badge/platform-macOS%20%7C%20Linux-lightgrey.svg)](#install-options)
+[![Providers](https://img.shields.io/badge/providers-OpenAI%20%7C%20Ollama%20%7C%20Anthropic-orange.svg)](#providers-and-models)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
+
 ```
        ╭───╮      scoot: a tiny coding agent that goes where you point it.
        │o o│
@@ -10,7 +18,7 @@
 
 `scoot` is a terminal coding agent in plain Python.
 You type what you want in natural language; it reads, searches, edits, and runs things in your repo, asking before anything risky.
-It talks to official model APIs (OpenAI today, a local Ollama for free, Anthropic next) and has **zero third-party dependencies**: the whole tool is the Python standard library, and it ships as a single-file zipapp as well as a wheel.
+It talks to official model APIs (OpenAI, Anthropic, and a local Ollama for free) and has **zero third-party dependencies**: the whole tool is the Python standard library, and it ships as a single-file zipapp as well as a wheel.
 
 ## Where this comes from
 
@@ -63,7 +71,7 @@ A bare name means the default provider, which is the first provider that has a k
 |---|---|---|---|
 | `openai` | OpenAI Responses API | `OPENAI_API_KEY` | `gpt-5.3-codex` |
 | `ollama` | local Ollama, Responses API | none | `llama3.2` |
-| `anthropic` | Messages API | `ANTHROPIC_API_KEY` | arrives in 0.2.0 |
+| `anthropic` | Anthropic Messages API | `ANTHROPIC_API_KEY` | `claude-opus-5` |
 
 ```bash
 scoot models                         # every configured provider, grouped
@@ -73,7 +81,8 @@ scoot --model auto "..."             # pick a model per prompt from the live lis
 ```
 
 Inside the REPL, `/model <provider/model>` switches and is remembered for the next launch; `/model default` goes back to the provider's preferred model.
-`SCOOT_EFFORT` (`low` | `medium` | `high` | `xhigh`, default `medium`) sets the reasoning effort for models that take it.
+`SCOOT_EFFORT` (`low` | `medium` | `high` | `xhigh`, default `medium`) sets the reasoning effort for models that take it, on both OpenAI and Anthropic.
+On Claude Opus 5 the server-side refusal fallback is requested by default, so a declined request is retried on another Claude model inside the same call; `SCOOT_ANTHROPIC_FALLBACKS=0` turns that off.
 
 A note on how this is built: scoot speaks the OpenAI chat format internally and translates at the edge.
 Adding a provider that speaks that format is one registry row; a different wire format is one small adapter (`src/scootcli/providers/`).
@@ -148,7 +157,7 @@ Without a TTY, scoot falls back to a plain prompt with no bar and no dock.
 
 ### Tools and approvals
 
-The agent has seven tools: `read_file`, `list_dir`, `search`, `write_file`, `edit_file`, `run_shell`, and `update_plan` (a progress checklist for multi-step work).
+The agent has eight tools: `read_file`, `list_dir`, `search`, `write_file`, `edit_file`, `run_shell`, `open_editor` (hands a file to IntelliJ IDEA's `idea -e` or to VS Code, `SCOOT_EDITOR` picks), and `update_plan` (a progress checklist for multi-step work).
 Every tool is sandboxed to the workspace root.
 
 When a call needs approval you can approve once `[a]`, trust that tool for the session `[t]`, approve everything this session `[A]`, edit the arguments `[e]`, skip `[s]`, or quit `[q]`.

{scootcli-0.1.0 → scootcli-0.2.0}/src/scootcli/__init__.py

@@ -1,4 +1,4 @@
 """scoot: a tiny coding agent that goes where you point it."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 

{scootcli-0.1.0 → scootcli-0.2.0}/src/scootcli/config.py

@@ -178,6 +178,7 @@ class Config:
     images: bool = True  # detect dropped image paths + describe them with a vision model (M22)
     vision_model: str = "auto"  # provider/model for image descriptions, or "auto" → pick a capable one
     image_max_bytes: int = 4 * 1024 * 1024  # per-image cap (no downscale without a 3rd-party lib)
+    editor: str = "idea"  # external editor for the open_editor tool: idea | vscode
     env_files: Tuple[str, ...] = ()  # the .env files that were read, in load order (shown by /status)
     logo: bool = True  # mascot in the launch banner + status-bar face (--no-logo / SCOOT_LOGO / /logo)
     emoji: bool = True  # 🛴 transcript label; off → ⏺ for terminals without an emoji font (--no-emoji)
@@ -214,6 +215,7 @@ class Config:
             images=_as_bool(get("SCOOT_IMAGES", "true")),
             vision_model=get("SCOOT_VISION_MODEL", "auto"),
             image_max_bytes=int(get("SCOOT_IMAGE_MAX_BYTES", str(4 * 1024 * 1024))),
+            editor=get("SCOOT_EDITOR", "idea").strip().lower(),
             logo=_resolve_logo_setting(get("SCOOT_LOGO")),
             emoji=_as_bool(get("SCOOT_EMOJI", "true")),
         )

scootcli-0.2.0/src/scootcli/providers/anthropic.py

@@ -0,0 +1,354 @@
+"""Anthropic Messages API adapter (``POST {base}/messages``).
+
+Anthropic has one chat endpoint and it is the same kind of API as OpenAI's Responses: stateless, a
+turn is a list of typed content blocks, opaque reasoning (``thinking`` blocks) is echoed back to the
+producing model. Translation from scoot's neutral format:
+
+  * ``system`` messages → the top-level ``system`` string
+  * ``user`` messages → ``text`` / ``image`` (base64) blocks
+  * ``assistant`` messages → ``text`` + ``tool_use`` blocks, or the verbatim ``provider_items`` blocks
+    (thinking included) when this very model produced them
+  * consecutive ``tool`` messages → one ``user`` message of ``tool_result`` blocks, never split
+  * tool schemas → ``{"name", "description", "input_schema"}``
+
+Model-specific request rules (from the Claude API reference, 2026-06):
+  * ``max_tokens`` is required; we default it generously because we stream.
+  * Thinking: on by default on Claude Opus 5, Sonnet 5, and Fable, so no parameter is sent there;
+    Opus 4.6/4.7/4.8 and Sonnet 4.6 need ``{"type": "adaptive"}`` explicitly; Haiku gets nothing.
+  * ``output_config.effort`` carries ``SCOOT_EFFORT`` (``xhigh`` is downgraded to ``high`` on 4.6).
+  * Sampling parameters (``temperature``) are rejected on 4.6+, so none are sent.
+  * ``cache_control: {"type": "ephemeral"}`` at the top level caches the stable prefix (system prompt
+    and tool list) automatically.
+  * On Claude Opus 5 and Fable the server-side refusal fallback is requested by default
+    (``fallbacks: "default"`` with its beta header); ``SCOOT_ANTHROPIC_FALLBACKS=0`` turns it off.
+  * ``stop_reason: "refusal"`` becomes a clear error instead of an empty answer.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Callable, List, Optional, Tuple
+
+from ..errors import ApiError
+from .base import (
+    BaseProvider,
+    ChatRequest,
+    ChatResult,
+    decode_json,
+    finish_stream,
+    iter_sse_json,
+    normalize_usage,
+    raise_for_status,
+)
+
+API_VERSION = "2023-06-01"
+FALLBACK_BETA = "server-side-fallback-2026-07-01"
+DEFAULT_MAX_TOKENS = 32000
+
+# Models where omitting ``thinking`` means *no* thinking: send adaptive explicitly.
+_EXPLICIT_ADAPTIVE = ("claude-opus-4-6", "claude-opus-4-7", "claude-opus-4-8", "claude-sonnet-4-6")
+# Models that get the server-side refusal fallback by default.
+_FALLBACK_MODELS = ("claude-opus-5", "claude-fable", "claude-mythos")
+# 4.6-generation models cap effort at ``high``.
+_EFFORT_HIGH_MAX = ("claude-opus-4-6", "claude-sonnet-4-6")
+
+
+def thinking_param(model: str) -> Optional[dict]:
+    m = (model or "").lower()
+    if any(m.startswith(p) for p in _EXPLICIT_ADAPTIVE):
+        return {"type": "adaptive"}
+    return None
+
+
+def effort_param(model: str, effort: str) -> Optional[str]:
+    m = (model or "").lower()
+    e = (effort or "").strip().lower()
+    if not e or "haiku" in m:
+        return None
+    if e == "xhigh" and any(m.startswith(p) for p in _EFFORT_HIGH_MAX):
+        return "high"
+    return e if e in ("low", "medium", "high", "xhigh", "max") else None
+
+
+def fallbacks_enabled(model: str) -> bool:
+    m = (model or "").lower()
+    if not any(m.startswith(p) for p in _FALLBACK_MODELS):
+        return False
+    return (os.environ.get("SCOOT_ANTHROPIC_FALLBACKS", "1").strip().lower()
+            not in ("0", "false", "no", "off"))
+
+
+# ── request translation ─────────────────────────────────────────────────────────
+def _image_block(url: str) -> dict:
+    if url.startswith("data:"):
+        head, _, data = url.partition(",")
+        media = head[len("data:"):].split(";")[0] or "image/png"
+        return {"type": "image", "source": {"type": "base64", "media_type": media, "data": data}}
+    return {"type": "image", "source": {"type": "url", "url": url}}
+
+
+def _user_blocks(content) -> object:
+    if isinstance(content, str) or content is None:
+        return content or ""
+    blocks = []
+    for part in content:
+        if not isinstance(part, dict):
+            continue
+        ptype = part.get("type")
+        if ptype == "text":
+            blocks.append({"type": "text", "text": part.get("text", "")})
+        elif ptype == "image_url":
+            img = part.get("image_url") or {}
+            url = img.get("url") if isinstance(img, dict) else img
+            if url:
+                blocks.append(_image_block(url))
+        elif ptype in ("image", "document", "tool_result"):
+            blocks.append(part)
+    return blocks
+
+
+def _arguments_dict(raw) -> dict:
+    if isinstance(raw, dict):
+        return raw
+    if not raw:
+        return {}
+    try:
+        parsed = json.loads(raw)
+        return parsed if isinstance(parsed, dict) else {}
+    except (json.JSONDecodeError, TypeError):
+        return {}
+
+
+def translate_messages(messages: List[dict], qualified_model: str) -> Tuple[str, List[dict]]:
+    """Return ``(system, messages)`` for the Messages request."""
+    system: List[str] = []
+    out: List[dict] = []
+    pending_results: List[dict] = []
+
+    def flush_results() -> None:
+        if pending_results:
+            out.append({"role": "user", "content": list(pending_results)})
+            pending_results.clear()
+
+    for m in messages:
+        role = m.get("role")
+        if role in ("system", "developer"):
+            text = m.get("content")
+            if isinstance(text, list):
+                text = "\n".join(p.get("text", "") for p in text if isinstance(p, dict))
+            if text:
+                system.append(str(text))
+            continue
+        if role == "tool":
+            content = m.get("content")
+            if not isinstance(content, str):
+                content = json.dumps(content) if content is not None else ""
+            pending_results.append({"type": "tool_result", "tool_use_id": m.get("tool_call_id", ""),
+                                    "content": content})
+            continue
+        flush_results()
+        if role == "user":
+            out.append({"role": "user", "content": _user_blocks(m.get("content"))})
+        elif role == "assistant":
+            replay = m.get("provider_items")
+            if isinstance(replay, dict) and replay.get("model") == qualified_model and replay.get("items"):
+                out.append({"role": "assistant", "content": list(replay["items"])})
+                continue
+            blocks: List[dict] = []
+            text = m.get("content")
+            if isinstance(text, list):
+                blocks.extend(b for b in _user_blocks(text) if b.get("type") == "text")
+            elif text:
+                blocks.append({"type": "text", "text": str(text)})
+            for tc in m.get("tool_calls") or []:
+                fn = tc.get("function") or {}
+                blocks.append({"type": "tool_use", "id": tc.get("id", ""), "name": fn.get("name", ""),
+                               "input": _arguments_dict(fn.get("arguments"))})
+            if blocks:
+                out.append({"role": "assistant", "content": blocks})
+    flush_results()
+    return "\n\n".join(system), out
+
+
+def translate_tool(tool: dict) -> dict:
+    fn = tool.get("function") if isinstance(tool, dict) else None
+    if not isinstance(fn, dict):
+        return tool
+    return {
+        "name": fn.get("name", ""),
+        "description": fn.get("description", ""),
+        "input_schema": fn.get("parameters") or {"type": "object", "properties": {}},
+    }
+
+
+# ── response parsing ────────────────────────────────────────────────────────────
+_STOP = {"end_turn": "stop", "tool_use": "tool_calls", "max_tokens": "length", "stop_sequence": "stop",
+         "pause_turn": "stop", "refusal": "refusal"}
+
+
+def total_input_usage(usage: Optional[dict]) -> dict:
+    """Anthropic's ``input_tokens`` excludes cached input; scoot's ``prompt_tokens`` is the whole prompt.
+
+    The context gauge and the session totals need the full size, so fold ``cache_read_input_tokens``
+    and ``cache_creation_input_tokens`` back in. The raw fields stay for cost analysis.
+    """
+    if not isinstance(usage, dict):
+        return {}
+    out = dict(usage)
+    total = (int(out.get("input_tokens") or 0) + int(out.get("cache_read_input_tokens") or 0)
+             + int(out.get("cache_creation_input_tokens") or 0))
+    out["prompt_tokens"] = total
+    return out
+
+
+def build_result(blocks: List[dict], model: str, usage: Optional[dict], stop_reason: str,
+                 stop_details: Optional[dict] = None, streamed_text: str = "") -> ChatResult:
+    if stop_reason == "refusal":
+        detail = (stop_details or {}).get("explanation") or (stop_details or {}).get("category") or ""
+        raise ApiError("the model declined this request" + (f": {detail}" if detail else ""),
+                       code="refusal", hint="rephrase the request or switch models with /model")
+    texts = [b.get("text", "") for b in blocks if b.get("type") == "text"]
+    tool_calls = [{"id": b.get("id", ""), "type": "function",
+                   "function": {"name": b.get("name", ""), "arguments": json.dumps(b.get("input") or {})}}
+                  for b in blocks if b.get("type") == "tool_use"]
+    content = streamed_text or "".join(texts)
+    finish = "tool_calls" if tool_calls else _STOP.get(stop_reason, "stop")
+    message: dict = {"role": "assistant", "content": content}
+    if tool_calls:
+        message["tool_calls"] = tool_calls
+    if blocks:
+        message["provider_items"] = {"model": model, "items": blocks}
+    return ChatResult(content=content, model=model, tool_calls=tool_calls, finish_reason=finish,
+                      usage=normalize_usage(total_input_usage(usage)), raw_message=message)
+
+
+class _StreamState:
+    """Accumulates Messages SSE events into content blocks + live text."""
+
+    def __init__(self) -> None:
+        self.blocks: dict = {}          # index -> block dict
+        self._json: dict = {}           # index -> partial tool input JSON
+        self.text: List[str] = []
+        self.usage: dict = {}
+        self.model = ""
+        self.stop_reason = ""
+        self.stop_details: Optional[dict] = None
+        self.error: Optional[dict] = None
+
+    def add(self, obj: dict) -> str:
+        etype = obj.get("type", "")
+        if etype == "message_start":
+            msg = obj.get("message") or {}
+            self.model = msg.get("model") or self.model
+            self.usage.update(msg.get("usage") or {})
+        elif etype == "content_block_start":
+            idx = obj.get("index", 0)
+            block = dict(obj.get("content_block") or {})
+            if block.get("type") == "tool_use":
+                self._json[idx] = ""
+                block.setdefault("input", {})
+            self.blocks[idx] = block
+        elif etype == "content_block_delta":
+            idx = obj.get("index", 0)
+            block = self.blocks.setdefault(idx, {"type": "text", "text": ""})
+            delta = obj.get("delta") or {}
+            dtype = delta.get("type")
+            if dtype == "text_delta":
+                text = delta.get("text") or ""
+                block["text"] = block.get("text", "") + text
+                self.text.append(text)
+                return text
+            if dtype == "input_json_delta":
+                self._json[idx] = self._json.get(idx, "") + (delta.get("partial_json") or "")
+            elif dtype == "thinking_delta":
+                block["thinking"] = block.get("thinking", "") + (delta.get("thinking") or "")
+            elif dtype == "signature_delta":
+                block["signature"] = delta.get("signature") or block.get("signature", "")
+        elif etype == "content_block_stop":
+            idx = obj.get("index", 0)
+            if idx in self._json:
+                raw = self._json.pop(idx)
+                try:
+                    self.blocks[idx]["input"] = json.loads(raw) if raw.strip() else {}
+                except json.JSONDecodeError:
+                    self.blocks[idx]["input"] = {}
+        elif etype == "message_delta":
+            delta = obj.get("delta") or {}
+            self.stop_reason = delta.get("stop_reason") or self.stop_reason
+            if delta.get("stop_details"):
+                self.stop_details = delta["stop_details"]
+            self.usage.update(obj.get("usage") or {})
+        elif etype == "error":
+            self.error = obj.get("error") or {"message": "stream error"}
+        return ""
+
+    def ordered_blocks(self) -> List[dict]:
+        return [self.blocks[i] for i in sorted(self.blocks)]
+
+
+class AnthropicProvider(BaseProvider):
+    wire = "anthropic"
+
+    # ── auth + headers ────────────────────────────────────────────────────────────
+    def _auth_token(self) -> str:
+        self._auth()  # raises the same "no API key" error as the other providers
+        return ""  # the key travels in x-api-key, not Authorization
+
+    def _headers_for(self, payload: Optional[dict]) -> List[str]:
+        headers = [f"x-api-key: {self._auth()}", f"anthropic-version: {API_VERSION}"]
+        if payload and payload.get("fallbacks"):
+            headers.append(f"anthropic-beta: {FALLBACK_BETA}")
+        return headers + self._extra_headers()
+
+    # ── request ───────────────────────────────────────────────────────────────────
+    def _payload(self, req: ChatRequest, stream: bool) -> dict:
+        system, messages = translate_messages(req.messages, self.qualified(req.model))
+        payload: dict = {
+            "model": req.model,
+            "max_tokens": req.max_tokens or DEFAULT_MAX_TOKENS,
+            "messages": messages,
+            "cache_control": {"type": "ephemeral"},
+        }
+        if system:
+            payload["system"] = system
+        if stream:
+            payload["stream"] = True
+        if req.tools:
+            payload["tools"] = [translate_tool(t) for t in req.tools]
+            payload["tool_choice"] = {"type": "auto"}
+        thinking = thinking_param(req.model)
+        if thinking:
+            payload["thinking"] = thinking
+        effort = effort_param(req.model, getattr(self.config, "effort", ""))
+        if effort:
+            payload["output_config"] = {"effort": effort}
+        if fallbacks_enabled(req.model):
+            payload["fallbacks"] = "default"
+        return payload
+
+    def _complete(self, req: ChatRequest) -> ChatResult:
+        payload = self._payload(req, stream=False)
+        status, body = self._http("POST", "/messages", payload, req.cancel_event)
+        data = decode_json(status, body)
+        if data.get("type") == "error" or data.get("error"):
+            raise_for_status(400, json.dumps({"error": data.get("error")}), self.name)
+        return build_result(data.get("content") or [], self.qualified(data.get("model") or req.model),
+                            data.get("usage"), data.get("stop_reason") or "", data.get("stop_details"))
+
+    def _stream(self, req: ChatRequest, on_delta: Callable[[str], None]) -> ChatResult:
+        payload = self._payload(req, stream=True)
+        state = _StreamState()
+        holder: dict = {}
+        leftovers: List[str] = []
+        for obj in iter_sse_json(self._http_stream("/messages", payload, req.cancel_event), holder,
+                                 leftovers):
+            text = state.add(obj)
+            if text:
+                on_delta(text)
+        finish_stream(holder, leftovers, self.name)
+        if state.error:
+            raise_for_status(400, json.dumps({"error": state.error}), self.name)
+            raise ApiError(str(state.error))
+        return build_result(state.ordered_blocks(), self.qualified(state.model or req.model), state.usage,
+                            state.stop_reason, state.stop_details, streamed_text="".join(state.text))

{scootcli-0.1.0 → scootcli-0.2.0}/src/scootcli/providers/base.py

@@ -154,11 +154,12 @@ def raise_for_status(status: int, body: str, provider: str = "") -> None:
                           hint=f"{who} issue; backing off and retrying")
     if status >= 400 or msg:
         low = (code + " " + msg).lower()
-        if "context" in low and any(w in low for w in ("length", "exceed", "maximum", "token")):
+        if ("prompt is too long" in low or "too many tokens" in low
+                or ("context" in low and any(w in low for w in ("length", "exceed", "maximum", "token")))):
             raise ContextLengthError(msg or "context length exceeded", status=status, code=code,
                                      hint="run /compact to shrink context, then retry")
         if "model" in low and any(w in low for w in
-                                  ("not supported", "not accessible", "not found", "unsupported",
+                                  ("not supported", "not accessible", "not found", "not_found", "unsupported",
                                    "does not exist", "not exist")):
             raise ModelUnavailableError(msg or "model unavailable", status=status, code=code,
                                         hint="switching to a supported model")
@@ -295,19 +296,27 @@ class BaseProvider:
     def _extra_headers(self) -> List[str]:
         return [f"{k}: {v}" for k, v in self.spec.extra_headers]
 
+    # Two hooks let an adapter change how the key travels: by default it is a Bearer token in
+    # ``Authorization``; Anthropic overrides both to send ``x-api-key`` plus its version header.
+    def _auth_token(self) -> str:
+        return self._auth()
+
+    def _headers_for(self, payload: Optional[dict]) -> List[str]:
+        return self._extra_headers()
+
     def _http(self, method: str, path: str, payload: Optional[dict], cancel_event) -> Tuple[int, str]:
         """One request, status-checked. Callers wrap it in :meth:`_with_retry` when appropriate."""
         status, body = self.transport.request(
-            method, self._url(path), self._auth(), extra_headers=self._extra_headers(), body=payload,
-            cancel_event=cancel_event,
+            method, self._url(path), self._auth_token(), extra_headers=self._headers_for(payload),
+            body=payload, cancel_event=cancel_event,
         )
         raise_for_status(status, body, self.name)
         return status, body
 
     def _http_stream(self, path: str, payload: dict, cancel_event) -> Iterator[str]:
         return self.transport.stream_request(
-            "POST", self._url(path), self._auth(), extra_headers=self._extra_headers(), body=payload,
-            cancel_event=cancel_event,
+            "POST", self._url(path), self._auth_token(), extra_headers=self._headers_for(payload),
+            body=payload, cancel_event=cancel_event,
         )
 
     # ── retry policy ─────────────────────────────────────────────────────────────

{scootcli-0.1.0 → scootcli-0.2.0}/src/scootcli/providers/registry.py

@@ -44,11 +44,13 @@ def load_builtins() -> None:
     global _loaded
     if _loaded:
         return
+    from .anthropic import AnthropicProvider
     from .openai_chat import OpenAIChatProvider
     from .openai_responses import OpenAIResponsesProvider
 
     _WIRES["openai_responses"] = OpenAIResponsesProvider
     _WIRES["openai_chat"] = OpenAIChatProvider
+    _WIRES["anthropic"] = AnthropicProvider
     register(ProviderSpec(
         name="openai",
         base_url="https://api.openai.com/v1",
@@ -69,6 +71,16 @@ def load_builtins() -> None:
         vision_models=("qwen2.5vl", "llama3.2-vision", "llava", "gemma3", "minicpm-v"),
         capabilities=frozenset({"tools", "streaming", "vision", "temperature"}),
     ))
+    register(ProviderSpec(
+        name="anthropic",
+        base_url="https://api.anthropic.com/v1",
+        wire="anthropic",
+        key_env=("ANTHROPIC_API_KEY",),
+        key_required=True,
+        preferred_models=("claude-opus-5", "claude-sonnet-5", "claude-opus-4-8", "claude-haiku-4-5"),
+        vision_models=("claude",),
+        capabilities=frozenset({"tools", "streaming", "vision", "reasoning"}),
+    ))
     _loaded = True
 
 

{scootcli-0.1.0 → scootcli-0.2.0}/src/scootcli/status.py

@@ -16,6 +16,13 @@ _FRAMES = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏"
 _CLEAR_LINE = "\r\033[K"
 
 
+def _fmt_elapsed(seconds: int) -> str:
+    """Compact elapsed-time label: ``8s`` or ``1m03s``."""
+    if seconds < 60:
+        return f"{seconds}s"
+    return f"{seconds // 60}m{seconds % 60:02d}s"
+
+
 class Status:
     """A threaded spinner with an updatable message and a persistent step hint."""
 
@@ -23,6 +30,7 @@ class Status:
         self.enabled = enabled and sys.stdout.isatty()
         self._message = ""
         self._hint = ""
+        self._started = 0.0
         self._thread = None
         self._stop = threading.Event()
         self._lock = threading.Lock()
@@ -30,6 +38,7 @@ class Status:
     def start(self, message: str = "thinking…", hint: str = "esc to stop") -> None:
         self._message = message
         self._hint = hint
+        self._started = time.time()
         if not self.enabled:
             return
         self._stop.clear()
@@ -47,9 +56,13 @@ class Status:
         while not self._stop.is_set():
             with self._lock:
                 message, hint = self._message, self._hint
+            elapsed = int(time.time() - self._started) if self._started else 0
             frame = color(_FRAMES[i % len(_FRAMES)], "cyan")
+            timer = color(f" ({_fmt_elapsed(elapsed)})", "gray") if elapsed >= 3 else ""
+            if elapsed >= 30:
+                hint = "still working · ctrl+c to force" + (f" — {hint}" if hint else "")
             tail = color(f" · {hint}", "gray") if hint else ""
-            sys.stdout.write(f"{_CLEAR_LINE}  {frame} {message}{tail}")
+            sys.stdout.write(f"{_CLEAR_LINE}  {frame} {message}{timer}{tail}")
             sys.stdout.flush()
             i += 1
             time.sleep(0.08)

{scootcli-0.1.0 → scootcli-0.2.0}/src/scootcli/tools/__init__.py

@@ -62,6 +62,7 @@ def load_builtins() -> None:
     from . import write_file  # noqa: F401
     from . import edit_file  # noqa: F401
     from . import run_shell  # noqa: F401
+    from . import open_editor  # noqa: F401
     from . import update_plan  # noqa: F401
 
     _loaded = True