deadpipe 2.0.1 → 3.0.0

package/dist/index.js

@@ -22,23 +22,34 @@ var index_exports = {};
 __export(index_exports, {
   PromptTracker: () => PromptTracker,
   VERSION: () => VERSION,
+  default: () => index_default,
+  detectClientProvider: () => detectClientProvider,
+  detectProvider: () => detectProvider,
   detectRefusal: () => detectRefusal,
   estimateCost: () => estimateCost,
   extractAnthropicResponse: () => extractAnthropicResponse,
+  extractCohereResponse: () => extractCohereResponse,
+  extractGoogleAIResponse: () => extractGoogleAIResponse,
+  extractMistralResponse: () => extractMistralResponse,
   extractOpenAIResponse: () => extractOpenAIResponse,
+  extractResponse: () => extractResponse,
   track: () => track,
   validateEnumBounds: () => validateEnumBounds,
   validateNumericBounds: () => validateNumericBounds,
+  wrap: () => wrap,
+  wrapAnthropic: () => wrapAnthropic,
+  wrapClient: () => wrap,
+  wrapCohere: () => wrapCohere,
+  wrapGoogleAI: () => wrapGoogleAI,
+  wrapMistral: () => wrapMistral,
   wrapOpenAI: () => wrapOpenAI
 });
 module.exports = __toCommonJS(index_exports);
-var VERSION = "2.0.0";
+var VERSION = "3.0.0";
 var MODEL_COSTS = {
   // OpenAI
   "gpt-4": { input: 0.03, output: 0.06 },
-  // legacy
   "gpt-4-turbo": { input: 0.01, output: 0.03 },
-  // legacy
   "gpt-4o": { input: 5e-3, output: 0.015 },
   "gpt-4o-mini": { input: 15e-5, output: 6e-4 },
   "gpt-4.1": { input: 2e-3, output: 8e-3 },
@@ -46,14 +57,37 @@ var MODEL_COSTS = {
   "gpt-5": { input: 175e-5, output: 0.014 },
   "gpt-5-mini": { input: 25e-5, output: 2e-3 },
   "gpt-5.2-pro": { input: 0.021, output: 0.168 },
+  "o1": { input: 0.015, output: 0.06 },
+  "o1-mini": { input: 3e-3, output: 0.012 },
+  "o1-pro": { input: 0.15, output: 0.6 },
   // Anthropic
   "claude-3-opus": { input: 0.015, output: 0.075 },
   "claude-3-sonnet": { input: 3e-3, output: 0.015 },
   "claude-3-haiku": { input: 25e-5, output: 125e-5 },
   "claude-3.5-sonnet": { input: 3e-3, output: 0.015 },
+  "claude-3.5-haiku": { input: 8e-4, output: 4e-3 },
   "claude-opus-4": { input: 0.015, output: 0.075 },
   "claude-sonnet-4": { input: 3e-3, output: 0.015 },
-  "claude-haiku-4": { input: 25e-5, output: 125e-5 }
+  "claude-haiku-4": { input: 25e-5, output: 125e-5 },
+  // Google AI / Gemini
+  "gemini-1.5-pro": { input: 125e-5, output: 5e-3 },
+  "gemini-1.5-flash": { input: 75e-6, output: 3e-4 },
+  "gemini-2.0-flash": { input: 1e-4, output: 4e-4 },
+  "gemini-2.0-pro": { input: 125e-5, output: 5e-3 },
+  "gemini-pro": { input: 5e-4, output: 15e-4 },
+  // Mistral
+  "mistral-large": { input: 4e-3, output: 0.012 },
+  "mistral-medium": { input: 27e-4, output: 81e-4 },
+  "mistral-small": { input: 1e-3, output: 3e-3 },
+  "mistral-nemo": { input: 3e-4, output: 3e-4 },
+  "codestral": { input: 1e-3, output: 3e-3 },
+  "pixtral": { input: 2e-3, output: 6e-3 },
+  "ministral": { input: 1e-4, output: 1e-4 },
+  // Cohere
+  "command-r-plus": { input: 3e-3, output: 0.015 },
+  "command-r": { input: 5e-4, output: 15e-4 },
+  "command": { input: 1e-3, output: 2e-3 },
+  "command-light": { input: 3e-4, output: 6e-4 }
 };
 function estimateCost(model, inputTokens, outputTokens) {
   const modelLower = model.toLowerCase();
@@ -132,6 +166,59 @@ 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.candidates !== void 0 || response.promptFeedback !== void 0) {
+    return "google";
+  }
+  if (response.text !== void 0 && response.generation_id !== void 0 || response.generations !== void 0) {
+    return "cohere";
+  }
+  if (response.choices !== void 0 || response.output !== void 0) {
+    const model = String(response.model || "").toLowerCase();
+    if (model.includes("mistral") || model.includes("codestral") || model.includes("pixtral") || model.includes("ministral")) {
+      return "mistral";
+    }
+    return "openai";
+  }
+  if (response.model) {
+    const modelLower = String(response.model).toLowerCase();
+    if (modelLower.includes("claude")) return "anthropic";
+    if (modelLower.includes("gemini")) return "google";
+    if (modelLower.includes("mistral") || modelLower.includes("codestral")) return "mistral";
+    if (modelLower.includes("command")) return "cohere";
+    if (modelLower.includes("gpt") || modelLower.includes("o1")) return "openai";
+  }
+  return "unknown";
+}
+function detectClientProvider(client) {
+  if (!client) return "unknown";
+  if (client.chat?.completions || client.responses) {
+    if (client._client?.baseURL?.includes("mistral") || client.baseURL?.includes("mistral")) {
+      return "mistral";
+    }
+    return "openai";
+  }
+  if (client.messages?.create) {
+    return "anthropic";
+  }
+  if (client.getGenerativeModel) {
+    return "google";
+  }
+  if (client.chat?.complete || client.chat) {
+    return "mistral";
+  }
+  if (client.chat && typeof client.chat === "function") {
+    return "cohere";
+  }
+  if (client.generate) {
+    return "cohere";
+  }
+  return "unknown";
+}
 function extractOpenAIResponse(response) {
   const result = {
     model: "",
@@ -211,6 +298,110 @@ function extractAnthropicResponse(response) {
   }
   return result;
 }
+function extractGoogleAIResponse(response) {
+  const result = {
+    model: "",
+    content: "",
+    inputTokens: null,
+    outputTokens: null,
+    totalTokens: null,
+    finishReason: null,
+    toolCalls: [],
+    logprobs: null
+  };
+  if (response?.modelVersion) {
+    result.model = response.modelVersion;
+  }
+  if (response?.candidates?.[0]) {
+    const candidate = response.candidates[0];
+    if (candidate.content?.parts) {
+      const textParts = candidate.content.parts.filter((part) => part.text !== void 0).map((part) => part.text);
+      result.content = textParts.join("");
+      const functionCalls = candidate.content.parts.filter((part) => part.functionCall).map((part) => ({
+        name: part.functionCall.name,
+        arguments: JSON.stringify(part.functionCall.args)
+      }));
+      result.toolCalls = functionCalls;
+    }
+    if (candidate.finishReason) {
+      result.finishReason = candidate.finishReason;
+    }
+  }
+  if (response?.usageMetadata) {
+    result.inputTokens = response.usageMetadata.promptTokenCount ?? null;
+    result.outputTokens = response.usageMetadata.candidatesTokenCount ?? null;
+    result.totalTokens = response.usageMetadata.totalTokenCount ?? null;
+  }
+  return result;
+}
+function extractMistralResponse(response) {
+  const result = extractOpenAIResponse(response);
+  if (response?.model) {
+    result.model = response.model;
+  }
+  return result;
+}
+function extractCohereResponse(response) {
+  const result = {
+    model: "",
+    content: "",
+    inputTokens: null,
+    outputTokens: null,
+    totalTokens: null,
+    finishReason: null,
+    toolCalls: [],
+    logprobs: null
+  };
+  if (response?.text !== void 0) {
+    result.content = response.text || "";
+  }
+  if (response?.generations?.[0]) {
+    result.content = response.generations[0].text || "";
+  }
+  if (response?.model) {
+    result.model = response.model;
+  }
+  if (response?.finish_reason) {
+    result.finishReason = response.finish_reason;
+  }
+  if (response?.tool_calls && Array.isArray(response.tool_calls)) {
+    result.toolCalls = response.tool_calls.map((tc) => ({
+      name: tc.name,
+      arguments: JSON.stringify(tc.parameters)
+    }));
+  }
+  if (response?.meta?.tokens) {
+    result.inputTokens = response.meta.tokens.input_tokens ?? null;
+    result.outputTokens = response.meta.tokens.output_tokens ?? null;
+    if (result.inputTokens !== null && result.outputTokens !== null) {
+      result.totalTokens = result.inputTokens + result.outputTokens;
+    }
+  }
+  if (response?.meta?.billed_units) {
+    result.inputTokens = response.meta.billed_units.input_tokens ?? null;
+    result.outputTokens = response.meta.billed_units.output_tokens ?? null;
+    if (result.inputTokens !== null && result.outputTokens !== null) {
+      result.totalTokens = result.inputTokens + result.outputTokens;
+    }
+  }
+  return result;
+}
+function extractResponse(response, provider) {
+  const detectedProvider = provider || detectProvider(response);
+  switch (detectedProvider) {
+    case "anthropic":
+      return extractAnthropicResponse(response);
+    case "google":
+      return extractGoogleAIResponse(response);
+    case "mistral":
+      return extractMistralResponse(response);
+    case "cohere":
+      return extractCohereResponse(response);
+    case "openai":
+    default:
+      return extractOpenAIResponse(response);
+  }
+}
 function calculateLogprobMean(logprobs) {
   if (!logprobs?.content) return null;
   try {
@@ -231,16 +422,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 +449,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 +480,49 @@ 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 = extractResponse(response, detectedProvider);
+    if (input) {
+      const messages = input.messages || [];
+      const tools = input.tools;
+      let systemPrompt;
+      if (input.system) {
+        systemPrompt = typeof input.system === "string" ? input.system : JSON.stringify(input.system);
+      }
+      if (!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;
@@ -308,7 +531,7 @@ var PromptTracker = class {
     const content = extracted.content;
     this.telemetry.output_length = content?.length ?? 0;
     this.telemetry.empty_output = !content || content.trim().length === 0;
-    this.telemetry.truncated = extracted.finishReason === "length";
+    this.telemetry.truncated = extracted.finishReason === "length" || extracted.finishReason === "MAX_TOKENS";
     const MAX_PREVIEW_LENGTH = 2e3;
     if (content) {
       this.telemetry.output_preview = content.length > MAX_PREVIEW_LENGTH ? content.substring(0, MAX_PREVIEW_LENGTH) + "..." : content;
@@ -418,17 +641,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 +667,10 @@ var PromptTracker = class {
         },
         body: JSON.stringify(payload),
         signal: controller.signal
+      }).catch(() => {
+      }).finally(() => {
+        clearTimeout(timeoutId);
       });
-      clearTimeout(timeoutId);
     } catch {
     }
   }
@@ -474,28 +707,14 @@ function wrapOpenAI(client, options) {
         ...client.chat.completions,
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         create: async (params) => {
-          const messages = params.messages || [];
-          const tools = params.tools;
-          let systemPrompt;
-          for (const msg of messages) {
-            if (msg.role === "system") {
-              systemPrompt = msg.content || "";
-              break;
-            }
-          }
           return track(
             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
           );
         }
       }
@@ -506,35 +725,224 @@ function wrapOpenAI(client, options) {
       ...client.responses,
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       create: async (params) => {
-        const inputContent = params.input || "";
-        const messages = typeof inputContent === "string" ? [{ role: "user", content: inputContent }] : inputContent;
         return track(
           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;
+}
+function wrapAnthropic(client, options) {
+  const { promptId, ...trackOptions } = options;
+  const wrappedClient = Object.create(client);
+  if (client.messages) {
+    wrappedClient.messages = {
+      ...client.messages,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      create: async (params) => {
+        return track(
+          promptId,
+          async (t) => {
+            const response = await client.messages.create(params);
+            t.record(response, void 0, params);
+            return response;
+          },
+          trackOptions
+        );
+      }
+    };
+  }
+  return wrappedClient;
+}
+function wrapGoogleAI(client, options) {
+  const { promptId, ...trackOptions } = options;
+  return {
+    ...client,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    getGenerativeModel: (modelParams) => {
+      const model = client.getGenerativeModel(modelParams);
+      return {
+        ...model,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        generateContent: async (params) => {
+          return track(
+            promptId,
+            async (t) => {
+              const response = await model.generateContent(params);
+              const input = {
+                messages: Array.isArray(params) ? params.map((p) => ({
+                  role: "user",
+                  content: typeof p === "string" ? p : p.text || ""
+                })) : [{ role: "user", content: typeof params === "string" ? params : params.contents?.[0]?.parts?.[0]?.text || "" }]
+              };
+              t.record(response.response || response, void 0, input);
+              return response;
+            },
+            trackOptions
+          );
+        },
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        startChat: (chatParams) => {
+          const chat = model.startChat(chatParams);
+          return {
+            ...chat,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            sendMessage: async (message) => {
+              return track(
+                promptId,
+                async (t) => {
+                  const response = await chat.sendMessage(message);
+                  const input = {
+                    messages: [{ role: "user", content: typeof message === "string" ? message : JSON.stringify(message) }]
+                  };
+                  t.record(response.response || response, void 0, input);
+                  return response;
+                },
+                trackOptions
+              );
+            }
+          };
+        }
+      };
+    }
+  };
+}
+function wrapMistral(client, options) {
+  const { promptId, ...trackOptions } = options;
+  const wrappedClient = Object.create(client);
+  if (client.chat?.complete) {
+    wrappedClient.chat = {
+      ...client.chat,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      complete: async (params) => {
+        return track(
+          promptId,
+          async (t) => {
+            const response = await client.chat.complete(params);
+            t.record(response, void 0, params);
+            return response;
+          },
+          trackOptions
         );
       }
     };
   }
+  if (client.chat?.completions) {
+    wrappedClient.chat = {
+      ...client.chat,
+      completions: {
+        ...client.chat.completions,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        create: async (params) => {
+          return track(
+            promptId,
+            async (t) => {
+              const response = await client.chat.completions.create(params);
+              t.record(response, void 0, params);
+              return response;
+            },
+            trackOptions
+          );
+        }
+      }
+    };
+  }
+  return wrappedClient;
+}
+function wrapCohere(client, options) {
+  const { promptId, ...trackOptions } = options;
+  const wrappedClient = Object.create(client);
+  if (typeof client.chat === "function") {
+    wrappedClient.chat = async (params) => {
+      return track(
+        promptId,
+        async (t) => {
+          const response = await client.chat(params);
+          const input = {
+            messages: params.chat_history || []
+          };
+          if (params.message) {
+            input.messages.push({ role: "user", content: params.message });
+          }
+          t.record(response, void 0, input);
+          return response;
+        },
+        trackOptions
+      );
+    };
+  }
+  if (typeof client.generate === "function") {
+    wrappedClient.generate = async (params) => {
+      return track(
+        promptId,
+        async (t) => {
+          const response = await client.generate(params);
+          const input = {
+            messages: [{ role: "user", content: params.prompt || "" }]
+          };
+          t.record(response, void 0, input);
+          return response;
+        },
+        trackOptions
+      );
+    };
+  }
   return wrappedClient;
 }
+function wrap(client, options) {
+  const provider = detectClientProvider(client);
+  switch (provider) {
+    case "openai":
+      return wrapOpenAI(client, options);
+    case "anthropic":
+      return wrapAnthropic(client, options);
+    case "google":
+      return wrapGoogleAI(client, options);
+    case "mistral":
+      return wrapMistral(client, options);
+    case "cohere":
+      return wrapCohere(client, options);
+    default:
+      if (client.chat?.completions) {
+        return wrapOpenAI(client, options);
+      }
+      if (client.messages) {
+        return wrapAnthropic(client, options);
+      }
+      console.warn("[Deadpipe] Could not detect provider. Returning unwrapped client.");
+      return client;
+  }
+}
+var index_default = wrap;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PromptTracker,
   VERSION,
+  detectClientProvider,
+  detectProvider,
   detectRefusal,
   estimateCost,
   extractAnthropicResponse,
+  extractCohereResponse,
+  extractGoogleAIResponse,
+  extractMistralResponse,
   extractOpenAIResponse,
+  extractResponse,
   track,
   validateEnumBounds,
   validateNumericBounds,
+  wrap,
+  wrapAnthropic,
+  wrapClient,
+  wrapCohere,
+  wrapGoogleAI,
+  wrapMistral,
   wrapOpenAI
 });