scootcli 0.1.0__py3-none-any.whl

scootcli/project.py

@@ -0,0 +1,94 @@
+"""Project learning for /init: scan the workspace and generate an AGENTS.md via the model.
+
+The scan is intentionally cheap and read-only: a bounded file tree plus the contents of common
+manifest/entry files. The model turns that digest into a concise AGENTS.md that is then auto-loaded
+into the system prompt on every run (PLAN §6, §15).
+"""
+
+from __future__ import annotations
+
+import threading
+from pathlib import Path
+from typing import List, Optional
+
+_SKIP_DIRS = {
+    ".git", ".hg", ".svn", "__pycache__", ".mypy_cache", ".pytest_cache", ".ruff_cache",
+    "node_modules", ".venv", "venv", "dist", "build", ".idea", ".vscode", ".cache",
+}
+_MANIFESTS = [
+    "README.md", "README.rst", "README", "pyproject.toml", "setup.cfg", "setup.py",
+    "requirements.txt", "package.json", "tsconfig.json", "pom.xml", "build.gradle",
+    "build.gradle.kts", "go.mod", "Cargo.toml", "Gemfile", "Makefile", "Dockerfile",
+]
+_MAX_TREE_ENTRIES = 200
+_MAX_MANIFEST_BYTES = 4000
+
+_INIT_SYSTEM = (
+    "You are documenting a software project for an AI coding assistant. Given a file tree and key "
+    "files, write a concise AGENTS.md in Markdown with these sections: Overview (what the project is), "
+    "Layout (key directories/files), Build & Test (exact commands if discoverable), Conventions, and "
+    "Notes. Be specific and terse. Output only the Markdown."
+)
+
+
+def _iter_tree(root: Path) -> List[str]:
+    entries: List[str] = []
+    for path in sorted(root.rglob("*")):
+        if any(part in _SKIP_DIRS for part in path.relative_to(root).parts):
+            continue
+        rel = path.relative_to(root).as_posix()
+        entries.append(rel + ("/" if path.is_dir() else ""))
+        if len(entries) >= _MAX_TREE_ENTRIES:
+            entries.append("… [tree truncated]")
+            break
+    return entries
+
+
+def _collect_manifests(root: Path) -> List[str]:
+    chunks: List[str] = []
+    for name in _MANIFESTS:
+        path = root / name
+        if path.exists() and path.is_file():
+            try:
+                text = path.read_text("utf-8", "replace")[:_MAX_MANIFEST_BYTES]
+            except OSError:
+                continue
+            chunks.append(f"### {name}\n```\n{text}\n```")
+    return chunks
+
+
+def scan(root: Path) -> str:
+    """Return a text digest of the project (tree + manifests) for the model."""
+    tree = "\n".join(_iter_tree(root))
+    manifests = "\n\n".join(_collect_manifests(root)) or "(no common manifest files found)"
+    return f"# File tree\n{tree}\n\n# Key files\n{manifests}"
+
+
+def _strip_code_fence(text: str) -> str:
+    """If the whole response is wrapped in a ``` fence, unwrap it."""
+    t = text.strip()
+    if t.startswith("```"):
+        lines = t.splitlines()
+        lines = lines[1:]  # drop opening ```lang
+        if lines and lines[-1].strip().startswith("```"):
+            lines = lines[:-1]  # drop closing ```
+        return "\n".join(lines).strip()
+    return t
+
+
+def generate_agents_md(session, cancel_event: Optional[threading.Event] = None) -> str:
+    """Scan the workspace root and ask the model to produce AGENTS.md content."""
+    root = session.config.root
+    digest = scan(root)
+    result = session.provider.chat(
+        [
+            {"role": "system", "content": _INIT_SYSTEM},
+            {"role": "user", "content": digest},
+        ],
+        model=session.active_model,
+        max_tokens=1200,
+        cancel_event=cancel_event,
+    )
+    session.account(result.usage)
+    return _strip_code_fence((result.content or "").strip())
+

scootcli/prompts.py

@@ -0,0 +1,100 @@
+"""System prompts.
+
+``CHAT_SYSTEM_PROMPT`` powers the simple one-shot ``scoot "..."`` path. ``AGENT_SYSTEM_PROMPT``
+(PLAN §15) powers the interactive agentic loop: intent inference, planning, tool use, and the DONE
+sentinel. Placeholders use ``{{name}}`` and are filled by :func:`build_agent_system_prompt`.
+"""
+
+from __future__ import annotations
+
+import platform
+from pathlib import Path
+
+CHAT_SYSTEM_PROMPT = (
+    "You are scoot, a concise terminal coding assistant for a software engineer. "
+    "Answer clearly and briefly. Prefer code and concrete steps over prose. "
+    "If a request is ambiguous, ask one short clarifying question."
+)
+
+AGENT_SYSTEM_PROMPT = """\
+You are scoot, a terminal coding assistant for a software engineer.
+You run inside the user's workspace and act through tools. Be concise, correct, and safe.
+
+ENVIRONMENT
+- Working directory (root): {{workspace_root}}
+- OS: {{os}}   Model: {{model}}
+- All file paths you use must stay inside the root. Never touch paths outside it.
+
+WORKSPACE (auto-generated map of the current repo — use it to orient before listing/reading files)
+{{workspace}}
+
+PROJECT CONTEXT (from AGENTS.md, if present)
+{{agent_md}}
+
+INTENT - READ THE USER, DON'T WAIT FOR COMMANDS
+The user just types natural language. Infer what they want and act:
+- A question ("what does X do?", "how do I...") -> answer directly. Read a file first only if you
+  need its contents to be accurate. Do NOT modify anything for a question.
+- "Explain / review X" -> read the relevant file(s), then explain. No edits.
+- "Add / change / fix / rename / refactor X" -> read what you need, then make the change via the
+  edit_file or write_file tool.
+- "Create a new file/script" -> use write_file.
+- If the request is ambiguous or could destroy work, ask ONE short clarifying question instead of
+  guessing. Prefer acting when the intent is clear.
+
+PLANNING
+- For a multi-step task, call the update_plan tool with a short plan (max ~6 steps), then execute it,
+  calling update_plan again to mark each step in_progress / completed as you go (one in_progress step).
+- For a trivial request (a question, a one-line change), skip the plan and just do it.
+- Keep the user oriented: briefly say what you're about to do before a tool call.
+
+TOOLS
+You have these tools:
+{{tool_list}}
+- Use tools to gather context instead of assuming. Read before you edit.
+- Make the smallest change that satisfies the request. Preserve existing style.
+- After editing, if feasible, verify (re-read the file or run a quick check via run_shell).
+- Every tool call is shown to the user and must be approved by them. If a call is declined, adapt:
+  choose another approach or ask what they'd prefer. Never try to bypass approval.
+- Tool results may be truncated; request more specifically if you need it.
+
+SAFETY
+- run_shell is powerful: prefer read-only/idempotent commands, keep them short, explain why.
+- Never print secrets or the contents of env files / tokens. Never exfiltrate data.
+- Do not make sweeping changes the user didn't ask for.
+
+COMPLETION
+- When the task is fully done, stop calling tools and give a short summary of what you did
+  (what changed, which files, any commands run, and anything the user should check).
+- End that final message with the token DONE on its own line so the CLI knows you're finished.
+- If you are blocked and cannot proceed, explain why and end with DONE.
+"""
+
+
+def load_agents_md(root: Path) -> str:
+    """Return the contents of AGENTS.md at the workspace root, or a placeholder if absent."""
+    for name in ("AGENTS.md", "AGENT.md"):
+        path = root / name
+        if path.exists() and path.is_file():
+            try:
+                return path.read_text("utf-8", "replace").strip()
+            except OSError:
+                break
+    return "(none - run /init to generate AGENTS.md)"
+
+
+def build_agent_system_prompt(root: Path, model: str, tool_list: str, agent_md: str = None,
+                              workspace: str = "") -> str:
+    """Fill the agent system-prompt template."""
+    if agent_md is None:
+        agent_md = load_agents_md(root)
+    return (
+        AGENT_SYSTEM_PROMPT.replace("{{workspace_root}}", str(root))
+        .replace("{{os}}", platform.system() or "unknown")
+        .replace("{{model}}", model)
+        .replace("{{tool_list}}", tool_list)
+        .replace("{{workspace}}", workspace.strip() or "(not available — use list_dir/search to explore)")
+        .replace("{{agent_md}}", agent_md)
+    )
+
+

scootcli/providers/__init__.py

@@ -0,0 +1,20 @@
+"""LLM providers behind one protocol.
+
+Consumers speak scoot's neutral conversation format (the OpenAI chat shape: ``system``/``user``/
+``assistant``/``tool`` messages, ``tool_calls`` on assistant messages, ``{"type": "function", ...}`` tool
+schemas, ``image_url`` parts with data URIs). Each wire adapter translates that to a vendor API at the
+edge. Models are addressed as ``provider/model`` (``openai/gpt-5.3-codex``, ``ollama/llama3.2``).
+
+Public surface:
+  * :class:`~scootcli.providers.base.ChatResult` / :class:`~scootcli.providers.base.ChatRequest`
+  * :class:`~scootcli.providers.base.ProviderSpec` (a registry row) and :func:`registry.register`
+  * :class:`~scootcli.providers.registry.ProviderPool`: what the app holds; dispatches by model prefix.
+"""
+
+from .base import ChatRequest, ChatResult, ModelInfo, ProviderSpec, qualify, split_model_id
+from .registry import ProviderPool, default_provider_name, fallback_model, make_provider
+
+__all__ = [
+    "ChatRequest", "ChatResult", "ModelInfo", "ProviderSpec", "ProviderPool",
+    "default_provider_name", "fallback_model", "make_provider", "qualify", "split_model_id",
+]

scootcli/providers/base.py

@@ -0,0 +1,370 @@
+"""Provider protocol, neutral types, and the plumbing every wire adapter shares.
+
+A wire adapter subclasses :class:`BaseProvider` and implements three things: ``_complete`` (one
+buffered chat call), ``_stream`` (one streamed call, invoking ``on_delta``), and optionally
+``_parse_models``. Everything else, API-key lookup, retries with capped backoff, HTTP status to typed
+error mapping, and ``provider/model`` id handling, lives here so adapters stay small.
+"""
+
+from __future__ import annotations
+
+import json
+import random
+import threading
+import time
+from dataclasses import dataclass, field
+from typing import Callable, Dict, FrozenSet, Iterator, List, Optional, Protocol, Tuple
+
+from ..errors import (
+    ApiError,
+    AuthError,
+    ContextLengthError,
+    Interrupted,
+    ModelUnavailableError,
+    QuotaError,
+    RETRIABLE,
+    RateLimitError,
+    ServerError,
+)
+from ..transport import _STATUS_MARKER, make_transport
+
+_RETRY_ATTEMPTS = 3
+_RETRY_BASE = 0.5
+_RETRY_CAP = 8.0
+
+STATUS_LINE_PREFIX = _STATUS_MARKER.strip()  # "HTTP_STATUS:"
+
+
+# ── neutral types ──────────────────────────────────────────────────────────────
+@dataclass
+class ChatResult:
+    """Parsed result of one model call (provider-independent)."""
+
+    content: str
+    model: str
+    tool_calls: List[dict] = field(default_factory=list)
+    finish_reason: str = ""
+    usage: dict = field(default_factory=dict)
+    raw_message: dict = field(default_factory=dict)  # the assistant message to append to history
+
+
+@dataclass
+class ChatRequest:
+    """One model call. ``hints`` is free-form metadata a router may read (task text, has_images…)."""
+
+    messages: List[dict]
+    model: str
+    tools: Optional[List[dict]] = None
+    tool_choice: str = "auto"
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+    cancel_event: Optional[threading.Event] = None
+    hints: Dict = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class ProviderSpec:
+    """A registry row: how to reach one provider. Pure data, so new providers are configuration."""
+
+    name: str
+    base_url: str
+    wire: str = "openai_responses"  # openai_responses | openai_chat
+    key_env: Tuple[str, ...] = ()  # env var names that may hold the API key, in order
+    key_required: bool = True
+    preferred_models: Tuple[str, ...] = ()  # substrings, best first; used by ``auto`` and as fallback
+    vision_models: Tuple[str, ...] = ()  # substrings of models that accept image input
+    capabilities: FrozenSet[str] = frozenset({"tools", "streaming"})  # + vision reasoning temperature
+    extra_headers: Tuple[Tuple[str, str], ...] = ()
+
+    def has(self, capability: str) -> bool:
+        return capability in self.capabilities
+
+
+@dataclass
+class ModelInfo:
+    """One model as listed by a provider; ``id`` is the qualified ``provider/name``."""
+
+    id: str
+    provider: str
+    name: str
+    raw: dict = field(default_factory=dict)
+
+
+def split_model_id(model: Optional[str]) -> Tuple[Optional[str], str]:
+    """``"openai/gpt-5.3-codex"`` → ``("openai", "gpt-5.3-codex")``; a bare name → ``(None, name)``."""
+    if model and "/" in model:
+        head, _, tail = model.partition("/")
+        if head and tail and " " not in head and "." not in head:
+            return head, tail
+    return None, model or ""
+
+
+def qualify(provider: str, model: str) -> str:
+    """Prefix ``model`` with ``provider/`` unless it already carries a provider."""
+    return model if split_model_id(model)[0] else f"{provider}/{model}"
+
+
+class Provider(Protocol):
+    """What consumers depend on. :class:`~scootcli.providers.registry.ProviderPool` implements it too."""
+
+    def chat(self, messages: List[dict], model: Optional[str] = None, tools=None, tool_choice="auto",
+             temperature=None, max_tokens=None, cancel_event=None, hints=None) -> ChatResult: ...
+
+    def chat_stream(self, messages: List[dict], model: Optional[str] = None, tools=None,
+                    tool_choice="auto", temperature=None, max_tokens=None, cancel_event=None,
+                    on_delta: Optional[Callable[[str], None]] = None, hints=None) -> ChatResult: ...
+
+    def list_models(self, cancel_event=None) -> List[ModelInfo]: ...
+
+
+# ── error mapping ──────────────────────────────────────────────────────────────
+def _error_fields(body: str) -> Tuple[str, str]:
+    """Pull ``(message, code)`` out of an OpenAI/Anthropic-style ``{"error": ...}`` body."""
+    if not body:
+        return "", ""
+    try:
+        data = json.loads(body)
+    except json.JSONDecodeError:
+        return body[:200], ""
+    if not isinstance(data, dict):
+        return "", ""
+    err = data.get("error")
+    if isinstance(err, dict):
+        return (err.get("message") or ""), (err.get("code") or err.get("type") or "")
+    if isinstance(err, str):
+        return err, ""
+    return "", ""
+
+
+def raise_for_status(status: int, body: str, provider: str = "") -> None:
+    """Classify an HTTP status + error body into a typed error; return silently on success."""
+    msg, code = _error_fields(body)
+    who = provider or "the provider"
+    if status == 401:
+        raise AuthError(msg or "unauthorized (401)",
+                        hint=f"API key for {who} is missing or invalid; run `scoot auth`")
+    if status in (402, 403):
+        raise QuotaError(msg or f"access denied ({status})", status=status,
+                         hint=f"check billing, quota, and permissions for {who}")
+    if status == 429:
+        raise RateLimitError(msg or "rate limited (429)", status=status,
+                             hint="too many requests; backing off and retrying")
+    if 500 <= status <= 599:
+        raise ServerError(msg or f"server error ({status})", status=status,
+                          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")):
+            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",
+                                   "does not exist", "not exist")):
+            raise ModelUnavailableError(msg or "model unavailable", status=status, code=code,
+                                        hint="switching to a supported model")
+        if msg:
+            raise ApiError(msg, status=status, code=code)
+        raise ApiError(f"request failed (HTTP {status})", status=status)
+
+
+def decode_json(status: int, body: str) -> dict:
+    if not body:
+        raise ApiError("empty response from API", status=status)
+    try:
+        return json.loads(body)
+    except json.JSONDecodeError as exc:
+        raise ApiError(f"non-JSON response (HTTP {status}): {body[:200]}", status=status) from exc
+
+
+def normalize_usage(usage: Optional[dict]) -> dict:
+    """Return usage with the neutral ``prompt_tokens`` / ``completion_tokens`` / ``total_tokens`` keys."""
+    if not isinstance(usage, dict):
+        return {}
+    out = dict(usage)
+    if "prompt_tokens" not in out and "input_tokens" in out:
+        out["prompt_tokens"] = out.get("input_tokens") or 0
+    if "completion_tokens" not in out and "output_tokens" in out:
+        out["completion_tokens"] = out.get("output_tokens") or 0
+    if "total_tokens" not in out:
+        out["total_tokens"] = int(out.get("prompt_tokens") or 0) + int(out.get("completion_tokens") or 0)
+    return out
+
+
+# ── shared plumbing ────────────────────────────────────────────────────────────
+class BaseProvider:
+    """Auth, retries, and HTTP for one provider; wire adapters implement the (de)serialisation."""
+
+    wire = "abstract"
+
+    def __init__(self, spec: ProviderSpec, config, transport=None, api_key: Optional[str] = None):
+        self.spec = spec
+        self.config = config
+        self.transport = transport or make_transport(config)
+        self._api_key = api_key
+
+    # ── identity ────────────────────────────────────────────────────────────────
+    @property
+    def name(self) -> str:
+        return self.spec.name
+
+    def default_model(self) -> Optional[str]:
+        """The provider's first preferred model (bare), or ``None`` when it has no opinion."""
+        return self.spec.preferred_models[0] if self.spec.preferred_models else None
+
+    def bare_model(self, model: Optional[str]) -> str:
+        """Strip our own ``provider/`` prefix; a bare name (or another provider's) passes through."""
+        head, tail = split_model_id(model)
+        return tail if head == self.name else (model or "")
+
+    def qualified(self, model: str) -> str:
+        return qualify(self.name, self.bare_model(model))
+
+    # ── public API (the Provider protocol) ───────────────────────────────────────
+    def chat(self, messages, model=None, tools=None, tool_choice="auto", temperature=None,
+             max_tokens=None, cancel_event=None, hints=None) -> ChatResult:
+        req = self._request(messages, model, tools, tool_choice, temperature, max_tokens,
+                            cancel_event, hints)
+        return self._with_retry(lambda: self._complete(req), req.cancel_event)
+
+    def chat_stream(self, messages, model=None, tools=None, tool_choice="auto", temperature=None,
+                    max_tokens=None, cancel_event=None, on_delta=None, hints=None) -> ChatResult:
+        req = self._request(messages, model, tools, tool_choice, temperature, max_tokens,
+                            cancel_event, hints)
+        emitted = [False]
+        sink = on_delta or (lambda _t: None)
+
+        def _on_delta(text: str) -> None:
+            emitted[0] = True
+            sink(text)
+
+        return self._with_retry(lambda: self._stream(req, _on_delta), req.cancel_event, emitted)
+
+    def list_models(self, cancel_event=None) -> List[ModelInfo]:
+        status, body = self._http("GET", "/models", None, cancel_event)
+        return self._parse_models(decode_json(status, body))
+
+    # ── adapter hooks ────────────────────────────────────────────────────────────
+    def _complete(self, req: ChatRequest) -> ChatResult:
+        raise NotImplementedError
+
+    def _stream(self, req: ChatRequest, on_delta: Callable[[str], None]) -> ChatResult:
+        raise NotImplementedError
+
+    def _parse_models(self, data) -> List[ModelInfo]:
+        """OpenAI-style ``{"data": [{"id": ...}]}`` (also what Ollama's ``/v1/models`` returns)."""
+        rows = data.get("data", []) if isinstance(data, dict) else data
+        out = []
+        for row in rows or []:
+            if not isinstance(row, dict):
+                continue
+            mid = row.get("id") or row.get("name")
+            if mid:
+                out.append(ModelInfo(id=qualify(self.name, mid), provider=self.name, name=mid, raw=row))
+        return out
+
+    # ── request assembly ─────────────────────────────────────────────────────────
+    def _request(self, messages, model, tools, tool_choice, temperature, max_tokens, cancel_event,
+                 hints) -> ChatRequest:
+        bare = self.bare_model(model) or self.default_model() or ""
+        if not bare:
+            raise ApiError(f"no model given for provider '{self.name}'",
+                           hint=f"pass --model {self.name}/<name> or set SCOOT_MODEL")
+        return ChatRequest(messages=list(messages), model=bare, tools=tools, tool_choice=tool_choice,
+                           temperature=temperature, max_tokens=max_tokens, cancel_event=cancel_event,
+                           hints=dict(hints or {}))
+
+    # ── HTTP ─────────────────────────────────────────────────────────────────────
+    def api_key(self) -> Optional[str]:
+        if self._api_key is None:
+            from ..auth import api_key_for
+
+            self._api_key = api_key_for(self.spec) or ""
+        return self._api_key or None
+
+    def _auth(self) -> str:
+        key = self.api_key()
+        if not key and self.spec.key_required:
+            env = self.spec.key_env[0] if self.spec.key_env else f"{self.name.upper()}_API_KEY"
+            raise AuthError(f"no API key for {self.name}",
+                            hint=f"set {env} or run `scoot auth set {self.name}`")
+        return key or ""
+
+    def _url(self, path: str) -> str:
+        return self.spec.base_url.rstrip("/") + path
+
+    def _extra_headers(self) -> List[str]:
+        return [f"{k}: {v}" for k, v in self.spec.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,
+        )
+        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,
+        )
+
+    # ── retry policy ─────────────────────────────────────────────────────────────
+    def _with_retry(self, fn: Callable[[], ChatResult], cancel_event, emitted=None) -> ChatResult:
+        """Retry transient failures with capped, jittered backoff; never after tokens were printed."""
+        attempt = 0
+        while True:
+            attempt += 1
+            try:
+                return fn()
+            except RETRIABLE:
+                if attempt >= _RETRY_ATTEMPTS or (emitted is not None and emitted[0]):
+                    raise
+                self._backoff(attempt, cancel_event)
+
+    @staticmethod
+    def _backoff(attempt: int, cancel_event) -> None:
+        delay = min(_RETRY_CAP, _RETRY_BASE * (2 ** (attempt - 1)))
+        delay += random.uniform(0, delay * 0.25)  # jitter
+        end = time.time() + delay
+        while time.time() < end:
+            if cancel_event is not None and cancel_event.is_set():
+                raise Interrupted("cancelled during backoff")
+            time.sleep(0.05)
+
+
+def iter_sse_json(lines: Iterator[str], status_holder: dict, leftovers: List[str]) -> Iterator[dict]:
+    """Walk raw SSE lines: yield each ``data:`` JSON object, record the status sentinel, collect
+    anything that is not SSE (an error body) into ``leftovers``."""
+    for line in lines:
+        if line.startswith(STATUS_LINE_PREFIX):
+            try:
+                status_holder["status"] = int(line.split(":", 1)[1].strip())
+            except (ValueError, IndexError):
+                pass
+            continue
+        stripped = line.strip()
+        if not stripped or stripped.startswith("event:") or stripped.startswith(":"):
+            continue
+        if stripped.startswith("data:"):
+            status_holder["saw_data"] = True
+            data = stripped[len("data:"):].strip()
+            if data == "[DONE]":
+                continue
+            try:
+                yield json.loads(data)
+            except json.JSONDecodeError:
+                continue
+        else:
+            leftovers.append(line)
+
+
+def finish_stream(status_holder: dict, leftovers: List[str], provider: str) -> None:
+    """After a stream ends: raise the typed error for a non-200 status or a plain error body."""
+    status = status_holder.get("status", 200)
+    if status != 200 or (not status_holder.get("saw_data") and leftovers):
+        body = "".join(leftovers).strip()
+        raise_for_status(status if status != 200 else 400, body, provider)
+        if body:
+            raise ApiError(body[:200], status=status)