@posthog/ai 6.5.1 → 7.0.0

package/dist/langchain/index.cjs

@@ -22,7 +22,7 @@ function _interopNamespaceDefault(e) {
 
 var uuid__namespace = /*#__PURE__*/_interopNamespaceDefault(uuid);
 
-var version = "6.5.1";
+var version = "7.0.0";
 
 // Type guards for safer type checking
 
@@ -75,6 +75,15 @@ const withPrivacyMode = (client, privacyMode, input) => {
   return client.privacy_mode || privacyMode ? null : input;
 };
 
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -227,370 +236,304 @@ function requireCamelcase () {
 
 requireCamelcase();
 
+//#region src/load/map_keys.ts
 function keyToJson(key, map) {
-    return map?.[key] || snakeCase(key);
+	return map?.[key] || snakeCase(key);
 }
 function mapKeys(fields, mapper, map) {
-    const mapped = {};
-    for (const key in fields) {
-        if (Object.hasOwn(fields, key)) {
-            mapped[mapper(key, map)] = fields[key];
-        }
-    }
-    return mapped;
+	const mapped = {};
+	for (const key in fields) if (Object.hasOwn(fields, key)) mapped[mapper(key, map)] = fields[key];
+	return mapped;
 }
 
+//#region src/load/serializable.ts
+var serializable_exports = {};
+__export(serializable_exports, {
+	Serializable: () => Serializable,
+	get_lc_unique_name: () => get_lc_unique_name
+});
 function shallowCopy(obj) {
-    return Array.isArray(obj) ? [...obj] : { ...obj };
+	return Array.isArray(obj) ? [...obj] : { ...obj };
 }
 function replaceSecrets(root, secretsMap) {
-    const result = shallowCopy(root);
-    for (const [path, secretId] of Object.entries(secretsMap)) {
-        const [last, ...partsReverse] = path.split(".").reverse();
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let current = result;
-        for (const part of partsReverse.reverse()) {
-            if (current[part] === undefined) {
-                break;
-            }
-            current[part] = shallowCopy(current[part]);
-            current = current[part];
-        }
-        if (current[last] !== undefined) {
-            current[last] = {
-                lc: 1,
-                type: "secret",
-                id: [secretId],
-            };
-        }
-    }
-    return result;
+	const result = shallowCopy(root);
+	for (const [path, secretId] of Object.entries(secretsMap)) {
+		const [last, ...partsReverse] = path.split(".").reverse();
+		let current = result;
+		for (const part of partsReverse.reverse()) {
+			if (current[part] === void 0) break;
+			current[part] = shallowCopy(current[part]);
+			current = current[part];
+		}
+		if (current[last] !== void 0) current[last] = {
+			lc: 1,
+			type: "secret",
+			id: [secretId]
+		};
+	}
+	return result;
 }
 /**
- * Get a unique name for the module, rather than parent class implementations.
- * Should not be subclassed, subclass lc_name above instead.
- */
-function get_lc_unique_name(
-// eslint-disable-next-line @typescript-eslint/no-use-before-define
-serializableClass) {
-    // "super" here would refer to the parent class of Serializable,
-    // when we want the parent class of the module actually calling this method.
-    const parentClass = Object.getPrototypeOf(serializableClass);
-    const lcNameIsSubclassed = typeof serializableClass.lc_name === "function" &&
-        (typeof parentClass.lc_name !== "function" ||
-            serializableClass.lc_name() !== parentClass.lc_name());
-    if (lcNameIsSubclassed) {
-        return serializableClass.lc_name();
-    }
-    else {
-        return serializableClass.name;
-    }
-}
-class Serializable {
-    /**
-     * The name of the serializable. Override to provide an alias or
-     * to preserve the serialized module name in minified environments.
-     *
-     * Implemented as a static method to support loading logic.
-     */
-    static lc_name() {
-        return this.name;
-    }
-    /**
-     * The final serialized identifier for the module.
-     */
-    get lc_id() {
-        return [
-            ...this.lc_namespace,
-            get_lc_unique_name(this.constructor),
-        ];
-    }
-    /**
-     * A map of secrets, which will be omitted from serialization.
-     * Keys are paths to the secret in constructor args, e.g. "foo.bar.baz".
-     * Values are the secret ids, which will be used when deserializing.
-     */
-    get lc_secrets() {
-        return undefined;
-    }
-    /**
-     * A map of additional attributes to merge with constructor args.
-     * Keys are the attribute names, e.g. "foo".
-     * Values are the attribute values, which will be serialized.
-     * These attributes need to be accepted by the constructor as arguments.
-     */
-    get lc_attributes() {
-        return undefined;
-    }
-    /**
-     * A map of aliases for constructor args.
-     * Keys are the attribute names, e.g. "foo".
-     * Values are the alias that will replace the key in serialization.
-     * This is used to eg. make argument names match Python.
-     */
-    get lc_aliases() {
-        return undefined;
-    }
-    /**
-     * A manual list of keys that should be serialized.
-     * If not overridden, all fields passed into the constructor will be serialized.
-     */
-    get lc_serializable_keys() {
-        return undefined;
-    }
-    constructor(kwargs, ..._args) {
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "lc_kwargs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        if (this.lc_serializable_keys !== undefined) {
-            this.lc_kwargs = Object.fromEntries(Object.entries(kwargs || {}).filter(([key]) => this.lc_serializable_keys?.includes(key)));
-        }
-        else {
-            this.lc_kwargs = kwargs ?? {};
-        }
-    }
-    toJSON() {
-        if (!this.lc_serializable) {
-            return this.toJSONNotImplemented();
-        }
-        if (
-        // eslint-disable-next-line no-instanceof/no-instanceof
-        this.lc_kwargs instanceof Serializable ||
-            typeof this.lc_kwargs !== "object" ||
-            Array.isArray(this.lc_kwargs)) {
-            // We do not support serialization of classes with arg not a POJO
-            // I'm aware the check above isn't as strict as it could be
-            return this.toJSONNotImplemented();
-        }
-        const aliases = {};
-        const secrets = {};
-        const kwargs = Object.keys(this.lc_kwargs).reduce((acc, key) => {
-            acc[key] = key in this ? this[key] : this.lc_kwargs[key];
-            return acc;
-        }, {});
-        // get secrets, attributes and aliases from all superclasses
-        for (
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        let current = Object.getPrototypeOf(this); current; current = Object.getPrototypeOf(current)) {
-            Object.assign(aliases, Reflect.get(current, "lc_aliases", this));
-            Object.assign(secrets, Reflect.get(current, "lc_secrets", this));
-            Object.assign(kwargs, Reflect.get(current, "lc_attributes", this));
-        }
-        // include all secrets used, even if not in kwargs,
-        // will be replaced with sentinel value in replaceSecrets
-        Object.keys(secrets).forEach((keyPath) => {
-            // eslint-disable-next-line @typescript-eslint/no-this-alias, @typescript-eslint/no-explicit-any
-            let read = this;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            let write = kwargs;
-            const [last, ...partsReverse] = keyPath.split(".").reverse();
-            for (const key of partsReverse.reverse()) {
-                if (!(key in read) || read[key] === undefined)
-                    return;
-                if (!(key in write) || write[key] === undefined) {
-                    if (typeof read[key] === "object" && read[key] != null) {
-                        write[key] = {};
-                    }
-                    else if (Array.isArray(read[key])) {
-                        write[key] = [];
-                    }
-                }
-                read = read[key];
-                write = write[key];
-            }
-            if (last in read && read[last] !== undefined) {
-                write[last] = write[last] || read[last];
-            }
-        });
-        return {
-            lc: 1,
-            type: "constructor",
-            id: this.lc_id,
-            kwargs: mapKeys(Object.keys(secrets).length ? replaceSecrets(kwargs, secrets) : kwargs, keyToJson, aliases),
-        };
-    }
-    toJSONNotImplemented() {
-        return {
-            lc: 1,
-            type: "not_implemented",
-            id: this.lc_id,
-        };
-    }
+* Get a unique name for the module, rather than parent class implementations.
+* Should not be subclassed, subclass lc_name above instead.
+*/
+function get_lc_unique_name(serializableClass) {
+	const parentClass = Object.getPrototypeOf(serializableClass);
+	const lcNameIsSubclassed = typeof serializableClass.lc_name === "function" && (typeof parentClass.lc_name !== "function" || serializableClass.lc_name() !== parentClass.lc_name());
+	if (lcNameIsSubclassed) return serializableClass.lc_name();
+	else return serializableClass.name;
 }
+var Serializable = class Serializable {
+	lc_serializable = false;
+	lc_kwargs;
+	/**
+	* The name of the serializable. Override to provide an alias or
+	* to preserve the serialized module name in minified environments.
+	*
+	* Implemented as a static method to support loading logic.
+	*/
+	static lc_name() {
+		return this.name;
+	}
+	/**
+	* The final serialized identifier for the module.
+	*/
+	get lc_id() {
+		return [...this.lc_namespace, get_lc_unique_name(this.constructor)];
+	}
+	/**
+	* A map of secrets, which will be omitted from serialization.
+	* Keys are paths to the secret in constructor args, e.g. "foo.bar.baz".
+	* Values are the secret ids, which will be used when deserializing.
+	*/
+	get lc_secrets() {
+		return void 0;
+	}
+	/**
+	* A map of additional attributes to merge with constructor args.
+	* Keys are the attribute names, e.g. "foo".
+	* Values are the attribute values, which will be serialized.
+	* These attributes need to be accepted by the constructor as arguments.
+	*/
+	get lc_attributes() {
+		return void 0;
+	}
+	/**
+	* A map of aliases for constructor args.
+	* Keys are the attribute names, e.g. "foo".
+	* Values are the alias that will replace the key in serialization.
+	* This is used to eg. make argument names match Python.
+	*/
+	get lc_aliases() {
+		return void 0;
+	}
+	/**
+	* A manual list of keys that should be serialized.
+	* If not overridden, all fields passed into the constructor will be serialized.
+	*/
+	get lc_serializable_keys() {
+		return void 0;
+	}
+	constructor(kwargs, ..._args) {
+		if (this.lc_serializable_keys !== void 0) this.lc_kwargs = Object.fromEntries(Object.entries(kwargs || {}).filter(([key]) => this.lc_serializable_keys?.includes(key)));
+		else this.lc_kwargs = kwargs ?? {};
+	}
+	toJSON() {
+		if (!this.lc_serializable) return this.toJSONNotImplemented();
+		if (this.lc_kwargs instanceof Serializable || typeof this.lc_kwargs !== "object" || Array.isArray(this.lc_kwargs)) return this.toJSONNotImplemented();
+		const aliases = {};
+		const secrets = {};
+		const kwargs = Object.keys(this.lc_kwargs).reduce((acc, key) => {
+			acc[key] = key in this ? this[key] : this.lc_kwargs[key];
+			return acc;
+		}, {});
+		for (let current = Object.getPrototypeOf(this); current; current = Object.getPrototypeOf(current)) {
+			Object.assign(aliases, Reflect.get(current, "lc_aliases", this));
+			Object.assign(secrets, Reflect.get(current, "lc_secrets", this));
+			Object.assign(kwargs, Reflect.get(current, "lc_attributes", this));
+		}
+		Object.keys(secrets).forEach((keyPath) => {
+			let read = this;
+			let write = kwargs;
+			const [last, ...partsReverse] = keyPath.split(".").reverse();
+			for (const key of partsReverse.reverse()) {
+				if (!(key in read) || read[key] === void 0) return;
+				if (!(key in write) || write[key] === void 0) {
+					if (typeof read[key] === "object" && read[key] != null) write[key] = {};
+					else if (Array.isArray(read[key])) write[key] = [];
+				}
+				read = read[key];
+				write = write[key];
+			}
+			if (last in read && read[last] !== void 0) write[last] = write[last] || read[last];
+		});
+		return {
+			lc: 1,
+			type: "constructor",
+			id: this.lc_id,
+			kwargs: mapKeys(Object.keys(secrets).length ? replaceSecrets(kwargs, secrets) : kwargs, keyToJson, aliases)
+		};
+	}
+	toJSONNotImplemented() {
+		return {
+			lc: 1,
+			type: "not_implemented",
+			id: this.lc_id
+		};
+	}
+};
 
-// Supabase Edge Function provides a `Deno` global object
-// without `version` property
+//#region src/utils/env.ts
+var env_exports = {};
+__export(env_exports, {
+	getEnv: () => getEnv,
+	getEnvironmentVariable: () => getEnvironmentVariable,
+	getRuntimeEnvironment: () => getRuntimeEnvironment,
+	isBrowser: () => isBrowser,
+	isDeno: () => isDeno,
+	isJsDom: () => isJsDom,
+	isNode: () => isNode,
+	isWebWorker: () => isWebWorker
+});
+const isBrowser = () => typeof window !== "undefined" && typeof window.document !== "undefined";
+const isWebWorker = () => typeof globalThis === "object" && globalThis.constructor && globalThis.constructor.name === "DedicatedWorkerGlobalScope";
+const isJsDom = () => typeof window !== "undefined" && window.name === "nodejs" || typeof navigator !== "undefined" && navigator.userAgent.includes("jsdom");
 const isDeno = () => typeof Deno !== "undefined";
+const isNode = () => typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined" && !isDeno();
+const getEnv = () => {
+	let env;
+	if (isBrowser()) env = "browser";
+	else if (isNode()) env = "node";
+	else if (isWebWorker()) env = "webworker";
+	else if (isJsDom()) env = "jsdom";
+	else if (isDeno()) env = "deno";
+	else env = "other";
+	return env;
+};
+let runtimeEnvironment;
+function getRuntimeEnvironment() {
+	if (runtimeEnvironment === void 0) {
+		const env = getEnv();
+		runtimeEnvironment = {
+			library: "langchain-js",
+			runtime: env
+		};
+	}
+	return runtimeEnvironment;
+}
 function getEnvironmentVariable(name) {
-    // Certain Deno setups will throw an error if you try to access environment variables
-    // https://github.com/langchain-ai/langchainjs/issues/1412
-    try {
-        if (typeof process !== "undefined") {
-            // eslint-disable-next-line no-process-env
-            return process.env?.[name];
-        }
-        else if (isDeno()) {
-            return Deno?.env.get(name);
-        }
-        else {
-            return undefined;
-        }
-    }
-    catch (e) {
-        return undefined;
-    }
+	try {
+		if (typeof process !== "undefined") return process.env?.[name];
+		else if (isDeno()) return Deno?.env.get(name);
+		else return void 0;
+	} catch {
+		return void 0;
+	}
 }
 
+//#region src/callbacks/base.ts
+var base_exports = {};
+__export(base_exports, {
+	BaseCallbackHandler: () => BaseCallbackHandler,
+	callbackHandlerPrefersStreaming: () => callbackHandlerPrefersStreaming,
+	isBaseCallbackHandler: () => isBaseCallbackHandler
+});
 /**
- * Abstract class that provides a set of optional methods that can be
- * overridden in derived classes to handle various events during the
- * execution of a LangChain application.
- */
-class BaseCallbackHandlerMethodsClass {
+* Abstract class that provides a set of optional methods that can be
+* overridden in derived classes to handle various events during the
+* execution of a LangChain application.
+*/
+var BaseCallbackHandlerMethodsClass = class {};
+function callbackHandlerPrefersStreaming(x) {
+	return "lc_prefer_streaming" in x && x.lc_prefer_streaming;
 }
 /**
- * Abstract base class for creating callback handlers in the LangChain
- * framework. It provides a set of optional methods that can be overridden
- * in derived classes to handle various events during the execution of a
- * LangChain application.
- */
-class BaseCallbackHandler extends BaseCallbackHandlerMethodsClass {
-    get lc_namespace() {
-        return ["langchain_core", "callbacks", this.name];
-    }
-    get lc_secrets() {
-        return undefined;
-    }
-    get lc_attributes() {
-        return undefined;
-    }
-    get lc_aliases() {
-        return undefined;
-    }
-    get lc_serializable_keys() {
-        return undefined;
-    }
-    /**
-     * The name of the serializable. Override to provide an alias or
-     * to preserve the serialized module name in minified environments.
-     *
-     * Implemented as a static method to support loading logic.
-     */
-    static lc_name() {
-        return this.name;
-    }
-    /**
-     * The final serialized identifier for the module.
-     */
-    get lc_id() {
-        return [
-            ...this.lc_namespace,
-            get_lc_unique_name(this.constructor),
-        ];
-    }
-    constructor(input) {
-        super();
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "lc_kwargs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "ignoreLLM", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "ignoreChain", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "ignoreAgent", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "ignoreRetriever", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "ignoreCustomEvent", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "raiseError", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "awaitHandlers", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") === "false"
-        });
-        this.lc_kwargs = input || {};
-        if (input) {
-            this.ignoreLLM = input.ignoreLLM ?? this.ignoreLLM;
-            this.ignoreChain = input.ignoreChain ?? this.ignoreChain;
-            this.ignoreAgent = input.ignoreAgent ?? this.ignoreAgent;
-            this.ignoreRetriever = input.ignoreRetriever ?? this.ignoreRetriever;
-            this.ignoreCustomEvent =
-                input.ignoreCustomEvent ?? this.ignoreCustomEvent;
-            this.raiseError = input.raiseError ?? this.raiseError;
-            this.awaitHandlers =
-                this.raiseError || (input._awaitHandler ?? this.awaitHandlers);
-        }
-    }
-    copy() {
-        return new this.constructor(this);
-    }
-    toJSON() {
-        return Serializable.prototype.toJSON.call(this);
-    }
-    toJSONNotImplemented() {
-        return Serializable.prototype.toJSONNotImplemented.call(this);
-    }
-    static fromMethods(methods) {
-        class Handler extends BaseCallbackHandler {
-            constructor() {
-                super();
-                Object.defineProperty(this, "name", {
-                    enumerable: true,
-                    configurable: true,
-                    writable: true,
-                    value: uuid__namespace.v4()
-                });
-                Object.assign(this, methods);
-            }
-        }
-        return new Handler();
-    }
-}
+* Abstract base class for creating callback handlers in the LangChain
+* framework. It provides a set of optional methods that can be overridden
+* in derived classes to handle various events during the execution of a
+* LangChain application.
+*/
+var BaseCallbackHandler = class extends BaseCallbackHandlerMethodsClass {
+	lc_serializable = false;
+	get lc_namespace() {
+		return [
+			"langchain_core",
+			"callbacks",
+			this.name
+		];
+	}
+	get lc_secrets() {
+		return void 0;
+	}
+	get lc_attributes() {
+		return void 0;
+	}
+	get lc_aliases() {
+		return void 0;
+	}
+	get lc_serializable_keys() {
+		return void 0;
+	}
+	/**
+	* The name of the serializable. Override to provide an alias or
+	* to preserve the serialized module name in minified environments.
+	*
+	* Implemented as a static method to support loading logic.
+	*/
+	static lc_name() {
+		return this.name;
+	}
+	/**
+	* The final serialized identifier for the module.
+	*/
+	get lc_id() {
+		return [...this.lc_namespace, get_lc_unique_name(this.constructor)];
+	}
+	lc_kwargs;
+	ignoreLLM = false;
+	ignoreChain = false;
+	ignoreAgent = false;
+	ignoreRetriever = false;
+	ignoreCustomEvent = false;
+	raiseError = false;
+	awaitHandlers = getEnvironmentVariable("LANGCHAIN_CALLBACKS_BACKGROUND") === "false";
+	constructor(input) {
+		super();
+		this.lc_kwargs = input || {};
+		if (input) {
+			this.ignoreLLM = input.ignoreLLM ?? this.ignoreLLM;
+			this.ignoreChain = input.ignoreChain ?? this.ignoreChain;
+			this.ignoreAgent = input.ignoreAgent ?? this.ignoreAgent;
+			this.ignoreRetriever = input.ignoreRetriever ?? this.ignoreRetriever;
+			this.ignoreCustomEvent = input.ignoreCustomEvent ?? this.ignoreCustomEvent;
+			this.raiseError = input.raiseError ?? this.raiseError;
+			this.awaitHandlers = this.raiseError || (input._awaitHandler ?? this.awaitHandlers);
+		}
+	}
+	copy() {
+		return new this.constructor(this);
+	}
+	toJSON() {
+		return Serializable.prototype.toJSON.call(this);
+	}
+	toJSONNotImplemented() {
+		return Serializable.prototype.toJSONNotImplemented.call(this);
+	}
+	static fromMethods(methods) {
+		class Handler extends BaseCallbackHandler {
+			name = uuid__namespace.v4();
+			constructor() {
+				super();
+				Object.assign(this, methods);
+			}
+		}
+		return new Handler();
+	}
+};
+const isBaseCallbackHandler = (x) => {
+	const callbackHandler = x;
+	return callbackHandler !== void 0 && typeof callbackHandler.copy === "function" && typeof callbackHandler.name === "string" && typeof callbackHandler.awaitHandlers === "boolean";
+};
 
 const REDACTED_IMAGE_PLACEHOLDER = '[base64 image redacted]';
 
@@ -1022,6 +965,9 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
       if (additionalTokenData.reasoningTokens) {
         eventProperties['$ai_reasoning_tokens'] = additionalTokenData.reasoningTokens;
       }
+      if (additionalTokenData.webSearchCount !== undefined) {
+        eventProperties['$ai_web_search_count'] = additionalTokenData.webSearchCount;
+      }
 
       // Handle generations/completions
       let completions;
@@ -1193,6 +1139,44 @@ class LangChainCallbackHandler extends BaseCallbackHandler {
       additionalTokenData.reasoningTokens = usage.reasoningTokens;
     }
 
+    // Extract web search counts from various provider formats
+    let webSearchCount;
+
+    // Priority 1: Exact Count
+    // Check Anthropic format (server_tool_use.web_search_requests)
+    if (usage.server_tool_use?.web_search_requests !== undefined) {
+      webSearchCount = usage.server_tool_use.web_search_requests;
+    }
+    // Priority 2: Binary Detection (1 or 0)
+    // Check for citations array (Perplexity)
+    else if (usage.citations && Array.isArray(usage.citations) && usage.citations.length > 0) {
+      webSearchCount = 1;
+    }
+    // Check for search_results array (Perplexity via OpenRouter)
+    else if (usage.search_results && Array.isArray(usage.search_results) && usage.search_results.length > 0) {
+      webSearchCount = 1;
+    }
+    // Check for search_context_size (Perplexity via OpenRouter)
+    else if (usage.search_context_size) {
+      webSearchCount = 1;
+    }
+    // Check for annotations with url_citation type
+    else if (usage.annotations && Array.isArray(usage.annotations)) {
+      const hasUrlCitation = usage.annotations.some(ann => {
+        return ann && typeof ann === 'object' && 'type' in ann && ann.type === 'url_citation';
+      });
+      if (hasUrlCitation) {
+        webSearchCount = 1;
+      }
+    }
+    // Check Gemini format (grounding metadata - binary 0 or 1)
+    else if (usage.grounding_metadata?.grounding_support !== undefined || usage.grounding_metadata?.web_search_queries !== undefined) {
+      webSearchCount = 1;
+    }
+    if (webSearchCount !== undefined) {
+      additionalTokenData.webSearchCount = webSearchCount;
+    }
+
     // In LangChain, input_tokens is the sum of input and cache read tokens.
     // Our cost calculation expects them to be separate, for Anthropic.
     if (parsedUsage.input && additionalTokenData.cacheReadInputTokens) {