Add tool outputs

Author: danielmillerp

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

@@ -452,16 +452,36 @@ async def get_response(
 
         trace = self.tracer.trace(trace_id)
 
+        # Serialize input for span tracing
+        span_input = {
+            "model": self.model_name,
+            "has_system_instructions": system_instructions is not None,
+            "input_type": type(input).__name__,
+            "tools_count": len(tools) if tools else 0,
+            "handoffs_count": len(handoffs) if handoffs else 0,
+        }
+
+        # Include actual input content for traceability
+        try:
+            if isinstance(input, str):
+                span_input["input_content"] = input
+            elif isinstance(input, list):
+                # Serialize input items
+                serialized_input = []
+                for item in input:
+                    try:
+                        serialized_input.append(_serialize_item(item))
+                    except Exception:
+                        pass
+                if serialized_input:
+                    span_input["input_items"] = serialized_input
+        except Exception as e:
+            logger.warning(f"Failed to serialize input for span: {e}")
+
         async with trace.span(
             parent_id=parent_span_id,
             name="streaming_model_get_response",
-            input={
-                "model": self.model_name,
-                "has_system_instructions": system_instructions is not None,
-                "input_type": type(input).__name__,
-                "tools_count": len(tools) if tools else 0,
-                "handoffs_count": len(handoffs) if handoffs else 0,
-            },
+            input=span_input,
         ) as span:
             # Always use Responses API for streaming
             if not task_id:
@@ -826,6 +846,8 @@ async def get_response(
                 # Serialize response output items for span tracing
                 new_items = []
                 final_output = None
+                tool_calls = []
+                tool_outputs = []
 
                 for item in response_output:
                     try:
@@ -845,12 +867,38 @@ async def get_response(
                         logger.warning(f"Failed to serialize item in temporal_streaming_model: {e}")
                         continue
 
+                # Extract tool calls and outputs from input
+                try:
+                    if isinstance(input, list):
+                        for item in input:
+                            try:
+                                item_dict = _serialize_item(item) if not isinstance(item, dict) else item
+                                if item_dict:
+                                    # Capture function calls
+                                    if item_dict.get('type') == 'function_call':
+                                        tool_calls.append(item_dict)
+                                    # Capture function outputs
+                                    elif item_dict.get('type') == 'function_call_output':
+                                        tool_outputs.append(item_dict)
+                            except Exception:
+                                pass
+                except Exception as e:
+                    logger.warning(f"Failed to extract tool calls and outputs: {e}")
+
                 # Set span output with structured data
                 if span:
-                    span.output = {
+                    output_data = {
                         "new_items": new_items,
                         "final_output": final_output,
                     }
+                    # Include tool calls if any were in the input
+                    if tool_calls:
+                        output_data["tool_calls"] = tool_calls
+                    # Include tool outputs if any were processed
+                    if tool_outputs:
+                        output_data["tool_outputs"] = tool_outputs
+                    
+                    span.output = output_data
 
                 # Return the response
                 return ModelResponse(