ai-dev-workflow 0.1.0__py3-none-any.whl

ai_provider.py

@@ -0,0 +1,149 @@
+"""Provider-neutral AI provider configuration and validation."""
+from __future__ import annotations
+
+from urllib.parse import urlparse
+
+PROVIDER_TYPES = {
+    "interactive",
+    "openai",
+    "chatgpt-codex",
+    "anthropic",
+    "litellm",
+    "openai-compatible",
+    "local-openai-compatible",
+}
+
+AUTH_TYPES = {"none", "chatgpt-oauth", "api-key-env", "bearer-env"}
+
+DEFAULT_CAPABILITIES = {
+    "interactive": ["planning", "review"],
+    "openai": ["planning", "test", "implementation", "review"],
+    "chatgpt-codex": ["planning", "test", "implementation", "review"],
+    "anthropic": ["planning", "test", "implementation", "review"],
+    "litellm": ["planning", "test", "implementation", "review"],
+    "openai-compatible": ["planning", "test", "implementation", "review"],
+    "local-openai-compatible": ["planning", "test", "implementation", "review"],
+}
+
+
+def provider_template(
+    provider_type: str,
+    *,
+    model: str | None = None,
+    base_url: str | None = None,
+    auth_type: str | None = None,
+    env: str | None = None,
+    capabilities: list[str] | None = None,
+) -> dict:
+    if provider_type not in PROVIDER_TYPES:
+        raise ValueError(f"unsupported provider type: {provider_type}")
+
+    if auth_type is None:
+        auth_type = {
+            "interactive": "none",
+            "chatgpt-codex": "chatgpt-oauth",
+            "local-openai-compatible": "none",
+            "openai": "api-key-env",
+            "anthropic": "api-key-env",
+            "litellm": "api-key-env",
+            "openai-compatible": "api-key-env",
+        }[provider_type]
+
+    auth = {"type": auth_type}
+    if env:
+        auth["env"] = env
+
+    result = {
+        "type": provider_type,
+        "auth": auth,
+        "capabilities": capabilities or list(DEFAULT_CAPABILITIES[provider_type]),
+    }
+    if model:
+        result["model"] = model
+    if base_url:
+        result["base_url"] = base_url
+    return result
+
+
+def _is_http_url(value: str) -> bool:
+    try:
+        parsed = urlparse(value)
+        return parsed.scheme in ("http", "https") and bool(parsed.netloc)
+    except Exception:
+        return False
+
+
+def validate_provider(provider_id: str, config: dict) -> list[str]:
+    errors = []
+    provider_type = config.get("type")
+    if provider_type not in PROVIDER_TYPES:
+        return [f"provider {provider_id}: unsupported type {provider_type!r}"]
+
+    auth = config.get("auth") or {}
+    auth_type = auth.get("type")
+    if auth_type not in AUTH_TYPES:
+        errors.append(f"provider {provider_id}: unsupported auth type {auth_type!r}")
+    if auth_type in ("api-key-env", "bearer-env") and not auth.get("env"):
+        errors.append(f"provider {provider_id}: auth env is required for {auth_type}")
+
+    if provider_type in ("litellm", "openai-compatible", "local-openai-compatible"):
+        base_url = config.get("base_url")
+        if not base_url or not _is_http_url(base_url):
+            errors.append(f"provider {provider_id}: valid base_url is required")
+
+    capabilities = config.get("capabilities")
+    if not isinstance(capabilities, list) or not capabilities:
+        errors.append(f"provider {provider_id}: at least one capability is required")
+
+    return errors
+
+
+def validate_provider_registry(providers: dict, agents: dict) -> list[str]:
+    errors = []
+    for provider_id, cfg in providers.items():
+        if not isinstance(cfg, dict):
+            errors.append(f"provider {provider_id}: config must be an object")
+            continue
+        errors.extend(validate_provider(provider_id, cfg))
+
+    for agent_key, agent in agents.items():
+        if not isinstance(agent, dict):
+            continue
+        provider_id = agent.get("provider")
+        if provider_id in (None, "none", "project-defined"):
+            continue
+        if provider_id not in providers:
+            errors.append(f"agent {agent_key}: unknown provider {provider_id}")
+
+    return errors
+
+
+def credential_requirements_for_providers(providers: dict) -> list[dict]:
+    result = []
+    seen = set()
+    for provider_id, cfg in providers.items():
+        auth = cfg.get("auth") or {}
+        auth_type = auth.get("type")
+        key = (provider_id, auth_type, auth.get("env"))
+        if key in seen:
+            continue
+        seen.add(key)
+
+        if auth_type == "none":
+            continue
+        if auth_type == "chatgpt-oauth":
+            result.append({
+                "name": f"{provider_id} ChatGPT sign-in",
+                "purpose": "Authenticate this provider using interactive ChatGPT OAuth.",
+                "required_for_setup": False,
+                "store": "provider/client auth store; never commit tokens",
+            })
+        elif auth_type in ("api-key-env", "bearer-env"):
+            env = auth.get("env")
+            result.append({
+                "name": env or f"{provider_id} credential",
+                "purpose": f"Authenticate AI provider '{provider_id}'.",
+                "required_for_setup": False,
+                "store": "environment/secret store; never commit",
+            })
+    return result