@posthog/ai 6.1.0 → 6.1.2

package/dist/index.mjs

@@ -238,9 +238,8 @@ const extractAvailableToolCalls = (provider, params) => {
     }
     return null;
   } else if (provider === 'vercel') {
-    // Vercel AI SDK stores tools in params.mode.tools when mode type is 'regular'
-    if (params.mode?.type === 'regular' && params.mode.tools) {
-      return params.mode.tools;
+    if (params.tools) {
+      return params.tools;
     }
     return null;
   }
@@ -350,6 +349,204 @@ const sendEventToPosthog = async ({
   }
 };
 
+// Type guards for safer type checking
+const isString = value => {
+  return typeof value === 'string';
+};
+const isObject = value => {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+};
+
+const REDACTED_IMAGE_PLACEHOLDER = '[base64 image redacted]';
+// ============================================
+// 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 (!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)
+      }
+    };
+  }
+  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 (!isObject(item)) return item;
+  // Handle Anthropic's image format
+  if (item.type === 'image' && '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 (!isObject(part)) return part;
+  // Handle Gemini's inline data format
+  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) {
+    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);
+};
+
 const Chat = OpenAI.Chat;
 const Completions = Chat.Completions;
 const Responses = OpenAI.Responses;
@@ -397,14 +594,52 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
           const [stream1, stream2] = value.tee();
           (async () => {
             try {
+              const contentBlocks = [];
               let accumulatedContent = '';
               let usage = {
                 inputTokens: 0,
                 outputTokens: 0
               };
+              // Map to track in-progress tool calls
+              const toolCallsInProgress = new Map();
               for await (const chunk of stream1) {
-                const delta = chunk?.choices?.[0]?.delta?.content ?? '';
-                accumulatedContent += delta;
+                const choice = chunk?.choices?.[0];
+                // Handle text content
+                const deltaContent = choice?.delta?.content;
+                if (deltaContent) {
+                  accumulatedContent += deltaContent;
+                }
+                // Handle tool calls
+                const deltaToolCalls = choice?.delta?.tool_calls;
+                if (deltaToolCalls && Array.isArray(deltaToolCalls)) {
+                  for (const toolCall of deltaToolCalls) {
+                    const index = toolCall.index;
+                    if (index !== undefined) {
+                      if (!toolCallsInProgress.has(index)) {
+                        // New tool call
+                        toolCallsInProgress.set(index, {
+                          id: toolCall.id || '',
+                          name: toolCall.function?.name || '',
+                          arguments: ''
+                        });
+                      }
+                      const inProgressCall = toolCallsInProgress.get(index);
+                      if (inProgressCall) {
+                        // Update tool call data
+                        if (toolCall.id) {
+                          inProgressCall.id = toolCall.id;
+                        }
+                        if (toolCall.function?.name) {
+                          inProgressCall.name = toolCall.function.name;
+                        }
+                        if (toolCall.function?.arguments) {
+                          inProgressCall.arguments += toolCall.function.arguments;
+                        }
+                      }
+                    }
+                  }
+                }
+                // Handle usage information
                 if (chunk.usage) {
                   usage = {
                     inputTokens: chunk.usage.prompt_tokens ?? 0,
@@ -414,6 +649,37 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
                   };
                 }
               }
+              // Build final content blocks
+              if (accumulatedContent) {
+                contentBlocks.push({
+                  type: 'text',
+                  text: accumulatedContent
+                });
+              }
+              // Add completed tool calls to content blocks
+              for (const toolCall of toolCallsInProgress.values()) {
+                if (toolCall.name) {
+                  contentBlocks.push({
+                    type: 'function',
+                    id: toolCall.id,
+                    function: {
+                      name: toolCall.name,
+                      arguments: toolCall.arguments
+                    }
+                  });
+                }
+              }
+              // Format output to match non-streaming version
+              const formattedOutput = contentBlocks.length > 0 ? [{
+                role: 'assistant',
+                content: contentBlocks
+              }] : [{
+                role: 'assistant',
+                content: [{
+                  type: 'text',
+                  text: ''
+                }]
+              }];
               const latency = (Date.now() - startTime) / 1000;
               const availableTools = extractAvailableToolCalls('openai', openAIParams);
               await sendEventToPosthog({
@@ -422,11 +688,8 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
                 traceId,
                 model: openAIParams.model,
                 provider: 'openai',
-                input: openAIParams.messages,
-                output: [{
-                  content: accumulatedContent,
-                  role: 'assistant'
-                }],
+                input: sanitizeOpenAI(openAIParams.messages),
+                output: formattedOutput,
                 latency,
                 baseURL: this.baseURL ?? '',
                 params: body,
@@ -436,18 +699,19 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
                 captureImmediate: posthogCaptureImmediate
               });
             } catch (error) {
+              const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
               await sendEventToPosthog({
                 client: this.phClient,
                 distinctId: posthogDistinctId,
                 traceId,
                 model: openAIParams.model,
                 provider: 'openai',
-                input: openAIParams.messages,
+                input: sanitizeOpenAI(openAIParams.messages),
                 output: [],
                 latency: 0,
                 baseURL: this.baseURL ?? '',
                 params: body,
-                httpStatus: error?.status ? error.status : 500,
+                httpStatus,
                 usage: {
                   inputTokens: 0,
                   outputTokens: 0
@@ -474,7 +738,7 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
             traceId,
             model: openAIParams.model,
             provider: 'openai',
-            input: openAIParams.messages,
+            input: sanitizeOpenAI(openAIParams.messages),
             output: formatResponseOpenAI(result),
             latency,
             baseURL: this.baseURL ?? '',
@@ -492,18 +756,19 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
         }
         return result;
       }, async error => {
+        const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
         await sendEventToPosthog({
           client: this.phClient,
           distinctId: posthogDistinctId,
           traceId,
           model: openAIParams.model,
           provider: 'openai',
-          input: openAIParams.messages,
+          input: sanitizeOpenAI(openAIParams.messages),
           output: [],
           latency: 0,
           baseURL: this.baseURL ?? '',
           params: body,
-          httpStatus: error?.status ? error.status : 500,
+          httpStatus,
           usage: {
             inputTokens: 0,
             outputTokens: 0
@@ -571,7 +836,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
                 //@ts-expect-error
                 model: openAIParams.model,
                 provider: 'openai',
-                input: openAIParams.input,
+                input: sanitizeOpenAIResponse(openAIParams.input),
                 output: finalContent,
                 latency,
                 baseURL: this.baseURL ?? '',
@@ -582,6 +847,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
                 captureImmediate: posthogCaptureImmediate
               });
             } catch (error) {
+              const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
               await sendEventToPosthog({
                 client: this.phClient,
                 distinctId: posthogDistinctId,
@@ -589,12 +855,12 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
                 //@ts-expect-error
                 model: openAIParams.model,
                 provider: 'openai',
-                input: openAIParams.input,
+                input: sanitizeOpenAIResponse(openAIParams.input),
                 output: [],
                 latency: 0,
                 baseURL: this.baseURL ?? '',
                 params: body,
-                httpStatus: error?.status ? error.status : 500,
+                httpStatus,
                 usage: {
                   inputTokens: 0,
                   outputTokens: 0
@@ -621,7 +887,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
             //@ts-expect-error
             model: openAIParams.model,
             provider: 'openai',
-            input: openAIParams.input,
+            input: sanitizeOpenAIResponse(openAIParams.input),
             output: formatResponseOpenAI({
               output: result.output
             }),
@@ -641,6 +907,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
         }
         return result;
       }, async error => {
+        const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
         await sendEventToPosthog({
           client: this.phClient,
           distinctId: posthogDistinctId,
@@ -648,12 +915,12 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
           //@ts-expect-error
           model: openAIParams.model,
           provider: 'openai',
-          input: openAIParams.input,
+          input: sanitizeOpenAIResponse(openAIParams.input),
           output: [],
           latency: 0,
           baseURL: this.baseURL ?? '',
           params: body,
-          httpStatus: error?.status ? error.status : 500,
+          httpStatus,
           usage: {
             inputTokens: 0,
             outputTokens: 0
@@ -696,7 +963,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
           //@ts-expect-error
           model: openAIParams.model,
           provider: 'openai',
-          input: openAIParams.input,
+          input: sanitizeOpenAIResponse(openAIParams.input),
           output: result.output,
           latency,
           baseURL: this.baseURL ?? '',
@@ -712,6 +979,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
         });
         return result;
       }, async error => {
+        const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
         await sendEventToPosthog({
           client: this.phClient,
           distinctId: posthogDistinctId,
@@ -719,12 +987,12 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
           //@ts-expect-error
           model: openAIParams.model,
           provider: 'openai',
-          input: openAIParams.input,
+          input: sanitizeOpenAIResponse(openAIParams.input),
           output: [],
           latency: 0,
           baseURL: this.baseURL ?? '',
           params: body,
-          httpStatus: error?.status ? error.status : 500,
+          httpStatus,
           usage: {
             inputTokens: 0,
             outputTokens: 0
@@ -786,14 +1054,52 @@ class WrappedCompletions extends AzureOpenAI.Chat.Completions {
           const [stream1, stream2] = value.tee();
           (async () => {
             try {
+              const contentBlocks = [];
               let accumulatedContent = '';
               let usage = {
                 inputTokens: 0,
                 outputTokens: 0
               };
+              // Map to track in-progress tool calls
+              const toolCallsInProgress = new Map();
               for await (const chunk of stream1) {
-                const delta = chunk?.choices?.[0]?.delta?.content ?? '';
-                accumulatedContent += delta;
+                const choice = chunk?.choices?.[0];
+                // Handle text content
+                const deltaContent = choice?.delta?.content;
+                if (deltaContent) {
+                  accumulatedContent += deltaContent;
+                }
+                // Handle tool calls
+                const deltaToolCalls = choice?.delta?.tool_calls;
+                if (deltaToolCalls && Array.isArray(deltaToolCalls)) {
+                  for (const toolCall of deltaToolCalls) {
+                    const index = toolCall.index;
+                    if (index !== undefined) {
+                      if (!toolCallsInProgress.has(index)) {
+                        // New tool call
+                        toolCallsInProgress.set(index, {
+                          id: toolCall.id || '',
+                          name: toolCall.function?.name || '',
+                          arguments: ''
+                        });
+                      }
+                      const inProgressCall = toolCallsInProgress.get(index);
+                      if (inProgressCall) {
+                        // Update tool call data
+                        if (toolCall.id) {
+                          inProgressCall.id = toolCall.id;
+                        }
+                        if (toolCall.function?.name) {
+                          inProgressCall.name = toolCall.function.name;
+                        }
+                        if (toolCall.function?.arguments) {
+                          inProgressCall.arguments += toolCall.function.arguments;
+                        }
+                      }
+                    }
+                  }
+                }
+                // Handle usage information
                 if (chunk.usage) {
                   usage = {
                     inputTokens: chunk.usage.prompt_tokens ?? 0,
@@ -803,6 +1109,37 @@ class WrappedCompletions extends AzureOpenAI.Chat.Completions {
                   };
                 }
               }
+              // Build final content blocks
+              if (accumulatedContent) {
+                contentBlocks.push({
+                  type: 'text',
+                  text: accumulatedContent
+                });
+              }
+              // Add completed tool calls to content blocks
+              for (const toolCall of toolCallsInProgress.values()) {
+                if (toolCall.name) {
+                  contentBlocks.push({
+                    type: 'function',
+                    id: toolCall.id,
+                    function: {
+                      name: toolCall.name,
+                      arguments: toolCall.arguments
+                    }
+                  });
+                }
+              }
+              // Format output to match non-streaming version
+              const formattedOutput = contentBlocks.length > 0 ? [{
+                role: 'assistant',
+                content: contentBlocks
+              }] : [{
+                role: 'assistant',
+                content: [{
+                  type: 'text',
+                  text: ''
+                }]
+              }];
               const latency = (Date.now() - startTime) / 1000;
               await sendEventToPosthog({
                 client: this.phClient,
@@ -811,10 +1148,7 @@ class WrappedCompletions extends AzureOpenAI.Chat.Completions {
                 model: openAIParams.model,
                 provider: 'azure',
                 input: openAIParams.messages,
-                output: [{
-                  content: accumulatedContent,
-                  role: 'assistant'
-                }],
+                output: formattedOutput,
                 latency,
                 baseURL: this.baseURL ?? '',
                 params: body,
@@ -823,6 +1157,7 @@ class WrappedCompletions extends AzureOpenAI.Chat.Completions {
                 captureImmediate: posthogCaptureImmediate
               });
             } catch (error) {
+              const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
               await sendEventToPosthog({
                 client: this.phClient,
                 distinctId: posthogDistinctId,
@@ -834,7 +1169,7 @@ class WrappedCompletions extends AzureOpenAI.Chat.Completions {
                 latency: 0,
                 baseURL: this.baseURL ?? '',
                 params: body,
-                httpStatus: error?.status ? error.status : 500,
+                httpStatus,
                 usage: {
                   inputTokens: 0,
                   outputTokens: 0
@@ -877,6 +1212,7 @@ class WrappedCompletions extends AzureOpenAI.Chat.Completions {
         }
         return result;
       }, async error => {
+        const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
         await sendEventToPosthog({
           client: this.phClient,
           distinctId: posthogDistinctId,
@@ -888,7 +1224,7 @@ class WrappedCompletions extends AzureOpenAI.Chat.Completions {
           latency: 0,
           baseURL: this.baseURL ?? '',
           params: body,
-          httpStatus: error?.status ? error.status : 500,
+          httpStatus,
           usage: {
             inputTokens: 0,
             outputTokens: 0
@@ -965,6 +1301,7 @@ class WrappedResponses extends AzureOpenAI.Responses {
                 captureImmediate: posthogCaptureImmediate
               });
             } catch (error) {
+              const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
               await sendEventToPosthog({
                 client: this.phClient,
                 distinctId: posthogDistinctId,
@@ -977,7 +1314,7 @@ class WrappedResponses extends AzureOpenAI.Responses {
                 latency: 0,
                 baseURL: this.baseURL ?? '',
                 params: body,
-                httpStatus: error?.status ? error.status : 500,
+                httpStatus,
                 usage: {
                   inputTokens: 0,
                   outputTokens: 0
@@ -1020,6 +1357,7 @@ class WrappedResponses extends AzureOpenAI.Responses {
         }
         return result;
       }, async error => {
+        const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
         await sendEventToPosthog({
           client: this.phClient,
           distinctId: posthogDistinctId,
@@ -1032,7 +1370,7 @@ class WrappedResponses extends AzureOpenAI.Responses {
           latency: 0,
           baseURL: this.baseURL ?? '',
           params: body,
-          httpStatus: error?.status ? error.status : 500,
+          httpStatus,
           usage: {
             inputTokens: 0,
             outputTokens: 0
@@ -1143,9 +1481,20 @@ const mapVercelPrompt = messages => {
               text: truncate(c.text)
             };
           } else if (c.type === 'file') {
+            // For file type, check if it's a data URL and redact if needed
+            let fileData;
+            const contentData = c.data;
+            if (contentData instanceof URL) {
+              fileData = contentData.toString();
+            } else if (isString(contentData)) {
+              // Redact base64 data URLs and raw base64 to prevent oversized events
+              fileData = redactBase64DataUrl(contentData);
+            } else {
+              fileData = 'raw files not supported';
+            }
             return {
               type: 'file',
-              file: c.data instanceof URL ? c.data.toString() : 'raw files not supported',
+              file: fileData,
               mediaType: c.mediaType
             };
           } else if (c.type === 'reasoning') {
@@ -1244,11 +1593,10 @@ const mapVercelOutput = result => {
       if (item.data instanceof URL) {
         fileData = item.data.toString();
       } else if (typeof item.data === 'string') {
-        // Check if it's base64 data and potentially large
-        if (item.data.startsWith('data:') || item.data.length > 1000) {
+        fileData = redactBase64DataUrl(item.data);
+        // If not redacted and still large, replace with size indicator
+        if (fileData === item.data && item.data.length > 1000) {
           fileData = `[${item.mediaType} file - ${item.data.length} bytes]`;
-        } else {
-          fileData = item.data;
         }
       } else {
         fileData = `[binary ${item.mediaType} file]`;
@@ -1389,6 +1737,8 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
       const provider = options.posthogProviderOverride ?? extractProvider(model);
       const availableTools = extractAvailableToolCalls('vercel', params);
       const baseURL = ''; // cannot currently get baseURL from vercel
+      // Map to track in-progress tool calls
+      const toolCallsInProgress = new Map();
       try {
         const {
           stream,
@@ -1403,6 +1753,34 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
             if (chunk.type === 'reasoning-delta') {
               reasoningText += chunk.delta; // New in v5
             }
+            // Handle tool call chunks
+            if (chunk.type === 'tool-input-start') {
+              // Initialize a new tool call
+              toolCallsInProgress.set(chunk.id, {
+                toolCallId: chunk.id,
+                toolName: chunk.toolName,
+                input: ''
+              });
+            }
+            if (chunk.type === 'tool-input-delta') {
+              // Accumulate tool call arguments
+              const toolCall = toolCallsInProgress.get(chunk.id);
+              if (toolCall) {
+                toolCall.input += chunk.delta;
+              }
+            }
+            if (chunk.type === 'tool-input-end') {
+              // Tool call is complete, keep it in the map for final processing
+              // Nothing specific to do here, the tool call is already complete
+            }
+            if (chunk.type === 'tool-call') {
+              // Direct tool call chunk (complete tool call)
+              toolCallsInProgress.set(chunk.toolCallId, {
+                toolCallId: chunk.toolCallId,
+                toolName: chunk.toolName,
+                input: chunk.input
+              });
+            }
             if (chunk.type === 'finish') {
               const providerMetadata = chunk.providerMetadata;
               const additionalTokenValues = {
@@ -1436,6 +1814,19 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
                 text: truncate(generatedText)
               });
             }
+            // Add completed tool calls to content
+            for (const toolCall of toolCallsInProgress.values()) {
+              if (toolCall.toolName) {
+                content.push({
+                  type: 'tool-call',
+                  id: toolCall.toolCallId,
+                  function: {
+                    name: toolCall.toolName,
+                    arguments: toolCall.input
+                  }
+                });
+              }
+            }
             // Structure output like mapVercelOutput does
             const output = content.length > 0 ? [{
               role: 'assistant',
@@ -1538,6 +1929,9 @@ class WrappedMessages extends AnthropicOriginal.Messages {
     if (anthropicParams.stream) {
       return parentPromise.then(value => {
         let accumulatedContent = '';
+        const contentBlocks = [];
+        const toolsInProgress = new Map();
+        let currentTextBlock = null;
         const usage = {
           inputTokens: 0,
           outputTokens: 0,
@@ -1549,10 +1943,70 @@ class WrappedMessages extends AnthropicOriginal.Messages {
           (async () => {
             try {
               for await (const chunk of stream1) {
+                // Handle content block start events
+                if (chunk.type === 'content_block_start') {
+                  if (chunk.content_block?.type === 'text') {
+                    currentTextBlock = {
+                      type: 'text',
+                      text: ''
+                    };
+                    contentBlocks.push(currentTextBlock);
+                  } else if (chunk.content_block?.type === 'tool_use') {
+                    const toolBlock = {
+                      type: 'function',
+                      id: chunk.content_block.id,
+                      function: {
+                        name: chunk.content_block.name,
+                        arguments: {}
+                      }
+                    };
+                    contentBlocks.push(toolBlock);
+                    toolsInProgress.set(chunk.content_block.id, {
+                      block: toolBlock,
+                      inputString: ''
+                    });
+                    currentTextBlock = null;
+                  }
+                }
+                // Handle text delta events
                 if ('delta' in chunk) {
                   if ('text' in chunk.delta) {
                     const delta = chunk?.delta?.text ?? '';
                     accumulatedContent += delta;
+                    if (currentTextBlock) {
+                      currentTextBlock.text += delta;
+                    }
+                  }
+                }
+                // Handle tool input delta events
+                if (chunk.type === 'content_block_delta' && chunk.delta?.type === 'input_json_delta') {
+                  const block = chunk.index !== undefined ? contentBlocks[chunk.index] : undefined;
+                  const toolId = block?.type === 'function' ? block.id : undefined;
+                  if (toolId && toolsInProgress.has(toolId)) {
+                    const tool = toolsInProgress.get(toolId);
+                    if (tool) {
+                      tool.inputString += chunk.delta.partial_json || '';
+                    }
+                  }
+                }
+                // Handle content block stop events
+                if (chunk.type === 'content_block_stop') {
+                  currentTextBlock = null;
+                  // Parse accumulated tool input
+                  if (chunk.index !== undefined) {
+                    const block = contentBlocks[chunk.index];
+                    if (block?.type === 'function' && block.id && toolsInProgress.has(block.id)) {
+                      const tool = toolsInProgress.get(block.id);
+                      if (tool) {
+                        try {
+                          block.function.arguments = JSON.parse(tool.inputString);
+                        } catch (e) {
+                          // Keep empty object if parsing fails
+                          console.error('Error parsing tool input:', e);
+                        }
+                      }
+                      toolsInProgress.delete(block.id);
+                    }
                   }
                 }
                 if (chunk.type == 'message_start') {
@@ -1566,17 +2020,25 @@ class WrappedMessages extends AnthropicOriginal.Messages {
               }
               const latency = (Date.now() - startTime) / 1000;
               const availableTools = extractAvailableToolCalls('anthropic', anthropicParams);
+              // Format output to match non-streaming version
+              const formattedOutput = contentBlocks.length > 0 ? [{
+                role: 'assistant',
+                content: contentBlocks
+              }] : [{
+                role: 'assistant',
+                content: [{
+                  type: 'text',
+                  text: accumulatedContent
+                }]
+              }];
               await sendEventToPosthog({
                 client: this.phClient,
                 distinctId: posthogDistinctId,
                 traceId,
                 model: anthropicParams.model,
                 provider: 'anthropic',
-                input: mergeSystemPrompt(anthropicParams, 'anthropic'),
-                output: [{
-                  content: accumulatedContent,
-                  role: 'assistant'
-                }],
+                input: sanitizeAnthropic(mergeSystemPrompt(anthropicParams, 'anthropic')),
+                output: formattedOutput,
                 latency,
                 baseURL: this.baseURL ?? '',
                 params: body,
@@ -1593,7 +2055,7 @@ class WrappedMessages extends AnthropicOriginal.Messages {
                 traceId,
                 model: anthropicParams.model,
                 provider: 'anthropic',
-                input: mergeSystemPrompt(anthropicParams),
+                input: sanitizeAnthropic(mergeSystemPrompt(anthropicParams)),
                 output: [],
                 latency: 0,
                 baseURL: this.baseURL ?? '',
@@ -1625,7 +2087,7 @@ class WrappedMessages extends AnthropicOriginal.Messages {
             traceId,
             model: anthropicParams.model,
             provider: 'anthropic',
-            input: mergeSystemPrompt(anthropicParams),
+            input: sanitizeAnthropic(mergeSystemPrompt(anthropicParams)),
             output: formatResponseAnthropic(result),
             latency,
             baseURL: this.baseURL ?? '',
@@ -1649,7 +2111,7 @@ class WrappedMessages extends AnthropicOriginal.Messages {
           traceId,
           model: anthropicParams.model,
           provider: 'anthropic',
-          input: mergeSystemPrompt(anthropicParams),
+          input: sanitizeAnthropic(mergeSystemPrompt(anthropicParams)),
           output: [],
           latency: 0,
           baseURL: this.baseURL ?? '',
@@ -1701,23 +2163,24 @@ class WrappedModels {
       const response = await this.client.models.generateContent(geminiParams);
       const latency = (Date.now() - startTime) / 1000;
       const availableTools = extractAvailableToolCalls('gemini', geminiParams);
+      const metadata = response.usageMetadata;
       await sendEventToPosthog({
         client: this.phClient,
         distinctId: posthogDistinctId,
         traceId,
         model: geminiParams.model,
         provider: 'gemini',
-        input: this.formatInput(geminiParams.contents),
+        input: this.formatInputForPostHog(geminiParams.contents),
         output: formatResponseGemini(response),
         latency,
         baseURL: 'https://generativelanguage.googleapis.com',
         params: params,
         httpStatus: 200,
         usage: {
-          inputTokens: response.usageMetadata?.promptTokenCount ?? 0,
-          outputTokens: response.usageMetadata?.candidatesTokenCount ?? 0,
-          reasoningTokens: response.usageMetadata?.thoughtsTokenCount ?? 0,
-          cacheReadInputTokens: response.usageMetadata?.cachedContentTokenCount ?? 0
+          inputTokens: metadata?.promptTokenCount ?? 0,
+          outputTokens: metadata?.candidatesTokenCount ?? 0,
+          reasoningTokens: metadata?.thoughtsTokenCount ?? 0,
+          cacheReadInputTokens: metadata?.cachedContentTokenCount ?? 0
         },
         tools: availableTools,
         captureImmediate: posthogCaptureImmediate
@@ -1731,7 +2194,7 @@ class WrappedModels {
         traceId,
         model: geminiParams.model,
         provider: 'gemini',
-        input: this.formatInput(geminiParams.contents),
+        input: this.formatInputForPostHog(geminiParams.contents),
         output: [],
         latency,
         baseURL: 'https://generativelanguage.googleapis.com',
@@ -1759,7 +2222,7 @@ class WrappedModels {
     } = params;
     const traceId = posthogTraceId ?? v4();
     const startTime = Date.now();
-    let accumulatedContent = '';
+    const accumulatedContent = [];
     let usage = {
       inputTokens: 0,
       outputTokens: 0
@@ -1767,32 +2230,74 @@ class WrappedModels {
     try {
       const stream = await this.client.models.generateContentStream(geminiParams);
       for await (const chunk of stream) {
+        // Handle text content
         if (chunk.text) {
-          accumulatedContent += chunk.text;
+          // Find if we already have a text item to append to
+          let lastTextItem;
+          for (let i = accumulatedContent.length - 1; i >= 0; i--) {
+            if (accumulatedContent[i].type === 'text') {
+              lastTextItem = accumulatedContent[i];
+              break;
+            }
+          }
+          if (lastTextItem && lastTextItem.type === 'text') {
+            lastTextItem.text += chunk.text;
+          } else {
+            accumulatedContent.push({
+              type: 'text',
+              text: chunk.text
+            });
+          }
         }
+        // Handle function calls from candidates
+        if (chunk.candidates && Array.isArray(chunk.candidates)) {
+          for (const candidate of chunk.candidates) {
+            if (candidate.content && candidate.content.parts) {
+              for (const part of candidate.content.parts) {
+                // Type-safe check for functionCall
+                if ('functionCall' in part) {
+                  const funcCall = part.functionCall;
+                  if (funcCall?.name) {
+                    accumulatedContent.push({
+                      type: 'function',
+                      function: {
+                        name: funcCall.name,
+                        arguments: funcCall.args || {}
+                      }
+                    });
+                  }
+                }
+              }
+            }
+          }
+        }
+        // Update usage metadata - handle both old and new field names
         if (chunk.usageMetadata) {
+          const metadata = chunk.usageMetadata;
           usage = {
-            inputTokens: chunk.usageMetadata.promptTokenCount ?? 0,
-            outputTokens: chunk.usageMetadata.candidatesTokenCount ?? 0,
-            reasoningTokens: chunk.usageMetadata.thoughtsTokenCount ?? 0,
-            cacheReadInputTokens: chunk.usageMetadata.cachedContentTokenCount ?? 0
+            inputTokens: metadata.promptTokenCount ?? 0,
+            outputTokens: metadata.candidatesTokenCount ?? 0,
+            reasoningTokens: metadata.thoughtsTokenCount ?? 0,
+            cacheReadInputTokens: metadata.cachedContentTokenCount ?? 0
           };
         }
         yield chunk;
       }
       const latency = (Date.now() - startTime) / 1000;
       const availableTools = extractAvailableToolCalls('gemini', geminiParams);
+      // Format output similar to formatResponseGemini
+      const output = accumulatedContent.length > 0 ? [{
+        role: 'assistant',
+        content: accumulatedContent
+      }] : [];
       await sendEventToPosthog({
         client: this.phClient,
         distinctId: posthogDistinctId,
         traceId,
         model: geminiParams.model,
         provider: 'gemini',
-        input: this.formatInput(geminiParams.contents),
-        output: [{
-          content: accumulatedContent,
-          role: 'assistant'
-        }],
+        input: this.formatInputForPostHog(geminiParams.contents),
+        output,
         latency,
         baseURL: 'https://generativelanguage.googleapis.com',
         params: params,
@@ -1809,7 +2314,7 @@ class WrappedModels {
         traceId,
         model: geminiParams.model,
         provider: 'gemini',
-        input: this.formatInput(geminiParams.contents),
+        input: this.formatInputForPostHog(geminiParams.contents),
         output: [],
         latency,
         baseURL: 'https://generativelanguage.googleapis.com',
@@ -1842,16 +2347,28 @@ class WrappedModels {
           };
         }
         if (item && typeof item === 'object') {
-          if (item.text) {
+          const obj = item;
+          if ('text' in obj && obj.text) {
+            return {
+              role: obj.role || 'user',
+              content: obj.text
+            };
+          }
+          if ('content' in obj && obj.content) {
             return {
-              role: item.role || 'user',
-              content: item.text
+              role: obj.role || 'user',
+              content: obj.content
             };
           }
-          if (item.content) {
+          if ('parts' in obj && Array.isArray(obj.parts)) {
             return {
-              role: item.role || 'user',
-              content: item.content
+              role: obj.role || 'user',
+              content: obj.parts.map(part => {
+                if (part && typeof part === 'object' && 'text' in part) {
+                  return part.text;
+                }
+                return part;
+              })
             };
           }
         }
@@ -1862,16 +2379,17 @@ class WrappedModels {
       });
     }
     if (contents && typeof contents === 'object') {
-      if (contents.text) {
+      const obj = contents;
+      if ('text' in obj && obj.text) {
         return [{
           role: 'user',
-          content: contents.text
+          content: obj.text
         }];
       }
-      if (contents.content) {
+      if ('content' in obj && obj.content) {
         return [{
           role: 'user',
-          content: contents.content
+          content: obj.content
         }];
       }
     }
@@ -1880,6 +2398,10 @@ class WrappedModels {
       content: String(contents)
     }];
   }
+  formatInputForPostHog(contents) {
+    const sanitized = sanitizeGemini(contents);
+    return this.formatInput(sanitized);
+  }
 }
 
 function getDefaultExportFromCjs (x) {
@@ -2571,7 +3093,7 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
     }) || 'generation';
     const generation = {
       name: runNameFound,
-      input: messages,
+      input: sanitizeLangChain(messages),
       startTime: Date.now()
     };
     if (extraParams) {
@@ -2834,7 +3356,8 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
         ...message.additional_kwargs
       };
     }
-    return messageDict;
+    // Sanitize the message content to redact base64 images
+    return sanitizeLangChain(messageDict);
   }
   _parseUsageModel(usage) {
     const conversionList = [['promptTokens', 'input'], ['completionTokens', 'output'], ['input_tokens', 'input'], ['output_tokens', 'output'], ['prompt_token_count', 'input'], ['candidates_token_count', 'output'], ['inputTokenCount', 'input'], ['outputTokenCount', 'output'], ['input_token_count', 'input'], ['generated_token_count', 'output']];