Spaces:
Sleeping
Sleeping
Download src/services/router.py from hashir-qt/tasklert-api: direct link, hf CLI and curl.
- Browser
- Download file 5.63 kB
-
https://huggingface.co/spaces/hashir-qt/tasklert-api/resolve/main/src/services/router.py
- Command line
-
hf download hf://spaces/hashir-qt/tasklert-api/src/services/router.py
-
curl -L -o router.py https://huggingface.co/spaces/hashir-qt/tasklert-api/resolve/main/src/services/router.py
5.63 kB
| """ | |
| Provider routing logic with automatic failover. | |
| Implements routing policies (manual, failover, round-robin, cost-optimized) | |
| and automatic failover when providers fail. | |
| Task References: T009, T010 | |
| Spec Reference: specs/001-multi-model-chat/spec.md (US2) | |
| """ | |
| from typing import Any | |
| from agents import Agent, Runner | |
| from fastapi import HTTPException | |
| from ..core.logging import get_logger | |
| from ..core.providers import ProviderName, RoutingPolicy, get_provider | |
| logger = get_logger(__name__) | |
| class ProviderRouter: | |
| """ | |
| Router for selecting and running agents with multiple providers. | |
| Implements routing policies and automatic failover logic. | |
| Args: | |
| policy: Routing policy (manual, failover, round-robin, cost-optimized) | |
| default_provider: Default provider name ("openai" or "gemini") | |
| Task References: T009, T010 | |
| """ | |
| def __init__(self, policy: RoutingPolicy, default_provider: ProviderName): | |
| self.policy = policy | |
| self.default_provider = default_provider | |
| self.round_robin_index = 0 | |
| self.logger = logger | |
| def select_provider( | |
| self, manual_choice: ProviderName | None = None | |
| ) -> ProviderName: | |
| """ | |
| Select provider based on routing policy. | |
| Args: | |
| manual_choice: User-specified provider (overrides policy) | |
| Returns: | |
| Provider name to use | |
| Task Reference: T009 | |
| """ | |
| # Manual selection ALWAYS overrides policy (user explicitly chose) | |
| if manual_choice: | |
| self.logger.info(f"Manual provider selection: {manual_choice}") | |
| return manual_choice | |
| # Round-robin: cycle through providers | |
| if self.policy == "round-robin": | |
| providers = ["openai", "gemini"] | |
| selected = providers[self.round_robin_index % len(providers)] | |
| self.round_robin_index += 1 | |
| self.logger.info(f"Round-robin selected: {selected}") | |
| return selected # type: ignore | |
| # Cost-optimized: prefer Gemini (cheaper) | |
| if self.policy == "cost-optimized": | |
| self.logger.info("Cost-optimized: selecting gemini") | |
| return "gemini" | |
| # Failover (default): use default provider | |
| self.logger.info(f"Failover: using default {self.default_provider}") | |
| return self.default_provider | |
| async def run_with_failover( | |
| self, | |
| agent: Agent, | |
| user_input: str, | |
| preferred_provider: ProviderName | None = None, | |
| ) -> tuple[Any, str]: | |
| """ | |
| Run agent with automatic failover on provider failure. | |
| Args: | |
| agent: Agent instance to run | |
| user_input: User message | |
| preferred_provider: User-specified provider (optional) | |
| Returns: | |
| Tuple of (RunResult, provider_name) | |
| Raises: | |
| HTTPException: If all providers fail (503) | |
| Task Reference: T010 | |
| """ | |
| # Select primary provider | |
| primary_provider_name = self.select_provider(preferred_provider) | |
| primary_provider = get_provider(primary_provider_name) | |
| try: | |
| # Try primary provider | |
| import time | |
| start_time = time.time() | |
| config = primary_provider.create_run_config() | |
| result = await Runner.run(agent, input=user_input, run_config=config) | |
| response_time = time.time() - start_time | |
| self.logger.info( | |
| f"Request handled by {primary_provider_name} " | |
| f"(response_time={response_time:.2f}s)" | |
| ) | |
| return result, primary_provider_name | |
| except TimeoutError as e: | |
| self.logger.error( | |
| f"Provider {primary_provider_name} timed out: {e}", exc_info=True | |
| ) | |
| except Exception as e: | |
| self.logger.error( | |
| f"Provider {primary_provider_name} failed: {e}", exc_info=True | |
| ) | |
| # Determine alternate provider | |
| alternate_name = ( | |
| "gemini" if primary_provider_name == "openai" else "openai" | |
| ) | |
| self.logger.info(f"Failing over to {alternate_name}") | |
| try: | |
| # Try alternate provider | |
| import time | |
| failover_start_time = time.time() | |
| alternate_provider = get_provider(alternate_name) # type: ignore | |
| alt_config = alternate_provider.create_run_config() | |
| result = await Runner.run(agent, input=user_input, run_config=alt_config) | |
| failover_response_time = time.time() - failover_start_time | |
| self.logger.info( | |
| f"Failover successful with {alternate_name} " | |
| f"(response_time={failover_response_time:.2f}s)" | |
| ) | |
| return result, alternate_name | |
| except TimeoutError as failover_error: | |
| self.logger.error( | |
| f"Failover to {alternate_name} timed out: {failover_error}", | |
| exc_info=True, | |
| ) | |
| raise HTTPException( | |
| status_code=503, | |
| detail="All AI providers are currently unavailable", | |
| ) | |
| except Exception as failover_error: | |
| self.logger.error( | |
| f"Failover to {alternate_name} also failed: {failover_error}", | |
| exc_info=True, | |
| ) | |
| raise HTTPException( | |
| status_code=503, | |
| detail="All AI providers are currently unavailable", | |
| ) | |