feat(ai-powerups): resolve AI models per capability instead of taking the first provider

packages/ai-powerups/__tests__/features/AiImageEnrichment/AiImageEnrichmentStreamRoute.test.ts

@@ -24,6 +24,7 @@ const prepared: IPreparedImageEnrichment = {
     imageBase64: "aGVsbG8=",
     imageMediaType: "image/png",
     model: "anthropic/claude-sonnet-4-5",
+    prompt: "Describe this image.",
     connection: { sdkName: "anthropic", apiKey: "key" }
 };
 

packages/ai-powerups/__tests__/features/Capabilities/CapabilitiesHandler.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect } from "vitest";
+import { Container } from "@webiny/di";
+import CapabilitiesHandler from "~/api/features/Capabilities/CapabilitiesHandler.js";
+import { AiPowerUpsSettingsGroupHandler } from "~/api/features/shared/index.js";
+
+function buildHandler(): AiPowerUpsSettingsGroupHandler.Interface {
+    const container = new Container();
+    container.register(CapabilitiesHandler);
+
+    return container.resolve(AiPowerUpsSettingsGroupHandler);
+}
+
+const handler = buildHandler();
+
+describe("CapabilitiesHandler", () => {
+    /*
+     * The admin form sends `null` for a field nobody has touched, and every field in an override is
+     * untouched by default. The first version of this schema required strings, so saving the
+     * settings screen without configuring a single capability failed with four copies of
+     * "Invalid input: expected string, received null" and no indication of which section was at
+     * fault.
+     */
+    it("accepts the nulls the form sends for untouched fields", () => {
+        const result = handler.inputSchema.safeParse({
+            overrides: {
+                "cms.generateEntry": {
+                    roleId: null,
+                    connectionId: null,
+                    model: null,
+                    additionalInstructions: null
+                }
+            }
+        });
+
+        expect(result.success).toBe(true);
+    });
+
+    it("accepts a fully configured override", () => {
+        const result = handler.inputSchema.safeParse({
+            overrides: {
+                "cms.generateEntry": {
+                    roleId: "fast",
+                    connectionId: "conn-1",
+                    model: "anthropic/claude-haiku-4-5",
+                    additionalInstructions: "Be brief."
+                }
+            }
+        });
+
+        expect(result.success).toBe(true);
+    });
+
+    it("still rejects a role that does not exist", () => {
+        const result = handler.inputSchema.safeParse({
+            overrides: { "cms.generateEntry": { roleId: "cheapest" } }
+        });
+
+        expect(result.success).toBe(false);
+    });
+
+    it("drops an override where every field is empty", async () => {
+        const stored = await handler.mapToStorage(
+            {
+                overrides: {
+                    "cms.generateEntry": {
+                        roleId: null,
+                        connectionId: null,
+                        additionalInstructions: "   "
+                    },
+                    "wb.generatePage": { additionalInstructions: "Keep it short." }
+                }
+            },
+            null
+        );
+
+        expect(Object.keys((stored as any).overrides)).toEqual(["wb.generatePage"]);
+    });
+
+    it("keeps nulls and empty strings out of a stored override", async () => {
+        const stored = await handler.mapToStorage(
+            {
+                overrides: {
+                    "wb.generatePage": {
+                        roleId: null,
+                        connectionId: "",
+                        model: null,
+                        additionalInstructions: "Keep it short."
+                    }
+                }
+            },
+            null
+        );
+
+        expect((stored as any).overrides["wb.generatePage"]).toEqual({
+            additionalInstructions: "Keep it short."
+        });
+    });
+
+    /*
+     * There is no prompt field here any more. Replacing a capability's prompt was offered and then
+     * removed: for most capabilities the prompt carries the output contract the surrounding code
+     * parses, so it is implementation rather than settings. `additionalInstructions` is the whole
+     * of prompt customisation now.
+     */
+    it("rejects a prompt override, which is no longer a thing", () => {
+        const result = handler.inputSchema.safeParse({
+            overrides: { "cms.compareEntryRevisions": { guidance: "Mine now." } }
+        });
+
+        // Zod strips the unknown key rather than failing, so the check is that it never lands.
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual({ overrides: { "cms.compareEntryRevisions": {} } });
+    });
+
+    it("round-trips an absent section to an empty override map", () => {
+        expect(handler.mapFromStorage(undefined)).toEqual({ overrides: {} });
+    });
+});

packages/ai-powerups/__tests__/features/Capabilities/ListAiCapabilitiesUseCase.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect } from "vitest";
+import { Container } from "@webiny/di";
+import {
+    AiCapability,
+    ListAiCapabilitiesUseCase
+} from "~/api/features/Capabilities/abstractions.js";
+import { ListAiCapabilitiesUseCaseImplementation } from "~/api/features/Capabilities/ListAiCapabilitiesUseCase.js";
+
+class WithGuidance implements AiCapability.Interface {
+    readonly id = "cms.compareEntryRevisions";
+    readonly label = "CMS revision comparison";
+    readonly description = "For tests.";
+    readonly defaultRole = "fast" as const;
+    readonly guidance = "Webiny's own prompt, which must not leave the api.";
+}
+
+class WithoutGuidance implements AiCapability.Interface {
+    readonly id = "cms.generateEntry";
+    readonly label = "CMS entry generation";
+    readonly description = "For tests.";
+    readonly defaultRole = "standard" as const;
+}
+
+function useCase(...capabilities: Array<new () => AiCapability.Interface>) {
+    const container = new Container();
+
+    for (const implementation of capabilities) {
+        container.register(AiCapability.createImplementation({ implementation, dependencies: [] }));
+    }
+    container.register(ListAiCapabilitiesUseCaseImplementation);
+
+    return container.resolve(ListAiCapabilitiesUseCase);
+}
+
+describe("ListAiCapabilitiesUseCase", () => {
+    it("returns every registered capability", async () => {
+        const result = await useCase(WithGuidance, WithoutGuidance).execute();
+
+        expect(result.map(c => c.id)).toEqual(
+            expect.arrayContaining(["cms.compareEntryRevisions", "cms.generateEntry"])
+        );
+    });
+
+    it("returns the fields the settings screen renders a row from", async () => {
+        const result = await useCase(WithoutGuidance).execute();
+
+        expect(result[0]).toEqual({
+            id: "cms.generateEntry",
+            label: "CMS entry generation",
+            description: "For tests.",
+            defaultRole: "standard"
+        });
+    });
+
+    /*
+     * A capability's prompt is implementation, not settings. There is no reason to ship ours to
+     * everyone who can read the settings screen, and the summary has no field for it.
+     */
+    it("never exposes a capability's guidance", async () => {
+        const result = await useCase(WithGuidance).execute();
+
+        expect(result[0]).not.toHaveProperty("guidance");
+        expect(JSON.stringify(result)).not.toContain("must not leave the api");
+    });
+
+    it("returns an empty list when nothing is registered", async () => {
+        const container = new Container();
+        container.register(ListAiCapabilitiesUseCaseImplementation);
+
+        expect(await container.resolve(ListAiCapabilitiesUseCase).execute()).toEqual([]);
+    });
+});