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

autogen/remote/httpx_client_factory.py

@@ -0,0 +1,131 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import ssl
+import typing
+from typing import Protocol
+
+from httpx._client import AsyncClient, Client, EventHook
+from httpx._config import DEFAULT_LIMITS, DEFAULT_MAX_REDIRECTS, DEFAULT_TIMEOUT_CONFIG, Limits
+from httpx._transports.base import AsyncBaseTransport
+from httpx._types import AuthTypes, CertTypes, CookieTypes, HeaderTypes, ProxyTypes, QueryParamTypes, TimeoutTypes
+from httpx._urls import URL
+
+from autogen.doc_utils import export_module
+
+
+class ClientFactory(Protocol):
+    def __call__(self) -> AsyncClient: ...
+
+    def make_sync(self) -> Client: ...
+
+
+@export_module("autogen.a2a")
+class HttpxClientFactory(ClientFactory):
+    """
+    An asynchronous HTTP client factory, with connection pooling, HTTP/2, redirects,
+    cookie persistence, etc.
+
+    It can be shared between tasks.
+
+    Usage:
+
+    ```python
+    >>> factory = HttpxClientFactory()
+    >>> async with factory() as client:
+    >>>     response = await client.get('https://example.org')
+    ```
+
+    **Parameters:**
+
+    * **auth** - *(optional)* An authentication class to use when sending
+    requests.
+    * **params** - *(optional)* Query parameters to include in request URLs, as
+    a string, dictionary, or sequence of two-tuples.
+    * **headers** - *(optional)* Dictionary of HTTP headers to include when
+    sending requests.
+    * **cookies** - *(optional)* Dictionary of Cookie items to include when
+    sending requests.
+    * **verify** - *(optional)* Either `True` to use an SSL context with the
+    default CA bundle, `False` to disable verification, or an instance of
+    `ssl.SSLContext` to use a custom context.
+    * **http2** - *(optional)* A boolean indicating if HTTP/2 support should be
+    enabled. Defaults to `False`.
+    * **proxy** - *(optional)* A proxy URL where all the traffic should be routed.
+    * **timeout** - *(optional)* The timeout configuration to use when sending
+    requests.
+    * **limits** - *(optional)* The limits configuration to use.
+    * **max_redirects** - *(optional)* The maximum number of redirect responses
+    that should be followed.
+    * **base_url** - *(optional)* A URL to use as the base when building
+    request URLs.
+    * **transport** - *(optional)* A transport class to use for sending requests
+    over the network.
+    * **trust_env** - *(optional)* Enables or disables usage of environment
+    variables for configuration.
+    * **default_encoding** - *(optional)* The default encoding to use for decoding
+    response text, if no charset information is included in a response Content-Type
+    header. Set to a callable for automatic character set detection. Default: "utf-8".
+    """
+
+    def __init__(
+        self,
+        *,
+        auth: AuthTypes | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        http1: bool = True,
+        http2: bool = False,
+        proxy: ProxyTypes | None = None,
+        mounts: None | (typing.Mapping[str, AsyncBaseTransport | None]) = None,
+        timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+        follow_redirects: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        max_redirects: int = DEFAULT_MAX_REDIRECTS,
+        event_hooks: None | (typing.Mapping[str, list[EventHook]]) = None,
+        base_url: URL | str = "",
+        transport: AsyncBaseTransport | None = None,
+        trust_env: bool = True,
+        default_encoding: str | typing.Callable[[bytes], str] = "utf-8",
+        **kwargs: typing.Any,
+    ) -> None:
+        self.options = {
+            "auth": auth,
+            "params": params,
+            "headers": headers,
+            "cookies": cookies,
+            "verify": verify,
+            "cert": cert,
+            "http1": http1,
+            "http2": http2,
+            "proxy": proxy,
+            "mounts": mounts,
+            "timeout": timeout,
+            "follow_redirects": follow_redirects,
+            "limits": limits,
+            "max_redirects": max_redirects,
+            "event_hooks": event_hooks,
+            "base_url": base_url,
+            "transport": transport,
+            "trust_env": trust_env,
+            "default_encoding": default_encoding,
+            **kwargs,
+        }
+
+    def __call__(self) -> AsyncClient:
+        return AsyncClient(**self.options)
+
+    def make_sync(self) -> Client:
+        return Client(**self.options)
+
+
+class EmptyClientFactory(ClientFactory):
+    def __call__(self) -> AsyncClient:
+        return AsyncClient(timeout=30.0)
+
+    def make_sync(self) -> Client:
+        return Client(timeout=30.0)

autogen/remote/protocol.py

@@ -0,0 +1,37 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from typing import Any, Protocol
+
+from pydantic import BaseModel, Field
+
+
+class AgentBusMessage(BaseModel):
+    messages: list[dict[str, Any]]
+    context: dict[str, Any] | None = None
+
+
+class RequestMessage(AgentBusMessage):
+    client_tools: list[dict[str, Any]] = Field(default_factory=list)
+
+    @property
+    def client_tool_names(self) -> set[str]:
+        return get_tool_names(self.client_tools)
+
+
+class ResponseMessage(AgentBusMessage):
+    pass
+
+
+class RemoteService(Protocol):
+    """Interface to make AgentBus compatible with non AG2 systems."""
+
+    name: str
+
+    async def __call__(self, state: RequestMessage) -> ResponseMessage | None:
+        """Executable that consumes Conversation State and returns a new state."""
+        ...
+
+
+def get_tool_names(tools: list[dict[str, Any]]) -> set[str]:
+    return set(filter(bool, (tool.get("function", {}).get("name", "") for tool in tools)))

autogen/remote/retry.py

@@ -0,0 +1,102 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+import time
+from types import TracebackType
+from typing import Protocol
+
+import anyio
+
+
+class RetryPolicyManager(Protocol):
+    def __enter__(self) -> None:
+        pass
+
+    async def __aenter__(self) -> None:
+        pass
+
+    def __exit__(
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
+    ) -> None | bool:
+        pass
+
+    async def __aexit__(
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, traceback: TracebackType | None
+    ) -> None | bool:
+        pass
+
+
+class RetryPolicy(Protocol):
+    def __call__(self) -> RetryPolicyManager: ...
+
+
+class SleepRetryPolicy(RetryPolicy):
+    def __init__(self, retry_interval: float = 10.0, retry_count: int = 3) -> None:
+        self.retry_interval = retry_interval
+        self.retry_count = retry_count
+
+    def __call__(self) -> RetryPolicyManager:
+        return _SleepRetryPolicy(self.retry_interval, self.retry_count)
+
+
+class _SleepRetryPolicy(RetryPolicyManager):
+    def __init__(self, retry_interval: float = 10.0, retry_count: int = 3) -> None:
+        self.retry_interval = retry_interval
+        self.retry_count = retry_count
+        self.errors_count = 0
+
+    def __enter__(self) -> None:
+        pass
+
+    async def __aenter__(self) -> None:
+        pass
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None | bool:
+        if exc_type is not None:
+            self.errors_count += 1
+            should_suppress = self.errors_count < self.retry_count
+            time.sleep(self.retry_interval)
+            return should_suppress
+        return None
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None | bool:
+        if exc_type is not None:
+            self.errors_count += 1
+            should_suppress = self.errors_count < self.retry_count
+            await anyio.sleep(self.retry_interval)
+            return should_suppress
+        return None
+
+
+class NoRetryPolicy(RetryPolicyManager):
+    def __enter__(self) -> None:
+        pass
+
+    async def __aenter__(self) -> None:
+        pass
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None | bool:
+        pass
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None | bool:
+        pass

autogen/remote/runtime.py

@@ -0,0 +1,96 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import asyncio
+from collections.abc import Awaitable, Callable, Iterable, MutableMapping
+from itertools import chain
+from typing import Any
+from uuid import UUID, uuid4
+
+from fastapi import FastAPI, HTTPException, Response, status
+
+from autogen.agentchat import ConversableAgent
+
+from .agent_service import AgentService
+from .protocol import RemoteService, RequestMessage, ResponseMessage
+
+
+class HTTPAgentBus:
+    def __init__(
+        self,
+        agents: Iterable[ConversableAgent] = (),
+        *,
+        long_polling_interval: float = 10.0,
+        additional_services: Iterable[RemoteService] = (),
+    ) -> None:
+        """Create HTTPAgentBus runtime.
+
+        Makes the passed agents capable of processing remote calls.
+
+        Args:
+            agents: Agents to register as remote services.
+            long_polling_interval: Timeout to respond on task status calls for long-living executions.
+                Should be less than clients' HTTP request timeout.
+            additional_services: Additional services to register.
+        """
+        self.app = FastAPI()
+
+        for service in chain(map(AgentService, agents), additional_services):
+            register_agent_endpoints(
+                app=self.app,
+                service=service,
+                long_polling_interval=long_polling_interval,
+            )
+
+    async def __call__(
+        self,
+        scope: MutableMapping[str, Any],
+        receive: Callable[[], Awaitable[MutableMapping[str, Any]]],
+        send: Callable[[MutableMapping[str, Any]], Awaitable[None]],
+    ) -> None:
+        """ASGI interface."""
+        await self.app(scope, receive, send)
+
+
+def register_agent_endpoints(
+    app: FastAPI,
+    service: RemoteService,
+    long_polling_interval: float,
+) -> None:
+    tasks: dict[UUID, asyncio.Task[ResponseMessage | None]] = {}
+
+    @app.get(f"/{service.name}" + "/{task_id}", response_model=ResponseMessage | None)
+    async def remote_call_result(task_id: UUID) -> Response | ResponseMessage | None:
+        if task_id not in tasks:
+            raise HTTPException(
+                detail=f"`{task_id}` task not found",
+                status_code=status.HTTP_404_NOT_FOUND,
+            )
+
+        task = tasks[task_id]
+
+        await asyncio.wait(
+            (task, asyncio.create_task(asyncio.sleep(long_polling_interval))),
+            return_when=asyncio.FIRST_COMPLETED,
+        )
+
+        if not task.done():
+            return Response(status_code=status.HTTP_425_TOO_EARLY)
+
+        try:
+            reply = task.result()  # Task inner errors raising here
+        finally:
+            # TODO: how to clear hanged tasks?
+            tasks.pop(task_id, None)
+
+        if reply is None:
+            return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+        return reply
+
+    @app.post(f"/{service.name}", status_code=status.HTTP_202_ACCEPTED)
+    async def remote_call_starter(state: RequestMessage) -> UUID:
+        task, task_id = asyncio.create_task(service(state)), uuid4()
+        tasks[task_id] = task
+        return task_id

autogen/testing/__init__.py

@@ -0,0 +1,12 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .messages import ToolCall, tools_message
+from .test_agent import TestAgent
+
+__all__ = (
+    "TestAgent",
+    "ToolCall",
+    "tools_message",
+)

autogen/testing/messages.py

@@ -0,0 +1,45 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any
+from uuid import uuid4
+
+from pydantic_core import to_json
+
+from autogen.events.agent_events import FunctionCall
+from autogen.events.agent_events import ToolCall as RawToolCall
+
+
+class ToolCall:
+    """Represents a tool call with a specified tool name and arguments.
+
+    Args:
+        tool_name: Tool name to call. Tool should be rigestered in Agent you send message.
+        arguments: keyword arguments to pass to the tool.
+    """
+
+    def __init__(self, tool_name: str, /, **arguments: Any) -> None:
+        self.tool_message = RawToolCall(
+            id=f"call_{uuid4()}",
+            type="function",
+            function=FunctionCall(name=tool_name, arguments=to_json(arguments).decode()),
+        ).model_dump()
+
+    def to_message(self) -> dict[str, Any]:
+        """Convert the tool call to a message format suitable for API calls.
+
+        Returns:
+            A dictionary containing the tool call in message format,
+            ready to be used in API requests or message queues.
+        """
+        return tools_message(self)
+
+
+def tools_message(*tool_calls: ToolCall) -> dict[str, Any]:
+    """Convert multiple tool calls into a message format suitable for API calls.
+
+    Args:
+        *tool_calls: One or more ToolCall objects to convert.
+    """
+    return {"content": None, "tool_calls": [c.tool_message for c in tool_calls]}

autogen/testing/test_agent.py

@@ -0,0 +1,111 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from collections.abc import Iterable
+from dataclasses import dataclass
+from types import TracebackType
+from typing import Any, TypedDict
+
+from autogen import ConversableAgent, ModelClient
+
+
+class TestAgent:
+    """A context manager for testing ConversableAgent instances with predefined messages.
+
+    This class allows you to temporarily replace an agent's LLM client with a fake client
+    that returns predefined messages. It's useful for testing agent behavior without
+    making actual API calls.
+
+    Attributes:
+        agent (ConversableAgent): The agent to be tested.
+        messages (Iterable[str  |  dict[str, Any]]): An iterable of messages to be returned by the fake client.
+        suppress_messages_end (bool): Whether to suppress StopIteration exceptions from the fake client.
+
+    Example:
+        >>> with TestAgent(agent, ["Hello", "How are you?"]) as test_agent:
+        ...     # Agent will respond with "Hello" then "How are you?"
+        ...     pass
+    """
+
+    def __init__(
+        self,
+        agent: ConversableAgent,
+        messages: Iterable[str | dict[str, Any]] = (),
+        *,
+        suppress_messages_end: bool = False,
+    ) -> None:
+        self.agent = agent
+
+        self.__original_human_input = self.agent.human_input_mode
+
+        self.__original_client = agent.client
+        self.__fake_client = FakeClient(messages)
+
+        self.suppress_messages_end = suppress_messages_end
+
+    def __enter__(self) -> None:
+        self.agent.human_input_mode = "NEVER"
+
+        self.__original_client = self.agent.client
+        self.agent.client = self.__fake_client  # type: ignore[assignment]
+        return None
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None | bool:
+        self.agent.human_input_mode = self.__original_human_input
+
+        self.agent.client = self.__original_client
+
+        if isinstance(exc_value, StopIteration):
+            # suppress fake client iterator ending
+            return self.suppress_messages_end
+        return None
+
+
+class FakeClient:
+    def __init__(self, messages: Iterable[str | dict[str, Any]]) -> None:
+        # do not unpack messages to allow endless generators pass
+        self.choice_iterator = iter(map(convert_fake_message, messages))
+
+        self.total_usage_summary = None
+        self.actual_usage_summary = None
+
+    def create(self, **params: Any) -> ModelClient.ModelClientResponseProtocol:
+        choice = next(self.choice_iterator)
+        return FakeClientResponse(choices=[choice])
+
+    def extract_text_or_completion_object(
+        self,
+        response: "FakeClientResponse",
+    ) -> list[str] | list["FakeMessage"]:
+        return response.message_retrieval_function()
+
+
+def convert_fake_message(message: str | dict[str, Any]) -> "FakeChoice":
+    if isinstance(message, str):
+        return FakeChoice({"content": message})
+    else:
+        return FakeChoice({"role": "assistant", **message})  # type: ignore[typeddict-item]
+
+
+class FakeMessage(TypedDict):
+    content: str | dict[str, Any]
+
+
+@dataclass
+class FakeChoice(ModelClient.ModelClientResponseProtocol.Choice):
+    message: FakeMessage  # type: ignore[assignment]
+
+
+@dataclass
+class FakeClientResponse(ModelClient.ModelClientResponseProtocol):
+    choices: list[FakeChoice]
+    model: str = "fake-model"
+
+    def message_retrieval_function(self) -> list[str] | list[FakeMessage]:
+        return [c.message for c in self.choices]

autogen/tools/dependency_injection.py

@@ -15,6 +15,7 @@ from ..doc_utils import export_module
 from ..fast_depends import Depends as FastDepends
 from ..fast_depends import inject
 from ..fast_depends.dependencies import model
+from ..fast_depends.utils import is_coroutine_callable
 
 if TYPE_CHECKING:
     from ..agentchat.conversable_agent import ConversableAgent
@@ -140,10 +141,7 @@ def remove_params(func: Callable[..., Any], sig: inspect.Signature, params: Iter
 
 
 def _remove_injected_params_from_signature(func: Callable[..., Any]) -> Callable[..., Any]:
-    # This is a workaround for Python 3.9+ where staticmethod.__func__ is accessible
-    if sys.version_info >= (3, 9) and isinstance(func, staticmethod) and hasattr(func, "__func__"):
-        func = _fix_staticmethod(func)
-
+    func = _fix_staticmethod(func)
     sig = inspect.signature(func)
     params_to_remove = [p.name for p in sig.parameters.values() if _is_context_param(p) or _is_depends_param(p)]
     remove_params(func, sig, params_to_remove)
@@ -205,7 +203,7 @@ def _fix_staticmethod(f: Callable[..., Any]) -> Callable[..., Any]:
 
 
 def _set_return_annotation_to_any(f: Callable[..., Any]) -> Callable[..., Any]:
-    if inspect.iscoroutinefunction(f):
+    if is_coroutine_callable(f):
 
         @functools.wraps(f)
         async def _a_wrapped_func(*args: Any, **kwargs: Any) -> Any:
@@ -242,9 +240,7 @@ def inject_params(f: Callable[..., Any]) -> Callable[..., Any]:
         The modified function with injected dependencies and updated signature.
     """
     # This is a workaround for Python 3.9+ where staticmethod.__func__ is accessible
-    if sys.version_info >= (3, 9) and isinstance(f, staticmethod) and hasattr(f, "__func__"):
-        f = _fix_staticmethod(f)
-
+    f = _fix_staticmethod(f)
     f = _string_metadata_to_description_field(f)
     f = _set_return_annotation_to_any(f)
     f = inject(f)

autogen/tools/experimental/reliable/reliable.py

@@ -26,6 +26,7 @@ from ....agentchat.group import AgentTarget, ReplyResult, TerminateTarget
 from ....agentchat.group.context_variables import ContextVariables
 from ....agentchat.group.patterns import DefaultPattern
 from ....doc_utils import export_module
+from ....fast_depends.utils import is_coroutine_callable
 from ....llm_config import LLMConfig
 from ....tools.dependency_injection import Field as AG2Field
 from ....tools.tool import Tool
@@ -375,7 +376,7 @@ def reliable_function_wrapper(
     Adds 'hypothesis' and 'context_variables' keyword-only arguments.
     Returns a ReplyResult targeting the validator.
     """
-    is_original_func_async = inspect.iscoroutinefunction(tool_function)
+    is_original_func_async = is_coroutine_callable(tool_function)
     tool_sig = inspect.signature(tool_function)
     wrapper_func: Callable[..., Any]  # Declare type for wrapper_func
 
@@ -653,7 +654,7 @@ class ReliableTool(Tool):
                 Example: `ground_truth=["The API rate limit is 10 requests per minute.", "User preference: only show results from the last 7 days."]`
         """
         self._original_func, original_name, original_description = self._extract_func_details(func_or_tool)
-        self._is_original_func_async = inspect.iscoroutinefunction(self._original_func)
+        self._is_original_func_async = is_coroutine_callable(self._original_func)
 
         self._runner_llm_config = ConversableAgent._validate_llm_config(runner_llm_config)
         if self._runner_llm_config is False:

autogen/tools/experimental/web_search_preview/web_search_preview.py

@@ -49,7 +49,7 @@ class WebSearchPreviewTool(Tool):
                 The default is `None`, which means the text will be returned as a string.
         """
         self.web_search_tool_param = WebSearchToolParam(
-            type="web_search_preview",
+            type="web_search",
             search_context_size=search_context_size,
             user_location=UserLocation(**user_location) if user_location else None,  # type: ignore[typeddict-item]
         )

autogen/tools/function_utils.py

@@ -17,6 +17,7 @@ from pydantic import __version__ as pydantic_version
 from pydantic.json_schema import JsonSchemaValue
 
 from ..doc_utils import export_module
+from ..fast_depends.utils import is_coroutine_callable
 from .dependency_injection import Field as AG2Field
 
 if parse(pydantic_version) < parse("2.10.2"):
@@ -381,7 +382,7 @@ def load_basemodels_if_needed(func: Callable[..., Any]) -> Callable[..., Any]:
         # call the original function
         return await func(*args, **kwargs)
 
-    if inspect.iscoroutinefunction(func):
+    if is_coroutine_callable(func):
         return _a_load_parameters_if_needed
     else:
         return _load_parameters_if_needed

autogen/version.py

@@ -4,4 +4,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.9.9"
+__version__ = "0.10.0"