@posthog/ai 8.14.1 → 8.14.2

package/dist/openai/index.mjs

@@ -6,6 +6,9 @@ import { Stream } from "openai/streaming";
 const isString = (value) => {
 	return typeof value === "string";
 };
+const isObject = (value) => {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+};
 //#endregion
 //#region src/captureAiEvent.ts
 /** @internal */
@@ -172,17 +175,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) {
@@ -204,8 +216,8 @@ var BinaryContentRedactor = class {
 };
 //#endregion
 //#region src/sanitization.ts
-const redactor = new BinaryContentRedactor();
-const sanitize = (data, client) => isFullAiCaptureEnabled(client) ? data : redactor.redact(data);
+const redactor$1 = new BinaryContentRedactor();
+const sanitize = (data, client) => isFullAiCaptureEnabled(client) ? data : redactor$1.redact(data);
 const sanitizeOpenAI = (data, client) => sanitize(data, client);
 const sanitizeOpenAIResponse = (data, client) => sanitize(data, client);
 //#endregion
@@ -228,9 +240,10 @@ function hasTokenOverrides(posthogProperties) {
 function getTokensSource(posthogProperties) {
 	return hasTokenOverrides(posthogProperties) ? "passthrough" : "sdk";
 }
+const MAX_OUTPUT_SIZE = 2e5;
 const STRING_FORMAT = "utf8";
-new TextEncoder();
-new TextDecoder(STRING_FORMAT, { fatal: false });
+const sharedTextEncoder = new TextEncoder();
+const sharedTextDecoder = 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
@@ -346,8 +359,30 @@ const formatResponseOpenAI = (response) => {
 	}
 	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 "";
+	if (typeof input === "string") return input;
+	try {
+		return JSON.stringify(input);
+	} catch {
+		console.warn("Failed to stringify input", input);
+		return "";
+	}
+}
+const truncate = (input, client, maxBytes = MAX_OUTPUT_SIZE) => {
+	const str = toSafeString(input);
+	if (str === "") return "";
+	if (isFullAiCaptureEnabled(client)) return str;
+	const buffer = sharedTextEncoder.encode(str);
+	if (buffer.length <= maxBytes) return sharedTextDecoder.decode(buffer);
+	const truncatedBuffer = buffer.slice(0, maxBytes);
+	let truncatedStr = sharedTextDecoder.decode(truncatedBuffer);
+	if (truncatedStr.endsWith("�")) truncatedStr = truncatedStr.slice(0, -1);
+	return `${truncatedStr}... [truncated]`;
 };
 /**
 * Calculate web search count from raw API response.
@@ -495,7 +530,7 @@ function formatOpenAIResponsesInput(input, instructions) {
 }
 //#endregion
 //#region package.json
-var version = "8.14.1";
+var version = "8.14.2";
 //#endregion
 //#region src/serializeError.ts
 const DEFAULT_MAX_DEPTH = 3;
@@ -582,7 +617,7 @@ const captureAiGeneration$1 = 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;
@@ -1213,7 +1248,114 @@ var OpenAIResponsesStreamAccumulator = class {
 	}
 };
 //#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/openai/telemetry.ts
+const RESPONSE_TOOL_RESULT_TYPES = /* @__PURE__ */ new Set([
+	"function_call_output",
+	"custom_tool_call_output",
+	"computer_call_output",
+	"local_shell_call_output",
+	"shell_call_output",
+	"apply_patch_call_output",
+	"mcp_call"
+]);
+function buildSanitizedChatInput(context) {
+	try {
+		if (isPrivacyModeEnabled(context.client, context.monitoring.privacyMode)) return null;
+		const messages = context.params.messages.map((message) => {
+			if ((message.role === "tool" || message.role === "function") && Object.hasOwn(message, "content")) return {
+				...message,
+				content: formatToolResult(message.content, context.client, Infinity)
+			};
+			return message;
+		});
+		return sanitizeOpenAI(messages, context.client);
+	} catch {
+		return "[Unserializable]";
+	}
+}
 function captureAiGenerationInBackground(...args) {
 	captureAiGeneration(...args).catch(() => void 0);
 }
@@ -1249,7 +1391,7 @@ function buildChatSuccessOptions(context, result) {
 		...context.monitoring,
 		model: context.params.model ?? result.model,
 		provider: context.provider,
-		input: sanitizeOpenAI(context.params.messages, context.client),
+		input: buildSanitizedChatInput(context),
 		output: sanitizeOpenAIResponse(result.output, context.client),
 		latency: result.latency,
 		timeToFirstToken: result.timeToFirstToken,
@@ -1272,7 +1414,7 @@ function buildChatErrorOptions(context, error, metadata) {
 		...context.monitoring,
 		model: context.params.model,
 		provider: context.provider,
-		input: sanitizeOpenAI(context.params.messages, context.client),
+		input: buildSanitizedChatInput(context),
 		output: [],
 		latency: metadata.latency,
 		baseURL: context.baseURL,
@@ -1284,7 +1426,21 @@ function buildChatErrorOptions(context, error, metadata) {
 	};
 }
 function buildSanitizedResponsesInput(context) {
-	return formatOpenAIResponsesInput(sanitizeOpenAIResponse(context.params.input, context.client), sanitizeOpenAIResponse(context.params.instructions, context.client));
+	try {
+		if (isPrivacyModeEnabled(context.client, context.monitoring.privacyMode)) return null;
+		const input = Array.isArray(context.params.input) ? context.params.input.map((item) => {
+			if (!isObject(item) || typeof item.type !== "string") return item;
+			const key = RESPONSE_TOOL_RESULT_TYPES.has(item.type) ? "output" : item.type === "code_interpreter_call" ? "outputs" : item.type === "file_search_call" ? "results" : void 0;
+			if (!key || !Object.hasOwn(item, key)) return item;
+			return {
+				...item,
+				[key]: formatToolResult(item[key], context.client, Infinity)
+			};
+		}) : context.params.input;
+		return formatOpenAIResponsesInput(sanitizeOpenAIResponse(input, context.client), sanitizeOpenAIResponse(context.params.instructions, context.client));
+	} catch {
+		return "[Unserializable]";
+	}
 }
 function buildResponsesSuccessOptions(context, result) {
 	const response = result.response;