Tracelane TypeScript SDK — @tracelanedev/sdk

npm install @tracelanedev/sdk
# or
pnpm add @tracelanedev/sdk

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://gateway.tracelane.dev/v1",
  apiKey: process.env.TRACELANE_API_KEY!, // tlane_… from app.tracelane.dev
});

await client.chat.completions.create({
  model: "claude-sonnet-4-6",
  messages: [{ role: "user", content: "Hello" }],
});
// → Trace visible at https://app.tracelane.dev/traces within ~1 second

import { init } from "@tracelanedev/sdk";

// endpoint + apiKey are REQUIRED (no env-var auto-read).
init({
  endpoint: "https://gateway.tracelane.dev", // Tracelane Cloud
  apiKey: process.env.TRACELANE_API_KEY!,    // needs the `ingest` scope
  serviceName: "my-agent",
});

import { init, instrumentAnthropic } from "@tracelanedev/sdk";
init({ endpoint: "http://localhost:4318", apiKey: process.env.TRACELANE_API_KEY! });

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();
instrumentAnthropic(client); // now every messages.create() emits a span
const response = await client.messages.create({
  model: "claude-sonnet-4-6",
  messages: [{ role: "user", content: "Hello" }],
  max_tokens: 1024,
});

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

const client = new OpenAI();
instrumentOpenAI(client); // chat.completions, embeddings, Responses now traced
await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Hello" }],
});

import { instrumentOpenAIAgents } from "@tracelanedev/sdk";
import { Agent, run, Runner } from "@openai/agents";

instrumentOpenAIAgents(Runner); // wrap the Runner class once, before running
const agent = new Agent({ name: "helper", model: "gpt-4o" });
const result = await run(agent, "Summarise this doc…");
// Agent steps, tool calls, and handoffs all traced.

import { instrumentLangGraph } from "@tracelanedev/sdk";
import { ChatAnthropic } from "@langchain/anthropic";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const model = new ChatAnthropic({ model: "claude-sonnet-4-6" });
const graph = createReactAgent({ llm: model, tools: [] });
instrumentLangGraph(graph); // wrap the compiled graph — steps + tool calls traced

// gateway as base URL (full routing + guardrails, no SDK needed)
import { generateText } from "ai";
import { createAnthropic } from "@ai-sdk/anthropic";

const anthropic = createAnthropic({
  baseURL: "https://gateway.tracelane.dev/v1",
  apiKey: process.env.TRACELANE_API_KEY,
});
const { text } = await generateText({
  model: anthropic("claude-sonnet-4-6"),
  prompt: "Write a haiku about observability.",
});

import { instrumentMCP } from "@tracelanedev/sdk";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";

const client = new Client({ name: "my-agent", version: "1.0" }, { capabilities: {} });
instrumentMCP(client); // tool_call and tool_result messages traced with latency + schema

import { trace } from "@opentelemetry/api";

const tracer = trace.getTracer("my-agent");
const hits = await tracer.startActiveSpan("retrieval", async (span) => {
  span.setAttribute("retrieval.top_k", 10);
  const results = await vectorStore.search(query, { topK: 10 });
  span.end();
  return results;
});

// instrumentation.ts (project root)
export async function register() {
  if (process.env.NEXT_RUNTIME === "nodejs") {
    const { init } = await import("@tracelanedev/sdk");
    init({
      endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://localhost:4318",
      apiKey: process.env.TRACELANE_API_KEY!,
      serviceName: "my-nextjs-app",
    });
  }
}

import { InMemorySpanExporter, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
import { instrumentAnthropic } from "@tracelanedev/sdk";

const exporter = new InMemorySpanExporter();
const provider = new NodeTracerProvider({ spanProcessors: [new SimpleSpanProcessor(exporter)] });
provider.register();

// ... construct + instrumentAnthropic(client), run the code under test ...

expect(exporter.getFinishedSpans()).toHaveLength(3);
expect(exporter.getFinishedSpans()[0]!.name).toBe("anthropic.messages.create");