minimalcode 1.5.2__py3-none-any.whl

minimalcode/provider/anthropic_env.py

@@ -0,0 +1,161 @@
+"""Claude Code style environment configuration for the Anthropic protocol.
+
+Claude Code is configured through process environment variables
+(``ANTHROPIC_BASE_URL``, ``ANTHROPIC_AUTH_TOKEN``, ``ANTHROPIC_MODEL`` and the
+``CLAUDE_CODE_*`` knobs). ``minimalcode --anthropic-env`` reuses that convention
+so an existing Claude Code setup can start MinimalCode without editing
+``settings.json``. Nothing here is written to disk: the caller injects the
+returned provider entry into the in-memory settings only.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+from collections.abc import Mapping
+from dataclasses import dataclass
+from typing import Any
+
+from ..config import EFFORT_LEVELS
+from ..errors import ConfigError
+
+# The provider name a session records when the environment is the source. It is
+# not written to settings.json, so it cannot collide with a configured provider.
+ANTHROPIC_ENV_PROVIDER = "anthropic-env"
+DEFAULT_ANTHROPIC_BASE_URL = "https://api.deepseek.com/anthropic"
+# Anthropic's standard Messages window. DeepSeek and other 1M endpoints opt in
+# with the Claude Code model suffix (``deepseek-flash[1m]``) or an explicit
+# ANTHROPIC_CONTEXT_WINDOW, so no hostname check is needed here.
+DEFAULT_CONTEXT_WINDOW = 200_000
+DEFAULT_MAX_TOKENS = 8192
+# Claude Code parses ``model[1m]`` client side and sends the bare model name;
+# the suffix only selects a context window.
+_CONTEXT_SUFFIX = re.compile(r"^(?P<model>.+?)\[(?P<size>\d+)(?P<unit>[kKmM])\]$")
+
+
+@dataclass(slots=True)
+class AnthropicEnvConfig:
+    """Provider entry derived from the environment, plus in-memory overrides."""
+
+    provider: str
+    config: dict[str, Any]
+    model: str
+    thinking: str | None
+    compact_at: float | None
+
+
+def _text(environ: Mapping[str, str], name: str) -> str | None:
+    value = environ.get(name)
+    if isinstance(value, str) and value.strip():
+        return value.strip()
+    return None
+
+
+def _positive_int(text: str, name: str) -> int:
+    try:
+        value = int(text)
+    except (TypeError, ValueError) as exc:
+        raise ConfigError(f"{name} must be a positive integer: {text!r}") from exc
+    if value < 1:
+        raise ConfigError(f"{name} must be a positive integer: {text!r}")
+    return value
+
+
+def _split_model(text: str) -> tuple[str, int | None]:
+    """Strip Claude Code's ``[Nk]``/``[Nm]`` suffix and return its window."""
+    match = _CONTEXT_SUFFIX.match(text)
+    if match is None:
+        return text, None
+    size = int(match.group("size"))
+    multiplier = 1_000 if match.group("unit").lower() == "k" else 1_000_000
+    return match.group("model"), max(1, size * multiplier)
+
+
+def from_anthropic_env(
+    environ: Mapping[str, str] | None = None,
+    *,
+    model: str | None = None,
+    thinking: str | None = None,
+) -> AnthropicEnvConfig:
+    """Build an Anthropic provider entry from Claude Code environment variables.
+
+    Explicit ``model`` / ``thinking`` arguments (the CLI flags) win over the
+    environment. The API key is never echoed in an error message.
+    """
+    env = os.environ if environ is None else environ
+
+    base_url = _text(env, "ANTHROPIC_BASE_URL") or DEFAULT_ANTHROPIC_BASE_URL
+    auth_token = _text(env, "ANTHROPIC_AUTH_TOKEN")
+    api_key = _text(env, "ANTHROPIC_API_KEY")
+    if not auth_token and not api_key:
+        raise ConfigError(
+            "--anthropic-env requires ANTHROPIC_AUTH_TOKEN or ANTHROPIC_API_KEY"
+        )
+
+    raw_model = (
+        (model or "").strip()
+        or _text(env, "ANTHROPIC_MODEL")
+        or _text(env, "ANTHROPIC_DEFAULT_SONNET_MODEL")
+    )
+    if not raw_model:
+        raise ConfigError(
+            "--anthropic-env requires a model: pass --model or set ANTHROPIC_MODEL"
+        )
+    model_id, suffix_window = _split_model(raw_model)
+
+    context_window = suffix_window or DEFAULT_CONTEXT_WINDOW
+    window_override = _text(env, "ANTHROPIC_CONTEXT_WINDOW")
+    if window_override is not None:
+        context_window = _positive_int(window_override, "ANTHROPIC_CONTEXT_WINDOW")
+
+    max_tokens = DEFAULT_MAX_TOKENS
+    max_tokens_override = _text(env, "ANTHROPIC_MAX_TOKENS")
+    if max_tokens_override is not None:
+        max_tokens = _positive_int(max_tokens_override, "ANTHROPIC_MAX_TOKENS")
+
+    compact_at: float | None = None
+    compact_window = _text(env, "CLAUDE_CODE_AUTO_COMPACT_WINDOW")
+    if compact_window is not None:
+        threshold = _positive_int(compact_window, "CLAUDE_CODE_AUTO_COMPACT_WINDOW")
+        ratio = threshold / context_window
+        # context.compact_at must stay inside (0, 1); a window larger than the
+        # context size means "compact as late as possible", not "never".
+        compact_at = round(min(0.95, max(0.1, ratio)), 4)
+
+    headers: dict[str, str] = {}
+    config: dict[str, Any] = {
+        "protocol": "anthropic_messages",
+        "base_url": base_url,
+        "model": model_id,
+        "context_window": context_window,
+        "max_tokens": max_tokens,
+        "timeout_seconds": 120,
+        "stream": True,
+        "send_reasoning_effort": True,
+        "headers": headers,
+        "extra_body": {},
+    }
+    if auth_token is not None:
+        # Claude Code's ANTHROPIC_AUTH_TOKEN is a bearer credential; an
+        # ANTHROPIC_API_KEY keeps the x-api-key header the client generates.
+        headers["Authorization"] = f"Bearer {auth_token}"
+    else:
+        config["api_key"] = api_key
+
+    effort = thinking or _text(env, "CLAUDE_CODE_EFFORT_LEVEL")
+    if effort is not None:
+        effort = effort.strip().lower()
+        if effort not in EFFORT_LEVELS:
+            if thinking is not None:
+                # An explicit flag is validated by argparse; reaching here means
+                # the caller passed something else and should hear about it.
+                raise ConfigError(f"unknown effort: {thinking!r}")
+            effort = None
+
+    return AnthropicEnvConfig(
+        provider=ANTHROPIC_ENV_PROVIDER,
+        config=config,
+        model=model_id,
+        thinking=effort,
+        compact_at=compact_at,
+    )

minimalcode/provider/chat.py

@@ -0,0 +1,394 @@
+"""OpenAI Chat Completions payloads, streams, and response parsing."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Callable, Iterable
+from typing import Any
+
+import httpx2
+
+from ..errors import ProviderError
+from .common import (
+    content_text,
+    decode_json_body,
+    is_event_stream,
+    normalize_usage,
+    stream_event_error,
+    strip_sse_bom,
+    tool_arguments,
+)
+from .types import ProviderReply, ToolCall
+
+
+class ChatProtocolMixin:
+    """Chat Completions wire format for the provider client."""
+
+    # Attributes supplied by OpenAICompatibleProvider.
+    config: dict[str, Any]
+    model: str
+    thinking: str
+    stream_enabled: bool
+    include_usage: bool
+    send_reasoning_effort: bool
+
+    def _open(self, payload: dict[str, Any]) -> httpx2.Response:
+        raise NotImplementedError
+
+    @staticmethod
+    def _chat_messages(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """Drop the Anthropic-only history field from Chat messages."""
+        return [
+            {key: value for key, value in message.items() if key != "provider_content"}
+            for message in messages
+            if isinstance(message, dict) and isinstance(message.get("role"), str)
+        ]
+
+    def _chat_payload(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None,
+    ) -> dict[str, Any]:
+        """Build the Chat Completions request body."""
+        payload: dict[str, Any] = {
+            "model": self.model,
+            "messages": self._chat_messages(messages),
+            "stream": self.stream_enabled,
+        }
+        if tools:
+            payload["tools"] = tools
+            payload["tool_choice"] = "auto"
+        if self.stream_enabled and self.include_usage:
+            payload["stream_options"] = {"include_usage": True}
+        if self.send_reasoning_effort:
+            effort = self.thinking.strip().lower()
+            if effort == "none":
+                payload["thinking"] = {"type": "disabled"}
+            elif effort:
+                payload["reasoning_effort"] = effort
+        extra = self.config.get("extra_body")
+        if isinstance(extra, dict):
+            # Never let extra_body override protocol-critical fields.
+            reserved = {"model", "messages", "stream", "tools", "tool_choice"}
+            payload.update(
+                {key: value for key, value in extra.items() if key not in reserved}
+            )
+        return payload
+
+    def _chat_stream_request(
+        self,
+        payload: dict[str, Any],
+        *,
+        on_text: Callable[[str], None] | None,
+        on_thinking: Callable[[str], None] | None,
+    ) -> ProviderReply:
+        """Request a streaming reply, tolerating JSON when SSE is misconfigured."""
+        response = self._open(payload)
+        try:
+            if not is_event_stream(response):
+                body = self._read_body(response)
+                parsed, data = decode_json_body(body)
+                if parsed:
+                    return self._parse_chat_payload(
+                        data, on_text=on_text, on_thinking=on_thinking
+                    )
+                text = body.decode("utf-8", errors="replace")
+                if "data:" not in text:
+                    raise ProviderError("provider returned an invalid response")
+                lines: Iterable[str] = text.splitlines()
+            else:
+                lines = response.iter_lines()
+            return self._parse_chat_stream(
+                lines, on_text=on_text, on_thinking=on_thinking
+            )
+        finally:
+            response.close()
+
+    def _parse_chat_stream(
+        self,
+        lines: Iterable[str],
+        *,
+        on_text: Callable[[str], None] | None,
+        on_thinking: Callable[[str], None] | None,
+    ) -> ProviderReply:
+        """Accumulate content, tool-call fragments, usage, and finish state."""
+        content_parts: list[str] = []
+        # Calls arrive as fragments keyed by `index`: id and name are sent once,
+        # while the arguments JSON string is split across many chunks, so each
+        # entry accumulates instead of being overwritten.
+        calls: dict[int, dict[str, str]] = {}
+        last_call_index = -1
+        finish_reason: str | None = None
+        saw_terminal = False
+        usage: dict[str, int] = {}
+
+        try:
+            for data in self._sse_events(lines):
+                # The assembler strips a line-leading BOM; a payload that
+                # carries one after `data: ` is stripped here.
+                data = strip_sse_bom(data).strip()
+                if not data:
+                    continue
+                if data == "[DONE]":
+                    saw_terminal = True
+                    continue
+                try:
+                    event = json.loads(data)
+                except json.JSONDecodeError:
+                    # Unknown SSE fields are ignored; malformed JSON is not a
+                    # protocol event and must not abort an otherwise valid stream.
+                    continue
+                if not isinstance(event, dict):
+                    continue
+                if event.get("error"):
+                    raise stream_event_error(event)
+
+                raw_usage = event.get("usage")
+                if isinstance(raw_usage, dict):
+                    parsed_usage = normalize_usage(raw_usage)
+                    if parsed_usage:
+                        usage = parsed_usage
+
+                choices = event.get("choices")
+                if not isinstance(choices, list) or not choices:
+                    continue
+                choice = choices[0]
+                if not isinstance(choice, dict):
+                    continue
+                delta = choice.get("delta")
+                if not isinstance(delta, dict):
+                    delta = {}
+                text = content_text(delta.get("content")) or content_text(
+                    delta.get("refusal")
+                )
+                if text:
+                    content_parts.append(text)
+                    if on_text is not None:
+                        on_text(text)
+
+                if on_thinking is not None:
+                    # DeepSeek/Qwen stream `reasoning_content`; OpenRouter uses
+                    # `reasoning`. Neither belongs in `content`: reasoning is
+                    # display-only and must never enter the assistant message.
+                    reasoning = content_text(
+                        delta.get("reasoning_content")
+                    ) or content_text(delta.get("reasoning"))
+                    if reasoning:
+                        on_thinking(reasoning)
+
+                raw_calls = delta.get("tool_calls")
+                if isinstance(raw_calls, list):
+                    for raw_call in raw_calls:
+                        if not isinstance(raw_call, dict):
+                            continue
+                        try:
+                            index = int(raw_call["index"])
+                        except (KeyError, TypeError, ValueError):
+                            # Some OpenAI-compatible servers omit `index`. A
+                            # fragment belongs to the call whose id it repeats,
+                            # so two interleaved parallel calls must be matched
+                            # by id: opening a new entry per fragment left the
+                            # earlier call with half its arguments and dropped
+                            # the rest with the unnamed entry.
+                            incoming_id = str(raw_call.get("id") or "")
+                            matched = next(
+                                (
+                                    position
+                                    for position, state in calls.items()
+                                    if incoming_id and state["id"] == incoming_id
+                                ),
+                                None,
+                            )
+                            if matched is not None:
+                                index = matched
+                            elif last_call_index >= 0 and (
+                                # An unlabelled continuation of the call that
+                                # just streamed, or the fragment that supplies
+                                # the id of a call whose first fragment had
+                                # none. Opening a new entry here truncated the
+                                # arguments of the common "id once, arguments in
+                                # many chunks" frame.
+                                not incoming_id
+                                or not calls[last_call_index]["id"]
+                                or calls[last_call_index]["id"] == incoming_id
+                            ):
+                                index = last_call_index
+                            else:
+                                index = max(calls, default=-1) + 1
+                        else:
+                            # A non-conforming server can reuse an index for a
+                            # new call id. Treat that as a new call instead of
+                            # overwriting the first one and concatenating its
+                            # arguments into invalid JSON. Each slot records the
+                            # wire index it belongs to, so the unlabelled
+                            # continuation fragments follow the replacement call
+                            # rather than falling back to the first one.
+                            wire_index = int(raw_call["index"])
+                            index = next(
+                                (
+                                    position
+                                    for position in reversed(calls)
+                                    if calls[position].get("wire") == str(wire_index)
+                                ),
+                                wire_index,
+                            )
+                            existing = calls.get(index)
+                            incoming_id = str(raw_call.get("id") or "")
+                            if (
+                                existing is not None
+                                and incoming_id
+                                and existing["id"]
+                                and incoming_id != existing["id"]
+                            ):
+                                index = max(calls, default=-1) + 1
+                            calls.setdefault(
+                                index,
+                                {"id": "", "name": "", "arguments": ""},
+                            )["wire"] = str(wire_index)
+                        last_call_index = index
+                        entry = calls.setdefault(
+                            index,
+                            {"id": "", "name": "", "arguments": ""},
+                        )
+                        if raw_call.get("id"):
+                            entry["id"] = str(raw_call["id"])
+                        function = raw_call.get("function")
+                        if isinstance(function, dict):
+                            if function.get("name"):
+                                entry["name"] = str(function["name"])
+                            arguments = function.get("arguments")
+                            if isinstance(arguments, str):
+                                if entry.get("object_arguments"):
+                                    # The call was already completed as an
+                                    # object; appending a stray fragment would
+                                    # produce `{"a":1}{"a":1}`.
+                                    continue
+                                entry["arguments"] += arguments
+                            elif arguments is not None:
+                                # A whole-object argument value is complete on
+                                # its own, so it replaces any partial string
+                                # earlier chunks accumulated: keeping the
+                                # fragment left invalid JSON behind.
+                                entry["arguments"] = tool_arguments(arguments)
+                                entry["object_arguments"] = True
+                if choice.get("finish_reason"):
+                    finish_reason = str(choice["finish_reason"])
+                    saw_terminal = True
+        except httpx2.HTTPError as exc:
+            raise ProviderError(f"provider stream interrupted: {exc}") from exc
+
+        tool_calls: list[ToolCall] = []
+        # Sorting by stream index replays the calls in the order the model emitted
+        # them; dict insertion order can differ when a later chunk fills in an
+        # earlier index.
+        for index in sorted(calls):
+            entry = calls[index]
+            if not entry["name"]:
+                continue
+            tool_calls.append(
+                ToolCall(
+                    id=entry["id"] or f"call_{index}",
+                    name=entry["name"],
+                    arguments=entry["arguments"] or "{}",
+                )
+            )
+        if not saw_terminal:
+            # The connection closed before the provider sent finish_reason or
+            # [DONE]. Treating that as a normal stop silently truncates answers
+            # and can execute a half-received tool call.
+            finish_reason = "incomplete"
+        elif finish_reason is None:
+            finish_reason = "tool_calls" if tool_calls else "stop"
+        if not content_parts and not tool_calls and not saw_terminal:
+            # `saw_terminal` is re-read here on purpose: a stream that terminated
+            # cleanly with no content is a legal empty answer, while one that died
+            # without a terminal event is a broken response.
+            raise ProviderError("provider returned an empty stream")
+        return ProviderReply(
+            content="".join(content_parts),
+            tool_calls=tool_calls,
+            finish_reason=finish_reason,
+            usage=usage,
+        )
+
+    def _parse_chat_payload(
+        self,
+        data: Any,
+        *,
+        on_text: Callable[[str], None] | None,
+        on_thinking: Callable[[str], None] | None,
+    ) -> ProviderReply:
+        """Parse one non-streaming Chat Completions response body."""
+        if not isinstance(data, dict):
+            raise ProviderError("provider response must be an object")
+        if data.get("error"):
+            raise ProviderError(f"provider response failed: {data['error']}")
+        choices = data.get("choices")
+        if not isinstance(choices, list) or not choices:
+            raise ProviderError("provider response has no choices")
+        choice = choices[0]
+        if not isinstance(choice, dict):
+            raise ProviderError("provider response choice must be an object")
+        message = choice.get("message")
+        if not isinstance(message, dict):
+            raise ProviderError("provider response has no message")
+        content = content_text(message.get("content")) or content_text(
+            message.get("refusal")
+        )
+        if content and on_text is not None:
+            on_text(content)
+        if on_thinking is not None:
+            reasoning = content_text(message.get("reasoning_content")) or content_text(
+                message.get("reasoning")
+            )
+            if reasoning:
+                on_thinking(reasoning)
+        calls: list[ToolCall] = []
+        raw_calls = message.get("tool_calls")
+        if isinstance(raw_calls, list):
+            for index, raw_call in enumerate(raw_calls):
+                if not isinstance(raw_call, dict):
+                    continue
+                function = raw_call.get("function")
+                if not isinstance(function, dict):
+                    continue
+                name = str(function.get("name") or "")
+                if not name:
+                    continue
+                calls.append(
+                    ToolCall(
+                        id=str(raw_call.get("id") or f"call_{index}"),
+                        name=name,
+                        arguments=tool_arguments(function.get("arguments")),
+                    )
+                )
+        finish_reason = choice.get("finish_reason")
+        return ProviderReply(
+            content=content,
+            tool_calls=calls,
+            finish_reason=str(finish_reason) if finish_reason is not None else None,
+            usage=normalize_usage(data.get("usage")),
+        )
+
+    def _chat_regular_request(
+        self,
+        payload: dict[str, Any],
+        *,
+        on_text: Callable[[str], None] | None,
+        on_thinking: Callable[[str], None] | None,
+    ) -> ProviderReply:
+        """Request a non-streaming reply, accepting SSE if the server sends it."""
+        response = self._open(payload)
+        try:
+            # Some gateways ignore `stream: false` and answer with SSE anyway, so
+            # the content type, not the request flag, selects the parser.
+            if is_event_stream(response):
+                return self._parse_chat_stream(
+                    response.iter_lines(), on_text=on_text, on_thinking=on_thinking
+                )
+            parsed, data = decode_json_body(self._read_body(response))
+            if not parsed:
+                raise ProviderError("provider returned invalid JSON")
+        finally:
+            response.close()
+        return self._parse_chat_payload(data, on_text=on_text, on_thinking=on_thinking)