retrace-sdk 0.1.6 → 0.2.0

package/dist/sdk.test.js

@@ -1,132 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { configure, getConfig } from "./config.js";
-// Reset config between tests
-beforeEach(() => {
-    configure({ apiKey: "", baseUrl: "http://localhost:3001", enabled: true, wsUrl: "" });
-});
-describe("Config", () => {
-    it("has sensible defaults", () => {
-        const c = getConfig();
-        expect(c.baseUrl).toBe("http://localhost:3001");
-        expect(c.enabled).toBe(true);
-    });
-    it("configures custom values", () => {
-        configure({ apiKey: "rt_live_test", baseUrl: "https://api.example.com" });
-        const c = getConfig();
-        expect(c.apiKey).toBe("rt_live_test");
-        expect(c.baseUrl).toBe("https://api.example.com");
-        expect(c.wsUrl).toBe("wss://api.example.com");
-    });
-    it("auto-derives wsUrl from baseUrl", () => {
-        configure({ baseUrl: "https://custom.io" });
-        expect(getConfig().wsUrl).toBe("wss://custom.io");
-        configure({ baseUrl: "http://localhost:3001" });
-        expect(getConfig().wsUrl).toBe("ws://localhost:3001");
-    });
-    it("warns on invalid API key prefix", () => {
-        const spy = vi.spyOn(console, "warn").mockImplementation(() => { });
-        configure({ apiKey: "invalid_key" });
-        expect(spy).toHaveBeenCalledWith(expect.stringContaining("rt_live_"));
-        spy.mockRestore();
-    });
-    it("does not warn on valid API key", () => {
-        const spy = vi.spyOn(console, "warn").mockImplementation(() => { });
-        configure({ apiKey: "rt_live_valid123" });
-        expect(spy).not.toHaveBeenCalled();
-        spy.mockRestore();
-    });
-});
-describe("Trace model", () => {
-    it("SpanBuilder creates valid span data", async () => {
-        const { SpanBuilder, SpanType } = await import("./trace.js");
-        const sb = new SpanBuilder("test-span", SpanType.LLM_CALL).start();
-        sb.setModel("gpt-4o");
-        sb.setInput({ prompt: "hi" });
-        const data = sb.end("hello");
-        expect(data.name).toBe("test-span");
-        expect(data.span_type).toBe("llm_call");
-        expect(data.model).toBe("gpt-4o");
-        expect(data.output).toBe("hello");
-        expect(data.id).toHaveLength(36);
-        expect(data.started_at).toBeDefined();
-        expect(data.ended_at).toBeDefined();
-    });
-    it("TraceBuilder creates valid trace data", async () => {
-        const { TraceBuilder, TraceStatus } = await import("./trace.js");
-        const tb = new TraceBuilder();
-        tb.start("my-trace", { prompt: "test" });
-        const data = tb.end("result", TraceStatus.COMPLETED);
-        expect(data.name).toBe("my-trace");
-        expect(data.status).toBe("completed");
-        expect(data.output).toBe("result");
-        expect(data.id).toHaveLength(36);
-    });
-    it("SpanType enum values", async () => {
-        const { SpanType } = await import("./trace.js");
-        expect(SpanType.LLM_CALL).toBe("llm_call");
-        expect(SpanType.TOOL_CALL).toBe("tool_call");
-        expect(SpanType.ERROR).toBe("error");
-        expect(SpanType.FORK_POINT).toBe("fork_point");
-    });
-});
-describe("Recorder", () => {
-    it("trace() wraps sync function", async () => {
-        configure({ apiKey: "rt_live_t", baseUrl: "http://x:1", enabled: true });
-        const { trace } = await import("./recorder.js");
-        const fn = trace((x) => `result:${x}`, { name: "sync-fn" });
-        expect(fn("hi")).toBe("result:hi");
-    });
-    it("trace() wraps async function", async () => {
-        configure({ apiKey: "rt_live_t", baseUrl: "http://x:1", enabled: true });
-        const { trace } = await import("./recorder.js");
-        const fn = trace(async (x) => `async:${x}`, { name: "async-fn" });
-        const result = await fn("hi");
-        expect(result).toBe("async:hi");
-    });
-    it("trace() propagates exceptions", async () => {
-        configure({ apiKey: "rt_live_t", baseUrl: "http://x:1", enabled: true });
-        const { trace } = await import("./recorder.js");
-        const fn = trace(() => { throw new Error("boom"); }, { name: "err-fn" });
-        expect(() => fn()).toThrow("boom");
-    });
-    it("disabled SDK is no-op", async () => {
-        configure({ apiKey: "rt_live_t", enabled: false });
-        const { trace } = await import("./recorder.js");
-        const fn = trace((x) => `r:${x}`, { name: "off" });
-        expect(fn("hi")).toBe("r:hi");
-    });
-});
-describe("Transport", () => {
-    it("HTTPTransport accumulates and flushes", async () => {
-        configure({ apiKey: "rt_live_t", baseUrl: "http://x:1" });
-        const { HTTPTransport } = await import("./transport.js");
-        const http = new HTTPTransport();
-        const mockFetch = vi.fn().mockResolvedValue({ ok: true });
-        vi.stubGlobal("fetch", mockFetch);
-        http.send("trace_started", { id: "abc", name: "t", status: "running", started_at: "2026-01-01T00:00:00Z", total_tokens: 0, total_cost: 0, total_duration_ms: 0 });
-        http.send("span_started", { id: "s1", trace_id: "abc", span_type: "llm_call", name: "s", started_at: "2026-01-01T00:00:00Z" });
-        http.send("span_ended", { id: "s1", ended_at: "2026-01-01T00:00:01Z", output: "hi" });
-        http.send("trace_ended", { id: "abc", ended_at: "2026-01-01T00:00:02Z", status: "completed" });
-        expect(mockFetch).toHaveBeenCalled();
-        const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-        expect(body.id).toBe("abc");
-        expect(body.spans).toHaveLength(1);
-        expect(body.spans[0].output).toBe("hi");
-        vi.unstubAllGlobals();
-    });
-    it("createTransport returns correct type", async () => {
-        const { createTransport, HTTPTransport } = await import("./transport.js");
-        expect(createTransport("http")).toBeInstanceOf(HTTPTransport);
-    });
-});
-describe("README examples", () => {
-    it("TypeScript README example works", async () => {
-        configure({ apiKey: "rt_live_test", enabled: false });
-        const { trace } = await import("./recorder.js");
-        const runAgent = trace(async (prompt) => {
-            return `Response to: ${prompt}`;
-        }, { name: "my-agent" });
-        const result = await runAgent("What is quantum computing?");
-        expect(result).toContain("quantum");
-    });
-});

package/dist/transport.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/transport.test.js

@@ -1,67 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { configure } from "./config.js";
-// Mock WebSocket to never connect (simulates unreachable WS endpoint)
-const mockWsInstances = [];
-vi.mock("ws", () => {
-    const MockWebSocket = function () {
-        this.readyState = 0;
-        this._listeners = {};
-        this.on = (event, cb) => { (this._listeners[event] ??= []).push(cb); return this; };
-        this.send = vi.fn();
-        this.close = vi.fn(() => {
-            this.readyState = 3;
-            for (const cb of (this._listeners["close"] ?? []))
-                cb();
-        });
-        mockWsInstances.push(this);
-    };
-    MockWebSocket.OPEN = 1;
-    return { default: MockWebSocket };
-});
-beforeEach(() => {
-    configure({ apiKey: "rt_live_test", baseUrl: "http://localhost:3001", enabled: true });
-    mockWsInstances.length = 0;
-});
-afterEach(() => {
-    vi.unstubAllGlobals();
-});
-describe("Auto transport fallback on early close()", () => {
-    it("flushes to HTTP when close() is called before WS connects", async () => {
-        const mockFetch = vi.fn().mockResolvedValue({ ok: true });
-        vi.stubGlobal("fetch", mockFetch);
-        const { createTransport } = await import("./transport.js");
-        const transport = createTransport("auto");
-        // Send trace events immediately (before WS could connect)
-        transport.send("trace_started", { id: "t1", name: "fast-trace", status: "running", started_at: "2026-01-01T00:00:00Z", total_tokens: 0, total_cost: 0, total_duration_ms: 0 });
-        transport.send("span_started", { id: "s1", trace_id: "t1", span_type: "llm_call", name: "call", started_at: "2026-01-01T00:00:00Z" });
-        transport.send("span_ended", { id: "s1", ended_at: "2026-01-01T00:00:01Z", output: "response" });
-        transport.send("trace_ended", { id: "t1", ended_at: "2026-01-01T00:00:01Z", status: "completed" });
-        // Close immediately — WS has NOT connected yet
-        transport.close();
-        // Should have fallen back to HTTP and flushed
-        expect(mockFetch).toHaveBeenCalledTimes(1);
-        const [url, opts] = mockFetch.mock.calls[0];
-        expect(url).toBe("http://localhost:3001/api/v1/traces");
-        const body = JSON.parse(opts.body);
-        expect(body.id).toBe("t1");
-        expect(body.name).toBe("fast-trace");
-        expect(body.spans).toHaveLength(1);
-        expect(body.spans[0].output).toBe("response");
-    });
-    it("does NOT reconnect after intentional close()", async () => {
-        vi.stubGlobal("fetch", vi.fn().mockResolvedValue({ ok: true }));
-        const { WSTransport } = await import("./transport.js");
-        const ws = new WSTransport();
-        ws.connect();
-        // Should have created a WS instance
-        expect(mockWsInstances.length).toBeGreaterThan(0);
-        const instanceCount = mockWsInstances.length;
-        // Close intentionally
-        ws.close();
-        // Trigger the "close" event that was registered — already fired by our mock's close()
-        // Wait a tick for any setTimeout reconnect to fire
-        await new Promise(r => setTimeout(r, 1100));
-        // Should NOT have created new WS instances (no reconnect)
-        expect(mockWsInstances.length).toBe(instanceCount);
-    });
-});

package/src/config.test.ts

@@ -1,16 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { configure, getConfig } from "./config.js";
-
-describe("SDK config", () => {
-  it("has defaults", () => {
-    const c = getConfig();
-    expect(c.baseUrl).toBe("http://localhost:3001");
-    expect(c.enabled).toBe(true);
-  });
-  it("configures custom values", () => {
-    configure({ apiKey: "rt_live_test", baseUrl: "http://custom:3001" });
-    const c = getConfig();
-    expect(c.apiKey).toBe("rt_live_test");
-    expect(c.baseUrl).toBe("http://custom:3001");
-  });
-});

package/src/config.ts

@@ -1,31 +0,0 @@
-export interface Config {
-  apiKey: string;
-  baseUrl: string;
-  wsUrl: string;
-  projectId: string | undefined;
-  enabled: boolean;
-}
-
-const config: Config = {
-  apiKey: process.env.RETRACE_API_KEY || "",
-  baseUrl: process.env.RETRACE_BASE_URL || "http://localhost:3001",
-  wsUrl: "",
-  projectId: process.env.RETRACE_PROJECT_ID || undefined,
-  enabled: !["false", "0"].includes((process.env.RETRACE_ENABLED || "true").toLowerCase()),
-};
-config.wsUrl = config.baseUrl.replace("https://", "wss://").replace("http://", "ws://");
-
-export function configure(opts: Partial<Config>): Config {
-  if (opts.apiKey && !opts.apiKey.startsWith("rt_live_")) {
-    console.warn("[retrace] API key does not start with 'rt_live_'. This may be invalid.");
-  }
-  Object.assign(config, opts);
-  if (opts.baseUrl && !opts.wsUrl) {
-    config.wsUrl = config.baseUrl.replace("https://", "wss://").replace("http://", "ws://");
-  }
-  return config;
-}
-
-export function getConfig(): Config {
-  return config;
-}

package/src/index.ts

@@ -1,6 +0,0 @@
-export { configure, getConfig } from "./config.js";
-export { record, trace, TraceRecorder } from "./recorder.js";
-export { SpanBuilder, TraceBuilder } from "./trace.js";
-export type { SpanData, TraceData } from "./trace.js";
-export { SpanType, TraceStatus } from "./trace.js";
-export { installGeminiInterceptor, uninstallGeminiInterceptor } from "./interceptors/gemini.js";

package/src/interceptors/gemini.ts

@@ -1,86 +0,0 @@
-import { SpanData, SpanType } from "../trace.js";
-import { genId, nowIso, truncateJson } from "../utils.js";
-
-const PRICING: Record<string, [number, number]> = {
-  "gemini-3.1-pro-preview": [2.0, 12.0],
-  "gemini-2.5-pro": [1.25, 10.0],
-  "gemini-2.5-flash": [0.15, 0.60],
-  "gemini-2.0-flash": [0.10, 0.40],
-};
-
-function calcCost(model: string, inputTokens: number, outputTokens: number): number {
-  const p = PRICING[model] || [0, 0];
-  return (inputTokens * p[0] + outputTokens * p[1]) / 1_000_000;
-}
-
- 
-let originalGenerateContent: ((...args: unknown[]) => unknown) | null = null;
-let installed = false;
-let onSpanCallback: ((span: SpanData) => void) | null = null;
-
-export function installGeminiInterceptor(onSpan: (span: SpanData) => void) {
-  if (installed) { onSpanCallback = onSpan; return; }
-  onSpanCallback = onSpan;
-
-  import("@google/genai").then((genaiMod) => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const mod = genaiMod as Record<string, any>;
-    const modelsProto = mod?.Models?.prototype || mod?.default?.Models?.prototype;
-    if (!modelsProto?.generateContent) return;
-
-    originalGenerateContent = modelsProto.generateContent;
-
-    modelsProto.generateContent = async function (...args: unknown[]) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const opts = (args[0] as Record<string, any>) || {};
-      const model = (opts.model as string) || "unknown";
-      const contents = opts.contents;
-      const spanId = genId();
-      const startedAt = nowIso();
-      const startMs = Date.now();
-
-      try {
-        const result = await originalGenerateContent!.apply(this, args);
-        const durationMs = Date.now() - startMs;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const res = result as any;
-        const inputTokens = res?.usageMetadata?.promptTokenCount || 0;
-        const outputTokens = res?.usageMetadata?.candidatesTokenCount || 0;
-
-        const span: SpanData = {
-          id: spanId, trace_id: "", parent_id: null,
-          span_type: SpanType.LLM_CALL, name: "retrace.ai.generate", model,
-          input: truncateJson(contents), output: truncateJson(res?.text || ""),
-          input_tokens: inputTokens, output_tokens: outputTokens,
-          cost: calcCost(model, inputTokens, outputTokens),
-          duration_ms: durationMs, started_at: startedAt, ended_at: nowIso(),
-        };
-        onSpanCallback?.(span);
-        return result;
-      } catch (err) {
-        const span: SpanData = {
-          id: spanId, trace_id: "", parent_id: null,
-          span_type: SpanType.LLM_CALL, name: "retrace.ai.generate", model,
-          input: truncateJson(contents), started_at: startedAt, ended_at: nowIso(),
-          duration_ms: Date.now() - startMs,
-          error: err instanceof Error ? err.message : String(err),
-        };
-        onSpanCallback?.(span);
-        throw err;
-      }
-    };
-    installed = true;
-  }).catch(() => { /* @google/genai not installed — skip */ });
-}
-
-export function uninstallGeminiInterceptor() {
-  if (!installed || !originalGenerateContent) return;
-  import("@google/genai").then((genaiMod) => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const mod = genaiMod as Record<string, any>;
-    const modelsProto = mod?.Models?.prototype || mod?.default?.Models?.prototype;
-    if (modelsProto) modelsProto.generateContent = originalGenerateContent;
-  }).catch(() => {});
-  installed = false;
-  onSpanCallback = null;
-}

package/src/interceptors/index.ts

@@ -1 +0,0 @@
-export { installGeminiInterceptor, uninstallGeminiInterceptor } from "./gemini.js";

package/src/recorder.ts

@@ -1,136 +0,0 @@
-import { getConfig } from "./config.js";
-import { SpanBuilder, SpanData, SpanType, TraceBuilder, TraceStatus } from "./trace.js";
-import { createTransport, Transport } from "./transport.js";
-import { installGeminiInterceptor } from "./interceptors/gemini.js";
-
-export interface RecordOptions {
-  name?: string;
-  input?: unknown;
-  metadata?: Record<string, unknown>;
-}
-
-export class TraceRecorder {
-  private builder: TraceBuilder;
-  private transport: Transport;
-  private interceptorsInstalled = false;
-  output: unknown = undefined;
-
-  constructor(opts?: RecordOptions) {
-    this.builder = new TraceBuilder();
-    this.transport = createTransport();
-    const cfg = getConfig();
-    if (cfg.projectId) this.builder.setProjectId(cfg.projectId);
-    if (opts?.metadata) this.builder.setMetadata(opts.metadata);
-    if (opts?.name || opts?.input) {
-      this.builder.start(opts.name, opts.input);
-    }
-  }
-
-  get traceId() { return this.builder.id; }
-
-  start(name?: string, input?: unknown): this {
-    this.builder.start(name, input);
-    this.installInterceptors();
-    this.transport.send("trace_started", this.builder.toDict() as unknown as Record<string, unknown>);
-    return this;
-  }
-
-  end(output?: unknown, status: TraceStatus = TraceStatus.COMPLETED) {
-    if (output !== undefined) this.output = output;
-    const data = this.builder.end(this.output, status);
-    this.transport.send("trace_ended", {
-      id: data.id,
-      ended_at: data.ended_at!,
-      output: data.output,
-      status: data.status,
-      total_tokens: data.total_tokens,
-      total_cost: data.total_cost,
-    });
-    this.transport.close();
-  }
-
-  addSpan(span: SpanData) {
-    span.trace_id = this.builder.id;
-    this.builder.addSpan(span);
-    this.transport.send("span_started", span as unknown as Record<string, unknown>);
-    if (span.ended_at) {
-      this.transport.send("span_ended", {
-        id: span.id,
-        ended_at: span.ended_at,
-        output: span.output,
-        output_tokens: span.output_tokens,
-        cost: span.cost,
-        error: span.error,
-      });
-    }
-  }
-
-  startSpan(name: string, spanType: SpanType = SpanType.LLM_CALL, input?: unknown, model?: string, parentId?: string): SpanBuilder {
-    const sb = new SpanBuilder(name, spanType).start();
-    sb.setTraceId(this.builder.id);
-    if (input !== undefined) sb.setInput(input);
-    if (model) sb.setModel(model);
-    if (parentId) sb.setParentId(parentId);
-    this.transport.send("span_started", sb.toData() as unknown as Record<string, unknown>);
-    return sb;
-  }
-
-  endSpan(spanBuilder: SpanBuilder, output?: unknown, error?: string) {
-    const span = spanBuilder.end(output, error);
-    span.trace_id = this.builder.id;
-    this.builder.addSpan(span);
-    this.transport.send("span_ended", {
-      id: span.id,
-      ended_at: span.ended_at,
-      output: span.output,
-      output_tokens: span.output_tokens,
-      cost: span.cost,
-      error: span.error,
-    });
-  }
-
-  private installInterceptors() {
-    if (this.interceptorsInstalled) return;
-    installGeminiInterceptor((span) => this.addSpan(span));
-    this.interceptorsInstalled = true;
-  }
-}
-
-export function record(opts?: RecordOptions): TraceRecorder {
-  const cfg = getConfig();
-  if (!cfg.enabled) {
-    // Return a no-op recorder
-    return new TraceRecorder(opts);
-  }
-  return new TraceRecorder(opts);
-}
-
-export function trace<T>(fn: (...args: unknown[]) => T, opts?: RecordOptions): (...args: unknown[]) => T {
-  const cfg = getConfig();
-  return (...args: unknown[]): T => {
-    if (!cfg.enabled) return fn(...args);
-
-    const recorder = new TraceRecorder({
-      name: opts?.name || fn.name || "anonymous",
-      input: opts?.input ?? args,
-      metadata: opts?.metadata,
-    });
-    recorder.start(opts?.name || fn.name || "anonymous", opts?.input ?? args);
-
-    try {
-      const result = fn(...args);
-      // Handle async functions
-      if (result && typeof (result as { then?: unknown }).then === "function") {
-        return (result as unknown as Promise<unknown>).then(
-          (resolved) => { recorder.end(resolved, TraceStatus.COMPLETED); return resolved; },
-          (err) => { recorder.end(undefined, TraceStatus.FAILED); throw err; }
-        ) as unknown as T;
-      }
-      recorder.end(result, TraceStatus.COMPLETED);
-      return result;
-    } catch (err) {
-      recorder.end(undefined, TraceStatus.FAILED);
-      throw err;
-    }
-  };
-}

package/src/sdk.test.ts

@@ -1,152 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { configure, getConfig } from "./config.js";
-
-// Reset config between tests
-beforeEach(() => {
-  configure({ apiKey: "", baseUrl: "http://localhost:3001", enabled: true, wsUrl: "" });
-});
-
-describe("Config", () => {
-  it("has sensible defaults", () => {
-    const c = getConfig();
-    expect(c.baseUrl).toBe("http://localhost:3001");
-    expect(c.enabled).toBe(true);
-  });
-
-  it("configures custom values", () => {
-    configure({ apiKey: "rt_live_test", baseUrl: "https://api.example.com" });
-    const c = getConfig();
-    expect(c.apiKey).toBe("rt_live_test");
-    expect(c.baseUrl).toBe("https://api.example.com");
-    expect(c.wsUrl).toBe("wss://api.example.com");
-  });
-
-  it("auto-derives wsUrl from baseUrl", () => {
-    configure({ baseUrl: "https://custom.io" });
-    expect(getConfig().wsUrl).toBe("wss://custom.io");
-    configure({ baseUrl: "http://localhost:3001" });
-    expect(getConfig().wsUrl).toBe("ws://localhost:3001");
-  });
-
-  it("warns on invalid API key prefix", () => {
-    const spy = vi.spyOn(console, "warn").mockImplementation(() => {});
-    configure({ apiKey: "invalid_key" });
-    expect(spy).toHaveBeenCalledWith(expect.stringContaining("rt_live_"));
-    spy.mockRestore();
-  });
-
-  it("does not warn on valid API key", () => {
-    const spy = vi.spyOn(console, "warn").mockImplementation(() => {});
-    configure({ apiKey: "rt_live_valid123" });
-    expect(spy).not.toHaveBeenCalled();
-    spy.mockRestore();
-  });
-});
-
-describe("Trace model", () => {
-  it("SpanBuilder creates valid span data", async () => {
-    const { SpanBuilder, SpanType } = await import("./trace.js");
-    const sb = new SpanBuilder("test-span", SpanType.LLM_CALL).start();
-    sb.setModel("gpt-4o");
-    sb.setInput({ prompt: "hi" });
-    const data = sb.end("hello");
-    expect(data.name).toBe("test-span");
-    expect(data.span_type).toBe("llm_call");
-    expect(data.model).toBe("gpt-4o");
-    expect(data.output).toBe("hello");
-    expect(data.id).toHaveLength(36);
-    expect(data.started_at).toBeDefined();
-    expect(data.ended_at).toBeDefined();
-  });
-
-  it("TraceBuilder creates valid trace data", async () => {
-    const { TraceBuilder, TraceStatus } = await import("./trace.js");
-    const tb = new TraceBuilder();
-    tb.start("my-trace", { prompt: "test" });
-    const data = tb.end("result", TraceStatus.COMPLETED);
-    expect(data.name).toBe("my-trace");
-    expect(data.status).toBe("completed");
-    expect(data.output).toBe("result");
-    expect(data.id).toHaveLength(36);
-  });
-
-  it("SpanType enum values", async () => {
-    const { SpanType } = await import("./trace.js");
-    expect(SpanType.LLM_CALL).toBe("llm_call");
-    expect(SpanType.TOOL_CALL).toBe("tool_call");
-    expect(SpanType.ERROR).toBe("error");
-    expect(SpanType.FORK_POINT).toBe("fork_point");
-  });
-});
-
-describe("Recorder", () => {
-  it("trace() wraps sync function", async () => {
-    configure({ apiKey: "rt_live_t", baseUrl: "http://x:1", enabled: true });
-    const { trace } = await import("./recorder.js");
-    const fn = trace((x: unknown) => `result:${x}`, { name: "sync-fn" });
-    expect(fn("hi")).toBe("result:hi");
-  });
-
-  it("trace() wraps async function", async () => {
-    configure({ apiKey: "rt_live_t", baseUrl: "http://x:1", enabled: true });
-    const { trace } = await import("./recorder.js");
-    const fn = trace(async (x: unknown) => `async:${x}`, { name: "async-fn" });
-    const result = await fn("hi");
-    expect(result).toBe("async:hi");
-  });
-
-  it("trace() propagates exceptions", async () => {
-    configure({ apiKey: "rt_live_t", baseUrl: "http://x:1", enabled: true });
-    const { trace } = await import("./recorder.js");
-    const fn = trace(() => { throw new Error("boom"); }, { name: "err-fn" });
-    expect(() => fn()).toThrow("boom");
-  });
-
-  it("disabled SDK is no-op", async () => {
-    configure({ apiKey: "rt_live_t", enabled: false });
-    const { trace } = await import("./recorder.js");
-    const fn = trace((x: unknown) => `r:${x}`, { name: "off" });
-    expect(fn("hi")).toBe("r:hi");
-  });
-});
-
-describe("Transport", () => {
-  it("HTTPTransport accumulates and flushes", async () => {
-    configure({ apiKey: "rt_live_t", baseUrl: "http://x:1" });
-    const { HTTPTransport } = await import("./transport.js");
-    const http = new HTTPTransport();
-
-    const mockFetch = vi.fn().mockResolvedValue({ ok: true });
-    vi.stubGlobal("fetch", mockFetch);
-
-    http.send("trace_started", { id: "abc", name: "t", status: "running", started_at: "2026-01-01T00:00:00Z", total_tokens: 0, total_cost: 0, total_duration_ms: 0 });
-    http.send("span_started", { id: "s1", trace_id: "abc", span_type: "llm_call", name: "s", started_at: "2026-01-01T00:00:00Z" });
-    http.send("span_ended", { id: "s1", ended_at: "2026-01-01T00:00:01Z", output: "hi" });
-    http.send("trace_ended", { id: "abc", ended_at: "2026-01-01T00:00:02Z", status: "completed" });
-
-    expect(mockFetch).toHaveBeenCalled();
-    const body = JSON.parse(mockFetch.mock.calls[0][1].body);
-    expect(body.id).toBe("abc");
-    expect(body.spans).toHaveLength(1);
-    expect(body.spans[0].output).toBe("hi");
-
-    vi.unstubAllGlobals();
-  });
-
-  it("createTransport returns correct type", async () => {
-    const { createTransport, HTTPTransport } = await import("./transport.js");
-    expect(createTransport("http")).toBeInstanceOf(HTTPTransport);
-  });
-});
-
-describe("README examples", () => {
-  it("TypeScript README example works", async () => {
-    configure({ apiKey: "rt_live_test", enabled: false });
-    const { trace } = await import("./recorder.js");
-    const runAgent = trace(async (prompt: unknown) => {
-      return `Response to: ${prompt}`;
-    }, { name: "my-agent" });
-    const result = await runAgent("What is quantum computing?");
-    expect(result).toContain("quantum");
-  });
-});