kaijibot 2026.6.21 → 2026.6.22

package/dist/media-runtime-CGXSFOdW.js

@@ -0,0 +1,312 @@
+import { n as normalizeAccountId } from "./account-id-Dw-dpL-T.js";
+import { a as shouldLogVerbose, r as logVerbose } from "./globals-D7B2Z7Cq.js";
+import "./image-ops-BZH0MN6X.js";
+import "./mime-BGkwIl6g.js";
+import { b as sendTextMediaPayload } from "./reply-payload-b0t2HuMm.js";
+import { a as chunkText } from "./chunk-D7s4Rbj9.js";
+import "./local-roots-O1oG5GXB.js";
+import { l as saveMediaBuffer } from "./store-D9Jf-5mx.js";
+import "./fetch-ISrAe7UQ.js";
+import { t as loadWebMedia } from "./web-media-CHsPL1ie.js";
+import "./entry-capabilities-BSz58Ocn.js";
+import "./resolve-BF5HlfJ2.js";
+import "./image-runtime-B76ETuEi.js";
+import { a as runCapability, i as resolveMediaAttachmentLocalRoots, o as createMediaAttachmentCache, s as normalizeMediaAttachments, t as buildProviderRegistry, v as isAudioAttachment } from "./runner-BhfpNH-y.js";
+import { t as buildOutboundMediaLoadOptions } from "./load-options-DMyZ__uP.js";
+import "./audio-Bd1Fa6k7.js";
+import "./agent-media-payload-Bih8avK2.js";
+import { t as sanitizeForPlainText } from "./sanitize-text-DrpmU2ko.js";
+import "./outbound-runtime-BlaC4B59.js";
+import fs from "node:fs/promises";
+import { deflateSync } from "node:zlib";
+import QRCodeModule from "qrcode-terminal/vendor/QRCode/index.js";
+import QRErrorCorrectLevelModule from "qrcode-terminal/vendor/QRCode/QRErrorCorrectLevel.js";
+//#region src/media/outbound-attachment.ts
+async function resolveOutboundAttachmentFromUrl(mediaUrl, maxBytes, options) {
+	const media = await loadWebMedia(mediaUrl, buildOutboundMediaLoadOptions({
+		maxBytes,
+		mediaAccess: options?.mediaAccess,
+		mediaLocalRoots: options?.localRoots,
+		mediaReadFile: options?.readFile
+	}));
+	const saved = await saveMediaBuffer(media.buffer, media.contentType ?? void 0, "outbound", maxBytes);
+	return {
+		path: saved.path,
+		contentType: saved.contentType
+	};
+}
+//#endregion
+//#region src/media/png-encode.ts
+/**
+* Minimal PNG encoder for generating simple RGBA images without native dependencies.
+* Used for QR codes, live probes, and other programmatic image generation.
+*/
+const CRC_TABLE = (() => {
+	const table = new Uint32Array(256);
+	for (let i = 0; i < 256; i += 1) {
+		let c = i;
+		for (let k = 0; k < 8; k += 1) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+		table[i] = c >>> 0;
+	}
+	return table;
+})();
+/** Compute CRC32 checksum for a buffer (used in PNG chunk encoding). */
+function crc32(buf) {
+	let crc = 4294967295;
+	for (let i = 0; i < buf.length; i += 1) crc = CRC_TABLE[(crc ^ buf[i]) & 255] ^ crc >>> 8;
+	return (crc ^ 4294967295) >>> 0;
+}
+/** Create a PNG chunk with type, data, and CRC. */
+function pngChunk(type, data) {
+	const typeBuf = Buffer.from(type, "ascii");
+	const len = Buffer.alloc(4);
+	len.writeUInt32BE(data.length, 0);
+	const crc = crc32(Buffer.concat([typeBuf, data]));
+	const crcBuf = Buffer.alloc(4);
+	crcBuf.writeUInt32BE(crc, 0);
+	return Buffer.concat([
+		len,
+		typeBuf,
+		data,
+		crcBuf
+	]);
+}
+/** Write a pixel to an RGBA buffer. Ignores out-of-bounds writes. */
+function fillPixel(buf, x, y, width, r, g, b, a = 255) {
+	if (x < 0 || y < 0 || x >= width) return;
+	const idx = (y * width + x) * 4;
+	if (idx < 0 || idx + 3 >= buf.length) return;
+	buf[idx] = r;
+	buf[idx + 1] = g;
+	buf[idx + 2] = b;
+	buf[idx + 3] = a;
+}
+/** Encode an RGBA buffer as a PNG image. */
+function encodePngRgba(buffer, width, height) {
+	const stride = width * 4;
+	const raw = Buffer.alloc((stride + 1) * height);
+	for (let row = 0; row < height; row += 1) {
+		const rawOffset = row * (stride + 1);
+		raw[rawOffset] = 0;
+		buffer.copy(raw, rawOffset + 1, row * stride, row * stride + stride);
+	}
+	const compressed = deflateSync(raw);
+	const signature = Buffer.from([
+		137,
+		80,
+		78,
+		71,
+		13,
+		10,
+		26,
+		10
+	]);
+	const ihdr = Buffer.alloc(13);
+	ihdr.writeUInt32BE(width, 0);
+	ihdr.writeUInt32BE(height, 4);
+	ihdr[8] = 8;
+	ihdr[9] = 6;
+	ihdr[10] = 0;
+	ihdr[11] = 0;
+	ihdr[12] = 0;
+	return Buffer.concat([
+		signature,
+		pngChunk("IHDR", ihdr),
+		pngChunk("IDAT", compressed),
+		pngChunk("IEND", Buffer.alloc(0))
+	]);
+}
+//#endregion
+//#region src/media/qr-image.ts
+const QRCode = QRCodeModule;
+const QRErrorCorrectLevel = QRErrorCorrectLevelModule;
+function createQrMatrix(input) {
+	const qr = new QRCode(-1, QRErrorCorrectLevel.L);
+	qr.addData(input);
+	qr.make();
+	return qr;
+}
+async function renderQrPngBase64(input, opts = {}) {
+	const { scale = 6, marginModules = 4 } = opts;
+	const qr = createQrMatrix(input);
+	const modules = qr.getModuleCount();
+	const size = (modules + marginModules * 2) * scale;
+	const buf = Buffer.alloc(size * size * 4, 255);
+	for (let row = 0; row < modules; row += 1) for (let col = 0; col < modules; col += 1) {
+		if (!qr.isDark(row, col)) continue;
+		const startX = (col + marginModules) * scale;
+		const startY = (row + marginModules) * scale;
+		for (let y = 0; y < scale; y += 1) {
+			const pixelY = startY + y;
+			for (let x = 0; x < scale; x += 1) fillPixel(buf, startX + x, pixelY, size, 0, 0, 0, 255);
+		}
+	}
+	return encodePngRgba(buf, size, size).toString("base64");
+}
+//#endregion
+//#region src/media/temp-files.ts
+async function unlinkIfExists(filePath) {
+	if (!filePath) return;
+	try {
+		await fs.unlink(filePath);
+	} catch {}
+}
+//#endregion
+//#region src/channels/plugins/media-limits.ts
+const MB = 1024 * 1024;
+function resolveChannelMediaMaxBytes(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const channelLimit = params.resolveChannelLimitMb({
+		cfg: params.cfg,
+		accountId
+	});
+	if (channelLimit) return channelLimit * MB;
+	if (params.cfg.agents?.defaults?.mediaMaxMb) return params.cfg.agents.defaults.mediaMaxMb * MB;
+}
+//#endregion
+//#region src/media-understanding/audio-transcription-runner.ts
+async function runAudioTranscription(params) {
+	const attachments = params.attachments ?? normalizeMediaAttachments(params.ctx);
+	if (attachments.length === 0) return {
+		transcript: void 0,
+		attachments
+	};
+	const providerRegistry = buildProviderRegistry(params.providers, params.cfg);
+	const cache = createMediaAttachmentCache(attachments, params.localPathRoots ? { localPathRoots: params.localPathRoots } : void 0);
+	try {
+		return {
+			transcript: (await runCapability({
+				capability: "audio",
+				cfg: params.cfg,
+				ctx: params.ctx,
+				attachments: cache,
+				media: attachments,
+				agentDir: params.agentDir,
+				providerRegistry,
+				config: params.cfg.tools?.media?.audio,
+				activeModel: params.activeModel
+			})).outputs.find((entry) => entry.kind === "audio.transcription")?.text?.trim() || void 0,
+			attachments
+		};
+	} finally {
+		await cache.cleanup();
+	}
+}
+//#endregion
+//#region src/media-understanding/audio-preflight.ts
+/**
+* Transcribes the first audio attachment BEFORE mention checking.
+* This allows voice notes to be processed in group chats with requireMention: true.
+* Returns the transcript or undefined if transcription fails or no audio is found.
+*/
+async function transcribeFirstAudio(params) {
+	const { ctx, cfg } = params;
+	if ((cfg.tools?.media?.audio)?.enabled === false) return;
+	const attachments = normalizeMediaAttachments(ctx);
+	if (!attachments || attachments.length === 0) return;
+	const firstAudio = attachments.find((att) => att && isAudioAttachment(att) && !att.alreadyTranscribed);
+	if (!firstAudio) return;
+	if (shouldLogVerbose()) logVerbose(`audio-preflight: transcribing attachment ${firstAudio.index} for mention check`);
+	try {
+		const { transcript } = await runAudioTranscription({
+			ctx,
+			cfg,
+			attachments,
+			agentDir: params.agentDir,
+			providers: params.providers,
+			activeModel: params.activeModel,
+			localPathRoots: resolveMediaAttachmentLocalRoots({
+				cfg,
+				ctx
+			})
+		});
+		if (!transcript) return;
+		firstAudio.alreadyTranscribed = true;
+		if (shouldLogVerbose()) logVerbose(`audio-preflight: transcribed ${transcript.length} chars from attachment ${firstAudio.index}`);
+		return transcript;
+	} catch (err) {
+		if (shouldLogVerbose()) logVerbose(`audio-preflight: transcription failed: ${String(err)}`);
+		return;
+	}
+}
+//#endregion
+//#region src/channels/plugins/outbound/direct-text-media.ts
+function resolveScopedChannelMediaMaxBytes(params) {
+	return resolveChannelMediaMaxBytes({
+		cfg: params.cfg,
+		resolveChannelLimitMb: params.resolveChannelLimitMb,
+		accountId: params.accountId
+	});
+}
+function createScopedChannelMediaMaxBytesResolver(channel) {
+	return (params) => resolveScopedChannelMediaMaxBytes({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		resolveChannelLimitMb: ({ cfg, accountId }) => (cfg.channels?.[channel]?.accounts?.[accountId])?.mediaMaxMb ?? cfg.channels?.[channel]?.mediaMaxMb
+	});
+}
+function createDirectTextMediaOutbound(params) {
+	const sendDirect = async (sendParams) => {
+		const send = params.resolveSender(sendParams.deps);
+		const maxBytes = params.resolveMaxBytes({
+			cfg: sendParams.cfg,
+			accountId: sendParams.accountId
+		});
+		const result = await send(sendParams.to, sendParams.text, sendParams.buildOptions({
+			cfg: sendParams.cfg,
+			mediaUrl: sendParams.mediaUrl,
+			mediaAccess: sendParams.mediaAccess,
+			mediaLocalRoots: sendParams.mediaAccess?.localRoots,
+			mediaReadFile: sendParams.mediaAccess?.readFile,
+			accountId: sendParams.accountId,
+			replyToId: sendParams.replyToId,
+			maxBytes
+		}));
+		return {
+			channel: params.channel,
+			...result
+		};
+	};
+	const outbound = {
+		deliveryMode: "direct",
+		chunker: chunkText,
+		chunkerMode: "text",
+		textChunkLimit: 4e3,
+		sanitizeText: ({ text }) => sanitizeForPlainText(text),
+		sendPayload: async (ctx) => await sendTextMediaPayload({
+			channel: params.channel,
+			ctx,
+			adapter: outbound
+		}),
+		sendText: async ({ cfg, to, text, accountId, deps, replyToId }) => {
+			return await sendDirect({
+				cfg,
+				to,
+				text,
+				accountId,
+				deps,
+				replyToId,
+				buildOptions: params.buildTextOptions
+			});
+		},
+		sendMedia: async ({ cfg, to, text, mediaUrl, mediaAccess, mediaLocalRoots, mediaReadFile, accountId, deps, replyToId }) => {
+			return await sendDirect({
+				cfg,
+				to,
+				text,
+				mediaUrl,
+				mediaAccess: mediaAccess ?? (mediaLocalRoots || mediaReadFile ? {
+					...mediaLocalRoots?.length ? { localRoots: mediaLocalRoots } : {},
+					...mediaReadFile ? { readFile: mediaReadFile } : {}
+				} : void 0),
+				accountId,
+				deps,
+				replyToId,
+				buildOptions: params.buildMediaOptions
+			});
+		}
+	};
+	return outbound;
+}
+//#endregion
+export { resolveChannelMediaMaxBytes as a, crc32 as c, pngChunk as d, resolveOutboundAttachmentFromUrl as f, transcribeFirstAudio as i, encodePngRgba as l, createScopedChannelMediaMaxBytesResolver as n, unlinkIfExists as o, resolveScopedChannelMediaMaxBytes as r, renderQrPngBase64 as s, createDirectTextMediaOutbound as t, fillPixel as u };

package/dist/media-understanding-CEFjui05.js

@@ -0,0 +1,83 @@
+import { s as normalizeOptionalString } from "./string-coerce-CIT1-v_a.js";
+import "./image-runtime-B76ETuEi.js";
+import { a as requireTranscriptionText, i as postTranscriptionRequest, o as resolveProviderHttpRequestConfig, t as assertOkOrThrowHttpError } from "./shared-8dEhm1pV.js";
+import path from "node:path";
+//#region src/media-understanding/openai-compatible-video.ts
+function resolveMediaUnderstandingString(value, fallback) {
+	return normalizeOptionalString(value) || fallback;
+}
+function coerceOpenAiCompatibleVideoText(payload) {
+	const message = payload.choices?.[0]?.message;
+	if (!message) return null;
+	if (typeof message.content === "string" && message.content.trim()) return message.content.trim();
+	if (Array.isArray(message.content)) {
+		const text = message.content.map((part) => typeof part.text === "string" ? part.text.trim() : "").filter(Boolean).join("\n").trim();
+		if (text) return text;
+	}
+	if (typeof message.reasoning_content === "string" && message.reasoning_content.trim()) return message.reasoning_content.trim();
+	return null;
+}
+function buildOpenAiCompatibleVideoRequestBody(params) {
+	return {
+		model: params.model,
+		messages: [{
+			role: "user",
+			content: [{
+				type: "text",
+				text: params.prompt
+			}, {
+				type: "video_url",
+				video_url: { url: `data:${params.mime};base64,${params.buffer.toString("base64")}` }
+			}]
+		}]
+	};
+}
+//#endregion
+//#region src/media-understanding/openai-compatible-audio.ts
+function resolveModel(model, fallback) {
+	return model?.trim() || fallback;
+}
+async function transcribeOpenAiCompatibleAudio(params) {
+	const fetchFn = params.fetchFn ?? fetch;
+	const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } = resolveProviderHttpRequestConfig({
+		baseUrl: params.baseUrl,
+		defaultBaseUrl: params.defaultBaseUrl,
+		headers: params.headers,
+		request: params.request,
+		defaultHeaders: { authorization: `Bearer ${params.apiKey}` },
+		provider: params.provider,
+		api: "openai-audio-transcriptions",
+		capability: "audio",
+		transport: "media-understanding"
+	});
+	const url = `${baseUrl}/audio/transcriptions`;
+	const model = resolveModel(params.model, params.defaultModel);
+	const form = new FormData();
+	const fileName = params.fileName?.trim() || path.basename(params.fileName) || "audio";
+	const bytes = new Uint8Array(params.buffer);
+	const blob = new Blob([bytes], { type: params.mime ?? "application/octet-stream" });
+	form.append("file", blob, fileName);
+	form.append("model", model);
+	if (params.language?.trim()) form.append("language", params.language.trim());
+	if (params.prompt?.trim()) form.append("prompt", params.prompt.trim());
+	const { response: res, release } = await postTranscriptionRequest({
+		url,
+		headers,
+		body: form,
+		timeoutMs: params.timeoutMs,
+		fetchFn,
+		allowPrivateNetwork,
+		dispatcherPolicy
+	});
+	try {
+		await assertOkOrThrowHttpError(res, "Audio transcription failed");
+		return {
+			text: requireTranscriptionText((await res.json()).text, "Audio transcription response missing text"),
+			model
+		};
+	} finally {
+		await release();
+	}
+}
+//#endregion
+export { resolveMediaUnderstandingString as i, buildOpenAiCompatibleVideoRequestBody as n, coerceOpenAiCompatibleVideoText as r, transcribeOpenAiCompatibleAudio as t };

package/dist/media-understanding-provider-2LeNsCXQ.js

@@ -0,0 +1,13 @@
+import { n as describeImagesWithModel, t as describeImageWithModel } from "./image-runtime-B76ETuEi.js";
+import "./media-understanding-CEFjui05.js";
+//#region extensions/zai/media-understanding-provider.ts
+const zaiMediaUnderstandingProvider = {
+	id: "zai",
+	capabilities: ["image"],
+	defaultModels: { image: "glm-4.6v" },
+	autoPriority: { image: 60 },
+	describeImage: describeImageWithModel,
+	describeImages: describeImagesWithModel
+};
+//#endregion
+export { zaiMediaUnderstandingProvider as t };

package/dist/media-understanding-provider-AxZChB3Q.js

@@ -0,0 +1,14 @@
+import { n as describeImagesWithModel, t as describeImageWithModel } from "./image-runtime-B76ETuEi.js";
+import "./media-understanding-CEFjui05.js";
+//#region extensions/anthropic/media-understanding-provider.ts
+const anthropicMediaUnderstandingProvider = {
+	id: "anthropic",
+	capabilities: ["image"],
+	defaultModels: { image: "claude-opus-4-6" },
+	autoPriority: { image: 20 },
+	nativeDocumentInputs: ["pdf"],
+	describeImage: describeImageWithModel,
+	describeImages: describeImagesWithModel
+};
+//#endregion
+export { anthropicMediaUnderstandingProvider as t };

package/dist/media-understanding-provider-B8KTGMNt.js

@@ -0,0 +1,67 @@
+import { n as describeImagesWithModel, t as describeImageWithModel } from "./image-runtime-B76ETuEi.js";
+import { o as resolveProviderHttpRequestConfig, r as postJsonRequest, t as assertOkOrThrowHttpError } from "./shared-8dEhm1pV.js";
+import { i as resolveMediaUnderstandingString, n as buildOpenAiCompatibleVideoRequestBody, r as coerceOpenAiCompatibleVideoText } from "./media-understanding-CEFjui05.js";
+import "./provider-http-2ogsNHhv.js";
+//#region extensions/moonshot/media-understanding-provider.ts
+const DEFAULT_MOONSHOT_VIDEO_BASE_URL = "https://api.moonshot.ai/v1";
+const DEFAULT_MOONSHOT_VIDEO_MODEL = "kimi-k2.5";
+const DEFAULT_MOONSHOT_VIDEO_PROMPT = "Describe the video.";
+async function describeMoonshotVideo(params) {
+	const fetchFn = params.fetchFn ?? fetch;
+	const model = resolveMediaUnderstandingString(params.model, DEFAULT_MOONSHOT_VIDEO_MODEL);
+	const mime = resolveMediaUnderstandingString(params.mime, "video/mp4");
+	const prompt = resolveMediaUnderstandingString(params.prompt, DEFAULT_MOONSHOT_VIDEO_PROMPT);
+	const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } = resolveProviderHttpRequestConfig({
+		baseUrl: params.baseUrl,
+		defaultBaseUrl: DEFAULT_MOONSHOT_VIDEO_BASE_URL,
+		headers: params.headers,
+		request: params.request,
+		defaultHeaders: {
+			"content-type": "application/json",
+			authorization: `Bearer ${params.apiKey}`
+		},
+		provider: "moonshot",
+		api: "openai-completions",
+		capability: "video",
+		transport: "media-understanding"
+	});
+	const { response: res, release } = await postJsonRequest({
+		url: `${baseUrl}/chat/completions`,
+		headers,
+		body: buildOpenAiCompatibleVideoRequestBody({
+			model,
+			prompt,
+			mime,
+			buffer: params.buffer
+		}),
+		timeoutMs: params.timeoutMs,
+		fetchFn,
+		allowPrivateNetwork,
+		dispatcherPolicy
+	});
+	try {
+		await assertOkOrThrowHttpError(res, "Moonshot video description failed");
+		const text = coerceOpenAiCompatibleVideoText(await res.json());
+		if (!text) throw new Error("Moonshot video description response missing content");
+		return {
+			text,
+			model
+		};
+	} finally {
+		await release();
+	}
+}
+const moonshotMediaUnderstandingProvider = {
+	id: "moonshot",
+	capabilities: ["image", "video"],
+	defaultModels: {
+		image: "kimi-k2.5",
+		video: DEFAULT_MOONSHOT_VIDEO_MODEL
+	},
+	autoPriority: { video: 20 },
+	describeImage: describeImageWithModel,
+	describeImages: describeImagesWithModel,
+	describeVideo: describeMoonshotVideo
+};
+//#endregion
+export { describeMoonshotVideo as n, moonshotMediaUnderstandingProvider as r, DEFAULT_MOONSHOT_VIDEO_BASE_URL as t };

package/dist/media-understanding-provider-BhfBs6XJ.js

@@ -0,0 +1,37 @@
+import { n as describeImagesWithModel, t as describeImageWithModel } from "./image-runtime-B76ETuEi.js";
+import { t as transcribeOpenAiCompatibleAudio } from "./media-understanding-CEFjui05.js";
+import { n as OPENAI_DEFAULT_AUDIO_TRANSCRIPTION_MODEL } from "./default-models-DxJmcrq7.js";
+//#region extensions/openai/media-understanding-provider.ts
+const DEFAULT_OPENAI_AUDIO_BASE_URL = "https://api.openai.com/v1";
+async function transcribeOpenAiAudio(params) {
+	return await transcribeOpenAiCompatibleAudio({
+		...params,
+		provider: "openai",
+		defaultBaseUrl: DEFAULT_OPENAI_AUDIO_BASE_URL,
+		defaultModel: OPENAI_DEFAULT_AUDIO_TRANSCRIPTION_MODEL
+	});
+}
+const openaiMediaUnderstandingProvider = {
+	id: "openai",
+	capabilities: ["image", "audio"],
+	defaultModels: {
+		image: "gpt-5.4-mini",
+		audio: OPENAI_DEFAULT_AUDIO_TRANSCRIPTION_MODEL
+	},
+	autoPriority: {
+		image: 10,
+		audio: 10
+	},
+	describeImage: describeImageWithModel,
+	describeImages: describeImagesWithModel,
+	transcribeAudio: transcribeOpenAiAudio
+};
+const openaiCodexMediaUnderstandingProvider = {
+	id: "openai-codex",
+	capabilities: ["image"],
+	defaultModels: { image: "gpt-5.4" },
+	describeImage: describeImageWithModel,
+	describeImages: describeImagesWithModel
+};
+//#endregion
+export { transcribeOpenAiAudio as i, openaiCodexMediaUnderstandingProvider as n, openaiMediaUnderstandingProvider as r, DEFAULT_OPENAI_AUDIO_BASE_URL as t };

package/dist/media-understanding-provider-By7-KDWp.js

@@ -0,0 +1,112 @@
+import { n as describeImagesWithModel, t as describeImageWithModel } from "./image-runtime-B76ETuEi.js";
+import { r as postJsonRequest, t as assertOkOrThrowHttpError } from "./shared-8dEhm1pV.js";
+import "./media-understanding-CEFjui05.js";
+import "./provider-http-2ogsNHhv.js";
+import { n as normalizeGoogleModelId } from "./model-id-DlDIg7zr.js";
+import { t as DEFAULT_GOOGLE_API_BASE_URL } from "./provider-policy-DRzWdKcA.js";
+import { i as resolveGoogleGenerativeAiHttpRequestConfig } from "./api-CgLK0Nl9.js";
+import "./runtime-api-DTGmvXqo.js";
+//#region extensions/google/media-understanding-provider.ts
+const DEFAULT_GOOGLE_AUDIO_BASE_URL = DEFAULT_GOOGLE_API_BASE_URL;
+const DEFAULT_GOOGLE_VIDEO_BASE_URL = DEFAULT_GOOGLE_API_BASE_URL;
+const DEFAULT_GOOGLE_AUDIO_MODEL = "gemini-3-flash-preview";
+const DEFAULT_GOOGLE_VIDEO_MODEL = "gemini-3-flash-preview";
+const DEFAULT_GOOGLE_AUDIO_PROMPT = "Transcribe the audio.";
+const DEFAULT_GOOGLE_VIDEO_PROMPT = "Describe the video.";
+async function generateGeminiInlineDataText(params) {
+	const fetchFn = params.fetchFn ?? fetch;
+	const model = (() => {
+		const trimmed = params.model?.trim();
+		if (!trimmed) return params.defaultModel;
+		return normalizeGoogleModelId(trimmed);
+	})();
+	const { baseUrl, allowPrivateNetwork, headers, dispatcherPolicy } = resolveGoogleGenerativeAiHttpRequestConfig({
+		apiKey: params.apiKey,
+		baseUrl: params.baseUrl,
+		headers: params.headers,
+		request: params.request,
+		capability: params.defaultMime.startsWith("audio/") ? "audio" : "video",
+		transport: "media-understanding"
+	});
+	const { response: res, release } = await postJsonRequest({
+		url: `${baseUrl ?? params.defaultBaseUrl}/models/${model}:generateContent`,
+		headers,
+		body: { contents: [{
+			role: "user",
+			parts: [{ text: params.prompt?.trim() || params.defaultPrompt }, { inline_data: {
+				mime_type: params.mime ?? params.defaultMime,
+				data: params.buffer.toString("base64")
+			} }]
+		}] },
+		timeoutMs: params.timeoutMs,
+		fetchFn,
+		allowPrivateNetwork,
+		dispatcherPolicy
+	});
+	try {
+		await assertOkOrThrowHttpError(res, params.httpErrorLabel);
+		const text = ((await res.json()).candidates?.[0]?.content?.parts ?? []).map((part) => part?.text?.trim()).filter(Boolean).join("\n");
+		if (!text) throw new Error(params.missingTextError);
+		return {
+			text,
+			model
+		};
+	} finally {
+		await release();
+	}
+}
+async function transcribeGeminiAudio(params) {
+	const { text, model } = await generateGeminiInlineDataText({
+		...params,
+		defaultBaseUrl: DEFAULT_GOOGLE_AUDIO_BASE_URL,
+		defaultModel: DEFAULT_GOOGLE_AUDIO_MODEL,
+		defaultPrompt: DEFAULT_GOOGLE_AUDIO_PROMPT,
+		defaultMime: "audio/wav",
+		httpErrorLabel: "Audio transcription failed",
+		missingTextError: "Audio transcription response missing text"
+	});
+	return {
+		text,
+		model
+	};
+}
+async function describeGeminiVideo(params) {
+	const { text, model } = await generateGeminiInlineDataText({
+		...params,
+		defaultBaseUrl: DEFAULT_GOOGLE_VIDEO_BASE_URL,
+		defaultModel: DEFAULT_GOOGLE_VIDEO_MODEL,
+		defaultPrompt: DEFAULT_GOOGLE_VIDEO_PROMPT,
+		defaultMime: "video/mp4",
+		httpErrorLabel: "Video description failed",
+		missingTextError: "Video description response missing text"
+	});
+	return {
+		text,
+		model
+	};
+}
+const googleMediaUnderstandingProvider = {
+	id: "google",
+	capabilities: [
+		"image",
+		"audio",
+		"video"
+	],
+	defaultModels: {
+		image: DEFAULT_GOOGLE_VIDEO_MODEL,
+		audio: DEFAULT_GOOGLE_AUDIO_MODEL,
+		video: DEFAULT_GOOGLE_VIDEO_MODEL
+	},
+	autoPriority: {
+		image: 30,
+		audio: 40,
+		video: 10
+	},
+	nativeDocumentInputs: ["pdf"],
+	describeImage: describeImageWithModel,
+	describeImages: describeImagesWithModel,
+	transcribeAudio: transcribeGeminiAudio,
+	describeVideo: describeGeminiVideo
+};
+//#endregion
+export { transcribeGeminiAudio as a, googleMediaUnderstandingProvider as i, DEFAULT_GOOGLE_VIDEO_BASE_URL as n, describeGeminiVideo as r, DEFAULT_GOOGLE_AUDIO_BASE_URL as t };

package/dist/media-understanding-provider-CJvPSRD_.js

@@ -0,0 +1,18 @@
+import { t as transcribeOpenAiCompatibleAudio } from "./media-understanding-CEFjui05.js";
+//#region extensions/groq/media-understanding-provider.ts
+const DEFAULT_GROQ_AUDIO_BASE_URL = "https://api.groq.com/openai/v1";
+const DEFAULT_GROQ_AUDIO_MODEL = "whisper-large-v3-turbo";
+const groqMediaUnderstandingProvider = {
+	id: "groq",
+	capabilities: ["audio"],
+	defaultModels: { audio: DEFAULT_GROQ_AUDIO_MODEL },
+	autoPriority: { audio: 20 },
+	transcribeAudio: (req) => transcribeOpenAiCompatibleAudio({
+		...req,
+		baseUrl: req.baseUrl ?? DEFAULT_GROQ_AUDIO_BASE_URL,
+		defaultBaseUrl: DEFAULT_GROQ_AUDIO_BASE_URL,
+		defaultModel: DEFAULT_GROQ_AUDIO_MODEL
+	})
+};
+//#endregion
+export { groqMediaUnderstandingProvider as t };

package/dist/media-understanding-provider-CeDiKBMV.js

@@ -0,0 +1,21 @@
+import { n as describeImagesWithModel, t as describeImageWithModel } from "./image-runtime-B76ETuEi.js";
+import "./media-understanding-CEFjui05.js";
+//#region extensions/minimax/media-understanding-provider.ts
+const minimaxMediaUnderstandingProvider = {
+	id: "minimax",
+	capabilities: ["image"],
+	defaultModels: { image: "MiniMax-VL-01" },
+	autoPriority: { image: 40 },
+	describeImage: describeImageWithModel,
+	describeImages: describeImagesWithModel
+};
+const minimaxPortalMediaUnderstandingProvider = {
+	id: "minimax-portal",
+	capabilities: ["image"],
+	defaultModels: { image: "MiniMax-VL-01" },
+	autoPriority: { image: 50 },
+	describeImage: describeImageWithModel,
+	describeImages: describeImagesWithModel
+};
+//#endregion
+export { minimaxPortalMediaUnderstandingProvider as n, minimaxMediaUnderstandingProvider as t };