@posthog/ai 8.11.2 → 8.12.0

package/dist/claude-agent-sdk/index.cjs

@@ -0,0 +1,1142 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _anthropic_ai_claude_agent_sdk = require("@anthropic-ai/claude-agent-sdk");
+let uuid = require("uuid");
+let _posthog_core = require("@posthog/core");
+//#region package.json
+var version = "8.12.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/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();
+const sanitize = (data, client) => isFullAiCaptureEnabled(client) ? data : redactor.redact(data);
+const sanitizeAnthropic = (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 MAX_OUTPUT_SIZE = 2e5;
+const STRING_FORMAT = "utf8";
+const sharedTextEncoder = new TextEncoder();
+const sharedTextDecoder = new TextDecoder(STRING_FORMAT, { fatal: false });
+/**
+* Safely converts content to a string, preserving structure for objects/arrays.
+* - If content is already a string, returns it as-is
+* - 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 {
+		try {
+			return String(content);
+		} catch {
+			return "";
+		}
+	}
+	return String(content);
+}
+const withPrivacyMode = (client, privacyMode, input) => {
+	return client.privacy_mode || privacyMode ? null : input;
+};
+function toSafeString(input) {
+	if (input === void 0 || input === null) return "";
+	if (typeof input === "string") return input;
+	try {
+		return JSON.stringify(input);
+	} catch {
+		console.warn("Failed to stringify input", input);
+		return "";
+	}
+}
+const truncate = (input, client, maxBytes = MAX_OUTPUT_SIZE) => {
+	const str = toSafeString(input);
+	if (str === "") return "";
+	if (isFullAiCaptureEnabled(client)) return str;
+	const buffer = sharedTextEncoder.encode(str);
+	if (buffer.length <= maxBytes) return sharedTextDecoder.decode(buffer);
+	const truncatedBuffer = buffer.slice(0, maxBytes);
+	let truncatedStr = sharedTextDecoder.decode(truncatedBuffer);
+	if (truncatedStr.endsWith("�")) truncatedStr = truncatedStr.slice(0, -1);
+	return `${truncatedStr}... [truncated]`;
+};
+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 ?? {},
+			...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: 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/claude-agent-sdk/formatting.ts
+/**
+* Tool results in an agent run carry whole files and command output, and the
+* same result is replayed as input on every later turn, so each string is
+* capped before it reaches the event.
+*/
+const TOOL_RESULT_MAX_STRING_LENGTH = 5e3;
+function capStrings(value, max) {
+	if (typeof value === "string") return truncate(value, void 0, max);
+	if (Array.isArray(value)) return value.map((item) => capStrings(item, max));
+	if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, capStrings(item, max)]));
+	return value;
+}
+function formatContent(content, client, maxBytes = MAX_OUTPUT_SIZE) {
+	const redacted = sanitizeAnthropic((0, _posthog_core.toJsonSafeValue)(content), client);
+	return isFullAiCaptureEnabled(client) ? redacted : capStrings(redacted, maxBytes);
+}
+/** Read the system prompt out of the SDK options, whatever shape it takes. */
+function extractSystemPrompt(options) {
+	const systemPrompt = options?.systemPrompt;
+	if (typeof systemPrompt === "string") return systemPrompt;
+	if (Array.isArray(systemPrompt)) return systemPrompt.filter((part) => part !== _anthropic_ai_claude_agent_sdk.SYSTEM_PROMPT_DYNAMIC_BOUNDARY).join("");
+	return systemPrompt?.append;
+}
+/** Convert Anthropic assistant content blocks into PostHog content items. */
+function formatAssistantBlocks(blocks, client) {
+	if (!Array.isArray(blocks)) return [];
+	const content = [];
+	for (const block of formatContent(blocks, client)) {
+		if (block == null) continue;
+		if (typeof block.thinking === "string") content.push({
+			type: "reasoning",
+			text: block.thinking
+		});
+		else if (block.type === "tool_use") content.push({
+			type: "function",
+			id: block.id,
+			function: {
+				name: block.name,
+				arguments: block.input ?? {}
+			}
+		});
+		else if (typeof block.text === "string") content.push({
+			type: "text",
+			text: block.text
+		});
+		else content.push({
+			type: "text",
+			text: toContentString(block)
+		});
+	}
+	return content;
+}
+/** Convert an Anthropic user message body into PostHog content items. */
+function formatUserContent(content, client) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return [];
+	const formatted = [];
+	for (const block of content) {
+		if (block == null) continue;
+		if (block.type === "tool_result") formatted.push({
+			type: "tool_result",
+			tool_use_id: block.tool_use_id,
+			content: formatContent(block.content, client, TOOL_RESULT_MAX_STRING_LENGTH),
+			...typeof block.is_error === "boolean" ? { is_error: block.is_error } : {}
+		});
+		else if (typeof block.text === "string") formatted.push({
+			type: "text",
+			text: block.text
+		});
+		else formatted.push(formatContent(block, client));
+	}
+	return formatted;
+}
+//#endregion
+//#region src/claude-agent-sdk/processor.ts
+const FRAMEWORK = "claude-agent-sdk";
+const PROVIDER = "anthropic";
+/**
+* Reconstructs per-generation metrics from the Anthropic streaming protocol the
+* Agent SDK relays: every `message_start` to `message_stop` cycle is one model
+* call.
+*/
+var GenerationTracker = class {
+	constructor() {
+		this._completed = [];
+		this._sawStreamEvents = false;
+	}
+	/**
+	* Queue the input of the next model call. The first call answers the prompt,
+	* and every later one answers the tool results of the call before it.
+	*/
+	setPendingInput(input) {
+		this._pendingInput = input;
+	}
+	appendPendingInput(input) {
+		this._pendingInput = [...this._pendingInput ?? [], ...input];
+	}
+	/** The queued input, still waiting for its model call. */
+	get pendingInput() {
+		return this._pendingInput;
+	}
+	processStreamEvent(event, client, ttftMs) {
+		this._sawStreamEvents = true;
+		if (event.type === "message_start") {
+			this.retryCurrent(/* @__PURE__ */ new Error("Model stream restarted before completing"));
+			const usage = event.message.usage;
+			this._current = {
+				spanId: (0, uuid.v4)(),
+				input: this._pendingInput,
+				startTime: performance.now() - (ttftMs ?? 0),
+				timeToFirstToken: ttftMs != null ? ttftMs / 1e3 : void 0,
+				model: event.message.model,
+				usage: readUsage(usage),
+				streamedOutput: []
+			};
+			this._pendingInput = void 0;
+		} else if (event.type === "content_block_start" && this._current?.streamedOutput) this._current.streamedOutput[event.index] = formatAssistantBlocks([event.content_block], client)[0];
+		else if (event.type === "content_block_delta") {
+			const block = this._current?.streamedOutput?.[event.index];
+			if (event.delta.type === "text_delta" && block?.type === "text") block.text += event.delta.text;
+			else if (event.delta.type === "thinking_delta" && block?.type === "reasoning") block.text += event.delta.thinking;
+			else if (event.delta.type === "input_json_delta" && block?.type === "function") {
+				const previous = block.function.arguments;
+				block.function.arguments = (typeof previous === "string" ? previous : "") + event.delta.partial_json;
+			}
+		} else if (event.type === "message_delta" && this._current) {
+			const usage = event.usage;
+			this._current.usage = {
+				...this._current.usage,
+				...readUsage(usage),
+				rawUsage: {
+					...this._current.usage.rawUsage,
+					...usage
+				}
+			};
+			if (event.delta?.stop_reason != null) this._current.stopReason = event.delta.stop_reason;
+		} else if (event.type === "message_stop") this.finishCurrent();
+	}
+	finishCurrent() {
+		if (this._current) {
+			this._current.endTime = performance.now();
+			this._completed.push(this._current);
+			this._lastModel = this._current.model;
+			this._current = void 0;
+		}
+	}
+	retryCurrent(error) {
+		if (this._current) {
+			this._pendingInput = this._current.input;
+			this._current.error = error;
+			this.finishCurrent();
+		}
+	}
+	setModel(model) {
+		if (model) this._lastModel = model;
+	}
+	popCompleted() {
+		return this._completed.shift();
+	}
+	/** Span ID of the generation in progress, before its `message_stop`. */
+	get currentSpanId() {
+		return this._current?.spanId;
+	}
+	get lastModel() {
+		return this._lastModel;
+	}
+	get sawStreamEvents() {
+		return this._sawStreamEvents;
+	}
+};
+/**
+* Wraps `query()` from `@anthropic-ai/claude-agent-sdk` to capture PostHog LLM
+* analytics.
+*
+* The Agent SDK runs Claude Code itself, so no request passes through an
+* Anthropic client the `@posthog/ai` Anthropic wrapper could patch. This
+* processor reads the SDK's own message stream instead and captures:
+*
+* - `$ai_generation` for each main-agent model call, reconstructed from the streamed
+*   Anthropic events;
+* - `$ai_span` for every tool use, parented to the generation that asked for it;
+* - `$ai_trace` for every turn, carrying its latency and reported cost.
+*
+* @example
+* ```typescript
+* import { PostHogClaudeAgentProcessor } from '@posthog/ai/claude-agent-sdk'
+* import { PostHog } from 'posthog-node'
+*
+* const phClient = new PostHog('<POSTHOG_API_KEY>')
+* const processor = new PostHogClaudeAgentProcessor({ client: phClient, distinctId: 'user@example.com' })
+*
+* for await (const message of processor.query({ prompt: 'Explain this repo' })) {
+*   console.log(message)
+* }
+* ```
+*/
+var PostHogClaudeAgentProcessor = class {
+	constructor(options) {
+		this._client = options.client;
+		this._traceOptions = options;
+		this._captureImmediate = options.captureImmediate ?? false;
+		this._onError = options.onError;
+	}
+	/**
+	* Drop-in replacement for `query()` from the Claude Agent SDK. Hidden partial
+	* messages pass their reply correlation to the first assistant message.
+	* Other messages and the control methods (`interrupt`,
+	* `setPermissionMode`, …) retain the SDK behavior.
+	*/
+	query({ prompt, options, posthog }) {
+		const trace = {
+			...this._traceOptions,
+			...posthog,
+			privacyMode: this._traceOptions.privacyMode === true || posthog?.privacyMode === true,
+			properties: {
+				...this._traceOptions.properties,
+				...posthog?.properties
+			}
+		};
+		for (const key of [
+			"$ai_trace_id",
+			"$ai_span_id",
+			"$ai_parent_id",
+			"$ai_session_id"
+		]) delete trace.properties?.[key];
+		const forwardStreamEvents = options?.includePartialMessages === true;
+		const state = this._createState(prompt, options, trace);
+		const inner = (0, _anthropic_ai_claude_agent_sdk.query)({
+			prompt: typeof prompt === "string" ? prompt : this._observePrompt(prompt, state),
+			options: {
+				...options,
+				includePartialMessages: true
+			}
+		});
+		const instrumented = this._instrument(inner, state, trace, forwardStreamEvents);
+		const iteration = {
+			next: instrumented.next.bind(instrumented),
+			streamInput: (stream) => inner.streamInput(this._observePrompt(stream, state)),
+			return: async (value) => {
+				try {
+					return await inner.return(value);
+				} finally {
+					await instrumented.return();
+				}
+			},
+			throw: async (error) => {
+				state.failure = error;
+				try {
+					return await inner.throw(error);
+				} finally {
+					await instrumented.return();
+				}
+			},
+			close: () => {
+				try {
+					inner.close();
+				} finally {
+					instrumented.return().catch((error) => this._handleError(error));
+				}
+			},
+			[Symbol.asyncDispose]: async () => {
+				try {
+					const dispose = Reflect.get(inner, Symbol.asyncDispose);
+					if (typeof dispose === "function") await dispose.call(inner);
+					else await inner.return();
+				} finally {
+					await instrumented.return();
+				}
+			},
+			[Symbol.asyncIterator]: () => wrapper
+		};
+		const wrapper = new Proxy(inner, { get(target, property) {
+			if (Object.hasOwn(iteration, property)) return iteration[property];
+			const value = Reflect.get(target, property, target);
+			return typeof value === "function" && property !== "constructor" ? value.bind(target) : value;
+		} });
+		return wrapper;
+	}
+	async *_instrument(inner, state, trace, forwardStreamEvents) {
+		try {
+			for await (const message of inner) {
+				try {
+					await this._handleMessage(message, state, trace);
+				} catch (error) {
+					this._handleError(error);
+				}
+				if (message.type !== "stream_event" || forwardStreamEvents) {
+					if (!forwardStreamEvents && message.type === "assistant" && !message.parent_tool_use_id && state.userMessageUuid) {
+						const userMessageUuid = state.userMessageUuid;
+						state.userMessageUuid = void 0;
+						yield {
+							...message,
+							user_message_uuid: message.user_message_uuid ?? userMessageUuid
+						};
+					} else yield message;
+				}
+			}
+		} catch (error) {
+			state.failure = error;
+			throw error;
+		} finally {
+			const failure = state.failure;
+			if (state.turnActive || state.turnCaptured || failure !== void 0 && !state.hasCapturedTrace) {
+				try {
+					state.tracker.finishCurrent();
+					await this._captureCompletedGenerations(state, trace, failure);
+					if (!state.tracker.sawStreamEvents && state.pendingOutput.length > 0) {
+						state.generationIndex += 1;
+						await this._captureGeneration({
+							spanId: (0, uuid.v4)(),
+							input: state.tracker.pendingInput,
+							startTime: state.turnStart,
+							endTime: performance.now(),
+							usage: {},
+							error: failure
+						}, state, trace);
+					}
+				} catch (error) {
+					this._handleError(error);
+				}
+				try {
+					await this._captureTrace(state, trace, void 0, failure);
+				} catch (error) {
+					this._handleError(error);
+				}
+			}
+		}
+	}
+	_createState(prompt, options, trace) {
+		const initialInput = [];
+		const systemPrompt = extractSystemPrompt(options);
+		if (systemPrompt) initialInput.push({
+			role: "system",
+			content: systemPrompt
+		});
+		const tracker = new GenerationTracker();
+		tracker.setPendingInput(initialInput.length > 0 ? initialInput : void 0);
+		return {
+			tracker,
+			systemPrompt,
+			pendingCaptures: [],
+			pendingTools: /* @__PURE__ */ new Map(),
+			traceId: trace.traceId ?? (0, uuid.v4)(),
+			turnStart: performance.now(),
+			turnCaptured: false,
+			turnActive: false,
+			hasCapturedTrace: false,
+			pendingPrompts: typeof prompt === "string" ? [{
+				type: "user",
+				message: {
+					role: "user",
+					content: prompt
+				},
+				parent_tool_use_id: null
+			}] : [],
+			generationIndex: 0,
+			pendingOutput: [],
+			totalCost: 0
+		};
+	}
+	async *_observePrompt(prompt, state) {
+		for await (const message of prompt) {
+			state.pendingPrompts.push(message);
+			yield message;
+		}
+	}
+	_beginTurn(state, userMessageUuid) {
+		if (state.turnActive) return;
+		state.turnActive = true;
+		let end = userMessageUuid ? state.pendingPrompts.findIndex((message) => message.uuid === userMessageUuid) : -1;
+		if (end < 0) {
+			const candidates = state.pendingPrompts.filter((message) => message.shouldQuery !== false);
+			if (candidates.length !== 1 || userMessageUuid && candidates[0].uuid) return;
+			end = state.pendingPrompts.indexOf(candidates[0]);
+		}
+		if (end < 0) return;
+		let start = end;
+		while (start > 0 && state.pendingPrompts[start - 1].shouldQuery === false) start -= 1;
+		for (const message of state.pendingPrompts.splice(start, end - start + 1)) state.tracker.appendPendingInput([{
+			role: "user",
+			content: formatUserContent(message.message.content, this._client)
+		}]);
+	}
+	async _handleMessage(message, state, trace) {
+		if ("session_id" in message && message.session_id) state.sessionId = message.session_id;
+		if (message.type === "conversation_reset") state.totalCost = 0;
+		else if (message.type === "system" && message.subtype === "api_retry") {
+			state.tracker.retryCurrent(Object.assign(new Error(message.error), { status: message.error_status }));
+			await this._captureCompletedGenerations(state, trace);
+		} else if (message.type === "stream_event") {
+			if (message.parent_tool_use_id) return;
+			if (message.user_message_uuid) state.userMessageUuid = message.user_message_uuid;
+			if (message.event.type === "message_start") this._beginTurn(state, message.user_message_uuid);
+			state.tracker.processStreamEvent(message.event, this._client, message.ttft_ms);
+			await this._captureCompletedGenerations(state, trace);
+		} else if (message.type === "assistant") {
+			if (!message.parent_tool_use_id) this._beginTurn(state, message.user_message_uuid);
+			this._handleAssistantMessage(message, state, trace);
+		} else if (message.type === "user") {
+			if ("isReplay" in message && message.isReplay) return;
+			if (Array.isArray(message.message.content)) {
+				for (const block of message.message.content) if (block.type === "tool_result") await this._finishToolSpan(block.tool_use_id, state, trace, block);
+			}
+			if (message.parent_tool_use_id) return;
+			const content = formatUserContent(message.message?.content, this._client);
+			if (typeof content === "string" || Array.isArray(content) && content.length > 0) state.tracker.appendPendingInput([{
+				role: "user",
+				content
+			}]);
+		} else if (message.type === "result") try {
+			this._beginTurn(state, message.user_message_uuid);
+			state.tracker.finishCurrent();
+			await this._captureCompletedGenerations(state, trace, resultError(message), message);
+			if (message.total_cost_usd != null) {
+				state.turnCost = message.total_cost_usd - (message.total_cost_usd >= state.totalCost ? state.totalCost : 0);
+				state.totalCost = message.total_cost_usd;
+			}
+			if (!state.tracker.sawStreamEvents) await this._captureGenerationFromResult(message, state, trace);
+		} finally {
+			await this._captureTrace(state, trace, message);
+		}
+	}
+	async _captureCompletedGenerations(state, trace, failure, result) {
+		let generation = state.tracker.popCompleted();
+		while (generation) {
+			generation.error ??= failure;
+			state.generationIndex += 1;
+			state.lastGenerationSpanId = generation.spanId;
+			state.turnCaptured = true;
+			await this._captureGeneration(generation, state, trace, {}, result);
+			state.pendingOutput = [];
+			generation = state.tracker.popCompleted();
+		}
+	}
+	_handleAssistantMessage(message, state, trace) {
+		if (!message.parent_tool_use_id) state.tracker.setModel(message.message?.model);
+		const parentSpanId = message.parent_tool_use_id ?? state.tracker.currentSpanId ?? state.lastGenerationSpanId;
+		const blocks = Array.isArray(message.message?.content) ? message.message.content : [];
+		for (const block of blocks) if (block?.type === "tool_use") {
+			state.turnCaptured = true;
+			this._startToolSpan(block, state, trace, parentSpanId);
+		}
+		if (!message.parent_tool_use_id) state.pendingOutput.push(...formatAssistantBlocks(message.message?.content, this._client));
+	}
+	async _captureGeneration(generation, state, trace, extraProperties = {}, result) {
+		const options = {
+			traceId: state.traceId,
+			model: generation.model ?? state.tracker.lastModel,
+			provider: PROVIDER,
+			baseURL: null,
+			httpStatus: result?.subtype === "success" ? result.api_error_status ?? void 0 : void 0,
+			error: generation.error,
+			input: generation.input ?? [],
+			output: formatContent(formatOutput([...state.pendingOutput, ...generation.streamedOutput?.slice(state.pendingOutput.length).filter(Boolean) ?? []]), this._client),
+			latency: generation.endTime != null ? (generation.endTime - generation.startTime) / 1e3 : void 0,
+			timeToFirstToken: generation.timeToFirstToken,
+			usage: generation.usage,
+			stopReason: generation.stopReason,
+			groups: trace.groups,
+			privacyMode: trace.privacyMode ?? false,
+			captureImmediate: this._captureImmediate,
+			onError: this._onError,
+			properties: {
+				$ai_framework: FRAMEWORK,
+				$ai_span_id: generation.spanId,
+				$ai_span_name: `generation_${state.generationIndex}`,
+				...state.sessionId ? { $ai_session_id: state.sessionId } : {},
+				...extraProperties,
+				...trace.properties
+			}
+		};
+		await this._withDistinctId(state, trace, (distinctId) => captureAiGeneration(this._client, {
+			...options,
+			distinctId
+		}));
+	}
+	/**
+	* Without partial messages there is no per-call metric, so the aggregate the
+	* result message reports becomes one generation.
+	*/
+	async _captureGenerationFromResult(result, state, trace) {
+		state.generationIndex += 1;
+		const endTime = performance.now();
+		const generation = {
+			spanId: (0, uuid.v4)(),
+			input: state.tracker.pendingInput ?? [],
+			startTime: endTime - (result.duration_api_ms ?? 0),
+			endTime,
+			usage: readUsage(result.usage),
+			stopReason: result.stop_reason ?? void 0,
+			error: resultError(result)
+		};
+		await this._captureGeneration(generation, state, trace, { ...state.turnCost != null ? { $ai_total_cost_usd: state.turnCost } : {} }, result);
+	}
+	_startToolSpan(block, state, trace, parentSpanId) {
+		const properties = {
+			$ai_span_id: block.id ?? (0, uuid.v4)(),
+			...parentSpanId ? { $ai_parent_id: parentSpanId } : {},
+			$ai_span_name: block.name,
+			$ai_span_type: "tool",
+			$ai_input_state: withPrivacyMode(this._client, trace.privacyMode ?? false, formatContent(block.input ?? {}, this._client))
+		};
+		state.pendingTools.set(properties.$ai_span_id, {
+			startTime: performance.now(),
+			properties
+		});
+	}
+	async _finishToolSpan(id, state, trace, result) {
+		const tool = state.pendingTools.get(id);
+		if (!tool) return;
+		state.pendingTools.delete(id);
+		const properties = {
+			...tool.properties,
+			$ai_latency: (performance.now() - tool.startTime) / 1e3,
+			...result ? {
+				$ai_output_state: withPrivacyMode(this._client, trace.privacyMode ?? false, formatContent(result.content, this._client)),
+				$ai_is_error: result.is_error === true
+			} : {}
+		};
+		await this._withDistinctId(state, trace, (distinctId) => this._captureLifecycleEvent("$ai_span", distinctId, state, trace, properties));
+	}
+	async _withDistinctId(state, trace, capture) {
+		if (typeof trace.distinctId === "function") state.pendingCaptures.push(capture);
+		else await capture(resolveDistinctId(trace.distinctId));
+	}
+	async _captureTrace(state, trace, result, failure) {
+		try {
+			const latency = result?.duration_ms != null ? result.duration_ms / 1e3 : (performance.now() - state.turnStart) / 1e3;
+			const isError = failure !== void 0 || result?.is_error === true;
+			const error = failure ?? (result && resultError(result));
+			for (const id of state.pendingTools.keys()) await this._finishToolSpan(id, state, trace);
+			let distinctId;
+			try {
+				distinctId = resolveDistinctId(trace.distinctId, result);
+			} catch (error) {
+				this._handleError(error);
+			}
+			for (const capture of state.pendingCaptures.splice(0)) try {
+				await capture(distinctId);
+			} catch (error) {
+				this._handleError(error);
+			}
+			await this._captureLifecycleEvent("$ai_trace", distinctId, state, trace, {
+				$ai_trace_name: "claude_agent_sdk_query",
+				$ai_latency: latency,
+				...state.turnCost != null ? { $ai_total_cost_usd: state.turnCost } : {},
+				...isError ? { $ai_is_error: true } : {},
+				...error !== void 0 ? { $ai_error: stringifyError(error) } : {},
+				...result?.subtype === "success" && result.api_error_status != null ? { $ai_http_status: result.api_error_status } : {}
+			});
+		} finally {
+			state.hasCapturedTrace = true;
+			state.traceId = trace.traceId ?? (0, uuid.v4)();
+			state.turnStart = performance.now();
+			state.turnCaptured = false;
+			state.turnActive = false;
+			state.userMessageUuid = void 0;
+			state.failure = void 0;
+			state.generationIndex = 0;
+			state.lastGenerationSpanId = void 0;
+			state.turnCost = void 0;
+			state.pendingCaptures = [];
+			state.pendingTools.clear();
+			if (result?.queued_turn_count === 0) state.pendingPrompts = state.pendingPrompts.filter((message) => message.shouldQuery === false);
+			state.tracker = new GenerationTracker();
+			if (state.systemPrompt) state.tracker.setPendingInput([{
+				role: "system",
+				content: state.systemPrompt
+			}]);
+			state.pendingOutput = [];
+		}
+	}
+	async _captureLifecycleEvent(event, distinctId, state, trace, properties) {
+		const message = {
+			distinctId: distinctId ?? state.traceId,
+			event,
+			properties: {
+				$ai_lib: "posthog-ai",
+				$ai_lib_version: version,
+				$ai_framework: FRAMEWORK,
+				$ai_provider: PROVIDER,
+				$ai_trace_id: state.traceId,
+				...state.sessionId ? { $ai_session_id: state.sessionId } : {},
+				...properties,
+				...trace.properties,
+				...distinctId ? {} : { $process_person_profile: false }
+			},
+			groups: trace.groups
+		};
+		try {
+			if (this._captureImmediate) await captureAiEventImmediate(this._client, message);
+			else captureAiEvent(this._client, message);
+		} catch (error) {
+			this._handleError(error);
+		}
+	}
+	_handleError(error) {
+		try {
+			this._onError?.(error);
+		} catch {}
+	}
+};
+function formatOutput(content) {
+	return content.length > 0 ? [{
+		role: "assistant",
+		content
+	}] : [];
+}
+function resultError(result) {
+	if (!result.is_error) return;
+	return (result.subtype === "success" ? result.result : result.errors.join("\n")) || result.subtype;
+}
+function readUsage(usage) {
+	return {
+		...usage && Object.keys(usage).length > 0 ? { rawUsage: { ...usage } } : {},
+		...usage?.input_tokens != null ? { inputTokens: usage.input_tokens } : {},
+		...usage?.output_tokens != null ? { outputTokens: usage.output_tokens } : {},
+		...usage?.cache_read_input_tokens != null ? { cacheReadInputTokens: usage.cache_read_input_tokens } : {},
+		...usage?.cache_creation_input_tokens != null ? { cacheCreationInputTokens: usage.cache_creation_input_tokens } : {},
+		...usage?.server_tool_use?.web_search_requests != null ? { webSearchCount: usage.server_tool_use.web_search_requests } : {}
+	};
+}
+function resolveDistinctId(resolver, result) {
+	if (typeof resolver === "function") {
+		if (!result) return;
+		const resolved = resolver(result);
+		return resolved ? String(resolved) : void 0;
+	}
+	return resolver ? String(resolver) : void 0;
+}
+//#endregion
+//#region src/claude-agent-sdk/index.ts
+/**
+* Create a PostHog-instrumented `query()` for the Claude Agent SDK.
+*
+* @param options - Configuration options
+* @returns A processor whose `query()` method replaces `query()` from the SDK
+*
+* @example
+* ```typescript
+* import { instrument } from '@posthog/ai/claude-agent-sdk'
+* import { PostHog } from 'posthog-node'
+*
+* const phClient = new PostHog('<POSTHOG_API_KEY>')
+* const claude = instrument({ client: phClient, distinctId: 'user@example.com' })
+*
+* for await (const message of claude.query({ prompt: 'Explain this repo' })) {
+*   console.log(message)
+* }
+* ```
+*/
+function instrument(options) {
+	return new PostHogClaudeAgentProcessor(options);
+}
+/**
+* Drop-in replacement for `query()` from the Claude Agent SDK, for a single
+* query. Use {@link instrument} to share one configuration across queries.
+*
+* @example
+* ```typescript
+* import { query } from '@posthog/ai/claude-agent-sdk'
+* import { PostHog } from 'posthog-node'
+*
+* const phClient = new PostHog('<POSTHOG_API_KEY>')
+*
+* for await (const message of query({
+*   prompt: 'Explain this repo',
+*   posthog: { client: phClient, distinctId: 'user@example.com' },
+* })) {
+*   console.log(message)
+* }
+* ```
+*/
+function query(params) {
+	const { prompt, options, posthog } = params;
+	return new PostHogClaudeAgentProcessor(posthog).query({
+		prompt,
+		options
+	});
+}
+//#endregion
+exports.PostHogClaudeAgentProcessor = PostHogClaudeAgentProcessor;
+exports.instrument = instrument;
+exports.query = query;
+
+//# sourceMappingURL=index.cjs.map