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

package/api/features/AiImageEnrichment/ApplyImageEnrichmentUseCase.js

@@ -0,0 +1,50 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateFileUseCase } from "@webiny/api-file-manager/features/file/UpdateFile/index.js";
+import { WebsocketsSendToIdentityUseCase } from "@webiny/api-websockets/features/SendToIdentity/abstractions.js";
+import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
+import { ApplyImageEnrichmentUseCase } from "./abstractions.js";
+import { EnrichmentPersistError } from "./errors.js";
+const FILE_ENRICHMENT_WEBSOCKET_ACTION = "fm.file.enrichment";
+class ApplyImageEnrichmentUseCaseImpl {
+    constructor(updateFile, identityContext, sendToIdentity){
+        this.updateFile = updateFile;
+        this.identityContext = identityContext;
+        this.sendToIdentity = sendToIdentity;
+    }
+    async execute(params) {
+        const { tags, description, fileId } = params;
+        const updateResult = await this.updateFile.execute({
+            id: fileId,
+            tags,
+            description
+        });
+        if (updateResult.isFail()) return Result.fail(new EnrichmentPersistError(updateResult.error.message));
+        const identity = this.identityContext.getIdentity();
+        await this.sendToIdentity.execute({
+            id: identity.id
+        }, {
+            action: FILE_ENRICHMENT_WEBSOCKET_ACTION,
+            data: {
+                id: fileId,
+                tags,
+                description
+            }
+        });
+        return Result.ok({
+            fileId,
+            tags,
+            description
+        });
+    }
+}
+const ApplyImageEnrichmentUseCase_ApplyImageEnrichmentUseCase = ApplyImageEnrichmentUseCase.createImplementation({
+    implementation: ApplyImageEnrichmentUseCaseImpl,
+    dependencies: [
+        UpdateFileUseCase,
+        IdentityContext,
+        WebsocketsSendToIdentityUseCase
+    ]
+});
+export { ApplyImageEnrichmentUseCase_ApplyImageEnrichmentUseCase as ApplyImageEnrichmentUseCase, FILE_ENRICHMENT_WEBSOCKET_ACTION };
+
+//# sourceMappingURL=ApplyImageEnrichmentUseCase.js.map

package/api/features/AiImageEnrichment/ApplyImageEnrichmentUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AiImageEnrichment/ApplyImageEnrichmentUseCase.js","sources":["../../../../src/api/features/AiImageEnrichment/ApplyImageEnrichmentUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { UpdateFileUseCase } from \"@webiny/api-file-manager/features/file/UpdateFile/index.js\";\nimport { WebsocketsSendToIdentityUseCase } from \"@webiny/api-websockets/features/SendToIdentity/abstractions.js\";\nimport { IdentityContext } from \"@webiny/api-core/exports/api/security.js\";\nimport {\n    ApplyImageEnrichmentUseCase as UseCaseAbstraction,\n    type IApplyImageEnrichmentParams,\n    type IAppliedImageEnrichment\n} from \"./abstractions.js\";\nimport { EnrichmentPersistError } from \"./errors.js\";\nimport type { ImageEnrichmentError } from \"./errors.js\";\n\nexport const FILE_ENRICHMENT_WEBSOCKET_ACTION = \"fm.file.enrichment\";\n\nclass ApplyImageEnrichmentUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private updateFile: UpdateFileUseCase.Interface,\n        private identityContext: IdentityContext.Interface,\n        private sendToIdentity: WebsocketsSendToIdentityUseCase.Interface\n    ) {}\n\n    async execute(\n        params: IApplyImageEnrichmentParams\n    ): Promise<Result<IAppliedImageEnrichment, ImageEnrichmentError>> {\n        // Enrichment REPLACES both fields. Tags used to be merged into the file's existing ones while\n        // the description was overwritten, which is an odd split: re-running would accumulate tags\n        // forever, so a wrong tag from an earlier run could never be dropped by re-running.\n        const { tags, description, fileId } = params;\n\n        const updateResult = await this.updateFile.execute({\n            id: fileId,\n            tags,\n            description\n        });\n\n        if (updateResult.isFail()) {\n            return Result.fail(new EnrichmentPersistError(updateResult.error.message));\n        }\n\n        // Push to the identity's open sockets even when the caller is streaming: the browser tab that\n        // triggered this isn't necessarily the only one showing the file, and the client-side list\n        // cache updates off this message (see AiImageEnrichmentEventHandler in @webiny/app-file-manager).\n        const identity = this.identityContext.getIdentity();\n        await this.sendToIdentity.execute(\n            { id: identity.id },\n            {\n                action: FILE_ENRICHMENT_WEBSOCKET_ACTION,\n                data: { id: fileId, tags, description }\n            }\n        );\n\n        return Result.ok({ fileId, tags, description });\n    }\n}\n\nexport const ApplyImageEnrichmentUseCase = UseCaseAbstraction.createImplementation({\n    implementation: ApplyImageEnrichmentUseCaseImpl,\n    dependencies: [UpdateFileUseCase, IdentityContext, WebsocketsSendToIdentityUseCase]\n});\n"],"names":["FILE_ENRICHMENT_WEBSOCKET_ACTION","ApplyImageEnrichmentUseCaseImpl","updateFile","identityContext","sendToIdentity","params","tags","description","fileId","updateResult","Result","EnrichmentPersistError","identity","ApplyImageEnrichmentUseCase","UseCaseAbstraction","UpdateFileUseCase","IdentityContext","WebsocketsSendToIdentityUseCase"],"mappings":";;;;;;AAYO,MAAMA,mCAAmC;AAEhD,MAAMC;IACF,YACYC,UAAuC,EACvCC,eAA0C,EAC1CC,cAAyD,CACnE;aAHUF,UAAU,GAAVA;aACAC,eAAe,GAAfA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QACFC,MAAmC,EAC2B;QAI9D,MAAM,EAAEC,IAAI,EAAEC,WAAW,EAAEC,MAAM,EAAE,GAAGH;QAEtC,MAAMI,eAAe,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;YAC/C,IAAID;YACJF;YACAC;QACJ;QAEA,IAAIE,aAAa,MAAM,IACnB,OAAOC,OAAO,IAAI,CAAC,IAAIC,uBAAuBF,aAAa,KAAK,CAAC,OAAO;QAM5E,MAAMG,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QACjD,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B;YAAE,IAAIA,SAAS,EAAE;QAAC,GAClB;YACI,QAAQZ;YACR,MAAM;gBAAE,IAAIQ;gBAAQF;gBAAMC;YAAY;QAC1C;QAGJ,OAAOG,OAAO,EAAE,CAAC;YAAEF;YAAQF;YAAMC;QAAY;IACjD;AACJ;AAEO,MAAMM,0DAA8BC,4BAAAA,oBAAuC,CAAC;IAC/E,gBAAgBb;IAChB,cAAc;QAACc;QAAmBC;QAAiBC;KAAgC;AACvF"}

package/api/features/AiImageEnrichment/EnrichmentCapabilityDisabledError.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Image enrichment is switched off in settings. Not a failure: someone chose it, so the upload task
+ * finishes as done, the same as for a file that is not an image. Kept apart from
+ * `EnrichmentNoProviderError`, which is a real misconfiguration and should stay loud.
+ */
+export declare class EnrichmentCapabilityDisabledError extends Error {
+    readonly code: "ENRICHMENT_CAPABILITY_DISABLED";
+    constructor(reason: string);
+}

package/api/features/AiImageEnrichment/EnrichmentCapabilityDisabledError.js

@@ -0,0 +1,8 @@
+class EnrichmentCapabilityDisabledError extends Error {
+    constructor(reason){
+        super(reason), this.code = "ENRICHMENT_CAPABILITY_DISABLED";
+    }
+}
+export { EnrichmentCapabilityDisabledError };
+
+//# sourceMappingURL=EnrichmentCapabilityDisabledError.js.map

package/api/features/AiImageEnrichment/EnrichmentCapabilityDisabledError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AiImageEnrichment/EnrichmentCapabilityDisabledError.js","sources":["../../../../src/api/features/AiImageEnrichment/EnrichmentCapabilityDisabledError.ts"],"sourcesContent":["/**\n * Image enrichment is switched off in settings. Not a failure: someone chose it, so the upload task\n * finishes as done, the same as for a file that is not an image. Kept apart from\n * `EnrichmentNoProviderError`, which is a real misconfiguration and should stay loud.\n */\nexport class EnrichmentCapabilityDisabledError extends Error {\n    readonly code = \"ENRICHMENT_CAPABILITY_DISABLED\" as const;\n\n    constructor(reason: string) {\n        super(reason);\n    }\n}\n"],"names":["EnrichmentCapabilityDisabledError","Error","reason"],"mappings":"AAKO,MAAMA,0CAA0CC;IAGnD,YAAYC,MAAc,CAAE;QACxB,KAAK,CAACA,SAAAA,IAAAA,CAHD,IAAI,GAAG;IAIhB;AACJ"}

package/api/features/AiImageEnrichment/PrepareImageEnrichmentUseCase.d.ts

@@ -0,0 +1,17 @@
+import { Result } from "@webiny/feature/api";
+import { GetFileUseCase } from "@webiny/api-file-manager/features/file/GetFile/index.js";
+import { GetFileContentsByIdUseCase } from "@webiny/api-file-manager/features/file/GetFileContentsById/abstractions.js";
+import { PrepareImageEnrichmentUseCase as UseCaseAbstraction, type IPreparedImageEnrichment } from "./abstractions.js";
+import { ResolveAiCapabilityUseCase } from "../../../api/features/Capabilities/index.js";
+import type { ImageEnrichmentError } from "./errors.js";
+declare class PrepareImageEnrichmentUseCaseImpl implements UseCaseAbstraction.Interface {
+    private getFile;
+    private getFileContents;
+    private resolveCapability;
+    constructor(getFile: GetFileUseCase.Interface, getFileContents: GetFileContentsByIdUseCase.Interface, resolveCapability: ResolveAiCapabilityUseCase.Interface);
+    execute(fileId: string): Promise<Result<IPreparedImageEnrichment, ImageEnrichmentError>>;
+}
+export declare const PrepareImageEnrichmentUseCase: typeof PrepareImageEnrichmentUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IPrepareImageEnrichmentUseCase>;
+};
+export {};

package/api/features/AiImageEnrichment/PrepareImageEnrichmentUseCase.js

@@ -0,0 +1,47 @@
+import { Result } from "@webiny/feature/api";
+import { GetFileUseCase } from "@webiny/api-file-manager/features/file/GetFile/index.js";
+import { GetFileContentsByIdUseCase } from "@webiny/api-file-manager/features/file/GetFileContentsById/abstractions.js";
+import { PrepareImageEnrichmentUseCase } from "./abstractions.js";
+import { AiCapabilityDisabledError, ResolveAiCapabilityUseCase, withAdditionalInstructions } from "../Capabilities/index.js";
+import { FM_IMAGE_ENRICHMENT_CAPABILITY } from "./capability.js";
+import { EnrichmentCapabilityDisabledError, EnrichmentFileContentsError, EnrichmentFileNotFoundError, EnrichmentNoProviderError, EnrichmentNotAnImageError } from "./errors.js";
+class PrepareImageEnrichmentUseCaseImpl {
+    constructor(getFile, getFileContents, resolveCapability){
+        this.getFile = getFile;
+        this.getFileContents = getFileContents;
+        this.resolveCapability = resolveCapability;
+    }
+    async execute(fileId) {
+        const fileResult = await this.getFile.execute(fileId);
+        if (fileResult.isFail()) return Result.fail(new EnrichmentFileNotFoundError(fileId));
+        const file = fileResult.value;
+        if (!file.type.startsWith("image/")) return Result.fail(new EnrichmentNotAnImageError(file.type));
+        const resolved = await this.resolveCapability.execute(FM_IMAGE_ENRICHMENT_CAPABILITY);
+        if (resolved.isFail()) {
+            if (resolved.error instanceof AiCapabilityDisabledError) return Result.fail(new EnrichmentCapabilityDisabledError(resolved.error.message));
+            return Result.fail(new EnrichmentNoProviderError(resolved.error.message));
+        }
+        const capability = resolved.value;
+        const contentsResult = await this.getFileContents.execute(fileId);
+        if (contentsResult.isFail()) return Result.fail(new EnrichmentFileContentsError(contentsResult.error.message));
+        return Result.ok({
+            fileId: file.id,
+            imageBase64: contentsResult.value.buffer.toString("base64"),
+            imageMediaType: contentsResult.value.contentType,
+            model: capability.model,
+            prompt: withAdditionalInstructions(capability),
+            connection: capability.connection
+        });
+    }
+}
+const PrepareImageEnrichmentUseCase_PrepareImageEnrichmentUseCase = PrepareImageEnrichmentUseCase.createImplementation({
+    implementation: PrepareImageEnrichmentUseCaseImpl,
+    dependencies: [
+        GetFileUseCase,
+        GetFileContentsByIdUseCase,
+        ResolveAiCapabilityUseCase
+    ]
+});
+export { PrepareImageEnrichmentUseCase_PrepareImageEnrichmentUseCase as PrepareImageEnrichmentUseCase };
+
+//# sourceMappingURL=PrepareImageEnrichmentUseCase.js.map

package/api/features/AiImageEnrichment/PrepareImageEnrichmentUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AiImageEnrichment/PrepareImageEnrichmentUseCase.js","sources":["../../../../src/api/features/AiImageEnrichment/PrepareImageEnrichmentUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetFileUseCase } from \"@webiny/api-file-manager/features/file/GetFile/index.js\";\nimport { GetFileContentsByIdUseCase } from \"@webiny/api-file-manager/features/file/GetFileContentsById/abstractions.js\";\nimport {\n    PrepareImageEnrichmentUseCase as UseCaseAbstraction,\n    type IPreparedImageEnrichment\n} from \"./abstractions.js\";\nimport { AiCapabilityDisabledError } from \"~/api/features/Capabilities/index.js\";\nimport {\n    ResolveAiCapabilityUseCase,\n    withAdditionalInstructions\n} from \"~/api/features/Capabilities/index.js\";\nimport { FM_IMAGE_ENRICHMENT_CAPABILITY } from \"./capability.js\";\nimport { EnrichmentCapabilityDisabledError } from \"./errors.js\";\nimport {\n    EnrichmentFileContentsError,\n    EnrichmentFileNotFoundError,\n    EnrichmentNoProviderError,\n    EnrichmentNotAnImageError\n} from \"./errors.js\";\nimport type { ImageEnrichmentError } from \"./errors.js\";\n\nclass PrepareImageEnrichmentUseCaseImpl implements UseCaseAbstraction.Interface {\n    constructor(\n        private getFile: GetFileUseCase.Interface,\n        private getFileContents: GetFileContentsByIdUseCase.Interface,\n        private resolveCapability: ResolveAiCapabilityUseCase.Interface\n    ) {}\n\n    async execute(fileId: string): Promise<Result<IPreparedImageEnrichment, ImageEnrichmentError>> {\n        const fileResult = await this.getFile.execute(fileId);\n        if (fileResult.isFail()) {\n            return Result.fail(new EnrichmentFileNotFoundError(fileId));\n        }\n\n        const file = fileResult.value;\n\n        if (!file.type.startsWith(\"image/\")) {\n            return Result.fail(new EnrichmentNotAnImageError(file.type));\n        }\n\n        /*\n         * Resolved before the download, not after. Switched off is now a quiet, normal outcome, so\n         * checking it last would pull the whole image from storage on every upload only to throw it\n         * away, with nothing in the logs to show for it.\n         */\n        const resolved = await this.resolveCapability.execute(FM_IMAGE_ENRICHMENT_CAPABILITY);\n        if (resolved.isFail()) {\n            /*\n             * Switched off is a decision, not a missing model, so it must not become the error\n             * that callers treat as a misconfiguration.\n             */\n            if (resolved.error instanceof AiCapabilityDisabledError) {\n                return Result.fail(new EnrichmentCapabilityDisabledError(resolved.error.message));\n            }\n            return Result.fail(new EnrichmentNoProviderError(resolved.error.message));\n        }\n\n        const capability = resolved.value;\n\n        // Read the image bytes and send them to the AI as base64, NOT a URL. A URL forces the\n        // provider to fetch the file — which fails for private/access-controlled files, leaks the\n        // domain, and can't reach a non-public origin (e.g. local dev). base64 is a portable standard\n        // that works on every setup. (Also resolves the AI-SDK \"image part\" deprecation.)\n        const contentsResult = await this.getFileContents.execute(fileId);\n        if (contentsResult.isFail()) {\n            return Result.fail(new EnrichmentFileContentsError(contentsResult.error.message));\n        }\n\n        return Result.ok({\n            fileId: file.id,\n            imageBase64: contentsResult.value.buffer.toString(\"base64\"),\n            imageMediaType: contentsResult.value.contentType,\n            model: capability.model,\n            prompt: withAdditionalInstructions(capability),\n            connection: capability.connection\n        });\n    }\n}\n\nexport const PrepareImageEnrichmentUseCase = UseCaseAbstraction.createImplementation({\n    implementation: PrepareImageEnrichmentUseCaseImpl,\n    dependencies: [GetFileUseCase, GetFileContentsByIdUseCase, ResolveAiCapabilityUseCase]\n});\n"],"names":["PrepareImageEnrichmentUseCaseImpl","getFile","getFileContents","resolveCapability","fileId","fileResult","Result","EnrichmentFileNotFoundError","file","EnrichmentNotAnImageError","resolved","FM_IMAGE_ENRICHMENT_CAPABILITY","AiCapabilityDisabledError","EnrichmentCapabilityDisabledError","EnrichmentNoProviderError","capability","contentsResult","EnrichmentFileContentsError","withAdditionalInstructions","PrepareImageEnrichmentUseCase","UseCaseAbstraction","GetFileUseCase","GetFileContentsByIdUseCase","ResolveAiCapabilityUseCase"],"mappings":";;;;;;;AAsBA,MAAMA;IACF,YACYC,OAAiC,EACjCC,eAAqD,EACrDC,iBAAuD,CACjE;aAHUF,OAAO,GAAPA;aACAC,eAAe,GAAfA;aACAC,iBAAiB,GAAjBA;IACT;IAEH,MAAM,QAAQC,MAAc,EAAmE;QAC3F,MAAMC,aAAa,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAACD;QAC9C,IAAIC,WAAW,MAAM,IACjB,OAAOC,OAAO,IAAI,CAAC,IAAIC,4BAA4BH;QAGvD,MAAMI,OAAOH,WAAW,KAAK;QAE7B,IAAI,CAACG,KAAK,IAAI,CAAC,UAAU,CAAC,WACtB,OAAOF,OAAO,IAAI,CAAC,IAAIG,0BAA0BD,KAAK,IAAI;QAQ9D,MAAME,WAAW,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAACC;QACtD,IAAID,SAAS,MAAM,IAAI;YAKnB,IAAIA,SAAS,KAAK,YAAYE,2BAC1B,OAAON,OAAO,IAAI,CAAC,IAAIO,kCAAkCH,SAAS,KAAK,CAAC,OAAO;YAEnF,OAAOJ,OAAO,IAAI,CAAC,IAAIQ,0BAA0BJ,SAAS,KAAK,CAAC,OAAO;QAC3E;QAEA,MAAMK,aAAaL,SAAS,KAAK;QAMjC,MAAMM,iBAAiB,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACZ;QAC1D,IAAIY,eAAe,MAAM,IACrB,OAAOV,OAAO,IAAI,CAAC,IAAIW,4BAA4BD,eAAe,KAAK,CAAC,OAAO;QAGnF,OAAOV,OAAO,EAAE,CAAC;YACb,QAAQE,KAAK,EAAE;YACf,aAAaQ,eAAe,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC;YAClD,gBAAgBA,eAAe,KAAK,CAAC,WAAW;YAChD,OAAOD,WAAW,KAAK;YACvB,QAAQG,2BAA2BH;YACnC,YAAYA,WAAW,UAAU;QACrC;IACJ;AACJ;AAEO,MAAMI,8DAAgCC,8BAAAA,oBAAuC,CAAC;IACjF,gBAAgBpB;IAChB,cAAc;QAACqB;QAAgBC;QAA4BC;KAA2B;AAC1F"}

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

@@ -0,0 +1,66 @@
+import { Result } from "@webiny/feature/api";
+import { z } from "zod";
+import type { ImageEnrichmentError } from "./errors.js";
+export declare const AI_ENRICHMENT_PROMPT = "Analyze this image and return up to 5 lowercase descriptive tags and one short sentence describing the image.";
+/**
+ * The shape both entry points ask the model for. Exported as the bare zod schema rather than a
+ * ready-made `Output.object(...)`: the AI SDK's `Output` type can't be named in emitted declarations
+ * (TS4023), so each call site wraps this locally instead.
+ */
+export declare const aiEnrichmentSchema: z.ZodObject<{
+    tags: z.ZodArray<z.ZodString>;
+    description: z.ZodString;
+}, z.core.$strip>;
+/** The enrichment result: what the model produces and what gets persisted. */
+export interface IEnrichmentOutput {
+    tags: string[];
+    description: string;
+}
+/**
+ * Everything needed to run the AI call, gathered up front: the image bytes, the resolved provider,
+ * and the file's current tags (needed to merge rather than overwrite).
+ *
+ * Deliberately split from the AI call itself so both entry points share the same preparation and the
+ * same failure modes — and so the streaming route can answer with a real HTTP status code for
+ * anything knowable before the stream opens, instead of burying it in a 200 response.
+ */
+export interface IPreparedImageEnrichment {
+    fileId: string;
+    imageBase64: string;
+    imageMediaType: string;
+    model: string;
+    /**
+     * The resolved prompt: this capability's guidance (or the project's replacement for it) with
+     * the project's additional instructions appended. `AI_ENRICHMENT_PROMPT` is the default that
+     * feeds it, not what gets sent.
+     */
+    prompt: string;
+    connection: {
+        sdkName: string;
+        apiKey: string;
+    };
+}
+export interface IPrepareImageEnrichmentUseCase {
+    execute(fileId: string): Promise<Result<IPreparedImageEnrichment, ImageEnrichmentError>>;
+}
+export declare const PrepareImageEnrichmentUseCase: import("@webiny/di").Abstraction<IPrepareImageEnrichmentUseCase>;
+export declare namespace PrepareImageEnrichmentUseCase {
+    type Interface = IPrepareImageEnrichmentUseCase;
+}
+export interface IApplyImageEnrichmentParams {
+    fileId: string;
+    tags: string[];
+    description: string;
+}
+export interface IAppliedImageEnrichment {
+    fileId: string;
+    tags: string[];
+    description: string;
+}
+export interface IApplyImageEnrichmentUseCase {
+    execute(params: IApplyImageEnrichmentParams): Promise<Result<IAppliedImageEnrichment, ImageEnrichmentError>>;
+}
+export declare const ApplyImageEnrichmentUseCase: import("@webiny/di").Abstraction<IApplyImageEnrichmentUseCase>;
+export declare namespace ApplyImageEnrichmentUseCase {
+    type Interface = IApplyImageEnrichmentUseCase;
+}

package/api/features/AiImageEnrichment/abstractions.js

@@ -0,0 +1,12 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { z } from "zod";
+const AI_ENRICHMENT_PROMPT = "Analyze this image and return up to 5 lowercase descriptive tags and one short sentence describing the image.";
+const aiEnrichmentSchema = z.object({
+    tags: z.array(z.string()),
+    description: z.string()
+});
+const PrepareImageEnrichmentUseCase = createAbstraction("PrepareImageEnrichmentUseCase");
+const ApplyImageEnrichmentUseCase = createAbstraction("ApplyImageEnrichmentUseCase");
+export { AI_ENRICHMENT_PROMPT, ApplyImageEnrichmentUseCase, PrepareImageEnrichmentUseCase, aiEnrichmentSchema };
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AiImageEnrichment/abstractions.js","sources":["../../../../src/api/features/AiImageEnrichment/abstractions.ts"],"sourcesContent":["import { createAbstraction, Result } from \"@webiny/feature/api\";\nimport { z } from \"zod\";\nimport type { ImageEnrichmentError } from \"./errors.js\";\n\nexport const AI_ENRICHMENT_PROMPT =\n    \"Analyze this image and return up to 5 lowercase descriptive tags and one short sentence describing the image.\";\n\n/**\n * The shape both entry points ask the model for. Exported as the bare zod schema rather than a\n * ready-made `Output.object(...)`: the AI SDK's `Output` type can't be named in emitted declarations\n * (TS4023), so each call site wraps this locally instead.\n */\nexport const aiEnrichmentSchema = z.object({\n    tags: z.array(z.string()),\n    description: z.string()\n});\n\n/** The enrichment result: what the model produces and what gets persisted. */\nexport interface IEnrichmentOutput {\n    tags: string[];\n    description: string;\n}\n\n/**\n * Everything needed to run the AI call, gathered up front: the image bytes, the resolved provider,\n * and the file's current tags (needed to merge rather than overwrite).\n *\n * Deliberately split from the AI call itself so both entry points share the same preparation and the\n * same failure modes — and so the streaming route can answer with a real HTTP status code for\n * anything knowable before the stream opens, instead of burying it in a 200 response.\n */\nexport interface IPreparedImageEnrichment {\n    fileId: string;\n    imageBase64: string;\n    imageMediaType: string;\n    model: string;\n    /**\n     * The resolved prompt: this capability's guidance (or the project's replacement for it) with\n     * the project's additional instructions appended. `AI_ENRICHMENT_PROMPT` is the default that\n     * feeds it, not what gets sent.\n     */\n    prompt: string;\n    connection: {\n        sdkName: string;\n        apiKey: string;\n    };\n}\n\nexport interface IPrepareImageEnrichmentUseCase {\n    execute(fileId: string): Promise<Result<IPreparedImageEnrichment, ImageEnrichmentError>>;\n}\n\nexport const PrepareImageEnrichmentUseCase = createAbstraction<IPrepareImageEnrichmentUseCase>(\n    \"PrepareImageEnrichmentUseCase\"\n);\n\nexport namespace PrepareImageEnrichmentUseCase {\n    export type Interface = IPrepareImageEnrichmentUseCase;\n}\n\nexport interface IApplyImageEnrichmentParams {\n    fileId: string;\n    tags: string[];\n    description: string;\n}\n\nexport interface IAppliedImageEnrichment {\n    fileId: string;\n    tags: string[];\n    description: string;\n}\n\nexport interface IApplyImageEnrichmentUseCase {\n    execute(\n        params: IApplyImageEnrichmentParams\n    ): Promise<Result<IAppliedImageEnrichment, ImageEnrichmentError>>;\n}\n\nexport const ApplyImageEnrichmentUseCase = createAbstraction<IApplyImageEnrichmentUseCase>(\n    \"ApplyImageEnrichmentUseCase\"\n);\n\nexport namespace ApplyImageEnrichmentUseCase {\n    export type Interface = IApplyImageEnrichmentUseCase;\n}\n"],"names":["AI_ENRICHMENT_PROMPT","aiEnrichmentSchema","z","PrepareImageEnrichmentUseCase","createAbstraction","ApplyImageEnrichmentUseCase"],"mappings":";;AAIO,MAAMA,uBACT;AAOG,MAAMC,qBAAqBC,EAAE,MAAM,CAAC;IACvC,MAAMA,EAAE,KAAK,CAACA,EAAE,MAAM;IACtB,aAAaA,EAAE,MAAM;AACzB;AAqCO,MAAMC,gCAAgCC,kBACzC;AAyBG,MAAMC,8BAA8BD,kBACvC"}

package/api/features/AiImageEnrichment/buildEnrichmentAiRequest.d.ts

@@ -0,0 +1,12 @@
+import type { Ai } from "@webiny/api-core/features/ai/index.js";
+import type { IPreparedImageEnrichment } from "./abstractions.js";
+/**
+ * Builds the AI request both enrichment entry points send — the background task via `generateText`
+ * and the streaming route via `streamText`. Identical model, structured output, connection, and
+ * message payload; only the call differs.
+ *
+ * This is also where `Output.object(...)` lives rather than on `IPreparedImageEnrichment`: the AI
+ * SDK's `Output` type can't be named in emitted declarations (TS4023), so it has to be built inside a
+ * function body, not held on an exported interface.
+ */
+export declare function buildEnrichmentAiRequest(prepared: IPreparedImageEnrichment): Ai.GenerateTextParams;

package/api/features/AiImageEnrichment/buildEnrichmentAiRequest.js

@@ -0,0 +1,30 @@
+import { Output } from "ai";
+import { aiEnrichmentSchema } from "./abstractions.js";
+function buildEnrichmentAiRequest(prepared) {
+    return {
+        model: prepared.model,
+        output: Output.object({
+            schema: aiEnrichmentSchema
+        }),
+        connection: prepared.connection,
+        messages: [
+            {
+                role: "user",
+                content: [
+                    {
+                        type: "file",
+                        data: prepared.imageBase64,
+                        mediaType: prepared.imageMediaType
+                    },
+                    {
+                        type: "text",
+                        text: prepared.prompt
+                    }
+                ]
+            }
+        ]
+    };
+}
+export { buildEnrichmentAiRequest };
+
+//# sourceMappingURL=buildEnrichmentAiRequest.js.map

package/api/features/AiImageEnrichment/buildEnrichmentAiRequest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AiImageEnrichment/buildEnrichmentAiRequest.js","sources":["../../../../src/api/features/AiImageEnrichment/buildEnrichmentAiRequest.ts"],"sourcesContent":["import { Output } from \"ai\";\nimport type { Ai } from \"@webiny/api-core/features/ai/index.js\";\nimport { aiEnrichmentSchema } from \"./abstractions.js\";\nimport type { IPreparedImageEnrichment } from \"./abstractions.js\";\n\n/**\n * Builds the AI request both enrichment entry points send — the background task via `generateText`\n * and the streaming route via `streamText`. Identical model, structured output, connection, and\n * message payload; only the call differs.\n *\n * This is also where `Output.object(...)` lives rather than on `IPreparedImageEnrichment`: the AI\n * SDK's `Output` type can't be named in emitted declarations (TS4023), so it has to be built inside a\n * function body, not held on an exported interface.\n */\nexport function buildEnrichmentAiRequest(\n    prepared: IPreparedImageEnrichment\n): Ai.GenerateTextParams {\n    return {\n        model: prepared.model,\n        output: Output.object({ schema: aiEnrichmentSchema }),\n        connection: prepared.connection,\n        messages: [\n            {\n                role: \"user\",\n                content: [\n                    {\n                        // Sent as base64, not a URL: a URL forces the provider to fetch the file,\n                        // which fails for private files and can't reach a non-public origin.\n                        type: \"file\",\n                        data: prepared.imageBase64,\n                        mediaType: prepared.imageMediaType\n                    },\n                    {\n                        type: \"text\",\n                        text: prepared.prompt\n                    }\n                ]\n            }\n        ]\n    };\n}\n"],"names":["buildEnrichmentAiRequest","prepared","Output","aiEnrichmentSchema"],"mappings":";;AAcO,SAASA,yBACZC,QAAkC;IAElC,OAAO;QACH,OAAOA,SAAS,KAAK;QACrB,QAAQC,OAAO,MAAM,CAAC;YAAE,QAAQC;QAAmB;QACnD,YAAYF,SAAS,UAAU;QAC/B,UAAU;YACN;gBACI,MAAM;gBACN,SAAS;oBACL;wBAGI,MAAM;wBACN,MAAMA,SAAS,WAAW;wBAC1B,WAAWA,SAAS,cAAc;oBACtC;oBACA;wBACI,MAAM;wBACN,MAAMA,SAAS,MAAM;oBACzB;iBACH;YACL;SACH;IACL;AACJ"}

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

@@ -0,0 +1,18 @@
+import { AiCapability } from "../../../api/features/Capabilities/index.js";
+export declare const FM_IMAGE_ENRICHMENT_CAPABILITY = "fmImageEnrichment";
+declare class FmImageEnrichmentCapabilityImpl implements AiCapability.Interface {
+    readonly id = "fmImageEnrichment";
+    readonly label = "Image enrichment";
+    readonly description = "Reads an uploaded image and writes its alt text, title and tags. Needs a model that accepts image input.";
+    readonly defaultRole: "vision";
+    /**
+     * The one prompt here whose structure does not come from the prose: `Output.object(...)` in
+     * `buildEnrichmentAiRequest` enforces the tags/description shape. Projects still adjust it by
+     * appending, which is where house tag vocabularies go ("use our taxonomy", "British spelling").
+     */
+    readonly guidance = "Analyze this image and return up to 5 lowercase descriptive tags and one short sentence describing the image.";
+}
+export declare const FmImageEnrichmentCapability: typeof FmImageEnrichmentCapabilityImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/api/features/Capabilities/index.js").IAiCapability>;
+};
+export {};

package/api/features/AiImageEnrichment/capability.js

@@ -0,0 +1,19 @@
+import { AiCapability } from "../Capabilities/index.js";
+import { AI_ENRICHMENT_PROMPT } from "./abstractions.js";
+const FM_IMAGE_ENRICHMENT_CAPABILITY = "fmImageEnrichment";
+class FmImageEnrichmentCapabilityImpl {
+    constructor(){
+        this.id = FM_IMAGE_ENRICHMENT_CAPABILITY;
+        this.label = "Image enrichment";
+        this.description = "Reads an uploaded image and writes its alt text, title and tags. Needs a model that accepts image input.";
+        this.defaultRole = "vision";
+        this.guidance = AI_ENRICHMENT_PROMPT;
+    }
+}
+const FmImageEnrichmentCapability = AiCapability.createImplementation({
+    implementation: FmImageEnrichmentCapabilityImpl,
+    dependencies: []
+});
+export { FM_IMAGE_ENRICHMENT_CAPABILITY, FmImageEnrichmentCapability };
+
+//# sourceMappingURL=capability.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AiImageEnrichment/capability.js","sources":["../../../../src/api/features/AiImageEnrichment/capability.ts"],"sourcesContent":["import { AiCapability } from \"~/api/features/Capabilities/index.js\";\nimport { AI_ENRICHMENT_PROMPT } from \"./abstractions.js\";\n\nexport const FM_IMAGE_ENRICHMENT_CAPABILITY = \"fmImageEnrichment\";\n\nclass FmImageEnrichmentCapabilityImpl implements AiCapability.Interface {\n    readonly id = FM_IMAGE_ENRICHMENT_CAPABILITY;\n    readonly label = \"Image enrichment\";\n    readonly description =\n        \"Reads an uploaded image and writes its alt text, title and tags. Needs a model that accepts image input.\";\n    readonly defaultRole = \"vision\" as const;\n    /**\n     * The one prompt here whose structure does not come from the prose: `Output.object(...)` in\n     * `buildEnrichmentAiRequest` enforces the tags/description shape. Projects still adjust it by\n     * appending, which is where house tag vocabularies go (\"use our taxonomy\", \"British spelling\").\n     */\n    readonly guidance = AI_ENRICHMENT_PROMPT;\n}\n\nexport const FmImageEnrichmentCapability = AiCapability.createImplementation({\n    implementation: FmImageEnrichmentCapabilityImpl,\n    dependencies: []\n});\n"],"names":["FM_IMAGE_ENRICHMENT_CAPABILITY","FmImageEnrichmentCapabilityImpl","AI_ENRICHMENT_PROMPT","FmImageEnrichmentCapability","AiCapability"],"mappings":";;AAGO,MAAMA,iCAAiC;AAE9C,MAAMC;;aACO,EAAE,GAAGD;aACL,KAAK,GAAG;aACR,WAAW,GAChB;aACK,WAAW,GAAG;QAKtB,KACQ,QAAQ,GAAGE;;AACxB;AAEO,MAAMC,8BAA8BC,aAAa,oBAAoB,CAAC;IACzE,gBAAgBH;IAChB,cAAc,EAAE;AACpB"}

package/api/features/AiImageEnrichment/errors.d.ts

@@ -0,0 +1,33 @@
+import type { EnrichmentCapabilityDisabledError } from "./EnrichmentCapabilityDisabledError.js";
+export { EnrichmentCapabilityDisabledError } from "./EnrichmentCapabilityDisabledError.js";
+/**
+ * Errors shared by every image-enrichment entry point (the background task and the streaming HTTP
+ * route). Each carries a `code` so callers can map it to their own transport: the task turns them
+ * into task results, the route into HTTP status codes.
+ */
+export declare class EnrichmentFileNotFoundError extends Error {
+    readonly code: "ENRICHMENT_FILE_NOT_FOUND";
+    constructor(fileId: string);
+}
+export declare class EnrichmentNotAnImageError extends Error {
+    readonly code: "ENRICHMENT_NOT_AN_IMAGE";
+    constructor(type: string);
+}
+export declare class EnrichmentFileContentsError extends Error {
+    readonly code: "ENRICHMENT_FILE_CONTENTS_UNREADABLE";
+    constructor(reason: string);
+}
+export declare class EnrichmentNoProviderError extends Error {
+    readonly code: "ENRICHMENT_NO_AI_PROVIDER";
+    /**
+     * The reason comes from capability resolution, which knows which of the several ways this can
+     * fail actually happened: no model in the Vision role, a deleted connection, a missing key.
+     * Passing it through beats replacing all of them with one generic sentence.
+     */
+    constructor(reason?: string);
+}
+export declare class EnrichmentPersistError extends Error {
+    readonly code: "ENRICHMENT_PERSIST_FAILED";
+    constructor(reason: string);
+}
+export type ImageEnrichmentError = EnrichmentFileNotFoundError | EnrichmentNotAnImageError | EnrichmentFileContentsError | EnrichmentNoProviderError | EnrichmentCapabilityDisabledError | EnrichmentPersistError;

package/api/features/AiImageEnrichment/errors.js

@@ -0,0 +1,29 @@
+class EnrichmentFileNotFoundError extends Error {
+    constructor(fileId){
+        super(`File not found: ${fileId}`), this.code = "ENRICHMENT_FILE_NOT_FOUND";
+    }
+}
+class EnrichmentNotAnImageError extends Error {
+    constructor(type){
+        super(`File is not an image (received "${type}"); skipping AI enrichment.`), this.code = "ENRICHMENT_NOT_AN_IMAGE";
+    }
+}
+class EnrichmentFileContentsError extends Error {
+    constructor(reason){
+        super(`Unable to read file contents: ${reason}`), this.code = "ENRICHMENT_FILE_CONTENTS_UNREADABLE";
+    }
+}
+class EnrichmentNoProviderError extends Error {
+    constructor(reason){
+        super(reason ?? "No AI model is configured for image enrichment. Pick one under Settings → AI Power-Ups → Model roles."), this.code = "ENRICHMENT_NO_AI_PROVIDER";
+    }
+}
+class EnrichmentPersistError extends Error {
+    constructor(reason){
+        super(`Failed to update file: ${reason}`), this.code = "ENRICHMENT_PERSIST_FAILED";
+    }
+}
+export { EnrichmentCapabilityDisabledError } from "./EnrichmentCapabilityDisabledError.js";
+export { EnrichmentFileContentsError, EnrichmentFileNotFoundError, EnrichmentNoProviderError, EnrichmentNotAnImageError, EnrichmentPersistError };
+
+//# sourceMappingURL=errors.js.map

package/api/features/AiImageEnrichment/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AiImageEnrichment/errors.js","sources":["../../../../src/api/features/AiImageEnrichment/errors.ts"],"sourcesContent":["import type { EnrichmentCapabilityDisabledError } from \"./EnrichmentCapabilityDisabledError.js\";\n\n/* Its own file, one class per file, but re-exported so every caller imports errors from here. */\nexport { EnrichmentCapabilityDisabledError } from \"./EnrichmentCapabilityDisabledError.js\";\n\n/**\n * Errors shared by every image-enrichment entry point (the background task and the streaming HTTP\n * route). Each carries a `code` so callers can map it to their own transport: the task turns them\n * into task results, the route into HTTP status codes.\n */\nexport class EnrichmentFileNotFoundError extends Error {\n    readonly code = \"ENRICHMENT_FILE_NOT_FOUND\" as const;\n\n    constructor(fileId: string) {\n        super(`File not found: ${fileId}`);\n    }\n}\n\nexport class EnrichmentNotAnImageError extends Error {\n    readonly code = \"ENRICHMENT_NOT_AN_IMAGE\" as const;\n\n    constructor(type: string) {\n        super(`File is not an image (received \"${type}\"); skipping AI enrichment.`);\n    }\n}\n\nexport class EnrichmentFileContentsError extends Error {\n    readonly code = \"ENRICHMENT_FILE_CONTENTS_UNREADABLE\" as const;\n\n    constructor(reason: string) {\n        super(`Unable to read file contents: ${reason}`);\n    }\n}\n\nexport class EnrichmentNoProviderError extends Error {\n    readonly code = \"ENRICHMENT_NO_AI_PROVIDER\" as const;\n\n    /**\n     * The reason comes from capability resolution, which knows which of the several ways this can\n     * fail actually happened: no model in the Vision role, a deleted connection, a missing key.\n     * Passing it through beats replacing all of them with one generic sentence.\n     */\n    constructor(reason?: string) {\n        super(\n            reason ??\n                \"No AI model is configured for image enrichment. Pick one under Settings → AI Power-Ups → Model roles.\"\n        );\n    }\n}\n\nexport class EnrichmentPersistError extends Error {\n    readonly code = \"ENRICHMENT_PERSIST_FAILED\" as const;\n\n    constructor(reason: string) {\n        super(`Failed to update file: ${reason}`);\n    }\n}\n\nexport type ImageEnrichmentError =\n    | EnrichmentFileNotFoundError\n    | EnrichmentNotAnImageError\n    | EnrichmentFileContentsError\n    | EnrichmentNoProviderError\n    | EnrichmentCapabilityDisabledError\n    | EnrichmentPersistError;\n"],"names":["EnrichmentFileNotFoundError","Error","fileId","EnrichmentNotAnImageError","type","EnrichmentFileContentsError","reason","EnrichmentNoProviderError","EnrichmentPersistError"],"mappings":"AAUO,MAAMA,oCAAoCC;IAG7C,YAAYC,MAAc,CAAE;QACxB,KAAK,CAAC,CAAC,gBAAgB,EAAEA,QAAQ,QAH5B,IAAI,GAAG;IAIhB;AACJ;AAEO,MAAMC,kCAAkCF;IAG3C,YAAYG,IAAY,CAAE;QACtB,KAAK,CAAC,CAAC,gCAAgC,EAAEA,KAAK,2BAA2B,CAAC,QAHrE,IAAI,GAAG;IAIhB;AACJ;AAEO,MAAMC,oCAAoCJ;IAG7C,YAAYK,MAAc,CAAE;QACxB,KAAK,CAAC,CAAC,8BAA8B,EAAEA,QAAQ,QAH1C,IAAI,GAAG;IAIhB;AACJ;AAEO,MAAMC,kCAAkCN;IAQ3C,YAAYK,MAAe,CAAE;QACzB,KAAK,CACDA,UACI,+GAVH,IAAI,GAAG;IAYhB;AACJ;AAEO,MAAME,+BAA+BP;IAGxC,YAAYK,MAAc,CAAE;QACxB,KAAK,CAAC,CAAC,uBAAuB,EAAEA,QAAQ,QAHnC,IAAI,GAAG;IAIhB;AACJ"}

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

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

package/api/features/AiImageEnrichment/feature.js

@@ -0,0 +1,24 @@
+import { createFeature } from "@webiny/feature/api";
+import { FeatureFlags } from "@webiny/api-core/features/featureFlags/abstractions.js";
+import { AiImageEnrichmentAfterCreateHandler } from "./AiImageEnrichmentAfterCreateHandler.js";
+import { AiImageEnrichmentTask } from "./AiImageEnrichmentTask.js";
+import { AiImageEnrichmentStreamRouteDefinition } from "./AiImageEnrichmentStreamRoute.js";
+import { PrepareImageEnrichmentUseCase } from "./PrepareImageEnrichmentUseCase.js";
+import { ApplyImageEnrichmentUseCase } from "./ApplyImageEnrichmentUseCase.js";
+import { FmImageEnrichmentCapability } from "./capability.js";
+const AiImageEnrichmentFeature = createFeature({
+    name: "AiPowerUps/AiImageEnrichment",
+    register (container) {
+        const enabled = container.resolve(FeatureFlags).get().isEnabled("aiPowerups.fileManager.imageEnrichment");
+        if (!enabled) return;
+        container.register(FmImageEnrichmentCapability);
+        container.register(PrepareImageEnrichmentUseCase);
+        container.register(ApplyImageEnrichmentUseCase);
+        container.register(AiImageEnrichmentAfterCreateHandler);
+        container.register(AiImageEnrichmentTask);
+        container.register(AiImageEnrichmentStreamRouteDefinition);
+    }
+});
+export { AiImageEnrichmentFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AiImageEnrichment/feature.js","sources":["../../../../src/api/features/AiImageEnrichment/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { FeatureFlags } from \"@webiny/api-core/features/featureFlags/abstractions.js\";\nimport { AiImageEnrichmentAfterCreateHandler } from \"./AiImageEnrichmentAfterCreateHandler.js\";\nimport { AiImageEnrichmentTask } from \"./AiImageEnrichmentTask.js\";\nimport { AiImageEnrichmentStreamRouteDefinition } from \"./AiImageEnrichmentStreamRoute.js\";\nimport { PrepareImageEnrichmentUseCase } from \"./PrepareImageEnrichmentUseCase.js\";\nimport { ApplyImageEnrichmentUseCase } from \"./ApplyImageEnrichmentUseCase.js\";\nimport { FmImageEnrichmentCapability } from \"./capability.js\";\n\nexport const AiImageEnrichmentFeature = createFeature({\n    name: \"AiPowerUps/AiImageEnrichment\",\n    register(container) {\n        // Register-time gate on the effective feature flags (userFlag && live WCP license). Valid at\n        // register() time because the license is refreshed PRE-register (WcpLicenseLoader.load() in\n        // registerApiRequestStack) and FeatureFlags reads that process cache — and it re-evaluates per\n        // request since the child re-registers, so a license change takes effect on the next request.\n        const enabled = container\n            .resolve(FeatureFlags)\n            .get()\n            .isEnabled(\"aiPowerups.fileManager.imageEnrichment\");\n\n        if (!enabled) {\n            return;\n        }\n\n        // Registered inside the gate, so a project without the license does not get a settings\n        // row for a feature it cannot use.\n        container.register(FmImageEnrichmentCapability);\n        container.register(PrepareImageEnrichmentUseCase);\n        container.register(ApplyImageEnrichmentUseCase);\n\n        // Automatic enrichment after a file is created.\n        container.register(AiImageEnrichmentAfterCreateHandler);\n        container.register(AiImageEnrichmentTask);\n\n        // On-demand re-enrichment, streamed.\n        container.register(AiImageEnrichmentStreamRouteDefinition);\n    }\n});\n"],"names":["AiImageEnrichmentFeature","createFeature","container","enabled","FeatureFlags","FmImageEnrichmentCapability","PrepareImageEnrichmentUseCase","ApplyImageEnrichmentUseCase","AiImageEnrichmentAfterCreateHandler","AiImageEnrichmentTask","AiImageEnrichmentStreamRouteDefinition"],"mappings":";;;;;;;;AASO,MAAMA,2BAA2BC,cAAc;IAClD,MAAM;IACN,UAASC,SAAS;QAKd,MAAMC,UAAUD,UACX,OAAO,CAACE,cACR,GAAG,GACH,SAAS,CAAC;QAEf,IAAI,CAACD,SACD;QAKJD,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QAGnBL,UAAU,QAAQ,CAACM;QACnBN,UAAU,QAAQ,CAACO;QAGnBP,UAAU,QAAQ,CAACQ;IACvB;AACJ"}

package/api/features/AiImageEnrichment/imageEnrichmentErrorStatusCode.d.ts

@@ -0,0 +1,6 @@
+import type { ImageEnrichmentError } from "./errors.js";
+/**
+ * Maps an enrichment failure to the HTTP status a transport should answer with. Lives next to the
+ * errors rather than in a route, so a second entry point can't invent a different mapping.
+ */
+export declare function imageEnrichmentErrorStatusCode(error: ImageEnrichmentError): number;

package/api/features/AiImageEnrichment/imageEnrichmentErrorStatusCode.js

@@ -0,0 +1,10 @@
+import { EnrichmentCapabilityDisabledError, EnrichmentFileNotFoundError, EnrichmentNotAnImageError } from "./errors.js";
+function imageEnrichmentErrorStatusCode(error) {
+    if (error instanceof EnrichmentFileNotFoundError) return 404;
+    if (error instanceof EnrichmentNotAnImageError) return 400;
+    if (error instanceof EnrichmentCapabilityDisabledError) return 409;
+    return 500;
+}
+export { imageEnrichmentErrorStatusCode };
+
+//# sourceMappingURL=imageEnrichmentErrorStatusCode.js.map

package/api/features/AiImageEnrichment/imageEnrichmentErrorStatusCode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AiImageEnrichment/imageEnrichmentErrorStatusCode.js","sources":["../../../../src/api/features/AiImageEnrichment/imageEnrichmentErrorStatusCode.ts"],"sourcesContent":["import { EnrichmentFileNotFoundError, EnrichmentNotAnImageError } from \"./errors.js\";\nimport { EnrichmentCapabilityDisabledError } from \"./errors.js\";\nimport type { ImageEnrichmentError } from \"./errors.js\";\n\n/**\n * Maps an enrichment failure to the HTTP status a transport should answer with. Lives next to the\n * errors rather than in a route, so a second entry point can't invent a different mapping.\n */\nexport function imageEnrichmentErrorStatusCode(error: ImageEnrichmentError): number {\n    if (error instanceof EnrichmentFileNotFoundError) {\n        return 404;\n    }\n    if (error instanceof EnrichmentNotAnImageError) {\n        return 400;\n    }\n    /*\n     * The request is fine and the server is fine; the feature is switched off. A 500 would tell\n     * whoever called it that something broke, which is the one thing that did not happen.\n     */\n    if (error instanceof EnrichmentCapabilityDisabledError) {\n        return 409;\n    }\n    return 500;\n}\n"],"names":["imageEnrichmentErrorStatusCode","error","EnrichmentFileNotFoundError","EnrichmentNotAnImageError","EnrichmentCapabilityDisabledError"],"mappings":";AAQO,SAASA,+BAA+BC,KAA2B;IACtE,IAAIA,iBAAiBC,6BACjB,OAAO;IAEX,IAAID,iBAAiBE,2BACjB,OAAO;IAMX,IAAIF,iBAAiBG,mCACjB,OAAO;IAEX,OAAO;AACX"}

package/api/features/AiImageEnrichment/readEnrichmentPartial.d.ts

@@ -0,0 +1,8 @@
+import type { IEnrichmentOutput } from "./abstractions.js";
+/**
+ * Normalises one value from `streamText`'s `partialOutputStream`.
+ *
+ * Partial output is exactly that: mid-stream the tag array can hold holes/undefined entries and the
+ * description may not have arrived, so callers get only the values that are actually present.
+ */
+export declare function readEnrichmentPartial(partial: unknown): IEnrichmentOutput;

package/api/features/AiImageEnrichment/readEnrichmentPartial.js

@@ -0,0 +1,16 @@
+function readEnrichmentPartial(partial) {
+    const value = partial ?? {};
+    const tags = [];
+    if (Array.isArray(value.tags)) {
+        for (const tag of value.tags)if ("string" == typeof tag && "" !== tag) tags.push(tag);
+    }
+    let description = "";
+    if ("string" == typeof value.description) description = value.description;
+    return {
+        tags,
+        description
+    };
+}
+export { readEnrichmentPartial };
+
+//# sourceMappingURL=readEnrichmentPartial.js.map

package/api/features/AiImageEnrichment/readEnrichmentPartial.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AiImageEnrichment/readEnrichmentPartial.js","sources":["../../../../src/api/features/AiImageEnrichment/readEnrichmentPartial.ts"],"sourcesContent":["import type { IEnrichmentOutput } from \"./abstractions.js\";\n\n/**\n * Normalises one value from `streamText`'s `partialOutputStream`.\n *\n * Partial output is exactly that: mid-stream the tag array can hold holes/undefined entries and the\n * description may not have arrived, so callers get only the values that are actually present.\n */\nexport function readEnrichmentPartial(partial: unknown): IEnrichmentOutput {\n    const value = (partial ?? {}) as { tags?: unknown; description?: unknown };\n\n    const tags: string[] = [];\n\n    if (Array.isArray(value.tags)) {\n        for (const tag of value.tags) {\n            // Empty strings are dropped, not just non-strings: mid-stream the array can hold `\"\"`\n            // for an entry the model has opened but not written into yet, which renders as a blank\n            // chip.\n            if (typeof tag === \"string\" && tag !== \"\") {\n                tags.push(tag);\n            }\n        }\n    }\n\n    let description = \"\";\n\n    if (typeof value.description === \"string\") {\n        description = value.description;\n    }\n\n    return { tags, description };\n}\n"],"names":["readEnrichmentPartial","partial","value","tags","Array","tag","description"],"mappings":"AAQO,SAASA,sBAAsBC,OAAgB;IAClD,MAAMC,QAASD,WAAW,CAAC;IAE3B,MAAME,OAAiB,EAAE;IAEzB,IAAIC,MAAM,OAAO,CAACF,MAAM,IAAI,GACxB;QAAA,KAAK,MAAMG,OAAOH,MAAM,IAAI,CAIxB,IAAI,AAAe,YAAf,OAAOG,OAAoBA,AAAQ,OAARA,KAC3BF,KAAK,IAAI,CAACE;IAElB;IAGJ,IAAIC,cAAc;IAElB,IAAI,AAA6B,YAA7B,OAAOJ,MAAM,WAAW,EACxBI,cAAcJ,MAAM,WAAW;IAGnC,OAAO;QAAEC;QAAMG;IAAY;AAC/B"}

package/api/features/AiImageEnrichment/streamEvents.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Server-sent event payloads emitted by `AiImageEnrichmentStreamRoute` — this feature's stream
+ * protocol, not a shared one. The SSE wire format itself (`toSseFrame`) is transport-level and lives
+ * in `@webiny/event-handler-core`; what the events are called and what they carry is per feature,
+ * since the next streaming route will want a different set.
+ *
+ * A small domain protocol rather than the AI SDK's UI message stream: the client
+ * doesn't render a chat transcript, it renders a progressively-completing `{ tags, description }`
+ * object, which is exactly what `streamText`'s `partialOutputStream` produces. The admin app mirrors
+ * these types (it can't import an api-side package), so keep the two in sync.
+ */
+export interface EnrichmentStreamStartEvent {
+    type: "start";
+    fileId: string;
+    model: string;
+}
+export interface EnrichmentStreamPartialEvent {
+    type: "partial";
+    tags: string[];
+    description: string;
+}
+export interface EnrichmentStreamDoneEvent {
+    type: "done";
+    fileId: string;
+    /**
+     * The model's final output. NOT persisted — the streaming route only proposes, and the client
+     * saves through the file's normal update path if the user accepts.
+     */
+    tags: string[];
+    description: string;
+}
+export interface EnrichmentStreamErrorEvent {
+    type: "error";
+    message: string;
+}
+export type EnrichmentStreamEvent = EnrichmentStreamStartEvent | EnrichmentStreamPartialEvent | EnrichmentStreamDoneEvent | EnrichmentStreamErrorEvent;

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

@@ -0,0 +1,19 @@
+import { GetSettingsUseCase } from "../../../api/features/GetSettings/index.js";
+import { GetFileContentsByIdUseCase } from "@webiny/api-file-manager/features/file/GetFileContentsById/index.js";
+import { GetFileUseCase } from "@webiny/api-file-manager/features/file/GetFile/index.js";
+import { TextExtractor } from "@webiny/api-core/features/ai/index.js";
+import { AiPromptContextBuilder as Abstraction, ProjectFileAssembler, type AiPromptContext, type AiPromptContextParams } from "./abstractions.js";
+declare class AiPromptContextBuilderImpl implements Abstraction.Interface {
+    private getSettings;
+    private fileAssembler;
+    private getFileContents;
+    private getFile;
+    private textExtractor;
+    constructor(getSettings: GetSettingsUseCase.Interface, fileAssembler: ProjectFileAssembler.Interface, getFileContents: GetFileContentsByIdUseCase.Interface, getFile: GetFileUseCase.Interface, textExtractor: TextExtractor.Interface);
+    execute(params: AiPromptContextParams): Promise<AiPromptContext>;
+    private fetchAdditionalFiles;
+}
+export declare const AiPromptContextBuilder: typeof AiPromptContextBuilderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IAiPromptContextBuilder>;
+};
+export {};