Issue in the span hierarchy in Python SDK

[JussiSpogen]

Hi, You are doing great work with your library! I like the UI a lot and still in the progress of learning about all the things you can do with Braintrust.

I'm having a little problem with the hierarchy of my span. So I'm creating a custom Agent-loop for my application. I have figured out stuff like marking spans as tool calls or LLM calls and such. How ever when I have a tool call that does OpenAI call the OpenAI call gets logged, but it is not under the tool call but after it as seen in the screenshot taken from your UI. I'll include a small (non-working) example code of my situation also to make the situation hopefully more clear. Am I forgetting to do something here or is this a limitation in your SDK?

def call_search(args):
    query = args["query"]
    # Custom wrapper for openai client to embed a phrase. Uses wrap_openai(openai.AsyncOpenAi()) under the hood
    embed = llm_embed(query)
    # Rest of some vector search functionality
    return results

@traced
def tool_caller(tool_name: str, args: Any):
    if tool.name == "search":
        result = call_search(args)
        return result

def my_agent_loop():
    context = ...
    while True:
        call_result = call_agent(context)
        if call_result.tool_calls:
            for tool_call in call_result.tool_calls:
                result = tool_caller(tool_call.name, tool_call.args)
                context.append(result)

I'm using the latest Python SDK

[clutchski]

@JussiSpogen I couldn't reproduce this. Can you provide (a) a fully functioning script and (b) the exact version of the library you're running (c) any details about the context that this is running in. does it have threads asyncio, etc?

[JussiSpogen]

Hi, thanks for quick response. I created a small test script that should let you reproduce the issue. This script produces tracing as shown in the screenshot included. The script runs a single tool call and returns a dummy response.

I use Azure as the openai provider but it shouldn't matter.

I have a version 0.5.0 of the braintrust library and python 3.13.2. My openai dependency is "openai[aiohttp]~=2.13.0"

My actual use case involves Fastapi and therefore I use async.

from openai.types.responses import ResponseOutputMessage
from openai.types.responses import ResponseFunctionToolCall
import json
from braintrust import SpanTypeAttribute
from braintrust import start_span
import asyncio

from braintrust import current_span, init_logger, traced, wrap_openai
from openai import AsyncOpenAI, DefaultAioHttpClient
from openai.types.responses import Response

from src.config import Config

init_logger("Debug braintrust")

client = wrap_openai(
    AsyncOpenAI(
        base_url="AZURE_INSTANCE_URL",
        api_key=Config.azure_openai_api_key,
        max_retries=3,
        timeout=4.0,
        http_client=DefaultAioHttpClient(),
    )
)


async def llm_caller(messages: list) -> Response:
    response = await client.responses.create(
        model="gpt-5-nano",
        input=messages,
        tools=[
            {
                "type": "function",
                "name": "tool_call",
                "description": ("Takes input and returns something random"),
                "parameters": {
                    "type": "object",
                    "properties": {
                        "query": {
                            "type": "string",
                            "description": "Any input text",
                        }
                    },
                },
            }
        ],
    )
    return response


async def tool_call(input_text: str) -> str:
    span = start_span(name="tool_call", type=SpanTypeAttribute.TOOL, set_current=True)
    span.log(input={"input_text": input_text})
    embedding = await client.embeddings.create(
        model="text-embedding-3-large",
        input=input_text,
    )
    print("Embedding successfully created")
    span.log(output={"embedding": embedding.data[0].embedding, "dummy": "dummy"})
    return "Random output"


@traced(name="Agent Search", notrace_io=True)
async def main():
    current_span().log(input={"input_text": "hello world"})
    messages = [
        {
            "role": "system",
            "content": "Run one tool call with the input text and return the result of the tool call.",
        },
        {"role": "user", "content": "hello world"},
    ]
    run = True
    while run:
        response = await llm_caller(messages)
        for item in response.output:
            print(item)
            messages.append(item)
            if isinstance(item, ResponseFunctionToolCall):
                print("tool call")
                args = json.loads(item.arguments)
                tool_output = await tool_call(args["query"])
                messages.append({
                    "type": "function_call_output",
                    "call_id": item.call_id,
                    "output": tool_output,
                })
            if isinstance(item, ResponseOutputMessage):
                print("output message")
                print(item.content)
                run = False


if __name__ == "__main__":
    asyncio.run(main())