TypeScript SDK tutorial

import { TruLayer } from "@trulayer/sdk";

const tl = new TruLayer({
  apiKey: process.env.TRULAYER_API_KEY!,
  projectName: "tutorial",
  environment: "development",
});

await tl.trace("answer_question", async (trace) => {
  trace.setInput({ question });
  const answer = await myAgent(question);
  trace.setOutput({ answer });
});

await tl.trace("answer_question", async (trace) => {
  trace.setInput({ question });

  const docs = await trace.span("retrieve", "retrieval", async (span) => {
    const results = await vectorStore.search(question, 5);
    span.setOutput({ docCount: results.length });
    return results;
  });

  const answer = await trace.span("generate", "llm", async (span) => {
    span.setModel("gpt-4o-mini");
    const response = await openai.chat.completions.create({
      model: "gpt-4o-mini",
      messages: buildMessages(question, docs),
    });
    span.setOutput(response.choices[0].message.content);
    span.setTokens({
      promptTokens: response.usage!.prompt_tokens,
      completionTokens: response.usage!.completion_tokens,
    });
    span.setCost(
      (response.usage!.prompt_tokens * 0.15 + response.usage!.completion_tokens * 0.60) / 1_000_000
    );
    return response.choices[0].message.content;
  });

  trace.setOutput({ answer });
});

import OpenAI from "openai";
import { instrumentOpenAI } from "@trulayer/sdk";

const openai = instrumentOpenAI(new OpenAI(), tl);

await tl.trace("answer_question", async (trace) => {
  trace.setInput({ question });
  const response = await openai.chat.completions.create({
    model: "gpt-4o-mini",
    messages: [{ role: "user", content: question }],
  });
  trace.setOutput(response.choices[0].message.content);
});

import Anthropic from "@anthropic-ai/sdk";
import { instrumentAnthropic } from "@trulayer/sdk";

const anthropic = instrumentAnthropic(new Anthropic(), tl);

await tl.trace("answer_question", async (trace) => {
  const message = await anthropic.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 1024,
    messages: [{ role: "user", content: question }],
  });
  trace.setOutput(message.content);
});

import { instrumentVercelAI } from "@trulayer/sdk";
import { openai as aiOpenAI } from "@ai-sdk/openai";
import { generateText } from "ai";

instrumentVercelAI(tl);

await tl.trace("chat", async (trace) => {
  const { text } = await generateText({
    model: aiOpenAI("gpt-4o-mini"),
    prompt: question,
  });
  trace.setOutput({ text });
});

// instrumentation.ts
import { TruLayer } from "@trulayer/sdk";

export async function register() {
  if (process.env.NEXT_RUNTIME === "nodejs") {
    const { instrumentOpenAI } = await import("@trulayer/sdk");
    const OpenAI = (await import("openai")).default;

    const tl = new TruLayer({
      apiKey: process.env.TRULAYER_API_KEY!,
      projectName: "web",
    });

    // Make the patched client available to your routes
    (globalThis as any).openai = instrumentOpenAI(new OpenAI(), tl);
    (globalThis as any).trulayer = tl;
  }
}

// app/api/chat/route.ts
export async function POST(req: Request) {
  const tl = (globalThis as any).trulayer as TruLayer;
  const openai = (globalThis as any).openai;

  return tl.trace("chat", async (trace) => {
    const { message } = await req.json();
    trace.setInput({ message });

    const response = await openai.chat.completions.create({
      model: "gpt-4o-mini",
      messages: [{ role: "user", content: message }],
    });

    trace.setOutput(response.choices[0].message.content);
    return Response.json({ answer: response.choices[0].message.content });
  });
}

export async function POST(req: Request) {
  try {
    return await tl.trace("edge_chat", async (trace) => {
      // ... work ...
      return Response.json({ ok: true });
    });
  } finally {
    await tl.flush();
  }
}

await tl.trace("user_message", async (trace) => {
  trace.setInput({ message });
}, { sessionId: conversationId });

await tl.trace("answer_question", async (trace) => {
  trace.setMetadata({
    userId: "u_42",
    tier: "pro",
    featureFlagRagV2: true,
  });
});

await tl.submitFeedback({
  traceId,
  label: "good",
  score: 0.95,
  comment: "Exactly what I needed.",
});

const tl = new TruLayer({
  apiKey: process.env.TRULAYER_API_KEY!,
  projectName: "prod",
  redact: (value) => {
    if (typeof value === "string") {
      return value
        .replace(/\b[\w.+-]+@[\w.-]+\.\w{2,}\b/gi, "[email]")
        .replace(/\b\d{13,16}\b/g, "[cc]");
    }
    return value;
  },
});

process.on("SIGTERM", async () => {
  await tl.shutdown();
  process.exit(0);
});