@posthog/ai 6.5.0 → 6.6.0

package/dist/openai/index.mjs

@@ -2,7 +2,7 @@ import { OpenAI } from 'openai';
 import { Buffer } from 'buffer';
 import { v4 } from 'uuid';
 
-var version = "6.5.0";
+var version = "6.6.0";
 
 // Type guards for safer type checking
 
@@ -147,6 +147,109 @@ const withPrivacyMode = (client, privacyMode, input) => {
   return client.privacy_mode || privacyMode ? null : input;
 };
 
+/**
+ * Calculate web search count from raw API response.
+ *
+ * Uses a two-tier detection strategy:
+ * Priority 1 (Exact Count): Count actual web search calls when available
+ * Priority 2 (Binary Detection): Return 1 if web search indicators are present, 0 otherwise
+ *
+ * @param result - Raw API response from any provider (OpenAI, Perplexity, OpenRouter, Gemini, etc.)
+ * @returns Number of web searches performed (exact count or binary 1/0)
+ */
+function calculateWebSearchCount(result) {
+  if (!result || typeof result !== 'object') {
+    return 0;
+  }
+
+  // Priority 1: Exact Count
+  // Check for OpenAI Responses API web_search_call items
+  if ('output' in result && Array.isArray(result.output)) {
+    let count = 0;
+    for (const item of result.output) {
+      if (typeof item === 'object' && item !== null && 'type' in item && item.type === 'web_search_call') {
+        count++;
+      }
+    }
+    if (count > 0) {
+      return count;
+    }
+  }
+
+  // Priority 2: Binary Detection (1 or 0)
+
+  // Check for citations at root level (Perplexity)
+  if ('citations' in result && Array.isArray(result.citations) && result.citations.length > 0) {
+    return 1;
+  }
+
+  // Check for search_results at root level (Perplexity via OpenRouter)
+  if ('search_results' in result && Array.isArray(result.search_results) && result.search_results.length > 0) {
+    return 1;
+  }
+
+  // Check for usage.search_context_size (Perplexity via OpenRouter)
+  if ('usage' in result && typeof result.usage === 'object' && result.usage !== null) {
+    if ('search_context_size' in result.usage && result.usage.search_context_size) {
+      return 1;
+    }
+  }
+
+  // Check for annotations with url_citation in choices[].message (OpenAI/Perplexity)
+  if ('choices' in result && Array.isArray(result.choices)) {
+    for (const choice of result.choices) {
+      if (typeof choice === 'object' && choice !== null && 'message' in choice) {
+        const message = choice.message;
+        if (typeof message === 'object' && message !== null && 'annotations' in message) {
+          const annotations = message.annotations;
+          if (Array.isArray(annotations)) {
+            const hasUrlCitation = annotations.some(ann => {
+              return typeof ann === 'object' && ann !== null && 'type' in ann && ann.type === 'url_citation';
+            });
+            if (hasUrlCitation) {
+              return 1;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Check for annotations in output[].content[] (OpenAI Responses API)
+  if ('output' in result && Array.isArray(result.output)) {
+    for (const item of result.output) {
+      if (typeof item === 'object' && item !== null && 'content' in item) {
+        const content = item.content;
+        if (Array.isArray(content)) {
+          for (const contentItem of content) {
+            if (typeof contentItem === 'object' && contentItem !== null && 'annotations' in contentItem) {
+              const annotations = contentItem.annotations;
+              if (Array.isArray(annotations)) {
+                const hasUrlCitation = annotations.some(ann => {
+                  return typeof ann === 'object' && ann !== null && 'type' in ann && ann.type === 'url_citation';
+                });
+                if (hasUrlCitation) {
+                  return 1;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Check for grounding_metadata (Gemini)
+  if ('candidates' in result && Array.isArray(result.candidates)) {
+    for (const candidate of result.candidates) {
+      if (typeof candidate === 'object' && candidate !== null && 'grounding_metadata' in candidate && candidate.grounding_metadata) {
+        return 1;
+      }
+    }
+  }
+  return 0;
+}
+
 /**
  * Extract available tool calls from the request parameters.
  * These are the tools provided to the LLM, not the tool calls in the response.
@@ -265,6 +368,9 @@ const sendEventToPosthog = async ({
     } : {}),
     ...(usage.cacheCreationInputTokens ? {
       $ai_cache_creation_input_tokens: usage.cacheCreationInputTokens
+    } : {}),
+    ...(usage.webSearchCount ? {
+      $ai_web_search_count: usage.webSearchCount
     } : {})
   };
   const properties = {
@@ -506,13 +612,18 @@ class WrappedCompletions extends Completions {
               let accumulatedContent = '';
               let usage = {
                 inputTokens: 0,
-                outputTokens: 0
+                outputTokens: 0,
+                webSearchCount: 0
               };
 
               // Map to track in-progress tool calls
               const toolCallsInProgress = new Map();
               for await (const chunk of stream1) {
                 const choice = chunk?.choices?.[0];
+                const chunkWebSearchCount = calculateWebSearchCount(chunk);
+                if (chunkWebSearchCount > 0 && chunkWebSearchCount > (usage.webSearchCount ?? 0)) {
+                  usage.webSearchCount = chunkWebSearchCount;
+                }
 
                 // Handle text content
                 const deltaContent = choice?.delta?.content;
@@ -554,6 +665,7 @@ class WrappedCompletions extends Completions {
                 // Handle usage information
                 if (chunk.usage) {
                   usage = {
+                    ...usage,
                     inputTokens: chunk.usage.prompt_tokens ?? 0,
                     outputTokens: chunk.usage.completion_tokens ?? 0,
                     reasoningTokens: chunk.usage.completion_tokens_details?.reasoning_tokens ?? 0,
@@ -608,7 +720,13 @@ class WrappedCompletions extends Completions {
                 baseURL: this.baseURL,
                 params: body,
                 httpStatus: 200,
-                usage,
+                usage: {
+                  inputTokens: usage.inputTokens,
+                  outputTokens: usage.outputTokens,
+                  reasoningTokens: usage.reasoningTokens,
+                  cacheReadInputTokens: usage.cacheReadInputTokens,
+                  webSearchCount: usage.webSearchCount
+                },
                 tools: availableTools
               });
             } catch (error) {
@@ -644,13 +762,14 @@ class WrappedCompletions extends Completions {
         if ('choices' in result) {
           const latency = (Date.now() - startTime) / 1000;
           const availableTools = extractAvailableToolCalls('openai', openAIParams);
+          const formattedOutput = formatResponseOpenAI(result);
           await sendEventToPosthog({
             client: this.phClient,
             ...posthogParams,
             model: openAIParams.model,
             provider: 'openai',
             input: sanitizeOpenAI(openAIParams.messages),
-            output: formatResponseOpenAI(result),
+            output: formattedOutput,
             latency,
             baseURL: this.baseURL,
             params: body,
@@ -659,7 +778,8 @@ class WrappedCompletions extends Completions {
               inputTokens: result.usage?.prompt_tokens ?? 0,
               outputTokens: result.usage?.completion_tokens ?? 0,
               reasoningTokens: result.usage?.completion_tokens_details?.reasoning_tokens ?? 0,
-              cacheReadInputTokens: result.usage?.prompt_tokens_details?.cached_tokens ?? 0
+              cacheReadInputTokens: result.usage?.prompt_tokens_details?.cached_tokens ?? 0,
+              webSearchCount: calculateWebSearchCount(result)
             },
             tools: availableTools
           });
@@ -721,14 +841,22 @@ class WrappedResponses extends Responses {
               let finalContent = [];
               let usage = {
                 inputTokens: 0,
-                outputTokens: 0
+                outputTokens: 0,
+                webSearchCount: 0
               };
               for await (const chunk of stream1) {
+                if ('response' in chunk && chunk.response) {
+                  const chunkWebSearchCount = calculateWebSearchCount(chunk.response);
+                  if (chunkWebSearchCount > 0 && chunkWebSearchCount > (usage.webSearchCount ?? 0)) {
+                    usage.webSearchCount = chunkWebSearchCount;
+                  }
+                }
                 if (chunk.type === 'response.completed' && 'response' in chunk && chunk.response?.output && chunk.response.output.length > 0) {
                   finalContent = chunk.response.output;
                 }
                 if ('response' in chunk && chunk.response?.usage) {
                   usage = {
+                    ...usage,
                     inputTokens: chunk.response.usage.input_tokens ?? 0,
                     outputTokens: chunk.response.usage.output_tokens ?? 0,
                     reasoningTokens: chunk.response.usage.output_tokens_details?.reasoning_tokens ?? 0,
@@ -750,7 +878,13 @@ class WrappedResponses extends Responses {
                 baseURL: this.baseURL,
                 params: body,
                 httpStatus: 200,
-                usage,
+                usage: {
+                  inputTokens: usage.inputTokens,
+                  outputTokens: usage.outputTokens,
+                  reasoningTokens: usage.reasoningTokens,
+                  cacheReadInputTokens: usage.cacheReadInputTokens,
+                  webSearchCount: usage.webSearchCount
+                },
                 tools: availableTools
               });
             } catch (error) {
@@ -785,6 +919,9 @@ class WrappedResponses extends Responses {
         if ('output' in result) {
           const latency = (Date.now() - startTime) / 1000;
           const availableTools = extractAvailableToolCalls('openai', openAIParams);
+          const formattedOutput = formatResponseOpenAI({
+            output: result.output
+          });
           await sendEventToPosthog({
             client: this.phClient,
             ...posthogParams,
@@ -792,9 +929,7 @@ class WrappedResponses extends Responses {
             model: openAIParams.model,
             provider: 'openai',
             input: formatOpenAIResponsesInput(openAIParams.input, openAIParams.instructions),
-            output: formatResponseOpenAI({
-              output: result.output
-            }),
+            output: formattedOutput,
             latency,
             baseURL: this.baseURL,
             params: body,
@@ -803,7 +938,8 @@ class WrappedResponses extends Responses {
               inputTokens: result.usage?.input_tokens ?? 0,
               outputTokens: result.usage?.output_tokens ?? 0,
               reasoningTokens: result.usage?.output_tokens_details?.reasoning_tokens ?? 0,
-              cacheReadInputTokens: result.usage?.input_tokens_details?.cached_tokens ?? 0
+              cacheReadInputTokens: result.usage?.input_tokens_details?.cached_tokens ?? 0,
+              webSearchCount: calculateWebSearchCount(result)
             },
             tools: availableTools
           });
@@ -841,9 +977,9 @@ class WrappedResponses extends Responses {
     } = extractPosthogParams(body);
     const startTime = Date.now();
     const originalCreate = super.create.bind(this);
-    const originalSelf = this;
-    const tempCreate = originalSelf.create;
-    originalSelf.create = originalCreate;
+    const originalSelfRecord = this;
+    const tempCreate = originalSelfRecord['create'];
+    originalSelfRecord['create'] = originalCreate;
     try {
       const parentPromise = super.parse(openAIParams, options);
       const wrappedPromise = parentPromise.then(async result => {
@@ -892,7 +1028,7 @@ class WrappedResponses extends Responses {
       return wrappedPromise;
     } finally {
       // Restore our wrapped create method
-      originalSelf.create = tempCreate;
+      originalSelfRecord['create'] = tempCreate;
     }
   }
 }