@posthog/ai 7.0.0 → 7.1.1

package/dist/index.d.ts

@@ -39,6 +39,8 @@ declare const Chat: typeof OpenAI.Chat;
 declare const Completions: typeof OpenAI.Chat.Completions;
 declare const Responses: typeof OpenAI.Responses;
 declare const Embeddings: typeof OpenAI.Embeddings;
+declare const Audio: typeof OpenAI.Audio;
+declare const Transcriptions: typeof OpenAI.Audio.Transcriptions;
 type ChatCompletion$1 = OpenAI.ChatCompletion;
 type ChatCompletionChunk$1 = OpenAI.ChatCompletionChunk;
 type ChatCompletionCreateParamsBase$1 = OpenAI.Chat.Completions.ChatCompletionCreateParams;
@@ -60,6 +62,7 @@ declare class PostHogOpenAI extends OpenAI {
     chat: WrappedChat$1;
     responses: WrappedResponses;
     embeddings: WrappedEmbeddings$1;
+    audio: WrappedAudio;
     constructor(config: MonitoringOpenAIConfig$1);
 }
 declare class WrappedChat$1 extends Chat {
@@ -89,6 +92,22 @@ declare class WrappedEmbeddings$1 extends Embeddings {
     constructor(client: OpenAI, phClient: PostHog);
     create(body: EmbeddingCreateParams$1 & MonitoringParams, options?: RequestOptions$2): APIPromise<CreateEmbeddingResponse$1>;
 }
+declare class WrappedAudio extends Audio {
+    constructor(parentClient: PostHogOpenAI, phClient: PostHog);
+    transcriptions: WrappedTranscriptions;
+}
+declare class WrappedTranscriptions extends Transcriptions {
+    private readonly phClient;
+    private readonly baseURL;
+    constructor(client: OpenAI, phClient: PostHog);
+    create(body: OpenAI.Audio.Transcriptions.TranscriptionCreateParamsNonStreaming<'json' | undefined> & MonitoringParams, options?: RequestOptions$2): APIPromise<OpenAI.Audio.Transcriptions.Transcription>;
+    create(body: OpenAI.Audio.Transcriptions.TranscriptionCreateParamsNonStreaming<'verbose_json'> & MonitoringParams, options?: RequestOptions$2): APIPromise<OpenAI.Audio.Transcriptions.TranscriptionVerbose>;
+    create(body: OpenAI.Audio.Transcriptions.TranscriptionCreateParamsNonStreaming<'srt' | 'vtt' | 'text'> & MonitoringParams, options?: RequestOptions$2): APIPromise<string>;
+    create(body: OpenAI.Audio.Transcriptions.TranscriptionCreateParamsNonStreaming, options?: RequestOptions$2): APIPromise<OpenAI.Audio.Transcriptions.Transcription>;
+    create(body: OpenAI.Audio.Transcriptions.TranscriptionCreateParamsStreaming & MonitoringParams, options?: RequestOptions$2): APIPromise<Stream<OpenAI.Audio.Transcriptions.TranscriptionStreamEvent>>;
+    create(body: OpenAI.Audio.Transcriptions.TranscriptionCreateParamsStreaming & MonitoringParams, options?: RequestOptions$2): APIPromise<OpenAI.Audio.Transcriptions.TranscriptionCreateResponse | string | Stream<OpenAI.Audio.Transcriptions.TranscriptionStreamEvent>>;
+    create(body: OpenAI.Audio.Transcriptions.TranscriptionCreateParams & MonitoringParams, options?: RequestOptions$2): APIPromise<OpenAI.Audio.Transcriptions.TranscriptionCreateResponse | string | Stream<OpenAI.Audio.Transcriptions.TranscriptionStreamEvent>>;
+}
 
 type ChatCompletion = OpenAIOrignal.ChatCompletion;
 type ChatCompletionChunk = OpenAIOrignal.ChatCompletionChunk;

package/dist/index.mjs

@@ -6,7 +6,7 @@ import { wrapLanguageModel } from 'ai';
 import AnthropicOriginal from '@anthropic-ai/sdk';
 import { GoogleGenAI } from '@google/genai';
 
-var version = "7.0.0";
+var version = "7.1.1";
 
 // Type guards for safer type checking
 const isString = value => {
@@ -49,7 +49,7 @@ const getModelParams = params => {
     return {};
   }
   const modelParams = {};
-  const paramKeys = ['temperature', 'max_tokens', 'max_completion_tokens', 'top_p', 'frequency_penalty', 'presence_penalty', 'n', 'stop', 'stream', 'streaming'];
+  const paramKeys = ['temperature', 'max_tokens', 'max_completion_tokens', 'top_p', 'frequency_penalty', 'presence_penalty', 'n', 'stop', 'stream', 'streaming', 'language', 'response_format', 'timestamp_granularities'];
   for (const key of paramKeys) {
     if (key in params && params[key] !== undefined) {
       modelParams[key] = params[key];
@@ -776,6 +776,8 @@ const Chat = OpenAI.Chat;
 const Completions = Chat.Completions;
 const Responses = OpenAI.Responses;
 const Embeddings = OpenAI.Embeddings;
+const Audio = OpenAI.Audio;
+const Transcriptions = OpenAI.Audio.Transcriptions;
 class PostHogOpenAI extends OpenAI {
   constructor(config) {
     const {
@@ -787,6 +789,7 @@ class PostHogOpenAI extends OpenAI {
     this.chat = new WrappedChat$1(this, this.phClient);
     this.responses = new WrappedResponses$1(this, this.phClient);
     this.embeddings = new WrappedEmbeddings$1(this, this.phClient);
+    this.audio = new WrappedAudio(this, this.phClient);
   }
 }
 let WrappedChat$1 = class WrappedChat extends Chat {
@@ -1283,6 +1286,139 @@ let WrappedEmbeddings$1 = class WrappedEmbeddings extends Embeddings {
     return wrappedPromise;
   }
 };
+class WrappedAudio extends Audio {
+  constructor(parentClient, phClient) {
+    super(parentClient);
+    this.transcriptions = new WrappedTranscriptions(parentClient, phClient);
+  }
+}
+class WrappedTranscriptions extends Transcriptions {
+  constructor(client, phClient) {
+    super(client);
+    this.phClient = phClient;
+    this.baseURL = client.baseURL;
+  }
+  // --- Implementation Signature
+  create(body, options) {
+    const {
+      providerParams: openAIParams,
+      posthogParams
+    } = extractPosthogParams(body);
+    const startTime = Date.now();
+    const parentPromise = openAIParams.stream ? super.create(openAIParams, options) : super.create(openAIParams, options);
+    if (openAIParams.stream) {
+      return parentPromise.then(value => {
+        if ('tee' in value && typeof value.tee === 'function') {
+          const [stream1, stream2] = value.tee();
+          (async () => {
+            try {
+              let finalContent = '';
+              let usage = {
+                inputTokens: 0,
+                outputTokens: 0
+              };
+              const doneEvent = 'transcript.text.done';
+              for await (const chunk of stream1) {
+                if (chunk.type === doneEvent && 'text' in chunk && chunk.text && chunk.text.length > 0) {
+                  finalContent = chunk.text;
+                }
+                if ('usage' in chunk && chunk.usage) {
+                  usage = {
+                    inputTokens: chunk.usage?.type === 'tokens' ? chunk.usage.input_tokens ?? 0 : 0,
+                    outputTokens: chunk.usage?.type === 'tokens' ? chunk.usage.output_tokens ?? 0 : 0
+                  };
+                }
+              }
+              const latency = (Date.now() - startTime) / 1000;
+              const availableTools = extractAvailableToolCalls('openai', openAIParams);
+              await sendEventToPosthog({
+                client: this.phClient,
+                ...posthogParams,
+                model: openAIParams.model,
+                provider: 'openai',
+                input: openAIParams.prompt,
+                output: finalContent,
+                latency,
+                baseURL: this.baseURL,
+                params: body,
+                httpStatus: 200,
+                usage,
+                tools: availableTools
+              });
+            } catch (error) {
+              const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
+              await sendEventToPosthog({
+                client: this.phClient,
+                ...posthogParams,
+                model: openAIParams.model,
+                provider: 'openai',
+                input: openAIParams.prompt,
+                output: [],
+                latency: 0,
+                baseURL: this.baseURL,
+                params: body,
+                httpStatus,
+                usage: {
+                  inputTokens: 0,
+                  outputTokens: 0
+                },
+                isError: true,
+                error: JSON.stringify(error)
+              });
+            }
+          })();
+          return stream2;
+        }
+        return value;
+      });
+    } else {
+      const wrappedPromise = parentPromise.then(async result => {
+        if ('text' in result) {
+          const latency = (Date.now() - startTime) / 1000;
+          await sendEventToPosthog({
+            client: this.phClient,
+            ...posthogParams,
+            model: String(openAIParams.model ?? ''),
+            provider: 'openai',
+            input: openAIParams.prompt,
+            output: result.text,
+            latency,
+            baseURL: this.baseURL,
+            params: body,
+            httpStatus: 200,
+            usage: {
+              inputTokens: result.usage?.type === 'tokens' ? result.usage.input_tokens ?? 0 : 0,
+              outputTokens: result.usage?.type === 'tokens' ? result.usage.output_tokens ?? 0 : 0
+            }
+          });
+          return result;
+        }
+      }, async error => {
+        const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
+        await sendEventToPosthog({
+          client: this.phClient,
+          ...posthogParams,
+          model: String(openAIParams.model ?? ''),
+          provider: 'openai',
+          input: openAIParams.prompt,
+          output: [],
+          latency: 0,
+          baseURL: this.baseURL,
+          params: body,
+          httpStatus,
+          usage: {
+            inputTokens: 0,
+            outputTokens: 0
+          },
+          isError: true,
+          error: JSON.stringify(error)
+        });
+        throw error;
+      });
+      return wrappedPromise;
+    }
+  }
+}
 
 class PostHogAzureOpenAI extends AzureOpenAI {
   constructor(config) {
@@ -3575,7 +3711,7 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
       eventProperties['$ai_is_error'] = true;
     } else {
       // Handle token usage
-      const [inputTokens, outputTokens, additionalTokenData] = this.parseUsage(output);
+      const [inputTokens, outputTokens, additionalTokenData] = this.parseUsage(output, run.provider, run.model);
       eventProperties['$ai_input_tokens'] = inputTokens;
       eventProperties['$ai_output_tokens'] = outputTokens;
       // Add additional token data to properties
@@ -3722,7 +3858,7 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
     // Sanitize the message content to redact base64 images
     return sanitizeLangChain(messageDict);
   }
-  _parseUsageModel(usage) {
+  _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]) => {
       const value = usage[modelKey];
@@ -3789,20 +3925,28 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
     if (webSearchCount !== undefined) {
       additionalTokenData.webSearchCount = webSearchCount;
     }
-    // In LangChain, input_tokens is the sum of input and cache read tokens.
-    // Our cost calculation expects them to be separate, for Anthropic.
-    if (parsedUsage.input && additionalTokenData.cacheReadInputTokens) {
+    // For Anthropic providers, LangChain reports input_tokens as the sum of input and cache read tokens.
+    // Our cost calculation expects them to be separate for Anthropic, so we subtract cache tokens.
+    // For other providers (OpenAI, etc.), input_tokens already excludes cache tokens as expected.
+    // Match logic consistent with plugin-server: exact match on provider OR substring match on model
+    let isAnthropic = false;
+    if (provider && provider.toLowerCase() === 'anthropic') {
+      isAnthropic = true;
+    } else if (model && model.toLowerCase().includes('anthropic')) {
+      isAnthropic = true;
+    }
+    if (isAnthropic && parsedUsage.input && additionalTokenData.cacheReadInputTokens) {
       parsedUsage.input = Math.max(parsedUsage.input - additionalTokenData.cacheReadInputTokens, 0);
     }
     return [parsedUsage.input, parsedUsage.output, additionalTokenData];
   }
-  parseUsage(response) {
+  parseUsage(response, provider, model) {
     let llmUsage = [0, 0, {}];
     const llmUsageKeys = ['token_usage', 'usage', 'tokenUsage'];
     if (response.llmOutput != null) {
       const key = llmUsageKeys.find(k => response.llmOutput?.[k] != null);
       if (key) {
-        llmUsage = this._parseUsageModel(response.llmOutput[key]);
+        llmUsage = this._parseUsageModel(response.llmOutput[key], provider, model);
       }
     }
     // If top-level usage info was not found, try checking the generations.
@@ -3811,14 +3955,14 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
         for (const genChunk of generation) {
           // Check other paths for usage information
           if (genChunk.generationInfo?.usage_metadata) {
-            llmUsage = this._parseUsageModel(genChunk.generationInfo.usage_metadata);
+            llmUsage = this._parseUsageModel(genChunk.generationInfo.usage_metadata, provider, model);
             return llmUsage;
           }
           const messageChunk = genChunk.generationInfo ?? {};
           const responseMetadata = messageChunk.response_metadata ?? {};
           const chunkUsage = responseMetadata['usage'] ?? responseMetadata['amazon-bedrock-invocationMetrics'] ?? messageChunk.usage_metadata;
           if (chunkUsage) {
-            llmUsage = this._parseUsageModel(chunkUsage);
+            llmUsage = this._parseUsageModel(chunkUsage, provider, model);
             return llmUsage;
           }
         }