devflow-engine 1.0.0__py3-none-any.whl

devflow_engine/llm/provider_api.py

@@ -0,0 +1,304 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Literal
+from urllib import error, request
+
+from ..api_keys import get_provider_api_key
+
+
+ANTHROPIC_MESSAGES_URL = "https://api.anthropic.com/v1/messages"
+ANTHROPIC_VERSION = "2023-06-01"
+ANTHROPIC_MODEL_DEFAULT = "claude-sonnet-4-6"
+OPENAI_RESPONSES_URL = "https://api.openai.com/v1/responses"
+OPENAI_MODEL_DEFAULT = "gpt-5"
+OLLAMA_RESPONSES_URL = "http://127.0.0.1:11434/v1/responses"
+OLLAMA_MODEL_DEFAULT = "llama3.2"
+GOOGLE_GENERATE_CONTENT_URL_TEMPLATE = "https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent"
+GOOGLE_MODEL_DEFAULT = "gemini-2.5-flash"
+ANTHROPIC_STYLE_PROVIDERS = frozenset({"anthropic", "minimax"})
+OPENAI_STYLE_PROVIDERS = frozenset({"openai", "ollama"})
+GOOGLE_STYLE_PROVIDERS = frozenset({"google"})
+ProviderApiShape = Literal["anthropic", "openai", "google"]
+
+
+@dataclass(frozen=True)
+class AnthropicApiSettings:
+    api_key: str
+    model: str
+    max_tokens: int
+    api_url: str = ANTHROPIC_MESSAGES_URL
+    api_version: str = ANTHROPIC_VERSION
+    provider_label: str = "Anthropic"
+
+
+@dataclass(frozen=True)
+class OpenAiApiSettings:
+    api_key: str
+    model: str
+    api_url: str = OPENAI_RESPONSES_URL
+    provider_label: str = "OpenAI"
+
+
+@dataclass(frozen=True)
+class GoogleApiSettings:
+    api_key: str
+    model: str
+
+
+def canonical_provider_api_shape(provider: str | None) -> ProviderApiShape | None:
+    normalized = str(provider or "").strip().lower()
+    if not normalized:
+        return None
+    if normalized in ANTHROPIC_STYLE_PROVIDERS:
+        return "anthropic"
+    if normalized in OPENAI_STYLE_PROVIDERS:
+        return "openai"
+    if normalized in GOOGLE_STYLE_PROVIDERS:
+        return "google"
+    return None
+
+
+def provider_uses_anthropic_api_shape(provider: str | None) -> bool:
+    return canonical_provider_api_shape(provider) == "anthropic"
+
+
+def read_provider_api_key(*, provider: str, repo_root: Path) -> str:
+    runtime_key = get_provider_api_key(provider)
+    if runtime_key:
+        return runtime_key
+
+    del repo_root
+    candidate_paths: list[Path] = []
+    try:
+        from ..idea.traditional_stories import _global_devflow_dir
+
+        candidate_paths.append(_global_devflow_dir() / "keys" / f"{provider}.json")
+    except Exception:
+        candidate_paths.append(Path.home() / ".devflow" / "keys" / f"{provider}.json")
+
+    for path in candidate_paths:
+        if not path.exists():
+            continue
+        try:
+            payload = json.loads(path.read_text(encoding="utf-8"))
+        except Exception as exc:  # pragma: no cover - invalid operator-managed secret file is operator error
+            raise RuntimeError(f"Failed to read {provider.capitalize()} key file: {path}") from exc
+        api_key = str(payload.get("api_key") or "").strip()
+        if api_key:
+            return api_key
+    raise RuntimeError(
+        f"{provider.capitalize()} API key not configured. "
+        f"Expected runtime env, macOS keychain entry, or global ~/.devflow/keys/{provider}.json."
+    )
+
+
+def read_anthropic_api_key(*, repo_root: Path) -> str:
+    return read_provider_api_key(provider="anthropic", repo_root=repo_root)
+
+
+def load_anthropic_api_settings(
+    *,
+    repo_root: Path,
+    model: str | None = None,
+    max_tokens: int = 1_200,
+) -> AnthropicApiSettings:
+    return AnthropicApiSettings(
+        api_key=read_anthropic_api_key(repo_root=repo_root),
+        model=str(model or ANTHROPIC_MODEL_DEFAULT).strip() or ANTHROPIC_MODEL_DEFAULT,
+        max_tokens=max_tokens,
+    )
+
+
+def load_openai_api_settings(
+    *,
+    repo_root: Path,
+    provider: str = "openai",
+    model: str | None = None,
+) -> OpenAiApiSettings:
+    normalized_provider = str(provider or "openai").strip().lower() or "openai"
+    if normalized_provider == "ollama":
+        api_key = get_provider_api_key("ollama") or "ollama"
+        api_url = OLLAMA_RESPONSES_URL
+        provider_label = "Ollama"
+        resolved_model = str(model or OLLAMA_MODEL_DEFAULT).strip() or OLLAMA_MODEL_DEFAULT
+    else:
+        api_key = read_provider_api_key(provider="openai", repo_root=repo_root)
+        api_url = OPENAI_RESPONSES_URL
+        provider_label = "OpenAI"
+        resolved_model = str(model or OPENAI_MODEL_DEFAULT).strip() or OPENAI_MODEL_DEFAULT
+    return OpenAiApiSettings(
+        api_key=api_key,
+        model=resolved_model,
+        api_url=api_url,
+        provider_label=provider_label,
+    )
+
+
+def load_google_api_settings(
+    *,
+    repo_root: Path,
+    model: str | None = None,
+) -> GoogleApiSettings:
+    return GoogleApiSettings(
+        api_key=read_provider_api_key(provider="google", repo_root=repo_root),
+        model=str(model or GOOGLE_MODEL_DEFAULT).strip() or GOOGLE_MODEL_DEFAULT,
+    )
+
+
+def anthropic_messages_create(
+    *,
+    settings: AnthropicApiSettings,
+    system_prompt: str,
+    messages: list[dict[str, Any]],
+    tools: list[dict[str, Any]],
+    timeout_seconds: int | None,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "model": settings.model,
+        "max_tokens": settings.max_tokens,
+        "system": system_prompt,
+        "messages": messages,
+        "tools": tools,
+    }
+    data = json.dumps(payload).encode("utf-8")
+    req = request.Request(
+        settings.api_url,
+        data=data,
+        headers={
+            "content-type": "application/json",
+            "x-api-key": settings.api_key,
+            "anthropic-version": settings.api_version,
+        },
+        method="POST",
+    )
+    try:
+        with request.urlopen(req, timeout=timeout_seconds) as resp:
+            raw = resp.read().decode("utf-8")
+    except error.HTTPError as exc:
+        body = exc.read().decode("utf-8", errors="replace")
+        raise RuntimeError(f"{settings.provider_label} API request failed: {exc.code} {body}") from exc
+    except error.URLError as exc:
+        raise RuntimeError(f"{settings.provider_label} API request failed: {exc}") from exc
+    return json.loads(raw)
+
+
+def anthropic_response_text(response: dict[str, Any]) -> str:
+    return "\n".join(
+        str(block.get("text") or "").strip()
+        for block in list(response.get("content") or [])
+        if block.get("type") == "text"
+    ).strip()
+
+
+def _openai_text_format_for_response_contract(response_contract: str | None) -> dict[str, Any] | None:
+    if response_contract != "json_only":
+        return None
+    return {
+        "format": {
+            "type": "json_schema",
+            "name": "generic_json_response",
+            "schema": {
+                "type": "object",
+                "additionalProperties": True,
+            },
+        }
+    }
+
+
+def openai_responses_create(
+    *,
+    settings: OpenAiApiSettings,
+    prompt: str,
+    timeout_seconds: int | None,
+    response_contract: str | None = None,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "model": settings.model,
+        "input": prompt,
+    }
+    text_format = _openai_text_format_for_response_contract(response_contract)
+    if text_format is not None:
+        payload["text"] = text_format
+    data = json.dumps(payload).encode("utf-8")
+    req = request.Request(
+        settings.api_url,
+        data=data,
+        headers={
+            "content-type": "application/json",
+            "authorization": f"Bearer {settings.api_key}",
+        },
+        method="POST",
+    )
+    try:
+        with request.urlopen(req, timeout=timeout_seconds) as resp:
+            raw = resp.read().decode("utf-8")
+    except error.HTTPError as exc:
+        body = exc.read().decode("utf-8", errors="replace")
+        raise RuntimeError(f"{settings.provider_label} API request failed: {exc.code} {body}") from exc
+    except error.URLError as exc:
+        raise RuntimeError(f"{settings.provider_label} API request failed: {exc}") from exc
+    return json.loads(raw)
+
+
+def openai_response_text(response: dict[str, Any]) -> str:
+    output_text = str(response.get("output_text") or "").strip()
+    if output_text:
+        return output_text
+
+    collected: list[str] = []
+    for item in list(response.get("output") or []):
+        for block in list(item.get("content") or []):
+            if block.get("type") in {"output_text", "text"}:
+                text = str(block.get("text") or "").strip()
+                if text:
+                    collected.append(text)
+    return "\n".join(collected).strip()
+
+
+def google_generate_content(
+    *,
+    settings: GoogleApiSettings,
+    prompt: str,
+    timeout_seconds: int | None,
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {
+        "contents": [
+            {
+                "role": "user",
+                "parts": [{"text": prompt}],
+            }
+        ]
+    }
+    data = json.dumps(payload).encode("utf-8")
+    req = request.Request(
+        GOOGLE_GENERATE_CONTENT_URL_TEMPLATE.format(model=settings.model),
+        data=data,
+        headers={
+            "content-type": "application/json",
+            "x-goog-api-key": settings.api_key,
+        },
+        method="POST",
+    )
+    try:
+        with request.urlopen(req, timeout=timeout_seconds) as resp:
+            raw = resp.read().decode("utf-8")
+    except error.HTTPError as exc:
+        body = exc.read().decode("utf-8", errors="replace")
+        raise RuntimeError(f"Google API request failed: {exc.code} {body}") from exc
+    except error.URLError as exc:
+        raise RuntimeError(f"Google API request failed: {exc}") from exc
+    return json.loads(raw)
+
+
+def google_response_text(response: dict[str, Any]) -> str:
+    collected: list[str] = []
+    for candidate in list(response.get("candidates") or []):
+        content = candidate.get("content") or {}
+        for part in list(content.get("parts") or []):
+            text = str(part.get("text") or "").strip()
+            if text:
+                collected.append(text)
+    return "\n".join(collected).strip()