@posthog/ai 7.0.0 → 7.1.0

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.0";
 
 // 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) {