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

autogen/a2a/errors.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
+
+
+from autogen.remote.errors import RemoteAgentError, RemoteAgentNotFoundError
+
+
+class A2aClientError(RemoteAgentError):
+    """Base class for A2A agent errors"""
+
+    pass
+
+
+class A2aAgentNotFoundError(A2aClientError, RemoteAgentNotFoundError):
+    """Raised when a A2A agent is not found"""
+
+    pass

autogen/a2a/httpx_client_factory.py

@@ -0,0 +1,79 @@
+# 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 a2a.types import AgentCapabilities, AgentCard, DataPart, Message, Part, Role, SendMessageSuccessResponse, TextPart
+from a2a.utils.constants import AGENT_CARD_WELL_KNOWN_PATH, EXTENDED_AGENT_CARD_PATH, PREV_AGENT_CARD_WELL_KNOWN_PATH
+from httpx import MockTransport, Request, Response
+
+from autogen.doc_utils import export_module
+from autogen.remote.httpx_client_factory import HttpxClientFactory
+
+
+@export_module("autogen.a2a")
+def MockClient(  # noqa: N802
+    response_message: str | dict[str, Any] | TextPart | DataPart | Part,
+) -> HttpxClientFactory:
+    """Create a mock HTTP client for testing A2A agent interactions.
+
+    This function creates a mock HTTP client that simulates responses from an A2A agent server.
+    It handles both agent card requests and message sending requests with configurable responses.
+
+    Args:
+        response_message: The message to return in response to SendMessage requests.
+
+    Returns:
+        An HttpxClientFactory configured with a mock transport that handles requests
+        to agent card endpoints and message sending endpoints.
+
+    Example:
+        >>> client = MockClient("Hello, world!")
+        >>> agent = A2aRemoteAgent(name="remote", url="http://fake", client=client)
+    """
+    if isinstance(response_message, Part):
+        parts = [response_message]
+    elif isinstance(response_message, (DataPart, TextPart)):
+        parts = [Part(root=response_message)]
+    elif isinstance(response_message, str):
+        parts = [Part(root=DataPart(data={"role": "assistant", "content": response_message}))]
+    elif isinstance(response_message, dict):
+        parts = [Part(root=DataPart(data={"role": "assistant", **response_message}))]
+    else:
+        raise ValueError(f"Invalid message type: {type(response_message)}")
+
+    async def mock_handler(request: Request) -> Response:
+        if (
+            request.url.path == AGENT_CARD_WELL_KNOWN_PATH
+            or request.url.path == EXTENDED_AGENT_CARD_PATH
+            or request.url.path == PREV_AGENT_CARD_WELL_KNOWN_PATH
+        ):
+            return Response(
+                status_code=200,
+                content=AgentCard(
+                    capabilities=AgentCapabilities(streaming=False),
+                    default_input_modes=["text"],
+                    default_output_modes=["text"],
+                    name="mock_agent",
+                    description="mock_agent",
+                    url="http://localhost:8000",
+                    supports_authenticated_extended_card=False,
+                    version="0.1.0",
+                    skills=[],
+                ).model_dump_json(),
+            )
+
+        return Response(
+            status_code=200,
+            content=SendMessageSuccessResponse(
+                result=Message(
+                    message_id=str(uuid4()),
+                    role=Role.agent,
+                    parts=parts,
+                ),
+            ).model_dump_json(),
+        )
+
+    return HttpxClientFactory(transport=MockTransport(handler=mock_handler))

autogen/a2a/server.py

@@ -0,0 +1,221 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import warnings
+from collections.abc import Callable
+from typing import TYPE_CHECKING
+
+from a2a.server.request_handlers import DefaultRequestHandler
+from a2a.server.tasks import InMemoryTaskStore
+from a2a.types import AgentCapabilities, AgentCard, AgentSkill
+from pydantic import Field
+
+from autogen import ConversableAgent
+from autogen.doc_utils import export_module
+
+from .agent_executor import AutogenAgentExecutor
+
+if TYPE_CHECKING:
+    from a2a.server.agent_execution import RequestContextBuilder
+    from a2a.server.apps import CallContextBuilder
+    from a2a.server.context import ServerCallContext
+    from a2a.server.events import QueueManager
+    from a2a.server.request_handlers import RequestHandler
+    from a2a.server.tasks import PushNotificationConfigStore, PushNotificationSender, TaskStore
+    from starlette.applications import Starlette
+
+    from autogen import ConversableAgent
+
+
+@export_module("autogen.a2a")
+class CardSettings(AgentCard):
+    """Original A2A AgentCard object inheritor making some fields optional."""
+
+    name: str | None = None  # type: ignore[assignment]
+    """
+    A human-readable name for the agent. Uses original agent name if not set.
+    """
+
+    description: str | None = None  # type: ignore[assignment]
+    """
+    A human-readable description of the agent, assisting users and other agents
+    in understanding its purpose. Uses original agent description if not set.
+    """
+
+    url: str | None = None  # type: ignore[assignment]
+    """
+    The preferred endpoint URL for interacting with the agent.
+    This URL MUST support the transport specified by 'preferredTransport'.
+    Uses original A2aAgentServer url if not set.
+    """
+
+    version: str = "0.1.0"
+    """
+    The agent's own version number. The format is defined by the provider.
+    """
+
+    default_input_modes: list[str] = Field(default_factory=lambda: ["text"])
+    """
+    Default set of supported input MIME types for all skills, which can be
+    overridden on a per-skill basis.
+    """
+
+    default_output_modes: list[str] = Field(default_factory=lambda: ["text"])
+    """
+    Default set of supported output MIME types for all skills, which can be
+    overridden on a per-skill basis.
+    """
+
+    capabilities: AgentCapabilities = Field(default_factory=lambda: AgentCapabilities(streaming=True))
+    """
+    A declaration of optional capabilities supported by the agent.
+    """
+
+    skills: list[AgentSkill] = Field(default_factory=list)
+    """
+    The set of skills, or distinct capabilities, that the agent can perform.
+    """
+
+
+@export_module("autogen.a2a")
+class A2aAgentServer:
+    """A server wrapper for running an AG2 agent via the A2A protocol.
+
+    This class provides functionality to wrap an AG2 ConversableAgent into an A2A server
+    that can be used to interact with the agent through A2A requests.
+    """
+
+    def __init__(
+        self,
+        agent: "ConversableAgent",
+        *,
+        url: str | None = "http://localhost:8000",
+        agent_card: CardSettings | None = None,
+        card_modifier: Callable[["AgentCard"], "AgentCard"] | None = None,
+        extended_agent_card: CardSettings | None = None,
+        extended_card_modifier: Callable[["AgentCard", "ServerCallContext"], "AgentCard"] | None = None,
+    ) -> None:
+        """Initialize the A2aAgentServer.
+
+        Args:
+            agent: The Autogen ConversableAgent to serve.
+            url: The base URL for the A2A server.
+            agent_card: Configuration for the base agent card.
+            card_modifier: Function to modify the base agent card.
+            extended_agent_card: Configuration for the extended agent card.
+            extended_card_modifier: Function to modify the extended agent card.
+        """
+        self.agent = agent
+
+        if not agent_card:
+            agent_card = CardSettings()
+
+        if agent_card.url and url != "http://localhost:8000":
+            warnings.warn(
+                (
+                    "You can't use `agent_card.url` and `url` options in the same time. "
+                    f"`agent_card.url` has a higher priority, so `{agent_card.url}` will be used."
+                ),
+                RuntimeWarning,
+                stacklevel=2,
+            )
+
+        self.card = AgentCard.model_validate({
+            # use agent options by default
+            "name": agent.name,
+            "description": agent.description,
+            "url": url,
+            "supports_authenticated_extended_card": extended_agent_card is not None,
+            # exclude name and description if not provided
+            **agent_card.model_dump(exclude_none=True),
+        })
+
+        self.extended_agent_card: AgentCard | None = None
+        if extended_agent_card:
+            if extended_agent_card.url and url != "http://localhost:8000":
+                warnings.warn(
+                    (
+                        "You can't use `extended_agent_card.url` and `url` options in the same time. "
+                        f"`agent_card.url` has a higher priority, so `{extended_agent_card.url}` will be used."
+                    ),
+                    RuntimeWarning,
+                    stacklevel=2,
+                )
+
+            self.extended_agent_card = AgentCard.model_validate({
+                "name": agent.name,
+                "description": agent.description,
+                "url": url,
+                **extended_agent_card.model_dump(exclude_none=True),
+            })
+
+        self.card_modifier = card_modifier
+        self.extended_card_modifier = extended_card_modifier
+
+    @property
+    def executor(self) -> AutogenAgentExecutor:
+        """Get the A2A agent executor."""
+        return AutogenAgentExecutor(self.agent)
+
+    def build_request_handler(
+        self,
+        *,
+        task_store: "TaskStore | None" = None,
+        queue_manager: "QueueManager | None" = None,
+        push_config_store: "PushNotificationConfigStore | None" = None,
+        push_sender: "PushNotificationSender | None" = None,
+        request_context_builder: "RequestContextBuilder | None" = None,
+    ) -> "RequestHandler":
+        """Build a request handler for A2A application.
+
+        Args:
+            task_store: The task store to use.
+            queue_manager: The queue manager to use.
+            push_config_store: The push notification config store to use.
+            push_sender: The push notification sender to use.
+            request_context_builder: The request context builder to use.
+
+        Returns:
+            A configured RequestHandler instance.
+        """
+        return DefaultRequestHandler(
+            agent_executor=self.executor,
+            task_store=task_store or InMemoryTaskStore(),
+            queue_manager=queue_manager,
+            push_config_store=push_config_store,
+            push_sender=push_sender,
+            request_context_builder=request_context_builder,
+        )
+
+    def build_starlette_app(
+        self,
+        *,
+        request_handler: "RequestHandler | None" = None,
+        context_builder: "CallContextBuilder | None" = None,
+    ) -> "Starlette":
+        """Build a Starlette A2A application for ASGI server.
+
+        Args:
+            request_handler: The request handler to use.
+            context_builder: The context builder to use.
+
+        Returns:
+            A configured Starlette application instance.
+        """
+        from a2a.server.apps import A2AStarletteApplication
+
+        return A2AStarletteApplication(
+            agent_card=self.card,
+            extended_agent_card=self.extended_agent_card,
+            http_handler=request_handler
+            or DefaultRequestHandler(
+                agent_executor=self.executor,
+                task_store=InMemoryTaskStore(),
+            ),
+            context_builder=context_builder,
+            card_modifier=self.card_modifier,
+            extended_card_modifier=self.extended_card_modifier,
+        ).build()
+
+    build = build_starlette_app  # default alias for build_starlette_app

autogen/a2a/utils.py

@@ -0,0 +1,165 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, cast
+from uuid import uuid4
+
+from a2a.types import Artifact, DataPart, Message, Part, Role, TextPart
+from a2a.utils import new_agent_parts_message, new_artifact
+
+from autogen.remote.protocol import RequestMessage, ResponseMessage
+
+CLIENT_TOOLS_KEY = "ag2_client_tools"
+CONTEXT_KEY = "ag2_context_update"
+
+
+def request_message_to_a2a(
+    request_message: RequestMessage,
+    context_id: str,
+) -> Message:
+    metadata: dict[str, Any] = {}
+    if request_message.client_tools:
+        metadata[CLIENT_TOOLS_KEY] = request_message.client_tools
+    if request_message.context:
+        metadata[CONTEXT_KEY] = request_message.context
+
+    return Message(
+        role=Role.user,
+        parts=[message_to_part(message) for message in request_message.messages],
+        message_id=uuid4().hex,
+        context_id=context_id,
+        metadata=metadata,
+    )
+
+
+def request_message_from_a2a(message: Message) -> RequestMessage:
+    metadata = message.metadata or {}
+    return RequestMessage(
+        messages=[message_from_part(part) for part in message.parts],
+        context=metadata.get(CONTEXT_KEY),
+        client_tools=metadata.get(CLIENT_TOOLS_KEY, []),
+    )
+
+
+def response_message_from_a2a_artifacts(artifacts: list[Artifact] | None) -> ResponseMessage | None:
+    if not artifacts:
+        return None
+
+    if len(artifacts) > 1:
+        raise NotImplementedError("Multiple artifacts are not supported")
+
+    artifact = artifacts[-1]
+
+    if not artifact.parts:
+        return None
+
+    if len(artifact.parts) > 1:
+        raise NotImplementedError("Multiple parts are not supported")
+
+    return ResponseMessage(
+        messages=[message_from_part(artifact.parts[-1])],
+        context=(artifact.metadata or {}).get(CONTEXT_KEY),
+    )
+
+
+def response_message_from_a2a_message(message: Message) -> ResponseMessage | None:
+    text_parts: list[Part] = []
+    data_parts: list[Part] = []
+    for part in message.parts:
+        if isinstance(part.root, TextPart):
+            text_parts.append(part)
+        elif isinstance(part.root, DataPart):
+            data_parts.append(part)
+        else:
+            raise NotImplementedError(f"Unsupported part type: {type(part.root)}")
+
+    tpn = len(text_parts)
+    if dpn := len(data_parts):
+        if dpn > 1:
+            raise NotImplementedError("Multiple data parts are not supported")
+
+        if tpn:
+            raise NotImplementedError("Data parts and text parts are not supported together")
+
+        messages = [message_from_part(data_parts[0])]
+    elif tpn == 1:
+        messages = [message_from_part(text_parts[0])]
+    else:
+        messages = [{"content": "\n".join(cast(TextPart, t.root).text for t in text_parts)}]
+
+    return ResponseMessage(
+        messages=messages,
+        context=(message.metadata or {}).get(CONTEXT_KEY),
+    )
+
+
+def response_message_to_a2a(
+    result: ResponseMessage | None,
+    context_id: str | None,
+    task_id: str | None,
+) -> tuple[Artifact, list[Message]]:
+    # mypy ignores could be removed after
+    # https://github.com/a2aproject/a2a-python/pull/503
+
+    if not result:
+        return new_artifact(
+            name="result",
+            parts=[],
+            description=None,  # type: ignore[arg-type]
+        ), []
+
+    artifact = new_artifact(
+        name="result",
+        parts=[message_to_part(result.messages[-1])],
+        description=None,  # type: ignore[arg-type]
+    )
+
+    if result.context:
+        artifact.metadata = {CONTEXT_KEY: result.context}
+
+    return (
+        artifact,
+        [
+            new_agent_parts_message(
+                parts=[message_to_part(m) for m in result.messages],
+                context_id=context_id,
+                task_id=task_id,
+            ),
+        ],
+    )
+
+
+def message_to_part(message: dict[str, Any]) -> Part:
+    message = message.copy()
+    text = message.pop("content", "") or ""
+    return Part(
+        root=TextPart(
+            text=text,
+            metadata=message or None,
+        )
+    )
+
+
+def message_from_part(part: Part) -> dict[str, Any]:
+    root = part.root
+
+    if isinstance(root, TextPart):
+        return {
+            **(root.metadata or {}),
+            "content": root.text,
+        }
+
+    elif isinstance(root, DataPart):
+        if (  # pydantic-ai specific
+            set(root.data.keys()) == {"result"}
+            and root.metadata
+            and "json_schema" in root.metadata
+            and isinstance(data := root.data["result"], dict)
+        ):
+            return data
+
+        return root.data
+
+    else:
+        raise NotImplementedError(f"Unsupported part type: {type(part.root)}")

autogen/agentchat/__init__.py

@@ -15,6 +15,7 @@ from .contrib.swarm_agent import (
     run_swarm,
 )
 from .conversable_agent import ConversableAgent, UpdateSystemMessage, register_function
+from .group import ContextVariables, ReplyResult
 from .group.multi_agent_chat import a_initiate_group_chat, a_run_group_chat, initiate_group_chat, run_group_chat
 from .groupchat import GroupChat, GroupChatManager
 from .user_proxy_agent import UserProxyAgent
@@ -24,10 +25,12 @@ __all__ = [
     "Agent",
     "AssistantAgent",
     "ChatResult",
+    "ContextVariables",
     "ConversableAgent",
     "GroupChat",
     "GroupChatManager",
     "LLMAgent",
+    "ReplyResult",
     "UpdateSystemMessage",
     "UserProxyAgent",
     "a_initiate_chats",

autogen/agentchat/agent.py

@@ -105,7 +105,6 @@ class Agent(Protocol):
         self,
         messages: list[dict[str, Any]] | None = None,
         sender: Optional["Agent"] = None,
-        **kwargs: Any,
     ) -> str | dict[str, Any] | None:
         """Generate a reply based on the received messages.
 
@@ -124,7 +123,6 @@ class Agent(Protocol):
         self,
         messages: list[dict[str, Any]] | None = None,
         sender: Optional["Agent"] = None,
-        **kwargs: Any,
     ) -> str | dict[str, Any] | None:
         """(Async) Generate a reply based on the received messages.
 

autogen/agentchat/chat.py

@@ -14,6 +14,7 @@ from dataclasses import dataclass, field
 from functools import partial
 from typing import Any, TypedDict
 
+from ..code_utils import content_str
 from ..doc_utils import export_module
 from ..events.agent_events import PostCarryoverProcessingEvent
 from ..io.base import IOStream
@@ -132,7 +133,10 @@ def _post_process_carryover_item(carryover_item):
     if isinstance(carryover_item, str):
         return carryover_item
     elif isinstance(carryover_item, dict) and "content" in carryover_item:
-        return str(carryover_item["content"])
+        content_value = carryover_item.get("content")
+        if isinstance(content_value, (str, list)) or content_value is None:
+            return content_str(content_value)
+        return str(content_value)
     else:
         return str(carryover_item)
 

autogen/agentchat/contrib/llava_agent.py

@@ -6,7 +6,6 @@
 # SPDX-License-Identifier: MIT
 import json
 import logging
-import warnings
 from typing import Any
 
 import requests
@@ -85,18 +84,7 @@ class LLaVAAgent(MultimodalConversableAgent):
         retry = 10
         while len(out) == 0 and retry > 0:
             # image names will be inferred automatically from llava_call
-            if "max_new_tokens" in self.llm_config:
-                warnings.warn(
-                    (
-                        "`max_new_tokens` is deprecated in `llm_config` for llava agents. "
-                        "Use `max_tokens` instead. "
-                        "Scheduled for removal in 0.10.0 version."
-                    ),
-                    DeprecationWarning,
-                )
-                max_tokens = self.llm_config["max_new_tokens"]
-            else:
-                max_tokens = self.llm_config.get("max_tokens")
+            max_tokens = self.llm_config.get("max_tokens")
 
             out = llava_call_binary(
                 prompt=prompt,