Anthropic

​

Language Support

​

Under a trace root

import Anthropic from "@anthropic-ai/sdk"
import { Bitfab } from "@bitfab/sdk"

const bitfab = new Bitfab({ apiKey: process.env.BITFAB_API_KEY })
const anthropic = new Anthropic()

async function classify(email: string) {
  const message = await anthropic.messages.create({
    model: "claude-sonnet-4-5",
    max_tokens: 1024,
    system: "You classify email.",
    messages: [{ role: "user", content: email }],
  })
  const [block] = message.content
  return block?.type === "text" ? block.text : undefined
}

export const detect = bitfab.withTrace("inbox-detection", (email: string) =>
  classify(email),
)

from anthropic import Anthropic
from bitfab import Bitfab

bitfab = Bitfab()
anthropic = Anthropic()


def classify(email: str) -> str:
    message = anthropic.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        system="You classify email.",
        messages=[{"role": "user", "content": email}],
    )
    return message.content[0].text


@bitfab.trace("inbox-detection", type="llm")
def detect(email: str) -> str:
    return classify(email)

​

Wrapping a call

const send = bitfab.wrapAnthropic(
  anthropic.messages.create.bind(anthropic.messages),
)

const classify = bitfab.withSpan(
  "classify-email",
  { type: "llm" },
  async (email: string) => {
    const message = await send({
      model: "claude-sonnet-4-5",
      max_tokens: 1024,
      messages: [{ role: "user", content: email }],
    })
    const [block] = message.content
    return block?.type === "text" ? block.text : undefined
  },
)

send = bitfab.wrap_anthropic(anthropic.messages.create)


@bitfab.span("classify-email", type="llm")
def classify(email: str) -> str:
    message = send(
        model="claude-sonnet-4-5",
        max_tokens=1024,
        messages=[{"role": "user", "content": email}],
    )
    return message.content[0].text

​

No duplicate spans

• 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_modules are never rewritten by the build transform, so only the framework’s own integration records them.

​

What gets captured

​

Limitations

• Streaming calls are not recorded. A call with stream: true / stream=True, or through messages.stream(), runs normally and records nothing.
• 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 in Promise.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.
• Cache writes are priced at the input rate. Anthropic charges more for tokens written to the prompt cache, so calls that write a lot to the cache show a slightly low cost.
• Only messages.create. The beta.messages client and messages.parse helpers are not recorded.