resolveCapabilityModelCandidates,

throwCapabilityGenerationFailure,

} from "../media-generation/runtime-shared.js";

import { getProviderEnvVars } from "../secrets/provider-env-vars.js";

import { parseImageGenerationModelRef } from "./model-ref.js";

import { resolveImageGenerationOverrides } from "./normalization.js";

import { getImageGenerationProvider, listImageGenerationProviders } from "./provider-registry.js";

const log = createSubsystemLogger("image-generation");

export type ImageGenerationRuntimeDeps = {

getProvider?: typeof getImageGenerationProvider;

listProviders?: typeof listImageGenerationProviders;

getProviderEnvVars?: typeof getProviderEnvVars;

log?: Pick<typeof log, "warn">;

};

export type { GenerateImageParams, GenerateImageRuntimeResult } from "./runtime-types.js";

function buildNoImageGenerationModelConfiguredMessage(cfg: OpenClawConfig): string {

function buildNoImageGenerationModelConfiguredMessage(

cfg: OpenClawConfig,

deps: ImageGenerationRuntimeDeps,

): string {

const listProviders = deps.listProviders ?? listImageGenerationProviders;

return buildNoCapabilityModelConfiguredMessage({

capabilityLabel: "image-generation",

modelConfigKey: "imageGenerationModel",

providers: listImageGenerationProviders(cfg),

providers: listProviders(cfg),

getProviderEnvVars: deps.getProviderEnvVars,

});

}

export function listRuntimeImageGenerationProviders(params?: { config?: OpenClawConfig }) {

return listImageGenerationProviders(params?.config);

export function listRuntimeImageGenerationProviders(

params?: { config?: OpenClawConfig },

deps: ImageGenerationRuntimeDeps = {},

) {

return (deps.listProviders ?? listImageGenerationProviders)(params?.config);

}

export async function generateImage(

params: GenerateImageParams,

deps: ImageGenerationRuntimeDeps = {},

): Promise<GenerateImageRuntimeResult> {

const getProvider = deps.getProvider ?? getImageGenerationProvider;

const listProviders = deps.listProviders ?? listImageGenerationProviders;

const logger = deps.log ?? log;

const timeoutMs =

params.timeoutMs ??

resolveAgentModelTimeoutMsValue(params.cfg.agents?.defaults?.imageGenerationModel);

modelOverride: params.modelOverride,

parseModelRef: parseImageGenerationModelRef,

agentDir: params.agentDir,

listProviders: listImageGenerationProviders,

listProviders,

});

if (candidates.length === 0) {

throw new Error(buildNoImageGenerationModelConfiguredMessage(params.cfg));

throw new Error(buildNoImageGenerationModelConfiguredMessage(params.cfg, deps));

}

const attempts: FallbackAttempt[] = [];

let lastError: unknown;

for (const candidate of candidates) {

const provider = getImageGenerationProvider(candidate.provider, params.cfg);

const provider = getProvider(candidate.provider, params.cfg);

if (!provider) {

const error = `No image-generation provider registered for ${candidate.provider}`;

attempts.push({

error,

});

lastError = new Error(error);

log.warn(

logger.warn(

`image-generation candidate failed: ${candidate.provider}/${candidate.model}: ${error}`,

);

continue;

status: described?.status,

code: described?.code,

});

log.warn(

logger.warn(

`image-generation candidate failed: ${candidate.provider}/${candidate.model}: ${

described?.message ?? formatErrorMessage(err)

}`,