@amplitude/ai 0.1.0

package/dist/patching.js

@@ -0,0 +1,891 @@
+import { getActiveContext } from "./context.js";
+import { ANTHROPIC_AVAILABLE, _AnthropicModule } from "./providers/anthropic.js";
+import { BEDROCK_AVAILABLE, _BedrockModule } from "./providers/bedrock.js";
+import { GEMINI_AVAILABLE, _GeminiModule } from "./providers/gemini.js";
+import { MISTRAL_AVAILABLE, _MistralModule } from "./providers/mistral.js";
+import { OPENAI_AVAILABLE, _OpenAIModule } from "./providers/openai.js";
+
+//#region src/patching.ts
+var PatchOwnershipError = class extends Error {};
+const _activePatches = [];
+const _patchedProviders = /* @__PURE__ */ new Set();
+const _providerOwners = /* @__PURE__ */ new Map();
+function patchedProviders() {
+	return [..._patchedProviders];
+}
+function _isMethodPatched(target, methodName) {
+	return target[methodName]?.__amplitudePatched === true;
+}
+function _patchMethod(target, methodName, wrapper, providerName) {
+	const original = target[methodName];
+	if (typeof original !== "function") return;
+	if (_isMethodPatched(target, methodName)) return;
+	const patched = function(...args) {
+		return wrapper(original.bind(this), ...args);
+	};
+	patched.__amplitudePatched = true;
+	target[methodName] = patched;
+	_activePatches.push({
+		module: target,
+		method: methodName,
+		original,
+		provider: providerName
+	});
+	_patchedProviders.add(providerName);
+}
+function _assertPatchOwner(providerName, ai) {
+	const existingOwner = _providerOwners.get(providerName);
+	if (existingOwner == null) {
+		_providerOwners.set(providerName, ai);
+		return;
+	}
+	if (existingOwner !== ai) throw new PatchOwnershipError(`Provider "${providerName}" is already patched by another AmplitudeAI instance. Call unpatch() before patching with a different instance.`);
+}
+function patchOpenAI(options) {
+	const { amplitudeAI } = options;
+	const mod = options.module ?? _OpenAIModule;
+	if (mod == null) throw new Error("openai package is not installed. Install it with: npm install openai — or pass the module via the modules option.");
+	_assertPatchOwner("openai", amplitudeAI);
+	if (_patchOpenAIClass(mod.OpenAI, mod, "OpenAI", amplitudeAI, "openai")) _patchedProviders.add("openai");
+}
+function patchAnthropic(options) {
+	const { amplitudeAI } = options;
+	const mod = options.module ?? _AnthropicModule;
+	if (mod == null) throw new Error("@anthropic-ai/sdk package is not installed. Install it with: npm install @anthropic-ai/sdk — or pass the module via the modules option.");
+	_assertPatchOwner("anthropic", amplitudeAI);
+	const AnthropicClass = mod.Anthropic;
+	if (!AnthropicClass?.prototype) return;
+	let didPatch = false;
+	const messagesProto = _getNestedPrototype(AnthropicClass, ["messages"]);
+	if (messagesProto) {
+		const target = messagesProto;
+		_patchMethod(target, "create", _makeCompletionWrapper(amplitudeAI, "anthropic"), "anthropic");
+		_patchMethod(target, "stream", _makeAnthropicStreamWrapper(amplitudeAI), "anthropic");
+		didPatch = _isMethodPatched(target, "create") || _isMethodPatched(target, "stream");
+	}
+	if (didPatch) _patchedProviders.add("anthropic");
+}
+function patchAzureOpenAI(options) {
+	const { amplitudeAI } = options;
+	const mod = options.module ?? _OpenAIModule;
+	if (mod == null) throw new Error("openai package is not installed. Install it with: npm install openai — or pass the module via the modules option.");
+	_assertPatchOwner("azure-openai", amplitudeAI);
+	if (_patchOpenAIClass(mod.AzureOpenAI, mod, "AzureOpenAI", amplitudeAI, "azure-openai")) _patchedProviders.add("azure-openai");
+}
+function patchGemini(options) {
+	const { amplitudeAI } = options;
+	const mod = options.module ?? _GeminiModule;
+	if (mod == null) throw new Error("@google/generative-ai is not installed. Install it with: npm install @google/generative-ai — or pass the module via the modules option.");
+	_assertPatchOwner("gemini", amplitudeAI);
+	const GeminiClass = mod.GoogleGenerativeAI;
+	if (!GeminiClass?.prototype) return;
+	const proto = GeminiClass.prototype;
+	_patchMethod(proto, "getGenerativeModel", (original, ...args) => {
+		const modelObj = original(...args);
+		if (modelObj == null || typeof modelObj !== "object") return modelObj;
+		const model = modelObj;
+		if (typeof model.generateContent === "function" && !(model.generateContent.__amplitudePatched === true)) _patchMethod(model, "generateContent", (innerOriginal, ...innerArgs) => {
+			const startTime = performance.now();
+			const result = innerOriginal(...innerArgs);
+			if (result instanceof Promise) return result.then((response) => {
+				_trackGeminiResponse(amplitudeAI, response, startTime);
+				return response;
+			}).catch((err) => {
+				_trackCompletionError(amplitudeAI, err, startTime, innerArgs[0], "gemini");
+				throw err;
+			});
+			return result;
+		}, "gemini");
+		if (typeof model.generateContentStream === "function" && !(model.generateContentStream.__amplitudePatched === true)) _patchMethod(model, "generateContentStream", (innerOriginal, ...innerArgs) => {
+			const startTime = performance.now();
+			const result = innerOriginal(...innerArgs);
+			if (result instanceof Promise) return result.then((response) => {
+				const streamResp = response;
+				const stream = streamResp.stream;
+				if (_isAsyncIterable(stream)) return {
+					...streamResp,
+					stream: _wrapPatchedStream(amplitudeAI, stream, startTime, innerArgs[0], "gemini")
+				};
+				return response;
+			}).catch((err) => {
+				_trackCompletionError(amplitudeAI, err, startTime, innerArgs[0], "gemini");
+				throw err;
+			});
+			return result;
+		}, "gemini");
+		return modelObj;
+	}, "gemini");
+	if (_isMethodPatched(proto, "getGenerativeModel")) _patchedProviders.add("gemini");
+}
+function patchMistral(options) {
+	const { amplitudeAI } = options;
+	const mod = options.module ?? _MistralModule;
+	if (mod == null) throw new Error("@mistralai/mistralai is not installed. Install it with: npm install @mistralai/mistralai — or pass the module via the modules option.");
+	_assertPatchOwner("mistral", amplitudeAI);
+	const MistralClass = mod.Mistral ?? mod.MistralClient ?? mod.default;
+	if (!MistralClass?.prototype) return;
+	const chatProto = _getNestedPrototype(MistralClass, ["chat"]);
+	let didPatch = false;
+	if (chatProto) {
+		const target = chatProto;
+		_patchMethod(target, "complete", _makeCompletionWrapper(amplitudeAI, "mistral"), "mistral");
+		_patchMethod(target, "stream", _makeCompletionWrapper(amplitudeAI, "mistral"), "mistral");
+		didPatch = _isMethodPatched(target, "complete") || _isMethodPatched(target, "stream");
+	}
+	if (didPatch) _patchedProviders.add("mistral");
+}
+function patchBedrock(options) {
+	const { amplitudeAI } = options;
+	const mod = options.module ?? _BedrockModule;
+	if (mod == null) throw new Error("@aws-sdk/client-bedrock-runtime is not installed. Install it with: npm install @aws-sdk/client-bedrock-runtime — or pass the module via the modules option.");
+	_assertPatchOwner("bedrock", amplitudeAI);
+	const ClientClass = mod.BedrockRuntimeClient;
+	if (!ClientClass?.prototype) return;
+	_patchMethod(ClientClass.prototype, "send", (original, ...args) => {
+		const command = args[0];
+		const commandName = String(command?.constructor?.name ?? "");
+		const shouldTrack = commandName.includes("ConverseCommand") || commandName.includes("ConverseStreamCommand");
+		const startTime = performance.now();
+		const result = original(...args);
+		if (result instanceof Promise) return result.then((response) => {
+			if (!shouldTrack) return response;
+			if (commandName.includes("ConverseStreamCommand")) {
+				const streamResp = response;
+				const stream = streamResp.stream;
+				if (_isAsyncIterable(stream)) return {
+					...streamResp,
+					stream: _wrapPatchedBedrockStream(amplitudeAI, stream, startTime, args[0])
+				};
+			} else _trackBedrockResponse(amplitudeAI, response, startTime, args[0]);
+			return response;
+		}).catch((err) => {
+			if (shouldTrack) _trackCompletionError(amplitudeAI, err, startTime, args[0], "bedrock");
+			throw err;
+		});
+		return result;
+	}, "bedrock");
+	if (_isMethodPatched(ClientClass.prototype, "send")) _patchedProviders.add("bedrock");
+}
+/**
+* Auto-detects installed provider SDKs and patches each supported surface.
+*
+* Returns the list of provider names that were successfully patched.
+* Ownership conflicts (same provider patched by a different `AmplitudeAI` instance)
+* throw immediately to prevent ambiguous instrumentation state.
+*
+* In bundler environments where `tryRequire` cannot resolve modules, pass them
+* explicitly via `modules`:
+* ```ts
+* import OpenAI from 'openai';
+* import Anthropic from '@anthropic-ai/sdk';
+* patch({ amplitudeAI: ai, modules: { openai: OpenAI, anthropic: Anthropic } });
+* ```
+*/
+function patch(options) {
+	const patched = [];
+	const mods = options.modules ?? {};
+	const providers = [
+		{
+			fn: patchOpenAI,
+			available: OPENAI_AVAILABLE || mods.openai != null,
+			name: "openai",
+			moduleKey: "openai"
+		},
+		{
+			fn: patchAzureOpenAI,
+			available: OPENAI_AVAILABLE || mods.openai != null,
+			name: "azure-openai",
+			moduleKey: "openai"
+		},
+		{
+			fn: patchAnthropic,
+			available: ANTHROPIC_AVAILABLE || mods.anthropic != null,
+			name: "anthropic",
+			moduleKey: "anthropic"
+		},
+		{
+			fn: patchGemini,
+			available: GEMINI_AVAILABLE || mods.gemini != null,
+			name: "gemini",
+			moduleKey: "gemini"
+		},
+		{
+			fn: patchMistral,
+			available: MISTRAL_AVAILABLE || mods.mistral != null,
+			name: "mistral",
+			moduleKey: "mistral"
+		},
+		{
+			fn: patchBedrock,
+			available: BEDROCK_AVAILABLE || mods.bedrock != null,
+			name: "bedrock",
+			moduleKey: "bedrock"
+		}
+	];
+	for (const { fn, available, name, moduleKey } of providers) {
+		if (!available) continue;
+		try {
+			fn({
+				amplitudeAI: options.amplitudeAI,
+				module: mods[moduleKey]
+			});
+			if (_patchedProviders.has(name)) patched.push(name);
+		} catch (error) {
+			if (error instanceof PatchOwnershipError) throw error;
+		}
+	}
+	return patched;
+}
+function unpatch() {
+	for (const record of _activePatches.reverse()) {
+		const target = record.module;
+		target[record.method] = record.original;
+	}
+	_activePatches.length = 0;
+	_patchedProviders.clear();
+	_providerOwners.clear();
+}
+function unpatchOpenAI() {
+	_unpatchByProvider("openai");
+}
+function unpatchAnthropic() {
+	_unpatchByProvider("anthropic");
+}
+function unpatchGemini() {
+	_unpatchByProvider("gemini");
+}
+function unpatchMistral() {
+	_unpatchByProvider("mistral");
+}
+function unpatchBedrock() {
+	_unpatchByProvider("bedrock");
+}
+function unpatchAzureOpenAI() {
+	_unpatchByProvider("azure-openai");
+}
+function _unpatchByProvider(providerName) {
+	const toRemove = [];
+	for (let i = _activePatches.length - 1; i >= 0; i--) {
+		const record = _activePatches[i];
+		if (record == null) continue;
+		if (record.provider === providerName) {
+			const target = record.module;
+			target[record.method] = record.original;
+			toRemove.push(i);
+		}
+	}
+	for (const idx of toRemove) _activePatches.splice(idx, 1);
+	_patchedProviders.delete(providerName);
+	_providerOwners.delete(providerName);
+}
+function _makeCompletionWrapper(amplitudeAI, providerName) {
+	return (original, ...args) => {
+		const startTime = performance.now();
+		const result = original(...args);
+		if (result instanceof Promise) return result.then((response) => {
+			if (_isAsyncIterable(response)) {
+				if (providerName === "anthropic") return _wrapPatchedAnthropicStream(amplitudeAI, response, startTime, args[0]);
+				return _wrapPatchedStream(amplitudeAI, response, startTime, args[0], providerName);
+			}
+			if (providerName === "anthropic") _trackAnthropicResponse(amplitudeAI, response, startTime, args[0]);
+			else _trackCompletionResponse(amplitudeAI, response, startTime, args[0], providerName);
+			return response;
+		}).catch((err) => {
+			_trackCompletionError(amplitudeAI, err, startTime, args[0], providerName);
+			throw err;
+		});
+		return result;
+	};
+}
+function _makeAnthropicStreamWrapper(amplitudeAI) {
+	return (original, ...args) => {
+		const startTime = performance.now();
+		const result = original(...args);
+		if (!(result instanceof Promise)) return result;
+		return result.then((response) => {
+			if (_isAsyncIterable(response)) return _wrapPatchedAnthropicStream(amplitudeAI, response, startTime, args[0]);
+			const respObj = response;
+			const stream = respObj.stream;
+			if (_isAsyncIterable(stream)) return {
+				...respObj,
+				stream: _wrapPatchedAnthropicStream(amplitudeAI, stream, startTime, args[0])
+			};
+			return response;
+		}).catch((err) => {
+			_trackCompletionError(amplitudeAI, err, startTime, args[0], "anthropic");
+			throw err;
+		});
+	};
+}
+function _isAsyncIterable(value) {
+	return value != null && typeof value[Symbol.asyncIterator] === "function";
+}
+async function* _wrapPatchedStream(ai, stream, startTime, requestOpts, providerName) {
+	if (providerName === "gemini") {
+		yield* _wrapPatchedGeminiStream(ai, stream, startTime, requestOpts);
+		return;
+	}
+	const ctx = getActiveContext();
+	if (ctx == null) {
+		yield* stream;
+		return;
+	}
+	let content = "";
+	let model = "unknown";
+	let finishReason = "";
+	let inputTokens;
+	let outputTokens;
+	let totalTokens;
+	let isError = false;
+	let errorMessage;
+	try {
+		for await (const chunk of stream) {
+			const c = chunk;
+			const choices = c.choices;
+			const delta = choices?.[0]?.delta;
+			if (delta?.content != null) content += String(delta.content);
+			if (c.model != null) model = String(c.model);
+			if (choices?.[0]?.finish_reason != null) finishReason = String(choices[0].finish_reason);
+			const usage = c.usage;
+			if (usage != null) {
+				inputTokens = usage.prompt_tokens;
+				outputTokens = usage.completion_tokens;
+				totalTokens = usage.total_tokens;
+			}
+			yield chunk;
+		}
+	} catch (error) {
+		isError = true;
+		errorMessage = error instanceof Error ? error.message : String(error);
+		throw error;
+	} finally {
+		const latencyMs = performance.now() - startTime;
+		ai.trackAiMessage({
+			userId: ctx.userId ?? "unknown",
+			content,
+			sessionId: ctx.sessionId,
+			model,
+			provider: providerName,
+			latencyMs,
+			traceId: ctx.traceId,
+			inputTokens,
+			outputTokens,
+			totalTokens,
+			finishReason,
+			agentId: ctx.agentId,
+			env: ctx.env,
+			isStreaming: true,
+			isError,
+			errorMessage,
+			..._contextExtras(ctx)
+		});
+	}
+}
+async function* _wrapPatchedAnthropicStream(ai, stream, startTime, requestOpts) {
+	const ctx = getActiveContext();
+	if (ctx == null) {
+		yield* stream;
+		return;
+	}
+	const req = requestOpts;
+	let content = "";
+	let model = String(req?.model ?? "unknown");
+	let finishReason = "";
+	let inputTokens;
+	let outputTokens;
+	let isError = false;
+	let errorMessage;
+	try {
+		for await (const chunk of stream) {
+			const c = chunk;
+			if (c.type === "message_start") {
+				const message = c.message;
+				if (typeof message?.model === "string") model = message.model;
+				const usage = message?.usage;
+				if (typeof usage?.input_tokens === "number") inputTokens = usage.input_tokens;
+			}
+			if (c.type === "content_block_delta") {
+				const delta = c.delta;
+				if (typeof delta?.text === "string") content += delta.text;
+			}
+			if (c.type === "message_delta") {
+				const delta = c.delta;
+				if (typeof delta?.stop_reason === "string") finishReason = delta.stop_reason;
+				else if (typeof c.stop_reason === "string") finishReason = c.stop_reason;
+				const usage = c.usage;
+				if (typeof usage?.output_tokens === "number") outputTokens = usage.output_tokens;
+			}
+			if (c.type === "message_stop") {
+				const usage = c.usage;
+				if (typeof usage?.output_tokens === "number") outputTokens = usage.output_tokens;
+			}
+			yield chunk;
+		}
+	} catch (error) {
+		isError = true;
+		errorMessage = error instanceof Error ? error.message : String(error);
+		throw error;
+	} finally {
+		const latencyMs = performance.now() - startTime;
+		ai.trackAiMessage({
+			userId: ctx.userId ?? "unknown",
+			content,
+			sessionId: ctx.sessionId,
+			model,
+			provider: "anthropic",
+			latencyMs,
+			traceId: ctx.traceId,
+			inputTokens,
+			outputTokens,
+			finishReason,
+			agentId: ctx.agentId,
+			env: ctx.env,
+			isStreaming: true,
+			isError,
+			errorMessage,
+			..._contextExtras(ctx)
+		});
+	}
+}
+async function* _wrapPatchedGeminiStream(ai, stream, startTime, _requestOpts) {
+	const ctx = getActiveContext();
+	if (ctx == null) {
+		yield* stream;
+		return;
+	}
+	let content = "";
+	const model = "gemini";
+	let finishReason = "";
+	let inputTokens;
+	let outputTokens;
+	let totalTokens;
+	let isError = false;
+	let errorMessage;
+	try {
+		for await (const chunk of stream) {
+			const c = chunk;
+			const respObj = c.response ?? c;
+			const textFn = respObj.text;
+			if (typeof textFn === "function") content += String(textFn());
+			const usage = respObj.usageMetadata;
+			if (typeof usage?.promptTokenCount === "number") inputTokens = usage.promptTokenCount;
+			if (typeof usage?.candidatesTokenCount === "number") outputTokens = usage.candidatesTokenCount;
+			if (typeof usage?.totalTokenCount === "number") totalTokens = usage.totalTokenCount;
+			const candidates = respObj.candidates;
+			if (typeof candidates?.[0]?.finishReason === "string") finishReason = candidates[0].finishReason;
+			yield chunk;
+		}
+	} catch (error) {
+		isError = true;
+		errorMessage = error instanceof Error ? error.message : String(error);
+		throw error;
+	} finally {
+		ai.trackAiMessage({
+			userId: ctx.userId ?? "unknown",
+			content,
+			sessionId: ctx.sessionId,
+			model,
+			provider: "gemini",
+			latencyMs: performance.now() - startTime,
+			traceId: ctx.traceId,
+			inputTokens,
+			outputTokens,
+			totalTokens,
+			finishReason,
+			agentId: ctx.agentId,
+			env: ctx.env,
+			isStreaming: true,
+			isError,
+			errorMessage,
+			..._contextExtras(ctx)
+		});
+	}
+}
+async function* _wrapPatchedBedrockStream(ai, stream, startTime, requestOpts) {
+	const ctx = getActiveContext();
+	if (ctx == null) {
+		yield* stream;
+		return;
+	}
+	const opts = requestOpts;
+	let model = String(opts?.modelId ?? "unknown");
+	let content = "";
+	let finishReason = "";
+	let inputTokens;
+	let outputTokens;
+	let totalTokens;
+	let isError = false;
+	let errorMessage;
+	try {
+		for await (const rawEvent of stream) {
+			const event = rawEvent;
+			const delta = event.contentBlockDelta?.delta;
+			if (typeof delta?.text === "string") content += delta.text;
+			const messageStart = event.messageStart;
+			if (typeof messageStart?.model === "string") model = messageStart.model;
+			const messageStop = event.messageStop;
+			if (typeof messageStop?.stopReason === "string") finishReason = messageStop.stopReason;
+			const usage = event.metadata?.usage;
+			if (typeof usage?.inputTokens === "number") inputTokens = usage.inputTokens;
+			if (typeof usage?.outputTokens === "number") outputTokens = usage.outputTokens;
+			if (typeof usage?.totalTokens === "number") totalTokens = usage.totalTokens;
+			yield rawEvent;
+		}
+	} catch (error) {
+		isError = true;
+		errorMessage = error instanceof Error ? error.message : String(error);
+		throw error;
+	} finally {
+		ai.trackAiMessage({
+			userId: ctx.userId ?? "unknown",
+			content,
+			sessionId: ctx.sessionId,
+			model,
+			provider: "bedrock",
+			latencyMs: performance.now() - startTime,
+			traceId: ctx.traceId,
+			inputTokens,
+			outputTokens,
+			totalTokens,
+			finishReason,
+			agentId: ctx.agentId,
+			env: ctx.env,
+			isStreaming: true,
+			isError,
+			errorMessage,
+			..._contextExtras(ctx)
+		});
+	}
+}
+function _patchConstructor(cls, moduleExports, exportKey, amplitudeAI, providerName) {
+	if (moduleExports[exportKey]?.__amplitudeCtorPatched === true) return;
+	const originalCtor = cls;
+	const proxy = new Proxy(originalCtor, { construct(target, args, newTarget) {
+		const instance = Reflect.construct(target, args, newTarget);
+		_patchInstanceCompletions(instance, amplitudeAI, providerName);
+		return instance;
+	} });
+	proxy.__amplitudeCtorPatched = true;
+	const mod = moduleExports;
+	let patchedExportKey = null;
+	if (mod[exportKey] === originalCtor) {
+		mod[exportKey] = proxy;
+		patchedExportKey = exportKey;
+	} else for (const key of Object.keys(mod)) if (mod[key] === originalCtor) {
+		mod[key] = proxy;
+		patchedExportKey = key;
+	}
+	if (patchedExportKey != null) _activePatches.push({
+		module: mod,
+		method: patchedExportKey,
+		original: originalCtor,
+		provider: providerName
+	});
+}
+function _patchOpenAIClass(maybeClass, moduleExports, exportKey, amplitudeAI, providerName) {
+	const OpenAIClass = maybeClass;
+	if (!OpenAIClass?.prototype) return false;
+	const completionsProto = _getNestedPrototype(OpenAIClass, ["chat", "completions"]);
+	if (completionsProto) {
+		const target = completionsProto;
+		_patchMethod(target, "create", _makeCompletionWrapper(amplitudeAI, providerName), providerName);
+		_patchMethod(target, "parse", _makeCompletionWrapper(amplitudeAI, providerName), providerName);
+	} else _patchConstructor(OpenAIClass, moduleExports, exportKey, amplitudeAI, providerName);
+	const responsesProto = _getNestedPrototype(OpenAIClass, ["responses"]);
+	if (responsesProto) {
+		const target = responsesProto;
+		_patchMethod(target, "create", _makeResponsesWrapper(amplitudeAI, providerName), providerName);
+		_patchMethod(target, "stream", _makeResponsesWrapper(amplitudeAI, providerName), providerName);
+	}
+	return true;
+}
+function _patchInstanceCompletions(instance, amplitudeAI, providerName) {
+	try {
+		const completions = instance.chat?.completions;
+		if (completions && typeof completions.create === "function") {
+			const original = completions.create.bind(completions);
+			completions.create = (...args) => _makeCompletionWrapper(amplitudeAI, providerName)(original, ...args);
+		}
+		if (completions && typeof completions.parse === "function") {
+			const originalParse = completions.parse.bind(completions);
+			completions.parse = (...args) => _makeCompletionWrapper(amplitudeAI, providerName)(originalParse, ...args);
+		}
+		const responses = instance.responses;
+		if (responses && typeof responses.create === "function") {
+			const originalResponses = responses.create.bind(responses);
+			responses.create = (...args) => _makeResponsesWrapper(amplitudeAI, providerName)(originalResponses, ...args);
+		}
+		if (responses && typeof responses.stream === "function") {
+			const originalResponsesStream = responses.stream.bind(responses);
+			responses.stream = (...args) => _makeResponsesWrapper(amplitudeAI, providerName)(originalResponsesStream, ...args);
+		}
+	} catch {}
+}
+function _makeResponsesWrapper(amplitudeAI, providerName) {
+	return (original, ...args) => {
+		const startTime = performance.now();
+		const result = original(...args);
+		if (result instanceof Promise) return result.then((response) => {
+			if (_isAsyncIterable(response)) return _wrapPatchedResponsesStream(amplitudeAI, response, startTime, args[0], providerName);
+			_trackResponsesResponse(amplitudeAI, response, startTime, args[0], providerName);
+			return response;
+		}).catch((err) => {
+			_trackCompletionError(amplitudeAI, err, startTime, args[0], providerName);
+			throw err;
+		});
+		return result;
+	};
+}
+function _getNestedPrototype(cls, path) {
+	let current = cls.prototype;
+	for (const key of path) {
+		if (current == null || typeof current !== "object") return null;
+		const obj = current;
+		if (typeof obj[key] === "object" && obj[key] != null) current = obj[key];
+		else return null;
+	}
+	return current;
+}
+function _trackCompletionResponse(ai, response, startTime, _requestOpts, providerName) {
+	if (response == null || typeof response !== "object") return;
+	const ctx = getActiveContext();
+	if (ctx == null) return;
+	const resp = response;
+	const usage = resp.usage;
+	const choice = resp.choices?.[0];
+	const message = choice?.message;
+	const latencyMs = performance.now() - startTime;
+	ai.trackAiMessage({
+		userId: ctx.userId ?? "unknown",
+		content: String(message?.content ?? ""),
+		sessionId: ctx.sessionId,
+		model: String(resp.model ?? "unknown"),
+		provider: providerName,
+		latencyMs,
+		traceId: ctx.traceId,
+		inputTokens: usage?.prompt_tokens,
+		outputTokens: usage?.completion_tokens,
+		totalTokens: usage?.total_tokens,
+		finishReason: String(choice?.finish_reason ?? ""),
+		agentId: ctx.agentId,
+		env: ctx.env,
+		..._contextExtras(ctx)
+	});
+}
+function _trackAnthropicResponse(ai, response, startTime, _requestOpts) {
+	if (response == null || typeof response !== "object") return;
+	const ctx = getActiveContext();
+	if (ctx == null) return;
+	const resp = response;
+	const usage = resp.usage;
+	const textBlock = resp.content?.find((b) => b.type === "text");
+	const latencyMs = performance.now() - startTime;
+	ai.trackAiMessage({
+		userId: ctx.userId ?? "unknown",
+		content: String(textBlock?.text ?? ""),
+		sessionId: ctx.sessionId,
+		model: String(resp.model ?? "unknown"),
+		provider: "anthropic",
+		latencyMs,
+		traceId: ctx.traceId,
+		inputTokens: usage?.input_tokens,
+		outputTokens: usage?.output_tokens,
+		finishReason: String(resp.stop_reason ?? ""),
+		agentId: ctx.agentId,
+		env: ctx.env,
+		..._contextExtras(ctx)
+	});
+}
+function _trackCompletionError(ai, error, startTime, requestOpts, providerName) {
+	const ctx = getActiveContext();
+	if (ctx == null) return;
+	const opts = requestOpts;
+	const latencyMs = performance.now() - startTime;
+	ai.trackAiMessage({
+		userId: ctx.userId ?? "unknown",
+		content: "",
+		sessionId: ctx.sessionId,
+		model: String(opts?.model ?? opts?.modelId ?? "unknown"),
+		provider: providerName,
+		latencyMs,
+		traceId: ctx.traceId,
+		isError: true,
+		errorMessage: error instanceof Error ? error.message : String(error),
+		agentId: ctx.agentId,
+		env: ctx.env,
+		..._contextExtras(ctx)
+	});
+}
+function _trackGeminiResponse(ai, response, startTime) {
+	if (response == null || typeof response !== "object") return;
+	const ctx = getActiveContext();
+	if (ctx == null) return;
+	const resp = response;
+	const respObj = resp.response ?? resp;
+	const text = typeof respObj.text === "function" ? String(respObj.text()) : "";
+	const usage = respObj.usageMetadata;
+	const latencyMs = performance.now() - startTime;
+	ai.trackAiMessage({
+		userId: ctx.userId ?? "unknown",
+		content: text,
+		sessionId: ctx.sessionId,
+		model: "gemini",
+		provider: "gemini",
+		latencyMs,
+		traceId: ctx.traceId,
+		inputTokens: usage?.promptTokenCount,
+		outputTokens: usage?.candidatesTokenCount,
+		totalTokens: usage?.totalTokenCount,
+		agentId: ctx.agentId,
+		env: ctx.env,
+		..._contextExtras(ctx)
+	});
+}
+function _trackBedrockResponse(ai, response, startTime, requestOpts) {
+	if (response == null || typeof response !== "object") return;
+	const ctx = getActiveContext();
+	if (ctx == null) return;
+	const resp = response;
+	const textBlock = ((resp.output?.message)?.content)?.find((b) => b.text != null);
+	const usage = resp.usage;
+	const opts = requestOpts;
+	const latencyMs = performance.now() - startTime;
+	ai.trackAiMessage({
+		userId: ctx.userId ?? "unknown",
+		content: String(textBlock?.text ?? ""),
+		sessionId: ctx.sessionId,
+		model: String(opts?.modelId ?? "unknown"),
+		provider: "bedrock",
+		latencyMs,
+		traceId: ctx.traceId,
+		inputTokens: usage?.inputTokens,
+		outputTokens: usage?.outputTokens,
+		totalTokens: usage?.totalTokens,
+		finishReason: String(resp.stopReason ?? ""),
+		agentId: ctx.agentId,
+		env: ctx.env,
+		..._contextExtras(ctx)
+	});
+}
+function _trackResponsesResponse(ai, response, startTime, requestOpts, providerName) {
+	if (response == null || typeof response !== "object") return;
+	const ctx = getActiveContext();
+	if (ctx == null) return;
+	const resp = response;
+	const usage = resp.usage;
+	const outputText = typeof resp.output_text === "string" ? resp.output_text : _extractResponsesText(resp.output);
+	const opts = requestOpts;
+	ai.trackAiMessage({
+		userId: ctx.userId ?? "unknown",
+		content: outputText,
+		sessionId: ctx.sessionId,
+		model: String(resp.model ?? opts?.model ?? "unknown"),
+		provider: providerName,
+		latencyMs: performance.now() - startTime,
+		traceId: ctx.traceId,
+		inputTokens: typeof usage?.input_tokens === "number" ? usage.input_tokens : void 0,
+		outputTokens: typeof usage?.output_tokens === "number" ? usage.output_tokens : void 0,
+		totalTokens: typeof usage?.total_tokens === "number" ? usage.total_tokens : void 0,
+		reasoningTokens: typeof (usage?.output_tokens_details)?.reasoning_tokens === "number" ? (usage?.output_tokens_details).reasoning_tokens : void 0,
+		finishReason: _extractResponsesFinishReason(resp),
+		agentId: ctx.agentId,
+		env: ctx.env,
+		..._contextExtras(ctx)
+	});
+}
+async function* _wrapPatchedResponsesStream(ai, stream, startTime, requestOpts, providerName) {
+	const ctx = getActiveContext();
+	if (ctx == null) {
+		yield* stream;
+		return;
+	}
+	const opts = requestOpts;
+	const model = String(opts?.model ?? "unknown");
+	let content = "";
+	let finishReason = "";
+	let inputTokens;
+	let outputTokens;
+	let totalTokens;
+	let isError = false;
+	let errorMessage;
+	try {
+		for await (const event of stream) {
+			const e = event;
+			const type = e.type;
+			if (type === "response.output_text.delta") {
+				const delta = e.delta;
+				if (typeof delta === "string") content += delta;
+			} else if (type === "response.completed") {
+				const response = e.response;
+				const usage = response?.usage;
+				const outputText = response?.output_text;
+				if (typeof outputText === "string" && outputText.length > 0) content = outputText;
+				if (typeof usage?.input_tokens === "number") inputTokens = usage.input_tokens;
+				if (typeof usage?.output_tokens === "number") outputTokens = usage.output_tokens;
+				if (typeof usage?.total_tokens === "number") totalTokens = usage.total_tokens;
+				const status = response?.status;
+				if (typeof status === "string") finishReason = status;
+			}
+			yield event;
+		}
+	} catch (error) {
+		isError = true;
+		errorMessage = error instanceof Error ? error.message : String(error);
+		throw error;
+	} finally {
+		ai.trackAiMessage({
+			userId: ctx.userId ?? "unknown",
+			content,
+			sessionId: ctx.sessionId,
+			model,
+			provider: providerName,
+			latencyMs: performance.now() - startTime,
+			traceId: ctx.traceId,
+			inputTokens,
+			outputTokens,
+			totalTokens,
+			finishReason,
+			agentId: ctx.agentId,
+			env: ctx.env,
+			isStreaming: true,
+			isError,
+			errorMessage,
+			..._contextExtras(ctx)
+		});
+	}
+}
+function _extractResponsesText(output) {
+	if (!Array.isArray(output)) return "";
+	let text = "";
+	for (const item of output) {
+		if (item == null || typeof item !== "object") continue;
+		const content = item.content;
+		if (!Array.isArray(content)) continue;
+		for (const part of content) {
+			if (part == null || typeof part !== "object") continue;
+			const partText = part.text;
+			if (typeof partText === "string") text += partText;
+		}
+	}
+	return text;
+}
+function _extractResponsesFinishReason(response) {
+	if (typeof response.status === "string" && response.status.length > 0) return response.status;
+	const output = response.output;
+	if (!Array.isArray(output) || output.length === 0) return void 0;
+	const first = output[0];
+	return typeof first?.status === "string" ? first.status : void 0;
+}
+function _contextExtras(ctx) {
+	return {
+		parentAgentId: ctx.parentAgentId ?? void 0,
+		customerOrgId: ctx.customerOrgId ?? void 0,
+		agentVersion: ctx.agentVersion ?? void 0,
+		context: ctx.context ?? void 0,
+		groups: ctx.groups ?? void 0
+	};
+}
+
+//#endregion
+export { patch, patchAnthropic, patchAzureOpenAI, patchBedrock, patchGemini, patchMistral, patchOpenAI, patchedProviders, unpatch, unpatchAnthropic, unpatchAzureOpenAI, unpatchBedrock, unpatchGemini, unpatchMistral, unpatchOpenAI };
+//# sourceMappingURL=patching.js.map