otto-cli-agent 0.1.0__py3-none-any.whl

agent/router/llm_provider/__init__.py

@@ -0,0 +1,202 @@
+"""Provider registry: Inception, OpenAI, Anthropic, Gemini, and any named
+OpenAI-compatible endpoint (agent/router/llm_provider/custom.py).
+Still a registry, not a hardcoded import: a second vendor showing up later is
+a dict entry here, not a rewrite of every call site that reaches through
+get_provider()/provider_names(). Importing this package stays cheap for the
+same reason it always did -- lazy import, so a missing optional dependency
+breaks one provider, not the whole app.
+"""
+
+from __future__ import annotations
+
+import importlib
+import os
+from functools import lru_cache
+
+from langchain_core.language_models import BaseChatModel
+
+from .base import (
+    AuthError,
+    BaseProvider,
+    Capability,
+    CapabilityNotSupported,
+    HealthReport,
+    ModelInfo,
+    ModelNotFound,
+    ProviderError,
+    ProviderStatus,
+    ProviderUnavailable,
+    SupportsEdit,
+    SupportsEmbeddings,
+    SupportsFIM,
+)
+
+__all__ = [
+    "AuthError",
+    "BaseProvider",
+    "Capability",
+    "CapabilityNotSupported",
+    "HealthReport",
+    "ModelInfo",
+    "ModelNotFound",
+    "ProviderError",
+    "ProviderStatus",
+    "ProviderUnavailable",
+    "SupportsEdit",
+    "SupportsEmbeddings",
+    "SupportsFIM",
+    "UnknownProvider",
+    "FALLBACK_MODEL_SPEC",
+    "default_model_spec",
+    "provider_names",
+    "builtin_provider_names",
+    "provider_class",
+    "register_custom",
+    "unregister_custom",
+    "is_custom",
+    "get_provider",
+    "parse_spec",
+    "get_chat_model",
+    "health_report",
+    "all_models",
+    "reset",
+]
+
+#: Used when OTTO_DEFAULT_MODEL is unset. Mercury 2.5 is Inception's current
+#: chat model (2026-09-09; mercury-2 is still documented but no longer what
+#: a fresh install should reach for).
+FALLBACK_MODEL_SPEC = "inception:mercury-2.5"
+
+_PROVIDER_MODULES: dict[str, tuple[str, str]] = {
+    "inception": (".inception_provider", "InceptionProvider"),
+    "anthropic": (".anthropic_provider", "AnthropicProvider"),
+    "openai": (".openai_provider", "OpenAIProvider"),
+    "gemini": (".gemini_provider", "GeminiProvider"),
+}
+
+
+class UnknownProvider(ProviderError):
+    """Spec named a provider that is not registered."""
+
+
+def default_model_spec() -> str:
+    """Resolve the default model, honouring OTTO_DEFAULT_MODEL.
+
+    A function, not a module constant: this package may well be imported before
+    the Typer callback calls `load_dotenv`, and a constant evaluated at import
+    time would freeze whatever the environment happened to hold then.
+    """
+    return os.environ.get("OTTO_DEFAULT_MODEL") or FALLBACK_MODEL_SPEC
+
+
+#: Providers registered at runtime -- the custom OpenAI-compatible endpoints
+#: a person adds in the TUI's setup screen (agent/router/llm_provider/custom.py
+#: builds the class, agent/router/overrides.py registers it from
+#: ~/.otto/routes.json at startup). Kept apart from the static table so the
+#: built-ins stay importable by name and a removed endpoint leaves no trace.
+_CUSTOM: dict[str, type[BaseProvider]] = {}
+
+
+def builtin_provider_names() -> tuple[str, ...]:
+    return tuple(_PROVIDER_MODULES)
+
+
+def provider_names() -> tuple[str, ...]:
+    return tuple(_PROVIDER_MODULES) + tuple(_CUSTOM)
+
+
+def is_custom(name: str) -> bool:
+    return name in _CUSTOM
+
+
+def register_custom(name: str, cls: type[BaseProvider]) -> None:
+    """Make `name` resolvable through provider_class()/get_provider().
+    Clears the caches, so a re-registered name is never served stale."""
+    if name in _PROVIDER_MODULES:
+        raise UnknownProvider(f"{name!r} is a built-in provider and cannot be replaced")
+    _CUSTOM[name] = cls
+    reset()
+
+
+def unregister_custom(name: str) -> None:
+    if _CUSTOM.pop(name, None) is not None:
+        reset()
+
+
+@lru_cache(maxsize=None)
+def provider_class(name: str) -> type[BaseProvider]:
+    """Import and return a provider class by name."""
+    if name in _CUSTOM:
+        return _CUSTOM[name]
+    try:
+        module_path, attr = _PROVIDER_MODULES[name]
+    except KeyError:
+        raise UnknownProvider(
+            f"unknown provider {name!r}. Known: {', '.join(provider_names())}"
+        ) from None
+    module = importlib.import_module(module_path, __package__)
+    return getattr(module, attr)
+
+
+@lru_cache(maxsize=None)
+def get_provider(name: str) -> BaseProvider:
+    """Return a constructed, cached provider. Raises `AuthError` without a key."""
+    return provider_class(name)()
+
+
+def parse_spec(spec: str) -> tuple[str, str]:
+    """Split ``"provider:model"``. A bare model name uses the default provider."""
+    provider, sep, model_id = spec.partition(":")
+    if not sep:
+        default_provider, _ = parse_spec(default_model_spec())
+        return default_provider, spec
+    if not model_id:
+        raise UnknownProvider(f"spec {spec!r} names a provider but no model")
+    return provider, model_id
+
+
+def get_chat_model(spec: str | None = None, **kwargs) -> BaseChatModel:
+    """Resolve ``"provider:model"`` to a LangChain chat model.
+
+    Validates the id against the provider's catalogue first, so a typo fails
+    here with the list of alternatives rather than as a vendor 404 midway
+    through a graph run.
+    """
+    provider_name, model_id = parse_spec(spec or default_model_spec())
+    provider = get_provider(provider_name)
+    provider.resolve_model(model_id)
+    return provider.chat_model(model_id, **kwargs)
+
+
+def health_report() -> list[HealthReport]:
+    """Check every registered provider. Never raises -- this is the doctor command."""
+    reports: list[HealthReport] = []
+    for name in provider_names():
+        try:
+            reports.append(provider_class(name).check())
+        except Exception as exc:  # import failure, e.g. SDK not installed
+            reports.append(
+                HealthReport(name, ProviderStatus.ERROR, detail=f"import failed: {exc}")
+            )
+    return reports
+
+
+def all_models(capability: Capability | None = None) -> list[ModelInfo]:
+    """Every model across every configured provider, skipping unusable ones."""
+    models: list[ModelInfo] = []
+    for name in provider_names():
+        cls = provider_class(name)
+        if not cls.is_configured():
+            continue
+        try:
+            models.extend(get_provider(name).list_models(capability))
+        except ProviderError:
+            # One dead key must not blank out the rest.
+            continue
+    return models
+
+
+def reset() -> None:
+    """Drop cached provider instances -- call after changing keys in-process."""
+    get_provider.cache_clear()
+    provider_class.cache_clear()

agent/router/llm_provider/anthropic_provider.py

@@ -0,0 +1,128 @@
+"""Anthropic provider.
+
+Discovery goes through the `anthropic` SDK; chat goes through `ChatAnthropic`.
+
+That split is deliberate and differs from `inception_provider.py`. Inception has
+no LangChain integration, so a custom `BaseChatModel` was the only way to reach
+it. Anthropic has a maintained one that already handles content blocks, tool
+binding, structured output, prompt caching and extended thinking -- reproducing
+that by hand over the raw SDK would be a few hundred lines of duplication with
+no capability gained.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from anthropic import (
+    Anthropic,
+    APIConnectionError,
+    APIStatusError,
+    AnthropicError,
+    AuthenticationError,
+    PermissionDeniedError,
+)
+from langchain_anthropic import ChatAnthropic
+from langchain_core.language_models import BaseChatModel
+
+from agent.router.llm_provider.base import (
+    AuthError,
+    BaseProvider,
+    Capability,
+    ModelInfo,
+    ProviderError,
+    ProviderUnavailable,
+)
+
+__all__ = ["AnthropicProvider"]
+
+
+def _translate(exc: Exception) -> ProviderError:
+    # AuthenticationError and PermissionDeniedError both subclass APIStatusError,
+    # so they must be tested before it.
+    if isinstance(exc, (AuthenticationError, PermissionDeniedError)):
+        return AuthError(f"anthropic: key rejected ({exc})")
+    if isinstance(exc, APIConnectionError):  # APITimeoutError subclasses this
+        return ProviderUnavailable(f"anthropic: {exc}")
+    if isinstance(exc, APIStatusError):
+        if exc.status_code in (401, 403):
+            return AuthError(f"anthropic: HTTP {exc.status_code}")
+        return ProviderError(f"anthropic: HTTP {exc.status_code}")
+    return ProviderError(f"anthropic: {exc}")
+
+
+def _capabilities_of(model: Any) -> set[Capability]:
+    """Read capabilities off `ModelInfo.capabilities`.
+
+    Anthropic publishes structured capability flags, so nothing here is guessed
+    from the model name -- only TOOLS is assumed, because the Models API exposes
+    no tool-use flag and every current Claude model supports tool use.
+    """
+    caps = {Capability.CHAT, Capability.TOOLS}
+
+    published = getattr(model, "capabilities", None)
+    if published is None:
+        # Older API versions omit the block entirely. Report the floor rather
+        # than inventing flags.
+        return caps
+
+    if getattr(published.image_input, "supported", False):
+        caps.add(Capability.VISION)
+    if getattr(published.structured_outputs, "supported", False):
+        caps.add(Capability.STRUCTURED_OUTPUT)
+    # Extended thinking and effort levels are two expressions of the same idea.
+    if getattr(published.thinking, "supported", False) or getattr(
+        published.effort, "supported", False
+    ):
+        caps.add(Capability.REASONING)
+
+    return caps
+
+
+class AnthropicProvider(BaseProvider):
+    name = "anthropic"
+    env_var = "ANTHROPIC_API_KEY"
+    default_base_url = None
+    capabilities = frozenset(
+        {
+            Capability.CHAT,
+            Capability.TOOLS,
+            Capability.VISION,
+            Capability.REASONING,
+            Capability.STRUCTURED_OUTPUT,
+        }
+    )
+
+    def _build_client(self) -> Anthropic:
+        kwargs: dict[str, Any] = {"api_key": self._api_key}
+        if self._base_url:
+            kwargs["base_url"] = self._base_url
+        return Anthropic(**kwargs)
+
+    def _fetch_models(self) -> list[ModelInfo]:
+        try:
+            # The Models API paginates and defaults to 20 per page. In this SDK
+            # SyncPage.__iter__ walks iter_pages() itself, so plain iteration
+            # already spans every page -- but the `limit` still matters: it sets
+            # the page size, and without it you pay a round trip per 20 models.
+            models = list(self._client.models.list(limit=1000))
+        except AnthropicError as exc:
+            raise _translate(exc) from exc
+
+        return [
+            ModelInfo(
+                id=model.id,
+                provider=self.name,
+                display_name=model.display_name,
+                capabilities=frozenset(_capabilities_of(model)),
+                context_window=model.max_input_tokens,
+                max_output_tokens=model.max_tokens,
+                raw=model.model_dump(mode="json"),
+            )
+            for model in models
+        ]
+
+    def chat_model(self, model_id: str, **kwargs: Any) -> BaseChatModel:
+        if self._base_url:
+            kwargs.setdefault("base_url", self._base_url)
+        return ChatAnthropic(model=model_id, api_key=self._api_key, **kwargs)