openai client: the prompt, the model, token counts, and latency. Bitfab works out the cost from the model and the token counts, or keeps the cost the response reports when it carries one.
Canonical signatures: TypeScript wrapOpenAIResponses · Python wrap_openai_responses
Language Support
Under a trace root
Beneath a trace root, everyresponses.create call on an openai client is recorded with no wrapper, whatever its base URL, as its own llm span named Responses.create (Python’s async client: AsyncResponses.create). responses.parse (Responses.parse) and streamed calls are recorded too. The span attaches under the function that made the call.
detect, then classify, then an llm span named Responses.create carrying the prompt, tokens, and cost.
In TypeScript, the build transform rewrites each .responses.create(...) call site in your code, so it works in bundled apps and the SDK never loads or patches openai. The client’s own APIPromise is handed back, so .withResponse() and .asResponse() keep working. In Python, the SDK patches the openai responses classes when a trace() root is set up. Calls made through with_raw_response (as Braintrust’s wrap_openai and Langfuse do) are recorded with their usage too, and the response’s .parse() still returns the same object.
exclude on the root matches the method name ("create", "parse") or the span name, and withNode() / node() on a wrapper (below) configures the one span.
Streaming
A streamed call (stream: true / stream=True, or responses.stream(), which is recorded as its Responses.create call) is recorded as one llm span when the stream finishes, is closed, or fails, with usage read from the last event. A stream returned from the trace root keeps the trace open until your code reads it. A stream your code drops without reading to the end is recorded when the runtime frees it, with the request and whatever was read but usually no usage, and its trace finishes then. Streamed calls always run for real during a replay, and the wrappers never record a stream.
A withNode() / node() placed directly on the client method records the stream on its own span instead of opening a second one. That span ends when the stream does, and the node’s finalize is not used.
Wrapping a call
UsewrapOpenAIResponses() / wrap_openai_responses() when you trace with withSpan() / span() instead of a trace root. It wraps the function that sends the request and writes the prompt and usage into the span that is current when the call starts. It opens no span of its own.
Responses.create records nothing more. onResponse / on_response receives each response after it is recorded.
No duplicate spans
Each model call is recorded once:- A wrapper around a call the trace root already recorded adds nothing.
- A call the OpenAI Agents SDK integration is recording as a generation or response span, or the LangChain callback handler is recording as an LLM run, is not recorded a second time. This includes a call made inside your own LangChain chat model class or inside your own Agents model class that opens a generation span. A call made alongside a LangChain run in the same trace is still recorded, except beside the first LangChain run in a TypeScript process (see Limitations).
- In TypeScript, calls made inside framework libraries in
node_modulesare never rewritten by the build transform, so only the framework’s own integration records them. The built-inOpenAIResponsesModelopens a response span, so its calls are left to that integration. In Python, the SDK patches the client classes, so a call another library makes through the client is recorded too, unless that library has a Bitfab integration recording it.
responses.create directly opens no generation or response span, so its calls are recorded as Responses.create spans under the agent run.
What gets captured
The context fields go in one context entry on the span. A key the response does not carry is left out. Without
costUsd, Bitfab works out the cost from model and the token counts.
Limitations
- Calls outside any trace are not recorded. A wrapper used outside a span or trace records nothing and never starts a trace of its own.
- TypeScript automatic capture needs the build transform. Code the transform does not compile (for example a call made from a dependency) is not rewritten; wrap it instead.
- TypeScript: calls beside the first LangChain run in a process. The SDK hooks into LangChain in the background when the first Bitfab LangChain handler or
withTrace()root is created. If a LangChain run starts before that finishes, calls made inside it are still recorded once, but a call made at the same time outside it (for example inPromise.all) is not recorded while that first run is open. Later runs are not affected. - Python automatic capture needs Python 3.12+, the same as
trace()subtree capture. - Only
responses.create,responses.parse, andresponses.stream. For chat completions, embeddings, and transcriptions, see OpenAI API.