seedcode-cli 6.1.5__py3-none-any.whl

seedcode/core/providers/aerolink.py

@@ -0,0 +1,324 @@
+"""AeroLink backend: Anthropic-compatible gateway at capi.aerolink.lat.
+
+AeroLink (https://aerolink.lat) exposes the Anthropic Messages API and
+serves Claude-family models only. This provider speaks that protocol
+directly over httpx: ``POST /v1/messages`` with SSE streaming, and
+``GET /v1/models`` for the catalogue when the gateway supports it. No
+models are hardcoded; if listing is unavailable the user types the model
+ID from their AeroLink dashboard. Independent API key and model.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterator
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import httpx
+
+from .base import (
+    ModelInfo,
+    Provider,
+    ProviderError,
+    StreamEvent,
+    TextDelta,
+    ToolCallEvent,
+    ToolSpec,
+    ValidationResult,
+)
+
+if TYPE_CHECKING:
+    from ..models import AppConfig, Message
+
+_BASE_URL = "https://capi.aerolink.lat"
+_API_VERSION = "2023-06-01"  # Anthropic Messages API version header
+_TIMEOUT = httpx.Timeout(20.0, read=180.0)
+
+
+def _headers(api_key: str) -> dict[str, str]:
+    return {
+        "x-api-key": api_key,
+        "anthropic-version": _API_VERSION,
+        "content-type": "application/json",
+    }
+
+
+@dataclass
+class AeroLinkProvider(Provider):
+    def __post_init__(self) -> None:
+        self.id = "aerolink"
+        self.label = "AeroLink"
+        self.base_url = _BASE_URL
+        self.requires_key = True
+        self.key_hint = "from your dashboard at https://aerolink.lat (API keys page)"
+
+    def validate_key(self, api_key: str) -> ValidationResult:
+        key = api_key.strip()
+        if not key:
+            return ValidationResult(False, "API key is empty.")
+        try:
+            response = httpx.get(
+                f"{_BASE_URL}/v1/models", headers=_headers(key), timeout=20.0
+            )
+        except httpx.TimeoutException:
+            return ValidationResult(False, "Validation timed out. Check your connection.")
+        except httpx.HTTPError:
+            return ValidationResult(False, "Could not reach AeroLink. Check your connection.")
+        if response.status_code == 200:
+            return ValidationResult(True, "API key verified.")
+        if response.status_code in (401, 403):
+            return ValidationResult(False, "API key was rejected by AeroLink.")
+        # Some gateways don't proxy /v1/models; accept and verify on first chat.
+        return ValidationResult(
+            True, "Key saved. AeroLink did not confirm it; it will be verified on first message."
+        )
+
+    def list_models(self, config: "AppConfig") -> list[ModelInfo]:
+        key = config.get_api_key("aerolink")
+        try:
+            response = httpx.get(
+                f"{_BASE_URL}/v1/models", headers=_headers(key), timeout=20.0
+            )
+            response.raise_for_status()
+            data = response.json().get("data", [])
+        except httpx.TimeoutException as exc:
+            raise ProviderError(
+                "Timed out fetching the AeroLink model list.", transient=True
+            ) from exc
+        except (httpx.HTTPError, ValueError) as exc:
+            raise ProviderError(
+                "AeroLink did not return a model list. Enter a model ID from your "
+                "dashboard with: /model <model-id>",
+            ) from exc
+
+        # AeroLink serves the Claude family only — filter anything else out.
+        models = [
+            ModelInfo(id=entry["id"], label=entry.get("display_name") or entry["id"])
+            for entry in data
+            if entry.get("id") and "claude" in entry["id"].lower()
+        ]
+        if not models:
+            raise ProviderError(
+                "AeroLink returned no Claude-family models. Enter a model ID from "
+                "your dashboard with: /model <model-id>"
+            )
+        return models
+
+    def stream_chat(self, config: "AppConfig", messages: list["Message"]) -> Iterator[str]:
+        # The Messages API takes the system prompt as a top-level field.
+        system = next((m.content for m in messages if m.role == "system"), None)
+        turns = [m.to_api() for m in messages if m.role != "system"]
+        payload: dict[str, object] = {
+            "model": config.model,
+            "max_tokens": config.effective_max_tokens(),
+            "messages": turns,
+            "stream": True,
+        }
+        if system:
+            payload["system"] = system
+        yield from self._stream_payload(config, payload, _iter_sse_text)
+
+    # --- native tool calling -------------------------------------------------
+    def supports_tools(self, config: "AppConfig") -> bool:
+        """AeroLink serves Claude models, which all take native tools."""
+        return True
+
+    def stream_chat_with_tools(
+        self, config: "AppConfig", messages: list["Message"], tools: list[ToolSpec]
+    ) -> Iterator[StreamEvent]:
+        system = next((m.content for m in messages if m.role == "system"), None)
+        payload: dict[str, object] = {
+            "model": config.model,
+            "max_tokens": config.effective_max_tokens(),
+            "messages": _to_anthropic_turns(messages),
+            "tools": [
+                {
+                    "name": t.name,
+                    "description": t.description,
+                    "input_schema": t.parameters,
+                }
+                for t in tools
+            ],
+            "stream": True,
+        }
+        if system:
+            payload["system"] = system
+        yield from self._stream_payload(config, payload, _iter_sse_events)
+
+    def _stream_payload(self, config: "AppConfig", payload: dict, parser) -> Iterator:
+        """POST /v1/messages with shared status handling; yield parser output."""
+        try:
+            with httpx.stream(
+                "POST",
+                f"{_BASE_URL}/v1/messages",
+                headers=_headers(config.get_api_key("aerolink")),
+                json=payload,
+                timeout=_TIMEOUT,
+            ) as response:
+                if response.status_code in (401, 403):
+                    raise ProviderError(
+                        "Authentication failed. Your AeroLink key may be invalid — run /apikey."
+                    )
+                if response.status_code == 402:
+                    raise ProviderError(
+                        "AeroLink says the account is out of credits (HTTP 402). "
+                        "Check your plan at https://aerolink.lat."
+                    )
+                if response.status_code == 404:
+                    raise ProviderError(
+                        f"Model '{config.model}' was not found on AeroLink — run /model."
+                    )
+                if response.status_code == 408:
+                    raise ProviderError(
+                        "AeroLink timed out handling the request. Please try again.",
+                        transient=True,
+                    )
+                if response.status_code == 429:
+                    raise ProviderError(
+                        "Rate limited by AeroLink. Please wait and try again.", transient=True
+                    )
+                if response.status_code >= 500:
+                    raise ProviderError(
+                        f"AeroLink had a server error (HTTP {response.status_code}). "
+                        "Please try again.",
+                        transient=True,
+                    )
+                if response.status_code >= 400:
+                    detail = response.read().decode("utf-8", "replace")[:300]
+                    raise ProviderError(f"AeroLink error (HTTP {response.status_code}): {detail}")
+                yield from parser(response)
+        except httpx.TimeoutException as exc:
+            raise ProviderError(
+                "Timed out talking to AeroLink. Please try again.", transient=True
+            ) from exc
+        except httpx.HTTPError as exc:
+            raise ProviderError(
+                "Network error reaching AeroLink. Check your connection.", transient=True
+            ) from exc
+
+
+def _iter_sse_text(response: httpx.Response) -> Iterator[str]:
+    """Yield text deltas from an Anthropic-style SSE stream."""
+    for line in response.iter_lines():
+        if not line.startswith("data:"):
+            continue
+        data = line[5:].strip()
+        if not data or data == "[DONE]":
+            continue
+        try:
+            event = json.loads(data)
+        except ValueError:
+            continue  # tolerate keep-alive noise
+        if event.get("type") == "content_block_delta":
+            delta = event.get("delta") or {}
+            if delta.get("type") == "text_delta" and delta.get("text"):
+                yield delta["text"]
+        elif event.get("type") == "error":
+            message = (event.get("error") or {}).get("message", "Unknown AeroLink error.")
+            raise ProviderError(f"AeroLink error: {message}")
+
+
+def _iter_sse_events(response: httpx.Response) -> Iterator[StreamEvent]:
+    """Yield text deltas and COMPLETE tool calls from an Anthropic SSE stream.
+
+    ``content_block_start`` with a ``tool_use`` block opens a call (id and
+    name arrive there); ``input_json_delta`` fragments accumulate its
+    argument JSON; ``content_block_stop`` closes and emits it.
+    """
+    open_calls: dict[int, dict[str, str]] = {}  # block index -> {id, name, json}
+    for line in response.iter_lines():
+        if not line.startswith("data:"):
+            continue
+        data = line[5:].strip()
+        if not data or data == "[DONE]":
+            continue
+        try:
+            event = json.loads(data)
+        except ValueError:
+            continue  # tolerate keep-alive noise
+        kind = event.get("type")
+        if kind == "content_block_start":
+            block = event.get("content_block") or {}
+            if block.get("type") == "tool_use":
+                open_calls[event.get("index", 0)] = {
+                    "id": block.get("id", ""),
+                    "name": block.get("name", ""),
+                    "json": "",
+                }
+        elif kind == "content_block_delta":
+            delta = event.get("delta") or {}
+            if delta.get("type") == "text_delta" and delta.get("text"):
+                yield TextDelta(delta["text"])
+            elif delta.get("type") == "input_json_delta":
+                slot = open_calls.get(event.get("index", 0))
+                if slot is not None:
+                    slot["json"] += delta.get("partial_json", "")
+        elif kind == "content_block_stop":
+            slot = open_calls.pop(event.get("index", 0), None)
+            if slot is not None:
+                raw = slot["json"].strip() or "{}"
+                try:
+                    arguments = json.loads(raw)
+                    if not isinstance(arguments, dict):
+                        raise ValueError("input must be a JSON object")
+                    yield ToolCallEvent(
+                        id=slot["id"], name=slot["name"], arguments=arguments
+                    )
+                except ValueError as exc:
+                    yield ToolCallEvent(
+                        id=slot["id"], name=slot["name"], arguments={},
+                        error=f"Tool call arguments were not valid JSON: {exc}",
+                    )
+        elif kind == "error":
+            message = (event.get("error") or {}).get("message", "Unknown AeroLink error.")
+            raise ProviderError(f"AeroLink error: {message}")
+
+
+def _to_anthropic_turns(messages: list["Message"]) -> list[dict]:
+    """Serialize history to Anthropic Messages turns with tool blocks.
+
+    Wire rules this must satisfy (the API 400s otherwise):
+    * an assistant turn that called tools carries ``tool_use`` content blocks;
+    * ALL of that turn's results arrive in the SINGLE next user message as
+      ``tool_result`` blocks — consecutive role=="tool" messages are merged.
+    """
+    turns: list[dict] = []
+    pending_results: list[dict] = []
+
+    def flush_results() -> None:
+        if pending_results:
+            turns.append({"role": "user", "content": list(pending_results)})
+            pending_results.clear()
+
+    for message in messages:
+        if message.role == "system":
+            continue
+        if message.role == "tool":
+            pending_results.append(
+                {
+                    "type": "tool_result",
+                    "tool_use_id": message.tool_call_id,
+                    "content": message.content,
+                }
+            )
+            continue
+        flush_results()
+        if message.role == "assistant" and message.tool_calls:
+            content: list[dict] = []
+            if message.content.strip():
+                content.append({"type": "text", "text": message.content})
+            content += [
+                {
+                    "type": "tool_use",
+                    "id": call.id,
+                    "name": call.name,
+                    "input": call.arguments,
+                }
+                for call in message.tool_calls
+            ]
+            turns.append({"role": "assistant", "content": content})
+        else:
+            turns.append({"role": message.role, "content": message.content})
+    flush_results()
+    return turns

seedcode/core/providers/base.py

@@ -0,0 +1,230 @@
+"""Provider abstraction: the contract every AI backend implements.
+
+A provider is a fully independent backend: it owns its API key slot, base
+URL, model catalogue, client, and connection status. The chat engine and the
+UI never talk to a vendor API directly — they go through this interface, so
+providers share ONLY the common chat contract, never each other's logic.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..models import AppConfig, Message
+
+
+class ProviderError(Exception):
+    """A provider request failed with a user-presentable message.
+
+    ``transient`` marks failures worth retrying automatically (timeouts,
+    connection drops, rate limits) as opposed to permanent ones (bad key,
+    unknown model).
+    """
+
+    def __init__(self, message: str, *, transient: bool = False) -> None:
+        super().__init__(message)
+        self.transient = transient
+
+
+@dataclass(slots=True)
+class ValidationResult:
+    """Outcome of an API key validation attempt."""
+
+    ok: bool
+    message: str
+
+
+@dataclass(slots=True)
+class ModelInfo:
+    """One selectable model as reported by a provider.
+
+    ``is_free`` is set by providers whose catalogue carries pricing
+    (True/False); ``None`` means pricing does not apply (e.g. local models).
+    """
+
+    id: str
+    label: str = ""
+    detail: str = ""
+    is_free: bool | None = None
+
+    def __post_init__(self) -> None:
+        if not self.label:
+            self.label = self.id
+
+
+# Connection-status display values (session-only, never persisted).
+STATUS_UNKNOWN = "Not Checked"
+STATUS_CONNECTED = "Connected"
+STATUS_OFFLINE = "Offline"
+STATUS_NO_KEY = "No API Key"
+STATUS_BAD_KEY = "Invalid Key"
+
+
+# --- native tool calling ------------------------------------------------------
+@dataclass(slots=True)
+class ToolSpec:
+    """Provider-neutral tool description.
+
+    ``parameters`` is a JSON-schema object
+    (``{"type": "object", "properties": {...}, "required": [...]}``); each
+    provider converts it to its own wire format (OpenAI ``function``,
+    Anthropic ``input_schema``, ...).
+    """
+
+    name: str
+    description: str
+    parameters: dict
+
+
+@dataclass(slots=True)
+class TextDelta:
+    """A streamed piece of assistant text."""
+
+    text: str
+
+
+@dataclass(slots=True)
+class ToolCallEvent:
+    """One COMPLETE native tool call.
+
+    Providers accumulate their own streamed argument fragments and emit a
+    single event per finished call, so consumers never see wire-format
+    details. When the accumulated argument JSON would not parse, ``error``
+    carries the parse problem (and ``arguments`` is empty) — the agent feeds
+    it back to the model like any other malformed call.
+    """
+
+    id: str
+    name: str
+    arguments: dict
+    error: str = ""
+
+
+StreamEvent = TextDelta | ToolCallEvent
+
+
+@dataclass
+class Provider(ABC):
+    """Base class for AI backends.
+
+    Each concrete provider sets its identity in ``__post_init__`` and keeps
+    its own private client/catalogue caches — nothing is shared between
+    provider modules.
+    """
+
+    id: str = field(init=False)
+    label: str = field(init=False)
+    base_url: str = field(init=False, default="")
+    requires_key: bool = field(init=False, default=True)
+    key_hint: str = field(init=False, default="")
+    # Human name of the API family this backend speaks (e.g. "Claude API",
+    # "Responses API"); shown on the dashboard. Empty means "<label> API".
+    backend_label: str = field(init=False, default="")
+    # True when the provider supports the 'auto' model sentinel (the best
+    # model is resolved from the live catalogue per request).
+    supports_auto: bool = field(init=False, default=False)
+    # Last known connection status for this provider (session-only cache;
+    # refreshed by :meth:`refresh_status` — reading it does no network I/O).
+    status: str = field(init=False, default=STATUS_UNKNOWN)
+
+    def prepare(self, config: "AppConfig") -> None:
+        """Sync per-config state (e.g. an active sub-backend) before use.
+
+        Called by shared flows (key entry, validation, doctor) so a provider
+        with internal modes always acts on the configured one. Default: no-op.
+        """
+
+    def supports_images(self, config: "AppConfig") -> bool:
+        """Whether this backend can accept image attachments on messages.
+
+        Providers that can forward base64 screenshots to a vision-capable
+        model override this; the default is text-only, and callers must not
+        attach images when it returns False.
+        """
+        return False
+
+    @abstractmethod
+    def validate_key(self, api_key: str) -> ValidationResult:
+        """Check credentials with a REAL API request (never heuristics).
+
+        Providers without keys validate connectivity instead.
+        """
+
+    @abstractmethod
+    def list_models(self, config: "AppConfig") -> list[ModelInfo]:
+        """Fetch the models the user may select. Raises ProviderError."""
+
+    @abstractmethod
+    def stream_chat(self, config: "AppConfig", messages: list["Message"]) -> Iterator[str]:
+        """Stream a reply for the conversation. Raises ProviderError."""
+
+    # --- native tool calling -------------------------------------------------
+    def supports_tools(self, config: "AppConfig") -> bool:
+        """Whether this backend can take native tool/function definitions.
+
+        When False, the agent talks to the model through the text protocol
+        instead (fenced ``tool`` blocks). True is an *attempt*: a runtime
+        failure still falls back gracefully at the agent layer.
+        """
+        return False
+
+    def stream_chat_with_tools(
+        self, config: "AppConfig", messages: list["Message"], tools: list[ToolSpec]
+    ) -> Iterator[StreamEvent]:
+        """Stream a reply as events: text deltas and complete tool calls.
+
+        Default degrades to plain text so a provider without an override
+        still works (through the text protocol). Raises ProviderError.
+        """
+        for piece in self.stream_chat(config, messages):
+            yield TextDelta(piece)
+
+    # --- connection status ---------------------------------------------------
+    def refresh_status(self, config: "AppConfig") -> str:
+        """Probe the backend with a real request and cache the outcome.
+
+        Never raises; the result is stored in :attr:`status` and returned so
+        the UI can refresh immediately after a provider switch.
+        """
+        try:
+            if self.requires_key:
+                key = config.get_api_key(self.id).strip()
+                if not key:
+                    self.status = STATUS_NO_KEY
+                    return self.status
+                result = self.validate_key(key)
+                if result.ok:
+                    self.status = STATUS_CONNECTED
+                elif "connection" in result.message.lower() or "timed out" in result.message.lower():
+                    self.status = STATUS_OFFLINE
+                else:
+                    self.status = STATUS_BAD_KEY
+            else:
+                self.status = STATUS_CONNECTED if self.detect(config) else STATUS_OFFLINE
+        except Exception:  # a status probe must never break the UI
+            self.status = STATUS_OFFLINE
+        return self.status
+
+    def detect(self, config: "AppConfig") -> bool:
+        """Backend reachability for key-less providers (default: unknown)."""
+        return False
+
+    # --- provider-specific settings -------------------------------------------
+    def extra_settings(self, config: "AppConfig") -> dict[str, str]:
+        """Provider-specific settings shown on its own settings screen.
+
+        Returns ``{setting name: current display value}``; empty when the
+        provider has none. Values live in the provider's own config entry
+        (``ProviderConfig.options``), never shared.
+        """
+        return {}
+
+    def set_extra_setting(
+        self, config: "AppConfig", name: str, value: str
+    ) -> tuple[bool, str]:
+        """Apply a provider-specific setting; returns (ok, user message)."""
+        return False, f"{self.label} has no setting '{name}'."