@posthog/ai 7.13.2 → 7.14.0

package/dist/index.d.ts

@@ -6,7 +6,7 @@ import { ResponseCreateParamsWithTools, ExtractParsedContentFromParams } from 'o
 import { LanguageModelV2, LanguageModelV3 } from '@ai-sdk/provider';
 import AnthropicOriginal, { APIPromise as APIPromise$1 } from '@anthropic-ai/sdk';
 import { Stream as Stream$1 } from '@anthropic-ai/sdk/streaming';
-import { GoogleGenAI, GenerateContentParameters, GenerateContentResponse, GoogleGenAIOptions } from '@google/genai';
+import { GoogleGenAI, GenerateContentParameters, GenerateContentResponse, EmbedContentParameters, EmbedContentResponse, GoogleGenAIOptions } from '@google/genai';
 import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
 import { Serialized } from '@langchain/core/load/serializable';
 import { ChainValues } from '@langchain/core/utils/types';
@@ -228,6 +228,7 @@ declare class WrappedModels {
     constructor(client: GoogleGenAI, phClient: PostHog);
     generateContent(params: GenerateContentParameters & MonitoringParams): Promise<GenerateContentResponse>;
     generateContentStream(params: GenerateContentParameters & MonitoringParams): AsyncGenerator<GenerateContentResponse, void, unknown>;
+    embedContent(params: EmbedContentParameters & MonitoringParams): Promise<EmbedContentResponse>;
     private formatPartsAsContentBlocks;
     private formatInput;
     private extractSystemInstruction;
@@ -290,6 +291,7 @@ declare class LangChainCallbackHandler extends BaseCallbackHandler {
     private _convertLcToolCallsToOai;
     private _extractRawResponse;
     private _convertMessageToDict;
+    private _extractStopReason;
     private _parseUsageModel;
     private parseUsage;
 }

package/dist/index.mjs

@@ -5,7 +5,7 @@ import { uuidv7 } from '@posthog/core';
 import AnthropicOriginal from '@anthropic-ai/sdk';
 import { GoogleGenAI } from '@google/genai';
 
-var version = "7.13.2";
+var version = "7.14.0";
 
 // Type guards for safer type checking
 const isString = value => {
@@ -754,6 +754,7 @@ const sendEventToPosthog = async ({
   usage = {},
   error,
   exceptionId,
+  stopReason,
   tools,
   captureImmediate = false
 }) => {
@@ -824,6 +825,9 @@ const sendEventToPosthog = async ({
     ...(distinctId ? {} : {
       $process_person_profile: false
     }),
+    ...(stopReason ? {
+      $ai_stop_reason: stopReason
+    } : {}),
     ...(tools ? {
       $ai_tools: tools
     } : {}),
@@ -947,6 +951,7 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
               let accumulatedContent = '';
               let modelFromResponse;
               let firstTokenTime;
+              let stopReason;
               let usage = {
                 inputTokens: 0,
                 outputTokens: 0,
@@ -961,6 +966,9 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
                   modelFromResponse = chunk.model;
                 }
                 const choice = chunk?.choices?.[0];
+                if (choice?.finish_reason) {
+                  stopReason = choice.finish_reason;
+                }
                 const chunkWebSearchCount = calculateWebSearchCount(chunk);
                 if (chunkWebSearchCount > 0 && chunkWebSearchCount > (usage.webSearchCount ?? 0)) {
                   usage.webSearchCount = chunkWebSearchCount;
@@ -1072,6 +1080,7 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
                   webSearchCount: usage.webSearchCount,
                   rawUsage: rawUsageData
                 },
+                stopReason,
                 tools: availableTools
               });
             } catch (error) {
@@ -1124,6 +1133,7 @@ let WrappedCompletions$1 = class WrappedCompletions extends Completions {
               webSearchCount: calculateWebSearchCount(result),
               rawUsage: result.usage
             },
+            stopReason: result.choices[0]?.finish_reason ?? undefined,
             tools: availableTools
           });
         }
@@ -1176,6 +1186,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
               let finalContent = [];
               let modelFromResponse;
               let firstTokenTime;
+              let stopReason;
               let usage = {
                 inputTokens: 0,
                 outputTokens: 0,
@@ -1199,6 +1210,9 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
                 }
                 if (chunk.type === 'response.completed' && 'response' in chunk && chunk.response?.output && chunk.response.output.length > 0) {
                   finalContent = chunk.response.output;
+                  if (chunk.response.status) {
+                    stopReason = chunk.response.status;
+                  }
                 }
                 if ('response' in chunk && chunk.response?.usage) {
                   rawUsageData = chunk.response.usage;
@@ -1234,6 +1248,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
                   webSearchCount: usage.webSearchCount,
                   rawUsage: rawUsageData
                 },
+                stopReason,
                 tools: availableTools
               });
             } catch (error) {
@@ -1287,6 +1302,7 @@ let WrappedResponses$1 = class WrappedResponses extends Responses {
               webSearchCount: calculateWebSearchCount(result),
               rawUsage: result.usage
             },
+            stopReason: result.status ?? undefined,
             tools: availableTools
           });
         }
@@ -1346,7 +1362,8 @@ 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,
             rawUsage: result.usage
-          }
+          },
+          stopReason: result.status ?? undefined
         });
         return result;
       }, async error => {
@@ -2382,6 +2399,9 @@ const wrapVercelLanguageModel = (model, phClient, options) => {
             rawUsage: rawUsageData
           };
           adjustAnthropicV3CacheTokens(model, provider, usage);
+          // Extract finish reason - V2 returns a string, V3 returns an object with .unified
+          const rawFinishReason = result.finishReason;
+          const finishReasonStr = typeof rawFinishReason === 'string' ? rawFinishReason : rawFinishReason && typeof rawFinishReason === 'object' && 'unified' in rawFinishReason ? String(rawFinishReason.unified) : undefined;
           await sendEventToPosthog({
             client: phClient,
             distinctId: mergedOptions.posthogDistinctId,
@@ -2395,6 +2415,7 @@ const wrapVercelLanguageModel = (model, phClient, options) => {
             params: mergedParams,
             httpStatus: 200,
             usage,
+            stopReason: finishReasonStr,
             tools: availableTools,
             captureImmediate: mergedOptions.posthogCaptureImmediate
           });
@@ -2433,6 +2454,7 @@ const wrapVercelLanguageModel = (model, phClient, options) => {
         let firstTokenTime;
         let generatedText = '';
         let reasoningText = '';
+        let stopReason;
         let usage = {};
         let providerMetadata = undefined;
         const mergedParams = {
@@ -2509,6 +2531,13 @@ const wrapVercelLanguageModel = (model, phClient, options) => {
                   cacheReadInputTokens: extractCacheReadTokens(chunkUsage),
                   ...additionalTokenValues
                 };
+                // Extract finish reason - V2 returns a string, V3 returns an object with .unified
+                const rawFinishReason = chunk.finishReason;
+                if (typeof rawFinishReason === 'string') {
+                  stopReason = rawFinishReason;
+                } else if (rawFinishReason && typeof rawFinishReason === 'object' && 'unified' in rawFinishReason) {
+                  stopReason = String(rawFinishReason.unified);
+                }
               }
               controller.enqueue(chunk);
             },
@@ -2572,6 +2601,7 @@ const wrapVercelLanguageModel = (model, phClient, options) => {
                 params: mergedParams,
                 httpStatus: 200,
                 usage: finalUsage,
+                stopReason,
                 tools: availableTools,
                 captureImmediate: mergedOptions.posthogCaptureImmediate
               });
@@ -2643,6 +2673,7 @@ class WrappedMessages extends AnthropicOriginal.Messages {
         const toolsInProgress = new Map();
         let currentTextBlock = null;
         let firstTokenTime;
+        let stopReason;
         const usage = {
           inputTokens: 0,
           outputTokens: 0,
@@ -2743,6 +2774,12 @@ class WrappedMessages extends AnthropicOriginal.Messages {
                     usage.webSearchCount = chunk.usage.server_tool_use.web_search_requests;
                   }
                 }
+                if (chunk.type === 'message_delta' && 'delta' in chunk) {
+                  const delta = chunk.delta;
+                  if ('stop_reason' in delta && typeof delta.stop_reason === 'string' && delta.stop_reason) {
+                    stopReason = delta.stop_reason;
+                  }
+                }
               }
               usage.rawUsage = lastRawUsage;
               const latency = (Date.now() - startTime) / 1000;
@@ -2772,6 +2809,7 @@ class WrappedMessages extends AnthropicOriginal.Messages {
                 params: body,
                 httpStatus: 200,
                 usage,
+                stopReason,
                 tools: availableTools
               });
             } catch (error) {
@@ -2823,6 +2861,7 @@ class WrappedMessages extends AnthropicOriginal.Messages {
               webSearchCount: result.usage.server_tool_use?.web_search_requests ?? 0,
               rawUsage: result.usage
             },
+            stopReason: result.stop_reason ?? undefined,
             tools: availableTools
           });
         }
@@ -2879,6 +2918,7 @@ class WrappedModels {
       const latency = (Date.now() - startTime) / 1000;
       const availableTools = extractAvailableToolCalls('gemini', geminiParams);
       const metadata = response.usageMetadata;
+      const finishReason = response.candidates?.[0]?.finishReason;
       await sendEventToPosthog({
         client: this.phClient,
         ...posthogParams,
@@ -2898,6 +2938,7 @@ class WrappedModels {
           webSearchCount: calculateGoogleWebSearchCount(response),
           rawUsage: metadata
         },
+        stopReason: finishReason ?? undefined,
         tools: availableTools
       });
       return response;
@@ -2930,6 +2971,7 @@ class WrappedModels {
     const startTime = Date.now();
     const accumulatedContent = [];
     let firstTokenTime;
+    let stopReason;
     let usage = {
       inputTokens: 0,
       outputTokens: 0,
@@ -2966,6 +3008,10 @@ class WrappedModels {
             });
           }
         }
+        // Track finish reason from candidates
+        if (chunk.candidates?.[0]?.finishReason) {
+          stopReason = chunk.candidates[0].finishReason;
+        }
         // Handle function calls from candidates
         if (chunk.candidates && Array.isArray(chunk.candidates)) {
           for (const candidate of chunk.candidates) {
@@ -3030,6 +3076,7 @@ class WrappedModels {
           webSearchCount: usage.webSearchCount,
           rawUsage: usage.rawUsage
         },
+        stopReason,
         tools: availableTools
       });
     } catch (error) {
@@ -3053,6 +3100,54 @@ class WrappedModels {
       throw enrichedError;
     }
   }
+  async embedContent(params) {
+    const {
+      providerParams: geminiParams,
+      posthogParams
+    } = extractPosthogParams(params);
+    const startTime = Date.now();
+    try {
+      const response = await this.client.models.embedContent(geminiParams);
+      const latency = (Date.now() - startTime) / 1000;
+      const inputTokens = extractEmbeddingTokenCount(response);
+      await sendEventToPosthog({
+        client: this.phClient,
+        ...posthogParams,
+        eventType: AIEvent.Embedding,
+        model: geminiParams.model,
+        provider: 'gemini',
+        input: withPrivacyMode(this.phClient, posthogParams.privacyMode ?? false, geminiParams.contents),
+        output: null,
+        latency,
+        baseURL: 'https://generativelanguage.googleapis.com',
+        params: params,
+        httpStatus: 200,
+        usage: {
+          inputTokens
+        }
+      });
+      return response;
+    } catch (error) {
+      const latency = (Date.now() - startTime) / 1000;
+      const enrichedError = await sendEventWithErrorToPosthog({
+        client: this.phClient,
+        ...posthogParams,
+        eventType: AIEvent.Embedding,
+        model: geminiParams.model,
+        provider: 'gemini',
+        input: withPrivacyMode(this.phClient, posthogParams.privacyMode ?? false, geminiParams.contents),
+        output: null,
+        latency,
+        baseURL: 'https://generativelanguage.googleapis.com',
+        params: params,
+        usage: {
+          inputTokens: 0
+        },
+        error: error
+      });
+      throw enrichedError;
+    }
+  }
   formatPartsAsContentBlocks(parts) {
     const blocks = [];
     for (const part of parts) {
@@ -3207,6 +3302,22 @@ class WrappedModels {
     return messages;
   }
 }
+/**
+ * Extract total token count from a Gemini embed_content response.
+ * Token counts are only available per-embedding via Vertex AI's statistics.tokenCount.
+ * Returns 0 if no token counts are available.
+ */
+function extractEmbeddingTokenCount(response) {
+  let total = 0;
+  if (response.embeddings) {
+    for (const embedding of response.embeddings) {
+      if (embedding.statistics?.tokenCount != null) {
+        total += embedding.statistics.tokenCount;
+      }
+    }
+  }
+  return total;
+}
 /**
  * Detect if Google Search grounding was used in the response.
  * Gemini bills per request that uses grounding, not per individual query.
@@ -4030,6 +4141,11 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
       if (additionalTokenData.webSearchCount !== undefined) {
         eventProperties['$ai_web_search_count'] = additionalTokenData.webSearchCount;
       }
+      // Extract stop reason from generation info
+      const stopReason = this._extractStopReason(output);
+      if (stopReason) {
+        eventProperties['$ai_stop_reason'] = stopReason;
+      }
       // Handle generations/completions
       let completions;
       if (output.generations && Array.isArray(output.generations)) {
@@ -4164,6 +4280,33 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
     // Sanitize the message content to redact base64 images
     return sanitizeLangChain(messageDict);
   }
+  _extractStopReason(output) {
+    if (!output.generations || !Array.isArray(output.generations)) {
+      return undefined;
+    }
+    const lastGeneration = output.generations[output.generations.length - 1];
+    if (!Array.isArray(lastGeneration) || lastGeneration.length === 0) {
+      return undefined;
+    }
+    const gen = lastGeneration[0];
+    // Check generationInfo for finish_reason (OpenAI format)
+    if (gen.generationInfo?.finish_reason) {
+      return String(gen.generationInfo.finish_reason);
+    }
+    // Check generationInfo for response_metadata.stop_reason (Anthropic format)
+    if (gen.generationInfo?.response_metadata?.stop_reason) {
+      return String(gen.generationInfo.response_metadata.stop_reason);
+    }
+    // Check message response_metadata for finish_reason (common LangChain format)
+    if (gen.generationInfo?.response_metadata?.finish_reason) {
+      return String(gen.generationInfo.response_metadata.finish_reason);
+    }
+    // Check for stop_reason directly in generationInfo
+    if (gen.generationInfo?.stop_reason) {
+      return String(gen.generationInfo.stop_reason);
+    }
+    return undefined;
+  }
   _parseUsageModel(usage, provider, model) {
     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']];
     const parsedUsage = conversionList.reduce((acc, [modelKey, typeKey]) => {