@posthog/ai 7.5.4 → 7.6.1

package/dist/index.mjs

@@ -6,7 +6,7 @@ import { uuidv7 } from '@posthog/core';
 import AnthropicOriginal from '@anthropic-ai/sdk';
 import { GoogleGenAI } from '@google/genai';
 
-var version = "7.5.4";
+var version = "7.6.1";
 
 // Type guards for safer type checking
 const isString = value => {
@@ -16,6 +16,215 @@ const isObject = value => {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 };
 
+const REDACTED_IMAGE_PLACEHOLDER = '[base64 image redacted]';
+// ============================================
+// Multimodal Feature Toggle
+// ============================================
+const isMultimodalEnabled = () => {
+  const val = process.env._INTERNAL_LLMA_MULTIMODAL || '';
+  return val.toLowerCase() === 'true' || val === '1' || val.toLowerCase() === 'yes';
+};
+// ============================================
+// Base64 Detection Helpers
+// ============================================
+const isBase64DataUrl = str => {
+  return /^data:([^;]+);base64,/.test(str);
+};
+const isValidUrl = str => {
+  try {
+    new URL(str);
+    return true;
+  } catch {
+    // Not an absolute URL, check if it's a relative URL or path
+    return str.startsWith('/') || str.startsWith('./') || str.startsWith('../');
+  }
+};
+const isRawBase64 = str => {
+  // Skip if it's a valid URL or path
+  if (isValidUrl(str)) {
+    return false;
+  }
+  // Check if it's a valid base64 string
+  // Base64 images are typically at least a few hundred chars, but we'll be conservative
+  return str.length > 20 && /^[A-Za-z0-9+/]+=*$/.test(str);
+};
+function redactBase64DataUrl(str) {
+  if (isMultimodalEnabled()) return str;
+  if (!isString(str)) return str;
+  // Check for data URL format
+  if (isBase64DataUrl(str)) {
+    return REDACTED_IMAGE_PLACEHOLDER;
+  }
+  // Check for raw base64 (Vercel sends raw base64 for inline images)
+  if (isRawBase64(str)) {
+    return REDACTED_IMAGE_PLACEHOLDER;
+  }
+  return str;
+}
+const processMessages = (messages, transformContent) => {
+  if (!messages) return messages;
+  const processContent = content => {
+    if (typeof content === 'string') return content;
+    if (!content) return content;
+    if (Array.isArray(content)) {
+      return content.map(transformContent);
+    }
+    // Handle single object content
+    return transformContent(content);
+  };
+  const processMessage = msg => {
+    if (!isObject(msg) || !('content' in msg)) return msg;
+    return {
+      ...msg,
+      content: processContent(msg.content)
+    };
+  };
+  // Handle both arrays and single messages
+  if (Array.isArray(messages)) {
+    return messages.map(processMessage);
+  }
+  return processMessage(messages);
+};
+// ============================================
+// Provider-Specific Image Sanitizers
+// ============================================
+const sanitizeOpenAIImage = item => {
+  if (!isObject(item)) return item;
+  // Handle image_url format
+  if (item.type === 'image_url' && 'image_url' in item && isObject(item.image_url) && 'url' in item.image_url) {
+    return {
+      ...item,
+      image_url: {
+        ...item.image_url,
+        url: redactBase64DataUrl(item.image_url.url)
+      }
+    };
+  }
+  // Handle audio format
+  if (item.type === 'audio' && 'data' in item) {
+    if (isMultimodalEnabled()) return item;
+    return {
+      ...item,
+      data: REDACTED_IMAGE_PLACEHOLDER
+    };
+  }
+  return item;
+};
+const sanitizeOpenAIResponseImage = item => {
+  if (!isObject(item)) return item;
+  // Handle input_image format
+  if (item.type === 'input_image' && 'image_url' in item) {
+    return {
+      ...item,
+      image_url: redactBase64DataUrl(item.image_url)
+    };
+  }
+  return item;
+};
+const sanitizeAnthropicImage = item => {
+  if (isMultimodalEnabled()) return item;
+  if (!isObject(item)) return item;
+  // Handle Anthropic's image and document formats (same structure, different type field)
+  if ((item.type === 'image' || item.type === 'document') && 'source' in item && isObject(item.source) && item.source.type === 'base64' && 'data' in item.source) {
+    return {
+      ...item,
+      source: {
+        ...item.source,
+        data: REDACTED_IMAGE_PLACEHOLDER
+      }
+    };
+  }
+  return item;
+};
+const sanitizeGeminiPart = part => {
+  if (isMultimodalEnabled()) return part;
+  if (!isObject(part)) return part;
+  // Handle Gemini's inline data format (images, audio, PDFs all use inlineData)
+  if ('inlineData' in part && isObject(part.inlineData) && 'data' in part.inlineData) {
+    return {
+      ...part,
+      inlineData: {
+        ...part.inlineData,
+        data: REDACTED_IMAGE_PLACEHOLDER
+      }
+    };
+  }
+  return part;
+};
+const processGeminiItem = item => {
+  if (!isObject(item)) return item;
+  // If it has parts, process them
+  if ('parts' in item && item.parts) {
+    const parts = Array.isArray(item.parts) ? item.parts.map(sanitizeGeminiPart) : sanitizeGeminiPart(item.parts);
+    return {
+      ...item,
+      parts
+    };
+  }
+  return item;
+};
+const sanitizeLangChainImage = item => {
+  if (!isObject(item)) return item;
+  // OpenAI style
+  if (item.type === 'image_url' && 'image_url' in item && isObject(item.image_url) && 'url' in item.image_url) {
+    return {
+      ...item,
+      image_url: {
+        ...item.image_url,
+        url: redactBase64DataUrl(item.image_url.url)
+      }
+    };
+  }
+  // Direct image with data field
+  if (item.type === 'image' && 'data' in item) {
+    return {
+      ...item,
+      data: redactBase64DataUrl(item.data)
+    };
+  }
+  // Anthropic style
+  if (item.type === 'image' && 'source' in item && isObject(item.source) && 'data' in item.source) {
+    if (isMultimodalEnabled()) return item;
+    return {
+      ...item,
+      source: {
+        ...item.source,
+        data: redactBase64DataUrl(item.source.data)
+      }
+    };
+  }
+  // Google style
+  if (item.type === 'media' && 'data' in item) {
+    return {
+      ...item,
+      data: redactBase64DataUrl(item.data)
+    };
+  }
+  return item;
+};
+// Export individual sanitizers for tree-shaking
+const sanitizeOpenAI = data => {
+  return processMessages(data, sanitizeOpenAIImage);
+};
+const sanitizeOpenAIResponse = data => {
+  return processMessages(data, sanitizeOpenAIResponseImage);
+};
+const sanitizeAnthropic = data => {
+  return processMessages(data, sanitizeAnthropicImage);
+};
+const sanitizeGemini = data => {
+  // Gemini has a different structure with 'parts' directly on items instead of 'content'
+  // So we need custom processing instead of using processMessages
+  if (!data) return data;
+  if (Array.isArray(data)) {
+    return data.map(processGeminiItem);
+  }
+  return processGeminiItem(data);
+};
+const sanitizeLangChain = data => {
+  return processMessages(data, sanitizeLangChainImage);
+};
+
 // limit large outputs by truncating to 200kb (approx 200k bytes)
 const MAX_OUTPUT_SIZE = 200000;
 const STRING_FORMAT = 'utf8';
@@ -209,6 +418,8 @@ const formatResponseGemini = response => {
             if (data instanceof Uint8Array || Buffer.isBuffer(data)) {
               data = Buffer.from(data).toString('base64');
             }
+            // Sanitize base64 data for images and other large inline data
+            data = redactBase64DataUrl(data);
             content.push({
               type: 'audio',
               mime_type: mimeType,
@@ -557,6 +768,9 @@ const sendEventToPosthog = async ({
     } : {}),
     ...(usage.webSearchCount ? {
       $ai_web_search_count: usage.webSearchCount
+    } : {}),
+    ...(usage.rawUsage ? {
+      $ai_usage: usage.rawUsage
     } : {})
   };
   const properties = {
@@ -645,201 +859,6 @@ function formatOpenAIResponsesInput(input, instructions) {
   return messages;
 }
 
-const REDACTED_IMAGE_PLACEHOLDER = '[base64 image redacted]';
-// ============================================
-// Multimodal Feature Toggle
-// ============================================
-const isMultimodalEnabled = () => {
-  const val = process.env._INTERNAL_LLMA_MULTIMODAL || '';
-  return val.toLowerCase() === 'true' || val === '1' || val.toLowerCase() === 'yes';
-};
-// ============================================
-// Base64 Detection Helpers
-// ============================================
-const isBase64DataUrl = str => {
-  return /^data:([^;]+);base64,/.test(str);
-};
-const isValidUrl = str => {
-  try {
-    new URL(str);
-    return true;
-  } catch {
-    // Not an absolute URL, check if it's a relative URL or path
-    return str.startsWith('/') || str.startsWith('./') || str.startsWith('../');
-  }
-};
-const isRawBase64 = str => {
-  // Skip if it's a valid URL or path
-  if (isValidUrl(str)) {
-    return false;
-  }
-  // Check if it's a valid base64 string
-  // Base64 images are typically at least a few hundred chars, but we'll be conservative
-  return str.length > 20 && /^[A-Za-z0-9+/]+=*$/.test(str);
-};
-function redactBase64DataUrl(str) {
-  if (isMultimodalEnabled()) return str;
-  if (!isString(str)) return str;
-  // Check for data URL format
-  if (isBase64DataUrl(str)) {
-    return REDACTED_IMAGE_PLACEHOLDER;
-  }
-  // Check for raw base64 (Vercel sends raw base64 for inline images)
-  if (isRawBase64(str)) {
-    return REDACTED_IMAGE_PLACEHOLDER;
-  }
-  return str;
-}
-const processMessages = (messages, transformContent) => {
-  if (!messages) return messages;
-  const processContent = content => {
-    if (typeof content === 'string') return content;
-    if (!content) return content;
-    if (Array.isArray(content)) {
-      return content.map(transformContent);
-    }
-    // Handle single object content
-    return transformContent(content);
-  };
-  const processMessage = msg => {
-    if (!isObject(msg) || !('content' in msg)) return msg;
-    return {
-      ...msg,
-      content: processContent(msg.content)
-    };
-  };
-  // Handle both arrays and single messages
-  if (Array.isArray(messages)) {
-    return messages.map(processMessage);
-  }
-  return processMessage(messages);
-};
-// ============================================
-// Provider-Specific Image Sanitizers
-// ============================================
-const sanitizeOpenAIImage = item => {
-  if (!isObject(item)) return item;
-  // Handle image_url format
-  if (item.type === 'image_url' && 'image_url' in item && isObject(item.image_url) && 'url' in item.image_url) {
-    return {
-      ...item,
-      image_url: {
-        ...item.image_url,
-        url: redactBase64DataUrl(item.image_url.url)
-      }
-    };
-  }
-  // Handle audio format
-  if (item.type === 'audio' && 'data' in item) {
-    if (isMultimodalEnabled()) return item;
-    return {
-      ...item,
-      data: REDACTED_IMAGE_PLACEHOLDER
-    };
-  }
-  return item;
-};
-const sanitizeAnthropicImage = item => {
-  if (isMultimodalEnabled()) return item;
-  if (!isObject(item)) return item;
-  // Handle Anthropic's image and document formats (same structure, different type field)
-  if ((item.type === 'image' || item.type === 'document') && 'source' in item && isObject(item.source) && item.source.type === 'base64' && 'data' in item.source) {
-    return {
-      ...item,
-      source: {
-        ...item.source,
-        data: REDACTED_IMAGE_PLACEHOLDER
-      }
-    };
-  }
-  return item;
-};
-const sanitizeGeminiPart = part => {
-  if (isMultimodalEnabled()) return part;
-  if (!isObject(part)) return part;
-  // Handle Gemini's inline data format (images, audio, PDFs all use inlineData)
-  if ('inlineData' in part && isObject(part.inlineData) && 'data' in part.inlineData) {
-    return {
-      ...part,
-      inlineData: {
-        ...part.inlineData,
-        data: REDACTED_IMAGE_PLACEHOLDER
-      }
-    };
-  }
-  return part;
-};
-const processGeminiItem = item => {
-  if (!isObject(item)) return item;
-  // If it has parts, process them
-  if ('parts' in item && item.parts) {
-    const parts = Array.isArray(item.parts) ? item.parts.map(sanitizeGeminiPart) : sanitizeGeminiPart(item.parts);
-    return {
-      ...item,
-      parts
-    };
-  }
-  return item;
-};
-const sanitizeLangChainImage = item => {
-  if (!isObject(item)) return item;
-  // OpenAI style
-  if (item.type === 'image_url' && 'image_url' in item && isObject(item.image_url) && 'url' in item.image_url) {
-    return {
-      ...item,
-      image_url: {
-        ...item.image_url,
-        url: redactBase64DataUrl(item.image_url.url)
-      }
-    };
-  }
-  // Direct image with data field
-  if (item.type === 'image' && 'data' in item) {
-    return {
-      ...item,
-      data: redactBase64DataUrl(item.data)
-    };
-  }
-  // Anthropic style
-  if (item.type === 'image' && 'source' in item && isObject(item.source) && 'data' in item.source) {
-    if (isMultimodalEnabled()) return item;
-    return {
-      ...item,
-      source: {
-        ...item.source,
-        data: redactBase64DataUrl(item.source.data)
-      }
-    };
-  }
-  // Google style
-  if (item.type === 'media' && 'data' in item) {
-    return {
-      ...item,
-      data: redactBase64DataUrl(item.data)
-    };
-  }
-  return item;
-};
-// Export individual sanitizers for tree-shaking
-const sanitizeOpenAI = data => {
-  return processMessages(data, sanitizeOpenAIImage);
-};
-const sanitizeAnthropic = data => {
-  return processMessages(data, sanitizeAnthropicImage);
-};
-const sanitizeGemini = data => {
-  // Gemini has a different structure with 'parts' directly on items instead of 'content'
-  // So we need custom processing instead of using processMessages
-  if (!data) return data;
-  if (Array.isArray(data)) {
-    return data.map(processGeminiItem);
-  }
-  return processGeminiItem(data);
-};
-const sanitizeLangChain = data => {
-  return processMessages(data, sanitizeLangChainImage);
-};
-
 const Chat = OpenAI.Chat;
 const Completions = Chat.Completions;
 const Responses = OpenAI.Responses;
@@ -896,6 +915,7 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
               };
               // Map to track in-progress tool calls
               const toolCallsInProgress = new Map();
+              let rawUsageData;
               for await (const chunk of stream1) {
                 // Extract model from chunk (Chat Completions chunks have model field)
                 if (!modelFromResponse && chunk.model) {
@@ -943,6 +963,7 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
                 }
                 // Handle usage information
                 if (chunk.usage) {
+                  rawUsageData = chunk.usage;
                   usage = {
                     ...usage,
                     inputTokens: chunk.usage.prompt_tokens ?? 0,
@@ -1001,7 +1022,8 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
                   outputTokens: usage.outputTokens,
                   reasoningTokens: usage.reasoningTokens,
                   cacheReadInputTokens: usage.cacheReadInputTokens,
-                  webSearchCount: usage.webSearchCount
+                  webSearchCount: usage.webSearchCount,
+                  rawUsage: rawUsageData
                 },
                 tools: availableTools
               });
@@ -1052,7 +1074,8 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
               outputTokens: result.usage?.completion_tokens ?? 0,
               reasoningTokens: result.usage?.completion_tokens_details?.reasoning_tokens ?? 0,
               cacheReadInputTokens: result.usage?.prompt_tokens_details?.cached_tokens ?? 0,
-              webSearchCount: calculateWebSearchCount(result)
+              webSearchCount: calculateWebSearchCount(result),
+              rawUsage: result.usage
             },
             tools: availableTools
           });
@@ -1110,6 +1133,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
                 outputTokens: 0,
                 webSearchCount: 0
               };
+              let rawUsageData;
               for await (const chunk of stream1) {
                 if ('response' in chunk && chunk.response) {
                   // Extract model from response object in chunk (for stored prompts)
@@ -1125,6 +1149,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
                   finalContent = chunk.response.output;
                 }
                 if ('response' in chunk && chunk.response?.usage) {
+                  rawUsageData = chunk.response.usage;
                   usage = {
                     ...usage,
                     inputTokens: chunk.response.usage.input_tokens ?? 0,
@@ -1141,7 +1166,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
                 ...posthogParams,
                 model: openAIParams.model ?? modelFromResponse,
                 provider: 'openai',
-                input: formatOpenAIResponsesInput(openAIParams.input, openAIParams.instructions),
+                input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
                 output: finalContent,
                 latency,
                 baseURL: this.baseURL,
@@ -1152,7 +1177,8 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
                   outputTokens: usage.outputTokens,
                   reasoningTokens: usage.reasoningTokens,
                   cacheReadInputTokens: usage.cacheReadInputTokens,
-                  webSearchCount: usage.webSearchCount
+                  webSearchCount: usage.webSearchCount,
+                  rawUsage: rawUsageData
                 },
                 tools: availableTools
               });
@@ -1162,7 +1188,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
                 ...posthogParams,
                 model: openAIParams.model,
                 provider: 'openai',
-                input: formatOpenAIResponsesInput(openAIParams.input, openAIParams.instructions),
+                input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
                 output: [],
                 latency: 0,
                 baseURL: this.baseURL,
@@ -1193,7 +1219,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
             ...posthogParams,
             model: openAIParams.model ?? result.model,
             provider: 'openai',
-            input: formatOpenAIResponsesInput(openAIParams.input, openAIParams.instructions),
+            input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
             output: formattedOutput,
             latency,
             baseURL: this.baseURL,
@@ -1204,7 +1230,8 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
               outputTokens: result.usage?.output_tokens ?? 0,
               reasoningTokens: result.usage?.output_tokens_details?.reasoning_tokens ?? 0,
               cacheReadInputTokens: result.usage?.input_tokens_details?.cached_tokens ?? 0,
-              webSearchCount: calculateWebSearchCount(result)
+              webSearchCount: calculateWebSearchCount(result),
+              rawUsage: result.usage
             },
             tools: availableTools
           });
@@ -1217,7 +1244,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
           ...posthogParams,
           model: openAIParams.model,
           provider: 'openai',
-          input: formatOpenAIResponsesInput(openAIParams.input, openAIParams.instructions),
+          input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
           output: [],
           latency: 0,
           baseURL: this.baseURL,
@@ -1253,7 +1280,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
           ...posthogParams,
           model: openAIParams.model ?? result.model,
           provider: 'openai',
-          input: formatOpenAIResponsesInput(openAIParams.input, openAIParams.instructions),
+          input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
           output: result.output,
           latency,
           baseURL: this.baseURL,
@@ -1263,7 +1290,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,
+            rawUsage: result.usage
           }
         });
         return result;
@@ -1273,7 +1301,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
           ...posthogParams,
           model: openAIParams.model,
           provider: 'openai',
-          input: formatOpenAIResponsesInput(openAIParams.input, openAIParams.instructions),
+          input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
           output: [],
           latency: 0,
           baseURL: this.baseURL,
@@ -1322,7 +1350,8 @@ let WrappedEmbeddings$1 = class WrappedEmbeddings extends Embeddings {
         params: body,
         httpStatus: 200,
         usage: {
-          inputTokens: result.usage?.prompt_tokens ?? 0
+          inputTokens: result.usage?.prompt_tokens ?? 0,
+          rawUsage: result.usage
         }
       });
       return result;
@@ -1390,7 +1419,8 @@ class WrappedTranscriptions extends Transcriptions {
                 if ('usage' in chunk && chunk.usage) {
                   usage = {
                     inputTokens: chunk.usage?.type === 'tokens' ? chunk.usage.input_tokens ?? 0 : 0,
-                    outputTokens: chunk.usage?.type === 'tokens' ? chunk.usage.output_tokens ?? 0 : 0
+                    outputTokens: chunk.usage?.type === 'tokens' ? chunk.usage.output_tokens ?? 0 : 0,
+                    rawUsage: chunk.usage
                   };
                 }
               }
@@ -1451,7 +1481,8 @@ class WrappedTranscriptions extends Transcriptions {
             httpStatus: 200,
             usage: {
               inputTokens: result.usage?.type === 'tokens' ? result.usage.input_tokens ?? 0 : 0,
-              outputTokens: result.usage?.type === 'tokens' ? result.usage.output_tokens ?? 0 : 0
+              outputTokens: result.usage?.type === 'tokens' ? result.usage.output_tokens ?? 0 : 0,
+              rawUsage: result.usage
             }
           });
           return result;
@@ -2247,13 +2278,29 @@ const wrapVercelLanguageModel = (model, phClient, options) => {
           const webSearchCount = extractWebSearchCount(providerMetadata, result.usage);
           // V2 usage has simple numbers, V3 has objects with .total - normalize both
           const usageObj = result.usage;
+          // Extract raw response for providers that include detailed usage metadata
+          // For Gemini, candidatesTokensDetails is in result.response.body.usageMetadata
+          const rawUsageData = {
+            usage: result.usage,
+            providerMetadata
+          };
+          // Include response body usageMetadata if it contains detailed token breakdown (e.g., candidatesTokensDetails)
+          if (result.response && typeof result.response === 'object') {
+            const responseBody = result.response.body;
+            if (responseBody && typeof responseBody === 'object' && 'usageMetadata' in responseBody) {
+              rawUsageData.rawResponse = {
+                usageMetadata: responseBody.usageMetadata
+              };
+            }
+          }
           const usage = {
             inputTokens: extractTokenCount(result.usage.inputTokens),
             outputTokens: extractTokenCount(result.usage.outputTokens),
             reasoningTokens: extractReasoningTokens(usageObj),
             cacheReadInputTokens: extractCacheReadTokens(usageObj),
             webSearchCount,
-            ...additionalTokenValues
+            ...additionalTokenValues,
+            rawUsage: rawUsageData
           };
           adjustAnthropicV3CacheTokens(model, provider, usage);
           await sendEventToPosthog({
@@ -2408,10 +2455,14 @@ const wrapVercelLanguageModel = (model, phClient, options) => {
                 content: content.length === 1 && content[0].type === 'text' ? content[0].text : content
               }] : [];
               const webSearchCount = extractWebSearchCount(providerMetadata, usage);
-              // Update usage with web search count
+              // Update usage with web search count and raw metadata
               const finalUsage = {
                 ...usage,
-                webSearchCount
+                webSearchCount,
+                rawUsage: {
+                  usage,
+                  providerMetadata
+                }
               };
               adjustAnthropicV3CacheTokens(model, provider, finalUsage);
               await sendEventToPosthog({
@@ -2504,6 +2555,7 @@ class WrappedMessages extends AnthropicOriginal.Messages {
           cacheReadInputTokens: 0,
           webSearchCount: 0
         };
+        let lastRawUsage;
         if ('tee' in value) {
           const [stream1, stream2] = value.tee();
           (async () => {
@@ -2576,12 +2628,14 @@ class WrappedMessages extends AnthropicOriginal.Messages {
                   }
                 }
                 if (chunk.type == 'message_start') {
+                  lastRawUsage = chunk.message.usage;
                   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) {
+                  lastRawUsage = chunk.usage;
                   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) {
@@ -2589,6 +2643,7 @@ class WrappedMessages extends AnthropicOriginal.Messages {
                   }
                 }
               }
+              usage.rawUsage = lastRawUsage;
               const latency = (Date.now() - startTime) / 1000;
               const availableTools = extractAvailableToolCalls('anthropic', anthropicParams);
               // Format output to match non-streaming version
@@ -2662,7 +2717,8 @@ class WrappedMessages extends AnthropicOriginal.Messages {
               outputTokens: result.usage.output_tokens ?? 0,
               cacheCreationInputTokens: result.usage.cache_creation_input_tokens ?? 0,
               cacheReadInputTokens: result.usage.cache_read_input_tokens ?? 0,
-              webSearchCount: result.usage.server_tool_use?.web_search_requests ?? 0
+              webSearchCount: result.usage.server_tool_use?.web_search_requests ?? 0,
+              rawUsage: result.usage
             },
             tools: availableTools
           });
@@ -2736,7 +2792,8 @@ class WrappedModels {
           outputTokens: metadata?.candidatesTokenCount ?? 0,
           reasoningTokens: metadata?.thoughtsTokenCount ?? 0,
           cacheReadInputTokens: metadata?.cachedContentTokenCount ?? 0,
-          webSearchCount: calculateGoogleWebSearchCount(response)
+          webSearchCount: calculateGoogleWebSearchCount(response),
+          rawUsage: metadata
         },
         tools: availableTools
       });
@@ -2772,7 +2829,8 @@ class WrappedModels {
     let usage = {
       inputTokens: 0,
       outputTokens: 0,
-      webSearchCount: 0
+      webSearchCount: 0,
+      rawUsage: undefined
     };
     try {
       const stream = await this.client.models.generateContentStream(geminiParams);
@@ -2830,7 +2888,8 @@ class WrappedModels {
             outputTokens: metadata.candidatesTokenCount ?? 0,
             reasoningTokens: metadata.thoughtsTokenCount ?? 0,
             cacheReadInputTokens: metadata.cachedContentTokenCount ?? 0,
-            webSearchCount: usage.webSearchCount
+            webSearchCount: usage.webSearchCount,
+            rawUsage: metadata
           };
         }
         yield chunk;
@@ -2855,7 +2914,8 @@ class WrappedModels {
         httpStatus: 200,
         usage: {
           ...usage,
-          webSearchCount: usage.webSearchCount
+          webSearchCount: usage.webSearchCount,
+          rawUsage: usage.rawUsage
         },
         tools: availableTools
       });
@@ -3293,6 +3353,20 @@ function isSerializableLike(obj) {
 	return obj !== null && typeof obj === "object" && "lc_serializable" in obj && typeof obj.toJSON === "function";
 }
 /**
+* Create a "not_implemented" serialization result for objects that cannot be serialized.
+*/
+function createNotImplemented(obj) {
+	let id;
+	if (obj !== null && typeof obj === "object") if ("lc_id" in obj && Array.isArray(obj.lc_id)) id = obj.lc_id;
+	else id = [obj.constructor?.name ?? "Object"];
+	else id = [typeof obj];
+	return {
+		lc: 1,
+		type: "not_implemented",
+		id
+	};
+}
+/**
 * Escape a value if it needs escaping (contains `lc` key).
 *
 * This is a simpler version of `serializeValue` that doesn't handle Serializable
@@ -3300,18 +3374,27 @@ function isSerializableLike(obj) {
 * processed by `toJSON()`.
 *
 * @param value - The value to potentially escape.
+* @param pathSet - WeakSet to track ancestor objects in the current path to detect circular references.
+*                  Objects are removed after processing to allow shared references (same object in
+*                  multiple places) while still detecting true circular references (ancestor in descendant).
 * @returns The value with any `lc`-containing objects wrapped in escape markers.
 */
-function escapeIfNeeded(value) {
+function escapeIfNeeded(value, pathSet = /* @__PURE__ */ new WeakSet()) {
 	if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+		if (pathSet.has(value)) return createNotImplemented(value);
 		if (isSerializableLike(value)) return value;
+		pathSet.add(value);
 		const record = value;
-		if (needsEscaping(record)) return escapeObject(record);
+		if (needsEscaping(record)) {
+			pathSet.delete(value);
+			return escapeObject(record);
+		}
 		const result = {};
-		for (const [key, val] of Object.entries(record)) result[key] = escapeIfNeeded(val);
+		for (const [key, val] of Object.entries(record)) result[key] = escapeIfNeeded(val, pathSet);
+		pathSet.delete(value);
 		return result;
 	}
-	if (Array.isArray(value)) return value.map((item) => escapeIfNeeded(item));
+	if (Array.isArray(value)) return value.map((item) => escapeIfNeeded(item, pathSet));
 	return value;
 }
 
@@ -3437,7 +3520,9 @@ var Serializable = class Serializable {
 			if (last in read && read[last] !== void 0) write[last] = write[last] || read[last];
 		});
 		const escapedKwargs = {};
-		for (const [key, value] of Object.entries(kwargs)) escapedKwargs[key] = escapeIfNeeded(value);
+		const pathSet = /* @__PURE__ */ new WeakSet();
+		pathSet.add(this);
+		for (const [key, value] of Object.entries(kwargs)) escapedKwargs[key] = escapeIfNeeded(value, pathSet);
 		const kwargsWithSecrets = Object.keys(secrets).length ? replaceSecrets(escapedKwargs, secrets) : escapedKwargs;
 		const processedKwargs = mapKeys(kwargsWithSecrets, keyToJson, aliases);
 		return {