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

autogen/oai/ollama.py

@@ -22,18 +22,19 @@ Resources:
 
 from __future__ import annotations
 
+import ast
 import copy
 import json
 import random
 import re
 import time
 import warnings
-from typing import Any, Literal, Optional, Union
+from typing import Any, Literal
 
 from pydantic import BaseModel, Field, HttpUrl
 
 from ..import_utils import optional_import_block, require_optional_import
-from ..llm_config import LLMConfigEntry, register_llm_config
+from ..llm_config.entry import LLMConfigEntry, LLMConfigEntryDict
 from .client_utils import FormatterProtocol, should_hide_tools, validate_parameter
 from .oai_models import ChatCompletion, ChatCompletionMessage, ChatCompletionMessageToolCall, Choice, CompletionUsage
 
@@ -43,10 +44,23 @@ with optional_import_block():
     from ollama import Client
 
 
-@register_llm_config
+class OllamaEntryDict(LLMConfigEntryDict, total=False):
+    api_type: Literal["ollama"]
+    client_host: HttpUrl | None
+    stream: bool
+    num_predict: int
+    num_ctx: int
+    repeat_penalty: float
+    seed: int
+    top_k: int
+    hide_tools: Literal["if_all_run", "if_any_run", "never"]
+    native_tool_calls: bool
+
+
 class OllamaLLMConfigEntry(LLMConfigEntry):
     api_type: Literal["ollama"] = "ollama"
-    client_host: Optional[HttpUrl] = None
+    # TODO: max_tokens
+    client_host: HttpUrl | None = None
     stream: bool = False
     num_predict: int = Field(
         default=-1,
@@ -55,10 +69,9 @@ class OllamaLLMConfigEntry(LLMConfigEntry):
     num_ctx: int = Field(default=2048)
     repeat_penalty: float = Field(default=1.1)
     seed: int = Field(default=0)
-    temperature: float = Field(default=0.8)
     top_k: int = Field(default=40)
-    top_p: float = Field(default=0.9)
     hide_tools: Literal["if_all_run", "if_any_run", "never"] = "never"
+    native_tool_calls: bool = False
 
     def create_client(self):
         raise NotImplementedError("OllamaLLMConfigEntry.create_client is not implemented.")
@@ -99,11 +112,10 @@ class OllamaClient:
     # Override using "manual_tool_call_step2" config parameter
     TOOL_CALL_MANUAL_STEP2 = " (proceed with step 2)"
 
-    def __init__(self, response_format: Optional[Union[BaseModel, dict[str, Any]]] = None, **kwargs):
+    def __init__(self, response_format: BaseModel | dict[str, Any] | None = None, **kwargs):
         """Note that no api_key or environment variable is required for Ollama."""
-
         # Store the response format, if provided (for structured outputs)
-        self._response_format: Optional[Union[BaseModel, dict[str, Any]]] = response_format
+        self._response_format: BaseModel | dict[str, Any] | None = response_format
 
     def message_retrieval(self, response) -> list:
         """Retrieve and return a list of strings or a list of Choice.Message from the response.
@@ -612,7 +624,7 @@ def _object_to_tool_call(data_object: Any) -> list[dict[str, Any]]:
         is_invalid = False
         for i, item in enumerate(data_copy):
             try:
-                new_item = eval(item)
+                new_item = ast.literal_eval(item)
                 if isinstance(new_item, dict):
                     if is_valid_tool_call_item(new_item):
                         data_object[i] = new_item

autogen/oai/openai_responses.py

@@ -4,7 +4,7 @@
 
 import copy
 import warnings
-from typing import TYPE_CHECKING, Any, Tuple, Union
+from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel
 
@@ -48,9 +48,8 @@ VALID_SIZES = {
 
 def calculate_openai_image_cost(
     model: str = "gpt-image-1", size: str = "1024x1024", quality: str = "high"
-) -> Tuple[float, str]:
-    """
-    Calculate the cost for a single image generation.
+) -> tuple[float, str]:
+    """Calculate the cost for a single image generation.
 
     Args:
         model: Model name ("gpt-image-1", "dall-e-3" or "dall-e-2")
@@ -114,7 +113,7 @@ class OpenAIResponsesClient:
     def __init__(
         self,
         client: "OpenAI",
-        response_format: Union[BaseModel, dict[str, Any], None] = None,
+        response_format: BaseModel | dict[str, Any] | None = None,
     ):
         self._oai_client = client  # plain openai.OpenAI instance
         self.response_format = response_format  # kept for parity but unused for now
@@ -195,6 +194,12 @@ class OpenAIResponsesClient:
             delta_messages.append(m)
         return delta_messages[::-1]
 
+    def _parse_params(self, params: dict[str, Any]) -> None:
+        if "verbosity" in params:
+            verbosity = params.pop("verbosity")
+            params["text"] = {"verbosity": verbosity}
+        return params
+
     def create(self, params: dict[str, Any]) -> "Response":
         """Invoke `client.responses.create() or .parse()`.
 
@@ -246,7 +251,14 @@ class OpenAIResponsesClient:
                         "output": content,
                     })
                     break
-            params["input"] = input_items[::-1]
+
+            # Ensure we have at least one valid input item
+            if input_items:
+                params["input"] = input_items[::-1]
+            else:
+                # If no valid input items were created, create a default one
+                # This prevents the API error about missing required parameters
+                params["input"] = [{"role": "user", "content": [{"type": "input_text", "text": "Hello"}]}]
 
         # Initialize tools list
         tools_list = []
@@ -274,6 +286,11 @@ class OpenAIResponsesClient:
                 UserWarning,
             )
 
+        # Validate that we have at least one of the required parameters
+        if not any(key in params for key in ["input", "previous_response_id", "prompt"]):
+            # If we still don't have any required parameters, create a minimal input
+            params["input"] = [{"role": "user", "content": [{"type": "input_text", "text": "Hello"}]}]
+
         # ------------------------------------------------------------------
         # Structured output handling - mimic OpenAIClient behaviour
         # ------------------------------------------------------------------
@@ -306,7 +323,6 @@ class OpenAIResponsesClient:
                     kwargs["text_format"] = type_to_response_format_param(rf)
                 if "response_format" in kwargs:
                     kwargs["text_format"] = kwargs.pop("response_format")
-
                 try:
                     return self._oai_client.responses.parse(**kwargs)
                 except TypeError as e:
@@ -325,22 +341,19 @@ class OpenAIResponsesClient:
             response = _create_or_parse(**params)
             self.previous_response_id = response.id
             return response
-
         # No structured output
+        params = self._parse_params(params)
         response = self._oai_client.responses.create(**params)
         self.previous_response_id = response.id
-
         # Accumulate image costs
         self._add_image_cost(response)
-
         return response
 
-    def message_retrieval(
-        self, response
-    ) -> Union[list[str], list["ModelClient.ModelClientResponseProtocol.Choice.Message"]]:
+    def message_retrieval(self, response) -> list[str] | list["ModelClient.ModelClientResponseProtocol.Choice.Message"]:
         output = getattr(response, "output", [])
-        content = []  # list[dict[str, Union[str, dict[str, Any]]]]]
+        content = []
         tool_calls = []
+
         for item in output:
             # Convert pydantic objects to plain dicts for uniform handling
             if hasattr(item, "model_dump"):
@@ -348,16 +361,26 @@ class OpenAIResponsesClient:
 
             item_type = item.get("type")
 
-            # ------------------------------------------------------------------
-            # 1) Normal messages
-            # ------------------------------------------------------------------
+            # Skip reasoning items - they're not messages
+            if item_type == "reasoning":
+                continue
+
             if item_type == "message":
                 new_item = copy.deepcopy(item)
                 new_item["type"] = "text"
                 new_item["role"] = "assistant"
+
                 blocks = item.get("content", [])
                 if len(blocks) == 1 and blocks[0].get("type") == "output_text":
                     new_item["text"] = blocks[0]["text"]
+                elif len(blocks) > 0:
+                    # Handle multiple content blocks
+                    text_parts = []
+                    for block in blocks:
+                        if block.get("type") == "output_text":
+                            text_parts.append(block.get("text", ""))
+                    new_item["text"] = " ".join(text_parts)
+
                 if "content" in new_item:
                     del new_item["content"]
                 content.append(new_item)

autogen/oai/openai_utils.py

@@ -17,7 +17,7 @@ import time
 import warnings
 from copy import deepcopy
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any, Union
 
 from dotenv import find_dotenv, load_dotenv
 from packaging.version import parse
@@ -27,8 +27,9 @@ if TYPE_CHECKING:
     from openai import OpenAI
     from openai.types.beta.assistant import Assistant
 
+    from ..llm_config import LLMConfig
+
 from ..doc_utils import export_module
-from ..llm_config import LLMConfig
 
 NON_CACHE_KEY = [
     "api_key",
@@ -58,6 +59,15 @@ OAI_PRICE1K = {
     # o3
     "o3": (0.0011, 0.0044),
     "o3-mini-2025-01-31": (0.0011, 0.0044),
+    # gpt-5
+    "gpt-5": (0.00125, 0.00125),
+    "gpt-5-2025-08-07": (0.00125, 0.00125),
+    # gpt-5-mini
+    "gpt-5-mini": (0.00025, 0.00025),
+    "gpt-5-mini-2025-08-07": (0.00025, 0.00025),
+    # gpt-5-nano
+    "gpt-5-nano": (0.00005, 0.00005),
+    "gpt-5-nano-2025-08-07": (0.00005, 0.00005),
     # gpt-4o
     "gpt-4o": (0.005, 0.015),
     "gpt-4o-2024-05-13": (0.005, 0.015),
@@ -157,9 +167,9 @@ def is_valid_api_key(api_key: str) -> bool:
 @export_module("autogen")
 def get_config_list(
     api_keys: list[str],
-    base_urls: Optional[list[str]] = None,
-    api_type: Optional[str] = None,
-    api_version: Optional[str] = None,
+    base_urls: list[str] | None = None,
+    api_type: str | None = None,
+    api_version: str | None = None,
 ) -> list[dict[str, Any]]:
     """Get a list of configs for OpenAI API client.
 
@@ -208,7 +218,7 @@ def get_config_list(
 
 @export_module("autogen")
 def get_first_llm_config(
-    llm_config: Union[LLMConfig, dict[str, Any]],
+    llm_config: Union["LLMConfig", dict[str, Any]],
 ) -> dict[str, Any]:
     """Get the first LLM config from the given LLM config.
 
@@ -236,12 +246,12 @@ def get_first_llm_config(
 
 @export_module("autogen")
 def config_list_openai_aoai(
-    key_file_path: Optional[str] = ".",
-    openai_api_key_file: Optional[str] = "key_openai.txt",
-    aoai_api_key_file: Optional[str] = "key_aoai.txt",
-    openai_api_base_file: Optional[str] = "base_openai.txt",
-    aoai_api_base_file: Optional[str] = "base_aoai.txt",
-    exclude: Optional[str] = None,
+    key_file_path: str | None = ".",
+    openai_api_key_file: str | None = "key_openai.txt",
+    aoai_api_key_file: str | None = "key_aoai.txt",
+    openai_api_base_file: str | None = "base_openai.txt",
+    aoai_api_base_file: str | None = "base_aoai.txt",
+    exclude: str | None = None,
 ) -> list[dict[str, Any]]:
     """Get a list of configs for OpenAI API client (including Azure or local model deployments that support OpenAI's chat completion API).
 
@@ -366,12 +376,12 @@ def config_list_openai_aoai(
 
 @export_module("autogen")
 def config_list_from_models(
-    key_file_path: Optional[str] = ".",
-    openai_api_key_file: Optional[str] = "key_openai.txt",
-    aoai_api_key_file: Optional[str] = "key_aoai.txt",
-    aoai_api_base_file: Optional[str] = "base_aoai.txt",
-    exclude: Optional[str] = None,
-    model_list: Optional[list[str]] = None,
+    key_file_path: str | None = ".",
+    openai_api_key_file: str | None = "key_openai.txt",
+    aoai_api_key_file: str | None = "key_aoai.txt",
+    aoai_api_base_file: str | None = "base_aoai.txt",
+    exclude: str | None = None,
+    model_list: list[str] | None = None,
 ) -> list[dict[str, Any]]:
     """Get a list of configs for API calls with models specified in the model list.
 
@@ -433,11 +443,11 @@ def config_list_from_models(
 
 @export_module("autogen")
 def config_list_gpt4_gpt35(
-    key_file_path: Optional[str] = ".",
-    openai_api_key_file: Optional[str] = "key_openai.txt",
-    aoai_api_key_file: Optional[str] = "key_aoai.txt",
-    aoai_api_base_file: Optional[str] = "base_aoai.txt",
-    exclude: Optional[str] = None,
+    key_file_path: str | None = ".",
+    openai_api_key_file: str | None = "key_openai.txt",
+    aoai_api_key_file: str | None = "key_aoai.txt",
+    aoai_api_base_file: str | None = "base_aoai.txt",
+    exclude: str | None = None,
 ) -> list[dict[str, Any]]:
     """Get a list of configs for 'gpt-4' followed by 'gpt-3.5-turbo' API calls.
 
@@ -464,62 +474,73 @@ def config_list_gpt4_gpt35(
 @export_module("autogen")
 def filter_config(
     config_list: list[dict[str, Any]],
-    filter_dict: Optional[dict[str, Union[list[Union[str, None]], set[Union[str, None]]]]],
+    filter_dict: dict[str, list[str | None] | set[str | None]] | None,
     exclude: bool = False,
 ) -> list[dict[str, Any]]:
-    """This function filters `config_list` by checking each configuration dictionary against the criteria specified in
-    `filter_dict`. A configuration dictionary is retained if for every key in `filter_dict`, see example below.
+    """Filter configuration dictionaries based on specified criteria.
+
+    This function filters a list of configuration dictionaries by applying ALL criteria specified in `filter_dict`.
+    A configuration is included in the result if it satisfies every key-value constraint in the filter dictionary.
+    For each filter key, the configuration's corresponding field value must match at least one of the acceptable
+    values (OR logic within each criteria, AND logic between different criteria).
 
     Args:
         config_list (list of dict): A list of configuration dictionaries to be filtered.
-        filter_dict (dict): A dictionary representing the filter criteria, where each key is a
-                            field name to check within the configuration dictionaries, and the
-                            corresponding value is a list of acceptable values for that field.
-                            If the configuration's field's value is not a list, then a match occurs
-                            when it is found in the list of acceptable values. If the configuration's
-                            field's value is a list, then a match occurs if there is a non-empty
-                            intersection with the acceptable values.
-        exclude (bool): If False (the default value), configs that match the filter will be included in the returned
-            list. If True, configs that match the filter will be excluded in the returned list.
+
+        filter_dict (dict, optional): A dictionary specifying filter criteria where:
+            - Keys are field names to check in each configuration dictionary
+            - Values are lists/sets of acceptable values for that field
+            - A configuration matches if ALL filter keys are satisfied AND for each key,
+              the config's field value matches at least one acceptable value
+            - If a filter value includes None, configurations missing that field will match
+            - If None, no filtering is applied
+
+        exclude (bool, optional): If False (default), return configurations that match the filter.
+                                If True, return configurations that do NOT match the filter.
 
     Returns:
-        list of dict: A list of configuration dictionaries that meet all the criteria specified
-                      in `filter_dict`.
+        list of dict: Filtered list of configuration dictionaries.
 
-    Example:
+    Matching Logic:
+        - **Between different filter keys**: AND logic (all criteria must be satisfied)
+        - **Within each filter key's values**: OR logic (any acceptable value can match)
+        - **For list-type config values**: Match if there's any intersection with acceptable values
+        - **For scalar config values**: Match if the value is in the list of acceptable values
+        - **Missing fields**: Only match if None is included in the acceptable values for that field
+
+    Examples:
         ```python
-        # Example configuration list with various models and API types
         configs = [
-            {"model": "gpt-3.5-turbo"},
-            {"model": "gpt-4"},
-            {"model": "gpt-3.5-turbo", "api_type": "azure"},
-            {"model": "gpt-3.5-turbo", "tags": ["gpt35_turbo", "gpt-35-turbo"]},
+            {"model": "gpt-3.5-turbo", "api_type": "openai"},
+            {"model": "gpt-4", "api_type": "openai"},
+            {"model": "gpt-3.5-turbo", "api_type": "azure", "api_version": "2024-02-01"},
+            {"model": "gpt-4", "tags": ["premium", "latest"]},
         ]
-        # Define filter criteria to select configurations for the 'gpt-3.5-turbo' model
-        # that are also using the 'azure' API type
-        filter_criteria = {
-            "model": ["gpt-3.5-turbo"],  # Only accept configurations for 'gpt-3.5-turbo'
-            "api_type": ["azure"],  # Only accept configurations for 'azure' API type
-        }
-        # Apply the filter to the configuration list
-        filtered_configs = filter_config(configs, filter_criteria)
-        # The resulting `filtered_configs` will be:
-        # [{'model': 'gpt-3.5-turbo', 'api_type': 'azure', ...}]
-        # Define a filter to select a given tag
-        filter_criteria = {
-            "tags": ["gpt35_turbo"],
-        }
-        # Apply the filter to the configuration list
-        filtered_configs = filter_config(configs, filter_criteria)
-        # The resulting `filtered_configs` will be:
-        # [{'model': 'gpt-3.5-turbo', 'tags': ['gpt35_turbo', 'gpt-35-turbo']}]
+
+        # Example 1: Single criterion - matches any model in the list
+        filter_dict = {"model": ["gpt-4", "gpt-4o"]}
+        result = filter_config(configs, filter_dict)
+        # Returns: [{"model": "gpt-4", "api_type": "openai"}, {"model": "gpt-4", "tags": ["premium", "latest"]}]
+
+        # Example 2: Multiple criteria - must satisfy ALL conditions
+        filter_dict = {"model": ["gpt-3.5-turbo"], "api_type": ["azure"]}
+        result = filter_config(configs, filter_dict)
+        # Returns: [{"model": "gpt-3.5-turbo", "api_type": "azure", "api_version": "2024-02-01"}]
+
+        # Example 3: Tag filtering with list intersection
+        filter_dict = {"tags": ["premium"]}
+        result = filter_config(configs, filter_dict)
+        # Returns: [{"model": "gpt-4", "tags": ["premium", "latest"]}]
+
+        # Example 4: Exclude matching configurations
+        filter_dict = {"api_type": ["openai"]}
+        result = filter_config(configs, filter_dict, exclude=True)
+        # Returns configs that do NOT have api_type="openai"
         ```
     Note:
         - If `filter_dict` is empty or None, no filtering is applied and `config_list` is returned as is.
         - If a configuration dictionary in `config_list` does not contain a key specified in `filter_dict`,
           it is considered a non-match and is excluded from the result.
-        - If the list of acceptable values for a key in `filter_dict` includes None, then configuration
-          dictionaries that do not have that key will also be considered a match.
 
     """
     if inspect.stack()[1].function != "where":
@@ -538,25 +559,80 @@ def filter_config(
     return config_list
 
 
-def _satisfies_criteria(value: Any, criteria_values: Any) -> bool:
-    if value is None:
+def _satisfies_criteria(config_value: Any, criteria_values: Any) -> bool:
+    """Check if a configuration field value satisfies the filter criteria.
+
+    This helper function implements the matching logic between a single configuration
+    field value and the acceptable values specified in the filter criteria. It handles
+    both scalar and list-type configuration values with appropriate matching strategies.
+
+    Args:
+        config_value (Any): The value from a configuration dictionary field.
+                           Can be None, a scalar value, or a list of values.
+        criteria_values (Any): The acceptable values from the filter dictionary.
+                              Can be a single value or a list/set of acceptable values.
+
+    Returns:
+        bool: True if the config_value satisfies the criteria, False otherwise.
+
+    Matching Logic:
+        - **None config values**: Always return False (missing fields don't match)
+        - **List config values**:
+            - If criteria is a list: Match if there's any intersection (set overlap)
+            - If criteria is scalar: Match if the scalar is contained in the config list
+        - **Scalar config values**:
+            - If criteria is a list: Match if the config value is in the criteria list
+            - If criteria is scalar: Match if the values are exactly equal
+
+    Examples:
+        ```python
+        # List config value with list criteria (intersection matching)
+        _satisfies_criteria(["gpt-4", "gpt-3.5"], ["gpt-4", "claude"])  # True (gpt-4 intersects)
+        _satisfies_criteria(["tag1", "tag2"], ["tag3", "tag4"])  # False (no intersection)
+
+        # List config value with scalar criteria (containment matching)
+        _satisfies_criteria(["premium", "latest"], "premium")  # True (premium is in list)
+        _satisfies_criteria(["tag1", "tag2"], "tag3")  # False (tag3 not in list)
+
+        # Scalar config value with list criteria (membership matching)
+        _satisfies_criteria("gpt-4", ["gpt-4", "gpt-3.5"])  # True (gpt-4 in criteria)
+        _satisfies_criteria("claude", ["gpt-4", "gpt-3.5"])  # False (claude not in criteria)
+
+        # Scalar config value with scalar criteria (equality matching)
+        _satisfies_criteria("openai", "openai")  # True (exact match)
+        _satisfies_criteria("openai", "azure")  # False (different values)
+
+        # None config values (missing fields)
+        _satisfies_criteria(None, ["gpt-4"])  # False (missing field)
+        _satisfies_criteria(None, "gpt-4")  # False (missing field)
+        ```
+
+    Note:
+        This is an internal helper function used by `filter_config()`. The function
+        assumes that both parameters can be of various types and handles type
+        checking internally to determine the appropriate matching strategy.
+    """
+    if config_value is None:
         return False
 
-    if isinstance(value, list):
-        return bool(set(value) & set(criteria_values))  # Non-empty intersection
+    if isinstance(config_value, list):
+        if isinstance(criteria_values, list):
+            return bool(set(config_value) & set(criteria_values))  # Non-empty intersection
+        else:
+            return criteria_values in config_value
     else:
         # In filter_dict, filter could be either a list of values or a single value.
         # For example, filter_dict = {"model": ["gpt-3.5-turbo"]} or {"model": "gpt-3.5-turbo"}
         if isinstance(criteria_values, list):
-            return value in criteria_values
-        return bool(value == criteria_values)
+            return config_value in criteria_values
+        return bool(config_value == criteria_values)
 
 
 @export_module("autogen")
 def config_list_from_json(
     env_or_file: str,
-    file_location: Optional[str] = "",
-    filter_dict: Optional[dict[str, Union[list[Union[str, None]], set[Union[str, None]]]]] = None,
+    file_location: str | None = "",
+    filter_dict: dict[str, list[str | None] | set[str | None]] | None = None,
 ) -> list[dict[str, Any]]:
     """Retrieves a list of API configurations from a JSON stored in an environment variable or a file.
 
@@ -620,16 +696,14 @@ def config_list_from_json(
         with open(config_list_path) as json_file:
             config_list = json.load(json_file)
 
-    config_list = filter_config(config_list, filter_dict)
-
     return filter_config(config_list, filter_dict)
 
 
 def get_config(
-    api_key: Optional[str],
-    base_url: Optional[str] = None,
-    api_type: Optional[str] = None,
-    api_version: Optional[str] = None,
+    api_key: str | None,
+    base_url: str | None = None,
+    api_type: str | None = None,
+    api_version: str | None = None,
 ) -> dict[str, Any]:
     """Constructs a configuration dictionary for a single model with the provided API configurations.
 
@@ -665,10 +739,10 @@ def get_config(
 
 @export_module("autogen")
 def config_list_from_dotenv(
-    dotenv_file_path: Optional[str] = None,
-    model_api_key_map: Optional[dict[str, Any]] = None,
-    filter_dict: Optional[dict[str, Union[list[Union[str, None]], set[Union[str, None]]]]] = None,
-) -> list[dict[str, Union[str, set[str]]]]:
+    dotenv_file_path: str | None = None,
+    model_api_key_map: dict[str, Any] | None = None,
+    filter_dict: dict[str, list[str | None] | set[str | None]] | None = None,
+) -> list[dict[str, str | set[str]]]:
     """Load API configurations from a specified .env file or environment variables and construct a list of configurations.
 
     This function will:
@@ -733,12 +807,12 @@ def config_list_from_dotenv(
             config_without_key_var = {k: v for k, v in config.items() if k != "api_key_env_var"}
             config_dict = get_config(api_key=api_key, **config_without_key_var)
         else:
-            logging.warning(f"Unsupported type {type(config)} for model {model} configuration")
-
-        if not config_dict["api_key"] or config_dict["api_key"].strip() == "":
             logging.warning(
-                f"API key not found or empty for model {model}. Please ensure path to .env file is correct."
+                "Unsupported configuration type encountered for a model. Please check your model_api_key_map."
             )
+
+        if not config_dict["api_key"] or config_dict["api_key"].strip() == "":
+            logging.warning("API key not found or empty for a model. Please ensure path to .env file is correct.")
             continue  # Skip this configuration and continue with the next
 
         # Add model to the configuration and append to the list

autogen/oai/together.py

@@ -33,12 +33,13 @@ import copy
 import os
 import time
 import warnings
-from typing import Any, Literal, Optional, Union
+from typing import Any, Literal
 
 from pydantic import Field
+from typing_extensions import Unpack
 
 from ..import_utils import optional_import_block, require_optional_import
-from ..llm_config import LLMConfigEntry, register_llm_config
+from ..llm_config.entry import LLMConfigEntry, LLMConfigEntryDict
 from .client_utils import should_hide_tools, validate_parameter
 from .oai_models import ChatCompletion, ChatCompletionMessage, ChatCompletionMessageToolCall, Choice, CompletionUsage
 
@@ -46,22 +47,36 @@ with optional_import_block():
     from together import Together
 
 
-@register_llm_config
+class TogetherEntryDict(LLMConfigEntryDict, total=False):
+    api_type: Literal["together"]
+
+    stream: bool
+    top_k: int | None
+    repetition_penalty: float | None
+    presence_penalty: float | None
+    frequency_penalty: float | None
+    min_p: float | None
+    safety_model: str | None
+    hide_tools: Literal["if_all_run", "if_any_run", "never"]
+    price: list[float] | None
+    tool_choice: str | dict[str, str | dict[str, str]] | None
+
+
 class TogetherLLMConfigEntry(LLMConfigEntry):
     api_type: Literal["together"] = "together"
+
     max_tokens: int = Field(default=512, ge=0)
+
     stream: bool = False
-    temperature: Optional[float] = Field(default=None)
-    top_p: Optional[float] = Field(default=None)
-    top_k: Optional[int] = Field(default=None)
-    repetition_penalty: Optional[float] = Field(default=None)
-    presence_penalty: Optional[float] = Field(default=None, ge=-2, le=2)
-    frequency_penalty: Optional[float] = Field(default=None, ge=-2, le=2)
-    min_p: Optional[float] = Field(default=None, ge=0, le=1)
-    safety_model: Optional[str] = None
+    top_k: int | None = Field(default=None)
+    repetition_penalty: float | None = Field(default=None)
+    presence_penalty: float | None = Field(default=None, ge=-2, le=2)
+    frequency_penalty: float | None = Field(default=None, ge=-2, le=2)
+    min_p: float | None = Field(default=None, ge=0, le=1)
+    safety_model: str | None = None
     hide_tools: Literal["if_all_run", "if_any_run", "never"] = "never"
-    price: Optional[list[float]] = Field(default=None, min_length=2, max_length=2)
-    tool_choice: Optional[Union[str, dict[str, Union[str, dict[str, str]]]]] = (
+    price: list[float] | None = Field(default=None, min_length=2, max_length=2)
+    tool_choice: str | dict[str, str | dict[str, str]] | None = (
         None  # dict is the tool to call: {"type": "function", "function": {"name": "my_function"}}
     )
 
@@ -72,7 +87,7 @@ class TogetherLLMConfigEntry(LLMConfigEntry):
 class TogetherClient:
     """Client for Together.AI's API."""
 
-    def __init__(self, **kwargs):
+    def __init__(self, **kwargs: Unpack[TogetherEntryDict]):
         """Requires api_key or environment variable to be set
 
         Args: