tasklert-api / src /services /router.py
hashir-qt's picture
initial deploy
507973e
Raw History Blame Contribute Delete
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",
)