Vercel

import { wrapNextjsConfigWithBraintrust } from "braintrust/next";

const nextConfig = {};

export default wrapNextjsConfigWithBraintrust(nextConfig);

import * as ai from "ai";
import { openai } from "@ai-sdk/openai";
import { braintrustAISDKTelemetry, initLogger } from "braintrust";

initLogger({
  projectName: "My AI Project",
  apiKey: process.env.BRAINTRUST_API_KEY,
});

ai.registerTelemetry(braintrustAISDKTelemetry());

async function main() {
  const { text } = await ai.generateText({
    model: openai("gpt-5-mini"),
    prompt: "What is the capital of France?",
  });
  console.log(text);
}

main().catch(console.error);

import { initLogger, wrapAISDK } from "braintrust";
import * as ai from "ai";
import { openai } from "@ai-sdk/openai";

initLogger({
  projectName: "My AI Project",
  apiKey: process.env.BRAINTRUST_API_KEY,
});

const { generateText } = wrapAISDK(ai);

async function main() {
  // This will automatically log the request, response, and metrics to Braintrust
  const { text } = await generateText({
    model: openai("gpt-5-mini"),
    prompt: "What is the capital of France?",
  });
  console.log(text);
}

main().catch(console.error);

const { text } = await generateText({
  model: openai("gpt-5-mini"),
  prompt: "What is 127 multiplied by 49?",
  tools: {
    multiply: {
      description: "Multiply two numbers",
      inputSchema: z.object({
        a: z.number(),
        b: z.number(),
      }),
      execute: async ({ a, b }: { a: number; b: number }) => a * b,
    },
  },
});

const tools = {
  multiply: {
    description: "Multiply two numbers",
    inputSchema: z.object({
      a: z.number(),
      b: z.number(),
    }),
    execute: async ({ a, b }: { a: number; b: number }) => a * b,
  },
};

const result = streamText({
  model: openai("gpt-5-mini"),
  prompt: "What is 127 multiplied by 49?",
  tools,
});

for await (const delta of result.textStream) {
  process.stdout.write(delta);
}

return traced(
  async (span) => {
    const { text } = await generateText({
      model: openai("gpt-5-mini"),
      prompt,
    });

    span.log({
      input: prompt,
      output: text,
      metadata: {
        userId,
        userTier,
      },
    });

    return text;
  },
  { name: "generate-with-context", type: "function" }
);

const { Experimental_Agent: Agent } = wrapAISDK(ai);

const agent = new Agent({
  model: openai("gpt-5-mini"),
  system: "You are a helpful assistant.",
});

const result = await agent.generate({
  prompt: "What is the capital of France?",
});

import * as ai from "ai";
import {
  completeAISDKBatchTrace,
  initLogger,
  startAISDKBatchTrace,
} from "braintrust";

const logger = initLogger({ projectName: "My AI Project" });

const provider = ai.createGateway(); // Replace with your batch provider
const requests = ["one", "two"].map((id) => ({
  id,
  type: "text" as const,
  model: "google/gemini-2.5-flash",
  prompt: `Reply with only the word ${id}.`,
}));

// When you submit the batch
const startTime = Date.now() / 1000;
const submitted = await ai.experimental_startBatch({ provider, requests });
const context = await startAISDKBatchTrace({
  batch: submitted,
  requests,
  startTime,
});
await logger.flush();
// Store the batch reference, requests, and context, for example in your database
const batch = {
  version: submitted.version,
  id: submitted.id,
  provider: submitted.provider,
};

// When the batch finishes, in the same or another process
const status = await ai.experimental_getBatchStatus({ provider, batch });
const results = [];
for await (const item of ai.experimental_getBatchResults({ provider, batch })) {
  results.push(item);
}
await completeAISDKBatchTrace({ batch, requests, context, status, results });
await logger.flush();

import * as codeModeModule from "@ai-sdk/code-mode";
import { jsonSchema } from "ai";
import { initLogger, wrapAISDK } from "braintrust";

initLogger({ projectName: "My AI Project" });

const codeMode = wrapAISDK(codeModeModule);

const result = await codeMode.experimental_runCodeMode({
  js: "const a = await tools.double({ value: 2 }); return await tools.double(a);",
  tools: {
    double: {
      inputSchema: jsonSchema<{ value: number }>({
        type: "object",
        properties: { value: { type: "number" } },
        required: ["value"],
      }),
      async execute({ value }: { value: number }) {
        return { value: value * 2 };
      },
    },
  },
});