@posthog/ai 5.2.3 → 6.0.1

package/dist/index.mjs

@@ -2,7 +2,7 @@ import { OpenAI, AzureOpenAI } from 'openai';
 import * as uuid from 'uuid';
 import { v4 } from 'uuid';
 import { Buffer } from 'buffer';
-import { experimental_wrapLanguageModel } from 'ai';
+import { wrapLanguageModel } from 'ai';
 import AnthropicOriginal from '@anthropic-ai/sdk';
 import { GoogleGenAI } from '@google/genai';
 
@@ -23,30 +23,171 @@ const getModelParams = params => {
   return modelParams;
 };
 const formatResponseAnthropic = response => {
-  // Example approach if "response.content" holds array of text segments, etc.
   const output = [];
+  const content = [];
   for (const choice of response.content ?? []) {
-    if (choice?.text) {
-      output.push({
-        role: 'assistant',
-        content: choice.text
+    if (choice?.type === 'text' && choice?.text) {
+      content.push({
+        type: 'text',
+        text: choice.text
+      });
+    } else if (choice?.type === 'tool_use' && choice?.name && choice?.id) {
+      content.push({
+        type: 'function',
+        id: choice.id,
+        function: {
+          name: choice.name,
+          arguments: choice.input || {}
+        }
       });
     }
   }
+  if (content.length > 0) {
+    output.push({
+      role: 'assistant',
+      content
+    });
+  }
   return output;
 };
 const formatResponseOpenAI = response => {
   const output = [];
-  for (const choice of response.choices ?? []) {
-    if (choice.message?.content) {
+  if (response.choices) {
+    for (const choice of response.choices) {
+      const content = [];
+      let role = 'assistant';
+      if (choice.message) {
+        if (choice.message.role) {
+          role = choice.message.role;
+        }
+        if (choice.message.content) {
+          content.push({
+            type: 'text',
+            text: choice.message.content
+          });
+        }
+        if (choice.message.tool_calls) {
+          for (const toolCall of choice.message.tool_calls) {
+            content.push({
+              type: 'function',
+              id: toolCall.id,
+              function: {
+                name: toolCall.function.name,
+                arguments: toolCall.function.arguments
+              }
+            });
+          }
+        }
+      }
+      if (content.length > 0) {
+        output.push({
+          role,
+          content
+        });
+      }
+    }
+  }
+  // Handle Responses API format
+  if (response.output) {
+    const content = [];
+    let role = 'assistant';
+    for (const item of response.output) {
+      if (item.type === 'message') {
+        role = item.role;
+        if (item.content && Array.isArray(item.content)) {
+          for (const contentItem of item.content) {
+            if (contentItem.type === 'output_text' && contentItem.text) {
+              content.push({
+                type: 'text',
+                text: contentItem.text
+              });
+            } else if (contentItem.text) {
+              content.push({
+                type: 'text',
+                text: contentItem.text
+              });
+            } else if (contentItem.type === 'input_image' && contentItem.image_url) {
+              content.push({
+                type: 'image',
+                image: contentItem.image_url
+              });
+            }
+          }
+        } else if (item.content) {
+          content.push({
+            type: 'text',
+            text: String(item.content)
+          });
+        }
+      } else if (item.type === 'function_call') {
+        content.push({
+          type: 'function',
+          id: item.call_id || item.id || '',
+          function: {
+            name: item.name,
+            arguments: item.arguments || {}
+          }
+        });
+      }
+    }
+    if (content.length > 0) {
       output.push({
-        role: choice.message.role,
-        content: choice.message.content
+        role,
+        content
       });
     }
   }
   return output;
 };
+const formatResponseGemini = response => {
+  const output = [];
+  if (response.candidates && Array.isArray(response.candidates)) {
+    for (const candidate of response.candidates) {
+      if (candidate.content && candidate.content.parts) {
+        const content = [];
+        for (const part of candidate.content.parts) {
+          if (part.text) {
+            content.push({
+              type: 'text',
+              text: part.text
+            });
+          } else if (part.functionCall) {
+            content.push({
+              type: 'function',
+              function: {
+                name: part.functionCall.name,
+                arguments: part.functionCall.args
+              }
+            });
+          }
+        }
+        if (content.length > 0) {
+          output.push({
+            role: 'assistant',
+            content
+          });
+        }
+      } else if (candidate.text) {
+        output.push({
+          role: 'assistant',
+          content: [{
+            type: 'text',
+            text: candidate.text
+          }]
+        });
+      }
+    }
+  } else if (response.text) {
+    output.push({
+      role: 'assistant',
+      content: [{
+        type: 'text',
+        text: response.text
+      }]
+    });
+  }
+  return output;
+};
 const mergeSystemPrompt = (params, provider) => {
   {
     const messages = params.messages || [];
@@ -76,6 +217,35 @@ const truncate = str => {
     return str;
   }
 };
+/**
+ * Extract available tool calls from the request parameters.
+ * These are the tools provided to the LLM, not the tool calls in the response.
+ */
+const extractAvailableToolCalls = (provider, params) => {
+  if (provider === 'anthropic') {
+    if (params.tools) {
+      return params.tools;
+    }
+    return null;
+  } else if (provider === 'gemini') {
+    if (params.config && params.config.tools) {
+      return params.config.tools;
+    }
+    return null;
+  } else if (provider === 'openai') {
+    if (params.tools) {
+      return params.tools;
+    }
+    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;
+    }
+    return null;
+  }
+  return null;
+};
 function sanitizeValues(obj) {
   if (obj === undefined || obj === null) {
     return obj;
@@ -245,6 +415,7 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
                 }
               }
               const latency = (Date.now() - startTime) / 1000;
+              const availableTools = extractAvailableToolCalls('openai', openAIParams);
               await sendEventToPosthog({
                 client: this.phClient,
                 distinctId: posthogDistinctId,
@@ -261,6 +432,7 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
                 params: body,
                 httpStatus: 200,
                 usage,
+                tools: availableTools,
                 captureImmediate: posthogCaptureImmediate
               });
             } catch (error) {
@@ -295,6 +467,7 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
       const wrappedPromise = parentPromise.then(async result => {
         if ('choices' in result) {
           const latency = (Date.now() - startTime) / 1000;
+          const availableTools = extractAvailableToolCalls('openai', openAIParams);
           await sendEventToPosthog({
             client: this.phClient,
             distinctId: posthogDistinctId,
@@ -313,6 +486,7 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
               reasoningTokens: result.usage?.completion_tokens_details?.reasoning_tokens ?? 0,
               cacheReadInputTokens: result.usage?.prompt_tokens_details?.cached_tokens ?? 0
             },
+            tools: availableTools,
             captureImmediate: posthogCaptureImmediate
           });
         }
@@ -389,6 +563,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
                 }
               }
               const latency = (Date.now() - startTime) / 1000;
+              const availableTools = extractAvailableToolCalls('openai', openAIParams);
               await sendEventToPosthog({
                 client: this.phClient,
                 distinctId: posthogDistinctId,
@@ -403,6 +578,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
                 params: body,
                 httpStatus: 200,
                 usage,
+                tools: availableTools,
                 captureImmediate: posthogCaptureImmediate
               });
             } catch (error) {
@@ -437,6 +613,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
       const wrappedPromise = parentPromise.then(async result => {
         if ('output' in result) {
           const latency = (Date.now() - startTime) / 1000;
+          const availableTools = extractAvailableToolCalls('openai', openAIParams);
           await sendEventToPosthog({
             client: this.phClient,
             distinctId: posthogDistinctId,
@@ -445,7 +622,9 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
             model: openAIParams.model,
             provider: 'openai',
             input: openAIParams.input,
-            output: result.output,
+            output: formatResponseOpenAI({
+              output: result.output
+            }),
             latency,
             baseURL: this.baseURL ?? '',
             params: body,
@@ -456,6 +635,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
               reasoningTokens: result.usage?.output_tokens_details?.reasoning_tokens ?? 0,
               cacheReadInputTokens: result.usage?.input_tokens_details?.cached_tokens ?? 0
             },
+            tools: availableTools,
             captureImmediate: posthogCaptureImmediate
           });
         }
@@ -935,7 +1115,7 @@ class WrappedResponses extends AzureOpenAI.Responses {
 const mapVercelParams = params => {
   return {
     temperature: params.temperature,
-    max_tokens: params.maxTokens,
+    max_output_tokens: params.maxOutputTokens,
     top_p: params.topP,
     frequency_penalty: params.frequencyPenalty,
     presence_penalty: params.presencePenalty,
@@ -943,78 +1123,67 @@ const mapVercelParams = params => {
     stream: params.stream
   };
 };
-const mapVercelPrompt = prompt => {
-  // normalize single inputs into an array of messages
-  let promptsArray;
-  if (typeof prompt === 'string') {
-    promptsArray = [{
-      role: 'user',
-      content: prompt
-    }];
-  } else if (!Array.isArray(prompt)) {
-    promptsArray = [prompt];
-  } else {
-    promptsArray = prompt;
-  }
+const mapVercelPrompt = messages => {
   // Map and truncate individual content
-  const inputs = promptsArray.map(p => {
-    let content = {};
-    if (Array.isArray(p.content)) {
-      content = p.content.map(c => {
-        if (c.type === 'text') {
-          return {
-            type: 'text',
-            content: truncate(c.text)
-          };
-        } else if (c.type === 'image') {
-          return {
-            type: 'image',
-            content: {
-              // if image is a url use it, or use "none supported"
-              image: c.image instanceof URL ? c.image.toString() : 'raw images not supported',
-              mimeType: c.mimeType
-            }
-          };
-        } else if (c.type === 'file') {
-          return {
-            type: 'file',
-            content: {
+  const inputs = messages.map(message => {
+    let content;
+    // Handle system role which has string content
+    if (message.role === 'system') {
+      content = [{
+        type: 'text',
+        text: truncate(String(message.content))
+      }];
+    } else {
+      // Handle other roles which have array content
+      if (Array.isArray(message.content)) {
+        content = message.content.map(c => {
+          if (c.type === 'text') {
+            return {
+              type: 'text',
+              text: truncate(c.text)
+            };
+          } else if (c.type === 'file') {
+            return {
+              type: 'file',
               file: c.data instanceof URL ? c.data.toString() : 'raw files not supported',
-              mimeType: c.mimeType
-            }
-          };
-        } else if (c.type === 'tool-call') {
-          return {
-            type: 'tool-call',
-            content: {
+              mediaType: c.mediaType
+            };
+          } else if (c.type === 'reasoning') {
+            return {
+              type: 'reasoning',
+              text: truncate(c.reasoning)
+            };
+          } else if (c.type === 'tool-call') {
+            return {
+              type: 'tool-call',
               toolCallId: c.toolCallId,
               toolName: c.toolName,
-              args: c.args
-            }
-          };
-        } else if (c.type === 'tool-result') {
-          return {
-            type: 'tool-result',
-            content: {
+              input: c.input
+            };
+          } else if (c.type === 'tool-result') {
+            return {
+              type: 'tool-result',
               toolCallId: c.toolCallId,
               toolName: c.toolName,
-              result: c.result,
+              output: c.output,
               isError: c.isError
-            }
+            };
+          }
+          return {
+            type: 'text',
+            text: ''
           };
-        }
-        return {
-          content: ''
-        };
-      });
-    } else {
-      content = {
-        type: 'text',
-        text: truncate(p.content)
-      };
+        });
+      } else {
+        // Fallback for non-array content
+        content = [{
+          type: 'text',
+          text: truncate(String(message.content))
+        }];
+      }
     }
     return {
-      role: p.role,
+      role: message.role,
       content
     };
   });
@@ -1046,52 +1215,75 @@ const mapVercelPrompt = prompt => {
   return inputs;
 };
 const mapVercelOutput = result => {
-  // normalize string results to object
-  const normalizedResult = typeof result === 'string' ? {
-    text: result
-  } : result;
-  const output = {
-    ...(normalizedResult.text ? {
-      text: normalizedResult.text
-    } : {}),
-    ...(normalizedResult.object ? {
-      object: normalizedResult.object
-    } : {}),
-    ...(normalizedResult.reasoning ? {
-      reasoning: normalizedResult.reasoning
-    } : {}),
-    ...(normalizedResult.response ? {
-      response: normalizedResult.response
-    } : {}),
-    ...(normalizedResult.finishReason ? {
-      finishReason: normalizedResult.finishReason
-    } : {}),
-    ...(normalizedResult.usage ? {
-      usage: normalizedResult.usage
-    } : {}),
-    ...(normalizedResult.warnings ? {
-      warnings: normalizedResult.warnings
-    } : {}),
-    ...(normalizedResult.providerMetadata ? {
-      toolCalls: normalizedResult.providerMetadata
-    } : {}),
-    ...(normalizedResult.files ? {
-      files: normalizedResult.files.map(file => ({
-        name: file.name,
-        size: file.size,
-        type: file.type
-      }))
-    } : {})
-  };
-  if (output.text && !output.object && !output.reasoning) {
+  const content = result.map(item => {
+    if (item.type === 'text') {
+      return {
+        type: 'text',
+        text: truncate(item.text)
+      };
+    }
+    if (item.type === 'tool-call') {
+      return {
+        type: 'tool-call',
+        id: item.toolCallId,
+        function: {
+          name: item.toolName,
+          arguments: item.args || JSON.stringify(item.arguments || {})
+        }
+      };
+    }
+    if (item.type === 'reasoning') {
+      return {
+        type: 'reasoning',
+        text: truncate(item.text)
+      };
+    }
+    if (item.type === 'file') {
+      // Handle files similar to input mapping - avoid large base64 data
+      let fileData;
+      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 = `[${item.mediaType} file - ${item.data.length} bytes]`;
+        } else {
+          fileData = item.data;
+        }
+      } else {
+        fileData = `[binary ${item.mediaType} file]`;
+      }
+      return {
+        type: 'file',
+        name: 'generated_file',
+        mediaType: item.mediaType,
+        data: fileData
+      };
+    }
+    if (item.type === 'source') {
+      return {
+        type: 'source',
+        sourceType: item.sourceType,
+        id: item.id,
+        url: item.url || '',
+        title: item.title || ''
+      };
+    }
+    // Fallback for unknown types - try to extract text if possible
+    return {
+      type: 'text',
+      text: truncate(JSON.stringify(item))
+    };
+  });
+  if (content.length > 0) {
     return [{
-      content: truncate(output.text),
-      role: 'assistant'
+      role: 'assistant',
+      content: content.length === 1 && content[0].type === 'text' ? content[0].text : content
     }];
   }
   // otherwise stringify and truncate
   try {
-    const jsonOutput = JSON.stringify(output);
+    const jsonOutput = JSON.stringify(result);
     return [{
       content: truncate(jsonOutput),
       role: 'assistant'
@@ -1117,14 +1309,14 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
         ...options,
         ...mapVercelParams(params)
       };
+      const availableTools = extractAvailableToolCalls('vercel', params);
       try {
         const result = await doGenerate();
-        const latency = (Date.now() - startTime) / 1000;
         const modelId = options.posthogModelOverride ?? (result.response?.modelId ? result.response.modelId : model.modelId);
         const provider = options.posthogProviderOverride ?? extractProvider(model);
         const baseURL = ''; // cannot currently get baseURL from vercel
-        const content = mapVercelOutput(result);
-        // let tools = result.toolCalls
+        const content = mapVercelOutput(result.content);
+        const latency = (Date.now() - startTime) / 1000;
         const providerMetadata = result.providerMetadata;
         const additionalTokenValues = {
           ...(providerMetadata?.openai?.reasoningTokens ? {
@@ -1145,19 +1337,17 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
           model: modelId,
           provider: provider,
           input: options.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
-          output: [{
-            content,
-            role: 'assistant'
-          }],
+          output: content,
           latency,
           baseURL,
           params: mergedParams,
           httpStatus: 200,
           usage: {
-            inputTokens: result.usage.promptTokens,
-            outputTokens: result.usage.completionTokens,
+            inputTokens: result.usage.inputTokens,
+            outputTokens: result.usage.outputTokens,
             ...additionalTokenValues
           },
+          tools: availableTools,
           captureImmediate: options.posthogCaptureImmediate
         });
         return result;
@@ -1181,6 +1371,7 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
           },
           isError: true,
           error: truncate(JSON.stringify(error)),
+          tools: availableTools,
           captureImmediate: options.posthogCaptureImmediate
         });
         throw error;
@@ -1192,6 +1383,7 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
     }) => {
       const startTime = Date.now();
       let generatedText = '';
+      let reasoningText = '';
       let usage = {};
       const mergedParams = {
         ...options,
@@ -1199,6 +1391,7 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
       };
       const modelId = options.posthogModelOverride ?? model.modelId;
       const provider = options.posthogProviderOverride ?? extractProvider(model);
+      const availableTools = extractAvailableToolCalls('vercel', params);
       const baseURL = ''; // cannot currently get baseURL from vercel
       try {
         const {
@@ -1207,13 +1400,17 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
         } = await doStream();
         const transformStream = new TransformStream({
           transform(chunk, controller) {
+            // Handle new v5 streaming patterns
             if (chunk.type === 'text-delta') {
-              generatedText += chunk.textDelta;
+              generatedText += chunk.delta;
+            }
+            if (chunk.type === 'reasoning-delta') {
+              reasoningText += chunk.delta; // New in v5
             }
             if (chunk.type === 'finish') {
               usage = {
-                inputTokens: chunk.usage?.promptTokens,
-                outputTokens: chunk.usage?.completionTokens
+                inputTokens: chunk.usage?.inputTokens,
+                outputTokens: chunk.usage?.outputTokens
               };
               if (chunk.providerMetadata?.openai?.reasoningTokens) {
                 usage.reasoningTokens = chunk.providerMetadata.openai.reasoningTokens;
@@ -1232,6 +1429,25 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
           },
           flush: async () => {
             const latency = (Date.now() - startTime) / 1000;
+            // Build content array similar to mapVercelOutput structure
+            const content = [];
+            if (reasoningText) {
+              content.push({
+                type: 'reasoning',
+                text: truncate(reasoningText)
+              });
+            }
+            if (generatedText) {
+              content.push({
+                type: 'text',
+                text: truncate(generatedText)
+              });
+            }
+            // Structure output like mapVercelOutput does
+            const output = content.length > 0 ? [{
+              role: 'assistant',
+              content: content.length === 1 && content[0].type === 'text' ? content[0].text : content
+            }] : [];
             await sendEventToPosthog({
               client: phClient,
               distinctId: options.posthogDistinctId,
@@ -1239,15 +1455,13 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
               model: modelId,
               provider: provider,
               input: options.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
-              output: [{
-                content: generatedText,
-                role: 'assistant'
-              }],
+              output: output,
               latency,
               baseURL,
               params: mergedParams,
               httpStatus: 200,
               usage,
+              tools: availableTools,
               captureImmediate: options.posthogCaptureImmediate
             });
           }
@@ -1275,6 +1489,7 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
           },
           isError: true,
           error: truncate(JSON.stringify(error)),
+          tools: availableTools,
           captureImmediate: options.posthogCaptureImmediate
         });
         throw error;
@@ -1290,7 +1505,7 @@ const wrapVercelLanguageModel = (model, phClient, options) => {
     posthogTraceId: traceId,
     posthogDistinctId: options.posthogDistinctId
   });
-  const wrappedModel = experimental_wrapLanguageModel({
+  const wrappedModel = wrapLanguageModel({
     model,
     middleware
   });
@@ -1357,6 +1572,7 @@ class WrappedMessages extends AnthropicOriginal.Messages {
                 }
               }
               const latency = (Date.now() - startTime) / 1000;
+              const availableTools = extractAvailableToolCalls('anthropic', anthropicParams);
               await sendEventToPosthog({
                 client: this.phClient,
                 distinctId: posthogDistinctId,
@@ -1373,6 +1589,7 @@ class WrappedMessages extends AnthropicOriginal.Messages {
                 params: body,
                 httpStatus: 200,
                 usage,
+                tools: availableTools,
                 captureImmediate: posthogCaptureImmediate
               });
             } catch (error) {
@@ -1408,6 +1625,7 @@ class WrappedMessages extends AnthropicOriginal.Messages {
       const wrappedPromise = parentPromise.then(async result => {
         if ('content' in result) {
           const latency = (Date.now() - startTime) / 1000;
+          const availableTools = extractAvailableToolCalls('anthropic', anthropicParams);
           await sendEventToPosthog({
             client: this.phClient,
             distinctId: posthogDistinctId,
@@ -1426,6 +1644,7 @@ class WrappedMessages extends AnthropicOriginal.Messages {
               cacheCreationInputTokens: result.usage.cache_creation_input_tokens ?? 0,
               cacheReadInputTokens: result.usage.cache_read_input_tokens ?? 0
             },
+            tools: availableTools,
             captureImmediate: posthogCaptureImmediate
           });
         }
@@ -1488,6 +1707,7 @@ class WrappedModels {
     try {
       const response = await this.client.models.generateContent(geminiParams);
       const latency = (Date.now() - startTime) / 1000;
+      const availableTools = extractAvailableToolCalls('gemini', geminiParams);
       await sendEventToPosthog({
         client: this.phClient,
         distinctId: posthogDistinctId,
@@ -1495,7 +1715,7 @@ class WrappedModels {
         model: geminiParams.model,
         provider: 'gemini',
         input: this.formatInput(geminiParams.contents),
-        output: this.formatOutput(response),
+        output: formatResponseGemini(response),
         latency,
         baseURL: 'https://generativelanguage.googleapis.com',
         params: params,
@@ -1504,6 +1724,7 @@ class WrappedModels {
           inputTokens: response.usageMetadata?.promptTokenCount ?? 0,
           outputTokens: response.usageMetadata?.candidatesTokenCount ?? 0
         },
+        tools: availableTools,
         captureImmediate: posthogCaptureImmediate
       });
       return response;
@@ -1563,6 +1784,7 @@ class WrappedModels {
         yield chunk;
       }
       const latency = (Date.now() - startTime) / 1000;
+      const availableTools = extractAvailableToolCalls('gemini', geminiParams);
       await sendEventToPosthog({
         client: this.phClient,
         distinctId: posthogDistinctId,
@@ -1579,6 +1801,7 @@ class WrappedModels {
         params: params,
         httpStatus: 200,
         usage,
+        tools: availableTools,
         captureImmediate: posthogCaptureImmediate
       });
     } catch (error) {
@@ -1660,30 +1883,6 @@ class WrappedModels {
       content: String(contents)
     }];
   }
-  formatOutput(response) {
-    if (response.text) {
-      return [{
-        role: 'assistant',
-        content: response.text
-      }];
-    }
-    if (response.candidates && Array.isArray(response.candidates)) {
-      return response.candidates.map(candidate => {
-        if (candidate.content && candidate.content.parts) {
-          const text = candidate.content.parts.filter(part => part.text).map(part => part.text).join('');
-          return {
-            role: 'assistant',
-            content: text
-          };
-        }
-        return {
-          role: 'assistant',
-          content: String(candidate)
-        };
-      });
-    }
-    return [];
-  }
 }
 
 function getDefaultExportFromCjs (x) {
@@ -2380,7 +2579,7 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
     };
     if (extraParams) {
       generation.modelParams = getModelParams(extraParams.invocation_params);
-      if (extraParams.invocation_params.tools) {
+      if (extraParams.invocation_params && extraParams.invocation_params.tools) {
         generation.tools = extraParams.invocation_params.tools;
       }
     }
@@ -2489,7 +2688,7 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
       $ai_base_url: run.baseUrl
     };
     if (run.tools) {
-      eventProperties['$ai_tools'] = withPrivacyMode(this.client, this.privacyMode, run.tools);
+      eventProperties['$ai_tools'] = run.tools;
     }
     if (output instanceof Error) {
       eventProperties['$ai_http_status'] = output.status || 500;
@@ -2511,13 +2710,20 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
       let completions;
       if (output.generations && Array.isArray(output.generations)) {
         const lastGeneration = output.generations[output.generations.length - 1];
-        if (Array.isArray(lastGeneration)) {
-          completions = lastGeneration.map(gen => {
-            return {
-              role: 'assistant',
-              content: gen.text
-            };
-          });
+        if (Array.isArray(lastGeneration) && lastGeneration.length > 0) {
+          // Check if this is a ChatGeneration by looking at the first item
+          const isChatGeneration = 'message' in lastGeneration[0] && lastGeneration[0].message;
+          if (isChatGeneration) {
+            // For ChatGeneration, convert messages to dict format
+            completions = lastGeneration.map(gen => {
+              return this._convertMessageToDict(gen.message);
+            });
+          } else {
+            // For non-ChatGeneration, extract raw response
+            completions = lastGeneration.map(gen => {
+              return this._extractRawResponse(gen);
+            });
+          }
         }
       }
       if (completions) {
@@ -2568,6 +2774,19 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
       }
     }));
   }
+  _extractRawResponse(generation) {
+    // Extract the response from the last response of the LLM call
+    // We return the text of the response if not empty
+    if (generation.text != null && generation.text.trim() !== '') {
+      return generation.text.trim();
+    } else if (generation.message) {
+      // Additional kwargs contains the response in case of tool usage
+      return generation.message.additional_kwargs || generation.message.additionalKwargs || {};
+    } else {
+      // Not tool usage, some LLM responses can be simply empty
+      return '';
+    }
+  }
   _convertMessageToDict(message) {
     let messageDict = {};
     const messageType = message.getType();