Support OpenAI transcriptions via @posthog/ai

packages/ai/src/openai/index.ts

@@ -21,6 +21,8 @@ const Chat = OpenAIOrignal.Chat
 const Completions = Chat.Completions
 const Responses = OpenAIOrignal.Responses
 const Embeddings = OpenAIOrignal.Embeddings
+const Audio = OpenAIOrignal.Audio
+const Transcriptions = OpenAIOrignal.Audio.Transcriptions
 
 type ChatCompletion = OpenAIOrignal.ChatCompletion
 type ChatCompletionChunk = OpenAIOrignal.ChatCompletionChunk
@@ -46,6 +48,7 @@ export class PostHogOpenAI extends OpenAIOrignal {
   public chat: WrappedChat
   public responses: WrappedResponses
   public embeddings: WrappedEmbeddings
+  public audio: WrappedAudio
 
   constructor(config: MonitoringOpenAIConfig) {
     const { posthog, ...openAIConfig } = config
@@ -54,6 +57,7 @@ export class PostHogOpenAI extends OpenAIOrignal {
     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)
   }
 }
 
@@ -651,6 +655,224 @@ export class WrappedEmbeddings extends Embeddings {
   }
 }
 
+export class WrappedAudio extends Audio {
+  constructor(parentClient: PostHogOpenAI, phClient: PostHog) {
+    super(parentClient)
+    this.transcriptions = new WrappedTranscriptions(parentClient, phClient)
+  }
+
+  public transcriptions: WrappedTranscriptions
+}
+
+export class WrappedTranscriptions extends Transcriptions {
+  private readonly phClient: PostHog
+  private readonly baseURL: string
+
+  constructor(client: OpenAIOrignal, phClient: PostHog) {
+    super(client)
+    this.phClient = phClient
+    this.baseURL = client.baseURL
+  }
+
+  // --- Overload #1: Non-streaming
+  public create(
+    body: OpenAIOrignal.Audio.Transcriptions.TranscriptionCreateParamsNonStreaming<'json' | undefined> &
+      MonitoringParams,
+    options?: RequestOptions
+  ): APIPromise<OpenAIOrignal.Audio.Transcriptions.Transcription>
+
+  // --- Overload #2: Non-streaming
+  public create(
+    body: OpenAIOrignal.Audio.Transcriptions.TranscriptionCreateParamsNonStreaming<'verbose_json'> & MonitoringParams,
+    options?: RequestOptions
+  ): APIPromise<OpenAIOrignal.Audio.Transcriptions.TranscriptionVerbose>
+
+  // --- Overload #3: Non-streaming
+  public create(
+    body: OpenAIOrignal.Audio.Transcriptions.TranscriptionCreateParamsNonStreaming<'srt' | 'vtt' | 'text'> &
+      MonitoringParams,
+    options?: RequestOptions
+  ): APIPromise<string>
+
+  // --- Overload #4: Non-streaming
+  public create(
+    body: OpenAIOrignal.Audio.Transcriptions.TranscriptionCreateParamsNonStreaming,
+    options?: RequestOptions
+  ): APIPromise<OpenAIOrignal.Audio.Transcriptions.Transcription>
+
+  // --- Overload #5: Streaming
+  public create(
+    body: OpenAIOrignal.Audio.Transcriptions.TranscriptionCreateParamsStreaming & MonitoringParams,
+    options?: RequestOptions
+  ): APIPromise<Stream<OpenAIOrignal.Audio.Transcriptions.TranscriptionStreamEvent>>
+
+  // --- Overload #6: Streaming
+  public create(
+    body: OpenAIOrignal.Audio.Transcriptions.TranscriptionCreateParamsStreaming & MonitoringParams,
+    options?: RequestOptions
+  ): APIPromise<
+    | OpenAIOrignal.Audio.Transcriptions.TranscriptionCreateResponse
+    | string
+    | Stream<OpenAIOrignal.Audio.Transcriptions.TranscriptionStreamEvent>
+  >
+
+  // --- Overload #7: Generic base
+  public create(
+    body: OpenAIOrignal.Audio.Transcriptions.TranscriptionCreateParams & MonitoringParams,
+    options?: RequestOptions
+  ): APIPromise<
+    | OpenAIOrignal.Audio.Transcriptions.TranscriptionCreateResponse
+    | string
+    | Stream<OpenAIOrignal.Audio.Transcriptions.TranscriptionStreamEvent>
+  >
+
+  // --- Implementation Signature
+  public create(
+    body: OpenAIOrignal.Audio.Transcriptions.TranscriptionCreateParams & MonitoringParams,
+    options?: RequestOptions
+  ): APIPromise<
+    | OpenAIOrignal.Audio.Transcriptions.TranscriptionCreateResponse
+    | string
+    | Stream<OpenAIOrignal.Audio.Transcriptions.TranscriptionStreamEvent>
+  > {
+    const { providerParams: openAIParams, posthogParams } =
+      extractPosthogParams<OpenAIOrignal.Audio.Transcriptions.TranscriptionCreateParams>(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 as any).tee === 'function') {
+          const [stream1, stream2] = (value as any).tee()
+          ;(async () => {
+            try {
+              let finalContent: string = ''
+              let usage: {
+                inputTokens?: number
+                outputTokens?: number
+              } = {
+                inputTokens: 0,
+                outputTokens: 0,
+              }
+
+              const doneEvent: OpenAIOrignal.Audio.Transcriptions.TranscriptionTextDoneEvent['type'] =
+                '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: unknown) {
+              const httpStatus =
+                error && typeof error === 'object' && 'status' in error
+                  ? ((error as { status?: number }).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
+      }) as APIPromise<Stream<OpenAIOrignal.Audio.Transcriptions.TranscriptionStreamEvent>>
+    } 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: unknown) => {
+          const httpStatus =
+            error && typeof error === 'object' && 'status' in error
+              ? ((error as { status?: number }).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
+        }
+      ) as APIPromise<OpenAIOrignal.Audio.Transcriptions.TranscriptionCreateResponse>
+
+      return wrappedPromise
+    }
+  }
+}
+
 export default PostHogOpenAI
 
 export { PostHogOpenAI as OpenAI }

packages/ai/src/utils.ts

@@ -14,6 +14,7 @@ type ChatCompletionCreateParamsBase = OpenAIOrignal.Chat.Completions.ChatComplet
 type MessageCreateParams = AnthropicOriginal.Messages.MessageCreateParams
 type ResponseCreateParams = OpenAIOrignal.Responses.ResponseCreateParams
 type EmbeddingCreateParams = OpenAIOrignal.EmbeddingCreateParams
+type TranscriptionCreateParams = OpenAIOrignal.Audio.Transcriptions.TranscriptionCreateParams
 type AnthropicTool = AnthropicOriginal.Tool
 
 // limit large outputs by truncating to 200kb (approx 200k bytes)
@@ -77,6 +78,7 @@ export const getModelParams = (
         | ResponseCreateParams
         | ResponseCreateParamsWithTools
         | EmbeddingCreateParams
+        | TranscriptionCreateParams
       ) &
         MonitoringParams)
     | null
@@ -402,6 +404,7 @@ export type SendEventToPosthogParams = {
     | ResponseCreateParams
     | ResponseCreateParamsWithTools
     | EmbeddingCreateParams
+    | TranscriptionCreateParams
   ) &
     MonitoringParams
   isError?: boolean