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",
                )