@webiny/ai-powerups 6.6.0-alpha.4 → 6.6.0-alpha.6

package/api/Extension.js

@@ -1,4 +1,5 @@
 import { createFeature } from "@webiny/feature/api";
+import { FeatureFlags } from "@webiny/api-core/features/featureFlags/abstractions.js";
 import { BaseGraphQLSchema } from "./graphql/BaseGraphQLSchema.js";
 import AiPowerUpsSettingsGraphQLMapper from "./graphql/AiPowerUpsSettingsGraphQLMapper.js";
 import { AiPowerUpsSettingsCache } from "./features/shared/SettingsCache.js";
@@ -6,6 +7,9 @@ import { GetSettingsFeature } from "./features/GetSettings/feature.js";
 import { UpdateSettingsFeature } from "./features/UpdateSettings/feature.js";
 import { WbGeneratePageContentFeature } from "./features/WbGeneratePageContent/feature.js";
 import { ProvidersFeature } from "./features/Providers/feature.js";
+import { ConnectionsFeature } from "./features/Connections/feature.js";
+import { ModelRolesFeature } from "./features/ModelRoles/feature.js";
+import { CapabilitiesFeature } from "./features/Capabilities/feature.js";
 import { ReaderPersonasFeature } from "./features/ReaderPersonas/feature.js";
 import { WriterPersonasFeature } from "./features/WriterPersonas/feature.js";
 import { ProjectsFeature } from "./features/Projects/feature.js";
@@ -14,17 +18,21 @@ import { AiImageEnrichmentFeature } from "./features/AiImageEnrichment/feature.j
 import { ExtractFrontmatterFeature } from "./features/ExtractFrontmatter/feature.js";
 import { CmsGenerateEntryContentFeature } from "./features/CmsGenerateEntryContent/feature.js";
 import { CmsResolveImageToolFeature } from "./features/CmsResolveImageTool/feature.js";
-import { AiChatProviderFeature } from "./features/AiChatProvider/index.js";
+import { AdminAssistantFeature } from "./features/AdminAssistant/index.js";
 import { CmsCompareEntryRevisionsFeature } from "./features/CmsCompareEntryRevisions/feature.js";
 import { WbTranslatePageFeature } from "./features/WbTranslatePage/feature.js";
 import { CmsCompareEntryRevisionsSchema } from "./graphql/CmsCompareEntryRevisionsSchema.js";
 const Extension = createFeature({
     name: "AiPowerUps",
     register (container) {
+        if (!container.resolve(FeatureFlags).get().isEnabled("aiPowerups")) return;
         container.register(AiPowerUpsSettingsCache).inSingletonScope();
         GetSettingsFeature.register(container);
         UpdateSettingsFeature.register(container);
         ProvidersFeature.register(container);
+        ConnectionsFeature.register(container);
+        ModelRolesFeature.register(container);
+        CapabilitiesFeature.register(container);
         ReaderPersonasFeature.register(container);
         WriterPersonasFeature.register(container);
         ProjectsFeature.register(container);
@@ -32,7 +40,7 @@ const Extension = createFeature({
         WbGeneratePageContentFeature.register(container);
         CmsGenerateEntryContentFeature.register(container);
         CmsResolveImageToolFeature.register(container);
-        AiChatProviderFeature.register(container);
+        AdminAssistantFeature.register(container);
         ExtractFrontmatterFeature.register(container);
         AiImageEnrichmentFeature.register(container);
         CmsCompareEntryRevisionsFeature.register(container);

package/api/Extension.js.map

@@ -1 +1 @@
-{"version":3,"file":"api/Extension.js","sources":["../../src/api/Extension.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { BaseGraphQLSchema } from \"./graphql/BaseGraphQLSchema.js\";\nimport AiPowerUpsSettingsGraphQLMapperImpl from \"./graphql/AiPowerUpsSettingsGraphQLMapper.js\";\nimport { AiPowerUpsSettingsCache } from \"./features/shared/SettingsCache.js\";\nimport { GetSettingsFeature } from \"./features/GetSettings/feature.js\";\nimport { UpdateSettingsFeature } from \"./features/UpdateSettings/feature.js\";\nimport { WbGeneratePageContentFeature } from \"./features/WbGeneratePageContent/feature.js\";\nimport { ProvidersFeature } from \"./features/Providers/feature.js\";\nimport { ReaderPersonasFeature } from \"./features/ReaderPersonas/feature.js\";\nimport { WriterPersonasFeature } from \"./features/WriterPersonas/feature.js\";\nimport { ProjectsFeature } from \"./features/Projects/feature.js\";\nimport { AiPromptContextFeature } from \"./features/AiPromptContext/feature.js\";\nimport { AiImageEnrichmentFeature } from \"./features/AiImageEnrichment/feature.js\";\nimport { ExtractFrontmatterFeature } from \"./features/ExtractFrontmatter/feature.js\";\nimport { CmsGenerateEntryContentFeature } from \"./features/CmsGenerateEntryContent/feature.js\";\nimport { CmsResolveImageToolFeature } from \"./features/CmsResolveImageTool/feature.js\";\nimport { AiChatProviderFeature } from \"./features/AiChatProvider/index.js\";\nimport { CmsCompareEntryRevisionsFeature } from \"./features/CmsCompareEntryRevisions/feature.js\";\nimport { WbTranslatePageFeature } from \"./features/WbTranslatePage/feature.js\";\nimport { CmsCompareEntryRevisionsSchema } from \"./graphql/CmsCompareEntryRevisionsSchema.js\";\n\nexport const Extension = createFeature({\n    name: \"AiPowerUps\",\n    register(container) {\n        container.register(AiPowerUpsSettingsCache).inSingletonScope();\n\n        GetSettingsFeature.register(container);\n        UpdateSettingsFeature.register(container);\n        ProvidersFeature.register(container);\n        ReaderPersonasFeature.register(container);\n        WriterPersonasFeature.register(container);\n        ProjectsFeature.register(container);\n        AiPromptContextFeature.register(container);\n        WbGeneratePageContentFeature.register(container);\n        CmsGenerateEntryContentFeature.register(container);\n        CmsResolveImageToolFeature.register(container);\n        AiChatProviderFeature.register(container);\n        ExtractFrontmatterFeature.register(container);\n\n        // Registered unconditionally. The WCP license gate lives inside the feature's\n        // FileAfterCreate handler (trigger-time), because the license isn't loaded yet during this\n        // register() phase — a register-time canUse* check reads NullLicense and is always false.\n        AiImageEnrichmentFeature.register(container);\n\n        CmsCompareEntryRevisionsFeature.register(container);\n        WbTranslatePageFeature.register(container);\n\n        container.register(AiPowerUpsSettingsGraphQLMapperImpl).inSingletonScope();\n        container.register(BaseGraphQLSchema);\n        container.register(CmsCompareEntryRevisionsSchema);\n    }\n});\n"],"names":["Extension","createFeature","container","AiPowerUpsSettingsCache","GetSettingsFeature","UpdateSettingsFeature","ProvidersFeature","ReaderPersonasFeature","WriterPersonasFeature","ProjectsFeature","AiPromptContextFeature","WbGeneratePageContentFeature","CmsGenerateEntryContentFeature","CmsResolveImageToolFeature","AiChatProviderFeature","ExtractFrontmatterFeature","AiImageEnrichmentFeature","CmsCompareEntryRevisionsFeature","WbTranslatePageFeature","AiPowerUpsSettingsGraphQLMapperImpl","BaseGraphQLSchema","CmsCompareEntryRevisionsSchema"],"mappings":";;;;;;;;;;;;;;;;;;;;AAqBO,MAAMA,YAAYC,cAAc;IACnC,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,yBAAyB,gBAAgB;QAE5DC,mBAAmB,QAAQ,CAACF;QAC5BG,sBAAsB,QAAQ,CAACH;QAC/BI,iBAAiB,QAAQ,CAACJ;QAC1BK,sBAAsB,QAAQ,CAACL;QAC/BM,sBAAsB,QAAQ,CAACN;QAC/BO,gBAAgB,QAAQ,CAACP;QACzBQ,uBAAuB,QAAQ,CAACR;QAChCS,6BAA6B,QAAQ,CAACT;QACtCU,+BAA+B,QAAQ,CAACV;QACxCW,2BAA2B,QAAQ,CAACX;QACpCY,sBAAsB,QAAQ,CAACZ;QAC/Ba,0BAA0B,QAAQ,CAACb;QAKnCc,yBAAyB,QAAQ,CAACd;QAElCe,gCAAgC,QAAQ,CAACf;QACzCgB,uBAAuB,QAAQ,CAAChB;QAEhCA,UAAU,QAAQ,CAACiB,iCAAqC,gBAAgB;QACxEjB,UAAU,QAAQ,CAACkB;QACnBlB,UAAU,QAAQ,CAACmB;IACvB;AACJ"}
+{"version":3,"file":"api/Extension.js","sources":["../../src/api/Extension.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { FeatureFlags } from \"@webiny/api-core/features/featureFlags/abstractions.js\";\nimport { BaseGraphQLSchema } from \"./graphql/BaseGraphQLSchema.js\";\nimport AiPowerUpsSettingsGraphQLMapperImpl from \"./graphql/AiPowerUpsSettingsGraphQLMapper.js\";\nimport { AiPowerUpsSettingsCache } from \"./features/shared/SettingsCache.js\";\nimport { GetSettingsFeature } from \"./features/GetSettings/feature.js\";\nimport { UpdateSettingsFeature } from \"./features/UpdateSettings/feature.js\";\nimport { WbGeneratePageContentFeature } from \"./features/WbGeneratePageContent/feature.js\";\nimport { ProvidersFeature } from \"./features/Providers/feature.js\";\nimport { ConnectionsFeature } from \"./features/Connections/feature.js\";\nimport { ModelRolesFeature } from \"./features/ModelRoles/feature.js\";\nimport { CapabilitiesFeature } from \"./features/Capabilities/feature.js\";\nimport { ReaderPersonasFeature } from \"./features/ReaderPersonas/feature.js\";\nimport { WriterPersonasFeature } from \"./features/WriterPersonas/feature.js\";\nimport { ProjectsFeature } from \"./features/Projects/feature.js\";\nimport { AiPromptContextFeature } from \"./features/AiPromptContext/feature.js\";\nimport { AiImageEnrichmentFeature } from \"./features/AiImageEnrichment/feature.js\";\nimport { ExtractFrontmatterFeature } from \"./features/ExtractFrontmatter/feature.js\";\nimport { CmsGenerateEntryContentFeature } from \"./features/CmsGenerateEntryContent/feature.js\";\nimport { CmsResolveImageToolFeature } from \"./features/CmsResolveImageTool/feature.js\";\nimport { AdminAssistantFeature } from \"./features/AdminAssistant/index.js\";\nimport { CmsCompareEntryRevisionsFeature } from \"./features/CmsCompareEntryRevisions/feature.js\";\nimport { WbTranslatePageFeature } from \"./features/WbTranslatePage/feature.js\";\nimport { CmsCompareEntryRevisionsSchema } from \"./graphql/CmsCompareEntryRevisionsSchema.js\";\n\nexport const Extension = createFeature({\n    name: \"AiPowerUps\",\n    register(container) {\n        /*\n         * The whole extension is gated here rather than around `<Api.Extension>` in\n         * `AiPowerups.tsx`. That wrapper read project config while the project graph was built, so\n         * a licence bought after the last deploy did nothing until the next one.\n         *\n         * Register time is early enough and the flags are correct here: `registerApiRequestStack`\n         * refreshes the WCP licence before any feature registers, so `isEnabled` sees the effective\n         * flags (project config && live licence). `AcoFeature` and `AiChatFeature` gate the same\n         * way.\n         *\n         * Nothing is registered when it is off, so a project without AI Power-Ups has no settings\n         * schema and no capability resolver at all, rather than ones that fail on use. Anything\n         * outside this extension that wants a capability must therefore declare\n         * `[ResolveAiCapabilityUseCase, { optional: true }]` and handle its absence.\n         */\n        if (!container.resolve(FeatureFlags).get().isEnabled(\"aiPowerups\")) {\n            return;\n        }\n\n        container.register(AiPowerUpsSettingsCache).inSingletonScope();\n\n        GetSettingsFeature.register(container);\n        UpdateSettingsFeature.register(container);\n        /*\n         * `ProvidersFeature` is still registered so the legacy `providers` section keeps round-\n         * tripping through storage. `Connections` and `ModelRoles` read it once to seed\n         * themselves; nothing else does. It goes away with the next breaking release.\n         */\n        ProvidersFeature.register(container);\n        ConnectionsFeature.register(container);\n        ModelRolesFeature.register(container);\n        CapabilitiesFeature.register(container);\n        ReaderPersonasFeature.register(container);\n        WriterPersonasFeature.register(container);\n        ProjectsFeature.register(container);\n        AiPromptContextFeature.register(container);\n        WbGeneratePageContentFeature.register(container);\n        CmsGenerateEntryContentFeature.register(container);\n        CmsResolveImageToolFeature.register(container);\n        AdminAssistantFeature.register(container);\n        ExtractFrontmatterFeature.register(container);\n\n        // Registered unconditionally. The WCP license gate lives inside the feature's\n        // FileAfterCreate handler (trigger-time), because the license isn't loaded yet during this\n        // register() phase — a register-time canUse* check reads NullLicense and is always false.\n        AiImageEnrichmentFeature.register(container);\n\n        CmsCompareEntryRevisionsFeature.register(container);\n        WbTranslatePageFeature.register(container);\n\n        container.register(AiPowerUpsSettingsGraphQLMapperImpl).inSingletonScope();\n        container.register(BaseGraphQLSchema);\n        container.register(CmsCompareEntryRevisionsSchema);\n    }\n});\n"],"names":["Extension","createFeature","container","FeatureFlags","AiPowerUpsSettingsCache","GetSettingsFeature","UpdateSettingsFeature","ProvidersFeature","ConnectionsFeature","ModelRolesFeature","CapabilitiesFeature","ReaderPersonasFeature","WriterPersonasFeature","ProjectsFeature","AiPromptContextFeature","WbGeneratePageContentFeature","CmsGenerateEntryContentFeature","CmsResolveImageToolFeature","AdminAssistantFeature","ExtractFrontmatterFeature","AiImageEnrichmentFeature","CmsCompareEntryRevisionsFeature","WbTranslatePageFeature","AiPowerUpsSettingsGraphQLMapperImpl","BaseGraphQLSchema","CmsCompareEntryRevisionsSchema"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAyBO,MAAMA,YAAYC,cAAc;IACnC,MAAM;IACN,UAASC,SAAS;QAgBd,IAAI,CAACA,UAAU,OAAO,CAACC,cAAc,GAAG,GAAG,SAAS,CAAC,eACjD;QAGJD,UAAU,QAAQ,CAACE,yBAAyB,gBAAgB;QAE5DC,mBAAmB,QAAQ,CAACH;QAC5BI,sBAAsB,QAAQ,CAACJ;QAM/BK,iBAAiB,QAAQ,CAACL;QAC1BM,mBAAmB,QAAQ,CAACN;QAC5BO,kBAAkB,QAAQ,CAACP;QAC3BQ,oBAAoB,QAAQ,CAACR;QAC7BS,sBAAsB,QAAQ,CAACT;QAC/BU,sBAAsB,QAAQ,CAACV;QAC/BW,gBAAgB,QAAQ,CAACX;QACzBY,uBAAuB,QAAQ,CAACZ;QAChCa,6BAA6B,QAAQ,CAACb;QACtCc,+BAA+B,QAAQ,CAACd;QACxCe,2BAA2B,QAAQ,CAACf;QACpCgB,sBAAsB,QAAQ,CAAChB;QAC/BiB,0BAA0B,QAAQ,CAACjB;QAKnCkB,yBAAyB,QAAQ,CAAClB;QAElCmB,gCAAgC,QAAQ,CAACnB;QACzCoB,uBAAuB,QAAQ,CAACpB;QAEhCA,UAAU,QAAQ,CAACqB,iCAAqC,gBAAgB;QACxErB,UAAU,QAAQ,CAACsB;QACnBtB,UAAU,QAAQ,CAACuB;IACvB;AACJ"}

package/api/features/AdminAssistant/AdminAssistantStreamRoute.d.ts

@@ -0,0 +1,34 @@
+import { HttpRouteDefinition, HttpRouteHandler } from "@webiny/event-handler-core";
+import type { IHttpRequest, IHttpResponseBuilder } from "@webiny/event-handler-core";
+import { AdminAssistantUseCase } from "./abstractions.js";
+/**
+ * `POST /stream/ai/admin-assistant`, reported as it works rather than all at once.
+ *
+ * A separate route rather than a flag on the buffered one: the two have genuinely different response
+ * contracts (one JSON object versus an event stream), so a client picks which it wants by the URL it
+ * calls, and the buffered route stays available for callers that cannot read a stream.
+ *
+ * Failures after the first byte cannot become a status code, since the response has already committed
+ * to 200, so the use case reports them as `error` events and the stream ends normally.
+ */
+declare class AdminAssistantStreamRouteImpl implements HttpRouteHandler.Interface {
+    private readonly assistant;
+    constructor(assistant: AdminAssistantUseCase.Interface);
+    handle(request: IHttpRequest, response: IHttpResponseBuilder): Promise<IHttpResponseBuilder>;
+}
+export declare const AdminAssistantStreamRoute: typeof AdminAssistantStreamRouteImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRoute>;
+};
+declare class AdminAssistantStreamRouteDefinitionImpl implements HttpRouteDefinition.Interface {
+    readonly name = "admin-assistant-stream";
+    readonly method = "POST";
+    readonly path = "/stream/ai/admin-assistant";
+    readonly handler: typeof AdminAssistantStreamRouteImpl & {
+        __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRoute>;
+    };
+}
+/** What the router matches on. Zero dependencies, so building it costs nothing. */
+export declare const AdminAssistantStreamRouteDefinition: typeof AdminAssistantStreamRouteDefinitionImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRouteDefinition>;
+};
+export {};

package/api/features/AdminAssistant/AdminAssistantStreamRoute.js

@@ -0,0 +1,42 @@
+import { HttpRouteDefinition, HttpRouteHandler, toSseFrame } from "@webiny/event-handler-core";
+import { AdminAssistantUseCase } from "./abstractions.js";
+import { parseChatBody } from "./parseChatBody.js";
+const BAD_REQUEST_MESSAGE = "Provide either a non-empty `prompt` string or a `messages` array of model messages.";
+async function* toSseFrames(events) {
+    for await (const event of events)yield toSseFrame(event);
+}
+class AdminAssistantStreamRouteImpl {
+    constructor(assistant){
+        this.assistant = assistant;
+    }
+    async handle(request, response) {
+        const parsed = parseChatBody(request.body);
+        if (!parsed) return response.status(400).json({
+            error: BAD_REQUEST_MESSAGE
+        });
+        const events = this.assistant.stream(parsed);
+        const frames = toSseFrames(events);
+        return response.sse(frames);
+    }
+}
+const AdminAssistantStreamRoute = HttpRouteHandler.createImplementation({
+    implementation: AdminAssistantStreamRouteImpl,
+    dependencies: [
+        AdminAssistantUseCase
+    ]
+});
+class AdminAssistantStreamRouteDefinitionImpl {
+    constructor(){
+        this.name = "admin-assistant-stream";
+        this.method = "POST";
+        this.path = "/stream/ai/admin-assistant";
+        this.handler = AdminAssistantStreamRoute;
+    }
+}
+const AdminAssistantStreamRouteDefinition = HttpRouteDefinition.createImplementation({
+    implementation: AdminAssistantStreamRouteDefinitionImpl,
+    dependencies: []
+});
+export { AdminAssistantStreamRoute, AdminAssistantStreamRouteDefinition };
+
+//# sourceMappingURL=AdminAssistantStreamRoute.js.map

package/api/features/AdminAssistant/AdminAssistantStreamRoute.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AdminAssistant/AdminAssistantStreamRoute.js","sources":["../../../../src/api/features/AdminAssistant/AdminAssistantStreamRoute.ts"],"sourcesContent":["import { HttpRouteDefinition, HttpRouteHandler, toSseFrame } from \"@webiny/event-handler-core\";\nimport type { IHttpRequest, IHttpResponseBuilder } from \"@webiny/event-handler-core\";\nimport { AdminAssistantUseCase } from \"./abstractions.js\";\nimport type { AdminAssistantEvent } from \"./events.js\";\nimport { parseChatBody } from \"./parseChatBody.js\";\n\nconst BAD_REQUEST_MESSAGE =\n    \"Provide either a non-empty `prompt` string or a `messages` array of model messages.\";\n\n/**\n * Frame the feature's events as SSE records. The wire format comes from `event-handler-core`; which\n * events exist, and what they carry, belongs to the feature, so the mapping lives here.\n */\nasync function* toSseFrames(events: AsyncIterable<AdminAssistantEvent>): AsyncIterable<string> {\n    for await (const event of events) {\n        yield toSseFrame(event);\n    }\n}\n\n/**\n * `POST /stream/ai/admin-assistant`, reported as it works rather than all at once.\n *\n * A separate route rather than a flag on the buffered one: the two have genuinely different response\n * contracts (one JSON object versus an event stream), so a client picks which it wants by the URL it\n * calls, and the buffered route stays available for callers that cannot read a stream.\n *\n * Failures after the first byte cannot become a status code, since the response has already committed\n * to 200, so the use case reports them as `error` events and the stream ends normally.\n */\nclass AdminAssistantStreamRouteImpl implements HttpRouteHandler.Interface {\n    public constructor(private readonly assistant: AdminAssistantUseCase.Interface) {}\n\n    public async handle(\n        request: IHttpRequest,\n        response: IHttpResponseBuilder\n    ): Promise<IHttpResponseBuilder> {\n        const parsed = parseChatBody(request.body);\n\n        if (!parsed) {\n            return response.status(400).json({ error: BAD_REQUEST_MESSAGE });\n        }\n\n        const events = this.assistant.stream(parsed);\n        const frames = toSseFrames(events);\n\n        return response.sse(frames);\n    }\n}\n\nexport const AdminAssistantStreamRoute = HttpRouteHandler.createImplementation({\n    implementation: AdminAssistantStreamRouteImpl,\n    dependencies: [AdminAssistantUseCase]\n});\n\nclass AdminAssistantStreamRouteDefinitionImpl implements HttpRouteDefinition.Interface {\n    readonly name = \"admin-assistant-stream\";\n    readonly method = \"POST\";\n    /*\n     * Under `/stream/*` because that prefix is what reaches a transport able to stream. On AWS,\n     * CloudFront routes `/stream/*` to the Lambda Function URL origin; everything else goes to API\n     * Gateway, which buffers the whole response no matter how the route produced it. A path outside\n     * this prefix still works, it just silently arrives all at once.\n     */\n    readonly path = \"/stream/ai/admin-assistant\";\n    readonly handler = AdminAssistantStreamRoute;\n}\n\n/** What the router matches on. Zero dependencies, so building it costs nothing. */\nexport const AdminAssistantStreamRouteDefinition = HttpRouteDefinition.createImplementation({\n    implementation: AdminAssistantStreamRouteDefinitionImpl,\n    dependencies: []\n});\n"],"names":["BAD_REQUEST_MESSAGE","toSseFrames","events","event","toSseFrame","AdminAssistantStreamRouteImpl","assistant","request","response","parsed","parseChatBody","frames","AdminAssistantStreamRoute","HttpRouteHandler","AdminAssistantUseCase","AdminAssistantStreamRouteDefinitionImpl","AdminAssistantStreamRouteDefinition","HttpRouteDefinition"],"mappings":";;;AAMA,MAAMA,sBACF;AAMJ,gBAAgBC,YAAYC,MAA0C;IAClE,WAAW,MAAMC,SAASD,OACtB,MAAME,WAAWD;AAEzB;AAYA,MAAME;IACF,YAAoCC,SAA0C,CAAE;aAA5CA,SAAS,GAATA;IAA6C;IAEjF,MAAa,OACTC,OAAqB,EACrBC,QAA8B,EACD;QAC7B,MAAMC,SAASC,cAAcH,QAAQ,IAAI;QAEzC,IAAI,CAACE,QACD,OAAOD,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC;YAAE,OAAOR;QAAoB;QAGlE,MAAME,SAAS,IAAI,CAAC,SAAS,CAAC,MAAM,CAACO;QACrC,MAAME,SAASV,YAAYC;QAE3B,OAAOM,SAAS,GAAG,CAACG;IACxB;AACJ;AAEO,MAAMC,4BAA4BC,iBAAiB,oBAAoB,CAAC;IAC3E,gBAAgBR;IAChB,cAAc;QAACS;KAAsB;AACzC;AAEA,MAAMC;;aACO,IAAI,GAAG;aACP,MAAM,GAAG;QAMjB,KACQ,IAAI,GAAG;aACP,OAAO,GAAGH;;AACvB;AAGO,MAAMI,sCAAsCC,oBAAoB,oBAAoB,CAAC;IACxF,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

package/api/features/AdminAssistant/AdminAssistantUseCase.d.ts

@@ -0,0 +1,42 @@
+import { Ai } from "@webiny/api-core/features/ai/index.js";
+import { AiSdkToolDefinition } from "@webiny/api-core/features/ai/index.js";
+import { AiSdkTools } from "@webiny/api-core/features/ai/index.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { ResolveAiCapabilityUseCase } from "../../../api/features/Capabilities/index.js";
+import { AdminAssistantConfig } from "./abstractions.js";
+import { AdminAssistantUseCase as Abstraction } from "./abstractions.js";
+import type { AdminAssistantParams } from "./abstractions.js";
+import type { AdminAssistantEvent } from "./events.js";
+/**
+ * Answers a question about the project by running an agent loop over the registered `AiSdkToolDefinition`s.
+ *
+ * Writes are gated. A tool that does not declare `readOnlyHint` is never executed on the model's word
+ * alone — the loop pauses and the pending call is returned for a human to approve. Everything runs
+ * under the caller's identity, so each tool is checked against that user's own permissions.
+ */
+declare class AdminAssistantUseCaseImpl implements Abstraction.Interface {
+    private readonly ai;
+    private readonly aiSdkTools;
+    private readonly declarations;
+    private readonly identityContext;
+    private readonly config;
+    private readonly resolveCapability;
+    constructor(ai: Ai.Interface, aiSdkTools: AiSdkTools.Interface, declarations: AiSdkToolDefinition.Interface[], identityContext: IdentityContext.Interface, config: AdminAssistantConfig.Interface, resolveCapability: ResolveAiCapabilityUseCase.Interface);
+    stream(params: AdminAssistantParams): AsyncIterable<AdminAssistantEvent>;
+    /**
+     * Everything both entry points need: the identity check, which tools may run unattended, and the
+     * fully-formed model request. Shared so streaming and buffered runs cannot drift apart.
+     */
+    private prepare;
+    /**
+     * `result.text` is empty when the run ended on a tool call or an approval request, so fall back to
+     * the most recent step that produced prose.
+     */
+    private extractText;
+    private extractToolCalls;
+    private extractPendingApprovals;
+}
+export declare const AdminAssistantUseCase: typeof AdminAssistantUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IAdminAssistantUseCase>;
+};
+export {};

package/api/features/AdminAssistant/AdminAssistantUseCase.js

@@ -0,0 +1,170 @@
+import { stepCountIs } from "ai";
+import { Ai, AiSdkToolDefinition, AiSdkTools } from "@webiny/api-core/features/ai/index.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { NotAuthorizedError } from "@webiny/api-core/features/security/shared/errors.js";
+import { ResolveAiCapabilityUseCase, withAdditionalInstructions } from "../Capabilities/index.js";
+import { AdminAssistantConfig, AdminAssistantUseCase } from "./abstractions.js";
+import { ADMIN_ASSISTANT_CAPABILITY } from "./capability.js";
+import { isReadOnly, toPendingApproval } from "./approvals.js";
+const toMessage = (error)=>error instanceof Error ? error.message : String(error);
+const toApprovalMessage = (decisions)=>({
+        role: "tool",
+        content: decisions.map((decision)=>{
+            const part = {
+                type: "tool-approval-response",
+                approvalId: decision.approvalId,
+                approved: decision.approved
+            };
+            if (decision.reason) part.reason = decision.reason;
+            return part;
+        })
+    });
+class AdminAssistantUseCaseImpl {
+    constructor(ai, aiSdkTools, declarations, identityContext, config, resolveCapability){
+        this.ai = ai;
+        this.aiSdkTools = aiSdkTools;
+        this.declarations = declarations;
+        this.identityContext = identityContext;
+        this.config = config;
+        this.resolveCapability = resolveCapability;
+    }
+    async *stream(params) {
+        let prepared;
+        try {
+            prepared = await this.prepare(params);
+        } catch (error) {
+            yield {
+                type: "error",
+                message: toMessage(error)
+            };
+            return;
+        }
+        const { request, appended } = prepared;
+        const pending = [];
+        try {
+            const result = await this.ai.streamText(request);
+            for await (const part of result.fullStream){
+                if ("text-delta" === part.type && part.text) {
+                    yield {
+                        type: "text",
+                        text: part.text
+                    };
+                    continue;
+                }
+                if ("tool-call" === part.type && part.toolName) {
+                    yield {
+                        type: "tool-call",
+                        name: part.toolName
+                    };
+                    continue;
+                }
+                if ("tool-result" === part.type && part.toolName) {
+                    yield {
+                        type: "tool-result",
+                        name: part.toolName
+                    };
+                    continue;
+                }
+                if ("tool-error" === part.type && part.toolName) {
+                    yield {
+                        type: "tool-error",
+                        name: part.toolName,
+                        message: toMessage(part.error)
+                    };
+                    continue;
+                }
+                if ("tool-approval-request" === part.type && part.approvalId && part.toolCall) {
+                    pending.push(toPendingApproval(part.approvalId, part.toolCall.toolName, part.toolCall.input, this.declarations));
+                    continue;
+                }
+                if ("error" === part.type) return void (yield {
+                    type: "error",
+                    message: toMessage(part.error)
+                });
+            }
+            if (pending.length > 0) yield {
+                type: "approval",
+                approvals: pending
+            };
+            yield {
+                type: "done",
+                messages: [
+                    ...appended,
+                    ...await result.responseMessages
+                ],
+                steps: (await result.steps).length
+            };
+        } catch (error) {
+            yield {
+                type: "error",
+                message: toMessage(error)
+            };
+        }
+    }
+    async prepare(params) {
+        if (this.identityContext.getIdentity().isAnonymous()) throw new NotAuthorizedError();
+        const tools = this.aiSdkTools.getToolSet();
+        const readOnlyNames = new Set(this.declarations.filter(isReadOnly).map((declaration)=>declaration.name));
+        const activeTools = Object.keys(tools);
+        const appended = [];
+        if (params.decisions.length > 0) appended.push(toApprovalMessage(params.decisions));
+        const messages = [
+            ...params.messages,
+            ...appended
+        ];
+        const resolution = await this.resolveCapability.execute(ADMIN_ASSISTANT_CAPABILITY);
+        if (resolution.isFail()) throw resolution.error;
+        const capability = resolution.value;
+        const request = {
+            model: capability.model,
+            connection: capability.connection,
+            system: withAdditionalInstructions(capability),
+            messages,
+            tools,
+            activeTools,
+            toolChoice: "auto",
+            toolApproval: ({ toolCall })=>readOnlyNames.has(toolCall.toolName) ? "not-applicable" : "user-approval",
+            stopWhen: stepCountIs(this.config.maxSteps)
+        };
+        return {
+            request,
+            appended
+        };
+    }
+    extractText(result) {
+        if (result.text) return result.text;
+        const lastWithText = result.steps.filter((step)=>step.text.length > 0).pop();
+        return lastWithText ? lastWithText.text : "";
+    }
+    extractToolCalls(result) {
+        return result.steps.flatMap((step)=>step.toolCalls.map((call)=>({
+                    name: call.toolName,
+                    input: call.input
+                })));
+    }
+    extractPendingApprovals(result) {
+        return result.steps.flatMap((step)=>step.content.filter((part)=>"tool-approval-request" === part.type).map((part)=>{
+                const request = part;
+                return toPendingApproval(request.approvalId, request.toolCall.toolName, request.toolCall.input, this.declarations);
+            }));
+    }
+}
+const AdminAssistantUseCase_AdminAssistantUseCase = AdminAssistantUseCase.createImplementation({
+    implementation: AdminAssistantUseCaseImpl,
+    dependencies: [
+        Ai,
+        AiSdkTools,
+        [
+            AiSdkToolDefinition,
+            {
+                multiple: true
+            }
+        ],
+        IdentityContext,
+        AdminAssistantConfig,
+        ResolveAiCapabilityUseCase
+    ]
+});
+export { AdminAssistantUseCase_AdminAssistantUseCase as AdminAssistantUseCase };
+
+//# sourceMappingURL=AdminAssistantUseCase.js.map

package/api/features/AdminAssistant/AdminAssistantUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AdminAssistant/AdminAssistantUseCase.js","sources":["../../../../src/api/features/AdminAssistant/AdminAssistantUseCase.ts"],"sourcesContent":["import { stepCountIs } from \"ai\";\nimport type { ModelMessage } from \"ai\";\nimport { Ai } from \"@webiny/api-core/features/ai/index.js\";\nimport { AiSdkToolDefinition } from \"@webiny/api-core/features/ai/index.js\";\nimport { AiSdkTools } from \"@webiny/api-core/features/ai/index.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { NotAuthorizedError } from \"@webiny/api-core/features/security/shared/errors.js\";\nimport {\n    ResolveAiCapabilityUseCase,\n    withAdditionalInstructions\n} from \"~/api/features/Capabilities/index.js\";\nimport { AdminAssistantConfig } from \"./abstractions.js\";\nimport { ADMIN_ASSISTANT_CAPABILITY } from \"./capability.js\";\nimport { AdminAssistantUseCase as Abstraction } from \"./abstractions.js\";\nimport type { AdminAssistantParams } from \"./abstractions.js\";\nimport { isReadOnly } from \"./approvals.js\";\nimport { toPendingApproval } from \"./approvals.js\";\nimport type { ApprovalDecision } from \"./approvals.js\";\nimport type { PendingApproval } from \"./approvals.js\";\nimport type { AdminAssistantEvent } from \"./events.js\";\n\n/** The subset of the AI SDK's stream parts this use case reacts to. */\ninterface StreamPart {\n    type: string;\n    text?: string;\n    toolName?: string;\n    approvalId?: string;\n    toolCall?: {\n        toolName: string;\n        input: unknown;\n    };\n    error?: unknown;\n}\n\nconst toMessage = (error: unknown): string => {\n    return error instanceof Error ? error.message : String(error);\n};\n\ninterface ApprovalRequestPart {\n    approvalId: string;\n    toolCall: {\n        toolName: string;\n        input: unknown;\n    };\n}\n\n/**\n * Turns the caller's approve/reject decisions into the tool message the SDK expects. Sent as its own\n * message so it lands after the assistant message that requested it.\n */\nconst toApprovalMessage = (decisions: ApprovalDecision[]): ModelMessage => {\n    return {\n        role: \"tool\",\n        content: decisions.map(decision => {\n            const part: {\n                type: \"tool-approval-response\";\n                approvalId: string;\n                approved: boolean;\n                reason?: string;\n            } = {\n                type: \"tool-approval-response\",\n                approvalId: decision.approvalId,\n                approved: decision.approved\n            };\n\n            if (decision.reason) {\n                part.reason = decision.reason;\n            }\n\n            return part;\n        })\n    };\n};\n\n/**\n * Answers a question about the project by running an agent loop over the registered `AiSdkToolDefinition`s.\n *\n * Writes are gated. A tool that does not declare `readOnlyHint` is never executed on the model's word\n * alone — the loop pauses and the pending call is returned for a human to approve. Everything runs\n * under the caller's identity, so each tool is checked against that user's own permissions.\n */\nclass AdminAssistantUseCaseImpl implements Abstraction.Interface {\n    constructor(\n        private readonly ai: Ai.Interface,\n        private readonly aiSdkTools: AiSdkTools.Interface,\n        private readonly declarations: AiSdkToolDefinition.Interface[],\n        private readonly identityContext: IdentityContext.Interface,\n        private readonly config: AdminAssistantConfig.Interface,\n        private readonly resolveCapability: ResolveAiCapabilityUseCase.Interface\n    ) {}\n\n    async *stream(params: AdminAssistantParams): AsyncIterable<AdminAssistantEvent> {\n        let prepared;\n\n        /*\n         * An auth failure has to arrive as an event, not a thrown error: by the time a transport is\n         * iterating this it has already committed to a 200 and a stream, so there is no status code\n         * left to change.\n         */\n        try {\n            prepared = await this.prepare(params);\n        } catch (error) {\n            yield { type: \"error\", message: toMessage(error) };\n            return;\n        }\n\n        const { request, appended } = prepared;\n        const pending: PendingApproval[] = [];\n\n        try {\n            const result = await this.ai.streamText(request);\n\n            for await (const part of result.fullStream as AsyncIterable<StreamPart>) {\n                if (part.type === \"text-delta\" && part.text) {\n                    yield { type: \"text\", text: part.text };\n                    continue;\n                }\n\n                if (part.type === \"tool-call\" && part.toolName) {\n                    yield { type: \"tool-call\", name: part.toolName };\n                    continue;\n                }\n\n                if (part.type === \"tool-result\" && part.toolName) {\n                    yield { type: \"tool-result\", name: part.toolName };\n                    continue;\n                }\n\n                /*\n                 * A tool threw. Deliberately not terminal, unlike the stream-level `error` below:\n                 * the SDK hands the message to the model, which typically fixes its arguments and\n                 * tries again, so ending the run here would abort a recoverable turn. Every tool\n                 * reports failure this way, so an unhandled `tool-error` leaves the call with no\n                 * outcome at all.\n                 */\n                if (part.type === \"tool-error\" && part.toolName) {\n                    yield {\n                        type: \"tool-error\",\n                        name: part.toolName,\n                        message: toMessage(part.error)\n                    };\n                    continue;\n                }\n\n                if (part.type === \"tool-approval-request\" && part.approvalId && part.toolCall) {\n                    pending.push(\n                        toPendingApproval(\n                            part.approvalId,\n                            part.toolCall.toolName,\n                            part.toolCall.input,\n                            this.declarations\n                        )\n                    );\n                    continue;\n                }\n\n                if (part.type === \"error\") {\n                    yield { type: \"error\", message: toMessage(part.error) };\n                    return;\n                }\n            }\n\n            if (pending.length > 0) {\n                yield { type: \"approval\", approvals: pending };\n            }\n\n            /*\n             * `responseMessages`, not `response.messages`: the former is the ACCUMULATED history of\n             * every step, the latter only the final step's. Resuming after an approval needs the step\n             * that carried the approval request, so the narrower one silently broke every write —\n             * the client replayed a single message, the SDK could not match the approvalId, and the\n             * model simply proposed the change again.\n             *\n             * Awaited only after the stream drains: these settle when the run finishes, so reading\n             * them earlier would block the loop above and defeat the point of streaming.\n             */\n            yield {\n                type: \"done\",\n                messages: [...appended, ...(await result.responseMessages)],\n                steps: (await result.steps).length\n            };\n        } catch (error) {\n            yield { type: \"error\", message: toMessage(error) };\n        }\n    }\n\n    /**\n     * Everything both entry points need: the identity check, which tools may run unattended, and the\n     * fully-formed model request. Shared so streaming and buffered runs cannot drift apart.\n     */\n    private async prepare(params: AdminAssistantParams): Promise<{\n        request: Ai.GenerateTextParams;\n        appended: ModelMessage[];\n    }> {\n        if (this.identityContext.getIdentity().isAnonymous()) {\n            throw new NotAuthorizedError();\n        }\n\n        const tools = this.aiSdkTools.getToolSet();\n        const readOnlyNames = new Set(\n            this.declarations.filter(isReadOnly).map(declaration => declaration.name)\n        );\n\n        /*\n         * Every tool is offered. The controls are the caller's own permissions — each tool runs through\n         * the same use cases as the admin UI — and the approval pause, which stops a mutating call\n         * until a human has seen its exact arguments.\n         */\n        const activeTools = Object.keys(tools);\n\n        /*\n         * Anything added here has to come back to the caller. The client replays the history on the\n         * next turn, and an approval response that never reached it would leave a `tool_result` with\n         * no preceding `tool_use` — which the provider rejects outright.\n         */\n        const appended: ModelMessage[] = [];\n        if (params.decisions.length > 0) {\n            appended.push(toApprovalMessage(params.decisions));\n        }\n\n        const messages = [...params.messages, ...appended];\n\n        const resolution = await this.resolveCapability.execute(ADMIN_ASSISTANT_CAPABILITY);\n\n        /*\n         * Thrown rather than swallowed. Every message the resolver produces names the setting to\n         * fix, and `stream` turns a throw into an `error` event, so the editor reads \"pick a model\n         * under Settings → AI Power-Ups → Model roles\" instead of watching the assistant fail.\n         */\n        if (resolution.isFail()) {\n            throw resolution.error;\n        }\n\n        const capability = resolution.value;\n\n        const request: Ai.GenerateTextParams = {\n            model: capability.model,\n            connection: capability.connection,\n            system: withAdditionalInstructions(capability),\n            messages,\n            tools,\n            activeTools,\n            toolChoice: \"auto\",\n            toolApproval: ({ toolCall }: { toolCall: { toolName: string } }) => {\n                return readOnlyNames.has(toolCall.toolName) ? \"not-applicable\" : \"user-approval\";\n            },\n            stopWhen: stepCountIs(this.config.maxSteps)\n        };\n\n        return { request, appended };\n    }\n\n    /**\n     * `result.text` is empty when the run ended on a tool call or an approval request, so fall back to\n     * the most recent step that produced prose.\n     */\n    private extractText(result: { text: string; steps: { text: string }[] }): string {\n        if (result.text) {\n            return result.text;\n        }\n\n        const lastWithText = result.steps.filter(step => step.text.length > 0).pop();\n\n        return lastWithText ? lastWithText.text : \"\";\n    }\n\n    private extractToolCalls(result: {\n        steps: { toolCalls: { toolName: string; input: unknown }[] }[];\n    }): { name: string; input: unknown }[] {\n        return result.steps.flatMap(step => {\n            return step.toolCalls.map(call => ({ name: call.toolName, input: call.input }));\n        });\n    }\n\n    private extractPendingApprovals(result: {\n        steps: { content: unknown[] }[];\n    }): PendingApproval[] {\n        return result.steps.flatMap(step => {\n            return step.content\n                .filter(part => (part as { type: string }).type === \"tool-approval-request\")\n                .map(part => {\n                    const request = part as unknown as ApprovalRequestPart;\n\n                    return toPendingApproval(\n                        request.approvalId,\n                        request.toolCall.toolName,\n                        request.toolCall.input,\n                        this.declarations\n                    );\n                });\n        });\n    }\n}\n\nexport const AdminAssistantUseCase = Abstraction.createImplementation({\n    implementation: AdminAssistantUseCaseImpl,\n    dependencies: [\n        Ai,\n        AiSdkTools,\n        [AiSdkToolDefinition, { multiple: true }],\n        IdentityContext,\n        AdminAssistantConfig,\n        ResolveAiCapabilityUseCase\n    ]\n});\n"],"names":["toMessage","error","Error","String","toApprovalMessage","decisions","decision","part","AdminAssistantUseCaseImpl","ai","aiSdkTools","declarations","identityContext","config","resolveCapability","params","prepared","request","appended","pending","result","toPendingApproval","NotAuthorizedError","tools","readOnlyNames","Set","isReadOnly","declaration","activeTools","Object","messages","resolution","ADMIN_ASSISTANT_CAPABILITY","capability","withAdditionalInstructions","toolCall","stepCountIs","lastWithText","step","call","AdminAssistantUseCase","Abstraction","Ai","AiSdkTools","AiSdkToolDefinition","IdentityContext","AdminAssistantConfig","ResolveAiCapabilityUseCase"],"mappings":"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"}

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

@@ -0,0 +1,38 @@
+import type { ModelMessage } from "ai";
+import type { ApprovalDecision } from "./approvals.js";
+import type { AdminAssistantEvent } from "./events.js";
+export interface IAdminAssistantConfig {
+    /**
+     * Upper bound on agent loop steps. Each tool call plus the final answer is a step, so a
+     * three-tool question (list models, describe, query) needs at least four.
+     */
+    readonly maxSteps: number;
+}
+/** Runtime limits for the assistant. The model comes from its capability. */
+export declare const AdminAssistantConfig: import("@webiny/di").Abstraction<IAdminAssistantConfig>;
+export declare namespace AdminAssistantConfig {
+    type Interface = IAdminAssistantConfig;
+}
+export interface AdminAssistantParams {
+    /** Conversation so far. Replayed verbatim, since approval requests live only in these messages. */
+    messages: ModelMessage[];
+    /** Approve or reject tool calls a previous run paused on. */
+    decisions: ApprovalDecision[];
+}
+export interface IAdminAssistantUseCase {
+    /**
+     * Run, and emit progress as it happens.
+     *
+     * Streaming only. A buffered `execute()` existed alongside this and nothing ever called it: a
+     * multi-tool question takes tens of seconds, so every caller wants the answer as it arrives, and
+     * the approval pause is worth showing the moment it appears rather than after everything
+     * settles. Anything that genuinely wants the whole result can collect the events.
+     */
+    stream(params: AdminAssistantParams): AsyncIterable<AdminAssistantEvent>;
+}
+/** Answer a question about the project using the registered AI tools, gating writes on approval. */
+export declare const AdminAssistantUseCase: import("@webiny/di").Abstraction<IAdminAssistantUseCase>;
+export declare namespace AdminAssistantUseCase {
+    type Interface = IAdminAssistantUseCase;
+    type Params = AdminAssistantParams;
+}

package/api/features/AdminAssistant/abstractions.js

@@ -0,0 +1,6 @@
+import { createAbstraction } from "@webiny/feature/api";
+const AdminAssistantConfig = createAbstraction("AdminAssistantConfig");
+const AdminAssistantUseCase = createAbstraction("AdminAssistantUseCase");
+export { AdminAssistantConfig, AdminAssistantUseCase };
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AdminAssistant/abstractions.js","sources":["../../../../src/api/features/AdminAssistant/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { ModelMessage } from \"ai\";\nimport type { ApprovalDecision } from \"./approvals.js\";\nimport type { AdminAssistantEvent } from \"./events.js\";\n\nexport interface IAdminAssistantConfig {\n    /**\n     * Upper bound on agent loop steps. Each tool call plus the final answer is a step, so a\n     * three-tool question (list models, describe, query) needs at least four.\n     */\n    readonly maxSteps: number;\n}\n\n/** Runtime limits for the assistant. The model comes from its capability. */\nexport const AdminAssistantConfig =\n    createAbstraction<IAdminAssistantConfig>(\"AdminAssistantConfig\");\n\nexport namespace AdminAssistantConfig {\n    export type Interface = IAdminAssistantConfig;\n}\n\nexport interface AdminAssistantParams {\n    /** Conversation so far. Replayed verbatim, since approval requests live only in these messages. */\n    messages: ModelMessage[];\n    /** Approve or reject tool calls a previous run paused on. */\n    decisions: ApprovalDecision[];\n}\n\nexport interface IAdminAssistantUseCase {\n    /**\n     * Run, and emit progress as it happens.\n     *\n     * Streaming only. A buffered `execute()` existed alongside this and nothing ever called it: a\n     * multi-tool question takes tens of seconds, so every caller wants the answer as it arrives, and\n     * the approval pause is worth showing the moment it appears rather than after everything\n     * settles. Anything that genuinely wants the whole result can collect the events.\n     */\n    stream(params: AdminAssistantParams): AsyncIterable<AdminAssistantEvent>;\n}\n\n/** Answer a question about the project using the registered AI tools, gating writes on approval. */\nexport const AdminAssistantUseCase =\n    createAbstraction<IAdminAssistantUseCase>(\"AdminAssistantUseCase\");\n\nexport namespace AdminAssistantUseCase {\n    export type Interface = IAdminAssistantUseCase;\n    export type Params = AdminAssistantParams;\n}\n"],"names":["AdminAssistantConfig","createAbstraction","AdminAssistantUseCase"],"mappings":";AAcO,MAAMA,uBACTC,kBAAyC;AA0BtC,MAAMC,wBACTD,kBAA0C"}

package/api/features/AdminAssistant/approvals.d.ts

@@ -0,0 +1,29 @@
+import { AiSdkToolDefinition } from "@webiny/api-core/features/ai/index.js";
+/**
+ * A tool call the assistant wants to make but has not made, because it mutates something.
+ * Returned to the client so a human can approve or reject it.
+ */
+export interface PendingApproval {
+    approvalId: string;
+    toolName: string;
+    /** Human-readable tool name where the tool supplied one. */
+    title?: string;
+    input: unknown;
+    /** True when the tool declared `destructiveHint` — the UI should say so louder. */
+    destructive: boolean;
+}
+export interface ApprovalDecision {
+    approvalId: string;
+    approved: boolean;
+    reason?: string;
+}
+/**
+ * A tool runs unattended only if it says, in its own declaration, that it does not change anything.
+ *
+ * The default is deliberately the safe one: a tool with no annotations requires approval. Tools are
+ * registered by extensions as well as by Webiny, so an author who forgets to annotate gets a confirm
+ * prompt rather than silent write access.
+ */
+export declare const isReadOnly: (tool: AiSdkToolDefinition.Interface) => boolean;
+export declare const toPendingApproval: (approvalId: string, toolName: string, input: unknown, tools: AiSdkToolDefinition.Interface[]) => PendingApproval;
+export declare const parseDecisions: (value: unknown) => ApprovalDecision[];

package/api/features/AdminAssistant/approvals.js

@@ -0,0 +1,30 @@
+const isReadOnly = (tool)=>tool.annotations?.readOnlyHint === true;
+const toPendingApproval = (approvalId, toolName, input, tools)=>{
+    const tool = tools.find((candidate)=>candidate.name === toolName);
+    return {
+        approvalId,
+        toolName,
+        title: tool?.title,
+        input,
+        destructive: tool?.annotations?.destructiveHint === true
+    };
+};
+const parseDecisions = (value)=>{
+    if (!Array.isArray(value)) return [];
+    return value.flatMap((entry)=>{
+        if (!entry || "object" != typeof entry) return [];
+        const { approvalId, approved, reason } = entry;
+        if ("string" != typeof approvalId || "boolean" != typeof approved) return [];
+        const decision = {
+            approvalId,
+            approved
+        };
+        if ("string" == typeof reason) decision.reason = reason;
+        return [
+            decision
+        ];
+    });
+};
+export { isReadOnly, parseDecisions, toPendingApproval };
+
+//# sourceMappingURL=approvals.js.map

package/api/features/AdminAssistant/approvals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AdminAssistant/approvals.js","sources":["../../../../src/api/features/AdminAssistant/approvals.ts"],"sourcesContent":["import { AiSdkToolDefinition } from \"@webiny/api-core/features/ai/index.js\";\n\n/**\n * A tool call the assistant wants to make but has not made, because it mutates something.\n * Returned to the client so a human can approve or reject it.\n */\nexport interface PendingApproval {\n    approvalId: string;\n    toolName: string;\n    /** Human-readable tool name where the tool supplied one. */\n    title?: string;\n    input: unknown;\n    /** True when the tool declared `destructiveHint` — the UI should say so louder. */\n    destructive: boolean;\n}\n\nexport interface ApprovalDecision {\n    approvalId: string;\n    approved: boolean;\n    reason?: string;\n}\n\n/**\n * A tool runs unattended only if it says, in its own declaration, that it does not change anything.\n *\n * The default is deliberately the safe one: a tool with no annotations requires approval. Tools are\n * registered by extensions as well as by Webiny, so an author who forgets to annotate gets a confirm\n * prompt rather than silent write access.\n */\nexport const isReadOnly = (tool: AiSdkToolDefinition.Interface): boolean =>\n    tool.annotations?.readOnlyHint === true;\n\nexport const toPendingApproval = (\n    approvalId: string,\n    toolName: string,\n    input: unknown,\n    tools: AiSdkToolDefinition.Interface[]\n): PendingApproval => {\n    const tool = tools.find(candidate => candidate.name === toolName);\n\n    return {\n        approvalId,\n        toolName,\n        title: tool?.title,\n        input,\n        destructive: tool?.annotations?.destructiveHint === true\n    };\n};\n\nexport const parseDecisions = (value: unknown): ApprovalDecision[] => {\n    if (!Array.isArray(value)) {\n        return [];\n    }\n\n    return value.flatMap(entry => {\n        if (!entry || typeof entry !== \"object\") {\n            return [];\n        }\n        const { approvalId, approved, reason } = entry as Record<string, unknown>;\n        if (typeof approvalId !== \"string\" || typeof approved !== \"boolean\") {\n            return [];\n        }\n        const decision: ApprovalDecision = { approvalId, approved };\n\n        if (typeof reason === \"string\") {\n            decision.reason = reason;\n        }\n\n        return [decision];\n    });\n};\n"],"names":["isReadOnly","tool","toPendingApproval","approvalId","toolName","input","tools","candidate","parseDecisions","value","Array","entry","approved","reason","decision"],"mappings":"AA6BO,MAAMA,aAAa,CAACC,OACvBA,KAAK,WAAW,EAAE,iBAAiB;AAEhC,MAAMC,oBAAoB,CAC7BC,YACAC,UACAC,OACAC;IAEA,MAAML,OAAOK,MAAM,IAAI,CAACC,CAAAA,YAAaA,UAAU,IAAI,KAAKH;IAExD,OAAO;QACHD;QACAC;QACA,OAAOH,MAAM;QACbI;QACA,aAAaJ,MAAM,aAAa,oBAAoB;IACxD;AACJ;AAEO,MAAMO,iBAAiB,CAACC;IAC3B,IAAI,CAACC,MAAM,OAAO,CAACD,QACf,OAAO,EAAE;IAGb,OAAOA,MAAM,OAAO,CAACE,CAAAA;QACjB,IAAI,CAACA,SAAS,AAAiB,YAAjB,OAAOA,OACjB,OAAO,EAAE;QAEb,MAAM,EAAER,UAAU,EAAES,QAAQ,EAAEC,MAAM,EAAE,GAAGF;QACzC,IAAI,AAAsB,YAAtB,OAAOR,cAA2B,AAAoB,aAApB,OAAOS,UACzC,OAAO,EAAE;QAEb,MAAME,WAA6B;YAAEX;YAAYS;QAAS;QAE1D,IAAI,AAAkB,YAAlB,OAAOC,QACPC,SAAS,MAAM,GAAGD;QAGtB,OAAO;YAACC;SAAS;IACrB;AACJ"}

package/api/features/AdminAssistant/capability.d.ts

@@ -0,0 +1,31 @@
+import { AiCapability } from "../../../api/features/Capabilities/index.js";
+export declare const ADMIN_ASSISTANT_CAPABILITY = "admin.assistant";
+/**
+ * The assistant behind the admin command palette.
+ *
+ * `admin.assistant` matches the WCP licence option and the `aiPowerups.adminAssistant` flag, so the
+ * feature has one name everywhere. It is also the name that survives: every other id says what the
+ * feature does (`fm.imageEnrichment`, `cms.generateEntry`), and this one deliberately does not do
+ * one thing. Today it reads and changes content, and the direction is for it to build things
+ * too, like a field renderer or a menu change. The id is the persisted settings key, so a later rename
+ * orphans a project's overrides.
+ *
+ * `guidance` is the prompt this feature ships, imported rather than restated so the two cannot
+ * drift. Unlike most capabilities this one is safe to append to freely: its output is prose for a
+ * human, not a shape the surrounding code parses. House rules ("our product is spelled like this",
+ * "never mention internal model ids") belong here.
+ *
+ * `standard` rather than `fast`: the assistant chains tool calls and has to reason about which model
+ * to describe before it can query anything, which is where small models fall down.
+ */
+declare class AdminAssistantCapabilityImpl implements AiCapability.Interface {
+    readonly id = "admin.assistant";
+    readonly label = "Admin assistant";
+    readonly description = "The assistant in the command palette. Answers questions about this project and proposes changes for approval, under the permissions of whoever is asking. The most open-ended capability here: it plans across several tool calls, so it gains the most from a strong model.";
+    readonly defaultRole: "standard";
+    readonly guidance = "You are the Webiny admin assistant. You help editors and developers find, understand and change the content in their Webiny project.\n\nYou have tools available. Use them \u2014 never answer a question about this project's content, models, or files from memory or assumption.\n\nHow to work:\n- Content model IDs and field IDs are specific to this project. Always discover them with listContentModels, then describeContentModel, before querying.\n- Build filters with the field IDs describeContentModel returned. Do not guess field names.\n- If a tool returns an error, read it and correct your call. A \"not allowed\" error means the user lacks permission \u2014 say so plainly rather than retrying.\n- If a query returns nothing, say so. Do not present an empty result as if it were data.\n\nChanging things:\n- Tools that change something are not executed until the user approves them. Propose the change by calling the tool; the user sees exactly what you asked for and confirms it.\n- Read first, then propose. Look up the ids you need (teams, folders, entries) rather than guessing them, because the user is approving the arguments you supply.\n- Propose one coherent change at a time. Do not bundle unrelated edits into a single step.\n- If an approval is denied, do not retry the same call. Acknowledge it and stop.\n\nHow to answer:\n- Be brief. These answers appear in a command palette, not a chat window.\n- Lead with the answer. No preamble, no restating the question.\n- When you list entries, give the few fields that matter, not every field you received.\n- State counts precisely (\"3 products are on sale\"), never vaguely.";
+}
+export declare const AdminAssistantCapability: typeof AdminAssistantCapabilityImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/api/features/Capabilities/index.js").IAiCapability>;
+};
+export {};

package/api/features/AdminAssistant/capability.js

@@ -0,0 +1,19 @@
+import { AiCapability } from "../Capabilities/index.js";
+import { SYSTEM_PROMPT } from "./systemPrompt.js";
+const ADMIN_ASSISTANT_CAPABILITY = "admin.assistant";
+class AdminAssistantCapabilityImpl {
+    constructor(){
+        this.id = ADMIN_ASSISTANT_CAPABILITY;
+        this.label = "Admin assistant";
+        this.description = "The assistant in the command palette. Answers questions about this project and proposes changes for approval, under the permissions of whoever is asking. The most open-ended capability here: it plans across several tool calls, so it gains the most from a strong model.";
+        this.defaultRole = "standard";
+        this.guidance = SYSTEM_PROMPT;
+    }
+}
+const AdminAssistantCapability = AiCapability.createImplementation({
+    implementation: AdminAssistantCapabilityImpl,
+    dependencies: []
+});
+export { ADMIN_ASSISTANT_CAPABILITY, AdminAssistantCapability };
+
+//# sourceMappingURL=capability.js.map

package/api/features/AdminAssistant/capability.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AdminAssistant/capability.js","sources":["../../../../src/api/features/AdminAssistant/capability.ts"],"sourcesContent":["import { AiCapability } from \"~/api/features/Capabilities/index.js\";\nimport { SYSTEM_PROMPT } from \"./systemPrompt.js\";\n\nexport const ADMIN_ASSISTANT_CAPABILITY = \"admin.assistant\";\n\n/**\n * The assistant behind the admin command palette.\n *\n * `admin.assistant` matches the WCP licence option and the `aiPowerups.adminAssistant` flag, so the\n * feature has one name everywhere. It is also the name that survives: every other id says what the\n * feature does (`fm.imageEnrichment`, `cms.generateEntry`), and this one deliberately does not do\n * one thing. Today it reads and changes content, and the direction is for it to build things\n * too, like a field renderer or a menu change. The id is the persisted settings key, so a later rename\n * orphans a project's overrides.\n *\n * `guidance` is the prompt this feature ships, imported rather than restated so the two cannot\n * drift. Unlike most capabilities this one is safe to append to freely: its output is prose for a\n * human, not a shape the surrounding code parses. House rules (\"our product is spelled like this\",\n * \"never mention internal model ids\") belong here.\n *\n * `standard` rather than `fast`: the assistant chains tool calls and has to reason about which model\n * to describe before it can query anything, which is where small models fall down.\n */\nclass AdminAssistantCapabilityImpl implements AiCapability.Interface {\n    readonly id = ADMIN_ASSISTANT_CAPABILITY;\n    readonly label = \"Admin assistant\";\n    readonly description =\n        \"The assistant in the command palette. Answers questions about this project and proposes changes for approval, under the permissions of whoever is asking. The most open-ended capability here: it plans across several tool calls, so it gains the most from a strong model.\";\n    readonly defaultRole = \"standard\" as const;\n    readonly guidance = SYSTEM_PROMPT;\n}\n\nexport const AdminAssistantCapability = AiCapability.createImplementation({\n    implementation: AdminAssistantCapabilityImpl,\n    dependencies: []\n});\n"],"names":["ADMIN_ASSISTANT_CAPABILITY","AdminAssistantCapabilityImpl","SYSTEM_PROMPT","AdminAssistantCapability","AiCapability"],"mappings":";;AAGO,MAAMA,6BAA6B;AAoB1C,MAAMC;;aACO,EAAE,GAAGD;aACL,KAAK,GAAG;aACR,WAAW,GAChB;aACK,WAAW,GAAG;aACd,QAAQ,GAAGE;;AACxB;AAEO,MAAMC,2BAA2BC,aAAa,oBAAoB,CAAC;IACtE,gBAAgBH;IAChB,cAAc,EAAE;AACpB"}