@posthog/ai 6.5.1 → 7.0.0

package/dist/openai/index.cjs

@@ -6,7 +6,7 @@ var openai = require('openai');
 var buffer = require('buffer');
 var uuid = require('uuid');
 
-var version = "6.5.1";
+var version = "7.0.0";
 
 // Type guards for safer type checking
 
@@ -151,6 +151,110 @@ 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 or choices[].delta (OpenAI/Perplexity)
+  if ('choices' in result && Array.isArray(result.choices)) {
+    for (const choice of result.choices) {
+      if (typeof choice === 'object' && choice !== null) {
+        // Check both message (non-streaming) and delta (streaming) for annotations
+        const content = ('message' in choice ? choice.message : null) || ('delta' in choice ? choice.delta : null);
+        if (typeof content === 'object' && content !== null && 'annotations' in content) {
+          const annotations = content.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.
@@ -269,6 +373,9 @@ const sendEventToPosthog = async ({
     } : {}),
     ...(usage.cacheCreationInputTokens ? {
       $ai_cache_creation_input_tokens: usage.cacheCreationInputTokens
+    } : {}),
+    ...(usage.webSearchCount ? {
+      $ai_web_search_count: usage.webSearchCount
     } : {})
   };
   const properties = {
@@ -510,13 +617,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;
@@ -558,6 +670,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,
@@ -612,7 +725,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) {
@@ -648,13 +767,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,
@@ -663,7 +783,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
           });
@@ -725,14 +846,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,
@@ -754,7 +883,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) {
@@ -789,6 +924,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,
@@ -796,9 +934,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,
@@ -807,7 +943,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
           });
@@ -845,9 +982,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 => {
@@ -896,7 +1033,7 @@ class WrappedResponses extends Responses {
       return wrappedPromise;
     } finally {
       // Restore our wrapped create method
-      originalSelf.create = tempCreate;
+      originalSelfRecord['create'] = tempCreate;
     }
   }
 }