@posthog/ai 6.5.0 → 6.6.0

package/dist/index.cjs

@@ -26,7 +26,7 @@ function _interopNamespaceDefault(e) {
 
 var uuid__namespace = /*#__PURE__*/_interopNamespaceDefault(uuid);
 
-var version = "6.5.0";
+var version = "6.6.0";
 
 // Type guards for safer type checking
 const isString = value => {
@@ -297,6 +297,100 @@ const truncate = input => {
   }
   return `${truncatedStr}... [truncated]`;
 };
+/**
+ * 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.
@@ -431,6 +525,9 @@ const sendEventToPosthog = async ({
     } : {}),
     ...(usage.cacheCreationInputTokens ? {
       $ai_cache_creation_input_tokens: usage.cacheCreationInputTokens
+    } : {}),
+    ...(usage.webSearchCount ? {
+      $ai_web_search_count: usage.webSearchCount
     } : {})
   };
   const properties = {
@@ -741,12 +838,17 @@ let WrappedCompletions$1 = 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;
                 if (deltaContent) {
@@ -785,6 +887,7 @@ let WrappedCompletions$1 = 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,
@@ -836,7 +939,13 @@ let WrappedCompletions$1 = 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) {
@@ -871,13 +980,14 @@ let WrappedCompletions$1 = 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,
@@ -886,7 +996,8 @@ let WrappedCompletions$1 = 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
           });
@@ -941,14 +1052,22 @@ let WrappedResponses$1 = 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,
@@ -970,7 +1089,13 @@ let WrappedResponses$1 = 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) {
@@ -1005,6 +1130,9 @@ let WrappedResponses$1 = 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,
@@ -1012,9 +1140,7 @@ let WrappedResponses$1 = 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,
@@ -1023,7 +1149,8 @@ let WrappedResponses$1 = 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
           });
@@ -1061,9 +1188,9 @@ let WrappedResponses$1 = 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 => {
@@ -1112,7 +1239,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
       return wrappedPromise;
     } finally {
       // Restore our wrapped create method
-      originalSelf.create = tempCreate;
+      originalSelfRecord['create'] = tempCreate;
     }
   }
 };
@@ -1858,11 +1985,29 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
             cacheCreationInputTokens: providerMetadata.anthropic.cacheCreationInputTokens
           } : {})
         };
+        // Calculate web search count based on provider
+        let webSearchCount = 0;
+        if (providerMetadata?.anthropic && typeof providerMetadata.anthropic === 'object' && 'server_tool_use' in providerMetadata.anthropic) {
+          // Anthropic-specific extraction
+          const serverToolUse = providerMetadata.anthropic.server_tool_use;
+          if (serverToolUse && typeof serverToolUse === 'object' && 'web_search_requests' in serverToolUse && typeof serverToolUse.web_search_requests === 'number') {
+            webSearchCount = serverToolUse.web_search_requests;
+          }
+        } else {
+          // For other providers through Vercel, pass available metadata to helper
+          // Note: Vercel abstracts provider responses, so we may not have access to
+          // raw citations/annotations unless Vercel exposes them in usage/metadata
+          webSearchCount = calculateWebSearchCount({
+            usage: result.usage,
+            providerMetadata: providerMetadata
+          });
+        }
         const usage = {
           inputTokens: result.usage.inputTokens,
           outputTokens: result.usage.outputTokens,
           reasoningTokens: result.usage.reasoningTokens,
           cacheReadInputTokens: result.usage.cachedInputTokens,
+          webSearchCount,
           ...additionalTokenValues
         };
         await sendEventToPosthog({
@@ -1916,6 +2061,7 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
       let generatedText = '';
       let reasoningText = '';
       let usage = {};
+      let providerMetadata = undefined;
       const mergedParams = {
         ...options,
         ...mapVercelParams(params),
@@ -1973,12 +2119,10 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
               });
             }
             if (chunk.type === 'finish') {
-              const providerMetadata = chunk.providerMetadata;
-              const additionalTokenValues = {
-                ...(providerMetadata?.anthropic ? {
-                  cacheCreationInputTokens: providerMetadata.anthropic.cacheCreationInputTokens
-                } : {})
-              };
+              providerMetadata = chunk.providerMetadata;
+              const additionalTokenValues = providerMetadata && typeof providerMetadata === 'object' && 'anthropic' in providerMetadata && providerMetadata.anthropic && typeof providerMetadata.anthropic === 'object' && 'cacheCreationInputTokens' in providerMetadata.anthropic ? {
+                cacheCreationInputTokens: providerMetadata.anthropic.cacheCreationInputTokens
+              } : {};
               usage = {
                 inputTokens: chunk.usage?.inputTokens,
                 outputTokens: chunk.usage?.outputTokens,
@@ -2023,6 +2167,28 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
               role: 'assistant',
               content: content.length === 1 && content[0].type === 'text' ? content[0].text : content
             }] : [];
+            // Calculate web search count based on provider
+            let webSearchCount = 0;
+            if (providerMetadata && typeof providerMetadata === 'object' && 'anthropic' in providerMetadata && providerMetadata.anthropic && typeof providerMetadata.anthropic === 'object' && 'server_tool_use' in providerMetadata.anthropic) {
+              // Anthropic-specific extraction
+              const serverToolUse = providerMetadata.anthropic.server_tool_use;
+              if (serverToolUse && typeof serverToolUse === 'object' && 'web_search_requests' in serverToolUse && typeof serverToolUse.web_search_requests === 'number') {
+                webSearchCount = serverToolUse.web_search_requests;
+              }
+            } else {
+              // For other providers through Vercel, pass available metadata to helper
+              // Note: Vercel abstracts provider responses, so we may not have access to
+              // raw citations/annotations unless Vercel exposes them in usage/metadata
+              webSearchCount = calculateWebSearchCount({
+                usage: usage,
+                providerMetadata: providerMetadata
+              });
+            }
+            // Update usage with web search count
+            const finalUsage = {
+              ...usage,
+              webSearchCount
+            };
             await sendEventToPosthog({
               client: phClient,
               distinctId: options.posthogDistinctId,
@@ -2035,7 +2201,7 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
               baseURL,
               params: mergedParams,
               httpStatus: 200,
-              usage,
+              usage: finalUsage,
               tools: availableTools,
               captureImmediate: options.posthogCaptureImmediate
             });
@@ -2121,7 +2287,8 @@ class WrappedMessages extends AnthropicOriginal.Messages {
           inputTokens: 0,
           outputTokens: 0,
           cacheCreationInputTokens: 0,
-          cacheReadInputTokens: 0
+          cacheReadInputTokens: 0,
+          webSearchCount: 0
         };
         if ('tee' in value) {
           const [stream1, stream2] = value.tee();
@@ -2198,9 +2365,14 @@ class WrappedMessages extends AnthropicOriginal.Messages {
                   usage.inputTokens = chunk.message.usage.input_tokens ?? 0;
                   usage.cacheCreationInputTokens = chunk.message.usage.cache_creation_input_tokens ?? 0;
                   usage.cacheReadInputTokens = chunk.message.usage.cache_read_input_tokens ?? 0;
+                  usage.webSearchCount = chunk.message.usage.server_tool_use?.web_search_requests ?? 0;
                 }
                 if ('usage' in chunk) {
                   usage.outputTokens = chunk.usage.output_tokens ?? 0;
+                  // Update web search count if present in delta
+                  if (chunk.usage.server_tool_use?.web_search_requests !== undefined) {
+                    usage.webSearchCount = chunk.usage.server_tool_use.web_search_requests;
+                  }
                 }
               }
               const latency = (Date.now() - startTime) / 1000;
@@ -2277,7 +2449,8 @@ class WrappedMessages extends AnthropicOriginal.Messages {
               inputTokens: result.usage.input_tokens ?? 0,
               outputTokens: result.usage.output_tokens ?? 0,
               cacheCreationInputTokens: result.usage.cache_creation_input_tokens ?? 0,
-              cacheReadInputTokens: result.usage.cache_read_input_tokens ?? 0
+              cacheReadInputTokens: result.usage.cache_read_input_tokens ?? 0,
+              webSearchCount: result.usage.server_tool_use?.web_search_requests ?? 0
             },
             tools: availableTools
           });
@@ -2351,7 +2524,8 @@ class WrappedModels {
           inputTokens: metadata?.promptTokenCount ?? 0,
           outputTokens: metadata?.candidatesTokenCount ?? 0,
           reasoningTokens: metadata?.thoughtsTokenCount ?? 0,
-          cacheReadInputTokens: metadata?.cachedContentTokenCount ?? 0
+          cacheReadInputTokens: metadata?.cachedContentTokenCount ?? 0,
+          webSearchCount: calculateGoogleWebSearchCount(response)
         },
         tools: availableTools
       });
@@ -2388,11 +2562,16 @@ class WrappedModels {
     const accumulatedContent = [];
     let usage = {
       inputTokens: 0,
-      outputTokens: 0
+      outputTokens: 0,
+      webSearchCount: 0
     };
     try {
       const stream = await this.client.models.generateContentStream(geminiParams);
       for await (const chunk of stream) {
+        const chunkWebSearchCount = calculateGoogleWebSearchCount(chunk);
+        if (chunkWebSearchCount > 0 && chunkWebSearchCount > (usage.webSearchCount ?? 0)) {
+          usage.webSearchCount = chunkWebSearchCount;
+        }
         // Handle text content
         if (chunk.text) {
           // Find if we already have a text item to append to
@@ -2441,7 +2620,8 @@ class WrappedModels {
             inputTokens: metadata.promptTokenCount ?? 0,
             outputTokens: metadata.candidatesTokenCount ?? 0,
             reasoningTokens: metadata.thoughtsTokenCount ?? 0,
-            cacheReadInputTokens: metadata.cachedContentTokenCount ?? 0
+            cacheReadInputTokens: metadata.cachedContentTokenCount ?? 0,
+            webSearchCount: usage.webSearchCount
           };
         }
         yield chunk;
@@ -2464,7 +2644,10 @@ class WrappedModels {
         baseURL: 'https://generativelanguage.googleapis.com',
         params: params,
         httpStatus: 200,
-        usage,
+        usage: {
+          ...usage,
+          webSearchCount: usage.webSearchCount
+        },
         tools: availableTools
       });
     } catch (error) {
@@ -2607,6 +2790,57 @@ class WrappedModels {
     return messages;
   }
 }
+/**
+ * Detect if Google Search grounding was used in the response.
+ * Gemini bills per request that uses grounding, not per individual query.
+ * Returns 1 if grounding was used, 0 otherwise.
+ */
+function calculateGoogleWebSearchCount(response) {
+  if (!response || typeof response !== 'object' || !('candidates' in response)) {
+    return 0;
+  }
+  const candidates = response.candidates;
+  if (!Array.isArray(candidates)) {
+    return 0;
+  }
+  const hasGrounding = candidates.some(candidate => {
+    if (!candidate || typeof candidate !== 'object') {
+      return false;
+    }
+    // Check for grounding metadata
+    if ('groundingMetadata' in candidate && candidate.groundingMetadata) {
+      const metadata = candidate.groundingMetadata;
+      if (typeof metadata === 'object') {
+        // Check if web_search_queries exists and is non-empty
+        if ('webSearchQueries' in metadata && Array.isArray(metadata.webSearchQueries) && metadata.webSearchQueries.length > 0) {
+          return true;
+        }
+        // Check if grounding_chunks exists and is non-empty
+        if ('groundingChunks' in metadata && Array.isArray(metadata.groundingChunks) && metadata.groundingChunks.length > 0) {
+          return true;
+        }
+      }
+    }
+    // Check for google search in function calls
+    if ('content' in candidate && candidate.content && typeof candidate.content === 'object') {
+      const content = candidate.content;
+      if ('parts' in content && Array.isArray(content.parts)) {
+        return content.parts.some(part => {
+          if (!part || typeof part !== 'object' || !('functionCall' in part)) {
+            return false;
+          }
+          const functionCall = part.functionCall;
+          if (functionCall && typeof functionCall === 'object' && 'name' in functionCall && typeof functionCall.name === 'string') {
+            return functionCall.name.includes('google_search') || functionCall.name.includes('grounding');
+          }
+          return false;
+        });
+      }
+    }
+    return false;
+  });
+  return hasGrounding ? 1 : 0;
+}
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -3427,6 +3661,9 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
       if (additionalTokenData.reasoningTokens) {
         eventProperties['$ai_reasoning_tokens'] = additionalTokenData.reasoningTokens;
       }
+      if (additionalTokenData.webSearchCount !== undefined) {
+        eventProperties['$ai_web_search_count'] = additionalTokenData.webSearchCount;
+      }
       // Handle generations/completions
       let completions;
       if (output.generations && Array.isArray(output.generations)) {
@@ -3592,6 +3829,47 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
     } else if (usage.reasoningTokens != null) {
       additionalTokenData.reasoningTokens = usage.reasoningTokens;
     }
+    // Extract web search counts from various provider formats
+    let webSearchCount;
+    // Priority 1: Exact Count
+    // Check Anthropic format (server_tool_use.web_search_requests)
+    if (usage.server_tool_use?.web_search_requests !== undefined) {
+      webSearchCount = usage.server_tool_use.web_search_requests;
+    }
+    // Priority 2: Binary Detection (1 or 0)
+    // Check for citations array (Perplexity)
+    else if (usage.citations && Array.isArray(usage.citations) && usage.citations.length > 0) {
+      webSearchCount = 1;
+    }
+    // Check for search_results array (Perplexity via OpenRouter)
+    else if (usage.search_results && Array.isArray(usage.search_results) && usage.search_results.length > 0) {
+      webSearchCount = 1;
+    }
+    // Check for search_context_size (Perplexity via OpenRouter)
+    else if (usage.search_context_size) {
+      webSearchCount = 1;
+    }
+    // Check for annotations with url_citation type
+    else if (usage.annotations && Array.isArray(usage.annotations)) {
+      const hasUrlCitation = usage.annotations.some(ann => {
+        return ann && typeof ann === 'object' && 'type' in ann && ann.type === 'url_citation';
+      });
+      if (hasUrlCitation) {
+        webSearchCount = 1;
+      }
+    }
+    // Check Gemini format (grounding metadata - binary 0 or 1)
+    else if (usage.grounding_metadata?.grounding_support !== undefined || usage.grounding_metadata?.web_search_queries !== undefined) {
+      webSearchCount = 1;
+    }
+    if (webSearchCount !== undefined) {
+      additionalTokenData.webSearchCount = webSearchCount;
+    }
+    // In LangChain, input_tokens is the sum of input and cache read tokens.
+    // Our cost calculation expects them to be separate, for Anthropic.
+    if (parsedUsage.input && additionalTokenData.cacheReadInputTokens) {
+      parsedUsage.input = Math.max(parsedUsage.input - additionalTokenData.cacheReadInputTokens, 0);
+    }
     return [parsedUsage.input, parsedUsage.output, additionalTokenData];
   }
   parseUsage(response) {