@webiny/ai-powerups 6.6.0-alpha.3 → 6.6.0-alpha.5

package/api/features/Capabilities/CapabilitiesHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/Capabilities/CapabilitiesHandler.js","sources":["../../../../src/api/features/Capabilities/CapabilitiesHandler.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { AiPowerUpsSettingsGroupHandler } from \"~/api/features/shared/index.js\";\nimport { AI_MODEL_ROLE_IDS } from \"~/api/features/ModelRoles/index.js\";\nimport type { AiCapabilityEntry } from \"./types.js\";\nimport type { AiCapabilityOverride } from \"./types.js\";\nimport type { CapabilitiesSettings } from \"./types.js\";\nimport type { PersistedCapabilities } from \"./types.js\";\n\n/*\n * Every field here is empty by default and the admin form sends `null` for an untouched one, so\n * each has to accept it. `mapToStorage` drops the nulls rather than persisting them.\n */\nconst overrideSchema = z.object({\n    roleId: z.union([z.enum(AI_MODEL_ROLE_IDS), z.literal(\"\")]).nullish(),\n    connectionId: z.string().nullish(),\n    model: z.string().nullish(),\n    additionalInstructions: z.string().nullish()\n});\n\n/*\n * `enabled` is `nullish` for the same reason the strings are: an untouched switch can arrive as\n * `null`. `mapToStorage` settles it to a real boolean before storing.\n */\nconst entrySchema = z.object({\n    enabled: z.boolean().nullish(),\n    overrides: overrideSchema.nullish()\n});\n\nconst inputSchema = z.object({\n    items: z.record(z.string(), entrySchema)\n});\n\n/**\n * Keeps values that mean \"not set\" out of a stored override. The form sends `null` for an untouched\n * field, and persisting those would fill the blob with keys nobody chose. Applies to the overrides\n * only: `enabled` is always written, because \"on\" is a state worth reading back.\n */\nconst dropEmptyValues = (override: AiCapabilityOverride): AiCapabilityOverride =>\n    Object.fromEntries(\n        Object.entries(override).filter(([, value]) => {\n            if (value === null || value === undefined) {\n                return false;\n            }\n            // Whitespace counts as empty. A textarea someone tabbed through holds \"  \", which would\n            // otherwise be stored and then appended to the prompt as blank noise.\n            return typeof value === \"string\" ? value.trim() !== \"\" : true;\n        })\n    ) as AiCapabilityOverride;\n\n/**\n * The form sends `null` for a switch nobody touched, and that reads as enabled, same as absence.\n * Only an explicit `false` turns a capability off.\n */\nconst normaliseEnabled = (enabled: boolean | null | undefined): boolean => enabled !== false;\n\nclass CapabilitiesHandlerImpl implements AiPowerUpsSettingsGroupHandler.Interface {\n    readonly name = \"capabilities\";\n    readonly inputSchema = inputSchema;\n\n    mapFromStorage(persisted: unknown): CapabilitiesSettings {\n        const stored = (persisted ?? {}) as PersistedCapabilities;\n        return { items: stored.items ?? {} };\n    }\n\n    async mapToStorage(internal: unknown): Promise<PersistedCapabilities> {\n        const input = internal as CapabilitiesSettings;\n\n        /*\n         * Every capability the form sent gets a key, `enabled` included, so the stored blob says\n         * plainly what the screen said. Entries are not dropped for being \"empty\": a row that only\n         * carries `enabled: true` is the normal state and worth seeing.\n         *\n         * Reading still has to treat a *missing* entry as enabled, because a capability registered\n         * after the last save has no key at all. `isCapabilityEnabled` is where that lives.\n         */\n        const entries = Object.entries(input.items ?? {})\n            // A type guard, not a plain predicate: a bare `Boolean(...)` filter reads the same but\n            // narrows nothing, so the `undefined` this exists to drop would flow straight on.\n            .filter((entry): entry is [string, AiCapabilityEntry] => Boolean(entry[1]))\n            .map(\n                ([id, entry]) =>\n                    [\n                        id,\n                        {\n                            enabled: normaliseEnabled(entry.enabled),\n                            overrides: dropEmptyValues(entry.overrides ?? {})\n                        }\n                    ] as const\n            );\n\n        return { items: Object.fromEntries(entries) };\n    }\n}\n\nexport default AiPowerUpsSettingsGroupHandler.createImplementation({\n    implementation: CapabilitiesHandlerImpl,\n    dependencies: []\n});\n"],"names":["overrideSchema","z","AI_MODEL_ROLE_IDS","entrySchema","inputSchema","dropEmptyValues","override","Object","value","normaliseEnabled","enabled","CapabilitiesHandlerImpl","persisted","stored","internal","input","entries","entry","Boolean","id","AiPowerUpsSettingsGroupHandler"],"mappings":";;;AAYA,MAAMA,iBAAiBC,EAAE,MAAM,CAAC;IAC5B,QAAQA,EAAE,KAAK,CAAC;QAACA,CAAC,CAADA,OAAM,CAACC;QAAoBD,EAAE,OAAO,CAAC;KAAI,EAAE,OAAO;IACnE,cAAcA,EAAE,MAAM,GAAG,OAAO;IAChC,OAAOA,EAAE,MAAM,GAAG,OAAO;IACzB,wBAAwBA,EAAE,MAAM,GAAG,OAAO;AAC9C;AAMA,MAAME,cAAcF,EAAE,MAAM,CAAC;IACzB,SAASA,EAAE,OAAO,GAAG,OAAO;IAC5B,WAAWD,eAAe,OAAO;AACrC;AAEA,MAAMI,cAAcH,EAAE,MAAM,CAAC;IACzB,OAAOA,EAAE,MAAM,CAACA,EAAE,MAAM,IAAIE;AAChC;AAOA,MAAME,kBAAkB,CAACC,WACrBC,OAAO,WAAW,CACdA,OAAO,OAAO,CAACD,UAAU,MAAM,CAAC,CAAC,GAAGE,MAAM;QACtC,IAAIA,QAAAA,OACA,OAAO;QAIX,OAAO,AAAiB,YAAjB,OAAOA,QAAqBA,AAAiB,OAAjBA,MAAM,IAAI,KAAY;IAC7D;AAOR,MAAMC,mBAAmB,CAACC,UAAiDA,AAAY,UAAZA;AAE3E,MAAMC;IAIF,eAAeC,SAAkB,EAAwB;QACrD,MAAMC,SAAUD,aAAa,CAAC;QAC9B,OAAO;YAAE,OAAOC,OAAO,KAAK,IAAI,CAAC;QAAE;IACvC;IAEA,MAAM,aAAaC,QAAiB,EAAkC;QAClE,MAAMC,QAAQD;QAUd,MAAME,UAAUT,OAAO,OAAO,CAACQ,MAAM,KAAK,IAAI,CAAC,GAG1C,MAAM,CAAC,CAACE,QAAgDC,QAAQD,KAAK,CAAC,EAAE,GACxE,GAAG,CACA,CAAC,CAACE,IAAIF,MAAM,GACR;gBACIE;gBACA;oBACI,SAASV,iBAAiBQ,MAAM,OAAO;oBACvC,WAAWZ,gBAAgBY,MAAM,SAAS,IAAI,CAAC;gBACnD;aACH;QAGb,OAAO;YAAE,OAAOV,OAAO,WAAW,CAACS;QAAS;IAChD;;aAnCS,IAAI,GAAG;aACP,WAAW,GAAGZ;;AAmC3B;AAEA,4BAAegB,+BAA+B,oBAAoB,CAAC;IAC/D,gBAAgBT;IAChB,cAAc,EAAE;AACpB"}

package/api/features/Capabilities/ListAiCapabilitiesUseCase.d.ts

@@ -0,0 +1,18 @@
+import { AiCapability, ListAiCapabilitiesUseCase } from "./abstractions.js";
+import type { IAiCapabilitySummary } from "./abstractions.js";
+/**
+ * Lists the registered capabilities for callers outside the api.
+ *
+ * The mapping lives here rather than in the GraphQL resolver so the shape sent over the wire is
+ * decided once, next to the abstraction it describes. It also keeps `guidance` from leaking: a
+ * capability's prompt is implementation, and the summary simply has no field for it.
+ */
+declare class ListAiCapabilitiesUseCaseImpl implements ListAiCapabilitiesUseCase.Interface {
+    private capabilities;
+    constructor(capabilities: AiCapability.Interface[]);
+    execute(): Promise<IAiCapabilitySummary[]>;
+}
+export declare const ListAiCapabilitiesUseCaseImplementation: typeof ListAiCapabilitiesUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListAiCapabilitiesUseCase>;
+};
+export {};

package/api/features/Capabilities/ListAiCapabilitiesUseCase.js

@@ -0,0 +1,28 @@
+import { AiCapability, ListAiCapabilitiesUseCase } from "./abstractions.js";
+class ListAiCapabilitiesUseCaseImpl {
+    constructor(capabilities){
+        this.capabilities = capabilities;
+    }
+    async execute() {
+        return this.capabilities.map((capability)=>({
+                id: capability.id,
+                label: capability.label,
+                description: capability.description,
+                defaultRole: capability.defaultRole
+            }));
+    }
+}
+const ListAiCapabilitiesUseCaseImplementation = ListAiCapabilitiesUseCase.createImplementation({
+    implementation: ListAiCapabilitiesUseCaseImpl,
+    dependencies: [
+        [
+            AiCapability,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { ListAiCapabilitiesUseCaseImplementation };
+
+//# sourceMappingURL=ListAiCapabilitiesUseCase.js.map

package/api/features/Capabilities/ListAiCapabilitiesUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/Capabilities/ListAiCapabilitiesUseCase.js","sources":["../../../../src/api/features/Capabilities/ListAiCapabilitiesUseCase.ts"],"sourcesContent":["import { AiCapability, ListAiCapabilitiesUseCase } from \"./abstractions.js\";\nimport type { IAiCapabilitySummary } from \"./abstractions.js\";\n\n/**\n * Lists the registered capabilities for callers outside the api.\n *\n * The mapping lives here rather than in the GraphQL resolver so the shape sent over the wire is\n * decided once, next to the abstraction it describes. It also keeps `guidance` from leaking: a\n * capability's prompt is implementation, and the summary simply has no field for it.\n */\nclass ListAiCapabilitiesUseCaseImpl implements ListAiCapabilitiesUseCase.Interface {\n    constructor(private capabilities: AiCapability.Interface[]) {}\n\n    async execute(): Promise<IAiCapabilitySummary[]> {\n        return this.capabilities.map(capability => ({\n            id: capability.id,\n            label: capability.label,\n            description: capability.description,\n            defaultRole: capability.defaultRole\n        }));\n    }\n}\n\nexport const ListAiCapabilitiesUseCaseImplementation =\n    ListAiCapabilitiesUseCase.createImplementation({\n        implementation: ListAiCapabilitiesUseCaseImpl,\n        dependencies: [[AiCapability, { multiple: true }]]\n    });\n"],"names":["ListAiCapabilitiesUseCaseImpl","capabilities","capability","ListAiCapabilitiesUseCaseImplementation","ListAiCapabilitiesUseCase","AiCapability"],"mappings":";AAUA,MAAMA;IACF,YAAoBC,YAAsC,CAAE;aAAxCA,YAAY,GAAZA;IAAyC;IAE7D,MAAM,UAA2C;QAC7C,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAACC,CAAAA,aAAe;gBACxC,IAAIA,WAAW,EAAE;gBACjB,OAAOA,WAAW,KAAK;gBACvB,aAAaA,WAAW,WAAW;gBACnC,aAAaA,WAAW,WAAW;YACvC;IACJ;AACJ;AAEO,MAAMC,0CACTC,0BAA0B,oBAAoB,CAAC;IAC3C,gBAAgBJ;IAChB,cAAc;QAAC;YAACK;YAAc;gBAAE,UAAU;YAAK;SAAE;KAAC;AACtD"}

package/api/features/Capabilities/ResolveAiCapabilityUseCase.d.ts

@@ -0,0 +1,30 @@
+import { Result } from "@webiny/feature/api";
+import { Encryption } from "@webiny/api-core/features/encryption/index.js";
+import { GetSettingsUseCase } from "../../../api/features/GetSettings/index.js";
+import { AiCapability, ResolveAiCapabilityUseCase } from "./abstractions.js";
+import type { IResolvedAiCapability } from "./abstractions.js";
+/**
+ * Turns a capability id into the model, credential and prompt text a use case needs.
+ *
+ * This is the single place that knows the precedence rules. Before it existed, six use cases each
+ * read `providers.presets[0]`, re-derived the SDK name from the model string and decrypted the key
+ * themselves, so "which model runs this feature" had six answers that only happened to agree.
+ *
+ * Precedence: a capability's pinned connection+model, else its chosen role, else its declared
+ * default role, else the `standard` role.
+ *
+ * There is deliberately no environment-variable fallback. A project whose settings say one thing
+ * and whose requests use another is the exact confusion this replaces.
+ */
+declare class ResolveAiCapabilityUseCaseImpl implements ResolveAiCapabilityUseCase.Interface {
+    private getSettings;
+    private encryption;
+    private capabilityLookup;
+    constructor(capabilities: AiCapability.Interface[], getSettings: GetSettingsUseCase.Interface, encryption: Encryption.Interface);
+    execute(capabilityId: string): Promise<Result<IResolvedAiCapability, Error>>;
+    private selectModel;
+}
+export declare const ResolveAiCapabilityUseCaseImplementation: typeof ResolveAiCapabilityUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IResolveAiCapabilityUseCase>;
+};
+export {};

package/api/features/Capabilities/ResolveAiCapabilityUseCase.js

@@ -0,0 +1,88 @@
+import { Result } from "@webiny/feature/api";
+import { Encryption } from "@webiny/api-core/features/encryption/index.js";
+import { GetSettingsUseCase } from "../GetSettings/index.js";
+import { sdkNameFromModel } from "../shared/modelId.js";
+import { AiCapability, ResolveAiCapabilityUseCase } from "./abstractions.js";
+import { isCapabilityEnabled } from "./types.js";
+const SETTINGS_PATH = "Settings → AI Power-Ups";
+class ResolveAiCapabilityUseCaseImpl {
+    constructor(capabilities, getSettings, encryption){
+        this.getSettings = getSettings;
+        this.encryption = encryption;
+        this.capabilityLookup = new Map(capabilities.map((c)=>[
+                c.id,
+                c
+            ]));
+    }
+    async execute(capabilityId) {
+        const capability = this.capabilityLookup.get(capabilityId);
+        if (!capability) return Result.fail(new Error(`Unknown AI capability "${capabilityId}". Register it with the AiCapability abstraction.`));
+        const settingsResult = await this.getSettings.execute();
+        if (settingsResult.isFail()) return Result.fail(new Error("Failed to load AI Power-Ups settings."));
+        const settings = settingsResult.value;
+        const entry = settings.capabilities?.items?.[capabilityId];
+        if (!isCapabilityEnabled(entry)) return Result.fail(new Error(`"${capability.label}" is switched off. Turn it back on under ${SETTINGS_PATH} → Capabilities.`));
+        const override = entry?.overrides ?? {};
+        const selection = this.selectModel(settings, capability.defaultRole, override);
+        if (selection.isFail()) return Result.fail(selection.error);
+        const { connectionId, model, roleId, fellBackToStandard } = selection.value;
+        const connection = settings.connections?.presets?.find((c)=>c.id === connectionId);
+        if (!connection) return Result.fail(new Error(`"${capability.label}" points at a connection that no longer exists. Pick one under ${SETTINGS_PATH} → Model roles.`));
+        if (!connection.apiKeyEncrypted) return Result.fail(new Error(`The connection "${connection.name}" has no API key. Add one under ${SETTINGS_PATH} → Connections.`));
+        const modelSdkName = sdkNameFromModel(model);
+        if (modelSdkName && connection.sdkName && modelSdkName !== connection.sdkName) return Result.fail(new Error(`The model "${model}" cannot run on the "${connection.name}" connection, which is a ${connection.sdkName} credential. Fix the pairing under ${SETTINGS_PATH} → Model roles.`));
+        return Result.ok({
+            capabilityId,
+            model,
+            connection: {
+                sdkName: modelSdkName || connection.sdkName,
+                apiKey: await this.encryption.decrypt(connection.apiKeyEncrypted)
+            },
+            roleId,
+            fellBackToStandard,
+            guidance: capability.guidance ?? "",
+            additionalInstructions: override.additionalInstructions?.trim() ?? ""
+        });
+    }
+    selectModel(settings, defaultRole, override) {
+        if (override.connectionId && override.model) return Result.ok({
+            connectionId: override.connectionId,
+            model: override.model,
+            roleId: null,
+            fellBackToStandard: false
+        });
+        const roles = settings.modelRoles?.roles;
+        const requestedRole = override.roleId || defaultRole;
+        const requested = roles?.[requestedRole];
+        if (requested?.connectionId && requested.model) return Result.ok({
+            connectionId: requested.connectionId,
+            model: requested.model,
+            roleId: requestedRole,
+            fellBackToStandard: false
+        });
+        const standard = roles?.standard;
+        if (standard?.connectionId && standard.model) return Result.ok({
+            connectionId: standard.connectionId,
+            model: standard.model,
+            roleId: "standard",
+            fellBackToStandard: "standard" !== requestedRole
+        });
+        return Result.fail(new Error(`No model is configured for the "${requestedRole}" role. Pick one under ${SETTINGS_PATH} → Model roles.`));
+    }
+}
+const ResolveAiCapabilityUseCaseImplementation = ResolveAiCapabilityUseCase.createImplementation({
+    implementation: ResolveAiCapabilityUseCaseImpl,
+    dependencies: [
+        [
+            AiCapability,
+            {
+                multiple: true
+            }
+        ],
+        GetSettingsUseCase,
+        Encryption
+    ]
+});
+export { ResolveAiCapabilityUseCaseImplementation };
+
+//# sourceMappingURL=ResolveAiCapabilityUseCase.js.map

package/api/features/Capabilities/ResolveAiCapabilityUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/Capabilities/ResolveAiCapabilityUseCase.js","sources":["../../../../src/api/features/Capabilities/ResolveAiCapabilityUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { Encryption } from \"@webiny/api-core/features/encryption/index.js\";\nimport { GetSettingsUseCase } from \"~/api/features/GetSettings/index.js\";\nimport { sdkNameFromModel } from \"~/api/features/shared/modelId.js\";\nimport { AiCapability, ResolveAiCapabilityUseCase } from \"./abstractions.js\";\nimport type { IResolvedAiCapability } from \"./abstractions.js\";\nimport { isCapabilityEnabled } from \"./types.js\";\nimport type { AiCapabilityOverride } from \"./types.js\";\nimport type { AiModelRoleId } from \"~/api/features/ModelRoles/index.js\";\nimport type { IAiPowerUpsSettings } from \"~/api/types.js\";\n\nconst SETTINGS_PATH = \"Settings → AI Power-Ups\";\n\n/**\n * Turns a capability id into the model, credential and prompt text a use case needs.\n *\n * This is the single place that knows the precedence rules. Before it existed, six use cases each\n * read `providers.presets[0]`, re-derived the SDK name from the model string and decrypted the key\n * themselves, so \"which model runs this feature\" had six answers that only happened to agree.\n *\n * Precedence: a capability's pinned connection+model, else its chosen role, else its declared\n * default role, else the `standard` role.\n *\n * There is deliberately no environment-variable fallback. A project whose settings say one thing\n * and whose requests use another is the exact confusion this replaces.\n */\nclass ResolveAiCapabilityUseCaseImpl implements ResolveAiCapabilityUseCase.Interface {\n    private capabilityLookup: Map<string, AiCapability.Interface>;\n\n    constructor(\n        capabilities: AiCapability.Interface[],\n        private getSettings: GetSettingsUseCase.Interface,\n        private encryption: Encryption.Interface\n    ) {\n        this.capabilityLookup = new Map(capabilities.map(c => [c.id, c]));\n    }\n\n    async execute(capabilityId: string): Promise<Result<IResolvedAiCapability, Error>> {\n        const capability = this.capabilityLookup.get(capabilityId);\n\n        if (!capability) {\n            // Nothing a project can do about this one: the caller passed an unregistered id.\n            return Result.fail(\n                new Error(\n                    `Unknown AI capability \"${capabilityId}\". Register it with the AiCapability abstraction.`\n                )\n            );\n        }\n\n        const settingsResult = await this.getSettings.execute();\n        if (settingsResult.isFail()) {\n            return Result.fail(new Error(\"Failed to load AI Power-Ups settings.\"));\n        }\n\n        const settings = settingsResult.value;\n        const entry = settings.capabilities?.items?.[capabilityId];\n\n        /*\n         * Checked here rather than at every call site, so a capability switched off in settings is\n         * off for the GraphQL mutation as much as for the button that usually triggers it. The\n         * admin hides the affordance too, but that is a courtesy and this is the actual gate.\n         */\n        if (!isCapabilityEnabled(entry)) {\n            return Result.fail(\n                new Error(\n                    `\"${capability.label}\" is switched off. Turn it back on under ${SETTINGS_PATH} → Capabilities.`\n                )\n            );\n        }\n\n        const override: AiCapabilityOverride = entry?.overrides ?? {};\n\n        const selection = this.selectModel(settings, capability.defaultRole, override);\n        if (selection.isFail()) {\n            return Result.fail(selection.error);\n        }\n\n        const { connectionId, model, roleId, fellBackToStandard } = selection.value;\n\n        const connection = settings.connections?.presets?.find(c => c.id === connectionId);\n\n        if (!connection) {\n            return Result.fail(\n                new Error(\n                    `\"${capability.label}\" points at a connection that no longer exists. Pick one under ${SETTINGS_PATH} → Model roles.`\n                )\n            );\n        }\n\n        if (!connection.apiKeyEncrypted) {\n            return Result.fail(\n                new Error(\n                    `The connection \"${connection.name}\" has no API key. Add one under ${SETTINGS_PATH} → Connections.`\n                )\n            );\n        }\n\n        /*\n         * A model is stored fully qualified (\"anthropic/claude-sonnet-4-5\") and a connection stores\n         * its vendor separately, so the two can disagree if a connection is re-pointed at another\n         * vendor after a role was filled. Catching it here beats a provider-side auth error.\n         */\n        const modelSdkName = sdkNameFromModel(model);\n        if (modelSdkName && connection.sdkName && modelSdkName !== connection.sdkName) {\n            return Result.fail(\n                new Error(\n                    `The model \"${model}\" cannot run on the \"${connection.name}\" connection, which is a ${connection.sdkName} credential. Fix the pairing under ${SETTINGS_PATH} → Model roles.`\n                )\n            );\n        }\n\n        return Result.ok({\n            capabilityId,\n            model,\n            connection: {\n                sdkName: modelSdkName || connection.sdkName,\n                apiKey: await this.encryption.decrypt(connection.apiKeyEncrypted)\n            },\n            roleId,\n            fellBackToStandard,\n            // Always the capability's own. Projects adjust prompts by appending, never by\n            // replacing, because for most capabilities the prompt is the output contract.\n            guidance: capability.guidance ?? \"\",\n            additionalInstructions: override.additionalInstructions?.trim() ?? \"\"\n        });\n    }\n\n    private selectModel(\n        settings: IAiPowerUpsSettings,\n        defaultRole: AiModelRoleId,\n        override: AiCapabilityOverride\n    ): Result<\n        {\n            connectionId: string;\n            model: string;\n            roleId: AiModelRoleId | null;\n            fellBackToStandard: boolean;\n        },\n        Error\n    > {\n        // A pinned connection+model wins outright. Both halves are required; one alone is a\n        // half-finished edit, so it is ignored rather than guessed at.\n        if (override.connectionId && override.model) {\n            return Result.ok({\n                connectionId: override.connectionId,\n                model: override.model,\n                roleId: null,\n                fellBackToStandard: false\n            });\n        }\n\n        const roles = settings.modelRoles?.roles;\n        const requestedRole = (override.roleId || defaultRole) as AiModelRoleId;\n        const requested = roles?.[requestedRole];\n\n        if (requested?.connectionId && requested.model) {\n            return Result.ok({\n                connectionId: requested.connectionId,\n                model: requested.model,\n                roleId: requestedRole,\n                fellBackToStandard: false\n            });\n        }\n\n        /*\n         * An unfilled role falls back to `standard` rather than failing. That is what keeps an\n         * upgrade quiet: migration fills only `standard`, and every feature that used to read\n         * `providers.presets[0]` keeps running on exactly the model it ran on before.\n         *\n         * It does mean an unfilled `vision` role sends images to whatever `standard` holds. Same\n         * as today's behaviour, and the settings screen says so next to the role.\n         */\n        const standard = roles?.standard;\n\n        if (standard?.connectionId && standard.model) {\n            return Result.ok({\n                connectionId: standard.connectionId,\n                model: standard.model,\n                roleId: \"standard\",\n                fellBackToStandard: requestedRole !== \"standard\"\n            });\n        }\n\n        return Result.fail(\n            new Error(\n                `No model is configured for the \"${requestedRole}\" role. Pick one under ${SETTINGS_PATH} → Model roles.`\n            )\n        );\n    }\n}\n\nexport const ResolveAiCapabilityUseCaseImplementation =\n    ResolveAiCapabilityUseCase.createImplementation({\n        implementation: ResolveAiCapabilityUseCaseImpl,\n        dependencies: [[AiCapability, { multiple: true }], GetSettingsUseCase, Encryption]\n    });\n"],"names":["SETTINGS_PATH","ResolveAiCapabilityUseCaseImpl","capabilities","getSettings","encryption","Map","c","capabilityId","capability","Result","Error","settingsResult","settings","entry","isCapabilityEnabled","override","selection","connectionId","model","roleId","fellBackToStandard","connection","modelSdkName","sdkNameFromModel","defaultRole","roles","requestedRole","requested","standard","ResolveAiCapabilityUseCaseImplementation","ResolveAiCapabilityUseCase","AiCapability","GetSettingsUseCase","Encryption"],"mappings":"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"}

package/api/features/Capabilities/abstractions.d.ts

@@ -0,0 +1,77 @@
+import { Result } from "@webiny/feature/api";
+import type { AiModelRoleId } from "../../../api/features/ModelRoles/index.js";
+/**
+ * One AI feature, declared so the settings screen can list it and a project can point it at a
+ * different model or adjust its prompt.
+ *
+ * Features register these; nothing hardcodes the list. An extension that adds an AI feature gets a
+ * row in Settings for free by registering a capability alongside it.
+ */
+export interface IAiCapability {
+    /** Stable, namespaced, and persisted as a settings key. Renaming one orphans its overrides. */
+    readonly id: string;
+    readonly label: string;
+    readonly description: string;
+    /** Which role supplies the model when the project has not overridden this capability. */
+    readonly defaultRole: AiModelRoleId;
+    /**
+     * The capability's fixed system-prompt block, owned by the code and not configurable.
+     *
+     * Leave it undefined when the prompt is assembled per request (from a content model schema, a
+     * component catalog, a persona) and the use case builds its own system text instead.
+     *
+     * Either way a project can only append to it, via `additionalInstructions`. These prompts carry
+     * the output contract the surrounding code parses, so they are implementation, not settings.
+     */
+    readonly guidance?: string;
+}
+export declare const AiCapability: import("@webiny/di").Abstraction<IAiCapability>;
+export declare namespace AiCapability {
+    type Interface = IAiCapability;
+}
+/**
+ * What a capability looks like to a caller outside the api.
+ *
+ * `guidance` is deliberately absent: a prompt is implementation, and there is no reason to ship ours
+ * over the wire to anyone who can read settings.
+ */
+export interface IAiCapabilitySummary {
+    id: string;
+    label: string;
+    description: string;
+    defaultRole: AiModelRoleId;
+}
+export interface IListAiCapabilitiesUseCase {
+    execute(): Promise<IAiCapabilitySummary[]>;
+}
+/** Everything registered, for the settings screen to render a row per feature. */
+export declare const ListAiCapabilitiesUseCase: import("@webiny/di").Abstraction<IListAiCapabilitiesUseCase>;
+export declare namespace ListAiCapabilitiesUseCase {
+    type Interface = IListAiCapabilitiesUseCase;
+    type Summary = IAiCapabilitySummary;
+}
+export interface IResolvedAiCapability {
+    capabilityId: string;
+    /** Fully qualified, e.g. `"anthropic/claude-sonnet-4-5"`. */
+    model: string;
+    connection: {
+        sdkName: string;
+        apiKey: string;
+    };
+    /** Which role supplied the model. `null` when a capability override pinned it directly. */
+    roleId: AiModelRoleId | null;
+    /** True when the requested role was empty and `standard` filled in for it. */
+    fellBackToStandard: boolean;
+    /** The capability's own guidance. Empty when it assembles its prompt per request. */
+    guidance: string;
+    /** Project text to append to the system prompt. Empty when unset. */
+    additionalInstructions: string;
+}
+export interface IResolveAiCapabilityUseCase {
+    execute(capabilityId: string): Promise<Result<IResolvedAiCapability, Error>>;
+}
+export declare const ResolveAiCapabilityUseCase: import("@webiny/di").Abstraction<IResolveAiCapabilityUseCase>;
+export declare namespace ResolveAiCapabilityUseCase {
+    type Interface = IResolveAiCapabilityUseCase;
+    type Resolution = IResolvedAiCapability;
+}

package/api/features/Capabilities/abstractions.js

@@ -0,0 +1,7 @@
+import { createAbstraction } from "@webiny/feature/api";
+const AiCapability = createAbstraction("AiPowerUpsAiCapability");
+const ListAiCapabilitiesUseCase = createAbstraction("AiPowerUpsListAiCapabilitiesUseCase");
+const ResolveAiCapabilityUseCase = createAbstraction("AiPowerUpsResolveAiCapabilityUseCase");
+export { AiCapability, ListAiCapabilitiesUseCase, ResolveAiCapabilityUseCase };
+
+//# sourceMappingURL=abstractions.js.map

package/api/features/Capabilities/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/Capabilities/abstractions.js","sources":["../../../../src/api/features/Capabilities/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport type { AiModelRoleId } from \"~/api/features/ModelRoles/index.js\";\n\n/**\n * One AI feature, declared so the settings screen can list it and a project can point it at a\n * different model or adjust its prompt.\n *\n * Features register these; nothing hardcodes the list. An extension that adds an AI feature gets a\n * row in Settings for free by registering a capability alongside it.\n */\nexport interface IAiCapability {\n    /** Stable, namespaced, and persisted as a settings key. Renaming one orphans its overrides. */\n    readonly id: string;\n    readonly label: string;\n    readonly description: string;\n    /** Which role supplies the model when the project has not overridden this capability. */\n    readonly defaultRole: AiModelRoleId;\n    /**\n     * The capability's fixed system-prompt block, owned by the code and not configurable.\n     *\n     * Leave it undefined when the prompt is assembled per request (from a content model schema, a\n     * component catalog, a persona) and the use case builds its own system text instead.\n     *\n     * Either way a project can only append to it, via `additionalInstructions`. These prompts carry\n     * the output contract the surrounding code parses, so they are implementation, not settings.\n     */\n    readonly guidance?: string;\n}\n\nexport const AiCapability = createAbstraction<IAiCapability>(\"AiPowerUpsAiCapability\");\n\nexport namespace AiCapability {\n    export type Interface = IAiCapability;\n}\n\n/**\n * What a capability looks like to a caller outside the api.\n *\n * `guidance` is deliberately absent: a prompt is implementation, and there is no reason to ship ours\n * over the wire to anyone who can read settings.\n */\nexport interface IAiCapabilitySummary {\n    id: string;\n    label: string;\n    description: string;\n    defaultRole: AiModelRoleId;\n}\n\nexport interface IListAiCapabilitiesUseCase {\n    execute(): Promise<IAiCapabilitySummary[]>;\n}\n\n/** Everything registered, for the settings screen to render a row per feature. */\nexport const ListAiCapabilitiesUseCase = createAbstraction<IListAiCapabilitiesUseCase>(\n    \"AiPowerUpsListAiCapabilitiesUseCase\"\n);\n\nexport namespace ListAiCapabilitiesUseCase {\n    export type Interface = IListAiCapabilitiesUseCase;\n    export type Summary = IAiCapabilitySummary;\n}\n\nexport interface IResolvedAiCapability {\n    capabilityId: string;\n    /** Fully qualified, e.g. `\"anthropic/claude-sonnet-4-5\"`. */\n    model: string;\n    connection: {\n        sdkName: string;\n        apiKey: string;\n    };\n    /** Which role supplied the model. `null` when a capability override pinned it directly. */\n    roleId: AiModelRoleId | null;\n    /** True when the requested role was empty and `standard` filled in for it. */\n    fellBackToStandard: boolean;\n    /** The capability's own guidance. Empty when it assembles its prompt per request. */\n    guidance: string;\n    /** Project text to append to the system prompt. Empty when unset. */\n    additionalInstructions: string;\n}\n\nexport interface IResolveAiCapabilityUseCase {\n    execute(capabilityId: string): Promise<Result<IResolvedAiCapability, Error>>;\n}\n\nexport const ResolveAiCapabilityUseCase = createAbstraction<IResolveAiCapabilityUseCase>(\n    \"AiPowerUpsResolveAiCapabilityUseCase\"\n);\n\nexport namespace ResolveAiCapabilityUseCase {\n    export type Interface = IResolveAiCapabilityUseCase;\n    export type Resolution = IResolvedAiCapability;\n}\n"],"names":["AiCapability","createAbstraction","ListAiCapabilitiesUseCase","ResolveAiCapabilityUseCase"],"mappings":";AA6BO,MAAMA,eAAeC,kBAAiC;AAwBtD,MAAMC,4BAA4BD,kBACrC;AA8BG,MAAME,6BAA6BF,kBACtC"}

package/api/features/Capabilities/composeSystemPrompt.d.ts

@@ -0,0 +1,14 @@
+import type { IResolvedAiCapability } from "./abstractions.js";
+/**
+ * Appends a project's additional instructions to a capability's system prompt.
+ *
+ * Appending is the only way a project adjusts a prompt, and the reason is upgrades: a project that
+ * appends keeps getting our prompt improvements, while one that replaced the prompt would be frozen
+ * at whatever we shipped the day they edited it. The heading is there so the model reads the
+ * project's text as instructions rather than as more of ours.
+ *
+ * `baseText` defaults to the capability's own guidance, which is what most callers want. The two
+ * generation use cases pass their own, because they build a prompt per request from a content model
+ * schema or a component catalog and the capability declares no fixed guidance of its own.
+ */
+export declare const withAdditionalInstructions: (resolved: Pick<IResolvedAiCapability, "guidance" | "additionalInstructions">, baseText?: string) => string;

package/api/features/Capabilities/composeSystemPrompt.js

@@ -0,0 +1,13 @@
+const withAdditionalInstructions = (resolved, baseText = resolved.guidance)=>{
+    if (!resolved.additionalInstructions) return baseText;
+    return `${baseText}
+
+### Project instructions
+
+These come from this project's settings and take precedence over the general guidance above.
+
+${resolved.additionalInstructions}`;
+};
+export { withAdditionalInstructions };
+
+//# sourceMappingURL=composeSystemPrompt.js.map

package/api/features/Capabilities/composeSystemPrompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/Capabilities/composeSystemPrompt.js","sources":["../../../../src/api/features/Capabilities/composeSystemPrompt.ts"],"sourcesContent":["import type { IResolvedAiCapability } from \"./abstractions.js\";\n\n/**\n * Appends a project's additional instructions to a capability's system prompt.\n *\n * Appending is the only way a project adjusts a prompt, and the reason is upgrades: a project that\n * appends keeps getting our prompt improvements, while one that replaced the prompt would be frozen\n * at whatever we shipped the day they edited it. The heading is there so the model reads the\n * project's text as instructions rather than as more of ours.\n *\n * `baseText` defaults to the capability's own guidance, which is what most callers want. The two\n * generation use cases pass their own, because they build a prompt per request from a content model\n * schema or a component catalog and the capability declares no fixed guidance of its own.\n */\nexport const withAdditionalInstructions = (\n    resolved: Pick<IResolvedAiCapability, \"guidance\" | \"additionalInstructions\">,\n    baseText: string = resolved.guidance\n): string => {\n    if (!resolved.additionalInstructions) {\n        return baseText;\n    }\n\n    return `${baseText}\n\n### Project instructions\n\nThese come from this project's settings and take precedence over the general guidance above.\n\n${resolved.additionalInstructions}`;\n};\n"],"names":["withAdditionalInstructions","resolved","baseText"],"mappings":"AAcO,MAAMA,6BAA6B,CACtCC,UACAC,WAAmBD,SAAS,QAAQ;IAEpC,IAAI,CAACA,SAAS,sBAAsB,EAChC,OAAOC;IAGX,OAAO,GAAGA,SAAS;;;;;;AAMvB,EAAED,SAAS,sBAAsB,EAAE;AACnC"}

package/api/features/Capabilities/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const CapabilitiesFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/api/features/Capabilities/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import CapabilitiesHandler from "./CapabilitiesHandler.js";
+import { ResolveAiCapabilityUseCaseImplementation } from "./ResolveAiCapabilityUseCase.js";
+import { ListAiCapabilitiesUseCaseImplementation } from "./ListAiCapabilitiesUseCase.js";
+const CapabilitiesFeature = createFeature({
+    name: "AiPowerUpsCapabilities",
+    register (container) {
+        container.register(CapabilitiesHandler);
+        container.register(ResolveAiCapabilityUseCaseImplementation);
+        container.register(ListAiCapabilitiesUseCaseImplementation);
+    }
+});
+export { CapabilitiesFeature };
+
+//# sourceMappingURL=feature.js.map

package/api/features/Capabilities/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/Capabilities/feature.js","sources":["../../../../src/api/features/Capabilities/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport CapabilitiesHandler from \"./CapabilitiesHandler.js\";\nimport { ResolveAiCapabilityUseCaseImplementation } from \"./ResolveAiCapabilityUseCase.js\";\nimport { ListAiCapabilitiesUseCaseImplementation } from \"./ListAiCapabilitiesUseCase.js\";\n\nexport const CapabilitiesFeature = createFeature({\n    name: \"AiPowerUpsCapabilities\",\n    register(container) {\n        container.register(CapabilitiesHandler);\n        container.register(ResolveAiCapabilityUseCaseImplementation);\n        container.register(ListAiCapabilitiesUseCaseImplementation);\n    }\n});\n"],"names":["CapabilitiesFeature","createFeature","container","CapabilitiesHandler","ResolveAiCapabilityUseCaseImplementation","ListAiCapabilitiesUseCaseImplementation"],"mappings":";;;;AAKO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;IACvB;AACJ"}

package/api/features/Capabilities/index.d.ts

@@ -0,0 +1,5 @@
+export { AiCapability, ResolveAiCapabilityUseCase, ListAiCapabilitiesUseCase } from "./abstractions.js";
+export type { IAiCapability, IResolvedAiCapability, IAiCapabilitySummary } from "./abstractions.js";
+export { withAdditionalInstructions } from "./composeSystemPrompt.js";
+export type { AiCapabilityOverride, CapabilitiesSettings } from "./types.js";
+export { CapabilitiesFeature } from "./feature.js";

package/api/features/Capabilities/index.js

@@ -0,0 +1,3 @@
+export { AiCapability, ListAiCapabilitiesUseCase, ResolveAiCapabilityUseCase } from "./abstractions.js";
+export { withAdditionalInstructions } from "./composeSystemPrompt.js";
+export { CapabilitiesFeature } from "./feature.js";

package/api/features/Capabilities/types.d.ts

@@ -0,0 +1,86 @@
+import type { IAiPowerUpsSettings } from "../../../api/types.js";
+import type { AiModelRoleId } from "../../../api/features/ModelRoles/index.js";
+/**
+ * What a project changed about one capability. Every field is optional and empty by default: an
+ * untouched capability runs on its declared role with its declared prompt.
+ */
+export interface AiCapabilityOverride {
+    /** Run this capability on a different role. Empty means use the capability's default. */
+    roleId?: AiModelRoleId | "";
+    /** Pin an exact connection, bypassing roles entirely. Requires `model` too. */
+    connectionId?: string;
+    /** Pin an exact model. Only read when `connectionId` is also set. */
+    model?: string;
+    /**
+     * Appended to the capability's prompt.
+     *
+     * The only prompt customisation there is, and deliberately so. Replacing a prompt outright
+     * used to be offered here and is not any more: for most capabilities the prompt *is* the output
+     * contract the surrounding code parses, so replacing it means replacing part of the
+     * implementation. Revision comparison regex-matches the HTML table its prompt specifies, and
+     * page translation `JSON.parse`s a shape its prompt dictates, both failing silently if the
+     * format goes away. Appending leaves the contract in place.
+     *
+     * A project that genuinely needs different behaviour decorates the use case in code, which is
+     * how the AI translation itself is built.
+     */
+    additionalInstructions?: string;
+}
+/**
+ * Everything a project decided about one capability.
+ *
+ * Two separate concerns, deliberately not flattened into one bag of optional fields. `enabled` is a
+ * boolean and the rest are strings, and an emptiness check that has to judge both at once is how
+ * "the user switched this off" ends up indistinguishable from "the user typed nothing".
+ */
+export interface AiCapabilityEntry {
+    /**
+     * Absent means enabled.
+     *
+     * A licence that grants a capability turns it on immediately; nobody opens settings to opt in.
+     * A save writes this explicitly either way, so a stored blob says plainly what the screen said,
+     * but absence still has to read as enabled: a capability registered since the last save has no
+     * entry at all.
+     *
+     * Read it as `enabled !== false`, never as `!enabled`. The second is true for `undefined` too,
+     * which silently disables every capability nobody has saved yet.
+     */
+    enabled?: boolean;
+    overrides: AiCapabilityOverride;
+}
+/**
+ * Keyed by capability id.
+ *
+ * Unlike model roles this cannot be a union of known keys: features register capabilities at
+ * runtime and an extension can add its own, so there is no compile-time set to enumerate.
+ *
+ * `Partial` is doing real work though. A bare `Record<string, T>` claims every string key is
+ * present, so a lookup types as `T` and the `?? {}` every caller writes looks redundant to the
+ * compiler. Most capabilities are untouched, so a miss is the common case.
+ */
+export type AiCapabilityEntries = Partial<Record<string, AiCapabilityEntry>>;
+declare module "~/api/types.js" {
+    interface IAiPowerUpsSettings {
+        capabilities: {
+            items: AiCapabilityEntries;
+        };
+    }
+}
+export type CapabilitiesSettings = IAiPowerUpsSettings["capabilities"];
+/**
+ * What `mapToStorage` writes, where `enabled` is required.
+ *
+ * Reading has to tolerate its absence, because an entry saved before this flag existed, or a
+ * capability registered since the last save, has no value for it. Writing never does: every entry
+ * the form posts is settled to a real boolean. Saying so here is what makes the compiler check the
+ * one place that writes the flag this feature is about.
+ */
+export interface PersistedAiCapabilityEntry {
+    enabled: boolean;
+    overrides: AiCapabilityOverride;
+}
+export interface PersistedCapabilities {
+    items?: Partial<Record<string, PersistedAiCapabilityEntry>>;
+}
+/** Absent means enabled. Spelled out once so no call site has to get the comparison right. */
+export declare const isCapabilityEnabled: (entry: AiCapabilityEntry | undefined) => boolean;

package/api/features/Capabilities/types.js

@@ -0,0 +1,4 @@
+const isCapabilityEnabled = (entry)=>entry?.enabled !== false;
+export { isCapabilityEnabled };
+
+//# sourceMappingURL=types.js.map

package/api/features/Capabilities/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/Capabilities/types.js","sources":["../../../../src/api/features/Capabilities/types.ts"],"sourcesContent":["import type { IAiPowerUpsSettings } from \"~/api/types.js\";\nimport type { AiModelRoleId } from \"~/api/features/ModelRoles/index.js\";\n\n/**\n * What a project changed about one capability. Every field is optional and empty by default: an\n * untouched capability runs on its declared role with its declared prompt.\n */\nexport interface AiCapabilityOverride {\n    /** Run this capability on a different role. Empty means use the capability's default. */\n    roleId?: AiModelRoleId | \"\";\n    /** Pin an exact connection, bypassing roles entirely. Requires `model` too. */\n    connectionId?: string;\n    /** Pin an exact model. Only read when `connectionId` is also set. */\n    model?: string;\n    /**\n     * Appended to the capability's prompt.\n     *\n     * The only prompt customisation there is, and deliberately so. Replacing a prompt outright\n     * used to be offered here and is not any more: for most capabilities the prompt *is* the output\n     * contract the surrounding code parses, so replacing it means replacing part of the\n     * implementation. Revision comparison regex-matches the HTML table its prompt specifies, and\n     * page translation `JSON.parse`s a shape its prompt dictates, both failing silently if the\n     * format goes away. Appending leaves the contract in place.\n     *\n     * A project that genuinely needs different behaviour decorates the use case in code, which is\n     * how the AI translation itself is built.\n     */\n    additionalInstructions?: string;\n}\n\n/**\n * Everything a project decided about one capability.\n *\n * Two separate concerns, deliberately not flattened into one bag of optional fields. `enabled` is a\n * boolean and the rest are strings, and an emptiness check that has to judge both at once is how\n * \"the user switched this off\" ends up indistinguishable from \"the user typed nothing\".\n */\nexport interface AiCapabilityEntry {\n    /**\n     * Absent means enabled.\n     *\n     * A licence that grants a capability turns it on immediately; nobody opens settings to opt in.\n     * A save writes this explicitly either way, so a stored blob says plainly what the screen said,\n     * but absence still has to read as enabled: a capability registered since the last save has no\n     * entry at all.\n     *\n     * Read it as `enabled !== false`, never as `!enabled`. The second is true for `undefined` too,\n     * which silently disables every capability nobody has saved yet.\n     */\n    enabled?: boolean;\n    overrides: AiCapabilityOverride;\n}\n\n/**\n * Keyed by capability id.\n *\n * Unlike model roles this cannot be a union of known keys: features register capabilities at\n * runtime and an extension can add its own, so there is no compile-time set to enumerate.\n *\n * `Partial` is doing real work though. A bare `Record<string, T>` claims every string key is\n * present, so a lookup types as `T` and the `?? {}` every caller writes looks redundant to the\n * compiler. Most capabilities are untouched, so a miss is the common case.\n */\nexport type AiCapabilityEntries = Partial<Record<string, AiCapabilityEntry>>;\n\ndeclare module \"~/api/types.js\" {\n    interface IAiPowerUpsSettings {\n        capabilities: {\n            items: AiCapabilityEntries;\n        };\n    }\n}\n\nexport type CapabilitiesSettings = IAiPowerUpsSettings[\"capabilities\"];\n\n/**\n * What `mapToStorage` writes, where `enabled` is required.\n *\n * Reading has to tolerate its absence, because an entry saved before this flag existed, or a\n * capability registered since the last save, has no value for it. Writing never does: every entry\n * the form posts is settled to a real boolean. Saying so here is what makes the compiler check the\n * one place that writes the flag this feature is about.\n */\nexport interface PersistedAiCapabilityEntry {\n    enabled: boolean;\n    overrides: AiCapabilityOverride;\n}\n\nexport interface PersistedCapabilities {\n    items?: Partial<Record<string, PersistedAiCapabilityEntry>>;\n}\n\n/** Absent means enabled. Spelled out once so no call site has to get the comparison right. */\nexport const isCapabilityEnabled = (entry: AiCapabilityEntry | undefined): boolean =>\n    entry?.enabled !== false;\n"],"names":["isCapabilityEnabled","entry"],"mappings":"AA6FO,MAAMA,sBAAsB,CAACC,QAChCA,OAAO,YAAY"}

package/api/features/CmsCompareEntryRevisions/CmsCompareEntryRevisionsUseCase.d.ts

@@ -1,19 +1,17 @@
 import { Ai } from "@webiny/api-core/features/ai/index.js";
-import { Encryption } from "@webiny/api-core/features/encryption/index.js";
 import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
 import { ModelToAstConverter } from "@webiny/api-headless-cms/features/contentModel/ModelToAstConverter/index.js";
 import { GetRevisionByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetRevisionById/index.js";
-import { GetSettingsUseCase } from "../../../api/features/GetSettings/index.js";
+import { ResolveAiCapabilityUseCase } from "../../../api/features/Capabilities/index.js";
 import { CmsCompareEntryRevisionsUseCase } from "./abstractions.js";
 import type { ICmsCompareEntryRevisionsParams, ICmsCompareEntryRevisionsResult } from "./abstractions.js";
 declare class CmsCompareEntryRevisionsUseCaseImpl implements CmsCompareEntryRevisionsUseCase.Interface {
-    private getSettings;
+    private resolveCapability;
     private ai;
-    private encryption;
     private getModel;
     private getRevisionById;
     private modelToAst;
-    constructor(getSettings: GetSettingsUseCase.Interface, ai: Ai.Interface, encryption: Encryption.Interface, getModel: GetModelUseCase.Interface, getRevisionById: GetRevisionByIdUseCase.Interface, modelToAst: ModelToAstConverter.Interface);
+    constructor(resolveCapability: ResolveAiCapabilityUseCase.Interface, ai: Ai.Interface, getModel: GetModelUseCase.Interface, getRevisionById: GetRevisionByIdUseCase.Interface, modelToAst: ModelToAstConverter.Interface);
     execute(params: ICmsCompareEntryRevisionsParams): Promise<ICmsCompareEntryRevisionsResult>;
 }
 export declare const CmsCompareEntryRevisionsUseCaseImplementation: typeof CmsCompareEntryRevisionsUseCaseImpl & {