@posthog/ai 8.17.1 → 8.18.0

package/dist/genkit/index.cjs

@@ -0,0 +1,1002 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let uuid = require("uuid");
+let _posthog_core = require("@posthog/core");
+//#region package.json
+var version = "8.18.0";
+//#endregion
+//#region src/captureAiEvent.ts
+/** @internal */
+function isFullAiCaptureEnabled(client) {
+	return client?.enableFullAiCapture === true;
+}
+/** @internal */
+function captureAiEvent(client, 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);
+}
+//#endregion
+//#region src/typeGuards.ts
+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+/_=-]+$/;
+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 TYPED_BINARY_DATA_TYPES = /* @__PURE__ */ new Set([
+	"image",
+	"audio",
+	"video",
+	"document"
+]);
+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";
+	}
+	hasDefiniteBinaryData() {
+		if (this.parent && this.key === "data" && typeof this.parent.type === "string" && TYPED_BINARY_DATA_TYPES.has(this.parent.type)) return true;
+		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;
+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);
+	}
+	/** 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.redactLeaf(value, ctx);
+		if (typeof value !== "object") return value;
+		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)) Object.defineProperty(out, k, {
+			value: this.walk(obj[k], new MediaTypeContext(obj, k)),
+			enumerable: true,
+			writable: true,
+			configurable: true
+		});
+		return out;
+	}
+	redactString(value, ctx) {
+		const hasDefiniteBinaryData = ctx.hasDefiniteBinaryData();
+		const recognitionValue = hasDefiniteBinaryData ? value.replace(/[\r\n]/g, "") : value;
+		const minLength = hasDefiniteBinaryData ? 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$1 = new BinaryContentRedactor();
+function redactBase64DataUrl(str, mediaType) {
+	return redactor$1.redact(str, mediaType);
+}
+//#endregion
+//#region src/privacyMode.ts
+/** Per-call settings can turn redaction on but never off. */
+const isPrivacyModeEnabled = (client, privacyMode = false) => privacyMode === true || client?.privacyMode === true || client?.privacy_mode === true || client?.options?.privacyMode === true;
+//#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.
+*/
+function hasTokenOverrides(posthogProperties) {
+	return !!posthogProperties && Object.keys(posthogProperties).some((key) => TOKEN_PROPERTY_KEYS.has(key));
+}
+function getTokensSource(posthogProperties) {
+	return hasTokenOverrides(posthogProperties) ? "passthrough" : "sdk";
+}
+const MAX_OUTPUT_SIZE = 2e5;
+const STRING_FORMAT = "utf8";
+const sharedTextEncoder = new TextEncoder();
+const sharedTextDecoder = new TextDecoder(STRING_FORMAT, { fatal: false });
+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
+		}
+	};
+};
+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 ?? ""));
+};
+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]`;
+};
+function sanitizeValues(obj) {
+	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;
+}
+//#endregion
+//#region src/serializeError.ts
+const DEFAULT_MAX_DEPTH = 3;
+const MAX_STACK_LINES = 20;
+const OMITTED_FIELD = "requestBodyValues";
+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)) if (key !== OMITTED_FIELD) out[key] = serializeError(Reflect.get(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;
+}
+const omitRequestBody = (key, value) => key === OMITTED_FIELD ? void 0 : value;
+function stringifyError(error) {
+	try {
+		return JSON.stringify(sanitizeValues(serializeError(error)), omitRequestBody);
+	} catch {
+		if (error instanceof Error) return JSON.stringify({
+			name: error.name,
+			message: error.message
+		});
+		return JSON.stringify({ message: String(error) });
+	}
+}
+const CLASS_NAME = /^[A-Za-z_$][A-Za-z0-9_$.]{0,127}$/;
+const PROVIDER_CODE = /^[A-Za-z0-9_.:-]{1,64}$/;
+const PARAM = /^[A-Za-z0-9_.[\]-]{1,128}$/;
+const REQUEST_ID = /^[A-Za-z0-9_.:-]{1,128}$/;
+const MAX_CAUSES = 3;
+const readField = (value, key) => {
+	if (value === null || typeof value !== "object" && typeof value !== "function") return;
+	try {
+		return Reflect.get(value, key);
+	} catch {
+		return;
+	}
+};
+const matching = (value, grammar) => typeof value === "string" && grammar.test(value) ? value : void 0;
+const firstMatching = (values, grammar) => {
+	for (const value of values) {
+		const match = matching(value, grammar);
+		if (match !== void 0) return match;
+	}
+};
+const className = (value) => {
+	if (!(value instanceof Error)) return "NonErrorThrown";
+	const name = readField(value, "name");
+	return firstMatching([
+		name === "Error" ? void 0 : name,
+		readField(readField(value, "constructor"), "name"),
+		name
+	], CLASS_NAME) ?? "Error";
+};
+const httpStatus = (error) => {
+	for (const key of ["status", "statusCode"]) {
+		const value = readField(error, key);
+		if (typeof value === "number" && Number.isInteger(value) && value >= 100 && value <= 599) return value;
+	}
+};
+const unwrapEnvelope = (body) => {
+	const inner = readField(body, "error");
+	return inner !== null && typeof inner === "object" ? inner : body;
+};
+const parsedResponseBody = (error) => {
+	const responseBody = readField(error, "responseBody");
+	if (typeof responseBody !== "string") return;
+	try {
+		return unwrapEnvelope(JSON.parse(responseBody));
+	} catch {
+		return;
+	}
+};
+const causeNames = (error) => {
+	const names = [];
+	let cause = readField(error, "cause");
+	while (cause !== void 0 && cause !== null && names.length < MAX_CAUSES) {
+		names.push(className(cause));
+		cause = readField(cause, "cause");
+	}
+	return names;
+};
+const describeError = (error) => {
+	const sources = [
+		error,
+		unwrapEnvelope(readField(error, "error")),
+		parsedResponseBody(error)
+	];
+	const codes = /* @__PURE__ */ new Set();
+	for (const source of sources) for (const key of [
+		"code",
+		"type",
+		"status"
+	]) {
+		const code = matching(readField(source, key), PROVIDER_CODE);
+		if (code !== void 0) codes.add(code);
+	}
+	const status = httpStatus(error);
+	const param = firstMatching(sources.map((source) => readField(source, "param")), PARAM);
+	const requestId = firstMatching([readField(error, "requestID"), readField(error, "request_id")], REQUEST_ID);
+	const causes = causeNames(error);
+	let summary = className(error);
+	if (status !== void 0) summary += `: ${status}`;
+	for (const code of codes) summary += ` ${code}`;
+	if (param !== void 0) summary += ` param=${param}`;
+	if (requestId !== void 0) summary += ` request_id=${requestId}`;
+	if (causes.length > 0) summary += ` (caused by ${causes.join(", ")})`;
+	return summary;
+};
+/**
+* Describes an error for `$ai_error` without its message, stack, or arbitrary fields, which
+* routinely echo the prompt. Only structured fields that pass a strict grammar are kept.
+* The format matches the Python SDK.
+*/
+function summarizeErrorForPrivacy(error) {
+	try {
+		return describeError(error);
+	} catch {
+		return error instanceof Error ? "Error" : "NonErrorThrown";
+	}
+}
+function formatAiError(error, privacyMode) {
+	return privacyMode ? summarizeErrorForPrivacy(error) : stringifyError(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");
+}
+//#endregion
+//#region src/mcpCredentials.ts
+const MCP_CREDENTIAL_FIELDS = ["headers", "authorization"];
+const MCP_PROVIDER_TOOL_IDS = /* @__PURE__ */ new Set([
+	"openai.mcp",
+	"xai.mcp",
+	"google.mcp_server"
+]);
+const isMcpProviderTool = (tool) => (tool.type === "provider" || tool.type === "provider-defined") && typeof tool.id === "string" && MCP_PROVIDER_TOOL_IDS.has(tool.id);
+const withoutMcpCredentials = (config) => {
+	const redacted = { ...config };
+	for (const field of MCP_CREDENTIAL_FIELDS) if (field in redacted) redacted[field] = "[REDACTED]";
+	return redacted;
+};
+/** Hides the credentials of a remote MCP tool definition; everything else is kept as sent. */
+function redactMcpToolDefinition(tool) {
+	if (!isObject(tool)) return tool;
+	if (tool.type === "mcp") return withoutMcpCredentials(tool);
+	if (isMcpProviderTool(tool) && isObject(tool.args)) return {
+		...tool,
+		args: withoutMcpCredentials(tool.args)
+	};
+	return tool;
+}
+function redactMcpToolCredentials(tools) {
+	return Array.isArray(tools) ? tools.map(redactMcpToolDefinition) : tools;
+}
+//#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 !== void 0 && POSTHOG_AI_GATEWAY_HOSTS.includes(host);
+};
+const warnIfPostHogAiGateway = (baseURL) => {
+	if (!isPostHogAiGatewayUrl(baseURL)) return;
+	console.warn(`[PostHog] The PostHog AI wrapper is pointed at the PostHog AI Gateway. Both capture \$ai_generation, so every call is double-counted and double-billed. Use one or the other — see ${GATEWAY_DOCS_URL}.`);
+};
+//#endregion
+//#region src/captureAiGeneration.ts
+/**
+* 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 ?? (0, uuid.v4)();
+		const eventType = options.eventType ?? "$ai_generation";
+		const privacyMode = options.privacyMode ?? false;
+		const usage = options.usage ?? {};
+		const shouldRedact = isPrivacyModeEnabled(client, privacyMode);
+		const safeInput = shouldRedact ? null : (0, _posthog_core.toJsonSafeValue)(options.input);
+		const safeOutput = shouldRedact ? null : (0, _posthog_core.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) {
+				if (!shouldRedact) {
+					exceptionId = (0, _posthog_core.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: formatAiError(options.error, shouldRedact),
+				$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 ?? {},
+			...options.servedServiceTier != null ? { $ai_service_tier: options.servedServiceTier } : {},
+			$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: redactMcpToolCredentials(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/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 (0, _posthog_core.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 = (0, _posthog_core.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 = (0, _posthog_core.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/genkit/processor.ts
+const SPAN_STATUS_ERROR = 2;
+const MODEL_PARAMETER_KEYS = [
+	"temperature",
+	"maxOutputTokens",
+	"topK",
+	"topP",
+	"stopSequences"
+];
+const CREDENTIAL_KEYS = /* @__PURE__ */ new Set([
+	"apikey",
+	"accesstoken",
+	"authorization",
+	"clientsecret",
+	"headers",
+	"password",
+	"secret",
+	"token"
+]);
+const PROVIDER_NAMES = /* @__PURE__ */ new Map([["googleai", "gemini"], ["vertexai", "vertex"]]);
+const STACK_ERROR_NAME = /^([A-Za-z_$][\w$]*)(?=:|\n|$)/;
+/**
+* An OpenTelemetry span processor that turns Genkit spans into PostHog AI events.
+*
+* - The root span of a Genkit trace (usually a flow) becomes an `$ai_trace`.
+* - Each model action becomes an `$ai_generation` with input, output, token usage, latency and tools.
+* - Each embedder action becomes an `$ai_embedding`.
+* - Every other Genkit span (tools, `generate` steps, retrievers, ...) becomes an `$ai_span`.
+*
+* Spans without Genkit attributes are ignored.
+*
+* @example
+* ```typescript
+* import { enableTelemetry } from 'genkit/tracing'
+* import { PostHogGenkitSpanProcessor } from '@posthog/ai/genkit'
+* import { PostHog } from 'posthog-node'
+*
+* const phClient = new PostHog('<POSTHOG_API_KEY>')
+*
+* await enableTelemetry({
+*   spanProcessors: [new PostHogGenkitSpanProcessor({ client: phClient })],
+* })
+* ```
+*
+* In serverless functions, call `await flushTracing()` from `genkit/tracing` before the function
+* returns. It calls {@link PostHogGenkitSpanProcessor.forceFlush}, which flushes the PostHog client.
+*/
+var PostHogGenkitSpanProcessor = class {
+	constructor(options) {
+		this._spanDistinctIds = /* @__PURE__ */ new WeakMap();
+		this._client = options.client;
+		this._distinctId = options.distinctId;
+		this._privacyMode = options.privacyMode ?? false;
+		this._groups = options.groups;
+		this._properties = options.properties ?? {};
+		this._onError = options.onError;
+	}
+	onStart(span) {
+		try {
+			const distinctId = this._distinctId ?? this._client.getContext?.()?.distinctId;
+			if (distinctId !== void 0) this._spanDistinctIds.set(span, distinctId);
+		} catch (error) {
+			this._handleError(error);
+		}
+	}
+	onEnd(span) {
+		const distinctId = this._distinctId ?? this._spanDistinctIds.get(span);
+		this._spanDistinctIds.delete(span);
+		try {
+			if (typeof span.attributes["genkit:type"] !== "string") return;
+			const subtype = span.attributes["genkit:metadata:subtype"];
+			if (subtype === "model") this._captureGeneration(span, distinctId);
+			else if (subtype === "embedder") this._captureEmbedding(span, distinctId);
+			else this._captureSpan(span, distinctId);
+		} catch (error) {
+			this._handleError(error);
+		}
+	}
+	async forceFlush() {
+		try {
+			await this._client.flush();
+		} catch (error) {
+			this._handleError(error);
+		}
+	}
+	async shutdown() {
+		await this.forceFlush();
+	}
+	_captureGeneration(span, distinctId) {
+		const request = parseAttribute(span, "genkit:input");
+		const response = parseAttribute(span, "genkit:output");
+		const usage = response?.usage;
+		const message = response?.message ?? response?.candidates?.[0]?.message;
+		const finishReason = response?.finishReason ?? response?.candidates?.[0]?.finishReason;
+		const shouldRedact = isPrivacyModeEnabled(this._client, this._privacyMode);
+		const { traceId, spanId, parentId } = spanIds(span);
+		captureAiGeneration(this._client, {
+			distinctId,
+			traceId,
+			...modelAndProvider(span.name),
+			baseURL: null,
+			input: shouldRedact ? null : this._formatMessages(request?.messages ?? []),
+			output: shouldRedact ? null : this._formatMessages(message ? [message] : []),
+			latency: latencySeconds(span),
+			modelParameters: pickModelParameters(request?.config),
+			tools: request?.tools?.length ? request.tools : null,
+			usage: usage && {
+				inputTokens: usage.inputTokens,
+				outputTokens: usage.outputTokens,
+				reasoningTokens: usage.thoughtsTokens,
+				cacheReadInputTokens: usage.cachedContentTokens,
+				rawUsage: usage
+			},
+			stopReason: finishReason,
+			groups: this._groups,
+			privacyMode: this._privacyMode,
+			onError: this._onError,
+			error: spanError(span),
+			properties: {
+				$ai_framework: "genkit",
+				$ai_span_id: spanId,
+				$ai_parent_id: parentId,
+				$ai_span_name: span.name,
+				...this._properties
+			}
+		});
+	}
+	_captureEmbedding(span, distinctId) {
+		const request = parseAttribute(span, "genkit:input");
+		const shouldRedact = isPrivacyModeEnabled(this._client, this._privacyMode);
+		const { traceId, spanId, parentId } = spanIds(span);
+		const input = (request?.input ?? []).map((document) => formatDocument(document.content ?? [], this._client));
+		captureAiGeneration(this._client, {
+			eventType: "$ai_embedding",
+			distinctId,
+			traceId,
+			...modelAndProvider(span.name),
+			baseURL: null,
+			input: shouldRedact ? null : formatToolResult(input, this._client, MAX_OUTPUT_SIZE),
+			output: null,
+			latency: latencySeconds(span),
+			groups: this._groups,
+			privacyMode: this._privacyMode,
+			onError: this._onError,
+			error: spanError(span),
+			properties: {
+				$ai_framework: "genkit",
+				$ai_span_id: spanId,
+				$ai_parent_id: parentId,
+				$ai_span_name: span.name,
+				...this._properties
+			}
+		});
+	}
+	_captureSpan(span, distinctId) {
+		const isRoot = span.attributes["genkit:isRoot"] === true;
+		const { traceId, spanId, parentId } = spanIds(span);
+		const error = spanError(span);
+		captureAiEvent(this._client, {
+			distinctId: distinctId ?? traceId,
+			event: isRoot ? "$ai_trace" : "$ai_span",
+			properties: {
+				$ai_lib: "posthog-ai",
+				$ai_lib_version: version,
+				$ai_framework: "genkit",
+				$ai_trace_id: traceId,
+				$ai_span_id: spanId,
+				...!isRoot && parentId ? { $ai_parent_id: parentId } : {},
+				$ai_span_name: span.name,
+				$ai_span_type: span.attributes["genkit:metadata:subtype"] ?? span.attributes["genkit:type"],
+				$ai_input_state: this._formatState(span, "genkit:input"),
+				$ai_output_state: this._formatState(span, "genkit:output"),
+				$ai_latency: latencySeconds(span),
+				...error ? {
+					$ai_is_error: true,
+					$ai_error: formatAiError(error, isPrivacyModeEnabled(this._client, this._privacyMode))
+				} : {},
+				...this._properties,
+				...distinctId ? {} : { $process_person_profile: false }
+			},
+			groups: this._groups
+		});
+	}
+	_handleError(error) {
+		try {
+			this._onError?.(error);
+		} catch {}
+	}
+	_formatState(span, key) {
+		if (isPrivacyModeEnabled(this._client, this._privacyMode)) return null;
+		return formatToolResult(redactCredentials(parseAttribute(span, key)), this._client, MAX_OUTPUT_SIZE);
+	}
+	_formatMessages(messages) {
+		return formatToolResult(messages.map((message) => ({
+			role: message.role === "model" ? "assistant" : message.role,
+			content: (message.content ?? []).map((part) => formatPart(part, this._client))
+		})), this._client, MAX_OUTPUT_SIZE);
+	}
+};
+function formatPart(part, client) {
+	if (typeof part.text === "string") return {
+		type: "text",
+		text: part.text
+	};
+	if (typeof part.reasoning === "string") return {
+		type: "reasoning",
+		text: part.reasoning
+	};
+	if (part.toolRequest) return {
+		type: "function",
+		id: part.toolRequest.ref,
+		function: {
+			name: part.toolRequest.name,
+			arguments: part.toolRequest.input ?? {}
+		}
+	};
+	if (part.toolResponse) return {
+		type: "tool_result",
+		tool_use_id: part.toolResponse.ref,
+		name: part.toolResponse.name,
+		content: part.toolResponse.output
+	};
+	if (part.media) return formatMedia(part.media, client);
+	return part;
+}
+function formatMedia(media, client) {
+	if (media.url.startsWith("data:")) {
+		const comma = media.url.indexOf(",");
+		const metadata = media.url.slice(5, comma);
+		if (comma !== -1 && metadata.endsWith(";base64")) return formatInlineDataBlock({
+			mimeType: media.contentType || metadata.split(";", 1)[0],
+			data: media.url.slice(comma + 1)
+		}, client);
+	}
+	if (!media.contentType || media.contentType.startsWith("image/")) return {
+		type: "image",
+		image: media.url
+	};
+	return { media };
+}
+/** A text-only document becomes one string, like the string input of the other embedding integrations. */
+function formatDocument(content, client) {
+	if (content.every((part) => typeof part.text === "string")) return content.map((part) => part.text).join("");
+	return content.map((part) => formatPart(part, client));
+}
+function redactCredentials(value) {
+	if (Array.isArray(value)) return value.map(redactCredentials);
+	if (!isObject(value)) return value;
+	return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, CREDENTIAL_KEYS.has(key.toLowerCase().replace(/[-_]/g, "")) ? "[REDACTED]" : redactCredentials(item)]));
+}
+/** Genkit stores span input and output as JSON strings. */
+function parseAttribute(span, key) {
+	const value = span.attributes[key];
+	if (typeof value !== "string") return;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+}
+function spanIds(span) {
+	const { traceId, spanId } = span.spanContext();
+	return {
+		traceId,
+		spanId,
+		parentId: span.parentSpanContext?.spanId ?? span.parentSpanId
+	};
+}
+function latencySeconds(span) {
+	return span.duration[0] + span.duration[1] / 1e9;
+}
+/** Rebuilds the error from the span's `exception` event, so error tracking gets a real `Error` with a stack. */
+function spanError(span) {
+	if (span.status.code !== SPAN_STATUS_ERROR) return;
+	const exception = span.events?.find((event) => event.name === "exception")?.attributes ?? {};
+	const message = exception["exception.message"];
+	const stack = exception["exception.stacktrace"];
+	const error = new Error(typeof message === "string" ? message : span.status.message);
+	error.stack = typeof stack === "string" ? stack : void 0;
+	const name = STACK_ERROR_NAME.exec(error.stack ?? "")?.[1] ?? exception["exception.type"];
+	if (typeof name === "string") error.name = name;
+	return error;
+}
+/** Genkit names models and embedders `<plugin>/<name>`, for example `vertexai/gemini-2.5-flash`. */
+function modelAndProvider(name) {
+	const slash = name.indexOf("/");
+	const plugin = slash > 0 ? name.slice(0, slash) : "";
+	return {
+		model: name.slice(slash + 1),
+		provider: PROVIDER_NAMES.get(plugin) ?? plugin
+	};
+}
+function pickModelParameters(config) {
+	const parameters = {};
+	for (const key of MODEL_PARAMETER_KEYS) if (config?.[key] !== void 0) parameters[key] = config[key];
+	return parameters;
+}
+//#endregion
+exports.PostHogGenkitSpanProcessor = PostHogGenkitSpanProcessor;
+
+//# sourceMappingURL=index.cjs.map