@posthog/ai 8.6.5 → 8.6.7

package/dist/openai/index.d.ts

@@ -1,7 +1,7 @@
 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';
+import { ResponseRetrieveParamsNonStreaming, ResponseRetrieveParamsStreaming, ResponseRetrieveParamsBase, ParsedResponse } from 'openai/resources/responses/responses';
 import { ResponseCreateParamsWithTools, ExtractParsedContentFromParams } from 'openai/lib/ResponsesParser';
 import { AzureClientOptions } from 'openai/azure';
 
@@ -62,10 +62,16 @@ declare class WrappedCompletions$1 extends AzureOpenAI.Chat.Completions {
 declare class WrappedResponses$1 extends AzureOpenAI.Responses {
     private readonly phClient;
     private readonly baseURL;
+    private readonly backgroundResponses;
     constructor(client: AzureOpenAI, phClient: PostHog);
+    private captureBackgroundResponse;
     create(body: ResponsesCreateParamsNonStreaming$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<OpenAIOrignal.Responses.Response>;
     create(body: ResponsesCreateParamsStreaming$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<Stream<OpenAIOrignal.Responses.ResponseStreamEvent>>;
     create(body: ResponsesCreateParamsBase$1 & MonitoringParams, options?: RequestOptions$1): APIPromise<OpenAIOrignal.Responses.Response | Stream<OpenAIOrignal.Responses.ResponseStreamEvent>>;
+    retrieve(responseID: string, query?: ResponseRetrieveParamsNonStreaming, options?: RequestOptions$1): APIPromise<OpenAIOrignal.Responses.Response>;
+    retrieve(responseID: string, query: ResponseRetrieveParamsStreaming, options?: RequestOptions$1): APIPromise<Stream<OpenAIOrignal.Responses.ResponseStreamEvent>>;
+    retrieve(responseID: string, query?: ResponseRetrieveParamsBase, options?: RequestOptions$1): APIPromise<OpenAIOrignal.Responses.Response | Stream<OpenAIOrignal.Responses.ResponseStreamEvent>>;
+    cancel(responseID: string, options?: RequestOptions$1): APIPromise<OpenAIOrignal.Responses.Response>;
     parse<Params extends ResponseCreateParamsWithTools, ParsedT = ExtractParsedContentFromParams<Params>>(body: Params & MonitoringParams, options?: RequestOptions$1): APIPromise<ParsedResponse<ParsedT>>;
 }
 declare class WrappedEmbeddings$1 extends AzureOpenAI.Embeddings {
@@ -120,10 +126,16 @@ declare class WrappedCompletions extends Completions {
 declare class WrappedResponses extends Responses {
     private readonly phClient;
     private readonly baseURL;
+    private readonly backgroundResponses;
     constructor(client: OpenAI, phClient: PostHog);
+    private captureBackgroundResponse;
     create(body: ResponsesCreateParamsNonStreaming & MonitoringParams, options?: RequestOptions): APIPromise<OpenAI.Responses.Response>;
     create(body: ResponsesCreateParamsStreaming & MonitoringParams, options?: RequestOptions): APIPromise<Stream<OpenAI.Responses.ResponseStreamEvent>>;
     create(body: ResponsesCreateParamsBase & MonitoringParams, options?: RequestOptions): APIPromise<OpenAI.Responses.Response | Stream<OpenAI.Responses.ResponseStreamEvent>>;
+    retrieve(responseID: string, query?: ResponseRetrieveParamsNonStreaming, options?: RequestOptions): APIPromise<OpenAI.Responses.Response>;
+    retrieve(responseID: string, query: ResponseRetrieveParamsStreaming, options?: RequestOptions): APIPromise<Stream<OpenAI.Responses.ResponseStreamEvent>>;
+    retrieve(responseID: string, query?: ResponseRetrieveParamsBase, options?: RequestOptions): APIPromise<OpenAI.Responses.Response | Stream<OpenAI.Responses.ResponseStreamEvent>>;
+    cancel(responseID: string, options?: RequestOptions): APIPromise<OpenAI.Responses.Response>;
     parse<Params extends ResponseCreateParamsWithTools, ParsedT = ExtractParsedContentFromParams<Params>>(body: Params & MonitoringParams, options?: RequestOptions): APIPromise<ParsedResponse<ParsedT>>;
 }
 declare class WrappedEmbeddings extends Embeddings {

package/dist/openai/index.mjs

@@ -544,7 +544,7 @@ function formatOpenAIResponsesInput(input, instructions) {
   return messages;
 }
 
-var version = "8.6.5";
+var version = "8.6.7";
 
 const DEFAULT_MAX_DEPTH = 3;
 const MAX_STACK_LINES = 20;
@@ -742,7 +742,9 @@ const captureAiGeneration$1 = async (client, options) => {
         $ai_output_tokens: usage.outputTokens
       } : {}),
       ...additionalTokenValues,
-      $ai_latency: options.latency ?? 0,
+      ...(options.latency !== undefined ? {
+        $ai_latency: options.latency
+      } : {}),
       ...(options.timeToFirstToken !== undefined ? {
         $ai_time_to_first_token: options.timeToFirstToken
       } : {}),
@@ -883,6 +885,77 @@ function getResponseFailure(response) {
   } : new Error(`OpenAI response ${response.id} failed without error details`);
 }
 
+function isPendingBackgroundResponse(params, response) {
+  return params.background === true && !!response.status && !isTerminalResponse(response);
+}
+
+/**
+ * Uses provider timestamps so background polling cadence does not inflate
+ * generation latency. Non-completed responses do not expose a terminal time.
+ */
+function getBackgroundResponseLatency(response) {
+  if (typeof response.created_at !== 'number' || typeof response.completed_at !== 'number') {
+    return undefined;
+  }
+  return Math.max(0, response.completed_at - response.created_at);
+}
+
+/**
+ * Keeps the original create context available while a background response is
+ * polled. Entries are insertion ordered, so the oldest context is discarded
+ * when the bound is reached.
+ */
+class BackgroundResponseTracker {
+  contexts = new Map();
+  constructor(maxEntries = 1000) {
+    this.maxEntries = maxEntries;
+  }
+  set(responseID, context) {
+    // Refresh an existing response's insertion order.
+    this.contexts.delete(responseID);
+    this.contexts.set(responseID, context);
+    while (this.contexts.size > this.maxEntries) {
+      const oldestResponseID = this.contexts.keys().next().value;
+      if (oldestResponseID === undefined) {
+        break;
+      }
+      this.contexts.delete(oldestResponseID);
+    }
+  }
+  get(responseID) {
+    return this.contexts.get(responseID);
+  }
+  take(responseID) {
+    const context = this.contexts.get(responseID);
+    if (context !== undefined) {
+      this.contexts.delete(responseID);
+    }
+    return context;
+  }
+}
+
+/**
+ * Inspects a streamed background retrieval without consuming it on the
+ * caller's behalf. The stored create context is consumed only by a terminal
+ * response; an interrupted or nonterminal stream may be followed by another
+ * retrieval while the background job continues.
+ */
+function wrapBackgroundResponseStream(stream, responseID, tracker, captureTerminalResponse) {
+  async function* inspectStream() {
+    for await (const event of stream) {
+      if ('response' in event && isTerminalResponse(event.response)) {
+        const context = tracker.take(responseID);
+        if (context) {
+          // Monitoring must not delay or disrupt delivery of the provider stream.
+          void captureTerminalResponse(event.response, context).catch(() => undefined);
+        }
+      }
+      yield event;
+    }
+  }
+  return new Stream(() => inspectStream(), stream.controller);
+}
+
 function addRequestId(result, response, requestIdHeader) {
   if (!result || typeof result !== 'object' || Array.isArray(result)) {
     return result;
@@ -1462,11 +1535,43 @@ let WrappedCompletions$1 = class WrappedCompletions extends AzureOpenAI.Chat.Com
   }
 };
 let WrappedResponses$1 = class WrappedResponses extends AzureOpenAI.Responses {
+  backgroundResponses = new BackgroundResponseTracker();
   constructor(client, phClient) {
     super(client);
     this.phClient = phClient;
     this.baseURL = client.baseURL;
   }
+  async captureBackgroundResponse(result, context) {
+    const {
+      openAIParams,
+      posthogParams
+    } = context;
+    await captureAiGeneration(this.phClient, {
+      ...posthogParams,
+      model: openAIParams.model ?? result.model,
+      provider: 'azure',
+      input: formatOpenAIResponsesInput(openAIParams.input, openAIParams.instructions),
+      output: result.output,
+      latency: getBackgroundResponseLatency(result),
+      baseURL: this.baseURL,
+      modelParameters: getModelParams(openAIParams, result.service_tier),
+      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,
+        rawUsage: result.usage
+      },
+      stopReason: result.status ?? undefined,
+      completionId: result.id,
+      providerMetadata: buildProviderMetadata({
+        requestId: extractRequestId(result),
+        incompleteDetails: result.incomplete_details
+      }),
+      error: getResponseFailure(result)
+    });
+  }
 
   // --- Overload #1: Non-streaming
 
@@ -1513,6 +1618,12 @@ let WrappedResponses$1 = class WrappedResponses extends AzureOpenAI.Responses {
                   if (!completionIdFromResponse && chunk.response.id) {
                     completionIdFromResponse = chunk.response.id;
                   }
+                  if (openAIParams.background === true && !this.backgroundResponses.get(chunk.response.id)) {
+                    this.backgroundResponses.set(chunk.response.id, {
+                      openAIParams,
+                      posthogParams
+                    });
+                  }
                   if (chunk.response.service_tier != null) {
                     serviceTierFromResponse = chunk.response.service_tier;
                   }
@@ -1530,6 +1641,15 @@ let WrappedResponses$1 = class WrappedResponses extends AzureOpenAI.Responses {
                   };
                 }
               }
+              if (openAIParams.background === true) {
+                if (terminalResponse) {
+                  const context = this.backgroundResponses.take(terminalResponse.id);
+                  if (context) {
+                    await this.captureBackgroundResponse(terminalResponse, context).catch(() => undefined);
+                  }
+                }
+                return;
+              }
               const latency = (Date.now() - startTime) / 1000;
               const timeToFirstToken = firstTokenTime !== undefined ? (firstTokenTime - startTime) / 1000 : undefined;
               await captureAiGeneration(this.phClient, {
@@ -1552,6 +1672,9 @@ let WrappedResponses$1 = class WrappedResponses extends AzureOpenAI.Responses {
                 error: getResponseFailure(terminalResponse)
               });
             } catch (error) {
+              if (openAIParams.background === true && completionIdFromResponse && this.backgroundResponses.get(completionIdFromResponse)) {
+                throw error;
+              }
               await captureAiGeneration(this.phClient, {
                 ...posthogParams,
                 model: openAIParams.model,
@@ -1584,6 +1707,13 @@ let WrappedResponses$1 = class WrappedResponses extends AzureOpenAI.Responses {
     } else {
       const wrappedPromise = parentPromise.then(async result => {
         if ('output' in result) {
+          if (isPendingBackgroundResponse(openAIParams, result)) {
+            this.backgroundResponses.set(result.id, {
+              openAIParams,
+              posthogParams
+            });
+            return result;
+          }
           const latency = (Date.now() - startTime) / 1000;
           await captureAiGeneration(this.phClient, {
             ...posthogParams,
@@ -1599,7 +1729,8 @@ let WrappedResponses$1 = class WrappedResponses extends AzureOpenAI.Responses {
               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
+              cacheReadInputTokens: result.usage?.input_tokens_details?.cached_tokens ?? 0,
+              rawUsage: result.usage
             },
             stopReason: result.status ?? undefined,
             completionId: result.id,
@@ -1634,6 +1765,55 @@ let WrappedResponses$1 = class WrappedResponses extends AzureOpenAI.Responses {
       return preserveProviderPromise(parentPromise, wrappedPromise);
     }
   }
+  retrieve(responseID, query = {}, options) {
+    const parentPromise = super.retrieve(responseID, query, options);
+
+    // Preserve the upstream promise and stream unchanged for responses that
+    // were not created through this client.
+    if (!this.backgroundResponses.get(responseID)) {
+      return parentPromise;
+    }
+    if (query.stream) {
+      return parentPromise._thenUnwrap(result => {
+        if ('controller' in result) {
+          return wrapBackgroundResponseStream(result, responseID, this.backgroundResponses, (response, context) => this.captureBackgroundResponse(response, context));
+        }
+        return result;
+      });
+    }
+    return parentPromise._thenUnwrap(async result => {
+      if (!('output' in result) || !isTerminalResponse(result)) {
+        return result;
+      }
+
+      // Removing the context before capture makes concurrent or repeated
+      // terminal polls idempotent.
+      const context = this.backgroundResponses.take(responseID);
+      if (context) {
+        await this.captureBackgroundResponse(result, context).catch(() => undefined);
+      }
+      return result;
+    });
+  }
+  cancel(responseID, options) {
+    const parentPromise = super.cancel(responseID, options);
+
+    // Avoid wrapping calls that do not belong to a background response created
+    // through this client, preserving the upstream APIPromise unchanged.
+    if (!this.backgroundResponses.get(responseID)) {
+      return parentPromise;
+    }
+    return parentPromise._thenUnwrap(async result => {
+      if (!isTerminalResponse(result)) {
+        return result;
+      }
+      const context = this.backgroundResponses.take(responseID);
+      if (context) {
+        await this.captureBackgroundResponse(result, context).catch(() => undefined);
+      }
+      return result;
+    });
+  }
   parse(body, options) {
     const {
       providerParams: openAIParams,
@@ -1642,6 +1822,13 @@ let WrappedResponses$1 = class WrappedResponses extends AzureOpenAI.Responses {
     const startTime = Date.now();
     const parentPromise = callWithOriginalCreate(this, super.create.bind(this), () => super.parse(openAIParams, options));
     const wrappedPromise = parentPromise.then(async result => {
+      if (isPendingBackgroundResponse(openAIParams, result)) {
+        this.backgroundResponses.set(result.id, {
+          openAIParams,
+          posthogParams
+        });
+        return result;
+      }
       const latency = (Date.now() - startTime) / 1000;
       await captureAiGeneration(this.phClient, {
         ...posthogParams,
@@ -1657,7 +1844,8 @@ let WrappedResponses$1 = class WrappedResponses extends AzureOpenAI.Responses {
           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
+          cacheReadInputTokens: result.usage?.input_tokens_details?.cached_tokens ?? 0,
+          rawUsage: result.usage
         },
         stopReason: result.status ?? undefined,
         completionId: result.id,
@@ -1763,9 +1951,6 @@ async function captureAiGenerationAfterSuccess(...args) {
     captureAiGenerationInBackground(...args);
   }
 }
-function isPendingBackgroundResponse(params, response) {
-  return params.background === true && !response.usage && !!response.status && !isTerminalResponse(response);
-}
 class PostHogOpenAI extends OpenAI {
   constructor(config) {
     const {
@@ -2068,11 +2253,47 @@ class WrappedCompletions extends Completions {
   }
 }
 class WrappedResponses extends Responses {
+  backgroundResponses = new BackgroundResponseTracker();
   constructor(client, phClient) {
     super(client);
     this.phClient = phClient;
     this.baseURL = client.baseURL;
   }
+  async captureBackgroundResponse(result, context) {
+    const {
+      openAIParams,
+      posthogParams
+    } = context;
+    await captureAiGenerationAfterSuccess(this.phClient, {
+      ...posthogParams,
+      model: openAIParams.model ?? result.model,
+      provider: 'openai',
+      input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
+      output: formatResponseOpenAI({
+        output: result.output
+      }),
+      latency: getBackgroundResponseLatency(result),
+      baseURL: this.baseURL,
+      modelParameters: getModelParams(openAIParams, result.service_tier),
+      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,
+        webSearchCount: calculateWebSearchCount(result),
+        rawUsage: result.usage
+      },
+      stopReason: result.status ?? undefined,
+      tools: extractAvailableToolCalls('openai', openAIParams),
+      completionId: result.id,
+      providerMetadata: buildProviderMetadata({
+        requestId: extractRequestId(result),
+        incompleteDetails: result.incomplete_details
+      }),
+      error: getResponseFailure(result)
+    });
+  }
 
   // --- Overload #1: Non-streaming
 
@@ -2122,6 +2343,12 @@ class WrappedResponses extends Responses {
                   if (!completionIdFromResponse && chunk.response.id) {
                     completionIdFromResponse = chunk.response.id;
                   }
+                  if (openAIParams.background === true && !this.backgroundResponses.get(chunk.response.id)) {
+                    this.backgroundResponses.set(chunk.response.id, {
+                      openAIParams,
+                      posthogParams
+                    });
+                  }
                   if (chunk.response.service_tier != null) {
                     serviceTierFromResponse = chunk.response.service_tier;
                   }
@@ -2146,6 +2373,15 @@ class WrappedResponses extends Responses {
                   };
                 }
               }
+              if (openAIParams.background === true) {
+                if (terminalResponse) {
+                  const context = this.backgroundResponses.take(terminalResponse.id);
+                  if (context) {
+                    await this.captureBackgroundResponse(terminalResponse, context).catch(() => undefined);
+                  }
+                }
+                return;
+              }
               const latency = (Date.now() - startTime) / 1000;
               const timeToFirstToken = firstTokenTime !== undefined ? (firstTokenTime - startTime) / 1000 : undefined;
               const availableTools = extractAvailableToolCalls('openai', openAIParams);
@@ -2177,6 +2413,9 @@ class WrappedResponses extends Responses {
                 error: getResponseFailure(terminalResponse)
               });
             } catch (error) {
+              if (openAIParams.background === true && completionIdFromResponse && this.backgroundResponses.get(completionIdFromResponse)) {
+                throw error;
+              }
               await captureAiGeneration(this.phClient, {
                 ...posthogParams,
                 model: openAIParams.model,
@@ -2210,6 +2449,10 @@ class WrappedResponses extends Responses {
       const wrappedPromise = parentPromise.then(async result => {
         if ('output' in result) {
           if (isPendingBackgroundResponse(openAIParams, result)) {
+            this.backgroundResponses.set(result.id, {
+              openAIParams,
+              posthogParams
+            });
             return result;
           }
           const latency = (Date.now() - startTime) / 1000;
@@ -2269,6 +2512,55 @@ class WrappedResponses extends Responses {
       return preserveProviderPromise(parentPromise, wrappedPromise);
     }
   }
+  retrieve(responseID, query = {}, options) {
+    const parentPromise = super.retrieve(responseID, query, options);
+
+    // Preserve the upstream promise and stream unchanged for responses that
+    // were not created through this client.
+    if (!this.backgroundResponses.get(responseID)) {
+      return parentPromise;
+    }
+    if (query.stream) {
+      return parentPromise._thenUnwrap(result => {
+        if ('controller' in result) {
+          return wrapBackgroundResponseStream(result, responseID, this.backgroundResponses, (response, context) => this.captureBackgroundResponse(response, context));
+        }
+        return result;
+      });
+    }
+    return parentPromise._thenUnwrap(async result => {
+      if (!('output' in result) || !isTerminalResponse(result)) {
+        return result;
+      }
+
+      // Removing the context before capture makes concurrent or repeated
+      // terminal polls idempotent.
+      const context = this.backgroundResponses.take(responseID);
+      if (context) {
+        await this.captureBackgroundResponse(result, context).catch(() => undefined);
+      }
+      return result;
+    });
+  }
+  cancel(responseID, options) {
+    const parentPromise = super.cancel(responseID, options);
+
+    // Avoid wrapping calls that do not belong to a background response created
+    // through this client, preserving the upstream APIPromise unchanged.
+    if (!this.backgroundResponses.get(responseID)) {
+      return parentPromise;
+    }
+    return parentPromise._thenUnwrap(async result => {
+      if (!isTerminalResponse(result)) {
+        return result;
+      }
+      const context = this.backgroundResponses.take(responseID);
+      if (context) {
+        await this.captureBackgroundResponse(result, context).catch(() => undefined);
+      }
+      return result;
+    });
+  }
   parse(body, options) {
     const {
       providerParams: openAIParams,
@@ -2278,6 +2570,10 @@ class WrappedResponses extends Responses {
     const parentPromise = callWithOriginalCreate(this, super.create.bind(this), () => super.parse(openAIParams, options));
     const wrappedPromise = parentPromise.then(async result => {
       if (isPendingBackgroundResponse(openAIParams, result)) {
+        this.backgroundResponses.set(result.id, {
+          openAIParams,
+          posthogParams
+        });
         return result;
       }
       const latency = (Date.now() - startTime) / 1000;