@agxnte/reidx 2.0.2

package/src/reidx/provider/anthropic.py

@@ -0,0 +1,176 @@
+"""Anthropic Messages API provider.
+
+Speaks the Anthropic Messages API (POST /v1/messages). Compatible with Anthropic
+directly and with Anthropic-compatible proxies (e.g. Reidchat). Uses stdlib
+urllib for zero extra dependencies.
+
+Env vars consumed:
+  ANTHROPIC_API_KEY   - auth key
+  ANTHROPIC_BASE_URL  - API base (defaults to https://api.anthropic.com)
+  ANTHROPIC_MODEL     - default model name
+"""
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+from typing import Any
+
+from reidx.diagnostics.logger import get_logger
+from reidx.provider.base import BaseProvider, Message, ProviderResponse, ToolCall, Usage
+
+log = get_logger("reidx.provider.anthropic")
+
+DEFAULT_BASE_URL = "https://api.anthropic.com"
+API_VERSION = "2023-06-01"
+MAX_TOKENS = 4096
+TIMEOUT_SECONDS = 120
+
+
+class AnthropicProvider(BaseProvider):
+    """Real provider that calls the Anthropic Messages API over HTTP."""
+
+    name = "anthropic"
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = DEFAULT_BASE_URL,
+        default_model: str = "",
+    ) -> None:
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.default_model = default_model
+
+    @classmethod
+    def from_env(cls) -> AnthropicProvider | None:
+        """Build from ANTHROPIC_* env vars. Returns None if no API key is set."""
+        key = os.environ.get("ANTHROPIC_API_KEY", "").strip()
+        if not key:
+            return None
+        base = os.environ.get("ANTHROPIC_BASE_URL", DEFAULT_BASE_URL).strip()
+        model = os.environ.get("ANTHROPIC_MODEL", "").strip()
+        return cls(api_key=key, base_url=base, default_model=model)
+
+    def _to_anthropic_messages(self, messages: list[Message]) -> tuple[str | None, list[dict]]:
+        """Convert ReidX Messages to Anthropic format. Returns (system, messages)."""
+        system: str | None = None
+        out: list[dict] = []
+        for m in messages:
+            if m.role == "system":
+                system = m.content
+                continue
+            if m.role == "tool":
+                # Tool results -> Anthropic tool_result content block.
+                out.append({
+                    "role": "user",
+                    "content": [{
+                        "type": "tool_result",
+                        "tool_use_id": m.tool_call_id or "",
+                        "content": m.content,
+                    }],
+                })
+                continue
+            if m.role == "assistant" and m.tool_calls:
+                # Assistant turn with tool calls -> content blocks.
+                blocks: list[dict] = []
+                if m.content:
+                    blocks.append({"type": "text", "text": m.content})
+                for tc in m.tool_calls:
+                    blocks.append({
+                        "type": "tool_use",
+                        "id": tc.id,
+                        "name": tc.name,
+                        "input": tc.arguments,
+                    })
+                out.append({"role": "assistant", "content": blocks})
+                continue
+            # Plain user or assistant text.
+            out.append({"role": m.role, "content": m.content})
+        return system, out
+
+    def _to_anthropic_tools(self, tools: list[dict] | None) -> list[dict]:
+        """Convert OpenAI-style tool schemas to Anthropic tool format."""
+        if not tools:
+            return []
+        result: list[dict] = []
+        for t in tools:
+            fn = t.get("function", t)
+            result.append({
+                "name": fn.get("name", ""),
+                "description": fn.get("description", ""),
+                "input_schema": fn.get("parameters", {"type": "object", "properties": {}}),
+            })
+        return result
+
+    def _parse_response(self, body: dict, model: str) -> ProviderResponse:
+        """Parse Anthropic response into ProviderResponse."""
+        content_blocks = body.get("content", [])
+        text_parts: list[str] = []
+        tool_calls: list[ToolCall] = []
+        for block in content_blocks:
+            btype = block.get("type", "")
+            if btype == "text":
+                text_parts.append(block.get("text", ""))
+            elif btype == "tool_use":
+                tool_calls.append(ToolCall(
+                    id=block.get("id", ""),
+                    name=block.get("name", ""),
+                    arguments=block.get("input", {}),
+                ))
+        usage_raw = body.get("usage", {})
+        return ProviderResponse(
+            text="\n".join(text_parts),
+            tool_calls=tool_calls,
+            usage=Usage(
+                prompt_tokens=usage_raw.get("input_tokens", 0),
+                completion_tokens=usage_raw.get("output_tokens", 0),
+            ),
+            stop_reason=body.get("stop_reason", "stop"),
+        )
+
+    def chat(
+        self,
+        messages: list[Message],
+        tools: list[dict[str, Any]] | None = None,
+        model: str | None = None,
+    ) -> ProviderResponse:
+        model = model or self.default_model or "claude-sonnet-4-20250514"
+        system, anthropic_msgs = self._to_anthropic_messages(messages)
+        anthropic_tools = self._to_anthropic_tools(tools)
+
+        payload: dict[str, Any] = {
+            "model": model,
+            "max_tokens": MAX_TOKENS,
+            "messages": anthropic_msgs,
+        }
+        if system:
+            payload["system"] = system
+        if anthropic_tools:
+            payload["tools"] = anthropic_tools
+
+        body = json.dumps(payload).encode("utf-8")
+        url = f"{self.base_url}/v1/messages"
+        req = urllib.request.Request(
+            url,
+            data=body,
+            headers={
+                "x-api-key": self.api_key,
+                "anthropic-version": API_VERSION,
+                "content-type": "application/json",
+            },
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=TIMEOUT_SECONDS) as resp:
+                raw = resp.read().decode("utf-8")
+        except urllib.error.HTTPError as exc:
+            err_body = exc.read().decode("utf-8", errors="replace")[:500]
+            log.error("Anthropic API error %s: %s", exc.code, err_body)
+            raise RuntimeError(f"Anthropic API error {exc.code}: {err_body}") from exc
+        except urllib.error.URLError as exc:
+            log.error("Anthropic connection error: %s", exc)
+            raise RuntimeError(f"connection error: {exc}") from exc
+
+        return self._parse_response(json.loads(raw), model)

package/src/reidx/provider/base.py

@@ -0,0 +1,50 @@
+"""Provider layer: abstract model access from runtime.
+
+Defines the message/response contract and BaseProvider. Real providers
+(OpenAI/Anthropic/local) plug in here. A StubProvider is included so the runtime
+loop is exercisable end-to-end without API keys.
+"""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class ToolCall(BaseModel):
+    id: str
+    name: str
+    arguments: dict[str, Any] = Field(default_factory=dict)
+
+
+class Message(BaseModel):
+    role: str  # "system" | "user" | "assistant" | "tool"
+    content: str = ""
+    tool_calls: list[ToolCall] = Field(default_factory=list)
+    tool_call_id: str | None = None  # set when role == "tool" (result)
+
+
+class Usage(BaseModel):
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+
+
+class ProviderResponse(BaseModel):
+    text: str = ""
+    tool_calls: list[ToolCall] = Field(default_factory=list)
+    usage: Usage = Field(default_factory=Usage)
+    stop_reason: str = "stop"
+
+
+class BaseProvider(ABC):
+    name: str = "base"
+
+    @abstractmethod
+    def chat(
+        self,
+        messages: list[Message],
+        tools: list[dict[str, Any]] | None = None,
+        model: str | None = None,
+    ) -> ProviderResponse:
+        """Run one model turn. Returns text and/or tool calls."""

package/src/reidx/provider/ollama.py

@@ -0,0 +1,109 @@
+"""Ollama native chat provider (POST /api/chat).
+
+Ollama also exposes an OpenAI-compatible endpoint at /v1, but the native
+endpoint is what `ollama serve` recommends and has cleaner tool-call payloads
+in current versions. No API key required.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from reidx.diagnostics.logger import get_logger
+from reidx.provider._http import post_json
+from reidx.provider.base import BaseProvider, Message, ProviderResponse, ToolCall, Usage
+
+log = get_logger("reidx.provider.ollama")
+
+
+class OllamaProvider(BaseProvider):
+    name = "ollama"
+    DEFAULT_BASE_URL = "http://localhost:11434"
+    DEFAULT_MODEL = "llama3.2"
+
+    def __init__(self, base_url: str = "", default_model: str = "", api_key: str = "") -> None:
+        self.base_url = (base_url or self.DEFAULT_BASE_URL).rstrip("/")
+        self.default_model = default_model or self.DEFAULT_MODEL
+        self.api_key = api_key  # unused; kept for uniform ProviderRecord shape
+
+    def _to_ollama_tools(self, tools: list[dict] | None) -> list[dict]:
+        if not tools:
+            return []
+        out: list[dict] = []
+        for t in tools:
+            fn = t.get("function", t)
+            out.append({
+                "type": "function",
+                "function": {
+                    "name": fn.get("name", ""),
+                    "description": fn.get("description", ""),
+                    "parameters": fn.get("parameters", {"type": "object", "properties": {}}),
+                },
+            })
+        return out
+
+    def _to_ollama_messages(self, messages: list[Message]) -> list[dict]:
+        out: list[dict] = []
+        for m in messages:
+            if m.role == "tool":
+                out.append({"role": "tool", "content": m.content})
+                continue
+            if m.role == "assistant" and m.tool_calls:
+                out.append({
+                    "role": "assistant",
+                    "content": m.content or "",
+                    "tool_calls": [
+                        {"function": {"name": tc.name, "arguments": tc.arguments}}
+                        for tc in m.tool_calls
+                    ],
+                })
+                continue
+            out.append({"role": m.role, "content": m.content})
+        return out
+
+    def chat(
+        self,
+        messages: list[Message],
+        tools: list[dict[str, Any]] | None = None,
+        model: str | None = None,
+    ) -> ProviderResponse:
+        model = model or self.default_model
+        payload: dict[str, Any] = {
+            "model": model,
+            "messages": self._to_ollama_messages(messages),
+            "stream": False,
+        }
+        ol_tools = self._to_ollama_tools(tools)
+        if ol_tools:
+            payload["tools"] = ol_tools
+        try:
+            body = post_json(f"{self.base_url}/api/chat", payload, {})
+        except RuntimeError:
+            log.exception("Ollama request failed")
+            raise
+
+        msg = body.get("message", {}) or {}
+        text = msg.get("content") or ""
+        tool_calls: list[ToolCall] = []
+        for i, tc in enumerate(msg.get("tool_calls") or []):
+            fn = tc.get("function", {})
+            args = fn.get("arguments") or {}
+            if isinstance(args, str):
+                try:
+                    import json as _json
+                    args = _json.loads(args)
+                except ValueError:
+                    args = {"_raw": args}
+            tool_calls.append(ToolCall(
+                id=tc.get("id") or f"ollama-{i}",
+                name=fn.get("name", ""),
+                arguments=args or {},
+            ))
+        return ProviderResponse(
+            text=text,
+            tool_calls=tool_calls,
+            usage=Usage(
+                prompt_tokens=body.get("prompt_eval_count", 0),
+                completion_tokens=body.get("eval_count", 0),
+            ),
+            stop_reason=body.get("done_reason", "stop"),
+        )

package/src/reidx/provider/openai.py

@@ -0,0 +1,144 @@
+"""OpenAI Chat Completions provider.
+
+Speaks the OpenAI Chat Completions API (POST /v1/chat/completions). The same
+wire format is spoken by llama.cpp's server (`/v1/chat/completions`) and by
+LM Studio's local server — see `OpenAICompatibleProvider` below for the
+local-endpoint variant that skips the auth header when no key is set.
+
+Tool schemas ReidX produces (`ToolBase.schema()`) are already OpenAI-style,
+so tool passing is a straight forward.
+"""
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from reidx.diagnostics.logger import get_logger
+from reidx.provider._http import post_json
+from reidx.provider.base import BaseProvider, Message, ProviderResponse, ToolCall, Usage
+
+log = get_logger("reidx.provider.openai")
+
+
+class OpenAIProvider(BaseProvider):
+    name = "openai"
+    DEFAULT_BASE_URL = "https://api.openai.com"
+    DEFAULT_MODEL = "gpt-4o-mini"
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = "",
+        default_model: str = "",
+    ) -> None:
+        self.api_key = api_key
+        self.base_url = (base_url or self.DEFAULT_BASE_URL).rstrip("/")
+        self.default_model = default_model or self.DEFAULT_MODEL
+
+    @classmethod
+    def from_env(cls) -> OpenAIProvider | None:
+        """Build from OPENAI_* env vars. Returns None if no API key is set, so
+        it can be auto-registered under `openai` alongside anthropic."""
+        key = os.environ.get("OPENAI_API_KEY", "").strip()
+        if not key:
+            return None
+        base = os.environ.get("OPENAI_BASE_URL", "").strip()
+        model = os.environ.get("OPENAI_MODEL", "").strip()
+        return cls(api_key=key, base_url=base, default_model=model)
+
+    def _to_openai_messages(self, messages: list[Message]) -> list[dict]:
+        out: list[dict] = []
+        for m in messages:
+            if m.role == "tool":
+                out.append({
+                    "role": "tool",
+                    "tool_call_id": m.tool_call_id or "",
+                    "content": m.content,
+                })
+                continue
+            if m.role == "assistant" and m.tool_calls:
+                out.append({
+                    "role": "assistant",
+                    "content": m.content or None,
+                    "tool_calls": [
+                        {
+                            "id": tc.id,
+                            "type": "function",
+                            "function": {"name": tc.name, "arguments": _json_dump(tc.arguments)},
+                        }
+                        for tc in m.tool_calls
+                    ],
+                })
+                continue
+            out.append({"role": m.role, "content": m.content})
+        return out
+
+    def _headers(self) -> dict[str, str]:
+        h = {}
+        if self.api_key:
+            h["authorization"] = f"Bearer {self.api_key}"
+        return h
+
+    def _parse(self, body: dict, model: str) -> ProviderResponse:
+        choices = body.get("choices") or [{}]
+        msg = (choices[0] or {}).get("message", {})
+        text = msg.get("content") or ""
+        tool_calls: list[ToolCall] = []
+        for tc in msg.get("tool_calls") or []:
+            fn = tc.get("function", {})
+            args_raw = fn.get("arguments") or "{}"
+            try:
+                import json as _json
+                args = _json.loads(args_raw) if isinstance(args_raw, str) else args_raw
+            except ValueError:
+                args = {"_raw": args_raw}
+            tool_calls.append(ToolCall(id=tc.get("id", ""), name=fn.get("name", ""), arguments=args or {}))
+        usage_raw = body.get("usage", {})
+        return ProviderResponse(
+            text=text,
+            tool_calls=tool_calls,
+            usage=Usage(
+                prompt_tokens=usage_raw.get("prompt_tokens", 0),
+                completion_tokens=usage_raw.get("completion_tokens", 0),
+            ),
+            stop_reason=(choices[0] or {}).get("finish_reason", "stop"),
+        )
+
+    def chat(
+        self,
+        messages: list[Message],
+        tools: list[dict[str, Any]] | None = None,
+        model: str | None = None,
+    ) -> ProviderResponse:
+        model = model or self.default_model
+        payload: dict[str, Any] = {
+            "model": model,
+            "messages": self._to_openai_messages(messages),
+        }
+        if tools:
+            payload["tools"] = tools
+        url = f"{self.base_url}/v1/chat/completions"
+        try:
+            body = post_json(url, payload, self._headers())
+        except RuntimeError:
+            log.exception("OpenAI-compatible request failed")
+            raise
+        return self._parse(body, model)
+
+
+class OpenAICompatibleProvider(OpenAIProvider):
+    """OpenAI-compatible endpoints (llama.cpp server, LM Studio, vLLM, etc.).
+
+    Same wire format as OpenAI; only default base_url differs and the API key
+    is optional. Kept as a subclass so `/providers` can show the kind
+    separately in the list.
+    """
+
+    name = "openai-compatible"
+    DEFAULT_BASE_URL = "http://localhost:8080"
+    DEFAULT_MODEL = "local"
+
+
+def _json_dump(obj) -> str:  # type: ignore[no-untyped-def]
+    import json
+    return json.dumps(obj, ensure_ascii=False)

package/src/reidx/provider/registry.py

@@ -0,0 +1,88 @@
+"""Provider registry: config-driven registration of providers by name.
+
+The built-in `stub` provider is always registered and remains the default.
+Real providers (Anthropic/OpenAI/OpenAI-compatible/Ollama) are added by
+`/connect` (see reidx.provider.store) or by env-var auto-registration for
+Anthropic, but never auto-promoted to default — the user picks with `/use`.
+"""
+from __future__ import annotations
+
+from reidx.config.models import Config
+from reidx.diagnostics.logger import get_logger
+from reidx.provider.anthropic import AnthropicProvider
+from reidx.provider.base import BaseProvider
+from reidx.provider.stub import StubProvider
+
+log = get_logger("reidx.provider")
+
+
+class ProviderRegistry:
+    def __init__(self) -> None:
+        self._providers: dict[str, BaseProvider] = {}
+
+    def register(self, name: str, provider: BaseProvider) -> None:
+        self._providers[name] = provider
+        log.debug("registered provider: %s", name)
+
+    def unregister(self, name: str) -> bool:
+        if name in self._providers:
+            del self._providers[name]
+            return True
+        return False
+
+    def get(self, name: str) -> BaseProvider:
+        if name not in self._providers:
+            raise KeyError(f"provider '{name}' not registered")
+        return self._providers[name]
+
+    def has(self, name: str) -> bool:
+        return name in self._providers
+
+    def names(self) -> list[str]:
+        return list(self._providers)
+
+
+def default_registry(config: Config) -> ProviderRegistry:
+    """Build the default registry. Stub is always registered and stays the
+    default; Anthropic and OpenAI auto-register under their own names when the
+    matching env vars are set (available via `/use`), but never override the
+    default. Every other configured provider is built from its `kind` so a
+    subagent can request it by name. Providers persisted by `/connect` are
+    layered on top by `reidx.provider.store.load_into`.
+    """
+    # Lazy import: store.py imports ProviderRegistry from this module, so a
+    # top-level import here would be circular.
+    from reidx.provider.store import ProviderRecord, build_provider
+
+    reg = ProviderRegistry()
+    reg.register("stub", StubProvider())
+
+    anthropic = AnthropicProvider.from_env()
+    if anthropic is not None:
+        reg.register("anthropic", anthropic)
+        log.debug("auto-registered anthropic provider from env vars")
+
+    from reidx.provider.openai import OpenAIProvider  # noqa: PLC0415
+    openai = OpenAIProvider.from_env()
+    if openai is not None:
+        reg.register("openai", openai)
+        log.debug("auto-registered openai provider from env vars")
+
+    for name, pc in config.providers.items():
+        if name == "stub" or reg.has(name):
+            continue
+        kind = (pc.kind or name).strip()
+        try:
+            provider = build_provider(ProviderRecord(
+                name=name,
+                kind=kind,
+                base_url=pc.base_url or "",
+                api_key=pc.api_key.get_secret_value() if pc.api_key else "",
+                default_model=pc.default_model,
+            ))
+        except (ValueError, TypeError):
+            log.warning("provider '%s' (kind=%s) configured but could not be built; skipping", name, kind)
+            continue
+        reg.register(name, provider)
+        log.debug("registered configured provider: %s (kind=%s)", name, kind)
+    return reg