@posthog/ai 8.10.0 → 8.10.2

package/dist/gemini/index.mjs

@@ -1,1176 +1,931 @@
-import { GoogleGenAI } from '@google/genai';
-import { v4 } from 'uuid';
-import { toJsonSafeValue, uuidv7 } from '@posthog/core';
-
-// Type guards for safer type checking
-
-const isString = value => {
-  return typeof value === 'string';
+import { GoogleGenAI } from "@google/genai";
+import { v4 } from "uuid";
+import { toJsonSafeValue, uuidv7 } from "@posthog/core";
+//#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();
 function redactBase64DataUrl(str, mediaType) {
-  return redactor.redact(str, mediaType);
+	return redactor.redact(str, mediaType);
 }
 const sanitize = (data, client) => isFullAiCaptureEnabled(client) ? data : redactor.redact(data);
 const sanitizeGemini = (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];
-    }
-  }
-  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 buildInlineDataBlock = (mimeType, data) => {
-  if (mimeType.startsWith('audio/')) {
-    return {
-      type: 'audio',
-      mime_type: mimeType,
-      data
-    };
-  }
-  if (mimeType.startsWith('image/')) {
-    return {
-      type: 'image',
-      inline_data: {
-        mime_type: mimeType,
-        data
-      }
-    };
-  }
-  return {
-    type: 'document',
-    inline_data: {
-      mime_type: mimeType,
-      data
-    }
-  };
+	if (mimeType.startsWith("audio/")) return {
+		type: "audio",
+		mime_type: mimeType,
+		data
+	};
+	if (mimeType.startsWith("image/")) return {
+		type: "image",
+		inline_data: {
+			mime_type: mimeType,
+			data
+		}
+	};
+	return {
+		type: "document",
+		inline_data: {
+			mime_type: mimeType,
+			data
+		}
+	};
 };
 const formatInlineDataBlock = (inlineData, client) => {
-  const mimeType = inlineData.mimeType || inlineData.mime_type || 'application/octet-stream';
-  let data = inlineData.data;
-  if (data instanceof Uint8Array) {
-    if (typeof Buffer !== 'undefined') {
-      data = Buffer.from(data).toString('base64');
-    } else {
-      let binary = '';
-      for (let i = 0; i < data.length; i++) {
-        binary += String.fromCharCode(data[i]);
-      }
-      data = btoa(binary);
-    }
-  }
-  data = isFullAiCaptureEnabled(client) ? data : redactBase64DataUrl(data, mimeType);
-  return buildInlineDataBlock(mimeType, String(data ?? ''));
+	const mimeType = inlineData.mimeType || inlineData.mime_type || "application/octet-stream";
+	let data = inlineData.data;
+	if (data instanceof Uint8Array) {
+		if (typeof Buffer !== "undefined") data = Buffer.from(data).toString("base64");
+		else {
+			let binary = "";
+			for (let i = 0; i < data.length; i++) binary += String.fromCharCode(data[i]);
+			data = btoa(binary);
+		}
+	}
+	data = isFullAiCaptureEnabled(client) ? data : redactBase64DataUrl(data, mimeType);
+	return buildInlineDataBlock(mimeType, String(data ?? ""));
 };
 const formatResponseGemini = (response, client) => {
-  const output = [];
-  if (response.candidates && Array.isArray(response.candidates)) {
-    for (const candidate of response.candidates) {
-      if (candidate.content && candidate.content.parts) {
-        const content = [];
-        for (const part of candidate.content.parts) {
-          if (part.text) {
-            content.push({
-              type: 'text',
-              text: part.text
-            });
-          } else if (part.functionCall) {
-            content.push({
-              type: 'function',
-              function: {
-                name: part.functionCall.name,
-                arguments: part.functionCall.args
-              }
-            });
-          } else if (part.inlineData) {
-            content.push(formatInlineDataBlock(part.inlineData, client));
-          }
-        }
-        if (content.length > 0) {
-          output.push({
-            role: 'assistant',
-            content
-          });
-        }
-      } else if (candidate.text) {
-        output.push({
-          role: 'assistant',
-          content: [{
-            type: 'text',
-            text: candidate.text
-          }]
-        });
-      }
-    }
-  } else if (response.text) {
-    output.push({
-      role: 'assistant',
-      content: [{
-        type: 'text',
-        text: response.text
-      }]
-    });
-  }
-  return output;
+	const output = [];
+	if (response.candidates && Array.isArray(response.candidates)) {
+		for (const candidate of response.candidates) if (candidate.content && candidate.content.parts) {
+			const content = [];
+			for (const part of candidate.content.parts) if (part.text) content.push({
+				type: "text",
+				text: part.text
+			});
+			else if (part.functionCall) content.push({
+				type: "function",
+				function: {
+					name: part.functionCall.name,
+					arguments: part.functionCall.args
+				}
+			});
+			else if (part.inlineData) content.push(formatInlineDataBlock(part.inlineData, client));
+			if (content.length > 0) output.push({
+				role: "assistant",
+				content
+			});
+		} else if (candidate.text) output.push({
+			role: "assistant",
+			content: [{
+				type: "text",
+				text: candidate.text
+			}]
+		});
+	} else if (response.text) output.push({
+		role: "assistant",
+		content: [{
+			type: "text",
+			text: response.text
+		}]
+	});
+	return output;
 };
 const withPrivacyMode = (client, privacyMode, input) => {
-  return client.privacy_mode || privacyMode ? null : input;
+	return client.privacy_mode || privacyMode ? null : input;
 };
-
 /**
- * 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.config && params.config.tools) {
-      return params.config.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()
+	};
 }
-
-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}.`);
 };
-
-/**
- * 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.
- */
-
+//#endregion
+//#region src/captureAiGeneration.ts
 /**
- * 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 = 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/gemini/usage.ts
 /** Map Gemini usage metadata to PostHog's provider-agnostic token fields. */
 function mapGeminiUsage(metadata, additionalUsage = {}) {
-  return {
-    inputTokens: metadata?.promptTokenCount ?? 0,
-    outputTokens: metadata?.candidatesTokenCount ?? 0,
-    reasoningTokens: metadata?.thoughtsTokenCount ?? 0,
-    cacheReadInputTokens: metadata?.cachedContentTokenCount ?? 0,
-    // Gemini counts cachedContentTokenCount inside promptTokenCount, so declare
-    // the accounting model rather than leaving ingestion to infer it. Under
-    // explicit context caching the two measurements can differ by a few percent.
-    ...(metadata?.cachedContentTokenCount ? {
-      cacheReportingExclusive: false
-    } : {}),
-    ...additionalUsage,
-    rawUsage: metadata
-  };
-}
-
-class PostHogGoogleGenAI {
-  constructor(config) {
-    const {
-      posthog,
-      ...geminiConfig
-    } = config;
-    this.phClient = posthog;
-    this.client = new GoogleGenAI(geminiConfig);
-    this.models = new WrappedModels(this.client, this.phClient);
-  }
+	return {
+		inputTokens: metadata?.promptTokenCount ?? 0,
+		outputTokens: metadata?.candidatesTokenCount ?? 0,
+		reasoningTokens: metadata?.thoughtsTokenCount ?? 0,
+		cacheReadInputTokens: metadata?.cachedContentTokenCount ?? 0,
+		...metadata?.cachedContentTokenCount ? { cacheReportingExclusive: false } : {},
+		...additionalUsage,
+		rawUsage: metadata
+	};
 }
-class WrappedModels {
-  constructor(client, phClient) {
-    this.client = client;
-    this.phClient = phClient;
-  }
-  async generateContent(params) {
-    const {
-      providerParams: geminiParams,
-      posthogParams
-    } = extractPosthogParams(params);
-    const startTime = Date.now();
-    try {
-      const response = await this.client.models.generateContent(geminiParams);
-      const latency = (Date.now() - startTime) / 1000;
-      const availableTools = extractAvailableToolCalls('gemini', geminiParams);
-      const metadata = response.usageMetadata;
-      const finishReason = response.candidates?.[0]?.finishReason;
-      await captureAiGeneration(this.phClient, {
-        ...posthogParams,
-        model: geminiParams.model,
-        provider: 'gemini',
-        input: this.formatInputForPostHog(geminiParams),
-        output: formatResponseGemini(response, this.phClient),
-        latency,
-        baseURL: 'https://generativelanguage.googleapis.com',
-        modelParameters: getModelParams(params),
-        httpStatus: 200,
-        usage: mapGeminiUsage(metadata, {
-          webSearchCount: calculateGoogleWebSearchCount(response)
-        }),
-        stopReason: finishReason ?? undefined,
-        tools: availableTools
-      });
-      return response;
-    } catch (error) {
-      const latency = (Date.now() - startTime) / 1000;
-      await captureAiGeneration(this.phClient, {
-        ...posthogParams,
-        model: geminiParams.model,
-        provider: 'gemini',
-        input: this.formatInputForPostHog(geminiParams),
-        output: [],
-        latency,
-        baseURL: 'https://generativelanguage.googleapis.com',
-        modelParameters: getModelParams(params),
-        usage: {},
-        error
-      });
-      throw error;
-    }
-  }
-  async *generateContentStream(params) {
-    const {
-      providerParams: geminiParams,
-      posthogParams
-    } = extractPosthogParams(params);
-    const startTime = Date.now();
-    const accumulatedContent = [];
-    let firstTokenTime;
-    let stopReason;
-    let usage = {
-      webSearchCount: 0,
-      rawUsage: undefined
-    };
-    let errored = false;
-    try {
-      const stream = await this.client.models.generateContentStream(geminiParams);
-      for await (const chunk of stream) {
-        // Track first token time when we get text content
-        if (firstTokenTime === undefined && chunk.text) {
-          firstTokenTime = Date.now();
-        }
-        const chunkWebSearchCount = calculateGoogleWebSearchCount(chunk);
-        if (chunkWebSearchCount > 0 && chunkWebSearchCount > (usage.webSearchCount ?? 0)) {
-          usage.webSearchCount = chunkWebSearchCount;
-        }
-
-        // Handle text content
-        if (chunk.text) {
-          // Find if we already have a text item to append to
-          let lastTextItem;
-          for (let i = accumulatedContent.length - 1; i >= 0; i--) {
-            if (accumulatedContent[i].type === 'text') {
-              lastTextItem = accumulatedContent[i];
-              break;
-            }
-          }
-          if (lastTextItem && lastTextItem.type === 'text') {
-            lastTextItem.text += chunk.text;
-          } else {
-            accumulatedContent.push({
-              type: 'text',
-              text: chunk.text
-            });
-          }
-        }
-
-        // Track finish reason from candidates
-        if (chunk.candidates?.[0]?.finishReason) {
-          stopReason = chunk.candidates[0].finishReason;
-        }
-
-        // Handle function calls from candidates
-        if (chunk.candidates && Array.isArray(chunk.candidates)) {
-          for (const candidate of chunk.candidates) {
-            if (candidate.content && candidate.content.parts) {
-              for (const part of candidate.content.parts) {
-                // Type-safe check for functionCall
-                if ('functionCall' in part) {
-                  if (firstTokenTime === undefined) {
-                    firstTokenTime = Date.now();
-                  }
-                  const funcCall = part.functionCall;
-                  if (funcCall?.name) {
-                    accumulatedContent.push({
-                      type: 'function',
-                      function: {
-                        name: funcCall.name,
-                        arguments: funcCall.args || {}
-                      }
-                    });
-                  }
-                }
-              }
-            }
-          }
-        }
-
-        // Update usage metadata - handle both old and new field names
-        if (chunk.usageMetadata) {
-          usage = mapGeminiUsage(chunk.usageMetadata, {
-            webSearchCount: usage.webSearchCount
-          });
-        }
-        yield chunk;
-      }
-    } catch (error) {
-      errored = true;
-      const latency = (Date.now() - startTime) / 1000;
-      await captureAiGeneration(this.phClient, {
-        ...posthogParams,
-        model: geminiParams.model,
-        provider: 'gemini',
-        input: this.formatInputForPostHog(geminiParams),
-        output: [],
-        latency,
-        baseURL: 'https://generativelanguage.googleapis.com',
-        modelParameters: getModelParams(params),
-        usage,
-        error
-      });
-      throw error;
-    } finally {
-      // A consumer that stops iterating resumes the pending yield as a return,
-      // skipping both the loop tail and the catch. Only a finally runs then, so
-      // the success capture lives here to cover completion and cancellation.
-      if (!errored) {
-        const latency = (Date.now() - startTime) / 1000;
-        const timeToFirstToken = firstTokenTime !== undefined ? (firstTokenTime - startTime) / 1000 : undefined;
-        const availableTools = extractAvailableToolCalls('gemini', geminiParams);
-
-        // Format output similar to formatResponseGemini
-        const output = accumulatedContent.length > 0 ? [{
-          role: 'assistant',
-          content: accumulatedContent
-        }] : [];
-        await captureAiGeneration(this.phClient, {
-          ...posthogParams,
-          model: geminiParams.model,
-          provider: 'gemini',
-          input: this.formatInputForPostHog(geminiParams),
-          output,
-          latency,
-          timeToFirstToken,
-          baseURL: 'https://generativelanguage.googleapis.com',
-          modelParameters: getModelParams(params),
-          httpStatus: 200,
-          usage: {
-            ...usage,
-            webSearchCount: usage.webSearchCount,
-            rawUsage: usage.rawUsage
-          },
-          stopReason,
-          tools: availableTools
-        });
-      }
-    }
-  }
-  async embedContent(params) {
-    const {
-      providerParams: geminiParams,
-      posthogParams
-    } = extractPosthogParams(params);
-    const startTime = Date.now();
-    try {
-      const response = await this.client.models.embedContent(geminiParams);
-      const latency = (Date.now() - startTime) / 1000;
-      const inputTokens = extractEmbeddingTokenCount(response);
-      await captureAiGeneration(this.phClient, {
-        ...posthogParams,
-        eventType: AIEvent.Embedding,
-        model: geminiParams.model,
-        provider: 'gemini',
-        input: withPrivacyMode(this.phClient, posthogParams.privacyMode ?? false, geminiParams.contents),
-        output: null,
-        latency,
-        baseURL: 'https://generativelanguage.googleapis.com',
-        modelParameters: getModelParams(params),
-        httpStatus: 200,
-        usage: {
-          inputTokens
-        }
-      });
-      return response;
-    } catch (error) {
-      const latency = (Date.now() - startTime) / 1000;
-      await captureAiGeneration(this.phClient, {
-        ...posthogParams,
-        eventType: AIEvent.Embedding,
-        model: geminiParams.model,
-        provider: 'gemini',
-        input: withPrivacyMode(this.phClient, posthogParams.privacyMode ?? false, geminiParams.contents),
-        output: null,
-        latency,
-        baseURL: 'https://generativelanguage.googleapis.com',
-        modelParameters: getModelParams(params),
-        usage: {},
-        error
-      });
-      throw error;
-    }
-  }
-  formatPartsAsContentBlocks(parts) {
-    const blocks = [];
-    for (const part of parts) {
-      // Handle dict/object with text field
-      if (part && typeof part === 'object' && 'text' in part && part.text) {
-        blocks.push({
-          type: 'text',
-          text: String(part.text)
-        });
-      }
-      // Handle string parts
-      else if (typeof part === 'string') {
-        blocks.push({
-          type: 'text',
-          text: part
-        });
-      }
-      // Handle inlineData (images, audio, PDFs)
-      else if (part && typeof part === 'object' && 'inlineData' in part) {
-        const inlineData = part.inlineData;
-        const mimeType = inlineData.mimeType || inlineData.mime_type || 'application/octet-stream';
-        blocks.push(buildInlineDataBlock(mimeType, inlineData.data));
-      }
-    }
-    return blocks;
-  }
-  formatInput(contents) {
-    if (typeof contents === 'string') {
-      return [{
-        role: 'user',
-        content: contents
-      }];
-    }
-    if (Array.isArray(contents)) {
-      return contents.map(item => {
-        if (typeof item === 'string') {
-          return {
-            role: 'user',
-            content: item
-          };
-        }
-        if (item && typeof item === 'object') {
-          const obj = item;
-          if ('text' in obj && obj.text) {
-            return {
-              role: isString(obj.role) ? obj.role : 'user',
-              content: obj.text
-            };
-          }
-          if ('content' in obj && obj.content) {
-            // If content is a list, format it as content blocks
-            if (Array.isArray(obj.content)) {
-              const contentBlocks = this.formatPartsAsContentBlocks(obj.content);
-              return {
-                role: isString(obj.role) ? obj.role : 'user',
-                content: contentBlocks
-              };
-            }
-            return {
-              role: isString(obj.role) ? obj.role : 'user',
-              content: obj.content
-            };
-          }
-          if ('parts' in obj && Array.isArray(obj.parts)) {
-            const contentBlocks = this.formatPartsAsContentBlocks(obj.parts);
-            return {
-              role: isString(obj.role) ? obj.role : 'user',
-              content: contentBlocks
-            };
-          }
-        }
-        return {
-          role: 'user',
-          content: toContentString(item)
-        };
-      });
-    }
-    if (contents && typeof contents === 'object') {
-      const obj = contents;
-      if ('text' in obj && obj.text) {
-        return [{
-          role: 'user',
-          content: obj.text
-        }];
-      }
-      if ('content' in obj && obj.content) {
-        return [{
-          role: 'user',
-          content: obj.content
-        }];
-      }
-    }
-    return [{
-      role: 'user',
-      content: toContentString(contents)
-    }];
-  }
-  extractSystemInstruction(params) {
-    if (!params || typeof params !== 'object' || !params.config) {
-      return null;
-    }
-    const config = params.config;
-    if (!('systemInstruction' in config)) {
-      return null;
-    }
-    const systemInstruction = config.systemInstruction;
-    if (typeof systemInstruction === 'string') {
-      return systemInstruction;
-    }
-    if (systemInstruction && typeof systemInstruction === 'object' && 'text' in systemInstruction) {
-      return systemInstruction.text;
-    }
-    if (systemInstruction && typeof systemInstruction === 'object' && 'parts' in systemInstruction && Array.isArray(systemInstruction.parts)) {
-      for (const part of systemInstruction.parts) {
-        if (part && typeof part === 'object' && 'text' in part && typeof part.text === 'string') {
-          return part.text;
-        }
-      }
-    }
-    if (Array.isArray(systemInstruction)) {
-      for (const part of systemInstruction) {
-        if (typeof part === 'string') {
-          return part;
-        }
-        if (part && typeof part === 'object' && 'text' in part && typeof part.text === 'string') {
-          return part.text;
-        }
-      }
-    }
-    return null;
-  }
-  formatInputForPostHog(params) {
-    const sanitized = sanitizeGemini(params.contents, this.phClient);
-    const messages = this.formatInput(sanitized);
-    const systemInstruction = this.extractSystemInstruction(params);
-    if (systemInstruction) {
-      const hasSystemMessage = messages.some(msg => msg.role === 'system');
-      if (!hasSystemMessage) {
-        return [{
-          role: 'system',
-          content: systemInstruction
-        }, ...messages];
-      }
-    }
-    return messages;
-  }
-}
-
+//#endregion
+//#region src/gemini/index.ts
+var PostHogGoogleGenAI = class {
+	constructor(config) {
+		const { posthog, ...geminiConfig } = config;
+		this.phClient = posthog;
+		this.client = new GoogleGenAI(geminiConfig);
+		this.models = new WrappedModels(this.client, this.phClient);
+	}
+};
+var WrappedModels = class {
+	constructor(client, phClient) {
+		this.client = client;
+		this.phClient = phClient;
+	}
+	async generateContent(params) {
+		const { providerParams: geminiParams, posthogParams } = extractPosthogParams(params);
+		const startTime = Date.now();
+		try {
+			const response = await this.client.models.generateContent(geminiParams);
+			const latency = (Date.now() - startTime) / 1e3;
+			const availableTools = extractAvailableToolCalls("gemini", geminiParams);
+			const metadata = response.usageMetadata;
+			const finishReason = response.candidates?.[0]?.finishReason;
+			await captureAiGeneration(this.phClient, {
+				...posthogParams,
+				model: geminiParams.model,
+				provider: "gemini",
+				input: this.formatInputForPostHog(geminiParams),
+				output: formatResponseGemini(response, this.phClient),
+				latency,
+				baseURL: "https://generativelanguage.googleapis.com",
+				modelParameters: getModelParams(params),
+				httpStatus: 200,
+				usage: mapGeminiUsage(metadata, { webSearchCount: calculateGoogleWebSearchCount(response) }),
+				stopReason: finishReason ?? void 0,
+				tools: availableTools
+			});
+			return response;
+		} catch (error) {
+			const latency = (Date.now() - startTime) / 1e3;
+			await captureAiGeneration(this.phClient, {
+				...posthogParams,
+				model: geminiParams.model,
+				provider: "gemini",
+				input: this.formatInputForPostHog(geminiParams),
+				output: [],
+				latency,
+				baseURL: "https://generativelanguage.googleapis.com",
+				modelParameters: getModelParams(params),
+				usage: {},
+				error
+			});
+			throw error;
+		}
+	}
+	async *generateContentStream(params) {
+		const { providerParams: geminiParams, posthogParams } = extractPosthogParams(params);
+		const startTime = Date.now();
+		const accumulatedContent = [];
+		let firstTokenTime;
+		let stopReason;
+		let usage = {
+			webSearchCount: 0,
+			rawUsage: void 0
+		};
+		let errored = false;
+		try {
+			const stream = await this.client.models.generateContentStream(geminiParams);
+			for await (const chunk of stream) {
+				if (firstTokenTime === void 0 && chunk.text) firstTokenTime = Date.now();
+				const chunkWebSearchCount = calculateGoogleWebSearchCount(chunk);
+				if (chunkWebSearchCount > 0 && chunkWebSearchCount > (usage.webSearchCount ?? 0)) usage.webSearchCount = chunkWebSearchCount;
+				if (chunk.text) {
+					let lastTextItem;
+					for (let i = accumulatedContent.length - 1; i >= 0; i--) if (accumulatedContent[i].type === "text") {
+						lastTextItem = accumulatedContent[i];
+						break;
+					}
+					if (lastTextItem && lastTextItem.type === "text") lastTextItem.text += chunk.text;
+					else accumulatedContent.push({
+						type: "text",
+						text: chunk.text
+					});
+				}
+				if (chunk.candidates?.[0]?.finishReason) stopReason = chunk.candidates[0].finishReason;
+				if (chunk.candidates && Array.isArray(chunk.candidates)) {
+					for (const candidate of chunk.candidates) if (candidate.content && candidate.content.parts) {
+						for (const part of candidate.content.parts) if ("functionCall" in part) {
+							if (firstTokenTime === void 0) firstTokenTime = Date.now();
+							const funcCall = part.functionCall;
+							if (funcCall?.name) accumulatedContent.push({
+								type: "function",
+								function: {
+									name: funcCall.name,
+									arguments: funcCall.args || {}
+								}
+							});
+						}
+					}
+				}
+				if (chunk.usageMetadata) usage = mapGeminiUsage(chunk.usageMetadata, { webSearchCount: usage.webSearchCount });
+				yield chunk;
+			}
+		} catch (error) {
+			errored = true;
+			const latency = (Date.now() - startTime) / 1e3;
+			await captureAiGeneration(this.phClient, {
+				...posthogParams,
+				model: geminiParams.model,
+				provider: "gemini",
+				input: this.formatInputForPostHog(geminiParams),
+				output: [],
+				latency,
+				baseURL: "https://generativelanguage.googleapis.com",
+				modelParameters: getModelParams(params),
+				usage,
+				error
+			});
+			throw error;
+		} finally {
+			if (!errored) {
+				const latency = (Date.now() - startTime) / 1e3;
+				const timeToFirstToken = firstTokenTime !== void 0 ? (firstTokenTime - startTime) / 1e3 : void 0;
+				const availableTools = extractAvailableToolCalls("gemini", geminiParams);
+				const output = accumulatedContent.length > 0 ? [{
+					role: "assistant",
+					content: accumulatedContent
+				}] : [];
+				await captureAiGeneration(this.phClient, {
+					...posthogParams,
+					model: geminiParams.model,
+					provider: "gemini",
+					input: this.formatInputForPostHog(geminiParams),
+					output,
+					latency,
+					timeToFirstToken,
+					baseURL: "https://generativelanguage.googleapis.com",
+					modelParameters: getModelParams(params),
+					httpStatus: 200,
+					usage: {
+						...usage,
+						webSearchCount: usage.webSearchCount,
+						rawUsage: usage.rawUsage
+					},
+					stopReason,
+					tools: availableTools
+				});
+			}
+		}
+	}
+	async embedContent(params) {
+		const { providerParams: geminiParams, posthogParams } = extractPosthogParams(params);
+		const startTime = Date.now();
+		try {
+			const response = await this.client.models.embedContent(geminiParams);
+			const latency = (Date.now() - startTime) / 1e3;
+			const inputTokens = extractEmbeddingTokenCount(response);
+			await captureAiGeneration(this.phClient, {
+				...posthogParams,
+				eventType: "$ai_embedding",
+				model: geminiParams.model,
+				provider: "gemini",
+				input: withPrivacyMode(this.phClient, posthogParams.privacyMode ?? false, geminiParams.contents),
+				output: null,
+				latency,
+				baseURL: "https://generativelanguage.googleapis.com",
+				modelParameters: getModelParams(params),
+				httpStatus: 200,
+				usage: { inputTokens }
+			});
+			return response;
+		} catch (error) {
+			const latency = (Date.now() - startTime) / 1e3;
+			await captureAiGeneration(this.phClient, {
+				...posthogParams,
+				eventType: "$ai_embedding",
+				model: geminiParams.model,
+				provider: "gemini",
+				input: withPrivacyMode(this.phClient, posthogParams.privacyMode ?? false, geminiParams.contents),
+				output: null,
+				latency,
+				baseURL: "https://generativelanguage.googleapis.com",
+				modelParameters: getModelParams(params),
+				usage: {},
+				error
+			});
+			throw error;
+		}
+	}
+	formatPartsAsContentBlocks(parts) {
+		const blocks = [];
+		for (const part of parts) if (part && typeof part === "object" && "text" in part && part.text) blocks.push({
+			type: "text",
+			text: String(part.text)
+		});
+		else if (typeof part === "string") blocks.push({
+			type: "text",
+			text: part
+		});
+		else if (part && typeof part === "object" && "inlineData" in part) {
+			const inlineData = part.inlineData;
+			const mimeType = inlineData.mimeType || inlineData.mime_type || "application/octet-stream";
+			blocks.push(buildInlineDataBlock(mimeType, inlineData.data));
+		}
+		return blocks;
+	}
+	formatInput(contents) {
+		if (typeof contents === "string") return [{
+			role: "user",
+			content: contents
+		}];
+		if (Array.isArray(contents)) return contents.map((item) => {
+			if (typeof item === "string") return {
+				role: "user",
+				content: item
+			};
+			if (item && typeof item === "object") {
+				const obj = item;
+				if ("text" in obj && obj.text) return {
+					role: isString(obj.role) ? obj.role : "user",
+					content: obj.text
+				};
+				if ("content" in obj && obj.content) {
+					if (Array.isArray(obj.content)) {
+						const contentBlocks = this.formatPartsAsContentBlocks(obj.content);
+						return {
+							role: isString(obj.role) ? obj.role : "user",
+							content: contentBlocks
+						};
+					}
+					return {
+						role: isString(obj.role) ? obj.role : "user",
+						content: obj.content
+					};
+				}
+				if ("parts" in obj && Array.isArray(obj.parts)) {
+					const contentBlocks = this.formatPartsAsContentBlocks(obj.parts);
+					return {
+						role: isString(obj.role) ? obj.role : "user",
+						content: contentBlocks
+					};
+				}
+			}
+			return {
+				role: "user",
+				content: toContentString(item)
+			};
+		});
+		if (contents && typeof contents === "object") {
+			const obj = contents;
+			if ("text" in obj && obj.text) return [{
+				role: "user",
+				content: obj.text
+			}];
+			if ("content" in obj && obj.content) return [{
+				role: "user",
+				content: obj.content
+			}];
+		}
+		return [{
+			role: "user",
+			content: toContentString(contents)
+		}];
+	}
+	extractSystemInstruction(params) {
+		if (!params || typeof params !== "object" || !params.config) return null;
+		const config = params.config;
+		if (!("systemInstruction" in config)) return null;
+		const systemInstruction = config.systemInstruction;
+		if (typeof systemInstruction === "string") return systemInstruction;
+		if (systemInstruction && typeof systemInstruction === "object" && "text" in systemInstruction) return systemInstruction.text;
+		if (systemInstruction && typeof systemInstruction === "object" && "parts" in systemInstruction && Array.isArray(systemInstruction.parts)) {
+			for (const part of systemInstruction.parts) if (part && typeof part === "object" && "text" in part && typeof part.text === "string") return part.text;
+		}
+		if (Array.isArray(systemInstruction)) for (const part of systemInstruction) {
+			if (typeof part === "string") return part;
+			if (part && typeof part === "object" && "text" in part && typeof part.text === "string") return part.text;
+		}
+		return null;
+	}
+	formatInputForPostHog(params) {
+		const sanitized = sanitizeGemini(params.contents, this.phClient);
+		const messages = this.formatInput(sanitized);
+		const systemInstruction = this.extractSystemInstruction(params);
+		if (systemInstruction) {
+			if (!messages.some((msg) => msg.role === "system")) return [{
+				role: "system",
+				content: systemInstruction
+			}, ...messages];
+		}
+		return messages;
+	}
+};
 /**
- * Extract total token count from a Gemini embed_content response.
- * Token counts are only available per-embedding via Vertex AI's statistics.tokenCount.
- * Returns 0 if no token counts are available.
- */
+* Extract total token count from a Gemini embed_content response.
+* Token counts are only available per-embedding via Vertex AI's statistics.tokenCount.
+* Returns 0 if no token counts are available.
+*/
 function extractEmbeddingTokenCount(response) {
-  let total = 0;
-  if (response.embeddings) {
-    for (const embedding of response.embeddings) {
-      if (embedding.statistics?.tokenCount != null) {
-        total += embedding.statistics.tokenCount;
-      }
-    }
-  }
-  return total;
+	let total = 0;
+	if (response.embeddings) {
+		for (const embedding of response.embeddings) if (embedding.statistics?.tokenCount != null) total += embedding.statistics.tokenCount;
+	}
+	return total;
 }
-
 /**
- * Detect if Google Search grounding was used in the response.
- * Gemini bills per request that uses grounding, not per individual query.
- * Returns 1 if grounding was used, 0 otherwise.
- */
+* Detect if Google Search grounding was used in the response.
+* Gemini bills per request that uses grounding, not per individual query.
+* Returns 1 if grounding was used, 0 otherwise.
+*/
 function calculateGoogleWebSearchCount(response) {
-  if (!response || typeof response !== 'object' || !('candidates' in response)) {
-    return 0;
-  }
-  const candidates = response.candidates;
-  if (!Array.isArray(candidates)) {
-    return 0;
-  }
-  const hasGrounding = candidates.some(candidate => {
-    if (!candidate || typeof candidate !== 'object') {
-      return false;
-    }
-
-    // Check for grounding metadata
-    if ('groundingMetadata' in candidate && candidate.groundingMetadata) {
-      const metadata = candidate.groundingMetadata;
-      if (typeof metadata === 'object') {
-        // Check if web_search_queries exists and is non-empty
-        if ('webSearchQueries' in metadata && Array.isArray(metadata.webSearchQueries) && metadata.webSearchQueries.length > 0) {
-          return true;
-        }
-
-        // Check if grounding_chunks exists and is non-empty
-        if ('groundingChunks' in metadata && Array.isArray(metadata.groundingChunks) && metadata.groundingChunks.length > 0) {
-          return true;
-        }
-      }
-    }
-
-    // Check for google search in function calls
-    if ('content' in candidate && candidate.content && typeof candidate.content === 'object') {
-      const content = candidate.content;
-      if ('parts' in content && Array.isArray(content.parts)) {
-        return content.parts.some(part => {
-          if (!part || typeof part !== 'object' || !('functionCall' in part)) {
-            return false;
-          }
-          const functionCall = part.functionCall;
-          if (functionCall && typeof functionCall === 'object' && 'name' in functionCall && typeof functionCall.name === 'string') {
-            return functionCall.name.includes('google_search') || functionCall.name.includes('grounding');
-          }
-          return false;
-        });
-      }
-    }
-    return false;
-  });
-  return hasGrounding ? 1 : 0;
+	if (!response || typeof response !== "object" || !("candidates" in response)) return 0;
+	const candidates = response.candidates;
+	if (!Array.isArray(candidates)) return 0;
+	return candidates.some((candidate) => {
+		if (!candidate || typeof candidate !== "object") return false;
+		if ("groundingMetadata" in candidate && candidate.groundingMetadata) {
+			const metadata = candidate.groundingMetadata;
+			if (typeof metadata === "object") {
+				if ("webSearchQueries" in metadata && Array.isArray(metadata.webSearchQueries) && metadata.webSearchQueries.length > 0) return true;
+				if ("groundingChunks" in metadata && Array.isArray(metadata.groundingChunks) && metadata.groundingChunks.length > 0) return true;
+			}
+		}
+		if ("content" in candidate && candidate.content && typeof candidate.content === "object") {
+			const content = candidate.content;
+			if ("parts" in content && Array.isArray(content.parts)) return content.parts.some((part) => {
+				if (!part || typeof part !== "object" || !("functionCall" in part)) return false;
+				const functionCall = part.functionCall;
+				if (functionCall && typeof functionCall === "object" && "name" in functionCall && typeof functionCall.name === "string") return functionCall.name.includes("google_search") || functionCall.name.includes("grounding");
+				return false;
+			});
+		}
+		return false;
+	}) ? 1 : 0;
 }
+//#endregion
+export { PostHogGoogleGenAI as Gemini, PostHogGoogleGenAI as GoogleGenAI, PostHogGoogleGenAI, PostHogGoogleGenAI as default, WrappedModels };
 
-export { PostHogGoogleGenAI as Gemini, PostHogGoogleGenAI as GoogleGenAI, PostHogGoogleGenAI, WrappedModels, PostHogGoogleGenAI as default };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map