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

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

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

package/api/features/WbTranslatePage/feature.js

@@ -0,0 +1,20 @@
+import { createFeature } from "@webiny/feature/api";
+import { FeatureFlags } from "@webiny/api-core/features/featureFlags/abstractions.js";
+import { WbTranslatePageDecorator } from "./WbTranslatePageDecorator.js";
+import { WbTranslateLayoutDecorator } from "./WbTranslateLayoutDecorator.js";
+import { LexicalParser } from "./LexicalParser.js";
+import { WbTranslatePageCapability } from "./capability.js";
+const WbTranslatePageFeature = createFeature({
+    name: "AiPowerUps/WbTranslatePage",
+    register (container) {
+        const enabled = container.resolve(FeatureFlags).get().isEnabled("aiPowerups.websiteBuilder.pageTranslation");
+        if (!enabled) return;
+        container.register(WbTranslatePageCapability);
+        container.register(LexicalParser).inSingletonScope();
+        container.registerDecorator(WbTranslatePageDecorator);
+        container.registerDecorator(WbTranslateLayoutDecorator);
+    }
+});
+export { WbTranslatePageFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/WbTranslatePage/feature.js","sources":["../../../../src/api/features/WbTranslatePage/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { FeatureFlags } from \"@webiny/api-core/features/featureFlags/abstractions.js\";\nimport { WbTranslatePageDecorator } from \"./WbTranslatePageDecorator.js\";\nimport { WbTranslateLayoutDecorator } from \"./WbTranslateLayoutDecorator.js\";\nimport { LexicalParser } from \"./LexicalParser.js\";\nimport { WbTranslatePageCapability } from \"./capability.js\";\n\nexport const WbTranslatePageFeature = createFeature({\n    name: \"AiPowerUps/WbTranslatePage\",\n    register(container) {\n        /*\n         * Register-time gate on the effective feature flags (project config && live WCP license),\n         * the same as AiImageEnrichmentFeature. Without it, translating a page still copies it into\n         * the target language, untranslated.\n         */\n        const enabled = container\n            .resolve(FeatureFlags)\n            .get()\n            .isEnabled(\"aiPowerups.websiteBuilder.pageTranslation\");\n\n        if (!enabled) {\n            return;\n        }\n\n        container.register(WbTranslatePageCapability);\n        container.register(LexicalParser).inSingletonScope();\n        container.registerDecorator(WbTranslatePageDecorator);\n        // Layout language versions are translated under the same \"Page translation\" capability.\n        container.registerDecorator(WbTranslateLayoutDecorator);\n    }\n});\n"],"names":["WbTranslatePageFeature","createFeature","container","enabled","FeatureFlags","WbTranslatePageCapability","LexicalParser","WbTranslatePageDecorator","WbTranslateLayoutDecorator"],"mappings":";;;;;;AAOO,MAAMA,yBAAyBC,cAAc;IAChD,MAAM;IACN,UAASC,SAAS;QAMd,MAAMC,UAAUD,UACX,OAAO,CAACE,cACR,GAAG,GACH,SAAS,CAAC;QAEf,IAAI,CAACD,SACD;QAGJD,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI,eAAe,gBAAgB;QAClDJ,UAAU,iBAAiB,CAACK;QAE5BL,UAAU,iBAAiB,CAACM;IAChC;AACJ"}

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

@@ -0,0 +1,2 @@
+export { LexicalParser } from "./abstractions/LexicalParser.js";
+export { WbTranslatePageFeature } from "./feature.js";

package/api/features/WbTranslatePage/index.js

@@ -0,0 +1,2 @@
+export { LexicalParser } from "./abstractions/LexicalParser.js";
+export { WbTranslatePageFeature } from "./feature.js";

package/api/features/WbTranslatePage/translatableBindings.d.ts

@@ -0,0 +1,21 @@
+import type { LexicalParser } from "./abstractions/LexicalParser.js";
+/**
+ * Collecting the text of a document's bindings for the AI, and writing the translated text back.
+ * Shared by page and layout translation. Every binding entry is walked, whatever element it's under:
+ * a document's own elements, and its overrides of elements it doesn't own (globals, layout elements).
+ */
+export type TranslatableInputType = "text" | "longText" | "lexical";
+export interface TranslatableBinding {
+    type: TranslatableInputType;
+    value: string;
+}
+export type TranslatableBindings = Record<string, TranslatableBinding>;
+/**
+ * The text, long text and rich text inputs of the given bindings, by binding key.
+ */
+export declare const extractTranslatableBindings: (bindings: Record<string, any> | null | undefined) => TranslatableBindings;
+/**
+ * A copy of the source bindings with the translated values written in. Inputs the AI left out keep
+ * their source values; keys that don't name an input are ignored.
+ */
+export declare const applyTranslatedBindings: (source: Record<string, any>, translated: Record<string, TranslatableBinding> | null | undefined, lexicalParser: LexicalParser.Interface) => Promise<Record<string, any>>;

package/api/features/WbTranslatePage/translatableBindings.js

@@ -0,0 +1,57 @@
+import set from "lodash/set";
+import { TranslatableBindingKey } from "../../../domain/TranslatableBindingKey.js";
+const extractTranslatableBindings = (bindings)=>{
+    const result = {};
+    for(const elementId in bindings ?? {}){
+        const inputs = bindings[elementId]?.inputs;
+        if (inputs) for(const inputName in inputs){
+            const input = inputs[inputName];
+            const key = TranslatableBindingKey.from(elementId, inputName).toString();
+            if (input && false !== input.translatable) {
+                if ("text" === input.type || "longText" === input.type) {
+                    if ("string" != typeof input.static || !input.static) continue;
+                    result[key] = {
+                        type: input.type,
+                        value: input.static
+                    };
+                } else if ("lexical" === input.type && input.static?.html) result[key] = {
+                    type: input.type,
+                    value: input.static.html
+                };
+            }
+        }
+    }
+    return result;
+};
+const applyTranslatedBindings = async (source, translated, lexicalParser)=>{
+    const bindings = structuredClone(source ?? {});
+    for (const [key, binding] of Object.entries(translated ?? {})){
+        const bindingKey = TranslatableBindingKey.parse(key);
+        if (!bindingKey || !binding || "string" != typeof binding.value) continue;
+        const { elementId, inputName } = bindingKey;
+        if (!bindings[elementId]?.inputs?.[inputName]) continue;
+        const path = [
+            elementId,
+            "inputs",
+            inputName,
+            "static"
+        ];
+        if ("lexical" === binding.type) {
+            const state = await lexicalParser.parse(binding.value);
+            if (state) {
+                set(bindings, [
+                    ...path,
+                    "state"
+                ], JSON.stringify(state));
+                set(bindings, [
+                    ...path,
+                    "html"
+                ], binding.value);
+            }
+        } else set(bindings, path, binding.value);
+    }
+    return bindings;
+};
+export { applyTranslatedBindings, extractTranslatableBindings };
+
+//# sourceMappingURL=translatableBindings.js.map

package/api/features/WbTranslatePage/translatableBindings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/WbTranslatePage/translatableBindings.js","sources":["../../../../src/api/features/WbTranslatePage/translatableBindings.ts"],"sourcesContent":["import set from \"lodash/set\";\nimport type { LexicalParser } from \"./abstractions/LexicalParser.js\";\nimport { TranslatableBindingKey } from \"~/domain/TranslatableBindingKey.js\";\n\n/**\n * Collecting the text of a document's bindings for the AI, and writing the translated text back.\n * Shared by page and layout translation. Every binding entry is walked, whatever element it's under:\n * a document's own elements, and its overrides of elements it doesn't own (globals, layout elements).\n */\n\nexport type TranslatableInputType = \"text\" | \"longText\" | \"lexical\";\n\nexport interface TranslatableBinding {\n    type: TranslatableInputType;\n    value: string;\n}\n\n// Keyed by `TranslatableBindingKey`.\nexport type TranslatableBindings = Record<string, TranslatableBinding>;\n\n/**\n * The text, long text and rich text inputs of the given bindings, by binding key.\n */\nexport const extractTranslatableBindings = (\n    bindings: Record<string, any> | null | undefined\n): TranslatableBindings => {\n    const result: TranslatableBindings = {};\n\n    for (const elementId in bindings ?? {}) {\n        const inputs = bindings![elementId]?.inputs;\n        if (!inputs) {\n            continue;\n        }\n\n        for (const inputName in inputs) {\n            const input = inputs[inputName];\n            const key = TranslatableBindingKey.from(elementId, inputName).toString();\n            // An input marked as not translatable keeps its value in every language (e.g., the name of a\n            // layout's page content area, which pages' content is stored under).\n            if (!input || input.translatable === false) {\n                continue;\n            }\n            if (input.type === \"text\" || input.type === \"longText\") {\n                if (typeof input.static !== \"string\" || !input.static) {\n                    continue;\n                }\n                result[key] = {\n                    type: input.type,\n                    value: input.static\n                };\n            } else if (input.type === \"lexical\" && input.static?.html) {\n                result[key] = {\n                    type: input.type,\n                    value: input.static.html\n                };\n            }\n        }\n    }\n\n    return result;\n};\n\n/**\n * A copy of the source bindings with the translated values written in. Inputs the AI left out keep\n * their source values; keys that don't name an input are ignored.\n */\nexport const applyTranslatedBindings = async (\n    source: Record<string, any>,\n    translated: Record<string, TranslatableBinding> | null | undefined,\n    lexicalParser: LexicalParser.Interface\n): Promise<Record<string, any>> => {\n    const bindings: Record<string, any> = structuredClone(source ?? {});\n\n    for (const [key, binding] of Object.entries(translated ?? {})) {\n        const bindingKey = TranslatableBindingKey.parse(key);\n        if (!bindingKey || !binding || typeof binding.value !== \"string\") {\n            continue;\n        }\n        const { elementId, inputName } = bindingKey;\n        // Only inputs that are in the source: an invented key must not create bindings.\n        if (!bindings[elementId]?.inputs?.[inputName]) {\n            continue;\n        }\n        // An array path, so lodash doesn't read the dots of an element id as nesting.\n        const path = [elementId, \"inputs\", inputName, \"static\"];\n        if (binding.type === \"lexical\") {\n            const state = await lexicalParser.parse(binding.value);\n            if (state) {\n                set(bindings, [...path, \"state\"], JSON.stringify(state));\n                set(bindings, [...path, \"html\"], binding.value);\n            }\n        } else {\n            set(bindings, path, binding.value);\n        }\n    }\n\n    return bindings;\n};\n"],"names":["extractTranslatableBindings","bindings","result","elementId","inputs","inputName","input","key","TranslatableBindingKey","applyTranslatedBindings","source","translated","lexicalParser","structuredClone","binding","Object","bindingKey","path","state","set","JSON"],"mappings":";;AAuBO,MAAMA,8BAA8B,CACvCC;IAEA,MAAMC,SAA+B,CAAC;IAEtC,IAAK,MAAMC,aAAaF,YAAY,CAAC,EAAG;QACpC,MAAMG,SAASH,QAAS,CAACE,UAAU,EAAE;QACrC,IAAKC,QAIL,IAAK,MAAMC,aAAaD,OAAQ;YAC5B,MAAME,QAAQF,MAAM,CAACC,UAAU;YAC/B,MAAME,MAAMC,uBAAuB,IAAI,CAACL,WAAWE,WAAW,QAAQ;YAGtE,IAAI,AAACC,SAASA,AAAuB,UAAvBA,MAAM,YAAY,EAGhC;gBAAA,IAAIA,AAAe,WAAfA,MAAM,IAAI,IAAeA,AAAe,eAAfA,MAAM,IAAI,EAAiB;oBACpD,IAAI,AAAwB,YAAxB,OAAOA,MAAM,MAAM,IAAiB,CAACA,MAAM,MAAM,EACjD;oBAEJJ,MAAM,CAACK,IAAI,GAAG;wBACV,MAAMD,MAAM,IAAI;wBAChB,OAAOA,MAAM,MAAM;oBACvB;gBACJ,OAAO,IAAIA,AAAe,cAAfA,MAAM,IAAI,IAAkBA,MAAM,MAAM,EAAE,MACjDJ,MAAM,CAACK,IAAI,GAAG;oBACV,MAAMD,MAAM,IAAI;oBAChB,OAAOA,MAAM,MAAM,CAAC,IAAI;gBAC5B;YACJ;QACJ;IACJ;IAEA,OAAOJ;AACX;AAMO,MAAMO,0BAA0B,OACnCC,QACAC,YACAC;IAEA,MAAMX,WAAgCY,gBAAgBH,UAAU,CAAC;IAEjE,KAAK,MAAM,CAACH,KAAKO,QAAQ,IAAIC,OAAO,OAAO,CAACJ,cAAc,CAAC,GAAI;QAC3D,MAAMK,aAAaR,uBAAuB,KAAK,CAACD;QAChD,IAAI,CAACS,cAAc,CAACF,WAAW,AAAyB,YAAzB,OAAOA,QAAQ,KAAK,EAC/C;QAEJ,MAAM,EAAEX,SAAS,EAAEE,SAAS,EAAE,GAAGW;QAEjC,IAAI,CAACf,QAAQ,CAACE,UAAU,EAAE,QAAQ,CAACE,UAAU,EACzC;QAGJ,MAAMY,OAAO;YAACd;YAAW;YAAUE;YAAW;SAAS;QACvD,IAAIS,AAAiB,cAAjBA,QAAQ,IAAI,EAAgB;YAC5B,MAAMI,QAAQ,MAAMN,cAAc,KAAK,CAACE,QAAQ,KAAK;YACrD,IAAII,OAAO;gBACPC,IAAIlB,UAAU;uBAAIgB;oBAAM;iBAAQ,EAAEG,KAAK,SAAS,CAACF;gBACjDC,IAAIlB,UAAU;uBAAIgB;oBAAM;iBAAO,EAAEH,QAAQ,KAAK;YAClD;QACJ,OACIK,IAAIlB,UAAUgB,MAAMH,QAAQ,KAAK;IAEzC;IAEA,OAAOb;AACX"}

package/api/features/WbTranslatePage/translatableGlobals.d.ts

@@ -0,0 +1,21 @@
+import type { Logger } from "@webiny/api-core/features/logger/index.js";
+import type { GlobalComponent, SaveGlobalComponentRepository } from "@webiny/api-website-builder/exports/api/website-builder/globals.js";
+import type { LexicalParser } from "./abstractions/LexicalParser.js";
+import { type TranslatableBindings } from "./translatableBindings.js";
+/**
+ * Creating the target-language records of global components while a page or layout is translated.
+ * Shared by page and layout translation. Each global's bindings are sent to the AI grouped by its name,
+ * apart from the document's own bindings (which may override the same global).
+ */
+export type TranslatableGlobals = Record<string, TranslatableBindings>;
+export declare const extractTranslatableGlobals: (globals: GlobalComponent[]) => TranslatableGlobals;
+interface SaveTranslatedGlobalComponentsParams {
+    globals: GlobalComponent[];
+    translated: TranslatableGlobals | null | undefined;
+    language: string;
+    lexicalParser: LexicalParser.Interface;
+    repository: SaveGlobalComponentRepository.Interface;
+    logger: Logger.Interface;
+}
+export declare const saveTranslatedGlobalComponents: (params: SaveTranslatedGlobalComponentsParams) => Promise<void>;
+export {};

package/api/features/WbTranslatePage/translatableGlobals.js

@@ -0,0 +1,29 @@
+import { applyTranslatedBindings, extractTranslatableBindings } from "./translatableBindings.js";
+const extractTranslatableGlobals = (globals)=>{
+    const result = {};
+    for (const globalComponent of globals){
+        const bindings = extractTranslatableBindings(globalComponent.bindings);
+        if (Object.keys(bindings).length) result[globalComponent.name] = bindings;
+    }
+    return result;
+};
+const saveTranslatedGlobalComponents = async (params)=>{
+    const { globals, translated, language, lexicalParser, repository, logger } = params;
+    for (const globalComponent of globals){
+        const bindings = await applyTranslatedBindings(globalComponent.bindings, translated?.[globalComponent.name], lexicalParser);
+        const result = await repository.execute({
+            name: globalComponent.name,
+            language,
+            elements: structuredClone(globalComponent.elements),
+            bindings
+        });
+        if (result.isFail()) logger.warn({
+            reason: result.error.message,
+            name: globalComponent.name,
+            language
+        }, "Could not save an AI translated global component.");
+    }
+};
+export { extractTranslatableGlobals, saveTranslatedGlobalComponents };
+
+//# sourceMappingURL=translatableGlobals.js.map

package/api/features/WbTranslatePage/translatableGlobals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/WbTranslatePage/translatableGlobals.js","sources":["../../../../src/api/features/WbTranslatePage/translatableGlobals.ts"],"sourcesContent":["import type { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport type {\n    GlobalComponent,\n    SaveGlobalComponentRepository\n} from \"@webiny/api-website-builder/exports/api/website-builder/globals.js\";\nimport type { LexicalParser } from \"./abstractions/LexicalParser.js\";\nimport {\n    applyTranslatedBindings,\n    extractTranslatableBindings,\n    type TranslatableBindings\n} from \"./translatableBindings.js\";\n\n/**\n * Creating the target-language records of global components while a page or layout is translated.\n * Shared by page and layout translation. Each global's bindings are sent to the AI grouped by its name,\n * apart from the document's own bindings (which may override the same global).\n */\n\n// The bindings of each global to create in the target language, by global name.\nexport type TranslatableGlobals = Record<string, TranslatableBindings>;\n\nexport const extractTranslatableGlobals = (globals: GlobalComponent[]): TranslatableGlobals => {\n    const result: TranslatableGlobals = {};\n    for (const globalComponent of globals) {\n        const bindings = extractTranslatableBindings(globalComponent.bindings);\n        if (Object.keys(bindings).length) {\n            result[globalComponent.name] = bindings;\n        }\n    }\n    return result;\n};\n\ninterface SaveTranslatedGlobalComponentsParams {\n    globals: GlobalComponent[];\n    translated: TranslatableGlobals | null | undefined;\n    language: string;\n    lexicalParser: LexicalParser.Interface;\n    repository: SaveGlobalComponentRepository.Interface;\n    logger: Logger.Interface;\n}\n\nexport const saveTranslatedGlobalComponents = async (\n    params: SaveTranslatedGlobalComponentsParams\n) => {\n    const { globals, translated, language, lexicalParser, repository, logger } = params;\n\n    for (const globalComponent of globals) {\n        // Inputs the AI left out keep their source values; a global with no text is copied as is.\n        const bindings = await applyTranslatedBindings(\n            globalComponent.bindings,\n            translated?.[globalComponent.name],\n            lexicalParser\n        );\n\n        // Saved through the repository, as the page or layout is: translating takes create\n        // permission, not the edit permission the save use case checks.\n        const result = await repository.execute({\n            name: globalComponent.name,\n            language,\n            elements: structuredClone(globalComponent.elements),\n            bindings\n        });\n\n        if (result.isFail()) {\n            logger.warn(\n                { reason: result.error.message, name: globalComponent.name, language },\n                \"Could not save an AI translated global component.\"\n            );\n        }\n    }\n};\n"],"names":["extractTranslatableGlobals","globals","result","globalComponent","bindings","extractTranslatableBindings","Object","saveTranslatedGlobalComponents","params","translated","language","lexicalParser","repository","logger","applyTranslatedBindings","structuredClone"],"mappings":";AAqBO,MAAMA,6BAA6B,CAACC;IACvC,MAAMC,SAA8B,CAAC;IACrC,KAAK,MAAMC,mBAAmBF,QAAS;QACnC,MAAMG,WAAWC,4BAA4BF,gBAAgB,QAAQ;QACrE,IAAIG,OAAO,IAAI,CAACF,UAAU,MAAM,EAC5BF,MAAM,CAACC,gBAAgB,IAAI,CAAC,GAAGC;IAEvC;IACA,OAAOF;AACX;AAWO,MAAMK,iCAAiC,OAC1CC;IAEA,MAAM,EAAEP,OAAO,EAAEQ,UAAU,EAAEC,QAAQ,EAAEC,aAAa,EAAEC,UAAU,EAAEC,MAAM,EAAE,GAAGL;IAE7E,KAAK,MAAML,mBAAmBF,QAAS;QAEnC,MAAMG,WAAW,MAAMU,wBACnBX,gBAAgB,QAAQ,EACxBM,YAAY,CAACN,gBAAgB,IAAI,CAAC,EAClCQ;QAKJ,MAAMT,SAAS,MAAMU,WAAW,OAAO,CAAC;YACpC,MAAMT,gBAAgB,IAAI;YAC1BO;YACA,UAAUK,gBAAgBZ,gBAAgB,QAAQ;YAClDC;QACJ;QAEA,IAAIF,OAAO,MAAM,IACbW,OAAO,IAAI,CACP;YAAE,QAAQX,OAAO,KAAK,CAAC,OAAO;YAAE,MAAMC,gBAAgB,IAAI;YAAEO;QAAS,GACrE;IAGZ;AACJ"}

package/api/features/WorkflowReview/AiStepRunner/AiStepRunner.d.ts

@@ -0,0 +1,41 @@
+import { Ai } from "@webiny/api-core/features/ai/index.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import type { Actor } from "@webiny/api-workflows/domain/review/types.js";
+import { WorkflowAiToolRegistryService } from "@webiny/api-workflows/features/aiTools/WorkflowAiToolRegistryService/index.js";
+import { ReviewTargetEditorService } from "@webiny/api-workflows/features/review/ReviewTargetEditorService/index.js";
+import { StepRunner } from "@webiny/api-workflows/features/stepRun/StepRunner/index.js";
+import { StepRunStaleCheckService } from "@webiny/api-workflows/features/stepRun/StepRunStaleCheckService/index.js";
+import { ResolveAiCapabilityUseCase } from "../../../../api/features/Capabilities/index.js";
+/**
+ * Runs one `ai` step (R170, R171, R175; spec 7.3): one `generateText` call with the structured
+ * decision output and the step's allowlisted tools, then the outcome the handler applies after
+ * its own re-guard. It never writes: the only writer is the `updateTargetFields` tool, which
+ * re-guards itself (R173). Every failure is a `StepRunFailure` with a fixed text; raw errors are
+ * logged here and never stored or shown to the model (R87).
+ *
+ * The call can run for minutes. A cancel or a restart under another task is noticed through
+ * `StepRunStaleCheckService`, called through one per-run closure before every tool execution and
+ * in a stop condition, at most once per `STEP_RUN_STALE_CHECK_INTERVAL_MS` and sticky once it said
+ * stale, with local state only (the SDK swallows throws from `onStepFinish`, so the flag is read
+ * after the call, before any output). A failed read counts as not stale: the post-run guard
+ * protects the write.
+ */
+declare class AiStepRunnerImpl implements StepRunner.Interface {
+    private resolveCapability;
+    private ai;
+    private editors;
+    private tools;
+    private staleCheck;
+    private logger;
+    readonly type = "ai";
+    readonly singleRun = true;
+    readonly failureReasons: StepRunner.FailureReasons;
+    constructor(resolveCapability: ResolveAiCapabilityUseCase.Interface, ai: Ai.Interface, editors: ReviewTargetEditorService.Interface, tools: WorkflowAiToolRegistryService.Interface, staleCheck: StepRunStaleCheckService.Interface, logger: Logger.Interface);
+    maxIterationsReason(): string;
+    getActor(requester: Actor): Actor;
+    run(params: StepRunner.Params): Promise<StepRunner.Outcome>;
+}
+export declare const AiStepRunner: typeof AiStepRunnerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-workflows/features/stepRun/StepRunner/abstractions.js").IStepRunner>;
+};
+export {};

package/api/features/WorkflowReview/AiStepRunner/AiStepRunner.js

@@ -0,0 +1,253 @@
+import { NoObjectGeneratedError, NoOutputGeneratedError, Output, stepCountIs } from "ai";
+import { Ai } from "@webiny/api-core/features/ai/index.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { getAiActor } from "@webiny/api-workflows/domain/ai/getAiActor.js";
+import { REJECT_COMMENT_MIN_LENGTH } from "@webiny/api-workflows/domain/review/Review.js";
+import { AI_STEP_TYPE } from "@webiny/api-workflows/domain/workflow/stepTypes.js";
+import { AI_STEP_CONTENT_TOO_LARGE_MESSAGE, AI_TOOL_STEP_NOT_RUNNING_MESSAGE } from "@webiny/api-workflows/features/aiTools/constants.js";
+import { WorkflowAiToolRegistryService } from "@webiny/api-workflows/features/aiTools/WorkflowAiToolRegistryService/index.js";
+import { ReviewTargetEditorService } from "@webiny/api-workflows/features/review/ReviewTargetEditorService/index.js";
+import { StepRunFailure } from "@webiny/api-workflows/features/stepRun/StepRunFailure.js";
+import { STEP_RUN_STALE_CHECK_INTERVAL_MS } from "@webiny/api-workflows/features/stepRun/constants.js";
+import { StepRunner } from "@webiny/api-workflows/features/stepRun/StepRunner/index.js";
+import { StepRunStaleCheckService } from "@webiny/api-workflows/features/stepRun/StepRunStaleCheckService/index.js";
+import { AiCapabilityDisabledError, AiModelNotAvailableError, ResolveAiCapabilityUseCase } from "../../Capabilities/index.js";
+import { AI_STEP_MAX_COMMENT_LENGTH, AI_STEP_MAX_ISSUES, AI_STEP_MAX_TOOL_STEPS, WORKFLOWS_REVIEW_CAPABILITY_ID } from "../constants.js";
+import { aiStepConfigSchema } from "../aiStepConfigSchema.js";
+import { toLoggedAiError } from "../toLoggedAiError.js";
+import { buildAiStepPrompt, exceedsAiInputLimit } from "../buildAiStepPrompt.js";
+import { aiReviewOutputSchema, normalizeAiIssues } from "../aiReviewOutputSchema.js";
+import { AI_CAPABILITY_NOT_AVAILABLE_REASON, AI_REVIEW_FAILED_REASON, AI_STEP_INVALID_CONFIGURATION_REASON, aiModelNotAvailableReason, aiToolNotAvailableReason } from "../aiFailureReasons.js";
+import { AI_REVIEW_NO_DECISION_REASON, AI_REVIEW_REJECTED_WITHOUT_COMMENT_REASON, AI_REVIEW_TIMED_OUT_REASON, getAiStepLimitReason } from "./aiRunFailureReasons.js";
+class AiStepRunnerImpl {
+    constructor(resolveCapability, ai, editors, tools, staleCheck, logger){
+        this.resolveCapability = resolveCapability;
+        this.ai = ai;
+        this.editors = editors;
+        this.tools = tools;
+        this.staleCheck = staleCheck;
+        this.logger = logger;
+        this.type = AI_STEP_TYPE;
+        this.singleRun = true;
+        this.failureReasons = {
+            error: AI_REVIEW_FAILED_REASON,
+            aborted: "The AI review was aborted.",
+            stuck: "The AI review task ended without a result."
+        };
+    }
+    maxIterationsReason() {
+        return this.failureReasons.error;
+    }
+    getActor(requester) {
+        return getAiActor(requester);
+    }
+    async run(params) {
+        const { review, step, requester, task, iteration, signal } = params;
+        const logFields = {
+            taskId: task.id,
+            reviewId: review.id,
+            stepId: step.id
+        };
+        try {
+            if (iteration > 1) {
+                this.logger.info({
+                    ...logFields,
+                    iteration
+                }, "Refused to run an AI review task again.");
+                throw new StepRunFailure(this.failureReasons.error);
+            }
+            if (signal.aborted) throw new StepRunFailure(AI_REVIEW_TIMED_OUT_REASON);
+            const config = aiStepConfigSchema.safeParse(step.config);
+            if (!config.success) throw new StepRunFailure(AI_STEP_INVALID_CONFIGURATION_REASON);
+            const allowlisted = [];
+            for (const name of config.data.tools){
+                const registered = this.tools.get(name);
+                if (!registered) throw new StepRunFailure(aiToolNotAvailableReason(name));
+                if (!allowlisted.includes(registered)) allowlisted.push(registered);
+            }
+            const resolved = await this.resolveCapability.execute(WORKFLOWS_REVIEW_CAPABILITY_ID, config.data.model);
+            if (resolved.isFail()) {
+                if (resolved.error instanceof AiModelNotAvailableError) throw new StepRunFailure(aiModelNotAvailableReason(config.data.model));
+                if (!(resolved.error instanceof AiCapabilityDisabledError)) this.logger.error({
+                    error: toLoggedAiError(resolved.error),
+                    ...logFields
+                }, "Could not resolve the AI review capability.");
+                throw new StepRunFailure(AI_CAPABILITY_NOT_AVAILABLE_REASON);
+            }
+            const capability = resolved.value;
+            const content = await this.editors.read({
+                model: review.model,
+                targetId: review.targetId,
+                targetRevisionId: review.targetRevisionId
+            });
+            if (content.isFail()) {
+                this.logger.info({
+                    ...logFields,
+                    reason: content.error.message
+                }, "The AI review could not read the target.");
+                throw new StepRunFailure(this.failureReasons.error);
+            }
+            const previousComments = [];
+            for (const earlier of review.steps){
+                if (earlier.id === step.id) break;
+                const comment = earlier.comment?.trim() ?? "";
+                if (("approved" === earlier.state || "rejected" === earlier.state) && "" !== comment) previousComments.push({
+                    stepTitle: earlier.title,
+                    actor: earlier.owner?.displayName ?? "(no name)",
+                    comment
+                });
+            }
+            const prompt = buildAiStepPrompt({
+                systemGuidance: capability.guidance,
+                additionalInstructions: capability.additionalInstructions,
+                instructions: config.data.instructions,
+                content: content.value,
+                previousComments
+            });
+            if (exceedsAiInputLimit(prompt)) throw new StepRunFailure(AI_STEP_CONTENT_TOO_LARGE_MESSAGE);
+            let stale = false;
+            let lastStaleCheckAt = null;
+            const checkStale = async ()=>{
+                if (stale) return true;
+                if (null !== lastStaleCheckAt && Date.now() - lastStaleCheckAt < STEP_RUN_STALE_CHECK_INTERVAL_MS) return false;
+                lastStaleCheckAt = Date.now();
+                try {
+                    const checked = await this.staleCheck.isStale({
+                        reviewId: review.id,
+                        stepId: step.id,
+                        task
+                    });
+                    if (checked.isOk() && checked.value) stale = true;
+                } catch (error) {
+                    this.logger.error({
+                        error: toLoggedAiError(error),
+                        ...logFields
+                    }, "Could not check whether the AI step is still running.");
+                }
+                return stale;
+            };
+            let toolChain = Promise.resolve();
+            const toolSet = {};
+            for (const workflowTool of allowlisted)toolSet[workflowTool.name] = {
+                description: workflowTool.description,
+                inputSchema: workflowTool.inputSchema,
+                execute: (input)=>{
+                    const turn = toolChain.then(async ()=>{
+                        if (await checkStale()) return {
+                            ok: false,
+                            error: AI_TOOL_STEP_NOT_RUNNING_MESSAGE
+                        };
+                        try {
+                            return await workflowTool.execute(input, {
+                                review,
+                                step,
+                                requester,
+                                task
+                            });
+                        } catch (error) {
+                            this.logger.error({
+                                error: toLoggedAiError(error),
+                                ...logFields,
+                                tool: workflowTool.name
+                            }, "An AI tool threw.");
+                            return {
+                                ok: false,
+                                error: `The tool "${workflowTool.name}" failed.`
+                            };
+                        }
+                    });
+                    toolChain = turn.then(()=>void 0, ()=>void 0);
+                    return turn;
+                }
+            };
+            let result;
+            let callError = null;
+            try {
+                result = await this.ai.generateText({
+                    model: capability.model,
+                    connection: capability.connection,
+                    system: prompt.system,
+                    prompt: prompt.user,
+                    abortSignal: signal,
+                    output: Output.object({
+                        schema: aiReviewOutputSchema,
+                        name: "decision"
+                    }),
+                    ...allowlisted.length > 0 ? {
+                        tools: toolSet,
+                        stopWhen: [
+                            stepCountIs(AI_STEP_MAX_TOOL_STEPS),
+                            checkStale
+                        ]
+                    } : {}
+                });
+            } catch (error) {
+                callError = error;
+            }
+            if (stale) throw new StepRunFailure(this.failureReasons.aborted);
+            if (!result) {
+                if (signal.aborted) throw new StepRunFailure(AI_REVIEW_TIMED_OUT_REASON);
+                if (NoObjectGeneratedError.isInstance(callError) || NoOutputGeneratedError.isInstance(callError)) throw new StepRunFailure(AI_REVIEW_NO_DECISION_REASON);
+                this.logger.error({
+                    error: toLoggedAiError(callError),
+                    ...logFields
+                }, "The AI review call failed.");
+                throw new StepRunFailure(this.failureReasons.error);
+            }
+            let output;
+            try {
+                output = result.output;
+            } catch (error) {
+                if (NoOutputGeneratedError.isInstance(error) || NoObjectGeneratedError.isInstance(error)) {
+                    const last = result.steps[result.steps.length - 1];
+                    const hitStepCap = result.steps.length >= AI_STEP_MAX_TOOL_STEPS && (last?.toolCalls.length ?? 0) > 0;
+                    throw new StepRunFailure(hitStepCap ? getAiStepLimitReason(AI_STEP_MAX_TOOL_STEPS) : AI_REVIEW_NO_DECISION_REASON);
+                }
+                throw error;
+            }
+            const decision = aiReviewOutputSchema.safeParse(output);
+            if (!decision.success) throw new StepRunFailure(AI_REVIEW_NO_DECISION_REASON);
+            if (decision.data.issues.length > AI_STEP_MAX_ISSUES) this.logger.info({
+                ...logFields,
+                count: decision.data.issues.length
+            }, "Dropped the AI issues over the cap.");
+            const issues = normalizeAiIssues(decision.data.issues);
+            const comment = decision.data.comment.trim().slice(0, AI_STEP_MAX_COMMENT_LENGTH).trim();
+            if (decision.data.approved) return "" === comment ? {
+                type: "approved",
+                issues
+            } : {
+                type: "approved",
+                comment,
+                issues
+            };
+            if (comment.length < REJECT_COMMENT_MIN_LENGTH) throw new StepRunFailure(AI_REVIEW_REJECTED_WITHOUT_COMMENT_REASON);
+            return {
+                type: "rejected",
+                comment,
+                issues
+            };
+        } catch (error) {
+            if (error instanceof StepRunFailure) throw error;
+            this.logger.error({
+                error: toLoggedAiError(error),
+                ...logFields
+            }, "The AI review threw.");
+            throw new StepRunFailure(this.failureReasons.error);
+        }
+    }
+}
+const AiStepRunner = StepRunner.createImplementation({
+    implementation: AiStepRunnerImpl,
+    dependencies: [
+        ResolveAiCapabilityUseCase,
+        Ai,
+        ReviewTargetEditorService,
+        WorkflowAiToolRegistryService,
+        StepRunStaleCheckService,
+        Logger
+    ]
+});
+export { AiStepRunner };
+
+//# sourceMappingURL=AiStepRunner.js.map

package/api/features/WorkflowReview/AiStepRunner/AiStepRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/WorkflowReview/AiStepRunner/AiStepRunner.js","sources":["../../../../../src/api/features/WorkflowReview/AiStepRunner/AiStepRunner.ts"],"sourcesContent":["import { NoObjectGeneratedError, NoOutputGeneratedError, Output, stepCountIs } from \"ai\";\nimport type { ToolSet } from \"ai\";\nimport { Ai } from \"@webiny/api-core/features/ai/index.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { getAiActor } from \"@webiny/api-workflows/domain/ai/getAiActor.js\";\nimport { REJECT_COMMENT_MIN_LENGTH } from \"@webiny/api-workflows/domain/review/Review.js\";\nimport type { Actor } from \"@webiny/api-workflows/domain/review/types.js\";\nimport { AI_STEP_TYPE } from \"@webiny/api-workflows/domain/workflow/stepTypes.js\";\nimport {\n    AI_STEP_CONTENT_TOO_LARGE_MESSAGE,\n    AI_TOOL_STEP_NOT_RUNNING_MESSAGE\n} from \"@webiny/api-workflows/features/aiTools/constants.js\";\nimport type { WorkflowAiTool } from \"@webiny/api-workflows/features/aiTools/WorkflowAiTool/index.js\";\nimport { WorkflowAiToolRegistryService } from \"@webiny/api-workflows/features/aiTools/WorkflowAiToolRegistryService/index.js\";\nimport { ReviewTargetEditorService } from \"@webiny/api-workflows/features/review/ReviewTargetEditorService/index.js\";\nimport { StepRunFailure } from \"@webiny/api-workflows/features/stepRun/StepRunFailure.js\";\nimport { STEP_RUN_STALE_CHECK_INTERVAL_MS } from \"@webiny/api-workflows/features/stepRun/constants.js\";\nimport { StepRunner } from \"@webiny/api-workflows/features/stepRun/StepRunner/index.js\";\nimport { StepRunStaleCheckService } from \"@webiny/api-workflows/features/stepRun/StepRunStaleCheckService/index.js\";\nimport {\n    AiCapabilityDisabledError,\n    AiModelNotAvailableError,\n    ResolveAiCapabilityUseCase\n} from \"~/api/features/Capabilities/index.js\";\nimport {\n    AI_STEP_MAX_COMMENT_LENGTH,\n    AI_STEP_MAX_ISSUES,\n    AI_STEP_MAX_TOOL_STEPS,\n    WORKFLOWS_REVIEW_CAPABILITY_ID\n} from \"../constants.js\";\nimport { aiStepConfigSchema } from \"../aiStepConfigSchema.js\";\nimport { toLoggedAiError } from \"../toLoggedAiError.js\";\nimport { buildAiStepPrompt, exceedsAiInputLimit } from \"../buildAiStepPrompt.js\";\nimport type { AiStepPreviousComment } from \"../buildAiStepPrompt.js\";\nimport { aiReviewOutputSchema, normalizeAiIssues } from \"../aiReviewOutputSchema.js\";\nimport {\n    AI_CAPABILITY_NOT_AVAILABLE_REASON,\n    AI_REVIEW_FAILED_REASON,\n    AI_STEP_INVALID_CONFIGURATION_REASON,\n    aiModelNotAvailableReason,\n    aiToolNotAvailableReason\n} from \"../aiFailureReasons.js\";\nimport {\n    AI_REVIEW_NO_DECISION_REASON,\n    AI_REVIEW_REJECTED_WITHOUT_COMMENT_REASON,\n    AI_REVIEW_TIMED_OUT_REASON,\n    getAiStepLimitReason\n} from \"./aiRunFailureReasons.js\";\n\n/**\n * Runs one `ai` step (R170, R171, R175; spec 7.3): one `generateText` call with the structured\n * decision output and the step's allowlisted tools, then the outcome the handler applies after\n * its own re-guard. It never writes: the only writer is the `updateTargetFields` tool, which\n * re-guards itself (R173). Every failure is a `StepRunFailure` with a fixed text; raw errors are\n * logged here and never stored or shown to the model (R87).\n *\n * The call can run for minutes. A cancel or a restart under another task is noticed through\n * `StepRunStaleCheckService`, called through one per-run closure before every tool execution and\n * in a stop condition, at most once per `STEP_RUN_STALE_CHECK_INTERVAL_MS` and sticky once it said\n * stale, with local state only (the SDK swallows throws from `onStepFinish`, so the flag is read\n * after the call, before any output). A failed read counts as not stale: the post-run guard\n * protects the write.\n */\nclass AiStepRunnerImpl implements StepRunner.Interface {\n    public readonly type = AI_STEP_TYPE;\n    public readonly singleRun = true;\n    public readonly failureReasons: StepRunner.FailureReasons = {\n        error: AI_REVIEW_FAILED_REASON,\n        aborted: \"The AI review was aborted.\",\n        stuck: \"The AI review task ended without a result.\"\n    };\n\n    public constructor(\n        private resolveCapability: ResolveAiCapabilityUseCase.Interface,\n        private ai: Ai.Interface,\n        private editors: ReviewTargetEditorService.Interface,\n        private tools: WorkflowAiToolRegistryService.Interface,\n        private staleCheck: StepRunStaleCheckService.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    public maxIterationsReason(): string {\n        // The AI task is one iteration (A56): the ceiling is never reached.\n        return this.failureReasons.error;\n    }\n\n    public getActor(requester: Actor): Actor {\n        return getAiActor(requester);\n    }\n\n    public async run(params: StepRunner.Params): Promise<StepRunner.Outcome> {\n        const { review, step, requester, task, iteration, signal } = params;\n        const logFields = { taskId: task.id, reviewId: review.id, stepId: step.id };\n\n        try {\n            // 1. One iteration only; the handler refuses a re-entered task too (R170).\n            if (iteration > 1) {\n                this.logger.info(\n                    { ...logFields, iteration },\n                    \"Refused to run an AI review task again.\"\n                );\n                throw new StepRunFailure(this.failureReasons.error);\n            }\n\n            // 2. The handler fires the signal at once when the remaining runtime is nearly gone.\n            if (signal.aborted) {\n                throw new StepRunFailure(AI_REVIEW_TIMED_OUT_REASON);\n            }\n\n            // 3. Everything comes from the review snapshot, never from the task input (R148).\n            const config = aiStepConfigSchema.safeParse(step.config);\n            if (!config.success) {\n                throw new StepRunFailure(AI_STEP_INVALID_CONFIGURATION_REASON);\n            }\n\n            // 4. The tool set is the allowlist and nothing else (D55, Review Focus 2).\n            // `Interface` defaults `TInput` to `unknown`, which is what `execute` below passes.\n            const allowlisted: WorkflowAiTool.Interface[] = [];\n            for (const name of config.data.tools) {\n                const registered = this.tools.get(name);\n                if (!registered) {\n                    throw new StepRunFailure(aiToolNotAvailableReason(name));\n                }\n                if (!allowlisted.includes(registered)) {\n                    allowlisted.push(registered);\n                }\n            }\n\n            // 5. The capability and the model the author picked (R169). Logged as in the step\n            // type's `reach`: a model that is not available is an expected typed state and a\n            // disabled capability is a decision (D40), neither is logged; any other failure is\n            // logged once here. The resolver logs nothing itself (an unreadable settings read is\n            // this one log); only a failed read inside `ConfiguredAiModelsService` adds that\n            // service's own log of the raw error, so that case logs twice.\n            const resolved = await this.resolveCapability.execute(\n                WORKFLOWS_REVIEW_CAPABILITY_ID,\n                config.data.model\n            );\n            if (resolved.isFail()) {\n                if (resolved.error instanceof AiModelNotAvailableError) {\n                    throw new StepRunFailure(aiModelNotAvailableReason(config.data.model));\n                }\n                if (!(resolved.error instanceof AiCapabilityDisabledError)) {\n                    this.logger.error(\n                        { error: toLoggedAiError(resolved.error), ...logFields },\n                        \"Could not resolve the AI review capability.\"\n                    );\n                }\n                // A disabled capability, unresolved settings, an unknown capability or a failed\n                // model list read: one fixed text (D40). The raw message never reaches the step.\n                throw new StepRunFailure(AI_CAPABILITY_NOT_AVAILABLE_REASON);\n            }\n            const capability = resolved.value;\n\n            // 6. The target, from the snapshot (adapters log their real errors).\n            const content = await this.editors.read({\n                model: review.model,\n                targetId: review.targetId,\n                targetRevisionId: review.targetRevisionId\n            });\n            if (content.isFail()) {\n                this.logger.info(\n                    { ...logFields, reason: content.error.message },\n                    \"The AI review could not read the target.\"\n                );\n                throw new StepRunFailure(this.failureReasons.error);\n            }\n\n            // 7. The prompt and the input cap: never truncate (R175).\n            const previousComments: AiStepPreviousComment[] = [];\n            for (const earlier of review.steps) {\n                if (earlier.id === step.id) {\n                    break;\n                }\n                const comment = earlier.comment?.trim() ?? \"\";\n                if (\n                    (earlier.state === \"approved\" || earlier.state === \"rejected\") &&\n                    comment !== \"\"\n                ) {\n                    previousComments.push({\n                        stepTitle: earlier.title,\n                        actor: earlier.owner?.displayName ?? \"(no name)\",\n                        comment\n                    });\n                }\n            }\n            const prompt = buildAiStepPrompt({\n                systemGuidance: capability.guidance,\n                additionalInstructions: capability.additionalInstructions,\n                instructions: config.data.instructions,\n                content: content.value,\n                previousComments\n            });\n            if (exceedsAiInputLimit(prompt)) {\n                throw new StepRunFailure(AI_STEP_CONTENT_TOO_LARGE_MESSAGE);\n            }\n\n            // 8. The stale state of this call (R175, Review Focus 1): one closure per run holding\n            // the throttle and the sticky flag. Its callers never overlap: tool calls run one at a\n            // time through `toolChain` below, and the SDK evaluates `stopWhen` only after a step's\n            // tool results are in.\n            let stale = false;\n            let lastStaleCheckAt: number | null = null;\n            const checkStale = async (): Promise<boolean> => {\n                if (stale) {\n                    return true;\n                }\n                if (\n                    lastStaleCheckAt !== null &&\n                    Date.now() - lastStaleCheckAt < STEP_RUN_STALE_CHECK_INTERVAL_MS\n                ) {\n                    return false;\n                }\n                lastStaleCheckAt = Date.now();\n                try {\n                    const checked = await this.staleCheck.isStale({\n                        reviewId: review.id,\n                        stepId: step.id,\n                        task\n                    });\n                    // A failed read is not stale: keep going (the service logged it).\n                    if (checked.isOk() && checked.value) {\n                        stale = true;\n                    }\n                } catch (error) {\n                    // The service returns Results; a throw is unexpected. Not stale, logged once\n                    // here, never handed to the AI SDK (R87).\n                    this.logger.error(\n                        { error: toLoggedAiError(error), ...logFields },\n                        \"Could not check whether the AI step is still running.\"\n                    );\n                }\n                return stale;\n            };\n\n            // The AI SDK tool set, one entry per allowlisted tool (the shape `AiSdkTools` builds).\n            // The context comes from the run, never from the model's input (Review Focus 2).\n            let toolChain: Promise<void> = Promise.resolve();\n            const toolSet: ToolSet = {};\n            for (const workflowTool of allowlisted) {\n                toolSet[workflowTool.name] = {\n                    description: workflowTool.description,\n                    inputSchema: workflowTool.inputSchema,\n                    execute: (input: unknown) => {\n                        // The SDK runs the tool calls of one model step in parallel, and a write\n                        // tool reads the entry and writes a merged object: two at once lose one\n                        // write. Each call waits for the previous one of this run. The chain\n                        // never rejects, so one failing call cannot break it for the next.\n                        const turn = toolChain.then(async () => {\n                            if (await checkStale()) {\n                                return { ok: false, error: AI_TOOL_STEP_NOT_RUNNING_MESSAGE };\n                            }\n                            try {\n                                return await workflowTool.execute(input, {\n                                    review,\n                                    step,\n                                    requester,\n                                    task\n                                });\n                            } catch (error) {\n                                // A custom tool threw (R87): the SDK would show its raw message\n                                // to the model.\n                                this.logger.error(\n                                    {\n                                        error: toLoggedAiError(error),\n                                        ...logFields,\n                                        tool: workflowTool.name\n                                    },\n                                    \"An AI tool threw.\"\n                                );\n                                return {\n                                    ok: false,\n                                    error: `The tool \"${workflowTool.name}\" failed.`\n                                };\n                            }\n                        });\n                        toolChain = turn.then(\n                            () => undefined,\n                            () => undefined\n                        );\n                        return turn;\n                    }\n                };\n            }\n\n            // 9. The call.\n            let result: Awaited<ReturnType<Ai.Interface[\"generateText\"]>> | undefined;\n            let callError: unknown = null;\n            try {\n                result = await this.ai.generateText({\n                    model: capability.model,\n                    connection: capability.connection,\n                    system: prompt.system,\n                    prompt: prompt.user,\n                    abortSignal: signal,\n                    output: Output.object({ schema: aiReviewOutputSchema, name: \"decision\" }),\n                    ...(allowlisted.length > 0\n                        ? {\n                              tools: toolSet,\n                              stopWhen: [stepCountIs(AI_STEP_MAX_TOOL_STEPS), checkStale]\n                          }\n                        : {})\n                });\n            } catch (error) {\n                callError = error;\n            }\n\n            // 10. A cancel or restart seen during the call wins over everything the call\n            // produced, and is checked before any output is read: a stopped call has none (R175).\n            if (stale) {\n                throw new StepRunFailure(this.failureReasons.aborted);\n            }\n\n            // 11. A call that threw.\n            if (!result) {\n                if (signal.aborted) {\n                    throw new StepRunFailure(AI_REVIEW_TIMED_OUT_REASON);\n                }\n                if (\n                    NoObjectGeneratedError.isInstance(callError) ||\n                    NoOutputGeneratedError.isInstance(callError)\n                ) {\n                    throw new StepRunFailure(AI_REVIEW_NO_DECISION_REASON);\n                }\n                this.logger.error(\n                    { error: toLoggedAiError(callError), ...logFields },\n                    \"The AI review call failed.\"\n                );\n                throw new StepRunFailure(this.failureReasons.error);\n            }\n\n            // 12. The structured output.\n            let output: unknown;\n            try {\n                output = result.output;\n            } catch (error) {\n                if (\n                    NoOutputGeneratedError.isInstance(error) ||\n                    NoObjectGeneratedError.isInstance(error)\n                ) {\n                    const last = result.steps[result.steps.length - 1];\n                    const hitStepCap =\n                        result.steps.length >= AI_STEP_MAX_TOOL_STEPS &&\n                        (last?.toolCalls.length ?? 0) > 0;\n                    throw new StepRunFailure(\n                        hitStepCap\n                            ? getAiStepLimitReason(AI_STEP_MAX_TOOL_STEPS)\n                            : AI_REVIEW_NO_DECISION_REASON\n                    );\n                }\n                throw error;\n            }\n            const decision = aiReviewOutputSchema.safeParse(output);\n            if (!decision.success) {\n                throw new StepRunFailure(AI_REVIEW_NO_DECISION_REASON);\n            }\n\n            // 13. The outcome (R171, D100). The handler applies it after its own re-guard.\n            if (decision.data.issues.length > AI_STEP_MAX_ISSUES) {\n                this.logger.info(\n                    { ...logFields, count: decision.data.issues.length },\n                    \"Dropped the AI issues over the cap.\"\n                );\n            }\n            const issues = normalizeAiIssues(decision.data.issues);\n            const comment = decision.data.comment\n                .trim()\n                .slice(0, AI_STEP_MAX_COMMENT_LENGTH)\n                .trim();\n            if (decision.data.approved) {\n                return comment === \"\"\n                    ? { type: \"approved\", issues }\n                    : { type: \"approved\", comment, issues };\n            }\n            if (comment.length < REJECT_COMMENT_MIN_LENGTH) {\n                throw new StepRunFailure(AI_REVIEW_REJECTED_WITHOUT_COMMENT_REASON);\n            }\n            return { type: \"rejected\", comment, issues };\n        } catch (error) {\n            if (error instanceof StepRunFailure) {\n                throw error;\n            }\n            // 14. Nothing but a `StepRunFailure` leaves this runner (R87).\n            this.logger.error(\n                { error: toLoggedAiError(error), ...logFields },\n                \"The AI review threw.\"\n            );\n            throw new StepRunFailure(this.failureReasons.error);\n        }\n    }\n}\n\nexport const AiStepRunner = StepRunner.createImplementation({\n    implementation: AiStepRunnerImpl,\n    dependencies: [\n        ResolveAiCapabilityUseCase,\n        Ai,\n        ReviewTargetEditorService,\n        WorkflowAiToolRegistryService,\n        StepRunStaleCheckService,\n        Logger\n    ]\n});\n"],"names":["AiStepRunnerImpl","resolveCapability","ai","editors","tools","staleCheck","logger","AI_STEP_TYPE","AI_REVIEW_FAILED_REASON","requester","getAiActor","params","review","step","task","iteration","signal","logFields","StepRunFailure","AI_REVIEW_TIMED_OUT_REASON","config","aiStepConfigSchema","AI_STEP_INVALID_CONFIGURATION_REASON","allowlisted","name","registered","aiToolNotAvailableReason","resolved","WORKFLOWS_REVIEW_CAPABILITY_ID","AiModelNotAvailableError","aiModelNotAvailableReason","AiCapabilityDisabledError","toLoggedAiError","AI_CAPABILITY_NOT_AVAILABLE_REASON","capability","content","previousComments","earlier","comment","prompt","buildAiStepPrompt","exceedsAiInputLimit","AI_STEP_CONTENT_TOO_LARGE_MESSAGE","stale","lastStaleCheckAt","checkStale","Date","STEP_RUN_STALE_CHECK_INTERVAL_MS","checked","error","toolChain","Promise","toolSet","workflowTool","input","turn","AI_TOOL_STEP_NOT_RUNNING_MESSAGE","undefined","result","callError","Output","aiReviewOutputSchema","stepCountIs","AI_STEP_MAX_TOOL_STEPS","NoObjectGeneratedError","NoOutputGeneratedError","AI_REVIEW_NO_DECISION_REASON","output","last","hitStepCap","getAiStepLimitReason","decision","AI_STEP_MAX_ISSUES","issues","normalizeAiIssues","AI_STEP_MAX_COMMENT_LENGTH","REJECT_COMMENT_MIN_LENGTH","AI_REVIEW_REJECTED_WITHOUT_COMMENT_REASON","AiStepRunner","StepRunner","ResolveAiCapabilityUseCase","Ai","ReviewTargetEditorService","WorkflowAiToolRegistryService","StepRunStaleCheckService","Logger"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA+DA,MAAMA;IASF,YACYC,iBAAuD,EACvDC,EAAgB,EAChBC,OAA4C,EAC5CC,KAA8C,EAC9CC,UAA8C,EAC9CC,MAAwB,CAClC;aANUL,iBAAiB,GAAjBA;aACAC,EAAE,GAAFA;aACAC,OAAO,GAAPA;aACAC,KAAK,GAALA;aACAC,UAAU,GAAVA;aACAC,MAAM,GAANA;aAdI,IAAI,GAAGC;aACP,SAAS,GAAG;aACZ,cAAc,GAA8B;YACxD,OAAOC;YACP,SAAS;YACT,OAAO;QACX;IASG;IAEI,sBAA8B;QAEjC,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK;IACpC;IAEO,SAASC,SAAgB,EAAS;QACrC,OAAOC,WAAWD;IACtB;IAEA,MAAa,IAAIE,MAAyB,EAA+B;QACrE,MAAM,EAAEC,MAAM,EAAEC,IAAI,EAAEJ,SAAS,EAAEK,IAAI,EAAEC,SAAS,EAAEC,MAAM,EAAE,GAAGL;QAC7D,MAAMM,YAAY;YAAE,QAAQH,KAAK,EAAE;YAAE,UAAUF,OAAO,EAAE;YAAE,QAAQC,KAAK,EAAE;QAAC;QAE1E,IAAI;YAEA,IAAIE,YAAY,GAAG;gBACf,IAAI,CAAC,MAAM,CAAC,IAAI,CACZ;oBAAE,GAAGE,SAAS;oBAAEF;gBAAU,GAC1B;gBAEJ,MAAM,IAAIG,eAAe,IAAI,CAAC,cAAc,CAAC,KAAK;YACtD;YAGA,IAAIF,OAAO,OAAO,EACd,MAAM,IAAIE,eAAeC;YAI7B,MAAMC,SAASC,mBAAmB,SAAS,CAACR,KAAK,MAAM;YACvD,IAAI,CAACO,OAAO,OAAO,EACf,MAAM,IAAIF,eAAeI;YAK7B,MAAMC,cAA0C,EAAE;YAClD,KAAK,MAAMC,QAAQJ,OAAO,IAAI,CAAC,KAAK,CAAE;gBAClC,MAAMK,aAAa,IAAI,CAAC,KAAK,CAAC,GAAG,CAACD;gBAClC,IAAI,CAACC,YACD,MAAM,IAAIP,eAAeQ,yBAAyBF;gBAEtD,IAAI,CAACD,YAAY,QAAQ,CAACE,aACtBF,YAAY,IAAI,CAACE;YAEzB;YAQA,MAAME,WAAW,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CACjDC,gCACAR,OAAO,IAAI,CAAC,KAAK;YAErB,IAAIO,SAAS,MAAM,IAAI;gBACnB,IAAIA,SAAS,KAAK,YAAYE,0BAC1B,MAAM,IAAIX,eAAeY,0BAA0BV,OAAO,IAAI,CAAC,KAAK;gBAExE,IAAI,CAAEO,CAAAA,SAAS,KAAK,YAAYI,yBAAwB,GACpD,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;oBAAE,OAAOC,gBAAgBL,SAAS,KAAK;oBAAG,GAAGV,SAAS;gBAAC,GACvD;gBAKR,MAAM,IAAIC,eAAee;YAC7B;YACA,MAAMC,aAAaP,SAAS,KAAK;YAGjC,MAAMQ,UAAU,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;gBACpC,OAAOvB,OAAO,KAAK;gBACnB,UAAUA,OAAO,QAAQ;gBACzB,kBAAkBA,OAAO,gBAAgB;YAC7C;YACA,IAAIuB,QAAQ,MAAM,IAAI;gBAClB,IAAI,CAAC,MAAM,CAAC,IAAI,CACZ;oBAAE,GAAGlB,SAAS;oBAAE,QAAQkB,QAAQ,KAAK,CAAC,OAAO;gBAAC,GAC9C;gBAEJ,MAAM,IAAIjB,eAAe,IAAI,CAAC,cAAc,CAAC,KAAK;YACtD;YAGA,MAAMkB,mBAA4C,EAAE;YACpD,KAAK,MAAMC,WAAWzB,OAAO,KAAK,CAAE;gBAChC,IAAIyB,QAAQ,EAAE,KAAKxB,KAAK,EAAE,EACtB;gBAEJ,MAAMyB,UAAUD,QAAQ,OAAO,EAAE,UAAU;gBAC3C,IACKA,AAAAA,CAAAA,AAAkB,eAAlBA,QAAQ,KAAK,IAAmBA,AAAkB,eAAlBA,QAAQ,KAAK,AAAc,KAC5DC,AAAY,OAAZA,SAEAF,iBAAiB,IAAI,CAAC;oBAClB,WAAWC,QAAQ,KAAK;oBACxB,OAAOA,QAAQ,KAAK,EAAE,eAAe;oBACrCC;gBACJ;YAER;YACA,MAAMC,SAASC,kBAAkB;gBAC7B,gBAAgBN,WAAW,QAAQ;gBACnC,wBAAwBA,WAAW,sBAAsB;gBACzD,cAAcd,OAAO,IAAI,CAAC,YAAY;gBACtC,SAASe,QAAQ,KAAK;gBACtBC;YACJ;YACA,IAAIK,oBAAoBF,SACpB,MAAM,IAAIrB,eAAewB;YAO7B,IAAIC,QAAQ;YACZ,IAAIC,mBAAkC;YACtC,MAAMC,aAAa;gBACf,IAAIF,OACA,OAAO;gBAEX,IACIC,AAAqB,SAArBA,oBACAE,KAAK,GAAG,KAAKF,mBAAmBG,kCAEhC,OAAO;gBAEXH,mBAAmBE,KAAK,GAAG;gBAC3B,IAAI;oBACA,MAAME,UAAU,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;wBAC1C,UAAUpC,OAAO,EAAE;wBACnB,QAAQC,KAAK,EAAE;wBACfC;oBACJ;oBAEA,IAAIkC,QAAQ,IAAI,MAAMA,QAAQ,KAAK,EAC/BL,QAAQ;gBAEhB,EAAE,OAAOM,OAAO;oBAGZ,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;wBAAE,OAAOjB,gBAAgBiB;wBAAQ,GAAGhC,SAAS;oBAAC,GAC9C;gBAER;gBACA,OAAO0B;YACX;YAIA,IAAIO,YAA2BC,QAAQ,OAAO;YAC9C,MAAMC,UAAmB,CAAC;YAC1B,KAAK,MAAMC,gBAAgB9B,YACvB6B,OAAO,CAACC,aAAa,IAAI,CAAC,GAAG;gBACzB,aAAaA,aAAa,WAAW;gBACrC,aAAaA,aAAa,WAAW;gBACrC,SAAS,CAACC;oBAKN,MAAMC,OAAOL,UAAU,IAAI,CAAC;wBACxB,IAAI,MAAML,cACN,OAAO;4BAAE,IAAI;4BAAO,OAAOW;wBAAiC;wBAEhE,IAAI;4BACA,OAAO,MAAMH,aAAa,OAAO,CAACC,OAAO;gCACrC1C;gCACAC;gCACAJ;gCACAK;4BACJ;wBACJ,EAAE,OAAOmC,OAAO;4BAGZ,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gCACI,OAAOjB,gBAAgBiB;gCACvB,GAAGhC,SAAS;gCACZ,MAAMoC,aAAa,IAAI;4BAC3B,GACA;4BAEJ,OAAO;gCACH,IAAI;gCACJ,OAAO,CAAC,UAAU,EAAEA,aAAa,IAAI,CAAC,SAAS,CAAC;4BACpD;wBACJ;oBACJ;oBACAH,YAAYK,KAAK,IAAI,CACjB,IAAME,QACN,IAAMA;oBAEV,OAAOF;gBACX;YACJ;YAIJ,IAAIG;YACJ,IAAIC,YAAqB;YACzB,IAAI;gBACAD,SAAS,MAAM,IAAI,CAAC,EAAE,CAAC,YAAY,CAAC;oBAChC,OAAOxB,WAAW,KAAK;oBACvB,YAAYA,WAAW,UAAU;oBACjC,QAAQK,OAAO,MAAM;oBACrB,QAAQA,OAAO,IAAI;oBACnB,aAAavB;oBACb,QAAQ4C,OAAO,MAAM,CAAC;wBAAE,QAAQC;wBAAsB,MAAM;oBAAW;oBACvE,GAAItC,YAAY,MAAM,GAAG,IACnB;wBACI,OAAO6B;wBACP,UAAU;4BAACU,YAAYC;4BAAyBlB;yBAAW;oBAC/D,IACA,CAAC,CAAC;gBACZ;YACJ,EAAE,OAAOI,OAAO;gBACZU,YAAYV;YAChB;YAIA,IAAIN,OACA,MAAM,IAAIzB,eAAe,IAAI,CAAC,cAAc,CAAC,OAAO;YAIxD,IAAI,CAACwC,QAAQ;gBACT,IAAI1C,OAAO,OAAO,EACd,MAAM,IAAIE,eAAeC;gBAE7B,IACI6C,uBAAuB,UAAU,CAACL,cAClCM,uBAAuB,UAAU,CAACN,YAElC,MAAM,IAAIzC,eAAegD;gBAE7B,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;oBAAE,OAAOlC,gBAAgB2B;oBAAY,GAAG1C,SAAS;gBAAC,GAClD;gBAEJ,MAAM,IAAIC,eAAe,IAAI,CAAC,cAAc,CAAC,KAAK;YACtD;YAGA,IAAIiD;YACJ,IAAI;gBACAA,SAAST,OAAO,MAAM;YAC1B,EAAE,OAAOT,OAAO;gBACZ,IACIgB,uBAAuB,UAAU,CAAChB,UAClCe,uBAAuB,UAAU,CAACf,QACpC;oBACE,MAAMmB,OAAOV,OAAO,KAAK,CAACA,OAAO,KAAK,CAAC,MAAM,GAAG,EAAE;oBAClD,MAAMW,aACFX,OAAO,KAAK,CAAC,MAAM,IAAIK,0BACtBK,AAAAA,CAAAA,MAAM,UAAU,UAAU,KAAK;oBACpC,MAAM,IAAIlD,eACNmD,aACMC,qBAAqBP,0BACrBG;gBAEd;gBACA,MAAMjB;YACV;YACA,MAAMsB,WAAWV,qBAAqB,SAAS,CAACM;YAChD,IAAI,CAACI,SAAS,OAAO,EACjB,MAAM,IAAIrD,eAAegD;YAI7B,IAAIK,SAAS,IAAI,CAAC,MAAM,CAAC,MAAM,GAAGC,oBAC9B,IAAI,CAAC,MAAM,CAAC,IAAI,CACZ;gBAAE,GAAGvD,SAAS;gBAAE,OAAOsD,SAAS,IAAI,CAAC,MAAM,CAAC,MAAM;YAAC,GACnD;YAGR,MAAME,SAASC,kBAAkBH,SAAS,IAAI,CAAC,MAAM;YACrD,MAAMjC,UAAUiC,SAAS,IAAI,CAAC,OAAO,CAChC,IAAI,GACJ,KAAK,CAAC,GAAGI,4BACT,IAAI;YACT,IAAIJ,SAAS,IAAI,CAAC,QAAQ,EACtB,OAAOjC,AAAY,OAAZA,UACD;gBAAE,MAAM;gBAAYmC;YAAO,IAC3B;gBAAE,MAAM;gBAAYnC;gBAASmC;YAAO;YAE9C,IAAInC,QAAQ,MAAM,GAAGsC,2BACjB,MAAM,IAAI1D,eAAe2D;YAE7B,OAAO;gBAAE,MAAM;gBAAYvC;gBAASmC;YAAO;QAC/C,EAAE,OAAOxB,OAAO;YACZ,IAAIA,iBAAiB/B,gBACjB,MAAM+B;YAGV,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBAAE,OAAOjB,gBAAgBiB;gBAAQ,GAAGhC,SAAS;YAAC,GAC9C;YAEJ,MAAM,IAAIC,eAAe,IAAI,CAAC,cAAc,CAAC,KAAK;QACtD;IACJ;AACJ;AAEO,MAAM4D,eAAeC,WAAW,oBAAoB,CAAC;IACxD,gBAAgB/E;IAChB,cAAc;QACVgF;QACAC;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

package/api/features/WorkflowReview/AiStepRunner/aiRunFailureReasons.d.ts

@@ -0,0 +1,4 @@
+export declare const AI_REVIEW_TIMED_OUT_REASON = "The AI review timed out.";
+export declare const AI_REVIEW_NO_DECISION_REASON = "The AI review returned no decision.";
+export declare const AI_REVIEW_REJECTED_WITHOUT_COMMENT_REASON = "The AI review rejected without a comment.";
+export declare const getAiStepLimitReason: (steps: number) => string;

package/api/features/WorkflowReview/AiStepRunner/aiRunFailureReasons.js

@@ -0,0 +1,7 @@
+const AI_REVIEW_TIMED_OUT_REASON = "The AI review timed out.";
+const AI_REVIEW_NO_DECISION_REASON = "The AI review returned no decision.";
+const AI_REVIEW_REJECTED_WITHOUT_COMMENT_REASON = "The AI review rejected without a comment.";
+const getAiStepLimitReason = (steps)=>`The AI review did not finish in ${steps} steps.`;
+export { AI_REVIEW_NO_DECISION_REASON, AI_REVIEW_REJECTED_WITHOUT_COMMENT_REASON, AI_REVIEW_TIMED_OUT_REASON, getAiStepLimitReason };
+
+//# sourceMappingURL=aiRunFailureReasons.js.map

package/api/features/WorkflowReview/AiStepRunner/aiRunFailureReasons.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/WorkflowReview/AiStepRunner/aiRunFailureReasons.js","sources":["../../../../../src/api/features/WorkflowReview/AiStepRunner/aiRunFailureReasons.ts"],"sourcesContent":["export const AI_REVIEW_TIMED_OUT_REASON = \"The AI review timed out.\";\nexport const AI_REVIEW_NO_DECISION_REASON = \"The AI review returned no decision.\";\nexport const AI_REVIEW_REJECTED_WITHOUT_COMMENT_REASON =\n    \"The AI review rejected without a comment.\";\n\nexport const getAiStepLimitReason = (steps: number): string => {\n    return `The AI review did not finish in ${steps} steps.`;\n};\n"],"names":["AI_REVIEW_TIMED_OUT_REASON","AI_REVIEW_NO_DECISION_REASON","AI_REVIEW_REJECTED_WITHOUT_COMMENT_REASON","getAiStepLimitReason","steps"],"mappings":"AAAO,MAAMA,6BAA6B;AACnC,MAAMC,+BAA+B;AACrC,MAAMC,4CACT;AAEG,MAAMC,uBAAuB,CAACC,QAC1B,CAAC,gCAAgC,EAAEA,MAAM,OAAO,CAAC"}

package/api/features/WorkflowReview/AiStepRunner/feature.d.ts

@@ -0,0 +1,5 @@
+/** The `StepRunner` for `ai` steps. Registered by `Extension.ts` inside the combined gate (R177, R178). */
+export declare const AiStepRunnerFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/api/features/WorkflowReview/AiStepRunner/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { AiStepRunner } from "./AiStepRunner.js";
+const AiStepRunnerFeature = createFeature({
+    name: "AiPowerUps/AiStepRunner",
+    register (container) {
+        container.register(AiStepRunner);
+    }
+});
+export { AiStepRunnerFeature };
+
+//# sourceMappingURL=feature.js.map

package/api/features/WorkflowReview/AiStepRunner/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api/features/WorkflowReview/AiStepRunner/feature.js","sources":["../../../../../src/api/features/WorkflowReview/AiStepRunner/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { AiStepRunner } from \"./AiStepRunner.js\";\n\n/** The `StepRunner` for `ai` steps. Registered by `Extension.ts` inside the combined gate (R177, R178). */\nexport const AiStepRunnerFeature = createFeature({\n    name: \"AiPowerUps/AiStepRunner\",\n    register(container) {\n        container.register(AiStepRunner);\n    }\n});\n"],"names":["AiStepRunnerFeature","createFeature","container","AiStepRunner"],"mappings":";;AAIO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}