@webiny/api-workflows 0.0.0-unstable.c27f4d8a31 → 0.0.0-unstable.d0f34a8194

package/domain/workflow/ruleErrorMessages.js

@@ -0,0 +1,16 @@
+const RULE_TARGET_FIELD = "config.assignment.rules.target";
+const RULES_FIELD = "config.assignment.rules";
+const getRuleIdDuplicateMessage = (stepTitle, ruleId)=>{
+    if (null === stepTitle) return `Two routing rules have the same ID "${ruleId}".`;
+    return `Two routing rules in step "${stepTitle}" have the same ID "${ruleId}".`;
+};
+const RULE_TARGET_USER_NOT_MEMBER_MESSAGE = "The target user is not a member of the step's teams.";
+const RULE_TARGET_TEAM_DELETED_MESSAGE = "The team was deleted.";
+const RULE_TARGET_TEAM_OUTSIDE_TEAMS_MESSAGE = "The target team is not one of the step's reviewing teams.";
+const getRuleTargetMissingMessage = (stepTitle)=>{
+    if (null === stepTitle) return "Every routing rule needs a target.";
+    return `Every routing rule in step "${stepTitle}" needs a target.`;
+};
+export { RULES_FIELD, RULE_TARGET_FIELD, RULE_TARGET_TEAM_DELETED_MESSAGE, RULE_TARGET_TEAM_OUTSIDE_TEAMS_MESSAGE, RULE_TARGET_USER_NOT_MEMBER_MESSAGE, getRuleIdDuplicateMessage, getRuleTargetMissingMessage };
+
+//# sourceMappingURL=ruleErrorMessages.js.map

package/domain/workflow/ruleErrorMessages.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/workflow/ruleErrorMessages.js","sources":["../../../src/domain/workflow/ruleErrorMessages.ts"],"sourcesContent":["/**\n * The field of every rule-level failure (R288): the rule is named by `ruleId` in the error data,\n * not by an index, so the editor finds it again after a reorder.\n */\nexport const RULE_TARGET_FIELD = \"config.assignment.rules.target\";\n\n/**\n * The field of a step whose rules share an id. The error names no `ruleId`: the id does not pick\n * out one rule.\n */\nexport const RULES_FIELD = \"config.assignment.rules\";\n\n/**\n * Two rules of a step share an id. Save names the step; the inspector has only the config and no\n * step title, so it passes `null`.\n */\nexport const getRuleIdDuplicateMessage = (stepTitle: string | null, ruleId: string): string => {\n    if (stepTitle === null) {\n        return `Two routing rules have the same ID \"${ruleId}\".`;\n    }\n    return `Two routing rules in step \"${stepTitle}\" have the same ID \"${ruleId}\".`;\n};\n\n/** A user target who is not a member of the step's teams; checked on save (R122, Q51). */\nexport const RULE_TARGET_USER_NOT_MEMBER_MESSAGE =\n    \"The target user is not a member of the step's teams.\";\n\n/** A team target whose team no longer exists; checked on save while teams are on (D174). */\nexport const RULE_TARGET_TEAM_DELETED_MESSAGE = \"The team was deleted.\";\n\n/** A team target outside the step's teams; checked on save and by the inspector (Q52). */\nexport const RULE_TARGET_TEAM_OUTSIDE_TEAMS_MESSAGE =\n    \"The target team is not one of the step's reviewing teams.\";\n\n/**\n * A rule without a target. Save names the step; the inspector has only the config and no step\n * title, so it passes `null`.\n */\nexport const getRuleTargetMissingMessage = (stepTitle: string | null): string => {\n    if (stepTitle === null) {\n        return \"Every routing rule needs a target.\";\n    }\n    return `Every routing rule in step \"${stepTitle}\" needs a target.`;\n};\n"],"names":["RULE_TARGET_FIELD","RULES_FIELD","getRuleIdDuplicateMessage","stepTitle","ruleId","RULE_TARGET_USER_NOT_MEMBER_MESSAGE","RULE_TARGET_TEAM_DELETED_MESSAGE","RULE_TARGET_TEAM_OUTSIDE_TEAMS_MESSAGE","getRuleTargetMissingMessage"],"mappings":"AAIO,MAAMA,oBAAoB;AAM1B,MAAMC,cAAc;AAMpB,MAAMC,4BAA4B,CAACC,WAA0BC;IAChE,IAAID,AAAc,SAAdA,WACA,OAAO,CAAC,oCAAoC,EAAEC,OAAO,EAAE,CAAC;IAE5D,OAAO,CAAC,2BAA2B,EAAED,UAAU,oBAAoB,EAAEC,OAAO,EAAE,CAAC;AACnF;AAGO,MAAMC,sCACT;AAGG,MAAMC,mCAAmC;AAGzC,MAAMC,yCACT;AAMG,MAAMC,8BAA8B,CAACL;IACxC,IAAIA,AAAc,SAAdA,WACA,OAAO;IAEX,OAAO,CAAC,4BAA4B,EAAEA,UAAU,iBAAiB,CAAC;AACtE"}

package/domain/workflow/stepTypes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The step type ids (R131, R164). review and automation are registered by the engine;
+ * ai is registered by ai-powerups (R177).
+ */
+export declare const REVIEW_STEP_TYPE = "review";
+export declare const AUTOMATION_STEP_TYPE = "automation";
+export declare const AI_STEP_TYPE = "ai";

package/domain/workflow/stepTypes.js

@@ -0,0 +1,6 @@
+const REVIEW_STEP_TYPE = "review";
+const AUTOMATION_STEP_TYPE = "automation";
+const AI_STEP_TYPE = "ai";
+export { AI_STEP_TYPE, AUTOMATION_STEP_TYPE, REVIEW_STEP_TYPE };
+
+//# sourceMappingURL=stepTypes.js.map

package/domain/workflow/stepTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/workflow/stepTypes.js","sources":["../../../src/domain/workflow/stepTypes.ts"],"sourcesContent":["/**\n * The step type ids (R131, R164). review and automation are registered by the engine;\n * ai is registered by ai-powerups (R177).\n */\nexport const REVIEW_STEP_TYPE = \"review\";\nexport const AUTOMATION_STEP_TYPE = \"automation\";\nexport const AI_STEP_TYPE = \"ai\";\n"],"names":["REVIEW_STEP_TYPE","AUTOMATION_STEP_TYPE","AI_STEP_TYPE"],"mappings":"AAIO,MAAMA,mBAAmB;AACzB,MAAMC,uBAAuB;AAC7B,MAAMC,eAAe"}

package/domain/workflow/types.d.ts

@@ -0,0 +1,102 @@
+export interface WorkflowStepNotification {
+    /** Notification transport id, e.g. "e-mail" (D44). */
+    id: string;
+}
+export interface WorkflowStep {
+    id: string;
+    title: string;
+    color: string;
+    description?: string;
+    /** Step type id; a registered `StepType` (R131), e.g. "review" or "automation". */
+    type: string;
+    notifications: WorkflowStepNotification[];
+    /** Validated by the step type's schema; for "review" see `ReviewStepConfig`. */
+    config: unknown;
+}
+export interface WorkflowValues {
+    id: string;
+    name: string;
+    /** Namespace ids, e.g. `["cms.article"]`; exactly one in v1 (D15). */
+    models: string[];
+    steps: WorkflowStep[];
+}
+export interface WorkflowIdentity {
+    id: string;
+    displayName: string;
+    type: string;
+}
+export interface Workflow extends WorkflowValues {
+    createdOn: string;
+    savedOn: string;
+    createdBy: WorkflowIdentity;
+    savedBy: WorkflowIdentity;
+}
+export type RoutingStrategy = "none" | "roundRobin" | "leastLoaded";
+export type RoutingRuleTargetType = "user" | "team";
+export interface RoutingRuleFolderCondition {
+    id: string;
+    type: string;
+    includeDescendants: boolean;
+}
+export interface RoutingRuleConditions {
+    requesterUserId?: string;
+    requesterTeamId?: string;
+    folder?: RoutingRuleFolderCondition;
+    modelId?: string;
+}
+export interface RoutingRuleTarget {
+    type: RoutingRuleTargetType;
+    id: string;
+}
+export interface RoutingRule {
+    id: string;
+    conditions: RoutingRuleConditions;
+    target: RoutingRuleTarget;
+}
+export interface ReviewStepAssignmentConfig {
+    strategy: RoutingStrategy;
+    allowManualPick: boolean;
+    /** Ordered; first match wins (spec 6). */
+    rules: RoutingRule[];
+}
+export interface ReviewStepConfig {
+    /** Team ids; at least one. */
+    teams: string[];
+    assignment: ReviewStepAssignmentConfig;
+}
+/** A step without teams (spec 4.1). */
+export interface ReviewStepConfigNoTeamsProblem {
+    type: "noTeams";
+}
+/**
+ * Two rules of a step share an id. Rules are named by id in errors, trace entries, assignment
+ * records and the narrowed team (R288), so ids must be unique within a step.
+ */
+export interface ReviewStepConfigDuplicateRuleIdProblem {
+    type: "duplicateRuleId";
+    ruleId: string;
+}
+/** A rule whose team target is not one of the step's teams (spec 6). */
+export interface ReviewStepConfigTeamTargetProblem {
+    type: "teamTargetOutsideTeams";
+    ruleId: string;
+}
+/** The first problem of a parsed review step config; callers word their own messages. */
+export type ReviewStepConfigProblem = ReviewStepConfigNoTeamsProblem | ReviewStepConfigDuplicateRuleIdProblem | ReviewStepConfigTeamTargetProblem;
+/**
+ * A review that blocks deleting its workflow (D115): the content reference, its title and where
+ * the review stands. The engine lists all of them; the app wrapper keeps the first 5 the caller
+ * can read (D133, R57).
+ */
+export interface WorkflowBlockingReview {
+    reviewId: string;
+    /** Namespace id, e.g. "cms.article" or "wb.page". */
+    model: string;
+    targetId: string;
+    targetRevisionId: string;
+    title: string;
+    /** 1-based position of the current step ("Step n of N"). */
+    stepPosition: number;
+    stepCount: number;
+    stepName: string;
+}

package/domain/workflow/workflow.model.d.ts

@@ -0,0 +1,12 @@
+import { ModelFactory } from "@webiny/api-headless-cms/features/modelBuilder/index.js";
+/**
+ * Private model for workflows (spec 4.1). Validation lives in `WorkflowValidator`; the step
+ * `config` is JSON so new step types need no model change.
+ */
+declare class WorkflowModelImpl implements ModelFactory.Interface {
+    execute(builder: ModelFactory.Builder): Promise<import("@webiny/api-headless-cms/features/modelBuilder/index.js").PrivateModelBuilder[]>;
+}
+export declare const WorkflowModel: typeof WorkflowModelImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms/features/modelBuilder/abstractions").IModelFactory>;
+};
+export {};

package/domain/workflow/workflow.model.js

@@ -0,0 +1,34 @@
+import { ModelFactory } from "@webiny/api-headless-cms/features/modelBuilder/index.js";
+import { WORKFLOW_MODEL_ID } from "../../constants.js";
+class WorkflowModelImpl {
+    async execute(builder) {
+        return [
+            builder.private({
+                modelId: WORKFLOW_MODEL_ID,
+                name: "Workflow",
+                lifecycleEvents: false
+            }).fields((fields)=>({
+                    name: fields.text().label("Name"),
+                    models: fields.text().label("Models").list(),
+                    steps: fields.object().label("Steps").list().fields((stepFields)=>({
+                            id: stepFields.text().label("ID"),
+                            title: stepFields.text().label("Title"),
+                            color: stepFields.text().label("Color"),
+                            description: stepFields.longText().label("Description"),
+                            type: stepFields.text().label("Type"),
+                            notifications: stepFields.object().label("Notifications").list().fields((notificationFields)=>({
+                                    id: notificationFields.text().label("ID")
+                                })),
+                            config: stepFields.json().label("Config")
+                        }))
+                }))
+        ];
+    }
+}
+const WorkflowModel = ModelFactory.createImplementation({
+    implementation: WorkflowModelImpl,
+    dependencies: []
+});
+export { WorkflowModel };
+
+//# sourceMappingURL=workflow.model.js.map

package/domain/workflow/workflow.model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain/workflow/workflow.model.js","sources":["../../../src/domain/workflow/workflow.model.ts"],"sourcesContent":["import { ModelFactory } from \"@webiny/api-headless-cms/features/modelBuilder/index.js\";\nimport { WORKFLOW_MODEL_ID } from \"~/constants.js\";\n\n/**\n * Private model for workflows (spec 4.1). Validation lives in `WorkflowValidator`; the step\n * `config` is JSON so new step types need no model change.\n */\nclass WorkflowModelImpl implements ModelFactory.Interface {\n    public async execute(builder: ModelFactory.Builder) {\n        return [\n            builder\n                .private({\n                    modelId: WORKFLOW_MODEL_ID,\n                    name: \"Workflow\",\n                    lifecycleEvents: false\n                })\n                .fields(fields => ({\n                    name: fields.text().label(\"Name\"),\n                    models: fields.text().label(\"Models\").list(),\n                    steps: fields\n                        .object()\n                        .label(\"Steps\")\n                        .list()\n                        .fields(stepFields => ({\n                            id: stepFields.text().label(\"ID\"),\n                            title: stepFields.text().label(\"Title\"),\n                            color: stepFields.text().label(\"Color\"),\n                            description: stepFields.longText().label(\"Description\"),\n                            type: stepFields.text().label(\"Type\"),\n                            notifications: stepFields\n                                .object()\n                                .label(\"Notifications\")\n                                .list()\n                                .fields(notificationFields => ({\n                                    id: notificationFields.text().label(\"ID\")\n                                })),\n                            config: stepFields.json().label(\"Config\")\n                        }))\n                }))\n        ];\n    }\n}\n\nexport const WorkflowModel = ModelFactory.createImplementation({\n    implementation: WorkflowModelImpl,\n    dependencies: []\n});\n"],"names":["WorkflowModelImpl","builder","WORKFLOW_MODEL_ID","fields","stepFields","notificationFields","WorkflowModel","ModelFactory"],"mappings":";;AAOA,MAAMA;IACF,MAAa,QAAQC,OAA6B,EAAE;QAChD,OAAO;YACHA,QACK,OAAO,CAAC;gBACL,SAASC;gBACT,MAAM;gBACN,iBAAiB;YACrB,GACC,MAAM,CAACC,CAAAA,SAAW;oBACf,MAAMA,OAAO,IAAI,GAAG,KAAK,CAAC;oBAC1B,QAAQA,OAAO,IAAI,GAAG,KAAK,CAAC,UAAU,IAAI;oBAC1C,OAAOA,OACF,MAAM,GACN,KAAK,CAAC,SACN,IAAI,GACJ,MAAM,CAACC,CAAAA,aAAe;4BACnB,IAAIA,WAAW,IAAI,GAAG,KAAK,CAAC;4BAC5B,OAAOA,WAAW,IAAI,GAAG,KAAK,CAAC;4BAC/B,OAAOA,WAAW,IAAI,GAAG,KAAK,CAAC;4BAC/B,aAAaA,WAAW,QAAQ,GAAG,KAAK,CAAC;4BACzC,MAAMA,WAAW,IAAI,GAAG,KAAK,CAAC;4BAC9B,eAAeA,WACV,MAAM,GACN,KAAK,CAAC,iBACN,IAAI,GACJ,MAAM,CAACC,CAAAA,qBAAuB;oCAC3B,IAAIA,mBAAmB,IAAI,GAAG,KAAK,CAAC;gCACxC;4BACJ,QAAQD,WAAW,IAAI,GAAG,KAAK,CAAC;wBACpC;gBACR;SACP;IACL;AACJ;AAEO,MAAME,gBAAgBC,aAAa,oBAAoB,CAAC;IAC3D,gBAAgBP;IAChB,cAAc,EAAE;AACpB"}

package/features/aiTools/BuiltInAiToolsFeature.d.ts

@@ -0,0 +1,5 @@
+/** The two built-in AI tools (R173); a step must allowlist them like any other tool. */
+export declare const BuiltInAiToolsFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/aiTools/BuiltInAiToolsFeature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { ReadTargetTool } from "./ReadTargetTool/ReadTargetTool.js";
+import { UpdateTargetFieldsTool } from "./UpdateTargetFieldsTool/UpdateTargetFieldsTool.js";
+const BuiltInAiToolsFeature = createFeature({
+    name: "Workflows/BuiltInAiTools",
+    register (container) {
+        container.register(ReadTargetTool);
+        container.register(UpdateTargetFieldsTool);
+    }
+});
+export { BuiltInAiToolsFeature };
+
+//# sourceMappingURL=BuiltInAiToolsFeature.js.map

package/features/aiTools/BuiltInAiToolsFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/aiTools/BuiltInAiToolsFeature.js","sources":["../../../src/features/aiTools/BuiltInAiToolsFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ReadTargetTool } from \"./ReadTargetTool/ReadTargetTool.js\";\nimport { UpdateTargetFieldsTool } from \"./UpdateTargetFieldsTool/UpdateTargetFieldsTool.js\";\n\n/** The two built-in AI tools (R173); a step must allowlist them like any other tool. */\nexport const BuiltInAiToolsFeature = createFeature({\n    name: \"Workflows/BuiltInAiTools\",\n    register(container) {\n        container.register(ReadTargetTool);\n        container.register(UpdateTargetFieldsTool);\n    }\n});\n"],"names":["BuiltInAiToolsFeature","createFeature","container","ReadTargetTool","UpdateTargetFieldsTool"],"mappings":";;;AAKO,MAAMA,wBAAwBC,cAAc;IAC/C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;IACvB;AACJ"}

package/features/aiTools/ReadTargetTool/ReadTargetTool.d.ts

@@ -0,0 +1,29 @@
+import zod from "zod";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { ReviewTargetEditorService } from "../../../features/review/ReviewTargetEditorService/index.js";
+import { WorkflowAiTool } from "../../../features/aiTools/WorkflowAiTool/abstractions.js";
+declare const readTargetInputSchema: zod.ZodObject<{}, zod.core.$strip>;
+type ReadTargetInput = zod.infer<typeof readTargetInputSchema>;
+/**
+ * Built-in tool (R173): the content under review, every field with `writable` (R172). It takes no
+ * input: the target comes from the review snapshot in the context, never from the model (Review
+ * Focus 2). Reads only; no stale check and no bypass. It holds no per-call state: the registry
+ * keeps one instance per container.
+ */
+declare class ReadTargetToolImpl implements WorkflowAiTool.Interface<ReadTargetInput> {
+    private editors;
+    private logger;
+    readonly name = "readTarget";
+    readonly title = "Read target";
+    readonly description = "Reads the content under review: its title and every field with its path, label, type, current value and whether it can be written. Takes no input. Call it before updateTargetFields, and use the paths it returns.";
+    readonly label = "Read fields";
+    readonly summary = "Reads every field of the revision under review.";
+    readonly changesContent = false;
+    readonly inputSchema: zod.ZodObject<{}, zod.core.$strip>;
+    constructor(editors: ReviewTargetEditorService.Interface, logger: Logger.Interface);
+    execute(_input: ReadTargetInput, context: WorkflowAiTool.Context): Promise<WorkflowAiTool.Result>;
+}
+export declare const ReadTargetTool: typeof ReadTargetToolImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/features/aiTools/WorkflowAiTool/abstractions.js").IWorkflowAiTool<unknown>>;
+};
+export {};

package/features/aiTools/ReadTargetTool/ReadTargetTool.js

@@ -0,0 +1,61 @@
+import zod from "zod";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { ReviewTargetEditorService } from "../../review/ReviewTargetEditorService/index.js";
+import { WorkflowAiTool } from "../WorkflowAiTool/abstractions.js";
+import { AI_STEP_CONTENT_TOO_LARGE_MESSAGE, AI_STEP_MAX_INPUT_CHARACTERS, READ_TARGET_TOOL_NAME } from "../constants.js";
+const readTargetInputSchema = zod.object({});
+class ReadTargetToolImpl {
+    constructor(editors, logger){
+        this.editors = editors;
+        this.logger = logger;
+        this.name = READ_TARGET_TOOL_NAME;
+        this.title = "Read target";
+        this.description = "Reads the content under review: its title and every field with its path, label, type, current value and whether it can be written. Takes no input. Call it before updateTargetFields, and use the paths it returns.";
+        this.label = "Read fields";
+        this.summary = "Reads every field of the revision under review.";
+        this.changesContent = false;
+        this.inputSchema = readTargetInputSchema;
+    }
+    async execute(_input, context) {
+        try {
+            const result = await this.editors.read({
+                model: context.review.model,
+                targetId: context.review.targetId,
+                targetRevisionId: context.review.targetRevisionId
+            });
+            if (result.isFail()) return {
+                ok: false,
+                error: result.error.message
+            };
+            if (JSON.stringify(result.value).length > AI_STEP_MAX_INPUT_CHARACTERS) return {
+                ok: false,
+                error: AI_STEP_CONTENT_TOO_LARGE_MESSAGE
+            };
+            return {
+                ok: true,
+                data: result.value
+            };
+        } catch (error) {
+            this.logger.error({
+                err: error,
+                reviewId: context.review.id,
+                stepId: context.step.id,
+                taskId: context.task.id
+            }, "The AI tool could not read the target.");
+            return {
+                ok: false,
+                error: "The target could not be read."
+            };
+        }
+    }
+}
+const ReadTargetTool = WorkflowAiTool.createImplementation({
+    implementation: ReadTargetToolImpl,
+    dependencies: [
+        ReviewTargetEditorService,
+        Logger
+    ]
+});
+export { ReadTargetTool };
+
+//# sourceMappingURL=ReadTargetTool.js.map

package/features/aiTools/ReadTargetTool/ReadTargetTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/aiTools/ReadTargetTool/ReadTargetTool.js","sources":["../../../../src/features/aiTools/ReadTargetTool/ReadTargetTool.ts"],"sourcesContent":["import zod from \"zod\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { ReviewTargetEditorService } from \"~/features/review/ReviewTargetEditorService/index.js\";\nimport { WorkflowAiTool } from \"~/features/aiTools/WorkflowAiTool/abstractions.js\";\nimport {\n    AI_STEP_CONTENT_TOO_LARGE_MESSAGE,\n    AI_STEP_MAX_INPUT_CHARACTERS,\n    READ_TARGET_TOOL_NAME\n} from \"~/features/aiTools/constants.js\";\n\nconst readTargetInputSchema = zod.object({});\n\ntype ReadTargetInput = zod.infer<typeof readTargetInputSchema>;\n\n/**\n * Built-in tool (R173): the content under review, every field with `writable` (R172). It takes no\n * input: the target comes from the review snapshot in the context, never from the model (Review\n * Focus 2). Reads only; no stale check and no bypass. It holds no per-call state: the registry\n * keeps one instance per container.\n */\nclass ReadTargetToolImpl implements WorkflowAiTool.Interface<ReadTargetInput> {\n    public readonly name = READ_TARGET_TOOL_NAME;\n    public readonly title = \"Read target\";\n    public readonly description =\n        \"Reads the content under review: its title and every field with its path, label, type, current value and whether it can be written. Takes no input. Call it before updateTargetFields, and use the paths it returns.\";\n    public readonly label = \"Read fields\";\n    public readonly summary = \"Reads every field of the revision under review.\";\n    public readonly changesContent = false;\n    public readonly inputSchema = readTargetInputSchema;\n\n    public constructor(\n        private editors: ReviewTargetEditorService.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    public async execute(\n        _input: ReadTargetInput,\n        context: WorkflowAiTool.Context\n    ): Promise<WorkflowAiTool.Result> {\n        try {\n            const result = await this.editors.read({\n                model: context.review.model,\n                targetId: context.review.targetId,\n                targetRevisionId: context.review.targetRevisionId\n            });\n            if (result.isFail()) {\n                return { ok: false, error: result.error.message };\n            }\n            // Never truncate: the model must not decide on content it did not see (R175).\n            if (JSON.stringify(result.value).length > AI_STEP_MAX_INPUT_CHARACTERS) {\n                return { ok: false, error: AI_STEP_CONTENT_TOO_LARGE_MESSAGE };\n            }\n            return { ok: true, data: result.value };\n        } catch (error) {\n            this.logger.error(\n                {\n                    err: error,\n                    reviewId: context.review.id,\n                    stepId: context.step.id,\n                    taskId: context.task.id\n                },\n                \"The AI tool could not read the target.\"\n            );\n            return { ok: false, error: \"The target could not be read.\" };\n        }\n    }\n}\n\nexport const ReadTargetTool = WorkflowAiTool.createImplementation({\n    implementation: ReadTargetToolImpl,\n    dependencies: [ReviewTargetEditorService, Logger]\n});\n"],"names":["readTargetInputSchema","zod","ReadTargetToolImpl","editors","logger","READ_TARGET_TOOL_NAME","_input","context","result","JSON","AI_STEP_MAX_INPUT_CHARACTERS","AI_STEP_CONTENT_TOO_LARGE_MESSAGE","error","ReadTargetTool","WorkflowAiTool","ReviewTargetEditorService","Logger"],"mappings":";;;;;AAUA,MAAMA,wBAAwBC,IAAI,MAAM,CAAC,CAAC;AAU1C,MAAMC;IAUF,YACYC,OAA4C,EAC5CC,MAAwB,CAClC;aAFUD,OAAO,GAAPA;aACAC,MAAM,GAANA;aAXI,IAAI,GAAGC;aACP,KAAK,GAAG;aACR,WAAW,GACvB;aACY,KAAK,GAAG;aACR,OAAO,GAAG;aACV,cAAc,GAAG;aACjB,WAAW,GAAGL;IAK3B;IAEH,MAAa,QACTM,MAAuB,EACvBC,OAA+B,EACD;QAC9B,IAAI;YACA,MAAMC,SAAS,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;gBACnC,OAAOD,QAAQ,MAAM,CAAC,KAAK;gBAC3B,UAAUA,QAAQ,MAAM,CAAC,QAAQ;gBACjC,kBAAkBA,QAAQ,MAAM,CAAC,gBAAgB;YACrD;YACA,IAAIC,OAAO,MAAM,IACb,OAAO;gBAAE,IAAI;gBAAO,OAAOA,OAAO,KAAK,CAAC,OAAO;YAAC;YAGpD,IAAIC,KAAK,SAAS,CAACD,OAAO,KAAK,EAAE,MAAM,GAAGE,8BACtC,OAAO;gBAAE,IAAI;gBAAO,OAAOC;YAAkC;YAEjE,OAAO;gBAAE,IAAI;gBAAM,MAAMH,OAAO,KAAK;YAAC;QAC1C,EAAE,OAAOI,OAAO;YACZ,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBACI,KAAKA;gBACL,UAAUL,QAAQ,MAAM,CAAC,EAAE;gBAC3B,QAAQA,QAAQ,IAAI,CAAC,EAAE;gBACvB,QAAQA,QAAQ,IAAI,CAAC,EAAE;YAC3B,GACA;YAEJ,OAAO;gBAAE,IAAI;gBAAO,OAAO;YAAgC;QAC/D;IACJ;AACJ;AAEO,MAAMM,iBAAiBC,eAAe,oBAAoB,CAAC;IAC9D,gBAAgBZ;IAChB,cAAc;QAACa;QAA2BC;KAAO;AACrD"}

package/features/aiTools/UpdateTargetFieldsTool/UpdateTargetFieldsTool.d.ts

@@ -0,0 +1,43 @@
+import zod from "zod";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { WorkflowBypassService } from "../../../features/bypass/WorkflowBypassService/index.js";
+import { ReviewTargetEditorService } from "../../../features/review/ReviewTargetEditorService/index.js";
+import { StepRunStaleCheckService } from "../../../features/stepRun/StepRunStaleCheckService/index.js";
+import { WorkflowAiTool } from "../../../features/aiTools/WorkflowAiTool/abstractions.js";
+declare const updateTargetFieldsInputSchema: zod.ZodObject<{
+    fields: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
+}, zod.core.$strip>;
+type UpdateTargetFieldsInput = zod.infer<typeof updateTargetFieldsInputSchema>;
+/**
+ * Built-in tool (R173): the only writer of the content under review. The target comes from the
+ * review snapshot in the context, never from the model (Review Focus 2). Order: re-check that the
+ * step still belongs to this task by re-reading the STORED review (a cancel, a delete or a restart
+ * during the model call, Review Focus 1). The check is fail-closed: when it fails (the stored
+ * review could not be read; the service already logged it) nothing is written. Then write through
+ * the target editor inside the bypass, with the write awaited inside `run` (`AsyncLocalStorage`:
+ * inactive the moment `update` returns or throws, never active for a save outside the tool, Review
+ * Focus 4). Which paths may be written is the adapter's rule (R172); a refusal or a throw is a tool
+ * answer and never fails the step. It holds no per-call state: the registry keeps one instance per
+ * container.
+ */
+declare class UpdateTargetFieldsToolImpl implements WorkflowAiTool.Interface<UpdateTargetFieldsInput> {
+    private editors;
+    private staleCheck;
+    private bypass;
+    private logger;
+    readonly name = "updateTargetFields";
+    readonly title = "Update target fields";
+    readonly description = "Changes fields of the content under review. Send fields as an object: each key is a field path returned by readTarget (only fields marked writable) and each value is the new value. Fields you do not list stay unchanged. The change is saved immediately; if any path is refused nothing is written and you get the reason.";
+    readonly label = "Update fields";
+    readonly summary = "Edits field values in the revision under review.";
+    readonly changesContent = true;
+    readonly inputSchema: zod.ZodObject<{
+        fields: zod.ZodRecord<zod.ZodString, zod.ZodUnknown>;
+    }, zod.core.$strip>;
+    constructor(editors: ReviewTargetEditorService.Interface, staleCheck: StepRunStaleCheckService.Interface, bypass: WorkflowBypassService.Interface, logger: Logger.Interface);
+    execute(input: UpdateTargetFieldsInput, context: WorkflowAiTool.Context): Promise<WorkflowAiTool.Result>;
+}
+export declare const UpdateTargetFieldsTool: typeof UpdateTargetFieldsToolImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/features/aiTools/WorkflowAiTool/abstractions.js").IWorkflowAiTool<unknown>>;
+};
+export {};

package/features/aiTools/UpdateTargetFieldsTool/UpdateTargetFieldsTool.js

@@ -0,0 +1,85 @@
+import zod from "zod";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { WorkflowBypassService } from "../../bypass/WorkflowBypassService/index.js";
+import { ReviewTargetEditorService } from "../../review/ReviewTargetEditorService/index.js";
+import { StepRunStaleCheckService } from "../../stepRun/StepRunStaleCheckService/index.js";
+import { WorkflowAiTool } from "../WorkflowAiTool/abstractions.js";
+import { AI_TOOL_NO_FIELDS_MESSAGE, AI_TOOL_STEP_CHECK_FAILED_MESSAGE, AI_TOOL_STEP_NOT_RUNNING_MESSAGE, UPDATE_TARGET_FIELDS_TOOL_NAME } from "../constants.js";
+const updateTargetFieldsInputSchema = zod.object({
+    fields: zod.record(zod.string(), zod.unknown())
+});
+class UpdateTargetFieldsToolImpl {
+    constructor(editors, staleCheck, bypass, logger){
+        this.editors = editors;
+        this.staleCheck = staleCheck;
+        this.bypass = bypass;
+        this.logger = logger;
+        this.name = UPDATE_TARGET_FIELDS_TOOL_NAME;
+        this.title = "Update target fields";
+        this.description = "Changes fields of the content under review. Send fields as an object: each key is a field path returned by readTarget (only fields marked writable) and each value is the new value. Fields you do not list stay unchanged. The change is saved immediately; if any path is refused nothing is written and you get the reason.";
+        this.label = "Update fields";
+        this.summary = "Edits field values in the revision under review.";
+        this.changesContent = true;
+        this.inputSchema = updateTargetFieldsInputSchema;
+    }
+    async execute(input, context) {
+        if (0 === Object.keys(input.fields).length) return {
+            ok: false,
+            error: AI_TOOL_NO_FIELDS_MESSAGE
+        };
+        try {
+            const stale = await this.staleCheck.isStale({
+                reviewId: context.review.id,
+                stepId: context.step.id,
+                task: context.task
+            });
+            if (stale.isFail()) return {
+                ok: false,
+                error: AI_TOOL_STEP_CHECK_FAILED_MESSAGE
+            };
+            if (stale.value) return {
+                ok: false,
+                error: AI_TOOL_STEP_NOT_RUNNING_MESSAGE
+            };
+            const result = await this.bypass.run(()=>this.editors.update({
+                    model: context.review.model,
+                    targetId: context.review.targetId,
+                    targetRevisionId: context.review.targetRevisionId,
+                    values: input.fields
+                }));
+            if (result.isFail()) return {
+                ok: false,
+                error: result.error.message
+            };
+            return {
+                ok: true,
+                data: {
+                    applied: result.value.applied
+                }
+            };
+        } catch (error) {
+            this.logger.error({
+                err: error,
+                reviewId: context.review.id,
+                stepId: context.step.id,
+                taskId: context.task.id
+            }, "The AI tool could not update the target.");
+            return {
+                ok: false,
+                error: "The target could not be updated."
+            };
+        }
+    }
+}
+const UpdateTargetFieldsTool = WorkflowAiTool.createImplementation({
+    implementation: UpdateTargetFieldsToolImpl,
+    dependencies: [
+        ReviewTargetEditorService,
+        StepRunStaleCheckService,
+        WorkflowBypassService,
+        Logger
+    ]
+});
+export { UpdateTargetFieldsTool };
+
+//# sourceMappingURL=UpdateTargetFieldsTool.js.map

package/features/aiTools/UpdateTargetFieldsTool/UpdateTargetFieldsTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/aiTools/UpdateTargetFieldsTool/UpdateTargetFieldsTool.js","sources":["../../../../src/features/aiTools/UpdateTargetFieldsTool/UpdateTargetFieldsTool.ts"],"sourcesContent":["import zod from \"zod\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { WorkflowBypassService } from \"~/features/bypass/WorkflowBypassService/index.js\";\nimport { ReviewTargetEditorService } from \"~/features/review/ReviewTargetEditorService/index.js\";\nimport { StepRunStaleCheckService } from \"~/features/stepRun/StepRunStaleCheckService/index.js\";\nimport { WorkflowAiTool } from \"~/features/aiTools/WorkflowAiTool/abstractions.js\";\nimport {\n    AI_TOOL_NO_FIELDS_MESSAGE,\n    AI_TOOL_STEP_CHECK_FAILED_MESSAGE,\n    AI_TOOL_STEP_NOT_RUNNING_MESSAGE,\n    UPDATE_TARGET_FIELDS_TOOL_NAME\n} from \"~/features/aiTools/constants.js\";\n\nconst updateTargetFieldsInputSchema = zod.object({\n    fields: zod.record(zod.string(), zod.unknown())\n});\n\ntype UpdateTargetFieldsInput = zod.infer<typeof updateTargetFieldsInputSchema>;\n\n/**\n * Built-in tool (R173): the only writer of the content under review. The target comes from the\n * review snapshot in the context, never from the model (Review Focus 2). Order: re-check that the\n * step still belongs to this task by re-reading the STORED review (a cancel, a delete or a restart\n * during the model call, Review Focus 1). The check is fail-closed: when it fails (the stored\n * review could not be read; the service already logged it) nothing is written. Then write through\n * the target editor inside the bypass, with the write awaited inside `run` (`AsyncLocalStorage`:\n * inactive the moment `update` returns or throws, never active for a save outside the tool, Review\n * Focus 4). Which paths may be written is the adapter's rule (R172); a refusal or a throw is a tool\n * answer and never fails the step. It holds no per-call state: the registry keeps one instance per\n * container.\n */\nclass UpdateTargetFieldsToolImpl implements WorkflowAiTool.Interface<UpdateTargetFieldsInput> {\n    public readonly name = UPDATE_TARGET_FIELDS_TOOL_NAME;\n    public readonly title = \"Update target fields\";\n    public readonly description =\n        \"Changes fields of the content under review. Send fields as an object: each key is a field path returned by readTarget (only fields marked writable) and each value is the new value. Fields you do not list stay unchanged. The change is saved immediately; if any path is refused nothing is written and you get the reason.\";\n    public readonly label = \"Update fields\";\n    public readonly summary = \"Edits field values in the revision under review.\";\n    public readonly changesContent = true;\n    public readonly inputSchema = updateTargetFieldsInputSchema;\n\n    public constructor(\n        private editors: ReviewTargetEditorService.Interface,\n        private staleCheck: StepRunStaleCheckService.Interface,\n        private bypass: WorkflowBypassService.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    public async execute(\n        input: UpdateTargetFieldsInput,\n        context: WorkflowAiTool.Context\n    ): Promise<WorkflowAiTool.Result> {\n        if (Object.keys(input.fields).length === 0) {\n            return { ok: false, error: AI_TOOL_NO_FIELDS_MESSAGE };\n        }\n        try {\n            // Right before the write, outside the bypass. The snapshot in `context.review` is the\n            // review as the run started with it, so the stored one is read (R175).\n            const stale = await this.staleCheck.isStale({\n                reviewId: context.review.id,\n                stepId: context.step.id,\n                task: context.task\n            });\n            if (stale.isFail()) {\n                // The service logged it; refuse instead of writing on an unverified step.\n                return { ok: false, error: AI_TOOL_STEP_CHECK_FAILED_MESSAGE };\n            }\n            if (stale.value) {\n                return { ok: false, error: AI_TOOL_STEP_NOT_RUNNING_MESSAGE };\n            }\n\n            // The write is awaited INSIDE `run`: the scope ends with the callback's promise.\n            const result = await this.bypass.run(() =>\n                this.editors.update({\n                    model: context.review.model,\n                    targetId: context.review.targetId,\n                    targetRevisionId: context.review.targetRevisionId,\n                    values: input.fields\n                })\n            );\n            if (result.isFail()) {\n                return { ok: false, error: result.error.message };\n            }\n            return { ok: true, data: { applied: result.value.applied } };\n        } catch (error) {\n            this.logger.error(\n                {\n                    err: error,\n                    reviewId: context.review.id,\n                    stepId: context.step.id,\n                    taskId: context.task.id\n                },\n                \"The AI tool could not update the target.\"\n            );\n            return { ok: false, error: \"The target could not be updated.\" };\n        }\n    }\n}\n\nexport const UpdateTargetFieldsTool = WorkflowAiTool.createImplementation({\n    implementation: UpdateTargetFieldsToolImpl,\n    dependencies: [\n        ReviewTargetEditorService,\n        StepRunStaleCheckService,\n        WorkflowBypassService,\n        Logger\n    ]\n});\n"],"names":["updateTargetFieldsInputSchema","zod","UpdateTargetFieldsToolImpl","editors","staleCheck","bypass","logger","UPDATE_TARGET_FIELDS_TOOL_NAME","input","context","Object","AI_TOOL_NO_FIELDS_MESSAGE","stale","AI_TOOL_STEP_CHECK_FAILED_MESSAGE","AI_TOOL_STEP_NOT_RUNNING_MESSAGE","result","error","UpdateTargetFieldsTool","WorkflowAiTool","ReviewTargetEditorService","StepRunStaleCheckService","WorkflowBypassService","Logger"],"mappings":";;;;;;;AAaA,MAAMA,gCAAgCC,IAAI,MAAM,CAAC;IAC7C,QAAQA,IAAI,MAAM,CAACA,IAAI,MAAM,IAAIA,IAAI,OAAO;AAChD;AAgBA,MAAMC;IAUF,YACYC,OAA4C,EAC5CC,UAA8C,EAC9CC,MAAuC,EACvCC,MAAwB,CAClC;aAJUH,OAAO,GAAPA;aACAC,UAAU,GAAVA;aACAC,MAAM,GAANA;aACAC,MAAM,GAANA;aAbI,IAAI,GAAGC;aACP,KAAK,GAAG;aACR,WAAW,GACvB;aACY,KAAK,GAAG;aACR,OAAO,GAAG;aACV,cAAc,GAAG;aACjB,WAAW,GAAGP;IAO3B;IAEH,MAAa,QACTQ,KAA8B,EAC9BC,OAA+B,EACD;QAC9B,IAAIC,AAAqC,MAArCA,OAAO,IAAI,CAACF,MAAM,MAAM,EAAE,MAAM,EAChC,OAAO;YAAE,IAAI;YAAO,OAAOG;QAA0B;QAEzD,IAAI;YAGA,MAAMC,QAAQ,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;gBACxC,UAAUH,QAAQ,MAAM,CAAC,EAAE;gBAC3B,QAAQA,QAAQ,IAAI,CAAC,EAAE;gBACvB,MAAMA,QAAQ,IAAI;YACtB;YACA,IAAIG,MAAM,MAAM,IAEZ,OAAO;gBAAE,IAAI;gBAAO,OAAOC;YAAkC;YAEjE,IAAID,MAAM,KAAK,EACX,OAAO;gBAAE,IAAI;gBAAO,OAAOE;YAAiC;YAIhE,MAAMC,SAAS,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IACjC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;oBAChB,OAAON,QAAQ,MAAM,CAAC,KAAK;oBAC3B,UAAUA,QAAQ,MAAM,CAAC,QAAQ;oBACjC,kBAAkBA,QAAQ,MAAM,CAAC,gBAAgB;oBACjD,QAAQD,MAAM,MAAM;gBACxB;YAEJ,IAAIO,OAAO,MAAM,IACb,OAAO;gBAAE,IAAI;gBAAO,OAAOA,OAAO,KAAK,CAAC,OAAO;YAAC;YAEpD,OAAO;gBAAE,IAAI;gBAAM,MAAM;oBAAE,SAASA,OAAO,KAAK,CAAC,OAAO;gBAAC;YAAE;QAC/D,EAAE,OAAOC,OAAO;YACZ,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBACI,KAAKA;gBACL,UAAUP,QAAQ,MAAM,CAAC,EAAE;gBAC3B,QAAQA,QAAQ,IAAI,CAAC,EAAE;gBACvB,QAAQA,QAAQ,IAAI,CAAC,EAAE;YAC3B,GACA;YAEJ,OAAO;gBAAE,IAAI;gBAAO,OAAO;YAAmC;QAClE;IACJ;AACJ;AAEO,MAAMQ,yBAAyBC,eAAe,oBAAoB,CAAC;IACtE,gBAAgBhB;IAChB,cAAc;QACViB;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/aiTools/WorkflowAiTool/abstractions.d.ts

@@ -0,0 +1,60 @@
+import type { ZodType } from "zod";
+import type { Actor, ReviewData, ReviewStep } from "../../../domain/review/types.js";
+import type { StepRunTaskIdentity } from "../../../domain/review/getStaleStepRunReason.js";
+/**
+ * What the runner supplies to every tool call (R167). It is the only place a handler learns which
+ * review, step, target and task it works for: a handler never takes a target, revision, review or
+ * step id from the model, so content under review cannot point a tool at another record (D55).
+ */
+export interface WorkflowAiToolContext {
+    /** The review as stored when the step run started. */
+    review: ReviewData;
+    /** The AI step being run. */
+    step: ReviewStep;
+    /** The requester: the identity the task runs as. */
+    requester: Actor;
+    /** The step run task, for the stale guard. */
+    task: StepRunTaskIdentity;
+}
+/**
+ * What a tool answers. `error` is a text the model may read, so it never holds a provider or
+ * storage error (the real error is logged). `execute` never rejects: a failure is `ok: false`.
+ */
+export interface WorkflowAiToolResult {
+    ok: boolean;
+    /** The answer, serialised for the model as JSON. */
+    data?: unknown;
+    error?: string;
+}
+export interface IWorkflowAiTool<TInput = unknown> {
+    /** Unique; `^[A-Za-z][A-Za-z0-9_]{0,63}$`. Stored on the step's `tools`; a rename breaks stored workflows. */
+    readonly name: string;
+    /** The tool's title as the model receives it. */
+    readonly title: string;
+    /** Shown to the model: what the tool does and when to call it. */
+    readonly description: string;
+    /** Shown to workflow authors in the step editor: a short, plain name. */
+    readonly label: string;
+    /** Shown to workflow authors in the step editor: one sentence on what the tool does. */
+    readonly summary: string;
+    /**
+     * Declare `true` when the tool writes or updates the content under review. The step editor
+     * marks such tools and says the step can change content (R283). Absent means `false`.
+     */
+    readonly changesContent?: boolean;
+    /** What the model sends. Never include a target, revision, review or step id: the context has them. */
+    readonly inputSchema: ZodType<TInput>;
+    execute(input: TInput, context: WorkflowAiToolContext): Promise<WorkflowAiToolResult>;
+}
+/**
+ * A tool an AI step may call (spec 9.3, R167, D55): register an implementation and a workflow
+ * author can allowlist it on an AI step. Multi-registered; the registry returns the last
+ * registration per `name`. Never the global `AiSdkTools`: a step gets only the tools it lists. A
+ * tool that writes is responsible for its own write path (A61).
+ */
+export declare const WorkflowAiTool: import("@webiny/di").Abstraction<IWorkflowAiTool<unknown>>;
+export declare namespace WorkflowAiTool {
+    type Interface<TInput = unknown> = IWorkflowAiTool<TInput>;
+    type Context = WorkflowAiToolContext;
+    type Result = WorkflowAiToolResult;
+}

package/features/aiTools/WorkflowAiTool/abstractions.js

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

package/features/aiTools/WorkflowAiTool/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/aiTools/WorkflowAiTool/abstractions.js","sources":["../../../../src/features/aiTools/WorkflowAiTool/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { ZodType } from \"zod\";\nimport type { Actor, ReviewData, ReviewStep } from \"~/domain/review/types.js\";\nimport type { StepRunTaskIdentity } from \"~/domain/review/getStaleStepRunReason.js\";\n\n/**\n * What the runner supplies to every tool call (R167). It is the only place a handler learns which\n * review, step, target and task it works for: a handler never takes a target, revision, review or\n * step id from the model, so content under review cannot point a tool at another record (D55).\n */\nexport interface WorkflowAiToolContext {\n    /** The review as stored when the step run started. */\n    review: ReviewData;\n    /** The AI step being run. */\n    step: ReviewStep;\n    /** The requester: the identity the task runs as. */\n    requester: Actor;\n    /** The step run task, for the stale guard. */\n    task: StepRunTaskIdentity;\n}\n\n/**\n * What a tool answers. `error` is a text the model may read, so it never holds a provider or\n * storage error (the real error is logged). `execute` never rejects: a failure is `ok: false`.\n */\nexport interface WorkflowAiToolResult {\n    ok: boolean;\n    /** The answer, serialised for the model as JSON. */\n    data?: unknown;\n    error?: string;\n}\n\nexport interface IWorkflowAiTool<TInput = unknown> {\n    /** Unique; `^[A-Za-z][A-Za-z0-9_]{0,63}$`. Stored on the step's `tools`; a rename breaks stored workflows. */\n    readonly name: string;\n    /** The tool's title as the model receives it. */\n    readonly title: string;\n    /** Shown to the model: what the tool does and when to call it. */\n    readonly description: string;\n    /** Shown to workflow authors in the step editor: a short, plain name. */\n    readonly label: string;\n    /** Shown to workflow authors in the step editor: one sentence on what the tool does. */\n    readonly summary: string;\n    /**\n     * Declare `true` when the tool writes or updates the content under review. The step editor\n     * marks such tools and says the step can change content (R283). Absent means `false`.\n     */\n    readonly changesContent?: boolean;\n    /** What the model sends. Never include a target, revision, review or step id: the context has them. */\n    readonly inputSchema: ZodType<TInput>;\n    execute(input: TInput, context: WorkflowAiToolContext): Promise<WorkflowAiToolResult>;\n}\n\n/**\n * A tool an AI step may call (spec 9.3, R167, D55): register an implementation and a workflow\n * author can allowlist it on an AI step. Multi-registered; the registry returns the last\n * registration per `name`. Never the global `AiSdkTools`: a step gets only the tools it lists. A\n * tool that writes is responsible for its own write path (A61).\n */\nexport const WorkflowAiTool = createAbstraction<IWorkflowAiTool>(\"WorkflowAiTool\");\n\nexport namespace WorkflowAiTool {\n    export type Interface<TInput = unknown> = IWorkflowAiTool<TInput>;\n    export type Context = WorkflowAiToolContext;\n    export type Result = WorkflowAiToolResult;\n}\n"],"names":["WorkflowAiTool","createAbstraction"],"mappings":";AA2DO,MAAMA,iBAAiBC,kBAAmC"}

package/features/aiTools/WorkflowAiTool/index.d.ts

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

package/features/aiTools/WorkflowAiTool/index.js

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

package/features/aiTools/WorkflowAiToolRegistryService/WorkflowAiToolRegistryService.d.ts

@@ -0,0 +1,13 @@
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { WorkflowAiTool } from "../../../features/aiTools/WorkflowAiTool/abstractions.js";
+import { WorkflowAiToolRegistryService as Abstraction } from "./abstractions.js";
+declare class WorkflowAiToolRegistryServiceImpl implements Abstraction.Interface {
+    private readonly tools;
+    constructor(tools: WorkflowAiTool.Interface[], logger: Logger.Interface);
+    get(name: string): WorkflowAiTool.Interface | null;
+    list(): WorkflowAiTool.Interface[];
+}
+export declare const WorkflowAiToolRegistryService: typeof WorkflowAiToolRegistryServiceImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IWorkflowAiToolRegistryService>;
+};
+export {};

package/features/aiTools/WorkflowAiToolRegistryService/WorkflowAiToolRegistryService.js

@@ -0,0 +1,42 @@
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { isWorkflowAiToolName } from "../../../domain/aiTools/isWorkflowAiToolName.js";
+import { WorkflowAiTool } from "../WorkflowAiTool/abstractions.js";
+import { WorkflowAiToolRegistryService } from "./abstractions.js";
+class WorkflowAiToolRegistryServiceImpl {
+    constructor(tools, logger){
+        this.tools = new Map();
+        for (const tool of tools){
+            if (!isWorkflowAiToolName(tool.name)) {
+                logger.error({
+                    toolName: tool.name,
+                    reason: `The AI tool name "${tool.name}" is not valid. Use 1 to 64 letters, digits or underscores, starting with a letter.`
+                }, "The AI tool was dropped.");
+                continue;
+            }
+            this.tools.set(tool.name, tool);
+        }
+    }
+    get(name) {
+        return this.tools.get(name) ?? null;
+    }
+    list() {
+        return [
+            ...this.tools.values()
+        ];
+    }
+}
+const WorkflowAiToolRegistryService_WorkflowAiToolRegistryService = WorkflowAiToolRegistryService.createImplementation({
+    implementation: WorkflowAiToolRegistryServiceImpl,
+    dependencies: [
+        [
+            WorkflowAiTool,
+            {
+                multiple: true
+            }
+        ],
+        Logger
+    ]
+});
+export { WorkflowAiToolRegistryService_WorkflowAiToolRegistryService as WorkflowAiToolRegistryService };
+
+//# sourceMappingURL=WorkflowAiToolRegistryService.js.map