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

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 = \"adminAssistant\";\n\n/**\n * The assistant behind the admin command palette.\n *\n * `adminAssistant` 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 (`fmImageEnrichment`, `cmsGenerateEntry`), 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"}

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

@@ -0,0 +1,54 @@
+import type { ModelMessage } from "ai";
+import type { PendingApproval } from "./approvals.js";
+/**
+ * What the assistant emits while it works.
+ *
+ * Deliberately a small, purpose-built set rather than the AI SDK's UI-message protocol: the client is
+ * a command palette, not a chat framework, and it needs one thing the SDK protocol does not model for
+ * us — the approval pause. Keeping our own events also means the admin bundle carries no AI SDK code.
+ *
+ * Transport-free by design. A transport frames these (as SSE, as newline JSON, as a CLI render); the
+ * feature only says what happened.
+ */
+export type AdminAssistantEvent = 
+/** A fragment of the answer. Concatenate in arrival order. */
+{
+    type: "text";
+    text: string;
+}
+/** A tool started running. Named so the UI can show work in progress, not just a spinner. */
+ | {
+    type: "tool-call";
+    name: string;
+}
+/** A tool finished. Pairs with `tool-call` by name. */
+ | {
+    type: "tool-result";
+    name: string;
+}
+/**
+ * A tool threw. Also pairs with `tool-call` by name, and is NOT terminal: the model reads the
+ * message and usually corrects itself on the next step, which is why tools report failure by
+ * throwing. Without this the call would have no outcome and its chip would spin forever.
+ */
+ | {
+    type: "tool-error";
+    name: string;
+    message: string;
+}
+/** The loop paused: these calls change something and need a human decision. */
+ | {
+    type: "approval";
+    approvals: PendingApproval[];
+}
+/** Terminal success. Carries what the client must replay to resume after an approval. */
+ | {
+    type: "done";
+    messages: ModelMessage[];
+    steps: number;
+}
+/** Terminal failure. The run produced no usable answer. */
+ | {
+    type: "error";
+    message: string;
+};

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

@@ -0,0 +1,12 @@
+/**
+ * The admin assistant: its capability, the use case, and the HTTP route that reaches it.
+ *
+ * Lives in AI Power-Ups rather than in a package of its own because everything it needs is here —
+ * the settings that choose its model, the capability resolver that reads them, and the tools it
+ * calls. As a separate package it could only reach those through an abstraction registered back
+ * from this side, which is an indirection that bought nothing.
+ */
+export declare const AdminAssistantFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/api/features/AdminAssistant/feature.js

@@ -0,0 +1,23 @@
+import { createFeature } from "@webiny/feature/api";
+import { FeatureFlags } from "@webiny/api-core/features/featureFlags/abstractions.js";
+import { AdminAssistantConfig } from "./abstractions.js";
+import { AdminAssistantUseCase } from "./AdminAssistantUseCase.js";
+import { AdminAssistantStreamRouteDefinition } from "./AdminAssistantStreamRoute.js";
+import { AdminAssistantCapability } from "./capability.js";
+const MAX_STEPS = 12;
+const AdminAssistantFeature = createFeature({
+    name: "AiPowerUps/AdminAssistant",
+    register (container) {
+        const enabled = container.resolve(FeatureFlags).get().isEnabled("aiPowerups.adminAssistant");
+        if (!enabled) return;
+        container.register(AdminAssistantCapability);
+        container.registerInstance(AdminAssistantConfig, {
+            maxSteps: MAX_STEPS
+        });
+        container.register(AdminAssistantUseCase);
+        container.register(AdminAssistantStreamRouteDefinition);
+    }
+});
+export { AdminAssistantFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AdminAssistant/feature.js","sources":["../../../../src/api/features/AdminAssistant/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { FeatureFlags } from \"@webiny/api-core/features/featureFlags/abstractions.js\";\nimport { AdminAssistantConfig } from \"./abstractions.js\";\nimport { AdminAssistantUseCase } from \"./AdminAssistantUseCase.js\";\nimport { AdminAssistantStreamRouteDefinition } from \"./AdminAssistantStreamRoute.js\";\nimport { AdminAssistantCapability } from \"./capability.js\";\n\n/**\n * How many rounds the agent loop may take before it is cut off.\n *\n * Enough for the deepest expected chain: list models, describe one, query it, answer — plus room for\n * a corrected retry after a rejected filter.\n *\n * Deliberately not configurable. It is a runaway guard, closer to a timeout than a setting, and the\n * number only means something next to the tool chains the assistant actually walks. Exposing it\n * invites a project to raise it to 100 and find out what that costs.\n */\nconst MAX_STEPS = 12;\n\n/**\n * The admin assistant: its capability, the use case, and the HTTP route that reaches it.\n *\n * Lives in AI Power-Ups rather than in a package of its own because everything it needs is here —\n * the settings that choose its model, the capability resolver that reads them, and the tools it\n * calls. As a separate package it could only reach those through an abstraction registered back\n * from this side, which is an indirection that bought nothing.\n */\nexport const AdminAssistantFeature = createFeature({\n    name: \"AiPowerUps/AdminAssistant\",\n    register(container) {\n        // Register-time gate on the effective flags (project config && live WCP license), matching\n        // how every other AI feature gates itself. Nothing is registered when it is off, so an\n        // unlicensed project has no `/stream/ai/admin-assistant` route and no settings row.\n        const enabled = container\n            .resolve(FeatureFlags)\n            .get()\n            .isEnabled(\"aiPowerups.adminAssistant\");\n\n        if (!enabled) {\n            return;\n        }\n\n        container.register(AdminAssistantCapability);\n        container.registerInstance(AdminAssistantConfig, { maxSteps: MAX_STEPS });\n        container.register(AdminAssistantUseCase);\n\n        /*\n         * Only the definition is registered: the router matches on it and builds the handler it\n         * names once a request actually hits the path.\n         */\n        container.register(AdminAssistantStreamRouteDefinition);\n    }\n});\n"],"names":["MAX_STEPS","AdminAssistantFeature","createFeature","container","enabled","FeatureFlags","AdminAssistantCapability","AdminAssistantConfig","AdminAssistantUseCase","AdminAssistantStreamRouteDefinition"],"mappings":";;;;;;AAiBA,MAAMA,YAAY;AAUX,MAAMC,wBAAwBC,cAAc;IAC/C,MAAM;IACN,UAASC,SAAS;QAId,MAAMC,UAAUD,UACX,OAAO,CAACE,cACR,GAAG,GACH,SAAS,CAAC;QAEf,IAAI,CAACD,SACD;QAGJD,UAAU,QAAQ,CAACG;QACnBH,UAAU,gBAAgB,CAACI,sBAAsB;YAAE,UAAUP;QAAU;QACvEG,UAAU,QAAQ,CAACK;QAMnBL,UAAU,QAAQ,CAACM;IACvB;AACJ"}

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

@@ -0,0 +1,5 @@
+export { AdminAssistantUseCase, AdminAssistantConfig } from "./abstractions.js";
+export type { AdminAssistantParams } from "./abstractions.js";
+export type { AdminAssistantEvent } from "./events.js";
+export { AdminAssistantCapability, ADMIN_ASSISTANT_CAPABILITY } from "./capability.js";
+export { AdminAssistantFeature } from "./feature.js";

package/api/features/AdminAssistant/index.js

@@ -0,0 +1,3 @@
+export { AdminAssistantConfig, AdminAssistantUseCase } from "./abstractions.js";
+export { ADMIN_ASSISTANT_CAPABILITY, AdminAssistantCapability } from "./capability.js";
+export { AdminAssistantFeature } from "./feature.js";

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

@@ -0,0 +1,14 @@
+import type { ModelMessage } from "ai";
+import type { ApprovalDecision } from "./approvals.js";
+export interface ParsedChatBody {
+    messages: ModelMessage[];
+    decisions: ApprovalDecision[];
+}
+/**
+ * Accepts either a fresh question or a continuation. A continuation replays `messages` verbatim,
+ * including the assistant message carrying the approval request, because the SDK matches an approval
+ * response to its request by id and that request exists nowhere else. We keep no session.
+ *
+ * Returns null for anything unusable, so the caller decides the status code.
+ */
+export declare const parseChatBody: (body: unknown) => ParsedChatBody | null;

package/api/features/AdminAssistant/parseChatBody.js

@@ -0,0 +1,33 @@
+import { parseDecisions } from "./approvals.js";
+const safeParse = (value)=>{
+    try {
+        return JSON.parse(value);
+    } catch  {
+        return;
+    }
+};
+const parseChatBody = (body)=>{
+    const raw = "string" == typeof body ? safeParse(body) : body;
+    const payload = raw;
+    if (!payload) return null;
+    const decisions = parseDecisions(payload["approvals"]);
+    const prompt = payload["prompt"];
+    if ("string" == typeof prompt && prompt.trim()) return {
+        messages: [
+            {
+                role: "user",
+                content: prompt
+            }
+        ],
+        decisions
+    };
+    const messages = payload["messages"];
+    if (!Array.isArray(messages) || 0 === messages.length) return null;
+    return {
+        messages: messages,
+        decisions
+    };
+};
+export { parseChatBody };
+
+//# sourceMappingURL=parseChatBody.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AdminAssistant/parseChatBody.js","sources":["../../../../src/api/features/AdminAssistant/parseChatBody.ts"],"sourcesContent":["import type { ModelMessage } from \"ai\";\nimport { parseDecisions } from \"./approvals.js\";\nimport type { ApprovalDecision } from \"./approvals.js\";\n\nexport interface ParsedChatBody {\n    messages: ModelMessage[];\n    decisions: ApprovalDecision[];\n}\n\nconst safeParse = (value: string): unknown => {\n    try {\n        return JSON.parse(value);\n    } catch {\n        return undefined;\n    }\n};\n\n/**\n * Accepts either a fresh question or a continuation. A continuation replays `messages` verbatim,\n * including the assistant message carrying the approval request, because the SDK matches an approval\n * response to its request by id and that request exists nowhere else. We keep no session.\n *\n * Returns null for anything unusable, so the caller decides the status code.\n */\nexport const parseChatBody = (body: unknown): ParsedChatBody | null => {\n    const raw = typeof body === \"string\" ? safeParse(body) : body;\n    const payload = raw as Record<string, unknown> | undefined;\n\n    if (!payload) {\n        return null;\n    }\n\n    const decisions = parseDecisions(payload[\"approvals\"]);\n    const prompt = payload[\"prompt\"];\n\n    if (typeof prompt === \"string\" && prompt.trim()) {\n        return { messages: [{ role: \"user\", content: prompt }], decisions };\n    }\n\n    const messages = payload[\"messages\"];\n\n    if (!Array.isArray(messages) || messages.length === 0) {\n        return null;\n    }\n\n    return { messages: messages as ModelMessage[], decisions };\n};\n"],"names":["safeParse","value","JSON","parseChatBody","body","raw","payload","decisions","parseDecisions","prompt","messages","Array"],"mappings":";AASA,MAAMA,YAAY,CAACC;IACf,IAAI;QACA,OAAOC,KAAK,KAAK,CAACD;IACtB,EAAE,OAAM;QACJ;IACJ;AACJ;AASO,MAAME,gBAAgB,CAACC;IAC1B,MAAMC,MAAM,AAAgB,YAAhB,OAAOD,OAAoBJ,UAAUI,QAAQA;IACzD,MAAME,UAAUD;IAEhB,IAAI,CAACC,SACD,OAAO;IAGX,MAAMC,YAAYC,eAAeF,OAAO,CAAC,YAAY;IACrD,MAAMG,SAASH,OAAO,CAAC,SAAS;IAEhC,IAAI,AAAkB,YAAlB,OAAOG,UAAuBA,OAAO,IAAI,IACzC,OAAO;QAAE,UAAU;YAAC;gBAAE,MAAM;gBAAQ,SAASA;YAAO;SAAE;QAAEF;IAAU;IAGtE,MAAMG,WAAWJ,OAAO,CAAC,WAAW;IAEpC,IAAI,CAACK,MAAM,OAAO,CAACD,aAAaA,AAAoB,MAApBA,SAAS,MAAM,EAC3C,OAAO;IAGX,OAAO;QAAE,UAAUA;QAA4BH;IAAU;AAC7D"}

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

@@ -0,0 +1,7 @@
+/**
+ * The assistant is deliberately told to DISCOVER rather than guess. Model IDs and field IDs are
+ * project-specific — there is no way to know them from training data — so every concrete answer has to
+ * come from a tool call. Without this instruction models happily invent a plausible `modelId` and then
+ * report the resulting error as if the content did not exist.
+ */
+export declare const SYSTEM_PROMPT = "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.";

package/api/features/AdminAssistant/systemPrompt.js

@@ -0,0 +1,24 @@
+const SYSTEM_PROMPT = `You are the Webiny admin assistant. You help editors and developers find, understand and change the content in their Webiny project.
+
+You have tools available. Use them — never answer a question about this project's content, models, or files from memory or assumption.
+
+How to work:
+- Content model IDs and field IDs are specific to this project. Always discover them with listContentModels, then describeContentModel, before querying.
+- Build filters with the field IDs describeContentModel returned. Do not guess field names.
+- If a tool returns an error, read it and correct your call. A "not allowed" error means the user lacks permission — say so plainly rather than retrying.
+- If a query returns nothing, say so. Do not present an empty result as if it were data.
+
+Changing things:
+- 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.
+- 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.
+- Propose one coherent change at a time. Do not bundle unrelated edits into a single step.
+- If an approval is denied, do not retry the same call. Acknowledge it and stop.
+
+How to answer:
+- Be brief. These answers appear in a command palette, not a chat window.
+- Lead with the answer. No preamble, no restating the question.
+- When you list entries, give the few fields that matter, not every field you received.
+- State counts precisely ("3 products are on sale"), never vaguely.`;
+export { SYSTEM_PROMPT };
+
+//# sourceMappingURL=systemPrompt.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AdminAssistant/systemPrompt.js","sources":["../../../../src/api/features/AdminAssistant/systemPrompt.ts"],"sourcesContent":["/**\n * The assistant is deliberately told to DISCOVER rather than guess. Model IDs and field IDs are\n * project-specific — there is no way to know them from training data — so every concrete answer has to\n * come from a tool call. Without this instruction models happily invent a plausible `modelId` and then\n * report the resulting error as if the content did not exist.\n */\nexport const SYSTEM_PROMPT = `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 — 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 — 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.`;\n"],"names":["SYSTEM_PROMPT"],"mappings":"AAMO,MAAMA,gBAAgB,CAAC;;;;;;;;;;;;;;;;;;;;mEAoBqC,CAAC"}

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

@@ -0,0 +1,11 @@
+import { FileAfterCreateEventHandler } from "@webiny/api-file-manager/features/file/CreateFile/events.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+declare class AiImageEnrichmentAfterCreateHandlerImpl implements FileAfterCreateEventHandler.Interface {
+    private taskService;
+    constructor(taskService: TaskService.Interface);
+    handle(event: FileAfterCreateEventHandler.Event): Promise<void>;
+}
+export declare const AiImageEnrichmentAfterCreateHandler: typeof AiImageEnrichmentAfterCreateHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<import("@webiny/api-file-manager/features/file/CreateFile/events.js").FileAfterCreateEvent>>;
+};
+export {};

package/api/features/AiImageEnrichment/AiImageEnrichmentAfterCreateHandler.js

@@ -0,0 +1,27 @@
+import { FileAfterCreateEventHandler } from "@webiny/api-file-manager/features/file/CreateFile/events.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { AI_IMAGE_ENRICHMENT_TASK_ID } from "./AiImageEnrichmentTask.js";
+class AiImageEnrichmentAfterCreateHandlerImpl {
+    constructor(taskService){
+        this.taskService = taskService;
+    }
+    async handle(event) {
+        const { file } = event.payload;
+        if (!file.type.startsWith("image/")) return;
+        await this.taskService.trigger({
+            definition: AI_IMAGE_ENRICHMENT_TASK_ID,
+            input: {
+                fileId: file.id
+            }
+        });
+    }
+}
+const AiImageEnrichmentAfterCreateHandler = FileAfterCreateEventHandler.createImplementation({
+    implementation: AiImageEnrichmentAfterCreateHandlerImpl,
+    dependencies: [
+        TaskService
+    ]
+});
+export { AiImageEnrichmentAfterCreateHandler };
+
+//# sourceMappingURL=AiImageEnrichmentAfterCreateHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AiImageEnrichment/AiImageEnrichmentAfterCreateHandler.js","sources":["../../../../src/api/features/AiImageEnrichment/AiImageEnrichmentAfterCreateHandler.ts"],"sourcesContent":["import { FileAfterCreateEventHandler } from \"@webiny/api-file-manager/features/file/CreateFile/events.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport type { IAiImageEnrichmentTaskInput } from \"./AiImageEnrichmentTask.js\";\nimport { AI_IMAGE_ENRICHMENT_TASK_ID } from \"./AiImageEnrichmentTask.js\";\n\nclass AiImageEnrichmentAfterCreateHandlerImpl implements FileAfterCreateEventHandler.Interface {\n    constructor(private taskService: TaskService.Interface) {}\n\n    async handle(event: FileAfterCreateEventHandler.Event): Promise<void> {\n        const { file } = event.payload;\n\n        if (!file.type.startsWith(\"image/\")) {\n            return;\n        }\n\n        await this.taskService.trigger<IAiImageEnrichmentTaskInput>({\n            definition: AI_IMAGE_ENRICHMENT_TASK_ID,\n            input: {\n                fileId: file.id\n            }\n        });\n    }\n}\n\nexport const AiImageEnrichmentAfterCreateHandler = FileAfterCreateEventHandler.createImplementation(\n    {\n        implementation: AiImageEnrichmentAfterCreateHandlerImpl,\n        dependencies: [TaskService]\n    }\n);\n"],"names":["AiImageEnrichmentAfterCreateHandlerImpl","taskService","event","file","AI_IMAGE_ENRICHMENT_TASK_ID","AiImageEnrichmentAfterCreateHandler","FileAfterCreateEventHandler","TaskService"],"mappings":";;;AAKA,MAAMA;IACF,YAAoBC,WAAkC,CAAE;aAApCA,WAAW,GAAXA;IAAqC;IAEzD,MAAM,OAAOC,KAAwC,EAAiB;QAClE,MAAM,EAAEC,IAAI,EAAE,GAAGD,MAAM,OAAO;QAE9B,IAAI,CAACC,KAAK,IAAI,CAAC,UAAU,CAAC,WACtB;QAGJ,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAA8B;YACxD,YAAYC;YACZ,OAAO;gBACH,QAAQD,KAAK,EAAE;YACnB;QACJ;IACJ;AACJ;AAEO,MAAME,sCAAsCC,4BAA4B,oBAAoB,CAC/F;IACI,gBAAgBN;IAChB,cAAc;QAACO;KAAY;AAC/B"}

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

@@ -0,0 +1,36 @@
+import { HttpRouteDefinition, HttpRouteHandler } from "@webiny/event-handler-core";
+import type { IHttpRequest, IHttpResponseBuilder } from "@webiny/event-handler-core";
+import { Ai } from "@webiny/api-core/features/ai/index.js";
+import { PrepareImageEnrichmentUseCase } from "./abstractions.js";
+/**
+ * Re-runs AI enrichment for a single file, streaming the model's output to the caller as
+ * server-sent events. Read-only: the result is a proposal the caller can accept or discard.
+ *
+ * Preparation (file lookup, image read, provider resolution) happens BEFORE the response opens, so
+ * anything knowable up front — missing file, wrong type, no provider — comes back as a real status
+ * code. Only the AI call itself streams; once the first byte is out the status is committed to 200
+ * and failures can only be reported as an `error` event.
+ */
+declare class AiImageEnrichmentStreamRouteImpl implements HttpRouteHandler.Interface {
+    private prepare;
+    private ai;
+    constructor(prepare: PrepareImageEnrichmentUseCase.Interface, ai: Ai.Interface);
+    handle(request: IHttpRequest, response: IHttpResponseBuilder): Promise<IHttpResponseBuilder>;
+    private enrich;
+}
+export declare const AiImageEnrichmentStreamRoute: typeof AiImageEnrichmentStreamRouteImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRoute>;
+};
+declare class AiImageEnrichmentStreamRouteDefinitionImpl implements HttpRouteDefinition.Interface {
+    readonly name = "ai-image-enrichment-stream";
+    readonly method = "POST";
+    readonly path = "/stream/fm/files/:fileId/enrich";
+    readonly handler: typeof AiImageEnrichmentStreamRouteImpl & {
+        __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 AiImageEnrichmentStreamRouteDefinition: typeof AiImageEnrichmentStreamRouteDefinitionImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/event-handler-core").IHttpRouteDefinition>;
+};
+export {};

package/api/features/AiImageEnrichment/AiImageEnrichmentStreamRoute.js

@@ -0,0 +1,92 @@
+import { HttpRouteDefinition, HttpRouteHandler, toSseFrame } from "@webiny/event-handler-core";
+import { Ai } from "@webiny/api-core/features/ai/index.js";
+import { PrepareImageEnrichmentUseCase } from "./abstractions.js";
+import { buildEnrichmentAiRequest } from "./buildEnrichmentAiRequest.js";
+import { readEnrichmentPartial } from "./readEnrichmentPartial.js";
+import { imageEnrichmentErrorStatusCode } from "./imageEnrichmentErrorStatusCode.js";
+class AiImageEnrichmentStreamRouteImpl {
+    constructor(prepare, ai){
+        this.prepare = prepare;
+        this.ai = ai;
+    }
+    async handle(request, response) {
+        const fileId = request.pathParameters.fileId;
+        if (!fileId) return response.status(400).json({
+            message: "Missing file ID."
+        });
+        const preparedResult = await this.prepare.execute(fileId);
+        if (preparedResult.isFail()) {
+            const error = preparedResult.error;
+            const statusCode = imageEnrichmentErrorStatusCode(error);
+            return response.status(statusCode).json({
+                message: error.message,
+                code: error.code
+            });
+        }
+        const events = this.enrich(preparedResult.value);
+        return response.sse(events);
+    }
+    async *enrich(prepared) {
+        yield toSseFrame({
+            type: "start",
+            fileId: prepared.fileId,
+            model: prepared.model
+        });
+        let output = {
+            tags: [],
+            description: ""
+        };
+        let failure;
+        try {
+            const request = buildEnrichmentAiRequest(prepared);
+            const stream = await this.ai.streamText({
+                ...request,
+                onError: ({ error })=>{
+                    failure ??= error;
+                }
+            });
+            for await (const partial of stream.partialOutputStream){
+                output = readEnrichmentPartial(partial);
+                yield toSseFrame({
+                    type: "partial",
+                    ...output
+                });
+            }
+            if (void 0 !== failure) throw failure;
+        } catch (error) {
+            yield toSseFrame({
+                type: "error",
+                message: `AI enrichment failed: ${error instanceof Error ? error.message : String(error)}`
+            });
+            return;
+        }
+        yield toSseFrame({
+            type: "done",
+            fileId: prepared.fileId,
+            tags: output.tags,
+            description: output.description
+        });
+    }
+}
+const AiImageEnrichmentStreamRoute = HttpRouteHandler.createImplementation({
+    implementation: AiImageEnrichmentStreamRouteImpl,
+    dependencies: [
+        PrepareImageEnrichmentUseCase,
+        Ai
+    ]
+});
+class AiImageEnrichmentStreamRouteDefinitionImpl {
+    constructor(){
+        this.name = "ai-image-enrichment-stream";
+        this.method = "POST";
+        this.path = "/stream/fm/files/:fileId/enrich";
+        this.handler = AiImageEnrichmentStreamRoute;
+    }
+}
+const AiImageEnrichmentStreamRouteDefinition = HttpRouteDefinition.createImplementation({
+    implementation: AiImageEnrichmentStreamRouteDefinitionImpl,
+    dependencies: []
+});
+export { AiImageEnrichmentStreamRoute, AiImageEnrichmentStreamRouteDefinition };
+
+//# sourceMappingURL=AiImageEnrichmentStreamRoute.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AiImageEnrichment/AiImageEnrichmentStreamRoute.js","sources":["../../../../src/api/features/AiImageEnrichment/AiImageEnrichmentStreamRoute.ts"],"sourcesContent":["import { HttpRouteDefinition, HttpRouteHandler, toSseFrame } from \"@webiny/event-handler-core\";\nimport type { IHttpRequest, IHttpResponseBuilder } from \"@webiny/event-handler-core\";\nimport { Ai } from \"@webiny/api-core/features/ai/index.js\";\nimport { PrepareImageEnrichmentUseCase } from \"./abstractions.js\";\nimport type { IPreparedImageEnrichment } from \"./abstractions.js\";\nimport { buildEnrichmentAiRequest } from \"./buildEnrichmentAiRequest.js\";\nimport { readEnrichmentPartial } from \"./readEnrichmentPartial.js\";\nimport { imageEnrichmentErrorStatusCode } from \"./imageEnrichmentErrorStatusCode.js\";\n\n/**\n * Re-runs AI enrichment for a single file, streaming the model's output to the caller as\n * server-sent events. Read-only: the result is a proposal the caller can accept or discard.\n *\n * Preparation (file lookup, image read, provider resolution) happens BEFORE the response opens, so\n * anything knowable up front — missing file, wrong type, no provider — comes back as a real status\n * code. Only the AI call itself streams; once the first byte is out the status is committed to 200\n * and failures can only be reported as an `error` event.\n */\nclass AiImageEnrichmentStreamRouteImpl implements HttpRouteHandler.Interface {\n    constructor(\n        private prepare: PrepareImageEnrichmentUseCase.Interface,\n        private ai: Ai.Interface\n    ) {}\n\n    async handle(\n        request: IHttpRequest,\n        response: IHttpResponseBuilder\n    ): Promise<IHttpResponseBuilder> {\n        const fileId = request.pathParameters.fileId;\n\n        if (!fileId) {\n            return response.status(400).json({ message: \"Missing file ID.\" });\n        }\n\n        const preparedResult = await this.prepare.execute(fileId);\n\n        if (preparedResult.isFail()) {\n            const error = preparedResult.error;\n\n            const statusCode = imageEnrichmentErrorStatusCode(error);\n\n            return response.status(statusCode).json({ message: error.message, code: error.code });\n        }\n\n        const events = this.enrich(preparedResult.value);\n\n        return response.sse(events);\n    }\n\n    private async *enrich(prepared: IPreparedImageEnrichment): AsyncGenerator<string> {\n        yield toSseFrame({ type: \"start\", fileId: prepared.fileId, model: prepared.model });\n\n        let output = { tags: [] as string[], description: \"\" };\n\n        /*\n         * `streamText` never throws a provider error. It hands it to `onError` and ends the stream,\n         * so without this an overloaded or rejected request drained the loop below with nothing in\n         * it and came back as a `done` with empty tags and description.\n         */\n        let failure: unknown;\n\n        try {\n            const request = buildEnrichmentAiRequest(prepared);\n            const stream = await this.ai.streamText({\n                ...request,\n                onError: ({ error }) => {\n                    failure ??= error;\n                }\n            });\n\n            for await (const partial of stream.partialOutputStream) {\n                output = readEnrichmentPartial(partial);\n                yield toSseFrame({ type: \"partial\", ...output });\n            }\n\n            if (failure !== undefined) {\n                throw failure;\n            }\n        } catch (error) {\n            yield toSseFrame({\n                type: \"error\",\n                message: `AI enrichment failed: ${\n                    error instanceof Error ? error.message : String(error)\n                }`\n            });\n            return;\n        }\n\n        // Nothing is persisted here. The route PROPOSES; the user accepts in the UI, and the save\n        // goes through the file's normal update path. The upload-time task still applies\n        // automatically — there is nobody to ask at that point.\n        yield toSseFrame({\n            type: \"done\",\n            fileId: prepared.fileId,\n            tags: output.tags,\n            description: output.description\n        });\n    }\n}\n\nexport const AiImageEnrichmentStreamRoute = HttpRouteHandler.createImplementation({\n    implementation: AiImageEnrichmentStreamRouteImpl,\n    dependencies: [PrepareImageEnrichmentUseCase, Ai]\n});\n\nclass AiImageEnrichmentStreamRouteDefinitionImpl implements HttpRouteDefinition.Interface {\n    readonly name = \"ai-image-enrichment-stream\";\n    readonly method = \"POST\";\n    readonly path = \"/stream/fm/files/:fileId/enrich\";\n    readonly handler = AiImageEnrichmentStreamRoute;\n}\n\n/** What the router matches on. Zero dependencies, so building it costs nothing. */\nexport const AiImageEnrichmentStreamRouteDefinition = HttpRouteDefinition.createImplementation({\n    implementation: AiImageEnrichmentStreamRouteDefinitionImpl,\n    dependencies: []\n});\n"],"names":["AiImageEnrichmentStreamRouteImpl","prepare","ai","request","response","fileId","preparedResult","error","statusCode","imageEnrichmentErrorStatusCode","events","prepared","toSseFrame","output","failure","buildEnrichmentAiRequest","stream","partial","readEnrichmentPartial","undefined","Error","String","AiImageEnrichmentStreamRoute","HttpRouteHandler","PrepareImageEnrichmentUseCase","Ai","AiImageEnrichmentStreamRouteDefinitionImpl","AiImageEnrichmentStreamRouteDefinition","HttpRouteDefinition"],"mappings":";;;;;;AAkBA,MAAMA;IACF,YACYC,OAAgD,EAChDC,EAAgB,CAC1B;aAFUD,OAAO,GAAPA;aACAC,EAAE,GAAFA;IACT;IAEH,MAAM,OACFC,OAAqB,EACrBC,QAA8B,EACD;QAC7B,MAAMC,SAASF,QAAQ,cAAc,CAAC,MAAM;QAE5C,IAAI,CAACE,QACD,OAAOD,SAAS,MAAM,CAAC,KAAK,IAAI,CAAC;YAAE,SAAS;QAAmB;QAGnE,MAAME,iBAAiB,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAACD;QAElD,IAAIC,eAAe,MAAM,IAAI;YACzB,MAAMC,QAAQD,eAAe,KAAK;YAElC,MAAME,aAAaC,+BAA+BF;YAElD,OAAOH,SAAS,MAAM,CAACI,YAAY,IAAI,CAAC;gBAAE,SAASD,MAAM,OAAO;gBAAE,MAAMA,MAAM,IAAI;YAAC;QACvF;QAEA,MAAMG,SAAS,IAAI,CAAC,MAAM,CAACJ,eAAe,KAAK;QAE/C,OAAOF,SAAS,GAAG,CAACM;IACxB;IAEA,OAAe,OAAOC,QAAkC,EAA0B;QAC9E,MAAMC,WAAW;YAAE,MAAM;YAAS,QAAQD,SAAS,MAAM;YAAE,OAAOA,SAAS,KAAK;QAAC;QAEjF,IAAIE,SAAS;YAAE,MAAM,EAAE;YAAc,aAAa;QAAG;QAOrD,IAAIC;QAEJ,IAAI;YACA,MAAMX,UAAUY,yBAAyBJ;YACzC,MAAMK,SAAS,MAAM,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC;gBACpC,GAAGb,OAAO;gBACV,SAAS,CAAC,EAAEI,KAAK,EAAE;oBACfO,YAAYP;gBAChB;YACJ;YAEA,WAAW,MAAMU,WAAWD,OAAO,mBAAmB,CAAE;gBACpDH,SAASK,sBAAsBD;gBAC/B,MAAML,WAAW;oBAAE,MAAM;oBAAW,GAAGC,MAAM;gBAAC;YAClD;YAEA,IAAIC,AAAYK,WAAZL,SACA,MAAMA;QAEd,EAAE,OAAOP,OAAO;YACZ,MAAMK,WAAW;gBACb,MAAM;gBACN,SAAS,CAAC,sBAAsB,EAC5BL,iBAAiBa,QAAQb,MAAM,OAAO,GAAGc,OAAOd,QAClD;YACN;YACA;QACJ;QAKA,MAAMK,WAAW;YACb,MAAM;YACN,QAAQD,SAAS,MAAM;YACvB,MAAME,OAAO,IAAI;YACjB,aAAaA,OAAO,WAAW;QACnC;IACJ;AACJ;AAEO,MAAMS,+BAA+BC,iBAAiB,oBAAoB,CAAC;IAC9E,gBAAgBvB;IAChB,cAAc;QAACwB;QAA+BC;KAAG;AACrD;AAEA,MAAMC;;aACO,IAAI,GAAG;aACP,MAAM,GAAG;aACT,IAAI,GAAG;aACP,OAAO,GAAGJ;;AACvB;AAGO,MAAMK,yCAAyCC,oBAAoB,oBAAoB,CAAC;IAC3F,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

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

@@ -0,0 +1,41 @@
+import { TaskDefinition, TaskHandler } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { Ai } from "@webiny/api-core/features/ai/index.js";
+import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
+import { WebsocketsSendToIdentityUseCase } from "@webiny/api-websockets/features/SendToIdentity/abstractions.js";
+import { ApplyImageEnrichmentUseCase, PrepareImageEnrichmentUseCase } from "./abstractions.js";
+export declare const AI_IMAGE_ENRICHMENT_TASK_ID = "fmAiImageEnrichment";
+export declare const FILE_ENRICHMENT_FAILED_WEBSOCKET_ACTION = "fm.file.enrichment.failed";
+export interface IAiImageEnrichmentTaskInput {
+    fileId: string;
+}
+/**
+ * Background enrichment, triggered after a file is created. Shares its preparation and persistence
+ * with the streaming HTTP route (`AiImageEnrichmentStreamRoute`); the only difference is that this
+ * one waits for the whole AI response, because a background task has no one to stream to.
+ */
+declare class AiImageEnrichmentTaskHandlerImpl implements TaskHandler.Interface<IAiImageEnrichmentTaskInput> {
+    private prepare;
+    private apply;
+    private ai;
+    private identityContext;
+    private sendToIdentity;
+    constructor(prepare: PrepareImageEnrichmentUseCase.Interface, apply: ApplyImageEnrichmentUseCase.Interface, ai: Ai.Interface, identityContext: IdentityContext.Interface, sendToIdentity: WebsocketsSendToIdentityUseCase.Interface);
+    run({ input, controller }: TaskHandler.RunParams<IAiImageEnrichmentTaskInput>): Promise<TaskDefinition.Result<IAiImageEnrichmentTaskInput>>;
+    private fail;
+}
+declare class AiImageEnrichmentTaskImpl implements TaskDefinition.Interface {
+    id: string;
+    title: string;
+    description: string;
+    maxIterations: number;
+    isPrivate: boolean;
+    databaseLogs: boolean;
+    readonly selfCleanup: ("onAbort" | "onSuccess")[];
+    handler: typeof AiImageEnrichmentTaskHandlerImpl & {
+        __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskHandler<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>>;
+    };
+}
+export declare const AiImageEnrichmentTask: typeof AiImageEnrichmentTaskImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskDefinition<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>>;
+};
+export {};

package/api/features/AiImageEnrichment/AiImageEnrichmentTask.js

@@ -0,0 +1,95 @@
+import { TaskDefinition, TaskHandler } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { Ai } from "@webiny/api-core/features/ai/index.js";
+import { IdentityContext } from "@webiny/api-core/exports/api/security.js";
+import { WebsocketsSendToIdentityUseCase } from "@webiny/api-websockets/features/SendToIdentity/abstractions.js";
+import { ApplyImageEnrichmentUseCase, PrepareImageEnrichmentUseCase } from "./abstractions.js";
+import { buildEnrichmentAiRequest } from "./buildEnrichmentAiRequest.js";
+import { EnrichmentCapabilityDisabledError, EnrichmentNotAnImageError } from "./errors.js";
+const AI_IMAGE_ENRICHMENT_TASK_ID = "fmAiImageEnrichment";
+const FILE_ENRICHMENT_FAILED_WEBSOCKET_ACTION = "fm.file.enrichment.failed";
+class AiImageEnrichmentTaskHandlerImpl {
+    constructor(prepare, apply, ai, identityContext, sendToIdentity){
+        this.prepare = prepare;
+        this.apply = apply;
+        this.ai = ai;
+        this.identityContext = identityContext;
+        this.sendToIdentity = sendToIdentity;
+    }
+    async run({ input, controller }) {
+        if (controller.runtime.isAborted()) return controller.response.aborted();
+        const preparedResult = await this.prepare.execute(input.fileId);
+        if (preparedResult.isFail()) {
+            const error = preparedResult.error;
+            if (error instanceof EnrichmentNotAnImageError || error instanceof EnrichmentCapabilityDisabledError) return controller.response.done(error.message);
+            return this.fail(controller, input.fileId, error.message);
+        }
+        const prepared = preparedResult.value;
+        let tags;
+        let description;
+        try {
+            const request = buildEnrichmentAiRequest(prepared);
+            const aiResult = await this.ai.generateText(request);
+            tags = aiResult.output.tags;
+            description = aiResult.output.description;
+        } catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            return this.fail(controller, input.fileId, `AI enrichment failed: ${reason}`);
+        }
+        const appliedResult = await this.apply.execute({
+            fileId: prepared.fileId,
+            tags,
+            description
+        });
+        if (appliedResult.isFail()) return this.fail(controller, input.fileId, appliedResult.error.message);
+        return controller.response.done("AI image enrichment completed successfully.");
+    }
+    async fail(controller, fileId, message) {
+        const identity = this.identityContext.getIdentity();
+        if (identity?.id) try {
+            await this.sendToIdentity.execute({
+                id: identity.id
+            }, {
+                action: FILE_ENRICHMENT_FAILED_WEBSOCKET_ACTION,
+                data: {
+                    id: fileId,
+                    message
+                }
+            });
+        } catch  {}
+        return controller.response.error({
+            message
+        });
+    }
+}
+const AiImageEnrichmentTaskHandler = TaskHandler.createImplementation({
+    implementation: AiImageEnrichmentTaskHandlerImpl,
+    dependencies: [
+        PrepareImageEnrichmentUseCase,
+        ApplyImageEnrichmentUseCase,
+        Ai,
+        IdentityContext,
+        WebsocketsSendToIdentityUseCase
+    ]
+});
+class AiImageEnrichmentTaskImpl {
+    constructor(){
+        this.id = AI_IMAGE_ENRICHMENT_TASK_ID;
+        this.title = "File Manager - AI Image Enrichment";
+        this.description = "Automatically enriches uploaded images with AI-generated tags and description.";
+        this.maxIterations = 1;
+        this.isPrivate = true;
+        this.databaseLogs = false;
+        this.selfCleanup = [
+            "onSuccess",
+            "onAbort"
+        ];
+        this.handler = AiImageEnrichmentTaskHandler;
+    }
+}
+const AiImageEnrichmentTask = TaskDefinition.createImplementation({
+    implementation: AiImageEnrichmentTaskImpl,
+    dependencies: []
+});
+export { AI_IMAGE_ENRICHMENT_TASK_ID, AiImageEnrichmentTask, FILE_ENRICHMENT_FAILED_WEBSOCKET_ACTION };
+
+//# sourceMappingURL=AiImageEnrichmentTask.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/AiImageEnrichment/AiImageEnrichmentTask.js","sources":["../../../../src/api/features/AiImageEnrichment/AiImageEnrichmentTask.ts"],"sourcesContent":["import {\n    TaskDefinition,\n    TaskHandler\n} from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { Ai } from \"@webiny/api-core/features/ai/index.js\";\nimport { IdentityContext } from \"@webiny/api-core/exports/api/security.js\";\nimport { WebsocketsSendToIdentityUseCase } from \"@webiny/api-websockets/features/SendToIdentity/abstractions.js\";\nimport { ApplyImageEnrichmentUseCase, PrepareImageEnrichmentUseCase } from \"./abstractions.js\";\nimport { buildEnrichmentAiRequest } from \"./buildEnrichmentAiRequest.js\";\nimport { EnrichmentCapabilityDisabledError } from \"./errors.js\";\nimport { EnrichmentNotAnImageError } from \"./errors.js\";\n\nexport const AI_IMAGE_ENRICHMENT_TASK_ID = \"fmAiImageEnrichment\";\n\nexport const FILE_ENRICHMENT_FAILED_WEBSOCKET_ACTION = \"fm.file.enrichment.failed\";\n\nexport interface IAiImageEnrichmentTaskInput {\n    fileId: string;\n}\n\n/**\n * Background enrichment, triggered after a file is created. Shares its preparation and persistence\n * with the streaming HTTP route (`AiImageEnrichmentStreamRoute`); the only difference is that this\n * one waits for the whole AI response, because a background task has no one to stream to.\n */\nclass AiImageEnrichmentTaskHandlerImpl implements TaskHandler.Interface<IAiImageEnrichmentTaskInput> {\n    constructor(\n        private prepare: PrepareImageEnrichmentUseCase.Interface,\n        private apply: ApplyImageEnrichmentUseCase.Interface,\n        private ai: Ai.Interface,\n        private identityContext: IdentityContext.Interface,\n        private sendToIdentity: WebsocketsSendToIdentityUseCase.Interface\n    ) {}\n\n    async run({\n        input,\n        controller\n    }: TaskHandler.RunParams<IAiImageEnrichmentTaskInput>): Promise<\n        TaskDefinition.Result<IAiImageEnrichmentTaskInput>\n    > {\n        if (controller.runtime.isAborted()) {\n            return controller.response.aborted();\n        }\n\n        const preparedResult = await this.prepare.execute(input.fileId);\n        if (preparedResult.isFail()) {\n            const error = preparedResult.error;\n            /*\n             * Neither of these is a failure. A non-image has nothing to enrich, and a switched-off\n             * capability is a setting someone chose. Reporting either as an error would log one on\n             * every upload. A real misconfiguration still falls through to the error below.\n             */\n            if (\n                error instanceof EnrichmentNotAnImageError ||\n                error instanceof EnrichmentCapabilityDisabledError\n            ) {\n                return controller.response.done(error.message);\n            }\n            return this.fail(controller, input.fileId, error.message);\n        }\n\n        const prepared = preparedResult.value;\n\n        let tags: string[];\n        let description: string;\n        try {\n            const request = buildEnrichmentAiRequest(prepared);\n            const aiResult = await this.ai.generateText(request);\n\n            tags = aiResult.output.tags;\n            description = aiResult.output.description;\n        } catch (error) {\n            const reason = error instanceof Error ? error.message : String(error);\n\n            return this.fail(controller, input.fileId, `AI enrichment failed: ${reason}`);\n        }\n\n        const appliedResult = await this.apply.execute({\n            fileId: prepared.fileId,\n            tags,\n            description\n        });\n\n        if (appliedResult.isFail()) {\n            return this.fail(controller, input.fileId, appliedResult.error.message);\n        }\n\n        return controller.response.done(\"AI image enrichment completed successfully.\");\n    }\n\n    /*\n     * Fails the task AND tells the uploader. A failed task on its own only reaches the API log, so\n     * a missing Vision model or an overloaded provider looked, from the File Manager, exactly like\n     * enrichment never having run. Success already reaches the uploader the same way, from\n     * `ApplyImageEnrichmentUseCase`.\n     */\n    private async fail(\n        controller: TaskHandler.RunParams<IAiImageEnrichmentTaskInput>[\"controller\"],\n        fileId: string,\n        message: string\n    ): Promise<TaskDefinition.Result<IAiImageEnrichmentTaskInput>> {\n        const identity = this.identityContext.getIdentity();\n\n        // A notification is a courtesy; failing to send one must not replace the real error.\n        if (identity?.id) {\n            try {\n                await this.sendToIdentity.execute(\n                    { id: identity.id },\n                    {\n                        action: FILE_ENRICHMENT_FAILED_WEBSOCKET_ACTION,\n                        data: { id: fileId, message }\n                    }\n                );\n            } catch {\n                // Deliberately ignored, see above.\n            }\n        }\n\n        return controller.response.error({ message });\n    }\n}\n\nconst AiImageEnrichmentTaskHandler = TaskHandler.createImplementation({\n    implementation: AiImageEnrichmentTaskHandlerImpl,\n    dependencies: [\n        PrepareImageEnrichmentUseCase,\n        ApplyImageEnrichmentUseCase,\n        Ai,\n        IdentityContext,\n        WebsocketsSendToIdentityUseCase\n    ]\n});\n\nclass AiImageEnrichmentTaskImpl implements TaskDefinition.Interface {\n    id = AI_IMAGE_ENRICHMENT_TASK_ID;\n    title = \"File Manager - AI Image Enrichment\";\n    description = \"Automatically enriches uploaded images with AI-generated tags and description.\";\n    maxIterations = 1;\n    isPrivate = true;\n    databaseLogs = false;\n    public readonly selfCleanup = [\"onSuccess\" as const, \"onAbort\" as const];\n\n    handler = AiImageEnrichmentTaskHandler;\n}\n\nexport const AiImageEnrichmentTask = TaskDefinition.createImplementation({\n    implementation: AiImageEnrichmentTaskImpl,\n    dependencies: []\n});\n"],"names":["AI_IMAGE_ENRICHMENT_TASK_ID","FILE_ENRICHMENT_FAILED_WEBSOCKET_ACTION","AiImageEnrichmentTaskHandlerImpl","prepare","apply","ai","identityContext","sendToIdentity","input","controller","preparedResult","error","EnrichmentNotAnImageError","EnrichmentCapabilityDisabledError","prepared","tags","description","request","buildEnrichmentAiRequest","aiResult","reason","Error","String","appliedResult","fileId","message","identity","AiImageEnrichmentTaskHandler","TaskHandler","PrepareImageEnrichmentUseCase","ApplyImageEnrichmentUseCase","Ai","IdentityContext","WebsocketsSendToIdentityUseCase","AiImageEnrichmentTaskImpl","AiImageEnrichmentTask","TaskDefinition"],"mappings":";;;;;;;AAYO,MAAMA,8BAA8B;AAEpC,MAAMC,0CAA0C;AAWvD,MAAMC;IACF,YACYC,OAAgD,EAChDC,KAA4C,EAC5CC,EAAgB,EAChBC,eAA0C,EAC1CC,cAAyD,CACnE;aALUJ,OAAO,GAAPA;aACAC,KAAK,GAALA;aACAC,EAAE,GAAFA;aACAC,eAAe,GAAfA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,IAAI,EACNC,KAAK,EACLC,UAAU,EACuC,EAEnD;QACE,IAAIA,WAAW,OAAO,CAAC,SAAS,IAC5B,OAAOA,WAAW,QAAQ,CAAC,OAAO;QAGtC,MAAMC,iBAAiB,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAACF,MAAM,MAAM;QAC9D,IAAIE,eAAe,MAAM,IAAI;YACzB,MAAMC,QAAQD,eAAe,KAAK;YAMlC,IACIC,iBAAiBC,6BACjBD,iBAAiBE,mCAEjB,OAAOJ,WAAW,QAAQ,CAAC,IAAI,CAACE,MAAM,OAAO;YAEjD,OAAO,IAAI,CAAC,IAAI,CAACF,YAAYD,MAAM,MAAM,EAAEG,MAAM,OAAO;QAC5D;QAEA,MAAMG,WAAWJ,eAAe,KAAK;QAErC,IAAIK;QACJ,IAAIC;QACJ,IAAI;YACA,MAAMC,UAAUC,yBAAyBJ;YACzC,MAAMK,WAAW,MAAM,IAAI,CAAC,EAAE,CAAC,YAAY,CAACF;YAE5CF,OAAOI,SAAS,MAAM,CAAC,IAAI;YAC3BH,cAAcG,SAAS,MAAM,CAAC,WAAW;QAC7C,EAAE,OAAOR,OAAO;YACZ,MAAMS,SAAST,iBAAiBU,QAAQV,MAAM,OAAO,GAAGW,OAAOX;YAE/D,OAAO,IAAI,CAAC,IAAI,CAACF,YAAYD,MAAM,MAAM,EAAE,CAAC,sBAAsB,EAAEY,QAAQ;QAChF;QAEA,MAAMG,gBAAgB,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC;YAC3C,QAAQT,SAAS,MAAM;YACvBC;YACAC;QACJ;QAEA,IAAIO,cAAc,MAAM,IACpB,OAAO,IAAI,CAAC,IAAI,CAACd,YAAYD,MAAM,MAAM,EAAEe,cAAc,KAAK,CAAC,OAAO;QAG1E,OAAOd,WAAW,QAAQ,CAAC,IAAI,CAAC;IACpC;IAQA,MAAc,KACVA,UAA4E,EAC5Ee,MAAc,EACdC,OAAe,EAC4C;QAC3D,MAAMC,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QAGjD,IAAIA,UAAU,IACV,IAAI;YACA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B;gBAAE,IAAIA,SAAS,EAAE;YAAC,GAClB;gBACI,QAAQzB;gBACR,MAAM;oBAAE,IAAIuB;oBAAQC;gBAAQ;YAChC;QAER,EAAE,OAAM,CAER;QAGJ,OAAOhB,WAAW,QAAQ,CAAC,KAAK,CAAC;YAAEgB;QAAQ;IAC/C;AACJ;AAEA,MAAME,+BAA+BC,YAAY,oBAAoB,CAAC;IAClE,gBAAgB1B;IAChB,cAAc;QACV2B;QACAC;QACAC;QACAC;QACAC;KACH;AACL;AAEA,MAAMC;;aACF,EAAE,GAAGlC;aACL,KAAK,GAAG;aACR,WAAW,GAAG;aACd,aAAa,GAAG;aAChB,SAAS,GAAG;aACZ,YAAY,GAAG;aACC,WAAW,GAAG;YAAC;YAAsB;SAAmB;aAExE,OAAO,GAAG2B;;AACd;AAEO,MAAMQ,wBAAwBC,eAAe,oBAAoB,CAAC;IACrE,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

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

@@ -0,0 +1,18 @@
+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 as UseCaseAbstraction, type IApplyImageEnrichmentParams, type IAppliedImageEnrichment } from "./abstractions.js";
+import type { ImageEnrichmentError } from "./errors.js";
+export declare const FILE_ENRICHMENT_WEBSOCKET_ACTION = "fm.file.enrichment";
+declare class ApplyImageEnrichmentUseCaseImpl implements UseCaseAbstraction.Interface {
+    private updateFile;
+    private identityContext;
+    private sendToIdentity;
+    constructor(updateFile: UpdateFileUseCase.Interface, identityContext: IdentityContext.Interface, sendToIdentity: WebsocketsSendToIdentityUseCase.Interface);
+    execute(params: IApplyImageEnrichmentParams): Promise<Result<IAppliedImageEnrichment, ImageEnrichmentError>>;
+}
+export declare const ApplyImageEnrichmentUseCase: typeof ApplyImageEnrichmentUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IApplyImageEnrichmentUseCase>;
+};
+export {};