@posthog/ai 8.14.1 → 8.14.3

package/dist/gemini/index.mjs

@@ -1,11 +1,6 @@
 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";
-};
-//#endregion
 //#region src/captureAiEvent.ts
 /** @internal */
 function isFullAiCaptureEnabled(client) {
@@ -28,6 +23,14 @@ async function captureAiEventImmediate(client, event) {
 	await client.captureImmediate(event);
 }
 //#endregion
+//#region src/typeGuards.ts
+const isString = (value) => {
+	return typeof value === "string";
+};
+const isObject = (value) => {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+};
+//#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+/_=-]+$/;
@@ -171,17 +174,26 @@ var BinaryContentRedactor = class {
 		this.visited = /* @__PURE__ */ new WeakSet();
 		return this.walk(value, mediaType ? new MediaTypeContext(void 0, void 0, mediaType) : MediaTypeContext.EMPTY);
 	}
+	/** Redact one leaf while a caller owns bounded, type-preserving traversal. @internal */
+	redactLeaf(value, context) {
+		return typeof value === "string" ? this.redactString(value, context) : this.placeholderFor(context.inferMediaType());
+	}
 	walk(value, ctx) {
 		if (value === null || value === void 0) return value;
-		if (typeof value === "string") return this.redactString(value, ctx);
+		if (typeof value === "string") return this.redactLeaf(value, ctx);
 		if (typeof value !== "object") return value;
-		if (typeof Uint8Array !== "undefined" && value instanceof Uint8Array) return this.placeholderFor(ctx.inferMediaType());
+		if (typeof Uint8Array !== "undefined" && value instanceof Uint8Array) return this.redactLeaf(value, ctx);
 		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));
+		for (const k of Object.keys(obj)) Object.defineProperty(out, k, {
+			value: this.walk(obj[k], new MediaTypeContext(obj, k)),
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
 		return out;
 	}
 	redactString(value, ctx) {
@@ -203,11 +215,11 @@ var BinaryContentRedactor = class {
 };
 //#endregion
 //#region src/sanitization.ts
-const redactor = new BinaryContentRedactor();
+const redactor$1 = new BinaryContentRedactor();
 function redactBase64DataUrl(str, mediaType) {
-	return redactor.redact(str, mediaType);
+	return redactor$1.redact(str, mediaType);
 }
-const sanitize = (data, client) => isFullAiCaptureEnabled(client) ? data : redactor.redact(data);
+const sanitize = (data, client) => isFullAiCaptureEnabled(client) ? data : redactor$1.redact(data);
 const sanitizeGemini = (data, client) => sanitize(data, client);
 //#endregion
 //#region src/utils.ts
@@ -352,8 +364,9 @@ const formatResponseGemini = (response, client) => {
 	});
 	return output;
 };
+const isPrivacyModeEnabled = (client, privacyMode) => Boolean(client.privacy_mode || privacyMode);
 const withPrivacyMode = (client, privacyMode, input) => {
-	return client.privacy_mode || privacyMode ? null : input;
+	return isPrivacyModeEnabled(client, privacyMode) ? null : input;
 };
 function toSafeString(input) {
 	if (input === void 0 || input === null) return "";
@@ -435,7 +448,7 @@ function addDefaults(params) {
 }
 //#endregion
 //#region package.json
-var version = "8.14.1";
+var version = "8.14.3";
 //#endregion
 //#region src/serializeError.ts
 const DEFAULT_MAX_DEPTH = 3;
@@ -522,7 +535,7 @@ const captureAiGeneration = async (client, options) => {
 		const eventType = options.eventType ?? "$ai_generation";
 		const privacyMode = options.privacyMode ?? false;
 		const usage = options.usage ?? {};
-		const shouldRedact = withPrivacyMode(client, privacyMode, false) === null;
+		const shouldRedact = isPrivacyModeEnabled(client, privacyMode);
 		const safeInput = shouldRedact ? null : toJsonSafeValue(options.input);
 		const safeOutput = shouldRedact ? null : toJsonSafeValue(options.output);
 		let httpStatus = options.httpStatus;
@@ -604,6 +617,89 @@ const captureAiGeneration = async (client, options) => {
 	}
 };
 //#endregion
+//#region src/toolResult.ts
+const MAX_DEPTH = 20;
+const MAX_ITEMS = 1e3;
+const MAX_NODES = 1e4;
+const TRUNCATED = "[Truncated]";
+const UNSERIALIZABLE = "[Unserializable]";
+const redactor = new BinaryContentRedactor();
+const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+/** @internal Preserve tool-result structure while bounding each string value. */
+function formatToolResult(content, client, maxBytes = 5e3) {
+	try {
+		if (isFullAiCaptureEnabled(client)) return toJsonSafeValue(content);
+		const ancestors = /* @__PURE__ */ new WeakSet();
+		let remainingNodes = MAX_NODES;
+		const convert = (value, depth, context) => {
+			if (remainingNodes <= 0) return TRUNCATED;
+			remainingNodes--;
+			try {
+				if (value === null || typeof value !== "object") {
+					const safe = toJsonSafeValue(value);
+					return typeof safe === "string" ? truncate(redactor.redactLeaf(safe, context), void 0, maxBytes) : safe;
+				}
+				if (depth >= MAX_DEPTH) return TRUNCATED;
+				if (typeof Uint8Array !== "undefined" && value instanceof Uint8Array) return redactor.redactLeaf(value, context);
+				if (ancestors.has(value)) return "[Circular]";
+				ancestors.add(value);
+				try {
+					if (value instanceof Date) {
+						const safe = toJsonSafeValue(value);
+						return typeof safe === "string" ? truncate(redactor.redactLeaf(safe, context), void 0, maxBytes) : safe;
+					}
+					let hasToJSONResult = false;
+					let toJSONResult;
+					try {
+						const toJSON = value.toJSON;
+						if (typeof toJSON === "function") {
+							toJSONResult = toJSON.call(value);
+							hasToJSONResult = true;
+						}
+					} catch {}
+					if (hasToJSONResult) return convert(toJSONResult, depth + 1, context);
+					if (Array.isArray(value)) {
+						const output = [];
+						const count = Math.min(value.length, MAX_ITEMS);
+						let index = 0;
+						for (; index < count && remainingNodes > 0; index++) output.push(convert(value[index], depth + 1, context));
+						if (value.length > index) output.push(TRUNCATED);
+						return output;
+					}
+					const input = value;
+					const output = {};
+					let count = 0;
+					let truncated = false;
+					for (const key in input) {
+						if (!propertyIsEnumerable.call(input, key)) break;
+						if (count >= MAX_ITEMS || remainingNodes <= 0) {
+							truncated = true;
+							break;
+						}
+						const converted = convert(input[key], depth + 1, new MediaTypeContext(input, key));
+						Object.defineProperty(output, key, {
+							value: converted,
+							enumerable: true,
+							writable: true,
+							configurable: true
+						});
+						count++;
+					}
+					if (truncated) output[TRUNCATED] = "Additional properties omitted";
+					return output;
+				} finally {
+					ancestors.delete(value);
+				}
+			} catch {
+				return UNSERIALIZABLE;
+			}
+		};
+		return convert(content, 0, MediaTypeContext.EMPTY);
+	} catch {
+		return UNSERIALIZABLE;
+	}
+}
+//#endregion
 //#region src/gemini/usage.ts
 /** Map Gemini usage metadata to PostHog's provider-agnostic token fields. */
 function mapGeminiUsage(metadata, additionalUsage = {}) {
@@ -620,6 +716,12 @@ function mapGeminiUsage(metadata, additionalUsage = {}) {
 //#endregion
 //#region src/gemini/index.ts
 const TOOL_RESULT_MAX_BYTES = 5e3;
+function geminiFunctionResponseContent(response) {
+	return response.parts !== void 0 ? {
+		...response.response !== void 0 && { response: response.response },
+		parts: response.parts
+	} : response.response ?? {};
+}
 var PostHogGoogleGenAI = class {
 	constructor(config) {
 		const { posthog, ...geminiConfig } = config;
@@ -646,7 +748,7 @@ var WrappedModels = class {
 				...posthogParams,
 				model: geminiParams.model,
 				provider: "gemini",
-				input: this.formatInputForPostHog(geminiParams),
+				input: this.formatInputForPostHog(geminiParams, posthogParams.privacyMode),
 				output: formatResponseGemini(response, this.phClient),
 				latency,
 				baseURL: "https://generativelanguage.googleapis.com",
@@ -663,7 +765,7 @@ var WrappedModels = class {
 				...posthogParams,
 				model: geminiParams.model,
 				provider: "gemini",
-				input: this.formatInputForPostHog(geminiParams),
+				input: this.formatInputForPostHog(geminiParams, posthogParams.privacyMode),
 				output: [],
 				latency,
 				baseURL: "https://generativelanguage.googleapis.com",
@@ -730,7 +832,7 @@ var WrappedModels = class {
 				...posthogParams,
 				model: geminiParams.model,
 				provider: "gemini",
-				input: this.formatInputForPostHog(geminiParams),
+				input: this.formatInputForPostHog(geminiParams, posthogParams.privacyMode),
 				output: [],
 				latency,
 				baseURL: "https://generativelanguage.googleapis.com",
@@ -752,7 +854,7 @@ var WrappedModels = class {
 					...posthogParams,
 					model: geminiParams.model,
 					provider: "gemini",
-					input: this.formatInputForPostHog(geminiParams),
+					input: this.formatInputForPostHog(geminiParams, posthogParams.privacyMode),
 					output,
 					latency,
 					timeToFirstToken,
@@ -836,28 +938,16 @@ var WrappedModels = class {
 		} else if (part && typeof part === "object" && "functionResponse" in part) {
 			const functionResponse = part.functionResponse;
 			if (functionResponse?.name) {
-				const content = functionResponse.parts !== void 0 ? {
-					...functionResponse.response !== void 0 && { response: functionResponse.response },
-					parts: functionResponse.parts
-				} : functionResponse.response ?? {};
+				const content = geminiFunctionResponseContent(functionResponse);
 				blocks.push({
 					type: "tool_result",
 					...functionResponse.id != null && { tool_use_id: functionResponse.id },
-					content: this.boundToolResult(content)
+					content
 				});
 			}
 		}
 		return blocks;
 	}
-	boundToolResult(content) {
-		if (isFullAiCaptureEnabled(this.phClient)) return content;
-		try {
-			const serialized = JSON.stringify(content);
-			return utf8ByteLength(serialized) > TOOL_RESULT_MAX_BYTES ? truncate(serialized, void 0, TOOL_RESULT_MAX_BYTES) : content;
-		} catch {
-			return "[Unserializable tool result]";
-		}
-	}
 	formatInput(contents) {
 		if (typeof contents === "string") return [{
 			role: "user",
@@ -932,17 +1022,63 @@ var WrappedModels = class {
 		}
 		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 [{
+	boundToolResult(content) {
+		const normalized = formatToolResult(content, this.phClient, Infinity);
+		if (isFullAiCaptureEnabled(this.phClient)) return normalized;
+		const serialized = JSON.stringify(normalized);
+		return serialized !== void 0 && utf8ByteLength(serialized) > TOOL_RESULT_MAX_BYTES ? truncate(serialized, void 0, TOOL_RESULT_MAX_BYTES) : normalized;
+	}
+	formatInputForPostHog(params, privacyMode) {
+		try {
+			if (isPrivacyModeEnabled(this.phClient, privacyMode)) return null;
+			const preparePart = (part) => {
+				if (!isObject(part) || !Object.hasOwn(part, "functionResponse") || !isObject(part.functionResponse)) return part;
+				const response = part.functionResponse;
+				const hasParts = response.parts !== void 0;
+				const hasResponse = Object.hasOwn(response, "response");
+				if (!hasParts && !hasResponse) return part;
+				const formatted = this.boundToolResult(geminiFunctionResponseContent(response));
+				const prepared = { ...response };
+				if (hasParts && isObject(formatted)) {
+					if (hasResponse) prepared.response = formatted.response;
+					prepared.parts = formatted.parts;
+				} else {
+					prepared.response = formatted;
+					if (hasParts) delete prepared.parts;
+				}
+				return {
+					...part,
+					functionResponse: prepared
+				};
+			};
+			const prepareContent = (content) => {
+				const part = preparePart(content);
+				if (!isObject(part)) return part;
+				const originalParts = Object.hasOwn(part, "parts") ? part.parts : void 0;
+				const originalContent = Object.hasOwn(part, "content") ? part.content : void 0;
+				const parts = Array.isArray(originalParts) ? originalParts.map(preparePart) : void 0;
+				const blocks = Array.isArray(originalContent) ? originalContent.map(preparePart) : void 0;
+				const partsChanged = parts?.some((value, index) => value !== originalParts[index]);
+				const contentChanged = blocks?.some((value, index) => value !== originalContent[index]);
+				if (!partsChanged && !contentChanged) return part;
+				return {
+					...part,
+					...partsChanged && { parts },
+					...contentChanged && { content: blocks }
+				};
+			};
+			const contents = Array.isArray(params.contents) ? params.contents.map(prepareContent) : prepareContent(params.contents);
+			const sanitized = sanitizeGemini(contents, this.phClient);
+			const messages = this.formatInput(sanitized);
+			const systemInstruction = this.extractSystemInstruction(params);
+			if (systemInstruction && !messages.some((message) => message.role === "system")) return [{
 				role: "system",
 				content: systemInstruction
 			}, ...messages];
+			return messages;
+		} catch {
+			return "[Unserializable]";
 		}
-		return messages;
 	}
 };
 /**