@posthog/ai 7.21.0 → 8.0.1

package/dist/openai/index.d.ts

@@ -1,4 +1,4 @@
-import { OpenAI, APIPromise, ClientOptions } from 'openai';
+import OpenAIOrignal, { AzureOpenAI, APIPromise, OpenAI, ClientOptions } from 'openai';
 import { PostHog } from 'posthog-node';
 import { Stream } from 'openai/streaming';
 import { ParsedResponse } from 'openai/resources/responses/responses';
@@ -24,6 +24,44 @@ interface CostOverride {
     outputCost: number;
 }
 
+type ChatCompletion$1 = OpenAIOrignal.ChatCompletion;
+type ChatCompletionChunk$1 = OpenAIOrignal.ChatCompletionChunk;
+type ChatCompletionCreateParamsBase$1 = OpenAIOrignal.Chat.Completions.ChatCompletionCreateParams;
+type ChatCompletionCreateParamsNonStreaming$1 = OpenAIOrignal.Chat.Completions.ChatCompletionCreateParamsNonStreaming;
+type ChatCompletionCreateParamsStreaming$1 = OpenAIOrignal.Chat.Completions.ChatCompletionCreateParamsStreaming;
+type CreateEmbeddingResponse$1 = OpenAIOrignal.CreateEmbeddingResponse;
+type EmbeddingCreateParams$1 = OpenAIOrignal.EmbeddingCreateParams;
+interface MonitoringOpenAIConfig$1 {
+    apiKey: string;
+    posthog: PostHog;
+    baseURL?: string;
+}
+type RequestOptions$1 = Record<string, any>;
+declare class PostHogAzureOpenAI extends AzureOpenAI {
+    private readonly phClient;
+    chat: WrappedChat$1;
+    embeddings: WrappedEmbeddings$1;
+    constructor(config: MonitoringOpenAIConfig$1);
+}
+declare class WrappedChat$1 extends AzureOpenAI.Chat {
+    constructor(parentClient: PostHogAzureOpenAI, phClient: PostHog);
+    completions: WrappedCompletions$1;
+}
+declare class WrappedCompletions$1 extends AzureOpenAI.Chat.Completions {
+    private readonly phClient;
+    private readonly baseURL;
+    constructor(client: AzureOpenAI, phClient: PostHog);
+    create(body: ChatCompletionCreateParamsNonStreaming$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<ChatCompletion$1>;
+    create(body: ChatCompletionCreateParamsStreaming$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<Stream<ChatCompletionChunk$1>>;
+    create(body: ChatCompletionCreateParamsBase$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<ChatCompletion$1 | Stream<ChatCompletionChunk$1>>;
+}
+declare class WrappedEmbeddings$1 extends AzureOpenAI.Embeddings {
+    private readonly phClient;
+    private readonly baseURL;
+    constructor(client: AzureOpenAI, phClient: PostHog);
+    create(body: EmbeddingCreateParams$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<CreateEmbeddingResponse$1>;
+}
+
 declare const Chat: typeof OpenAI.Chat;
 declare const Completions: typeof OpenAI.Chat.Completions;
 declare const Responses: typeof OpenAI.Responses;
@@ -98,4 +136,4 @@ declare class WrappedTranscriptions extends Transcriptions {
     create(body: OpenAI.Audio.Transcriptions.TranscriptionCreateParams & MonitoringParams, options?: RequestOptions): APIPromise<OpenAI.Audio.Transcriptions.TranscriptionCreateResponse | string | Stream<OpenAI.Audio.Transcriptions.TranscriptionStreamEvent>>;
 }
 
-export { PostHogOpenAI as OpenAI, PostHogOpenAI, WrappedAudio, WrappedChat, WrappedCompletions, WrappedEmbeddings, WrappedResponses, WrappedTranscriptions, PostHogOpenAI as default };
+export { PostHogAzureOpenAI as AzureOpenAI, PostHogOpenAI as OpenAI, PostHogOpenAI, WrappedAudio, WrappedChat, WrappedCompletions, WrappedEmbeddings, WrappedResponses, WrappedTranscriptions, PostHogOpenAI as default };

package/dist/openai/index.mjs

@@ -1,4 +1,4 @@
-import { OpenAI } from 'openai';
+import { AzureOpenAI, OpenAI } from 'openai';
 import { v4 } from 'uuid';
 import { uuidv7 } from '@posthog/core';
 
@@ -530,7 +530,7 @@ function formatOpenAIResponsesInput(input, instructions) {
   return messages;
 }
 
-var version = "7.21.0";
+var version = "8.0.1";
 
 const DEFAULT_MAX_DEPTH = 3;
 const MAX_STACK_LINES = 20;
@@ -755,6 +755,533 @@ function buildProviderMetadata(fields) {
   return Object.keys(metadata).length > 0 ? metadata : undefined;
 }
 
+class PostHogAzureOpenAI extends AzureOpenAI {
+  constructor(config) {
+    const {
+      posthog,
+      ...openAIConfig
+    } = config;
+    super(openAIConfig);
+    this.phClient = posthog;
+    this.chat = new WrappedChat$1(this, this.phClient);
+    this.embeddings = new WrappedEmbeddings$1(this, this.phClient);
+  }
+}
+let WrappedChat$1 = class WrappedChat extends AzureOpenAI.Chat {
+  constructor(parentClient, phClient) {
+    super(parentClient);
+    this.completions = new WrappedCompletions$1(parentClient, phClient);
+  }
+};
+let WrappedCompletions$1 = class WrappedCompletions extends AzureOpenAI.Chat.Completions {
+  constructor(client, phClient) {
+    super(client);
+    this.phClient = phClient;
+    this.baseURL = client.baseURL;
+  }
+
+  // --- Overload #1: Non-streaming
+
+  // --- Overload #2: Streaming
+
+  // --- Overload #3: Generic base
+
+  // --- Implementation Signature
+  create(body, options) {
+    const {
+      providerParams: openAIParams,
+      posthogParams
+    } = extractPosthogParams(body);
+    const startTime = Date.now();
+    const parentPromise = super.create(openAIParams, options);
+    if (openAIParams.stream) {
+      return parentPromise.then(value => {
+        if ('tee' in value) {
+          const [stream1, stream2] = value.tee();
+          (async () => {
+            // Hoisted so the catch block can surface whatever was accumulated
+            // from the streamed chunks before the failure.
+            let completionIdFromResponse;
+            let systemFingerprintFromResponse;
+            try {
+              const contentBlocks = [];
+              let accumulatedContent = '';
+              let modelFromResponse;
+              let firstTokenTime;
+              let usage = {
+                inputTokens: 0,
+                outputTokens: 0
+              };
+
+              // Map to track in-progress tool calls
+              const toolCallsInProgress = new Map();
+              for await (const chunk of stream1) {
+                // Extract model and completion metadata from chunk (Chat Completions chunks carry these fields)
+                if (!modelFromResponse && chunk.model) {
+                  modelFromResponse = chunk.model;
+                }
+                if (!completionIdFromResponse && chunk.id) {
+                  completionIdFromResponse = chunk.id;
+                }
+                if (!systemFingerprintFromResponse && chunk.system_fingerprint) {
+                  systemFingerprintFromResponse = chunk.system_fingerprint;
+                }
+                const choice = chunk?.choices?.[0];
+
+                // Handle text content
+                const deltaContent = choice?.delta?.content;
+                if (deltaContent) {
+                  if (firstTokenTime === undefined) {
+                    firstTokenTime = Date.now();
+                  }
+                  accumulatedContent += deltaContent;
+                }
+
+                // Handle tool calls
+                const deltaToolCalls = choice?.delta?.tool_calls;
+                if (deltaToolCalls && Array.isArray(deltaToolCalls)) {
+                  if (firstTokenTime === undefined) {
+                    firstTokenTime = Date.now();
+                  }
+                  for (const toolCall of deltaToolCalls) {
+                    const index = toolCall.index;
+                    if (index !== undefined) {
+                      if (!toolCallsInProgress.has(index)) {
+                        // New tool call
+                        toolCallsInProgress.set(index, {
+                          id: toolCall.id || '',
+                          name: toolCall.function?.name || '',
+                          arguments: ''
+                        });
+                      }
+                      const inProgressCall = toolCallsInProgress.get(index);
+                      if (inProgressCall) {
+                        // Update tool call data
+                        if (toolCall.id) {
+                          inProgressCall.id = toolCall.id;
+                        }
+                        if (toolCall.function?.name) {
+                          inProgressCall.name = toolCall.function.name;
+                        }
+                        if (toolCall.function?.arguments) {
+                          inProgressCall.arguments += toolCall.function.arguments;
+                        }
+                      }
+                    }
+                  }
+                }
+
+                // Handle usage information
+                if (chunk.usage) {
+                  usage = {
+                    inputTokens: chunk.usage.prompt_tokens ?? 0,
+                    outputTokens: chunk.usage.completion_tokens ?? 0,
+                    reasoningTokens: chunk.usage.completion_tokens_details?.reasoning_tokens ?? 0,
+                    cacheReadInputTokens: chunk.usage.prompt_tokens_details?.cached_tokens ?? 0
+                  };
+                }
+              }
+
+              // Build final content blocks
+              if (accumulatedContent) {
+                contentBlocks.push({
+                  type: 'text',
+                  text: accumulatedContent
+                });
+              }
+
+              // Add completed tool calls to content blocks
+              for (const toolCall of toolCallsInProgress.values()) {
+                if (toolCall.name) {
+                  contentBlocks.push({
+                    type: 'function',
+                    id: toolCall.id,
+                    function: {
+                      name: toolCall.name,
+                      arguments: toolCall.arguments
+                    }
+                  });
+                }
+              }
+
+              // Format output to match non-streaming version
+              const formattedOutput = contentBlocks.length > 0 ? [{
+                role: 'assistant',
+                content: contentBlocks
+              }] : [{
+                role: 'assistant',
+                content: [{
+                  type: 'text',
+                  text: ''
+                }]
+              }];
+              const latency = (Date.now() - startTime) / 1000;
+              const timeToFirstToken = firstTokenTime !== undefined ? (firstTokenTime - startTime) / 1000 : undefined;
+              await captureAiGeneration(this.phClient, {
+                ...posthogParams,
+                model: openAIParams.model ?? modelFromResponse,
+                provider: 'azure',
+                input: sanitizeOpenAI(openAIParams.messages),
+                output: formattedOutput,
+                latency,
+                timeToFirstToken,
+                baseURL: this.baseURL,
+                modelParameters: getModelParams(body),
+                httpStatus: 200,
+                usage,
+                completionId: completionIdFromResponse,
+                providerMetadata: buildProviderMetadata({
+                  systemFingerprint: systemFingerprintFromResponse
+                })
+              });
+            } catch (error) {
+              await captureAiGeneration(this.phClient, {
+                ...posthogParams,
+                model: openAIParams.model,
+                provider: 'azure',
+                input: sanitizeOpenAI(openAIParams.messages),
+                output: [],
+                latency: 0,
+                baseURL: this.baseURL,
+                modelParameters: getModelParams(body),
+                usage: {
+                  inputTokens: 0,
+                  outputTokens: 0
+                },
+                // If the stream fails mid-flight, surface whatever completion
+                // metadata the consumed chunks already provided so the error
+                // event can still be correlated to OpenAI's Logs dashboard.
+                completionId: completionIdFromResponse,
+                providerMetadata: buildProviderMetadata({
+                  systemFingerprint: systemFingerprintFromResponse
+                }),
+                error: error
+              });
+              throw error;
+            }
+          })();
+
+          // Return the other stream to the user
+          return stream2;
+        }
+        return value;
+      });
+    } else {
+      const wrappedPromise = parentPromise.then(async result => {
+        if ('choices' in result) {
+          const latency = (Date.now() - startTime) / 1000;
+          await captureAiGeneration(this.phClient, {
+            ...posthogParams,
+            model: openAIParams.model ?? result.model,
+            provider: 'azure',
+            input: openAIParams.messages,
+            output: formatResponseOpenAI(result),
+            latency,
+            baseURL: this.baseURL,
+            modelParameters: getModelParams(body),
+            httpStatus: 200,
+            usage: {
+              inputTokens: result.usage?.prompt_tokens ?? 0,
+              outputTokens: result.usage?.completion_tokens ?? 0,
+              reasoningTokens: result.usage?.completion_tokens_details?.reasoning_tokens ?? 0,
+              cacheReadInputTokens: result.usage?.prompt_tokens_details?.cached_tokens ?? 0
+            },
+            completionId: result.id,
+            providerMetadata: buildProviderMetadata({
+              systemFingerprint: result.system_fingerprint,
+              requestId: extractRequestId(result)
+            })
+          });
+        }
+        return result;
+      }, async error => {
+        const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
+        await captureAiGeneration(this.phClient, {
+          ...posthogParams,
+          model: openAIParams.model,
+          provider: 'azure',
+          input: openAIParams.messages,
+          output: [],
+          latency: 0,
+          baseURL: this.baseURL,
+          modelParameters: getModelParams(body),
+          httpStatus,
+          usage: {
+            inputTokens: 0,
+            outputTokens: 0
+          },
+          error
+        });
+        throw error;
+      });
+      return wrappedPromise;
+    }
+  }
+};
+let WrappedResponses$1 = class WrappedResponses extends AzureOpenAI.Responses {
+  constructor(client, phClient) {
+    super(client);
+    this.phClient = phClient;
+    this.baseURL = client.baseURL;
+  }
+
+  // --- Overload #1: Non-streaming
+
+  // --- Overload #2: Streaming
+
+  // --- Overload #3: Generic base
+
+  // --- Implementation Signature
+  create(body, options) {
+    const {
+      providerParams: openAIParams,
+      posthogParams
+    } = extractPosthogParams(body);
+    const startTime = Date.now();
+    const parentPromise = 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 () => {
+            // Hoisted so the catch block can surface the completion ID that
+            // was accumulated from the streamed chunks before the failure.
+            let completionIdFromResponse;
+            try {
+              let finalContent = [];
+              let modelFromResponse;
+              let firstTokenTime;
+              let usage = {
+                inputTokens: 0,
+                outputTokens: 0
+              };
+              for await (const chunk of stream1) {
+                // Track first token time on content delta events
+                if (firstTokenTime === undefined && isResponseTokenChunk(chunk)) {
+                  firstTokenTime = Date.now();
+                }
+                if ('response' in chunk && chunk.response) {
+                  // Extract model and completion ID from the response object in the chunk (for stored prompts)
+                  if (!modelFromResponse && chunk.response.model) {
+                    modelFromResponse = chunk.response.model;
+                  }
+                  if (!completionIdFromResponse && chunk.response.id) {
+                    completionIdFromResponse = chunk.response.id;
+                  }
+                }
+                if (chunk.type === 'response.completed' && 'response' in chunk && chunk.response?.output && chunk.response.output.length > 0) {
+                  finalContent = chunk.response.output;
+                }
+                if ('usage' in chunk && chunk.usage) {
+                  usage = {
+                    inputTokens: chunk.usage.input_tokens ?? 0,
+                    outputTokens: chunk.usage.output_tokens ?? 0,
+                    reasoningTokens: chunk.usage.output_tokens_details?.reasoning_tokens ?? 0,
+                    cacheReadInputTokens: chunk.usage.input_tokens_details?.cached_tokens ?? 0
+                  };
+                }
+              }
+              const latency = (Date.now() - startTime) / 1000;
+              const timeToFirstToken = firstTokenTime !== undefined ? (firstTokenTime - startTime) / 1000 : undefined;
+              await captureAiGeneration(this.phClient, {
+                ...posthogParams,
+                model: openAIParams.model ?? modelFromResponse,
+                provider: 'azure',
+                input: formatOpenAIResponsesInput(openAIParams.input, openAIParams.instructions),
+                output: finalContent,
+                latency,
+                timeToFirstToken,
+                baseURL: this.baseURL,
+                modelParameters: getModelParams(body),
+                httpStatus: 200,
+                usage,
+                completionId: completionIdFromResponse
+              });
+            } catch (error) {
+              await captureAiGeneration(this.phClient, {
+                ...posthogParams,
+                model: openAIParams.model,
+                provider: 'azure',
+                input: formatOpenAIResponsesInput(openAIParams.input, openAIParams.instructions),
+                output: [],
+                latency: 0,
+                baseURL: this.baseURL,
+                modelParameters: getModelParams(body),
+                usage: {
+                  inputTokens: 0,
+                  outputTokens: 0
+                },
+                // Surface the completion ID from any chunks consumed before
+                // the stream failed so the error event remains correlatable.
+                completionId: completionIdFromResponse,
+                error: error
+              });
+              throw error;
+            }
+          })();
+          return stream2;
+        }
+        return value;
+      });
+    } else {
+      const wrappedPromise = parentPromise.then(async result => {
+        if ('output' in result) {
+          const latency = (Date.now() - startTime) / 1000;
+          await captureAiGeneration(this.phClient, {
+            ...posthogParams,
+            model: openAIParams.model ?? result.model,
+            provider: 'azure',
+            input: formatOpenAIResponsesInput(openAIParams.input, openAIParams.instructions),
+            output: result.output,
+            latency,
+            baseURL: this.baseURL,
+            modelParameters: getModelParams(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
+            },
+            completionId: result.id,
+            providerMetadata: buildProviderMetadata({
+              requestId: extractRequestId(result)
+            })
+          });
+        }
+        return result;
+      }, async error => {
+        const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
+        await captureAiGeneration(this.phClient, {
+          ...posthogParams,
+          model: openAIParams.model,
+          provider: 'azure',
+          input: formatOpenAIResponsesInput(openAIParams.input, openAIParams.instructions),
+          output: [],
+          latency: 0,
+          baseURL: this.baseURL,
+          modelParameters: getModelParams(body),
+          httpStatus,
+          usage: {
+            inputTokens: 0,
+            outputTokens: 0
+          },
+          error
+        });
+        throw error;
+      });
+      return wrappedPromise;
+    }
+  }
+  parse(body, options) {
+    const {
+      providerParams: openAIParams,
+      posthogParams
+    } = extractPosthogParams(body);
+    const startTime = Date.now();
+    const parentPromise = super.parse(openAIParams, options);
+    const wrappedPromise = parentPromise.then(async result => {
+      const latency = (Date.now() - startTime) / 1000;
+      await captureAiGeneration(this.phClient, {
+        ...posthogParams,
+        model: openAIParams.model ?? result.model,
+        provider: 'azure',
+        input: formatOpenAIResponsesInput(openAIParams.input, openAIParams.instructions),
+        output: result.output,
+        latency,
+        baseURL: this.baseURL,
+        modelParameters: getModelParams(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
+        },
+        completionId: result.id,
+        providerMetadata: buildProviderMetadata({
+          requestId: extractRequestId(result)
+        })
+      });
+      return result;
+    }, async error => {
+      await captureAiGeneration(this.phClient, {
+        ...posthogParams,
+        model: openAIParams.model,
+        provider: 'azure',
+        input: formatOpenAIResponsesInput(openAIParams.input, openAIParams.instructions),
+        output: [],
+        latency: 0,
+        baseURL: this.baseURL,
+        modelParameters: getModelParams(body),
+        httpStatus: error?.status ? error.status : 500,
+        usage: {
+          inputTokens: 0,
+          outputTokens: 0
+        },
+        error
+      });
+      throw error;
+    });
+    return wrappedPromise;
+  }
+};
+let WrappedEmbeddings$1 = class WrappedEmbeddings extends AzureOpenAI.Embeddings {
+  constructor(client, phClient) {
+    super(client);
+    this.phClient = phClient;
+    this.baseURL = client.baseURL;
+  }
+  create(body, options) {
+    const {
+      providerParams: openAIParams,
+      posthogParams
+    } = extractPosthogParams(body);
+    const startTime = Date.now();
+    const parentPromise = super.create(openAIParams, options);
+    const wrappedPromise = parentPromise.then(async result => {
+      const latency = (Date.now() - startTime) / 1000;
+      await captureAiGeneration(this.phClient, {
+        eventType: AIEvent.Embedding,
+        ...posthogParams,
+        model: openAIParams.model,
+        provider: 'azure',
+        input: withPrivacyMode(this.phClient, posthogParams.privacyMode, openAIParams.input),
+        output: null,
+        // Embeddings don't have output content
+        latency,
+        baseURL: this.baseURL,
+        modelParameters: getModelParams(body),
+        httpStatus: 200,
+        usage: {
+          inputTokens: result.usage?.prompt_tokens ?? 0
+        }
+      });
+      return result;
+    }, async error => {
+      const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
+      await captureAiGeneration(this.phClient, {
+        eventType: AIEvent.Embedding,
+        ...posthogParams,
+        model: openAIParams.model,
+        provider: 'azure',
+        input: withPrivacyMode(this.phClient, posthogParams.privacyMode, openAIParams.input),
+        output: null,
+        latency: 0,
+        baseURL: this.baseURL,
+        modelParameters: getModelParams(body),
+        httpStatus,
+        usage: {
+          inputTokens: 0
+        },
+        error
+      });
+      throw error;
+    });
+    return wrappedPromise;
+  }
+};
+
 const Chat = OpenAI.Chat;
 const Completions = Chat.Completions;
 const Responses = OpenAI.Responses;
@@ -1538,5 +2065,5 @@ class WrappedTranscriptions extends Transcriptions {
   }
 }
 
-export { PostHogOpenAI as OpenAI, PostHogOpenAI, WrappedAudio, WrappedChat, WrappedCompletions, WrappedEmbeddings, WrappedResponses, WrappedTranscriptions, PostHogOpenAI as default };
+export { PostHogAzureOpenAI as AzureOpenAI, PostHogOpenAI as OpenAI, PostHogOpenAI, WrappedAudio, WrappedChat, WrappedCompletions, WrappedEmbeddings, WrappedResponses, WrappedTranscriptions, PostHogOpenAI as default };
 //# sourceMappingURL=index.mjs.map