@nocobase/plugin-flow-engine 2.1.0-beta.36 → 2.1.0-beta.37

package/dist/server/flow-surfaces/service.js

@@ -461,12 +461,17 @@ const AI_EMPLOYEE_ACTION_USE = "AIEmployeeButtonModel";
 const AI_EMPLOYEE_OWNER_PLUGIN = "@nocobase/plugin-ai";
 const AI_EMPLOYEE_PUBLIC_SETTING_KEYS = ["username", "auto", "workContext", "tasks", "style"];
 const AI_EMPLOYEE_INTERNAL_PROP_KEYS = ["aiEmployee", "context", "auto", "tasks", "style"];
+const AI_EMPLOYEE_TASK_STEP_PARAMS_PATH = ["shortcutSettings", "editTasks", "tasks"];
 const AI_EMPLOYEE_WORK_CONTEXT_PUBLIC_KEYS = ["type", "uid", "target"];
 const AI_EMPLOYEE_TASK_PUBLIC_SETTING_KEYS = ["title", "message", "autoSend", "skillSettings", "model", "webSearch"];
 const AI_EMPLOYEE_TASK_MESSAGE_PUBLIC_KEYS = ["system", "user", "workContext"];
 const AI_EMPLOYEE_TASK_MODEL_PUBLIC_KEYS = ["llmService", "model"];
 const AI_EMPLOYEE_SKILL_SETTINGS_PUBLIC_KEYS = ["skills", "tools", "skillsVersion", "toolsVersion"];
 const AI_EMPLOYEE_STYLE_PUBLIC_KEYS = ["size", "mask"];
+const AI_EMPLOYEE_PROMPT_CONTEXT_MAX_DEPTH = 8;
+const AI_EMPLOYEE_PROMPT_VARIABLE_INVALID = "FLOW_SURFACE_AI_EMPLOYEE_PROMPT_VARIABLE_INVALID";
+const AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE = "{{ ctx.record }}";
+const AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE_RE = /\{\{\s*ctx\.record\s*\}\}/;
 const AI_EMPLOYEE_DEFAULT_STYLE = {
   size: 40,
   mask: false
@@ -710,10 +715,16 @@ class FlowSurfacesService {
     );
   }
   async loadEnabledPluginPackages(transaction) {
-    if (!this.db.getCollection("applicationPlugins")) {
+    var _a;
+    const db = this.db;
+    if (!((_a = db == null ? void 0 : db.getCollection) == null ? void 0 : _a.call(db, "applicationPlugins")) || !(db == null ? void 0 : db.getRepository)) {
+      return /* @__PURE__ */ new Set();
+    }
+    const repository = db.getRepository("applicationPlugins");
+    if (!(repository == null ? void 0 : repository.find)) {
       return /* @__PURE__ */ new Set();
     }
-    const plugins = await this.db.getRepository("applicationPlugins").find({
+    const plugins = await repository.find({
       fields: ["packageName"],
       filter: {
         enabled: true
@@ -721,8 +732,8 @@ class FlowSurfacesService {
       transaction
     });
     const packageNames = plugins.map((plugin) => {
-      var _a;
-      return ((_a = plugin == null ? void 0 : plugin.get) == null ? void 0 : _a.call(plugin, "packageName")) || (plugin == null ? void 0 : plugin.packageName);
+      var _a2;
+      return ((_a2 = plugin == null ? void 0 : plugin.get) == null ? void 0 : _a2.call(plugin, "packageName")) || (plugin == null ? void 0 : plugin.packageName);
     }).filter((packageName) => typeof packageName === "string" && !!packageName.trim()).map((packageName) => packageName.trim());
     return new Set(packageNames);
   }
@@ -2843,6 +2854,22 @@ class FlowSurfacesService {
       getCollection: (dataSourceKey, collectionName) => this.getCollection(dataSourceKey || "main", collectionName || "")
     });
   }
+  async prevalidateApplyBlueprintChartAssets(document, transaction) {
+    var _a;
+    const chartAssets = import_lodash.default.isPlainObject((_a = document.assets) == null ? void 0 : _a.charts) ? document.assets.charts : {};
+    for (const [chartKey, chartAsset] of Object.entries(chartAssets)) {
+      if (!import_lodash.default.isPlainObject(chartAsset)) {
+        continue;
+      }
+      (0, import_service_utils.assertSupportedSimpleChanges)("chart", chartAsset, (0, import_configure_options.getConfigureOptionKeysForUse)("ChartBlockModel"));
+      const nextConfigure = (0, import_chart_config.buildChartConfigureFromSemanticChanges)(void 0, chartAsset);
+      await this.validateChartConfigureForRuntime(
+        `applyBlueprint assets.charts.${chartKey}`,
+        nextConfigure,
+        transaction
+      );
+    }
+  }
   getApplyBlueprintKanbanBlockResourceObject(block) {
     return import_lodash.default.isPlainObject(block == null ? void 0 : block.resource) ? block.resource : {};
   }
@@ -3231,25 +3258,48 @@ class FlowSurfacesService {
     }
     if (!options.transaction) {
       const createdKanbanSortFields = [];
-      try {
-        return await this.transaction(
-          (transaction) => this.applyBlueprintWithTransaction(
-            values,
-            {
-              ...options,
-              transaction
-            },
-            createdKanbanSortFields
-          )
+      const mutationResult = await this.applyBlueprintMutationWithoutExternalTransaction(
+        values,
+        options,
+        createdKanbanSortFields
+      );
+      const surface = await this.get(mutationResult.pageLocator, { currentRoles: options.currentRoles });
+      return this.buildApplyBlueprintResponse(mutationResult.mode, mutationResult.pageLocator, surface);
+    }
+  }
+  async applyBlueprintMutationWithoutExternalTransaction(values, options = {}, createdKanbanSortFields) {
+    try {
+      await this.assertApplyBlueprintAuthoringPayload(values, options);
+      const document = (0, import_blueprint.prepareFlowSurfaceApplyBlueprintDocument)(values);
+      await this.prevalidateApplyBlueprintChartAssets(document);
+      if (document.mode === "create") {
+        return await this.applyBlueprintWithTransaction(
+          values,
+          { ...options, skipAuthoringValidation: true },
+          createdKanbanSortFields,
+          {
+            readSurface: false
+          }
         );
-      } catch (error) {
-        await this.cleanupApplyBlueprintKanbanSortFields(createdKanbanSortFields);
-        throw error;
       }
+      return await this.transaction(
+        (transaction) => this.applyBlueprintWithTransaction(
+          values,
+          {
+            ...options,
+            transaction,
+            skipAuthoringValidation: true
+          },
+          createdKanbanSortFields,
+          { readSurface: false }
+        )
+      );
+    } catch (error) {
+      await this.cleanupApplyBlueprintKanbanSortFields(createdKanbanSortFields);
+      throw error;
     }
   }
-  async applyBlueprintWithTransaction(values, options = {}, createdKanbanSortFields) {
-    var _a;
+  async assertApplyBlueprintAuthoringPayload(values, options = {}) {
     const enabledPackages = await this.resolveEnabledPluginPackages(options);
     await (0, import_authoring_validation.assertFlowSurfaceAuthoringPayload)("applyBlueprint", values, {
       transaction: options.transaction,
@@ -3257,6 +3307,11 @@ class FlowSurfacesService {
       findMenuGroupRoutesByTitle: (title, transaction) => this.findMenuGroupRoutesByTitle(title, transaction),
       getCollection: (dataSourceKey, collectionName) => this.getCollection(dataSourceKey || "main", collectionName || "")
     });
+  }
+  async applyBlueprintWithTransaction(values, options = {}, createdKanbanSortFields, resultOptions = {}) {
+    if (options.skipAuthoringValidation !== true) {
+      await this.assertApplyBlueprintAuthoringPayload(values, options);
+    }
     const prepared = await this.prepareApplyBlueprintRequest(values, options.transaction, createdKanbanSortFields);
     const popupTemplateAliasSession = this.createPopupTemplateAliasSession();
     const popupTemplateTreeCache = /* @__PURE__ */ new Map();
@@ -3277,10 +3332,21 @@ class FlowSurfacesService {
       options
     );
     const pageLocator = (0, import_blueprint.resolveApplyBlueprintPageLocator)(prepared, result);
+    if (resultOptions.readSurface === false) {
+      return {
+        version: "1",
+        mode: prepared.document.mode,
+        pageLocator
+      };
+    }
     const surface = await this.get(pageLocator, options);
+    return this.buildApplyBlueprintResponse(prepared.document.mode, pageLocator, surface);
+  }
+  buildApplyBlueprintResponse(mode, pageLocator, surface) {
+    var _a;
     return {
       version: "1",
-      mode: prepared.document.mode,
+      mode,
       target: (0, import_service_utils.buildDefinedPayload)({
         pageSchemaUid: pageLocator.pageSchemaUid,
         pageUid: (_a = surface == null ? void 0 : surface.target) == null ? void 0 : _a.uid
@@ -7041,20 +7107,36 @@ class FlowSurfacesService {
       return result2;
     }
     const resourceContext = container.ownerUid ? await this.locator.resolveCollectionContext(container.ownerUid, options.transaction).catch(() => null) : null;
-    const aiEmployeeProps = this.isAIEmployeeActionUse(actionCatalogItem.use) ? await this.normalizeAIEmployeeActionPublicSettings("addAction", inlineSettings || {}, {
+    const aiEmployeeSettingsPayload = this.isAIEmployeeActionUse(actionCatalogItem.use) ? await this.normalizeAIEmployeeActionPublicSettings("addAction", inlineSettings || {}, {
       transaction: options.transaction,
       enabledPackages,
       requireUsername: true,
       currentRoles: options.currentRoles,
-      selfUid: container.ownerUid
+      selfUid: container.ownerUid,
+      promptContext: {
+        kind: "container",
+        ownerUid: container.ownerUid,
+        scope: resolvedScope
+      }
     }) : void 0;
+    const actionSettingsPayload = {
+      props: values.props,
+      stepParams: values.stepParams
+    };
+    if (aiEmployeeSettingsPayload) {
+      this.mergeAIEmployeeActionSettingsPayload(
+        { use: actionCatalogItem.use },
+        actionSettingsPayload,
+        aiEmployeeSettingsPayload
+      );
+    }
     const action = (0, import_builder.buildActionTree)({
       use: actionCatalogItem.use,
       containerUse: container.ownerUse,
       resourceInit: values.resourceInit || (resourceContext == null ? void 0 : resourceContext.resourceInit),
-      props: aiEmployeeProps || values.props,
+      props: actionSettingsPayload.props,
       decoratorProps: values.decoratorProps,
-      stepParams: values.stepParams,
+      stepParams: actionSettingsPayload.stepParams,
       flowRegistry: values.flowRegistry
     });
     this.contractGuard.validateNodeTreeAgainstContract(action);
@@ -7141,20 +7223,36 @@ class FlowSurfacesService {
     }
     const resourceContext = container.ownerUid ? await this.locator.resolveCollectionContext(container.ownerUid, options.transaction).catch(() => null) : null;
     const resourceInit = this.isAddChildCatalogItem(actionCatalogItem) ? await this.resolveAddChildResourceInitForOwnerNode(container.ownerNode, options.transaction) : values.resourceInit || (resourceContext == null ? void 0 : resourceContext.resourceInit);
-    const aiEmployeeProps = this.isAIEmployeeActionUse(actionCatalogItem.use) ? await this.normalizeAIEmployeeActionPublicSettings("addRecordAction", inlineSettings || {}, {
+    const aiEmployeeSettingsPayload = this.isAIEmployeeActionUse(actionCatalogItem.use) ? await this.normalizeAIEmployeeActionPublicSettings("addRecordAction", inlineSettings || {}, {
       transaction: options.transaction,
       enabledPackages,
       requireUsername: true,
       currentRoles: options.currentRoles,
-      selfUid: container.ownerUid
+      selfUid: container.ownerUid,
+      promptContext: {
+        kind: "container",
+        ownerUid: container.ownerUid,
+        scope: resolvedScope
+      }
     }) : void 0;
+    const actionSettingsPayload = {
+      props: values.props,
+      stepParams: values.stepParams
+    };
+    if (aiEmployeeSettingsPayload) {
+      this.mergeAIEmployeeActionSettingsPayload(
+        { use: actionCatalogItem.use },
+        actionSettingsPayload,
+        aiEmployeeSettingsPayload
+      );
+    }
     const action = (0, import_builder.buildActionTree)({
       use: actionCatalogItem.use,
       containerUse: container.containerUse,
       resourceInit,
-      props: aiEmployeeProps || values.props,
+      props: actionSettingsPayload.props,
       decoratorProps: values.decoratorProps,
-      stepParams: values.stepParams,
+      stepParams: actionSettingsPayload.stepParams,
       flowRegistry: values.flowRegistry
     });
     this.contractGuard.validateNodeTreeAgainstContract(action);
@@ -10641,7 +10739,7 @@ class FlowSurfacesService {
     }
     if (this.isAIEmployeeActionUse(current == null ? void 0 : current.use) && this.hasAIEmployeePublicSettings(normalizedValues)) {
       const enabledPackages = await this.resolveEnabledPluginPackages(options);
-      const aiEmployeeProps = await this.normalizeAIEmployeeActionPublicSettings(
+      const aiEmployeeSettingsPayload = await this.normalizeAIEmployeeActionPublicSettings(
         "updateSettings",
         import_lodash.default.pick(normalizedValues, AI_EMPLOYEE_PUBLIC_SETTING_KEYS),
         {
@@ -10649,13 +10747,17 @@ class FlowSurfacesService {
           enabledPackages,
           current,
           currentRoles: options.currentRoles,
-          selfUid: await this.resolveAIEmployeeActionSelfUid(current, options.transaction)
+          selfUid: await this.resolveAIEmployeeActionSelfUid(current, options.transaction),
+          promptContext: {
+            kind: "target",
+            targetUid: (current == null ? void 0 : current.uid) || writeTarget.uid
+          }
         }
       );
       AI_EMPLOYEE_PUBLIC_SETTING_KEYS.forEach((key) => {
         delete normalizedValues[key];
       });
-      normalizedValues.props = import_lodash.default.merge({}, normalizedValues.props || {}, aiEmployeeProps);
+      this.mergeAIEmployeeActionSettingsPayload(current, normalizedValues, aiEmployeeSettingsPayload);
     }
     assertNoFlowSurfaceIdTitleFieldSettings(normalizedValues, {
       action: "updateSettings",
@@ -10703,6 +10805,14 @@ class FlowSurfacesService {
       nextPayload,
       options.replaceRecordHistorySettings === true
     );
+    this.syncAIEmployeeTaskStepParamsForUpdateSettings(current, nextPayload);
+    await this.normalizeAIEmployeeStepParamTasksForUpdateSettings(current, nextPayload, writeTarget, options);
+    await this.assertAIEmployeeStepParamTaskPromptVariablesAllowedForUpdateSettings(
+      current,
+      nextPayload,
+      writeTarget,
+      options
+    );
     this.syncCalendarPopupPropsForUpdateSettings(current, normalizedValues, nextPayload);
     this.syncKanbanPopupPropsForUpdateSettings(current, normalizedValues, nextPayload);
     this.syncDefaultSortingForUpdateSettings(current, normalizedValues, nextPayload);
@@ -11679,6 +11789,36 @@ class FlowSurfacesService {
       suggestedFieldPath: `${fieldPath}.<field>`
     };
   }
+  async validateChartConfigureForRuntime(actionName, configure, transaction) {
+    var _a, _b, _c;
+    if (!import_lodash.default.isPlainObject(configure)) {
+      return;
+    }
+    this.validateBuilderChartFieldsForRuntime(actionName, configure);
+    const state = (0, import_chart_config.deriveChartSemanticState)(configure);
+    if (((_a = state.query) == null ? void 0 : _a.mode) !== "sql") {
+      return;
+    }
+    const sqlPreview = await this.resolveSqlChartPreview(state.query, transaction);
+    if (((_b = state.visual) == null ? void 0 : _b.mode) !== "basic") {
+      return;
+    }
+    if (!((_c = sqlPreview.queryOutputs) == null ? void 0 : _c.length)) {
+      (0, import_errors.throwBadRequest)(
+        "chart visual.mode='basic' requires previewable SQL query outputs; write query first, then read flowSurfaces:context(path='chart'), or use visual.mode='custom' after browser verification"
+      );
+    }
+    const supportedOutputs = new Set(
+      sqlPreview.queryOutputs.map((output) => String((output == null ? void 0 : output.alias) || "").trim()).filter(Boolean)
+    );
+    for (const mappingField of (0, import_chart_config.getChartVisualMappingAliases)(state.visual)) {
+      if (!supportedOutputs.has(mappingField)) {
+        (0, import_errors.throwBadRequest)(
+          `chart visual mappings only support SQL query output fields: ${Array.from(supportedOutputs).join(", ")}`
+        );
+      }
+    }
+  }
   stripChartSqlForInspection(sql) {
     return sql.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/--[^\r\n]*/g, " ").replace(/'(?:''|[^'])*'/g, "''").replace(/"(?:[""]|[^"])*"/g, '""');
   }
@@ -16381,6 +16521,67 @@ class FlowSurfacesService {
       )}; use top-level username, auto, workContext, tasks or style instead`
     );
   }
+  readAIEmployeePersistedTasks(current) {
+    var _a;
+    const stepTasks = import_lodash.default.get(current, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
+    if (Array.isArray(stepTasks)) {
+      return stepTasks;
+    }
+    const legacyPropsTasks = (_a = current == null ? void 0 : current.props) == null ? void 0 : _a.tasks;
+    return Array.isArray(legacyPropsTasks) ? legacyPropsTasks : [];
+  }
+  buildAIEmployeeTaskStepParams(tasks) {
+    const stepParams = {};
+    import_lodash.default.set(stepParams, AI_EMPLOYEE_TASK_STEP_PARAMS_PATH, import_lodash.default.cloneDeep(tasks));
+    return stepParams;
+  }
+  mergeAIEmployeeActionSettingsPayload(current, values, payload) {
+    if (Object.keys(payload.props).length) {
+      values.props = import_lodash.default.merge({}, values.props || {}, payload.props);
+    }
+    if (Object.keys(payload.stepParams).length) {
+      values.stepParams = import_lodash.default.mergeWith({}, values.stepParams || {}, payload.stepParams, (_currentValue, nextValue) => {
+        if (Array.isArray(nextValue)) {
+          return import_lodash.default.cloneDeep(nextValue);
+        }
+        return void 0;
+      });
+    }
+    if (import_lodash.default.has(payload.stepParams, AI_EMPLOYEE_TASK_STEP_PARAMS_PATH) && this.isAIEmployeeActionUse(current == null ? void 0 : current.use)) {
+      if (import_lodash.default.isPlainObject(values.props)) {
+        delete values.props.tasks;
+      }
+    }
+  }
+  syncAIEmployeeTaskStepParamsForUpdateSettings(current, nextPayload) {
+    var _a;
+    if (!this.isAIEmployeeActionUse(current == null ? void 0 : current.use)) {
+      return;
+    }
+    const legacyPropsTasks = (_a = current == null ? void 0 : current.props) == null ? void 0 : _a.tasks;
+    const hasLegacyPropsTasks = Array.isArray(legacyPropsTasks);
+    const hasNextStepTasks = import_lodash.default.has(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
+    const currentStepTasks = import_lodash.default.get(current, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
+    if (!hasNextStepTasks && hasLegacyPropsTasks && !Array.isArray(currentStepTasks)) {
+      nextPayload.stepParams = import_lodash.default.mergeWith(
+        {},
+        (current == null ? void 0 : current.stepParams) || {},
+        this.buildAIEmployeeTaskStepParams(legacyPropsTasks),
+        (_currentValue, nextValue) => {
+          if (Array.isArray(nextValue)) {
+            return import_lodash.default.cloneDeep(nextValue);
+          }
+          return void 0;
+        }
+      );
+    }
+    if (!hasLegacyPropsTasks && !import_lodash.default.has(nextPayload, ["props", "tasks"])) {
+      return;
+    }
+    const nextProps = import_lodash.default.cloneDeep(nextPayload.props ?? (current == null ? void 0 : current.props) ?? {});
+    delete nextProps.tasks;
+    nextPayload.props = nextProps;
+  }
   assertAIEmployeePluginEnabled(actionName, enabledPackages) {
     if (!enabledPackages.has(AI_EMPLOYEE_OWNER_PLUGIN)) {
       (0, import_errors.throwBadRequest)(
@@ -16574,8 +16775,290 @@ class FlowSurfacesService {
     if (Object.prototype.hasOwnProperty.call(next, "toolsVersion") && typeof next.toolsVersion !== "number") {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path}.toolsVersion must be a number`);
     }
+    const hasSkills = Object.prototype.hasOwnProperty.call(next, "skills");
+    const hasTools = Object.prototype.hasOwnProperty.call(next, "tools");
+    const hasSkillsVersion = Object.prototype.hasOwnProperty.call(next, "skillsVersion");
+    const hasToolsVersion = Object.prototype.hasOwnProperty.call(next, "toolsVersion");
+    if (hasSkills && hasTools && !hasSkillsVersion && !hasToolsVersion && Array.isArray(next.skills) && Array.isArray(next.tools) && next.skills.length === 0 && next.tools.length === 0) {
+      return null;
+    }
+    if (hasSkills && !hasSkillsVersion) {
+      next.skillsVersion = 2;
+    }
+    if (hasTools && !hasToolsVersion) {
+      next.toolsVersion = 2;
+    }
     return next;
   }
+  collectAIEmployeePromptVariables(value) {
+    if (!value.includes("{{")) {
+      return [];
+    }
+    return [...value.matchAll(/\{\{\s*([\s\S]+?)\s*\}\}/g)].map(([raw, inner]) => ({
+      raw,
+      inner: String(inner || "").trim()
+    }));
+  }
+  hasAIEmployeePromptVariables(tasks) {
+    return import_lodash.default.castArray(tasks || []).some((task) => {
+      const message = task == null ? void 0 : task.message;
+      return typeof (message == null ? void 0 : message.system) === "string" && this.collectAIEmployeePromptVariables(message.system).length > 0 || typeof (message == null ? void 0 : message.user) === "string" && this.collectAIEmployeePromptVariables(message.user).length > 0;
+    });
+  }
+  collectAIEmployeeContextPathEntries(context) {
+    const result = /* @__PURE__ */ new Map();
+    const visit = (prefix, info) => {
+      if (!prefix || !info) {
+        return;
+      }
+      result.set(prefix, info);
+      if (info.dynamicProperties) {
+        result.set(`${prefix}.*`, info.dynamicProperties);
+      }
+      for (const [childKey, childInfo] of Object.entries(info.properties || {})) {
+        visit(`${prefix}.${childKey}`, childInfo);
+      }
+    };
+    for (const [key, info] of Object.entries((context == null ? void 0 : context.vars) || {})) {
+      visit(key, info);
+    }
+    return result;
+  }
+  isAIEmployeeContextInfoPathAllowed(info, segments) {
+    var _a;
+    if (!info) {
+      return false;
+    }
+    if (!segments.length) {
+      return true;
+    }
+    const [segment, ...rest] = segments;
+    const staticChild = (_a = info.properties) == null ? void 0 : _a[segment];
+    if (staticChild) {
+      return this.isAIEmployeeContextInfoPathAllowed(staticChild, rest);
+    }
+    if (info.dynamicProperties) {
+      return this.isAIEmployeeContextInfoPathAllowed(info.dynamicProperties, rest);
+    }
+    return false;
+  }
+  canResolveAIEmployeeContextPath(path, semantic) {
+    var _a;
+    return !!((_a = (0, import_context.buildFlowSurfaceContextResponse)({
+      semantic,
+      path,
+      maxDepth: 1
+    }).vars) == null ? void 0 : _a[path]);
+  }
+  isAIEmployeeContextPathAllowed(path, validation) {
+    if (validation.contextPaths.has(path)) {
+      return true;
+    }
+    for (const [allowedPath, info] of validation.contextPaths) {
+      if (!allowedPath.endsWith(".*")) {
+        continue;
+      }
+      const prefix = allowedPath.slice(0, -2);
+      if (!path.startsWith(`${prefix}.`)) {
+        continue;
+      }
+      const dynamicSegments = path.slice(prefix.length + 1).split(".").filter(Boolean);
+      if (dynamicSegments.length && this.isAIEmployeeContextInfoPathAllowed(info, dynamicSegments.slice(1))) {
+        return true;
+      }
+    }
+    return this.canResolveAIEmployeeContextPath(path, validation.semantic);
+  }
+  extractAIEmployeePromptContextPath(expression) {
+    const normalized = String(expression || "").trim();
+    if (normalized === "ctx") {
+      return "";
+    }
+    if (!normalized.startsWith("ctx.")) {
+      return null;
+    }
+    const path = normalized.slice(4).trim();
+    return (0, import_context.isBareFlowContextPath)(path) ? path : null;
+  }
+  buildAIEmployeePromptVariableHint(targetUid) {
+    return `Call flowSurfaces:context${targetUid ? ` with target.uid "${targetUid}"` : ""} to inspect available ctx paths before writing prompt variables.`;
+  }
+  throwAIEmployeePromptVariableInvalid(input) {
+    (0, import_errors.throwBadRequest)(
+      `flowSurfaces ${input.actionName} ${input.fieldPath} variable "${input.variable}" is not allowed: ${input.reason}. Use a concrete ctx path such as "{{ ctx.record.id }}" only when that path is available. ${this.buildAIEmployeePromptVariableHint(
+        input.targetUid
+      )}`,
+      AI_EMPLOYEE_PROMPT_VARIABLE_INVALID,
+      {
+        path: input.fieldPath,
+        details: (0, import_service_utils.buildDefinedPayload)({
+          variable: input.variable,
+          contextPath: input.path,
+          targetUid: input.targetUid
+        })
+      }
+    );
+  }
+  assertAIEmployeePromptVariablesAllowed(actionName, fieldPath, value, validation) {
+    for (const variable of this.collectAIEmployeePromptVariables(value)) {
+      const path = this.extractAIEmployeePromptContextPath(variable.inner);
+      if (path === "") {
+        this.throwAIEmployeePromptVariableInvalid({
+          actionName,
+          fieldPath,
+          variable: variable.raw,
+          targetUid: validation.targetUid,
+          reason: "the whole ctx object is not a valid prompt variable; use a concrete ctx path"
+        });
+      }
+      if (!path) {
+        this.throwAIEmployeePromptVariableInvalid({
+          actionName,
+          fieldPath,
+          variable: variable.raw,
+          targetUid: validation.targetUid,
+          reason: 'only simple ctx dot paths like "{{ ctx.record.id }}" are supported'
+        });
+      }
+      if (!this.isAIEmployeeContextPathAllowed(path, validation)) {
+        this.throwAIEmployeePromptVariableInvalid({
+          actionName,
+          fieldPath,
+          variable: variable.raw,
+          targetUid: validation.targetUid,
+          path,
+          reason: `path "${path}" is not available in the current Flow Surface context`
+        });
+      }
+    }
+  }
+  assertAIEmployeeTaskPromptVariablesAllowed(actionName, tasks, validation, path = "settings.tasks") {
+    if (!validation) {
+      return;
+    }
+    tasks.forEach((task, index) => {
+      const message = task == null ? void 0 : task.message;
+      if (typeof (message == null ? void 0 : message.system) === "string") {
+        this.assertAIEmployeePromptVariablesAllowed(
+          actionName,
+          `${path}[${index}].message.system`,
+          message.system,
+          validation
+        );
+      }
+      if (typeof (message == null ? void 0 : message.user) === "string") {
+        this.assertAIEmployeePromptVariablesAllowed(
+          actionName,
+          `${path}[${index}].message.user`,
+          message.user,
+          validation
+        );
+      }
+    });
+  }
+  appendAIEmployeeCurrentRecordPromptVariable(value) {
+    if (AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE_RE.test(value)) {
+      return value;
+    }
+    return value ? `${value}
+${AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE}` : AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE;
+  }
+  async resolveAIEmployeePromptActionTargetUid(context, transaction) {
+    if (!context) {
+      return void 0;
+    }
+    if (context.kind === "target") {
+      return String(context.targetUid || "").trim() || void 0;
+    }
+    return String(context.ownerUid || "").trim() || void 0;
+  }
+  async buildAIEmployeePromptValidationContext(actionName, tasks, options) {
+    var _a, _b;
+    if (!this.hasAIEmployeePromptVariables(tasks)) {
+      return void 0;
+    }
+    const targetUid = await this.resolveAIEmployeePromptActionTargetUid(options.promptContext, options.transaction);
+    if (!targetUid) {
+      (0, import_errors.throwBadRequest)(
+        `flowSurfaces ${actionName} AI employee prompt variables require a resolvable Flow Surface context. ${this.buildAIEmployeePromptVariableHint()}`,
+        AI_EMPLOYEE_PROMPT_VARIABLE_INVALID
+      );
+    }
+    const target = { uid: targetUid };
+    const resolved = await this.locator.resolve(target, { transaction: options.transaction });
+    let semantic = await this.resolveContextSemantic(((_a = resolved == null ? void 0 : resolved.node) == null ? void 0 : _a.uid) || target.uid, resolved, options.transaction);
+    if (((_b = options.promptContext) == null ? void 0 : _b.kind) === "container" && options.promptContext.scope === "record") {
+      semantic = {
+        ...semantic,
+        recordCollection: semantic.recordCollection || semantic.collection || await this.resolveContextOwnerCollection(targetUid, options.transaction).catch(() => null)
+      };
+    }
+    const context = (0, import_context.buildFlowSurfaceContextResponse)({
+      semantic,
+      maxDepth: AI_EMPLOYEE_PROMPT_CONTEXT_MAX_DEPTH
+    });
+    return {
+      targetUid,
+      semantic,
+      contextPaths: this.collectAIEmployeeContextPathEntries(context)
+    };
+  }
+  appendAIEmployeeCurrentRecordPromptVariableToTasks(tasks, validation) {
+    if (!tasks.length || !validation || !this.isAIEmployeeContextPathAllowed("record", validation)) {
+      return tasks;
+    }
+    return tasks.map((task) => {
+      var _a;
+      if (typeof ((_a = task == null ? void 0 : task.message) == null ? void 0 : _a.user) !== "string") {
+        return task;
+      }
+      const next = import_lodash.default.cloneDeep(task);
+      next.message.user = this.appendAIEmployeeCurrentRecordPromptVariable(next.message.user);
+      return next;
+    });
+  }
+  async assertAIEmployeeStepParamTaskPromptVariablesAllowedForUpdateSettings(current, nextPayload, writeTarget, options) {
+    if (!this.isAIEmployeeActionUse(current == null ? void 0 : current.use) || !import_lodash.default.has(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH])) {
+      return;
+    }
+    const tasks = import_lodash.default.get(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
+    if (!Array.isArray(tasks)) {
+      return;
+    }
+    const actionName = options.openViewActionName || "updateSettings";
+    this.assertAIEmployeeTaskPromptVariablesAllowed(
+      actionName,
+      tasks,
+      await this.buildAIEmployeePromptValidationContext(actionName, tasks, {
+        transaction: options.transaction,
+        promptContext: {
+          kind: "target",
+          targetUid: (current == null ? void 0 : current.uid) || writeTarget.uid
+        }
+      }),
+      "stepParams.shortcutSettings.editTasks.tasks"
+    );
+  }
+  async normalizeAIEmployeeStepParamTasksForUpdateSettings(current, nextPayload, writeTarget, options) {
+    if (!this.isAIEmployeeActionUse(current == null ? void 0 : current.use) || !import_lodash.default.has(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH])) {
+      return;
+    }
+    const tasks = import_lodash.default.get(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH]);
+    if (!Array.isArray(tasks)) {
+      return;
+    }
+    const actionName = options.openViewActionName || "updateSettings";
+    const normalizedTasks = this.normalizeAIEmployeeTasks(
+      actionName,
+      tasks,
+      this.readAIEmployeePersistedTasks(current),
+      {
+        selfUid: await this.resolveAIEmployeeActionSelfUid(current || { uid: writeTarget.uid }, options.transaction),
+        path: "stepParams.shortcutSettings.editTasks.tasks"
+      }
+    );
+    import_lodash.default.set(nextPayload, ["stepParams", ...AI_EMPLOYEE_TASK_STEP_PARAMS_PATH], normalizedTasks);
+  }
   normalizeAIEmployeeTaskMessage(actionName, path, value, existing, options) {
     if (!import_lodash.default.isPlainObject(value)) {
       (0, import_errors.throwBadRequest)(`flowSurfaces ${actionName} ${path} must be an object`);
@@ -16661,6 +17144,14 @@ class FlowSurfacesService {
     if (!import_lodash.default.isPlainObject(next.message)) {
       next.message = {};
     }
+    if (import_lodash.default.isPlainObject(next.skillSettings)) {
+      if (Array.isArray(next.skillSettings.skills) && !Object.prototype.hasOwnProperty.call(next.skillSettings, "skillsVersion")) {
+        next.skillSettings.skillsVersion = 2;
+      }
+      if (Array.isArray(next.skillSettings.tools) && !Object.prototype.hasOwnProperty.call(next.skillSettings, "toolsVersion")) {
+        next.skillSettings.toolsVersion = 2;
+      }
+    }
     return next;
   }
   normalizeAIEmployeeTasks(actionName, value, currentTasks, options) {
@@ -16723,6 +17214,7 @@ class FlowSurfacesService {
       });
     }
     const props = {};
+    const stepParams = {};
     if (effectiveUsername && (hasUsername || options.requireUsername)) {
       props.aiEmployee = {
         ...import_lodash.default.isPlainObject(currentProps.aiEmployee) ? import_lodash.default.cloneDeep(currentProps.aiEmployee) : {},
@@ -16748,11 +17240,36 @@ class FlowSurfacesService {
       };
     }
     if (Object.prototype.hasOwnProperty.call(settings, "tasks")) {
-      props.tasks = this.normalizeAIEmployeeTasks(actionName, settings.tasks, currentProps.tasks, {
-        selfUid: options.selfUid,
-        keyMap: options.keyMap,
-        path: "settings.tasks"
+      const normalizedTasks = this.normalizeAIEmployeeTasks(
+        actionName,
+        settings.tasks,
+        this.readAIEmployeePersistedTasks(options.current),
+        {
+          selfUid: options.selfUid,
+          keyMap: options.keyMap,
+          path: "settings.tasks"
+        }
+      );
+      const validation = options.promptContext && normalizedTasks.length ? await this.buildAIEmployeePromptValidationContext(
+        actionName,
+        [
+          {
+            message: {
+              user: AI_EMPLOYEE_CURRENT_RECORD_PROMPT_VARIABLE
+            }
+          }
+        ],
+        {
+          transaction: options.transaction,
+          promptContext: options.promptContext
+        }
+      ) : await this.buildAIEmployeePromptValidationContext(actionName, normalizedTasks, {
+        transaction: options.transaction,
+        promptContext: options.promptContext
       });
+      const tasks = this.appendAIEmployeeCurrentRecordPromptVariableToTasks(normalizedTasks, validation);
+      this.assertAIEmployeeTaskPromptVariablesAllowed(actionName, tasks, validation);
+      import_lodash.default.merge(stepParams, this.buildAIEmployeeTaskStepParams(tasks));
     }
     if (Object.prototype.hasOwnProperty.call(settings, "style") || options.requireUsername) {
       const style = Object.prototype.hasOwnProperty.call(settings, "style") ? settings.style : {};
@@ -16780,7 +17297,10 @@ class FlowSurfacesService {
         import_lodash.default.isPlainObject(style) ? import_lodash.default.pick(import_lodash.default.cloneDeep(style), AI_EMPLOYEE_STYLE_PUBLIC_KEYS) : {}
       );
     }
-    return props;
+    return {
+      props,
+      stepParams
+    };
   }
   async resolveAIEmployeeActionSelfUid(actionNode, transaction) {
     const parentUid = String((actionNode == null ? void 0 : actionNode.parentId) || "").trim() || ((actionNode == null ? void 0 : actionNode.uid) ? await this.locator.findParentUid(actionNode.uid, transaction).catch(() => "") : "");
@@ -16806,25 +17326,34 @@ class FlowSurfacesService {
     const allowedKeys = (0, import_configure_options.getConfigureOptionKeysForUse)(use);
     (0, import_service_utils.assertSupportedSimpleChanges)("action", changes, allowedKeys);
     if (this.isAIEmployeeActionUse(use)) {
-      const props2 = await this.normalizeAIEmployeeActionPublicSettings("configure action", changes, {
-        transaction: options.transaction,
-        enabledPackages: options.enabledPackages || await this.resolveEnabledPluginPackages(options),
-        current: currentNode,
-        currentRoles: options.currentRoles,
-        selfUid: await this.resolveAIEmployeeActionSelfUid(currentNode, options.transaction)
-      });
-      return this.updateSettings(
+      const aiEmployeeSettingsPayload = await this.normalizeAIEmployeeActionPublicSettings(
+        "configure action",
+        changes,
         {
-          target,
-          props: props2
-        },
-        {
-          ...options,
-          openViewActionName: options.openViewActionName || "configure action",
-          popupTemplateHostUid: target.uid,
-          allowAIEmployeeInternalProps: true
+          transaction: options.transaction,
+          enabledPackages: options.enabledPackages || await this.resolveEnabledPluginPackages(options),
+          current: currentNode,
+          currentRoles: options.currentRoles,
+          selfUid: await this.resolveAIEmployeeActionSelfUid(currentNode, options.transaction),
+          promptContext: {
+            kind: "target",
+            targetUid: (currentNode == null ? void 0 : currentNode.uid) || target.uid
+          }
         }
       );
+      const settingsValues = { target };
+      if (Object.keys(aiEmployeeSettingsPayload.props).length) {
+        settingsValues.props = aiEmployeeSettingsPayload.props;
+      }
+      if (Object.keys(aiEmployeeSettingsPayload.stepParams).length) {
+        settingsValues.stepParams = aiEmployeeSettingsPayload.stepParams;
+      }
+      return this.updateSettings(settingsValues, {
+        ...options,
+        openViewActionName: options.openViewActionName || "configure action",
+        popupTemplateHostUid: target.uid,
+        allowAIEmployeeInternalProps: true
+      });
     }
     const normalizedDefaultFilter = (0, import_service_utils.hasOwnDefined)(changes, "defaultFilter") ? this.normalizeFilterActionDefaultFilterValue(changes.defaultFilter) : void 0;
     const stepParams = {};
@@ -18117,7 +18646,8 @@ class FlowSurfacesService {
   }
   resolveRecordActionContextOwner(ancestors) {
     const currentNode = ancestors[0];
-    if (!String((currentNode == null ? void 0 : currentNode.use) || "").endsWith("ActionModel")) {
+    const currentUse = String((currentNode == null ? void 0 : currentNode.use) || "").trim();
+    if (!currentUse.endsWith("ActionModel") && !import_node_use_sets.ACTION_BUTTON_USES.has(currentUse)) {
       return null;
     }
     return ancestors.slice(1).find((node) => (0, import_action_scope.getActionContainerScope)(node == null ? void 0 : node.use) === "record") || null;
@@ -18368,11 +18898,12 @@ class FlowSurfacesService {
     };
   }
   getCollection(dataSourceKey, collectionName) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
     const normalizedDataSourceKey = dataSourceKey || "main";
-    const dataSourceManager = this.plugin.app.dataSourceManager;
-    const dataSource = (_a = dataSourceManager == null ? void 0 : dataSourceManager.get) == null ? void 0 : _a.call(dataSourceManager, normalizedDataSourceKey);
-    return ((_c = (_b = dataSource == null ? void 0 : dataSource.collectionManager) == null ? void 0 : _b.getCollection) == null ? void 0 : _c.call(_b, collectionName)) || ((_e = (_d = this.plugin.app.db) == null ? void 0 : _d.getCollection) == null ? void 0 : _e.call(_d, collectionName));
+    const app = (_a = this.plugin) == null ? void 0 : _a.app;
+    const dataSourceManager = app == null ? void 0 : app.dataSourceManager;
+    const dataSource = (_b = dataSourceManager == null ? void 0 : dataSourceManager.get) == null ? void 0 : _b.call(dataSourceManager, normalizedDataSourceKey);
+    return ((_d = (_c = dataSource == null ? void 0 : dataSource.collectionManager) == null ? void 0 : _c.getCollection) == null ? void 0 : _d.call(_c, collectionName)) || ((_f = (_e = app == null ? void 0 : app.db) == null ? void 0 : _e.getCollection) == null ? void 0 : _f.call(_e, collectionName)) || ((_h = (_g = this.db) == null ? void 0 : _g.getCollection) == null ? void 0 : _h.call(_g, collectionName));
   }
   normalizeKanbanFieldNameInput(value, context, options = {}) {
     if (import_lodash.default.isUndefined(value)) {