Spaces:
Sleeping
Sleeping
File size: 5,630 Bytes
507973e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 | """
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",
)
|