deadpipe 2.0.1 → 2.0.2

package/README.md

@@ -14,36 +14,37 @@ pnpm add deadpipe
 
 ## Quick Start
 
-### Option 1: Context Manager (Recommended)
+**Recommended: Wrap your client (zero code changes, automatic context capture)**
 
 ```typescript
-import { track } from 'deadpipe';
+import { wrapOpenAI } from 'deadpipe';
 import OpenAI from 'openai';
 
-const client = new OpenAI();
+const client = wrapOpenAI(new OpenAI(), { promptId: 'checkout_agent' });
 
-const response = await track('checkout_agent', async (t) => {
-  const response = await client.chat.completions.create({
-    model: 'gpt-4',
-    messages: [{ role: 'user', content: 'Process refund for order 1938' }]
-  });
-  t.record(response);
-  return response;
+// All calls automatically tracked with full input/output context
+const response = await client.chat.completions.create({
+  model: 'gpt-4',
+  messages: [{ role: 'user', content: 'Process refund for order 1938' }]
 });
 ```
 
-### Option 2: Auto-Wrapping (Zero Code Changes)
+**Advanced: Manual tracking (for streaming, custom logic, etc.)**
 
 ```typescript
-import { wrapOpenAI } from 'deadpipe';
+import { track } from 'deadpipe';
 import OpenAI from 'openai';
 
-const client = wrapOpenAI(new OpenAI(), { promptId: 'checkout_agent' });
-
-// All calls automatically tracked
-const response = await client.chat.completions.create({
+const client = new OpenAI();
+const params = {
   model: 'gpt-4',
   messages: [{ role: 'user', content: 'Process refund for order 1938' }]
+};
+
+const response = await track('checkout_agent', async (t) => {
+  const response = await client.chat.completions.create(params);
+  t.record(response, undefined, params);  // Pass params to capture input
+  return response;
 });
 ```
 
@@ -105,12 +106,14 @@ Every prompt execution captures:
 ### Track Streaming Responses
 
 ```typescript
+const params = {
+  model: 'gpt-4',
+  messages: [{ role: 'user', content: 'Tell me a story' }],
+  stream: true,
+};
+
 const response = await track('streaming_agent', async (t) => {
-  const stream = await client.chat.completions.create({
-    model: 'gpt-4',
-    messages: [{ role: 'user', content: 'Tell me a story' }],
-    stream: true,
-  });
+  const stream = await client.chat.completions.create(params);
 
   let fullContent = '';
   for await (const chunk of stream) {
@@ -120,12 +123,12 @@ const response = await track('streaming_agent', async (t) => {
     }
   }
 
-  // Record manually for streams
+  // Record manually for streams - pass input params to capture context
   t.record({ 
     model: 'gpt-4',
     choices: [{ message: { content: fullContent } }],
     usage: { prompt_tokens: 10, completion_tokens: 100, total_tokens: 110 }
-  });
+  }, undefined, params);
 
   return fullContent;
 });
@@ -162,9 +165,9 @@ const response = await track('claude_agent', async (t) => {
     max_tokens: 1024,
     messages: [{ role: 'user', content: 'Hello, Claude!' }]
   });
-  t.record(response);
+  t.record(response);  // Provider auto-detected from response
   return response;
-}, { provider: 'anthropic' });
+});
 ```
 
 ### Environment-Based Configuration
@@ -197,17 +200,11 @@ await track('checkout_agent', fn, {
   appId: 'my-app',
   environment: 'production',
   version: '1.2.3',
-  provider: 'openai', // or 'anthropic'
 
   // Validation
   schema: { validate: (data) => ({ success: true, data }) },
   enumFields: { status: ['pending', 'approved', 'rejected'] },
   numericBounds: { amount: [0, 10000] },
-
-  // Context (for change detection)
-  messages: [...],
-  tools: [...],
-  systemPrompt: 'You are a helpful assistant...',
 });
 ```
 
@@ -284,12 +281,22 @@ Returns: Wrapped client with identical API
 
 The tracker object passed to your function:
 
-- `record(response)` - Record the LLM response
+- `record(response, parsedOutput?, input?)` - Record the LLM response
+  - `response` - The LLM response object
+  - `parsedOutput` - Optional pre-parsed output (if you already parsed JSON)
+  - `input` - Optional input parameters (messages, tools, etc.) to capture context
 - `markFirstToken()` - Mark when first token received (streaming)
 - `markRetry()` - Mark a retry attempt
 - `recordError(error)` - Record an error
 - `getTelemetry()` - Get the telemetry object
 
+**Tip:** Always pass the input parameters to `record()` to capture full context:
+```typescript
+const params = { model: 'gpt-4', messages: [...] };
+const response = await client.chat.completions.create(params);
+t.record(response, undefined, params);  // Pass params to capture input context
+```
+
 ### `estimateCost(model, inputTokens, outputTokens)`
 
 Estimate USD cost for a completion.

package/dist/index.d.mts

@@ -2,28 +2,29 @@
  * Deadpipe - LLM observability that answers one question:
  * "Is this prompt behaving the same as when it was last safe?"
  *
- * @example
+ * @example Recommended: Wrap your client (zero code changes)
+ * import { wrapOpenAI } from 'deadpipe';
+ * import OpenAI from 'openai';
+ *
+ * const client = wrapOpenAI(new OpenAI(), { promptId: 'checkout_agent' });
+ * // All calls automatically tracked with full context
+ * const response = await client.chat.completions.create({
+ *   model: 'gpt-4',
+ *   messages: [{ role: 'user', content: 'Process refund for order 1938' }]
+ * });
+ *
+ * @example Advanced: Manual tracking (for streaming, custom logic, etc.)
  * import { track } from 'deadpipe';
  * import OpenAI from 'openai';
  *
  * const client = new OpenAI();
+ * const params = { model: 'gpt-4', messages: [...] };
  *
- * const { response, tracker } = await track('checkout_agent', async (t) => {
- *   const response = await client.chat.completions.create({
- *     model: 'gpt-4',
- *     messages: [{ role: 'user', content: 'Process refund for order 1938' }]
- *   });
- *   t.record(response);
+ * const response = await track('checkout_agent', async (t) => {
+ *   const response = await client.chat.completions.create(params);
+ *   t.record(response, undefined, params);  // Pass params to capture input
  *   return response;
  * });
- *
- * @example Auto-wrapping (zero code changes):
- * import { wrapOpenAI } from 'deadpipe';
- * import OpenAI from 'openai';
- *
- * const client = wrapOpenAI(new OpenAI(), { promptId: 'checkout_agent' });
- * // All calls automatically tracked
- * const response = await client.chat.completions.create(...);
  */
 declare const VERSION = "2.0.0";
 type StatusType = 'success' | 'error' | 'timeout' | 'empty' | 'schema_violation' | 'refusal';
@@ -77,17 +78,9 @@ interface TrackOptions {
     appId?: string;
     environment?: string;
     version?: string;
-    provider?: 'openai' | 'anthropic' | string;
     schema?: SchemaValidator;
     enumFields?: Record<string, unknown[]>;
     numericBounds?: Record<string, [number | null, number | null]>;
-    messages?: Array<{
-        role: string;
-        content: string;
-        [key: string]: unknown;
-    }>;
-    tools?: Array<Record<string, unknown>>;
-    systemPrompt?: string;
 }
 interface SchemaValidator {
     validate: (data: unknown) => {
@@ -96,13 +89,18 @@ interface SchemaValidator {
         errors?: string[];
     };
 }
-interface WrapOpenAIOptions extends Omit<TrackOptions, 'messages' | 'tools' | 'systemPrompt'> {
+interface WrapOpenAIOptions extends TrackOptions {
     promptId: string;
 }
 declare function estimateCost(model: string, inputTokens: number, outputTokens: number): number | null;
 declare function detectRefusal(text: string): boolean;
 declare function validateEnumBounds(data: Record<string, unknown>, enumFields?: Record<string, unknown[]>): boolean;
 declare function validateNumericBounds(data: Record<string, unknown>, numericBounds?: Record<string, [number | null, number | null]>): boolean;
+/**
+ * Auto-detect provider from response object.
+ * Checks for provider-specific response structures.
+ */
+declare function detectProvider(response: any): 'openai' | 'anthropic' | 'unknown';
 interface ExtractedResponse {
     model: string;
     content: string;
@@ -126,7 +124,6 @@ declare class PromptTracker {
     private appId;
     private environment;
     private versionStr;
-    private provider;
     private schema;
     private enumFields;
     private numericBounds;
@@ -145,7 +142,7 @@ declare class PromptTracker {
     start(): void;
     markFirstToken(): void;
     markRetry(): void;
-    record(response: any, parsedOutput?: unknown): unknown;
+    record(response: any, parsedOutput?: unknown, input?: any): unknown;
     recordError(error: Error): void;
     private send;
     isRecorded(): boolean;
@@ -164,4 +161,4 @@ interface TrackedOpenAIClient extends OpenAIClient {
 }
 declare function wrapOpenAI(client: OpenAIClient, options: WrapOpenAIOptions): TrackedOpenAIClient;
 
-export { type PromptTelemetry, PromptTracker, type SchemaValidator, type StatusType, type TrackOptions, VERSION, type WrapOpenAIOptions, detectRefusal, estimateCost, extractAnthropicResponse, extractOpenAIResponse, track, validateEnumBounds, validateNumericBounds, wrapOpenAI };
+export { type PromptTelemetry, PromptTracker, type SchemaValidator, type StatusType, type TrackOptions, VERSION, type WrapOpenAIOptions, wrapOpenAI as default, detectProvider, detectRefusal, estimateCost, extractAnthropicResponse, extractOpenAIResponse, track, validateEnumBounds, validateNumericBounds, wrapOpenAI };

package/dist/index.d.ts

@@ -2,28 +2,29 @@
  * Deadpipe - LLM observability that answers one question:
  * "Is this prompt behaving the same as when it was last safe?"
  *
- * @example
+ * @example Recommended: Wrap your client (zero code changes)
+ * import { wrapOpenAI } from 'deadpipe';
+ * import OpenAI from 'openai';
+ *
+ * const client = wrapOpenAI(new OpenAI(), { promptId: 'checkout_agent' });
+ * // All calls automatically tracked with full context
+ * const response = await client.chat.completions.create({
+ *   model: 'gpt-4',
+ *   messages: [{ role: 'user', content: 'Process refund for order 1938' }]
+ * });
+ *
+ * @example Advanced: Manual tracking (for streaming, custom logic, etc.)
  * import { track } from 'deadpipe';
  * import OpenAI from 'openai';
  *
  * const client = new OpenAI();
+ * const params = { model: 'gpt-4', messages: [...] };
  *
- * const { response, tracker } = await track('checkout_agent', async (t) => {
- *   const response = await client.chat.completions.create({
- *     model: 'gpt-4',
- *     messages: [{ role: 'user', content: 'Process refund for order 1938' }]
- *   });
- *   t.record(response);
+ * const response = await track('checkout_agent', async (t) => {
+ *   const response = await client.chat.completions.create(params);
+ *   t.record(response, undefined, params);  // Pass params to capture input
  *   return response;
  * });
- *
- * @example Auto-wrapping (zero code changes):
- * import { wrapOpenAI } from 'deadpipe';
- * import OpenAI from 'openai';
- *
- * const client = wrapOpenAI(new OpenAI(), { promptId: 'checkout_agent' });
- * // All calls automatically tracked
- * const response = await client.chat.completions.create(...);
  */
 declare const VERSION = "2.0.0";
 type StatusType = 'success' | 'error' | 'timeout' | 'empty' | 'schema_violation' | 'refusal';
@@ -77,17 +78,9 @@ interface TrackOptions {
     appId?: string;
     environment?: string;
     version?: string;
-    provider?: 'openai' | 'anthropic' | string;
     schema?: SchemaValidator;
     enumFields?: Record<string, unknown[]>;
     numericBounds?: Record<string, [number | null, number | null]>;
-    messages?: Array<{
-        role: string;
-        content: string;
-        [key: string]: unknown;
-    }>;
-    tools?: Array<Record<string, unknown>>;
-    systemPrompt?: string;
 }
 interface SchemaValidator {
     validate: (data: unknown) => {
@@ -96,13 +89,18 @@ interface SchemaValidator {
         errors?: string[];
     };
 }
-interface WrapOpenAIOptions extends Omit<TrackOptions, 'messages' | 'tools' | 'systemPrompt'> {
+interface WrapOpenAIOptions extends TrackOptions {
     promptId: string;
 }
 declare function estimateCost(model: string, inputTokens: number, outputTokens: number): number | null;
 declare function detectRefusal(text: string): boolean;
 declare function validateEnumBounds(data: Record<string, unknown>, enumFields?: Record<string, unknown[]>): boolean;
 declare function validateNumericBounds(data: Record<string, unknown>, numericBounds?: Record<string, [number | null, number | null]>): boolean;
+/**
+ * Auto-detect provider from response object.
+ * Checks for provider-specific response structures.
+ */
+declare function detectProvider(response: any): 'openai' | 'anthropic' | 'unknown';
 interface ExtractedResponse {
     model: string;
     content: string;
@@ -126,7 +124,6 @@ declare class PromptTracker {
     private appId;
     private environment;
     private versionStr;
-    private provider;
     private schema;
     private enumFields;
     private numericBounds;
@@ -145,7 +142,7 @@ declare class PromptTracker {
     start(): void;
     markFirstToken(): void;
     markRetry(): void;
-    record(response: any, parsedOutput?: unknown): unknown;
+    record(response: any, parsedOutput?: unknown, input?: any): unknown;
     recordError(error: Error): void;
     private send;
     isRecorded(): boolean;
@@ -164,4 +161,4 @@ interface TrackedOpenAIClient extends OpenAIClient {
 }
 declare function wrapOpenAI(client: OpenAIClient, options: WrapOpenAIOptions): TrackedOpenAIClient;
 
-export { type PromptTelemetry, PromptTracker, type SchemaValidator, type StatusType, type TrackOptions, VERSION, type WrapOpenAIOptions, detectRefusal, estimateCost, extractAnthropicResponse, extractOpenAIResponse, track, validateEnumBounds, validateNumericBounds, wrapOpenAI };
+export { type PromptTelemetry, PromptTracker, type SchemaValidator, type StatusType, type TrackOptions, VERSION, type WrapOpenAIOptions, wrapOpenAI as default, detectProvider, detectRefusal, estimateCost, extractAnthropicResponse, extractOpenAIResponse, track, validateEnumBounds, validateNumericBounds, wrapOpenAI };

package/dist/index.js

@@ -22,6 +22,8 @@ var index_exports = {};
 __export(index_exports, {
   PromptTracker: () => PromptTracker,
   VERSION: () => VERSION,
+  default: () => index_default,
+  detectProvider: () => detectProvider,
   detectRefusal: () => detectRefusal,
   estimateCost: () => estimateCost,
   extractAnthropicResponse: () => extractAnthropicResponse,
@@ -132,6 +134,25 @@ function validateNumericBounds(data, numericBounds) {
   }
   return true;
 }
+function detectProvider(response) {
+  if (!response) return "unknown";
+  if (Array.isArray(response.content) || response.stop_reason !== void 0) {
+    return "anthropic";
+  }
+  if (response.choices !== void 0 || response.output !== void 0) {
+    return "openai";
+  }
+  if (response.model) {
+    const modelLower = String(response.model).toLowerCase();
+    if (modelLower.includes("claude")) {
+      return "anthropic";
+    }
+    if (modelLower.includes("gpt") || modelLower.includes("o1")) {
+      return "openai";
+    }
+  }
+  return "unknown";
+}
 function extractOpenAIResponse(response) {
   const result = {
     model: "",
@@ -231,16 +252,15 @@ var PromptTracker = class {
   appId;
   environment;
   versionStr;
-  provider;
   // Validation
   schema;
   enumFields;
   numericBounds;
-  // Context hashes
+  // Context hashes (auto-extracted from response)
   promptHash;
   toolSchemaHash;
   systemPromptHash;
-  // Context for previews
+  // Context for previews (auto-extracted from response)
   messages;
   systemPrompt;
   // Timing
@@ -259,24 +279,19 @@ var PromptTracker = class {
     this.appId = options.appId || process.env.DEADPIPE_APP_ID;
     this.environment = options.environment || process.env.DEADPIPE_ENVIRONMENT;
     this.versionStr = options.version || process.env.DEADPIPE_VERSION || process.env.GIT_COMMIT;
-    this.provider = options.provider || "openai";
     this.schema = options.schema;
     this.enumFields = options.enumFields;
     this.numericBounds = options.numericBounds;
-    this.promptHash = options.messages ? hashMessages(options.messages) : void 0;
-    this.toolSchemaHash = hashTools(options.tools);
-    this.systemPromptHash = options.systemPrompt ? hashContentSync(options.systemPrompt) : void 0;
-    this.messages = options.messages;
-    this.systemPrompt = options.systemPrompt;
+    this.messages = void 0;
+    this.systemPrompt = void 0;
+    this.promptHash = void 0;
+    this.toolSchemaHash = void 0;
+    this.systemPromptHash = void 0;
     this.telemetry = {
       prompt_id: this.promptId,
-      provider: this.provider,
       app_id: this.appId,
       environment: this.environment,
       version: this.versionStr,
-      prompt_hash: this.promptHash,
-      tool_schema_hash: this.toolSchemaHash,
-      system_prompt_hash: this.systemPromptHash,
       status: "success"
     };
   }
@@ -295,11 +310,44 @@ var PromptTracker = class {
     this.telemetry.retry_count = this.retryCount;
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  record(response, parsedOutput) {
+  record(response, parsedOutput, input) {
     this.endTime = Date.now();
     this.telemetry.end_time = new Date(this.endTime).toISOString();
     this.telemetry.total_latency = this.startTime ? this.endTime - this.startTime : 0;
-    const extracted = this.provider === "anthropic" ? extractAnthropicResponse(response) : extractOpenAIResponse(response);
+    const detectedProvider = detectProvider(response);
+    this.telemetry.provider = detectedProvider !== "unknown" ? detectedProvider : "openai";
+    const extracted = detectedProvider === "anthropic" ? extractAnthropicResponse(response) : extractOpenAIResponse(response);
+    if (input) {
+      const messages = input.messages || [];
+      const tools = input.tools;
+      let systemPrompt;
+      for (const msg of messages) {
+        if (msg.role === "system") {
+          systemPrompt = msg.content || "";
+          break;
+        }
+      }
+      if (messages.length > 0) {
+        this.promptHash = hashMessages(messages);
+        this.messages = messages;
+      }
+      if (tools) {
+        this.toolSchemaHash = hashTools(tools);
+      }
+      if (systemPrompt) {
+        this.systemPromptHash = hashContentSync(systemPrompt);
+        this.systemPrompt = systemPrompt;
+      }
+    }
+    if (this.promptHash) {
+      this.telemetry.prompt_hash = this.promptHash;
+    }
+    if (this.toolSchemaHash) {
+      this.telemetry.tool_schema_hash = this.toolSchemaHash;
+    }
+    if (this.systemPromptHash) {
+      this.telemetry.system_prompt_hash = this.systemPromptHash;
+    }
     this.telemetry.model = extracted.model;
     this.telemetry.input_tokens = extracted.inputTokens ?? void 0;
     this.telemetry.output_tokens = extracted.outputTokens ?? void 0;
@@ -418,17 +466,25 @@ var PromptTracker = class {
     this.recorded = true;
   }
   async send() {
-    if (!this.apiKey) return;
+    if (!this.apiKey) {
+      if (process.env.NODE_ENV === "development" || process.env.DEADPIPE_DEBUG === "1") {
+        console.warn("[Deadpipe] DEADPIPE_API_KEY not set. Telemetry will not be sent.");
+      }
+      return;
+    }
     try {
       const controller = new AbortController();
       const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
       const payload = {};
       for (const [key, value] of Object.entries(this.telemetry)) {
-        if (value !== void 0) {
-          payload[key] = value;
-        }
+        if (value === void 0 || value === null) continue;
+        if (typeof value === "string" && value === "") continue;
+        if (typeof value === "boolean" && value === false) continue;
+        if (Array.isArray(value) && value.length === 0) continue;
+        if (typeof value === "object" && Object.keys(value).length === 0) continue;
+        payload[key] = value;
       }
-      await fetch(`${this.baseUrl}/prompt`, {
+      fetch(`${this.baseUrl}/prompt`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -436,8 +492,10 @@ var PromptTracker = class {
         },
         body: JSON.stringify(payload),
         signal: controller.signal
+      }).catch(() => {
+      }).finally(() => {
+        clearTimeout(timeoutId);
       });
-      clearTimeout(timeoutId);
     } catch {
     }
   }
@@ -487,15 +545,10 @@ function wrapOpenAI(client, options) {
             promptId,
             async (t) => {
               const response = await client.chat.completions.create(params);
-              t.record(response);
+              t.record(response, void 0, params);
               return response;
             },
-            {
-              ...trackOptions,
-              messages,
-              tools,
-              systemPrompt
-            }
+            trackOptions
           );
         }
       }
@@ -512,23 +565,22 @@ function wrapOpenAI(client, options) {
           promptId,
           async (t) => {
             const response = await client.responses.create(params);
-            t.record(response);
+            t.record(response, void 0, params);
             return response;
           },
-          {
-            ...trackOptions,
-            messages
-          }
+          trackOptions
         );
       }
     };
   }
   return wrappedClient;
 }
+var index_default = wrapOpenAI;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PromptTracker,
   VERSION,
+  detectProvider,
   detectRefusal,
   estimateCost,
   extractAnthropicResponse,

package/dist/index.mjs

@@ -99,6 +99,25 @@ function validateNumericBounds(data, numericBounds) {
   }
   return true;
 }
+function detectProvider(response) {
+  if (!response) return "unknown";
+  if (Array.isArray(response.content) || response.stop_reason !== void 0) {
+    return "anthropic";
+  }
+  if (response.choices !== void 0 || response.output !== void 0) {
+    return "openai";
+  }
+  if (response.model) {
+    const modelLower = String(response.model).toLowerCase();
+    if (modelLower.includes("claude")) {
+      return "anthropic";
+    }
+    if (modelLower.includes("gpt") || modelLower.includes("o1")) {
+      return "openai";
+    }
+  }
+  return "unknown";
+}
 function extractOpenAIResponse(response) {
   const result = {
     model: "",
@@ -198,16 +217,15 @@ var PromptTracker = class {
   appId;
   environment;
   versionStr;
-  provider;
   // Validation
   schema;
   enumFields;
   numericBounds;
-  // Context hashes
+  // Context hashes (auto-extracted from response)
   promptHash;
   toolSchemaHash;
   systemPromptHash;
-  // Context for previews
+  // Context for previews (auto-extracted from response)
   messages;
   systemPrompt;
   // Timing
@@ -226,24 +244,19 @@ var PromptTracker = class {
     this.appId = options.appId || process.env.DEADPIPE_APP_ID;
     this.environment = options.environment || process.env.DEADPIPE_ENVIRONMENT;
     this.versionStr = options.version || process.env.DEADPIPE_VERSION || process.env.GIT_COMMIT;
-    this.provider = options.provider || "openai";
     this.schema = options.schema;
     this.enumFields = options.enumFields;
     this.numericBounds = options.numericBounds;
-    this.promptHash = options.messages ? hashMessages(options.messages) : void 0;
-    this.toolSchemaHash = hashTools(options.tools);
-    this.systemPromptHash = options.systemPrompt ? hashContentSync(options.systemPrompt) : void 0;
-    this.messages = options.messages;
-    this.systemPrompt = options.systemPrompt;
+    this.messages = void 0;
+    this.systemPrompt = void 0;
+    this.promptHash = void 0;
+    this.toolSchemaHash = void 0;
+    this.systemPromptHash = void 0;
     this.telemetry = {
       prompt_id: this.promptId,
-      provider: this.provider,
       app_id: this.appId,
       environment: this.environment,
       version: this.versionStr,
-      prompt_hash: this.promptHash,
-      tool_schema_hash: this.toolSchemaHash,
-      system_prompt_hash: this.systemPromptHash,
       status: "success"
     };
   }
@@ -262,11 +275,44 @@ var PromptTracker = class {
     this.telemetry.retry_count = this.retryCount;
   }
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  record(response, parsedOutput) {
+  record(response, parsedOutput, input) {
     this.endTime = Date.now();
     this.telemetry.end_time = new Date(this.endTime).toISOString();
     this.telemetry.total_latency = this.startTime ? this.endTime - this.startTime : 0;
-    const extracted = this.provider === "anthropic" ? extractAnthropicResponse(response) : extractOpenAIResponse(response);
+    const detectedProvider = detectProvider(response);
+    this.telemetry.provider = detectedProvider !== "unknown" ? detectedProvider : "openai";
+    const extracted = detectedProvider === "anthropic" ? extractAnthropicResponse(response) : extractOpenAIResponse(response);
+    if (input) {
+      const messages = input.messages || [];
+      const tools = input.tools;
+      let systemPrompt;
+      for (const msg of messages) {
+        if (msg.role === "system") {
+          systemPrompt = msg.content || "";
+          break;
+        }
+      }
+      if (messages.length > 0) {
+        this.promptHash = hashMessages(messages);
+        this.messages = messages;
+      }
+      if (tools) {
+        this.toolSchemaHash = hashTools(tools);
+      }
+      if (systemPrompt) {
+        this.systemPromptHash = hashContentSync(systemPrompt);
+        this.systemPrompt = systemPrompt;
+      }
+    }
+    if (this.promptHash) {
+      this.telemetry.prompt_hash = this.promptHash;
+    }
+    if (this.toolSchemaHash) {
+      this.telemetry.tool_schema_hash = this.toolSchemaHash;
+    }
+    if (this.systemPromptHash) {
+      this.telemetry.system_prompt_hash = this.systemPromptHash;
+    }
     this.telemetry.model = extracted.model;
     this.telemetry.input_tokens = extracted.inputTokens ?? void 0;
     this.telemetry.output_tokens = extracted.outputTokens ?? void 0;
@@ -385,17 +431,25 @@ var PromptTracker = class {
     this.recorded = true;
   }
   async send() {
-    if (!this.apiKey) return;
+    if (!this.apiKey) {
+      if (process.env.NODE_ENV === "development" || process.env.DEADPIPE_DEBUG === "1") {
+        console.warn("[Deadpipe] DEADPIPE_API_KEY not set. Telemetry will not be sent.");
+      }
+      return;
+    }
     try {
       const controller = new AbortController();
       const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
       const payload = {};
       for (const [key, value] of Object.entries(this.telemetry)) {
-        if (value !== void 0) {
-          payload[key] = value;
-        }
+        if (value === void 0 || value === null) continue;
+        if (typeof value === "string" && value === "") continue;
+        if (typeof value === "boolean" && value === false) continue;
+        if (Array.isArray(value) && value.length === 0) continue;
+        if (typeof value === "object" && Object.keys(value).length === 0) continue;
+        payload[key] = value;
       }
-      await fetch(`${this.baseUrl}/prompt`, {
+      fetch(`${this.baseUrl}/prompt`, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
@@ -403,8 +457,10 @@ var PromptTracker = class {
         },
         body: JSON.stringify(payload),
         signal: controller.signal
+      }).catch(() => {
+      }).finally(() => {
+        clearTimeout(timeoutId);
       });
-      clearTimeout(timeoutId);
     } catch {
     }
   }
@@ -454,15 +510,10 @@ function wrapOpenAI(client, options) {
             promptId,
             async (t) => {
               const response = await client.chat.completions.create(params);
-              t.record(response);
+              t.record(response, void 0, params);
               return response;
             },
-            {
-              ...trackOptions,
-              messages,
-              tools,
-              systemPrompt
-            }
+            trackOptions
           );
         }
       }
@@ -479,22 +530,22 @@ function wrapOpenAI(client, options) {
           promptId,
           async (t) => {
             const response = await client.responses.create(params);
-            t.record(response);
+            t.record(response, void 0, params);
             return response;
           },
-          {
-            ...trackOptions,
-            messages
-          }
+          trackOptions
         );
       }
     };
   }
   return wrappedClient;
 }
+var index_default = wrapOpenAI;
 export {
   PromptTracker,
   VERSION,
+  index_default as default,
+  detectProvider,
   detectRefusal,
   estimateCost,
   extractAnthropicResponse,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deadpipe",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "LLM observability that answers: Is this prompt behaving the same as when it was last safe?",
   "keywords": [
     "llm",