After an approval, the resumed run records the approved tool span outside the agent span #5290

import asyncio
import sys

from agents import Agent, Runner, add_trace_processor, function_tool
from agents.testing import ScriptedModel, assistant_message, function_call
from agents.tracing import TracingProcessor

STREAMED = "--streamed" in sys.argv
spans = {}


class Spans(TracingProcessor):
    def on_trace_start(self, trace): pass
    def on_trace_end(self, trace): pass
    def on_span_start(self, span): pass
    def on_span_end(self, span): spans[span.span_id] = span
    def shutdown(self): pass
    def force_flush(self): pass


add_trace_processor(Spans())


def show(title):
    print(title)
    for s in sorted(spans.values(), key=lambda s: s.started_at):
        parent = spans.get(s.parent_id)
        where = f"{parent.span_data.type}" if parent else "trace root"
        error = f"  error={s.error['message']!r}" if s.error else ""
        print(f"    {s.span_data.type:8} {s.span_data.export().get('name', ''):8} parent={where}{error}")
    spans.clear()


@function_tool(name_override="refund", needs_approval=True, failure_error_function=None)
def approved_refund(order_id: str) -> str:
    return f"refunded {order_id}"


@function_tool(name_override="refund", needs_approval=True, failure_error_function=None)
def approved_failing_refund(order_id: str) -> str:
    raise RuntimeError("payments API down")


@function_tool(name_override="refund", failure_error_function=None)
def failing_refund(order_id: str) -> str:
    raise RuntimeError("payments API down")


async def run(agent, input):
    if STREAMED:
        result = Runner.run_streamed(agent, input)
        async for _ in result.stream_events():
            pass
        return result
    return await Runner.run(agent, input)


def agent_with(tool):
    model = ScriptedModel(
        [[function_call("refund", {"order_id": "A1"}, call_id="c1")], [assistant_message("done")]]
    )
    return Agent(name="support", model=model, tools=[tool])


async def main():
    try:
        await run(agent_with(failing_refund), "refund A1")
    except Exception as e:
        show(f"no approval, tool raises ({type(e).__name__}):")
    for tool in (approved_refund, approved_failing_refund):
        agent = agent_with(tool)
        first = await run(agent, "refund A1")
        spans.clear()  # the first run's paused refund span sits under its turn
        state = first.to_state()
        state.approve(first.interruptions[0])
        try:
            await run(agent, state)
            outcome = "completed"
        except Exception as e:
            outcome = type(e).__name__
        show(f"resumed after approval, tool {'raises' if tool is approved_failing_refund else 'succeeds'} ({outcome}):")


asyncio.run(main())