@posthog/ai 5.0.1 → 5.2.0

package/src/openai/index.ts

@@ -2,14 +2,18 @@ import OpenAIOrignal, { ClientOptions } from 'openai'
 import { PostHog } from 'posthog-node'
 import { v4 as uuidv4 } from 'uuid'
 import { formatResponseOpenAI, MonitoringParams, sendEventToPosthog } from '../utils'
+import type { APIPromise } from 'openai'
+import type { Stream } from 'openai/streaming'
+import type { ParsedResponse } from 'openai/resources/responses/responses'
 
 type ChatCompletion = OpenAIOrignal.ChatCompletion
 type ChatCompletionChunk = OpenAIOrignal.ChatCompletionChunk
 type ChatCompletionCreateParamsBase = OpenAIOrignal.Chat.Completions.ChatCompletionCreateParams
 type ChatCompletionCreateParamsNonStreaming = OpenAIOrignal.Chat.Completions.ChatCompletionCreateParamsNonStreaming
 type ChatCompletionCreateParamsStreaming = OpenAIOrignal.Chat.Completions.ChatCompletionCreateParamsStreaming
-import type { APIPromise, RequestOptions } from 'openai/core'
-import type { Stream } from 'openai/streaming'
+type ResponsesCreateParamsBase = OpenAIOrignal.Responses.ResponseCreateParams
+type ResponsesCreateParamsNonStreaming = OpenAIOrignal.Responses.ResponseCreateParamsNonStreaming
+type ResponsesCreateParamsStreaming = OpenAIOrignal.Responses.ResponseCreateParamsStreaming
 
 interface MonitoringOpenAIConfig extends ClientOptions {
   apiKey: string
@@ -17,15 +21,19 @@ interface MonitoringOpenAIConfig extends ClientOptions {
   baseURL?: string
 }
 
+type RequestOptions = Record<string, any>
+
 export class PostHogOpenAI extends OpenAIOrignal {
   private readonly phClient: PostHog
   public chat: WrappedChat
+  public responses: WrappedResponses
 
   constructor(config: MonitoringOpenAIConfig) {
     const { posthog, ...openAIConfig } = config
     super(openAIConfig)
     this.phClient = posthog
     this.chat = new WrappedChat(this, this.phClient)
+    this.responses = new WrappedResponses(this, this.phClient)
   }
 }
 
@@ -118,7 +126,7 @@ export class WrappedCompletions extends OpenAIOrignal.Chat.Completions {
               const latency = (Date.now() - startTime) / 1000
               await sendEventToPosthog({
                 client: this.phClient,
-                distinctId: posthogDistinctId ?? traceId,
+                distinctId: posthogDistinctId,
                 traceId,
                 model: openAIParams.model,
                 provider: 'openai',
@@ -134,7 +142,7 @@ export class WrappedCompletions extends OpenAIOrignal.Chat.Completions {
             } catch (error: any) {
               await sendEventToPosthog({
                 client: this.phClient,
-                distinctId: posthogDistinctId ?? traceId,
+                distinctId: posthogDistinctId,
                 traceId,
                 model: openAIParams.model,
                 provider: 'openai',
@@ -164,7 +172,7 @@ export class WrappedCompletions extends OpenAIOrignal.Chat.Completions {
             const latency = (Date.now() - startTime) / 1000
             await sendEventToPosthog({
               client: this.phClient,
-              distinctId: posthogDistinctId ?? traceId,
+              distinctId: posthogDistinctId,
               traceId,
               model: openAIParams.model,
               provider: 'openai',
@@ -188,7 +196,7 @@ export class WrappedCompletions extends OpenAIOrignal.Chat.Completions {
         async (error: any) => {
           await sendEventToPosthog({
             client: this.phClient,
-            distinctId: posthogDistinctId ?? traceId,
+            distinctId: posthogDistinctId,
             traceId,
             model: openAIParams.model,
             provider: 'openai',
@@ -215,6 +223,272 @@ export class WrappedCompletions extends OpenAIOrignal.Chat.Completions {
   }
 }
 
+export class WrappedResponses extends OpenAIOrignal.Responses {
+  private readonly phClient: PostHog
+
+  constructor(client: OpenAIOrignal, phClient: PostHog) {
+    super(client)
+    this.phClient = phClient
+  }
+
+  // --- Overload #1: Non-streaming
+  public create(
+    body: ResponsesCreateParamsNonStreaming & MonitoringParams,
+    options?: RequestOptions
+  ): APIPromise<OpenAIOrignal.Responses.Response>
+
+  // --- Overload #2: Streaming
+  public create(
+    body: ResponsesCreateParamsStreaming & MonitoringParams,
+    options?: RequestOptions
+  ): APIPromise<Stream<OpenAIOrignal.Responses.ResponseStreamEvent>>
+
+  // --- Overload #3: Generic base
+  public create(
+    body: ResponsesCreateParamsBase & MonitoringParams,
+    options?: RequestOptions
+  ): APIPromise<OpenAIOrignal.Responses.Response | Stream<OpenAIOrignal.Responses.ResponseStreamEvent>>
+
+  // --- Implementation Signature
+  public create(
+    body: ResponsesCreateParamsBase & MonitoringParams,
+    options?: RequestOptions
+  ): APIPromise<OpenAIOrignal.Responses.Response | Stream<OpenAIOrignal.Responses.ResponseStreamEvent>> {
+    const {
+      posthogDistinctId,
+      posthogTraceId,
+      posthogProperties,
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      posthogPrivacyMode = false,
+      posthogGroups,
+      posthogCaptureImmediate,
+      ...openAIParams
+    } = body
+
+    const traceId = posthogTraceId ?? uuidv4()
+    const startTime = Date.now()
+
+    const parentPromise = 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: any[] = []
+              let usage: {
+                inputTokens?: number
+                outputTokens?: number
+                reasoningTokens?: number
+                cacheReadInputTokens?: number
+              } = {
+                inputTokens: 0,
+                outputTokens: 0,
+              }
+
+              for await (const chunk of stream1) {
+                if (
+                  chunk.type === 'response.completed' &&
+                  'response' in chunk &&
+                  chunk.response?.output &&
+                  chunk.response.output.length > 0
+                ) {
+                  finalContent = chunk.response.output
+                }
+                if ('response' in chunk && chunk.response?.usage) {
+                  usage = {
+                    inputTokens: chunk.response.usage.input_tokens ?? 0,
+                    outputTokens: chunk.response.usage.output_tokens ?? 0,
+                    reasoningTokens: chunk.response.usage.output_tokens_details?.reasoning_tokens ?? 0,
+                    cacheReadInputTokens: chunk.response.usage.input_tokens_details?.cached_tokens ?? 0,
+                  }
+                }
+              }
+
+              const latency = (Date.now() - startTime) / 1000
+              await sendEventToPosthog({
+                client: this.phClient,
+                distinctId: posthogDistinctId,
+                traceId,
+                model: openAIParams.model,
+                provider: 'openai',
+                input: openAIParams.input,
+                output: finalContent,
+                latency,
+                baseURL: (this as any).baseURL ?? '',
+                params: body,
+                httpStatus: 200,
+                usage,
+                captureImmediate: posthogCaptureImmediate,
+              })
+            } catch (error: any) {
+              await sendEventToPosthog({
+                client: this.phClient,
+                distinctId: posthogDistinctId,
+                traceId,
+                model: openAIParams.model,
+                provider: 'openai',
+                input: openAIParams.input,
+                output: [],
+                latency: 0,
+                baseURL: (this as any).baseURL ?? '',
+                params: body,
+                httpStatus: error?.status ? error.status : 500,
+                usage: { inputTokens: 0, outputTokens: 0 },
+                isError: true,
+                error: JSON.stringify(error),
+                captureImmediate: posthogCaptureImmediate,
+              })
+            }
+          })()
+
+          return stream2
+        }
+        return value
+      }) as APIPromise<Stream<OpenAIOrignal.Responses.ResponseStreamEvent>>
+    } else {
+      const wrappedPromise = parentPromise.then(
+        async (result) => {
+          if ('output' in result) {
+            const latency = (Date.now() - startTime) / 1000
+            await sendEventToPosthog({
+              client: this.phClient,
+              distinctId: posthogDistinctId,
+              traceId,
+              model: openAIParams.model,
+              provider: 'openai',
+              input: openAIParams.input,
+              output: result.output,
+              latency,
+              baseURL: (this as any).baseURL ?? '',
+              params: body,
+              httpStatus: 200,
+              usage: {
+                inputTokens: result.usage?.input_tokens ?? 0,
+                outputTokens: result.usage?.output_tokens ?? 0,
+                reasoningTokens: result.usage?.output_tokens_details?.reasoning_tokens ?? 0,
+                cacheReadInputTokens: result.usage?.input_tokens_details?.cached_tokens ?? 0,
+              },
+              captureImmediate: posthogCaptureImmediate,
+            })
+          }
+          return result
+        },
+        async (error: any) => {
+          await sendEventToPosthog({
+            client: this.phClient,
+            distinctId: posthogDistinctId,
+            traceId,
+            model: openAIParams.model,
+            provider: 'openai',
+            input: openAIParams.input,
+            output: [],
+            latency: 0,
+            baseURL: (this as any).baseURL ?? '',
+            params: body,
+            httpStatus: error?.status ? error.status : 500,
+            usage: {
+              inputTokens: 0,
+              outputTokens: 0,
+            },
+            isError: true,
+            error: JSON.stringify(error),
+            captureImmediate: posthogCaptureImmediate,
+          })
+          throw error
+        }
+      ) as APIPromise<OpenAIOrignal.Responses.Response>
+
+      return wrappedPromise
+    }
+  }
+
+  public parse<Params extends ResponsesCreateParamsBase, ParsedT = any>(
+    body: Params & MonitoringParams,
+    options?: RequestOptions
+  ): APIPromise<ParsedResponse<ParsedT>> {
+    const {
+      posthogDistinctId,
+      posthogTraceId,
+      posthogProperties,
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      posthogPrivacyMode = false,
+      posthogGroups,
+      posthogCaptureImmediate,
+      ...openAIParams
+    } = body
+
+    const traceId = posthogTraceId ?? uuidv4()
+    const startTime = Date.now()
+
+    // Create a temporary instance that bypasses our wrapped create method
+    const originalCreate = super.create.bind(this)
+    const originalSelf = this as any
+    const tempCreate = originalSelf.create
+    originalSelf.create = originalCreate
+
+    try {
+      const parentPromise = super.parse(openAIParams, options)
+
+      const wrappedPromise = parentPromise.then(
+        async (result) => {
+          const latency = (Date.now() - startTime) / 1000
+          await sendEventToPosthog({
+            client: this.phClient,
+            distinctId: posthogDistinctId,
+            traceId,
+            model: openAIParams.model,
+            provider: 'openai',
+            input: openAIParams.input,
+            output: result.output,
+            latency,
+            baseURL: (this as any).baseURL ?? '',
+            params: body,
+            httpStatus: 200,
+            usage: {
+              inputTokens: result.usage?.input_tokens ?? 0,
+              outputTokens: result.usage?.output_tokens ?? 0,
+              reasoningTokens: result.usage?.output_tokens_details?.reasoning_tokens ?? 0,
+              cacheReadInputTokens: result.usage?.input_tokens_details?.cached_tokens ?? 0,
+            },
+            captureImmediate: posthogCaptureImmediate,
+          })
+          return result
+        },
+        async (error: any) => {
+          await sendEventToPosthog({
+            client: this.phClient,
+            distinctId: posthogDistinctId,
+            traceId,
+            model: openAIParams.model,
+            provider: 'openai',
+            input: openAIParams.input,
+            output: [],
+            latency: 0,
+            baseURL: (this as any).baseURL ?? '',
+            params: body,
+            httpStatus: error?.status ? error.status : 500,
+            usage: {
+              inputTokens: 0,
+              outputTokens: 0,
+            },
+            isError: true,
+            error: JSON.stringify(error),
+            captureImmediate: posthogCaptureImmediate,
+          })
+          throw error
+        }
+      )
+
+      return wrappedPromise as APIPromise<ParsedResponse<ParsedT>>
+    } finally {
+      // Restore our wrapped create method
+      originalSelf.create = tempCreate
+    }
+  }
+}
+
 export default PostHogOpenAI
 
 export { PostHogOpenAI as OpenAI }

package/src/utils.ts

@@ -5,6 +5,7 @@ import AnthropicOriginal from '@anthropic-ai/sdk'
 
 type ChatCompletionCreateParamsBase = OpenAIOrignal.Chat.Completions.ChatCompletionCreateParams
 type MessageCreateParams = AnthropicOriginal.Messages.MessageCreateParams
+type ResponseCreateParams = OpenAIOrignal.Responses.ResponseCreateParams
 
 // limit large outputs by truncating to 200kb (approx 200k bytes)
 export const MAX_OUTPUT_SIZE = 200000
@@ -28,7 +29,7 @@ export interface CostOverride {
 }
 
 export const getModelParams = (
-  params: ((ChatCompletionCreateParamsBase | MessageCreateParams) & MonitoringParams) | null
+  params: ((ChatCompletionCreateParamsBase | MessageCreateParams | ResponseCreateParams) & MonitoringParams) | null
 ): Record<string, any> => {
   if (!params) {
     return {}
@@ -178,7 +179,7 @@ export type SendEventToPosthogParams = {
     cacheReadInputTokens?: any
     cacheCreationInputTokens?: any
   }
-  params: (ChatCompletionCreateParamsBase | MessageCreateParams) & MonitoringParams
+  params: (ChatCompletionCreateParamsBase | MessageCreateParams | ResponseCreateParams) & MonitoringParams
   isError?: boolean
   error?: string
   tools?: any

package/src/vercel/middleware.ts

@@ -18,8 +18,8 @@ interface ClientOptions {
 }
 
 interface CreateInstrumentationMiddlewareOptions {
-  posthogDistinctId: string
-  posthogTraceId: string
+  posthogDistinctId?: string
+  posthogTraceId?: string
   posthogProperties?: Record<string, any>
   posthogPrivacyMode?: boolean
   posthogGroups?: Record<string, any>
@@ -229,7 +229,7 @@ export const createInstrumentationMiddleware = (
         await sendEventToPosthog({
           client: phClient,
           distinctId: options.posthogDistinctId,
-          traceId: options.posthogTraceId,
+          traceId: options.posthogTraceId ?? uuidv4(),
           model: modelId,
           provider: provider,
           input: options.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
@@ -252,7 +252,7 @@ export const createInstrumentationMiddleware = (
         await sendEventToPosthog({
           client: phClient,
           distinctId: options.posthogDistinctId,
-          traceId: options.posthogTraceId,
+          traceId: options.posthogTraceId ?? uuidv4(),
           model: modelId,
           provider: model.provider,
           input: options.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
@@ -324,7 +324,7 @@ export const createInstrumentationMiddleware = (
             await sendEventToPosthog({
               client: phClient,
               distinctId: options.posthogDistinctId,
-              traceId: options.posthogTraceId,
+              traceId: options.posthogTraceId ?? uuidv4(),
               model: modelId,
               provider: provider,
               input: options.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
@@ -347,7 +347,7 @@ export const createInstrumentationMiddleware = (
         await sendEventToPosthog({
           client: phClient,
           distinctId: options.posthogDistinctId,
-          traceId: options.posthogTraceId,
+          traceId: options.posthogTraceId ?? uuidv4(),
           model: modelId,
           provider: provider,
           input: options.posthogPrivacyMode ? '' : mapVercelPrompt(params.prompt),
@@ -381,7 +381,7 @@ export const wrapVercelLanguageModel = (
   const middleware = createInstrumentationMiddleware(phClient, model, {
     ...options,
     posthogTraceId: traceId,
-    posthogDistinctId: options.posthogDistinctId ?? traceId,
+    posthogDistinctId: options.posthogDistinctId,
   })
 
   const wrappedModel = wrapLanguageModel({

package/tests/gemini.test.ts

@@ -310,4 +310,35 @@ describe('PostHogGemini - Jest test suite', () => {
     expect(vertexClient).toBeInstanceOf(PostHogGemini)
     expect(vertexClient.models).toBeDefined()
   })
+
+  conditionalTest('anonymous user - $process_person_profile set to false', async () => {
+    await client.models.generateContent({
+      model: 'gemini-2.0-flash-001',
+      contents: 'Hello',
+      posthogTraceId: 'trace-123',
+    })
+
+    expect(mockPostHogClient.capture).toHaveBeenCalledTimes(1)
+    const [captureArgs] = (mockPostHogClient.capture as jest.Mock).mock.calls
+    const { distinctId, properties } = captureArgs[0]
+
+    expect(distinctId).toBe('trace-123')
+    expect(properties['$process_person_profile']).toBe(false)
+  })
+
+  conditionalTest('identified user - $process_person_profile not set', async () => {
+    await client.models.generateContent({
+      model: 'gemini-2.0-flash-001',
+      contents: 'Hello',
+      posthogDistinctId: 'user-456',
+      posthogTraceId: 'trace-123',
+    })
+
+    expect(mockPostHogClient.capture).toHaveBeenCalledTimes(1)
+    const [captureArgs] = (mockPostHogClient.capture as jest.Mock).mock.calls
+    const { distinctId, properties } = captureArgs[0]
+
+    expect(distinctId).toBe('user-456')
+    expect(properties['$process_person_profile']).toBeUndefined()
+  })
 })