@syntheticminds/wiretap-llm 0.2.3

package/README.md

@@ -0,0 +1,176 @@
+# wiretap-llm
+
+Telemetry client for sending LLM logs to your Wiretap instance.
+
+## Installation
+
+```bash
+npm install wiretap-llm
+# or
+bun add wiretap-llm
+```
+
+## Quick Start - Automatic Instrumentation
+
+The easiest way to use wiretap-llm is with `createInstrumentedFetch`. It automatically captures all OpenRouter/OpenAI requests:
+
+```ts
+import OpenAI from "openai";
+import { TelemetryClient, createInstrumentedFetch } from "wiretap-llm";
+
+// Create telemetry client
+const telemetry = new TelemetryClient({
+  baseUrl: process.env.WIRETAP_BASE_URL!,
+  apiKey: process.env.WIRETAP_API_KEY!,
+});
+
+// Create OpenAI client with instrumented fetch
+const openrouter = new OpenAI({
+  baseURL: "https://openrouter.ai/api/v1",
+  apiKey: process.env.OPENROUTER_API_KEY!,
+  fetch: createInstrumentedFetch(telemetry),
+});
+
+// Use normally - all requests are automatically logged
+const response = await openrouter.chat.completions.create({
+  model: "anthropic/claude-sonnet-4",
+  messages: [{ role: "user", content: "Hello!" }],
+});
+
+// Streaming works too
+const stream = await openrouter.chat.completions.create({
+  model: "anthropic/claude-sonnet-4",
+  messages: [{ role: "user", content: "Count to 5" }],
+  stream: true,
+});
+
+for await (const chunk of stream) {
+  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
+}
+
+// On app shutdown
+await telemetry.shutdown();
+```
+
+## Manual Reporting
+
+For custom logging scenarios, you can report logs manually:
+
+```ts
+import { TelemetryClient, createId, toIso } from "wiretap-llm";
+
+const client = new TelemetryClient({
+  baseUrl: process.env.WIRETAP_BASE_URL!,
+  apiKey: process.env.WIRETAP_API_KEY!,
+});
+
+client.report({
+  id: createId(),
+  timestamp: toIso(new Date()),
+  project: "",  // Inferred from API key
+  source: "openrouter",
+  method: "POST",
+  url: "https://openrouter.ai/api/v1/chat/completions",
+  path: "/v1/chat/completions",
+  model: "anthropic/claude-sonnet-4",
+  streamed: false,
+  timing: {
+    started_at: toIso(startTime),
+    ended_at: toIso(endTime),
+    duration_ms: endTime.getTime() - startTime.getTime(),
+  },
+  request: {
+    body_json: requestBody,
+  },
+  response: {
+    status: 200,
+    body_json: responseBody,
+  },
+  usage: responseBody.usage,
+});
+
+await client.shutdown();
+```
+
+## Configuration
+
+### TelemetryClient Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `baseUrl` | string | required | Your Wiretap instance URL |
+| `apiKey` | string | required | Your Wiretap API key |
+| `project` | string | - | Project slug (usually inferred from API key) |
+| `environment` | string | - | Environment name (e.g., "production") |
+| `defaultMetadata` | object | - | Metadata added to all logs |
+| `timeoutMs` | number | 5000 | Request timeout |
+| `maxBatchSize` | number | 25 | Max logs per batch |
+| `flushIntervalMs` | number | 2000 | Auto-flush interval |
+| `maxLogBytes` | number | 1000000 | Max log size before truncation |
+| `maxQueueSize` | number | 1000 | Max queue size (drops oldest when exceeded) |
+| `retryBaseDelayMs` | number | 1000 | Initial retry delay |
+| `retryMaxDelayMs` | number | 30000 | Maximum retry delay |
+| `maxRetries` | number | 5 | Max retries before dropping batch |
+| `onError` | function | - | Error handler callback |
+
+### createInstrumentedFetch Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `baseFetch` | fetch | globalThis.fetch | Base fetch function to wrap |
+| `defaultMetadata` | object | - | Metadata added to all logs |
+| `source` | string | "openrouter" | Source identifier in logs |
+
+## Reliability Features
+
+### Automatic Retry with Exponential Backoff
+
+Failed batches are automatically retried with exponential backoff (1s, 2s, 4s, ...) up to 30s max delay.
+
+### Circuit Breaker
+
+After 5 consecutive failures, the circuit breaker opens for 30 seconds. During this time, flushes are skipped to prevent hammering a dead server.
+
+### Queue Limits
+
+If the queue exceeds 1000 logs (configurable), oldest logs are dropped to prevent memory exhaustion.
+
+### Graceful Shutdown
+
+Call `shutdown()` on app exit to flush remaining logs:
+
+```ts
+process.on("SIGTERM", async () => {
+  await telemetry.shutdown();
+  process.exit(0);
+});
+```
+
+## Helper Utilities
+
+```ts
+import { createId, toIso, sanitizeHeaders, safeJsonParse } from "wiretap-llm";
+
+// Generate unique ID
+const id = createId();  // "abc123..."
+
+// ISO timestamp
+const ts = toIso(new Date());  // "2024-01-20T..."
+
+// Remove sensitive headers
+const headers = sanitizeHeaders(req.headers);  // Strips auth headers
+
+// Safe JSON parse
+const { ok, value } = safeJsonParse(jsonString);
+```
+
+## Environment Variables
+
+```bash
+WIRETAP_BASE_URL=https://your-wiretap-instance.com
+WIRETAP_API_KEY=wt_your_api_key
+```
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,57 @@
+import type { JsonValue } from "./json";
+import type { TelemetryLog } from "./types/telemetry";
+export type TelemetryClientOptions = {
+    baseUrl: string;
+    apiKey: string;
+    /** Optional - project is automatically inferred from API key on server */
+    project?: string;
+    environment?: string;
+    defaultMetadata?: Record<string, JsonValue>;
+    timeoutMs?: number;
+    maxBatchSize?: number;
+    flushIntervalMs?: number;
+    maxLogBytes?: number;
+    /** Max queue size before dropping oldest logs (default: 1000) */
+    maxQueueSize?: number;
+    /** Base delay for retry backoff in ms (default: 1000) */
+    retryBaseDelayMs?: number;
+    /** Max retry delay in ms (default: 30000) */
+    retryMaxDelayMs?: number;
+    /** Max retries per batch before dropping (default: 5) */
+    maxRetries?: number;
+    onError?: (err: unknown) => void;
+};
+export declare class TelemetryClient {
+    readonly baseUrl: string;
+    readonly apiKey: string;
+    readonly project?: string;
+    readonly environment?: string;
+    readonly defaultMetadata?: Record<string, JsonValue>;
+    private timeoutMs;
+    private maxBatchSize;
+    private flushIntervalMs;
+    private maxLogBytes;
+    private maxQueueSize;
+    private retryBaseDelayMs;
+    private retryMaxDelayMs;
+    private maxRetries;
+    private queue;
+    private flushing;
+    private timer;
+    private retryCount;
+    private retryDelayMs;
+    private circuitOpen;
+    private circuitOpenUntil;
+    private consecutiveFailures;
+    private readonly circuitBreakerThreshold;
+    private readonly circuitBreakerDurationMs;
+    private onError?;
+    constructor(opts: TelemetryClientOptions);
+    report(log: TelemetryLog): void;
+    private enforceQueueLimit;
+    flush(): Promise<void>;
+    private handleSuccess;
+    private handleFailure;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAExC,OAAO,KAAK,EAAyB,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAE7E,MAAM,MAAM,sBAAsB,GAAG;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,0EAA0E;IAC1E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yDAAyD;IACzD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,6CAA6C;IAC7C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,yDAAyD;IACzD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;CAClC,CAAC;AAEF,qBAAa,eAAe;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAErD,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,eAAe,CAAS;IAChC,OAAO,CAAC,UAAU,CAAS;IAE3B,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,KAAK,CAA+C;IAG5D,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,YAAY,CAAS;IAG7B,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,mBAAmB,CAAK;IAChC,OAAO,CAAC,QAAQ,CAAC,uBAAuB,CAAK;IAC7C,OAAO,CAAC,QAAQ,CAAC,wBAAwB,CAAU;IAEnD,OAAO,CAAC,OAAO,CAAC,CAAyB;gBAE7B,IAAI,EAAE,sBAAsB;IA4BxC,MAAM,CAAC,GAAG,EAAE,YAAY,GAAG,IAAI;IAsC/B,OAAO,CAAC,iBAAiB;IAQnB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAuF5B,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,aAAa;IAkCf,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAUhC"}

package/dist/fetch.d.ts

@@ -0,0 +1,12 @@
+import type { TelemetryClient } from "./client";
+import type { JsonValue } from "./json";
+export type InstrumentedFetchOptions = {
+    /** Base fetch to wrap (defaults to globalThis.fetch) */
+    baseFetch?: typeof fetch;
+    /** Additional metadata to include in all logs */
+    defaultMetadata?: Record<string, JsonValue>;
+    /** Source identifier (default: "openrouter") */
+    source?: string;
+};
+export declare function createInstrumentedFetch(client: TelemetryClient, options?: InstrumentedFetchOptions): typeof fetch;
+//# sourceMappingURL=fetch.d.ts.map

package/dist/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../src/fetch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAKxC,MAAM,MAAM,wBAAwB,GAAG;IACrC,wDAAwD;IACxD,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;IACzB,iDAAiD;IACjD,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC5C,gDAAgD;IAChD,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,CAAC;AAoBF,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,eAAe,EACvB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,KAAK,CA8Td"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { TelemetryClient } from "./client";
+export type { TelemetryClientOptions } from "./client";
+export { createInstrumentedFetch } from "./fetch";
+export type { InstrumentedFetchOptions } from "./fetch";
+export { parseSSE } from "./sse";
+export type { SSEEvent } from "./sse";
+export type { TelemetryBatchPayload, TelemetryLog, TelemetryTrace, } from "./types/telemetry";
+export { createId, safeJsonParse, sanitizeHeaders, toIso, truncateUtf8 } from "./json";
+export type { JsonPrimitive, JsonValue } from "./json";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAC3C,YAAY,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAGvD,OAAO,EAAE,uBAAuB,EAAE,MAAM,SAAS,CAAC;AAClD,YAAY,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAGxD,OAAO,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AACjC,YAAY,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAGtC,YAAY,EACV,qBAAqB,EACrB,YAAY,EACZ,cAAc,GACf,MAAM,mBAAmB,CAAC;AAG3B,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,eAAe,EAAE,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AACvF,YAAY,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC"}

package/dist/index.js

@@ -0,0 +1,547 @@
+// src/json.ts
+function toIso(d) {
+  return d.toISOString();
+}
+function createId() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID)
+    return c.randomUUID();
+  return `id_${Date.now().toString(36)}_${Math.random().toString(36).slice(2)}`;
+}
+function safeJsonParse(text) {
+  try {
+    const v = JSON.parse(text);
+    return { ok: true, value: v };
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : "Invalid JSON" };
+  }
+}
+var SENSITIVE_HEADERS = new Set([
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key",
+  "api-key"
+]);
+function sanitizeHeaders(headers) {
+  const out = {};
+  if (!headers)
+    return out;
+  const set = (k, v) => {
+    const key = k.toLowerCase();
+    if (SENSITIVE_HEADERS.has(key))
+      return;
+    out[key] = v;
+  };
+  if (headers instanceof Headers) {
+    headers.forEach((v, k) => set(k, v));
+  } else if (Array.isArray(headers)) {
+    for (const [k, v] of headers)
+      set(k, v);
+  } else {
+    for (const [k, v] of Object.entries(headers))
+      set(k, String(v));
+  }
+  return out;
+}
+function truncateUtf8(input, maxBytes) {
+  const enc = new TextEncoder;
+  const bytes = enc.encode(input);
+  if (bytes.length <= maxBytes)
+    return { text: input, truncated: false };
+  const sliced = bytes.slice(0, maxBytes);
+  const dec = new TextDecoder("utf-8", { fatal: false });
+  return { text: dec.decode(sliced), truncated: true };
+}
+
+// src/client.ts
+class TelemetryClient {
+  baseUrl;
+  apiKey;
+  project;
+  environment;
+  defaultMetadata;
+  timeoutMs;
+  maxBatchSize;
+  flushIntervalMs;
+  maxLogBytes;
+  maxQueueSize;
+  retryBaseDelayMs;
+  retryMaxDelayMs;
+  maxRetries;
+  queue = [];
+  flushing = false;
+  timer = null;
+  retryCount = 0;
+  retryDelayMs;
+  circuitOpen = false;
+  circuitOpenUntil = 0;
+  consecutiveFailures = 0;
+  circuitBreakerThreshold = 5;
+  circuitBreakerDurationMs = 30000;
+  onError;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.apiKey = opts.apiKey;
+    this.project = opts.project;
+    this.environment = opts.environment;
+    this.defaultMetadata = opts.defaultMetadata;
+    this.timeoutMs = opts.timeoutMs ?? 5000;
+    this.maxBatchSize = opts.maxBatchSize ?? 25;
+    this.flushIntervalMs = opts.flushIntervalMs ?? 2000;
+    this.maxLogBytes = opts.maxLogBytes ?? 1e6;
+    this.maxQueueSize = opts.maxQueueSize ?? 1000;
+    this.retryBaseDelayMs = opts.retryBaseDelayMs ?? 1000;
+    this.retryMaxDelayMs = opts.retryMaxDelayMs ?? 30000;
+    this.maxRetries = opts.maxRetries ?? 5;
+    this.retryDelayMs = this.retryBaseDelayMs;
+    this.onError = opts.onError;
+    if (this.flushIntervalMs > 0) {
+      this.timer = setInterval(() => void this.flush(), this.flushIntervalMs);
+      if (typeof this.timer === "object" && "unref" in this.timer) {
+        this.timer.unref();
+      }
+    }
+  }
+  report(log) {
+    if (this.project) {
+      log.project = log.project || this.project;
+    }
+    log.environment = log.environment ?? this.environment;
+    if (this.defaultMetadata) {
+      log.metadata = { ...this.defaultMetadata, ...log.metadata ?? {} };
+    }
+    const raw = JSON.stringify(log);
+    const truncated = truncateUtf8(raw, this.maxLogBytes);
+    if (!truncated.truncated) {
+      this.queue.push(log);
+    } else {
+      this.queue.push({
+        ...log,
+        request: {
+          ...log.request,
+          body_text: "[truncated - log exceeded maxLogBytes]",
+          body_truncated: true
+        },
+        error: log.error ?? { message: "Log truncated to maxLogBytes" }
+      });
+    }
+    this.enforceQueueLimit();
+    if (this.queue.length >= this.maxBatchSize) {
+      this.flush();
+    }
+  }
+  enforceQueueLimit() {
+    if (this.queue.length > this.maxQueueSize) {
+      const dropped = this.queue.length - this.maxQueueSize;
+      this.queue.splice(0, dropped);
+      this.onError?.(new Error(`Queue limit exceeded, dropped ${dropped} logs`));
+    }
+  }
+  async flush() {
+    if (this.flushing)
+      return;
+    if (this.queue.length === 0)
+      return;
+    if (this.circuitOpen) {
+      if (Date.now() < this.circuitOpenUntil) {
+        return;
+      }
+      this.circuitOpen = false;
+    }
+    this.flushing = true;
+    const batch = this.queue.splice(0, this.maxBatchSize);
+    try {
+      const payload = { logs: batch };
+      const ctrl = new AbortController;
+      const t = setTimeout(() => ctrl.abort(), this.timeoutMs);
+      const res = await fetch(`${this.baseUrl}/v1/logs/batch`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(payload),
+        signal: ctrl.signal
+      });
+      clearTimeout(t);
+      if (res.status === 207) {
+        const body = await res.json().catch(() => null);
+        const failedIds = new Set;
+        if (body && typeof body === "object") {
+          const failed = body.failed;
+          if (Array.isArray(failed)) {
+            for (const item of failed) {
+              if (item && typeof item === "object") {
+                const id = item.id;
+                if (typeof id === "string") {
+                  failedIds.add(id);
+                }
+              }
+            }
+          }
+        }
+        if (failedIds.size > 0) {
+          const retry = batch.filter((log) => failedIds.has(log.id));
+          if (retry.length > 0) {
+            this.queue.unshift(...retry);
+            this.enforceQueueLimit();
+          }
+        }
+        const partialMessage = body && typeof body === "object" ? body.partial_success?.error_message : undefined;
+        const message = typeof partialMessage === "string" ? partialMessage : "Telemetry partial success";
+        this.onError?.(new Error(message));
+        this.handleSuccess();
+        return;
+      }
+      if (!res.ok) {
+        const errorText = await res.text().catch(() => "");
+        throw new Error(`Telemetry ingest failed: ${res.status} ${res.statusText} - ${errorText}`);
+      }
+      this.handleSuccess();
+    } catch (err) {
+      this.handleFailure(batch, err);
+    } finally {
+      this.flushing = false;
+    }
+  }
+  handleSuccess() {
+    this.consecutiveFailures = 0;
+    this.retryCount = 0;
+    this.retryDelayMs = this.retryBaseDelayMs;
+    this.circuitOpen = false;
+  }
+  handleFailure(batch, err) {
+    this.consecutiveFailures++;
+    this.retryCount++;
+    if (this.consecutiveFailures >= this.circuitBreakerThreshold) {
+      this.circuitOpen = true;
+      this.circuitOpenUntil = Date.now() + this.circuitBreakerDurationMs;
+      this.onError?.(new Error(`Circuit breaker opened after ${this.consecutiveFailures} failures`));
+    }
+    if (this.retryCount > this.maxRetries) {
+      this.onError?.(new Error(`Dropping batch after ${this.maxRetries} retries: ${err}`));
+      this.retryCount = 0;
+      this.retryDelayMs = this.retryBaseDelayMs;
+      return;
+    }
+    this.queue.unshift(...batch);
+    this.enforceQueueLimit();
+    this.onError?.(err);
+    this.retryDelayMs = Math.min(this.retryDelayMs * 2 + Math.random() * 100, this.retryMaxDelayMs);
+    setTimeout(() => void this.flush(), this.retryDelayMs);
+  }
+  async shutdown() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.circuitOpen = false;
+    await this.flush();
+  }
+}
+// src/sse.ts
+function parseSSE(chunk) {
+  const events = [];
+  const normalized = chunk.replace(/\r\n/g, "\n");
+  const blocks = normalized.split("\n\n");
+  for (let i = 0;i < blocks.length - 1; i += 1) {
+    const block = blocks[i];
+    if (!block.trim())
+      continue;
+    const lines = block.split("\n");
+    const data = [];
+    let event;
+    let id;
+    for (const line of lines) {
+      if (!line || line.startsWith(":"))
+        continue;
+      const idx = line.indexOf(":");
+      if (idx === -1)
+        continue;
+      const field = line.slice(0, idx).trim();
+      const raw = line.slice(idx + 1);
+      const value = raw.startsWith(" ") ? raw.slice(1) : raw;
+      if (field === "data") {
+        data.push(value);
+      } else if (field === "event") {
+        event = value;
+      } else if (field === "id") {
+        id = value;
+      }
+    }
+    if (data.length === 0)
+      continue;
+    events.push({ data: data.join("\n"), event, id });
+  }
+  return events;
+}
+
+// src/fetch.ts
+function shouldIntercept(url) {
+  return url.includes("/chat/completions") || url.includes("/completions");
+}
+function safeJsonParse2(text) {
+  try {
+    return { json: JSON.parse(text) };
+  } catch {
+    return { text };
+  }
+}
+function createInstrumentedFetch(client, options) {
+  const baseFetch = options?.baseFetch ?? globalThis.fetch;
+  const defaultMetadata = options?.defaultMetadata;
+  const source = options?.source ?? "openrouter";
+  const instrumentedFetch = async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    if (!shouldIntercept(url)) {
+      return baseFetch(input, init);
+    }
+    const startTime = new Date;
+    const logId = createId();
+    const method = init?.method ?? "GET";
+    const path = new URL(url).pathname;
+    let requestBody = {};
+    if (init?.body) {
+      const bodyStr = typeof init.body === "string" ? init.body : String(init.body);
+      requestBody = safeJsonParse2(bodyStr);
+    }
+    const model = requestBody.json?.model;
+    const streamed = requestBody.json?.stream === true;
+    const requestMetadata = requestBody.json?.metadata;
+    const sanitizedHeaders = sanitizeHeaders(init?.headers);
+    try {
+      const response = await baseFetch(input, init);
+      if (!streamed) {
+        const endTime = new Date;
+        const cloned = response.clone();
+        let responseBody = {};
+        let outputText;
+        let finishReason2;
+        let usage2;
+        try {
+          const text = await cloned.text();
+          responseBody = safeJsonParse2(text);
+          if (responseBody.json) {
+            const json = responseBody.json;
+            const choices = json.choices;
+            if (choices?.[0]) {
+              const message = choices[0].message;
+              outputText = message?.content;
+              finishReason2 = choices[0].finish_reason;
+            }
+            usage2 = json.usage;
+          }
+        } catch {
+        }
+        try {
+          const log = {
+            id: logId,
+            timestamp: toIso(startTime),
+            project: client.project ?? "",
+            environment: client.environment,
+            source,
+            method,
+            url,
+            path,
+            model,
+            streamed: false,
+            timing: {
+              started_at: toIso(startTime),
+              ended_at: toIso(endTime),
+              duration_ms: endTime.getTime() - startTime.getTime()
+            },
+            metadata: requestMetadata ? { ...defaultMetadata, ...requestMetadata } : defaultMetadata,
+            request: {
+              headers: sanitizedHeaders,
+              body_json: requestBody.json,
+              body_text: requestBody.text
+            },
+            response: {
+              status: response.status,
+              headers: sanitizeHeaders(response.headers),
+              body_json: responseBody.json,
+              body_text: responseBody.text
+            },
+            stream: outputText ? {
+              output_text: outputText,
+              finish_reason: finishReason2 ?? null,
+              usage: usage2
+            } : undefined,
+            usage: usage2
+          };
+          client.report(log);
+        } catch {
+        }
+        return response;
+      }
+      if (!response.body) {
+        return response;
+      }
+      const sseEvents = [];
+      let sseTruncated = false;
+      const textChunks = [];
+      const toolCalls = new Map;
+      let finishReason = null;
+      let usage;
+      const transform = new TransformStream({
+        transform(chunk, controller) {
+          controller.enqueue(chunk);
+          try {
+            const text = new TextDecoder().decode(chunk);
+            const events = parseSSE(text);
+            for (const event of events) {
+              if (event.data === "[DONE]")
+                continue;
+              try {
+                const parsed = JSON.parse(event.data);
+                if (sseEvents.length < 100) {
+                  sseEvents.push(parsed);
+                } else if (!sseTruncated) {
+                  sseTruncated = true;
+                }
+                const choices = parsed.choices;
+                const delta = choices?.[0]?.delta;
+                if (delta?.content) {
+                  textChunks.push(delta.content);
+                }
+                const deltaToolCalls = delta?.tool_calls;
+                if (deltaToolCalls) {
+                  for (const tc of deltaToolCalls) {
+                    const idx = tc.index ?? 0;
+                    if (!toolCalls.has(idx)) {
+                      toolCalls.set(idx, {
+                        id: tc.id ?? "",
+                        type: "function",
+                        function: { name: "", arguments: "" }
+                      });
+                    }
+                    const existing = toolCalls.get(idx);
+                    if (tc.id)
+                      existing.id = tc.id;
+                    const fn = tc.function;
+                    if (fn?.name)
+                      existing.function.name = fn.name;
+                    if (fn?.arguments)
+                      existing.function.arguments += fn.arguments;
+                  }
+                }
+                if (choices?.[0]?.finish_reason) {
+                  finishReason = choices[0].finish_reason;
+                }
+                if (parsed.usage) {
+                  usage = parsed.usage;
+                }
+              } catch {
+              }
+            }
+          } catch {
+          }
+        },
+        flush() {
+          const endTime = new Date;
+          const toolCallsArray = Array.from(toolCalls.values());
+          const outputText = textChunks.join("");
+          let finalEvents = sseEvents;
+          if (sseTruncated && sseEvents.length >= 100) {
+            finalEvents = [
+              ...sseEvents.slice(0, 50),
+              { truncated: true, total: sseEvents.length },
+              ...sseEvents.slice(-50)
+            ];
+          }
+          try {
+            const log = {
+              id: logId,
+              timestamp: toIso(startTime),
+              project: client.project ?? "",
+              environment: client.environment,
+              source,
+              method,
+              url,
+              path,
+              model,
+              streamed: true,
+              timing: {
+                started_at: toIso(startTime),
+                ended_at: toIso(endTime),
+                duration_ms: endTime.getTime() - startTime.getTime()
+              },
+              metadata: requestMetadata ? { ...defaultMetadata, ...requestMetadata } : defaultMetadata,
+              request: {
+                headers: sanitizedHeaders,
+                body_json: requestBody.json,
+                body_text: requestBody.text
+              },
+              response: {
+                status: response.status,
+                headers: sanitizeHeaders(response.headers)
+              },
+              stream: {
+                sse_events: finalEvents,
+                sse_events_truncated: sseTruncated,
+                output_text: outputText,
+                tool_calls: toolCallsArray.length > 0 ? toolCallsArray : undefined,
+                finish_reason: finishReason,
+                usage
+              },
+              usage
+            };
+            client.report(log);
+          } catch {
+          }
+        }
+      });
+      return new Response(response.body.pipeThrough(transform), {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers
+      });
+    } catch (err) {
+      const endTime = new Date;
+      try {
+        const log = {
+          id: logId,
+          timestamp: toIso(startTime),
+          project: client.project ?? "",
+          environment: client.environment,
+          source,
+          method,
+          url,
+          path,
+          model,
+          streamed,
+          timing: {
+            started_at: toIso(startTime),
+            ended_at: toIso(endTime),
+            duration_ms: endTime.getTime() - startTime.getTime()
+          },
+          metadata: requestMetadata ? { ...defaultMetadata, ...requestMetadata } : defaultMetadata,
+          request: {
+            headers: sanitizedHeaders,
+            body_json: requestBody.json,
+            body_text: requestBody.text
+          },
+          error: {
+            message: err instanceof Error ? err.message : String(err),
+            stack: err instanceof Error ? err.stack : undefined
+          }
+        };
+        client.report(log);
+      } catch {
+      }
+      throw err;
+    }
+  };
+  return instrumentedFetch;
+}
+export {
+  truncateUtf8,
+  toIso,
+  sanitizeHeaders,
+  safeJsonParse,
+  parseSSE,
+  createInstrumentedFetch,
+  createId,
+  TelemetryClient
+};

package/dist/json.d.ts

@@ -0,0 +1,19 @@
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export declare function toIso(d: Date): string;
+export declare function createId(): string;
+export declare function safeJsonParse(text: string): {
+    ok: true;
+    value: JsonValue;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function sanitizeHeaders(headers: HeadersInit | undefined): Record<string, string>;
+export declare function truncateUtf8(input: string, maxBytes: number): {
+    text: string;
+    truncated: boolean;
+};
+//# sourceMappingURL=json.d.ts.map

package/dist/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../src/json.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC;AAC7D,MAAM,MAAM,SAAS,GAAG,aAAa,GAAG,SAAS,EAAE,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAEnF,wBAAgB,KAAK,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAErC;AAED,wBAAgB,QAAQ,IAAI,MAAM,CAIjC;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAOzG;AAUD,wBAAgB,eAAe,CAAC,OAAO,EAAE,WAAW,GAAG,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAmBxF;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAQlG"}

package/dist/sse.d.ts

@@ -0,0 +1,7 @@
+export type SSEEvent = {
+    data: string;
+    event?: string;
+    id?: string;
+};
+export declare function parseSSE(chunk: string): SSEEvent[];
+//# sourceMappingURL=sse.d.ts.map

package/dist/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../src/sse.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,EAAE,CAAC,EAAE,MAAM,CAAC;CACb,CAAC;AAEF,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,QAAQ,EAAE,CAoClD"}

package/dist/types/telemetry.d.ts

@@ -0,0 +1,56 @@
+import type { JsonValue } from "../json";
+export type TelemetryTrace = {
+    trace_id?: string;
+    span_id?: string;
+    parent_span_id?: string;
+};
+export type TelemetryLog = {
+    id: string;
+    timestamp: string;
+    project: string;
+    environment?: string;
+    source: string;
+    method: string;
+    url: string;
+    path: string;
+    model?: string;
+    generation_id?: string;
+    streamed: boolean;
+    timing: {
+        started_at: string;
+        ended_at?: string;
+        duration_ms?: number;
+    };
+    metadata?: Record<string, JsonValue>;
+    trace?: TelemetryTrace;
+    request: {
+        headers?: Record<string, string>;
+        body_json?: JsonValue;
+        body_text?: string;
+        body_truncated?: boolean;
+    };
+    response?: {
+        status: number;
+        headers?: Record<string, string>;
+        body_json?: JsonValue;
+        body_text?: string;
+        body_truncated?: boolean;
+    };
+    stream?: {
+        sse_events?: JsonValue[];
+        sse_events_truncated?: boolean;
+        output_text?: string;
+        tool_calls?: JsonValue;
+        finish_reason?: string | null;
+        usage?: JsonValue;
+    };
+    usage?: JsonValue;
+    error?: {
+        message: string;
+        stack?: string;
+    };
+};
+export type TelemetryBatchPayload = {
+    logs: TelemetryLog[];
+};
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/types/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../../src/types/telemetry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAElB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IAEb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;IAElB,MAAM,EAAE;QACN,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC;IAEF,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACrC,KAAK,CAAC,EAAE,cAAc,CAAC;IAEvB,OAAO,EAAE;QACP,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACjC,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B,CAAC;IAEF,QAAQ,CAAC,EAAE;QACT,MAAM,EAAE,MAAM,CAAC;QACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACjC,SAAS,CAAC,EAAE,SAAS,CAAC;QACtB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B,CAAC;IAEF,MAAM,CAAC,EAAE;QACP,UAAU,CAAC,EAAE,SAAS,EAAE,CAAC;QACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,SAAS,CAAC;QACvB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAC9B,KAAK,CAAC,EAAE,SAAS,CAAC;KACnB,CAAC;IAEF,KAAK,CAAC,EAAE,SAAS,CAAC;IAElB,KAAK,CAAC,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC7C,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,YAAY,EAAE,CAAC;CACtB,CAAC"}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@syntheticminds/wiretap-llm",
+  "version": "0.2.3",
+  "description": "Telemetry client for sending LLM logs to Wiretap",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target node && tsc --emitDeclarationOnly",
+    "dev": "bun build ./src/index.ts --outdir ./dist --target node --watch",
+    "typecheck": "tsc --noEmit",
+    "test:e2e": "bun test tests/e2e --preload ./tests/e2e/setup.ts",
+    "test:e2e:setup": "bun run ./tests/e2e/setup.ts",
+    "test:e2e:teardown": "bun run ./tests/e2e/teardown.ts",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "llm",
+    "telemetry",
+    "openrouter",
+    "openai",
+    "observability",
+    "monitoring",
+    "ai",
+    "wiretap"
+  ],
+  "author": "Saint",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kingbootoshi/wiretap.git",
+    "directory": "packages/sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/kingbootoshi/wiretap/issues"
+  },
+  "homepage": "https://github.com/kingbootoshi/wiretap/tree/main/packages/sdk#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@supabase/supabase-js": "^2.90.1",
+    "openai": "latest",
+    "typescript": "^5.7.2"
+  }
+}