@posthog/ai 8.10.0 → 8.10.2

package/dist/openai/index.mjs

@@ -1,2663 +1,2130 @@
-import { AzureOpenAI, OpenAI } from 'openai';
-import { v4 } from 'uuid';
-import { toJsonSafeValue, uuidv7 } from '@posthog/core';
-import { Stream } from 'openai/streaming';
-
-// Type guards for safer type checking
-
-const isString = value => {
-  return typeof value === 'string';
+import { AzureOpenAI, OpenAI } from "openai";
+import { v4 } from "uuid";
+import { toJsonSafeValue, uuidv7 } from "@posthog/core";
+import { Stream } from "openai/streaming";
+//#region src/typeGuards.ts
+const isString = (value) => {
+	return typeof value === "string";
 };
-
-/** @internal */
-
-/** @internal */
-
+//#endregion
+//#region src/captureAiEvent.ts
 /** @internal */
 function isFullAiCaptureEnabled(client) {
-  return client?.enableFullAiCapture === true;
+	return client?.enableFullAiCapture === true;
 }
-
 /** @internal */
 function captureAiEvent(client, event) {
-  if (isFullAiCaptureEnabled(client) && typeof client.captureAi === 'function') {
-    client.captureAi(event);
-    return;
-  }
-  client.capture(event);
+	if (isFullAiCaptureEnabled(client) && typeof client.captureAi === "function") {
+		client.captureAi(event);
+		return;
+	}
+	client.capture(event);
 }
-
 /** @internal */
 async function captureAiEventImmediate(client, event) {
-  if (isFullAiCaptureEnabled(client) && typeof client.captureAiImmediate === 'function') {
-    await client.captureAiImmediate(event);
-    return;
-  }
-  await client.captureImmediate(event);
+	if (isFullAiCaptureEnabled(client) && typeof client.captureAiImmediate === "function") {
+		await client.captureAiImmediate(event);
+		return;
+	}
+	await client.captureImmediate(event);
 }
-
+//#endregion
+//#region src/sanitization/base64_recognizer.ts
 const DATA_URL_PREFIX_RE = /^data:([^;,\s]+)(?:;[^;,\s]+)*;base64,/i;
 const BASE64_ALPHABET_RE = /^[A-Za-z0-9+/_=-]+$/;
-class Base64Recognizer {
-  recognize(value, minLength) {
-    const dataUrl = DATA_URL_PREFIX_RE.exec(value);
-    if (dataUrl) return {
-      kind: 'data-url',
-      mediaType: dataUrl[1]
-    };
-    if (value.length < minLength) return {
-      kind: 'none'
-    };
-    const confidencePrefix = value.slice(0, minLength);
-    if (BASE64_ALPHABET_RE.test(confidencePrefix)) {
-      return {
-        kind: 'raw'
-      };
-    } else {
-      return {
-        kind: 'none'
-      };
-    }
-  }
-}
-
-const MIME_HINT_KEYS = ['mediaType', 'media_type', 'mimeType', 'mime_type'];
-const STRONG_CONTEXT_KEYS = new Set(['data', 'file_data', 'fileData', 'image_url', 'imageUrl', 'video_url', 'videoUrl', 'audio', 'audio_data', 'audioData', 'inline_data', 'inlineData', 'source', 'result']);
-const STRONG_CONTEXT_TYPES = new Set(['image', 'image_url', 'input_image', 'audio', 'input_audio', 'video', 'video_url', 'file', 'input_file', 'document', 'media', 'file-data']);
-const FILE_FAMILY_TYPES = new Set(['file', 'input_file', 'document', 'media', 'file-data']);
-const KNOWN_AUDIO_FORMATS = new Set(['wav', 'mp3', 'ogg', 'flac', 'm4a', 'aac', 'webm']);
-class MediaTypeContext {
-  static EMPTY = new MediaTypeContext(undefined, undefined);
-  constructor(parent, key, explicitMediaType) {
-    this.parent = parent;
-    this.key = key;
-    this.explicitMediaType = explicitMediaType;
-  }
-  inferMediaType() {
-    return this.inferFromSiblingMime() ?? this.inferFromSiblingFormat() ?? this.inferFromParentType() ?? this.inferFromKey();
-  }
-  inferFromSiblingMime() {
-    if (this.explicitMediaType) return this.explicitMediaType;
-    if (!this.parent) return undefined;
-    for (const hint of MIME_HINT_KEYS) {
-      const v = this.parent[hint];
-      if (typeof v === 'string') return v;
-    }
-    return undefined;
-  }
-  inferFromSiblingFormat() {
-    if (!this.parent) return undefined;
-    const fmt = this.parent.format;
-    if (typeof fmt === 'string' && KNOWN_AUDIO_FORMATS.has(fmt.toLowerCase())) {
-      return `audio/${fmt.toLowerCase()}`;
-    }
-    return undefined;
-  }
-  inferFromParentType() {
-    if (!this.parent) return undefined;
-    const t = this.parent.type;
-    if (typeof t !== 'string') return undefined;
-    if (t === 'image' || t === 'image_url' || t === 'input_image') return 'image';
-    if (t === 'audio' || t === 'input_audio') return 'audio';
-    if (t === 'video' || t === 'video_url') return 'video';
-    if (FILE_FAMILY_TYPES.has(t)) return 'application/octet-stream';
-    return undefined;
-  }
-  inferFromKey() {
-    if (!this.key) return undefined;
-    const key = this.key.toLowerCase();
-    if (key.includes('audio')) return 'audio';
-    if (key.includes('video')) return 'video';
-    if (key.includes('image')) return 'image';
-    if (key.includes('file') || key.includes('document')) return 'application/octet-stream';
-    return undefined;
-  }
-  hasExplicitBinaryMediaType() {
-    if (!this.explicitMediaType && (!this.parent || !this.key || !STRONG_CONTEXT_KEYS.has(this.key))) return false;
-    const mediaType = this.inferFromSiblingMime();
-    return mediaType !== undefined && !mediaType.toLowerCase().startsWith('text/');
-  }
-  signalsBinary() {
-    if (this.explicitMediaType) return true;
-    if (this.parent) {
-      for (const hint of MIME_HINT_KEYS) {
-        if (typeof this.parent[hint] === 'string') return true;
-      }
-      const fmt = this.parent.format;
-      if (typeof fmt === 'string' && KNOWN_AUDIO_FORMATS.has(fmt.toLowerCase())) return true;
-      const t = this.parent.type;
-      if (typeof t === 'string' && STRONG_CONTEXT_TYPES.has(t)) return true;
-    }
-    if (this.key && STRONG_CONTEXT_KEYS.has(this.key)) return true;
-    return false;
-  }
-}
-
+var Base64Recognizer = class {
+	recognize(value, minLength) {
+		const dataUrl = DATA_URL_PREFIX_RE.exec(value);
+		if (dataUrl) return {
+			kind: "data-url",
+			mediaType: dataUrl[1]
+		};
+		if (value.length < minLength) return { kind: "none" };
+		const confidencePrefix = value.slice(0, minLength);
+		if (BASE64_ALPHABET_RE.test(confidencePrefix)) return { kind: "raw" };
+		else return { kind: "none" };
+	}
+};
+//#endregion
+//#region src/sanitization/media_type_context.ts
+const MIME_HINT_KEYS = [
+	"mediaType",
+	"media_type",
+	"mimeType",
+	"mime_type"
+];
+const STRONG_CONTEXT_KEYS = /* @__PURE__ */ new Set([
+	"data",
+	"file_data",
+	"fileData",
+	"image_url",
+	"imageUrl",
+	"video_url",
+	"videoUrl",
+	"audio",
+	"audio_data",
+	"audioData",
+	"inline_data",
+	"inlineData",
+	"source",
+	"result"
+]);
+const STRONG_CONTEXT_TYPES = /* @__PURE__ */ new Set([
+	"image",
+	"image_url",
+	"input_image",
+	"audio",
+	"input_audio",
+	"video",
+	"video_url",
+	"file",
+	"input_file",
+	"document",
+	"media",
+	"file-data"
+]);
+const FILE_FAMILY_TYPES = /* @__PURE__ */ new Set([
+	"file",
+	"input_file",
+	"document",
+	"media",
+	"file-data"
+]);
+const KNOWN_AUDIO_FORMATS = /* @__PURE__ */ new Set([
+	"wav",
+	"mp3",
+	"ogg",
+	"flac",
+	"m4a",
+	"aac",
+	"webm"
+]);
+var MediaTypeContext = class MediaTypeContext {
+	static {
+		this.EMPTY = new MediaTypeContext(void 0, void 0);
+	}
+	constructor(parent, key, explicitMediaType) {
+		this.parent = parent;
+		this.key = key;
+		this.explicitMediaType = explicitMediaType;
+	}
+	inferMediaType() {
+		return this.inferFromSiblingMime() ?? this.inferFromSiblingFormat() ?? this.inferFromParentType() ?? this.inferFromKey();
+	}
+	inferFromSiblingMime() {
+		if (this.explicitMediaType) return this.explicitMediaType;
+		if (!this.parent) return void 0;
+		for (const hint of MIME_HINT_KEYS) {
+			const v = this.parent[hint];
+			if (typeof v === "string") return v;
+		}
+	}
+	inferFromSiblingFormat() {
+		if (!this.parent) return void 0;
+		const fmt = this.parent.format;
+		if (typeof fmt === "string" && KNOWN_AUDIO_FORMATS.has(fmt.toLowerCase())) return `audio/${fmt.toLowerCase()}`;
+	}
+	inferFromParentType() {
+		if (!this.parent) return void 0;
+		const t = this.parent.type;
+		if (typeof t !== "string") return void 0;
+		if (t === "image" || t === "image_url" || t === "input_image") return "image";
+		if (t === "audio" || t === "input_audio") return "audio";
+		if (t === "video" || t === "video_url") return "video";
+		if (FILE_FAMILY_TYPES.has(t)) return "application/octet-stream";
+	}
+	inferFromKey() {
+		if (!this.key) return void 0;
+		const key = this.key.toLowerCase();
+		if (key.includes("audio")) return "audio";
+		if (key.includes("video")) return "video";
+		if (key.includes("image")) return "image";
+		if (key.includes("file") || key.includes("document")) return "application/octet-stream";
+	}
+	hasExplicitBinaryMediaType() {
+		if (!this.explicitMediaType && (!this.parent || !this.key || !STRONG_CONTEXT_KEYS.has(this.key))) return false;
+		const mediaType = this.inferFromSiblingMime();
+		return mediaType !== void 0 && !mediaType.toLowerCase().startsWith("text/");
+	}
+	signalsBinary() {
+		if (this.explicitMediaType) return true;
+		if (this.parent) {
+			for (const hint of MIME_HINT_KEYS) if (typeof this.parent[hint] === "string") return true;
+			const fmt = this.parent.format;
+			if (typeof fmt === "string" && KNOWN_AUDIO_FORMATS.has(fmt.toLowerCase())) return true;
+			const t = this.parent.type;
+			if (typeof t === "string" && STRONG_CONTEXT_TYPES.has(t)) return true;
+		}
+		if (this.key && STRONG_CONTEXT_KEYS.has(this.key)) return true;
+		return false;
+	}
+};
+//#endregion
+//#region src/sanitization/binary_content_redactor.ts
 const STRONG_CONTEXT_MIN_LENGTH = 64;
 const WEAK_CONTEXT_MIN_LENGTH = 1024;
-class BinaryContentRedactor {
-  visited = new WeakSet();
-  constructor(recognizer = new Base64Recognizer()) {
-    this.recognizer = recognizer;
-  }
-  redact(value, mediaType) {
-    this.visited = new WeakSet();
-    return this.walk(value, mediaType ? new MediaTypeContext(undefined, undefined, mediaType) : MediaTypeContext.EMPTY);
-  }
-  walk(value, ctx) {
-    if (value === null || value === undefined) return value;
-    if (typeof value === 'string') return this.redactString(value, ctx);
-    if (typeof value !== 'object') return value;
-
-    // Buffer extends Uint8Array, so this branch catches both.
-    if (typeof Uint8Array !== 'undefined' && value instanceof Uint8Array) {
-      return this.placeholderFor(ctx.inferMediaType());
-    }
-    if (this.visited.has(value)) return null;
-    this.visited.add(value);
-    if (Array.isArray(value)) {
-      return value.map(item => this.walk(item, ctx));
-    }
-    const obj = value;
-    const out = {};
-    for (const k of Object.keys(obj)) {
-      out[k] = this.walk(obj[k], new MediaTypeContext(obj, k));
-    }
-    return out;
-  }
-  redactString(value, ctx) {
-    const hasExplicitBinaryMediaType = ctx.hasExplicitBinaryMediaType();
-    const recognitionValue = hasExplicitBinaryMediaType ? value.replace(/[\r\n]/g, '') : value;
-    const minLength = hasExplicitBinaryMediaType ? Math.min(recognitionValue.length, STRONG_CONTEXT_MIN_LENGTH) : ctx.signalsBinary() ? STRONG_CONTEXT_MIN_LENGTH : WEAK_CONTEXT_MIN_LENGTH;
-    const recognition = this.recognizer.recognize(recognitionValue, minLength);
-    switch (recognition.kind) {
-      case 'data-url':
-        return this.placeholderFor(recognition.mediaType);
-      case 'raw':
-        return this.placeholderFor(ctx.inferMediaType());
-      case 'none':
-        return value;
-    }
-  }
-  placeholderFor(mediaType) {
-    if (!mediaType) return '[base64 redacted]';
-    if (mediaType === 'application/octet-stream') return '[base64 file redacted]';
-    return `[base64 ${mediaType} redacted]`;
-  }
-}
-
+var BinaryContentRedactor = class {
+	constructor(recognizer = new Base64Recognizer()) {
+		this.recognizer = recognizer;
+		this.visited = /* @__PURE__ */ new WeakSet();
+	}
+	redact(value, mediaType) {
+		this.visited = /* @__PURE__ */ new WeakSet();
+		return this.walk(value, mediaType ? new MediaTypeContext(void 0, void 0, mediaType) : MediaTypeContext.EMPTY);
+	}
+	walk(value, ctx) {
+		if (value === null || value === void 0) return value;
+		if (typeof value === "string") return this.redactString(value, ctx);
+		if (typeof value !== "object") return value;
+		if (typeof Uint8Array !== "undefined" && value instanceof Uint8Array) return this.placeholderFor(ctx.inferMediaType());
+		if (this.visited.has(value)) return null;
+		this.visited.add(value);
+		if (Array.isArray(value)) return value.map((item) => this.walk(item, ctx));
+		const obj = value;
+		const out = {};
+		for (const k of Object.keys(obj)) out[k] = this.walk(obj[k], new MediaTypeContext(obj, k));
+		return out;
+	}
+	redactString(value, ctx) {
+		const hasExplicitBinaryMediaType = ctx.hasExplicitBinaryMediaType();
+		const recognitionValue = hasExplicitBinaryMediaType ? value.replace(/[\r\n]/g, "") : value;
+		const minLength = hasExplicitBinaryMediaType ? Math.min(recognitionValue.length, STRONG_CONTEXT_MIN_LENGTH) : ctx.signalsBinary() ? STRONG_CONTEXT_MIN_LENGTH : WEAK_CONTEXT_MIN_LENGTH;
+		const recognition = this.recognizer.recognize(recognitionValue, minLength);
+		switch (recognition.kind) {
+			case "data-url": return this.placeholderFor(recognition.mediaType);
+			case "raw": return this.placeholderFor(ctx.inferMediaType());
+			case "none": return value;
+		}
+	}
+	placeholderFor(mediaType) {
+		if (!mediaType) return "[base64 redacted]";
+		if (mediaType === "application/octet-stream") return "[base64 file redacted]";
+		return `[base64 ${mediaType} redacted]`;
+	}
+};
+//#endregion
+//#region src/sanitization.ts
 const redactor = new BinaryContentRedactor();
 const sanitize = (data, client) => isFullAiCaptureEnabled(client) ? data : redactor.redact(data);
 const sanitizeOpenAI = (data, client) => sanitize(data, client);
 const sanitizeOpenAIResponse = (data, client) => sanitize(data, client);
-
-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']);
-
+//#endregion
+//#region src/utils.ts
+const TOKEN_PROPERTY_KEYS = /* @__PURE__ */ new Set([
+	"$ai_input_tokens",
+	"$ai_output_tokens",
+	"$ai_cache_read_input_tokens",
+	"$ai_cache_creation_input_tokens",
+	"$ai_total_tokens",
+	"$ai_reasoning_tokens"
+]);
 /**
- * Whether the caller supplied their own token counts, which override the ones the SDK
- * derived from the provider response.
- */
+* Whether the caller supplied their own token counts, which override the ones the SDK
+* derived from the provider response.
+*/
 function hasTokenOverrides(posthogProperties) {
-  return !!posthogProperties && Object.keys(posthogProperties).some(key => TOKEN_PROPERTY_KEYS.has(key));
+	return !!posthogProperties && Object.keys(posthogProperties).some((key) => TOKEN_PROPERTY_KEYS.has(key));
 }
 function getTokensSource(posthogProperties) {
-  return hasTokenOverrides(posthogProperties) ? 'passthrough' : 'sdk';
+	return hasTokenOverrides(posthogProperties) ? "passthrough" : "sdk";
 }
-const STRING_FORMAT = 'utf8';
-
-// Reused across calls to avoid per-invocation allocation; truncate() runs
-// hundreds of times for prompts with many parts.
+const STRING_FORMAT = "utf8";
 new TextEncoder();
-new TextDecoder(STRING_FORMAT, {
-  fatal: false
-});
-
+new TextDecoder(STRING_FORMAT, { fatal: false });
 /**
- * Safely converts content to a string, preserving structure for objects/arrays.
- * - If content is already a string, returns it as-is
- * - If content is an object or array, stringifies it with JSON.stringify to preserve structure
- * - Otherwise, converts to string with String()
- *
- * This prevents the "[object Object]" bug when objects are naively converted to strings.
- *
- * @param content - The content to convert to a string
- * @returns A string representation that preserves structure for complex types
- */
+* Safely converts content to a string, preserving structure for objects/arrays.
+* - If content is already a string, returns it as-is
+* - If content is an object or array, stringifies it with JSON.stringify to preserve structure
+* - Otherwise, converts to string with String()
+*
+* This prevents the "[object Object]" bug when objects are naively converted to strings.
+*
+* @param content - The content to convert to a string
+* @returns A string representation that preserves structure for complex types
+*/
 function toContentString(content) {
-  if (typeof content === 'string') {
-    return content;
-  }
-  if (content !== undefined && content !== null && typeof content === 'object') {
-    try {
-      return JSON.stringify(content);
-    } catch {
-      // Fallback for circular refs, BigInt, or objects with throwing toJSON
-      return String(content);
-    }
-  }
-  return String(content);
+	if (typeof content === "string") return content;
+	if (content !== void 0 && content !== null && typeof content === "object") try {
+		return JSON.stringify(content);
+	} catch {
+		return String(content);
+	}
+	return String(content);
 }
 const getModelParams = (params, responseServiceTier) => {
-  if (!params) {
-    return {};
-  }
-  const modelParams = {};
-  const paramKeys = ['temperature', 'max_tokens', 'max_completion_tokens', 'top_p', 'frequency_penalty', 'presence_penalty', 'n', 'stop', 'stream', 'streaming', 'language', 'response_format', 'timestamp_granularities', 'service_tier'];
-  for (const key of paramKeys) {
-    if (key in params && params[key] !== undefined) {
-      modelParams[key] = params[key];
-    }
-  }
-  if (responseServiceTier != null) {
-    modelParams.service_tier = responseServiceTier;
-  }
-  return modelParams;
+	if (!params) return {};
+	const modelParams = {};
+	for (const key of [
+		"temperature",
+		"max_tokens",
+		"max_completion_tokens",
+		"top_p",
+		"frequency_penalty",
+		"presence_penalty",
+		"n",
+		"stop",
+		"stream",
+		"streaming",
+		"language",
+		"response_format",
+		"timestamp_granularities",
+		"service_tier"
+	]) if (key in params && params[key] !== void 0) modelParams[key] = params[key];
+	if (responseServiceTier != null) modelParams.service_tier = responseServiceTier;
+	return modelParams;
 };
-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 || {}
-          }
-        });
-      } else if (item.type === 'image_generation_call' && item.result) {
-        content.push({
-          type: 'image',
-          image: item.result
-        });
-      }
-    }
-    if (content.length > 0) {
-      output.push({
-        role,
-        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
+				}
+			});
+			if (choice.message.audio) content.push({
+				type: "audio",
+				...choice.message.audio
+			});
+		}
+		if (content.length > 0) output.push({
+			role,
+			content
+		});
+	}
+	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 || {}
+			}
+		});
+		else if (item.type === "image_generation_call" && item.result) content.push({
+			type: "image",
+			image: item.result
+		});
+		if (content.length > 0) output.push({
+			role,
+			content
+		});
+	}
+	return output;
 };
 const withPrivacyMode = (client, privacyMode, input) => {
-  return client.privacy_mode || privacyMode ? null : input;
+	return client.privacy_mode || privacyMode ? null : input;
 };
-
 /**
- * Calculate web search count from raw API response.
- *
- * Uses a two-tier detection strategy:
- * Priority 1 (Exact Count): Count actual web search calls when available
- * Priority 2 (Binary Detection): Return 1 if web search indicators are present, 0 otherwise
- *
- * @param result - Raw API response from any provider (OpenAI, Perplexity, OpenRouter, Gemini, etc.)
- * @returns Number of web searches performed (exact count or binary 1/0)
- */
+* Calculate web search count from raw API response.
+*
+* Uses a two-tier detection strategy:
+* Priority 1 (Exact Count): Count actual web search calls when available
+* Priority 2 (Binary Detection): Return 1 if web search indicators are present, 0 otherwise
+*
+* @param result - Raw API response from any provider (OpenAI, Perplexity, OpenRouter, Gemini, etc.)
+* @returns Number of web searches performed (exact count or binary 1/0)
+*/
 function calculateWebSearchCount(result) {
-  if (!result || typeof result !== 'object') {
-    return 0;
-  }
-
-  // Priority 1: Exact Count
-  // Check for OpenAI Responses API web_search_call items
-  if ('output' in result && Array.isArray(result.output)) {
-    let count = 0;
-    for (const item of result.output) {
-      if (typeof item === 'object' && item !== null && 'type' in item && item.type === 'web_search_call') {
-        count++;
-      }
-    }
-    if (count > 0) {
-      return count;
-    }
-  }
-
-  // Priority 2: Binary Detection (1 or 0)
-
-  // Check for citations at root level (Perplexity)
-  if ('citations' in result && Array.isArray(result.citations) && result.citations.length > 0) {
-    return 1;
-  }
-
-  // Check for search_results at root level (Perplexity via OpenRouter)
-  if ('search_results' in result && Array.isArray(result.search_results) && result.search_results.length > 0) {
-    return 1;
-  }
-
-  // Check for usage.search_context_size (Perplexity via OpenRouter)
-  if ('usage' in result && typeof result.usage === 'object' && result.usage !== null) {
-    if ('search_context_size' in result.usage && result.usage.search_context_size) {
-      return 1;
-    }
-  }
-
-  // Check for annotations with url_citation in choices[].message or choices[].delta (OpenAI/Perplexity)
-  if ('choices' in result && Array.isArray(result.choices)) {
-    for (const choice of result.choices) {
-      if (typeof choice === 'object' && choice !== null) {
-        // Check both message (non-streaming) and delta (streaming) for annotations
-        const content = ('message' in choice ? choice.message : null) || ('delta' in choice ? choice.delta : null);
-        if (typeof content === 'object' && content !== null && 'annotations' in content) {
-          const annotations = content.annotations;
-          if (Array.isArray(annotations)) {
-            const hasUrlCitation = annotations.some(ann => {
-              return typeof ann === 'object' && ann !== null && 'type' in ann && ann.type === 'url_citation';
-            });
-            if (hasUrlCitation) {
-              return 1;
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // Check for annotations in output[].content[] (OpenAI Responses API)
-  if ('output' in result && Array.isArray(result.output)) {
-    for (const item of result.output) {
-      if (typeof item === 'object' && item !== null && 'content' in item) {
-        const content = item.content;
-        if (Array.isArray(content)) {
-          for (const contentItem of content) {
-            if (typeof contentItem === 'object' && contentItem !== null && 'annotations' in contentItem) {
-              const annotations = contentItem.annotations;
-              if (Array.isArray(annotations)) {
-                const hasUrlCitation = annotations.some(ann => {
-                  return typeof ann === 'object' && ann !== null && 'type' in ann && ann.type === 'url_citation';
-                });
-                if (hasUrlCitation) {
-                  return 1;
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-
-  // Check for grounding_metadata (Gemini)
-  if ('candidates' in result && Array.isArray(result.candidates)) {
-    for (const candidate of result.candidates) {
-      if (typeof candidate === 'object' && candidate !== null && 'grounding_metadata' in candidate && candidate.grounding_metadata) {
-        return 1;
-      }
-    }
-  }
-  return 0;
+	if (!result || typeof result !== "object") return 0;
+	if ("output" in result && Array.isArray(result.output)) {
+		let count = 0;
+		for (const item of result.output) if (typeof item === "object" && item !== null && "type" in item && item.type === "web_search_call") count++;
+		if (count > 0) return count;
+	}
+	if ("citations" in result && Array.isArray(result.citations) && result.citations.length > 0) return 1;
+	if ("search_results" in result && Array.isArray(result.search_results) && result.search_results.length > 0) return 1;
+	if ("usage" in result && typeof result.usage === "object" && result.usage !== null) {
+		if ("search_context_size" in result.usage && result.usage.search_context_size) return 1;
+	}
+	if ("choices" in result && Array.isArray(result.choices)) {
+		for (const choice of result.choices) if (typeof choice === "object" && choice !== null) {
+			const content = ("message" in choice ? choice.message : null) || ("delta" in choice ? choice.delta : null);
+			if (typeof content === "object" && content !== null && "annotations" in content) {
+				const annotations = content.annotations;
+				if (Array.isArray(annotations)) {
+					if (annotations.some((ann) => {
+						return typeof ann === "object" && ann !== null && "type" in ann && ann.type === "url_citation";
+					})) return 1;
+				}
+			}
+		}
+	}
+	if ("output" in result && Array.isArray(result.output)) {
+		for (const item of result.output) if (typeof item === "object" && item !== null && "content" in item) {
+			const content = item.content;
+			if (Array.isArray(content)) {
+				for (const contentItem of content) if (typeof contentItem === "object" && contentItem !== null && "annotations" in contentItem) {
+					const annotations = contentItem.annotations;
+					if (Array.isArray(annotations)) {
+						if (annotations.some((ann) => {
+							return typeof ann === "object" && ann !== null && "type" in ann && ann.type === "url_citation";
+						})) return 1;
+					}
+				}
+			}
+		}
+	}
+	if ("candidates" in result && Array.isArray(result.candidates)) {
+		for (const candidate of result.candidates) if (typeof candidate === "object" && candidate !== null && "grounding_metadata" in candidate && candidate.grounding_metadata) return 1;
+	}
+	return 0;
 }
-
 /**
- * Extract available tool calls from the request parameters.
- * These are the tools provided to the LLM, not the tool calls in the response.
- */
+* Extract available tool calls from the request parameters.
+* These are the tools provided to the LLM, not the tool calls in the response.
+*/
 const extractAvailableToolCalls = (provider, params) => {
-  {
-    if (params.tools) {
-      return params.tools;
-    }
-    return null;
-  }
+	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;
 };
-let AIEvent = /*#__PURE__*/function (AIEvent) {
-  AIEvent["Generation"] = "$ai_generation";
-  AIEvent["Embedding"] = "$ai_embedding";
-  return AIEvent;
-}({});
 function sanitizeValues(obj) {
-  if (obj === undefined || obj === null) {
-    return obj;
-  }
-  const jsonSafe = JSON.parse(JSON.stringify(obj));
-  if (typeof jsonSafe === 'string') {
-    // Sanitize lone surrogates by round-tripping through UTF-8
-    return new TextDecoder().decode(new TextEncoder().encode(jsonSafe));
-  } else if (Array.isArray(jsonSafe)) {
-    return jsonSafe.map(sanitizeValues);
-  } else if (jsonSafe && typeof jsonSafe === 'object') {
-    return Object.fromEntries(Object.entries(jsonSafe).map(([k, v]) => [k, sanitizeValues(v)]));
-  }
-  return jsonSafe;
+	if (obj === void 0 || obj === null) return obj;
+	const jsonSafe = JSON.parse(JSON.stringify(obj));
+	if (typeof jsonSafe === "string") return new TextDecoder().decode(new TextEncoder().encode(jsonSafe));
+	else if (Array.isArray(jsonSafe)) return jsonSafe.map(sanitizeValues);
+	else if (jsonSafe && typeof jsonSafe === "object") return Object.fromEntries(Object.entries(jsonSafe).map(([k, v]) => [k, sanitizeValues(v)]));
+	return jsonSafe;
 }
 const POSTHOG_PARAMS_MAP = {
-  posthogDistinctId: 'distinctId',
-  posthogTraceId: 'traceId',
-  posthogProperties: 'properties',
-  posthogPrivacyMode: 'privacyMode',
-  posthogGroups: 'groups',
-  posthogModelOverride: 'modelOverride',
-  posthogProviderOverride: 'providerOverride',
-  posthogCostOverride: 'costOverride',
-  posthogCaptureImmediate: 'captureImmediate'
+	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)
-  };
+	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,
+		posthogParams: addDefaults(posthogParams)
+	};
 }
 function addDefaults(params) {
-  return {
-    ...params,
-    privacyMode: params.privacyMode ?? false,
-    traceId: params.traceId ?? v4()
-  };
+	return {
+		...params,
+		privacyMode: params.privacyMode ?? false,
+		traceId: params.traceId ?? 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;
+	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";
+		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 = "8.10.0";
-
+//#endregion
+//#region package.json
+var version = "8.10.2";
+//#endregion
+//#region src/serializeError.ts
 const DEFAULT_MAX_DEPTH = 3;
 const MAX_STACK_LINES = 20;
 function serializeError(value, depth = DEFAULT_MAX_DEPTH) {
-  if (depth < 0 || value === null || typeof value !== 'object') {
-    return value;
-  }
-  if (value instanceof Error) {
-    const out = {
-      name: value.name,
-      message: value.message,
-      stack: truncateStack(value.stack)
-    };
-    for (const key of Object.keys(value)) {
-      out[key] = serializeError(value[key], depth - 1);
-    }
-    if (value.cause !== undefined) {
-      out.cause = serializeError(value.cause, depth - 1);
-    }
-    return out;
-  }
-  if (Array.isArray(value)) {
-    return value.map(item => serializeError(item, depth - 1));
-  }
-  return value;
+	if (depth < 0 || value === null || typeof value !== "object") return value;
+	if (value instanceof Error) {
+		const out = {
+			name: value.name,
+			message: value.message,
+			stack: truncateStack(value.stack)
+		};
+		for (const key of Object.keys(value)) out[key] = serializeError(value[key], depth - 1);
+		if (value.cause !== void 0) out.cause = serializeError(value.cause, depth - 1);
+		return out;
+	}
+	if (Array.isArray(value)) return value.map((item) => serializeError(item, depth - 1));
+	return value;
 }
 function stringifyError(error) {
-  try {
-    return JSON.stringify(sanitizeValues(serializeError(error)));
-  } catch {
-    if (error instanceof Error) {
-      return JSON.stringify({
-        name: error.name,
-        message: error.message
-      });
-    }
-    return JSON.stringify({
-      message: String(error)
-    });
-  }
+	try {
+		return JSON.stringify(sanitizeValues(serializeError(error)));
+	} catch {
+		if (error instanceof Error) return JSON.stringify({
+			name: error.name,
+			message: error.message
+		});
+		return JSON.stringify({ message: String(error) });
+	}
 }
 function truncateStack(stack) {
-  if (!stack) {
-    return stack;
-  }
-  const lines = stack.split('\n');
-  if (lines.length <= MAX_STACK_LINES) {
-    return stack;
-  }
-  return [...lines.slice(0, MAX_STACK_LINES), '... (truncated)'].join('\n');
+	if (!stack) return stack;
+	const lines = stack.split("\n");
+	if (lines.length <= MAX_STACK_LINES) return stack;
+	return [...lines.slice(0, MAX_STACK_LINES), "... (truncated)"].join("\n");
 }
-
-// Warn when a wrapper's base_url points at the PostHog AI Gateway: the gateway
-// emits its own $ai_generation, so each call would be captured (and, for billable
-// products, billed) twice. We only warn — the wrapper's event carries data the
-// gateway never sees (groups, custom properties, trace hierarchy).
-
-// Keep in sync with the gateway's deployed hosts (see services/llm-gateway in the
-// main repo). gateway.us.posthog.com is live today; the rest are listed ahead of
-// any traffic moving to them.
-const POSTHOG_AI_GATEWAY_HOSTS = ['gateway.posthog.com', 'gateway.us.posthog.com', 'gateway.eu.posthog.com', 'ai-gateway.us.posthog.com', 'ai-gateway.eu.posthog.com'];
-
-// Swap for the dedicated AI Gateway page once it ships.
-const GATEWAY_DOCS_URL = 'https://posthog.com/docs/ai-observability';
-const extractHost = baseURL => {
-  try {
-    // Tolerate bare hosts that omit a scheme, e.g. "gateway.us.posthog.com/v1".
-    const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(baseURL);
-    return new URL(hasScheme ? baseURL : `https://${baseURL}`).hostname.toLowerCase();
-  } catch {
-    return undefined;
-  }
+//#endregion
+//#region src/gatewayWarning.ts
+const POSTHOG_AI_GATEWAY_HOSTS = [
+	"gateway.posthog.com",
+	"gateway.us.posthog.com",
+	"gateway.eu.posthog.com",
+	"ai-gateway.us.posthog.com",
+	"ai-gateway.eu.posthog.com"
+];
+const GATEWAY_DOCS_URL = "https://posthog.com/docs/ai-observability";
+const extractHost = (baseURL) => {
+	try {
+		const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(baseURL);
+		return new URL(hasScheme ? baseURL : `https://${baseURL}`).hostname.toLowerCase();
+	} catch {
+		return;
+	}
 };
-const isPostHogAiGatewayUrl = baseURL => {
-  if (!baseURL) {
-    return false;
-  }
-  const host = extractHost(baseURL);
-  return host !== undefined && POSTHOG_AI_GATEWAY_HOSTS.includes(host);
+const isPostHogAiGatewayUrl = (baseURL) => {
+	if (!baseURL) return false;
+	const host = extractHost(baseURL);
+	return host !== void 0 && POSTHOG_AI_GATEWAY_HOSTS.includes(host);
 };
-
-// Warns on every gateway call by design: the misconfiguration is impossible to
-// miss that way, and a doubled bill is worse than noisy logs.
-const warnIfPostHogAiGateway = baseURL => {
-  if (!isPostHogAiGatewayUrl(baseURL)) {
-    return;
-  }
-  console.warn('[PostHog] The PostHog AI wrapper is pointed at the PostHog AI Gateway. ' + 'Both capture $ai_generation, so every call is double-counted and double-billed. ' + `Use one or the other — see ${GATEWAY_DOCS_URL}.`);
+const warnIfPostHogAiGateway = (baseURL) => {
+	if (!isPostHogAiGatewayUrl(baseURL)) return;
+	console.warn(`[PostHog] The PostHog AI wrapper is pointed at the PostHog AI Gateway. Both capture \$ai_generation, so every call is double-counted and double-billed. Use one or the other — see ${GATEWAY_DOCS_URL}.`);
 };
-
+//#endregion
+//#region src/captureAiGeneration.ts
 /**
- * Options for `captureAiGeneration`. Mirrors the `$ai_generation` event shape
- * directly so that any caller — first-party SDK wrappers and external code
- * alike — produces an identical event.
- */
-
-/**
- * Capture an `$ai_generation` (or `$ai_embedding`) event to PostHog.
- *
- * This is the canonical primitive that every `@posthog/ai` wrapper
- * (`withTracing`, `OpenAI`, `Anthropic`, `GoogleGenAI`, …) funnels through, so
- * external code can use it directly to instrument LLM calls made through
- * arbitrary clients (Cloudflare Workers AI, custom HTTP, etc.) and get the
- * same events the SDK wrappers produce.
- *
- * When `error` is set, the event is captured as an error. If the error is an
- * object, it is mutated in place to set `__posthog_previously_captured_error`
- * so callers can re-throw the original error reference safely.
- */
+* Capture an `$ai_generation` (or `$ai_embedding`) event to PostHog.
+*
+* This is the canonical primitive that every `@posthog/ai` wrapper
+* (`withTracing`, `OpenAI`, `Anthropic`, `GoogleGenAI`, …) funnels through, so
+* external code can use it directly to instrument LLM calls made through
+* arbitrary clients (Cloudflare Workers AI, custom HTTP, etc.) and get the
+* same events the SDK wrappers produce.
+*
+* When `error` is set, the event is captured as an error. If the error is an
+* object, it is mutated in place to set `__posthog_previously_captured_error`
+* so callers can re-throw the original error reference safely.
+*/
 const captureAiGeneration$1 = async (client, options) => {
-  try {
-    if (!client.capture) {
-      return;
-    }
-    warnIfPostHogAiGateway(options.baseURL);
-    const traceId = options.traceId ?? v4();
-    const eventType = options.eventType ?? AIEvent.Generation;
-    const privacyMode = options.privacyMode ?? false;
-    const usage = options.usage ?? {};
-
-    // Check privacy before reading or traversing input/output. Besides avoiding
-    // needless work, this ensures hostile getters/proxies cannot observe a value
-    // that the caller explicitly requested us to redact.
-    const shouldRedact = withPrivacyMode(client, privacyMode, false) === null;
-    const safeInput = shouldRedact ? null : toJsonSafeValue(options.input);
-    const safeOutput = shouldRedact ? null : toJsonSafeValue(options.output);
-    let httpStatus = options.httpStatus;
-    let errorData = {};
-    if (options.error) {
-      if (httpStatus === undefined) {
-        if (typeof options.error === 'object' && 'status' in options.error && typeof options.error.status === 'number') {
-          httpStatus = options.error.status;
-        } else if (typeof options.error === 'object' && 'statusCode' in options.error && typeof options.error.statusCode === 'number') {
-          httpStatus = options.error.statusCode;
-        } else {
-          httpStatus = 500;
-        }
-      }
-      let exceptionId;
-      if (client.options?.enableExceptionAutocapture) {
-        exceptionId = uuidv7();
-        client.captureException(options.error, undefined, {
-          $ai_trace_id: traceId
-        }, exceptionId);
-        if (typeof options.error === 'object') {
-          ;
-          options.error.__posthog_previously_captured_error = true;
-        }
-      }
-      errorData = {
-        $ai_is_error: true,
-        $ai_error: stringifyError(options.error),
-        $exception_event_id: exceptionId
-      };
-    }
-    httpStatus = httpStatus ?? 200;
-
-    // A configured price applies only to a count the provider reported, so a call with no
-    // reported usage sends no cost instead of asserting $0. $ai_total_cost_usd sums the sides
-    // that were priced, which makes it the cost of the known side alone when the other side
-    // went unreported: a lower bound on the true total, not an assertion of it.
-    const costOverrideData = {};
-    if (options.costOverride) {
-      if (usage.inputTokens !== undefined) {
-        costOverrideData.$ai_input_cost_usd = (options.costOverride.inputCost ?? 0) * usage.inputTokens;
-      }
-      if (usage.outputTokens !== undefined) {
-        costOverrideData.$ai_output_cost_usd = (options.costOverride.outputCost ?? 0) * usage.outputTokens;
-      }
-      if (Object.keys(costOverrideData).length > 0) {
-        costOverrideData.$ai_total_cost_usd = (costOverrideData.$ai_input_cost_usd ?? 0) + (costOverrideData.$ai_output_cost_usd ?? 0);
-      }
-    }
-
-    // The caller's own token counts override the SDK-derived ones further down, via the
-    // `options.properties` spread.
-    const tokensOverridden = hasTokenOverrides(options.properties);
-    const additionalTokenValues = {
-      ...(usage.reasoningTokens ? {
-        $ai_reasoning_tokens: usage.reasoningTokens
-      } : {}),
-      ...(usage.cacheReadInputTokens ? {
-        $ai_cache_read_input_tokens: usage.cacheReadInputTokens
-      } : {}),
-      ...(usage.cacheCreationInputTokens ? {
-        $ai_cache_creation_input_tokens: usage.cacheCreationInputTokens
-      } : {}),
-      // Checked against undefined rather than truthiness, because false is the meaningful
-      // value here and a truthiness guard would drop it.
-      //
-      // Dropped entirely when the caller overrides the token counts: the flag describes how
-      // the SDK-derived counts relate to each other, so against passthrough counts it can be
-      // wrong in the expensive direction. Declaring inclusive over counts that are actually
-      // exclusive makes ingestion subtract the cache pool that was never in the input. A
-      // caller who knows their own accounting model can still pass
-      // `$ai_cache_reporting_exclusive` themselves, and that value wins.
-      ...(usage.cacheReportingExclusive !== undefined && !tokensOverridden ? {
-        $ai_cache_reporting_exclusive: usage.cacheReportingExclusive
-      } : {}),
-      ...(usage.webSearchCount ? {
-        $ai_web_search_count: usage.webSearchCount
-      } : {}),
-      ...(usage.rawUsage ? {
-        $ai_usage: usage.rawUsage
-      } : {})
-    };
-    const properties = {
-      $ai_lib: 'posthog-ai',
-      $ai_lib_version: version,
-      $ai_provider: options.providerOverride ?? options.provider,
-      $ai_model: options.modelOverride ?? options.model,
-      $ai_model_parameters: options.modelParameters ?? {},
-      $ai_input: safeInput,
-      $ai_output_choices: safeOutput,
-      $ai_http_status: httpStatus,
-      ...(usage.inputTokens !== undefined ? {
-        $ai_input_tokens: usage.inputTokens
-      } : {}),
-      ...(usage.outputTokens !== undefined ? {
-        $ai_output_tokens: usage.outputTokens
-      } : {}),
-      ...additionalTokenValues,
-      ...(options.latency !== undefined ? {
-        $ai_latency: options.latency
-      } : {}),
-      ...(options.timeToFirstToken !== undefined ? {
-        $ai_time_to_first_token: options.timeToFirstToken
-      } : {}),
-      $ai_trace_id: traceId,
-      ...(options.baseURL === null ? {} : {
-        $ai_base_url: options.baseURL ?? ''
-      }),
-      ...options.properties,
-      $ai_tokens_source: getTokensSource(options.properties),
-      ...(options.distinctId ? {} : {
-        $process_person_profile: false
-      }),
-      ...(options.stopReason ? {
-        $ai_stop_reason: options.stopReason
-      } : {}),
-      ...(options.tools ? {
-        $ai_tools: options.tools
-      } : {}),
-      ...(options.completionId ? {
-        $ai_completion_id: options.completionId
-      } : {}),
-      ...(options.providerMetadata && Object.keys(options.providerMetadata).length > 0 ? {
-        $ai_provider_metadata: options.providerMetadata
-      } : {}),
-      ...errorData,
-      ...costOverrideData
-    };
-    const event = {
-      distinctId: options.distinctId ?? traceId,
-      event: eventType,
-      properties,
-      groups: options.groups
-    };
-    if (options.captureImmediate) {
-      await captureAiEventImmediate(client, event);
-    } else {
-      captureAiEvent(client, event);
-    }
-  } catch (error) {
-    // Telemetry failures must never affect the instrumented provider call.
-    try {
-      options.onError?.(error);
-    } catch {
-      // Error reporting must not affect the instrumented provider call either.
-    }
-    console.warn('[PostHog AI] Failed to capture generation telemetry:', error);
-  }
+	try {
+		if (!client.capture) return;
+		warnIfPostHogAiGateway(options.baseURL);
+		const traceId = options.traceId ?? v4();
+		const eventType = options.eventType ?? "$ai_generation";
+		const privacyMode = options.privacyMode ?? false;
+		const usage = options.usage ?? {};
+		const shouldRedact = withPrivacyMode(client, privacyMode, false) === null;
+		const safeInput = shouldRedact ? null : toJsonSafeValue(options.input);
+		const safeOutput = shouldRedact ? null : toJsonSafeValue(options.output);
+		let httpStatus = options.httpStatus;
+		let errorData = {};
+		if (options.error) {
+			if (httpStatus === void 0) {
+				if (typeof options.error === "object" && "status" in options.error && typeof options.error.status === "number") httpStatus = options.error.status;
+				else if (typeof options.error === "object" && "statusCode" in options.error && typeof options.error.statusCode === "number") httpStatus = options.error.statusCode;
+				else httpStatus = 500;
+			}
+			let exceptionId;
+			if (client.options?.enableExceptionAutocapture) {
+				exceptionId = uuidv7();
+				client.captureException(options.error, void 0, { $ai_trace_id: traceId }, exceptionId);
+				if (typeof options.error === "object") options.error.__posthog_previously_captured_error = true;
+			}
+			errorData = {
+				$ai_is_error: true,
+				$ai_error: stringifyError(options.error),
+				$exception_event_id: exceptionId
+			};
+		}
+		httpStatus = httpStatus ?? 200;
+		const costOverrideData = {};
+		if (options.costOverride) {
+			if (usage.inputTokens !== void 0) costOverrideData.$ai_input_cost_usd = (options.costOverride.inputCost ?? 0) * usage.inputTokens;
+			if (usage.outputTokens !== void 0) costOverrideData.$ai_output_cost_usd = (options.costOverride.outputCost ?? 0) * usage.outputTokens;
+			if (Object.keys(costOverrideData).length > 0) costOverrideData.$ai_total_cost_usd = (costOverrideData.$ai_input_cost_usd ?? 0) + (costOverrideData.$ai_output_cost_usd ?? 0);
+		}
+		const tokensOverridden = hasTokenOverrides(options.properties);
+		const additionalTokenValues = {
+			...usage.reasoningTokens ? { $ai_reasoning_tokens: usage.reasoningTokens } : {},
+			...usage.cacheReadInputTokens ? { $ai_cache_read_input_tokens: usage.cacheReadInputTokens } : {},
+			...usage.cacheCreationInputTokens ? { $ai_cache_creation_input_tokens: usage.cacheCreationInputTokens } : {},
+			...usage.cacheReportingExclusive !== void 0 && !tokensOverridden ? { $ai_cache_reporting_exclusive: usage.cacheReportingExclusive } : {},
+			...usage.webSearchCount ? { $ai_web_search_count: usage.webSearchCount } : {},
+			...usage.rawUsage ? { $ai_usage: usage.rawUsage } : {}
+		};
+		const properties = {
+			$ai_lib: "posthog-ai",
+			$ai_lib_version: version,
+			$ai_provider: options.providerOverride ?? options.provider,
+			$ai_model: options.modelOverride ?? options.model,
+			$ai_model_parameters: options.modelParameters ?? {},
+			$ai_input: safeInput,
+			$ai_output_choices: safeOutput,
+			$ai_http_status: httpStatus,
+			...usage.inputTokens !== void 0 ? { $ai_input_tokens: usage.inputTokens } : {},
+			...usage.outputTokens !== void 0 ? { $ai_output_tokens: usage.outputTokens } : {},
+			...additionalTokenValues,
+			...options.latency !== void 0 ? { $ai_latency: options.latency } : {},
+			...options.timeToFirstToken !== void 0 ? { $ai_time_to_first_token: options.timeToFirstToken } : {},
+			$ai_trace_id: traceId,
+			...options.baseURL === null ? {} : { $ai_base_url: options.baseURL ?? "" },
+			...options.properties,
+			$ai_tokens_source: getTokensSource(options.properties),
+			...options.distinctId ? {} : { $process_person_profile: false },
+			...options.stopReason ? { $ai_stop_reason: options.stopReason } : {},
+			...options.tools ? { $ai_tools: options.tools } : {},
+			...options.completionId ? { $ai_completion_id: options.completionId } : {},
+			...options.providerMetadata && Object.keys(options.providerMetadata).length > 0 ? { $ai_provider_metadata: options.providerMetadata } : {},
+			...errorData,
+			...costOverrideData
+		};
+		const event = {
+			distinctId: options.distinctId ?? traceId,
+			event: eventType,
+			properties,
+			groups: options.groups
+		};
+		if (options.captureImmediate) await captureAiEventImmediate(client, event);
+		else captureAiEvent(client, event);
+	} catch (error) {
+		try {
+			options.onError?.(error);
+		} catch {}
+		console.warn("[PostHog AI] Failed to capture generation telemetry:", error);
+	}
 };
-
+//#endregion
+//#region src/openai/capture.ts
 /**
- * The declared convention only describes the wrapper's own usage numbers, so
- * when the caller passes any of these through posthogProperties the wrapper no
- * longer knows the convention of the reported counts (callers working around
- * the double-billing already pass exclusive ones) and must not declare it.
- * Output/reasoning token overrides don't affect the input/cache relationship,
- * so they don't suppress the declaration. Subset of the input/cache keys in
- * `TOKEN_PROPERTY_KEYS` (../utils.ts) — keep in sync if that taxonomy grows.
- */
-const INPUT_OR_CACHE_TOKEN_KEYS = ['$ai_input_tokens', '$ai_cache_read_input_tokens', '$ai_cache_creation_input_tokens'];
-
+* The declared convention only describes the wrapper's own usage numbers, so
+* when the caller passes any of these through posthogProperties the wrapper no
+* longer knows the convention of the reported counts (callers working around
+* the double-billing already pass exclusive ones) and must not declare it.
+* Output/reasoning token overrides don't affect the input/cache relationship,
+* so they don't suppress the declaration. Subset of the input/cache keys in
+* `TOKEN_PROPERTY_KEYS` (../utils.ts) — keep in sync if that taxonomy grows.
+*/
+const INPUT_OR_CACHE_TOKEN_KEYS = [
+	"$ai_input_tokens",
+	"$ai_cache_read_input_tokens",
+	"$ai_cache_creation_input_tokens"
+];
 /**
- * OpenAI-compatible usage reports `prompt_tokens` INCLUSIVE of cached tokens
- * (`prompt_tokens_details.cached_tokens` is a subset of it), unlike Anthropic's
- * exclusive convention. Ingestion auto-classifies Claude-shaped models as
- * exclusive regardless of provider, so events for Claude served through
- * OpenAI-compatible hosts (e.g. OpenRouter) would get cache reads billed twice.
- * Declaring the convention on every event from this wrapper lets ingestion
- * normalize correctly (see PostHog/posthog#49252); for non-Claude models the
- * flag is a no-op. Callers can still override it via posthogProperties, and
- * when they pass through input or cache token counts themselves the flag stays
- * unset unless they declare it explicitly.
- */
+* OpenAI-compatible usage reports `prompt_tokens` INCLUSIVE of cached tokens
+* (`prompt_tokens_details.cached_tokens` is a subset of it), unlike Anthropic's
+* exclusive convention. Ingestion auto-classifies Claude-shaped models as
+* exclusive regardless of provider, so events for Claude served through
+* OpenAI-compatible hosts (e.g. OpenRouter) would get cache reads billed twice.
+* Declaring the convention on every event from this wrapper lets ingestion
+* normalize correctly (see PostHog/posthog#49252); for non-Claude models the
+* flag is a no-op. Callers can still override it via posthogProperties, and
+* when they pass through input or cache token counts themselves the flag stays
+* unset unless they declare it explicitly.
+*/
 const captureAiGeneration = (client, options) => {
-  const props = options.properties;
-  // Own-property check, matching how getTokensSource detects passthrough and
-  // how the properties spread actually copies values into the event.
-  const callerReportsTokens = props !== undefined && INPUT_OR_CACHE_TOKEN_KEYS.some(key => Object.prototype.hasOwnProperty.call(props, key));
-  return captureAiGeneration$1(client, {
-    ...options,
-    properties: callerReportsTokens ? props : {
-      $ai_cache_reporting_exclusive: false,
-      ...props
-    }
-  });
+	const props = options.properties;
+	const callerReportsTokens = props !== void 0 && INPUT_OR_CACHE_TOKEN_KEYS.some((key) => Object.prototype.hasOwnProperty.call(props, key));
+	return captureAiGeneration$1(client, {
+		...options,
+		properties: callerReportsTokens ? props : {
+			$ai_cache_reporting_exclusive: false,
+			...props
+		}
+	});
 };
-
+//#endregion
+//#region src/openai/utils.ts
 /**
- * Checks if a ResponseStreamEvent chunk represents the first token/content from the model.
- * This includes various content types like text, reasoning, audio, and refusals.
- */
+* 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';
+	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`.
- */
+* 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;
+	return result?._request_id ?? void 0;
 }
-
 /**
- * Reads `cache_write_tokens` from a usage details object — Chat Completions'
- * `prompt_tokens_details` or the Responses API's `input_tokens_details`, both of
- * which carry the field — and returns 0 when it is absent. A defensive reader
- * (mirroring `extractRequestId`) that tolerates the loosely-typed usage shapes
- * OpenAI-compatible providers return, used to populate
- * `$ai_cache_creation_input_tokens`.
- */
+* Reads `cache_write_tokens` from a usage details object — Chat Completions'
+* `prompt_tokens_details` or the Responses API's `input_tokens_details`, both of
+* which carry the field — and returns 0 when it is absent. A defensive reader
+* (mirroring `extractRequestId`) that tolerates the loosely-typed usage shapes
+* OpenAI-compatible providers return, used to populate
+* `$ai_cache_creation_input_tokens`.
+*/
 function extractCacheWriteTokens(details) {
-  return details?.cache_write_tokens ?? 0;
+	return details?.cache_write_tokens ?? 0;
 }
-
 /**
- * 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
- * meaningful value are included, and `undefined` is returned when there is nothing
- * to report so the property can be omitted from the event entirely.
- */
+* 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
+* meaningful 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;
-  }
-  if (fields.incompleteDetails != null) {
-    metadata.incomplete_details = fields.incompleteDetails;
-  }
-  return Object.keys(metadata).length > 0 ? metadata : undefined;
+	const metadata = {};
+	if (fields.systemFingerprint) metadata.system_fingerprint = fields.systemFingerprint;
+	if (fields.requestId) metadata.request_id = fields.requestId;
+	if (fields.incompleteDetails != null) metadata.incomplete_details = fields.incompleteDetails;
+	return Object.keys(metadata).length > 0 ? metadata : void 0;
 }
-const TERMINAL_RESPONSE_STATUSES = new Set(['completed', 'failed', 'cancelled', 'incomplete']);
-
+const TERMINAL_RESPONSE_STATUSES = /* @__PURE__ */ new Set([
+	"completed",
+	"failed",
+	"cancelled",
+	"incomplete"
+]);
 /**
- * Checks whether a Responses API response has reached a status that should
- * produce a final `$ai_generation` event.
- */
+* Checks whether a Responses API response has reached a status that should
+* produce a final `$ai_generation` event.
+*/
 function isTerminalResponse(response) {
-  return !!response?.status && TERMINAL_RESPONSE_STATUSES.has(response.status);
+	return !!response?.status && TERMINAL_RESPONSE_STATUSES.has(response.status);
+}
+/**
+* Maps a Responses API outcome to a `$ai_stop_reason`. An incomplete run is
+* named by what cut it short (`incomplete_details.reason`, e.g.
+* `max_output_tokens`); the other terminal statuses stand for themselves.
+* Non-terminal lifecycle statuses (`queued`, `in_progress`) are not stop
+* reasons, so they yield undefined.
+*/
+function responsesStopReason(response) {
+	if (!response || !isTerminalResponse(response)) return;
+	if (response.status === "incomplete" && response.incomplete_details?.reason) return response.incomplete_details.reason;
+	return response.status ?? void 0;
 }
-
 /**
- * Returns an isolated copy of a failed Responses API error for `$ai_error`, or
- * creates a fallback error when the provider omitted failure details.
- */
+* Returns an isolated copy of a failed Responses API error for `$ai_error`, or
+* creates a fallback error when the provider omitted failure details.
+*/
 function getResponseFailure(response) {
-  if (response?.status !== 'failed') {
-    return undefined;
-  }
-  return response.error ? {
-    ...response.error
-  } : new Error(`OpenAI response ${response.id} failed without error details`);
+	if (response?.status !== "failed") return;
+	return response.error ? { ...response.error } : /* @__PURE__ */ new Error(`OpenAI response ${response.id} failed without error details`);
 }
-
+//#endregion
+//#region src/openai/background-responses.ts
 function isPendingBackgroundResponse(params, response) {
-  return params.background === true && !!response.status && !isTerminalResponse(response);
+	return params.background === true && !!response.status && !isTerminalResponse(response);
 }
-
 /**
- * Uses provider timestamps so background polling cadence does not inflate
- * generation latency. Non-completed responses do not expose a terminal time.
- */
+* Uses provider timestamps so background polling cadence does not inflate
+* generation latency. Non-completed responses do not expose a terminal time.
+*/
 function getBackgroundResponseLatency(response) {
-  if (typeof response.created_at !== 'number' || typeof response.completed_at !== 'number') {
-    return undefined;
-  }
-  return Math.max(0, response.completed_at - response.created_at);
+	if (typeof response.created_at !== "number" || typeof response.completed_at !== "number") return;
+	return Math.max(0, response.completed_at - response.created_at);
 }
-
 /**
- * Keeps the original create context available while a background response is
- * polled. Entries are insertion ordered, so the oldest context is discarded
- * when the bound is reached.
- */
-class BackgroundResponseTracker {
-  contexts = new Map();
-  constructor(maxEntries = 1000) {
-    this.maxEntries = maxEntries;
-  }
-  set(responseID, context) {
-    // Refresh an existing response's insertion order.
-    this.contexts.delete(responseID);
-    this.contexts.set(responseID, context);
-    while (this.contexts.size > this.maxEntries) {
-      const oldestResponseID = this.contexts.keys().next().value;
-      if (oldestResponseID === undefined) {
-        break;
-      }
-      this.contexts.delete(oldestResponseID);
-    }
-  }
-  get(responseID) {
-    return this.contexts.get(responseID);
-  }
-  take(responseID) {
-    const context = this.contexts.get(responseID);
-    if (context !== undefined) {
-      this.contexts.delete(responseID);
-    }
-    return context;
-  }
-}
-
+* Keeps the original create context available while a background response is
+* polled. Entries are insertion ordered, so the oldest context is discarded
+* when the bound is reached.
+*/
+var BackgroundResponseTracker = class {
+	constructor(maxEntries = 1e3) {
+		this.maxEntries = maxEntries;
+		this.contexts = /* @__PURE__ */ new Map();
+	}
+	set(responseID, context) {
+		this.contexts.delete(responseID);
+		this.contexts.set(responseID, context);
+		while (this.contexts.size > this.maxEntries) {
+			const oldestResponseID = this.contexts.keys().next().value;
+			if (oldestResponseID === void 0) break;
+			this.contexts.delete(oldestResponseID);
+		}
+	}
+	get(responseID) {
+		return this.contexts.get(responseID);
+	}
+	take(responseID) {
+		const context = this.contexts.get(responseID);
+		if (context !== void 0) this.contexts.delete(responseID);
+		return context;
+	}
+};
 /**
- * Inspects a streamed background retrieval without consuming it on the
- * caller's behalf. The stored create context is consumed only by a terminal
- * response; an interrupted or nonterminal stream may be followed by another
- * retrieval while the background job continues.
- */
+* Inspects a streamed background retrieval without consuming it on the
+* caller's behalf. The stored create context is consumed only by a terminal
+* response; an interrupted or nonterminal stream may be followed by another
+* retrieval while the background job continues.
+*/
 function wrapBackgroundResponseStream(stream, responseID, tracker, captureTerminalResponse) {
-  async function* inspectStream() {
-    for await (const event of stream) {
-      if ('response' in event && isTerminalResponse(event.response)) {
-        const context = tracker.take(responseID);
-        if (context) {
-          // Monitoring must not delay or disrupt delivery of the provider stream.
-          void captureTerminalResponse(event.response, context).catch(() => undefined);
-        }
-      }
-      yield event;
-    }
-  }
-  return new Stream(() => inspectStream(), stream.controller);
+	async function* inspectStream() {
+		for await (const event of stream) {
+			if ("response" in event && isTerminalResponse(event.response)) {
+				const context = tracker.take(responseID);
+				if (context) captureTerminalResponse(event.response, context).catch(() => void 0);
+			}
+			yield event;
+		}
+	}
+	return new Stream(() => inspectStream(), stream.controller);
 }
-
+//#endregion
+//#region src/providerPromise.ts
 function addResponseIds(result, response, requestIdHeader, workspaceIdHeader) {
-  if (!result || typeof result !== 'object' || Array.isArray(result)) {
-    return result;
-  }
-  const properties = {
-    _request_id: {
-      value: response.headers.get(requestIdHeader),
-      enumerable: false
-    }
-  };
-  if (workspaceIdHeader) {
-    properties._workspace_id = {
-      value: response.headers.get(workspaceIdHeader),
-      enumerable: false
-    };
-  }
-  return Object.defineProperties(result, properties);
+	if (!result || typeof result !== "object" || Array.isArray(result)) return result;
+	const properties = { _request_id: {
+		value: response.headers.get(requestIdHeader),
+		enumerable: false
+	} };
+	if (workspaceIdHeader) properties._workspace_id = {
+		value: response.headers.get(workspaceIdHeader),
+		enumerable: false
+	};
+	return Object.defineProperties(result, properties);
 }
 function getResponsePropsPromise(parentPromise) {
-  const responsePromise = parentPromise.responsePromise;
-  if (!responsePromise || typeof responsePromise.then !== 'function') {
-    return undefined;
-  }
-  return responsePromise;
+	const responsePromise = parentPromise.responsePromise;
+	if (!responsePromise || typeof responsePromise.then !== "function") return;
+	return responsePromise;
 }
 function decorateProviderPromise(wrappedPromise, responsePropsPromise, requestIdHeader, workspaceIdHeader, preserveThenUnwrap) {
-  const providerPromise = wrappedPromise;
-  if (responsePropsPromise) {
-    providerPromise.asResponse = async () => (await responsePropsPromise).response;
-    providerPromise.withResponse = async () => {
-      const [props, data] = await Promise.all([responsePropsPromise, wrappedPromise]);
-      return {
-        response: props.response,
-        data,
-        request_id: props.response.headers.get(requestIdHeader),
-        ...(workspaceIdHeader ? {
-          workspace_id: props.response.headers.get(workspaceIdHeader)
-        } : {})
-      };
-    };
-  }
-  if (preserveThenUnwrap) {
-    providerPromise._thenUnwrap = transform => {
-      if (!responsePropsPromise) {
-        throw new Error('The provider promise response metadata is unavailable');
-      }
-      const transformedPromise = Promise.all([wrappedPromise, responsePropsPromise]).then(([data, props]) => addResponseIds(transform(data, props), props.response, requestIdHeader, workspaceIdHeader));
-      return decorateProviderPromise(transformedPromise, responsePropsPromise, requestIdHeader, workspaceIdHeader, true);
-    };
-  }
-  return providerPromise;
+	const providerPromise = wrappedPromise;
+	if (responsePropsPromise) {
+		providerPromise.asResponse = async () => (await responsePropsPromise).response;
+		providerPromise.withResponse = async () => {
+			const [props, data] = await Promise.all([responsePropsPromise, wrappedPromise]);
+			return {
+				response: props.response,
+				data,
+				request_id: props.response.headers.get(requestIdHeader),
+				...workspaceIdHeader ? { workspace_id: props.response.headers.get(workspaceIdHeader) } : {}
+			};
+		};
+	}
+	if (preserveThenUnwrap) providerPromise._thenUnwrap = (transform) => {
+		if (!responsePropsPromise) throw new Error("The provider promise response metadata is unavailable");
+		return decorateProviderPromise(Promise.all([wrappedPromise, responsePropsPromise]).then(([data, props]) => addResponseIds(transform(data, props), props.response, requestIdHeader, workspaceIdHeader)), responsePropsPromise, requestIdHeader, workspaceIdHeader, true);
+	};
+	return providerPromise;
 }
-
-/**
- * Keep the provider SDK helpers on a promise whose resolved value is instrumented.
- * OpenAI's parse helpers compose create calls through `_thenUnwrap`, while both
- * OpenAI and Anthropic expose the raw response through `asResponse` and
- * `withResponse`.
- */
-
 function preserveProviderPromise(parentPromise, wrappedPromise, options = {}) {
-  const responsePropsPromise = getResponsePropsPromise(parentPromise);
-  const preserveThenUnwrap = typeof parentPromise._thenUnwrap === 'function';
-  const providerPromise = decorateProviderPromise(wrappedPromise, responsePropsPromise, options.requestIdHeader ?? 'x-request-id', options.workspaceIdHeader, preserveThenUnwrap);
-  if (!responsePropsPromise) {
-    const asResponse = parentPromise.asResponse?.bind(parentPromise);
-    if (asResponse) {
-      providerPromise.asResponse = asResponse;
-    }
-    const withResponse = parentPromise.withResponse?.bind(parentPromise);
-    if (withResponse) {
-      providerPromise.withResponse = async () => {
-        const [response, data] = await Promise.all([withResponse(), wrappedPromise]);
-        return {
-          ...response,
-          data
-        };
-      };
-    }
-  }
-  return providerPromise;
+	const responsePropsPromise = getResponsePropsPromise(parentPromise);
+	const preserveThenUnwrap = typeof parentPromise._thenUnwrap === "function";
+	const providerPromise = decorateProviderPromise(wrappedPromise, responsePropsPromise, options.requestIdHeader ?? "x-request-id", options.workspaceIdHeader, preserveThenUnwrap);
+	if (!responsePropsPromise) {
+		const asResponse = parentPromise.asResponse?.bind(parentPromise);
+		if (asResponse) providerPromise.asResponse = asResponse;
+		const withResponse = parentPromise.withResponse?.bind(parentPromise);
+		if (withResponse) providerPromise.withResponse = async () => {
+			const [response, data] = await Promise.all([withResponse(), wrappedPromise]);
+			return {
+				...response,
+				data
+			};
+		};
+	}
+	return providerPromise;
 }
-
 /**
- * OpenAI's `Responses.parse` dispatches through `this._client.responses.create`.
- * Temporarily use the provider's original `create` implementation so parsing a
- * wrapped response does not capture the same request twice.
- */
+* OpenAI's `Responses.parse` dispatches through `this._client.responses.create`.
+* Temporarily use the provider's original `create` implementation so parsing a
+* wrapped response does not capture the same request twice.
+*/
 function callWithOriginalCreate(resource, originalCreate, callback) {
-  const resourceRecord = resource;
-  const hadOwnCreate = Object.prototype.hasOwnProperty.call(resource, 'create');
-  const wrappedCreate = resourceRecord['create'];
-  resourceRecord['create'] = originalCreate;
-  try {
-    return callback();
-  } finally {
-    if (hadOwnCreate) {
-      resourceRecord['create'] = wrappedCreate;
-    } else {
-      delete resourceRecord['create'];
-    }
-  }
+	const resourceRecord = resource;
+	const hadOwnCreate = Object.prototype.hasOwnProperty.call(resource, "create");
+	const wrappedCreate = resourceRecord["create"];
+	resourceRecord["create"] = originalCreate;
+	try {
+		return callback();
+	} finally {
+		if (hadOwnCreate) resourceRecord["create"] = wrappedCreate;
+		else delete resourceRecord["create"];
+	}
 }
-
+//#endregion
+//#region src/stream.ts
 /**
- * Splits an SDK stream into a monitoring branch and a caller branch without
- * allowing either branch to read ahead of the other. Unlike the SDKs' `tee()`
- * implementations, this keeps at most one result in flight and makes caller
- * cancellation terminate the monitoring branch and the source iterator.
- */
+* Splits an SDK stream into a monitoring branch and a caller branch without
+* allowing either branch to read ahead of the other. Unlike the SDKs' `tee()`
+* implementations, this keeps at most one result in flight and makes caller
+* cancellation terminate the monitoring branch and the source iterator.
+*/
 function monitoredStreamTee(source, createStream) {
-  const controller = source.controller ?? new AbortController();
-  const sourceIterator = source[Symbol.asyncIterator]();
-  const callerQueue = [];
-  let monitorPending;
-  let monitorActive = true;
-  let operationInFlight = false;
-  let terminalResult;
-  let bufferedMonitorResult;
-  let terminalError;
-  let hasTerminalError = false;
-  let cancellationPromise;
-  let abortListener;
-  const removeAbortListener = () => {
-    if (abortListener) {
-      controller.signal.removeEventListener('abort', abortListener);
-      abortListener = undefined;
-    }
-  };
-  const settleMonitorTerminal = () => {
-    if (!monitorPending) {
-      return;
-    }
-    const pending = monitorPending;
-    monitorPending = undefined;
-    if (hasTerminalError) {
-      pending.reject(terminalError);
-    } else if (terminalResult) {
-      pending.resolve(terminalResult);
-    }
-  };
-  const settleCallersTerminal = () => {
-    while (callerQueue.length > 0) {
-      const pending = callerQueue.shift();
-      if (hasTerminalError) {
-        pending.reject(terminalError);
-      } else if (terminalResult) {
-        pending.resolve(terminalResult);
-      }
-    }
-  };
-  const pump = () => {
-    if (operationInFlight || callerQueue.length === 0 || monitorActive && !monitorPending) {
-      return;
-    }
-    const pendingCaller = callerQueue.shift();
-    const pendingMonitor = monitorPending;
-    monitorPending = undefined;
-    operationInFlight = true;
-    void sourceIterator.next().then(result => {
-      operationInFlight = false;
-      if (result.done) {
-        terminalResult = result;
-        removeAbortListener();
-      }
-      pendingCaller.resolve(result);
-      pendingMonitor?.resolve(result);
-      if (result.done) {
-        settleCallersTerminal();
-      } else {
-        pump();
-      }
-    }, error => {
-      operationInFlight = false;
-      terminalError = error;
-      hasTerminalError = true;
-      removeAbortListener();
-      pendingCaller.reject(error);
-      pendingMonitor?.reject(error);
-      settleCallersTerminal();
-    });
-  };
-  const monitoringStream = {
-    [Symbol.asyncIterator]() {
-      return {
-        next: () => {
-          if (hasTerminalError) {
-            return Promise.reject(terminalError);
-          }
-          if (terminalResult) {
-            return Promise.resolve(terminalResult);
-          }
-          if (bufferedMonitorResult) {
-            const result = bufferedMonitorResult;
-            bufferedMonitorResult = undefined;
-            return Promise.resolve(result);
-          }
-          return new Promise((resolve, reject) => {
-            monitorPending = {
-              resolve,
-              reject
-            };
-            pump();
-          });
-        },
-        return: async value => {
-          monitorActive = false;
-          monitorPending = undefined;
-          pump();
-          return {
-            done: true,
-            value: value
-          };
-        }
-      };
-    }
-  };
-  const cancelSource = value => {
-    if (cancellationPromise) {
-      return cancellationPromise;
-    }
-    removeAbortListener();
-    if (!controller.signal.aborted) {
-      controller.abort();
-    }
-    cancellationPromise = (async () => {
-      try {
-        const defaultResult = {
-          done: true,
-          value
-        };
-        const result = sourceIterator.return ? await sourceIterator.return(value) : defaultResult;
-        if (result.done) {
-          terminalResult = result;
-          removeAbortListener();
-          settleMonitorTerminal();
-          settleCallersTerminal();
-        } else if (monitorPending) {
-          monitorPending.resolve(result);
-          monitorPending = undefined;
-          cancellationPromise = undefined;
-        } else {
-          bufferedMonitorResult = result;
-          cancellationPromise = undefined;
-        }
-        return result;
-      } catch (error) {
-        terminalError = error;
-        hasTerminalError = true;
-        removeAbortListener();
-        settleMonitorTerminal();
-        settleCallersTerminal();
-        throw error;
-      }
-    })();
-    // An AbortController cancellation has no caller awaiting this promise.
-    void cancellationPromise.catch(() => undefined);
-    return cancellationPromise;
-  };
-  abortListener = () => {
-    void cancelSource();
-  };
-  if (controller.signal.aborted) {
-    abortListener();
-  } else {
-    controller.signal.addEventListener('abort', abortListener, {
-      once: true
-    });
-  }
-  const callerStream = createStream(() => ({
-    next: () => {
-      if (hasTerminalError) {
-        return Promise.reject(terminalError);
-      }
-      if (terminalResult) {
-        return Promise.resolve(terminalResult);
-      }
-      return new Promise((resolve, reject) => {
-        callerQueue.push({
-          resolve,
-          reject
-        });
-        pump();
-      });
-    },
-    return: value => cancelSource(value),
-    throw: async error => {
-      if (!sourceIterator.throw) {
-        await cancelSource();
-        throw error;
-      }
-      try {
-        const result = await sourceIterator.throw(error);
-        if (result.done) {
-          terminalResult = result;
-          removeAbortListener();
-          settleCallersTerminal();
-        }
-        if (monitorPending) {
-          monitorPending.resolve(result);
-          monitorPending = undefined;
-        } else {
-          bufferedMonitorResult = result;
-        }
-        return result;
-      } catch (sourceError) {
-        terminalError = sourceError;
-        hasTerminalError = true;
-        removeAbortListener();
-        settleMonitorTerminal();
-        settleCallersTerminal();
-        throw sourceError;
-      }
-    }
-  }), controller);
-  return [monitoringStream, callerStream];
+	const controller = source.controller ?? new AbortController();
+	const sourceIterator = source[Symbol.asyncIterator]();
+	const callerQueue = [];
+	let monitorPending;
+	let monitorActive = true;
+	let operationInFlight = false;
+	let terminalResult;
+	let bufferedMonitorResult;
+	let terminalError;
+	let hasTerminalError = false;
+	let cancellationPromise;
+	let abortListener;
+	const removeAbortListener = () => {
+		if (abortListener) {
+			controller.signal.removeEventListener("abort", abortListener);
+			abortListener = void 0;
+		}
+	};
+	const settleMonitorTerminal = () => {
+		if (!monitorPending) return;
+		const pending = monitorPending;
+		monitorPending = void 0;
+		if (hasTerminalError) pending.reject(terminalError);
+		else if (terminalResult) pending.resolve(terminalResult);
+	};
+	const settleCallersTerminal = () => {
+		while (callerQueue.length > 0) {
+			const pending = callerQueue.shift();
+			if (hasTerminalError) pending.reject(terminalError);
+			else if (terminalResult) pending.resolve(terminalResult);
+		}
+	};
+	const pump = () => {
+		if (operationInFlight || callerQueue.length === 0 || monitorActive && !monitorPending) return;
+		const pendingCaller = callerQueue.shift();
+		const pendingMonitor = monitorPending;
+		monitorPending = void 0;
+		operationInFlight = true;
+		sourceIterator.next().then((result) => {
+			operationInFlight = false;
+			if (result.done) {
+				terminalResult = result;
+				removeAbortListener();
+			}
+			pendingCaller.resolve(result);
+			pendingMonitor?.resolve(result);
+			if (result.done) settleCallersTerminal();
+			else pump();
+		}, (error) => {
+			operationInFlight = false;
+			terminalError = error;
+			hasTerminalError = true;
+			removeAbortListener();
+			pendingCaller.reject(error);
+			pendingMonitor?.reject(error);
+			settleCallersTerminal();
+		});
+	};
+	const monitoringStream = { [Symbol.asyncIterator]() {
+		return {
+			next: () => {
+				if (hasTerminalError) return Promise.reject(terminalError);
+				if (terminalResult) return Promise.resolve(terminalResult);
+				if (bufferedMonitorResult) {
+					const result = bufferedMonitorResult;
+					bufferedMonitorResult = void 0;
+					return Promise.resolve(result);
+				}
+				return new Promise((resolve, reject) => {
+					monitorPending = {
+						resolve,
+						reject
+					};
+					pump();
+				});
+			},
+			return: async (value) => {
+				monitorActive = false;
+				monitorPending = void 0;
+				pump();
+				return {
+					done: true,
+					value
+				};
+			}
+		};
+	} };
+	const cancelSource = (value) => {
+		if (cancellationPromise) return cancellationPromise;
+		removeAbortListener();
+		if (!controller.signal.aborted) controller.abort();
+		cancellationPromise = (async () => {
+			try {
+				const defaultResult = {
+					done: true,
+					value
+				};
+				const result = sourceIterator.return ? await sourceIterator.return(value) : defaultResult;
+				if (result.done) {
+					terminalResult = result;
+					removeAbortListener();
+					settleMonitorTerminal();
+					settleCallersTerminal();
+				} else if (monitorPending) {
+					monitorPending.resolve(result);
+					monitorPending = void 0;
+					cancellationPromise = void 0;
+				} else {
+					bufferedMonitorResult = result;
+					cancellationPromise = void 0;
+				}
+				return result;
+			} catch (error) {
+				terminalError = error;
+				hasTerminalError = true;
+				removeAbortListener();
+				settleMonitorTerminal();
+				settleCallersTerminal();
+				throw error;
+			}
+		})();
+		cancellationPromise.catch(() => void 0);
+		return cancellationPromise;
+	};
+	abortListener = () => {
+		cancelSource();
+	};
+	if (controller.signal.aborted) abortListener();
+	else controller.signal.addEventListener("abort", abortListener, { once: true });
+	return [monitoringStream, createStream(() => ({
+		next: () => {
+			if (hasTerminalError) return Promise.reject(terminalError);
+			if (terminalResult) return Promise.resolve(terminalResult);
+			return new Promise((resolve, reject) => {
+				callerQueue.push({
+					resolve,
+					reject
+				});
+				pump();
+			});
+		},
+		return: (value) => cancelSource(value),
+		throw: async (error) => {
+			if (!sourceIterator.throw) {
+				await cancelSource();
+				throw error;
+			}
+			try {
+				const result = await sourceIterator.throw(error);
+				if (result.done) {
+					terminalResult = result;
+					removeAbortListener();
+					settleCallersTerminal();
+				}
+				if (monitorPending) {
+					monitorPending.resolve(result);
+					monitorPending = void 0;
+				} else bufferedMonitorResult = result;
+				return result;
+			} catch (sourceError) {
+				terminalError = sourceError;
+				hasTerminalError = true;
+				removeAbortListener();
+				settleMonitorTerminal();
+				settleCallersTerminal();
+				throw sourceError;
+			}
+		}
+	}), controller)];
 }
-
+//#endregion
+//#region src/openai/stream-accumulators.ts
 /** Pure state accumulator for OpenAI-compatible Chat Completions chunks. */
-class OpenAIChatStreamAccumulator {
-  accumulatedContent = '';
-  usage = {
-    webSearchCount: 0
-  };
-  toolCalls = new Map();
-  consume(chunk, receivedAt = Date.now()) {
-    this.model ||= chunk.model || undefined;
-    this.completionId ||= chunk.id || undefined;
-    this.systemFingerprint ||= chunk.system_fingerprint || undefined;
-    if (chunk.service_tier != null) {
-      this.serviceTier = chunk.service_tier;
-    }
-    const choice = chunk.choices?.[0];
-    if (choice?.finish_reason) {
-      this.stopReason = choice.finish_reason;
-    }
-    const webSearchCount = calculateWebSearchCount(chunk);
-    if (webSearchCount > (this.usage.webSearchCount ?? 0)) {
-      this.usage.webSearchCount = webSearchCount;
-    }
-    if (choice?.delta?.content) {
-      this.firstTokenTime ??= receivedAt;
-      this.accumulatedContent += choice.delta.content;
-    }
-    if (Array.isArray(choice?.delta?.tool_calls)) {
-      this.firstTokenTime ??= receivedAt;
-      for (const toolCall of choice.delta.tool_calls) {
-        if (toolCall.index === undefined) {
-          continue;
-        }
-        const current = this.toolCalls.get(toolCall.index) ?? {
-          id: '',
-          name: '',
-          arguments: ''
-        };
-        if (toolCall.id) {
-          current.id = toolCall.id;
-        }
-        if (toolCall.function?.name) {
-          current.name = toolCall.function.name;
-        }
-        if (toolCall.function?.arguments) {
-          current.arguments += toolCall.function.arguments;
-        }
-        this.toolCalls.set(toolCall.index, current);
-      }
-    }
-    if (chunk.usage) {
-      this.usage = {
-        ...this.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,
-        cacheCreationInputTokens: extractCacheWriteTokens(chunk.usage.prompt_tokens_details),
-        rawUsage: chunk.usage
-      };
-    }
-  }
-  result() {
-    const content = [];
-    if (this.accumulatedContent) {
-      content.push({
-        type: 'text',
-        text: this.accumulatedContent
-      });
-    }
-    for (const toolCall of this.toolCalls.values()) {
-      if (toolCall.name) {
-        content.push({
-          type: 'function',
-          id: toolCall.id,
-          function: {
-            name: toolCall.name,
-            arguments: toolCall.arguments
-          }
-        });
-      }
-    }
-    return {
-      output: [{
-        role: 'assistant',
-        content: content.length > 0 ? content : [{
-          type: 'text',
-          text: ''
-        }]
-      }],
-      model: this.model,
-      completionId: this.completionId,
-      systemFingerprint: this.systemFingerprint,
-      serviceTier: this.serviceTier,
-      firstTokenTime: this.firstTokenTime,
-      stopReason: this.stopReason,
-      usage: {
-        ...this.usage
-      }
-    };
-  }
-}
+var OpenAIChatStreamAccumulator = class {
+	constructor() {
+		this.accumulatedContent = "";
+		this.usage = { webSearchCount: 0 };
+		this.toolCalls = /* @__PURE__ */ new Map();
+	}
+	consume(chunk, receivedAt = Date.now()) {
+		this.model ||= chunk.model || void 0;
+		this.completionId ||= chunk.id || void 0;
+		this.systemFingerprint ||= chunk.system_fingerprint || void 0;
+		if (chunk.service_tier != null) this.serviceTier = chunk.service_tier;
+		const choice = chunk.choices?.[0];
+		if (choice?.finish_reason) this.stopReason = choice.finish_reason;
+		const webSearchCount = calculateWebSearchCount(chunk);
+		if (webSearchCount > (this.usage.webSearchCount ?? 0)) this.usage.webSearchCount = webSearchCount;
+		if (choice?.delta?.content) {
+			this.firstTokenTime ??= receivedAt;
+			this.accumulatedContent += choice.delta.content;
+		}
+		if (Array.isArray(choice?.delta?.tool_calls)) {
+			this.firstTokenTime ??= receivedAt;
+			for (const toolCall of choice.delta.tool_calls) {
+				if (toolCall.index === void 0) continue;
+				const current = this.toolCalls.get(toolCall.index) ?? {
+					id: "",
+					name: "",
+					arguments: ""
+				};
+				if (toolCall.id) current.id = toolCall.id;
+				if (toolCall.function?.name) current.name = toolCall.function.name;
+				if (toolCall.function?.arguments) current.arguments += toolCall.function.arguments;
+				this.toolCalls.set(toolCall.index, current);
+			}
+		}
+		if (chunk.usage) this.usage = {
+			...this.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,
+			cacheCreationInputTokens: extractCacheWriteTokens(chunk.usage.prompt_tokens_details),
+			rawUsage: chunk.usage
+		};
+	}
+	result() {
+		const content = [];
+		if (this.accumulatedContent) content.push({
+			type: "text",
+			text: this.accumulatedContent
+		});
+		for (const toolCall of this.toolCalls.values()) if (toolCall.name) content.push({
+			type: "function",
+			id: toolCall.id,
+			function: {
+				name: toolCall.name,
+				arguments: toolCall.arguments
+			}
+		});
+		return {
+			output: [{
+				role: "assistant",
+				content: content.length > 0 ? content : [{
+					type: "text",
+					text: ""
+				}]
+			}],
+			model: this.model,
+			completionId: this.completionId,
+			systemFingerprint: this.systemFingerprint,
+			serviceTier: this.serviceTier,
+			firstTokenTime: this.firstTokenTime,
+			stopReason: this.stopReason,
+			usage: { ...this.usage }
+		};
+	}
+};
 /** Pure state accumulator for OpenAI-compatible Responses stream events. */
-class OpenAIResponsesStreamAccumulator {
-  output = [];
-  usage = {
-    webSearchCount: 0
-  };
-  consume(event, receivedAt = Date.now()) {
-    if (this.firstTokenTime === undefined && isResponseTokenChunk(event)) {
-      this.firstTokenTime = receivedAt;
-    }
-    if (!('response' in event) || !event.response) {
-      return;
-    }
-    const response = event.response;
-    this.model ||= response.model || undefined;
-    this.completionId ||= response.id || undefined;
-    if (response.service_tier != null) {
-      this.serviceTier = response.service_tier;
-    }
-    const webSearchCount = calculateWebSearchCount(response);
-    if (webSearchCount > (this.usage.webSearchCount ?? 0)) {
-      this.usage.webSearchCount = webSearchCount;
-    }
-    if (response.usage) {
-      this.usage = {
-        ...this.usage,
-        inputTokens: response.usage.input_tokens ?? 0,
-        outputTokens: response.usage.output_tokens ?? 0,
-        reasoningTokens: response.usage.output_tokens_details?.reasoning_tokens ?? 0,
-        cacheReadInputTokens: response.usage.input_tokens_details?.cached_tokens ?? 0,
-        cacheCreationInputTokens: extractCacheWriteTokens(response.usage.input_tokens_details),
-        rawUsage: response.usage
-      };
-    }
-    if (isTerminalResponse(response)) {
-      this.terminalResponse = response;
-      this.output = response.output ?? [];
-      this.stopReason = response.status;
-    }
-  }
-  result() {
-    return {
-      output: [...this.output],
-      model: this.model,
-      completionId: this.completionId,
-      serviceTier: this.serviceTier,
-      firstTokenTime: this.firstTokenTime,
-      stopReason: this.stopReason,
-      usage: {
-        ...this.usage
-      },
-      terminalResponse: this.terminalResponse
-    };
-  }
-}
-
+var OpenAIResponsesStreamAccumulator = class {
+	constructor() {
+		this.output = [];
+		this.usage = { webSearchCount: 0 };
+	}
+	consume(event, receivedAt = Date.now()) {
+		if (this.firstTokenTime === void 0 && isResponseTokenChunk(event)) this.firstTokenTime = receivedAt;
+		if (!("response" in event) || !event.response) return;
+		const response = event.response;
+		this.model ||= response.model || void 0;
+		this.completionId ||= response.id || void 0;
+		if (response.service_tier != null) this.serviceTier = response.service_tier;
+		const webSearchCount = calculateWebSearchCount(response);
+		if (webSearchCount > (this.usage.webSearchCount ?? 0)) this.usage.webSearchCount = webSearchCount;
+		if (response.usage) this.usage = {
+			...this.usage,
+			inputTokens: response.usage.input_tokens ?? 0,
+			outputTokens: response.usage.output_tokens ?? 0,
+			reasoningTokens: response.usage.output_tokens_details?.reasoning_tokens ?? 0,
+			cacheReadInputTokens: response.usage.input_tokens_details?.cached_tokens ?? 0,
+			cacheCreationInputTokens: extractCacheWriteTokens(response.usage.input_tokens_details),
+			rawUsage: response.usage
+		};
+		if (isTerminalResponse(response)) {
+			this.terminalResponse = response;
+			this.output = response.output ?? [];
+			this.stopReason = responsesStopReason(response);
+		}
+	}
+	result() {
+		return {
+			output: [...this.output],
+			model: this.model,
+			completionId: this.completionId,
+			serviceTier: this.serviceTier,
+			firstTokenTime: this.firstTokenTime,
+			stopReason: this.stopReason,
+			usage: { ...this.usage },
+			terminalResponse: this.terminalResponse
+		};
+	}
+};
+//#endregion
+//#region src/openai/telemetry.ts
 function captureAiGenerationInBackground(...args) {
-  void captureAiGeneration(...args).catch(() => undefined);
+	captureAiGeneration(...args).catch(() => void 0);
 }
-
 /** Preserve immediate delivery while isolating normal telemetry from provider latency/failures. */
 async function captureAiGenerationAfterSuccess(...args) {
-  if (args[1].captureImmediate) {
-    await captureAiGeneration(...args);
-  } else {
-    captureAiGenerationInBackground(...args);
-  }
+	if (args[1].captureImmediate) await captureAiGeneration(...args);
+	else captureAiGenerationInBackground(...args);
 }
 function buildChatUsage(usage, webSearchSource) {
-  return {
-    inputTokens: usage?.prompt_tokens ?? 0,
-    outputTokens: usage?.completion_tokens ?? 0,
-    reasoningTokens: usage?.completion_tokens_details?.reasoning_tokens ?? 0,
-    cacheReadInputTokens: usage?.prompt_tokens_details?.cached_tokens ?? 0,
-    cacheCreationInputTokens: extractCacheWriteTokens(usage?.prompt_tokens_details),
-    webSearchCount: calculateWebSearchCount(webSearchSource),
-    rawUsage: usage
-  };
+	return {
+		inputTokens: usage?.prompt_tokens ?? 0,
+		outputTokens: usage?.completion_tokens ?? 0,
+		reasoningTokens: usage?.completion_tokens_details?.reasoning_tokens ?? 0,
+		cacheReadInputTokens: usage?.prompt_tokens_details?.cached_tokens ?? 0,
+		cacheCreationInputTokens: extractCacheWriteTokens(usage?.prompt_tokens_details),
+		webSearchCount: calculateWebSearchCount(webSearchSource),
+		rawUsage: usage
+	};
 }
 function buildResponsesUsage(usage, webSearchSource) {
-  return {
-    inputTokens: usage?.input_tokens ?? 0,
-    outputTokens: usage?.output_tokens ?? 0,
-    reasoningTokens: usage?.output_tokens_details?.reasoning_tokens ?? 0,
-    cacheReadInputTokens: usage?.input_tokens_details?.cached_tokens ?? 0,
-    cacheCreationInputTokens: extractCacheWriteTokens(usage?.input_tokens_details),
-    webSearchCount: calculateWebSearchCount(webSearchSource),
-    rawUsage: usage
-  };
+	return {
+		inputTokens: usage?.input_tokens ?? 0,
+		outputTokens: usage?.output_tokens ?? 0,
+		reasoningTokens: usage?.output_tokens_details?.reasoning_tokens ?? 0,
+		cacheReadInputTokens: usage?.input_tokens_details?.cached_tokens ?? 0,
+		cacheCreationInputTokens: extractCacheWriteTokens(usage?.input_tokens_details),
+		webSearchCount: calculateWebSearchCount(webSearchSource),
+		rawUsage: usage
+	};
 }
 function buildChatSuccessOptions(context, result) {
-  return {
-    ...context.monitoring,
-    model: context.params.model ?? result.model,
-    provider: context.provider,
-    input: sanitizeOpenAI(context.params.messages, context.client),
-    output: sanitizeOpenAIResponse(result.output, context.client),
-    latency: result.latency,
-    timeToFirstToken: result.timeToFirstToken,
-    baseURL: context.baseURL,
-    modelParameters: getModelParams(context.modelParametersSource, result.serviceTier),
-    httpStatus: 200,
-    usage: result.usage,
-    stopReason: result.stopReason,
-    tools: extractAvailableToolCalls('openai', context.params),
-    completionId: result.completionId,
-    providerMetadata: buildProviderMetadata({
-      systemFingerprint: result.systemFingerprint,
-      requestId: result.requestId
-    })
-  };
+	return {
+		...context.monitoring,
+		model: context.params.model ?? result.model,
+		provider: context.provider,
+		input: sanitizeOpenAI(context.params.messages, context.client),
+		output: sanitizeOpenAIResponse(result.output, context.client),
+		latency: result.latency,
+		timeToFirstToken: result.timeToFirstToken,
+		baseURL: context.baseURL,
+		modelParameters: getModelParams(context.modelParametersSource, result.serviceTier),
+		httpStatus: 200,
+		usage: result.usage,
+		stopReason: result.stopReason,
+		tools: extractAvailableToolCalls("openai", context.params),
+		completionId: result.completionId,
+		providerMetadata: buildProviderMetadata({
+			systemFingerprint: result.systemFingerprint,
+			requestId: result.requestId
+		})
+	};
 }
 function buildChatErrorOptions(context, error, metadata) {
-  return {
-    ...context.monitoring,
-    model: context.params.model,
-    provider: context.provider,
-    input: sanitizeOpenAI(context.params.messages, context.client),
-    output: [],
-    latency: metadata.latency,
-    baseURL: context.baseURL,
-    modelParameters: getModelParams(context.modelParametersSource),
-    usage: metadata.usage ?? {},
-    completionId: metadata.completionId,
-    providerMetadata: buildProviderMetadata({
-      systemFingerprint: metadata.systemFingerprint
-    }),
-    error
-  };
+	return {
+		...context.monitoring,
+		model: context.params.model,
+		provider: context.provider,
+		input: sanitizeOpenAI(context.params.messages, context.client),
+		output: [],
+		latency: metadata.latency,
+		baseURL: context.baseURL,
+		modelParameters: getModelParams(context.modelParametersSource),
+		usage: metadata.usage ?? {},
+		completionId: metadata.completionId,
+		providerMetadata: buildProviderMetadata({ systemFingerprint: metadata.systemFingerprint }),
+		error
+	};
 }
 function buildSanitizedResponsesInput(context) {
-  return formatOpenAIResponsesInput(sanitizeOpenAIResponse(context.params.input, context.client), sanitizeOpenAIResponse(context.params.instructions, context.client));
+	return formatOpenAIResponsesInput(sanitizeOpenAIResponse(context.params.input, context.client), sanitizeOpenAIResponse(context.params.instructions, context.client));
 }
 function buildResponsesSuccessOptions(context, result) {
-  const response = result.response;
-  return {
-    ...context.monitoring,
-    model: context.params.model ?? response.model,
-    provider: context.provider,
-    input: buildSanitizedResponsesInput(context),
-    output: sanitizeOpenAIResponse(result.output, context.client),
-    latency: result.latency,
-    timeToFirstToken: result.timeToFirstToken,
-    baseURL: context.baseURL,
-    modelParameters: getModelParams(context.modelParametersSource, response.service_tier),
-    httpStatus: 200,
-    usage: result.usage ?? buildResponsesUsage(response.usage, response),
-    stopReason: response.status ?? undefined,
-    tools: result.includeTools ? extractAvailableToolCalls('openai', context.params) : undefined,
-    completionId: response.id,
-    providerMetadata: buildProviderMetadata({
-      requestId: result.includeRequestId ? extractRequestId(response) : undefined,
-      incompleteDetails: response.incomplete_details
-    }),
-    error: getResponseFailure({
-      id: response.id,
-      status: response.status,
-      error: response.error ?? null
-    })
-  };
+	const response = result.response;
+	return {
+		...context.monitoring,
+		model: context.params.model ?? response.model,
+		provider: context.provider,
+		input: buildSanitizedResponsesInput(context),
+		output: sanitizeOpenAIResponse(result.output, context.client),
+		latency: result.latency,
+		timeToFirstToken: result.timeToFirstToken,
+		baseURL: context.baseURL,
+		modelParameters: getModelParams(context.modelParametersSource, response.service_tier),
+		httpStatus: 200,
+		usage: result.usage ?? buildResponsesUsage(response.usage, response),
+		stopReason: responsesStopReason(response),
+		tools: result.includeTools ? extractAvailableToolCalls("openai", context.params) : void 0,
+		completionId: response.id,
+		providerMetadata: buildProviderMetadata({
+			requestId: result.includeRequestId ? extractRequestId(response) : void 0,
+			incompleteDetails: response.incomplete_details
+		}),
+		error: getResponseFailure({
+			id: response.id,
+			status: response.status,
+			error: response.error ?? null
+		})
+	};
 }
 function buildBackgroundResponseOptions(context, response) {
-  return buildResponsesSuccessOptions(context, {
-    response,
-    output: formatResponseOpenAI({
-      output: response.output
-    }),
-    latency: getBackgroundResponseLatency(response),
-    includeTools: true,
-    includeRequestId: true
-  });
+	return buildResponsesSuccessOptions(context, {
+		response,
+		output: formatResponseOpenAI({ output: response.output }),
+		latency: getBackgroundResponseLatency(response),
+		includeTools: true,
+		includeRequestId: true
+	});
 }
 function buildResponsesErrorOptions(context, error, metadata) {
-  return {
-    ...context.monitoring,
-    model: context.params.model,
-    provider: context.provider,
-    input: buildSanitizedResponsesInput(context),
-    output: [],
-    latency: metadata.latency,
-    baseURL: context.baseURL,
-    modelParameters: getModelParams(context.modelParametersSource),
-    usage: metadata.usage ?? {},
-    completionId: metadata.completionId,
-    error
-  };
+	return {
+		...context.monitoring,
+		model: context.params.model,
+		provider: context.provider,
+		input: buildSanitizedResponsesInput(context),
+		output: [],
+		latency: metadata.latency,
+		baseURL: context.baseURL,
+		modelParameters: getModelParams(context.modelParametersSource),
+		usage: metadata.usage ?? {},
+		completionId: metadata.completionId,
+		error
+	};
 }
 function buildEmbeddingSuccessOptions(context, usage, latency) {
-  return {
-    eventType: AIEvent.Embedding,
-    ...context.monitoring,
-    model: context.params.model,
-    provider: context.provider,
-    input: withPrivacyMode(context.client, context.monitoring.privacyMode, context.params.input),
-    output: null,
-    latency,
-    baseURL: context.baseURL,
-    modelParameters: getModelParams(context.modelParametersSource),
-    httpStatus: 200,
-    usage: {
-      inputTokens: usage?.prompt_tokens ?? 0,
-      rawUsage: usage
-    }
-  };
+	return {
+		eventType: "$ai_embedding",
+		...context.monitoring,
+		model: context.params.model,
+		provider: context.provider,
+		input: withPrivacyMode(context.client, context.monitoring.privacyMode, context.params.input),
+		output: null,
+		latency,
+		baseURL: context.baseURL,
+		modelParameters: getModelParams(context.modelParametersSource),
+		httpStatus: 200,
+		usage: {
+			inputTokens: usage?.prompt_tokens ?? 0,
+			rawUsage: usage
+		}
+	};
 }
 function buildEmbeddingErrorOptions(context, error, latency) {
-  return {
-    eventType: AIEvent.Embedding,
-    ...context.monitoring,
-    model: context.params.model,
-    provider: context.provider,
-    input: withPrivacyMode(context.client, context.monitoring.privacyMode, context.params.input),
-    output: null,
-    latency,
-    baseURL: context.baseURL,
-    modelParameters: getModelParams(context.modelParametersSource),
-    usage: {},
-    error
-  };
-}
-
-class PostHogAzureOpenAI extends AzureOpenAI {
-  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);
-  }
+	return {
+		eventType: "$ai_embedding",
+		...context.monitoring,
+		model: context.params.model,
+		provider: context.provider,
+		input: withPrivacyMode(context.client, context.monitoring.privacyMode, context.params.input),
+		output: null,
+		latency,
+		baseURL: context.baseURL,
+		modelParameters: getModelParams(context.modelParametersSource),
+		usage: {},
+		error
+	};
 }
-let WrappedChat$1 = class WrappedChat extends AzureOpenAI.Chat {
-  constructor(parentClient, phClient) {
-    super(parentClient);
-    this.completions = new WrappedCompletions$1(parentClient, phClient);
-  }
+//#endregion
+//#region src/openai/azure.ts
+var PostHogAzureOpenAI = class extends AzureOpenAI {
+	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);
+	}
 };
-let WrappedCompletions$1 = class WrappedCompletions extends AzureOpenAI.Chat.Completions {
-  constructor(client, phClient) {
-    super(client);
-    this.phClient = phClient;
-    this.baseURL = client.baseURL;
-  }
-
-  // --- Overload #1: Non-streaming
-
-  // --- Overload #2: Streaming
-
-  // --- Overload #3: Generic base
-
-  // --- Implementation Signature
-  create(body, options) {
-    const {
-      providerParams: openAIParams,
-      posthogParams
-    } = extractPosthogParams(body);
-    const startTime = Date.now();
-    const parentPromise = super.create(openAIParams, options);
-    if (openAIParams.stream) {
-      const wrappedPromise = parentPromise.then(value => {
-        if (Symbol.asyncIterator in value) {
-          const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new Stream(iterator, controller));
-          (async () => {
-            const accumulator = new OpenAIChatStreamAccumulator();
-            try {
-              for await (const chunk of stream1) {
-                accumulator.consume(chunk);
-              }
-              const accumulated = accumulator.result();
-              await captureAiGeneration(this.phClient, buildChatSuccessOptions({
-                client: this.phClient,
-                provider: 'azure',
-                baseURL: this.baseURL,
-                params: openAIParams,
-                monitoring: posthogParams,
-                modelParametersSource: body
-              }, {
-                ...accumulated,
-                latency: (Date.now() - startTime) / 1000,
-                timeToFirstToken: accumulated.firstTokenTime === undefined ? undefined : (accumulated.firstTokenTime - startTime) / 1000
-              }));
-            } catch (error) {
-              const accumulated = accumulator.result();
-              await captureAiGeneration(this.phClient, buildChatErrorOptions({
-                client: this.phClient,
-                provider: 'azure',
-                baseURL: this.baseURL,
-                params: openAIParams,
-                monitoring: posthogParams,
-                modelParametersSource: body
-              }, error, {
-                completionId: accumulated.completionId,
-                systemFingerprint: accumulated.systemFingerprint,
-                usage: accumulated.usage,
-                latency: (Date.now() - startTime) / 1000
-              }));
-              throw error;
-            }
-          })().catch(() => {
-            // Swallow: analytics must never crash the host process. The caller
-            // already receives this error via their own tee of the stream.
-          });
-
-          // Return the other stream to the user
-          return stream2;
-        }
-        return value;
-      });
-      return preserveProviderPromise(parentPromise, wrappedPromise);
-    } else {
-      const wrappedPromise = parentPromise.then(async result => {
-        if ('choices' in result) {
-          await captureAiGenerationAfterSuccess(this.phClient, buildChatSuccessOptions({
-            client: this.phClient,
-            provider: 'azure',
-            baseURL: this.baseURL,
-            params: openAIParams,
-            monitoring: posthogParams,
-            modelParametersSource: body
-          }, {
-            output: formatResponseOpenAI(result),
-            model: result.model,
-            serviceTier: result.service_tier ?? undefined,
-            latency: (Date.now() - startTime) / 1000,
-            usage: buildChatUsage(result.usage, result),
-            stopReason: result.choices[0]?.finish_reason ?? undefined,
-            completionId: result.id,
-            systemFingerprint: result.system_fingerprint,
-            requestId: result._request_id
-          }));
-        }
-        return result;
-      }, async error => {
-        await captureAiGeneration(this.phClient, buildChatErrorOptions({
-          client: this.phClient,
-          provider: 'azure',
-          baseURL: this.baseURL,
-          params: openAIParams,
-          monitoring: posthogParams,
-          modelParametersSource: body
-        }, error, {
-          latency: (Date.now() - startTime) / 1000
-        }));
-        throw error;
-      });
-      return preserveProviderPromise(parentPromise, wrappedPromise);
-    }
-  }
+var WrappedChat$1 = class extends AzureOpenAI.Chat {
+	constructor(parentClient, phClient) {
+		super(parentClient);
+		this.completions = new WrappedCompletions$1(parentClient, phClient);
+	}
 };
-let WrappedResponses$1 = class WrappedResponses extends AzureOpenAI.Responses {
-  backgroundResponses = new BackgroundResponseTracker();
-  constructor(client, phClient) {
-    super(client);
-    this.phClient = phClient;
-    this.baseURL = client.baseURL;
-  }
-  async captureBackgroundResponse(result, context) {
-    const {
-      openAIParams,
-      posthogParams
-    } = context;
-    await captureAiGenerationAfterSuccess(this.phClient, buildBackgroundResponseOptions({
-      client: this.phClient,
-      provider: 'azure',
-      baseURL: this.baseURL,
-      params: openAIParams,
-      monitoring: posthogParams,
-      modelParametersSource: openAIParams
-    }, result));
-  }
-
-  // --- Overload #1: Non-streaming
-
-  // --- Overload #2: Streaming
-
-  // --- Overload #3: Generic base
-
-  // --- Implementation Signature
-  create(body, options) {
-    const {
-      providerParams: openAIParams,
-      posthogParams
-    } = extractPosthogParams(body);
-    const startTime = Date.now();
-    const parentPromise = super.create(openAIParams, options);
-    if (openAIParams.stream) {
-      const wrappedPromise = parentPromise.then(value => {
-        if (Symbol.asyncIterator in value) {
-          const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new Stream(iterator, controller));
-          (async () => {
-            const accumulator = new OpenAIResponsesStreamAccumulator();
-            try {
-              for await (const chunk of stream1) {
-                accumulator.consume(chunk);
-                if (openAIParams.background === true && 'response' in chunk && chunk.response && !this.backgroundResponses.get(chunk.response.id)) {
-                  this.backgroundResponses.set(chunk.response.id, {
-                    openAIParams,
-                    posthogParams
-                  });
-                }
-              }
-              const accumulated = accumulator.result();
-              if (openAIParams.background === true) {
-                if (accumulated.terminalResponse) {
-                  const context = this.backgroundResponses.take(accumulated.terminalResponse.id);
-                  if (context) {
-                    await this.captureBackgroundResponse(accumulated.terminalResponse, context).catch(() => undefined);
-                  }
-                }
-                return;
-              }
-              const response = accumulated.terminalResponse ?? {
-                id: accumulated.completionId ?? '',
-                model: accumulated.model ?? openAIParams.model,
-                status: accumulated.stopReason,
-                service_tier: accumulated.serviceTier
-              };
-              await captureAiGeneration(this.phClient, buildResponsesSuccessOptions({
-                client: this.phClient,
-                provider: 'azure',
-                baseURL: this.baseURL,
-                params: openAIParams,
-                monitoring: posthogParams,
-                modelParametersSource: body
-              }, {
-                response,
-                output: accumulated.output,
-                latency: (Date.now() - startTime) / 1000,
-                timeToFirstToken: accumulated.firstTokenTime === undefined ? undefined : (accumulated.firstTokenTime - startTime) / 1000,
-                usage: accumulated.usage,
-                includeTools: true
-              }));
-            } catch (error) {
-              const accumulated = accumulator.result();
-              if (openAIParams.background === true && accumulated.completionId && this.backgroundResponses.get(accumulated.completionId)) {
-                throw error;
-              }
-              await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
-                client: this.phClient,
-                provider: 'azure',
-                baseURL: this.baseURL,
-                params: openAIParams,
-                monitoring: posthogParams,
-                modelParametersSource: body
-              }, error, {
-                completionId: accumulated.completionId,
-                usage: accumulated.usage,
-                latency: (Date.now() - startTime) / 1000
-              }));
-              throw error;
-            }
-          })().catch(() => {
-            // Swallow: analytics must never crash the host process. The caller
-            // already receives this error via their own tee of the stream.
-          });
-          return stream2;
-        }
-        return value;
-      });
-      return preserveProviderPromise(parentPromise, wrappedPromise);
-    } else {
-      const wrappedPromise = parentPromise.then(async result => {
-        if ('output' in result) {
-          if (isPendingBackgroundResponse(openAIParams, result)) {
-            this.backgroundResponses.set(result.id, {
-              openAIParams,
-              posthogParams
-            });
-            return result;
-          }
-          await captureAiGenerationAfterSuccess(this.phClient, buildResponsesSuccessOptions({
-            client: this.phClient,
-            provider: 'azure',
-            baseURL: this.baseURL,
-            params: openAIParams,
-            monitoring: posthogParams,
-            modelParametersSource: body
-          }, {
-            response: result,
-            output: formatResponseOpenAI({
-              output: result.output
-            }),
-            latency: (Date.now() - startTime) / 1000,
-            includeTools: true,
-            includeRequestId: true
-          }));
-        }
-        return result;
-      }, async error => {
-        await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
-          client: this.phClient,
-          provider: 'azure',
-          baseURL: this.baseURL,
-          params: openAIParams,
-          monitoring: posthogParams,
-          modelParametersSource: body
-        }, error, {
-          latency: (Date.now() - startTime) / 1000
-        }));
-        throw error;
-      });
-      return preserveProviderPromise(parentPromise, wrappedPromise);
-    }
-  }
-  retrieve(responseID, query = {}, options) {
-    const parentPromise = super.retrieve(responseID, query, options);
-
-    // Preserve the upstream promise and stream unchanged for responses that
-    // were not created through this client.
-    if (!this.backgroundResponses.get(responseID)) {
-      return parentPromise;
-    }
-    if (query.stream) {
-      return parentPromise._thenUnwrap(result => {
-        if ('controller' in result) {
-          return wrapBackgroundResponseStream(result, responseID, this.backgroundResponses, (response, context) => this.captureBackgroundResponse(response, context));
-        }
-        return result;
-      });
-    }
-    return parentPromise._thenUnwrap(async result => {
-      if (!('output' in result) || !isTerminalResponse(result)) {
-        return result;
-      }
-
-      // Removing the context before capture makes concurrent or repeated
-      // terminal polls idempotent.
-      const context = this.backgroundResponses.take(responseID);
-      if (context) {
-        await this.captureBackgroundResponse(result, context).catch(() => undefined);
-      }
-      return result;
-    });
-  }
-  cancel(responseID, options) {
-    const parentPromise = super.cancel(responseID, options);
-
-    // Avoid wrapping calls that do not belong to a background response created
-    // through this client, preserving the upstream APIPromise unchanged.
-    if (!this.backgroundResponses.get(responseID)) {
-      return parentPromise;
-    }
-    return parentPromise._thenUnwrap(async result => {
-      if (!isTerminalResponse(result)) {
-        return result;
-      }
-      const context = this.backgroundResponses.take(responseID);
-      if (context) {
-        await this.captureBackgroundResponse(result, context).catch(() => undefined);
-      }
-      return result;
-    });
-  }
-  parse(body, options) {
-    const {
-      providerParams: openAIParams,
-      posthogParams
-    } = extractPosthogParams(body);
-    const startTime = Date.now();
-    const parentPromise = callWithOriginalCreate(this, super.create.bind(this), () => super.parse(openAIParams, options));
-    const wrappedPromise = parentPromise.then(async result => {
-      if (isPendingBackgroundResponse(openAIParams, result)) {
-        this.backgroundResponses.set(result.id, {
-          openAIParams,
-          posthogParams
-        });
-        return result;
-      }
-      await captureAiGeneration(this.phClient, buildResponsesSuccessOptions({
-        client: this.phClient,
-        provider: 'azure',
-        baseURL: this.baseURL,
-        params: openAIParams,
-        monitoring: posthogParams,
-        modelParametersSource: body
-      }, {
-        response: result,
-        output: result.output,
-        latency: (Date.now() - startTime) / 1000,
-        includeRequestId: true
-      }));
-      return result;
-    }, async error => {
-      await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
-        client: this.phClient,
-        provider: 'azure',
-        baseURL: this.baseURL,
-        params: openAIParams,
-        monitoring: posthogParams,
-        modelParametersSource: body
-      }, error, {
-        latency: (Date.now() - startTime) / 1000
-      }));
-      throw error;
-    });
-    return preserveProviderPromise(parentPromise, wrappedPromise);
-  }
+var WrappedCompletions$1 = class extends AzureOpenAI.Chat.Completions {
+	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);
+		if (openAIParams.stream) return preserveProviderPromise(parentPromise, parentPromise.then((value) => {
+			if (Symbol.asyncIterator in value) {
+				const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new Stream(iterator, controller));
+				(async () => {
+					const accumulator = new OpenAIChatStreamAccumulator();
+					try {
+						for await (const chunk of stream1) accumulator.consume(chunk);
+						const accumulated = accumulator.result();
+						await captureAiGeneration(this.phClient, buildChatSuccessOptions({
+							client: this.phClient,
+							provider: "azure",
+							baseURL: this.baseURL,
+							params: openAIParams,
+							monitoring: posthogParams,
+							modelParametersSource: body
+						}, {
+							...accumulated,
+							latency: (Date.now() - startTime) / 1e3,
+							timeToFirstToken: accumulated.firstTokenTime === void 0 ? void 0 : (accumulated.firstTokenTime - startTime) / 1e3
+						}));
+					} catch (error) {
+						const accumulated = accumulator.result();
+						await captureAiGeneration(this.phClient, buildChatErrorOptions({
+							client: this.phClient,
+							provider: "azure",
+							baseURL: this.baseURL,
+							params: openAIParams,
+							monitoring: posthogParams,
+							modelParametersSource: body
+						}, error, {
+							completionId: accumulated.completionId,
+							systemFingerprint: accumulated.systemFingerprint,
+							usage: accumulated.usage,
+							latency: (Date.now() - startTime) / 1e3
+						}));
+						throw error;
+					}
+				})().catch(() => {});
+				return stream2;
+			}
+			return value;
+		}));
+		else return preserveProviderPromise(parentPromise, parentPromise.then(async (result) => {
+			if ("choices" in result) await captureAiGenerationAfterSuccess(this.phClient, buildChatSuccessOptions({
+				client: this.phClient,
+				provider: "azure",
+				baseURL: this.baseURL,
+				params: openAIParams,
+				monitoring: posthogParams,
+				modelParametersSource: body
+			}, {
+				output: formatResponseOpenAI(result),
+				model: result.model,
+				serviceTier: result.service_tier ?? void 0,
+				latency: (Date.now() - startTime) / 1e3,
+				usage: buildChatUsage(result.usage, result),
+				stopReason: result.choices[0]?.finish_reason ?? void 0,
+				completionId: result.id,
+				systemFingerprint: result.system_fingerprint,
+				requestId: result._request_id
+			}));
+			return result;
+		}, async (error) => {
+			await captureAiGeneration(this.phClient, buildChatErrorOptions({
+				client: this.phClient,
+				provider: "azure",
+				baseURL: this.baseURL,
+				params: openAIParams,
+				monitoring: posthogParams,
+				modelParametersSource: body
+			}, error, { latency: (Date.now() - startTime) / 1e3 }));
+			throw error;
+		}));
+	}
 };
-let WrappedEmbeddings$1 = class WrappedEmbeddings extends AzureOpenAI.Embeddings {
-  constructor(client, phClient) {
-    super(client);
-    this.phClient = phClient;
-    this.baseURL = client.baseURL;
-  }
-  create(body, options) {
-    const {
-      providerParams: openAIParams,
-      posthogParams
-    } = extractPosthogParams(body);
-    const startTime = Date.now();
-    const parentPromise = super.create(openAIParams, options);
-    const wrappedPromise = parentPromise.then(async result => {
-      await captureAiGeneration(this.phClient, buildEmbeddingSuccessOptions({
-        client: this.phClient,
-        provider: 'azure',
-        baseURL: this.baseURL,
-        params: openAIParams,
-        monitoring: posthogParams,
-        modelParametersSource: body
-      }, result.usage, (Date.now() - startTime) / 1000));
-      return result;
-    }, async error => {
-      await captureAiGeneration(this.phClient, buildEmbeddingErrorOptions({
-        client: this.phClient,
-        provider: 'azure',
-        baseURL: this.baseURL,
-        params: openAIParams,
-        monitoring: posthogParams,
-        modelParametersSource: body
-      }, error, (Date.now() - startTime) / 1000));
-      throw error;
-    });
-    return preserveProviderPromise(parentPromise, wrappedPromise);
-  }
+var WrappedResponses$1 = class extends AzureOpenAI.Responses {
+	constructor(client, phClient) {
+		super(client);
+		this.backgroundResponses = new BackgroundResponseTracker();
+		this.phClient = phClient;
+		this.baseURL = client.baseURL;
+	}
+	async captureBackgroundResponse(result, context) {
+		const { openAIParams, posthogParams } = context;
+		await captureAiGenerationAfterSuccess(this.phClient, buildBackgroundResponseOptions({
+			client: this.phClient,
+			provider: "azure",
+			baseURL: this.baseURL,
+			params: openAIParams,
+			monitoring: posthogParams,
+			modelParametersSource: openAIParams
+		}, result));
+	}
+	create(body, options) {
+		const { providerParams: openAIParams, posthogParams } = extractPosthogParams(body);
+		const startTime = Date.now();
+		const parentPromise = super.create(openAIParams, options);
+		if (openAIParams.stream) return preserveProviderPromise(parentPromise, parentPromise.then((value) => {
+			if (Symbol.asyncIterator in value) {
+				const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new Stream(iterator, controller));
+				(async () => {
+					const accumulator = new OpenAIResponsesStreamAccumulator();
+					try {
+						for await (const chunk of stream1) {
+							accumulator.consume(chunk);
+							if (openAIParams.background === true && "response" in chunk && chunk.response && !this.backgroundResponses.get(chunk.response.id)) this.backgroundResponses.set(chunk.response.id, {
+								openAIParams,
+								posthogParams
+							});
+						}
+						const accumulated = accumulator.result();
+						if (openAIParams.background === true) {
+							if (accumulated.terminalResponse) {
+								const context = this.backgroundResponses.take(accumulated.terminalResponse.id);
+								if (context) await this.captureBackgroundResponse(accumulated.terminalResponse, context).catch(() => void 0);
+							}
+							return;
+						}
+						const response = accumulated.terminalResponse ?? {
+							id: accumulated.completionId ?? "",
+							model: accumulated.model ?? openAIParams.model,
+							service_tier: accumulated.serviceTier
+						};
+						await captureAiGeneration(this.phClient, buildResponsesSuccessOptions({
+							client: this.phClient,
+							provider: "azure",
+							baseURL: this.baseURL,
+							params: openAIParams,
+							monitoring: posthogParams,
+							modelParametersSource: body
+						}, {
+							response,
+							output: accumulated.output,
+							latency: (Date.now() - startTime) / 1e3,
+							timeToFirstToken: accumulated.firstTokenTime === void 0 ? void 0 : (accumulated.firstTokenTime - startTime) / 1e3,
+							usage: accumulated.usage,
+							includeTools: true
+						}));
+					} catch (error) {
+						const accumulated = accumulator.result();
+						if (openAIParams.background === true && accumulated.completionId && this.backgroundResponses.get(accumulated.completionId)) throw error;
+						await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
+							client: this.phClient,
+							provider: "azure",
+							baseURL: this.baseURL,
+							params: openAIParams,
+							monitoring: posthogParams,
+							modelParametersSource: body
+						}, error, {
+							completionId: accumulated.completionId,
+							usage: accumulated.usage,
+							latency: (Date.now() - startTime) / 1e3
+						}));
+						throw error;
+					}
+				})().catch(() => {});
+				return stream2;
+			}
+			return value;
+		}));
+		else return preserveProviderPromise(parentPromise, parentPromise.then(async (result) => {
+			if ("output" in result) {
+				if (isPendingBackgroundResponse(openAIParams, result)) {
+					this.backgroundResponses.set(result.id, {
+						openAIParams,
+						posthogParams
+					});
+					return result;
+				}
+				await captureAiGenerationAfterSuccess(this.phClient, buildResponsesSuccessOptions({
+					client: this.phClient,
+					provider: "azure",
+					baseURL: this.baseURL,
+					params: openAIParams,
+					monitoring: posthogParams,
+					modelParametersSource: body
+				}, {
+					response: result,
+					output: formatResponseOpenAI({ output: result.output }),
+					latency: (Date.now() - startTime) / 1e3,
+					includeTools: true,
+					includeRequestId: true
+				}));
+			}
+			return result;
+		}, async (error) => {
+			await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
+				client: this.phClient,
+				provider: "azure",
+				baseURL: this.baseURL,
+				params: openAIParams,
+				monitoring: posthogParams,
+				modelParametersSource: body
+			}, error, { latency: (Date.now() - startTime) / 1e3 }));
+			throw error;
+		}));
+	}
+	retrieve(responseID, query = {}, options) {
+		const parentPromise = super.retrieve(responseID, query, options);
+		if (!this.backgroundResponses.get(responseID)) return parentPromise;
+		if (query.stream) return parentPromise._thenUnwrap((result) => {
+			if ("controller" in result) return wrapBackgroundResponseStream(result, responseID, this.backgroundResponses, (response, context) => this.captureBackgroundResponse(response, context));
+			return result;
+		});
+		return parentPromise._thenUnwrap(async (result) => {
+			if (!("output" in result) || !isTerminalResponse(result)) return result;
+			const context = this.backgroundResponses.take(responseID);
+			if (context) await this.captureBackgroundResponse(result, context).catch(() => void 0);
+			return result;
+		});
+	}
+	cancel(responseID, options) {
+		const parentPromise = super.cancel(responseID, options);
+		if (!this.backgroundResponses.get(responseID)) return parentPromise;
+		return parentPromise._thenUnwrap(async (result) => {
+			if (!isTerminalResponse(result)) return result;
+			const context = this.backgroundResponses.take(responseID);
+			if (context) await this.captureBackgroundResponse(result, context).catch(() => void 0);
+			return result;
+		});
+	}
+	parse(body, options) {
+		const { providerParams: openAIParams, posthogParams } = extractPosthogParams(body);
+		const startTime = Date.now();
+		const parentPromise = callWithOriginalCreate(this, super.create.bind(this), () => super.parse(openAIParams, options));
+		return preserveProviderPromise(parentPromise, parentPromise.then(async (result) => {
+			if (isPendingBackgroundResponse(openAIParams, result)) {
+				this.backgroundResponses.set(result.id, {
+					openAIParams,
+					posthogParams
+				});
+				return result;
+			}
+			await captureAiGeneration(this.phClient, buildResponsesSuccessOptions({
+				client: this.phClient,
+				provider: "azure",
+				baseURL: this.baseURL,
+				params: openAIParams,
+				monitoring: posthogParams,
+				modelParametersSource: body
+			}, {
+				response: result,
+				output: result.output,
+				latency: (Date.now() - startTime) / 1e3,
+				includeRequestId: true
+			}));
+			return result;
+		}, async (error) => {
+			await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
+				client: this.phClient,
+				provider: "azure",
+				baseURL: this.baseURL,
+				params: openAIParams,
+				monitoring: posthogParams,
+				modelParametersSource: body
+			}, error, { latency: (Date.now() - startTime) / 1e3 }));
+			throw error;
+		}));
+	}
 };
-
+var WrappedEmbeddings$1 = class extends AzureOpenAI.Embeddings {
+	constructor(client, phClient) {
+		super(client);
+		this.phClient = phClient;
+		this.baseURL = client.baseURL;
+	}
+	create(body, options) {
+		const { providerParams: openAIParams, posthogParams } = extractPosthogParams(body);
+		const startTime = Date.now();
+		const parentPromise = super.create(openAIParams, options);
+		return preserveProviderPromise(parentPromise, parentPromise.then(async (result) => {
+			await captureAiGeneration(this.phClient, buildEmbeddingSuccessOptions({
+				client: this.phClient,
+				provider: "azure",
+				baseURL: this.baseURL,
+				params: openAIParams,
+				monitoring: posthogParams,
+				modelParametersSource: body
+			}, result.usage, (Date.now() - startTime) / 1e3));
+			return result;
+		}, async (error) => {
+			await captureAiGeneration(this.phClient, buildEmbeddingErrorOptions({
+				client: this.phClient,
+				provider: "azure",
+				baseURL: this.baseURL,
+				params: openAIParams,
+				monitoring: posthogParams,
+				modelParametersSource: body
+			}, error, (Date.now() - startTime) / 1e3));
+			throw error;
+		}));
+	}
+};
+//#endregion
+//#region src/openai/index.ts
 const Chat = OpenAI.Chat;
 const Completions = Chat.Completions;
 const Responses = OpenAI.Responses;
 const Embeddings = OpenAI.Embeddings;
 const Audio = OpenAI.Audio;
 const Transcriptions = OpenAI.Audio.Transcriptions;
-class PostHogOpenAI extends OpenAI {
-  constructor(config) {
-    const {
-      posthog,
-      ...openAIConfig
-    } = config;
-    super(openAIConfig);
-    this.phClient = posthog;
-    this.chat = new WrappedChat(this, this.phClient);
-    this.responses = new WrappedResponses(this, this.phClient);
-    this.embeddings = new WrappedEmbeddings(this, this.phClient);
-    this.audio = new WrappedAudio(this, this.phClient);
-  }
-}
-class WrappedChat extends Chat {
-  constructor(parentClient, phClient) {
-    super(parentClient);
-    this.completions = new WrappedCompletions(parentClient, phClient);
-  }
-}
-class WrappedCompletions extends Completions {
-  constructor(client, phClient) {
-    super(client);
-    this.phClient = phClient;
-    this.baseURL = client.baseURL;
-  }
-
-  // --- Overload #1: Non-streaming
-
-  // --- Overload #2: Streaming
-
-  // --- Overload #3: Generic base
-
-  // --- Implementation Signature
-  create(body, options) {
-    const {
-      providerParams: openAIParams,
-      posthogParams
-    } = extractPosthogParams(body);
-    const startTime = Date.now();
-    const parentPromise = super.create(openAIParams, options);
-    if (openAIParams.stream) {
-      const wrappedPromise = parentPromise.then(value => {
-        if (Symbol.asyncIterator in value) {
-          const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new Stream(iterator, controller));
-          (async () => {
-            const accumulator = new OpenAIChatStreamAccumulator();
-            try {
-              for await (const chunk of stream1) {
-                accumulator.consume(chunk);
-              }
-              const accumulated = accumulator.result();
-              await captureAiGeneration(this.phClient, buildChatSuccessOptions({
-                client: this.phClient,
-                provider: 'openai',
-                baseURL: this.baseURL,
-                params: openAIParams,
-                monitoring: posthogParams,
-                modelParametersSource: body
-              }, {
-                ...accumulated,
-                latency: (Date.now() - startTime) / 1000,
-                timeToFirstToken: accumulated.firstTokenTime === undefined ? undefined : (accumulated.firstTokenTime - startTime) / 1000
-              }));
-            } catch (error) {
-              const accumulated = accumulator.result();
-              await captureAiGeneration(this.phClient, buildChatErrorOptions({
-                client: this.phClient,
-                provider: 'openai',
-                baseURL: this.baseURL,
-                params: openAIParams,
-                monitoring: posthogParams,
-                modelParametersSource: body
-              }, error, {
-                completionId: accumulated.completionId,
-                systemFingerprint: accumulated.systemFingerprint,
-                usage: accumulated.usage,
-                latency: (Date.now() - startTime) / 1000
-              }));
-              throw error;
-            }
-          })().catch(() => {
-            // Swallow: analytics must never crash the host process. The caller
-            // already receives this error via their own tee of the stream.
-          });
-
-          // Return the other stream to the user
-          return stream2;
-        }
-        return value;
-      });
-      return preserveProviderPromise(parentPromise, wrappedPromise);
-    } else {
-      const wrappedPromise = parentPromise.then(async result => {
-        if ('choices' in result) {
-          await captureAiGenerationAfterSuccess(this.phClient, buildChatSuccessOptions({
-            client: this.phClient,
-            provider: 'openai',
-            baseURL: this.baseURL,
-            params: openAIParams,
-            monitoring: posthogParams,
-            modelParametersSource: body
-          }, {
-            output: formatResponseOpenAI(result),
-            model: result.model,
-            serviceTier: result.service_tier ?? undefined,
-            latency: (Date.now() - startTime) / 1000,
-            usage: buildChatUsage(result.usage, result),
-            stopReason: result.choices[0]?.finish_reason ?? undefined,
-            completionId: result.id,
-            systemFingerprint: result.system_fingerprint,
-            requestId: extractRequestId(result)
-          }));
-        }
-        return result;
-      }, async error => {
-        await captureAiGeneration(this.phClient, buildChatErrorOptions({
-          client: this.phClient,
-          provider: 'openai',
-          baseURL: this.baseURL,
-          params: openAIParams,
-          monitoring: posthogParams,
-          modelParametersSource: body
-        }, error, {
-          latency: (Date.now() - startTime) / 1000
-        }));
-        throw error;
-      });
-      return preserveProviderPromise(parentPromise, wrappedPromise);
-    }
-  }
-}
-class WrappedResponses extends Responses {
-  backgroundResponses = new BackgroundResponseTracker();
-  constructor(client, phClient) {
-    super(client);
-    this.phClient = phClient;
-    this.baseURL = client.baseURL;
-  }
-  async captureBackgroundResponse(result, context) {
-    const {
-      openAIParams,
-      posthogParams
-    } = context;
-    await captureAiGenerationAfterSuccess(this.phClient, buildBackgroundResponseOptions({
-      client: this.phClient,
-      provider: 'openai',
-      baseURL: this.baseURL,
-      params: openAIParams,
-      monitoring: posthogParams,
-      modelParametersSource: openAIParams
-    }, result));
-  }
-
-  // --- Overload #1: Non-streaming
-
-  // --- Overload #2: Streaming
-
-  // --- Overload #3: Generic base
-
-  // --- Implementation Signature
-  create(body, options) {
-    const {
-      providerParams: openAIParams,
-      posthogParams
-    } = extractPosthogParams(body);
-    const startTime = Date.now();
-    const parentPromise = super.create(openAIParams, options);
-    if (openAIParams.stream) {
-      const wrappedPromise = parentPromise.then(value => {
-        if (Symbol.asyncIterator in value) {
-          const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new Stream(iterator, controller));
-          (async () => {
-            const accumulator = new OpenAIResponsesStreamAccumulator();
-            try {
-              for await (const chunk of stream1) {
-                accumulator.consume(chunk);
-                if (openAIParams.background === true && 'response' in chunk && chunk.response && !this.backgroundResponses.get(chunk.response.id)) {
-                  this.backgroundResponses.set(chunk.response.id, {
-                    openAIParams,
-                    posthogParams
-                  });
-                }
-              }
-              const accumulated = accumulator.result();
-              if (openAIParams.background === true) {
-                if (accumulated.terminalResponse) {
-                  const context = this.backgroundResponses.take(accumulated.terminalResponse.id);
-                  if (context) {
-                    await this.captureBackgroundResponse(accumulated.terminalResponse, context).catch(() => undefined);
-                  }
-                }
-                return;
-              }
-              const response = accumulated.terminalResponse ?? {
-                id: accumulated.completionId ?? '',
-                model: accumulated.model ?? openAIParams.model,
-                status: accumulated.stopReason,
-                service_tier: accumulated.serviceTier
-              };
-              await captureAiGeneration(this.phClient, buildResponsesSuccessOptions({
-                client: this.phClient,
-                provider: 'openai',
-                baseURL: this.baseURL,
-                params: openAIParams,
-                monitoring: posthogParams,
-                modelParametersSource: body
-              }, {
-                response,
-                output: accumulated.output,
-                latency: (Date.now() - startTime) / 1000,
-                timeToFirstToken: accumulated.firstTokenTime === undefined ? undefined : (accumulated.firstTokenTime - startTime) / 1000,
-                usage: accumulated.usage,
-                includeTools: true
-              }));
-            } catch (error) {
-              const accumulated = accumulator.result();
-              if (openAIParams.background === true && accumulated.completionId && this.backgroundResponses.get(accumulated.completionId)) {
-                throw error;
-              }
-              await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
-                client: this.phClient,
-                provider: 'openai',
-                baseURL: this.baseURL,
-                params: openAIParams,
-                monitoring: posthogParams,
-                modelParametersSource: body
-              }, error, {
-                completionId: accumulated.completionId,
-                usage: accumulated.usage,
-                latency: (Date.now() - startTime) / 1000
-              }));
-              throw error;
-            }
-          })().catch(() => {
-            // Swallow: analytics must never crash the host process. The caller
-            // already receives this error via their own tee of the stream.
-          });
-          return stream2;
-        }
-        return value;
-      });
-      return preserveProviderPromise(parentPromise, wrappedPromise);
-    } else {
-      const wrappedPromise = parentPromise.then(async result => {
-        if ('output' in result) {
-          if (isPendingBackgroundResponse(openAIParams, result)) {
-            this.backgroundResponses.set(result.id, {
-              openAIParams,
-              posthogParams
-            });
-            return result;
-          }
-          await captureAiGenerationAfterSuccess(this.phClient, buildResponsesSuccessOptions({
-            client: this.phClient,
-            provider: 'openai',
-            baseURL: this.baseURL,
-            params: openAIParams,
-            monitoring: posthogParams,
-            modelParametersSource: body
-          }, {
-            response: result,
-            output: formatResponseOpenAI({
-              output: result.output
-            }),
-            latency: (Date.now() - startTime) / 1000,
-            includeTools: true,
-            includeRequestId: true
-          }));
-        }
-        return result;
-      }, async error => {
-        await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
-          client: this.phClient,
-          provider: 'openai',
-          baseURL: this.baseURL,
-          params: openAIParams,
-          monitoring: posthogParams,
-          modelParametersSource: body
-        }, error, {
-          latency: (Date.now() - startTime) / 1000
-        }));
-        throw error;
-      });
-      return preserveProviderPromise(parentPromise, wrappedPromise);
-    }
-  }
-  retrieve(responseID, query = {}, options) {
-    const parentPromise = super.retrieve(responseID, query, options);
-
-    // Preserve the upstream promise and stream unchanged for responses that
-    // were not created through this client.
-    if (!this.backgroundResponses.get(responseID)) {
-      return parentPromise;
-    }
-    if (query.stream) {
-      return parentPromise._thenUnwrap(result => {
-        if ('controller' in result) {
-          return wrapBackgroundResponseStream(result, responseID, this.backgroundResponses, (response, context) => this.captureBackgroundResponse(response, context));
-        }
-        return result;
-      });
-    }
-    return parentPromise._thenUnwrap(async result => {
-      if (!('output' in result) || !isTerminalResponse(result)) {
-        return result;
-      }
-
-      // Removing the context before capture makes concurrent or repeated
-      // terminal polls idempotent.
-      const context = this.backgroundResponses.take(responseID);
-      if (context) {
-        await this.captureBackgroundResponse(result, context).catch(() => undefined);
-      }
-      return result;
-    });
-  }
-  cancel(responseID, options) {
-    const parentPromise = super.cancel(responseID, options);
-
-    // Avoid wrapping calls that do not belong to a background response created
-    // through this client, preserving the upstream APIPromise unchanged.
-    if (!this.backgroundResponses.get(responseID)) {
-      return parentPromise;
-    }
-    return parentPromise._thenUnwrap(async result => {
-      if (!isTerminalResponse(result)) {
-        return result;
-      }
-      const context = this.backgroundResponses.take(responseID);
-      if (context) {
-        await this.captureBackgroundResponse(result, context).catch(() => undefined);
-      }
-      return result;
-    });
-  }
-  parse(body, options) {
-    const {
-      providerParams: openAIParams,
-      posthogParams
-    } = extractPosthogParams(body);
-    const startTime = Date.now();
-    const parentPromise = callWithOriginalCreate(this, super.create.bind(this), () => super.parse(openAIParams, options));
-    const wrappedPromise = parentPromise.then(async result => {
-      if (isPendingBackgroundResponse(openAIParams, result)) {
-        this.backgroundResponses.set(result.id, {
-          openAIParams,
-          posthogParams
-        });
-        return result;
-      }
-      await captureAiGeneration(this.phClient, buildResponsesSuccessOptions({
-        client: this.phClient,
-        provider: 'openai',
-        baseURL: this.baseURL,
-        params: openAIParams,
-        monitoring: posthogParams,
-        modelParametersSource: body
-      }, {
-        response: result,
-        output: result.output,
-        latency: (Date.now() - startTime) / 1000,
-        includeRequestId: true
-      }));
-      return result;
-    }, async error => {
-      await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
-        client: this.phClient,
-        provider: 'openai',
-        baseURL: this.baseURL,
-        params: openAIParams,
-        monitoring: posthogParams,
-        modelParametersSource: body
-      }, error, {
-        latency: (Date.now() - startTime) / 1000
-      }));
-      throw error;
-    });
-    return preserveProviderPromise(parentPromise, wrappedPromise);
-  }
-}
-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 => {
-      await captureAiGeneration(this.phClient, buildEmbeddingSuccessOptions({
-        client: this.phClient,
-        provider: 'openai',
-        baseURL: this.baseURL,
-        params: openAIParams,
-        monitoring: posthogParams,
-        modelParametersSource: body
-      }, result.usage, (Date.now() - startTime) / 1000));
-      return result;
-    }, async error => {
-      await captureAiGeneration(this.phClient, buildEmbeddingErrorOptions({
-        client: this.phClient,
-        provider: 'openai',
-        baseURL: this.baseURL,
-        params: openAIParams,
-        monitoring: posthogParams,
-        modelParametersSource: body
-      }, error, (Date.now() - startTime) / 1000));
-      throw error;
-    });
-    return preserveProviderPromise(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;
-  }
-
-  // --- Overload #1: Non-streaming
-
-  // --- Overload #2: Non-streaming
-
-  // --- Overload #3: Non-streaming
-
-  // --- Overload #4: Non-streaming
-
-  // --- Overload #5: Streaming
-
-  // --- Overload #6: Streaming
-
-  // --- Overload #7: Generic base
-
-  // --- 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 (Symbol.asyncIterator in value) {
-          const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new Stream(iterator, controller));
-          (async () => {
-            let usage = {};
-            try {
-              let finalContent = '';
-              let firstTokenTime;
-              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: sanitizeOpenAIResponse(finalContent, this.phClient),
-                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: (Date.now() - startTime) / 1000,
-                baseURL: this.baseURL,
-                modelParameters: getModelParams(body),
-                usage,
-                error
-              });
-              throw error;
-            }
-          })().catch(() => {
-            // Swallow: analytics must never crash the host process. The caller
-            // already receives this error via their own tee of the stream.
-          });
-          return stream2;
-        }
-        return value;
-      });
-      return preserveProviderPromise(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: sanitizeOpenAIResponse(result.text, this.phClient),
-            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: (Date.now() - startTime) / 1000,
-          baseURL: this.baseURL,
-          modelParameters: getModelParams(body),
-          usage: {},
-          error
-        });
-        throw error;
-      });
-      return preserveProviderPromise(parentPromise, wrappedPromise);
-    }
-  }
-}
+var PostHogOpenAI = class extends OpenAI {
+	constructor(config) {
+		const { posthog, ...openAIConfig } = config;
+		super(openAIConfig);
+		this.phClient = posthog;
+		this.chat = new WrappedChat(this, this.phClient);
+		this.responses = new WrappedResponses(this, this.phClient);
+		this.embeddings = new WrappedEmbeddings(this, this.phClient);
+		this.audio = new WrappedAudio(this, this.phClient);
+	}
+};
+var WrappedChat = class extends Chat {
+	constructor(parentClient, phClient) {
+		super(parentClient);
+		this.completions = new WrappedCompletions(parentClient, phClient);
+	}
+};
+var WrappedCompletions = class extends Completions {
+	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);
+		if (openAIParams.stream) return preserveProviderPromise(parentPromise, parentPromise.then((value) => {
+			if (Symbol.asyncIterator in value) {
+				const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new Stream(iterator, controller));
+				(async () => {
+					const accumulator = new OpenAIChatStreamAccumulator();
+					try {
+						for await (const chunk of stream1) accumulator.consume(chunk);
+						const accumulated = accumulator.result();
+						await captureAiGeneration(this.phClient, buildChatSuccessOptions({
+							client: this.phClient,
+							provider: "openai",
+							baseURL: this.baseURL,
+							params: openAIParams,
+							monitoring: posthogParams,
+							modelParametersSource: body
+						}, {
+							...accumulated,
+							latency: (Date.now() - startTime) / 1e3,
+							timeToFirstToken: accumulated.firstTokenTime === void 0 ? void 0 : (accumulated.firstTokenTime - startTime) / 1e3
+						}));
+					} catch (error) {
+						const accumulated = accumulator.result();
+						await captureAiGeneration(this.phClient, buildChatErrorOptions({
+							client: this.phClient,
+							provider: "openai",
+							baseURL: this.baseURL,
+							params: openAIParams,
+							monitoring: posthogParams,
+							modelParametersSource: body
+						}, error, {
+							completionId: accumulated.completionId,
+							systemFingerprint: accumulated.systemFingerprint,
+							usage: accumulated.usage,
+							latency: (Date.now() - startTime) / 1e3
+						}));
+						throw error;
+					}
+				})().catch(() => {});
+				return stream2;
+			}
+			return value;
+		}));
+		else return preserveProviderPromise(parentPromise, parentPromise.then(async (result) => {
+			if ("choices" in result) await captureAiGenerationAfterSuccess(this.phClient, buildChatSuccessOptions({
+				client: this.phClient,
+				provider: "openai",
+				baseURL: this.baseURL,
+				params: openAIParams,
+				monitoring: posthogParams,
+				modelParametersSource: body
+			}, {
+				output: formatResponseOpenAI(result),
+				model: result.model,
+				serviceTier: result.service_tier ?? void 0,
+				latency: (Date.now() - startTime) / 1e3,
+				usage: buildChatUsage(result.usage, result),
+				stopReason: result.choices[0]?.finish_reason ?? void 0,
+				completionId: result.id,
+				systemFingerprint: result.system_fingerprint,
+				requestId: extractRequestId(result)
+			}));
+			return result;
+		}, async (error) => {
+			await captureAiGeneration(this.phClient, buildChatErrorOptions({
+				client: this.phClient,
+				provider: "openai",
+				baseURL: this.baseURL,
+				params: openAIParams,
+				monitoring: posthogParams,
+				modelParametersSource: body
+			}, error, { latency: (Date.now() - startTime) / 1e3 }));
+			throw error;
+		}));
+	}
+};
+var WrappedResponses = class extends Responses {
+	constructor(client, phClient) {
+		super(client);
+		this.backgroundResponses = new BackgroundResponseTracker();
+		this.phClient = phClient;
+		this.baseURL = client.baseURL;
+	}
+	async captureBackgroundResponse(result, context) {
+		const { openAIParams, posthogParams } = context;
+		await captureAiGenerationAfterSuccess(this.phClient, buildBackgroundResponseOptions({
+			client: this.phClient,
+			provider: "openai",
+			baseURL: this.baseURL,
+			params: openAIParams,
+			monitoring: posthogParams,
+			modelParametersSource: openAIParams
+		}, result));
+	}
+	create(body, options) {
+		const { providerParams: openAIParams, posthogParams } = extractPosthogParams(body);
+		const startTime = Date.now();
+		const parentPromise = super.create(openAIParams, options);
+		if (openAIParams.stream) return preserveProviderPromise(parentPromise, parentPromise.then((value) => {
+			if (Symbol.asyncIterator in value) {
+				const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new Stream(iterator, controller));
+				(async () => {
+					const accumulator = new OpenAIResponsesStreamAccumulator();
+					try {
+						for await (const chunk of stream1) {
+							accumulator.consume(chunk);
+							if (openAIParams.background === true && "response" in chunk && chunk.response && !this.backgroundResponses.get(chunk.response.id)) this.backgroundResponses.set(chunk.response.id, {
+								openAIParams,
+								posthogParams
+							});
+						}
+						const accumulated = accumulator.result();
+						if (openAIParams.background === true) {
+							if (accumulated.terminalResponse) {
+								const context = this.backgroundResponses.take(accumulated.terminalResponse.id);
+								if (context) await this.captureBackgroundResponse(accumulated.terminalResponse, context).catch(() => void 0);
+							}
+							return;
+						}
+						const response = accumulated.terminalResponse ?? {
+							id: accumulated.completionId ?? "",
+							model: accumulated.model ?? openAIParams.model,
+							service_tier: accumulated.serviceTier
+						};
+						await captureAiGeneration(this.phClient, buildResponsesSuccessOptions({
+							client: this.phClient,
+							provider: "openai",
+							baseURL: this.baseURL,
+							params: openAIParams,
+							monitoring: posthogParams,
+							modelParametersSource: body
+						}, {
+							response,
+							output: accumulated.output,
+							latency: (Date.now() - startTime) / 1e3,
+							timeToFirstToken: accumulated.firstTokenTime === void 0 ? void 0 : (accumulated.firstTokenTime - startTime) / 1e3,
+							usage: accumulated.usage,
+							includeTools: true
+						}));
+					} catch (error) {
+						const accumulated = accumulator.result();
+						if (openAIParams.background === true && accumulated.completionId && this.backgroundResponses.get(accumulated.completionId)) throw error;
+						await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
+							client: this.phClient,
+							provider: "openai",
+							baseURL: this.baseURL,
+							params: openAIParams,
+							monitoring: posthogParams,
+							modelParametersSource: body
+						}, error, {
+							completionId: accumulated.completionId,
+							usage: accumulated.usage,
+							latency: (Date.now() - startTime) / 1e3
+						}));
+						throw error;
+					}
+				})().catch(() => {});
+				return stream2;
+			}
+			return value;
+		}));
+		else return preserveProviderPromise(parentPromise, parentPromise.then(async (result) => {
+			if ("output" in result) {
+				if (isPendingBackgroundResponse(openAIParams, result)) {
+					this.backgroundResponses.set(result.id, {
+						openAIParams,
+						posthogParams
+					});
+					return result;
+				}
+				await captureAiGenerationAfterSuccess(this.phClient, buildResponsesSuccessOptions({
+					client: this.phClient,
+					provider: "openai",
+					baseURL: this.baseURL,
+					params: openAIParams,
+					monitoring: posthogParams,
+					modelParametersSource: body
+				}, {
+					response: result,
+					output: formatResponseOpenAI({ output: result.output }),
+					latency: (Date.now() - startTime) / 1e3,
+					includeTools: true,
+					includeRequestId: true
+				}));
+			}
+			return result;
+		}, async (error) => {
+			await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
+				client: this.phClient,
+				provider: "openai",
+				baseURL: this.baseURL,
+				params: openAIParams,
+				monitoring: posthogParams,
+				modelParametersSource: body
+			}, error, { latency: (Date.now() - startTime) / 1e3 }));
+			throw error;
+		}));
+	}
+	retrieve(responseID, query = {}, options) {
+		const parentPromise = super.retrieve(responseID, query, options);
+		if (!this.backgroundResponses.get(responseID)) return parentPromise;
+		if (query.stream) return parentPromise._thenUnwrap((result) => {
+			if ("controller" in result) return wrapBackgroundResponseStream(result, responseID, this.backgroundResponses, (response, context) => this.captureBackgroundResponse(response, context));
+			return result;
+		});
+		return parentPromise._thenUnwrap(async (result) => {
+			if (!("output" in result) || !isTerminalResponse(result)) return result;
+			const context = this.backgroundResponses.take(responseID);
+			if (context) await this.captureBackgroundResponse(result, context).catch(() => void 0);
+			return result;
+		});
+	}
+	cancel(responseID, options) {
+		const parentPromise = super.cancel(responseID, options);
+		if (!this.backgroundResponses.get(responseID)) return parentPromise;
+		return parentPromise._thenUnwrap(async (result) => {
+			if (!isTerminalResponse(result)) return result;
+			const context = this.backgroundResponses.take(responseID);
+			if (context) await this.captureBackgroundResponse(result, context).catch(() => void 0);
+			return result;
+		});
+	}
+	parse(body, options) {
+		const { providerParams: openAIParams, posthogParams } = extractPosthogParams(body);
+		const startTime = Date.now();
+		const parentPromise = callWithOriginalCreate(this, super.create.bind(this), () => super.parse(openAIParams, options));
+		return preserveProviderPromise(parentPromise, parentPromise.then(async (result) => {
+			if (isPendingBackgroundResponse(openAIParams, result)) {
+				this.backgroundResponses.set(result.id, {
+					openAIParams,
+					posthogParams
+				});
+				return result;
+			}
+			await captureAiGeneration(this.phClient, buildResponsesSuccessOptions({
+				client: this.phClient,
+				provider: "openai",
+				baseURL: this.baseURL,
+				params: openAIParams,
+				monitoring: posthogParams,
+				modelParametersSource: body
+			}, {
+				response: result,
+				output: result.output,
+				latency: (Date.now() - startTime) / 1e3,
+				includeRequestId: true
+			}));
+			return result;
+		}, async (error) => {
+			await captureAiGeneration(this.phClient, buildResponsesErrorOptions({
+				client: this.phClient,
+				provider: "openai",
+				baseURL: this.baseURL,
+				params: openAIParams,
+				monitoring: posthogParams,
+				modelParametersSource: body
+			}, error, { latency: (Date.now() - startTime) / 1e3 }));
+			throw error;
+		}));
+	}
+};
+var WrappedEmbeddings = class 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);
+		return preserveProviderPromise(parentPromise, parentPromise.then(async (result) => {
+			await captureAiGeneration(this.phClient, buildEmbeddingSuccessOptions({
+				client: this.phClient,
+				provider: "openai",
+				baseURL: this.baseURL,
+				params: openAIParams,
+				monitoring: posthogParams,
+				modelParametersSource: body
+			}, result.usage, (Date.now() - startTime) / 1e3));
+			return result;
+		}, async (error) => {
+			await captureAiGeneration(this.phClient, buildEmbeddingErrorOptions({
+				client: this.phClient,
+				provider: "openai",
+				baseURL: this.baseURL,
+				params: openAIParams,
+				monitoring: posthogParams,
+				modelParametersSource: body
+			}, error, (Date.now() - startTime) / 1e3));
+			throw error;
+		}));
+	}
+};
+var WrappedAudio = class extends Audio {
+	constructor(parentClient, phClient) {
+		super(parentClient);
+		this.transcriptions = new WrappedTranscriptions(parentClient, phClient);
+	}
+};
+var WrappedTranscriptions = class extends Transcriptions {
+	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 = openAIParams.stream ? super.create(openAIParams, options) : super.create(openAIParams, options);
+		if (openAIParams.stream) return preserveProviderPromise(parentPromise, parentPromise.then((value) => {
+			if (Symbol.asyncIterator in value) {
+				const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new Stream(iterator, controller));
+				(async () => {
+					let usage = {};
+					try {
+						let finalContent = "";
+						let firstTokenTime;
+						const doneEvent = "transcript.text.done";
+						for await (const chunk of stream1) {
+							if (firstTokenTime === void 0 && 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) / 1e3;
+						const timeToFirstToken = firstTokenTime !== void 0 ? (firstTokenTime - startTime) / 1e3 : void 0;
+						const availableTools = extractAvailableToolCalls("openai", openAIParams);
+						await captureAiGeneration(this.phClient, {
+							...posthogParams,
+							model: openAIParams.model,
+							provider: "openai",
+							input: openAIParams.prompt,
+							output: sanitizeOpenAIResponse(finalContent, this.phClient),
+							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: (Date.now() - startTime) / 1e3,
+							baseURL: this.baseURL,
+							modelParameters: getModelParams(body),
+							usage,
+							error
+						});
+						throw error;
+					}
+				})().catch(() => {});
+				return stream2;
+			}
+			return value;
+		}));
+		else return preserveProviderPromise(parentPromise, parentPromise.then(async (result) => {
+			if (result && typeof result === "object" && "text" in result) {
+				const latency = (Date.now() - startTime) / 1e3;
+				await captureAiGenerationAfterSuccess(this.phClient, {
+					...posthogParams,
+					model: openAIParams.model,
+					provider: "openai",
+					input: openAIParams.prompt,
+					output: sanitizeOpenAIResponse(result.text, this.phClient),
+					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: (Date.now() - startTime) / 1e3,
+				baseURL: this.baseURL,
+				modelParameters: getModelParams(body),
+				usage: {},
+				error
+			});
+			throw error;
+		}));
+	}
+};
+//#endregion
+export { PostHogAzureOpenAI as AzureOpenAI, PostHogOpenAI as OpenAI, PostHogOpenAI, PostHogOpenAI as default, WrappedAudio, WrappedChat, WrappedCompletions, WrappedEmbeddings, WrappedResponses, WrappedTranscriptions };
 
-export { PostHogAzureOpenAI as AzureOpenAI, PostHogOpenAI as OpenAI, PostHogOpenAI, WrappedAudio, WrappedChat, WrappedCompletions, WrappedEmbeddings, WrappedResponses, WrappedTranscriptions, PostHogOpenAI as default };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map