wiretap-llm 0.1.0 → 0.2.0

package/README.md

@@ -10,18 +10,60 @@ npm install wiretap-llm
 bun add wiretap-llm
 ```
 
-## Quick Start
+## 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";
 
-// Create client
 const client = new TelemetryClient({
   baseUrl: process.env.WIRETAP_BASE_URL!,
   apiKey: process.env.WIRETAP_API_KEY!,
 });
 
-// Send a log
 client.report({
   id: createId(),
   timestamp: toIso(new Date()),
@@ -31,7 +73,7 @@ client.report({
   url: "https://openrouter.ai/api/v1/chat/completions",
   path: "/v1/chat/completions",
   model: "anthropic/claude-sonnet-4",
-  streamed: true,
+  streamed: false,
   timing: {
     started_at: toIso(startTime),
     ended_at: toIso(endTime),
@@ -40,14 +82,13 @@ client.report({
   request: {
     body_json: requestBody,
   },
-  stream: {
-    output_text: "Hello!",
-    finish_reason: "stop",
-    usage: { prompt_tokens: 10, completion_tokens: 5 },
+  response: {
+    status: 200,
+    body_json: responseBody,
   },
+  usage: responseBody.usage,
 });
 
-// On app shutdown
 await client.shutdown();
 ```
 
@@ -55,32 +96,55 @@ await client.shutdown();
 
 ### TelemetryClient Options
 
-| Option | Type | Required | Default | Description |
-|--------|------|----------|---------|-------------|
-| `baseUrl` | string | Yes | - | Your Wiretap instance URL |
-| `apiKey` | string | Yes | - | Your Wiretap API key |
-| `project` | string | No | - | Project slug (usually inferred from API key) |
-| `environment` | string | No | - | Environment name (e.g., "production") |
-| `defaultMetadata` | object | No | - | Metadata added to all logs |
-| `timeoutMs` | number | No | 5000 | Request timeout |
-| `maxBatchSize` | number | No | 25 | Max logs per batch |
-| `flushIntervalMs` | number | No | 2000 | Auto-flush interval |
-| `maxLogBytes` | number | No | 1000000 | Max log size before truncation |
-| `onError` | function | No | - | Error handler |
+| 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
 
-## API
+| 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 |
 
-### `client.report(log: TelemetryLog)`
+## Reliability Features
 
-Queue a log for sending. Logs are batched and sent automatically.
+### Automatic Retry with Exponential Backoff
 
-### `client.flush()`
+Failed batches are automatically retried with exponential backoff (1s, 2s, 4s, ...) up to 30s max delay.
 
-Manually flush pending logs.
+### Circuit Breaker
 
-### `client.shutdown()`
+After 5 consecutive failures, the circuit breaker opens for 30 seconds. During this time, flushes are skipped to prevent hammering a dead server.
 
-Flush remaining logs and stop the client. Call on app shutdown.
+### 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
 

package/dist/client.d.ts

@@ -11,6 +11,14 @@ export type TelemetryClientOptions = {
     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 {
@@ -23,13 +31,27 @@ export declare class TelemetryClient {
     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

@@ -1 +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,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;IAE5B,OAAO,CAAC,KAAK,CAAsB;IACnC,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,KAAK,CAA+C;IAE5D,OAAO,CAAC,OAAO,CAAC,CAAyB;gBAE7B,IAAI,EAAE,sBAAsB;IAuBxC,MAAM,CAAC,GAAG,EAAE,YAAY,GAAG,IAAI;IAmCzB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA0EtB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAQhC"}
+{"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,CAsTd"}

package/dist/index.d.ts

@@ -1,5 +1,9 @@
 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";

package/dist/index.d.ts.map

@@ -1 +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,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"}
+{"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

@@ -65,9 +65,20 @@ class TelemetryClient {
   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(/\/+$/, "");
@@ -79,6 +90,11 @@ class TelemetryClient {
     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);
@@ -110,15 +126,29 @@ class TelemetryClient {
         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 {
@@ -155,38 +185,362 @@ class TelemetryClient {
           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) {
-        this.queue.unshift(...batch);
         const errorText = await res.text().catch(() => "");
         throw new Error(`Telemetry ingest failed: ${res.status} ${res.statusText} - ${errorText}`);
       }
+      this.handleSuccess();
     } catch (err) {
-      this.queue.unshift(...batch);
-      this.onError?.(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 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: 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: 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: 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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wiretap-llm",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Telemetry client for sending LLM logs to Wiretap",
   "type": "module",
   "main": "./dist/index.js",