Python: [Breaking] Simplified Content types to a single class with classmethod constructors. (#3252)

* ported Content to a new model

* fixed linting

* fixes

* fixed data format handling

* fix for 3.10 mypy

* fix

* fix int test

python/packages/ag-ui/agent_framework_ag_ui/_client.py

@@ -17,12 +17,10 @@ from agent_framework import (
     ChatMessage,
     ChatResponse,
     ChatResponseUpdate,
-    DataContent,
-    FunctionCallContent,
+    Content,
+    use_chat_middleware,
+    use_function_invocation,
 )
-from agent_framework._middleware import use_chat_middleware
-from agent_framework._tools import use_function_invocation
-from agent_framework._types import BaseContent, Contents
 from agent_framework.observability import use_instrumentation
 
 from ._event_converters import AGUIEventConverter
@@ -53,26 +51,11 @@ else:
 logger: logging.Logger = logging.getLogger(__name__)
 
 
-class ServerFunctionCallContent(BaseContent):
-    """Wrapper for server function calls to prevent client re-execution.
-
-    All function calls from the remote server are server-side executions.
-    This wrapper prevents @use_function_invocation from trying to execute them again.
-    """
-
-    function_call_content: FunctionCallContent
-
-    def __init__(self, function_call_content: FunctionCallContent) -> None:
-        """Initialize with the function call content."""
-        super().__init__(type="server_function_call")
-        self.function_call_content = function_call_content
-
-
-def _unwrap_server_function_call_contents(contents: MutableSequence[Contents | dict[str, Any]]) -> None:
-    """Replace ServerFunctionCallContent instances with their underlying call content."""
+def _unwrap_server_function_call_contents(contents: MutableSequence[Content | dict[str, Any]]) -> None:
+    """Replace server_function_call instances with their underlying call content."""
     for idx, content in enumerate(contents):
-        if isinstance(content, ServerFunctionCallContent):
-            contents[idx] = content.function_call_content  # type: ignore[assignment]
+        if content.type == "server_function_call":  # type: ignore[union-attr]
+            contents[idx] = content.function_call  # type: ignore[assignment, union-attr]
 
 
 TBaseChatClient = TypeVar("TBaseChatClient", bound=type[BaseChatClient[Any]])
@@ -93,7 +76,7 @@ def _apply_server_function_call_unwrap(chat_client: TBaseChatClient) -> TBaseCha
     @wraps(original_get_streaming_response)
     async def streaming_wrapper(self, *args: Any, **kwargs: Any) -> AsyncIterable[ChatResponseUpdate]:
         async for update in original_get_streaming_response(self, *args, **kwargs):
-            _unwrap_server_function_call_contents(cast(MutableSequence[Contents | dict[str, Any]], update.contents))
+            _unwrap_server_function_call_contents(cast(MutableSequence[Content | dict[str, Any]], update.contents))
             yield update
 
     chat_client.get_streaming_response = streaming_wrapper  # type: ignore[assignment]
@@ -105,9 +88,7 @@ def _apply_server_function_call_unwrap(chat_client: TBaseChatClient) -> TBaseCha
         response = await original_get_response(self, *args, **kwargs)
         if response.messages:
             for message in response.messages:
-                _unwrap_server_function_call_contents(
-                    cast(MutableSequence[Contents | dict[str, Any]], message.contents)
-                )
+                _unwrap_server_function_call_contents(cast(MutableSequence[Content | dict[str, Any]], message.contents))
         return response
 
     chat_client.get_response = response_wrapper  # type: ignore[assignment]
@@ -289,13 +270,13 @@ class AGUIChatClient(BaseChatClient[TAGUIChatOptions], Generic[TAGUIChatOptions]
         last_message = messages[-1]
 
         for content in last_message.contents:
-            if isinstance(content, DataContent) and content.media_type == "application/json":
+            if isinstance(content, Content) and content.type == "data" and content.media_type == "application/json":
                 try:
                     uri = content.uri
-                    if uri.startswith("data:application/json;base64,"):
+                    if uri.startswith("data:application/json;base64,"):  # type: ignore[union-attr]
                         import base64
 
-                        encoded_data = uri.split(",", 1)[1]
+                        encoded_data = uri.split(",", 1)[1]  # type: ignore[union-attr]
                         decoded_bytes = base64.b64decode(encoded_data)
                         state = json.loads(decoded_bytes.decode("utf-8"))
 
@@ -433,19 +414,19 @@ class AGUIChatClient(BaseChatClient[TAGUIChatOptions], Generic[TAGUIChatOptions]
                 )
                 # Distinguish client vs server tools
                 for i, content in enumerate(update.contents):
-                    if isinstance(content, FunctionCallContent):
+                    if content.type == "function_call":  # type: ignore[attr-defined]
                         logger.debug(
-                            f"[AGUIChatClient] Function call: {content.name}, in client_tool_set: {content.name in client_tool_set}"
+                            f"[AGUIChatClient] Function call: {content.name}, in client_tool_set: {content.name in client_tool_set}"  # type: ignore[attr-defined]
                         )
-                        if content.name in client_tool_set:
+                        if content.name in client_tool_set:  # type: ignore[attr-defined]
                             # Client tool - let @use_function_invocation execute it
-                            if not content.additional_properties:
-                                content.additional_properties = {}
-                            content.additional_properties["agui_thread_id"] = thread_id
+                            if not content.additional_properties:  # type: ignore[attr-defined]
+                                content.additional_properties = {}  # type: ignore[attr-defined]
+                            content.additional_properties["agui_thread_id"] = thread_id  # type: ignore[attr-defined]
                         else:
                             # Server tool - wrap so @use_function_invocation ignores it
-                            logger.debug(f"[AGUIChatClient] Wrapping server tool: {content.name}")
-                            self._register_server_tool_placeholder(content.name)
-                            update.contents[i] = ServerFunctionCallContent(content)  # type: ignore
+                            logger.debug(f"[AGUIChatClient] Wrapping server tool: {content.name}")  # type: ignore[union-attr]
+                            self._register_server_tool_placeholder(content.name)  # type: ignore[arg-type]
+                            update.contents[i] = Content(type="server_function_call", function_call=content)  # type: ignore
 
                 yield update

python/packages/ag-ui/agent_framework_ag_ui/_event_converters.py

@@ -6,12 +6,9 @@ from typing import Any
 
 from agent_framework import (
     ChatResponseUpdate,
-    ErrorContent,
+    Content,
     FinishReason,
-    FunctionCallContent,
-    FunctionResultContent,
     Role,
-    TextContent,
 )
 
 
@@ -117,7 +114,7 @@ class AGUIEventConverter:
         return ChatResponseUpdate(
             role=Role.ASSISTANT,
             message_id=self.current_message_id,
-            contents=[TextContent(text=delta)],
+            contents=[Content.from_text(text=delta)],
         )
 
     def _handle_text_message_end(self, event: dict[str, Any]) -> ChatResponseUpdate | None:
@@ -133,7 +130,7 @@ class AGUIEventConverter:
         return ChatResponseUpdate(
             role=Role.ASSISTANT,
             contents=[
-                FunctionCallContent(
+                Content.from_function_call(
                     call_id=self.current_tool_call_id or "",
                     name=self.current_tool_name or "",
                     arguments="",
@@ -149,7 +146,7 @@ class AGUIEventConverter:
         return ChatResponseUpdate(
             role=Role.ASSISTANT,
             contents=[
-                FunctionCallContent(
+                Content.from_function_call(
                     call_id=self.current_tool_call_id or "",
                     name=self.current_tool_name or "",
                     arguments=delta,
@@ -170,7 +167,7 @@ class AGUIEventConverter:
         return ChatResponseUpdate(
             role=Role.TOOL,
             contents=[
-                FunctionResultContent(
+                Content.from_function_result(
                     call_id=tool_call_id,
                     result=result,
                 )
@@ -197,7 +194,7 @@ class AGUIEventConverter:
             role=Role.ASSISTANT,
             finish_reason=FinishReason.CONTENT_FILTER,
             contents=[
-                ErrorContent(
+                Content.from_error(
                     message=error_message,
                     error_code="RUN_ERROR",
                 )

python/packages/ag-ui/agent_framework_ag_ui/_events.py

@@ -25,10 +25,7 @@ from ag_ui.core import (
 )
 from agent_framework import (
     AgentResponseUpdate,
-    FunctionApprovalRequestContent,
-    FunctionCallContent,
-    FunctionResultContent,
-    TextContent,
+    Content,
     prepare_function_call_results,
 )
 
@@ -96,20 +93,22 @@ class AgentFrameworkEventBridge:
         logger.info(f"Processing AgentRunUpdate with {len(update.contents)} content items")
         for idx, content in enumerate(update.contents):
             logger.info(f"  Content {idx}: type={type(content).__name__}")
-            if isinstance(content, TextContent):
-                events.extend(self._handle_text_content(content))
-            elif isinstance(content, FunctionCallContent):
-                events.extend(self._handle_function_call_content(content))
-            elif isinstance(content, FunctionResultContent):
-                events.extend(self._handle_function_result_content(content))
-            elif isinstance(content, FunctionApprovalRequestContent):
-                events.extend(self._handle_function_approval_request_content(content))
-
+            match content.type:
+                case "text":
+                    events.extend(self._handle_text_content(content))
+                case "function_call":
+                    events.extend(self._handle_function_call_content(content))
+                case "function_result":
+                    events.extend(self._handle_function_result_content(content))
+                case "function_approval_request":
+                    events.extend(self._handle_function_approval_request_content(content))
+                case _:
+                    logger.warning(f"  Unsupported content type: {content.type}, skipping.")
         return events
 
-    def _handle_text_content(self, content: TextContent) -> list[BaseEvent]:
+    def _handle_text_content(self, content: Content) -> list[BaseEvent]:
         events: list[BaseEvent] = []
-        logger.info(f"  TextContent found: length={len(content.text)}")
+        logger.info(f"  TextContent found: length={len(content.text)}")  # type: ignore[arg-type]
         logger.info(
             "  Flags: skip_text_content=%s, should_stop_after_confirm=%s",
             self.skip_text_content,
@@ -122,7 +121,7 @@ class AgentFrameworkEventBridge:
 
         if self.should_stop_after_confirm:
             logger.info("  SKIPPING TextContent: waiting for confirm_changes response")
-            self.suppressed_summary += content.text
+            self.suppressed_summary += content.text  # type: ignore[operator]
             logger.info(f"  Suppressed summary length={len(self.suppressed_summary)}")
             return events
 
@@ -150,14 +149,14 @@ class AgentFrameworkEventBridge:
         events.append(event)
         return events
 
-    def _handle_function_call_content(self, content: FunctionCallContent) -> list[BaseEvent]:
+    def _handle_function_call_content(self, content: Content) -> list[BaseEvent]:
         events: list[BaseEvent] = []
         if content.name:
             logger.debug(f"Tool call: {content.name} (call_id: {content.call_id})")
 
         if not content.name and not content.call_id and not self.current_tool_call_name:
             args_length = len(str(content.arguments)) if content.arguments else 0
-            logger.warning(f"FunctionCallContent missing name and call_id. args_length={args_length}")
+            logger.warning(f"Content missing name and call_id. args_length={args_length}")
 
         tool_call_id = self._coalesce_tool_call_id(content)
         # Only emit ToolCallStartEvent once per tool call (when it's a new tool call)
@@ -190,7 +189,7 @@ class AgentFrameworkEventBridge:
 
         return events
 
-    def _coalesce_tool_call_id(self, content: FunctionCallContent) -> str:
+    def _coalesce_tool_call_id(self, content: Content) -> str:
         if content.call_id:
             return content.call_id
         if self.current_tool_call_id:
@@ -286,7 +285,7 @@ class AgentFrameworkEventBridge:
                     self.pending_state_updates[state_key] = state_value
         return events
 
-    def _handle_function_result_content(self, content: FunctionResultContent) -> list[BaseEvent]:
+    def _handle_function_result_content(self, content: Content) -> list[BaseEvent]:
         events: list[BaseEvent] = []
         if content.call_id:
             end_event = ToolCallEndEvent(
@@ -310,7 +309,7 @@ class AgentFrameworkEventBridge:
 
         result_event = ToolCallResultEvent(
             message_id=result_message_id,
-            tool_call_id=content.call_id,
+            tool_call_id=content.call_id,  # type: ignore[arg-type]
             content=result_content,
             role="tool",
         )
@@ -367,7 +366,7 @@ class AgentFrameworkEventBridge:
             self.current_tool_call_name = None
         return events
 
-    def _emit_confirm_changes_tool_call(self, function_call: FunctionCallContent | None = None) -> list[BaseEvent]:
+    def _emit_confirm_changes_tool_call(self, function_call: Content | None = None) -> list[BaseEvent]:
         """Emit a confirm_changes tool call for Dojo UI compatibility.
 
         Args:
@@ -419,7 +418,7 @@ class AgentFrameworkEventBridge:
         logger.info("Set flag to stop run after confirm_changes")
         return events
 
-    def _emit_function_approval_tool_call(self, function_call: FunctionCallContent) -> list[BaseEvent]:
+    def _emit_function_approval_tool_call(self, function_call: Content) -> list[BaseEvent]:
         """Emit a tool call that can drive UI approval for function requests."""
         tool_call_name = "confirm_changes"
         if self.approval_tool_name and self.approval_tool_name != function_call.name:
@@ -462,13 +461,13 @@ class AgentFrameworkEventBridge:
         logger.info("Set flag to stop run after confirm_changes")
         return events
 
-    def _handle_function_approval_request_content(self, content: FunctionApprovalRequestContent) -> list[BaseEvent]:
+    def _handle_function_approval_request_content(self, content: Content) -> list[BaseEvent]:
         events: list[BaseEvent] = []
         logger.info("=== FUNCTION APPROVAL REQUEST ===")
-        logger.info(f"  Function: {content.function_call.name}")
-        logger.info(f"  Call ID: {content.function_call.call_id}")
+        logger.info(f"  Function: {content.function_call.name}")  # type: ignore[union-attr]
+        logger.info(f"  Call ID: {content.function_call.call_id}")  # type: ignore[union-attr]
 
-        parsed_args = content.function_call.parse_arguments()
+        parsed_args = content.function_call.parse_arguments()  # type: ignore[union-attr]
         parsed_arg_keys = list(parsed_args.keys()) if parsed_args else "None"
         logger.info(f"  Parsed args keys: {parsed_arg_keys}")
 
@@ -478,12 +477,12 @@ class AgentFrameworkEventBridge:
                 list(self.predict_state_config.keys()) if self.predict_state_config else "None",
             )
             for state_key, config in self.predict_state_config.items():
-                if config["tool"] != content.function_call.name:
+                if config["tool"] != content.function_call.name:  # type: ignore[union-attr]
                     continue
                 tool_arg_name = config["tool_argument"]
                 logger.info(
                     "  MATCHED tool '%s' for state key '%s', arg='%s'",
-                    content.function_call.name,
+                    content.function_call.name,  # type: ignore[union-attr]
                     state_key,
                     tool_arg_name,
                 )
@@ -500,11 +499,11 @@ class AgentFrameworkEventBridge:
                 )
                 events.append(state_snapshot)
 
-        if content.function_call.call_id:
+        if content.function_call.call_id:  # type: ignore[union-attr]
             end_event = ToolCallEndEvent(
-                tool_call_id=content.function_call.call_id,
+                tool_call_id=content.function_call.call_id,  # type: ignore[union-attr]
             )
-            logger.info(f"Emitting ToolCallEndEvent for approval-required tool '{content.function_call.call_id}'")
+            logger.info(f"Emitting ToolCallEndEvent for approval-required tool '{content.function_call.call_id}'")  # type: ignore[union-attr]
             events.append(end_event)
 
         # Emit the function_approval_request custom event for UI implementations that support it
@@ -513,18 +512,18 @@ class AgentFrameworkEventBridge:
             value={
                 "id": content.id,
                 "function_call": {
-                    "call_id": content.function_call.call_id,
-                    "name": content.function_call.name,
-                    "arguments": content.function_call.parse_arguments(),
+                    "call_id": content.function_call.call_id,  # type: ignore[union-attr]
+                    "name": content.function_call.name,  # type: ignore[union-attr]
+                    "arguments": content.function_call.parse_arguments(),  # type: ignore[union-attr]
                 },
             },
         )
-        logger.info(f"Emitting function_approval_request custom event for '{content.function_call.name}'")
+        logger.info(f"Emitting function_approval_request custom event for '{content.function_call.name}'")  # type: ignore[union-attr]
         events.append(approval_event)
 
         # Emit a UI-friendly approval tool call for function approvals.
         if self.require_confirmation:
-            events.extend(self._emit_function_approval_tool_call(content.function_call))
+            events.extend(self._emit_function_approval_tool_call(content.function_call))  # type: ignore[arg-type]
 
         # Signal orchestrator to stop the run and wait for user approval response
         self.should_stop_after_confirm = True

python/packages/ag-ui/agent_framework_ag_ui/_message_adapters.py

@@ -8,11 +8,8 @@ from typing import Any, cast
 
 from agent_framework import (
     ChatMessage,
-    FunctionApprovalResponseContent,
-    FunctionCallContent,
-    FunctionResultContent,
+    Content,
     Role,
-    TextContent,
     prepare_function_call_results,
 )
 
@@ -40,11 +37,11 @@ def _sanitize_tool_history(messages: list[ChatMessage]) -> list[ChatMessage]:
             tool_ids = {
                 str(content.call_id)
                 for content in msg.contents or []
-                if isinstance(content, FunctionCallContent) and content.call_id
+                if content.type == "function_call" and content.call_id
             }
             confirm_changes_call = None
             for content in msg.contents or []:
-                if isinstance(content, FunctionCallContent) and content.name == "confirm_changes":
+                if content.type == "function_call" and content.name == "confirm_changes":
                     confirm_changes_call = content
                     break
 
@@ -59,7 +56,7 @@ def _sanitize_tool_history(messages: list[ChatMessage]) -> list[ChatMessage]:
             approval_call_ids: set[str] = set()
             approval_accepted: bool | None = None
             for content in msg.contents or []:
-                if type(content) is FunctionApprovalResponseContent:
+                if content.type == "function_approval_response":
                     if content.function_call and content.function_call.call_id:
                         approval_call_ids.add(str(content.function_call.call_id))
                     if approval_accepted is None:
@@ -79,7 +76,7 @@ def _sanitize_tool_history(messages: list[ChatMessage]) -> list[ChatMessage]:
                 synthetic_result = ChatMessage(
                     role="tool",
                     contents=[
-                        FunctionResultContent(
+                        Content.from_function_result(
                             call_id=pending_confirm_changes_id,
                             result="Confirmed" if approval_accepted else "Rejected",
                         )
@@ -93,12 +90,12 @@ def _sanitize_tool_history(messages: list[ChatMessage]) -> list[ChatMessage]:
             if pending_confirm_changes_id:
                 user_text = ""
                 for content in msg.contents or []:
-                    if isinstance(content, TextContent):
-                        user_text = content.text
+                    if content.type == "text":
+                        user_text = content.text  # type: ignore[assignment]
                         break
 
                 try:
-                    parsed = json.loads(user_text)
+                    parsed = json.loads(user_text)  # type: ignore[arg-type]
                     if "accepted" in parsed:
                         logger.info(
                             f"Injecting synthetic tool result for confirm_changes call_id={pending_confirm_changes_id}"
@@ -106,7 +103,7 @@ def _sanitize_tool_history(messages: list[ChatMessage]) -> list[ChatMessage]:
                         synthetic_result = ChatMessage(
                             role="tool",
                             contents=[
-                                FunctionResultContent(
+                                Content.from_function_result(
                                     call_id=pending_confirm_changes_id,
                                     result="Confirmed" if parsed.get("accepted") else "Rejected",
                                 )
@@ -130,7 +127,7 @@ def _sanitize_tool_history(messages: list[ChatMessage]) -> list[ChatMessage]:
                     synthetic_result = ChatMessage(
                         role="tool",
                         contents=[
-                            FunctionResultContent(
+                            Content.from_function_result(
                                 call_id=pending_call_id,
                                 result="Tool execution skipped - user provided follow-up message",
                             )
@@ -149,7 +146,7 @@ def _sanitize_tool_history(messages: list[ChatMessage]) -> list[ChatMessage]:
                 continue
             keep = False
             for content in msg.contents or []:
-                if isinstance(content, FunctionResultContent):
+                if content.type == "function_result" and content.call_id:
                     call_id = str(content.call_id)
                     if call_id in pending_tool_call_ids:
                         keep = True
@@ -175,7 +172,7 @@ def _deduplicate_messages(messages: list[ChatMessage]) -> list[ChatMessage]:
     for idx, msg in enumerate(messages):
         role_value = get_role_value(msg)
 
-        if role_value == "tool" and msg.contents and isinstance(msg.contents[0], FunctionResultContent):
+        if role_value == "tool" and msg.contents and msg.contents[0].type == "function_result":
             call_id = str(msg.contents[0].call_id)
             key: Any = (role_value, call_id)
 
@@ -184,7 +181,7 @@ def _deduplicate_messages(messages: list[ChatMessage]) -> list[ChatMessage]:
                 existing_msg = unique_messages[existing_idx]
 
                 existing_result = None
-                if existing_msg.contents and isinstance(existing_msg.contents[0], FunctionResultContent):
+                if existing_msg.contents and existing_msg.contents[0].type == "function_result":
                     existing_result = existing_msg.contents[0].result
                 new_result = msg.contents[0].result
 
@@ -198,11 +195,9 @@ def _deduplicate_messages(messages: list[ChatMessage]) -> list[ChatMessage]:
             seen_keys[key] = len(unique_messages)
             unique_messages.append(msg)
 
-        elif (
-            role_value == "assistant" and msg.contents and any(isinstance(c, FunctionCallContent) for c in msg.contents)
-        ):
+        elif role_value == "assistant" and msg.contents and any(c.type == "function_call" for c in msg.contents):
             tool_call_ids = tuple(
-                sorted(str(c.call_id) for c in msg.contents if isinstance(c, FunctionCallContent) and c.call_id)
+                sorted(str(c.call_id) for c in msg.contents if c.type == "function_call" and c.call_id)
             )
             key = (role_value, tool_call_ids)
 
@@ -275,15 +270,14 @@ def agui_messages_to_agent_framework(messages: list[dict[str, Any]]) -> list[Cha
                     function_payload_dict["arguments"] = modified_args
                 return
 
-    def _find_matching_func_call(call_id: str) -> FunctionCallContent | None:
+    def _find_matching_func_call(call_id: str) -> Content | None:
         for prev_msg in result:
             role_val = prev_msg.role.value if hasattr(prev_msg.role, "value") else str(prev_msg.role)
             if role_val != "assistant":
                 continue
             for content in prev_msg.contents or []:
-                if isinstance(content, FunctionCallContent):
-                    if content.call_id == call_id and content.name != "confirm_changes":
-                        return content
+                if content.type == "function_call" and content.call_id == call_id and content.name != "confirm_changes":
+                    return content
         return None
 
     def _parse_arguments(arguments: Any) -> dict[str, Any] | None:
@@ -301,9 +295,9 @@ def agui_messages_to_agent_framework(messages: list[dict[str, Any]]) -> list[Cha
                 continue
             direct_call = None
             confirm_call = None
-            sibling_calls: list[FunctionCallContent] = []
+            sibling_calls: list[Content] = []
             for content in prev_msg.contents or []:
-                if not isinstance(content, FunctionCallContent):
+                if content.type != "function_call":
                     continue
                 if content.call_id == tool_call_id:
                     direct_call = content
@@ -407,7 +401,7 @@ def agui_messages_to_agent_framework(messages: list[dict[str, Any]]) -> list[Cha
                         if not (
                             (m.role.value if hasattr(m.role, "value") else str(m.role)) == "tool"
                             and any(
-                                isinstance(c, FunctionResultContent) and c.call_id == approval_call_id
+                                c.type == "function_result" and c.call_id == approval_call_id
                                 for c in (m.contents or [])
                             )
                         )
@@ -465,9 +459,9 @@ def agui_messages_to_agent_framework(messages: list[dict[str, Any]]) -> list[Cha
                         matching_func_call.arguments = updated_args
                         _update_tool_call_arguments(messages, str(approval_call_id), merged_args)
                         # Create a new FunctionCallContent with the modified arguments
-                        func_call_for_approval = FunctionCallContent(
-                            call_id=matching_func_call.call_id,
-                            name=matching_func_call.name,
+                        func_call_for_approval = Content.from_function_call(
+                            call_id=matching_func_call.call_id,  # type: ignore[arg-type]
+                            name=matching_func_call.name,  # type: ignore[arg-type]
                             arguments=json.dumps(filtered_args),
                         )
                         logger.info(f"Using modified arguments from approval: {filtered_args}")
@@ -476,7 +470,7 @@ def agui_messages_to_agent_framework(messages: list[dict[str, Any]]) -> list[Cha
                         func_call_for_approval = matching_func_call
 
                     # Create FunctionApprovalResponseContent for the agent framework
-                    approval_response = FunctionApprovalResponseContent(
+                    approval_response = Content.from_function_approval_response(
                         approved=accepted,
                         id=str(approval_call_id),
                         function_call=func_call_for_approval,
@@ -491,7 +485,7 @@ def agui_messages_to_agent_framework(messages: list[dict[str, Any]]) -> list[Cha
                     # Keep the old behavior for backwards compatibility
                     chat_msg = ChatMessage(
                         role=Role.USER,
-                        contents=[TextContent(text=approval_payload_text)],
+                        contents=[Content.from_text(text=approval_payload_text)],
                         additional_properties={"is_tool_result": True, "tool_call_id": str(tool_call_id or "")},
                     )
                 if "id" in msg:
@@ -511,7 +505,7 @@ def agui_messages_to_agent_framework(messages: list[dict[str, Any]]) -> list[Cha
                 func_result = str(result_content)
             chat_msg = ChatMessage(
                 role=Role.TOOL,
-                contents=[FunctionResultContent(call_id=str(tool_call_id), result=func_result)],
+                contents=[Content.from_function_result(call_id=str(tool_call_id), result=func_result)],
             )
             if "id" in msg:
                 chat_msg.message_id = msg["id"]
@@ -527,21 +521,21 @@ def agui_messages_to_agent_framework(messages: list[dict[str, Any]]) -> list[Cha
 
             chat_msg = ChatMessage(
                 role=Role.TOOL,
-                contents=[FunctionResultContent(call_id=str(tool_call_id), result=result_content)],
+                contents=[Content.from_function_result(call_id=str(tool_call_id), result=result_content)],
             )
             if "id" in msg:
                 chat_msg.message_id = msg["id"]
             result.append(chat_msg)
             continue
 
-        # If assistant message includes tool calls, convert to FunctionCallContent(s)
+        # If assistant message includes tool calls, convert to Content.from_function_call(s)
         tool_calls = msg.get("tool_calls") or msg.get("toolCalls")
         if tool_calls:
             contents: list[Any] = []
             # Include any assistant text content if present
             content_text = msg.get("content")
             if isinstance(content_text, str) and content_text:
-                contents.append(TextContent(text=content_text))
+                contents.append(Content.from_text(text=content_text))
             # Convert each tool call entry
             for tc in tool_calls:
                 if not isinstance(tc, dict):
@@ -558,7 +552,7 @@ def agui_messages_to_agent_framework(messages: list[dict[str, Any]]) -> list[Cha
                     arguments = func_dict.get("arguments")
 
                     contents.append(
-                        FunctionCallContent(
+                        Content.from_function_call(
                             call_id=call_id,
                             name=name,
                             arguments=arguments,
@@ -580,14 +574,14 @@ def agui_messages_to_agent_framework(messages: list[dict[str, Any]]) -> list[Cha
             approval_contents: list[Any] = []
             for approval in msg["function_approvals"]:
                 # Create FunctionCallContent with the modified arguments
-                func_call = FunctionCallContent(
+                func_call = Content.from_function_call(
                     call_id=approval.get("call_id", ""),
                     name=approval.get("name", ""),
                     arguments=approval.get("arguments", {}),
                 )
 
                 # Create the approval response
-                approval_response = FunctionApprovalResponseContent(
+                approval_response = Content.from_function_approval_response(
                     approved=approval.get("approved", True),
                     id=approval.get("id", ""),
                     function_call=func_call,
@@ -599,9 +593,9 @@ def agui_messages_to_agent_framework(messages: list[dict[str, Any]]) -> list[Cha
             # Regular text message
             content = msg.get("content", "")
             if isinstance(content, str):
-                chat_msg = ChatMessage(role=role, contents=[TextContent(text=content)])
+                chat_msg = ChatMessage(role=role, contents=[Content.from_text(text=content)])
             else:
-                chat_msg = ChatMessage(role=role, contents=[TextContent(text=str(content))])
+                chat_msg = ChatMessage(role=role, contents=[Content.from_text(text=str(content))])
 
         if "id" in msg:
             chat_msg.message_id = msg["id"]
@@ -652,9 +646,9 @@ def agent_framework_messages_to_agui(messages: list[ChatMessage] | list[dict[str
         tool_result_call_id: str | None = None
 
         for content in msg.contents:
-            if isinstance(content, TextContent):
-                content_text += content.text
-            elif isinstance(content, FunctionCallContent):
+            if content.type == "text":
+                content_text += content.text  # type: ignore[operator]
+            elif content.type == "function_call":
                 tool_calls.append(
                     {
                         "id": content.call_id,
@@ -665,7 +659,7 @@ def agent_framework_messages_to_agui(messages: list[ChatMessage] | list[dict[str
                         },
                     }
                 )
-            elif isinstance(content, FunctionResultContent):
+            elif content.type == "function_result":
                 # Tool result content - extract call_id and result
                 tool_result_call_id = content.call_id
                 # Serialize result to string using core utility
@@ -702,8 +696,13 @@ def extract_text_from_contents(contents: list[Any]) -> str:
     """
     text_parts: list[str] = []
     for content in contents:
-        if isinstance(content, TextContent):
-            text_parts.append(content.text)
+        if type_ := getattr(content, "type", None):
+            if type_ == "text_reasoning":
+                continue
+            if text := getattr(content, "text", None):
+                text_parts.append(text)
+            continue
+        # TODO (moonbox3): should this handle both text and text_reasoning?
         elif hasattr(content, "text"):
             text_parts.append(content.text)
     return "".join(text_parts)

python/packages/ag-ui/agent_framework_ag_ui/_orchestration/_helpers.py

@@ -9,10 +9,7 @@ from typing import TYPE_CHECKING, Any
 from ag_ui.core import StateSnapshotEvent
 from agent_framework import (
     ChatMessage,
-    FunctionApprovalResponseContent,
-    FunctionCallContent,
-    FunctionResultContent,
-    TextContent,
+    Content,
 )
 
 from .._utils import get_role_value, safe_json_parse
@@ -37,9 +34,9 @@ def pending_tool_call_ids(messages: list[ChatMessage]) -> set[str]:
     resolved_ids: set[str] = set()
     for msg in messages:
         for content in msg.contents:
-            if isinstance(content, FunctionCallContent) and content.call_id:
+            if content.type == "function_call" and content.call_id:
                 pending_ids.add(str(content.call_id))
-            elif isinstance(content, FunctionResultContent) and content.call_id:
+            elif content.type == "function_result" and content.call_id:
                 resolved_ids.add(str(content.call_id))
     return pending_ids - resolved_ids
 
@@ -56,7 +53,7 @@ def is_state_context_message(message: ChatMessage) -> bool:
     if get_role_value(message) != "system":
         return False
     for content in message.contents:
-        if isinstance(content, TextContent) and content.text.startswith("Current state of the application:"):
+        if content.type == "text" and content.text.startswith("Current state of the application:"):  # type: ignore[union-attr]
             return True
     return False
 
@@ -139,7 +136,7 @@ def tool_calls_match_state(
             if get_role_value(msg) != "assistant":
                 continue
             for content in msg.contents:
-                if isinstance(content, FunctionCallContent) and content.name == tool_name:
+                if content.type == "function_call" and content.name == tool_name:
                     tool_args = safe_json_parse(content.arguments)
                     break
             if tool_args is not None:
@@ -287,7 +284,7 @@ def collect_approved_state_snapshots(
         if get_role_value(msg) != "user":
             continue
         for content in msg.contents:
-            if type(content) is FunctionApprovalResponseContent:
+            if content.type == "function_approval_response":
                 if not content.function_call or not content.approved:
                     continue
                 parsed_args = content.function_call.parse_arguments()
@@ -319,7 +316,7 @@ def collect_approved_state_snapshots(
     return events
 
 
-def latest_approval_response(messages: list[ChatMessage]) -> FunctionApprovalResponseContent | None:
+def latest_approval_response(messages: list[ChatMessage]) -> Content | None:
     """Get the latest approval response from messages.
 
     Args:
@@ -332,12 +329,12 @@ def latest_approval_response(messages: list[ChatMessage]) -> FunctionApprovalRes
         return None
     last_message = messages[-1]
     for content in last_message.contents:
-        if type(content) is FunctionApprovalResponseContent:
+        if content.type == "function_approval_response":
             return content
     return None
 
 
-def approval_steps(approval: FunctionApprovalResponseContent) -> list[Any]:
+def approval_steps(approval: Content) -> list[Any]:
     """Extract steps from an approval response.
 
     Args:
@@ -346,9 +343,7 @@ def approval_steps(approval: FunctionApprovalResponseContent) -> list[Any]:
     Returns:
         List of steps, or empty list if none
     """
-    state_args: Any | None = None
-    if approval.additional_properties:
-        state_args = approval.additional_properties.get("ag_ui_state_args")
+    state_args = approval.additional_properties.get("ag_ui_state_args", None)
     if isinstance(state_args, dict):
         steps = state_args.get("steps")
         if isinstance(steps, list):
@@ -365,7 +360,7 @@ def approval_steps(approval: FunctionApprovalResponseContent) -> list[Any]:
 
 
 def is_step_based_approval(
-    approval: FunctionApprovalResponseContent,
+    approval: Content,
     predict_state_config: dict[str, dict[str, str]] | None,
 ) -> bool:
     """Check if an approval is step-based.

python/packages/ag-ui/agent_framework_ag_ui/_orchestration/_state_manager.py

@@ -6,7 +6,7 @@ import json
 from typing import Any
 
 from ag_ui.core import CustomEvent, EventType
-from agent_framework import ChatMessage, TextContent
+from agent_framework import ChatMessage, Content
 
 
 class StateManager:
@@ -71,7 +71,7 @@ class StateManager:
         return ChatMessage(
             role="system",
             contents=[
-                TextContent(
+                Content.from_text(
                     text=(
                         "Current state of the application:\n"
                         f"{state_json}\n\n"

python/packages/ag-ui/agent_framework_ag_ui/_orchestrators.py

@@ -25,13 +25,11 @@ from agent_framework import (
     AgentProtocol,
     AgentThread,
     ChatAgent,
-    FunctionCallContent,
-    FunctionResultContent,
-    TextContent,
+    Content,
+    FunctionInvocationConfiguration,
 )
 from agent_framework._middleware import extract_and_merge_function_middleware
 from agent_framework._tools import (
-    FunctionInvocationConfiguration,
     _collect_approval_responses,  # type: ignore
     _replace_approval_contents_with_results,  # type: ignore
     _try_execute_function_calls,  # type: ignore
@@ -285,12 +283,12 @@ class HumanInTheLoopOrchestrator(Orchestrator):
         last_message = context.last_message
         if last_message:
             for content in last_message.contents:
-                if isinstance(content, TextContent):
+                if content.type == "text":
                     tool_content_text = content.text
                     break
 
         try:
-            tool_result = json.loads(tool_content_text)
+            tool_result = json.loads(tool_content_text)  # type: ignore[arg-type]
             accepted = tool_result.get("accepted", False)
             steps = tool_result.get("steps", [])
 
@@ -328,7 +326,7 @@ class HumanInTheLoopOrchestrator(Orchestrator):
 
         except json.JSONDecodeError:
             logger.error(f"Failed to parse tool result: {tool_content_text}")
-            yield RunErrorEvent(message=f"Invalid tool result format: {tool_content_text[:100]}")
+            yield RunErrorEvent(message=f"Invalid tool result format: {tool_content_text[:100]}")  # type: ignore[index]
             yield event_bridge.create_run_finished_event()
 
 
@@ -441,25 +439,24 @@ class DefaultOrchestrator(Orchestrator):
             logger.info(f"  Message {i}: role={role}, id={msg_id}")
             if hasattr(msg, "contents") and msg.contents:
                 for j, content in enumerate(msg.contents):
-                    content_type = type(content).__name__
-                    if isinstance(content, TextContent):
-                        logger.debug("    Content %s: %s - text_length=%s", j, content_type, len(content.text))
-                    elif isinstance(content, FunctionCallContent):
+                    if content.type == "text":
+                        logger.debug("    Content %s: %s - text_length=%s", j, content.type, len(content.text))  # type: ignore[arg-type]
+                    elif content.type == "function_call":
                         arg_length = len(str(content.arguments)) if content.arguments else 0
                         logger.debug(
-                            "    Content %s: %s - %s args_length=%s", j, content_type, content.name, arg_length
+                            "    Content %s: %s - %s args_length=%s", j, content.type, content.name, arg_length
                         )
-                    elif isinstance(content, FunctionResultContent):
+                    elif content.type == "function_result":
                         result_preview = type(content.result).__name__ if content.result is not None else "None"
                         logger.debug(
                             "    Content %s: %s - call_id=%s, result_type=%s",
                             j,
-                            content_type,
+                            content.type,
                             content.call_id,
                             result_preview,
                         )
                     else:
-                        logger.debug(f"    Content {j}: {content_type}")
+                        logger.debug(f"    Content {j}: {content.type}")
 
         pending_tool_calls: list[dict[str, Any]] = []
         tool_calls_by_id: dict[str, dict[str, Any]] = {}
@@ -536,16 +533,14 @@ class DefaultOrchestrator(Orchestrator):
                     logger.error("Failed to execute approved tool calls; injecting error results.")
                     approved_function_results = []
 
-            normalized_results: list[FunctionResultContent] = []
+            normalized_results: list[Content] = []
             for idx, approval in enumerate(approved_responses):
-                if idx < len(approved_function_results) and isinstance(
-                    approved_function_results[idx], FunctionResultContent
-                ):
+                if idx < len(approved_function_results) and approved_function_results[idx].type == "function_result":
                     normalized_results.append(approved_function_results[idx])
                     continue
-                call_id = approval.function_call.call_id or approval.id
+                call_id = approval.function_call.call_id or approval.id  # type: ignore[union-attr]
                 normalized_results.append(
-                    FunctionResultContent(call_id=call_id, result="Error: Tool call invocation failed.")
+                    Content.from_function_result(call_id=call_id, result="Error: Tool call invocation failed.")  # type: ignore[arg-type]
                 )
 
             _replace_approval_contents_with_results(messages, fcc_todo, normalized_results)  # type: ignore
@@ -661,8 +656,8 @@ class DefaultOrchestrator(Orchestrator):
             if all_updates is not None:
                 all_updates.append(update)
             if event_bridge.current_message_id is None and update.contents:
-                has_tool_call = any(isinstance(content, FunctionCallContent) for content in update.contents)
-                has_text = any(isinstance(content, TextContent) for content in update.contents)
+                has_tool_call = any(content.type == "function_call" for content in update.contents)
+                has_text = any(content.type == "text" for content in update.contents)
                 if has_tool_call and not has_text:
                     tool_message_id = generate_event_id()
                     event_bridge.current_message_id = tool_message_id

python/packages/ag-ui/agent_framework_ag_ui/_types.py

@@ -6,6 +6,7 @@ import sys
 from typing import Any, TypedDict
 
 from agent_framework import ChatOptions
+from pydantic import BaseModel, Field
 
 if sys.version_info >= (3, 13):
     from typing import TypeVar
@@ -19,8 +20,6 @@ __all__ = [
     "RunMetadata",
 ]
 
-from pydantic import BaseModel, Field
-
 
 class PredictStateConfig(TypedDict):
     """Configuration for predictive state updates."""