ag2 0.9.7__py3-none-any.whl → 0.9.8.post1__py3-none-any.whl

autogen/io/run_response.py

@@ -7,7 +7,8 @@
 
 import queue
 from asyncio import Queue as AsyncQueue
-from typing import Any, AsyncIterable, Dict, Iterable, Optional, Protocol, Sequence, Union
+from collections.abc import AsyncIterable, Iterable, Sequence
+from typing import Any, Optional, Protocol
 from uuid import UUID, uuid4
 
 from pydantic import BaseModel, Field
@@ -46,7 +47,7 @@ class Usage(BaseModel):
 
 class CostBreakdown(BaseModel):
     total_cost: float
-    models: Dict[str, Usage] = Field(default_factory=dict)
+    models: dict[str, Usage] = Field(default_factory=dict)
 
     @classmethod
     def from_raw(cls, data: dict[str, Any]) -> "CostBreakdown":
@@ -79,18 +80,18 @@ class RunResponseProtocol(RunInfoProtocol, Protocol):
     def messages(self) -> Iterable[Message]: ...
 
     @property
-    def summary(self) -> Optional[str]: ...
+    def summary(self) -> str | None: ...
 
     @property
-    def context_variables(self) -> Optional[ContextVariables]: ...
+    def context_variables(self) -> ContextVariables | None: ...
 
     @property
-    def last_speaker(self) -> Optional[str]: ...
+    def last_speaker(self) -> str | None: ...
 
     @property
-    def cost(self) -> Optional[Cost]: ...
+    def cost(self) -> Cost | None: ...
 
-    def process(self, processor: Optional[EventProcessorProtocol] = None) -> None: ...
+    def process(self, processor: EventProcessorProtocol | None = None) -> None: ...
 
     def set_ui_tools(self, tools: list[Tool]) -> None: ...
 
@@ -103,18 +104,18 @@ class AsyncRunResponseProtocol(RunInfoProtocol, Protocol):
     async def messages(self) -> Iterable[Message]: ...
 
     @property
-    async def summary(self) -> Optional[str]: ...
+    async def summary(self) -> str | None: ...
 
     @property
-    async def context_variables(self) -> Optional[ContextVariables]: ...
+    async def context_variables(self) -> ContextVariables | None: ...
 
     @property
-    async def last_speaker(self) -> Optional[str]: ...
+    async def last_speaker(self) -> str | None: ...
 
     @property
-    async def cost(self) -> Optional[Cost]: ...
+    async def cost(self) -> Cost | None: ...
 
-    async def process(self, processor: Optional[AsyncEventProcessorProtocol] = None) -> None: ...
+    async def process(self, processor: AsyncEventProcessorProtocol | None = None) -> None: ...
 
     def set_ui_tools(self, tools: list[Tool]) -> None: ...
 
@@ -123,12 +124,12 @@ class RunResponse:
     def __init__(self, iostream: ThreadIOStream, agents: list[Agent]):
         self.iostream = iostream
         self.agents = agents
-        self._summary: Optional[str] = None
+        self._summary: str | None = None
         self._messages: Sequence[LLMMessageType] = []
         self._uuid = uuid4()
-        self._context_variables: Optional[ContextVariables] = None
-        self._last_speaker: Optional[str] = None
-        self._cost: Optional[Cost] = None
+        self._context_variables: ContextVariables | None = None
+        self._last_speaker: str | None = None
+        self._cost: Cost | None = None
 
     def _queue_generator(self, q: queue.Queue) -> Iterable[BaseEvent]:  # type: ignore[type-arg]
         """A generator to yield items from the queue until the termination message is found."""
@@ -164,7 +165,7 @@ class RunResponse:
         return self._messages
 
     @property
-    def summary(self) -> Optional[str]:
+    def summary(self) -> str | None:
         return self._summary
 
     @property
@@ -176,25 +177,25 @@ class RunResponse:
         return self._uuid
 
     @property
-    def context_variables(self) -> Optional[ContextVariables]:
+    def context_variables(self) -> ContextVariables | None:
         return self._context_variables
 
     @property
-    def last_speaker(self) -> Optional[str]:
+    def last_speaker(self) -> str | None:
         return self._last_speaker
 
     @property
-    def cost(self) -> Optional[Cost]:
+    def cost(self) -> Cost | None:
         return self._cost
 
     @cost.setter
-    def cost(self, value: Union[Cost, dict[str, Any]]) -> None:
+    def cost(self, value: Cost | dict[str, Any]) -> None:
         if isinstance(value, dict):
             self._cost = Cost.from_raw(value)
         else:
             self._cost = value
 
-    def process(self, processor: Optional[EventProcessorProtocol] = None) -> None:
+    def process(self, processor: EventProcessorProtocol | None = None) -> None:
         processor = processor or ConsoleEventProcessor()
         processor.process(self)
 
@@ -208,12 +209,12 @@ class AsyncRunResponse:
     def __init__(self, iostream: AsyncThreadIOStream, agents: list[Agent]):
         self.iostream = iostream
         self.agents = agents
-        self._summary: Optional[str] = None
+        self._summary: str | None = None
         self._messages: Sequence[LLMMessageType] = []
         self._uuid = uuid4()
-        self._context_variables: Optional[ContextVariables] = None
-        self._last_speaker: Optional[str] = None
-        self._cost: Optional[Cost] = None
+        self._context_variables: ContextVariables | None = None
+        self._last_speaker: str | None = None
+        self._cost: Cost | None = None
 
     async def _queue_generator(self, q: AsyncQueue[Any]) -> AsyncIterable[BaseEvent]:  # type: ignore[type-arg]
         """A generator to yield items from the queue until the termination message is found."""
@@ -253,7 +254,7 @@ class AsyncRunResponse:
         return self._messages
 
     @property
-    async def summary(self) -> Optional[str]:
+    async def summary(self) -> str | None:
         return self._summary
 
     @property
@@ -265,25 +266,25 @@ class AsyncRunResponse:
         return self._uuid
 
     @property
-    async def context_variables(self) -> Optional[ContextVariables]:
+    async def context_variables(self) -> ContextVariables | None:
         return self._context_variables
 
     @property
-    async def last_speaker(self) -> Optional[str]:
+    async def last_speaker(self) -> str | None:
         return self._last_speaker
 
     @property
-    async def cost(self) -> Optional[Cost]:
+    async def cost(self) -> Cost | None:
         return self._cost
 
     @cost.setter
-    def cost(self, value: Union[Cost, dict[str, Any]]) -> None:
+    def cost(self, value: Cost | dict[str, Any]) -> None:
         if isinstance(value, dict):
             self._cost = Cost.from_raw(value)
         else:
             self._cost = value
 
-    async def process(self, processor: Optional[AsyncEventProcessorProtocol] = None) -> None:
+    async def process(self, processor: AsyncEventProcessorProtocol | None = None) -> None:
         processor = processor or AsyncConsoleEventProcessor()
         await processor.process(self)
 

autogen/io/websockets.py

@@ -7,10 +7,11 @@
 import logging
 import ssl
 import threading
+from collections.abc import Callable, Iterable, Iterator
 from contextlib import contextmanager
 from functools import partial
 from time import sleep
-from typing import Any, Callable, Iterable, Iterator, Optional, Protocol, Union
+from typing import Any, Protocol
 
 from ..doc_utils import export_module
 from ..events.base_event import BaseEvent
@@ -30,11 +31,11 @@ logger.setLevel(logging.INFO)
 
 # The following type and protocols are used to define the ServerConnection and WebSocketServer classes
 # if websockets is not installed, they would be untyped
-Data = Union[str, bytes]
+Data = str | bytes
 
 
 class ServerConnection(Protocol):
-    def send(self, message: Union[Data, Iterable[Data]]) -> None:
+    def send(self, message: Data | Iterable[Data]) -> None:
         """Send a message to the client.
 
         Args:
@@ -43,7 +44,7 @@ class ServerConnection(Protocol):
         """
         ...  # pragma: no cover
 
-    def recv(self, timeout: Optional[float] = None) -> Data:
+    def recv(self, timeout: float | None = None) -> Data:
         """Receive a message from the client.
 
         Args:
@@ -114,7 +115,7 @@ class IOWebsockets(IOStream):
         host: str = "127.0.0.1",
         port: int = 8765,
         on_connect: Callable[["IOWebsockets"], None],
-        ssl_context: Optional[ssl.SSLContext] = None,
+        ssl_context: ssl.SSLContext | None = None,
         **kwargs: Any,
     ) -> Iterator[str]:
         """Factory function to create a websocket input/output stream.

autogen/json_utils.py

@@ -14,8 +14,7 @@ __all__ = ["resolve_json_references"]
 
 @require_optional_import("jsonschema", "gemini")
 def resolve_json_references(schema: dict[str, Any]) -> dict[str, Any]:
-    """
-    Resolve JSON references in the given schema.
+    """Resolve JSON references in the given schema.
 
     Args:
         schema (dict): The JSON schema with references.

autogen/llm_config/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .client import ModelClient
+from .config import LLMConfig
+
+__all__ = (
+    "LLMConfig",
+    "ModelClient",
+)

autogen/llm_config/client.py

@@ -0,0 +1,58 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+from typing import Any, Protocol
+
+from ..doc_utils import export_module
+
+
+@export_module("autogen")
+class ModelClient(Protocol):
+    """A client class must implement the following methods:
+    - create must return a response object that implements the ModelClientResponseProtocol
+    - cost must return the cost of the response
+    - get_usage must return a dict with the following keys:
+        - prompt_tokens
+        - completion_tokens
+        - total_tokens
+        - cost
+        - model
+
+    This class is used to create a client that can be used by OpenAIWrapper.
+    The response returned from create must adhere to the ModelClientResponseProtocol but can be extended however needed.
+    The message_retrieval method must be implemented to return a list of str or a list of messages from the response.
+    """
+
+    RESPONSE_USAGE_KEYS: list[str] = ["prompt_tokens", "completion_tokens", "total_tokens", "cost", "model"]
+
+    class ModelClientResponseProtocol(Protocol):
+        class Choice(Protocol):
+            class Message(Protocol):
+                content: str | dict[str, Any]
+
+            message: Message
+
+        choices: list[Choice]
+        model: str
+
+    def create(self, params: dict[str, Any]) -> ModelClientResponseProtocol: ...  # pragma: no cover
+
+    def message_retrieval(
+        self, response: ModelClientResponseProtocol
+    ) -> list[str] | list["ModelClient.ModelClientResponseProtocol.Choice.Message"]:
+        """Retrieve and return a list of strings or a list of Choice.Message from the response.
+
+        NOTE: if a list of Choice.Message is returned, it currently needs to contain the fields of OpenAI's ChatCompletion Message object,
+        since that is expected for function or tool calling in the rest of the codebase at the moment, unless a custom agent is being used.
+        """
+        ...  # pragma: no cover
+
+    def cost(self, response: ModelClientResponseProtocol) -> float: ...  # pragma: no cover
+
+    @staticmethod
+    def get_usage(response: ModelClientResponseProtocol) -> dict[str, Any]:
+        """Return usage summary of the response using RESPONSE_USAGE_KEYS."""
+        ...  # pragma: no cover

autogen/llm_config/config.py

@@ -0,0 +1,384 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import functools
+import json
+import re
+from collections.abc import Iterable
+from contextvars import ContextVar
+from pathlib import Path
+from typing import Annotated, Any, Literal, TypeAlias
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from autogen.oai.anthropic import AnthropicEntryDict, AnthropicLLMConfigEntry
+from autogen.oai.bedrock import BedrockEntryDict, BedrockLLMConfigEntry
+from autogen.oai.cerebras import CerebrasEntryDict, CerebrasLLMConfigEntry
+from autogen.oai.client import (
+    AzureOpenAIEntryDict,
+    AzureOpenAILLMConfigEntry,
+    DeepSeekEntyDict,
+    DeepSeekLLMConfigEntry,
+    OpenAIEntryDict,
+    OpenAILLMConfigEntry,
+    OpenAIResponsesLLMConfigEntry,
+)
+from autogen.oai.cohere import CohereEntryDict, CohereLLMConfigEntry
+from autogen.oai.gemini import GeminiEntryDict, GeminiLLMConfigEntry
+from autogen.oai.groq import GroqEntryDict, GroqLLMConfigEntry
+from autogen.oai.mistral import MistralEntryDict, MistralLLMConfigEntry
+from autogen.oai.ollama import OllamaEntryDict, OllamaLLMConfigEntry
+from autogen.oai.together import TogetherEntryDict, TogetherLLMConfigEntry
+
+from ..doc_utils import export_module
+from .entry import ApplicationConfig, LLMConfigEntry
+
+
+# Meta class to allow LLMConfig.current and LLMConfig.default to be used as class properties
+class MetaLLMConfig(type):
+    def __init__(cls, *args: Any, **kwargs: Any) -> None:
+        pass
+
+    @property
+    def current(cls) -> "LLMConfig":
+        current_llm_config = LLMConfig.get_current_llm_config(llm_config=None)
+        if current_llm_config is None:
+            raise ValueError("No current LLMConfig set. Are you inside a context block?")
+        return current_llm_config  # type: ignore[return-value]
+
+    @property
+    def default(cls) -> "LLMConfig":
+        return cls.current
+
+
+ConfigItem: TypeAlias = (
+    LLMConfigEntry
+    | AnthropicEntryDict
+    | BedrockEntryDict
+    | CerebrasEntryDict
+    | CohereEntryDict
+    | AzureOpenAIEntryDict
+    | OpenAIEntryDict
+    | DeepSeekEntyDict
+    | MistralEntryDict
+    | GroqEntryDict
+    | OllamaEntryDict
+    | GeminiEntryDict
+    | TogetherEntryDict
+    | dict[str, Any]
+)
+
+
+@export_module("autogen")
+class LLMConfig(metaclass=MetaLLMConfig):
+    _current_llm_config: ContextVar["LLMConfig"] = ContextVar("current_llm_config")
+
+    def __init__(
+        self,
+        *,
+        top_p: float | None = None,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+        config_list: Iterable[ConfigItem] | dict[str, Any] = (),
+        check_every_ms: int | None = None,
+        allow_format_str_template: bool | None = None,
+        response_format: str | dict[str, Any] | BaseModel | type[BaseModel] | None = None,
+        timeout: int | None = None,
+        seed: int | None = None,
+        cache_seed: int | None = None,
+        parallel_tool_calls: bool | None = None,
+        tools: Iterable[Any] = (),
+        functions: Iterable[Any] = (),
+        routing_method: Literal["fixed_order", "round_robin"] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initializes the LLMConfig object.
+
+        Args:
+            config_list: A list of LLM configuration entries or dictionaries.
+            temperature: The sampling temperature for LLM generation.
+            check_every_ms: The interval (in milliseconds) to check for updates
+            allow_format_str_template: Whether to allow format string templates.
+            response_format: The format of the response (e.g., JSON, text).
+            timeout: The timeout for LLM requests in seconds.
+            seed: The random seed for reproducible results.
+            cache_seed: The seed for caching LLM responses.
+            parallel_tool_calls: Whether to enable parallel tool calls.
+            tools: A list of tools available for the LLM.
+            functions: A list of functions available for the LLM.
+            max_tokens: The maximum number of tokens to generate.
+            top_p: The nucleus sampling probability.
+            routing_method: The method used to route requests (e.g., fixed_order, round_robin).
+            **kwargs: Additional keyword arguments for future extensions.
+
+        Examples:
+            ```python
+            # Example 1: create config from `kwargs` options
+            config = LLMConfig(
+                model="gpt-4o-mini",
+                api_key=os.environ["OPENAI_API_KEY"],
+            )
+
+            # Example 2: create config from `config_list` dictionary
+            config = LLMConfig(
+                config_list={
+                    "model": "gpt-4o-mini",
+                    "api_key": os.environ["OPENAI_API_KEY"],
+                }
+            )
+
+            # Example 3: create config from `config_list` list
+            config = LLMConfig(
+                config_list=[
+                    {
+                        "model": "gpt-4o-mini",
+                        "api_key": os.environ["OPENAI_API_KEY"],
+                    },
+                    {
+                        "model": "gpt-4",
+                        "api_key": os.environ["OPENAI_API_KEY"],
+                    },
+                ]
+            )
+            ```
+        """
+        app_config = ApplicationConfig(
+            max_tokens=max_tokens,
+            top_p=top_p,
+            temperature=temperature,
+        )
+
+        application_level_options = app_config.model_dump(exclude_none=True)
+
+        final_config_list: list[LLMConfigEntry | dict[str, Any]] = []
+
+        if isinstance(config_list, dict):
+            config_list = [config_list]
+
+        for c in filter(bool, (*config_list, kwargs)):
+            if isinstance(c, LLMConfigEntry):
+                final_config_list.append(c.apply_application_config(app_config))
+                continue
+
+            else:
+                final_config_list.append({
+                    "api_type": "openai",  # default api_type
+                    **application_level_options,
+                    **c,
+                })
+
+        self._model = _LLMConfig(
+            **application_level_options,
+            config_list=final_config_list,
+            check_every_ms=check_every_ms,
+            seed=seed,
+            allow_format_str_template=allow_format_str_template,
+            response_format=response_format,
+            timeout=timeout,
+            cache_seed=cache_seed,
+            tools=tools or [],
+            functions=functions or [],
+            parallel_tool_calls=parallel_tool_calls,
+            routing_method=routing_method,
+        )
+
+    # used by BaseModel to create instance variables
+    def __enter__(self) -> "LLMConfig":
+        # Store previous context and set self as current
+        self._token = LLMConfig._current_llm_config.set(self)
+        return self
+
+    def __exit__(self, exc_type: type[Exception], exc_val: Exception, exc_tb: Any) -> None:
+        LLMConfig._current_llm_config.reset(self._token)
+
+    @classmethod
+    def get_current_llm_config(cls, llm_config: "LLMConfig | None" = None) -> "LLMConfig | None":
+        if llm_config is not None:
+            return llm_config
+        try:
+            return (LLMConfig._current_llm_config.get()).copy()
+        except LookupError:
+            return None
+
+    def _satisfies_criteria(self, value: Any, criteria_values: Any) -> bool:
+        if value is None:
+            return False
+
+        if isinstance(value, list):
+            return bool(set(value) & set(criteria_values))  # Non-empty intersection
+        else:
+            return value in criteria_values
+
+    @classmethod
+    def from_json(
+        cls,
+        *,
+        env: str | None = None,
+        path: str | Path | None = None,
+        file_location: str | None = None,
+        **kwargs: Any,
+    ) -> "LLMConfig":
+        from autogen.oai.openai_utils import config_list_from_json
+
+        if env is None and path is None:
+            raise ValueError("Either 'env' or 'path' must be provided")
+        if env is not None and path is not None:
+            raise ValueError("Only one of 'env' or 'path' can be provided")
+
+        config_list = config_list_from_json(
+            env_or_file=env if env is not None else str(path), file_location=file_location
+        )
+        return LLMConfig(config_list=config_list, **kwargs)
+
+    def where(self, *, exclude: bool = False, **kwargs: Any) -> "LLMConfig":
+        from autogen.oai.openai_utils import filter_config
+
+        filtered_config_list = filter_config(config_list=self.config_list, filter_dict=kwargs, exclude=exclude)
+        if len(filtered_config_list) == 0:
+            raise ValueError(f"No config found that satisfies the filter criteria: {kwargs}")
+
+        kwargs = self.model_dump()
+        kwargs["config_list"] = filtered_config_list
+
+        return LLMConfig(**kwargs)
+
+    # @functools.wraps(BaseModel.model_dump)
+    def model_dump(self, *args: Any, exclude_none: bool = True, **kwargs: Any) -> dict[str, Any]:
+        d = self._model.model_dump(*args, exclude_none=exclude_none, **kwargs)
+        return {k: v for k, v in d.items() if not (isinstance(v, list) and len(v) == 0)}
+
+    # @functools.wraps(BaseModel.model_dump_json)
+    def model_dump_json(self, *args: Any, exclude_none: bool = True, **kwargs: Any) -> str:
+        # return self._model.model_dump_json(*args, exclude_none=exclude_none, **kwargs)
+        d = self.model_dump(*args, exclude_none=exclude_none, **kwargs)
+        return json.dumps(d)
+
+    # @functools.wraps(BaseModel.model_validate)
+    def model_validate(self, *args: Any, **kwargs: Any) -> Any:
+        return self._model.model_validate(*args, **kwargs)
+
+    @functools.wraps(BaseModel.model_validate_json)
+    def model_validate_json(self, *args: Any, **kwargs: Any) -> Any:
+        return self._model.model_validate_json(*args, **kwargs)
+
+    @functools.wraps(BaseModel.model_validate_strings)
+    def model_validate_strings(self, *args: Any, **kwargs: Any) -> Any:
+        return self._model.model_validate_strings(*args, **kwargs)
+
+    def __eq__(self, value: Any) -> bool:
+        if not isinstance(value, LLMConfig):
+            return NotImplemented
+        return self._model == value._model
+
+    def _getattr(self, o: object, name: str) -> Any:
+        val = getattr(o, name)
+        return val
+
+    def get(self, key: str, default: Any | None = None) -> Any:
+        val = getattr(self._model, key, default)
+        return val
+
+    def __getitem__(self, key: str) -> Any:
+        try:
+            return self._getattr(self._model, key)
+        except AttributeError:
+            raise KeyError(f"Key '{key}' not found in {self.__class__.__name__}")
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        try:
+            setattr(self._model, key, value)
+        except ValueError:
+            raise ValueError(f"'{self.__class__.__name__}' object has no field '{key}'")
+
+    def __getattr__(self, name: Any) -> Any:
+        try:
+            return self._getattr(self._model, name)
+        except AttributeError:
+            raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        if name == "_model":
+            object.__setattr__(self, name, value)
+        else:
+            setattr(self._model, name, value)
+
+    def __contains__(self, key: str) -> bool:
+        return hasattr(self._model, key)
+
+    def __repr__(self) -> str:
+        d = self.model_dump()
+        r = [f"{k}={repr(v)}" for k, v in d.items()]
+
+        s = f"LLMConfig({', '.join(r)})"
+        # Replace any keys ending with 'key' or 'token' values with stars for security
+        s = re.sub(
+            r"(['\"])(\w*(key|token))\1:\s*(['\"])([^'\"]*)(?:\4)", r"\1\2\1: \4**********\4", s, flags=re.IGNORECASE
+        )
+        return s
+
+    def __copy__(self) -> "LLMConfig":
+        return LLMConfig(**self.model_dump())
+
+    def __deepcopy__(self, memo: dict[int, Any] | None = None) -> "LLMConfig":
+        return self.__copy__()
+
+    def copy(self) -> "LLMConfig":
+        return self.__copy__()
+
+    def deepcopy(self, memo: dict[int, Any] | None = None) -> "LLMConfig":
+        return self.__deepcopy__(memo)
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def items(self) -> Iterable[tuple[str, Any]]:
+        d = self.model_dump()
+        return d.items()
+
+    def keys(self) -> Iterable[str]:
+        d = self.model_dump()
+        return d.keys()
+
+    def values(self) -> Iterable[Any]:
+        d = self.model_dump()
+        return d.values()
+
+    _base_model_classes: dict[tuple[type["LLMConfigEntry"], ...], type[BaseModel]] = {}
+
+
+class _LLMConfig(ApplicationConfig):
+    check_every_ms: int | None
+    seed: int | None
+    allow_format_str_template: bool | None
+    response_format: str | dict[str, Any] | BaseModel | type[BaseModel] | None
+    timeout: int | None
+    cache_seed: int | None
+    parallel_tool_calls: bool | None
+
+    tools: list[Any]
+    functions: list[Any]
+
+    config_list: list[  # type: ignore[valid-type]
+        Annotated[
+            AnthropicLLMConfigEntry
+            | CerebrasLLMConfigEntry
+            | BedrockLLMConfigEntry
+            | AzureOpenAILLMConfigEntry
+            | DeepSeekLLMConfigEntry
+            | OpenAILLMConfigEntry
+            | OpenAIResponsesLLMConfigEntry
+            | CohereLLMConfigEntry
+            | GeminiLLMConfigEntry
+            | GroqLLMConfigEntry
+            | MistralLLMConfigEntry
+            | OllamaLLMConfigEntry
+            | TogetherLLMConfigEntry,
+            Field(discriminator="api_type"),
+        ],
+    ] = Field(..., min_length=1)
+
+    routing_method: Literal["fixed_order", "round_robin"] | None
+
+    # Following field is configuration for pydantic to disallow extra fields
+    model_config = ConfigDict(extra="forbid")