agentex-sdk 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

agentex/_client.py

@@ -21,7 +21,7 @@ from ._types import (
 )
 from ._utils import is_given, get_async_library
 from ._version import __version__
-from .resources import spans, tasks, agents, events, states, tracker
+from .resources import spans, tasks, agents, events, states, tracker, deployment_history
 from ._streaming import Stream as Stream, AsyncStream as AsyncStream
 from ._exceptions import APIStatusError
 from ._base_client import (
@@ -57,6 +57,7 @@ class Agentex(SyncAPIClient):
     states: states.StatesResource
     events: events.EventsResource
     tracker: tracker.TrackerResource
+    deployment_history: deployment_history.DeploymentHistoryResource
     with_raw_response: AgentexWithRawResponse
     with_streaming_response: AgentexWithStreamedResponse
 
@@ -141,6 +142,7 @@ class Agentex(SyncAPIClient):
         self.states = states.StatesResource(self)
         self.events = events.EventsResource(self)
         self.tracker = tracker.TrackerResource(self)
+        self.deployment_history = deployment_history.DeploymentHistoryResource(self)
         self.with_raw_response = AgentexWithRawResponse(self)
         self.with_streaming_response = AgentexWithStreamedResponse(self)
 
@@ -261,6 +263,7 @@ class AsyncAgentex(AsyncAPIClient):
     states: states.AsyncStatesResource
     events: events.AsyncEventsResource
     tracker: tracker.AsyncTrackerResource
+    deployment_history: deployment_history.AsyncDeploymentHistoryResource
     with_raw_response: AsyncAgentexWithRawResponse
     with_streaming_response: AsyncAgentexWithStreamedResponse
 
@@ -345,6 +348,7 @@ class AsyncAgentex(AsyncAPIClient):
         self.states = states.AsyncStatesResource(self)
         self.events = events.AsyncEventsResource(self)
         self.tracker = tracker.AsyncTrackerResource(self)
+        self.deployment_history = deployment_history.AsyncDeploymentHistoryResource(self)
         self.with_raw_response = AsyncAgentexWithRawResponse(self)
         self.with_streaming_response = AsyncAgentexWithStreamedResponse(self)
 
@@ -466,6 +470,7 @@ class AgentexWithRawResponse:
         self.states = states.StatesResourceWithRawResponse(client.states)
         self.events = events.EventsResourceWithRawResponse(client.events)
         self.tracker = tracker.TrackerResourceWithRawResponse(client.tracker)
+        self.deployment_history = deployment_history.DeploymentHistoryResourceWithRawResponse(client.deployment_history)
 
 
 class AsyncAgentexWithRawResponse:
@@ -477,6 +482,9 @@ class AsyncAgentexWithRawResponse:
         self.states = states.AsyncStatesResourceWithRawResponse(client.states)
         self.events = events.AsyncEventsResourceWithRawResponse(client.events)
         self.tracker = tracker.AsyncTrackerResourceWithRawResponse(client.tracker)
+        self.deployment_history = deployment_history.AsyncDeploymentHistoryResourceWithRawResponse(
+            client.deployment_history
+        )
 
 
 class AgentexWithStreamedResponse:
@@ -488,6 +496,9 @@ class AgentexWithStreamedResponse:
         self.states = states.StatesResourceWithStreamingResponse(client.states)
         self.events = events.EventsResourceWithStreamingResponse(client.events)
         self.tracker = tracker.TrackerResourceWithStreamingResponse(client.tracker)
+        self.deployment_history = deployment_history.DeploymentHistoryResourceWithStreamingResponse(
+            client.deployment_history
+        )
 
 
 class AsyncAgentexWithStreamedResponse:
@@ -499,6 +510,9 @@ class AsyncAgentexWithStreamedResponse:
         self.states = states.AsyncStatesResourceWithStreamingResponse(client.states)
         self.events = events.AsyncEventsResourceWithStreamingResponse(client.events)
         self.tracker = tracker.AsyncTrackerResourceWithStreamingResponse(client.tracker)
+        self.deployment_history = deployment_history.AsyncDeploymentHistoryResourceWithStreamingResponse(
+            client.deployment_history
+        )
 
 
 Client = Agentex

agentex/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "agentex"
-__version__ = "0.6.0"  # x-release-please-version
+__version__ = "0.6.2"  # x-release-please-version

agentex/lib/adk/providers/_modules/litellm.py

@@ -32,7 +32,7 @@ DEFAULT_RETRY_POLICY = RetryPolicy(maximum_attempts=1)
 class LiteLLMModule:
     """
     Module for managing LiteLLM agent operations in Agentex.
-    Provides high-level methods for chat completion, streaming, agentic streaming.
+    Provides high-level methods for chat completion, streaming.
     """
 
     def __init__(

agentex/lib/adk/providers/_modules/openai.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import sys
 from typing import Any, Literal
 from datetime import timedelta
 
@@ -12,6 +13,12 @@ from temporalio.common import RetryPolicy
 from agents.agent_output import AgentOutputSchemaBase
 from agents.model_settings import ModelSettings
 
+# Use warnings.deprecated in Python 3.13+, typing_extensions.deprecated for older versions
+if sys.version_info >= (3, 13):
+    from warnings import deprecated
+else:
+    from typing_extensions import deprecated
+
 from agentex.lib.utils.logging import make_logger
 from agentex.lib.utils.temporal import in_temporal_workflow
 from agentex.lib.core.tracing.tracer import AsyncTracer
@@ -383,6 +390,10 @@ class OpenAIModule:
             previous_response_id=previous_response_id,
         )
 
+    @deprecated(
+        "Use the OpenAI Agents SDK integration with Temporal instead. "
+        "See examples in tutorials/10_agentic/10_temporal/ for migration guidance."
+    )
     async def run_agent_streamed_auto_send(
         self,
         task_id: str,
@@ -413,6 +424,10 @@ class OpenAIModule:
         """
         Run an agent with streaming enabled and automatic TaskMessage creation.
 
+        .. deprecated::
+            Use the OpenAI Agents SDK integration with Temporal instead.
+            See examples in tutorials/10_agentic/10_temporal/ for migration guidance.
+
         Args:
             task_id: The ID of the task to run the agent for.
             input_list: List of input data for the agent.
@@ -494,4 +509,4 @@ class OpenAIModule:
                 output_guardrails=output_guardrails,
                 max_turns=max_turns,
                 previous_response_id=previous_response_id,
-            )
+            )

agentex/lib/adk/providers/_modules/sgp.py

@@ -25,7 +25,7 @@ DEFAULT_RETRY_POLICY = RetryPolicy(maximum_attempts=1)
 class SGPModule:
     """
     Module for managing SGP agent operations in Agentex.
-    Provides high-level methods for chat completion, streaming, agentic streaming, and message classification.
+    Provides high-level methods for chat completion, streaming, and message classification.
     """
 
     def __init__(

agentex/lib/adk/providers/_modules/sync_provider.py

@@ -164,18 +164,22 @@ class SyncStreamingModel(Model):
                         output_items = response_output if isinstance(response_output, list) else [response_output]
 
                         for item in output_items:
-                            item_dict = _serialize_item(item)
-                            if item_dict:
-                                new_items.append(item_dict)
-
-                                # Extract final_output from message type if available
-                                if item_dict.get('type') == 'message' and not final_output:
-                                    content = item_dict.get('content', [])
-                                    if content and isinstance(content, list):
-                                        for content_part in content:
-                                            if isinstance(content_part, dict) and 'text' in content_part:
-                                                final_output = content_part['text']
-                                                break
+                            try:
+                                item_dict = _serialize_item(item)
+                                if item_dict:
+                                    new_items.append(item_dict)
+
+                                    # Extract final_output from message type if available
+                                    if item_dict.get('type') == 'message' and not final_output:
+                                        content = item_dict.get('content', [])
+                                        if content and isinstance(content, list):
+                                            for content_part in content:
+                                                if isinstance(content_part, dict) and 'text' in content_part:
+                                                    final_output = content_part['text']
+                                                    break
+                            except Exception as e:
+                                logger.warning(f"Failed to serialize item in get_response: {e}")
+                                continue
 
                     span.output = {
                         "new_items": new_items,
@@ -275,18 +279,22 @@ class SyncStreamingModel(Model):
                     if event_type == 'response.output_item.done':
                         item = getattr(event, 'item', None)
                         if item is not None:
-                            item_dict = _serialize_item(item)
-                            if item_dict:
-                                new_items.append(item_dict)
-
-                                # Update final_response_text from message type if available
-                                if item_dict.get('type') == 'message':
-                                    content = item_dict.get('content', [])
-                                    if content and isinstance(content, list):
-                                        for content_part in content:
-                                            if isinstance(content_part, dict) and 'text' in content_part:
-                                                final_response_text = content_part['text']
-                                                break
+                            try:
+                                item_dict = _serialize_item(item)
+                                if item_dict:
+                                    new_items.append(item_dict)
+
+                                    # Update final_response_text from message type if available
+                                    if item_dict.get('type') == 'message':
+                                        content = item_dict.get('content', [])
+                                        if content and isinstance(content, list):
+                                            for content_part in content:
+                                                if isinstance(content_part, dict) and 'text' in content_part:
+                                                    final_response_text = content_part['text']
+                                                    break
+                            except Exception as e:
+                                logger.warning(f"Failed to serialize item in stream_response: {e}")
+                                continue
 
                     yield event
 

agentex/lib/cli/commands/init.py

@@ -125,16 +125,16 @@ def init():
     table.add_column("Template", style="cyan", no_wrap=True)
     table.add_column("Description", style="white")
     table.add_row(
-        "[bold cyan]Agentic - ACP Only[/bold cyan]",
-        "A simple synchronous agent that handles tasks directly. Best for straightforward agents that don't need long-running operations.",
+        "[bold cyan]Async - ACP Only[/bold cyan]",
+        "Asynchronous, non-blocking agent that can process multiple concurrent requests. Best for straightforward asynchronous agents that don't need durable execution. Good for asynchronous workflows, stateful applications, and multi-step analysis.",
     )
     table.add_row(
-        "[bold cyan]Agentic - Temporal[/bold cyan]",
-        "An asynchronous agent powered by Temporal workflows. Best for agents that need to handle long-running tasks, retries, or complex state management.",
+        "[bold cyan]Async - Temporal[/bold cyan]",
+        "Asynchronous, non-blocking agent with durable execution for all steps. Best for production-grade agents that require complex multi-step tool calls, human-in-the-loop approvals, and long-running processes that require transactional reliability.",
     )
     table.add_row(
         "[bold cyan]Sync ACP[/bold cyan]",
-        "A synchronous agent that handles tasks directly. The difference is that this Sync ACP will be required to respond with the results in the same call as the input.Best for straightforward agents that don't need long-running operations.",
+        "Synchronous agent that processes one request per task with a simple request-response pattern. Best for low-latency use cases, FAQ bots, translation services, and data lookups.",
     )
     console.print()
     console.print(table)
@@ -151,8 +151,8 @@ def init():
     template_type = questionary.select(
         "What type of template would you like to create?",
         choices=[
-            {"name": "Agentic - ACP Only", "value": TemplateType.DEFAULT},
-            {"name": "Agentic - Temporal", "value": TemplateType.TEMPORAL},
+            {"name": "Async - ACP Only", "value": TemplateType.DEFAULT},
+            {"name": "Async - Temporal", "value": TemplateType.TEMPORAL},
             {"name": "Sync ACP", "value": TemplateType.SYNC},
         ],
     ).ask()
@@ -184,16 +184,6 @@ def init():
     ).ask()
     if not description:
         return
-    
-    agent_input_type = questionary.select(
-        "What type of input will your agent handle?",
-        choices=[
-            {"name": "Text Input", "value": "text"},
-            {"name": "Structured Input", "value": "json"},
-        ],    
-    ).ask()
-    if not agent_input_type:
-        return
 
     use_uv = questionary.select(
         "Would you like to use uv for package management?",
@@ -206,7 +196,6 @@ def init():
     answers = {
         "template_type": template_type,
         "project_path": project_path,
-        "agent_input_type": agent_input_type,
         "agent_name": agent_name,
         "agent_directory_name": agent_directory_name,
         "description": description,

agentex/lib/cli/templates/default/README.md.j2

@@ -95,7 +95,7 @@ The notebook includes:
 - **Async message subscription**: Subscribe to server-side events to receive agent responses
 - **Rich message display**: Beautiful formatting with timestamps and author information
 
-The notebook automatically uses your agent name (`{{ agent_name }}`) and demonstrates the agentic ACP workflow: create task → send event → subscribe to responses.
+The notebook automatically uses your agent name (`{{ agent_name }}`) and demonstrates the async ACP workflow: create task → send event → subscribe to responses.
 
 ### 3. Manage Dependencies
 

agentex/lib/cli/templates/default/dev.ipynb.j2

@@ -29,7 +29,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# (REQUIRED) Create a new task. For Agentic agents, you must create a task for messages to be associated with.\n",
+    "# (REQUIRED) Create a new task. For Async agents, you must create a task for messages to be associated with.\n",
     "import uuid\n",
     "\n",
     "rpc_response = client.agents.create_task(\n",

agentex/lib/cli/templates/default/manifest.yaml.j2

@@ -57,7 +57,7 @@ local_development:
 # Agent Configuration
 # -----------------
 agent:
-  acp_type: agentic
+  acp_type: async
   
   # Unique name for your agent
   # Used for task routing and monitoring
@@ -67,9 +67,6 @@ agent:
   # Helps with documentation and discovery
   description: {{ description }}
 
-  # Type of input the agent will handle: text or json
-  agent_input_type: {{ agent_input_type }}
-
   # Temporal workflow configuration
   # Set enabled: true to use Temporal workflows for long-running tasks
   temporal:

agentex/lib/cli/templates/default/project/acp.py.j2

@@ -1,12 +1,12 @@
 from agentex.lib.sdk.fastacp.fastacp import FastACP
-from agentex.lib.types.fastacp import AgenticACPConfig
+from agentex.lib.types.fastacp import AsyncACPConfig
 from agentex.lib.types.acp import SendEventParams, CancelTaskParams, CreateTaskParams
 
 
 # Create an ACP server
 acp = FastACP.create(
-    acp_type="agentic",
-    config=AgenticACPConfig(type="base")
+    acp_type="async",
+    config=AsyncACPConfig(type="base")
 )
 
 

agentex/lib/cli/templates/default/test_agent.py.j2

@@ -24,7 +24,7 @@ from agentex import AsyncAgentex
 from agentex.types import TaskMessage
 from agentex.types.agent_rpc_params import ParamsCreateTaskRequest
 from agentex.types.text_content_param import TextContentParam
-from test_utils.agentic import (
+from test_utils.async_utils import (
     poll_for_agent_response,
     send_event_and_poll_yielding,
     stream_agent_response,

agentex/lib/cli/templates/sync/manifest.yaml.j2

@@ -66,9 +66,6 @@ agent:
   # Helps with documentation and discovery
   description: {{ description }}
 
-  # Type of input the agent will handle: text or json
-  agent_input_type: {{ agent_input_type }}
-
   # Temporal workflow configuration
   # Set enabled: true to use Temporal workflows for long-running tasks
   temporal:

agentex/lib/cli/templates/temporal/README.md.j2

@@ -101,7 +101,7 @@ The notebook includes:
 - **Async message subscription**: Subscribe to server-side events to receive agent responses
 - **Rich message display**: Beautiful formatting with timestamps and author information
 
-The notebook automatically uses your agent name (`{{ agent_name }}`) and demonstrates the agentic ACP workflow: create task → send event → subscribe to responses.
+The notebook automatically uses your agent name (`{{ agent_name }}`) and demonstrates the async ACP workflow: create task → send event → subscribe to responses.
 
 ### 3. Develop Temporal Workflows
 - Edit `workflow.py` to define your agent's async workflow logic

agentex/lib/cli/templates/temporal/dev.ipynb.j2

@@ -29,7 +29,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# (REQUIRED) Create a new task. For Agentic agents, you must create a task for messages to be associated with.\n",
+    "# (REQUIRED) Create a new task. For Async agents, you must create a task for messages to be associated with.\n",
     "import uuid\n",
     "\n",
     "rpc_response = client.agents.create_task(\n",

agentex/lib/cli/templates/temporal/manifest.yaml.j2

@@ -64,8 +64,8 @@ local_development:
 # Agent Configuration
 # -----------------
 agent:
-  # Type of agent - either sync or agentic
-  acp_type: agentic
+  # Type of agent - either sync or async
+  acp_type: async
 
   # Unique name for your agent
   # Used for task routing and monitoring
@@ -75,9 +75,6 @@ agent:
   # Helps with documentation and discovery
   description: {{ description }}
 
-  # Type of input the agent will handle: text or json
-  agent_input_type: {{ agent_input_type }}
-
   # Temporal workflow configuration
   # This enables your agent to run as a Temporal workflow for long-running tasks
   temporal:

agentex/lib/cli/templates/temporal/project/acp.py.j2

@@ -39,7 +39,7 @@ from agentex.lib.types.fastacp import TemporalACPConfig
 
 # Create the ACP server
 acp = FastACP.create(
-    acp_type="agentic",
+    acp_type="async",
     config=TemporalACPConfig(
         # When deployed to the cluster, the Temporal address will automatically be set to the cluster address
         # For local development, we set the address manually to talk to the local Temporal service set up via docker compose

agentex/lib/cli/templates/temporal/test_agent.py.j2

@@ -24,7 +24,7 @@ from agentex import AsyncAgentex
 from agentex.types import TaskMessage
 from agentex.types.agent_rpc_params import ParamsCreateTaskRequest
 from agentex.types.text_content_param import TextContentParam
-from test_utils.agentic import (
+from test_utils.async_utils import (
     poll_for_agent_response,
     send_event_and_poll_yielding,
     stream_agent_response,

agentex/lib/core/temporal/plugins/openai_agents/models/temporal_streaming_model.py

@@ -62,6 +62,43 @@ from agentex.lib.core.temporal.plugins.openai_agents.interceptors.context_interc
 # Create logger for this module
 logger = logging.getLogger("agentex.temporal.streaming")
 
+
+def _serialize_item(item: Any) -> dict[str, Any]:
+    """
+    Universal serializer for any item type from OpenAI Agents SDK.
+
+    Uses model_dump() for Pydantic models, otherwise extracts attributes manually.
+    Filters out internal Pydantic fields that can't be serialized.
+    """
+    if hasattr(item, 'model_dump'):
+        # Pydantic model - use model_dump for proper serialization
+        try:
+            return item.model_dump(mode='json', exclude_unset=True)
+        except Exception:
+            # Fallback to dict conversion
+            return dict(item) if hasattr(item, '__iter__') else {}
+    else:
+        # Not a Pydantic model - extract attributes manually
+        item_dict = {}
+        for attr_name in dir(item):
+            if not attr_name.startswith('_') and attr_name not in ('model_fields', 'model_config', 'model_computed_fields'):
+                try:
+                    attr_value = getattr(item, attr_name, None)
+                    # Skip methods and None values
+                    if attr_value is not None and not callable(attr_value):
+                        # Convert to JSON-serializable format
+                        if hasattr(attr_value, 'model_dump'):
+                            item_dict[attr_name] = attr_value.model_dump()
+                        elif isinstance(attr_value, (str, int, float, bool, list, dict)):
+                            item_dict[attr_name] = attr_value
+                        else:
+                            item_dict[attr_name] = str(attr_value)
+                except Exception:
+                    # Skip attributes that can't be accessed
+                    pass
+        return item_dict
+
+
 class TemporalStreamingModel(Model):
     """Custom model implementation with streaming support."""
 
@@ -739,6 +776,35 @@ class TemporalStreamingModel(Model):
                     output_tokens_details=OutputTokensDetails(reasoning_tokens=len(''.join(reasoning_contents)) // 4),  # Approximate
                 )
 
+                # Serialize response output items for span tracing
+                new_items = []
+                final_output = None
+
+                for item in response_output:
+                    try:
+                        item_dict = _serialize_item(item)
+                        if item_dict:
+                            new_items.append(item_dict)
+
+                            # Extract final_output from message type if available
+                            if item_dict.get('type') == 'message' and not final_output:
+                                content = item_dict.get('content', [])
+                                if content and isinstance(content, list):
+                                    for content_part in content:
+                                        if isinstance(content_part, dict) and 'text' in content_part:
+                                            final_output = content_part['text']
+                                            break
+                    except Exception as e:
+                        logger.warning(f"Failed to serialize item in temporal_streaming_model: {e}")
+                        continue
+
+                # Set span output with structured data
+                if span:
+                    span.output = {
+                        "new_items": new_items,
+                        "final_output": final_output,
+                    }
+
                 # Return the response
                 return ModelResponse(
                     output=response_output,

agentex/lib/core/temporal/plugins/openai_agents/models/temporal_tracing_model.py

@@ -7,9 +7,10 @@ context interceptor to access task_id, trace_id, and parent_span_id.
 The key innovation is that these are thin wrappers around the standard OpenAI models,
 avoiding code duplication while adding tracing capabilities.
 """
+from __future__ import annotations
 
 import logging
-from typing import List, Union, Optional, override
+from typing import Any, List, Union, Optional, override
 
 from agents import (
     Tool,
@@ -41,6 +42,42 @@ from agentex.lib.core.temporal.plugins.openai_agents.interceptors.context_interc
 logger = logging.getLogger("agentex.temporal.tracing")
 
 
+def _serialize_item(item: Any) -> dict[str, Any]:
+    """
+    Universal serializer for any item type from OpenAI Agents SDK.
+
+    Uses model_dump() for Pydantic models, otherwise extracts attributes manually.
+    Filters out internal Pydantic fields that can't be serialized.
+    """
+    if hasattr(item, 'model_dump'):
+        # Pydantic model - use model_dump for proper serialization
+        try:
+            return item.model_dump(mode='json', exclude_unset=True)
+        except Exception:
+            # Fallback to dict conversion
+            return dict(item) if hasattr(item, '__iter__') else {}
+    else:
+        # Not a Pydantic model - extract attributes manually
+        item_dict = {}
+        for attr_name in dir(item):
+            if not attr_name.startswith('_') and attr_name not in ('model_fields', 'model_config', 'model_computed_fields'):
+                try:
+                    attr_value = getattr(item, attr_name, None)
+                    # Skip methods and None values
+                    if attr_value is not None and not callable(attr_value):
+                        # Convert to JSON-serializable format
+                        if hasattr(attr_value, 'model_dump'):
+                            item_dict[attr_name] = attr_value.model_dump()
+                        elif isinstance(attr_value, (str, int, float, bool, list, dict)):
+                            item_dict[attr_name] = attr_value
+                        else:
+                            item_dict[attr_name] = str(attr_value)
+                except Exception:
+                    # Skip attributes that can't be accessed
+                    pass
+        return item_dict
+
+
 class TemporalTracingModelProvider(OpenAIProvider):
     """Model provider that returns OpenAI models wrapped with AgentEx tracing.
 
@@ -171,15 +208,35 @@ class TemporalTracingResponsesModel(Model):
                         **kwargs,
                     )
 
-                    # Add response info to span output
+                    # Serialize response output items for span tracing
+                    new_items = []
+                    final_output = None
+
+                    if hasattr(response, 'output') and response.output:
+                        response_output = response.output if isinstance(response.output, list) else [response.output]
+
+                        for item in response_output:
+                            try:
+                                item_dict = _serialize_item(item)
+                                if item_dict:
+                                    new_items.append(item_dict)
+
+                                    # Extract final_output from message type if available
+                                    if item_dict.get('type') == 'message' and not final_output:
+                                        content = item_dict.get('content', [])
+                                        if content and isinstance(content, list):
+                                            for content_part in content:
+                                                if isinstance(content_part, dict) and 'text' in content_part:
+                                                    final_output = content_part['text']
+                                                    break
+                            except Exception as e:
+                                logger.warning(f"Failed to serialize item in temporal tracing model: {e}")
+                                continue
+
+                    # Set span output with structured data
                     span.output = {  # type: ignore[attr-defined]
-                        "response_id": getattr(response, "id", None),
-                        "model_used": getattr(response, "model", None),
-                        "usage": {
-                            "input_tokens": response.usage.input_tokens if response.usage else None,
-                            "output_tokens": response.usage.output_tokens if response.usage else None,
-                            "total_tokens": response.usage.total_tokens if response.usage else None,
-                        } if response.usage else None,
+                        "new_items": new_items,
+                        "final_output": final_output,
                     }
 
                     return response
@@ -284,15 +341,35 @@ class TemporalTracingChatCompletionsModel(Model):
                         **kwargs,
                     )
 
-                    # Add response info to span output
+                    # Serialize response output items for span tracing
+                    new_items = []
+                    final_output = None
+
+                    if hasattr(response, 'output') and response.output:
+                        response_output = response.output if isinstance(response.output, list) else [response.output]
+
+                        for item in response_output:
+                            try:
+                                item_dict = _serialize_item(item)
+                                if item_dict:
+                                    new_items.append(item_dict)
+
+                                    # Extract final_output from message type if available
+                                    if item_dict.get('type') == 'message' and not final_output:
+                                        content = item_dict.get('content', [])
+                                        if content and isinstance(content, list):
+                                            for content_part in content:
+                                                if isinstance(content_part, dict) and 'text' in content_part:
+                                                    final_output = content_part['text']
+                                                    break
+                            except Exception as e:
+                                logger.warning(f"Failed to serialize item in temporal tracing model: {e}")
+                                continue
+
+                    # Set span output with structured data
                     span.output = {  # type: ignore[attr-defined]
-                        "response_id": getattr(response, "id", None),
-                        "model_used": getattr(response, "model", None),
-                        "usage": {
-                            "input_tokens": response.usage.input_tokens if response.usage else None,
-                            "output_tokens": response.usage.output_tokens if response.usage else None,
-                            "total_tokens": response.usage.total_tokens if response.usage else None,
-                        } if response.usage else None,
+                        "new_items": new_items,
+                        "final_output": final_output,
                     }
 
                     return response