@posthog/ai 6.6.0 → 7.1.0

package/dist/openai/index.mjs

@@ -2,7 +2,7 @@ import { OpenAI } from 'openai';
 import { Buffer } from 'buffer';
 import { v4 } from 'uuid';
 
-var version = "6.6.0";
+var version = "7.1.0";
 
 // Type guards for safer type checking
 
@@ -45,7 +45,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];
@@ -195,13 +195,14 @@ function calculateWebSearchCount(result) {
     }
   }
 
-  // Check for annotations with url_citation in choices[].message (OpenAI/Perplexity)
+  // Check for annotations with url_citation in choices[].message or choices[].delta (OpenAI/Perplexity)
   if ('choices' in result && Array.isArray(result.choices)) {
     for (const choice of result.choices) {
-      if (typeof choice === 'object' && choice !== null && 'message' in choice) {
-        const message = choice.message;
-        if (typeof message === 'object' && message !== null && 'annotations' in message) {
-          const annotations = message.annotations;
+      if (typeof choice === 'object' && choice !== null) {
+        // Check both message (non-streaming) and delta (streaming) for annotations
+        const content = ('message' in choice ? choice.message : null) || ('delta' in choice ? choice.delta : null);
+        if (typeof content === 'object' && content !== null && 'annotations' in content) {
+          const annotations = content.annotations;
           if (Array.isArray(annotations)) {
             const hasUrlCitation = annotations.some(ann => {
               return typeof ann === 'object' && ann !== null && 'type' in ann && ann.type === 'url_citation';
@@ -562,6 +563,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 {
@@ -573,6 +576,7 @@ class PostHogOpenAI extends OpenAI {
     this.chat = new WrappedChat(this, this.phClient);
     this.responses = new WrappedResponses(this, this.phClient);
     this.embeddings = new WrappedEmbeddings(this, this.phClient);
+    this.audio = new WrappedAudio(this, this.phClient);
   }
 }
 class WrappedChat extends Chat {
@@ -1091,6 +1095,154 @@ 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;
+  }
+
+  // --- Overload #1: Non-streaming
+
+  // --- Overload #2: Non-streaming
+
+  // --- Overload #3: Non-streaming
+
+  // --- Overload #4: Non-streaming
+
+  // --- Overload #5: Streaming
+
+  // --- Overload #6: Streaming
+
+  // --- Overload #7: Generic base
+
+  // --- 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;
+    }
+  }
+}
 
-export { PostHogOpenAI as OpenAI, PostHogOpenAI, WrappedChat, WrappedCompletions, WrappedEmbeddings, WrappedResponses, PostHogOpenAI as default };
+export { PostHogOpenAI as OpenAI, PostHogOpenAI, WrappedAudio, WrappedChat, WrappedCompletions, WrappedEmbeddings, WrappedResponses, WrappedTranscriptions, PostHogOpenAI as default };
 //# sourceMappingURL=index.mjs.map