deadpipe 2.0.2 → 3.0.1

package/dist/index.mjs

@@ -1,11 +1,9 @@
 // src/index.ts
-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 },
@@ -13,14 +11,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();
@@ -101,20 +122,54 @@ function validateNumericBounds(data, numericBounds) {
 }
 function detectProvider(response) {
   if (!response) return "unknown";
-  if (Array.isArray(response.content) || response.stop_reason !== void 0) {
+  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("gpt") || modelLower.includes("o1")) {
-      return "openai";
+    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";
 }
@@ -197,6 +252,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 {
@@ -281,15 +440,20 @@ var PromptTracker = class {
     this.telemetry.total_latency = this.startTime ? this.endTime - this.startTime : 0;
     const detectedProvider = detectProvider(response);
     this.telemetry.provider = detectedProvider !== "unknown" ? detectedProvider : "openai";
-    const extracted = detectedProvider === "anthropic" ? extractAnthropicResponse(response) : extractOpenAIResponse(response);
+    const extracted = extractResponse(response, detectedProvider);
     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 (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) {
@@ -321,7 +485,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;
@@ -497,15 +661,6 @@ 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) => {
@@ -524,8 +679,6 @@ 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) => {
@@ -540,18 +693,210 @@ function wrapOpenAI(client, options) {
   }
   return wrappedClient;
 }
-var index_default = wrapOpenAI;
+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;
 export {
   PromptTracker,
   VERSION,
   index_default as default,
+  detectClientProvider,
   detectProvider,
   detectRefusal,
   estimateCost,
   extractAnthropicResponse,
+  extractCohereResponse,
+  extractGoogleAIResponse,
+  extractMistralResponse,
   extractOpenAIResponse,
+  extractResponse,
   track,
   validateEnumBounds,
   validateNumericBounds,
+  wrap,
+  wrapAnthropic,
+  wrap as wrapClient,
+  wrapCohere,
+  wrapGoogleAI,
+  wrapMistral,
   wrapOpenAI
 };

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "deadpipe",
-  "version": "2.0.2",
-  "description": "LLM observability that answers: Is this prompt behaving the same as when it was last safe?",
+  "version": "3.0.1",
+  "description": "LLM observability that answers: Is this prompt still behaving safely?",
   "keywords": [
     "llm",
     "openai",
     "anthropic",
+    "google-ai",
+    "gemini",
+    "mistral",
+    "cohere",
     "gpt",
     "claude",
     "observability",