@posthog/ai 8.10.0 → 8.10.2

package/dist/anthropic/index.cjs

@@ -1,1179 +1,995 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var AnthropicOriginal = require('@anthropic-ai/sdk');
-var uuid = require('uuid');
-var core = require('@posthog/core');
-var streaming = require('@anthropic-ai/sdk/streaming');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var AnthropicOriginal__default = /*#__PURE__*/_interopDefault(AnthropicOriginal);
-
-/** @internal */
-
-/** @internal */
-
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let _anthropic_ai_sdk = require("@anthropic-ai/sdk");
+_anthropic_ai_sdk = __toESM(_anthropic_ai_sdk);
+let uuid = require("uuid");
+let _posthog_core = require("@posthog/core");
+let _anthropic_ai_sdk_streaming = require("@anthropic-ai/sdk/streaming");
+//#region src/captureAiEvent.ts
 /** @internal */
 function isFullAiCaptureEnabled(client) {
-  return client?.enableFullAiCapture === true;
+	return client?.enableFullAiCapture === true;
 }
-
 /** @internal */
 function captureAiEvent(client, event) {
-  if (isFullAiCaptureEnabled(client) && typeof client.captureAi === 'function') {
-    client.captureAi(event);
-    return;
-  }
-  client.capture(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);
+	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+/_=-]+$/;
-class Base64Recognizer {
-  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'
-      };
-    }
-  }
-}
-
-const MIME_HINT_KEYS = ['mediaType', 'media_type', 'mimeType', 'mime_type'];
-const STRONG_CONTEXT_KEYS = 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 = new Set(['image', 'image_url', 'input_image', 'audio', 'input_audio', 'video', 'video_url', 'file', 'input_file', 'document', 'media', 'file-data']);
-const FILE_FAMILY_TYPES = new Set(['file', 'input_file', 'document', 'media', 'file-data']);
-const KNOWN_AUDIO_FORMATS = new Set(['wav', 'mp3', 'ogg', 'flac', 'm4a', 'aac', 'webm']);
-class MediaTypeContext {
-  static EMPTY = new MediaTypeContext(undefined, undefined);
-  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 undefined;
-    for (const hint of MIME_HINT_KEYS) {
-      const v = this.parent[hint];
-      if (typeof v === 'string') return v;
-    }
-    return undefined;
-  }
-  inferFromSiblingFormat() {
-    if (!this.parent) return undefined;
-    const fmt = this.parent.format;
-    if (typeof fmt === 'string' && KNOWN_AUDIO_FORMATS.has(fmt.toLowerCase())) {
-      return `audio/${fmt.toLowerCase()}`;
-    }
-    return undefined;
-  }
-  inferFromParentType() {
-    if (!this.parent) return undefined;
-    const t = this.parent.type;
-    if (typeof t !== 'string') return undefined;
-    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';
-    return undefined;
-  }
-  inferFromKey() {
-    if (!this.key) return undefined;
-    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';
-    return undefined;
-  }
-  hasExplicitBinaryMediaType() {
-    if (!this.explicitMediaType && (!this.parent || !this.key || !STRONG_CONTEXT_KEYS.has(this.key))) return false;
-    const mediaType = this.inferFromSiblingMime();
-    return mediaType !== undefined && !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;
-  }
-}
-
+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;
-class BinaryContentRedactor {
-  visited = new WeakSet();
-  constructor(recognizer = new Base64Recognizer()) {
-    this.recognizer = recognizer;
-  }
-  redact(value, mediaType) {
-    this.visited = new WeakSet();
-    return this.walk(value, mediaType ? new MediaTypeContext(undefined, undefined, mediaType) : MediaTypeContext.EMPTY);
-  }
-  walk(value, ctx) {
-    if (value === null || value === undefined) return value;
-    if (typeof value === 'string') return this.redactString(value, ctx);
-    if (typeof value !== 'object') return value;
-
-    // Buffer extends Uint8Array, so this branch catches both.
-    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]`;
-  }
-}
-
+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);
-
-const TOKEN_PROPERTY_KEYS = new Set(['$ai_input_tokens', '$ai_output_tokens', '$ai_cache_read_input_tokens', '$ai_cache_creation_input_tokens', '$ai_total_tokens', '$ai_reasoning_tokens']);
-
+//#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.
- */
+* 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));
+	return !!posthogProperties && Object.keys(posthogProperties).some((key) => TOKEN_PROPERTY_KEYS.has(key));
 }
 function getTokensSource(posthogProperties) {
-  return hasTokenOverrides(posthogProperties) ? 'passthrough' : 'sdk';
+	return hasTokenOverrides(posthogProperties) ? "passthrough" : "sdk";
 }
-const STRING_FORMAT = 'utf8';
-
-// Reused across calls to avoid per-invocation allocation; truncate() runs
-// hundreds of times for prompts with many parts.
+const STRING_FORMAT = "utf8";
 new TextEncoder();
-new TextDecoder(STRING_FORMAT, {
-  fatal: false
-});
+new TextDecoder(STRING_FORMAT, { fatal: false });
 const getModelParams = (params, responseServiceTier) => {
-  if (!params) {
-    return {};
-  }
-  const modelParams = {};
-  const paramKeys = ['temperature', 'max_tokens', 'max_completion_tokens', 'top_p', 'frequency_penalty', 'presence_penalty', 'n', 'stop', 'stream', 'streaming', 'language', 'response_format', 'timestamp_granularities', 'service_tier'];
-  for (const key of paramKeys) {
-    if (key in params && params[key] !== undefined) {
-      modelParams[key] = params[key];
-    }
-  }
-  return modelParams;
+	if (!params) return {};
+	const modelParams = {};
+	for (const key of [
+		"temperature",
+		"max_tokens",
+		"max_completion_tokens",
+		"top_p",
+		"frequency_penalty",
+		"presence_penalty",
+		"n",
+		"stop",
+		"stream",
+		"streaming",
+		"language",
+		"response_format",
+		"timestamp_granularities",
+		"service_tier"
+	]) if (key in params && params[key] !== void 0) modelParams[key] = params[key];
+	if (responseServiceTier != null) modelParams.service_tier = responseServiceTier;
+	return modelParams;
 };
-const formatResponseAnthropic = response => {
-  const output = [];
-  const content = [];
-  for (const choice of response.content ?? []) {
-    if (choice?.type === 'text' && choice?.text) {
-      content.push({
-        type: 'text',
-        text: choice.text
-      });
-    } else if (choice?.type === 'tool_use' && choice?.name && choice?.id) {
-      content.push({
-        type: 'function',
-        id: choice.id,
-        function: {
-          name: choice.name,
-          arguments: choice.input || {}
-        }
-      });
-    }
-  }
-  if (content.length > 0) {
-    output.push({
-      role: 'assistant',
-      content
-    });
-  }
-  return output;
+const formatResponseAnthropic = (response) => {
+	const output = [];
+	const content = [];
+	for (const choice of response.content ?? []) if (choice?.type === "text" && choice?.text) content.push({
+		type: "text",
+		text: choice.text
+	});
+	else if (choice?.type === "tool_use" && choice?.name && choice?.id) content.push({
+		type: "function",
+		id: choice.id,
+		function: {
+			name: choice.name,
+			arguments: choice.input || {}
+		}
+	});
+	if (content.length > 0) output.push({
+		role: "assistant",
+		content
+	});
+	return output;
 };
 const mergeSystemPrompt = (params, provider) => {
-  {
-    const messages = params.messages || [];
-    if (!params.system) {
-      return messages;
-    }
-    const systemMessage = params.system;
-    return [{
-      role: 'system',
-      content: systemMessage
-    }, ...messages];
-  }
+	if (provider == "anthropic") {
+		const messages = params.messages || [];
+		if (!params.system) return messages;
+		return [{
+			role: "system",
+			content: params.system
+		}, ...messages];
+	}
+	return params.messages;
 };
 const withPrivacyMode = (client, privacyMode, input) => {
-  return client.privacy_mode || privacyMode ? null : input;
+	return client.privacy_mode || privacyMode ? null : input;
 };
-
 /**
- * Extract available tool calls from the request parameters.
- * These are the tools provided to the LLM, not the tool calls in the response.
- */
+* Extract available tool calls from the request parameters.
+* These are the tools provided to the LLM, not the tool calls in the response.
+*/
 const extractAvailableToolCalls = (provider, params) => {
-  {
-    if (params.tools) {
-      return params.tools;
-    }
-    return null;
-  }
+	if (provider === "anthropic") {
+		if (params.tools) return params.tools;
+		return null;
+	} else if (provider === "gemini") {
+		if (params.config && params.config.tools) return params.config.tools;
+		return null;
+	} else if (provider === "openai") {
+		if (params.tools) return params.tools;
+		return null;
+	} else if (provider === "vercel") {
+		if (params.tools) return params.tools;
+		return null;
+	}
+	return null;
 };
-let AIEvent = /*#__PURE__*/function (AIEvent) {
-  AIEvent["Generation"] = "$ai_generation";
-  AIEvent["Embedding"] = "$ai_embedding";
-  return AIEvent;
-}({});
 function sanitizeValues(obj) {
-  if (obj === undefined || obj === null) {
-    return obj;
-  }
-  const jsonSafe = JSON.parse(JSON.stringify(obj));
-  if (typeof jsonSafe === 'string') {
-    // Sanitize lone surrogates by round-tripping through UTF-8
-    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;
+	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;
 }
 const POSTHOG_PARAMS_MAP = {
-  posthogDistinctId: 'distinctId',
-  posthogTraceId: 'traceId',
-  posthogProperties: 'properties',
-  posthogPrivacyMode: 'privacyMode',
-  posthogGroups: 'groups',
-  posthogModelOverride: 'modelOverride',
-  posthogProviderOverride: 'providerOverride',
-  posthogCostOverride: 'costOverride',
-  posthogCaptureImmediate: 'captureImmediate'
+	posthogDistinctId: "distinctId",
+	posthogTraceId: "traceId",
+	posthogProperties: "properties",
+	posthogPrivacyMode: "privacyMode",
+	posthogGroups: "groups",
+	posthogModelOverride: "modelOverride",
+	posthogProviderOverride: "providerOverride",
+	posthogCostOverride: "costOverride",
+	posthogCaptureImmediate: "captureImmediate"
 };
 function extractPosthogParams(body) {
-  const providerParams = {};
-  const posthogParams = {};
-  for (const [key, value] of Object.entries(body)) {
-    if (POSTHOG_PARAMS_MAP[key]) {
-      posthogParams[POSTHOG_PARAMS_MAP[key]] = value;
-    } else if (key.startsWith('posthog')) {
-      console.warn(`Unknown Posthog parameter ${key}`);
-    } else {
-      providerParams[key] = value;
-    }
-  }
-  return {
-    providerParams: providerParams,
-    posthogParams: addDefaults(posthogParams)
-  };
+	const providerParams = {};
+	const posthogParams = {};
+	for (const [key, value] of Object.entries(body)) if (POSTHOG_PARAMS_MAP[key]) posthogParams[POSTHOG_PARAMS_MAP[key]] = value;
+	else if (key.startsWith("posthog")) console.warn(`Unknown Posthog parameter ${key}`);
+	else providerParams[key] = value;
+	return {
+		providerParams,
+		posthogParams: addDefaults(posthogParams)
+	};
 }
 function addDefaults(params) {
-  return {
-    ...params,
-    privacyMode: params.privacyMode ?? false,
-    traceId: params.traceId ?? uuid.v4()
-  };
+	return {
+		...params,
+		privacyMode: params.privacyMode ?? false,
+		traceId: params.traceId ?? (0, uuid.v4)()
+	};
 }
-
-var version = "8.10.0";
-
+//#endregion
+//#region package.json
+var version = "8.10.2";
+//#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 !== undefined) {
-      out.cause = serializeError(value.cause, depth - 1);
-    }
-    return out;
-  }
-  if (Array.isArray(value)) {
-    return value.map(item => serializeError(item, depth - 1));
-  }
-  return value;
+	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)
-    });
-  }
+	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');
+	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");
 }
-
-// Warn when a wrapper's base_url points at the PostHog AI Gateway: the gateway
-// emits its own $ai_generation, so each call would be captured (and, for billable
-// products, billed) twice. We only warn — the wrapper's event carries data the
-// gateway never sees (groups, custom properties, trace hierarchy).
-
-// Keep in sync with the gateway's deployed hosts (see services/llm-gateway in the
-// main repo). gateway.us.posthog.com is live today; the rest are listed ahead of
-// any traffic moving to them.
-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'];
-
-// Swap for the dedicated AI Gateway page once it ships.
-const GATEWAY_DOCS_URL = 'https://posthog.com/docs/ai-observability';
-const extractHost = baseURL => {
-  try {
-    // Tolerate bare hosts that omit a scheme, e.g. "gateway.us.posthog.com/v1".
-    const hasScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(baseURL);
-    return new URL(hasScheme ? baseURL : `https://${baseURL}`).hostname.toLowerCase();
-  } catch {
-    return undefined;
-  }
+//#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 !== undefined && POSTHOG_AI_GATEWAY_HOSTS.includes(host);
+const isPostHogAiGatewayUrl = (baseURL) => {
+	if (!baseURL) return false;
+	const host = extractHost(baseURL);
+	return host !== void 0 && POSTHOG_AI_GATEWAY_HOSTS.includes(host);
 };
-
-// Warns on every gateway call by design: the misconfiguration is impossible to
-// miss that way, and a doubled bill is worse than noisy logs.
-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}.`);
+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}.`);
 };
-
-/**
- * Options for `captureAiGeneration`. Mirrors the `$ai_generation` event shape
- * directly so that any caller — first-party SDK wrappers and external code
- * alike — produces an identical event.
- */
-
+//#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.
- */
+* 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 ?? uuid.v4();
-    const eventType = options.eventType ?? AIEvent.Generation;
-    const privacyMode = options.privacyMode ?? false;
-    const usage = options.usage ?? {};
-
-    // Check privacy before reading or traversing input/output. Besides avoiding
-    // needless work, this ensures hostile getters/proxies cannot observe a value
-    // that the caller explicitly requested us to redact.
-    const shouldRedact = withPrivacyMode(client, privacyMode, false) === null;
-    const safeInput = shouldRedact ? null : core.toJsonSafeValue(options.input);
-    const safeOutput = shouldRedact ? null : core.toJsonSafeValue(options.output);
-    let httpStatus = options.httpStatus;
-    let errorData = {};
-    if (options.error) {
-      if (httpStatus === undefined) {
-        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 = core.uuidv7();
-        client.captureException(options.error, undefined, {
-          $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;
-
-    // A configured price applies only to a count the provider reported, so a call with no
-    // reported usage sends no cost instead of asserting $0. $ai_total_cost_usd sums the sides
-    // that were priced, which makes it the cost of the known side alone when the other side
-    // went unreported: a lower bound on the true total, not an assertion of it.
-    const costOverrideData = {};
-    if (options.costOverride) {
-      if (usage.inputTokens !== undefined) {
-        costOverrideData.$ai_input_cost_usd = (options.costOverride.inputCost ?? 0) * usage.inputTokens;
-      }
-      if (usage.outputTokens !== undefined) {
-        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);
-      }
-    }
-
-    // The caller's own token counts override the SDK-derived ones further down, via the
-    // `options.properties` spread.
-    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
-      } : {}),
-      // Checked against undefined rather than truthiness, because false is the meaningful
-      // value here and a truthiness guard would drop it.
-      //
-      // Dropped entirely when the caller overrides the token counts: the flag describes how
-      // the SDK-derived counts relate to each other, so against passthrough counts it can be
-      // wrong in the expensive direction. Declaring inclusive over counts that are actually
-      // exclusive makes ingestion subtract the cache pool that was never in the input. A
-      // caller who knows their own accounting model can still pass
-      // `$ai_cache_reporting_exclusive` themselves, and that value wins.
-      ...(usage.cacheReportingExclusive !== undefined && !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 !== undefined ? {
-        $ai_input_tokens: usage.inputTokens
-      } : {}),
-      ...(usage.outputTokens !== undefined ? {
-        $ai_output_tokens: usage.outputTokens
-      } : {}),
-      ...additionalTokenValues,
-      ...(options.latency !== undefined ? {
-        $ai_latency: options.latency
-      } : {}),
-      ...(options.timeToFirstToken !== undefined ? {
-        $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) {
-    // Telemetry failures must never affect the instrumented provider call.
-    try {
-      options.onError?.(error);
-    } catch {
-      // Error reporting must not affect the instrumented provider call either.
-    }
-    console.warn('[PostHog AI] Failed to capture generation telemetry:', error);
-  }
+	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/providerPromise.ts
 function addResponseIds(result, response, requestIdHeader, workspaceIdHeader) {
-  if (!result || typeof result !== 'object' || Array.isArray(result)) {
-    return result;
-  }
-  const properties = {
-    _request_id: {
-      value: response.headers.get(requestIdHeader),
-      enumerable: false
-    }
-  };
-  if (workspaceIdHeader) {
-    properties._workspace_id = {
-      value: response.headers.get(workspaceIdHeader),
-      enumerable: false
-    };
-  }
-  return Object.defineProperties(result, properties);
+	if (!result || typeof result !== "object" || Array.isArray(result)) return result;
+	const properties = { _request_id: {
+		value: response.headers.get(requestIdHeader),
+		enumerable: false
+	} };
+	if (workspaceIdHeader) properties._workspace_id = {
+		value: response.headers.get(workspaceIdHeader),
+		enumerable: false
+	};
+	return Object.defineProperties(result, properties);
 }
 function getResponsePropsPromise(parentPromise) {
-  const responsePromise = parentPromise.responsePromise;
-  if (!responsePromise || typeof responsePromise.then !== 'function') {
-    return undefined;
-  }
-  return responsePromise;
+	const responsePromise = parentPromise.responsePromise;
+	if (!responsePromise || typeof responsePromise.then !== "function") return;
+	return responsePromise;
 }
 function decorateProviderPromise(wrappedPromise, responsePropsPromise, requestIdHeader, workspaceIdHeader, preserveThenUnwrap) {
-  const providerPromise = wrappedPromise;
-  if (responsePropsPromise) {
-    providerPromise.asResponse = async () => (await responsePropsPromise).response;
-    providerPromise.withResponse = async () => {
-      const [props, data] = await Promise.all([responsePropsPromise, wrappedPromise]);
-      return {
-        response: props.response,
-        data,
-        request_id: props.response.headers.get(requestIdHeader),
-        ...(workspaceIdHeader ? {
-          workspace_id: props.response.headers.get(workspaceIdHeader)
-        } : {})
-      };
-    };
-  }
-  if (preserveThenUnwrap) {
-    providerPromise._thenUnwrap = transform => {
-      if (!responsePropsPromise) {
-        throw new Error('The provider promise response metadata is unavailable');
-      }
-      const transformedPromise = Promise.all([wrappedPromise, responsePropsPromise]).then(([data, props]) => addResponseIds(transform(data, props), props.response, requestIdHeader, workspaceIdHeader));
-      return decorateProviderPromise(transformedPromise, responsePropsPromise, requestIdHeader, workspaceIdHeader, true);
-    };
-  }
-  return providerPromise;
+	const providerPromise = wrappedPromise;
+	if (responsePropsPromise) {
+		providerPromise.asResponse = async () => (await responsePropsPromise).response;
+		providerPromise.withResponse = async () => {
+			const [props, data] = await Promise.all([responsePropsPromise, wrappedPromise]);
+			return {
+				response: props.response,
+				data,
+				request_id: props.response.headers.get(requestIdHeader),
+				...workspaceIdHeader ? { workspace_id: props.response.headers.get(workspaceIdHeader) } : {}
+			};
+		};
+	}
+	if (preserveThenUnwrap) providerPromise._thenUnwrap = (transform) => {
+		if (!responsePropsPromise) throw new Error("The provider promise response metadata is unavailable");
+		return decorateProviderPromise(Promise.all([wrappedPromise, responsePropsPromise]).then(([data, props]) => addResponseIds(transform(data, props), props.response, requestIdHeader, workspaceIdHeader)), responsePropsPromise, requestIdHeader, workspaceIdHeader, true);
+	};
+	return providerPromise;
 }
-
-/**
- * Keep the provider SDK helpers on a promise whose resolved value is instrumented.
- * OpenAI's parse helpers compose create calls through `_thenUnwrap`, while both
- * OpenAI and Anthropic expose the raw response through `asResponse` and
- * `withResponse`.
- */
-
 function preserveProviderPromise(parentPromise, wrappedPromise, options = {}) {
-  const responsePropsPromise = getResponsePropsPromise(parentPromise);
-  const preserveThenUnwrap = typeof parentPromise._thenUnwrap === 'function';
-  const providerPromise = decorateProviderPromise(wrappedPromise, responsePropsPromise, options.requestIdHeader ?? 'x-request-id', options.workspaceIdHeader, preserveThenUnwrap);
-  if (!responsePropsPromise) {
-    const asResponse = parentPromise.asResponse?.bind(parentPromise);
-    if (asResponse) {
-      providerPromise.asResponse = asResponse;
-    }
-    const withResponse = parentPromise.withResponse?.bind(parentPromise);
-    if (withResponse) {
-      providerPromise.withResponse = async () => {
-        const [response, data] = await Promise.all([withResponse(), wrappedPromise]);
-        return {
-          ...response,
-          data
-        };
-      };
-    }
-  }
-  return providerPromise;
+	const responsePropsPromise = getResponsePropsPromise(parentPromise);
+	const preserveThenUnwrap = typeof parentPromise._thenUnwrap === "function";
+	const providerPromise = decorateProviderPromise(wrappedPromise, responsePropsPromise, options.requestIdHeader ?? "x-request-id", options.workspaceIdHeader, preserveThenUnwrap);
+	if (!responsePropsPromise) {
+		const asResponse = parentPromise.asResponse?.bind(parentPromise);
+		if (asResponse) providerPromise.asResponse = asResponse;
+		const withResponse = parentPromise.withResponse?.bind(parentPromise);
+		if (withResponse) providerPromise.withResponse = async () => {
+			const [response, data] = await Promise.all([withResponse(), wrappedPromise]);
+			return {
+				...response,
+				data
+			};
+		};
+	}
+	return providerPromise;
 }
-
+//#endregion
+//#region src/stream.ts
 /**
- * Splits an SDK stream into a monitoring branch and a caller branch without
- * allowing either branch to read ahead of the other. Unlike the SDKs' `tee()`
- * implementations, this keeps at most one result in flight and makes caller
- * cancellation terminate the monitoring branch and the source iterator.
- */
+* Splits an SDK stream into a monitoring branch and a caller branch without
+* allowing either branch to read ahead of the other. Unlike the SDKs' `tee()`
+* implementations, this keeps at most one result in flight and makes caller
+* cancellation terminate the monitoring branch and the source iterator.
+*/
 function monitoredStreamTee(source, createStream) {
-  const controller = source.controller ?? new AbortController();
-  const sourceIterator = source[Symbol.asyncIterator]();
-  const callerQueue = [];
-  let monitorPending;
-  let monitorActive = true;
-  let operationInFlight = false;
-  let terminalResult;
-  let bufferedMonitorResult;
-  let terminalError;
-  let hasTerminalError = false;
-  let cancellationPromise;
-  let abortListener;
-  const removeAbortListener = () => {
-    if (abortListener) {
-      controller.signal.removeEventListener('abort', abortListener);
-      abortListener = undefined;
-    }
-  };
-  const settleMonitorTerminal = () => {
-    if (!monitorPending) {
-      return;
-    }
-    const pending = monitorPending;
-    monitorPending = undefined;
-    if (hasTerminalError) {
-      pending.reject(terminalError);
-    } else if (terminalResult) {
-      pending.resolve(terminalResult);
-    }
-  };
-  const settleCallersTerminal = () => {
-    while (callerQueue.length > 0) {
-      const pending = callerQueue.shift();
-      if (hasTerminalError) {
-        pending.reject(terminalError);
-      } else if (terminalResult) {
-        pending.resolve(terminalResult);
-      }
-    }
-  };
-  const pump = () => {
-    if (operationInFlight || callerQueue.length === 0 || monitorActive && !monitorPending) {
-      return;
-    }
-    const pendingCaller = callerQueue.shift();
-    const pendingMonitor = monitorPending;
-    monitorPending = undefined;
-    operationInFlight = true;
-    void sourceIterator.next().then(result => {
-      operationInFlight = false;
-      if (result.done) {
-        terminalResult = result;
-        removeAbortListener();
-      }
-      pendingCaller.resolve(result);
-      pendingMonitor?.resolve(result);
-      if (result.done) {
-        settleCallersTerminal();
-      } else {
-        pump();
-      }
-    }, error => {
-      operationInFlight = false;
-      terminalError = error;
-      hasTerminalError = true;
-      removeAbortListener();
-      pendingCaller.reject(error);
-      pendingMonitor?.reject(error);
-      settleCallersTerminal();
-    });
-  };
-  const monitoringStream = {
-    [Symbol.asyncIterator]() {
-      return {
-        next: () => {
-          if (hasTerminalError) {
-            return Promise.reject(terminalError);
-          }
-          if (terminalResult) {
-            return Promise.resolve(terminalResult);
-          }
-          if (bufferedMonitorResult) {
-            const result = bufferedMonitorResult;
-            bufferedMonitorResult = undefined;
-            return Promise.resolve(result);
-          }
-          return new Promise((resolve, reject) => {
-            monitorPending = {
-              resolve,
-              reject
-            };
-            pump();
-          });
-        },
-        return: async value => {
-          monitorActive = false;
-          monitorPending = undefined;
-          pump();
-          return {
-            done: true,
-            value: value
-          };
-        }
-      };
-    }
-  };
-  const cancelSource = value => {
-    if (cancellationPromise) {
-      return cancellationPromise;
-    }
-    removeAbortListener();
-    if (!controller.signal.aborted) {
-      controller.abort();
-    }
-    cancellationPromise = (async () => {
-      try {
-        const defaultResult = {
-          done: true,
-          value
-        };
-        const result = sourceIterator.return ? await sourceIterator.return(value) : defaultResult;
-        if (result.done) {
-          terminalResult = result;
-          removeAbortListener();
-          settleMonitorTerminal();
-          settleCallersTerminal();
-        } else if (monitorPending) {
-          monitorPending.resolve(result);
-          monitorPending = undefined;
-          cancellationPromise = undefined;
-        } else {
-          bufferedMonitorResult = result;
-          cancellationPromise = undefined;
-        }
-        return result;
-      } catch (error) {
-        terminalError = error;
-        hasTerminalError = true;
-        removeAbortListener();
-        settleMonitorTerminal();
-        settleCallersTerminal();
-        throw error;
-      }
-    })();
-    // An AbortController cancellation has no caller awaiting this promise.
-    void cancellationPromise.catch(() => undefined);
-    return cancellationPromise;
-  };
-  abortListener = () => {
-    void cancelSource();
-  };
-  if (controller.signal.aborted) {
-    abortListener();
-  } else {
-    controller.signal.addEventListener('abort', abortListener, {
-      once: true
-    });
-  }
-  const callerStream = createStream(() => ({
-    next: () => {
-      if (hasTerminalError) {
-        return Promise.reject(terminalError);
-      }
-      if (terminalResult) {
-        return Promise.resolve(terminalResult);
-      }
-      return new Promise((resolve, reject) => {
-        callerQueue.push({
-          resolve,
-          reject
-        });
-        pump();
-      });
-    },
-    return: value => cancelSource(value),
-    throw: async error => {
-      if (!sourceIterator.throw) {
-        await cancelSource();
-        throw error;
-      }
-      try {
-        const result = await sourceIterator.throw(error);
-        if (result.done) {
-          terminalResult = result;
-          removeAbortListener();
-          settleCallersTerminal();
-        }
-        if (monitorPending) {
-          monitorPending.resolve(result);
-          monitorPending = undefined;
-        } else {
-          bufferedMonitorResult = result;
-        }
-        return result;
-      } catch (sourceError) {
-        terminalError = sourceError;
-        hasTerminalError = true;
-        removeAbortListener();
-        settleMonitorTerminal();
-        settleCallersTerminal();
-        throw sourceError;
-      }
-    }
-  }), controller);
-  return [monitoringStream, callerStream];
+	const controller = source.controller ?? new AbortController();
+	const sourceIterator = source[Symbol.asyncIterator]();
+	const callerQueue = [];
+	let monitorPending;
+	let monitorActive = true;
+	let operationInFlight = false;
+	let terminalResult;
+	let bufferedMonitorResult;
+	let terminalError;
+	let hasTerminalError = false;
+	let cancellationPromise;
+	let abortListener;
+	const removeAbortListener = () => {
+		if (abortListener) {
+			controller.signal.removeEventListener("abort", abortListener);
+			abortListener = void 0;
+		}
+	};
+	const settleMonitorTerminal = () => {
+		if (!monitorPending) return;
+		const pending = monitorPending;
+		monitorPending = void 0;
+		if (hasTerminalError) pending.reject(terminalError);
+		else if (terminalResult) pending.resolve(terminalResult);
+	};
+	const settleCallersTerminal = () => {
+		while (callerQueue.length > 0) {
+			const pending = callerQueue.shift();
+			if (hasTerminalError) pending.reject(terminalError);
+			else if (terminalResult) pending.resolve(terminalResult);
+		}
+	};
+	const pump = () => {
+		if (operationInFlight || callerQueue.length === 0 || monitorActive && !monitorPending) return;
+		const pendingCaller = callerQueue.shift();
+		const pendingMonitor = monitorPending;
+		monitorPending = void 0;
+		operationInFlight = true;
+		sourceIterator.next().then((result) => {
+			operationInFlight = false;
+			if (result.done) {
+				terminalResult = result;
+				removeAbortListener();
+			}
+			pendingCaller.resolve(result);
+			pendingMonitor?.resolve(result);
+			if (result.done) settleCallersTerminal();
+			else pump();
+		}, (error) => {
+			operationInFlight = false;
+			terminalError = error;
+			hasTerminalError = true;
+			removeAbortListener();
+			pendingCaller.reject(error);
+			pendingMonitor?.reject(error);
+			settleCallersTerminal();
+		});
+	};
+	const monitoringStream = { [Symbol.asyncIterator]() {
+		return {
+			next: () => {
+				if (hasTerminalError) return Promise.reject(terminalError);
+				if (terminalResult) return Promise.resolve(terminalResult);
+				if (bufferedMonitorResult) {
+					const result = bufferedMonitorResult;
+					bufferedMonitorResult = void 0;
+					return Promise.resolve(result);
+				}
+				return new Promise((resolve, reject) => {
+					monitorPending = {
+						resolve,
+						reject
+					};
+					pump();
+				});
+			},
+			return: async (value) => {
+				monitorActive = false;
+				monitorPending = void 0;
+				pump();
+				return {
+					done: true,
+					value
+				};
+			}
+		};
+	} };
+	const cancelSource = (value) => {
+		if (cancellationPromise) return cancellationPromise;
+		removeAbortListener();
+		if (!controller.signal.aborted) controller.abort();
+		cancellationPromise = (async () => {
+			try {
+				const defaultResult = {
+					done: true,
+					value
+				};
+				const result = sourceIterator.return ? await sourceIterator.return(value) : defaultResult;
+				if (result.done) {
+					terminalResult = result;
+					removeAbortListener();
+					settleMonitorTerminal();
+					settleCallersTerminal();
+				} else if (monitorPending) {
+					monitorPending.resolve(result);
+					monitorPending = void 0;
+					cancellationPromise = void 0;
+				} else {
+					bufferedMonitorResult = result;
+					cancellationPromise = void 0;
+				}
+				return result;
+			} catch (error) {
+				terminalError = error;
+				hasTerminalError = true;
+				removeAbortListener();
+				settleMonitorTerminal();
+				settleCallersTerminal();
+				throw error;
+			}
+		})();
+		cancellationPromise.catch(() => void 0);
+		return cancellationPromise;
+	};
+	abortListener = () => {
+		cancelSource();
+	};
+	if (controller.signal.aborted) abortListener();
+	else controller.signal.addEventListener("abort", abortListener, { once: true });
+	return [monitoringStream, createStream(() => ({
+		next: () => {
+			if (hasTerminalError) return Promise.reject(terminalError);
+			if (terminalResult) return Promise.resolve(terminalResult);
+			return new Promise((resolve, reject) => {
+				callerQueue.push({
+					resolve,
+					reject
+				});
+				pump();
+			});
+		},
+		return: (value) => cancelSource(value),
+		throw: async (error) => {
+			if (!sourceIterator.throw) {
+				await cancelSource();
+				throw error;
+			}
+			try {
+				const result = await sourceIterator.throw(error);
+				if (result.done) {
+					terminalResult = result;
+					removeAbortListener();
+					settleCallersTerminal();
+				}
+				if (monitorPending) {
+					monitorPending.resolve(result);
+					monitorPending = void 0;
+				} else bufferedMonitorResult = result;
+				return result;
+			} catch (sourceError) {
+				terminalError = sourceError;
+				hasTerminalError = true;
+				removeAbortListener();
+				settleMonitorTerminal();
+				settleCallersTerminal();
+				throw sourceError;
+			}
+		}
+	}), controller)];
 }
-
-class PostHogAnthropic extends AnthropicOriginal__default.default {
-  constructor(config) {
-    const {
-      posthog,
-      ...anthropicConfig
-    } = config;
-    super(anthropicConfig);
-    this.phClient = posthog;
-    this.messages = new WrappedMessages(this, this.phClient);
-  }
-}
-class WrappedMessages extends AnthropicOriginal__default.default.Messages {
-  constructor(parentClient, phClient) {
-    super(parentClient);
-    this.phClient = phClient;
-    this.baseURL = parentClient.baseURL;
-  }
-  create(body, options) {
-    const {
-      providerParams: anthropicParams,
-      posthogParams
-    } = extractPosthogParams(body);
-    const startTime = Date.now();
-    if (anthropicParams.stream) {
-      const parentPromise = super.create(anthropicParams, options);
-      const wrappedPromise = parentPromise.then(value => {
-        let accumulatedContent = '';
-        const contentBlocks = [];
-        const toolsInProgress = new Map();
-        let currentTextBlock = null;
-        let firstTokenTime;
-        let stopReason;
-        const usage = {
-          webSearchCount: 0
-        };
-        let rawUsage = {};
-        if (Symbol.asyncIterator in value) {
-          const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new streaming.Stream(iterator, controller));
-          (async () => {
-            try {
-              for await (const chunk of stream1) {
-                // Handle content block start events
-                if (chunk.type === 'content_block_start') {
-                  if (chunk.content_block?.type === 'text') {
-                    currentTextBlock = {
-                      type: 'text',
-                      text: ''
-                    };
-                    contentBlocks.push(currentTextBlock);
-                  } else if (chunk.content_block?.type === 'tool_use') {
-                    if (firstTokenTime === undefined) {
-                      firstTokenTime = Date.now();
-                    }
-                    const toolBlock = {
-                      type: 'function',
-                      id: chunk.content_block.id,
-                      function: {
-                        name: chunk.content_block.name,
-                        arguments: {}
-                      }
-                    };
-                    contentBlocks.push(toolBlock);
-                    toolsInProgress.set(chunk.content_block.id, {
-                      block: toolBlock,
-                      inputString: ''
-                    });
-                    currentTextBlock = null;
-                  }
-                }
-
-                // Handle text delta events
-                if ('delta' in chunk) {
-                  if ('text' in chunk.delta) {
-                    const delta = chunk.delta.text;
-                    if (firstTokenTime === undefined) {
-                      firstTokenTime = Date.now();
-                    }
-                    accumulatedContent += delta;
-                    if (currentTextBlock) {
-                      currentTextBlock.text += delta;
-                    }
-                  }
-                }
-
-                // Handle tool input delta events
-                if (chunk.type === 'content_block_delta' && chunk.delta?.type === 'input_json_delta') {
-                  const block = chunk.index !== undefined ? contentBlocks[chunk.index] : undefined;
-                  const toolId = block?.type === 'function' ? block.id : undefined;
-                  if (toolId && toolsInProgress.has(toolId)) {
-                    const tool = toolsInProgress.get(toolId);
-                    if (tool) {
-                      tool.inputString += chunk.delta.partial_json || '';
-                    }
-                  }
-                }
-
-                // Handle content block stop events
-                if (chunk.type === 'content_block_stop') {
-                  currentTextBlock = null;
-
-                  // Parse accumulated tool input
-                  if (chunk.index !== undefined) {
-                    const block = contentBlocks[chunk.index];
-                    if (block?.type === 'function' && block.id && toolsInProgress.has(block.id)) {
-                      const tool = toolsInProgress.get(block.id);
-                      if (tool) {
-                        try {
-                          block.function.arguments = JSON.parse(tool.inputString);
-                        } catch (e) {
-                          // Keep empty object if parsing fails
-                          console.error('Error parsing tool input:', e);
-                        }
-                      }
-                      toolsInProgress.delete(block.id);
-                    }
-                  }
-                }
-                if (chunk.type == 'message_start') {
-                  rawUsage = {
-                    ...chunk.message.usage
-                  };
-                  usage.inputTokens = chunk.message.usage.input_tokens ?? 0;
-                  usage.cacheCreationInputTokens = chunk.message.usage.cache_creation_input_tokens ?? 0;
-                  usage.cacheReadInputTokens = chunk.message.usage.cache_read_input_tokens ?? 0;
-                  usage.webSearchCount = chunk.message.usage.server_tool_use?.web_search_requests ?? 0;
-                }
-                if ('usage' in chunk) {
-                  rawUsage = {
-                    ...rawUsage,
-                    ...Object.fromEntries(Object.entries(chunk.usage).filter(([, value]) => value != null))
-                  };
-                  usage.outputTokens = chunk.usage.output_tokens ?? 0;
-                  // Update web search count if present in delta
-                  if (chunk.usage.server_tool_use?.web_search_requests !== undefined) {
-                    usage.webSearchCount = chunk.usage.server_tool_use.web_search_requests;
-                  }
-                }
-                if (chunk.type === 'message_delta' && 'delta' in chunk) {
-                  const delta = chunk.delta;
-                  if ('stop_reason' in delta && typeof delta.stop_reason === 'string' && delta.stop_reason) {
-                    stopReason = delta.stop_reason;
-                  }
-                }
-              }
-              usage.rawUsage = rawUsage;
-              const latency = (Date.now() - startTime) / 1000;
-              const timeToFirstToken = firstTokenTime !== undefined ? (firstTokenTime - startTime) / 1000 : undefined;
-              const availableTools = extractAvailableToolCalls('anthropic', anthropicParams);
-
-              // Format output to match non-streaming version
-              const formattedOutput = contentBlocks.length > 0 ? [{
-                role: 'assistant',
-                content: contentBlocks
-              }] : [{
-                role: 'assistant',
-                content: [{
-                  type: 'text',
-                  text: accumulatedContent
-                }]
-              }];
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: anthropicParams.model,
-                provider: 'anthropic',
-                input: sanitizeAnthropic(mergeSystemPrompt(anthropicParams, 'anthropic'), this.phClient),
-                output: formattedOutput,
-                latency,
-                timeToFirstToken,
-                baseURL: this.baseURL,
-                modelParameters: getModelParams(body),
-                httpStatus: 200,
-                usage,
-                stopReason,
-                tools: availableTools
-              });
-            } catch (error) {
-              // The final usage delta may never arrive; whatever raw usage did
-              // still belongs on the event.
-              if (Object.keys(rawUsage).length > 0) {
-                usage.rawUsage = rawUsage;
-              }
-              await captureAiGeneration(this.phClient, {
-                ...posthogParams,
-                model: anthropicParams.model,
-                provider: 'anthropic',
-                input: sanitizeAnthropic(mergeSystemPrompt(anthropicParams), this.phClient),
-                output: [],
-                latency: (Date.now() - startTime) / 1000,
-                baseURL: this.baseURL,
-                modelParameters: getModelParams(body),
-                usage,
-                error: error
-              });
-              throw error;
-            }
-          })().catch(() => {
-            // Swallow: analytics must never crash the host process. The caller
-            // already receives this error via their own tee of the stream.
-          });
-
-          // Return the other stream to the user
-          return stream2;
-        }
-        return value;
-      });
-      return preserveProviderPromise(parentPromise, wrappedPromise, {
-        requestIdHeader: 'request-id',
-        workspaceIdHeader: 'anthropic-workspace-id'
-      });
-    } else {
-      const parentPromise = super.create(anthropicParams, options);
-      const wrappedPromise = parentPromise.then(async result => {
-        if ('content' in result) {
-          const latency = (Date.now() - startTime) / 1000;
-          const availableTools = extractAvailableToolCalls('anthropic', anthropicParams);
-          await captureAiGeneration(this.phClient, {
-            ...posthogParams,
-            model: anthropicParams.model,
-            provider: 'anthropic',
-            input: sanitizeAnthropic(mergeSystemPrompt(anthropicParams), this.phClient),
-            output: formatResponseAnthropic(result),
-            latency,
-            baseURL: this.baseURL,
-            modelParameters: getModelParams(body),
-            httpStatus: 200,
-            usage: {
-              inputTokens: result.usage.input_tokens ?? 0,
-              outputTokens: result.usage.output_tokens ?? 0,
-              cacheCreationInputTokens: result.usage.cache_creation_input_tokens ?? 0,
-              cacheReadInputTokens: result.usage.cache_read_input_tokens ?? 0,
-              webSearchCount: result.usage.server_tool_use?.web_search_requests ?? 0,
-              rawUsage: result.usage
-            },
-            stopReason: result.stop_reason ?? undefined,
-            tools: availableTools
-          });
-        }
-        return result;
-      }, async error => {
-        await captureAiGeneration(this.phClient, {
-          ...posthogParams,
-          model: anthropicParams.model,
-          provider: 'anthropic',
-          input: sanitizeAnthropic(mergeSystemPrompt(anthropicParams), this.phClient),
-          output: [],
-          latency: (Date.now() - startTime) / 1000,
-          baseURL: this.baseURL,
-          modelParameters: getModelParams(body),
-          httpStatus: error?.status ? error.status : 500,
-          usage: {},
-          error: error
-        });
-        throw error;
-      });
-      return preserveProviderPromise(parentPromise, wrappedPromise, {
-        requestIdHeader: 'request-id',
-        workspaceIdHeader: 'anthropic-workspace-id'
-      });
-    }
-  }
-}
-
+//#endregion
+//#region src/anthropic/index.ts
+var PostHogAnthropic = class extends _anthropic_ai_sdk.default {
+	constructor(config) {
+		const { posthog, ...anthropicConfig } = config;
+		super(anthropicConfig);
+		this.phClient = posthog;
+		this.messages = new WrappedMessages(this, this.phClient);
+	}
+};
+var WrappedMessages = class extends _anthropic_ai_sdk.default.Messages {
+	constructor(parentClient, phClient) {
+		super(parentClient);
+		this.phClient = phClient;
+		this.baseURL = parentClient.baseURL;
+	}
+	create(body, options) {
+		const { providerParams: anthropicParams, posthogParams } = extractPosthogParams(body);
+		const startTime = Date.now();
+		if (anthropicParams.stream) {
+			const parentPromise = super.create(anthropicParams, options);
+			return preserveProviderPromise(parentPromise, parentPromise.then((value) => {
+				let accumulatedContent = "";
+				const contentBlocks = [];
+				const toolsInProgress = /* @__PURE__ */ new Map();
+				let currentTextBlock = null;
+				let firstTokenTime;
+				let stopReason;
+				const usage = { webSearchCount: 0 };
+				let rawUsage = {};
+				if (Symbol.asyncIterator in value) {
+					const [stream1, stream2] = monitoredStreamTee(value, (iterator, controller) => new _anthropic_ai_sdk_streaming.Stream(iterator, controller));
+					(async () => {
+						try {
+							for await (const chunk of stream1) {
+								if (chunk.type === "content_block_start") {
+									if (chunk.content_block?.type === "text") {
+										currentTextBlock = {
+											type: "text",
+											text: ""
+										};
+										contentBlocks.push(currentTextBlock);
+									} else if (chunk.content_block?.type === "tool_use") {
+										if (firstTokenTime === void 0) firstTokenTime = Date.now();
+										const toolBlock = {
+											type: "function",
+											id: chunk.content_block.id,
+											function: {
+												name: chunk.content_block.name,
+												arguments: {}
+											}
+										};
+										contentBlocks.push(toolBlock);
+										toolsInProgress.set(chunk.content_block.id, {
+											block: toolBlock,
+											inputString: ""
+										});
+										currentTextBlock = null;
+									}
+								}
+								if ("delta" in chunk) {
+									if ("text" in chunk.delta) {
+										const delta = chunk.delta.text;
+										if (firstTokenTime === void 0) firstTokenTime = Date.now();
+										accumulatedContent += delta;
+										if (currentTextBlock) currentTextBlock.text += delta;
+									}
+								}
+								if (chunk.type === "content_block_delta" && chunk.delta?.type === "input_json_delta") {
+									const block = chunk.index !== void 0 ? contentBlocks[chunk.index] : void 0;
+									const toolId = block?.type === "function" ? block.id : void 0;
+									if (toolId && toolsInProgress.has(toolId)) {
+										const tool = toolsInProgress.get(toolId);
+										if (tool) tool.inputString += chunk.delta.partial_json || "";
+									}
+								}
+								if (chunk.type === "content_block_stop") {
+									currentTextBlock = null;
+									if (chunk.index !== void 0) {
+										const block = contentBlocks[chunk.index];
+										if (block?.type === "function" && block.id && toolsInProgress.has(block.id)) {
+											const tool = toolsInProgress.get(block.id);
+											if (tool) try {
+												block.function.arguments = JSON.parse(tool.inputString);
+											} catch (e) {
+												console.error("Error parsing tool input:", e);
+											}
+											toolsInProgress.delete(block.id);
+										}
+									}
+								}
+								if (chunk.type == "message_start") {
+									rawUsage = { ...chunk.message.usage };
+									usage.inputTokens = chunk.message.usage.input_tokens ?? 0;
+									usage.cacheCreationInputTokens = chunk.message.usage.cache_creation_input_tokens ?? 0;
+									usage.cacheReadInputTokens = chunk.message.usage.cache_read_input_tokens ?? 0;
+									usage.webSearchCount = chunk.message.usage.server_tool_use?.web_search_requests ?? 0;
+								}
+								if ("usage" in chunk) {
+									rawUsage = {
+										...rawUsage,
+										...Object.fromEntries(Object.entries(chunk.usage).filter(([, value]) => value != null))
+									};
+									usage.outputTokens = chunk.usage.output_tokens ?? 0;
+									if (chunk.usage.server_tool_use?.web_search_requests !== void 0) usage.webSearchCount = chunk.usage.server_tool_use.web_search_requests;
+								}
+								if (chunk.type === "message_delta" && "delta" in chunk) {
+									const delta = chunk.delta;
+									if ("stop_reason" in delta && typeof delta.stop_reason === "string" && delta.stop_reason) stopReason = delta.stop_reason;
+								}
+							}
+							usage.rawUsage = rawUsage;
+							const latency = (Date.now() - startTime) / 1e3;
+							const timeToFirstToken = firstTokenTime !== void 0 ? (firstTokenTime - startTime) / 1e3 : void 0;
+							const availableTools = extractAvailableToolCalls("anthropic", anthropicParams);
+							const formattedOutput = contentBlocks.length > 0 ? [{
+								role: "assistant",
+								content: contentBlocks
+							}] : [{
+								role: "assistant",
+								content: [{
+									type: "text",
+									text: accumulatedContent
+								}]
+							}];
+							await captureAiGeneration(this.phClient, {
+								...posthogParams,
+								model: anthropicParams.model,
+								provider: "anthropic",
+								input: sanitizeAnthropic(mergeSystemPrompt(anthropicParams, "anthropic"), this.phClient),
+								output: formattedOutput,
+								latency,
+								timeToFirstToken,
+								baseURL: this.baseURL,
+								modelParameters: getModelParams(body),
+								httpStatus: 200,
+								usage,
+								stopReason,
+								tools: availableTools
+							});
+						} catch (error) {
+							if (Object.keys(rawUsage).length > 0) usage.rawUsage = rawUsage;
+							await captureAiGeneration(this.phClient, {
+								...posthogParams,
+								model: anthropicParams.model,
+								provider: "anthropic",
+								input: sanitizeAnthropic(mergeSystemPrompt(anthropicParams, "anthropic"), this.phClient),
+								output: [],
+								latency: (Date.now() - startTime) / 1e3,
+								baseURL: this.baseURL,
+								modelParameters: getModelParams(body),
+								usage,
+								error
+							});
+							throw error;
+						}
+					})().catch(() => {});
+					return stream2;
+				}
+				return value;
+			}), {
+				requestIdHeader: "request-id",
+				workspaceIdHeader: "anthropic-workspace-id"
+			});
+		} else {
+			const parentPromise = super.create(anthropicParams, options);
+			return preserveProviderPromise(parentPromise, parentPromise.then(async (result) => {
+				if ("content" in result) {
+					const latency = (Date.now() - startTime) / 1e3;
+					const availableTools = extractAvailableToolCalls("anthropic", anthropicParams);
+					await captureAiGeneration(this.phClient, {
+						...posthogParams,
+						model: anthropicParams.model,
+						provider: "anthropic",
+						input: sanitizeAnthropic(mergeSystemPrompt(anthropicParams, "anthropic"), this.phClient),
+						output: formatResponseAnthropic(result),
+						latency,
+						baseURL: this.baseURL,
+						modelParameters: getModelParams(body),
+						httpStatus: 200,
+						usage: {
+							inputTokens: result.usage.input_tokens ?? 0,
+							outputTokens: result.usage.output_tokens ?? 0,
+							cacheCreationInputTokens: result.usage.cache_creation_input_tokens ?? 0,
+							cacheReadInputTokens: result.usage.cache_read_input_tokens ?? 0,
+							webSearchCount: result.usage.server_tool_use?.web_search_requests ?? 0,
+							rawUsage: result.usage
+						},
+						stopReason: result.stop_reason ?? void 0,
+						tools: availableTools
+					});
+				}
+				return result;
+			}, async (error) => {
+				await captureAiGeneration(this.phClient, {
+					...posthogParams,
+					model: anthropicParams.model,
+					provider: "anthropic",
+					input: sanitizeAnthropic(mergeSystemPrompt(anthropicParams, "anthropic"), this.phClient),
+					output: [],
+					latency: (Date.now() - startTime) / 1e3,
+					baseURL: this.baseURL,
+					modelParameters: getModelParams(body),
+					httpStatus: error?.status ? error.status : 500,
+					usage: {},
+					error
+				});
+				throw error;
+			}), {
+				requestIdHeader: "request-id",
+				workspaceIdHeader: "anthropic-workspace-id"
+			});
+		}
+	}
+};
+//#endregion
 exports.Anthropic = PostHogAnthropic;
 exports.PostHogAnthropic = PostHogAnthropic;
-exports.WrappedMessages = WrappedMessages;
 exports.default = PostHogAnthropic;
-//# sourceMappingURL=index.cjs.map
+exports.WrappedMessages = WrappedMessages;
+
+//# sourceMappingURL=index.cjs.map