refactored function target logic, new FunctionTargetResult and FunctionTargetMessage classes

Author: gabriel-eidelman

autogen/agentchat/group/__init__.py

@@ -14,6 +14,7 @@
 from .on_condition import OnCondition
 from .on_context_condition import OnContextCondition
 from .reply_result import ReplyResult
+from .function_target_result import FunctionTargetResult
 from .speaker_selection_result import SpeakerSelectionResult
 from .targets.group_chat_target import GroupChatConfig, GroupChatTarget
 
@@ -55,6 +56,7 @@
     "OnCondition",
     "OnContextCondition",
     "ReplyResult",
+    "FunctionTargetResult",
     "RevertToUserTarget",
     "SpeakerSelectionResult",
     "StayTarget",

autogen/agentchat/group/function_target_result.py

@@ -0,0 +1,32 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+__all__ = ["FunctionTargetResult"]
+
+
+from pydantic import BaseModel
+from typing import TYPE_CHECKING, Any
+from .context_variables import ContextVariables
+from .targets.transition_target import TransitionTarget
+
+if TYPE_CHECKING:
+    from ..conversable_agent import ConversableAgent
+    class FunctionTargetMessage(BaseModel):
+        content: str
+        msg_target: "ConversableAgent"
+else:
+    class FunctionTargetMessage(BaseModel):
+        content: str
+        msg_target: Any
+
+class FunctionTargetResult(BaseModel):
+    """Result of a function handoff that is used to provide the return message and the target to transition to."""
+    messages: list[FunctionTargetMessage] | str | None = None
+    target: TransitionTarget
+    context_variables: ContextVariables | None = None
+
+    def __str__(self) -> str:
+        """The string representation for FunctionTargetResult will be """
+        # not implemented yet
+        return ""

autogen/agentchat/group/group_utils.py

@@ -16,7 +16,6 @@
 from .targets.transition_target import (
     AgentNameTarget,
     AgentTarget,
-    FunctionTarget,
     TransitionTarget,
 )
 
@@ -114,101 +113,13 @@ def _evaluate_after_works_conditions(
         if is_available and (
             after_work_condition.condition is None or after_work_condition.condition.evaluate(agent.context_variables)
         ):
-            tgt = after_work_condition.target
-
-            # NEW: Inline execution path for FunctionTarget
-            if isinstance(tgt, FunctionTarget):
-                # extract the agent output and context variables to pass in to the FunctionTarget
-                first_input = groupchat.messages[-1]["content"] if groupchat.messages else ""
-                ctx = agent.context_variables
-
-                try:
-                    rr = tgt.fn(first_input, ctx)  # rr: ReplyResult
-                except Exception as e:
-                    from types import SimpleNamespace
-                    rr = SimpleNamespace(message=f"[{tgt.fn_name}] error: {e}", target=None, context_variables=None)
-
-                # 1) merge returned context vars (if your ReplyResult carries them)
-                if getattr(rr, "context_variables", None):
-                    if isinstance(ctx, dict) and isinstance(rr.context_variables, dict):
-                        ctx.update(rr.context_variables)
-
-                # 2) append/broadcast the tool output
-                fn_content = rr.message if getattr(rr, "message", None) is not None else str(rr)
-
-                # send to manager itself for visibility
-                agent._group_manager.send(
-                    {
-                        "role": "assistant",
-                        "name": tgt.fn_name,
-                        "content": f"[{tgt.fn_name}] {fn_content}",
-                    },
-                    agent._group_manager, 
-                    request_reply=False,
-                    silent=True,
-                )
-                # this may not be ideal but system gives more priority to the msg than tool
-                broadcast = {
-                    "role": "system",
-                    "name": tgt.fn_name,
-                    "content": f"""{fn_content}"""
-                }
-                # 3) choose next agent and broadcast based on rr.target or broadcast_recipients parameter if provided
-                # TODO: fix for StayTarget and TerminateTarget
-                next_target = getattr(rr, "target", None)
-                if hasattr(next_target, "agent_name"):
-                    next_ag_name = next_target.agent_name
-                else:
-                    next_ag_name = None
-                    print("No next target. next_target: ", next_target)
-                for ag in groupchat.agents:
-                    if (
-                        # ag != tool_executor
-                        ag != agent._group_manager
-                        and (
-                            # 1. broadcast_recipients overrides everything
-                            (tgt.broadcast_recipients == "all")
-                            or (tgt.broadcast_recipients is not None and ag.name in tgt.broadcast_recipients)
-                            # 2. otherwise, send only to next agent if present
-                            or (tgt.broadcast_recipients is None and next_ag_name is not None and ag.name == next_ag_name)
-                            # 3. otherwise, send to all
-                            or (tgt.broadcast_recipients is None and next_ag_name is None)
-                        )
-                    ):
-                        # sending from group manager seems to give higher priority than from tool executor.
-                        agent._group_manager.send(
-                            broadcast,
-                            ag,   
-                            request_reply=False,
-                            silent=False,
-                        )
-
-                # add some error handling
-                if next_target is None:
-                    # no explicit next target: delegate to the manager's auto selection
-                    from .targets.group_manager_target import GroupManagerTarget
-                    return GroupManagerTarget().resolve(groupchat, agent, user_agent).get_speaker_selection_result(groupchat)
-
-                # explicit target provided
-                if isinstance(next_target, TransitionTarget):
-                    if next_target.can_resolve_for_speaker_selection():
-                        return next_target.resolve(groupchat, agent, user_agent).get_speaker_selection_result(groupchat)
-                    else:
-                        # If someone tries to return another FunctionTarget here, you can decide what to do.
-                        # For now, delegate to manager to avoid loops.
-                        from .targets.group_manager_target import GroupManagerTarget
-                        return GroupManagerTarget().resolve(groupchat, agent, user_agent).get_speaker_selection_result(groupchat)
-
-                # fallback if target type isn't recognized
-                from .targets.group_manager_target import GroupManagerTarget
-                return GroupManagerTarget().resolve(groupchat, agent, user_agent).get_speaker_selection_result(groupchat)
-            else:
-                # proceed as before if not a FunctionTarget
-                return after_work_condition.target.resolve(
-                    groupchat,
-                    agent,
-                    user_agent,
-                ).get_speaker_selection_result(groupchat)
+            # Condition matched, resolve and return
+            return after_work_condition.target.resolve(
+                groupchat,
+                agent,
+                user_agent,
+            ).get_speaker_selection_result(groupchat)
+        
     return None
 
 

autogen/agentchat/group/targets/transition_target.py

@@ -4,7 +4,8 @@
 
 import random
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Any, Optional
+from types import SimpleNamespace
+from typing import TYPE_CHECKING, Any, List, Optional
 
 from pydantic import BaseModel, Field
 
@@ -423,19 +424,44 @@ def create_wrapper_agent(self, parent_agent: "ConversableAgent", index: int) ->
 
 
 if TYPE_CHECKING:
-    from ..reply_result import ReplyResult
-
-    AfterworkFn = Callable[[str, Any], "ReplyResult"]
+    from ..function_target_result import FunctionTargetResult
+    from ..function_target_result import FunctionTargetMessage
+    AfterworkFn = Callable[..., "FunctionTargetResult"]
 else:
-    AfterworkFn = Callable[[str, Any], Any]
-
+    AfterworkFn = Callable[..., Any]
+
+def broadcast(messages: List["FunctionTargetMessage"] | str, group_chat, current_agent, fn_name, target, user_agent, *args) -> None:
+    """Broadcast a message to a specific agent."""
+    if isinstance(messages, str):
+        if hasattr(target, "agent_name"):
+            next_target = target.agent_name
+            for agent in group_chat.agents:
+                if agent.name == next_target:
+                    messages = [SimpleNamespace(content=messages, msg_target=agent)]
+                    break
+        elif isinstance(target, RevertToUserTarget):
+            messages = [SimpleNamespace(content=messages, msg_target=user_agent)]
+        elif isinstance(target, StayTarget):
+            messages = [SimpleNamespace(content=messages, msg_target=current_agent)]
+    for message in messages:
+        content = message.content
+        broadcast = {
+            "role": "system",
+            "name": f"{fn_name}",
+            "content": f"[FUNCTION_HANDOFF] - Reply from function {fn_name}: \n\n {content}"
+        }
+        current_agent._group_manager.send(
+            broadcast,
+            message.msg_target,   
+            request_reply=False,
+            silent=False,
+        )
 
 class FunctionTarget(TransitionTarget):
     """Transition target that invokes a tool function with (prev_output, context)."""
 
     fn_name: str = Field(...)
     fn: AfterworkFn = Field(..., repr=False)
-    broadcast_recipients: list[str] | None = None
 
     def __init__(self, incoming_fn, **kwargs):
         # If the first arg is callable, auto-populate fn and fn_name
@@ -446,7 +472,6 @@ def __init__(self, incoming_fn, **kwargs):
             raise ValueError(
                 "FunctionTarget must be initialized with a callable function as the first argument or 'fn' keyword argument."
             )
-    # --- TransitionTarget API ---
     def can_resolve_for_speaker_selection(self) -> bool:
         return False
 
@@ -455,17 +480,13 @@ def resolve(self, *args, **kwargs) -> SpeakerSelectionResult:
         last_message = group_chat.messages[-1]["content"] if group_chat.messages else ""
         current_agent: ConversableAgent = args[1]
         ctx = current_agent.context_variables
-
-        # Define the signature of the function that can be called (parameters and return type)
-        # Create a message class and object for adding a message to the conversation
-        function_target_result = self.fn(group_chat, current_agent, last_message, ctx)
-
-        # resolve_next_target = function_target_result.target.resolve(group_chat, args[1], args[2])
-
-        # if function_target_result.message:
-        #     broadcast(function_target_result.message.content, function_target_result.message.target_agent)
-
-        return function_target_result.target.resolve(group_chat, args[1], args[2])
+        user_agent = args[2]
+        function_target_result = self.fn(last_message, ctx, group_chat, current_agent)
+        if function_target_result.context_variables:
+            ctx.update(function_target_result.context_variables)
+        if function_target_result.messages:
+            broadcast(function_target_result.messages, group_chat, current_agent, self.fn_name, function_target_result.target, user_agent)
+        return function_target_result.target.resolve(group_chat, current_agent, user_agent)
 
     def display_name(self) -> str:
         return self.fn_name

test/agentchat/test_function_targets.py

@@ -11,7 +11,9 @@
 from autogen import LLMConfig, ConversableAgent
 from autogen.agentchat import initiate_group_chat
 from autogen.agentchat.group import ContextVariables, AgentTarget, FunctionTarget, ReplyResult
+from autogen.agentchat.group.function_target_result import FunctionTargetMessage, FunctionTargetResult
 from autogen.agentchat.group.patterns import DefaultPattern
+from autogen.agentchat.group.targets.transition_target import RevertToUserTarget, StayTarget, TerminateTarget
 
 load_dotenv()
 
@@ -21,7 +23,7 @@ def main(session_id: Optional[str] = None) -> dict:
     cfg = LLMConfig(api_type="openai", model="gpt-4o", api_key=os.environ["OPENAI_API_KEY"])
 
     # Shared context
-    ctx = ContextVariables(data={"variable": "value1"})
+    ctx = ContextVariables(data={"application": "<empty>"})
 
     # Agents
     first_agent = ConversableAgent(
@@ -43,20 +45,23 @@ def main(session_id: Optional[str] = None) -> dict:
     )
 
     # After-work hook
-    def afterwork_function(output: str, context_variables: Any) -> ReplyResult:
+    def afterwork_function(output: str, context_variables: Any, *args) -> FunctionTargetResult:
         """
         Switches a context variable and routes the next turn.
         """
-        if context_variables.get("variable") == "value1":
-            context_variables["variable"] = "value2"
-            return ReplyResult(
-                message="The job you are applying to is specifically in GPU optimization",
-                target=AgentTarget(first_agent),
+        if context_variables.get("application") == "<empty>":
+            context_variables["application"] = output
+            return FunctionTargetResult(
+                messages="apply for a job in gpu optimization",
+                target=StayTarget(),
                 context_variables=context_variables,
             )
 
-        return ReplyResult(
-            message="The job you are applying to is specifically in agentic open source development",
+        return FunctionTargetResult(
+            messages=[FunctionTargetMessage(
+                content=f"Revise the draft written by the first agent: {output}",
+                msg_target=second_agent
+            )],
             target=AgentTarget(second_agent),
             context_variables=context_variables,
         )
@@ -77,7 +82,7 @@ def afterwork_function(output: str, context_variables: Any) -> ReplyResult:
     initiate_group_chat(
         pattern=pattern,
         messages="the job you are applying to is specifically in machine learning",
-        max_rounds=60,
+        max_rounds=20,
     )
 
     return {"session_id": session_id}