| """ |
| Provider Discovery Package (Facade Pattern) |
| Standardized L2 Modularization for Phase 4.6.24. |
| """ |
|
|
| import logging |
| import time |
| from typing import Any, cast |
|
|
| import aiohttp |
|
|
| from ..credential_service import credential_service |
| from .engine import DiscoveryEngine |
| from .models import ModelSpec, ProviderStatus |
|
|
| logger = logging.getLogger(__name__) |
|
|
|
|
| class ProviderDiscoveryService: |
| """Facade for multi-provider AI model discovery and health checking.""" |
|
|
| def __init__(self): |
| self._session: aiohttp.ClientSession | None = None |
|
|
| async def _get_session(self) -> aiohttp.ClientSession: |
| if self._session is None or self._session.closed: |
| timeout = aiohttp.ClientTimeout(total=30, connect=10) |
| self._session = aiohttp.ClientSession(timeout=timeout) |
| return self._session |
|
|
| async def close(self): |
| if self._session: |
| await self._session.close() |
|
|
| async def discover_openai_models(self, api_key: str) -> list[ModelSpec]: |
| from .providers.openai_handler import discover_openai_models |
|
|
| cache_key = f"openai_{hash(api_key)}" |
| cached = DiscoveryEngine.get_cached_result(cache_key) |
| if cached: |
| return cast(list[ModelSpec], cached) |
|
|
| models = await discover_openai_models(api_key) |
| DiscoveryEngine.cache_result(cache_key, models) |
| return models |
|
|
| async def discover_google_models(self, api_key: str) -> list[ModelSpec]: |
| from .providers.google_handler import discover_google_models |
|
|
| cache_key = f"google_{hash(api_key)}" |
| cached = DiscoveryEngine.get_cached_result(cache_key) |
| if cached: |
| return cast(list[ModelSpec], cached) |
|
|
| session = await self._get_session() |
| models = await discover_google_models(api_key, session) |
| DiscoveryEngine.cache_result(cache_key, models) |
| return models |
|
|
| async def discover_ollama_models(self, base_urls: list[str]) -> list[ModelSpec]: |
| from .providers.ollama_handler import discover_ollama_models |
|
|
| session = await self._get_session() |
| return await discover_ollama_models(base_urls, session, DiscoveryEngine.test_tool_support) |
|
|
| async def check_provider_health(self, provider: str, config: dict[str, Any]) -> ProviderStatus: |
| """Physical Parity: End-to-end health check for a provider.""" |
| start_time = time.time() |
| try: |
| api_key = config.get("api_key") |
| models = [] |
| if provider == "openai" and isinstance(api_key, str): |
| models = await self.discover_openai_models(api_key) |
| elif provider == "google" and isinstance(api_key, str): |
| models = await self.discover_google_models(api_key) |
|
|
| return ProviderStatus( |
| provider=provider, |
| is_available=len(models) > 0, |
| response_time_ms=(time.time() - start_time) * 1000, |
| models_available=len(models), |
| last_checked=time.time(), |
| ) |
| except Exception as e: |
| return ProviderStatus(provider=provider, is_available=False, error_message=str(e), last_checked=time.time()) |
|
|
| async def get_all_available_models(self) -> dict[str, list[ModelSpec]]: |
| """Consolidated discovery logic.""" |
| results: dict[str, list[ModelSpec]] = {} |
| openai_key = await credential_service.get_credential("OPENAI_API_KEY") |
| if isinstance(openai_key, str): |
| results["openai"] = await self.discover_openai_models(openai_key) |
| return results |
|
|
|
|
| |
| provider_discovery_service = ProviderDiscoveryService() |
|
|
