openclaw/dist/image-DdVoq-Ac.mjs

Multi-channel AI gateway with extensible messaging integrations

import { p as clampPositiveTimerTimeoutMs } from "./number-coercion-CkhMiRw8.mjs";
import { s as trackAsyncWork } from "./async-work-scope-DDiH0P7W.mjs";
import { c as isRecord } from "./record-coerce-TIsquoVR.mjs";
import { o as racePromiseWithAbortSignal, s as raceWithTimeout } from "./src-D1BHGNTj.mjs";
import "./abort-signal-QqAmLWTl.mjs";
import { c as isSecretRef } from "./ref-contract-Bfd9_-Lp.mjs";
import "./types.secrets-DD-Q2SS_.mjs";
import { t as isPromiseLike } from "./promise-like-D7-l5Fsp.mjs";
import { d as resolveAgentWorkspaceDir } from "./agent-scope-config-BEk6-ThS.mjs";
import "./agent-scope-bJOokm5r.mjs";
import { f as runPluginStreamConsumer } from "./plugin-instance-scope-Cm6nCHVN.mjs";
import { o as normalizeModelRef } from "./model-ref-shared-Df4xc5Gg.mjs";
import { n as withPluginRuntimeGenerationScope } from "./generation-scope-DnORwJwz.mjs";
import { n as resolveProviderModelMaterializationAuthMode } from "./provider-model-route-auth-CQFn7FNj.mjs";
import { a as prepareProviderRuntimeAuth } from "./provider-runtime.runtime.js";
import { i as resolveProviderRequestCapabilities } from "./provider-attribution-DTlkhSx_.mjs";
import { a as getModelProviderRequestRouteFacts, o as getModelProviderRequestTransport, t as applyPreparedRuntimeAuthToModel } from "./provider-request-config-zrhxha-3.mjs";
import { A as requireApiKey } from "./model-auth-provider-config-Cwa51-db.mjs";
import { d as resolveProviderRuntimePluginHandle, t as attachModelProviderRuntimePluginHandle } from "./provider-hook-runtime-DXt-lONr.mjs";
import { i as unwrapSecretSentinelsForProviderEgress, r as unwrapModelHeaderSentinelsForProviderEgress } from "./provider-secret-egress-CRmcEjuL.mjs";
import { h as retainPreparedModelRuntimeSnapshotResources } from "./prepared-model-runtime.plugin-generation-Cw0RTUTR.mjs";
import { n as getModelRegistryRuntime } from "./model-registry-Gn0C-qAI.mjs";
import { n as bindModelLlmRuntime } from "./model-runtime-binding-DgnrsJj9.mjs";
import "./model-selection-Cpoq0B2R.mjs";
import { t as acquireAgentRunPreparedModelRuntime } from "./prepared-model-runtime-l04jZgyc.mjs";
import { t as resolveApiKeyForProviderCore } from "./model-auth-provider-Dx8NYoTR.mjs";
import { i as getApiKeyForModelCore, r as applySecretRefHeaderSentinels } from "./model-auth-CGgrsVoA.mjs";
import { n as normalizeMediaProviderId } from "./provider-id-BZvihdyi.mjs";
import { r as minimaxUnderstandImage, t as isMinimaxVlmModel } from "./minimax-vlm-DEtrlDRF.mjs";
import { t as runWithAsyncWorkResources } from "./async-work-resources-BvYhIOBb.mjs";
import { n as resolveModelAsync } from "./model-Co5AQ0pq.mjs";
import { i as providerUsesCredentialScopedModelMetadata, t as protectPreparedProviderRuntimeAuth } from "./provider-runtime-auth-protection-ZTqTlJ4N.mjs";
import { i as hasImageReasoningOnlyResponse, t as coerceImageAssistantText } from "./image-tool.helpers-BUDrRl_A.mjs";
import { t as complete } from "./stream-B2a9zNQj.mjs";
import { t as registerProviderStreamForModel } from "./provider-stream-BMdyPkWO.mjs";
import { randomUUID } from "node:crypto";
import { prepareHeadersForSimpleCompletion } from "@openclaw/ai/transports";
//#region src/media-understanding/image-model-runtime.ts
const resolvedImageRuntimeContexts = /* @__PURE__ */ new WeakMap();
function getResolvedImageRuntimeContext(model) {
	return resolvedImageRuntimeContexts.get(model);
}
function bindResolvedImageRuntime(params, apiKey, model) {
	resolvedImageRuntimeContexts.set(model, {
		cfg: params.cfg,
		agentDir: params.agentDir,
		...params.workspaceDir ? { workspaceDir: params.workspaceDir } : {}
	});
	return {
		runtimeValue: apiKey,
		model
	};
}
function formatModelInputCapabilities(input) {
	return input && input.length > 0 ? input.join(", ") : "none";
}
function requireImageCapableModel(params) {
	if (!params.model) throw new Error(`Unknown model: ${params.resolvedProvider}/${params.resolvedModel}`);
	if (params.model.input?.includes("image")) return params.model;
	if (isMinimaxVlmModel(params.resolvedProvider, params.resolvedModel)) throw new Error(`Unknown model: ${params.resolvedProvider}/${params.resolvedModel}`);
	throw new Error(`Model does not support images: ${params.requestedProvider}/${params.requestedModel} (resolved ${params.model.provider}/${params.model.id} input: ${formatModelInputCapabilities(params.model.input)})`);
}
async function prepareResolvedImageRuntime(params, preparedRuntime, resolvedModel, authStorage, modelRegistry) {
	let model = resolvedModel;
	const modelRuntime = getModelRegistryRuntime(modelRegistry);
	const bindPreparedModel = (candidate) => {
		const requestModel = applySecretRefHeaderSentinels(candidate, params.cfg);
		const providerRuntimeHandle = resolveProviderRuntimePluginHandle({
			provider: requestModel.provider,
			modelId: requestModel.id,
			config: params.cfg,
			workspaceDir: params.workspaceDir,
			env: process.env,
			pluginMetadataSnapshot: preparedRuntime.metadataSnapshot
		});
		return bindModelLlmRuntime(attachModelProviderRuntimePluginHandle(requestModel, providerRuntimeHandle), modelRuntime.llmRuntime);
	};
	const apiKeyInfo = await getApiKeyForModelCore({
		model,
		cfg: params.cfg,
		agentDir: params.agentDir,
		...params.workspaceDir ? { workspaceDir: params.workspaceDir } : {},
		profileId: params.profile,
		preferredProfile: params.preferredProfile,
		store: params.authStore,
		secretSentinels: true
	});
	params.signal?.throwIfAborted();
	if (providerUsesCredentialScopedModelMetadata({
		provider: model.provider,
		modelId: model.id,
		config: params.cfg,
		agentDir: params.agentDir,
		workspaceDir: params.workspaceDir
	})) {
		const authProfileMode = resolveProviderModelMaterializationAuthMode(apiKeyInfo.mode);
		const authoritative = await resolveModelAsync(model.provider, model.id, params.agentDir, params.cfg, {
			abortSignal: params.signal,
			modelIdSource: "selected",
			authStorage,
			modelRegistry,
			skipAgentDiscovery: true,
			allowBundledStaticCatalogFallback: true,
			preparedModelRuntime: params.preparedModelRuntime,
			...params.workspaceDir ? { workspaceDir: params.workspaceDir } : {},
			...apiKeyInfo.profileId ? { authProfileId: apiKeyInfo.profileId } : authProfileMode ? { authProfileMode } : {}
		});
		params.signal?.throwIfAborted();
		model = requireImageCapableModel({
			model: authoritative.model,
			resolvedProvider: model.provider,
			resolvedModel: model.id,
			requestedProvider: params.provider,
			requestedModel: params.model
		});
	}
	if (!apiKeyInfo.apiKey?.trim() && apiKeyInfo.mode === "aws-sdk" && model.api === "bedrock-converse-stream") return bindResolvedImageRuntime(params, "", bindPreparedModel(model));
	let apiKey = requireApiKey(apiKeyInfo, model.provider);
	const runtimeAuth = await prepareProviderRuntimeAuth({
		provider: model.provider,
		config: params.cfg,
		workspaceDir: params.workspaceDir,
		env: process.env,
		context: {
			config: params.cfg,
			workspaceDir: params.workspaceDir,
			env: process.env,
			provider: model.provider,
			modelId: model.id,
			model,
			apiKey,
			authMode: apiKeyInfo.mode,
			profileId: apiKeyInfo.profileId
		}
	});
	params.signal?.throwIfAborted();
	const preparedAuth = protectPreparedProviderRuntimeAuth({
		provider: model.provider,
		preparedAuth: runtimeAuth
	});
	apiKey = preparedAuth?.apiKey?.trim() || apiKey;
	model = applyPreparedRuntimeAuthToModel(model, preparedAuth);
	authStorage.setRuntimeApiKey(model.provider, apiKey);
	return bindResolvedImageRuntime(params, apiKey, bindPreparedModel(model));
}
async function resolveImageRuntime(params, onAcquired) {
	const workspaceDir = params.workspaceDir ?? (params.agentId ? resolveAgentWorkspaceDir(params.cfg ?? {}, params.agentId) : void 0);
	const runtimeParams = workspaceDir ? {
		...params,
		workspaceDir
	} : params;
	const authProfileOptions = {
		...params.profile ? { authProfileId: params.profile } : {},
		...params.preferredProfile ? { preferredProfile: params.preferredProfile } : {}
	};
	const suppliedSnapshot = params.preparedModelRuntime;
	let resolvedRef = suppliedSnapshot ? normalizeModelRef(params.provider, params.model, { manifestPlugins: suppliedSnapshot.metadataSnapshot }) : {
		provider: params.provider,
		model: params.model
	};
	const suppliedClaim = suppliedSnapshot ? retainPreparedModelRuntimeSnapshotResources(suppliedSnapshot) : void 0;
	const preparedRuntimeLease = suppliedSnapshot ? {
		snapshot: suppliedSnapshot,
		async [Symbol.asyncDispose]() {
			await suppliedClaim?.release();
		}
	} : await acquireAgentRunPreparedModelRuntime({
		agentDir: params.agentDir,
		...params.agentId ? { agentId: params.agentId } : {},
		config: params.cfg ?? {},
		...runtimeParams.workspaceDir ? { workspaceDir: runtimeParams.workspaceDir } : {},
		loadRuntimePlugins: true
	}, {
		catalogMode: "static",
		abortSignal: params.signal,
		deriveRuntimePluginSelections: ({ metadataSnapshot }) => {
			resolvedRef = normalizeModelRef(params.provider, params.model, { manifestPlugins: metadataSnapshot });
			return [{
				provider: resolvedRef.provider,
				modelId: resolvedRef.model,
				...params.agentId ? { agentId: params.agentId } : {}
			}];
		}
	});
	onAcquired({
		[Symbol.asyncDispose]: () => preparedRuntimeLease[Symbol.asyncDispose](),
		...suppliedClaim ? { assertResourcesOpen: suppliedClaim.assertOpen } : {}
	});
	params.signal?.throwIfAborted();
	const preparedRuntime = preparedRuntimeLease.snapshot;
	const preparedWorkspaceDir = preparedRuntime.workspaceDir ?? runtimeParams.workspaceDir;
	const preparedParams = {
		...runtimeParams,
		agentDir: preparedRuntime.agentDir,
		cfg: preparedRuntime.config,
		preparedModelRuntime: preparedRuntime,
		...preparedWorkspaceDir ? { workspaceDir: preparedWorkspaceDir } : {}
	};
	const preparedStores = preparedRuntime.createStores();
	const resolveOptions = {
		abortSignal: params.signal,
		modelIdSource: "selected",
		allowBundledStaticCatalogFallback: true,
		...preparedStores,
		preparedModelRuntime: preparedRuntime,
		skipAgentDiscovery: true,
		...preparedParams.workspaceDir ? { workspaceDir: preparedParams.workspaceDir } : {},
		...authProfileOptions
	};
	return await withPluginRuntimeGenerationScope(preparedRuntime, async () => {
		const resolved = await resolveModelAsync(resolvedRef.provider, resolvedRef.model, preparedParams.agentDir, preparedParams.cfg, resolveOptions);
		params.signal?.throwIfAborted();
		const model = requireImageCapableModel({
			model: resolved.model,
			resolvedProvider: resolvedRef.provider,
			resolvedModel: resolvedRef.model,
			requestedProvider: params.provider,
			requestedModel: params.model
		});
		return await prepareResolvedImageRuntime(preparedParams, preparedRuntime, model, resolved.authStorage, resolved.modelRegistry);
	});
}
//#endregion
//#region src/media-understanding/image.ts
function resolveImageToolMaxTokens(modelMaxTokens, requestedMaxTokens = 4096) {
	if (typeof modelMaxTokens !== "number" || !Number.isFinite(modelMaxTokens) || modelMaxTokens <= 0) return requestedMaxTokens;
	return Math.min(requestedMaxTokens, modelMaxTokens);
}
function isNativeResponsesReasoningPayload(model) {
	if (model.api !== "openai-responses" && model.api !== "azure-openai-responses" && model.api !== "openai-chatgpt-responses") return false;
	return resolveProviderRequestCapabilities({
		provider: model.provider,
		api: model.api,
		baseUrl: model.baseUrl,
		capability: "image",
		transport: "media-understanding",
		providerMetadataOwners: getModelProviderRequestRouteFacts(model)?.providerMetadataOwners
	}).usesKnownNativeOpenAIRoute;
}
function disableReasoningForImageRetryPayload(payload, model) {
	if (!isRecord(payload)) return;
	const next = { ...payload };
	delete next.reasoning;
	delete next.reasoning_effort;
	const include = Array.isArray(next.include) ? next.include.filter((entry) => entry !== "reasoning.encrypted_content") : next.include;
	if (include === void 0 || Array.isArray(include) && include.length === 0) delete next.include;
	else next.include = include;
	if (isNativeResponsesReasoningPayload(model)) next.reasoning = { effort: "none" };
	return next;
}
function isImageModelNoTextError(err) {
	return err instanceof Error && /^Image model returned no text\b/.test(err.message);
}
function imageRetryPayloadHandler(onPayload) {
	return (payload, payloadModel) => {
		const stripped = disableReasoningForImageRetryPayload(payload, payloadModel);
		const result = onPayload?.(stripped === void 0 ? payload : stripped, payloadModel);
		const fallback = (value) => value === void 0 ? stripped : value;
		return isPromiseLike(result) ? Promise.resolve(result).then(fallback) : fallback(result);
	};
}
function shouldPlaceImagePromptInUserContent(model) {
	if (model.provider === "github-copilot") return true;
	const capabilities = resolveProviderRequestCapabilities({
		provider: model.provider,
		api: model.api,
		baseUrl: model.baseUrl,
		capability: "image",
		transport: "media-understanding",
		providerMetadataOwners: getModelProviderRequestRouteFacts(model)?.providerMetadataOwners
	});
	return capabilities.endpointClass === "openrouter" || capabilities.endpointClass === "modelstudio-native" || model.provider.toLowerCase() === "openrouter" && capabilities.endpointClass === "default";
}
async function describeImagesWithMinimax(params) {
	const responses = [];
	const apiKey = unwrapSecretSentinelsForProviderEgress(params.runtimeValue, "MiniMax VLM request");
	for (const [index, image] of params.images.entries()) {
		params.signal?.throwIfAborted();
		params.assertResourcesOpen?.();
		const prompt = params.images.length > 1 ? `${params.prompt}\n\nDescribe image ${index + 1} of ${params.images.length} independently.` : params.prompt;
		const text = await minimaxUnderstandImage({
			apiKey,
			provider: params.provider,
			prompt,
			imageDataUrl: `data:${image.mime ?? "image/jpeg"};base64,${image.buffer.toString("base64")}`,
			modelBaseUrl: params.modelBaseUrl,
			timeoutMs: params.timeoutMs,
			allowPrivateNetwork: params.allowPrivateNetwork,
			request: params.request,
			signal: params.signal
		});
		responses.push(params.images.length > 1 ? `Image ${index + 1}:\n${text.trim()}` : text.trim());
	}
	return {
		text: responses.join("\n\n").trim(),
		model: params.modelId
	};
}
function isUnknownModelError(err) {
	return err instanceof Error && /^Unknown model:/i.test(err.message);
}
function resolveConfiguredProviderBaseUrl(cfg, provider) {
	const direct = cfg.models?.providers?.[provider];
	if (typeof direct?.baseUrl === "string" && direct.baseUrl.trim()) return direct.baseUrl.trim();
	const normalizedProvider = normalizeMediaProviderId(provider);
	const normalized = cfg.models?.providers?.[normalizedProvider];
	if (typeof normalized?.baseUrl === "string" && normalized.baseUrl.trim()) {
		if (isMinimaxCnAlias(provider) && !isMinimaxCnBaseUrl(normalized.baseUrl)) return;
		return normalized.baseUrl.trim();
	}
}
function resolveConfiguredProviderAllowPrivateNetwork(cfg, provider) {
	const direct = cfg.models?.providers?.[provider]?.request?.allowPrivateNetwork;
	if (typeof direct === "boolean") return direct;
	const normalizedProvider = normalizeMediaProviderId(provider);
	const normalized = cfg.models?.providers?.[normalizedProvider]?.request?.allowPrivateNetwork;
	if (typeof normalized === "boolean") return normalized;
}
function isMinimaxCnAlias(provider) {
	const normalized = provider.trim().toLowerCase();
	return normalized === "minimax-cn" || normalized === "minimax-portal-cn";
}
function isMinimaxCnBaseUrl(baseUrl) {
	const trimmed = baseUrl.trim();
	if (!trimmed) return false;
	try {
		return new URL(/^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`).hostname.toLowerCase() === "api.minimaxi.com";
	} catch {
		return false;
	}
}
function hasConfiguredProviderApiKey(cfg, provider) {
	const apiKey = cfg.models?.providers?.[provider]?.apiKey;
	return typeof apiKey === "string" && apiKey.trim().length > 0 || isSecretRef(apiKey);
}
function resolveMinimaxVlmAuthProvider(cfg, provider) {
	if (!isMinimaxCnAlias(provider) || hasConfiguredProviderApiKey(cfg, provider)) return provider;
	return normalizeMediaProviderId(provider);
}
async function resolveMinimaxVlmFallbackRuntime(params) {
	const authProvider = resolveMinimaxVlmAuthProvider(params.cfg, params.provider);
	const auth = await resolveApiKeyForProviderCore({
		provider: authProvider,
		cfg: params.cfg,
		secretSentinels: true,
		profileId: params.profile,
		preferredProfile: params.preferredProfile,
		agentDir: params.agentDir,
		...params.workspaceDir ? { workspaceDir: params.workspaceDir } : {}
	});
	return {
		runtimeValue: requireApiKey(auth, authProvider),
		modelBaseUrl: resolveConfiguredProviderBaseUrl(params.cfg, params.provider)
	};
}
function buildImageDescriptionTimeoutError(params) {
	if (params.phase === "setup") return /* @__PURE__ */ new Error(`image description setup timed out after ${params.timeoutMs}ms before provider request started`);
	const setupDurationMs = typeof params.setupDurationMs === "number" && Number.isFinite(params.setupDurationMs) ? Math.max(0, Math.floor(params.setupDurationMs)) : 0;
	return /* @__PURE__ */ new Error(setupDurationMs > 0 ? `image description request timed out after ${params.timeoutMs}ms (setup took ${setupDurationMs}ms before provider request started)` : `image description request timed out after ${params.timeoutMs}ms`);
}
async function withImageDescriptionTimeout(params) {
	params.signal?.throwIfAborted();
	const abortError = (signal) => signal.reason instanceof Error ? signal.reason : new Error("image description aborted", { cause: signal.reason });
	if (params.timeoutMs === void 0) return await racePromiseWithAbortSignal(params.task, params.signal, abortError);
	const timeoutMs = params.timeoutMs;
	return await raceWithTimeout(params.task, timeoutMs, () => {
		params.controller.abort();
		throw params.createTimeoutError(timeoutMs);
	}, {
		signal: params.signal,
		onAbort: (signal) => {
			throw abortError(signal);
		}
	});
}
async function describeImagesWithModelPayloadTransformCore(params, onPayload) {
	return await runWithAsyncWorkResources(async (onAcquired) => {
		let assertResourcesOpen;
		const prompt = params.prompt ?? "Describe the image.";
		params.signal?.throwIfAborted();
		const startedAtMs = Date.now();
		const controller = new AbortController();
		const requestSignal = params.signal ? AbortSignal.any([params.signal, controller.signal]) : controller.signal;
		const configuredTimeoutMs = clampPositiveTimerTimeoutMs(params.timeoutMs);
		const allowPrivateNetwork = resolveConfiguredProviderAllowPrivateNetwork(params.cfg, params.provider);
		let runtimeValue;
		let model;
		const resolutionTask = trackAsyncWork(() => resolveImageRuntime({
			...params,
			signal: requestSignal
		}, (resources) => {
			onAcquired({ release: async () => await resources[Symbol.asyncDispose]() });
			assertResourcesOpen = resources.assertResourcesOpen;
		}));
		try {
			const resolved = await withImageDescriptionTimeout({
				controller,
				signal: params.signal,
				timeoutMs: configuredTimeoutMs,
				createTimeoutError: (timeoutMs) => buildImageDescriptionTimeoutError({
					phase: "setup",
					timeoutMs
				}),
				task: resolutionTask
			});
			runtimeValue = resolved.runtimeValue;
			model = resolved.model;
		} catch (err) {
			params.signal?.throwIfAborted();
			if (!isMinimaxVlmModel(params.provider, params.model) || !isUnknownModelError(err)) throw err;
			const fallback = await withImageDescriptionTimeout({
				controller,
				signal: params.signal,
				timeoutMs: configuredTimeoutMs,
				createTimeoutError: (timeoutMs) => buildImageDescriptionTimeoutError({
					phase: "setup",
					timeoutMs
				}),
				task: trackAsyncWork(() => resolveMinimaxVlmFallbackRuntime(params))
			});
			return await describeImagesWithMinimax({
				assertResourcesOpen,
				runtimeValue: fallback.runtimeValue,
				provider: params.provider,
				modelId: params.model,
				modelBaseUrl: fallback.modelBaseUrl,
				prompt,
				timeoutMs: params.timeoutMs,
				images: params.images,
				allowPrivateNetwork,
				signal: params.signal
			});
		}
		const apiKey = runtimeValue;
		params.signal?.throwIfAborted();
		assertResourcesOpen?.();
		const setupDurationMs = Date.now() - startedAtMs;
		if (isMinimaxVlmModel(model.provider, model.id)) return await describeImagesWithMinimax({
			assertResourcesOpen,
			runtimeValue,
			provider: model.provider,
			modelId: model.id,
			modelBaseUrl: model.baseUrl,
			prompt,
			timeoutMs: params.timeoutMs,
			images: params.images,
			request: getModelProviderRequestTransport(model),
			signal: params.signal
		});
		const resolvedRuntimeContext = getResolvedImageRuntimeContext(model);
		const requestModel = unwrapModelHeaderSentinelsForProviderEgress(model, "image description provider request");
		const providerStreamFn = registerProviderStreamForModel({
			model: requestModel,
			cfg: resolvedRuntimeContext?.cfg ?? params.cfg,
			agentDir: resolvedRuntimeContext?.agentDir ?? params.agentDir,
			wrapProviderStream: true,
			...resolvedRuntimeContext?.workspaceDir ? { workspaceDir: resolvedRuntimeContext.workspaceDir } : params.workspaceDir ? { workspaceDir: params.workspaceDir } : {}
		});
		const promptInUserContent = shouldPlaceImagePromptInUserContent(model);
		const context = {
			...promptInUserContent ? {} : { systemPrompt: prompt },
			messages: [{
				role: "user",
				content: [...promptInUserContent ? [{
					type: "text",
					text: prompt
				}] : [], ...params.images.map((image) => ({
					type: "image",
					data: image.buffer.toString("base64"),
					mimeType: image.mime ?? "image/jpeg"
				}))],
				timestamp: Date.now()
			}]
		};
		const maxTokens = resolveImageToolMaxTokens(model.maxTokens, params.maxTokens);
		const imageRequestHeaders = prepareHeadersForSimpleCompletion(requestModel, {
			sessionId: randomUUID(),
			...requestModel.provider === "github-copilot" ? { headers: {
				"x-initiator": "user",
				"Copilot-Vision-Request": "true"
			} } : {}
		});
		const completeImage = async (retry = false) => {
			params.signal?.throwIfAborted();
			assertResourcesOpen?.();
			const payloadHandler = retry ? imageRetryPayloadHandler(onPayload) : onPayload;
			const timeoutMs = configuredTimeoutMs;
			const streamOptions = {
				apiKey,
				maxTokens,
				signal: requestSignal,
				...timeoutMs !== void 0 ? { timeoutMs } : {},
				...imageRequestHeaders ? { headers: imageRequestHeaders } : {},
				...payloadHandler ? { onPayload: payloadHandler } : {}
			};
			const task = trackAsyncWork(() => {
				if (!providerStreamFn) return complete(requestModel, context, streamOptions, assertResourcesOpen);
				const stream = providerStreamFn(requestModel, context, streamOptions);
				return runPluginStreamConsumer(stream, async () => await (await stream).result());
			});
			return await withImageDescriptionTimeout({
				controller,
				signal: params.signal,
				timeoutMs,
				createTimeoutError: (requestTimeoutMs) => buildImageDescriptionTimeoutError({
					phase: "request",
					timeoutMs: requestTimeoutMs,
					setupDurationMs
				}),
				task
			});
		};
		const message = await completeImage();
		try {
			return {
				text: coerceImageAssistantText({
					message,
					provider: model.provider,
					model: model.id
				}),
				model: model.id
			};
		} catch (err) {
			if (!isImageModelNoTextError(err) || !hasImageReasoningOnlyResponse(message)) throw err;
		}
		params.signal?.throwIfAborted();
		const retryMessage = await completeImage(true);
		return {
			text: coerceImageAssistantText({
				message: retryMessage,
				provider: model.provider,
				model: model.id
			}),
			model: model.id
		};
	});
}
function toImagesDescriptionRequest(params) {
	const { buffer, fileName, mime, signal, agentId, workspaceDir, preparedModelRuntime, ...request } = params;
	return {
		...request,
		images: [{
			buffer,
			fileName,
			mime
		}],
		...signal ? { signal } : {},
		...agentId ? { agentId } : {},
		...workspaceDir ? { workspaceDir } : {},
		...preparedModelRuntime ? { preparedModelRuntime } : {}
	};
}
async function describeImagesWithModelCore(params) {
	return await describeImagesWithModelPayloadTransformCore(params, void 0);
}
async function describeImageWithModelCore(params) {
	return await describeImagesWithModelCore(toImagesDescriptionRequest(params));
}
async function describeImageWithModelPayloadTransformCore(params, onPayload) {
	return await describeImagesWithModelPayloadTransformCore(toImagesDescriptionRequest(params), onPayload);
}
//#endregion
export { describeImageWithModelCore, describeImageWithModelPayloadTransformCore, describeImagesWithModelCore, describeImagesWithModelPayloadTransformCore };