Gemini

​

Language Support

​

Under a trace root

import { GoogleGenAI } from "@google/genai"
import { Bitfab } from "@bitfab/sdk"

const bitfab = new Bitfab({ apiKey: process.env.BITFAB_API_KEY })
const ai = new GoogleGenAI({})

async function classify(email: string) {
  const response = await ai.models.generateContent({
    model: "gemini-2.5-flash",
    contents: email,
    config: { systemInstruction: "You classify email." },
  })
  return response.text
}

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

from google import genai
from google.genai import types
from bitfab import Bitfab

bitfab = Bitfab()
ai = genai.Client()


def classify(email: str) -> str:
    response = ai.models.generate_content(
        model="gemini-2.5-flash",
        contents=email,
        config=types.GenerateContentConfig(system_instruction="You classify email."),
    )
    return response.text


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

​

Streaming

​

Wrapping a call

const generate = bitfab.wrapGemini(ai.models.generateContent)

const classify = bitfab.withSpan(
  "classify-email",
  { type: "llm" },
  async (email: string) => {
    const response = await generate({ model: "gemini-2.5-flash", contents: email })
    return response.text
  },
)

generate = bitfab.wrap_gemini(ai.models.generate_content)


@bitfab.span("classify-email", type="llm")
def classify(email: str) -> str:
    return generate(model="gemini-2.5-flash", contents=email).text

​

No duplicate spans

• A wrapper around a call the trace root already recorded adds nothing.
• A call the LangChain callback handler is recording as an LLM run is not recorded a second time, including a call made inside your own LangChain chat model class, streamed or not. 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 (such as @langchain/google-genai) are never rewritten by the build transform, so only the framework’s own integration records them. 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.

​

What gets captured

​

Limitations

• Only generateContent and generateContentStream. Embeddings (embedContent), image and video generation, token counting, and the Live API are not recorded.
• 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.