@posthog/ai 8.9.3 → 8.10.1

package/dist/adk/index.cjs

@@ -0,0 +1,977 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _google_adk = require("@google/adk");
+let uuid = require("uuid");
+let _posthog_core = require("@posthog/core");
+//#region package.json
+var version = "8.10.1";
+//#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/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 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;
+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);
+}
+const sanitize = (data, client) => isFullAiCaptureEnabled(client) ? data : redactor.redact(data);
+const sanitizeGemini = (data, client) => sanitize(data, client);
+//#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 STRING_FORMAT = "utf8";
+new TextEncoder();
+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
+*/
+function toContentString(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 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 ?? ""));
+};
+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 withPrivacyMode = (client, privacyMode, input) => {
+	return client.privacy_mode || privacyMode ? null : input;
+};
+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;
+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 !== 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) });
+	}
+}
+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/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 = withPrivacyMode(client, privacyMode, false) === null;
+		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) {
+				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: 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,
+		...metadata?.cachedContentTokenCount ? { cacheReportingExclusive: false } : {},
+		...additionalUsage,
+		rawUsage: metadata
+	};
+}
+//#endregion
+//#region src/adk/plugin.ts
+/** Calls older than this are treated as abandoned rather than evicting live calls by count. */
+const MAX_PENDING_AGE_MS = 36e5;
+/**
+* A Google ADK (`@google/adk`) `BasePlugin` that captures PostHog AI traces,
+* agent and tool spans, and a full `$ai_generation` event for every model call.
+*
+* Run, agent, and tool callbacks build the trace hierarchy. Model callbacks
+* record input, output, model, token usage, latency, and finish reason through
+* the shared {@link captureAiGeneration} primitive so PostHog derives cost from
+* the model and tokens (never hardcoded here).
+*
+* ADK already emits OpenTelemetry `gen_ai.*` spans; this plugin is the
+* complement for users who capture LLM analytics through the PostHog SDK rather
+* than an OTEL exporter.
+*
+* @example
+* ```typescript
+* import { PostHogADKPlugin } from '@posthog/ai/adk'
+* import { Runner } from '@google/adk'
+* import { PostHog } from 'posthog-node'
+*
+* const phClient = new PostHog('<POSTHOG_API_KEY>')
+*
+* const runner = new Runner({
+*   appName: 'my-app',
+*   agent,
+*   sessionService,
+*   plugins: [new PostHogADKPlugin({ client: phClient, distinctId: 'user@example.com' })],
+* })
+* ```
+*/
+var PostHogADKPlugin = class extends _google_adk.BasePlugin {
+	constructor(options) {
+		super("posthog");
+		this._pending = /* @__PURE__ */ new Map();
+		this._traces = /* @__PURE__ */ new Map();
+		this._pendingAgents = /* @__PURE__ */ new Map();
+		this._pendingTools = /* @__PURE__ */ new Map();
+		this._client = options.client;
+		this._distinctId = options.distinctId;
+		this._provider = options.provider ?? "gemini";
+		this._privacyMode = options.privacyMode ?? false;
+		this._groups = options.groups;
+		this._properties = options.properties ?? {};
+		this._captureImmediate = options.captureImmediate ?? false;
+		this._onError = options.onError;
+	}
+	async beforeRunCallback({ invocationContext }) {
+		try {
+			this._evictStalePending();
+			this._traces.set(invocationContext.invocationId, {
+				startTime: Date.now(),
+				spanId: invocationContext.invocationId,
+				name: invocationContext.agent?.name ?? "ADK invocation",
+				input: invocationContext.userContent,
+				distinctId: this._resolveInvocationDistinctId(invocationContext),
+				sessionId: invocationContext.session?.id
+			});
+		} catch (error) {
+			this._handleError(error);
+		}
+	}
+	async afterRunCallback({ invocationContext }) {
+		try {
+			const trace = this._traces.get(invocationContext.invocationId);
+			this._traces.delete(invocationContext.invocationId);
+			this._clearPendingInvocation(invocationContext.invocationId);
+			if (!trace) return;
+			await this._captureLifecycleEvent("$ai_trace", trace.distinctId, {
+				$ai_trace_id: invocationContext.invocationId,
+				$ai_span_id: trace.spanId,
+				$ai_span_name: trace.name,
+				$ai_input_state: withPrivacyMode(this._client, this._privacyMode, trace.input),
+				$ai_latency: (Date.now() - trace.startTime) / 1e3,
+				...trace.sessionId ? { $ai_session_id: trace.sessionId } : {}
+			});
+		} catch (error) {
+			this._handleError(error);
+		}
+	}
+	async beforeAgentCallback({ agent, callbackContext }) {
+		try {
+			this._evictStalePending();
+			this._rememberContext(callbackContext);
+			const key = this._pendingKey(callbackContext);
+			const pending = {
+				startTime: Date.now(),
+				spanId: (0, uuid.v4)(),
+				name: agent.name,
+				input: callbackContext.userContent
+			};
+			const queue = this._pendingAgents.get(key);
+			if (queue) queue.push(pending);
+			else this._pendingAgents.set(key, [pending]);
+		} catch (error) {
+			this._handleError(error);
+		}
+	}
+	async afterAgentCallback({ callbackContext }) {
+		try {
+			const pending = this._takePendingAgent(this._pendingKey(callbackContext));
+			if (pending) await this._captureLifecycleEvent("$ai_span", this._resolveDistinctId(callbackContext), {
+				$ai_trace_id: callbackContext.invocationId,
+				$ai_span_id: pending.spanId,
+				...this._traces.get(callbackContext.invocationId)?.spanId ? { $ai_parent_id: this._traces.get(callbackContext.invocationId)?.spanId } : {},
+				$ai_span_name: pending.name,
+				$ai_input_state: withPrivacyMode(this._client, this._privacyMode, pending.input),
+				$ai_latency: (Date.now() - pending.startTime) / 1e3,
+				...callbackContext.sessionId ? { $ai_session_id: callbackContext.sessionId } : {},
+				...callbackContext.agentName ? { $ai_agent_name: callbackContext.agentName } : {}
+			});
+		} catch (error) {
+			this._handleError(error);
+		}
+	}
+	async beforeModelCallback({ callbackContext, llmRequest }) {
+		try {
+			this._evictStalePending();
+			this._rememberContext(callbackContext);
+			const pending = {
+				startTime: Date.now(),
+				spanId: (0, uuid.v4)(),
+				input: this._formatInput(llmRequest),
+				model: llmRequest.model,
+				modelParameters: extractModelParameters(llmRequest.config),
+				tools: extractTools(llmRequest),
+				streamedOutput: []
+			};
+			const key = this._pendingKey(callbackContext);
+			const queue = this._pending.get(key);
+			if (queue) queue.push(pending);
+			else this._pending.set(key, [pending]);
+		} catch (error) {
+			this._handleError(error);
+		}
+	}
+	async afterModelCallback({ callbackContext, llmResponse }) {
+		try {
+			if (llmResponse.partial) return;
+			const key = this._pendingKey(callbackContext);
+			const pending = this._peekPending(key);
+			if (this._isNonTerminalStreamResponse(llmResponse)) {
+				if (pending) pending.streamedOutput.push(...this._formatOutput(llmResponse));
+				return;
+			}
+			const completedPending = this._takePending(key);
+			const error = llmResponse.errorCode ? new Error(llmResponse.errorMessage ?? String(llmResponse.errorCode)) : void 0;
+			const output = error ? [] : this._formatOutput(llmResponse);
+			await this._capture(callbackContext, {
+				pending: completedPending,
+				output: !error && output.length === 0 && completedPending?.streamedOutput.length ? completedPending.streamedOutput : output,
+				model: llmResponse.modelVersion ?? completedPending?.model,
+				usage: llmResponse.usageMetadata,
+				stopReason: llmResponse.finishReason ? String(llmResponse.finishReason) : void 0,
+				error
+			});
+		} catch (error) {
+			this._handleError(error);
+		}
+	}
+	async onModelErrorCallback({ callbackContext, llmRequest, error }) {
+		try {
+			const pending = this._takePending(this._pendingKey(callbackContext));
+			await this._capture(callbackContext, {
+				pending: pending ?? {
+					startTime: Date.now(),
+					spanId: (0, uuid.v4)(),
+					input: this._formatInput(llmRequest),
+					model: llmRequest.model,
+					modelParameters: extractModelParameters(llmRequest.config),
+					tools: extractTools(llmRequest),
+					streamedOutput: []
+				},
+				output: [],
+				model: llmRequest.model,
+				usage: void 0,
+				error
+			});
+		} catch (captureError) {
+			this._handleError(captureError);
+		}
+	}
+	async beforeToolCallback({ tool, toolArgs, toolContext }) {
+		try {
+			this._evictStalePending();
+			this._rememberContext(toolContext);
+			const key = this._toolKey(toolContext, tool.name);
+			const pending = {
+				startTime: Date.now(),
+				spanId: toolContext.functionCallId ?? (0, uuid.v4)(),
+				name: tool.name,
+				input: toolArgs
+			};
+			const queue = this._pendingTools.get(key);
+			if (queue) queue.push(pending);
+			else this._pendingTools.set(key, [pending]);
+		} catch (error) {
+			this._handleError(error);
+		}
+	}
+	async afterToolCallback({ tool, toolContext, result }) {
+		try {
+			const pending = this._takePendingTool(this._toolKey(toolContext, tool.name));
+			if (pending) await this._captureToolSpan(toolContext, pending, result);
+		} catch (error) {
+			this._handleError(error);
+		}
+	}
+	async onToolErrorCallback({ tool, toolContext, error }) {
+		try {
+			const pending = this._takePendingTool(this._toolKey(toolContext, tool.name));
+			if (pending) await this._captureToolSpan(toolContext, pending, void 0, error);
+		} catch (captureError) {
+			this._handleError(captureError);
+		}
+	}
+	async _capture(callbackContext, args) {
+		const { pending, output, model, usage, stopReason, error } = args;
+		const latency = pending ? (Date.now() - pending.startTime) / 1e3 : void 0;
+		await captureAiGeneration(this._client, {
+			distinctId: this._resolveDistinctId(callbackContext),
+			traceId: callbackContext.invocationId,
+			model,
+			provider: this._provider,
+			baseURL: null,
+			input: pending?.input ?? [],
+			output,
+			latency,
+			modelParameters: pending?.modelParameters,
+			usage: mapGeminiUsage(usage),
+			stopReason,
+			tools: pending?.tools,
+			groups: this._groups,
+			privacyMode: this._privacyMode,
+			captureImmediate: this._captureImmediate,
+			onError: this._onError,
+			properties: {
+				$ai_framework: "google-adk",
+				$ai_span_id: pending?.spanId ?? (0, uuid.v4)(),
+				...this._parentSpanId(callbackContext) ? { $ai_parent_id: this._parentSpanId(callbackContext) } : {},
+				...callbackContext.sessionId ? { $ai_session_id: callbackContext.sessionId } : {},
+				...callbackContext.agentName ? {
+					$ai_agent_name: callbackContext.agentName,
+					$ai_span_name: callbackContext.agentName
+				} : {},
+				...this._properties
+			},
+			error
+		});
+	}
+	async _captureToolSpan(context, pending, result, error) {
+		await this._captureLifecycleEvent("$ai_span", this._resolveDistinctId(context), {
+			$ai_trace_id: context.invocationId,
+			$ai_span_id: pending.spanId,
+			...this._parentSpanId(context) ? { $ai_parent_id: this._parentSpanId(context) } : {},
+			$ai_span_name: pending.name,
+			$ai_input_state: withPrivacyMode(this._client, this._privacyMode, pending.input),
+			...result !== void 0 ? { $ai_output_state: withPrivacyMode(this._client, this._privacyMode, result) } : {},
+			$ai_latency: (Date.now() - pending.startTime) / 1e3,
+			...context.sessionId ? { $ai_session_id: context.sessionId } : {},
+			...context.agentName ? { $ai_agent_name: context.agentName } : {},
+			...error ? {
+				$ai_is_error: true,
+				$ai_error: stringifyError(error)
+			} : {}
+		});
+	}
+	async _captureLifecycleEvent(event, distinctId, properties) {
+		const message = {
+			distinctId: distinctId ?? String(properties.$ai_trace_id),
+			event,
+			properties: {
+				$ai_lib: "posthog-ai",
+				$ai_lib_version: version,
+				$ai_framework: "google-adk",
+				...properties,
+				...this._properties,
+				...distinctId ? {} : { $process_person_profile: false }
+			},
+			groups: this._groups
+		};
+		if (this._captureImmediate) await captureAiEventImmediate(this._client, message);
+		else captureAiEvent(this._client, message);
+	}
+	_resolveDistinctId(context) {
+		if (typeof this._distinctId === "function") {
+			const resolved = this._distinctId(context);
+			if (resolved) return String(resolved);
+		} else if (this._distinctId) return String(this._distinctId);
+		return context.userId ? String(context.userId) : void 0;
+	}
+	_resolveInvocationDistinctId(context) {
+		if (typeof this._distinctId === "string" && this._distinctId) return String(this._distinctId);
+		return context.userId ? String(context.userId) : void 0;
+	}
+	_rememberContext(context) {
+		const trace = this._traces.get(context.invocationId);
+		if (trace) {
+			trace.distinctId = this._resolveDistinctId(context);
+			trace.sessionId = context.sessionId || trace.sessionId;
+		}
+	}
+	_parentSpanId(context) {
+		return this._pendingAgents.get(this._pendingKey(context))?.[0]?.spanId ?? this._traces.get(context.invocationId)?.spanId;
+	}
+	_pendingKey(context) {
+		return [
+			context.invocationId,
+			context.invocationContext?.branch ?? "",
+			context.agentName
+		].join("\0");
+	}
+	_toolKey(context, toolName) {
+		return [
+			this._pendingKey(context),
+			context.functionCallId ?? "",
+			toolName
+		].join("\0");
+	}
+	_peekPending(key) {
+		return this._pending.get(key)?.[0];
+	}
+	_takePending(key) {
+		const queue = this._pending.get(key);
+		if (!queue || queue.length === 0) return;
+		const pending = queue.shift();
+		if (queue.length === 0) this._pending.delete(key);
+		return pending;
+	}
+	_takePendingAgent(key) {
+		const queue = this._pendingAgents.get(key);
+		if (!queue || queue.length === 0) return;
+		const pending = queue.shift();
+		if (queue.length === 0) this._pendingAgents.delete(key);
+		return pending;
+	}
+	_takePendingTool(key) {
+		const queue = this._pendingTools.get(key);
+		if (!queue || queue.length === 0) return;
+		const pending = queue.shift();
+		if (queue.length === 0) this._pendingTools.delete(key);
+		return pending;
+	}
+	_isNonTerminalStreamResponse(llmResponse) {
+		if (llmResponse.turnComplete === false) return true;
+		return llmResponse.partial === false && llmResponse.turnComplete !== true && llmResponse.content !== void 0 && llmResponse.finishReason === void 0 && llmResponse.errorCode === void 0;
+	}
+	_evictStalePending() {
+		const cutoff = Date.now() - MAX_PENDING_AGE_MS;
+		this._evictStaleQueueEntries(this._pending, cutoff);
+		this._evictStaleQueueEntries(this._pendingAgents, cutoff);
+		this._evictStaleQueueEntries(this._pendingTools, cutoff);
+		for (const [invocationId, trace] of this._traces) if (trace.startTime < cutoff) this._traces.delete(invocationId);
+	}
+	_evictStaleQueueEntries(queues, cutoff) {
+		for (const [key, queue] of queues) {
+			const active = queue.filter((entry) => entry.startTime >= cutoff);
+			if (active.length > 0) queues.set(key, active);
+			else queues.delete(key);
+		}
+	}
+	_clearPendingInvocation(invocationId) {
+		const prefix = `${invocationId}\0`;
+		for (const key of this._pending.keys()) if (key.startsWith(prefix)) this._pending.delete(key);
+		for (const key of this._pendingAgents.keys()) if (key.startsWith(prefix)) this._pendingAgents.delete(key);
+		for (const key of this._pendingTools.keys()) if (key.startsWith(prefix)) this._pendingTools.delete(key);
+	}
+	_formatInput(llmRequest) {
+		const contents = sanitizeGemini(llmRequest.contents, this._client) ?? [];
+		const messages = Array.isArray(contents) ? contents.map((content) => formatContent(content, this._client)) : [];
+		const systemInstruction = extractSystemInstruction(llmRequest);
+		if (systemInstruction && !messages.some((message) => message.role === "system")) return [{
+			role: "system",
+			content: systemInstruction
+		}, ...messages];
+		return messages;
+	}
+	_formatOutput(llmResponse) {
+		return formatResponseGemini({ candidates: llmResponse.content ? [{ content: llmResponse.content }] : [] }, this._client);
+	}
+	_handleError(error) {
+		try {
+			this._onError?.(error);
+		} catch {}
+	}
+};
+/** Map a genai content role to PostHog's convention (`model` -> `assistant`). */
+function mapRole(role) {
+	if (role === "model") return "assistant";
+	return role ?? "user";
+}
+function formatContent(content, client) {
+	const parts = Array.isArray(content?.parts) ? content.parts : [];
+	const blocks = [];
+	for (const part of parts) {
+		if (part == null) continue;
+		if (part.text) blocks.push({
+			type: "text",
+			text: String(part.text)
+		});
+		else if (part.functionCall) blocks.push({
+			type: "function",
+			id: part.functionCall.id,
+			function: {
+				name: part.functionCall.name,
+				arguments: part.functionCall.args ?? {}
+			}
+		});
+		else if (part.functionResponse) blocks.push({
+			type: "text",
+			text: toContentString(part.functionResponse.response ?? part.functionResponse)
+		});
+		else if (part.inlineData) blocks.push(formatInlineDataBlock(part.inlineData, client));
+	}
+	return {
+		role: mapRole(content?.role),
+		content: blocks
+	};
+}
+/** Extract the system instruction text from an LlmRequest's config, if any. */
+function extractSystemInstruction(llmRequest) {
+	const systemInstruction = llmRequest.config?.systemInstruction;
+	if (!systemInstruction) return null;
+	if (typeof systemInstruction === "string") return systemInstruction;
+	const asObject = systemInstruction;
+	if (typeof asObject.text === "string") return asObject.text;
+	const textParts = (Array.isArray(asObject.parts) ? asObject.parts : Array.isArray(systemInstruction) ? systemInstruction : []).flatMap((part) => {
+		if (typeof part === "string") return [part];
+		if (part && typeof part === "object" && typeof part.text === "string") return [part.text];
+		return [];
+	});
+	return textParts.length > 0 ? textParts.join("") : null;
+}
+const MODEL_PARAM_KEYS = [
+	"temperature",
+	"topP",
+	"topK",
+	"maxOutputTokens",
+	"candidateCount",
+	"stopSequences",
+	"presencePenalty",
+	"frequencyPenalty",
+	"seed"
+];
+function extractModelParameters(config) {
+	const params = {};
+	if (!config || typeof config !== "object") return params;
+	const source = config;
+	for (const key of MODEL_PARAM_KEYS) if (source[key] !== void 0) params[key] = source[key];
+	return params;
+}
+function extractTools(llmRequest) {
+	const tools = llmRequest.config?.tools;
+	return Array.isArray(tools) && tools.length > 0 ? tools : null;
+}
+//#endregion
+exports.PostHogADKPlugin = PostHogADKPlugin;
+
+//# sourceMappingURL=index.cjs.map