@posthog/ai 3.3.0 → 3.3.2

package/lib/index.esm.js

@@ -94,7 +94,7 @@ const sendEventToPosthog = ({
         $ai_total_cost_usd: inputCostUSD + outputCostUSD
       };
     }
-    let additionalTokenValues = {
+    const additionalTokenValues = {
       ...(usage.reasoningTokens ? {
         $ai_reasoning_tokens: usage.reasoningTokens
       } : {}),
@@ -531,6 +531,45 @@ const mapVercelPrompt = prompt => {
     };
   });
 };
+const mapVercelOutput = result => {
+  const output = {
+    ...(result.text ? {
+      text: result.text
+    } : {}),
+    ...(result.object ? {
+      object: result.object
+    } : {}),
+    ...(result.reasoning ? {
+      reasoning: result.reasoning
+    } : {}),
+    ...(result.response ? {
+      response: result.response
+    } : {}),
+    ...(result.finishReason ? {
+      finishReason: result.finishReason
+    } : {}),
+    ...(result.usage ? {
+      usage: result.usage
+    } : {}),
+    ...(result.warnings ? {
+      warnings: result.warnings
+    } : {}),
+    ...(result.providerMetadata ? {
+      toolCalls: result.providerMetadata
+    } : {})
+  };
+  // if text and no object or reasoning, return text
+  if (output.text && !output.object && !output.reasoning) {
+    return [{
+      content: output.text,
+      role: 'assistant'
+    }];
+  }
+  return [{
+    content: JSON.stringify(output),
+    role: 'assistant'
+  }];
+};
 const extractProvider = model => {
   // vercel provider is in the format of provider.endpoint
   const provider = model.provider.toLowerCase();
@@ -554,14 +593,14 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
         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
-        let content = result.text || JSON.stringify(result);
+        const content = mapVercelOutput(result);
         // let tools = result.toolCalls
-        let providerMetadata = result.providerMetadata;
-        let additionalTokenValues = {
+        const providerMetadata = result.providerMetadata;
+        const additionalTokenValues = {
           ...(providerMetadata?.openai?.reasoningTokens ? {
             reasoningTokens: providerMetadata.openai.reasoningTokens
           } : {}),
-          ...(providerMetadata?.openai?.cachedPromptToken ? {
+          ...(providerMetadata?.openai?.cachedPromptTokens ? {
             cacheReadInputTokens: providerMetadata.openai.cachedPromptTokens
           } : {}),
           ...(providerMetadata?.anthropic ? {
@@ -647,8 +686,8 @@ const createInstrumentationMiddleware = (phClient, model, options) => {
               if (chunk.providerMetadata?.openai?.reasoningTokens) {
                 usage.reasoningTokens = chunk.providerMetadata.openai.reasoningTokens;
               }
-              if (chunk.providerMetadata?.openai?.cachedPromptToken) {
-                usage.cacheReadInputTokens = chunk.providerMetadata.openai.cachedPromptToken;
+              if (chunk.providerMetadata?.openai?.cachedPromptTokens) {
+                usage.cacheReadInputTokens = chunk.providerMetadata.openai.cachedPromptTokens;
               }
               if (chunk.providerMetadata?.anthropic?.cacheReadInputTokens) {
                 usage.cacheReadInputTokens = chunk.providerMetadata.anthropic.cacheReadInputTokens;
@@ -1628,9 +1667,16 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
       eventProperties['$ai_is_error'] = true;
     } else {
       // Handle token usage
-      const [inputTokens, outputTokens] = this.parseUsage(output);
+      const [inputTokens, outputTokens, additionalTokenData] = this.parseUsage(output);
       eventProperties['$ai_input_tokens'] = inputTokens;
       eventProperties['$ai_output_tokens'] = outputTokens;
+      // Add additional token data to properties
+      if (additionalTokenData.cacheReadInputTokens) {
+        eventProperties['$ai_cache_read_tokens'] = additionalTokenData.cacheReadInputTokens;
+      }
+      if (additionalTokenData.reasoningTokens) {
+        eventProperties['$ai_reasoning_tokens'] = additionalTokenData.reasoningTokens;
+      }
       // Handle generations/completions
       let completions;
       if (output.generations && Array.isArray(output.generations)) {
@@ -1669,6 +1715,8 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
       for (const arg of args) {
         if (arg && typeof arg === 'object' && 'name' in arg) {
           return arg.name;
+        } else if (arg && typeof arg === 'object' && 'runName' in arg) {
+          return arg.runName;
         }
       }
     }
@@ -1742,10 +1790,28 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
       input: 0,
       output: 0
     });
-    return [parsedUsage.input, parsedUsage.output];
+    // Extract additional token details like cached tokens and reasoning tokens
+    const additionalTokenData = {};
+    // Check for cached tokens in various formats
+    if (usage.prompt_tokens_details?.cached_tokens != null) {
+      additionalTokenData.cacheReadInputTokens = usage.prompt_tokens_details.cached_tokens;
+    } else if (usage.input_token_details?.cache_read != null) {
+      additionalTokenData.cacheReadInputTokens = usage.input_token_details.cache_read;
+    } else if (usage.cachedPromptTokens != null) {
+      additionalTokenData.cacheReadInputTokens = usage.cachedPromptTokens;
+    }
+    // Check for reasoning tokens in various formats
+    if (usage.completion_tokens_details?.reasoning_tokens != null) {
+      additionalTokenData.reasoningTokens = usage.completion_tokens_details.reasoning_tokens;
+    } else if (usage.output_token_details?.reasoning != null) {
+      additionalTokenData.reasoningTokens = usage.output_token_details.reasoning;
+    } else if (usage.reasoningTokens != null) {
+      additionalTokenData.reasoningTokens = usage.reasoningTokens;
+    }
+    return [parsedUsage.input, parsedUsage.output, additionalTokenData];
   }
   parseUsage(response) {
-    let llmUsage = [0, 0];
+    let llmUsage = [0, 0, {}];
     const llmUsageKeys = ['token_usage', 'usage', 'tokenUsage'];
     if (response.llmOutput != null) {
       const key = llmUsageKeys.find(k => response.llmOutput?.[k] != null);
@@ -1757,6 +1823,7 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
     if (llmUsage[0] === 0 && llmUsage[1] === 0 && response.generations) {
       for (const generation of response.generations) {
         for (const genChunk of generation) {
+          // Check other paths for usage information
           if (genChunk.generationInfo?.usage_metadata) {
             llmUsage = this._parseUsageModel(genChunk.generationInfo.usage_metadata);
             return llmUsage;