@webiny/ai-powerups 0.0.0-unstable.0156a4c312

package/api/features/AiPromptContext/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { ProjectFileCache } from "./ProjectFileCache.js";
+import { ProjectFileAssembler } from "./ProjectFileAssembler.js";
+import { AiPromptContextBuilder } from "./AiPromptContextBuilder.js";
+const AiPromptContextFeature = createFeature({
+    name: "AiPowerUps/AiPromptContext",
+    register (container) {
+        container.register(ProjectFileCache);
+        container.register(ProjectFileAssembler);
+        container.register(AiPromptContextBuilder);
+    }
+});
+export { AiPromptContextFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AiPromptContext/feature.js","sources":["../../../../src/api/features/AiPromptContext/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ProjectFileCache } from \"./ProjectFileCache.js\";\nimport { ProjectFileAssembler } from \"./ProjectFileAssembler.js\";\nimport { AiPromptContextBuilder } from \"./AiPromptContextBuilder.js\";\n\nexport const AiPromptContextFeature = createFeature({\n    name: \"AiPowerUps/AiPromptContext\",\n    register(container) {\n        container.register(ProjectFileCache);\n        container.register(ProjectFileAssembler);\n        container.register(AiPromptContextBuilder);\n    }\n});\n"],"names":["AiPromptContextFeature","createFeature","container","ProjectFileCache","ProjectFileAssembler","AiPromptContextBuilder"],"mappings":";;;;AAKO,MAAMA,yBAAyBC,cAAc;IAChD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;IACvB;AACJ"}

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

@@ -0,0 +1 @@
+export { AiPromptContextBuilder, formatAdditionalFilesContext, type ResolvedProject, type ResolvedPersona, type ProjectFileContent } from "./abstractions.js";

package/api/features/AiPromptContext/index.js

@@ -0,0 +1 @@
+export { AiPromptContextBuilder, formatAdditionalFilesContext } from "./abstractions.js";

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

@@ -0,0 +1,16 @@
+/**
+ * A capability someone switched off in settings.
+ *
+ * Typed, rather than a plain `Error` like the resolver's other failures, because it is the one
+ * failure that is not a problem. Every other reason a capability cannot resolve (no model on the
+ * role, a deleted connection, a missing key) is a misconfiguration someone should hear about. This
+ * one is a decision someone already made, and a caller that runs automatically, on an upload or a
+ * page save, should skip quietly instead of reporting it as a failure every time.
+ *
+ * A caller a user triggered by hand can still show the message: it names the switch to flip.
+ */
+export declare class AiCapabilityDisabledError extends Error {
+    readonly capabilityId: string;
+    readonly code: "AI_CAPABILITY_DISABLED";
+    constructor(capabilityId: string, label: string, settingsPath: string);
+}

package/api/features/Capabilities/AiCapabilityDisabledError.js

@@ -0,0 +1,8 @@
+class AiCapabilityDisabledError extends Error {
+    constructor(capabilityId, label, settingsPath){
+        super(`"${label}" is switched off. Turn it back on under ${settingsPath} → Capabilities.`), this.capabilityId = capabilityId, this.code = "AI_CAPABILITY_DISABLED";
+    }
+}
+export { AiCapabilityDisabledError };
+
+//# sourceMappingURL=AiCapabilityDisabledError.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/Capabilities/AiCapabilityDisabledError.js","sources":["../../../../src/api/features/Capabilities/AiCapabilityDisabledError.ts"],"sourcesContent":["/**\n * A capability someone switched off in settings.\n *\n * Typed, rather than a plain `Error` like the resolver's other failures, because it is the one\n * failure that is not a problem. Every other reason a capability cannot resolve (no model on the\n * role, a deleted connection, a missing key) is a misconfiguration someone should hear about. This\n * one is a decision someone already made, and a caller that runs automatically, on an upload or a\n * page save, should skip quietly instead of reporting it as a failure every time.\n *\n * A caller a user triggered by hand can still show the message: it names the switch to flip.\n */\nexport class AiCapabilityDisabledError extends Error {\n    readonly code = \"AI_CAPABILITY_DISABLED\" as const;\n\n    constructor(\n        readonly capabilityId: string,\n        label: string,\n        settingsPath: string\n    ) {\n        super(`\"${label}\" is switched off. Turn it back on under ${settingsPath} → Capabilities.`);\n    }\n}\n"],"names":["AiCapabilityDisabledError","Error","capabilityId","label","settingsPath"],"mappings":"AAWO,MAAMA,kCAAkCC;IAG3C,YACaC,YAAoB,EAC7BC,KAAa,EACbC,YAAoB,CACtB;QACE,KAAK,CAAC,CAAC,CAAC,EAAED,MAAM,yCAAyC,EAAEC,aAAa,gBAAgB,CAAC,QAJhFF,YAAY,GAAZA,cAAAA,IAAAA,CAHJ,IAAI,GAAG;IAQhB;AACJ"}

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

@@ -0,0 +1,13 @@
+/**
+ * A model chosen on a workflow step that no settings connection can run (R169): its provider has
+ * no connection with a stored key any more, the provider no longer lists the model, or the id is
+ * not `<provider>/<id>`.
+ *
+ * Typed, like `AiCapabilityDisabledError`, so a caller maps it to its own fixed text without
+ * parsing the message. The message names the fix and carries no settings content.
+ */
+export declare class AiModelNotAvailableError extends Error {
+    readonly model: string;
+    readonly code: "AI_MODEL_NOT_AVAILABLE";
+    constructor(model: string);
+}

package/api/features/Capabilities/AiModelNotAvailableError.js

@@ -0,0 +1,8 @@
+class AiModelNotAvailableError extends Error {
+    constructor(model){
+        super(`The model "${model}" is not available. Add a connection for its provider under Settings → AI Power-Ups.`), this.model = model, this.code = "AI_MODEL_NOT_AVAILABLE";
+    }
+}
+export { AiModelNotAvailableError };
+
+//# sourceMappingURL=AiModelNotAvailableError.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/Capabilities/AiModelNotAvailableError.js","sources":["../../../../src/api/features/Capabilities/AiModelNotAvailableError.ts"],"sourcesContent":["/**\n * A model chosen on a workflow step that no settings connection can run (R169): its provider has\n * no connection with a stored key any more, the provider no longer lists the model, or the id is\n * not `<provider>/<id>`.\n *\n * Typed, like `AiCapabilityDisabledError`, so a caller maps it to its own fixed text without\n * parsing the message. The message names the fix and carries no settings content.\n */\nexport class AiModelNotAvailableError extends Error {\n    readonly code = \"AI_MODEL_NOT_AVAILABLE\" as const;\n\n    constructor(readonly model: string) {\n        super(\n            `The model \"${model}\" is not available. Add a connection for its provider under Settings → AI Power-Ups.`\n        );\n    }\n}\n"],"names":["AiModelNotAvailableError","Error","model"],"mappings":"AAQO,MAAMA,iCAAiCC;IAG1C,YAAqBC,KAAa,CAAE;QAChC,KAAK,CACD,CAAC,WAAW,EAAEA,MAAM,oFAAoF,CAAC,QAF5FA,KAAK,GAALA,OAAAA,IAAAA,CAFZ,IAAI,GAAG;IAMhB;AACJ"}

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

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { AiPowerUpsSettingsGroupHandler } from "../../../api/features/shared/index.js";
+import type { CapabilitiesSettings } from "./types.js";
+import type { PersistedCapabilities } from "./types.js";
+declare class CapabilitiesHandlerImpl implements AiPowerUpsSettingsGroupHandler.Interface {
+    readonly name = "capabilities";
+    readonly inputSchema: z.ZodObject<{
+        items: z.ZodRecord<z.ZodString, z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            overrides: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                roleId: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodEnum<{
+                    fast: "fast";
+                    standard: "standard";
+                    vision: "vision";
+                }>, z.ZodLiteral<"">]>>>;
+                connectionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                additionalInstructions: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    mapFromStorage(persisted: unknown): CapabilitiesSettings;
+    mapToStorage(internal: unknown): Promise<PersistedCapabilities>;
+}
+declare const _default: typeof CapabilitiesHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("../shared/abstractions.js").IAiPowerUpsSettingsGroupHandler>;
+};
+export default _default;

package/api/features/Capabilities/CapabilitiesHandler.js

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import { AiPowerUpsSettingsGroupHandler } from "../shared/index.js";
+import { AI_MODEL_ROLE_IDS } from "../ModelRoles/index.js";
+const overrideSchema = z.object({
+    roleId: z.union([
+        z["enum"](AI_MODEL_ROLE_IDS),
+        z.literal("")
+    ]).nullish(),
+    connectionId: z.string().nullish(),
+    model: z.string().nullish(),
+    additionalInstructions: z.string().nullish()
+});
+const entrySchema = z.object({
+    enabled: z.boolean().nullish(),
+    overrides: overrideSchema.nullish()
+});
+const inputSchema = z.object({
+    items: z.record(z.string(), entrySchema)
+});
+const dropEmptyValues = (override)=>Object.fromEntries(Object.entries(override).filter(([, value])=>{
+        if (null == value) return false;
+        return "string" == typeof value ? "" !== value.trim() : true;
+    }));
+const normaliseEnabled = (enabled)=>false !== enabled;
+class CapabilitiesHandlerImpl {
+    mapFromStorage(persisted) {
+        const stored = persisted ?? {};
+        return {
+            items: stored.items ?? {}
+        };
+    }
+    async mapToStorage(internal) {
+        const input = internal;
+        const entries = Object.entries(input.items ?? {}).filter((entry)=>Boolean(entry[1])).map(([id, entry])=>[
+                id,
+                {
+                    enabled: normaliseEnabled(entry.enabled),
+                    overrides: dropEmptyValues(entry.overrides ?? {})
+                }
+            ]);
+        return {
+            items: Object.fromEntries(entries)
+        };
+    }
+    constructor(){
+        this.name = "capabilities";
+        this.inputSchema = inputSchema;
+    }
+}
+const CapabilitiesHandler = AiPowerUpsSettingsGroupHandler.createImplementation({
+    implementation: CapabilitiesHandlerImpl,
+    dependencies: []
+});
+export default CapabilitiesHandler;
+
+//# sourceMappingURL=CapabilitiesHandler.js.map

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,33 @@
+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 { ConfiguredAiModelsService } from "../../../api/features/ConfiguredAiModels/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. The last step does not apply to `vision`, which fails
+ * rather than sending images to a model that may not accept them.
+ *
+ * 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 configuredModels;
+    private capabilityLookup;
+    constructor(capabilities: AiCapability.Interface[], getSettings: GetSettingsUseCase.Interface, encryption: Encryption.Interface, configuredModels: ConfiguredAiModelsService.Interface);
+    execute(capabilityId: string, model?: 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,114 @@
+import { Result } from "@webiny/feature/api";
+import { Encryption } from "@webiny/api-core/features/encryption/index.js";
+import { GetSettingsUseCase } from "../GetSettings/index.js";
+import { ConfiguredAiModelsService } from "../ConfiguredAiModels/index.js";
+import { sdkNameFromModel } from "../shared/modelId.js";
+import { AiCapability, ResolveAiCapabilityUseCase } from "./abstractions.js";
+import { isCapabilityEnabled } from "./types.js";
+import { AiCapabilityDisabledError } from "./AiCapabilityDisabledError.js";
+import { AiModelNotAvailableError } from "./AiModelNotAvailableError.js";
+const SETTINGS_PATH = "Settings → AI Power-Ups";
+class ResolveAiCapabilityUseCaseImpl {
+    constructor(capabilities, getSettings, encryption, configuredModels){
+        this.getSettings = getSettings;
+        this.encryption = encryption;
+        this.configuredModels = configuredModels;
+        this.capabilityLookup = new Map(capabilities.map((c)=>[
+                c.id,
+                c
+            ]));
+    }
+    async execute(capabilityId, model) {
+        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 AiCapabilityDisabledError(capabilityId, capability.label, SETTINGS_PATH));
+        const override = entry?.overrides ?? {};
+        if (void 0 !== model) {
+            const found = await this.configuredModels.findConnection(model);
+            if (found.isFail()) return Result.fail(found.error);
+            if (!found.value) return Result.fail(new AiModelNotAvailableError(model));
+            const configured = await this.configuredModels.list();
+            if (configured.isFail()) return Result.fail(configured.error);
+            if (!configured.value.some((item)=>item.id === model)) return Result.fail(new AiModelNotAvailableError(model));
+            return Result.ok({
+                capabilityId,
+                model,
+                connection: {
+                    sdkName: found.value.sdkName,
+                    apiKey: await this.encryption.decrypt(found.value.apiKeyEncrypted)
+                },
+                roleId: null,
+                fellBackToStandard: false,
+                guidance: capability.guidance ?? "",
+                additionalInstructions: override.additionalInstructions?.trim() ?? ""
+            });
+        }
+        const selection = this.selectModel(settings, capability.defaultRole, override);
+        if (selection.isFail()) return Result.fail(selection.error);
+        const { connectionId, model: selectedModel, 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(selectedModel);
+        if (modelSdkName && connection.sdkName && modelSdkName !== connection.sdkName) return Result.fail(new Error(`The model "${selectedModel}" 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: selectedModel,
+            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
+        });
+        if ("vision" === requestedRole) return Result.fail(new Error(`No model is configured for the "vision" role, and image work does not fall back to Standard. Pick one under ${SETTINGS_PATH} → Model roles.`));
+        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,
+        ConfiguredAiModelsService
+    ]
+});
+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 { ConfiguredAiModelsService } from \"~/api/features/ConfiguredAiModels/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 { AiCapabilityDisabledError } from \"./AiCapabilityDisabledError.js\";\nimport { AiModelNotAvailableError } from \"./AiModelNotAvailableError.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. The last step does not apply to `vision`, which fails\n * rather than sending images to a model that may not accept them.\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        private configuredModels: ConfiguredAiModelsService.Interface\n    ) {\n        this.capabilityLookup = new Map(capabilities.map(c => [c.id, c]));\n    }\n\n    async execute(\n        capabilityId: string,\n        model?: string\n    ): 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 AiCapabilityDisabledError(capabilityId, capability.label, SETTINGS_PATH)\n            );\n        }\n\n        const override: AiCapabilityOverride = entry?.overrides ?? {};\n\n        /*\n         * A model chosen on a workflow step (R169): run on the connection of its provider. No\n         * role, no pinned override, no standard fallback. The enabled gate above already ran, so\n         * a switched off capability or a lapsed licence still stops a step.\n         *\n         * The model must also still be one of the configured models, the list the step was saved\n         * against: one the provider dropped since would only fail later, inside the model call,\n         * with a generic reason instead of this typed one. A failed read is the service's fixed\n         * error (it logged the raw one).\n         */\n        if (model !== undefined) {\n            const found = await this.configuredModels.findConnection(model);\n            if (found.isFail()) {\n                return Result.fail(found.error);\n            }\n            if (!found.value) {\n                return Result.fail(new AiModelNotAvailableError(model));\n            }\n            const configured = await this.configuredModels.list();\n            if (configured.isFail()) {\n                return Result.fail(configured.error);\n            }\n            if (!configured.value.some(item => item.id === model)) {\n                return Result.fail(new AiModelNotAvailableError(model));\n            }\n            return Result.ok({\n                capabilityId,\n                model,\n                connection: {\n                    sdkName: found.value.sdkName,\n                    apiKey: await this.encryption.decrypt(found.value.apiKeyEncrypted)\n                },\n                roleId: null,\n                fellBackToStandard: false,\n                guidance: capability.guidance ?? \"\",\n                additionalInstructions: override.additionalInstructions?.trim() ?? \"\"\n            });\n        }\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: selectedModel, 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(selectedModel);\n        if (modelSdkName && connection.sdkName && modelSdkName !== connection.sdkName) {\n            return Result.fail(\n                new Error(\n                    `The model \"${selectedModel}\" 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: selectedModel,\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         * `vision` never falls back. Work on this role sends images, and nothing guarantees the\n         * Standard model accepts them, so falling through would trade a clear \"set a Vision model\"\n         * for a provider error about image input, or a text-only model silently guessing.\n         *\n         * Upgrades are not broken by this: `ModelRolesHandler` seeds `vision` from the legacy\n         * preset alongside `standard`, so a project that ran image work on `providers.presets[0]`\n         * keeps running it there, with the choice visible on the settings screen. A capability can\n         * still be pointed at another role deliberately through its `roleId` override.\n         */\n        if (requestedRole === \"vision\") {\n            return Result.fail(\n                new Error(\n                    `No model is configured for the \"vision\" role, and image work does not fall back to Standard. Pick one under ${SETTINGS_PATH} → Model roles.`\n                )\n            );\n        }\n\n        /*\n         * Every other role falls back to `standard`. Running cheap work on a stronger model is\n         * always correct, only more expensive.\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: [\n            [AiCapability, { multiple: true }],\n            GetSettingsUseCase,\n            Encryption,\n            ConfiguredAiModelsService\n        ]\n    });\n"],"names":["SETTINGS_PATH","ResolveAiCapabilityUseCaseImpl","capabilities","getSettings","encryption","configuredModels","Map","c","capabilityId","model","capability","Result","Error","settingsResult","settings","entry","isCapabilityEnabled","AiCapabilityDisabledError","override","undefined","found","AiModelNotAvailableError","configured","item","selection","connectionId","selectedModel","roleId","fellBackToStandard","connection","modelSdkName","sdkNameFromModel","defaultRole","roles","requestedRole","requested","standard","ResolveAiCapabilityUseCaseImplementation","ResolveAiCapabilityUseCase","AiCapability","GetSettingsUseCase","Encryption","ConfiguredAiModelsService"],"mappings":"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"}

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

@@ -0,0 +1,90 @@
+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, prefixed with its app (`cmsGenerateEntry`), and persisted as a settings key. Renaming
+     * one orphans its overrides.
+     *
+     * No dots. The id becomes a key under `capabilities.items`, and the settings form names its
+     * fields by dotted path, so `cms.generateEntry` reads as two levels of nesting.
+     */
+    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 {
+    /**
+     * Without `model` the model comes from the capability's override, role or the `standard` role.
+     * With `model` (the full id, `"<provider>/<id>"`) it is used as given on the first settings
+     * connection with a key for its provider (R169); the capability must still exist and be
+     * enabled. Fails with `AiModelNotAvailableError` when no such connection exists or the model
+     * is not one of the configured models (`ConfiguredAiModelsService.list`) any more.
+     */
+    execute(capabilityId: string, model?: 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    /**\n     * Stable, prefixed with its app (`cmsGenerateEntry`), and persisted as a settings key. Renaming\n     * one orphans its overrides.\n     *\n     * No dots. The id becomes a key under `capabilities.items`, and the settings form names its\n     * fields by dotted path, so `cms.generateEntry` reads as two levels of nesting.\n     */\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    /**\n     * Without `model` the model comes from the capability's override, role or the `standard` role.\n     * With `model` (the full id, `\"<provider>/<id>\"`) it is used as given on the first settings\n     * connection with a key for its provider (R169); the capability must still exist and be\n     * enabled. Fails with `AiModelNotAvailableError` when no such connection exists or the model\n     * is not one of the configured models (`ConfiguredAiModelsService.list`) any more.\n     */\n    execute(capabilityId: string, model?: 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":";AAmCO,MAAMA,eAAeC,kBAAiC;AAwBtD,MAAMC,4BAA4BD,kBACrC;AAqCG,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,7 @@
+export { AiCapability, ResolveAiCapabilityUseCase, ListAiCapabilitiesUseCase } from "./abstractions.js";
+export type { IAiCapability, IResolvedAiCapability, IAiCapabilitySummary } from "./abstractions.js";
+export { withAdditionalInstructions } from "./composeSystemPrompt.js";
+export { AiCapabilityDisabledError } from "./AiCapabilityDisabledError.js";
+export { AiModelNotAvailableError } from "./AiModelNotAvailableError.js";
+export type { AiCapabilityOverride, CapabilitiesSettings } from "./types.js";
+export { CapabilitiesFeature } from "./feature.js";