ag2 0.9.9__py3-none-any.whl → 0.10.0__py3-none-any.whl

autogen/llm_config/utils.py

@@ -0,0 +1,223 @@
+# 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
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+
+def config_list_from_json(
+    env_or_file: str | Path,
+    file_location: str | Path | 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.
+
+    This function attempts to parse JSON data from the given `env_or_file` parameter. If `env_or_file` is an
+    environment variable containing JSON data, it will be used directly. Otherwise, it is assumed to be a filename,
+    and the function will attempt to read the file from the specified `file_location`.
+
+    The `filter_dict` parameter allows for filtering the configurations based on specified criteria. Each key in the
+    `filter_dict` corresponds to a field in the configuration dictionaries, and the associated value is a list or set
+    of acceptable values for that field. If a field is missing in a configuration and `None` is included in the list
+    of acceptable values for that field, the configuration will still be considered a match.
+
+    Args:
+        env_or_file (str): The name of the environment variable, the filename, or the environment variable of the filename
+            that containing the JSON data.
+        file_location (str, optional): The directory path where the file is located, if `env_or_file` is a filename.
+        filter_dict (dict, optional): A dictionary specifying the filtering criteria for the configurations, with
+            keys representing field names and values being lists or sets of acceptable values for those fields.
+
+    Example:
+    ```python
+    # Suppose we have an environment variable 'CONFIG_JSON' with the following content:
+    # '[{"model": "gpt-3.5-turbo", "api_type": "azure"}, {"model": "gpt-4"}]'
+
+    # We can retrieve a filtered list of configurations like this:
+    filter_criteria = {"model": ["gpt-3.5-turbo"]}
+    configs = config_list_from_json("CONFIG_JSON", filter_dict=filter_criteria)
+    # The 'configs' variable will now contain only the configurations that match the filter criteria.
+    ```
+
+    Returns:
+        List[Dict]: A list of configuration dictionaries that match the filtering criteria specified in `filter_dict`.
+
+    Raises:
+        FileNotFoundError: if env_or_file is neither found as an environment variable nor a file
+    """
+    env_str = os.environ.get(str(env_or_file))
+
+    if env_str:
+        # The environment variable exists. We should use information from it.
+        if os.path.exists(env_str):  # noqa: SIM108
+            # It is a file location, and we need to load the json from the file.
+            json_str = Path(env_str).read_text()
+        else:
+            # Else, it should be a JSON string by itself.
+            json_str = env_str
+        config_list = json.loads(json_str)
+
+    else:
+        # The environment variable does not exist.
+        # So, `env_or_file` is a filename. We should use the file location.
+        config_list_path = Path(file_location) / env_or_file if file_location else Path(env_or_file)
+
+        with open(config_list_path) as json_file:
+            config_list = json.load(json_file)
+
+    return filter_config(config_list, filter_dict)
+
+
+def filter_config(
+    config_list: list[dict[str, Any]],
+    filter_dict: dict[str, list[str | None] | set[str | None]] | None,
+    exclude: bool = False,
+) -> list[dict[str, Any]]:
+    """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, 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: Filtered list of configuration dictionaries.
+
+    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
+        configs = [
+            {"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"]},
+        ]
+
+        # 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 filter_dict:
+        return [
+            item
+            for item in config_list
+            if all(_satisfies_criteria(item.get(key), values) != exclude for key, values in filter_dict.items())
+        ]
+
+    return config_list
+
+
+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(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 config_value in criteria_values
+        return bool(config_value == criteria_values)

autogen/mcp/mcp_proxy/operation_grouping.py

@@ -67,37 +67,43 @@ def discover_groups(operations: list["Operation"], chunk_size: int = 30) -> dict
     for config in llm_config.config_list:
         config.response_format = GroupSuggestions
 
-    with llm_config:
-        agent = ConversableAgent(name="group_discovery_agent", system_message=GROUP_DISCOVERY_MESSAGE)
-        groups = {}
+    agent = ConversableAgent(
+        name="group_discovery_agent",
+        system_message=GROUP_DISCOVERY_MESSAGE,
+        llm_config=llm_config,
+    )
+    groups = {}
 
-        for i, chunk in enumerate(chunk_list(operations, chunk_size)):
-            func_descriptions = [f"- {op.function_name}: {op.summary} (args: {op.arguments})" for op in chunk]
-            message = "Here are some functions:\n" + "\n".join(func_descriptions)
+    for chunk in chunk_list(operations, chunk_size):
+        func_descriptions = [f"- {op.function_name}: {op.summary} (args: {op.arguments})" for op in chunk]
+        message = "Here are some functions:\n" + "\n".join(func_descriptions)
 
-            response = agent.run(message=message, max_turns=1, user_input=False)
+        response = agent.run(message=message, max_turns=1, user_input=False)
 
-            for event in response.events:
-                if event.type == "text" and event.content.sender == "group_discovery_agent":
-                    # Naively parse "group_name: description" from text block
-                    new_groups = GroupSuggestions.model_validate_json(event.content.content).groups
-                    groups.update(new_groups)
+        for event in response.events:
+            if event.type == "text" and event.content.sender == "group_discovery_agent":
+                # Naively parse "group_name: description" from text block
+                new_groups = GroupSuggestions.model_validate_json(event.content.content).groups
+                groups.update(new_groups)
 
     logger.warning("Discovered groups: %s", groups)
 
     # Remove duplicates
-    with llm_config:
-        agent = ConversableAgent(name="group_refining_agent", system_message=GROUP_DISCOVERY_MESSAGE)
-
-        message = (
-            "You need to refine the group names and descriptions to ensure they are unique.\n"
-            "Here are the groups:\n" + "\n".join([f"- {name}: {desc}" for name, desc in groups.items()])
-        )
-        response = agent.run(message=message, max_turns=1, user_input=False)
-        for event in response.events:
-            if event.type == "text" and event.content.sender == "group_refining_agent":
-                # Naively parse "group_name: description" from text block
-                refined_groups = json.loads(event.content.content)
+    agent = ConversableAgent(
+        name="group_refining_agent",
+        system_message=GROUP_DISCOVERY_MESSAGE,
+        llm_config=llm_config,
+    )
+
+    message = (
+        "You need to refine the group names and descriptions to ensure they are unique.\n"
+        "Here are the groups:\n" + "\n".join([f"- {name}: {desc}" for name, desc in groups.items()])
+    )
+    response = agent.run(message=message, max_turns=1, user_input=False)
+    for event in response.events:
+        if event.type == "text" and event.content.sender == "group_refining_agent":
+            # Naively parse "group_name: description" from text block
+            refined_groups = json.loads(event.content.content)
 
     return refined_groups
 
@@ -108,25 +114,28 @@ def assign_operation_to_group(operation: "Operation", groups: dict[str, str]) ->
     for config in llm_config.config_list:
         config.response_format = GroupNames
 
-    with llm_config:
-        agent = ConversableAgent(name="group_assignment_agent", system_message=GROUP_ASSIGNMENT_MESSAGE)
+    agent = ConversableAgent(
+        name="group_assignment_agent",
+        system_message=GROUP_ASSIGNMENT_MESSAGE,
+        llm_config=llm_config,
+    )
 
-        message = (
-            "Function summary:\n"
-            f"{operation.summary}\n\n"
-            f"Arguments: {operation.arguments}\n\n"
-            f"Available groups: {json.dumps(groups)}\n\n"
-            "What group should this function go in?"
-        )
+    message = (
+        "Function summary:\n"
+        f"{operation.summary}\n\n"
+        f"Arguments: {operation.arguments}\n\n"
+        f"Available groups: {json.dumps(groups)}\n\n"
+        "What group should this function go in?"
+    )
 
-        response = agent.run(message=message, max_turns=1, user_input=True)
+    response = agent.run(message=message, max_turns=1, user_input=True)
 
-        groups = []
-        for event in response.events:
-            if event.type == "text" and event.content.sender == "group_assignment_agent":
-                groups = GroupNames.model_validate_json(event.content.content).groups
+    groups = []
+    for event in response.events:
+        if event.type == "text" and event.content.sender == "group_assignment_agent":
+            groups = GroupNames.model_validate_json(event.content.content).groups
 
-        return groups
+    return groups
 
 
 def refine_group_names(groups: dict[str, str]) -> dict[str, str]:

autogen/messages/agent_messages.py

@@ -911,7 +911,7 @@ class GenerateCodeExecutionReplyMessage(BaseMessage):
         else:
             f(
                 colored(
-                    f"\n>>>>>>>> EXECUTING {num_code_blocks} CODE BLOCKS (inferred languages are [{', '.join([x for x in self.code_block_languages])}])...",
+                    f"\n>>>>>>>> EXECUTING {num_code_blocks} CODE BLOCKS (inferred languages are [{', '.join(list(self.code_block_languages))}])...",
                     "red",
                 ),
                 flush=True,

autogen/messages/client_messages.py

@@ -64,7 +64,7 @@ def _change_usage_summary_format(
         usage_summary_altered_format: dict[str, list[dict[str, Any]]] = {"usages": []}
         for k, v in usage_summary.items():
             if isinstance(k, str) and isinstance(v, dict):
-                current_usage = {key: value for key, value in v.items()}
+                current_usage = dict(v.items())
                 current_usage["model"] = k
                 usage_summary_altered_format["usages"].append(current_usage)
             else:

autogen/oai/__init__.py

@@ -8,7 +8,13 @@ from ..cache.cache import Cache
 from .anthropic import AnthropicLLMConfigEntry
 from .bedrock import BedrockLLMConfigEntry
 from .cerebras import CerebrasLLMConfigEntry
-from .client import AzureOpenAILLMConfigEntry, DeepSeekLLMConfigEntry, OpenAILLMConfigEntry, OpenAIWrapper
+from .client import (
+    AzureOpenAILLMConfigEntry,
+    DeepSeekLLMConfigEntry,
+    OpenAILLMConfigEntry,
+    OpenAIResponsesLLMConfigEntry,
+    OpenAIWrapper,
+)
 from .cohere import CohereLLMConfigEntry
 from .gemini import GeminiLLMConfigEntry
 from .groq import GroqLLMConfigEntry
@@ -39,6 +45,7 @@ __all__ = [
     "MistralLLMConfigEntry",
     "OllamaLLMConfigEntry",
     "OpenAILLMConfigEntry",
+    "OpenAIResponsesLLMConfigEntry",
     "OpenAIWrapper",
     "TogetherLLMConfigEntry",
     "config_list_from_dotenv",

autogen/oai/bedrock.py

@@ -198,22 +198,9 @@ class BedrockClient:
         if "top_p" in params:
             base_params["topP"] = validate_parameter(params, "top_p", (float, int), False, None, None, None)
 
-        if "topP" in params:
-            warnings.warn(
-                ("topP is deprecated, use top_p instead. Scheduled for removal in 0.10.0 version."), DeprecationWarning
-            )
-            base_params["topP"] = validate_parameter(params, "topP", (float, int), False, None, None, None)
-
         if "max_tokens" in params:
             base_params["maxTokens"] = validate_parameter(params, "max_tokens", (int,), False, None, None, None)
 
-        if "maxTokens" in params:
-            warnings.warn(
-                ("maxTokens is deprecated, use max_tokens instead. Scheduled for removal in 0.10.0 version."),
-                DeprecationWarning,
-            )
-            base_params["maxTokens"] = validate_parameter(params, "maxTokens", (int,), False, None, None, None)
-
         # Here are the possible "model-specific" parameters and their suitable types, known as additional parameters
         additional_params = {}
 

autogen/oai/client.py

@@ -2,7 +2,6 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 #
-# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
 # SPDX-License-Identifier: MIT
 from __future__ import annotations
 
@@ -21,6 +20,7 @@ from pydantic import BaseModel, Field, HttpUrl
 from pydantic.type_adapter import TypeAdapter
 
 from ..cache import Cache
+from ..code_utils import content_str
 from ..doc_utils import export_module
 from ..events.client_events import StreamEvent, UsageSummaryEvent
 from ..exception_utils import ModelToolNotSupportedError
@@ -31,7 +31,7 @@ from ..llm_config.entry import LLMConfigEntry, LLMConfigEntryDict
 from ..logger.logger_utils import get_current_ts
 from ..runtime_logging import log_chat_completion, log_new_client, log_new_wrapper, logging_enabled
 from ..token_count_utils import count_token
-from .client_utils import FormatterProtocol, logging_formatter
+from .client_utils import FormatterProtocol, logging_formatter, merge_config_with_tools
 from .openai_utils import OAI_PRICE1K, get_key, is_valid_api_key
 
 TOOL_ENABLED = False
@@ -287,7 +287,7 @@ class AzureOpenAIEntryDict(LLMConfigEntryDict, total=False):
     stream: bool
     tool_choice: Literal["none", "auto", "required"] | None
     user: str | None
-    reasoning_effort: Literal["low", "medium", "high"] | None
+    reasoning_effort: Literal["low", "minimal", "medium", "high"] | None
     max_completion_tokens: int | None
 
 
@@ -301,7 +301,7 @@ class AzureOpenAILLMConfigEntry(LLMConfigEntry):
     # reasoning models - see:
     # - https://learn.microsoft.com/en-us/azure/ai-services/openai/how-to/reasoning
     # - https://learn.microsoft.com/en-us/azure/ai-services/openai/reference-preview
-    reasoning_effort: Literal["low", "medium", "high"] | None = None
+    reasoning_effort: Literal["low", "minimal", "medium", "high"] | None = None
     max_completion_tokens: int | None = None
 
     def create_client(self) -> ModelClient:
@@ -366,11 +366,12 @@ class OpenAIClient:
         if isinstance(response, Completion):
             return [choice.text for choice in choices]  # type: ignore [union-attr]
 
-        def _format_content(content: str) -> str:
+        def _format_content(content: str | list[dict[str, Any]] | None) -> str:
+            normalized_content = content_str(content)
             return (
-                self.response_format.model_validate_json(content).format()
+                self.response_format.model_validate_json(normalized_content).format()
                 if isinstance(self.response_format, FormatterProtocol)
-                else content
+                else normalized_content
             )
 
         if TOOL_ENABLED:
@@ -638,8 +639,11 @@ class OpenAIClient:
                     warnings.warn(
                         f"The {params.get('model')} model does not support streaming. The stream will be set to False."
                     )
-                if params.get("tools", False):
-                    raise ModelToolNotSupportedError(params.get("model"))
+                if "tools" in params:
+                    if params["tools"]:  # If tools exist, raise as unsupported
+                        raise ModelToolNotSupportedError(params.get("model"))
+                    else:
+                        params.pop("tools")  # Remove empty tools list
                 self._process_reasoning_model_params(params)
             params["stream"] = False
             response = create_or_parse(**params)
@@ -884,6 +888,7 @@ class OpenAIWrapper:
             # a config for a custom client is set
             # adding placeholder until the register_model_client is called with the appropriate class
             self._clients.append(PlaceHolderClient(config))
+            # codeql[py/clear-text-logging-sensitive-data]
             logger.info(
                 f"Detected custom model client in config: {model_client_cls_name}, model client can not be used until register_model_client is called."
             )
@@ -1079,9 +1084,10 @@ class OpenAIWrapper:
             self._round_robin_index = (self._round_robin_index + 1) % len(self._clients)
 
         for i in ordered_clients_indices:
-            client = self._clients[i]
             # merge the input config with the i-th config in the config list
-            full_config = {**config, **self._config_list[i]}
+            client_config = self._config_list[i]
+            full_config = merge_config_with_tools(config, client_config)
+
             # separate the config into create_config and extra_kwargs
             create_config, extra_kwargs = self._separate_create_config(full_config)
             # construct the create params
@@ -1112,6 +1118,7 @@ class OpenAIWrapper:
                 # Legacy cache behavior, if cache_seed is given, use DiskCache.
                 cache_client = Cache.disk(cache_seed, LEGACY_CACHE_DIR)
 
+            client = self._clients[i]
             log_cache_seed_value(cache if cache is not None else cache_seed, client=client)
 
             if cache_client is not None:
@@ -1462,6 +1469,13 @@ class OpenAIWrapper:
 # -----------------------------------------------------------------------------
 
 
+class OpenAIResponsesEntryDict(LLMConfigEntryDict, total=False):
+    api_type: Literal["responses"]
+
+    tool_choice: Literal["none", "auto", "required"] | None
+    built_in_tools: list[str] | None
+
+
 class OpenAIResponsesLLMConfigEntry(OpenAILLMConfigEntry):
     """LLMConfig entry for the OpenAI Responses API (stateful, tool-enabled).
 

autogen/oai/client_utils.py

@@ -110,6 +110,36 @@ def validate_parameter(
     return param_value
 
 
+def merge_config_with_tools(config: dict[str, Any], client_config: dict[str, Any]) -> dict[str, Any]:
+    """Merge configuration dictionaries with proper tools and functions handling.
+
+    This function merges two configuration dictionaries while ensuring that:
+    1. Empty 'tools' arrays are not added unnecessarily
+    2. 'tools' and deprecated 'functions' parameters are not both present
+    3. Actual tool configurations are properly merged
+
+    Args:
+        config: The base configuration dictionary (e.g., from create() call)
+        client_config: The client-specific configuration dictionary (e.g., from config_list)
+
+    Returns:
+        dict[str, Any]: The merged configuration with proper tools/functions handling
+    """
+    # Start with a clean merge of both configs
+    full_config = {**config, **client_config}
+
+    # Add tools if tools contains something AND are not using deprecated functions
+    config_tools = config.get("tools", [])
+    client_tools = client_config.get("tools", [])
+
+    if config_tools or client_tools:
+        # Don't add tools if functions parameter is present (deprecated API)
+        if "functions" not in full_config:
+            full_config["tools"] = config_tools + client_tools
+
+    return full_config
+
+
 def should_hide_tools(messages: list[dict[str, Any]], tools: list[dict[str, Any]], hide_tools_param: str) -> bool:
     """Determines if tools should be hidden. This function is used to hide tools when they have been run, minimising the chance of the LLM choosing them when they shouldn't.
     Parameters:
@@ -131,7 +161,7 @@ def should_hide_tools(messages: list[dict[str, Any]], tools: list[dict[str, Any]
         return False
     elif hide_tools_param == "if_any_run":
         # Return True if any tool_call_id exists, indicating a tool call has been executed. False otherwise.
-        return any(["tool_call_id" in dictionary for dictionary in messages])
+        return any("tool_call_id" in dictionary for dictionary in messages)
     elif hide_tools_param == "if_all_run":
         # Return True if all tools have been executed at least once. False otherwise.
 

autogen/oai/cohere.py

@@ -217,16 +217,6 @@ class CohereClient:
         if "top_p" in params:
             cohere_params["p"] = validate_parameter(params, "top_p", (int, float), False, 0.75, (0.01, 0.99), None)
 
-        if "p" in params:
-            warnings.warn(
-                (
-                    "parameter 'p' is deprecated, use 'top_p' instead for consistency with OpenAI API spec. "
-                    "Scheduled for removal in 0.10.0 version."
-                ),
-                DeprecationWarning,
-            )
-            cohere_params["p"] = validate_parameter(params, "p", (int, float), False, 0.75, (0.01, 0.99), None)
-
         if "seed" in params:
             cohere_params["seed"] = validate_parameter(params, "seed", int, True, None, None, None)
 
@@ -260,7 +250,7 @@ class CohereClient:
         cohere_params["messages"] = messages
 
         if "tools" in params:
-            cohere_tool_names = set([tool["function"]["name"] for tool in params["tools"]])
+            cohere_tool_names = {tool["function"]["name"] for tool in params["tools"]}
             cohere_params["tools"] = params["tools"]
 
         # Strip out name
@@ -285,9 +275,9 @@ class CohereClient:
                     ) not in cohere_tool_names:
                         message["role"] = "assistant"
                         message["content"] = f"{message.pop('tool_plan', '')}{str(message['tool_calls'])}"
-                        tool_calls_modified_ids = tool_calls_modified_ids.union(
-                            set([tool_call.get("id") for tool_call in message["tool_calls"]])
-                        )
+                        tool_calls_modified_ids = tool_calls_modified_ids.union({
+                            tool_call.get("id") for tool_call in message["tool_calls"]
+                        })
                         del message["tool_calls"]
                         break
 

autogen/oai/gemini.py

@@ -246,7 +246,7 @@ class GeminiClient:
 
         if model_name == "gemini-pro-vision":
             raise ValueError(
-                "Gemini 1.0 Pro vision ('gemini-pro-vision') has been deprecated, please consider switching to a different model, for example 'gemini-1.5-flash'."
+                "Gemini 1.0 Pro vision ('gemini-pro-vision') has been deprecated, please consider switching to a different model, for example 'gemini-2.5-flash'."
             )
         elif not model_name:
             raise ValueError(
@@ -385,9 +385,7 @@ class GeminiClient:
                             function={
                                 "name": fn_call.name,
                                 "arguments": (
-                                    json.dumps({key: val for key, val in fn_call.args.items()})
-                                    if fn_call.args is not None
-                                    else ""
+                                    json.dumps(dict(fn_call.args.items())) if fn_call.args is not None else ""
                                 ),
                             },
                             type="function",
@@ -857,10 +855,10 @@ class GeminiClient:
         """Convert safety settings to VertexAI format if needed,
         like when specifying them in the OAI_CONFIG_LIST
         """
-        if isinstance(safety_settings, list) and all([
+        if isinstance(safety_settings, list) and all(
             isinstance(safety_setting, dict) and not isinstance(safety_setting, VertexAISafetySetting)
             for safety_setting in safety_settings
-        ]):
+        ):
             vertexai_safety_settings = []
             for safety_setting in safety_settings:
                 if safety_setting["category"] not in VertexAIHarmCategory.__members__:

autogen/oai/gemini_types.py

@@ -105,6 +105,7 @@ class FunctionCallingConfigMode(CaseInSensitiveEnum):
     AUTO = "AUTO"
     ANY = "ANY"
     NONE = "NONE"
+    VALIDATED = "VALIDATED"
 
 
 class LatLng(CommonBaseModel):