File size: 3,523 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
"""
Multi-provider AI configuration for OpenAI Agents SDK.

This module implements the provider abstraction layer documented in
.claude/skills/multi-model/SKILL.md, enabling support for multiple
OpenAI-compatible AI providers (OpenAI, Gemini).

Task References: T004, T005, T006
Spec Reference: specs/001-multi-model-chat/spec.md (US1)
"""

from typing import Literal

from agents import AsyncOpenAI, OpenAIChatCompletionsModel
from agents.run import RunConfig

from .config import settings

# Type Definitions (T005)
ProviderName = Literal["openai", "gemini"]
RoutingPolicy = Literal["manual", "failover", "round-robin", "cost-optimized"]


class ProviderConfig:
    """
    Configuration for a single AI model provider.

    Encapsulates all provider-specific details (API key, base URL, model name)
    and provides factory methods for creating SDK-compatible objects.

    Args:
        name: Provider identifier ("openai" or "gemini")
        api_key: API key from environment variable
        base_url: Provider's OpenAI-compatible endpoint (None = default OpenAI)
        model: Model name to use (e.g., "gpt-4o", "gemini-2.5-flash")

    Task Reference: T004
    """

    def __init__(self, name: str, api_key: str, base_url: str | None, model: str):
        self.name = name
        self.api_key = api_key
        self.base_url = base_url
        self.model = model

    def create_client(self) -> AsyncOpenAI:
        """
        Create AsyncOpenAI client for this provider.

        Returns:
            AsyncOpenAI client configured with provider's base_url

        Task Reference: T004
        """
        return AsyncOpenAI(api_key=self.api_key, base_url=self.base_url)

    def create_model(self) -> OpenAIChatCompletionsModel:
        """
        Create OpenAIChatCompletionsModel for this provider.

        Returns:
            Model instance using this provider's external client

        Task Reference: T004
        """
        client = self.create_client()
        return OpenAIChatCompletionsModel(model=self.model, openai_client=client)

    def create_run_config(self) -> RunConfig:
        """
        Create RunConfig for running agents with this provider.

        Returns:
            RunConfig with model and model_provider set

        Task Reference: T004
        """
        client = self.create_client()
        model = self.create_model()
        return RunConfig(
            model=model, model_provider=client, tracing_disabled=True
        )


# Provider Registry (T004)
# Single source of truth for all provider configurations
PROVIDERS: dict[str, ProviderConfig] = {
    "openai": ProviderConfig(
        name="openai",
        api_key=settings.openai_api_key,
        base_url=None,  # Use default OpenAI base URL
        model="gpt-4o",
    ),
    "gemini": ProviderConfig(
        name="gemini",
        api_key=settings.gemini_api_key,
        base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
        model="gemini-2.5-flash",
    ),
}


def get_provider(name: ProviderName) -> ProviderConfig:
    """
    Get provider configuration by name.

    Args:
        name: Provider identifier ("openai" or "gemini")

    Returns:
        ProviderConfig instance for the requested provider

    Raises:
        ValueError: If provider name is unknown

    Task Reference: T006
    """
    if name not in PROVIDERS:
        raise ValueError(
            f"Unknown provider: {name}. Available providers: {list(PROVIDERS.keys())}"
        )
    return PROVIDERS[name]