@posthog/ai 8.14.5 → 8.15.0

package/dist/gemini/index.d.ts

@@ -22,6 +22,33 @@ interface CostOverride {
   outputCost: number;
 }
 //#endregion
+//#region src/gemini/interactions.d.ts
+type Create = GoogleGenAI['interactions']['create'];
+type CreateParams = Parameters<Create>[0];
+type ForegroundParams = CreateParams & {
+  model: string;
+  agent?: never;
+  background?: false;
+};
+type CreateOptions = Parameters<Create>[1];
+type CreateResult = Awaited<ReturnType<Create>>;
+type Interaction = Exclude<CreateResult, AsyncIterable<unknown>>;
+type InteractionStream = Extract<CreateResult, AsyncIterable<unknown>>;
+type InteractionEvent = InteractionStream extends AsyncIterable<infer Event> ? Event : never;
+declare class WrappedInteractions {
+  private readonly client;
+  private readonly phClient;
+  constructor(client: GoogleGenAI, phClient: PostHog);
+  create(params: ForegroundParams & MonitoringParams & {
+    stream: true;
+  }, options?: CreateOptions): Promise<ReadableStream<InteractionEvent> & AsyncIterable<InteractionEvent>>;
+  create(params: ForegroundParams & MonitoringParams & {
+    stream?: false;
+  }, options?: CreateOptions): Promise<Interaction>;
+  create(params: ForegroundParams & MonitoringParams, options?: CreateOptions): Promise<Interaction | (ReadableStream<InteractionEvent> & AsyncIterable<InteractionEvent>)>;
+  private wrapStream;
+}
+//#endregion
 //#region src/gemini/index.d.ts
 interface MonitoringGeminiConfig extends GoogleGenAIOptions {
   posthog: PostHog;
@@ -30,6 +57,7 @@ declare class PostHogGoogleGenAI {
   private readonly phClient;
   private readonly client;
   models: WrappedModels;
+  interactions: WrappedInteractions;
   constructor(config: MonitoringGeminiConfig);
 }
 declare class WrappedModels {

package/dist/gemini/index.mjs

@@ -92,6 +92,12 @@ const FILE_FAMILY_TYPES = /* @__PURE__ */ new Set([
 	"media",
 	"file-data"
 ]);
+const TYPED_BINARY_DATA_TYPES = /* @__PURE__ */ new Set([
+	"image",
+	"audio",
+	"video",
+	"document"
+]);
 const KNOWN_AUDIO_FORMATS = /* @__PURE__ */ new Set([
 	"wav",
 	"mp3",
@@ -143,7 +149,8 @@ var MediaTypeContext = class MediaTypeContext {
 		if (key.includes("image")) return "image";
 		if (key.includes("file") || key.includes("document")) return "application/octet-stream";
 	}
-	hasExplicitBinaryMediaType() {
+	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/");
@@ -197,9 +204,9 @@ var BinaryContentRedactor = class {
 		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 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);
@@ -452,7 +459,7 @@ function addDefaults(params) {
 }
 //#endregion
 //#region package.json
-var version = "8.14.5";
+var version = "8.15.0";
 //#endregion
 //#region src/serializeError.ts
 const DEFAULT_MAX_DEPTH = 3;
@@ -718,6 +725,370 @@ function mapGeminiUsage(metadata, additionalUsage = {}) {
 	};
 }
 //#endregion
+//#region src/gemini/interactions.ts
+function record(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function string(value) {
+	return typeof value === "string" ? value : void 0;
+}
+function number(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function isStream(value) {
+	return value !== null && typeof value === "object" && Symbol.asyncIterator in value;
+}
+function usageFromInteraction(value, model) {
+	const usage = record(value);
+	if (!usage) return {};
+	const cached = number(usage.total_cached_tokens);
+	const searches = Array.isArray(usage.grounding_tool_count) ? usage.grounding_tool_count.reduce((total, entry) => {
+		const grounding = record(entry);
+		return total + (grounding?.type === "google_search" ? number(grounding.count) ?? 0 : 0);
+	}, 0) : void 0;
+	const modelMajor = /^(?:models\/)?gemini-(\d+)/.exec(model ?? "")?.[1];
+	const webSearchCount = modelMajor === void 0 ? void 0 : Number(modelMajor) >= 3 ? searches : searches ? 1 : 0;
+	return {
+		inputTokens: number(usage.total_input_tokens),
+		outputTokens: number(usage.total_output_tokens),
+		reasoningTokens: number(usage.total_thought_tokens),
+		cacheReadInputTokens: cached,
+		...cached !== void 0 ? { cacheReportingExclusive: false } : {},
+		webSearchCount,
+		rawUsage: usage
+	};
+}
+function functionArguments(value) {
+	if (typeof value !== "string") return record(value) ?? {};
+	try {
+		return record(JSON.parse(value)) ?? value;
+	} catch {
+		return value;
+	}
+}
+function outputFromSteps(steps, fallbackText) {
+	const content = [];
+	if (Array.isArray(steps)) for (const rawStep of steps) {
+		const step = record(rawStep);
+		if (step?.type === "model_output" && Array.isArray(step.content)) content.push(...step.content);
+		else if (step?.type === "function_call" && string(step.name)) content.push({
+			type: "function",
+			id: string(step.id),
+			function: {
+				name: step.name,
+				arguments: functionArguments(step.arguments)
+			}
+		});
+	}
+	if (content.length === 0 && fallbackText) content.push({
+		type: "text",
+		text: fallbackText
+	});
+	return content.length ? [{
+		role: "assistant",
+		content
+	}] : [];
+}
+function inputFromRequest(input, systemInstruction) {
+	const messages = [];
+	if (typeof systemInstruction === "string") messages.push({
+		role: "system",
+		content: systemInstruction
+	});
+	let userContent = [];
+	const flushUserContent = () => {
+		if (userContent.length) messages.push({
+			role: "user",
+			content: userContent
+		});
+		userContent = [];
+	};
+	for (const part of Array.isArray(input) ? input : [input]) {
+		const step = record(part);
+		if (step?.type === "text" || step?.type === "image" || step?.type === "audio" || step?.type === "video" || step?.type === "document") {
+			userContent.push(part);
+			continue;
+		}
+		flushUserContent();
+		if (step?.type === "function_result") messages.push({
+			role: "tool",
+			content: [{
+				type: "tool_result",
+				tool_use_id: step.call_id,
+				content: step.result
+			}]
+		});
+		else if (step?.type === "user_input") messages.push({
+			role: "user",
+			content: step.content ?? [part]
+		});
+		else if (step?.type === "model_output") messages.push({
+			role: "assistant",
+			content: step.content ?? [part]
+		});
+		else if (step?.type === "function_call") {
+			const output = outputFromSteps([part]);
+			messages.push(...output.length ? output : [{
+				role: "assistant",
+				content: [part]
+			}]);
+		} else messages.push({
+			role: "user",
+			content: part
+		});
+	}
+	flushUserContent();
+	return messages;
+}
+function safeTools(tools) {
+	if (!Array.isArray(tools)) return void 0;
+	return tools.map((tool) => ({
+		type: string(record(tool)?.type),
+		name: string(record(tool)?.name)
+	}));
+}
+function isFailure(status) {
+	return status === "failed" || status === "cancelled" || status === "incomplete" || status === "budget_exceeded";
+}
+var WrappedInteractions = class {
+	constructor(client, phClient) {
+		this.client = client;
+		this.phClient = phClient;
+	}
+	async create(params, options) {
+		const { providerParams, posthogParams } = extractPosthogParams(params);
+		const request = providerParams;
+		const requestData = record(request) ?? {};
+		if (requestData.background === true || typeof requestData.model !== "string" || requestData.agent !== void 0) throw new Error("Gemini Interactions tracing supports foreground model calls only");
+		const startTime = Date.now();
+		const capture = async (interaction, error, output, firstTokenTime) => {
+			try {
+				const privateCapture = withPrivacyMode(this.phClient, posthogParams.privacyMode, false) === null;
+				const model = string(interaction?.model) ?? string(requestData.model);
+				const generationConfig = record(requestData.generation_config);
+				const modelParameters = privateCapture ? {} : {
+					...number(generationConfig?.max_output_tokens) !== void 0 ? { max_tokens: generationConfig?.max_output_tokens } : {},
+					...string(generationConfig?.thinking_level) !== void 0 ? { thinking_level: generationConfig?.thinking_level } : {}
+				};
+				await captureAiGeneration(this.phClient, {
+					...posthogParams,
+					model,
+					provider: "gemini",
+					input: privateCapture ? null : inputFromRequest(sanitizeGemini(requestData.input, this.phClient), sanitizeGemini(requestData.system_instruction, this.phClient)),
+					output: privateCapture ? null : sanitizeGemini(output ?? outputFromSteps(interaction?.steps, string(interaction?.output_text)), this.phClient),
+					latency: (Date.now() - startTime) / 1e3,
+					timeToFirstToken: firstTokenTime === void 0 ? void 0 : (firstTokenTime - startTime) / 1e3,
+					baseURL: "https://generativelanguage.googleapis.com",
+					modelParameters,
+					completionId: string(interaction?.id),
+					stopReason: string(interaction?.status),
+					servedServiceTier: string(interaction?.service_tier),
+					usage: usageFromInteraction(interaction?.usage, model),
+					tools: privateCapture ? void 0 : safeTools(requestData.tools),
+					error: privateCapture && error ? /* @__PURE__ */ new Error("Gemini interaction failed") : error
+				});
+			} catch {}
+		};
+		try {
+			if (!this.client.interactions?.create) throw new Error("Gemini Interactions requires @google/genai 2.18.0 or newer");
+			const result = await (options === void 0 ? this.client.interactions.create(request) : this.client.interactions.create(request, options));
+			if (requestData.stream === true) {
+				if (!isStream(result)) throw new Error("Gemini Interactions did not return a stream");
+				return this.wrapStream(result, capture);
+			}
+			if (isStream(result)) throw new Error("Gemini Interactions returned an unexpected stream");
+			const interaction = record(result);
+			let unsupportedSchema = false;
+			try {
+				unsupportedSchema = Array.isArray(interaction?.outputs) && !Array.isArray(interaction?.steps);
+			} catch {
+				return result;
+			}
+			if (unsupportedSchema) throw new Error("Gemini Interactions GA schema requires @google/genai 2.18.0 or newer");
+			try {
+				const status = interaction?.status;
+				if (status !== "queued" && status !== "in_progress") await capture(interaction, isFailure(status) ? /* @__PURE__ */ new Error(`Gemini interaction ${status}`) : void 0);
+			} catch {}
+			return result;
+		} catch (error) {
+			await capture(void 0, error);
+			throw error;
+		}
+	}
+	wrapStream(stream, capture) {
+		const reader = "getReader" in stream && typeof stream.getReader === "function" ? stream.getReader() : void 0;
+		const iterator = reader ? void 0 : stream[Symbol.asyncIterator]();
+		let readerReleased = false;
+		let errorIterator;
+		let readError;
+		const next = async () => {
+			if (!reader) return iterator.next();
+			try {
+				return await reader.read();
+			} catch (providerError) {
+				if (closed) throw providerError;
+				readError = providerError;
+				release();
+				try {
+					errorIterator = stream[Symbol.asyncIterator]();
+				} catch {
+					throw providerError;
+				}
+				try {
+					await errorIterator.next();
+				} finally {
+					try {
+						await errorIterator.return?.();
+					} catch {}
+				}
+				throw providerError;
+			}
+		};
+		const cancelSource = async (reason) => {
+			if (reader && !readerReleased) await reader.cancel(reason);
+			else if (reader) {
+				try {
+					await errorIterator?.return?.();
+				} catch {}
+				throw readError;
+			} else await iterator?.return?.();
+		};
+		const release = () => {
+			if (readerReleased) return;
+			try {
+				reader?.releaseLock();
+				readerReleased = true;
+			} catch {}
+		};
+		let interaction;
+		let latestUsage;
+		let finalUsage;
+		let error;
+		let firstTokenTime;
+		const steps = /* @__PURE__ */ new Map();
+		let completed = false;
+		let closed = false;
+		let cancelled = false;
+		let captured = false;
+		const observe = (event) => {
+			let schemaError;
+			try {
+				const item = record(event);
+				const eventType = item?.event_type;
+				if (eventType === "interaction.start" || eventType === "interaction.complete" || eventType === "interaction.delta" || typeof eventType === "string" && eventType.startsWith("content.")) schemaError = /* @__PURE__ */ new Error("Gemini Interactions GA schema requires @google/genai 2.18.0 or newer");
+				else {
+					const usage = record(record(item?.metadata)?.total_usage) ?? (eventType === "step.stop" ? record(item?.usage) : void 0);
+					if (usage) latestUsage = { ...usage };
+					if (eventType === "interaction.created") {
+						interaction = { ...record(item?.interaction) };
+						const initialUsage = record(interaction.usage);
+						if (initialUsage) latestUsage = { ...initialUsage };
+					} else if (eventType === "step.start") {
+						const index = number(item?.index);
+						const step = record(item?.step);
+						if (index !== void 0) steps.set(index, {
+							...step,
+							content: Array.isArray(step?.content) ? step.content.map((item) => ({ ...record(item) })) : []
+						});
+					} else if (eventType === "step.delta") {
+						const index = number(item?.index);
+						const delta = record(item?.delta);
+						const step = index === void 0 ? void 0 : steps.get(index);
+						if (step && delta?.type === "text" && typeof delta.text === "string") {
+							const last = step.content?.at(-1);
+							const text = record(last);
+							if (text?.type === "text") text.text = `${text.text ?? ""}${delta.text}`;
+							else step.content?.push({
+								type: "text",
+								text: delta.text
+							});
+							firstTokenTime ??= Date.now();
+						} else if (step && (delta?.type === "image" || delta?.type === "audio" || delta?.type === "video" || delta?.type === "document")) {
+							step.content?.push({ ...delta });
+							firstTokenTime ??= Date.now();
+						} else if (step && delta?.type === "arguments_delta" && typeof delta.arguments === "string") {
+							step.argumentChunks = `${step.argumentChunks ?? ""}${delta.arguments}`;
+							firstTokenTime ??= Date.now();
+						}
+					} else if (eventType === "interaction.completed") {
+						const result = record(item?.interaction);
+						interaction = {
+							...interaction,
+							...result
+						};
+						completed = interaction.status !== "queued" && interaction.status !== "in_progress";
+						const reportedUsage = record(result?.usage);
+						if (reportedUsage) {
+							latestUsage = { ...reportedUsage };
+							if (completed) finalUsage = latestUsage;
+						}
+						if (isFailure(interaction.status)) error = /* @__PURE__ */ new Error(`Gemini interaction ${interaction.status}`);
+						if (!completed) error = /* @__PURE__ */ new Error("Gemini interaction stream ended without a terminal result");
+					} else if (eventType === "error") error = /* @__PURE__ */ new Error("Gemini interaction stream failed");
+				}
+			} catch {}
+			if (schemaError) throw schemaError;
+		};
+		const finish = async (status, providerError) => {
+			if (captured) return;
+			captured = true;
+			try {
+				const streamedSteps = [...steps.entries()].sort(([left], [right]) => left - right).map(([, step]) => ({
+					...step,
+					arguments: step.argumentChunks === void 0 ? step.arguments : functionArguments(step.argumentChunks)
+				}));
+				const output = outputFromSteps(Array.isArray(interaction?.steps) && interaction.steps.length > 0 ? interaction.steps : streamedSteps);
+				await capture({
+					...interaction,
+					usage: finalUsage ?? latestUsage,
+					...completed ? {} : { status }
+				}, providerError ?? error ?? (!completed && status === "incomplete" ? /* @__PURE__ */ new Error("Gemini interaction stream ended without completion") : void 0), output, firstTokenTime);
+			} catch {}
+		};
+		return new ReadableStream({
+			async pull(controller) {
+				try {
+					const result = await next();
+					if (closed) return;
+					if (result.done) {
+						closed = true;
+						await finish("incomplete");
+						release();
+						if (!cancelled) controller.close();
+					} else {
+						observe(result.value);
+						controller.enqueue(result.value);
+					}
+				} catch (providerError) {
+					if (closed) return;
+					closed = true;
+					try {
+						await cancelSource(providerError);
+					} catch {}
+					await finish("failed", providerError);
+					release();
+					if (!cancelled) controller.error(providerError);
+				}
+			},
+			async cancel(reason) {
+				cancelled = true;
+				if (closed) return;
+				closed = true;
+				let cancellationError;
+				try {
+					await cancelSource(reason);
+				} catch (providerError) {
+					cancellationError = providerError;
+					throw providerError;
+				} finally {
+					await finish("cancelled", cancellationError);
+					release();
+				}
+			}
+		});
+	}
+};
+//#endregion
 //#region src/gemini/index.ts
 /** Append streamed text to the last block of the same type, or start a new one. */
 function appendStreamedText(content, type, text) {
@@ -746,6 +1117,7 @@ var PostHogGoogleGenAI = class {
 		this.phClient = posthog;
 		this.client = new GoogleGenAI(geminiConfig);
 		this.models = new WrappedModels(this.client, this.phClient);
+		this.interactions = new WrappedInteractions(this.client, this.phClient);
 	}
 };
 var WrappedModels = class {