};

}

async function loadRegistry(): Promise<typeof import("./provider-registry.js")> {

return await import("./provider-registry.js");

}

type ImageProviderRegistry = typeof import("./provider-registry.js");

function requireLoadedImageProvider(

registry: Awaited<ReturnType<typeof loadRegistry>>,

function requireImageProvider(

registry: ImageProviderRegistry,

id: string,

): ImageGenerationProviderPlugin {

const provider = registry.getImageGenerationProvider(id);

return provider;

}

async function loadProviderRegistry(): Promise<ImageProviderRegistry> {

vi.resetModules();

return await import("./provider-registry.js");

}

describe("image-generation provider registry", () => {

beforeEach(() => {

vi.resetModules();

});

it("delegates provider resolution to the capability provider boundary", async () => {

const { listImageGenerationProviders } = await loadRegistry();

const { listImageGenerationProviders } = await loadProviderRegistry();

const cfg = {} as OpenClawConfig;

expect(listImageGenerationProviders(cfg)).toStrictEqual([]);

});

it("uses active plugin providers without loading from disk", async () => {

const { getImageGenerationProvider } = await loadRegistry();

resolvePluginCapabilityProvidersMock.mockReturnValue([createProvider({ id: "custom-image" })]);

const { getImageGenerationProvider } = await loadProviderRegistry();

const provider = getImageGenerationProvider("custom-image");

});

it("ignores prototype-like provider ids and aliases", async () => {

const registry = await loadRegistry();

resolvePluginCapabilityProvidersMock.mockReturnValue([

createProvider({ id: "__proto__", aliases: ["constructor", "prototype"] }),

createProvider({ id: "safe-image", aliases: ["safe-alias", "constructor"] }),

]);

const registry = await loadProviderRegistry();

const { getImageGenerationProvider, listImageGenerationProviders } = registry;

expect(registry.listImageGenerationProviders().map((provider) => provider.id)).toEqual([

"safe-image",

]);

expect(registry.getImageGenerationProvider("__proto__")).toBeUndefined();

expect(registry.getImageGenerationProvider("constructor")).toBeUndefined();

expect(requireLoadedImageProvider(registry, "safe-alias").id).toBe("safe-image");

expect(listImageGenerationProviders().map((provider) => provider.id)).toEqual(["safe-image"]);

expect(getImageGenerationProvider("__proto__")).toBeUndefined();

expect(getImageGenerationProvider("constructor")).toBeUndefined();

expect(requireImageProvider(registry, "safe-alias").id).toBe("safe-image");

});

});