promptfoo 0.125.0 → 0.125.1

package/dist/src/live-5g2w-M-E.js

@@ -0,0 +1,891 @@
+import { $ as getProcessEnv, X as getEnvString, o as logger } from "./logger-Gff7RMNF.js";
+import "./dataUrl-DBMifX6C.js";
+import { t as fetchWithProxy } from "./fetch-B5KxZuKu.js";
+import { n as resolveProviderApiKey } from "./credentials-DH6z4brQ.js";
+import { g as withGenAIToolSpan } from "./genaiTracer-CuSjHi4t.js";
+import { r as validatePythonPath } from "./pythonUtils-DC5a7NAK.js";
+import { c as maybeLoadToolsFromExternalFile } from "./file-Di0ypTgN.js";
+import "./tracing-CfUes1dH.js";
+import { A as stripExecutableToolFileReferences, C as normalizeTools, D as removeGoogleFunctionDeclarations, N as GOOGLE_MODELS, O as resolveGoogleToolConfig, V as loadCredentials, _ as mergeGoogleCompletionOptions, j as validateFunctionCall, l as getGoogleAccessToken, s as geminiFormatAndSystemInstructions, t as calculateGoogleCost } from "./util-BHkj9joz.js";
+import { r as loadProviderCallbackFromFileUrl } from "./functionCallbackUtils-BfXnPo0o.js";
+import { spawn } from "child_process";
+//#region src/providers/google/live.ts
+const GEMINI_LIVE_TRANSLATE_MODEL = "gemini-3.5-live-translate-preview";
+const ROBOTICS_TEXT_MODALITY_ERROR = "Gemini Robotics ER 2 Streaming only supports TEXT response modality. Omit generationConfig.response_modalities/responseModalities to use the TEXT default, or set it to [\"TEXT\"].";
+const LIVE_TRANSLATE_AUDIO_MODALITY_ERROR = "Gemini 3.5 Live Translate only supports AUDIO response modality. Omit generationConfig.response_modalities/responseModalities to use the AUDIO default, or set it to [\"AUDIO\"].";
+const ROBOTICS_CODE_EXECUTION_ERROR = "Gemini Robotics ER 2 Streaming does not support code execution. Use function calling or Google Search instead.";
+const ROBOTICS_FILE_SEARCH_OR_COMPUTER_USE_ERROR = "Gemini Robotics ER 2 Streaming does not support file search or computer use.";
+const ROBOTICS_GROUNDING_ERROR = "Gemini Robotics ER 2 Streaming does not support Google Maps or URL context grounding. Use Google Search instead.";
+const ROBOTICS_STRUCTURED_OUTPUT_ERROR = "Gemini Robotics ER 2 Streaming does not support structured output. Remove responseSchema and generationConfig response schema/MIME type options.";
+const LIVE_TRANSLATE_STRUCTURED_OUTPUT_ERROR = "Gemini 3.5 Live Translate does not support structured output. Remove responseSchema and generationConfig response schema/MIME type options.";
+const ROBOTICS_UNSUPPORTED_TOOL_ERROR = "Gemini Robotics ER 2 Streaming only supports function declarations and Google Search tools.";
+const ROBOTICS_API_VERSION_ERROR = "Gemini Robotics ER 2 Streaming requires apiVersion v1beta; remove the override or set apiVersion to v1beta.";
+const ROBOTICS_SUPPORTED_TOOL_FIELDS = /* @__PURE__ */ new Set(["functionDeclarations", "googleSearch"]);
+const LIVE_TRANSLATE_SILENCE_PEAK_THRESHOLD = 32;
+function hasStructuredOutputConfiguration(config) {
+	const generationConfig = config.generationConfig;
+	return config.responseSchema !== void 0 || generationConfig?.response_schema !== void 0 || generationConfig?.response_mime_type !== void 0 || generationConfig?.responseSchema !== void 0 || generationConfig?.responseMimeType !== void 0;
+}
+function hasCodeExecutionTool(tools) {
+	return tools.some((tool) => tool.codeExecution !== void 0 || tool.code_execution !== void 0);
+}
+function hasUnsupportedRoboticsGroundingTool(tools) {
+	return tools.some((tool) => {
+		const groundingTool = tool;
+		return groundingTool.googleMaps !== void 0 || groundingTool.google_maps !== void 0 || groundingTool.urlContext !== void 0 || groundingTool.url_context !== void 0;
+	});
+}
+function hasUnsupportedRoboticsFileSearchOrComputerUseTool(tools) {
+	return tools.some((tool) => {
+		const unsupportedTool = tool;
+		return unsupportedTool.computerUse !== void 0 || unsupportedTool.computer_use !== void 0 || unsupportedTool.fileSearch !== void 0 || unsupportedTool.file_search !== void 0;
+	});
+}
+function hasUnsupportedRoboticsTool(tools) {
+	return tools.some((tool) => {
+		const fields = Object.keys(tool);
+		return fields.length === 0 || fields.some((field) => !ROBOTICS_SUPPORTED_TOOL_FIELDS.has(field));
+	});
+}
+function getRoboticsConfigError(isRoboticsStreamingModel, config, responseModalities, tools) {
+	if (!isRoboticsStreamingModel) return;
+	if (responseModalities !== void 0 && (responseModalities.length !== 1 || responseModalities[0] !== "TEXT")) return ROBOTICS_TEXT_MODALITY_ERROR;
+	if (hasStructuredOutputConfiguration(config)) return ROBOTICS_STRUCTURED_OUTPUT_ERROR;
+	if (hasCodeExecutionTool(tools)) return ROBOTICS_CODE_EXECUTION_ERROR;
+	if (hasUnsupportedRoboticsFileSearchOrComputerUseTool(tools)) return ROBOTICS_FILE_SEARCH_OR_COMPUTER_USE_ERROR;
+	if (hasUnsupportedRoboticsGroundingTool(tools)) return ROBOTICS_GROUNDING_ERROR;
+	return hasUnsupportedRoboticsTool(tools) ? ROBOTICS_UNSUPPORTED_TOOL_ERROR : void 0;
+}
+function hasUnsupportedLiveTranslateToolsOrInstructions(config, systemInstruction) {
+	return (Array.isArray(config.tools) ? config.tools.length > 0 : Boolean(config.tools)) || config.tool_choice !== void 0 || config.toolConfig !== void 0 || config.tool_config !== void 0 || config.mcp?.enabled || Boolean(config.functionToolStatefulApi?.file) || Boolean(systemInstruction);
+}
+function hasUnsupportedLiveTranslateThinkingConfig(config) {
+	const generationConfig = config.generationConfig;
+	return generationConfig?.thinkingConfig !== void 0 || generationConfig?.thinking_config !== void 0;
+}
+function getEffectiveLiveTranslateServiceTier(mergedConfig, promptConfig) {
+	const providerPassthrough = mergedConfig.passthrough;
+	const promptPassthrough = promptConfig?.passthrough;
+	const providerServiceTier = providerPassthrough?.service_tier ?? providerPassthrough?.serviceTier ?? mergedConfig.service_tier;
+	return promptPassthrough?.service_tier ?? promptPassthrough?.serviceTier ?? promptConfig?.service_tier ?? providerServiceTier;
+}
+function hasMeaningfulPcm(audio) {
+	for (let offset = 0; offset + 1 < audio.length; offset += 2) if (Math.abs(audio.readInt16LE(offset)) > LIVE_TRANSLATE_SILENCE_PEAK_THRESHOLD) return true;
+	return false;
+}
+function getUnsupportedLiveTranslateConfigurationError(config, systemInstruction, responseModalities, serviceTier) {
+	if (responseModalities !== void 0 && (responseModalities.length !== 1 || responseModalities[0] !== "AUDIO")) return LIVE_TRANSLATE_AUDIO_MODALITY_ERROR;
+	return (hasUnsupportedLiveTranslateToolsOrInstructions(config, systemInstruction) ? "Gemini 3.5 Live Translate does not support tools or instructions." : void 0) ?? (hasStructuredOutputConfiguration(config) ? LIVE_TRANSLATE_STRUCTURED_OUTPUT_ERROR : void 0) ?? (serviceTier !== void 0 && serviceTier !== "standard" ? "Gemini 3.5 Live Translate does not support flex, priority, batch, or other non-standard inference tiers; remove service_tier/serviceTier or set it to standard." : void 0);
+}
+const formatContentMessages = (contents, contentIndex, useRealtimeTextInput = false, useManualAudioActivity = false, useClientContentText = false) => {
+	if (contents[contentIndex].role !== "user") throw new Error("Can only take user role inputs.");
+	const parts = contents[contentIndex].parts;
+	if (useClientContentText && parts.every((part) => typeof part.text === "string")) return [{ clientContent: {
+		turns: [{
+			role: "user",
+			parts
+		}],
+		turnComplete: true
+	} }];
+	if (useRealtimeTextInput) {
+		const mappedMessages = parts.map((part) => {
+			const userPart = part;
+			if (userPart.text !== void 0) return { realtimeInput: { text: userPart.text } };
+			const inlineData = userPart.inlineData ?? userPart.inline_data;
+			if (inlineData) {
+				const mimeType = "mimeType" in inlineData ? inlineData.mimeType : inlineData.mime_type;
+				if (mimeType.startsWith("video/")) throw new Error("Google Live video input must be sent as individual image/jpeg or image/png frames (maximum 1 frame per second).");
+				if (mimeType.startsWith("audio/") && !mimeType.startsWith("audio/pcm")) throw new Error(`Unsupported Google Live realtime input MIME type: ${mimeType}. Audio input must be raw 16-bit PCM (for example, audio/pcm;rate=16000).`);
+				if (!mimeType.startsWith("audio/") && mimeType !== "image/jpeg" && mimeType !== "image/png") throw new Error(`Unsupported Google Live realtime input MIME type: ${mimeType}`);
+				return { realtimeInput: { [mimeType.startsWith("audio/") ? "audio" : "video"]: {
+					mimeType,
+					data: inlineData.data
+				} } };
+			}
+			throw new Error("Unsupported part in Google Live realtime input.");
+		});
+		const textMessages = mappedMessages.filter((message) => "text" in message.realtimeInput);
+		const contentMessages = mappedMessages.filter((message) => !("text" in message.realtimeInput));
+		if (useClientContentText && textMessages.length > 0) {
+			const text = textMessages.map((message) => message.realtimeInput.text).join("\n");
+			const hasAudio = contentMessages.some((message) => "audio" in message.realtimeInput);
+			const clientContent = { clientContent: {
+				turns: [{
+					role: "user",
+					parts: [{ text }]
+				}],
+				turnComplete: !hasAudio
+			} };
+			if (hasAudio) return [
+				clientContent,
+				{ realtimeInput: { activityStart: {} } },
+				...contentMessages,
+				{ realtimeInput: { activityEnd: {} } }
+			];
+			return [...contentMessages, clientContent];
+		}
+		if (textMessages.length > 0) contentMessages.push({ realtimeInput: { text: textMessages.map((message) => message.realtimeInput.text).join("\n") } });
+		if (contentMessages.some((message) => "audio" in message.realtimeInput)) {
+			if (useManualAudioActivity) return [
+				{ realtimeInput: { activityStart: {} } },
+				...contentMessages,
+				{ realtimeInput: { activityEnd: {} } }
+			];
+			contentMessages.push({ realtimeInput: { audioStreamEnd: true } });
+		} else if (contentMessages.some((message) => "video" in message.realtimeInput) && textMessages.length === 0) contentMessages.push({ clientContent: { turnComplete: true } });
+		return contentMessages;
+	}
+	if (parts.length !== 1) throw new Error("Unexpected number of parts in user input.");
+	return [{ client_content: {
+		turns: [{
+			role: "user",
+			parts: [{ text: parts[0].text }]
+		}],
+		turn_complete: true
+	} }];
+};
+const getModalityTokenCount = (details, modality) => {
+	if (!Array.isArray(details)) return 0;
+	return details.reduce((total, detail) => {
+		const count = detail?.tokenCount ?? detail?.token_count;
+		return detail?.modality === modality && typeof count === "number" && Number.isFinite(count) ? total + Math.max(count, 0) : total;
+	}, 0);
+};
+const getTokenCount = (...values) => {
+	const value = values.find((entry) => typeof entry === "number" && Number.isFinite(entry));
+	return typeof value === "number" ? Math.max(value, 0) : 0;
+};
+const getGemini38ConfigError = (generationConfig, extendedThinking) => {
+	const thinking = generationConfig?.thinkingConfig;
+	if (!extendedThinking && thinking) return "gemini-3.8-live does not support thinkingConfig. Use gemini-3.8-live-extended-thinking instead.";
+	if (thinking?.thinkingBudget !== void 0) return "gemini-3.8-live-extended-thinking does not support thinkingBudget. Use thinkingLevel LOW, MEDIUM, or HIGH.";
+	if (thinking?.thinkingLevel !== void 0 && ![
+		"LOW",
+		"MEDIUM",
+		"HIGH"
+	].includes(thinking.thinkingLevel)) return "gemini-3.8-live-extended-thinking supports thinkingLevel LOW, MEDIUM, or HIGH.";
+	if (generationConfig?.enableAffectiveDialog !== void 0) return "Gemini 3.8 Live does not support enableAffectiveDialog.";
+	if (generationConfig?.proactivity?.proactiveAudio === false) return "Gemini 3.8 Live has permanently enabled proactive audio; proactivity.proactiveAudio cannot be false.";
+};
+/**
+* Helper function to fetch JSON with error handling
+*/
+const fetchJson = async (url, options) => {
+	const response = await fetchWithProxy(url, options);
+	if (!response.ok) throw new Error(`HTTP error - status: ${response.status}`);
+	return response.json();
+};
+/**
+* Helper function to try GET with query params, fallback to POST with JSON body
+*/
+const tryGetThenPost = async (url, data) => {
+	try {
+		const urlWithParams = new URL(url);
+		if (data) {
+			const params = typeof data === "string" ? JSON.parse(data) : data;
+			Object.entries(params).forEach(([key, value]) => {
+				urlWithParams.searchParams.append(key, String(value));
+			});
+		}
+		return await fetchJson(urlWithParams.href);
+	} catch {
+		return fetchJson(url, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: data ? JSON.stringify(typeof data === "string" ? JSON.parse(data) : data) : null
+		});
+	}
+};
+var GoogleLiveProvider = class {
+	config;
+	modelName;
+	env;
+	isVertex = false;
+	loadedFunctionCallbacks = {};
+	constructor(modelName, options) {
+		this.modelName = modelName;
+		this.config = options.config || {};
+		this.env = options.env;
+	}
+	validateFunctionToolCall(output, vars) {
+		validateFunctionCall(output, this.config.tools, vars);
+	}
+	id() {
+		return `google:live:${this.modelName}`;
+	}
+	toString() {
+		return `[Google Live Provider ${this.modelName}]`;
+	}
+	convertPcmToWav(pcmBuffer) {
+		const wavBuffer = this.createWavHeader(pcmBuffer.length, 24e3, 16, 1);
+		return Buffer.concat([wavBuffer, pcmBuffer]).toString("base64");
+	}
+	createWavHeader(dataLength, sampleRate, bitsPerSample, channels) {
+		const header = Buffer.alloc(44);
+		header.write("RIFF", 0);
+		header.writeUInt32LE(36 + dataLength, 4);
+		header.write("WAVE", 8);
+		header.write("fmt ", 12);
+		header.writeUInt32LE(16, 16);
+		header.writeUInt16LE(1, 20);
+		header.writeUInt16LE(channels, 22);
+		header.writeUInt32LE(sampleRate, 24);
+		header.writeUInt32LE(sampleRate * channels * bitsPerSample / 8, 28);
+		header.writeUInt16LE(channels * bitsPerSample / 8, 32);
+		header.writeUInt16LE(bitsPerSample, 34);
+		header.write("data", 36);
+		header.writeUInt32LE(dataLength, 40);
+		return header;
+	}
+	getApiKey() {
+		return resolveProviderApiKey({ apiKey: this.config.apiKey }, this.env, ["GOOGLE_API_KEY", "GEMINI_API_KEY"]);
+	}
+	async getAccessToken(config) {
+		const credentials = loadCredentials(config.credentials);
+		return getGoogleAccessToken(credentials);
+	}
+	async getConnection(config) {
+		const apiKey = config.apiKey || (config.credentials ? void 0 : this.getApiKey());
+		const accessToken = apiKey ? void 0 : await this.getAccessToken(config);
+		if (!accessToken && !apiKey) throw new Error("Google authentication is not configured. For the Live API, set apiKey in the provider config, GOOGLE_API_KEY, or GEMINI_API_KEY. Alternatively, configure OAuth2 credentials; see https://ai.google.dev/gemini-api/docs/oauth.");
+		const prefersV1beta = this.modelName === GEMINI_LIVE_TRANSLATE_MODEL || this.modelName.startsWith("gemini-robotics-er-2-streaming-") || this.modelName.startsWith("gemini-3.1-flash-live") || this.modelName.startsWith("gemini-2.5-flash-native-audio-") || this.modelName.startsWith("gemini-live-2.5-flash-preview-native-audio-");
+		const apiVersion = config.apiVersion || (prefersV1beta ? "v1beta" : "v1alpha");
+		return {
+			url: `wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.${apiVersion}.GenerativeService.BidiGenerateContent?${accessToken ? `access_token=${accessToken}` : `key=${apiKey}`}`,
+			model: `models/${this.modelName}`,
+			apiVersion
+		};
+	}
+	async callApi(prompt, context) {
+		const isGemini38Live = this.modelName === "gemini-3.8-live" || this.modelName === "gemini-3.8-live-extended-thinking";
+		const usesInteractionStatus = this.modelName === "gemini-3.8-live-extended-thinking";
+		const promptConfig = context?.prompt?.config;
+		const config = mergeGoogleCompletionOptions(this.config, promptConfig);
+		const promptBasePath = promptConfig?.basePath ?? this.config.basePath;
+		const supportsTextResponse = this.modelName.startsWith("gemini-robotics-er-2-streaming-");
+		const configuredResponseModalities = (config.generationConfig?.response_modalities ?? config.generationConfig?.responseModalities)?.map((modality) => modality.toUpperCase());
+		if (isGemini38Live) {
+			const error = getGemini38ConfigError(config.generationConfig, usesInteractionStatus);
+			if (error) return { error };
+		}
+		const connection = await this.getConnection(config);
+		const usesRealtimeTextInput = isGemini38Live || connection.apiVersion === "v1beta" || this.isVertex;
+		const { toolConfig, toolsDisabled } = resolveGoogleToolConfig(config);
+		const { contents, systemInstruction } = geminiFormatAndSystemInstructions(prompt, context?.vars, config.systemInstruction, {
+			basePath: promptConfig?.systemInstruction === void 0 ? this.config.basePath : promptBasePath,
+			useAssistantRole: config.useAssistantRole
+		});
+		const useManualAudioActivity = (isGemini38Live || this.isVertex) && contents.some((content) => content.parts.some((part) => {
+			const audioPart = part;
+			return (audioPart.inlineData?.mimeType ?? audioPart.inline_data?.mime_type)?.startsWith("audio/");
+		}));
+		let contentIndex = 0;
+		if (this.modelName === GEMINI_LIVE_TRANSLATE_MODEL) {
+			const translationConfig = config.generationConfig?.translationConfig;
+			if (!translationConfig) return { error: "Gemini 3.5 Live Translate requires generationConfig.translationConfig (targetLanguageCode defaults to en)." };
+			if (translationConfig.targetLanguageCode !== void 0 && (typeof translationConfig.targetLanguageCode !== "string" || translationConfig.targetLanguageCode.trim().length === 0)) return { error: "Gemini 3.5 Live Translate requires a non-empty targetLanguageCode in generationConfig.translationConfig when provided." };
+			if (translationConfig.targetLanguageCode === void 0) config.generationConfig = {
+				...config.generationConfig,
+				translationConfig: {
+					...translationConfig,
+					targetLanguageCode: "en"
+				}
+			};
+			if (hasUnsupportedLiveTranslateThinkingConfig(config)) return { error: "Gemini 3.5 Live Translate does not support generationConfig.thinkingConfig or generationConfig.thinking_config; remove the thinking configuration." };
+			if (!this.isVertex && config.apiVersion && config.apiVersion !== "v1beta") return { error: "Gemini 3.5 Live Translate requires apiVersion v1beta; remove the override or set apiVersion to v1beta." };
+			const unsupportedConfigurationError = getUnsupportedLiveTranslateConfigurationError(config, systemInstruction, configuredResponseModalities, getEffectiveLiveTranslateServiceTier(config, promptConfig));
+			if (unsupportedConfigurationError) return { error: unsupportedConfigurationError };
+			if (!(contents.length > 0 && contents.every((content) => content.role === "user" && content.parts.length > 0 && content.parts.every((part) => {
+				const inlineData = part.inlineData ?? part.inline_data;
+				return (inlineData?.mimeType ?? inlineData?.mime_type)?.toLowerCase() === "audio/pcm;rate=16000" && typeof inlineData?.data === "string" && inlineData.data.trim().length > 0;
+			})))) return { error: "Gemini 3.5 Live Translate only supports raw PCM audio input with MIME type audio/pcm;rate=16000 (16-bit mono) and non-empty base64 data; text, image, video, missing sample rates, and other sample rates are not supported." };
+		}
+		const configTools = toolsDisabled ? stripExecutableToolFileReferences(config.tools, context?.vars) : config.tools;
+		const fileTools = configTools ? await maybeLoadToolsFromExternalFile(configTools, context?.vars) : [];
+		const normalizedTools = fileTools ? normalizeTools(Array.isArray(fileTools) ? fileTools : [fileTools]) : [];
+		const requestTools = toolsDisabled ? removeGoogleFunctionDeclarations(normalizedTools) : normalizedTools;
+		if (supportsTextResponse && !this.isVertex && config.apiVersion && config.apiVersion !== "v1beta") return { error: ROBOTICS_API_VERSION_ERROR };
+		const roboticsConfigError = getRoboticsConfigError(supportsTextResponse, config, configuredResponseModalities, requestTools);
+		if (roboticsConfigError) return { error: roboticsConfigError };
+		if (usesInteractionStatus) for (const tool of requestTools) {
+			if (tool.functionDeclarations?.some((declaration) => declaration.behavior === "BLOCKING")) return { error: "gemini-3.8-live-extended-thinking requires NON_BLOCKING function declarations." };
+			if (tool.functionDeclarations) tool.functionDeclarations = tool.functionDeclarations.map((declaration) => ({
+				...declaration,
+				behavior: "NON_BLOCKING"
+			}));
+		}
+		let statefulApi;
+		if (!toolsDisabled && config.functionToolStatefulApi?.file) try {
+			const pythonPath = await validatePythonPath(config.functionToolStatefulApi.pythonExecutable || getEnvString("PROMPTFOO_PYTHON") || "python3", !!config.functionToolStatefulApi.pythonExecutable || !!getEnvString("PROMPTFOO_PYTHON"));
+			logger.debug(`Spawning API with Python executable: ${pythonPath}`);
+			statefulApi = spawn(pythonPath, [config.functionToolStatefulApi.file], { env: getProcessEnv() });
+			statefulApi.on("error", (err) => {
+				logger.error(`Error spawning Python process: ${JSON.stringify(err)}`);
+			});
+			statefulApi.stdout?.on("data", (data) => {
+				logger.debug(`Python API stdout: ${data.toString()}`);
+			});
+			statefulApi.stderr?.on("data", (data) => {
+				logger.error(`Python API stderr: ${data.toString()}`);
+			});
+			await new Promise((resolve) => setTimeout(resolve, 1e3));
+			logger.debug("Stateful API process started");
+		} catch (err) {
+			logger.error(`Failed to spawn Python API: ${JSON.stringify(err)}`);
+		}
+		const WebSocketCtor = (await import("ws")).default;
+		return new Promise((resolve) => {
+			const isNativeAudioModel = this.modelName.includes("native-audio");
+			let isResolved = false;
+			let liveTranslateCompletionTimeout;
+			let liveTranslateHardTimeout;
+			let timeout;
+			let cancelFinalStateRetrieval;
+			let statefulApiCleanupStarted = false;
+			let armLiveTranslateCompletion = () => {};
+			let armLiveTranslateHardTimeout = () => {};
+			const safeResolve = (response) => {
+				if (!isResolved) {
+					isResolved = true;
+					clearTimeout(timeout);
+					clearTimeout(liveTranslateCompletionTimeout);
+					clearTimeout(liveTranslateHardTimeout);
+					cancelFinalStateRetrieval?.(/* @__PURE__ */ new Error("Final state retrieval cancelled"));
+					if (statefulApi && !statefulApiCleanupStarted) {
+						statefulApiCleanupStarted = true;
+						try {
+							statefulApi.kill("SIGTERM");
+						} catch (error) {
+							logger.error("Failed to terminate stateful API process", { error });
+						}
+					}
+					resolve(response);
+				}
+			};
+			const ws = connection.headers ? new WebSocketCtor(connection.url, { headers: connection.headers }) : new WebSocketCtor(connection.url);
+			let response_text_total = "";
+			const responseAudioChunks = [];
+			let response_audio_transcript = "";
+			let hasAudioContent = false;
+			const function_calls_total = [];
+			let statefulApiState = void 0;
+			const usageMetadata = [];
+			let pendingUsageMetadata;
+			let completedGenerations = 0;
+			let completedTurns = 0;
+			let hasPendingToolFollowup = false;
+			let receivedMessageIndex = 0;
+			let lastToolResponseMessageIndex = 0;
+			let lastVideoFrameSentAt = 0;
+			let hasFinalized = false;
+			let liveTranslateInputEnded = false;
+			const requestedText = configuredResponseModalities?.includes("TEXT") ?? false;
+			const responseModalities = usesRealtimeTextInput && !supportsTextResponse ? configuredResponseModalities?.filter((modality) => modality !== "TEXT") : configuredResponseModalities;
+			const effectiveResponseModalities = supportsTextResponse && responseModalities === void 0 ? ["TEXT"] : usesRealtimeTextInput && !supportsTextResponse && !responseModalities?.length ? ["AUDIO"] : responseModalities;
+			if (requestedText && !effectiveResponseModalities?.includes("TEXT")) logger.warn(`[Google Live] ${this.modelName} does not support TEXT response modality; requesting AUDIO with output transcription instead. Audio output is billed at audio rates.`);
+			const isTextExpected = effectiveResponseModalities?.includes("TEXT") ?? false;
+			const isAudioExpected = effectiveResponseModalities?.includes("AUDIO") ?? false;
+			let hasTextStreamEnded = !isTextExpected;
+			let hasAudioStreamEnded = !isAudioExpected;
+			const sendContentMessages = async (contentMessages) => {
+				if (this.modelName === GEMINI_LIVE_TRANSLATE_MODEL) {
+					liveTranslateInputEnded = false;
+					clearTimeout(liveTranslateHardTimeout);
+					liveTranslateHardTimeout = void 0;
+				}
+				for (const contentMessage of contentMessages) {
+					if (contentMessage.realtimeInput?.video) {
+						const delayMs = Math.max(lastVideoFrameSentAt + 1e3 - Date.now(), 0);
+						if (delayMs > 0) await new Promise((resolve) => setTimeout(resolve, delayMs));
+						if (isResolved) return;
+						lastVideoFrameSentAt = Date.now();
+					}
+					ws.send(JSON.stringify(contentMessage));
+					if (this.modelName === GEMINI_LIVE_TRANSLATE_MODEL && contentMessage.realtimeInput?.audioStreamEnd) {
+						liveTranslateInputEnded = true;
+						armLiveTranslateHardTimeout();
+					}
+				}
+			};
+			const hasOutputTranscription = !!config.generationConfig?.outputAudioTranscription || isGemini38Live || this.isVertex || usesRealtimeTextInput && !supportsTextResponse && requestedText;
+			const videoFrameCount = contents.reduce((total, content) => total + content.parts.filter((part) => {
+				const inlineData = part.inlineData ?? part.inline_data;
+				const mimeType = inlineData?.mimeType ?? inlineData?.mime_type;
+				return mimeType === "image/jpeg" || mimeType === "image/png";
+			}).length, 0);
+			const framePacingAllowanceMs = Math.max(videoFrameCount - 1, 0) * 1e3;
+			const effectiveTimeoutMs = (config.timeoutMs || 3e4) + framePacingAllowanceMs;
+			const liveTranslateCompletionGraceMs = Math.min(4e3, Math.max(1, Math.floor(effectiveTimeoutMs / 2)));
+			const liveTranslateHardDeadlineMs = effectiveTimeoutMs + liveTranslateCompletionGraceMs;
+			const armIdleTimeout = () => {
+				clearTimeout(timeout);
+				if (isResolved || hasFinalized) return;
+				timeout = setTimeout(() => {
+					logger.error(`WebSocket connection timed out after ${effectiveTimeoutMs}ms of inactivity`);
+					ws.close();
+					safeResolve({ error: `WebSocket request timed out after ${effectiveTimeoutMs}ms of inactivity` });
+				}, effectiveTimeoutMs);
+			};
+			armIdleTimeout();
+			armLiveTranslateHardTimeout = () => {
+				clearTimeout(liveTranslateHardTimeout);
+				liveTranslateHardTimeout = setTimeout(() => {
+					liveTranslateHardTimeout = void 0;
+					logger.error(`WebSocket request timed out after ${liveTranslateHardDeadlineMs}ms waiting for Live Translate output`);
+					ws.close();
+					safeResolve({ error: `WebSocket request timed out after ${liveTranslateHardDeadlineMs}ms waiting for Live Translate output` });
+				}, liveTranslateHardDeadlineMs);
+			};
+			const sendNextContentMessages = async (isMultiTurn = false) => {
+				if (contentIndex >= contents.length) return;
+				clearTimeout(liveTranslateCompletionTimeout);
+				liveTranslateCompletionTimeout = void 0;
+				const contentMessages = formatContentMessages(contents, contentIndex, usesRealtimeTextInput, useManualAudioActivity, this.isVertex && !isGemini38Live);
+				contentIndex += 1;
+				armIdleTimeout();
+				logger.debug(isMultiTurn ? "WebSocket sent (multi-turn)" : "WebSocket sent", { messageCount: contentMessages.length });
+				await sendContentMessages(contentMessages);
+			};
+			const finalizeResponse = async () => {
+				if (hasFinalized || isResolved) {
+					logger.debug("Response already finalized or resolved, skipping finalization");
+					return;
+				}
+				hasFinalized = true;
+				clearTimeout(liveTranslateCompletionTimeout);
+				clearTimeout(liveTranslateHardTimeout);
+				if (pendingUsageMetadata) {
+					usageMetadata.push(pendingUsageMetadata);
+					pendingUsageMetadata = void 0;
+				}
+				if (ws.readyState === WebSocketCtor.OPEN) ws.close();
+				clearTimeout(timeout);
+				if (!isResolved && !toolsDisabled && config.functionToolStatefulApi) {
+					const controller = new AbortController();
+					const finalStateTimeoutMs = config.timeoutMs || 3e4;
+					let finalStateTimeout;
+					const cancelled = new Promise((_, reject) => {
+						cancelFinalStateRetrieval = (reason) => {
+							clearTimeout(finalStateTimeout);
+							reject(reason);
+							controller.abort();
+						};
+						finalStateTimeout = setTimeout(() => {
+							cancelFinalStateRetrieval?.(/* @__PURE__ */ new Error(`Final state retrieval timed out after ${finalStateTimeoutMs}ms`));
+						}, finalStateTimeoutMs);
+					});
+					try {
+						const url = new URL("get_state", config.functionToolStatefulApi.url).href;
+						const state = await Promise.race([fetchJson(url, { signal: controller.signal }), cancelled]);
+						if (isResolved) return;
+						statefulApiState = state;
+						logger.debug(`Stateful api state: ${JSON.stringify(statefulApiState)}`);
+					} catch (err) {
+						if (!isResolved) logger.error("Error retrieving final state of api", { error: err });
+					} finally {
+						clearTimeout(finalStateTimeout);
+						cancelFinalStateRetrieval = void 0;
+					}
+				}
+				if (isResolved) return;
+				let outputText = response_text_total;
+				let thinking = void 0;
+				if (hasAudioContent && response_audio_transcript) {
+					if (response_text_total) {
+						thinking = response_text_total;
+						outputText = response_audio_transcript;
+					} else outputText = response_audio_transcript;
+				}
+				const result = {
+					output: {
+						text: outputText,
+						toolCall: { functionCalls: function_calls_total },
+						statefulApiState,
+						...thinking && { thinking }
+					},
+					metadata: {}
+				};
+				if (usageMetadata.length > 0) {
+					const promptTokens = usageMetadata.reduce((total, usage) => total + getTokenCount(usage.promptTokenCount, usage.prompt_token_count) + getTokenCount(usage.toolUsePromptTokenCount, usage.tool_use_prompt_token_count), 0);
+					const responseTokens = usageMetadata.reduce((total, usage) => total + getTokenCount(usage.responseTokenCount, usage.candidatesTokenCount, usage.response_token_count, usage.candidates_token_count), 0);
+					const thoughtTokens = usageMetadata.reduce((total, usage) => total + getTokenCount(usage.thoughtsTokenCount, usage.thoughts_token_count), 0);
+					const billableCompletionTokens = usageMetadata.reduce((total, usage) => {
+						const promptTokenCount = getTokenCount(usage.promptTokenCount, usage.prompt_token_count);
+						const toolUsePromptTokenCount = getTokenCount(usage.toolUsePromptTokenCount, usage.tool_use_prompt_token_count);
+						const responseTokenCount = getTokenCount(usage.responseTokenCount, usage.candidatesTokenCount, usage.response_token_count, usage.candidates_token_count);
+						const totalTokenCount = getTokenCount(usage.totalTokenCount, usage.total_token_count);
+						const thoughtsTokenCount = getTokenCount(usage.thoughtsTokenCount, usage.thoughts_token_count);
+						const thoughtsIncluded = totalTokenCount > 0 && (totalTokenCount === promptTokenCount + responseTokenCount || totalTokenCount === promptTokenCount + toolUsePromptTokenCount + responseTokenCount);
+						return total + responseTokenCount + (thoughtsIncluded ? 0 : thoughtsTokenCount);
+					}, 0);
+					const audioPromptTokens = usageMetadata.reduce((total, usage) => {
+						const details = usage.promptTokensDetails ?? usage.prompt_tokens_details;
+						if (this.modelName === GEMINI_LIVE_TRANSLATE_MODEL && (!Array.isArray(details) || details.length === 0)) return total + getTokenCount(usage.promptTokenCount, usage.prompt_token_count) + getTokenCount(usage.toolUsePromptTokenCount, usage.tool_use_prompt_token_count);
+						return total + getModalityTokenCount(details, "AUDIO") + getModalityTokenCount(usage.toolUsePromptTokensDetails ?? usage.tool_use_prompt_tokens_details, "AUDIO");
+					}, 0);
+					const audioCompletionTokens = usageMetadata.reduce((total, usage) => {
+						const details = usage.responseTokensDetails ?? usage.candidatesTokensDetails ?? usage.response_tokens_details ?? usage.candidates_tokens_details;
+						if (this.modelName === GEMINI_LIVE_TRANSLATE_MODEL && (!Array.isArray(details) || details.length === 0)) return total + getTokenCount(usage.responseTokenCount, usage.candidatesTokenCount, usage.response_token_count, usage.candidates_token_count);
+						return total + getModalityTokenCount(details, "AUDIO");
+					}, 0);
+					const imagePromptTokens = usageMetadata.reduce((total, usage) => total + getModalityTokenCount(usage.promptTokensDetails ?? usage.prompt_tokens_details, "IMAGE") + getModalityTokenCount(usage.toolUsePromptTokensDetails ?? usage.tool_use_prompt_tokens_details, "IMAGE") + getModalityTokenCount(usage.promptTokensDetails ?? usage.prompt_tokens_details, "DOCUMENT") + getModalityTokenCount(usage.toolUsePromptTokensDetails ?? usage.tool_use_prompt_tokens_details, "DOCUMENT"), 0);
+					const videoPromptTokens = usageMetadata.reduce((total, usage) => total + getModalityTokenCount(usage.promptTokensDetails ?? usage.prompt_tokens_details, "VIDEO") + getModalityTokenCount(usage.toolUsePromptTokensDetails ?? usage.tool_use_prompt_tokens_details, "VIDEO"), 0);
+					const cachedPromptTokens = usageMetadata.reduce((total, usage) => total + getTokenCount(usage.cachedContentTokenCount, usage.cached_content_token_count), 0);
+					const cachedAudioPromptTokens = usageMetadata.reduce((total, usage) => total + getModalityTokenCount(usage.cacheTokensDetails ?? usage.cache_tokens_details, "AUDIO"), 0);
+					const cachedImagePromptTokens = usageMetadata.reduce((total, usage) => total + getModalityTokenCount(usage.cacheTokensDetails ?? usage.cache_tokens_details, "IMAGE") + getModalityTokenCount(usage.cacheTokensDetails ?? usage.cache_tokens_details, "DOCUMENT"), 0);
+					const cachedVideoPromptTokens = usageMetadata.reduce((total, usage) => total + getModalityTokenCount(usage.cacheTokensDetails ?? usage.cache_tokens_details, "VIDEO"), 0);
+					const videoInputPerSecond = GOOGLE_MODELS.find((model) => model.id === this.modelName)?.cost?.videoInputPerSecond;
+					const billVideoPerSecond = videoFrameCount > 0 && videoInputPerSecond !== void 0 && (videoPromptTokens > 0 || imagePromptTokens === 0);
+					const billableVideoFrameCount = videoPromptTokens > 0 ? Math.min(videoFrameCount, Math.ceil(videoPromptTokens / 263)) : videoFrameCount;
+					result.tokenUsage = {
+						prompt: promptTokens,
+						completion: responseTokens,
+						total: usageMetadata.reduce((total, usage) => total + getTokenCount(usage.totalTokenCount, usage.total_token_count), 0),
+						numRequests: usageMetadata.length,
+						...cachedPromptTokens > 0 ? { cached: cachedPromptTokens } : {},
+						...thoughtTokens > 0 ? { completionDetails: { reasoning: thoughtTokens } } : {}
+					};
+					const costPromptTokens = this.modelName === GEMINI_LIVE_TRANSLATE_MODEL ? audioPromptTokens : Math.max(promptTokens - (billVideoPerSecond ? videoPromptTokens : 0), 0);
+					const costCompletionTokens = this.modelName === GEMINI_LIVE_TRANSLATE_MODEL ? audioCompletionTokens : billableCompletionTokens;
+					const tokenCost = calculateGoogleCost(this.modelName, config, costPromptTokens, costCompletionTokens, this.isVertex, audioPromptTokens, audioCompletionTokens, void 0, imagePromptTokens + (billVideoPerSecond ? 0 : videoPromptTokens), Math.max(cachedPromptTokens - (billVideoPerSecond ? cachedVideoPromptTokens : 0), 0), cachedAudioPromptTokens, cachedImagePromptTokens + (billVideoPerSecond ? 0 : cachedVideoPromptTokens));
+					result.cost = tokenCost === void 0 ? void 0 : tokenCost + (billVideoPerSecond ? billableVideoFrameCount * videoInputPerSecond : 0);
+				}
+				if (hasAudioContent && responseAudioChunks.length > 0) result.audio = {
+					data: this.convertPcmToWav(Buffer.concat(responseAudioChunks)),
+					format: "wav",
+					transcript: response_audio_transcript || response_text_total || void 0
+				};
+				safeResolve(result);
+			};
+			armLiveTranslateCompletion = () => {
+				if (this.modelName !== GEMINI_LIVE_TRANSLATE_MODEL || !liveTranslateInputEnded || hasFinalized || isResolved) return;
+				clearTimeout(liveTranslateHardTimeout);
+				liveTranslateHardTimeout = void 0;
+				clearTimeout(liveTranslateCompletionTimeout);
+				liveTranslateCompletionTimeout = setTimeout(() => {
+					liveTranslateCompletionTimeout = void 0;
+					(async () => {
+						if (contentIndex < contents.length) {
+							await sendNextContentMessages(true);
+							return;
+						}
+						await finalizeResponse();
+					})().catch((err) => {
+						logger.error(`Error advancing Live Translate response: ${err}`);
+						safeResolve({ error: `Error advancing Live Translate response: ${err}` });
+					});
+				}, liveTranslateCompletionGraceMs);
+			};
+			ws.onopen = () => {
+				logger.debug("WebSocket connection is opening...");
+				const { speechConfig: generationSpeechConfig, response_modalities: _responseModalities, responseModalities: _camelResponseModalities, outputAudioTranscription: configuredOutputAudioTranscription, inputAudioTranscription, enableAffectiveDialog, proactivity, ...restGenerationConfig } = config.generationConfig || {};
+				const speechConfig = generationSpeechConfig ?? config.speechConfig;
+				const outputAudioTranscription = configuredOutputAudioTranscription ?? (isGemini38Live || this.isVertex || usesRealtimeTextInput && !supportsTextResponse && requestedText ? {} : void 0);
+				let formattedSpeechConfig;
+				if (speechConfig) formattedSpeechConfig = {
+					...speechConfig.voiceConfig && { [usesRealtimeTextInput ? "voiceConfig" : "voice_config"]: { [usesRealtimeTextInput ? "prebuiltVoiceConfig" : "prebuilt_voice_config"]: { [usesRealtimeTextInput ? "voiceName" : "voice_name"]: speechConfig.voiceConfig.prebuiltVoiceConfig?.voiceName } } },
+					...speechConfig.languageCode && { [usesRealtimeTextInput ? "languageCode" : "language_code"]: speechConfig.languageCode }
+				};
+				let formattedProactivity;
+				if (proactivity && !usesRealtimeTextInput) formattedProactivity = { proactive_audio: proactivity.proactiveAudio };
+				const setupMessage = { setup: {
+					model: connection.model,
+					...useManualAudioActivity ? { realtimeInputConfig: { automaticActivityDetection: { disabled: true } } } : {},
+					[usesRealtimeTextInput ? "generationConfig" : "generation_config"]: {
+						context: config.context,
+						examples: config.examples,
+						stopSequences: config.stopSequences,
+						temperature: config.temperature,
+						maxOutputTokens: config.maxOutputTokens,
+						topP: config.topP,
+						topK: config.topK,
+						...restGenerationConfig,
+						...usesInteractionStatus ? { thinkingConfig: {
+							thinkingLevel: "LOW",
+							...restGenerationConfig.thinkingConfig
+						} } : {},
+						...effectiveResponseModalities ? { [usesRealtimeTextInput ? "responseModalities" : "response_modalities"]: effectiveResponseModalities } : {},
+						...formattedSpeechConfig ? { [usesRealtimeTextInput ? "speechConfig" : "speech_config"]: formattedSpeechConfig } : {},
+						...enableAffectiveDialog && !usesRealtimeTextInput ? { enable_affective_dialog: enableAffectiveDialog } : {},
+						...formattedProactivity ? { proactivity: formattedProactivity } : {},
+						...this.modelName === GEMINI_LIVE_TRANSLATE_MODEL && inputAudioTranscription ? { inputAudioTranscription } : {},
+						...this.modelName === GEMINI_LIVE_TRANSLATE_MODEL && outputAudioTranscription ? { outputAudioTranscription } : {}
+					},
+					...toolConfig ? { toolConfig } : {},
+					...requestTools.length > 0 ? { tools: requestTools } : {},
+					...systemInstruction ? { systemInstruction } : {},
+					...this.modelName !== GEMINI_LIVE_TRANSLATE_MODEL && outputAudioTranscription ? { [usesRealtimeTextInput ? "outputAudioTranscription" : "output_audio_transcription"]: outputAudioTranscription } : {},
+					...this.modelName !== GEMINI_LIVE_TRANSLATE_MODEL && inputAudioTranscription ? { [usesRealtimeTextInput ? "inputAudioTranscription" : "input_audio_transcription"]: inputAudioTranscription } : {}
+				} };
+				logger.debug("Sending setup message", {
+					model: this.modelName,
+					hasTools: requestTools.length > 0,
+					hasSystemInstruction: !!systemInstruction
+				});
+				ws.send(JSON.stringify(setupMessage));
+			};
+			const processMessage = async (event, messageIndex) => {
+				if (isResolved) return;
+				armIdleTimeout();
+				logger.debug("WebSocket message received");
+				let responseData;
+				if (event.data instanceof ArrayBuffer || event.data instanceof Buffer) {
+					const dataString = event.data.toString("utf-8");
+					try {
+						JSON.parse(dataString);
+						responseData = dataString;
+					} catch {
+						hasAudioContent = true;
+						const audioBuffer = Buffer.isBuffer(event.data) ? event.data : Buffer.from(event.data);
+						responseAudioChunks.push(audioBuffer);
+						hasPendingToolFollowup = false;
+						if (isAudioExpected) hasAudioStreamEnded = false;
+						if (hasMeaningfulPcm(audioBuffer)) armLiveTranslateCompletion();
+						return;
+					}
+				} else if (typeof event.data === "string") responseData = event.data;
+				else {
+					logger.warn(`Unexpected event.data type: ${typeof event.data}`);
+					ws.close();
+					safeResolve({ error: "Unexpected response data format" });
+					return;
+				}
+				try {
+					const responseText = await new Response(responseData).text();
+					if (isResolved) return;
+					const response = JSON.parse(responseText);
+					if ((isGemini38Live || this.isVertex) && Object.keys(response).length === 0) return;
+					const interactionStatus = response.interactionStatus ?? response.interaction_status ?? response.serverContent?.interactionStatus ?? response.serverContent?.interaction_status;
+					const interactionComplete = usesInteractionStatus && interactionStatus === "IDLE";
+					const frameUsageMetadata = response.usageMetadata ?? response.usage_metadata;
+					if (frameUsageMetadata) pendingUsageMetadata = frameUsageMetadata;
+					if ((response.serverContent?.turnComplete || response.toolCall || interactionComplete) && pendingUsageMetadata) {
+						usageMetadata.push(pendingUsageMetadata);
+						pendingUsageMetadata = void 0;
+					}
+					if (response.error) {
+						logger.error(`Google Live API error: ${JSON.stringify(response.error)}`);
+						ws.close();
+						safeResolve({ error: `Google Live API error: ${JSON.stringify(response.error)}` });
+						return;
+					}
+					const messageType = response.setupComplete ? "setupComplete" : response.serverContent?.modelTurn ? "modelTurn" : response.serverContent?.generationComplete ? "generationComplete" : response.serverContent?.turnComplete ? "turnComplete" : response.toolCall ? "toolCall" : response.streamingCustomOp ? "streamingCustomOp" : "unknown";
+					logger.debug(`Message type: ${messageType}, hasAudioContent: ${hasAudioContent}, hasOutputTranscription: ${hasOutputTranscription}`);
+					if (response.setupComplete) await sendNextContentMessages();
+					else if (response.serverContent || interactionComplete) {
+						const serverContent = response.serverContent ?? {};
+						let hasMeaningfulLiveTranslateOutput = false;
+						const inputComplete = usesInteractionStatus ? interactionComplete && messageIndex > lastToolResponseMessageIndex : serverContent.turnComplete;
+						if (Boolean(serverContent.modelTurn?.parts?.length) || Boolean(serverContent.outputTranscription?.text) || !isGemini38Live && !this.isVertex && Boolean(serverContent.generationComplete)) hasPendingToolFollowup = false;
+						else if (!usesInteractionStatus && serverContent.turnComplete && hasPendingToolFollowup) {
+							hasPendingToolFollowup = false;
+							logger.debug("Ignoring Gemini Live bookkeeping turnComplete after a tool response.");
+							return;
+						}
+						if (serverContent.modelTurn?.parts) {
+							for (const part of serverContent.modelTurn.parts) {
+								if (part.text) {
+									response_text_total += part.text;
+									hasMeaningfulLiveTranslateOutput = true;
+								}
+								if (part.inlineData?.mimeType?.includes("audio")) {
+									hasAudioContent = true;
+									const audioChunk = Buffer.from(part.inlineData.data, "base64");
+									responseAudioChunks.push(audioChunk);
+									if (hasMeaningfulPcm(audioChunk)) hasMeaningfulLiveTranslateOutput = true;
+									if (isAudioExpected) hasAudioStreamEnded = false;
+								}
+							}
+							if (serverContent.outputTranscription?.text) {
+								response_audio_transcript += serverContent.outputTranscription.text;
+								hasMeaningfulLiveTranslateOutput = true;
+								if (isAudioExpected) hasAudioContent = true;
+							}
+						} else if (serverContent.outputTranscription?.text) {
+							response_audio_transcript += serverContent.outputTranscription.text;
+							hasMeaningfulLiveTranslateOutput = true;
+							if (isAudioExpected) hasAudioContent = true;
+						}
+						if (serverContent.generationComplete) {
+							completedGenerations += 1;
+							logger.debug(`Generation complete received - text expected: ${isTextExpected}, audio expected: ${isAudioExpected}, has transcription: ${hasOutputTranscription}`);
+							if (isTextExpected && !hasTextStreamEnded) hasTextStreamEnded = true;
+							if (isAudioExpected && !hasAudioStreamEnded && hasOutputTranscription) hasAudioStreamEnded = true;
+						}
+						if (hasMeaningfulLiveTranslateOutput) armLiveTranslateCompletion();
+						if (inputComplete && contentIndex < contents.length) {
+							completedTurns += 1;
+							hasTextStreamEnded = !isTextExpected;
+							hasAudioStreamEnded = !isAudioExpected;
+							await sendNextContentMessages(true);
+							return;
+						}
+						if (inputComplete && contentIndex >= contents.length) {
+							completedTurns += 1;
+							logger.debug(`Turn complete received - text expected: ${isTextExpected}, text ended: ${hasTextStreamEnded}, audio expected: ${isAudioExpected}, audio ended: ${hasAudioStreamEnded}, has audio: ${hasAudioContent}, has transcription: ${!!response_audio_transcript}`);
+							if (isTextExpected && !hasTextStreamEnded) hasTextStreamEnded = true;
+							if (isAudioExpected && !hasAudioStreamEnded) hasAudioStreamEnded = true;
+						}
+						if (inputComplete && Math.max(completedGenerations, completedTurns) >= contents.length && hasTextStreamEnded && hasAudioStreamEnded && contentIndex >= contents.length) try {
+							await finalizeResponse();
+						} catch (err) {
+							logger.error(`Error in finalizeResponse: ${err}`);
+							safeResolve({ error: `Error finalizing response: ${err}` });
+						}
+						return;
+					} else if (response.toolCall?.functionCalls) {
+						if (isResolved) return;
+						hasPendingToolFollowup = response.toolCall.functionCalls.some((functionCall) => Boolean(functionCall?.id && functionCall.name));
+						if (toolsDisabled) {
+							logger.warn("Ignoring function calls received while tools are disabled.");
+							for (const functionCall of response.toolCall.functionCalls) if (functionCall?.id && functionCall.name) {
+								const functionResponse = {
+									id: functionCall.id,
+									name: functionCall.name,
+									response: { error: "Tool calls are disabled for this request." }
+								};
+								const toolMessage = usesRealtimeTextInput ? { toolResponse: { functionResponses: [functionResponse] } } : { tool_response: { function_responses: functionResponse } };
+								lastToolResponseMessageIndex = receivedMessageIndex;
+								ws.send(JSON.stringify(toolMessage));
+							}
+						} else for (const functionCall of response.toolCall.functionCalls) {
+							function_calls_total.push(functionCall);
+							if (functionCall && functionCall.id && functionCall.name) {
+								let callbackResponse = {};
+								const functionName = functionCall.name;
+								try {
+									if (config.functionToolCallbacks?.[functionName]) callbackResponse = await this.executeFunctionCallback(functionName, JSON.stringify(typeof functionCall.args === "string" ? JSON.parse(functionCall.args) : functionCall.args), config.functionToolCallbacks, functionCall.id);
+									else if (config.functionToolStatefulApi) {
+										logger.warn("functionToolStatefulApi configured but no HTTP client implemented for it after cleanup.");
+										const baseUrl = new URL(functionName, config.functionToolStatefulApi.url).href;
+										try {
+											callbackResponse = await tryGetThenPost(baseUrl, functionCall.args);
+											logger.debug(`Stateful api response: ${JSON.stringify(callbackResponse)}`);
+										} catch (err) {
+											callbackResponse = { error: `Error executing function ${functionName}: ${JSON.stringify(err)}` };
+											logger.error(`Error executing function ${functionName}: ${JSON.stringify(err)}`);
+										}
+									}
+								} catch (err) {
+									callbackResponse = { error: `Error executing function ${functionName}: ${JSON.stringify(err)}` };
+									logger.error(`Error executing function ${functionName}: ${JSON.stringify(err)}`);
+								}
+								if (isResolved) return;
+								const functionResponse = {
+									id: functionCall.id,
+									name: functionName,
+									response: callbackResponse !== null && typeof callbackResponse === "object" && !Array.isArray(callbackResponse) ? callbackResponse : { result: callbackResponse }
+								};
+								const toolMessage = usesRealtimeTextInput ? { toolResponse: { functionResponses: [functionResponse] } } : { tool_response: { function_responses: functionResponse } };
+								logger.debug(`WebSocket sent: ${JSON.stringify(toolMessage)}`);
+								lastToolResponseMessageIndex = receivedMessageIndex;
+								ws.send(JSON.stringify(toolMessage));
+							}
+						}
+					} else if (frameUsageMetadata) logger.debug("Usage metadata update received.");
+					else if (response.sessionResumptionUpdate) logger.debug(`Session resumption update received: ${JSON.stringify(response.sessionResumptionUpdate)}`);
+					else if (response.realtimeInput?.mediaChunks) {
+						for (const chunk of response.realtimeInput.mediaChunks) if (chunk.mimeType?.includes("audio")) {
+							hasAudioContent = true;
+							responseAudioChunks.push(Buffer.from(chunk.data, "base64"));
+							hasPendingToolFollowup = false;
+						}
+					} else if (response.candidates?.[0]?.content?.parts) {
+						for (const part of response.candidates[0].content.parts) if (part.inlineData?.mimeType?.includes("audio")) {
+							hasAudioContent = true;
+							responseAudioChunks.push(Buffer.from(part.inlineData.data, "base64"));
+							hasPendingToolFollowup = false;
+						}
+					} else if (response.streamingCustomOp?.["type.googleapis.com/google.ai.generativelanguage.v1alpha.StreamingCustomOpOutput"]?.audioCompletionSignal) hasAudioStreamEnded = true;
+					else if (!response.setupComplete && !response.serverContent && !response.toolCall && !interactionStatus && !response.realtimeInput && !response.candidates && !response.streamingCustomOp) {
+						logger.warn(`Received unhandled WebSocket message structure: ${JSON.stringify(response).substring(0, 200)}`);
+						if (hasOutputTranscription && !isGemini38Live && !this.isVertex && hasAudioContent && isAudioExpected && !hasAudioStreamEnded) {
+							logger.debug("Unknown message with transcription enabled - marking audio as complete");
+							hasAudioStreamEnded = true;
+							if (hasTextStreamEnded) try {
+								await finalizeResponse();
+							} catch (err) {
+								logger.error(`Error in finalizeResponse: ${err}`);
+								safeResolve({ error: `Error finalizing response: ${err}` });
+							}
+						}
+					}
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					logger.error(`Failed to process WebSocket response: ${message}`);
+					ws.close();
+					safeResolve({ error: `Failed to process WebSocket response: ${message}` });
+				}
+			};
+			let messageQueue = Promise.resolve();
+			ws.onmessage = (event) => {
+				if (isResolved) return;
+				const messageIndex = ++receivedMessageIndex;
+				if (!isGemini38Live && !this.isVertex) return processMessage(event, messageIndex);
+				armIdleTimeout();
+				messageQueue = messageQueue.then(() => processMessage(event, messageIndex));
+				return messageQueue;
+			};
+			ws.onerror = (err) => {
+				const message = err.message || "Connection failed";
+				logger.error("Google Live WebSocket error", {
+					model: this.modelName,
+					message
+				});
+				if (isNativeAudioModel) logger.error(`Native audio model ${this.modelName} may not be available or may require different configuration`);
+				clearTimeout(timeout);
+				ws.close();
+				safeResolve({ error: `WebSocket error for model ${this.modelName}: ${message}` });
+			};
+			ws.onclose = (event) => {
+				logger.debug(`WebSocket connection closed. Code: ${event.code}, Reason: ${event.reason}, Clean: ${event.wasClean}`);
+				if (hasFinalized) return;
+				clearTimeout(timeout);
+				if (!isResolved) safeResolve({ error: `WebSocket connection closed unexpectedly. Code: ${event.code}, Reason: ${event.reason}` });
+			};
+		});
+	}
+	/**
+	* Loads a function from an external file
+	* @param fileRef The file reference in the format 'file://path/to/file:functionName'
+	* @returns The loaded function
+	*/
+	loadExternalFunction(fileRef) {
+		return loadProviderCallbackFromFileUrl(fileRef);
+	}
+	/**
+	* Executes a function callback with proper error handling
+	*/
+	async executeFunctionCallback(functionName, args, callbacks = this.config.functionToolCallbacks, callId) {
+		try {
+			const shouldUseSharedCache = callbacks === this.config.functionToolCallbacks;
+			let callback = shouldUseSharedCache ? this.loadedFunctionCallbacks[functionName] : void 0;
+			if (!callback) {
+				const callbackRef = callbacks?.[functionName];
+				if (callbackRef && typeof callbackRef === "string") {
+					const callbackStr = callbackRef;
+					if (callbackStr.startsWith("file://")) callback = await this.loadExternalFunction(callbackStr);
+					else callback = new Function("return " + callbackStr)();
+					if (shouldUseSharedCache && callback) this.loadedFunctionCallbacks[functionName] = callback;
+				} else if (typeof callbackRef === "function") {
+					callback = callbackRef;
+					if (shouldUseSharedCache) this.loadedFunctionCallbacks[functionName] = callback;
+				}
+			}
+			if (!callback) throw new Error(`No callback found for function '${functionName}'`);
+			logger.debug(`Executing function '${functionName}' with args: ${args}`);
+			return await withGenAIToolSpan({
+				name: functionName,
+				arguments: args,
+				callId
+			}, () => callback(args));
+		} catch (error) {
+			logger.error(`Error executing function '${functionName}': ${error.message || String(error)}`);
+			throw error;
+		}
+	}
+};
+//#endregion
+export { GoogleLiveProvider };
+
+//# sourceMappingURL=live-5g2w-M-E.js.map