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

autogen/agentchat/groupchat.py

@@ -1021,9 +1021,7 @@ class GroupChat:
         return mentions
 
     def _run_input_guardrails(
-        self,
-        agent: "ConversableAgent",
-        messages: list[dict[str, Any]] | None = None,
+        self, agent: "ConversableAgent", messages: list[dict[str, Any]] | None = None
     ) -> str | None:
         """Run input guardrails for an agent before the reply is generated.
 
@@ -1031,27 +1029,21 @@ class GroupChat:
             agent (ConversableAgent): The agent whose input guardrails to run.
             messages (Optional[list[dict[str, Any]]]): The messages to check against the guardrails.
         """
-        for guardrail in agent.input_guardrails:
-            guardrail_result = guardrail.check(context=messages)
-
-            if guardrail_result.activated:
-                guardrail.target.activate_target(self)
-                return f"{guardrail.activation_message}\nJustification: {guardrail_result.justification}"
+        if guardrail_result := agent.run_input_guardrails(messages):
+            guardrail_result.guardrail.target.activate_target(self)
+            return guardrail_result.reply
         return None
 
-    def _run_output_guardrails(self, agent: "ConversableAgent", reply: str) -> None:
+    def _run_output_guardrails(self, agent: "ConversableAgent", reply: str | dict[str, Any]) -> str | None:
         """Run output guardrails for an agent after the reply is generated.
 
         Args:
             agent (ConversableAgent): The agent whose output guardrails to run.
-            reply (str): The reply generated by the agent.
+            reply (str | dict[str, Any]): The reply generated by the agent.
         """
-        for guardrail in agent.output_guardrails:
-            guardrail_result = guardrail.check(context=reply)
-
-            if guardrail_result.activated:
-                guardrail.target.activate_target(self)
-                return f"{guardrail.activation_message}\nJustification: {guardrail_result.justification}"
+        if guardrail_result := agent.run_output_guardrails(reply):
+            guardrail_result.guardrail.target.activate_target(self)
+            return guardrail_result.reply
         return None
 
     def _run_inter_agent_guardrails(
@@ -1303,13 +1295,16 @@ class GroupChatManager(ConversableAgent):
                     reply = guardrails_reply
 
             # check for "clear history" phrase in reply and activate clear history function if found
-            if (
-                groupchat.enable_clear_history
-                and isinstance(reply, dict)
-                and reply["content"]
-                and "CLEAR HISTORY" in reply["content"].upper()
-            ):
-                reply["content"] = self.clear_agents_history(reply, groupchat)
+            if groupchat.enable_clear_history and isinstance(reply, dict) and reply.get("content"):
+                raw_content = reply.get("content")
+                normalized_content = (
+                    content_str(raw_content)
+                    if isinstance(raw_content, (str, list)) or raw_content is None
+                    else str(raw_content)
+                )
+                if "CLEAR HISTORY" in normalized_content.upper():
+                    reply["content"] = normalized_content
+                    reply["content"] = self.clear_agents_history(reply, groupchat)
 
             # The speaker sends the message without requesting a reply
             speaker.send(reply, self, request_reply=False, silent=silent)
@@ -1420,13 +1415,16 @@ class GroupChatManager(ConversableAgent):
                     reply = guardrails_reply
 
             # check for "clear history" phrase in reply and activate clear history function if found
-            if (
-                groupchat.enable_clear_history
-                and isinstance(reply, dict)
-                and reply["content"]
-                and "CLEAR HISTORY" in reply["content"].upper()
-            ):
-                reply["content"] = self.clear_agents_history(reply, groupchat)
+            if groupchat.enable_clear_history and isinstance(reply, dict) and reply.get("content"):
+                raw_content = reply.get("content")
+                normalized_content = (
+                    content_str(raw_content)
+                    if isinstance(raw_content, (str, list)) or raw_content is None
+                    else str(raw_content)
+                )
+                if "CLEAR HISTORY" in normalized_content.upper():
+                    reply["content"] = normalized_content
+                    reply["content"] = self.clear_agents_history(reply, groupchat)
 
             # The speaker sends the message without requesting a reply
             await speaker.a_send(reply, self, request_reply=False, silent=silent)
@@ -1701,7 +1699,13 @@ class GroupChatManager(ConversableAgent):
             _remove_termination_string = remove_termination_string
 
         if _remove_termination_string and messages[-1].get("content"):
-            messages[-1]["content"] = _remove_termination_string(messages[-1]["content"])
+            content_value = messages[-1]["content"]
+            if isinstance(content_value, str):
+                messages[-1]["content"] = _remove_termination_string(content_value)
+            elif isinstance(content_value, list):
+                messages[-1]["content"] = _remove_termination_string(content_str(content_value))
+            else:
+                messages[-1]["content"] = _remove_termination_string(str(content_value))
 
         # Check if the last message meets termination (if it has one)
         if self._is_termination_msg and self._is_termination_msg(last_message):
@@ -1764,7 +1768,15 @@ class GroupChatManager(ConversableAgent):
         """
         iostream = IOStream.get_default()
 
-        reply_content = reply["content"]
+        raw_reply_content = reply.get("content")
+        if isinstance(raw_reply_content, str):
+            reply_content = raw_reply_content
+        elif isinstance(raw_reply_content, (list, type(None))):
+            reply_content = content_str(raw_reply_content)
+            reply["content"] = reply_content
+        else:
+            reply_content = str(raw_reply_content)
+            reply["content"] = reply_content
         # Split the reply into words
         words = reply_content.split()
         # Find the position of "clear" to determine where to start processing

autogen/agentchat/realtime/experimental/realtime_swarm.py

@@ -185,7 +185,6 @@ class SwarmableAgent(Agent):
         self,
         messages: list[dict[str, Any]] | None = None,
         sender: Optional["Agent"] = None,
-        **kwargs: Any,
     ) -> str | dict[str, Any] | None:
         if messages is None:
             if sender is None:
@@ -242,9 +241,8 @@ class SwarmableAgent(Agent):
         self,
         messages: list[dict[str, Any]] | None = None,
         sender: Optional["Agent"] = None,
-        **kwargs: Any,
     ) -> str | dict[str, Any] | None:
-        return self.generate_reply(messages=messages, sender=sender, **kwargs)
+        return self.generate_reply(messages=messages, sender=sender)
 
     async def a_receive(
         self,

autogen/interop/pydantic_ai/pydantic_ai.py

@@ -78,7 +78,7 @@ class PydanticAIInteroperability:
                     result = f(**kwargs)  # type: ignore[call-arg]
             except Exception as e:
                 if ctx_typed is not None:
-                    ctx_typed.retries[tool_typed.name] += 1
+                    ctx_typed.retries[tool_typed.name] = ctx_typed.retries.get(tool_typed.name, 0) + 1
                 raise e
 
             return result

autogen/llm_config/client.py

@@ -4,6 +4,7 @@
 #
 # Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
 # SPDX-License-Identifier: MIT
+from collections.abc import Sequence
 from typing import Any, Protocol
 
 from ..doc_utils import export_module
@@ -31,11 +32,11 @@ class ModelClient(Protocol):
     class ModelClientResponseProtocol(Protocol):
         class Choice(Protocol):
             class Message(Protocol):
-                content: str | dict[str, Any]
+                content: str | dict[str, Any] | list[dict[str, Any]]
 
             message: Message
 
-        choices: list[Choice]
+        choices: Sequence[Choice]
         model: str
 
     def create(self, params: dict[str, Any]) -> ModelClientResponseProtocol: ...  # pragma: no cover

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

@@ -20,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
@@ -30,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
@@ -365,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:
@@ -637,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)
@@ -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:

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:

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)
 

autogen/remote/__init__.py

@@ -0,0 +1,18 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+try:
+    import httpx  # noqa: F401
+except ImportError as e:
+    raise ImportError("httpx is not installed. Please install it with:\npip install httpx") from e
+
+from .agent import HTTPRemoteAgent
+from .httpx_client_factory import HttpxClientFactory
+from .runtime import HTTPAgentBus
+
+__all__ = (
+    "HTTPAgentBus",
+    "HTTPRemoteAgent",
+    "HttpxClientFactory",
+)

autogen/remote/agent.py

@@ -0,0 +1,199 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from typing import Any
+
+import httpx
+
+from autogen import ConversableAgent
+from autogen.agentchat.group import ContextVariables
+from autogen.oai.client import OpenAIWrapper
+
+from .errors import RemoteAgentError, RemoteAgentNotFoundError
+from .httpx_client_factory import ClientFactory, EmptyClientFactory
+from .protocol import RequestMessage, ResponseMessage
+from .retry import NoRetryPolicy, RetryPolicy
+
+
+class HTTPRemoteAgent(ConversableAgent):
+    """A remote agent that communicates with other agents via HTTP long-polling.
+
+    This agent forwards messages to a remote endpoint and handles the response
+    through HTTP requests. It supports both synchronous and asynchronous operations.
+
+    Example:
+        >>> remote_agent = HTTPRemoteAgent(url="http://api.example.com/agents", name="my_remote_agent")
+    """
+
+    def __init__(
+        self,
+        url: str,
+        name: str,
+        *,
+        silent: bool = False,
+        client: ClientFactory | None = None,
+        retry_policy: RetryPolicy | None = None,
+    ) -> None:
+        """Initialize the HTTPRemoteAgent.
+
+        Args:
+            url (str): The base URL of the remote agent service.
+            name (str): The name of this agent.
+            silent (bool): If True, suppresses logging output.
+            client (ClientFactory | None): HTTP client factory. If None, uses EmptyClientFactory.
+            retry_policy (RetryPolicy | None): Retry policy for HTTP requests. If None, uses NoRetryPolicy.
+        """
+
+        self.url = url
+        self.retry_policy: RetryPolicy = retry_policy or NoRetryPolicy
+
+        self._httpx_client_factory = client or EmptyClientFactory()
+
+        super().__init__(name, silent=silent)
+
+        self.__llm_config: dict[str, Any] = {}
+
+        self.replace_reply_func(
+            ConversableAgent.generate_oai_reply,
+            HTTPRemoteAgent.generate_remote_reply,
+        )
+        self.replace_reply_func(
+            ConversableAgent.a_generate_oai_reply,
+            HTTPRemoteAgent.a_generate_remote_reply,
+        )
+
+    def generate_remote_reply(
+        self,
+        messages: list[dict[str, Any]] | None = None,
+        sender: ConversableAgent | None = None,
+        config: OpenAIWrapper | None = None,
+    ) -> tuple[bool, dict[str, Any] | None]:
+        if messages is None:
+            messages = self._oai_messages[sender]
+
+        retry_policy = self.retry_policy()
+
+        task_id: Any = None
+        with self._httpx_client_factory.make_sync() as client:
+            while True:
+                with retry_policy:
+                    if task_id is None:
+                        # initiate remote procedure
+                        task_id = self._process_create_remote_task_response(
+                            client.post(
+                                f"{self.url}/{self.name}",
+                                content=RequestMessage(
+                                    messages=messages,
+                                    context=self.context_variables.data,
+                                    client_tools=self.__llm_config.get("tools", []),
+                                ).model_dump_json(),
+                            )
+                        )
+
+                    reply_response = client.get(f"{self.url}/{self.name}/{task_id}")
+
+                    if reply_response.status_code in (200, 204):  # valid answer codes
+                        break
+
+                    if reply_response.status_code == 425:  # task still in progress
+                        continue
+
+                    if reply_response.status_code == 404:
+                        task_id = None  # recreate task due remote agent lost it
+                        continue
+
+                    raise RemoteAgentError(f"Remote client error: {reply_response}, {reply_response.content!r}")
+
+        if reply := self._process_remote_reply(reply_response):
+            if sender:
+                context_variables = ContextVariables(reply.context)
+                sender.context_variables.update(context_variables.to_dict())
+            # TODO: support multiple messages response for remote chat history
+            return True, reply.messages[-1]
+
+        return True, None
+
+    async def a_generate_remote_reply(
+        self,
+        messages: list[dict[str, Any]] | None = None,
+        sender: ConversableAgent | None = None,
+        config: OpenAIWrapper | None = None,
+    ) -> tuple[bool, dict[str, Any] | None]:
+        if messages is None:
+            messages = self._oai_messages[sender]
+
+        retry_policy = self.retry_policy()
+
+        task_id: Any = None
+        async with self._httpx_client_factory() as client:
+            while True:
+                with retry_policy:
+                    if task_id is None:
+                        # initiate remote procedure
+                        task_id = self._process_create_remote_task_response(
+                            await client.post(
+                                f"{self.url}/{self.name}",
+                                content=RequestMessage(
+                                    messages=messages,
+                                    context=self.context_variables.data,
+                                    client_tools=self.__llm_config.get("tools", []),
+                                ).model_dump_json(),
+                            )
+                        )
+
+                    reply_response = await client.get(f"{self.url}/{self.name}/{task_id}")
+
+                    if reply_response.status_code in (200, 204):  # valid answer codes
+                        break
+
+                    if reply_response.status_code == 425:  # task still in progress
+                        continue
+
+                    if reply_response.status_code == 404:
+                        task_id = None  # recreate task due remote agent lost it
+                        continue
+
+                    raise RemoteAgentError(f"Remote client error: {reply_response}, {reply_response.content!r}")
+
+        if reply := self._process_remote_reply(reply_response):
+            if sender:
+                context_variables = ContextVariables(reply.context)
+                sender.context_variables.update(context_variables.to_dict())
+            # TODO: support multiple messages response for remote chat history
+            return True, reply.messages[-1]
+
+        return True, None
+
+    def _process_create_remote_task_response(self, response: httpx.Response) -> Any:
+        if response.status_code == 404:
+            raise RemoteAgentNotFoundError(self.name)
+
+        if response.status_code != 202:
+            raise RemoteAgentError(f"Remote client error: {response}, {response.content!r}")
+
+        return response.json()
+
+    def _process_remote_reply(self, reply_response: httpx.Response) -> ResponseMessage | None:
+        if reply_response.status_code == 204:
+            return None
+
+        try:
+            serialized_message = ResponseMessage.model_validate_json(reply_response.content)
+
+        except Exception as e:
+            raise RemoteAgentError(f"Remote client error: {reply_response}, {reply_response.content!r}") from e
+
+        return serialized_message
+
+    def update_tool_signature(
+        self,
+        tool_sig: str | dict[str, Any],
+        is_remove: bool,
+        silent_override: bool = False,
+    ) -> None:
+        self.__llm_config = self._update_tool_config(
+            self.__llm_config,
+            tool_sig=tool_sig,
+            is_remove=is_remove,
+            silent_override=silent_override,
+        )