LLMConfig

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