Capture Reasoning Content Reasoning Tools

Capture available tool-generated reasoning from a completed run and its successful terminal streaming event.

capture_reasoning_content_reasoning_tools.py
"""
Capture Reasoning Content Reasoning Tools
=========================================

Demonstrates this reasoning cookbook example.
"""

from textwrap import dedent

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.reasoning import ReasoningTools


# ---------------------------------------------------------------------------
# Create Example
# ---------------------------------------------------------------------------
def run_example() -> None:
    """Test function to verify reasoning_content is populated in RunOutput."""
    print("\n=== Testing reasoning_content generation ===\n")

    # Create an agent with ReasoningTools
    agent = Agent(
        model=OpenAIChat(id="gpt-5.6-luna"),
        tools=[ReasoningTools(add_instructions=True)],
        instructions=dedent("""\
            You are an expert problem-solving assistant with strong analytical skills!         Use step-by-step reasoning to solve the problem.
            \
        """),
    )

    # Test 1: Non-streaming mode
    print("Running with stream=False...")
    response = agent.run(
        "What is the sum of the first 10 natural numbers?", stream=False
    )

    # Check reasoning_content
    if hasattr(response, "reasoning_content") and response.reasoning_content:
        print("[OK] reasoning_content FOUND in non-streaming response")
        print(f"   Length: {len(response.reasoning_content)} characters")
        print("\n=== reasoning_content preview (non-streaming) ===")
        preview = response.reasoning_content[:1000]
        if len(response.reasoning_content) > 1000:
            preview += "..."
        print(preview)
    else:
        print("[NOT FOUND] reasoning_content NOT FOUND in non-streaming response")

    # Process streaming responses to find the final one
    print("\n\n=== Test 2: Processing stream to find final response ===\n")

    # Create another fresh agent
    streaming_agent_alt = Agent(
        model=OpenAIChat(id="gpt-5.6-luna"),
        tools=[ReasoningTools(add_instructions=True)],
        instructions=dedent("""\
            You are an expert problem-solving assistant with strong analytical skills!         Use step-by-step reasoning to solve the problem.
            \
        """),
    )

    # Process streaming responses and look for the final RunOutput
    final_response = None
    for event in streaming_agent_alt.run(
        "What is the value of 3! (factorial)?",
        stream=True,
        stream_events=True,
    ):
        # The final event in the stream should be a RunOutput object
        if hasattr(event, "reasoning_content"):
            final_response = event

    print("--- Checking reasoning_content from final stream event ---")
    if (
        final_response
        and hasattr(final_response, "reasoning_content")
        and final_response.reasoning_content
    ):
        print("[OK] reasoning_content FOUND in final stream event")
        print(f"   Length: {len(final_response.reasoning_content)} characters")
        print("\n=== reasoning_content preview (final stream event) ===")
        preview = final_response.reasoning_content[:1000]
        if len(final_response.reasoning_content) > 1000:
            preview += "..."
        print(preview)
    else:
        print("[NOT FOUND] reasoning_content NOT FOUND in final stream event")


# ---------------------------------------------------------------------------
# Run Example
# ---------------------------------------------------------------------------
if __name__ == "__main__":
    run_example()

Gate capture on successful completion

Reasoning content appears when the model selects the relevant tools. A reasoning event can arrive before the model later fails, so finding a reasoning_content attribute does not prove that a run completed.

Before running the preserved program, add these imports:

from agno.run.agent import RunEvent
from agno.run.base import RunStatus

Immediately after the non-streaming response = agent.run(...) call, add:

if response.status != RunStatus.completed:
    raise RuntimeError(f"Run ended with {response.status}")

Inside the streaming loop, replace the if hasattr(event, "reasoning_content"): assignment block with:

if event.event in (RunEvent.run_error, RunEvent.run_cancelled):
    raise RuntimeError(f"Stream ended with {event.event}")
if event.event == RunEvent.run_completed:
    final_response = event

After the loop, before printing its final-result checks, add:

if final_response is None:
    raise RuntimeError("Stream ended without RunCompleted")

The selected object is a RunCompletedEvent, rather than a final RunOutput. Keep the existing nonempty-content check: a completed run can contain no tool-generated reasoning. These tools expose model-authored scratchpad text; their output is not a private internal trace.

Run the Example

Set up your virtual environment

uv venv --python 3.12
source .venv/bin/activate

Install dependencies

uv pip install -U agno openai

Export your OpenAI API key

export OPENAI_API_KEY="your_openai_api_key_here"

Run the example

Save the code above as capture_reasoning_content_reasoning_tools.py, then run:

python capture_reasoning_content_reasoning_tools.py

Full source: cookbook/10_reasoning/tools/capture_reasoning_content_reasoning_tools.py