@posthog/ai 7.21.0 → 8.0.0

package/dist/index.cjs

@@ -1,33 +1,7 @@
 'use strict';
 
-var openai = require('openai');
 var uuid = require('uuid');
 var core = require('@posthog/core');
-var AnthropicOriginal = require('@anthropic-ai/sdk');
-var genai = require('@google/genai');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-function _interopNamespace(e) {
-    if (e && e.__esModule) return e;
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var uuid__namespace = /*#__PURE__*/_interopNamespace(uuid);
-var AnthropicOriginal__default = /*#__PURE__*/_interopDefault(AnthropicOriginal);
 
 // Type guards for safer type checking
 const isString = value => {
@@ -182,11 +156,6 @@ const redactor = new BinaryContentRedactor();
 function redactBase64DataUrl(str) {
   return redactor.redact(str);
 }
-const sanitizeOpenAI = data => redactor.redact(data);
-const sanitizeOpenAIResponse = data => redactor.redact(data);
-const sanitizeAnthropic = data => redactor.redact(data);
-const sanitizeGemini = data => redactor.redact(data);
-const sanitizeLangChain = data => redactor.redact(data);
 
 const TOKEN_PROPERTY_KEYS = new Set(['$ai_input_tokens', '$ai_output_tokens', '$ai_cache_read_input_tokens', '$ai_cache_creation_input_tokens', '$ai_total_tokens', '$ai_reasoning_tokens']);
 function getTokensSource(posthogProperties) {
@@ -243,236 +212,6 @@ const getModelParams = params => {
   }
   return modelParams;
 };
-const formatResponseAnthropic = response => {
-  const output = [];
-  const content = [];
-  for (const choice of response.content ?? []) {
-    if (choice?.type === 'text' && choice?.text) {
-      content.push({
-        type: 'text',
-        text: choice.text
-      });
-    } else if (choice?.type === 'tool_use' && choice?.name && choice?.id) {
-      content.push({
-        type: 'function',
-        id: choice.id,
-        function: {
-          name: choice.name,
-          arguments: choice.input || {}
-        }
-      });
-    }
-  }
-  if (content.length > 0) {
-    output.push({
-      role: 'assistant',
-      content
-    });
-  }
-  return output;
-};
-const formatResponseOpenAI = response => {
-  const output = [];
-  if (response.choices) {
-    for (const choice of response.choices) {
-      const content = [];
-      let role = 'assistant';
-      if (choice.message) {
-        if (choice.message.role) {
-          role = choice.message.role;
-        }
-        if (choice.message.content) {
-          content.push({
-            type: 'text',
-            text: choice.message.content
-          });
-        }
-        if (choice.message.tool_calls) {
-          for (const toolCall of choice.message.tool_calls) {
-            content.push({
-              type: 'function',
-              id: toolCall.id,
-              function: {
-                name: toolCall.function.name,
-                arguments: toolCall.function.arguments
-              }
-            });
-          }
-        }
-        // Handle audio output (gpt-4o-audio-preview)
-        if (choice.message.audio) {
-          content.push({
-            type: 'audio',
-            ...choice.message.audio
-          });
-        }
-      }
-      if (content.length > 0) {
-        output.push({
-          role,
-          content
-        });
-      }
-    }
-  }
-  // Handle Responses API format
-  if (response.output) {
-    const content = [];
-    let role = 'assistant';
-    for (const item of response.output) {
-      if (item.type === 'message') {
-        role = item.role;
-        if (item.content && Array.isArray(item.content)) {
-          for (const contentItem of item.content) {
-            if (contentItem.type === 'output_text' && contentItem.text) {
-              content.push({
-                type: 'text',
-                text: contentItem.text
-              });
-            } else if (contentItem.text) {
-              content.push({
-                type: 'text',
-                text: contentItem.text
-              });
-            } else if (contentItem.type === 'input_image' && contentItem.image_url) {
-              content.push({
-                type: 'image',
-                image: contentItem.image_url
-              });
-            }
-          }
-        } else if (item.content) {
-          content.push({
-            type: 'text',
-            text: String(item.content)
-          });
-        }
-      } else if (item.type === 'function_call') {
-        content.push({
-          type: 'function',
-          id: item.call_id || item.id || '',
-          function: {
-            name: item.name,
-            arguments: item.arguments || {}
-          }
-        });
-      }
-    }
-    if (content.length > 0) {
-      output.push({
-        role,
-        content
-      });
-    }
-  }
-  return output;
-};
-const buildInlineDataBlock = (mimeType, data) => {
-  if (mimeType.startsWith('audio/')) {
-    return {
-      type: 'audio',
-      mime_type: mimeType,
-      data
-    };
-  }
-  if (mimeType.startsWith('image/')) {
-    return {
-      type: 'image',
-      inline_data: {
-        mime_type: mimeType,
-        data
-      }
-    };
-  }
-  return {
-    type: 'document',
-    inline_data: {
-      mime_type: mimeType,
-      data
-    }
-  };
-};
-const formatResponseGemini = response => {
-  const output = [];
-  if (response.candidates && Array.isArray(response.candidates)) {
-    for (const candidate of response.candidates) {
-      if (candidate.content && candidate.content.parts) {
-        const content = [];
-        for (const part of candidate.content.parts) {
-          if (part.text) {
-            content.push({
-              type: 'text',
-              text: part.text
-            });
-          } else if (part.functionCall) {
-            content.push({
-              type: 'function',
-              function: {
-                name: part.functionCall.name,
-                arguments: part.functionCall.args
-              }
-            });
-          } else if (part.inlineData) {
-            // Handle inline data (images, audio, documents)
-            const mimeType = part.inlineData.mimeType || part.inlineData.mime_type || 'application/octet-stream';
-            let data = part.inlineData.data;
-            // Handle binary data (Uint8Array/Buffer -> base64)
-            if (data instanceof Uint8Array) {
-              if (typeof Buffer !== 'undefined') {
-                data = Buffer.from(data).toString('base64');
-              } else {
-                let binary = '';
-                for (let i = 0; i < data.length; i++) {
-                  binary += String.fromCharCode(data[i]);
-                }
-                data = btoa(binary);
-              }
-            }
-            // Sanitize base64 data for images and other large inline data
-            data = redactBase64DataUrl(data);
-            content.push(buildInlineDataBlock(mimeType, data));
-          }
-        }
-        if (content.length > 0) {
-          output.push({
-            role: 'assistant',
-            content
-          });
-        }
-      } else if (candidate.text) {
-        output.push({
-          role: 'assistant',
-          content: [{
-            type: 'text',
-            text: candidate.text
-          }]
-        });
-      }
-    }
-  } else if (response.text) {
-    output.push({
-      role: 'assistant',
-      content: [{
-        type: 'text',
-        text: response.text
-      }]
-    });
-  }
-  return output;
-};
-const mergeSystemPrompt = (params, provider) => {
-  {
-    const messages = params.messages || [];
-    if (!params.system) {
-      return messages;
-    }
-    const systemMessage = params.system;
-    return [{
-      role: 'system',
-      content: systemMessage
-    }, ...messages];
-  }
-};
 const withPrivacyMode = (client, privacyMode, input) => {
   return client.privacy_mode || privacyMode ? null : input;
 };
@@ -610,28 +349,12 @@ function calculateWebSearchCount(result) {
  * These are the tools provided to the LLM, not the tool calls in the response.
  */
 const extractAvailableToolCalls = (provider, params) => {
-  if (provider === 'anthropic') {
-    if (params.tools) {
-      return params.tools;
-    }
-    return null;
-  } else if (provider === 'gemini') {
-    if (params.config && params.config.tools) {
-      return params.config.tools;
-    }
-    return null;
-  } else if (provider === 'openai') {
-    if (params.tools) {
-      return params.tools;
-    }
-    return null;
-  } else if (provider === 'vercel') {
+  {
     if (params.tools) {
       return params.tools;
     }
     return null;
   }
-  return null;
 };
 exports.AIEvent = void 0;
 (function (AIEvent) {
@@ -653,87 +376,8 @@ function sanitizeValues(obj) {
   }
   return jsonSafe;
 }
-const POSTHOG_PARAMS_MAP = {
-  posthogDistinctId: 'distinctId',
-  posthogTraceId: 'traceId',
-  posthogProperties: 'properties',
-  posthogPrivacyMode: 'privacyMode',
-  posthogGroups: 'groups',
-  posthogModelOverride: 'modelOverride',
-  posthogProviderOverride: 'providerOverride',
-  posthogCostOverride: 'costOverride',
-  posthogCaptureImmediate: 'captureImmediate'
-};
-function extractPosthogParams(body) {
-  const providerParams = {};
-  const posthogParams = {};
-  for (const [key, value] of Object.entries(body)) {
-    if (POSTHOG_PARAMS_MAP[key]) {
-      posthogParams[POSTHOG_PARAMS_MAP[key]] = value;
-    } else if (key.startsWith('posthog')) {
-      console.warn(`Unknown Posthog parameter ${key}`);
-    } else {
-      providerParams[key] = value;
-    }
-  }
-  return {
-    providerParams: providerParams,
-    posthogParams: addDefaults(posthogParams)
-  };
-}
-function addDefaults(params) {
-  return {
-    ...params,
-    privacyMode: params.privacyMode ?? false,
-    traceId: params.traceId ?? uuid.v4()
-  };
-}
-function formatOpenAIResponsesInput(input, instructions) {
-  const messages = [];
-  if (instructions) {
-    messages.push({
-      role: 'system',
-      content: instructions
-    });
-  }
-  if (Array.isArray(input)) {
-    for (const item of input) {
-      if (typeof item === 'string') {
-        messages.push({
-          role: 'user',
-          content: item
-        });
-      } else if (item && typeof item === 'object') {
-        const obj = item;
-        const role = isString(obj.role) ? obj.role : 'user';
-        // Handle content properly - preserve structure for objects/arrays
-        const content = obj.content ?? obj.text ?? item;
-        messages.push({
-          role,
-          content: toContentString(content)
-        });
-      } else {
-        messages.push({
-          role: 'user',
-          content: toContentString(item)
-        });
-      }
-    }
-  } else if (typeof input === 'string') {
-    messages.push({
-      role: 'user',
-      content: input
-    });
-  } else if (input) {
-    messages.push({
-      role: 'user',
-      content: toContentString(input)
-    });
-  }
-  return messages;
-}
 
-var version = "7.21.0";
+var version = "8.0.0";
 
 const DEFAULT_MAX_DEPTH = 3;
 const MAX_STACK_LINES = 20;
@@ -916,1336 +560,51 @@ const captureAiGeneration = async (client, options) => {
   }
 };
 
-/**
- * Checks if a ResponseStreamEvent chunk represents the first token/content from the model.
- * This includes various content types like text, reasoning, audio, and refusals.
- */
-function isResponseTokenChunk(chunk) {
-  return chunk.type === 'response.output_item.added' || chunk.type === 'response.content_part.added' || chunk.type === 'response.output_text.delta' || chunk.type === 'response.reasoning_text.delta' || chunk.type === 'response.reasoning_summary_text.delta' || chunk.type === 'response.audio.delta' || chunk.type === 'response.audio.transcript.delta' || chunk.type === 'response.refusal.delta';
-}
-/**
- * Reads the OpenAI SDK's `_request_id` field from a response object. The SDK
- * attaches the `x-request-id` response header here, but it is not part of the
- * public response types, so it has to be read through a cast. Used to populate
- * `$ai_provider_metadata.request_id`.
- */
-function extractRequestId(result) {
-  return result?._request_id ?? undefined;
-}
-/**
- * Assembles the `$ai_provider_metadata` blob for OpenAI / Azure OpenAI events.
- * Provider-specific fields (system fingerprint, request id) live here rather
- * than in the shared, provider-agnostic `$ai_*` namespace. Only keys with a
- * truthy value are included, and `undefined` is returned when there is nothing
- * to report so the property can be omitted from the event entirely.
- */
-function buildProviderMetadata(fields) {
-  const metadata = {};
-  if (fields.systemFingerprint) {
-    metadata.system_fingerprint = fields.systemFingerprint;
-  }
-  if (fields.requestId) {
-    metadata.request_id = fields.requestId;
-  }
-  return Object.keys(metadata).length > 0 ? metadata : undefined;
-}
-
-const Chat = openai.OpenAI.Chat;
-const Completions = Chat.Completions;
-const Responses = openai.OpenAI.Responses;
-const Embeddings = openai.OpenAI.Embeddings;
-const Audio = openai.OpenAI.Audio;
-const Transcriptions = openai.OpenAI.Audio.Transcriptions;
-function captureAiGenerationInBackground(...args) {
-  void captureAiGeneration(...args).catch(() => undefined);
-}
-async function captureAiGenerationAfterSuccess(...args) {
-  const [, options] = args;
-  if (options.captureImmediate) {
-    await captureAiGeneration(...args);
-  } else {
-    captureAiGenerationInBackground(...args);
-  }
-}
-function preserveAPIPromiseHelpers(parentPromise, wrappedPromise) {
-  const apiPromise = wrappedPromise;
-  if (typeof parentPromise.asResponse === 'function') {
-    apiPromise.asResponse = () => parentPromise.asResponse();
-  }
-  if (typeof parentPromise.withResponse === 'function') {
-    apiPromise.withResponse = async () => {
-      const [response, data] = await Promise.all([parentPromise.withResponse(), wrappedPromise]);
-      return {
-        ...response,
-        data
-      };
-    };
-  }
-  return apiPromise;
-}
-class PostHogOpenAI extends openai.OpenAI {
-  constructor(config) {
-    const {
-      posthog,
-      ...openAIConfig
-    } = config;
-    super(openAIConfig);
-    this.phClient = posthog;
-    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);
-  }
+// Type guards
+function isV3Model(model) {
+  return model.specificationVersion === 'v3';
 }
-let WrappedChat$1 = class WrappedChat extends Chat {
-  constructor(parentClient, phClient) {
-    super(parentClient);
-    this.completions = new WrappedCompletions$1(parentClient, phClient);
-  }
+const mapVercelParams = params => {
+  return {
+    temperature: params.temperature,
+    max_output_tokens: params.maxOutputTokens,
+    top_p: params.topP,
+    frequency_penalty: params.frequencyPenalty,
+    presence_penalty: params.presencePenalty,
+    stop: params.stopSequences,
+    stream: params.stream
+  };
 };
-let WrappedCompletions$1 = class WrappedCompletions extends Completions {
-  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 = super.create(openAIParams, options);
-    if (openAIParams.stream) {
-      const wrappedPromise = 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 stopReason;
-              let usage = {
-                inputTokens: 0,
-                outputTokens: 0,
-                webSearchCount: 0
-              };
-              // Map to track in-progress tool calls
-              const toolCallsInProgress = new Map();
-              let rawUsageData;
-              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];
-                if (choice?.finish_reason) {
-                  stopReason = choice.finish_reason;
-                }
-                const chunkWebSearchCount = calculateWebSearchCount(chunk);
-                if (chunkWebSearchCount > 0 && chunkWebSearchCount > (usage.webSearchCount ?? 0)) {
-                  usage.webSearchCount = chunkWebSearchCount;
-                }
-                // 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) {
-                  rawUsageData = chunk.usage;
-                  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;
-              const availableTools = extractAvailableToolCalls('openai', openAIParams);
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: openAIParams.model ?? modelFromResponse,
-                provider: 'openai',
-                input: sanitizeOpenAI(openAIParams.messages),
-                output: formattedOutput,
-                latency,
-                timeToFirstToken,
-                baseURL: this.baseURL,
-                modelParameters: getModelParams(body),
-                httpStatus: 200,
-                usage: {
-                  inputTokens: usage.inputTokens,
-                  outputTokens: usage.outputTokens,
-                  reasoningTokens: usage.reasoningTokens,
-                  cacheReadInputTokens: usage.cacheReadInputTokens,
-                  webSearchCount: usage.webSearchCount,
-                  rawUsage: rawUsageData
-                },
-                stopReason,
-                tools: availableTools,
-                completionId: completionIdFromResponse,
-                providerMetadata: buildProviderMetadata({
-                  systemFingerprint: systemFingerprintFromResponse
-                })
-              });
-            } catch (error) {
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: openAIParams.model,
-                provider: 'openai',
-                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
-              });
-              throw error;
-            }
-          })();
-          // Return the other stream to the user
-          return stream2;
-        }
-        return value;
-      });
-      return preserveAPIPromiseHelpers(parentPromise, wrappedPromise);
+const mapVercelPrompt = messages => {
+  // Map and truncate individual content
+  const inputs = messages.map(message => {
+    let content;
+    // Handle system role which has string content
+    if (message.role === 'system') {
+      content = [{
+        type: 'text',
+        text: truncate(toContentString(message.content))
+      }];
     } else {
-      const wrappedPromise = parentPromise.then(async result => {
-        if ('choices' in result) {
-          const latency = (Date.now() - startTime) / 1000;
-          const availableTools = extractAvailableToolCalls('openai', openAIParams);
-          const formattedOutput = formatResponseOpenAI(result);
-          await captureAiGenerationAfterSuccess(this.phClient, {
-            ...posthogParams,
-            model: openAIParams.model ?? result.model,
-            provider: 'openai',
-            input: sanitizeOpenAI(openAIParams.messages),
-            output: formattedOutput,
-            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,
-              webSearchCount: calculateWebSearchCount(result),
-              rawUsage: result.usage
-            },
-            stopReason: result.choices[0]?.finish_reason ?? undefined,
-            tools: availableTools,
-            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: 'openai',
-          input: sanitizeOpenAI(openAIParams.messages),
-          output: [],
-          latency: 0,
-          baseURL: this.baseURL,
-          modelParameters: getModelParams(body),
-          httpStatus,
-          usage: {
-            inputTokens: 0,
-            outputTokens: 0
-          },
-          error
-        });
-        throw error;
-      });
-      return preserveAPIPromiseHelpers(parentPromise, wrappedPromise);
-    }
-  }
-};
-let WrappedResponses$1 = class WrappedResponses extends Responses {
-  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 = super.create(openAIParams, options);
-    if (openAIParams.stream) {
-      const wrappedPromise = 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 stopReason;
-              let usage = {
-                inputTokens: 0,
-                outputTokens: 0,
-                webSearchCount: 0
-              };
-              let rawUsageData;
-              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;
-                  }
-                  const chunkWebSearchCount = calculateWebSearchCount(chunk.response);
-                  if (chunkWebSearchCount > 0 && chunkWebSearchCount > (usage.webSearchCount ?? 0)) {
-                    usage.webSearchCount = chunkWebSearchCount;
-                  }
-                }
-                if (chunk.type === 'response.completed' && 'response' in chunk && chunk.response?.output && chunk.response.output.length > 0) {
-                  finalContent = chunk.response.output;
-                  if (chunk.response.status) {
-                    stopReason = chunk.response.status;
-                  }
-                }
-                if ('response' in chunk && chunk.response?.usage) {
-                  rawUsageData = chunk.response.usage;
-                  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;
-              const timeToFirstToken = firstTokenTime !== undefined ? (firstTokenTime - startTime) / 1000 : undefined;
-              const availableTools = extractAvailableToolCalls('openai', openAIParams);
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: openAIParams.model ?? modelFromResponse,
-                provider: 'openai',
-                input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-                output: finalContent,
-                latency,
-                timeToFirstToken,
-                baseURL: this.baseURL,
-                modelParameters: getModelParams(body),
-                httpStatus: 200,
-                usage: {
-                  inputTokens: usage.inputTokens,
-                  outputTokens: usage.outputTokens,
-                  reasoningTokens: usage.reasoningTokens,
-                  cacheReadInputTokens: usage.cacheReadInputTokens,
-                  webSearchCount: usage.webSearchCount,
-                  rawUsage: rawUsageData
-                },
-                stopReason,
-                tools: availableTools,
-                completionId: completionIdFromResponse
-              });
-            } catch (error) {
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: openAIParams.model,
-                provider: 'openai',
-                input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(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
-              });
-              throw error;
-            }
-          })();
-          return stream2;
-        }
-        return value;
-      });
-      return preserveAPIPromiseHelpers(parentPromise, wrappedPromise);
-    } else {
-      const wrappedPromise = parentPromise.then(async result => {
-        if ('output' in result) {
-          const latency = (Date.now() - startTime) / 1000;
-          const availableTools = extractAvailableToolCalls('openai', openAIParams);
-          const formattedOutput = formatResponseOpenAI({
-            output: result.output
-          });
-          await captureAiGenerationAfterSuccess(this.phClient, {
-            ...posthogParams,
-            model: openAIParams.model ?? result.model,
-            provider: 'openai',
-            input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-            output: formattedOutput,
-            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,
-              webSearchCount: calculateWebSearchCount(result),
-              rawUsage: result.usage
-            },
-            stopReason: result.status ?? undefined,
-            tools: availableTools,
-            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: 'openai',
-          input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-          output: [],
-          latency: 0,
-          baseURL: this.baseURL,
-          modelParameters: getModelParams(body),
-          httpStatus,
-          usage: {
-            inputTokens: 0,
-            outputTokens: 0
-          },
-          error
-        });
-        throw error;
-      });
-      return preserveAPIPromiseHelpers(parentPromise, wrappedPromise);
-    }
-  }
-  parse(body, options) {
-    const {
-      providerParams: openAIParams,
-      posthogParams
-    } = extractPosthogParams(body);
-    const startTime = Date.now();
-    const originalCreate = super.create.bind(this);
-    const originalSelfRecord = this;
-    const tempCreate = originalSelfRecord['create'];
-    originalSelfRecord['create'] = originalCreate;
-    try {
-      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: 'openai',
-          input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(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,
-            rawUsage: result.usage
-          },
-          stopReason: result.status ?? undefined,
-          completionId: result.id,
-          providerMetadata: buildProviderMetadata({
-            requestId: extractRequestId(result)
-          })
-        });
-        return result;
-      }, async error => {
-        await captureAiGeneration(this.phClient, {
-          ...posthogParams,
-          model: openAIParams.model,
-          provider: 'openai',
-          input: formatOpenAIResponsesInput(sanitizeOpenAIResponse(openAIParams.input), openAIParams.instructions),
-          output: [],
-          latency: 0,
-          baseURL: this.baseURL,
-          modelParameters: getModelParams(body),
-          usage: {
-            inputTokens: 0,
-            outputTokens: 0
-          },
-          error
-        });
-        throw error;
-      });
-      return preserveAPIPromiseHelpers(parentPromise, wrappedPromise);
-    } finally {
-      // Restore our wrapped create method
-      originalSelfRecord['create'] = tempCreate;
-    }
-  }
-};
-let WrappedEmbeddings$1 = class WrappedEmbeddings extends 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, {
-        ...posthogParams,
-        eventType: exports.AIEvent.Embedding,
-        model: openAIParams.model,
-        provider: 'openai',
-        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,
-          rawUsage: result.usage
-        }
-      });
-      return result;
-    }, async error => {
-      const httpStatus = error && typeof error === 'object' && 'status' in error ? error.status ?? 500 : 500;
-      await captureAiGeneration(this.phClient, {
-        eventType: exports.AIEvent.Embedding,
-        ...posthogParams,
-        model: openAIParams.model,
-        provider: 'openai',
-        input: withPrivacyMode(this.phClient, posthogParams.privacyMode, openAIParams.input),
-        output: null,
-        // Embeddings don't have output content
-        latency: 0,
-        baseURL: this.baseURL,
-        modelParameters: getModelParams(body),
-        httpStatus,
-        usage: {
-          inputTokens: 0
-        },
-        error
-      });
-      throw error;
-    });
-    return preserveAPIPromiseHelpers(parentPromise, 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) {
-      const wrappedPromise = parentPromise.then(value => {
-        if ('tee' in value && typeof value.tee === 'function') {
-          const [stream1, stream2] = value.tee();
-          (async () => {
-            try {
-              let finalContent = '';
-              let firstTokenTime;
-              let usage = {
-                inputTokens: 0,
-                outputTokens: 0
-              };
-              const doneEvent = 'transcript.text.done';
-              for await (const chunk of stream1) {
-                // Track first token on text delta events
-                if (firstTokenTime === undefined && chunk.type === 'transcript.text.delta') {
-                  firstTokenTime = Date.now();
-                }
-                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,
-                    rawUsage: chunk.usage
-                  };
-                }
-              }
-              const latency = (Date.now() - startTime) / 1000;
-              const timeToFirstToken = firstTokenTime !== undefined ? (firstTokenTime - startTime) / 1000 : undefined;
-              const availableTools = extractAvailableToolCalls('openai', openAIParams);
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: openAIParams.model,
-                provider: 'openai',
-                input: openAIParams.prompt,
-                output: finalContent,
-                latency,
-                timeToFirstToken,
-                baseURL: this.baseURL,
-                modelParameters: getModelParams(body),
-                httpStatus: 200,
-                usage,
-                tools: availableTools
-              });
-            } catch (error) {
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: openAIParams.model,
-                provider: 'openai',
-                input: openAIParams.prompt,
-                output: [],
-                latency: 0,
-                baseURL: this.baseURL,
-                modelParameters: getModelParams(body),
-                usage: {
-                  inputTokens: 0,
-                  outputTokens: 0
-                },
-                error
-              });
-              throw error;
-            }
-          })();
-          return stream2;
-        }
-        return value;
-      });
-      return preserveAPIPromiseHelpers(parentPromise, wrappedPromise);
-    } else {
-      const wrappedPromise = parentPromise.then(async result => {
-        if (result && typeof result === 'object' && 'text' in result) {
-          const latency = (Date.now() - startTime) / 1000;
-          await captureAiGenerationAfterSuccess(this.phClient, {
-            ...posthogParams,
-            model: openAIParams.model,
-            provider: 'openai',
-            input: openAIParams.prompt,
-            output: result.text,
-            latency,
-            baseURL: this.baseURL,
-            modelParameters: getModelParams(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,
-              rawUsage: result.usage
-            }
-          });
-        }
-        return result;
-      }, async error => {
-        await captureAiGeneration(this.phClient, {
-          ...posthogParams,
-          model: openAIParams.model,
-          provider: 'openai',
-          input: openAIParams.prompt,
-          output: [],
-          latency: 0,
-          baseURL: this.baseURL,
-          modelParameters: getModelParams(body),
-          usage: {
-            inputTokens: 0,
-            outputTokens: 0
-          },
-          error
-        });
-        throw error;
-      });
-      return preserveAPIPromiseHelpers(parentPromise, wrappedPromise);
-    }
-  }
-}
-
-class PostHogAzureOpenAI extends openai.AzureOpenAI {
-  constructor(config) {
-    const {
-      posthog,
-      ...openAIConfig
-    } = config;
-    super(openAIConfig);
-    this.phClient = posthog;
-    this.chat = new WrappedChat(this, this.phClient);
-    this.embeddings = new WrappedEmbeddings(this, this.phClient);
-  }
-}
-class WrappedChat extends openai.AzureOpenAI.Chat {
-  constructor(parentClient, phClient) {
-    super(parentClient);
-    this.completions = new WrappedCompletions(parentClient, phClient);
-  }
-}
-class WrappedCompletions extends openai.AzureOpenAI.Chat.Completions {
-  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 = 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;
-    }
-  }
-}
-class WrappedResponses extends openai.AzureOpenAI.Responses {
-  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 = 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;
-  }
-}
-class WrappedEmbeddings extends openai.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: exports.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: exports.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;
-  }
-}
-
-// Type guards
-function isV3Model(model) {
-  return model.specificationVersion === 'v3';
-}
-const mapVercelParams = params => {
-  return {
-    temperature: params.temperature,
-    max_output_tokens: params.maxOutputTokens,
-    top_p: params.topP,
-    frequency_penalty: params.frequencyPenalty,
-    presence_penalty: params.presencePenalty,
-    stop: params.stopSequences,
-    stream: params.stream
-  };
-};
-const mapVercelPrompt = messages => {
-  // Map and truncate individual content
-  const inputs = messages.map(message => {
-    let content;
-    // Handle system role which has string content
-    if (message.role === 'system') {
-      content = [{
-        type: 'text',
-        text: truncate(toContentString(message.content))
-      }];
-    } else {
-      // Handle other roles which have array content
-      if (Array.isArray(message.content)) {
-        content = message.content.map(c => {
-          if (c.type === 'text') {
-            return {
-              type: 'text',
-              text: truncate(c.text)
-            };
-          } else if (c.type === 'file') {
-            // For file type, check if it's a data URL and redact if needed
-            let fileData;
-            const contentData = c.data;
-            if (contentData instanceof URL) {
-              fileData = contentData.toString();
-            } else if (isString(contentData)) {
-              // Redact base64 data URLs and raw base64 to prevent oversized events
-              fileData = redactBase64DataUrl(contentData);
-            } else {
-              fileData = 'raw files not supported';
+      // Handle other roles which have array content
+      if (Array.isArray(message.content)) {
+        content = message.content.map(c => {
+          if (c.type === 'text') {
+            return {
+              type: 'text',
+              text: truncate(c.text)
+            };
+          } else if (c.type === 'file') {
+            // For file type, check if it's a data URL and redact if needed
+            let fileData;
+            const contentData = c.data;
+            if (contentData instanceof URL) {
+              fileData = contentData.toString();
+            } else if (isString(contentData)) {
+              // Redact base64 data URLs and raw base64 to prevent oversized events
+              fileData = redactBase64DataUrl(contentData);
+            } else {
+              fileData = 'raw files not supported';
             }
             return {
               type: 'file',
@@ -2822,1794 +1181,19 @@ const wrapVercelLanguageModel = (model, phClient, options) => {
   return wrappedModel;
 };
 
-class PostHogAnthropic extends AnthropicOriginal__default.default {
-  constructor(config) {
-    const {
-      posthog,
-      ...anthropicConfig
-    } = config;
-    super(anthropicConfig);
-    this.phClient = posthog;
-    this.messages = new WrappedMessages(this, this.phClient);
-  }
+/// <reference lib="dom" />
+const DEFAULT_CACHE_TTL_SECONDS = 300; // 5 minutes
+const DEFAULT_PROMPTS_HOST = 'https://us.posthog.com';
+function normalizeApiKey(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+function normalizeHost(value) {
+  const normalizedHost = typeof value === 'string' ? value.trim() : '';
+  return (normalizedHost || DEFAULT_PROMPTS_HOST).replace(/\/+$/, '');
 }
-class WrappedMessages extends AnthropicOriginal__default.default.Messages {
-  constructor(parentClient, phClient) {
-    super(parentClient);
-    this.phClient = phClient;
-    this.baseURL = parentClient.baseURL;
-  }
-  create(body, options) {
-    const {
-      providerParams: anthropicParams,
-      posthogParams
-    } = extractPosthogParams(body);
-    const startTime = Date.now();
-    const parentPromise = super.create(anthropicParams, options);
-    if (anthropicParams.stream) {
-      return parentPromise.then(value => {
-        let accumulatedContent = '';
-        const contentBlocks = [];
-        const toolsInProgress = new Map();
-        let currentTextBlock = null;
-        let firstTokenTime;
-        let stopReason;
-        const usage = {
-          inputTokens: 0,
-          outputTokens: 0,
-          cacheCreationInputTokens: 0,
-          cacheReadInputTokens: 0,
-          webSearchCount: 0
-        };
-        let lastRawUsage;
-        if ('tee' in value) {
-          const [stream1, stream2] = value.tee();
-          (async () => {
-            try {
-              for await (const chunk of stream1) {
-                // Handle content block start events
-                if (chunk.type === 'content_block_start') {
-                  if (chunk.content_block?.type === 'text') {
-                    currentTextBlock = {
-                      type: 'text',
-                      text: ''
-                    };
-                    contentBlocks.push(currentTextBlock);
-                  } else if (chunk.content_block?.type === 'tool_use') {
-                    if (firstTokenTime === undefined) {
-                      firstTokenTime = Date.now();
-                    }
-                    const toolBlock = {
-                      type: 'function',
-                      id: chunk.content_block.id,
-                      function: {
-                        name: chunk.content_block.name,
-                        arguments: {}
-                      }
-                    };
-                    contentBlocks.push(toolBlock);
-                    toolsInProgress.set(chunk.content_block.id, {
-                      block: toolBlock,
-                      inputString: ''
-                    });
-                    currentTextBlock = null;
-                  }
-                }
-                // Handle text delta events
-                if ('delta' in chunk) {
-                  if ('text' in chunk.delta) {
-                    const delta = chunk.delta.text;
-                    if (firstTokenTime === undefined) {
-                      firstTokenTime = Date.now();
-                    }
-                    accumulatedContent += delta;
-                    if (currentTextBlock) {
-                      currentTextBlock.text += delta;
-                    }
-                  }
-                }
-                // Handle tool input delta events
-                if (chunk.type === 'content_block_delta' && chunk.delta?.type === 'input_json_delta') {
-                  const block = chunk.index !== undefined ? contentBlocks[chunk.index] : undefined;
-                  const toolId = block?.type === 'function' ? block.id : undefined;
-                  if (toolId && toolsInProgress.has(toolId)) {
-                    const tool = toolsInProgress.get(toolId);
-                    if (tool) {
-                      tool.inputString += chunk.delta.partial_json || '';
-                    }
-                  }
-                }
-                // Handle content block stop events
-                if (chunk.type === 'content_block_stop') {
-                  currentTextBlock = null;
-                  // Parse accumulated tool input
-                  if (chunk.index !== undefined) {
-                    const block = contentBlocks[chunk.index];
-                    if (block?.type === 'function' && block.id && toolsInProgress.has(block.id)) {
-                      const tool = toolsInProgress.get(block.id);
-                      if (tool) {
-                        try {
-                          block.function.arguments = JSON.parse(tool.inputString);
-                        } catch (e) {
-                          // Keep empty object if parsing fails
-                          console.error('Error parsing tool input:', e);
-                        }
-                      }
-                      toolsInProgress.delete(block.id);
-                    }
-                  }
-                }
-                if (chunk.type == 'message_start') {
-                  lastRawUsage = chunk.message.usage;
-                  usage.inputTokens = chunk.message.usage.input_tokens ?? 0;
-                  usage.cacheCreationInputTokens = chunk.message.usage.cache_creation_input_tokens ?? 0;
-                  usage.cacheReadInputTokens = chunk.message.usage.cache_read_input_tokens ?? 0;
-                  usage.webSearchCount = chunk.message.usage.server_tool_use?.web_search_requests ?? 0;
-                }
-                if ('usage' in chunk) {
-                  lastRawUsage = chunk.usage;
-                  usage.outputTokens = chunk.usage.output_tokens ?? 0;
-                  // Update web search count if present in delta
-                  if (chunk.usage.server_tool_use?.web_search_requests !== undefined) {
-                    usage.webSearchCount = chunk.usage.server_tool_use.web_search_requests;
-                  }
-                }
-                if (chunk.type === 'message_delta' && 'delta' in chunk) {
-                  const delta = chunk.delta;
-                  if ('stop_reason' in delta && typeof delta.stop_reason === 'string' && delta.stop_reason) {
-                    stopReason = delta.stop_reason;
-                  }
-                }
-              }
-              usage.rawUsage = lastRawUsage;
-              const latency = (Date.now() - startTime) / 1000;
-              const timeToFirstToken = firstTokenTime !== undefined ? (firstTokenTime - startTime) / 1000 : undefined;
-              const availableTools = extractAvailableToolCalls('anthropic', anthropicParams);
-              // Format output to match non-streaming version
-              const formattedOutput = contentBlocks.length > 0 ? [{
-                role: 'assistant',
-                content: contentBlocks
-              }] : [{
-                role: 'assistant',
-                content: [{
-                  type: 'text',
-                  text: accumulatedContent
-                }]
-              }];
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: anthropicParams.model,
-                provider: 'anthropic',
-                input: sanitizeAnthropic(mergeSystemPrompt(anthropicParams, 'anthropic')),
-                output: formattedOutput,
-                latency,
-                timeToFirstToken,
-                baseURL: this.baseURL,
-                modelParameters: getModelParams(body),
-                httpStatus: 200,
-                usage,
-                stopReason,
-                tools: availableTools
-              });
-            } catch (error) {
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: anthropicParams.model,
-                provider: 'anthropic',
-                input: sanitizeAnthropic(mergeSystemPrompt(anthropicParams)),
-                output: [],
-                latency: 0,
-                baseURL: this.baseURL,
-                modelParameters: getModelParams(body),
-                usage: {
-                  inputTokens: 0,
-                  outputTokens: 0
-                },
-                error: error
-              });
-              throw error;
-            }
-          })();
-          // Return the other stream to the user
-          return stream2;
-        }
-        return value;
-      });
-    } else {
-      const wrappedPromise = parentPromise.then(async result => {
-        if ('content' in result) {
-          const latency = (Date.now() - startTime) / 1000;
-          const availableTools = extractAvailableToolCalls('anthropic', anthropicParams);
-          await captureAiGeneration(this.phClient, {
-            ...posthogParams,
-            model: anthropicParams.model,
-            provider: 'anthropic',
-            input: sanitizeAnthropic(mergeSystemPrompt(anthropicParams)),
-            output: formatResponseAnthropic(result),
-            latency,
-            baseURL: this.baseURL,
-            modelParameters: getModelParams(body),
-            httpStatus: 200,
-            usage: {
-              inputTokens: result.usage.input_tokens ?? 0,
-              outputTokens: result.usage.output_tokens ?? 0,
-              cacheCreationInputTokens: result.usage.cache_creation_input_tokens ?? 0,
-              cacheReadInputTokens: result.usage.cache_read_input_tokens ?? 0,
-              webSearchCount: result.usage.server_tool_use?.web_search_requests ?? 0,
-              rawUsage: result.usage
-            },
-            stopReason: result.stop_reason ?? undefined,
-            tools: availableTools
-          });
-        }
-        return result;
-      }, async error => {
-        await captureAiGeneration(this.phClient, {
-          ...posthogParams,
-          model: anthropicParams.model,
-          provider: 'anthropic',
-          input: sanitizeAnthropic(mergeSystemPrompt(anthropicParams)),
-          output: [],
-          latency: 0,
-          baseURL: this.baseURL,
-          modelParameters: getModelParams(body),
-          httpStatus: error?.status ? error.status : 500,
-          usage: {
-            inputTokens: 0,
-            outputTokens: 0
-          },
-          error: error
-        });
-        throw error;
-      });
-      return wrappedPromise;
-    }
-  }
-}
-
-class PostHogGoogleGenAI {
-  constructor(config) {
-    const {
-      posthog,
-      ...geminiConfig
-    } = config;
-    this.phClient = posthog;
-    this.client = new genai.GoogleGenAI(geminiConfig);
-    this.models = new WrappedModels(this.client, this.phClient);
-  }
-}
-class WrappedModels {
-  constructor(client, phClient) {
-    this.client = client;
-    this.phClient = phClient;
-  }
-  async generateContent(params) {
-    const {
-      providerParams: geminiParams,
-      posthogParams
-    } = extractPosthogParams(params);
-    const startTime = Date.now();
-    try {
-      const response = await this.client.models.generateContent(geminiParams);
-      const latency = (Date.now() - startTime) / 1000;
-      const availableTools = extractAvailableToolCalls('gemini', geminiParams);
-      const metadata = response.usageMetadata;
-      const finishReason = response.candidates?.[0]?.finishReason;
-      await captureAiGeneration(this.phClient, {
-        ...posthogParams,
-        model: geminiParams.model,
-        provider: 'gemini',
-        input: this.formatInputForPostHog(geminiParams),
-        output: formatResponseGemini(response),
-        latency,
-        baseURL: 'https://generativelanguage.googleapis.com',
-        modelParameters: getModelParams(params),
-        httpStatus: 200,
-        usage: {
-          inputTokens: metadata?.promptTokenCount ?? 0,
-          outputTokens: metadata?.candidatesTokenCount ?? 0,
-          reasoningTokens: metadata?.thoughtsTokenCount ?? 0,
-          cacheReadInputTokens: metadata?.cachedContentTokenCount ?? 0,
-          webSearchCount: calculateGoogleWebSearchCount(response),
-          rawUsage: metadata
-        },
-        stopReason: finishReason ?? undefined,
-        tools: availableTools
-      });
-      return response;
-    } catch (error) {
-      const latency = (Date.now() - startTime) / 1000;
-      await captureAiGeneration(this.phClient, {
-        ...posthogParams,
-        model: geminiParams.model,
-        provider: 'gemini',
-        input: this.formatInputForPostHog(geminiParams),
-        output: [],
-        latency,
-        baseURL: 'https://generativelanguage.googleapis.com',
-        modelParameters: getModelParams(params),
-        usage: {
-          inputTokens: 0,
-          outputTokens: 0
-        },
-        error
-      });
-      throw error;
-    }
-  }
-  async *generateContentStream(params) {
-    const {
-      providerParams: geminiParams,
-      posthogParams
-    } = extractPosthogParams(params);
-    const startTime = Date.now();
-    const accumulatedContent = [];
-    let firstTokenTime;
-    let stopReason;
-    let usage = {
-      inputTokens: 0,
-      outputTokens: 0,
-      webSearchCount: 0,
-      rawUsage: undefined
-    };
-    try {
-      const stream = await this.client.models.generateContentStream(geminiParams);
-      for await (const chunk of stream) {
-        // Track first token time when we get text content
-        if (firstTokenTime === undefined && chunk.text) {
-          firstTokenTime = Date.now();
-        }
-        const chunkWebSearchCount = calculateGoogleWebSearchCount(chunk);
-        if (chunkWebSearchCount > 0 && chunkWebSearchCount > (usage.webSearchCount ?? 0)) {
-          usage.webSearchCount = chunkWebSearchCount;
-        }
-        // Handle text content
-        if (chunk.text) {
-          // Find if we already have a text item to append to
-          let lastTextItem;
-          for (let i = accumulatedContent.length - 1; i >= 0; i--) {
-            if (accumulatedContent[i].type === 'text') {
-              lastTextItem = accumulatedContent[i];
-              break;
-            }
-          }
-          if (lastTextItem && lastTextItem.type === 'text') {
-            lastTextItem.text += chunk.text;
-          } else {
-            accumulatedContent.push({
-              type: 'text',
-              text: chunk.text
-            });
-          }
-        }
-        // Track finish reason from candidates
-        if (chunk.candidates?.[0]?.finishReason) {
-          stopReason = chunk.candidates[0].finishReason;
-        }
-        // Handle function calls from candidates
-        if (chunk.candidates && Array.isArray(chunk.candidates)) {
-          for (const candidate of chunk.candidates) {
-            if (candidate.content && candidate.content.parts) {
-              for (const part of candidate.content.parts) {
-                // Type-safe check for functionCall
-                if ('functionCall' in part) {
-                  if (firstTokenTime === undefined) {
-                    firstTokenTime = Date.now();
-                  }
-                  const funcCall = part.functionCall;
-                  if (funcCall?.name) {
-                    accumulatedContent.push({
-                      type: 'function',
-                      function: {
-                        name: funcCall.name,
-                        arguments: funcCall.args || {}
-                      }
-                    });
-                  }
-                }
-              }
-            }
-          }
-        }
-        // Update usage metadata - handle both old and new field names
-        if (chunk.usageMetadata) {
-          const metadata = chunk.usageMetadata;
-          usage = {
-            inputTokens: metadata.promptTokenCount ?? 0,
-            outputTokens: metadata.candidatesTokenCount ?? 0,
-            reasoningTokens: metadata.thoughtsTokenCount ?? 0,
-            cacheReadInputTokens: metadata.cachedContentTokenCount ?? 0,
-            webSearchCount: usage.webSearchCount,
-            rawUsage: metadata
-          };
-        }
-        yield chunk;
-      }
-      const latency = (Date.now() - startTime) / 1000;
-      const timeToFirstToken = firstTokenTime !== undefined ? (firstTokenTime - startTime) / 1000 : undefined;
-      const availableTools = extractAvailableToolCalls('gemini', geminiParams);
-      // Format output similar to formatResponseGemini
-      const output = accumulatedContent.length > 0 ? [{
-        role: 'assistant',
-        content: accumulatedContent
-      }] : [];
-      await captureAiGeneration(this.phClient, {
-        ...posthogParams,
-        model: geminiParams.model,
-        provider: 'gemini',
-        input: this.formatInputForPostHog(geminiParams),
-        output,
-        latency,
-        timeToFirstToken,
-        baseURL: 'https://generativelanguage.googleapis.com',
-        modelParameters: getModelParams(params),
-        httpStatus: 200,
-        usage: {
-          ...usage,
-          webSearchCount: usage.webSearchCount,
-          rawUsage: usage.rawUsage
-        },
-        stopReason,
-        tools: availableTools
-      });
-    } catch (error) {
-      const latency = (Date.now() - startTime) / 1000;
-      await captureAiGeneration(this.phClient, {
-        ...posthogParams,
-        model: geminiParams.model,
-        provider: 'gemini',
-        input: this.formatInputForPostHog(geminiParams),
-        output: [],
-        latency,
-        baseURL: 'https://generativelanguage.googleapis.com',
-        modelParameters: getModelParams(params),
-        usage: {
-          inputTokens: 0,
-          outputTokens: 0
-        },
-        error
-      });
-      throw error;
-    }
-  }
-  async embedContent(params) {
-    const {
-      providerParams: geminiParams,
-      posthogParams
-    } = extractPosthogParams(params);
-    const startTime = Date.now();
-    try {
-      const response = await this.client.models.embedContent(geminiParams);
-      const latency = (Date.now() - startTime) / 1000;
-      const inputTokens = extractEmbeddingTokenCount(response);
-      await captureAiGeneration(this.phClient, {
-        ...posthogParams,
-        eventType: exports.AIEvent.Embedding,
-        model: geminiParams.model,
-        provider: 'gemini',
-        input: withPrivacyMode(this.phClient, posthogParams.privacyMode ?? false, geminiParams.contents),
-        output: null,
-        latency,
-        baseURL: 'https://generativelanguage.googleapis.com',
-        modelParameters: getModelParams(params),
-        httpStatus: 200,
-        usage: {
-          inputTokens
-        }
-      });
-      return response;
-    } catch (error) {
-      const latency = (Date.now() - startTime) / 1000;
-      await captureAiGeneration(this.phClient, {
-        ...posthogParams,
-        eventType: exports.AIEvent.Embedding,
-        model: geminiParams.model,
-        provider: 'gemini',
-        input: withPrivacyMode(this.phClient, posthogParams.privacyMode ?? false, geminiParams.contents),
-        output: null,
-        latency,
-        baseURL: 'https://generativelanguage.googleapis.com',
-        modelParameters: getModelParams(params),
-        usage: {
-          inputTokens: 0
-        },
-        error
-      });
-      throw error;
-    }
-  }
-  formatPartsAsContentBlocks(parts) {
-    const blocks = [];
-    for (const part of parts) {
-      // Handle dict/object with text field
-      if (part && typeof part === 'object' && 'text' in part && part.text) {
-        blocks.push({
-          type: 'text',
-          text: String(part.text)
-        });
-      }
-      // Handle string parts
-      else if (typeof part === 'string') {
-        blocks.push({
-          type: 'text',
-          text: part
-        });
-      }
-      // Handle inlineData (images, audio, PDFs)
-      else if (part && typeof part === 'object' && 'inlineData' in part) {
-        const inlineData = part.inlineData;
-        const mimeType = inlineData.mimeType || inlineData.mime_type || 'application/octet-stream';
-        blocks.push(buildInlineDataBlock(mimeType, inlineData.data));
-      }
-    }
-    return blocks;
-  }
-  formatInput(contents) {
-    if (typeof contents === 'string') {
-      return [{
-        role: 'user',
-        content: contents
-      }];
-    }
-    if (Array.isArray(contents)) {
-      return contents.map(item => {
-        if (typeof item === 'string') {
-          return {
-            role: 'user',
-            content: item
-          };
-        }
-        if (item && typeof item === 'object') {
-          const obj = item;
-          if ('text' in obj && obj.text) {
-            return {
-              role: isString(obj.role) ? obj.role : 'user',
-              content: obj.text
-            };
-          }
-          if ('content' in obj && obj.content) {
-            // If content is a list, format it as content blocks
-            if (Array.isArray(obj.content)) {
-              const contentBlocks = this.formatPartsAsContentBlocks(obj.content);
-              return {
-                role: isString(obj.role) ? obj.role : 'user',
-                content: contentBlocks
-              };
-            }
-            return {
-              role: isString(obj.role) ? obj.role : 'user',
-              content: obj.content
-            };
-          }
-          if ('parts' in obj && Array.isArray(obj.parts)) {
-            const contentBlocks = this.formatPartsAsContentBlocks(obj.parts);
-            return {
-              role: isString(obj.role) ? obj.role : 'user',
-              content: contentBlocks
-            };
-          }
-        }
-        return {
-          role: 'user',
-          content: toContentString(item)
-        };
-      });
-    }
-    if (contents && typeof contents === 'object') {
-      const obj = contents;
-      if ('text' in obj && obj.text) {
-        return [{
-          role: 'user',
-          content: obj.text
-        }];
-      }
-      if ('content' in obj && obj.content) {
-        return [{
-          role: 'user',
-          content: obj.content
-        }];
-      }
-    }
-    return [{
-      role: 'user',
-      content: toContentString(contents)
-    }];
-  }
-  extractSystemInstruction(params) {
-    if (!params || typeof params !== 'object' || !params.config) {
-      return null;
-    }
-    const config = params.config;
-    if (!('systemInstruction' in config)) {
-      return null;
-    }
-    const systemInstruction = config.systemInstruction;
-    if (typeof systemInstruction === 'string') {
-      return systemInstruction;
-    }
-    if (systemInstruction && typeof systemInstruction === 'object' && 'text' in systemInstruction) {
-      return systemInstruction.text;
-    }
-    if (systemInstruction && typeof systemInstruction === 'object' && 'parts' in systemInstruction && Array.isArray(systemInstruction.parts)) {
-      for (const part of systemInstruction.parts) {
-        if (part && typeof part === 'object' && 'text' in part && typeof part.text === 'string') {
-          return part.text;
-        }
-      }
-    }
-    if (Array.isArray(systemInstruction)) {
-      for (const part of systemInstruction) {
-        if (typeof part === 'string') {
-          return part;
-        }
-        if (part && typeof part === 'object' && 'text' in part && typeof part.text === 'string') {
-          return part.text;
-        }
-      }
-    }
-    return null;
-  }
-  formatInputForPostHog(params) {
-    const sanitized = sanitizeGemini(params.contents);
-    const messages = this.formatInput(sanitized);
-    const systemInstruction = this.extractSystemInstruction(params);
-    if (systemInstruction) {
-      const hasSystemMessage = messages.some(msg => msg.role === 'system');
-      if (!hasSystemMessage) {
-        return [{
-          role: 'system',
-          content: systemInstruction
-        }, ...messages];
-      }
-    }
-    return messages;
-  }
-}
-/**
- * Extract total token count from a Gemini embed_content response.
- * Token counts are only available per-embedding via Vertex AI's statistics.tokenCount.
- * Returns 0 if no token counts are available.
- */
-function extractEmbeddingTokenCount(response) {
-  let total = 0;
-  if (response.embeddings) {
-    for (const embedding of response.embeddings) {
-      if (embedding.statistics?.tokenCount != null) {
-        total += embedding.statistics.tokenCount;
-      }
-    }
-  }
-  return total;
-}
-/**
- * Detect if Google Search grounding was used in the response.
- * Gemini bills per request that uses grounding, not per individual query.
- * Returns 1 if grounding was used, 0 otherwise.
- */
-function calculateGoogleWebSearchCount(response) {
-  if (!response || typeof response !== 'object' || !('candidates' in response)) {
-    return 0;
-  }
-  const candidates = response.candidates;
-  if (!Array.isArray(candidates)) {
-    return 0;
-  }
-  const hasGrounding = candidates.some(candidate => {
-    if (!candidate || typeof candidate !== 'object') {
-      return false;
-    }
-    // Check for grounding metadata
-    if ('groundingMetadata' in candidate && candidate.groundingMetadata) {
-      const metadata = candidate.groundingMetadata;
-      if (typeof metadata === 'object') {
-        // Check if web_search_queries exists and is non-empty
-        if ('webSearchQueries' in metadata && Array.isArray(metadata.webSearchQueries) && metadata.webSearchQueries.length > 0) {
-          return true;
-        }
-        // Check if grounding_chunks exists and is non-empty
-        if ('groundingChunks' in metadata && Array.isArray(metadata.groundingChunks) && metadata.groundingChunks.length > 0) {
-          return true;
-        }
-      }
-    }
-    // Check for google search in function calls
-    if ('content' in candidate && candidate.content && typeof candidate.content === 'object') {
-      const content = candidate.content;
-      if ('parts' in content && Array.isArray(content.parts)) {
-        return content.parts.some(part => {
-          if (!part || typeof part !== 'object' || !('functionCall' in part)) {
-            return false;
-          }
-          const functionCall = part.functionCall;
-          if (functionCall && typeof functionCall === 'object' && 'name' in functionCall && typeof functionCall.name === 'string') {
-            return functionCall.name.includes('google_search') || functionCall.name.includes('grounding');
-          }
-          return false;
-        });
-      }
-    }
-    return false;
-  });
-  return hasGrounding ? 1 : 0;
-}
-
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
-var decamelize;
-var hasRequiredDecamelize;
-
-function requireDecamelize () {
-	if (hasRequiredDecamelize) return decamelize;
-	hasRequiredDecamelize = 1;
-	decamelize = function (str, sep) {
-		if (typeof str !== 'string') {
-			throw new TypeError('Expected a string');
-		}
-
-		sep = typeof sep === 'undefined' ? '_' : sep;
-
-		return str
-			.replace(/([a-z\d])([A-Z])/g, '$1' + sep + '$2')
-			.replace(/([A-Z]+)([A-Z][a-z\d]+)/g, '$1' + sep + '$2')
-			.toLowerCase();
-	};
-	return decamelize;
-}
-
-var decamelizeExports = requireDecamelize();
-var snakeCase = /*@__PURE__*/getDefaultExportFromCjs(decamelizeExports);
-
-var camelcase = {exports: {}};
-
-var hasRequiredCamelcase;
-
-function requireCamelcase () {
-	if (hasRequiredCamelcase) return camelcase.exports;
-	hasRequiredCamelcase = 1;
-
-	const UPPERCASE = /[\p{Lu}]/u;
-	const LOWERCASE = /[\p{Ll}]/u;
-	const LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/gu;
-	const IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
-	const SEPARATORS = /[_.\- ]+/;
-
-	const LEADING_SEPARATORS = new RegExp('^' + SEPARATORS.source);
-	const SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, 'gu');
-	const NUMBERS_AND_IDENTIFIER = new RegExp('\\d+' + IDENTIFIER.source, 'gu');
-
-	const preserveCamelCase = (string, toLowerCase, toUpperCase) => {
-		let isLastCharLower = false;
-		let isLastCharUpper = false;
-		let isLastLastCharUpper = false;
-
-		for (let i = 0; i < string.length; i++) {
-			const character = string[i];
-
-			if (isLastCharLower && UPPERCASE.test(character)) {
-				string = string.slice(0, i) + '-' + string.slice(i);
-				isLastCharLower = false;
-				isLastLastCharUpper = isLastCharUpper;
-				isLastCharUpper = true;
-				i++;
-			} else if (isLastCharUpper && isLastLastCharUpper && LOWERCASE.test(character)) {
-				string = string.slice(0, i - 1) + '-' + string.slice(i - 1);
-				isLastLastCharUpper = isLastCharUpper;
-				isLastCharUpper = false;
-				isLastCharLower = true;
-			} else {
-				isLastCharLower = toLowerCase(character) === character && toUpperCase(character) !== character;
-				isLastLastCharUpper = isLastCharUpper;
-				isLastCharUpper = toUpperCase(character) === character && toLowerCase(character) !== character;
-			}
-		}
-
-		return string;
-	};
-
-	const preserveConsecutiveUppercase = (input, toLowerCase) => {
-		LEADING_CAPITAL.lastIndex = 0;
-
-		return input.replace(LEADING_CAPITAL, m1 => toLowerCase(m1));
-	};
-
-	const postProcess = (input, toUpperCase) => {
-		SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
-		NUMBERS_AND_IDENTIFIER.lastIndex = 0;
-
-		return input.replace(SEPARATORS_AND_IDENTIFIER, (_, identifier) => toUpperCase(identifier))
-			.replace(NUMBERS_AND_IDENTIFIER, m => toUpperCase(m));
-	};
-
-	const camelCase = (input, options) => {
-		if (!(typeof input === 'string' || Array.isArray(input))) {
-			throw new TypeError('Expected the input to be `string | string[]`');
-		}
-
-		options = {
-			pascalCase: false,
-			preserveConsecutiveUppercase: false,
-			...options
-		};
-
-		if (Array.isArray(input)) {
-			input = input.map(x => x.trim())
-				.filter(x => x.length)
-				.join('-');
-		} else {
-			input = input.trim();
-		}
-
-		if (input.length === 0) {
-			return '';
-		}
-
-		const toLowerCase = options.locale === false ?
-			string => string.toLowerCase() :
-			string => string.toLocaleLowerCase(options.locale);
-		const toUpperCase = options.locale === false ?
-			string => string.toUpperCase() :
-			string => string.toLocaleUpperCase(options.locale);
-
-		if (input.length === 1) {
-			return options.pascalCase ? toUpperCase(input) : toLowerCase(input);
-		}
-
-		const hasUpperCase = input !== toLowerCase(input);
-
-		if (hasUpperCase) {
-			input = preserveCamelCase(input, toLowerCase, toUpperCase);
-		}
-
-		input = input.replace(LEADING_SEPARATORS, '');
-
-		if (options.preserveConsecutiveUppercase) {
-			input = preserveConsecutiveUppercase(input, toLowerCase);
-		} else {
-			input = toLowerCase(input);
-		}
-
-		if (options.pascalCase) {
-			input = toUpperCase(input.charAt(0)) + input.slice(1);
-		}
-
-		return postProcess(input, toUpperCase);
-	};
-
-	camelcase.exports = camelCase;
-	// TODO: Remove this for the next major release
-	camelcase.exports.default = camelCase;
-	return camelcase.exports;
-}
-
-requireCamelcase();
-
-//#region src/load/map_keys.ts
-function keyToJson(key, map) {
-	return map?.[key] || snakeCase(key);
-}
-function mapKeys(fields, mapper, map) {
-	const mapped = {};
-	for (const key in fields) if (Object.hasOwn(fields, key)) mapped[mapper(key, map)] = fields[key];
-	return mapped;
-}
-
-//#region src/load/validation.ts
-/**
-* Sentinel key used to mark escaped user objects during serialization.
-*
-* When a plain object contains 'lc' key (which could be confused with LC objects),
-* we wrap it as `{"__lc_escaped__": {...original...}}`.
-*/
-const LC_ESCAPED_KEY = "__lc_escaped__";
-/**
-* Check if an object needs escaping to prevent confusion with LC objects.
-*
-* An object needs escaping if:
-* 1. It has an `'lc'` key (could be confused with LC serialization format)
-* 2. It has only the escape key (would be mistaken for an escaped object)
-*/
-function needsEscaping(obj) {
-	return "lc" in obj || Object.keys(obj).length === 1 && LC_ESCAPED_KEY in obj;
-}
-/**
-* Wrap an object in the escape marker.
-*
-* @example
-* ```typescript
-* {"key": "value"}  // becomes {"__lc_escaped__": {"key": "value"}}
-* ```
-*/
-function escapeObject(obj) {
-	return { [LC_ESCAPED_KEY]: obj };
-}
-/**
-* Check if an object looks like a Serializable instance (duck typing).
-*/
-function isSerializableLike(obj) {
-	return obj !== null && typeof obj === "object" && "lc_serializable" in obj && typeof obj.toJSON === "function";
-}
-/**
-* Create a "not_implemented" serialization result for objects that cannot be serialized.
-*/
-function createNotImplemented(obj) {
-	let id;
-	if (obj !== null && typeof obj === "object") if ("lc_id" in obj && Array.isArray(obj.lc_id)) id = obj.lc_id;
-	else id = [obj.constructor?.name ?? "Object"];
-	else id = [typeof obj];
-	return {
-		lc: 1,
-		type: "not_implemented",
-		id
-	};
-}
-/**
-* Escape a value if it needs escaping (contains `lc` key).
-*
-* This is a simpler version of `serializeValue` that doesn't handle Serializable
-* objects - it's meant to be called on kwargs values that have already been
-* processed by `toJSON()`.
-*
-* @param value - The value to potentially escape.
-* @param pathSet - WeakSet to track ancestor objects in the current path to detect circular references.
-*                  Objects are removed after processing to allow shared references (same object in
-*                  multiple places) while still detecting true circular references (ancestor in descendant).
-* @returns The value with any `lc`-containing objects wrapped in escape markers.
-*/
-function escapeIfNeeded(value, pathSet = /* @__PURE__ */ new WeakSet()) {
-	if (value !== null && typeof value === "object" && !Array.isArray(value)) {
-		if (pathSet.has(value)) return createNotImplemented(value);
-		if (isSerializableLike(value)) return value;
-		pathSet.add(value);
-		const record = value;
-		if (needsEscaping(record)) {
-			pathSet.delete(value);
-			return escapeObject(record);
-		}
-		const result = {};
-		for (const [key, val] of Object.entries(record)) result[key] = escapeIfNeeded(val, pathSet);
-		pathSet.delete(value);
-		return result;
-	}
-	if (Array.isArray(value)) return value.map((item) => escapeIfNeeded(item, pathSet));
-	return value;
-}
-
-function shallowCopy(obj) {
-	return Array.isArray(obj) ? [...obj] : { ...obj };
-}
-function replaceSecrets(root, secretsMap) {
-	const result = shallowCopy(root);
-	for (const [path, secretId] of Object.entries(secretsMap)) {
-		const [last, ...partsReverse] = path.split(".").reverse();
-		let current = result;
-		for (const part of partsReverse.reverse()) {
-			if (current[part] === void 0) break;
-			current[part] = shallowCopy(current[part]);
-			current = current[part];
-		}
-		if (current[last] !== void 0) current[last] = {
-			lc: 1,
-			type: "secret",
-			id: [secretId]
-		};
-	}
-	return result;
-}
-/**
-* Get a unique name for the module, rather than parent class implementations.
-* Should not be subclassed, subclass lc_name above instead.
-*/
-function get_lc_unique_name(serializableClass) {
-	const parentClass = Object.getPrototypeOf(serializableClass);
-	if (typeof serializableClass.lc_name === "function" && (typeof parentClass.lc_name !== "function" || serializableClass.lc_name() !== parentClass.lc_name())) return serializableClass.lc_name();
-	else return serializableClass.name;
-}
-var Serializable = class Serializable {
-	lc_serializable = false;
-	lc_kwargs;
-	/**
-	* The name of the serializable. Override to provide an alias or
-	* to preserve the serialized module name in minified environments.
-	*
-	* Implemented as a static method to support loading logic.
-	*/
-	static lc_name() {
-		return this.name;
-	}
-	/**
-	* The final serialized identifier for the module.
-	*/
-	get lc_id() {
-		return [...this.lc_namespace, get_lc_unique_name(this.constructor)];
-	}
-	/**
-	* A map of secrets, which will be omitted from serialization.
-	* Keys are paths to the secret in constructor args, e.g. "foo.bar.baz".
-	* Values are the secret ids, which will be used when deserializing.
-	*/
-	get lc_secrets() {}
-	/**
-	* A map of additional attributes to merge with constructor args.
-	* Keys are the attribute names, e.g. "foo".
-	* Values are the attribute values, which will be serialized.
-	* These attributes need to be accepted by the constructor as arguments.
-	*/
-	get lc_attributes() {}
-	/**
-	* A map of aliases for constructor args.
-	* Keys are the attribute names, e.g. "foo".
-	* Values are the alias that will replace the key in serialization.
-	* This is used to eg. make argument names match Python.
-	*/
-	get lc_aliases() {}
-	/**
-	* A manual list of keys that should be serialized.
-	* If not overridden, all fields passed into the constructor will be serialized.
-	*/
-	get lc_serializable_keys() {}
-	constructor(kwargs, ..._args) {
-		if (this.lc_serializable_keys !== void 0) this.lc_kwargs = Object.fromEntries(Object.entries(kwargs || {}).filter(([key]) => this.lc_serializable_keys?.includes(key)));
-		else this.lc_kwargs = kwargs ?? {};
-	}
-	toJSON() {
-		if (!this.lc_serializable) return this.toJSONNotImplemented();
-		if (this.lc_kwargs instanceof Serializable || typeof this.lc_kwargs !== "object" || Array.isArray(this.lc_kwargs)) return this.toJSONNotImplemented();
-		const aliases = {};
-		const secrets = {};
-		const kwargs = Object.keys(this.lc_kwargs).reduce((acc, key) => {
-			acc[key] = key in this ? this[key] : this.lc_kwargs[key];
-			return acc;
-		}, {});
-		for (let current = Object.getPrototypeOf(this); current; current = Object.getPrototypeOf(current)) {
-			Object.assign(aliases, Reflect.get(current, "lc_aliases", this));
-			Object.assign(secrets, Reflect.get(current, "lc_secrets", this));
-			Object.assign(kwargs, Reflect.get(current, "lc_attributes", this));
-		}
-		Object.keys(secrets).forEach((keyPath) => {
-			let read = this;
-			let write = kwargs;
-			const [last, ...partsReverse] = keyPath.split(".").reverse();
-			for (const key of partsReverse.reverse()) {
-				if (!(key in read) || read[key] === void 0) return;
-				if (!(key in write) || write[key] === void 0) {
-					if (typeof read[key] === "object" && read[key] != null) write[key] = {};
-					else if (Array.isArray(read[key])) write[key] = [];
-				}
-				read = read[key];
-				write = write[key];
-			}
-			if (last in read && read[last] !== void 0) write[last] = write[last] || read[last];
-		});
-		const escapedKwargs = {};
-		const pathSet = /* @__PURE__ */ new WeakSet();
-		pathSet.add(this);
-		for (const [key, value] of Object.entries(kwargs)) escapedKwargs[key] = escapeIfNeeded(value, pathSet);
-		const processedKwargs = mapKeys(Object.keys(secrets).length ? replaceSecrets(escapedKwargs, secrets) : escapedKwargs, keyToJson, aliases);
-		return {
-			lc: 1,
-			type: "constructor",
-			id: this.lc_id,
-			kwargs: processedKwargs
-		};
-	}
-	toJSONNotImplemented() {
-		return {
-			lc: 1,
-			type: "not_implemented",
-			id: this.lc_id
-		};
-	}
-};
-
-const isDeno = () => typeof Deno !== "undefined";
-function getEnvironmentVariable(name) {
-	try {
-		if (typeof process !== "undefined") return process.env?.[name];
-		else if (isDeno()) return Deno?.env.get(name);
-		else return;
-	} catch {
-		return;
-	}
-}
-
-/**
-* Abstract class that provides a set of optional methods that can be
-* overridden in derived classes to handle various events during the
-* execution of a LangChain application.
-*/
-var BaseCallbackHandlerMethodsClass = class {};
-/**
-* Abstract base class for creating callback handlers in the LangChain
-* framework. It provides a set of optional methods that can be overridden
-* in derived classes to handle various events during the execution of a
-* LangChain application.
-*/
-var BaseCallbackHandler = class extends BaseCallbackHandlerMethodsClass {
-	lc_serializable = false;
-	get lc_namespace() {
-		return [
-			"langchain_core",
-			"callbacks",
-			this.name
-		];
-	}
-	get lc_secrets() {}
-	get lc_attributes() {}
-	get lc_aliases() {}
-	get lc_serializable_keys() {}
-	/**
-	* The name of the serializable. Override to provide an alias or
-	* to preserve the serialized module name in minified environments.
-	*
-	* Implemented as a static method to support loading logic.
-	*/
-	static lc_name() {
-		return this.name;
-	}
-	/**
-	* The final serialized identifier for the module.
-	*/
-	get lc_id() {
-		return [...this.lc_namespace, get_lc_unique_name(this.constructor)];
-	}
-	lc_kwargs;
-	ignoreLLM = false;
-	ignoreChain = false;
-	ignoreAgent = false;
-	ignoreRetriever = false;
-	ignoreCustomEvent = false;
-	raiseError = false;
-	awaitHandlers = getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") === "false";
-	constructor(input) {
-		super();
-		this.lc_kwargs = input || {};
-		if (input) {
-			this.ignoreLLM = input.ignoreLLM ?? this.ignoreLLM;
-			this.ignoreChain = input.ignoreChain ?? this.ignoreChain;
-			this.ignoreAgent = input.ignoreAgent ?? this.ignoreAgent;
-			this.ignoreRetriever = input.ignoreRetriever ?? this.ignoreRetriever;
-			this.ignoreCustomEvent = input.ignoreCustomEvent ?? this.ignoreCustomEvent;
-			this.raiseError = input.raiseError ?? this.raiseError;
-			this.awaitHandlers = this.raiseError || (input._awaitHandler ?? this.awaitHandlers);
-		}
-	}
-	copy() {
-		return new this.constructor(this);
-	}
-	toJSON() {
-		return Serializable.prototype.toJSON.call(this);
-	}
-	toJSONNotImplemented() {
-		return Serializable.prototype.toJSONNotImplemented.call(this);
-	}
-	static fromMethods(methods) {
-		class Handler extends BaseCallbackHandler {
-			name = uuid__namespace.v7();
-			constructor() {
-				super();
-				Object.assign(this, methods);
-			}
-		}
-		return new Handler();
-	}
-};
-
-class LangChainCallbackHandler extends BaseCallbackHandler {
-  constructor(options) {
-    if (!options.client) {
-      throw new Error('PostHog client is required');
-    }
-    super();
-    this.name = 'PosthogCallbackHandler';
-    this.runs = {};
-    this.parentTree = {};
-    this.client = options.client;
-    this.distinctId = options.distinctId;
-    this.traceId = options.traceId;
-    this.properties = options.properties || {};
-    this.privacyMode = options.privacyMode || false;
-    this.groups = options.groups || {};
-    this.debug = options.debug || false;
-  }
-  // ===== CALLBACK METHODS =====
-  handleChainStart(chain, inputs, runId, parentRunId, tags, metadata, _runType, runName) {
-    this._logDebugEvent('on_chain_start', runId, parentRunId, {
-      inputs,
-      tags
-    });
-    this._setParentOfRun(runId, parentRunId);
-    this._setTraceOrSpanMetadata(chain, inputs, runId, parentRunId, metadata, tags, runName);
-  }
-  handleChainEnd(outputs, runId, parentRunId, tags, _kwargs) {
-    this._logDebugEvent('on_chain_end', runId, parentRunId, {
-      outputs,
-      tags
-    });
-    this._popRunAndCaptureTraceOrSpan(runId, parentRunId, outputs);
-  }
-  handleChainError(error, runId, parentRunId, tags, _kwargs) {
-    this._logDebugEvent('on_chain_error', runId, parentRunId, {
-      error,
-      tags
-    });
-    this._popRunAndCaptureTraceOrSpan(runId, parentRunId, error);
-  }
-  handleChatModelStart(serialized, messages, runId, parentRunId, extraParams, tags, metadata, runName) {
-    this._logDebugEvent('on_chat_model_start', runId, parentRunId, {
-      messages,
-      tags
-    });
-    this._setParentOfRun(runId, parentRunId);
-    // Flatten the two-dimensional messages and convert each message to a plain object
-    const input = messages.flat().map(m => this._convertMessageToDict(m));
-    this._setLLMMetadata(serialized, runId, input, metadata, extraParams, runName);
-  }
-  handleLLMStart(serialized, prompts, runId, parentRunId, extraParams, tags, metadata, runName) {
-    this._logDebugEvent('on_llm_start', runId, parentRunId, {
-      prompts,
-      tags
-    });
-    this._setParentOfRun(runId, parentRunId);
-    this._setLLMMetadata(serialized, runId, prompts, metadata, extraParams, runName);
-  }
-  handleLLMEnd(output, runId, parentRunId, tags, _extraParams) {
-    this._logDebugEvent('on_llm_end', runId, parentRunId, {
-      output,
-      tags
-    });
-    this._popRunAndCaptureGeneration(runId, parentRunId, output);
-  }
-  handleLLMError(err, runId, parentRunId, tags, _extraParams) {
-    this._logDebugEvent('on_llm_error', runId, parentRunId, {
-      err,
-      tags
-    });
-    this._popRunAndCaptureGeneration(runId, parentRunId, err);
-  }
-  handleToolStart(tool, input, runId, parentRunId, tags, metadata, runName) {
-    this._logDebugEvent('on_tool_start', runId, parentRunId, {
-      input,
-      tags
-    });
-    this._setParentOfRun(runId, parentRunId);
-    this._setTraceOrSpanMetadata(tool, input, runId, parentRunId, metadata, tags, runName);
-  }
-  handleToolEnd(output, runId, parentRunId, tags) {
-    this._logDebugEvent('on_tool_end', runId, parentRunId, {
-      output,
-      tags
-    });
-    this._popRunAndCaptureTraceOrSpan(runId, parentRunId, output);
-  }
-  handleToolError(err, runId, parentRunId, tags) {
-    this._logDebugEvent('on_tool_error', runId, parentRunId, {
-      err,
-      tags
-    });
-    this._popRunAndCaptureTraceOrSpan(runId, parentRunId, err);
-  }
-  handleRetrieverStart(retriever, query, runId, parentRunId, tags, metadata, name) {
-    this._logDebugEvent('on_retriever_start', runId, parentRunId, {
-      query,
-      tags
-    });
-    this._setParentOfRun(runId, parentRunId);
-    this._setTraceOrSpanMetadata(retriever, query, runId, parentRunId, metadata, tags, name);
-  }
-  handleRetrieverEnd(documents, runId, parentRunId, tags) {
-    this._logDebugEvent('on_retriever_end', runId, parentRunId, {
-      documents,
-      tags
-    });
-    this._popRunAndCaptureTraceOrSpan(runId, parentRunId, documents);
-  }
-  handleRetrieverError(err, runId, parentRunId, tags) {
-    this._logDebugEvent('on_retriever_error', runId, parentRunId, {
-      err,
-      tags
-    });
-    this._popRunAndCaptureTraceOrSpan(runId, parentRunId, err);
-  }
-  handleAgentAction(action, runId, parentRunId, tags) {
-    this._logDebugEvent('on_agent_action', runId, parentRunId, {
-      action,
-      tags
-    });
-    this._setParentOfRun(runId, parentRunId);
-    this._setTraceOrSpanMetadata(null, action, runId, parentRunId);
-  }
-  handleAgentEnd(action, runId, parentRunId, tags) {
-    this._logDebugEvent('on_agent_finish', runId, parentRunId, {
-      action,
-      tags
-    });
-    this._popRunAndCaptureTraceOrSpan(runId, parentRunId, action);
-  }
-  // ===== PRIVATE HELPERS =====
-  _setParentOfRun(runId, parentRunId) {
-    if (parentRunId) {
-      this.parentTree[runId] = parentRunId;
-    }
-  }
-  _popParentOfRun(runId) {
-    delete this.parentTree[runId];
-  }
-  _findRootRun(runId) {
-    let id = runId;
-    while (this.parentTree[id]) {
-      id = this.parentTree[id];
-    }
-    return id;
-  }
-  _setTraceOrSpanMetadata(serialized, input, runId, parentRunId, ...args) {
-    // Use default names if not provided: if this is a top-level run, we mark it as a trace, otherwise as a span.
-    const defaultName = parentRunId ? 'span' : 'trace';
-    const runName = this._getLangchainRunName(serialized, ...args) || defaultName;
-    this.runs[runId] = {
-      name: runName,
-      input,
-      startTime: Date.now()
-    };
-  }
-  _setLLMMetadata(serialized, runId, messages, metadata, extraParams, runName) {
-    const runNameFound = this._getLangchainRunName(serialized, {
-      extraParams,
-      runName
-    }) || 'generation';
-    const generation = {
-      name: runNameFound,
-      input: sanitizeLangChain(messages),
-      startTime: Date.now()
-    };
-    if (extraParams) {
-      generation.modelParams = getModelParams(extraParams.invocation_params);
-      if (extraParams.invocation_params && extraParams.invocation_params.tools) {
-        generation.tools = extraParams.invocation_params.tools;
-      }
-    }
-    if (metadata) {
-      if (metadata.ls_model_name) {
-        generation.model = metadata.ls_model_name;
-      }
-      if (metadata.ls_provider) {
-        generation.provider = metadata.ls_provider;
-      }
-    }
-    if (serialized && 'kwargs' in serialized && serialized.kwargs.openai_api_base) {
-      generation.baseUrl = serialized.kwargs.openai_api_base;
-    }
-    this.runs[runId] = generation;
-  }
-  _popRunMetadata(runId) {
-    const endTime = Date.now();
-    const run = this.runs[runId];
-    if (!run) {
-      console.warn(`No run metadata found for run ${runId}`);
-      return undefined;
-    }
-    run.endTime = endTime;
-    delete this.runs[runId];
-    return run;
-  }
-  _getTraceId(runId) {
-    return this.traceId ? String(this.traceId) : this._findRootRun(runId);
-  }
-  _getParentRunId(traceId, _runId, parentRunId) {
-    // Replace the parent-run if not found in our stored parent tree.
-    if (parentRunId && !this.parentTree[parentRunId]) {
-      return traceId;
-    }
-    return parentRunId;
-  }
-  _popRunAndCaptureTraceOrSpan(runId, parentRunId, outputs) {
-    const traceId = this._getTraceId(runId);
-    this._popParentOfRun(runId);
-    const run = this._popRunMetadata(runId);
-    if (!run) {
-      return;
-    }
-    if ('modelParams' in run) {
-      console.warn(`Run ${runId} is a generation, but attempted to be captured as a trace/span.`);
-      return;
-    }
-    const actualParentRunId = this._getParentRunId(traceId, runId, parentRunId);
-    this._captureTraceOrSpan(traceId, runId, run, outputs, actualParentRunId);
-  }
-  _captureTraceOrSpan(traceId, runId, run, outputs, parentRunId) {
-    const eventName = parentRunId ? '$ai_span' : '$ai_trace';
-    const latency = run.endTime ? (run.endTime - run.startTime) / 1000 : 0;
-    const eventProperties = {
-      $ai_lib: 'posthog-ai',
-      $ai_lib_version: version,
-      $ai_trace_id: traceId,
-      $ai_input_state: withPrivacyMode(this.client, this.privacyMode, run.input),
-      $ai_latency: latency,
-      $ai_span_name: run.name,
-      $ai_span_id: runId,
-      $ai_framework: 'langchain'
-    };
-    if (parentRunId) {
-      eventProperties['$ai_parent_id'] = parentRunId;
-    }
-    Object.assign(eventProperties, this.properties);
-    if (!this.distinctId) {
-      eventProperties['$process_person_profile'] = false;
-    }
-    if (outputs instanceof Error) {
-      eventProperties['$ai_error'] = stringifyError(outputs);
-      eventProperties['$ai_is_error'] = true;
-    } else if (outputs !== undefined) {
-      eventProperties['$ai_output_state'] = withPrivacyMode(this.client, this.privacyMode, outputs);
-    }
-    this.client.capture({
-      distinctId: this.distinctId ? this.distinctId.toString() : runId,
-      event: eventName,
-      properties: eventProperties,
-      groups: this.groups
-    });
-  }
-  _popRunAndCaptureGeneration(runId, parentRunId, response) {
-    const traceId = this._getTraceId(runId);
-    this._popParentOfRun(runId);
-    const run = this._popRunMetadata(runId);
-    if (!run || typeof run !== 'object' || !('modelParams' in run)) {
-      console.warn(`Run ${runId} is not a generation, but attempted to be captured as such.`);
-      return;
-    }
-    const actualParentRunId = this._getParentRunId(traceId, runId, parentRunId);
-    this._captureGeneration(traceId, runId, run, response, actualParentRunId);
-  }
-  _captureGeneration(traceId, runId, run, output, parentRunId) {
-    const latency = run.endTime ? (run.endTime - run.startTime) / 1000 : 0;
-    const eventProperties = {
-      $ai_lib: 'posthog-ai',
-      $ai_lib_version: version,
-      $ai_trace_id: traceId,
-      $ai_span_id: runId,
-      $ai_span_name: run.name,
-      $ai_parent_id: parentRunId,
-      $ai_provider: run.provider,
-      $ai_model: run.model,
-      $ai_model_parameters: run.modelParams,
-      $ai_input: withPrivacyMode(this.client, this.privacyMode, run.input),
-      $ai_http_status: 200,
-      $ai_latency: latency,
-      $ai_base_url: run.baseUrl,
-      $ai_framework: 'langchain'
-    };
-    if (run.tools) {
-      eventProperties['$ai_tools'] = run.tools;
-    }
-    if (output instanceof Error) {
-      eventProperties['$ai_http_status'] = output.status || 500;
-      eventProperties['$ai_error'] = stringifyError(output);
-      eventProperties['$ai_is_error'] = true;
-    } else {
-      // Handle token usage
-      const [inputTokens, outputTokens, additionalTokenData] = this.parseUsage(output, run.provider, run.model);
-      eventProperties['$ai_input_tokens'] = inputTokens;
-      eventProperties['$ai_output_tokens'] = outputTokens;
-      // Add additional token data to properties
-      if (additionalTokenData.cacheReadInputTokens) {
-        eventProperties['$ai_cache_read_input_tokens'] = additionalTokenData.cacheReadInputTokens;
-      }
-      if (additionalTokenData.cacheWriteInputTokens) {
-        eventProperties['$ai_cache_creation_input_tokens'] = additionalTokenData.cacheWriteInputTokens;
-      }
-      if (additionalTokenData.reasoningTokens) {
-        eventProperties['$ai_reasoning_tokens'] = additionalTokenData.reasoningTokens;
-      }
-      if (additionalTokenData.webSearchCount !== undefined) {
-        eventProperties['$ai_web_search_count'] = additionalTokenData.webSearchCount;
-      }
-      // Extract stop reason from generation info
-      const stopReason = this._extractStopReason(output);
-      if (stopReason) {
-        eventProperties['$ai_stop_reason'] = stopReason;
-      }
-      // Handle generations/completions
-      let completions;
-      if (output.generations && Array.isArray(output.generations)) {
-        const lastGeneration = output.generations[output.generations.length - 1];
-        if (Array.isArray(lastGeneration) && lastGeneration.length > 0) {
-          // Check if this is a ChatGeneration by looking at the first item
-          const isChatGeneration = 'message' in lastGeneration[0] && lastGeneration[0].message;
-          if (isChatGeneration) {
-            // For ChatGeneration, convert messages to dict format
-            completions = lastGeneration.map(gen => {
-              return this._convertMessageToDict(gen.message);
-            });
-          } else {
-            // For non-ChatGeneration, extract raw response
-            completions = lastGeneration.map(gen => {
-              return this._extractRawResponse(gen);
-            });
-          }
-        }
-      }
-      if (completions) {
-        eventProperties['$ai_output_choices'] = withPrivacyMode(this.client, this.privacyMode, completions);
-      }
-    }
-    Object.assign(eventProperties, this.properties);
-    if (!this.distinctId) {
-      eventProperties['$process_person_profile'] = false;
-    }
-    this.client.capture({
-      distinctId: this.distinctId ? this.distinctId.toString() : traceId,
-      event: '$ai_generation',
-      properties: eventProperties,
-      groups: this.groups
-    });
-  }
-  _logDebugEvent(eventName, runId, parentRunId, extra) {
-    if (this.debug) {
-      console.log(`Event: ${eventName}, runId: ${runId}, parentRunId: ${parentRunId}, extra:`, extra);
-    }
-  }
-  _getLangchainRunName(serialized, ...args) {
-    if (args && args.length > 0) {
-      for (const arg of args) {
-        if (arg && typeof arg === 'object' && 'name' in arg) {
-          return arg.name;
-        } else if (arg && typeof arg === 'object' && 'runName' in arg) {
-          return arg.runName;
-        }
-      }
-    }
-    if (serialized && serialized.name) {
-      return serialized.name;
-    }
-    if (serialized && serialized.id) {
-      return Array.isArray(serialized.id) ? serialized.id[serialized.id.length - 1] : serialized.id;
-    }
-    return undefined;
-  }
-  _convertLcToolCallsToOai(toolCalls) {
-    return toolCalls.map(toolCall => ({
-      type: 'function',
-      id: toolCall.id,
-      function: {
-        name: toolCall.name,
-        arguments: JSON.stringify(toolCall.args)
-      }
-    }));
-  }
-  _extractRawResponse(generation) {
-    // Extract the response from the last response of the LLM call
-    // We return the text of the response if not empty
-    if (generation.text != null && generation.text.trim() !== '') {
-      return generation.text.trim();
-    } else if (generation.message) {
-      // Additional kwargs contains the response in case of tool usage
-      return generation.message.additional_kwargs || generation.message.additionalKwargs || {};
-    } else {
-      // Not tool usage, some LLM responses can be simply empty
-      return '';
-    }
-  }
-  _convertMessageToDict(message) {
-    let messageDict = {};
-    const messageType = message.getType();
-    switch (messageType) {
-      case 'human':
-        messageDict = {
-          role: 'user',
-          content: message.content
-        };
-        break;
-      case 'ai':
-        messageDict = {
-          role: 'assistant',
-          content: message.content
-        };
-        if (message.tool_calls) {
-          messageDict.tool_calls = this._convertLcToolCallsToOai(message.tool_calls);
-        }
-        break;
-      case 'system':
-        messageDict = {
-          role: 'system',
-          content: message.content
-        };
-        break;
-      case 'tool':
-        messageDict = {
-          role: 'tool',
-          content: message.content
-        };
-        break;
-      case 'function':
-        messageDict = {
-          role: 'function',
-          content: message.content
-        };
-        break;
-      default:
-        messageDict = {
-          role: messageType,
-          content: toContentString(message.content)
-        };
-        break;
-    }
-    if (message.additional_kwargs) {
-      messageDict = {
-        ...messageDict,
-        ...message.additional_kwargs
-      };
-    }
-    // Sanitize the message content to redact base64 images
-    return sanitizeLangChain(messageDict);
-  }
-  _extractStopReason(output) {
-    if (!output.generations || !Array.isArray(output.generations)) {
-      return undefined;
-    }
-    const lastGeneration = output.generations[output.generations.length - 1];
-    if (!Array.isArray(lastGeneration) || lastGeneration.length === 0) {
-      return undefined;
-    }
-    const gen = lastGeneration[0];
-    // Check generationInfo for finish_reason (OpenAI format)
-    if (gen.generationInfo?.finish_reason) {
-      return String(gen.generationInfo.finish_reason);
-    }
-    // Check generationInfo for response_metadata.stop_reason (Anthropic format)
-    if (gen.generationInfo?.response_metadata?.stop_reason) {
-      return String(gen.generationInfo.response_metadata.stop_reason);
-    }
-    // Check message response_metadata for finish_reason (common LangChain format)
-    if (gen.generationInfo?.response_metadata?.finish_reason) {
-      return String(gen.generationInfo.response_metadata.finish_reason);
-    }
-    // Check for stop_reason directly in generationInfo
-    if (gen.generationInfo?.stop_reason) {
-      return String(gen.generationInfo.stop_reason);
-    }
-    return undefined;
-  }
-  _parseUsageModel(usage, provider, model) {
-    const conversionList = [['promptTokens', 'input'], ['completionTokens', 'output'], ['input_tokens', 'input'], ['output_tokens', 'output'], ['prompt_token_count', 'input'], ['candidates_token_count', 'output'], ['inputTokenCount', 'input'], ['outputTokenCount', 'output'], ['input_token_count', 'input'], ['generated_token_count', 'output']];
-    const parsedUsage = conversionList.reduce((acc, [modelKey, typeKey]) => {
-      const value = usage[modelKey];
-      if (value != null) {
-        const finalCount = Array.isArray(value) ? value.reduce((sum, tokenCount) => sum + tokenCount, 0) : value;
-        acc[typeKey] = finalCount;
-      }
-      return acc;
-    }, {
-      input: 0,
-      output: 0
-    });
-    // Extract additional token details like cached tokens and reasoning tokens
-    const additionalTokenData = {};
-    // Check for cached tokens in various formats
-    if (usage.prompt_tokens_details?.cached_tokens != null) {
-      additionalTokenData.cacheReadInputTokens = usage.prompt_tokens_details.cached_tokens;
-    } else if (usage.input_token_details?.cache_read != null) {
-      additionalTokenData.cacheReadInputTokens = usage.input_token_details.cache_read;
-    } else if (usage.cachedPromptTokens != null) {
-      additionalTokenData.cacheReadInputTokens = usage.cachedPromptTokens;
-    } else if (usage.cache_read_input_tokens != null) {
-      additionalTokenData.cacheReadInputTokens = usage.cache_read_input_tokens;
-    }
-    // Check for cache write/creation tokens in various formats
-    if (usage.cache_creation_input_tokens != null) {
-      additionalTokenData.cacheWriteInputTokens = usage.cache_creation_input_tokens;
-    } else if (usage.input_token_details?.cache_creation != null) {
-      additionalTokenData.cacheWriteInputTokens = usage.input_token_details.cache_creation;
-    }
-    // Check for reasoning tokens in various formats
-    if (usage.completion_tokens_details?.reasoning_tokens != null) {
-      additionalTokenData.reasoningTokens = usage.completion_tokens_details.reasoning_tokens;
-    } else if (usage.output_token_details?.reasoning != null) {
-      additionalTokenData.reasoningTokens = usage.output_token_details.reasoning;
-    } else if (usage.reasoningTokens != null) {
-      additionalTokenData.reasoningTokens = usage.reasoningTokens;
-    }
-    // Extract web search counts from various provider formats
-    let webSearchCount;
-    // Priority 1: Exact Count
-    // Check Anthropic format (server_tool_use.web_search_requests)
-    if (usage.server_tool_use?.web_search_requests !== undefined) {
-      webSearchCount = usage.server_tool_use.web_search_requests;
-    }
-    // Priority 2: Binary Detection (1 or 0)
-    // Check for citations array (Perplexity)
-    else if (usage.citations && Array.isArray(usage.citations) && usage.citations.length > 0) {
-      webSearchCount = 1;
-    }
-    // Check for search_results array (Perplexity via OpenRouter)
-    else if (usage.search_results && Array.isArray(usage.search_results) && usage.search_results.length > 0) {
-      webSearchCount = 1;
-    }
-    // Check for search_context_size (Perplexity via OpenRouter)
-    else if (usage.search_context_size) {
-      webSearchCount = 1;
-    }
-    // Check for annotations with url_citation type
-    else if (usage.annotations && Array.isArray(usage.annotations)) {
-      const hasUrlCitation = usage.annotations.some(ann => {
-        return ann && typeof ann === 'object' && 'type' in ann && ann.type === 'url_citation';
-      });
-      if (hasUrlCitation) {
-        webSearchCount = 1;
-      }
-    }
-    // Check Gemini format (grounding metadata - binary 0 or 1)
-    else if (usage.grounding_metadata?.grounding_support !== undefined || usage.grounding_metadata?.web_search_queries !== undefined) {
-      webSearchCount = 1;
-    }
-    if (webSearchCount !== undefined) {
-      additionalTokenData.webSearchCount = webSearchCount;
-    }
-    // For Anthropic providers, LangChain reports input_tokens as the sum of all input tokens.
-    // Our cost calculation expects them to be separate for Anthropic, so we subtract cache tokens.
-    // Both cache_read and cache_write tokens should be subtracted since Anthropic's raw API
-    // reports input_tokens as tokens NOT read from or used to create a cache.
-    // For other providers (OpenAI, etc.), input_tokens already excludes cache tokens as expected.
-    // Match logic consistent with plugin-server: exact match on provider OR substring match on model
-    let isAnthropic = false;
-    if (provider && provider.toLowerCase() === 'anthropic') {
-      isAnthropic = true;
-    } else if (model && model.toLowerCase().includes('anthropic')) {
-      isAnthropic = true;
-    }
-    if (isAnthropic && parsedUsage.input) {
-      const cacheTokens = (additionalTokenData.cacheReadInputTokens || 0) + (additionalTokenData.cacheWriteInputTokens || 0);
-      if (cacheTokens > 0) {
-        parsedUsage.input = Math.max(parsedUsage.input - cacheTokens, 0);
-      }
-    }
-    return [parsedUsage.input, parsedUsage.output, additionalTokenData];
-  }
-  parseUsage(response, provider, model) {
-    let llmUsage = [0, 0, {}];
-    const llmUsageKeys = ['token_usage', 'usage', 'tokenUsage'];
-    if (response.llmOutput != null) {
-      const key = llmUsageKeys.find(k => response.llmOutput?.[k] != null);
-      if (key) {
-        llmUsage = this._parseUsageModel(response.llmOutput[key], provider, model);
-      }
-    }
-    // If top-level usage info was not found, try checking the generations.
-    if (llmUsage[0] === 0 && llmUsage[1] === 0 && response.generations) {
-      for (const generation of response.generations) {
-        for (const genChunk of generation) {
-          // Check other paths for usage information
-          if (genChunk.generationInfo?.usage_metadata) {
-            llmUsage = this._parseUsageModel(genChunk.generationInfo.usage_metadata, provider, model);
-            return llmUsage;
-          }
-          const messageChunk = genChunk.generationInfo ?? {};
-          const responseMetadata = messageChunk.response_metadata ?? {};
-          const chunkUsage = responseMetadata['usage'] ?? responseMetadata['amazon-bedrock-invocationMetrics'] ?? messageChunk.usage_metadata;
-          if (chunkUsage) {
-            llmUsage = this._parseUsageModel(chunkUsage, provider, model);
-            return llmUsage;
-          }
-        }
-      }
-    }
-    return llmUsage;
-  }
-}
-
-/// <reference lib="dom" />
-const DEFAULT_CACHE_TTL_SECONDS = 300; // 5 minutes
-const DEFAULT_PROMPTS_HOST = 'https://us.posthog.com';
-function normalizeApiKey(value) {
-  return typeof value === 'string' ? value.trim() : '';
-}
-function normalizeHost(value) {
-  const normalizedHost = typeof value === 'string' ? value.trim() : '';
-  return (normalizedHost || DEFAULT_PROMPTS_HOST).replace(/\/+$/, '');
-}
-function isPromptApiResponse(data) {
-  if (typeof data !== 'object' || data === null) {
-    return false;
+function isPromptApiResponse(data) {
+  if (typeof data !== 'object' || data === null) {
+    return false;
   }
   const record = data;
   return typeof record.prompt === 'string' && typeof record.name === 'string' && typeof record.version === 'number';
@@ -4633,18 +1217,18 @@ function isPromptsWithPostHog(options) {
  * })
  *
  * // Fetch with caching and fallback
- * const template = await prompts.get('support-system-prompt', {
+ * const result = await prompts.get('support-system-prompt', {
  *   cacheTtlSeconds: 300,
  *   fallback: 'You are a helpful assistant.',
  * })
  *
  * // Or fetch an exact published version
- * const v3Template = await prompts.get('support-system-prompt', {
+ * const v3 = await prompts.get('support-system-prompt', {
  *   version: 3,
  * })
  *
  * // Compile with variables
- * const systemPrompt = prompts.compile(template, {
+ * const systemPrompt = prompts.compile(result.prompt, {
  *   company: 'Acme Corp',
  *   tier: 'premium',
  * })
@@ -4653,7 +1237,6 @@ function isPromptsWithPostHog(options) {
 class Prompts {
   constructor(options) {
     this.cache = new Map();
-    this.hasWarnedDeprecation = false;
     this.defaultCacheTtlSeconds = options.defaultCacheTtlSeconds ?? DEFAULT_CACHE_TTL_SECONDS;
     if (isPromptsWithPostHog(options)) {
       this.personalApiKey = options.posthog.options.personalApiKey ?? '';
@@ -4681,32 +1264,26 @@ class Prompts {
   getPromptLabel(name, version) {
     return version === undefined ? `"${name}"` : `"${name}" version ${version}`;
   }
+  /**
+   * Fetch a prompt by name from the PostHog API.
+   *
+   * Returns a `PromptResult` object carrying the prompt text alongside `source`,
+   * `name`, and `version` metadata. Read `result.prompt` for the template string.
+   */
   async get(name, options) {
-    const withMetadata = options?.withMetadata;
-    if (withMetadata === undefined && !this.hasWarnedDeprecation) {
-      this.hasWarnedDeprecation = true;
-      console.warn('[PostHog Prompts] Calling get() without { withMetadata: true } is deprecated and will be ' + 'removed in a future major version. Pass { withMetadata: true } to receive a PromptResult ' + 'object with source, name, and version metadata. ' + 'You can pass { withMetadata: false } to silence this warning, but the plain-string return ' + 'will still be removed in the next major version.');
-    }
     try {
-      const result = await this.getInternal(name, options);
-      if (withMetadata) {
-        return result;
-      }
-      return result.prompt;
+      return await this.getInternal(name, options);
     } catch (error) {
       const fallback = options?.fallback;
       if (fallback !== undefined) {
         const promptLabel = this.getPromptLabel(name, options?.version);
         console.warn(`[PostHog Prompts] Failed to fetch prompt ${promptLabel}, using fallback:`, error);
-        if (withMetadata) {
-          return {
-            source: 'code_fallback',
-            prompt: fallback,
-            name: undefined,
-            version: undefined
-          };
-        }
-        return fallback;
+        return {
+          source: 'code_fallback',
+          prompt: fallback,
+          name: undefined,
+          version: undefined
+        };
       }
       throw error;
     }
@@ -4844,11 +1421,6 @@ class Prompts {
   }
 }
 
-exports.Anthropic = PostHogAnthropic;
-exports.AzureOpenAI = PostHogAzureOpenAI;
-exports.GoogleGenAI = PostHogGoogleGenAI;
-exports.LangChainCallbackHandler = LangChainCallbackHandler;
-exports.OpenAI = PostHogOpenAI;
 exports.Prompts = Prompts;
 exports.captureAiGeneration = captureAiGeneration;
 exports.withTracing = wrapVercelLanguageModel;