@shwfed/config 3.0.6 → 3.0.8

package/dist/runtime/components/actions/utils/ai-button-tools.js

@@ -0,0 +1,664 @@
+import { JSONSchema, ParseResult, Schema } from "effect";
+import { Environment } from "../../../vendor/cel-js/lib/index.js";
+import { coerceFromString } from "../../../share/coerce-from-string.js";
+import { getCelCatalog } from "../../../utils/cel-catalog.js";
+import { Expression } from "../../../share/expression.js";
+import { activeButtons, findButton } from "./resolve.js";
+import { activeOperations } from "../../operations/utils/resolve.js";
+const ACTION_HARNESS_KEYS = ["type", "compatibilityDate"];
+function emptyLocale() {
+  return [{ locale: "zh", message: "" }];
+}
+function toLocale(title) {
+  if (typeof title === "string") return [{ locale: "zh", message: title }];
+  if (Array.isArray(title)) return title;
+  return emptyLocale();
+}
+function decode(schema, input) {
+  const result = Schema.decodeUnknownEither(schema)(coerceFromString(input, schema));
+  if (result._tag === "Right") return { ok: true, value: result.right };
+  const issues = ParseResult.ArrayFormatter.formatErrorSync(result.left);
+  const report = issues.map((i) => `- ${i.path.map(String).join(".") || "(root)"}: ${i.message}`).join("\n");
+  return { ok: false, report };
+}
+function publicActionSchema(entry, configure) {
+  return entry.schema(configure).pipe(Schema.omit(...ACTION_HARNESS_KEYS));
+}
+function safeJsonSchema(schema) {
+  try {
+    return JSONSchema.make(schema);
+  } catch {
+    return "(schema unavailable)";
+  }
+}
+function detectTriggerFields(jsonSchema) {
+  if (!jsonSchema || typeof jsonSchema !== "object") return [];
+  const props = jsonSchema.properties;
+  if (!props) return [];
+  const out = [];
+  for (const [name, spec] of Object.entries(props)) {
+    const s = spec;
+    const candidates = Array.isArray(s.anyOf) ? s.anyOf : [s];
+    for (const c of candidates) {
+      if (c?.type === "array" && c.items && typeof c.items === "object") {
+        const itemProps = c.items.properties ?? c.items.$ref;
+        if (typeof itemProps === "object" && "target" in itemProps && "operation" in itemProps) {
+          out.push(name);
+        } else if (typeof c.items.$ref === "string" && c.items.$ref.includes("Trigger")) {
+          out.push(name);
+        }
+      }
+    }
+  }
+  return out;
+}
+function validateTriggerRows(action, targets, configure) {
+  if (!targets) return null;
+  const byId = new Map(targets.filter((t) => t.id !== null).map((t) => [t.id, t]));
+  const validTargetsBlock = targets.filter((t) => t.id !== null).map((t) => `  - ${t.id}\uFF08${t.name}\uFF09: ${t.operations.map((o) => o.id).join(" / ")}`).join("\n");
+  const errors = [];
+  for (const [field, v] of Object.entries(action)) {
+    if (!Array.isArray(v) || v.length === 0) continue;
+    if (!v.every((x) => x && typeof x === "object" && typeof x.target === "string" && typeof x.operation === "string")) continue;
+    v.forEach((row, i) => {
+      const t = byId.get(row.target);
+      if (!t) {
+        errors.push(
+          `- ${field}[${i}].target "${row.target}" is not a reachable target from this actions bar. Valid targets (id\uFF08name\uFF09: operations):
+${validTargetsBlock || "  (none \u2014 this bar has no reachable targets)"}`
+        );
+        return;
+      }
+      const op = t.operations.find((o) => o.id === row.operation);
+      if (!op) {
+        errors.push(
+          `- ${field}[${i}].operation "${row.operation}" is not exposed by target "${t.name}" (${t.id}). Its operations: ${t.operations.map((o) => o.id).join(" / ")}.`
+        );
+        return;
+      }
+      if (op.compatibilityDate !== void 0) {
+        if (row.compatibilityDate !== op.compatibilityDate) {
+          errors.push(
+            `- ${field}[${i}]: operation "${op.id}" is parameterized \u2014 the row must carry compatibilityDate "${op.compatibilityDate}" (see list_operations).`
+          );
+        }
+        const opEntry = activeOperations().find((o) => o.type === row.operation);
+        if (opEntry) {
+          const paramsVerdict = decode(opEntry.schema(configure), row.params ?? {});
+          if (!paramsVerdict.ok) {
+            errors.push(
+              `- ${field}[${i}].params (operation "${op.id}"; contract in list_operations):
+` + paramsVerdict.report.split("\n").map((l) => `  ${l}`).join("\n")
+            );
+          } else {
+            v[i] = { ...row, params: paramsVerdict.value };
+          }
+        }
+      }
+    });
+  }
+  return errors.length > 0 ? errors.join("\n") : null;
+}
+function probeCelScope(configure) {
+  const env = new Environment({ unlistedVariablesAreDyn: false });
+  const baseline = new Set(env.getDefinitions().variables.map((v) => v.name));
+  configure(env);
+  const out = [];
+  for (const v of env.getDefinitions().variables) {
+    if (baseline.has(v.name)) continue;
+    out.push({
+      name: v.name,
+      type: v.type,
+      ...v.label && v.label !== v.name ? { label: v.label } : {},
+      ...v.description ? { description: v.description } : {}
+    });
+  }
+  return out;
+}
+function isDropdown(item) {
+  return Array.isArray(item.items);
+}
+function isButton(item) {
+  return item.action !== void 0 && typeof item.action === "object";
+}
+function itemKind(item) {
+  if (isDropdown(item)) return "dropdown";
+  if (isButton(item)) return "button";
+  return "item";
+}
+function isModalLayout(action) {
+  return action?.type === "com.shwfed.actions.button.modal.layout";
+}
+function locateButton(container, id) {
+  const items = Array.isArray(container.items) ? container.items : [];
+  const topIdx = items.findIndex((it) => it.id === id);
+  if (topIdx >= 0) {
+    return {
+      node: items[topIdx],
+      replace: (next) => {
+        container.items = items.map((it, i) => i === topIdx ? next : it);
+      }
+    };
+  }
+  for (let di = 0; di < items.length; di++) {
+    const dd = items[di];
+    if (!isDropdown(dd)) continue;
+    const subs = dd.items;
+    const subIdx = subs.findIndex((s) => s.id === id);
+    if (subIdx >= 0) {
+      return {
+        node: subs[subIdx],
+        replace: (next) => {
+          const nextSubs = subs.map((s, i) => i === subIdx ? next : s);
+          container.items = items.map((it, i) => i === di ? { ...dd, items: nextSubs } : it);
+        }
+      };
+    }
+  }
+  return void 0;
+}
+export function createActionsAiTools(deps) {
+  function readContainer() {
+    const c = deps.read();
+    return c && typeof c === "object" ? { ...c } : {};
+  }
+  function groupsOf(c) {
+    return Array.isArray(c.groups) ? [...c.groups] : [];
+  }
+  function itemsOf(c) {
+    return Array.isArray(c.items) ? [...c.items] : [];
+  }
+  function commit(c, next) {
+    deps.write({
+      ...c,
+      ...next.groups !== void 0 ? { groups: next.groups } : {},
+      ...next.items !== void 0 ? { items: next.items } : {}
+    });
+  }
+  const CelBool = Expression({ configure: deps.configure, resultType: "bool" });
+  return [
+    // ---- 信息获取 ----
+    {
+      name: "list_available_button_types",
+      description: "List the button (action) types you can insert into this actions bar. Returns each type's name and, when set, a one-line description of when to use it. Use this first to discover what buttons exist; for a button's full config contract, trigger fields, and gotchas call describe_specific_button_type. Deprecated types are hidden.",
+      inputJsonSchema: { type: "object", properties: {}, additionalProperties: false },
+      execute: () => activeButtons().map((b) => {
+        const entry = { type: b.type, name: b.metadata.name };
+        if (b.metadata.description !== void 0) entry.description = b.metadata.description;
+        return entry;
+      })
+    },
+    {
+      name: "describe_specific_button_type",
+      description: "Return, for one button type: the JSON Schema of its action config (without type/compatibilityDate \u2014 managed by the harness), the names of its trigger-list fields (e.g. `triggers`, `before`, `onSuccess` \u2014 each an ordered list of `{ target, operation, params }` rows), and \u2014 when the type has one \u2014 a prose `guide`. Call this before insert_button / configure_button to learn the contract. For a `modal.layout` button, its inner slot is configured by enter_node-ing into it. Deprecated types are not accepted.",
+      inputJsonSchema: {
+        type: "object",
+        properties: {
+          type: { type: "string", description: "A `type` value from list_available_button_types." }
+        },
+        required: ["type"],
+        additionalProperties: false
+      },
+      execute: (input) => {
+        const { type } = input ?? {};
+        if (typeof type !== "string" || type.length === 0) {
+          return "describe failed: `type` must be a non-empty string.";
+        }
+        const entry = activeButtons().find((b) => b.type === type);
+        if (!entry) {
+          return `describe failed: button type "${type}" is not available. Call list_available_button_types to see what is.`;
+        }
+        const jsonSchema = safeJsonSchema(publicActionSchema(entry, deps.configure));
+        const result = {
+          schema: jsonSchema,
+          triggerFields: detectTriggerFields(jsonSchema),
+          drillable: entry.type === "com.shwfed.actions.button.modal.layout"
+        };
+        if (entry.prompt !== void 0) result.guide = entry.prompt;
+        return result;
+      }
+    },
+    {
+      name: "list_operations",
+      description: "List the parameterized operations a trigger row can invoke (alert / send request / navigate / download \u2026), each with its params JSON Schema and \u2014 when it publishes a chain-step output \u2014 an `output` label. A trigger row is `{ target, operation, params }`: `operation` is this `type`, `params` is validated against this schema, and `compatibilityDate` (returned here) must be carried on the row. Param-LESS operations (a table's search / reset, the page's close) are NOT listed here \u2014 discover those via describe_event_targets, where each target lists the operation ids it exposes.",
+      inputJsonSchema: { type: "object", properties: {}, additionalProperties: false },
+      execute: () => activeOperations().map((o) => {
+        const entry = {
+          operation: o.type,
+          compatibilityDate: o.compatibilityDate,
+          name: o.metadata.name,
+          params: safeJsonSchema(o.schema(deps.configure))
+        };
+        if (o.metadata.description !== void 0) entry.description = o.metadata.description;
+        if (o.metadata.output !== void 0) entry.output = o.metadata.output;
+        if (o.prompt !== void 0) entry.guide = o.prompt;
+        return entry;
+      })
+    },
+    {
+      name: "describe_event_targets",
+      description: "List the instances a button in THIS actions bar can dispatch operations to \u2014 the valid `target` (an instance id) and, per target, the `operation` ids it exposes for a trigger row `{ target, operation, params }`. Targets are the page plus the operation-exposing hosts that enclose this actions bar (the owning table / tree, and any button hosting the modal you are inside). A trigger's `target` MUST be one id returned here. Operations whose entry carries a `compatibilityDate` are parameterized \u2014 consult list_operations for their params; the rest are param-less (search / reset / close / validate).",
+      inputJsonSchema: { type: "object", properties: {}, additionalProperties: false },
+      execute: () => {
+        if (!deps.eventTargets) {
+          return "This actions bar has no enclosing operation targets wired yet. A button here cannot reliably dispatch an operation.";
+        }
+        return deps.eventTargets();
+      }
+    },
+    {
+      name: "list_action_groups",
+      description: "Return the current button groups \u2014 each with its `id`, optional `variant` (the default variant new buttons in it inherit), and how many items it holds. Buttons live inside groups; get a group id here before insert_button, or create one with insert_action_group.",
+      inputJsonSchema: { type: "object", properties: {}, additionalProperties: false },
+      execute: () => {
+        const c = readContainer();
+        const groups = groupsOf(c);
+        const items = itemsOf(c);
+        return groups.map((g) => ({
+          id: g.id,
+          variant: g.variant ?? null,
+          itemCount: items.filter((it) => it.groupId === g.id).length
+        }));
+      }
+    },
+    {
+      name: "list_action_items",
+      description: "Return the current items in this actions bar. Each has an `id`, `groupId`, and `kind`: a `button` (with `buttonType`, its `title`, and `drillable` true for a modal.layout button you can enter_node into), a `dropdown` (with its `subItems`, each a button), or a plug-in `item`. Use this to discover ids before configure_button / set_action_item / delete_action_items / enter_node.",
+      inputJsonSchema: { type: "object", properties: {}, additionalProperties: false },
+      execute: () => {
+        const c = readContainer();
+        return itemsOf(c).map((it) => {
+          const kind = itemKind(it);
+          if (kind === "dropdown") {
+            return {
+              id: it.id,
+              groupId: it.groupId,
+              kind,
+              subItems: it.items.map((s) => ({
+                id: s.id,
+                buttonType: s.action?.type ?? null,
+                drillable: isModalLayout(s.action)
+              }))
+            };
+          }
+          if (kind === "button") {
+            return {
+              id: it.id,
+              groupId: it.groupId,
+              kind,
+              buttonType: it.action.type ?? null,
+              drillable: isModalLayout(it.action)
+            };
+          }
+          return { id: it.id, groupId: it.groupId, kind, type: it.type ?? null };
+        });
+      }
+    },
+    {
+      name: "describe_button_settings",
+      description: "Return one button's current action config values (including any trigger rows), its trigger-list field names, and the CEL scope for this actions bar: `celScope` lists every variable expressions here may reference (e.g. `row` for a table row action, `selected` / `query` for a table toolbar, `form` for a form field), and `celFunctions` is the operator & function catalog. Call this before configure_button to see what is set and what CEL you may write. Pass the item id from list_action_items (a top-level button or a dropdown sub-item).",
+      inputJsonSchema: {
+        type: "object",
+        properties: {
+          itemId: { type: "string", description: "A button item id from list_action_items." }
+        },
+        required: ["itemId"],
+        additionalProperties: false
+      },
+      execute: (input) => {
+        const { itemId } = input ?? {};
+        if (typeof itemId !== "string" || itemId.length === 0) {
+          return "describe_button_settings failed: `itemId` must be a non-empty string.";
+        }
+        const c = readContainer();
+        const loc = locateButton(c, itemId);
+        if (!loc || !isButton(loc.node)) {
+          return `describe_button_settings failed: no button with id "${itemId}". Call list_action_items to see ids.`;
+        }
+        const action = loc.node.action;
+        const entry = findButton(action.type, action.compatibilityDate) ?? activeButtons().find((b) => b.type === action.type);
+        const jsonSchema = entry ? safeJsonSchema(publicActionSchema(entry, deps.configure)) : "(schema unavailable)";
+        const { type: _t, compatibilityDate: _c, ...values } = action;
+        return {
+          buttonType: action.type,
+          values,
+          triggerFields: detectTriggerFields(jsonSchema),
+          schema: jsonSchema,
+          celScope: probeCelScope(deps.configure),
+          celFunctions: getCelCatalog()
+        };
+      }
+    },
+    // ---- 配置：分组 ----
+    {
+      name: "insert_action_group",
+      description: "Create a new empty button group and return its `id`. Buttons belong to a group; create one (or reuse an existing id from list_action_groups) before insert_button. `variant` optionally sets the group's default button variant.",
+      inputJsonSchema: {
+        type: "object",
+        properties: {
+          variant: {
+            type: "string",
+            enum: ["default", "primary", "destructive", "ghost", "link"],
+            description: "Optional default variant for buttons added to this group."
+          }
+        },
+        additionalProperties: false
+      },
+      execute: (input) => {
+        const { variant } = input ?? {};
+        const c = readContainer();
+        const groups = groupsOf(c);
+        const id = deps.genUuid();
+        const group = { id };
+        if (typeof variant === "string" && variant.length > 0) group.variant = variant;
+        commit(c, { groups: [...groups, group] });
+        return { id };
+      }
+    },
+    {
+      name: "delete_action_groups",
+      description: "Delete one or more button groups by id, along with every item inside them. Get ids from list_action_groups. On any unknown id the whole call is rejected without writing.",
+      inputJsonSchema: {
+        type: "object",
+        properties: {
+          ids: {
+            type: "array",
+            items: { type: "string", minLength: 1 },
+            minItems: 1,
+            description: "Group ids to delete. Get them from list_action_groups first."
+          }
+        },
+        required: ["ids"],
+        additionalProperties: false
+      },
+      execute: (input) => {
+        const raw = input ?? {};
+        const ids = raw.ids;
+        if (!Array.isArray(ids) || ids.length === 0) {
+          return "delete failed: `ids` must be a non-empty array of group ids.";
+        }
+        for (const id of ids) {
+          if (typeof id !== "string" || id.length === 0) {
+            return "delete failed: every `ids` entry must be a non-empty string.";
+          }
+        }
+        const c = readContainer();
+        const groups = groupsOf(c);
+        const existing = new Set(groups.map((g) => g.id));
+        for (const id of ids) {
+          if (!existing.has(id)) {
+            return `delete failed: group id "${id}" is not present. Call list_action_groups to see current ids.`;
+          }
+        }
+        const drop = new Set(ids);
+        commit(c, {
+          groups: groups.filter((g) => !drop.has(g.id)),
+          items: itemsOf(c).filter((it) => !drop.has(it.groupId))
+        });
+        return { deleted: ids, count: ids.length };
+      }
+    },
+    // ---- 配置：按钮 / 下拉 ----
+    {
+      name: "insert_button",
+      description: 'Add one button of the given `type` (from list_available_button_types). The harness mints the id and seeds an empty title; the button\'s action config starts minimal (invalid until you fill required fields via configure_button \u2014 mirror the human "add then configure" flow). Pass `groupId` to add into an existing group, or omit it to create a fresh group for this button. Pass `dropdownId` to add the button as a sub-item inside an existing dropdown instead. `title` optionally sets the label. Returns the new item id; configure it with configure_button, and for a modal.layout button enter_node into it.',
+      inputJsonSchema: {
+        type: "object",
+        properties: {
+          type: { type: "string", description: "A button type from list_available_button_types." },
+          groupId: { type: "string", description: "Existing group id (from list_action_groups); omit to create a new group." },
+          dropdownId: { type: "string", description: "Add as a sub-item of this dropdown item instead of a top-level button." },
+          title: { type: "string", description: "Optional button label." }
+        },
+        required: ["type"],
+        additionalProperties: false
+      },
+      execute: (input) => {
+        const { type, groupId, dropdownId, title } = input ?? {};
+        if (typeof type !== "string" || type.length === 0) {
+          return "insert_button failed: `type` must be a non-empty string.";
+        }
+        const entry = activeButtons().find((b) => b.type === type);
+        if (!entry) {
+          return `insert_button failed: button type "${type}" is not available. Call list_available_button_types to see what is.`;
+        }
+        const c = readContainer();
+        const items = itemsOf(c);
+        const action = { type: entry.type, compatibilityDate: entry.compatibilityDate };
+        if (typeof dropdownId === "string" && dropdownId.length > 0) {
+          const idx = items.findIndex((it) => it.id === dropdownId);
+          if (idx < 0 || !isDropdown(items[idx])) {
+            return `insert_button failed: no dropdown with id "${dropdownId}". Call list_action_items to see dropdown ids.`;
+          }
+          const sub = { id: deps.genUuid(), title: toLocale(title), action };
+          const dd = items[idx];
+          const nextItems = items.map((it, i) => i === idx ? { ...dd, items: [...dd.items, sub] } : it);
+          commit(c, { items: nextItems });
+          return { id: sub.id, buttonType: type, dropdownId };
+        }
+        const groups = groupsOf(c);
+        let gid;
+        let nextGroups = groups;
+        if (typeof groupId === "string" && groupId.length > 0) {
+          if (!groups.some((g) => g.id === groupId)) {
+            return `insert_button failed: group id "${groupId}" is not present. Call list_action_groups, or omit groupId to create one.`;
+          }
+          gid = groupId;
+        } else {
+          gid = deps.genUuid();
+          nextGroups = [...groups, { id: gid }];
+        }
+        const item = { id: deps.genUuid(), groupId: gid, title: toLocale(title), action };
+        commit(c, { groups: nextGroups, items: [...items, item] });
+        return { id: item.id, buttonType: type, groupId: gid };
+      }
+    },
+    {
+      name: "insert_dropdown",
+      description: "Add an empty dropdown menu item to this actions bar. A dropdown groups several buttons behind one trigger; add buttons into it with insert_button ({ dropdownId }). Pass `groupId` to place it in an existing group, or omit to create a fresh group. `title` optionally sets the dropdown trigger label. Returns the new dropdown id.",
+      inputJsonSchema: {
+        type: "object",
+        properties: {
+          groupId: { type: "string", description: "Existing group id; omit to create a new group." },
+          title: { type: "string", description: "Optional dropdown trigger label." }
+        },
+        additionalProperties: false
+      },
+      execute: (input) => {
+        const { groupId, title } = input ?? {};
+        const c = readContainer();
+        const items = itemsOf(c);
+        const groups = groupsOf(c);
+        let gid;
+        let nextGroups = groups;
+        if (typeof groupId === "string" && groupId.length > 0) {
+          if (!groups.some((g) => g.id === groupId)) {
+            return `insert_dropdown failed: group id "${groupId}" is not present. Call list_action_groups, or omit groupId.`;
+          }
+          gid = groupId;
+        } else {
+          gid = deps.genUuid();
+          nextGroups = [...groups, { id: gid }];
+        }
+        const dropdown = { id: deps.genUuid(), groupId: gid, title: toLocale(title), items: [] };
+        commit(c, { groups: nextGroups, items: [...items, dropdown] });
+        return { id: dropdown.id, groupId: gid };
+      }
+    },
+    {
+      name: "configure_button",
+      description: "Set a button's action config \u2014 its own fields (e.g. a request expression, a state path/value, a modal title) AND its trigger lists (`triggers` / `before` / `onSuccess` / \u2026 , each an ordered list of `{ target, operation, params, compatibilityDate }` rows). Pass `itemId` (a button or dropdown sub-item id) plus `values` with only the action fields you want to set; omitted fields keep their current value. Discover targets/operations with describe_event_targets + list_operations first \u2014 every trigger row's `target` MUST be an id from describe_event_targets and its `operation` one that target exposes (the tool rejects anything else, listing the valid options), and a parameterized operation's `params` are validated against its schema. On validation failure the tool returns the issues; fix and call again. (A modal.layout button's inner slot is configured by enter_node, not here.)",
+      inputJsonSchema: {
+        type: "object",
+        properties: {
+          itemId: { type: "string", description: "The button item id (from list_action_items)." },
+          values: {
+            type: "object",
+            description: "Action config fields to set (merged over current). See describe_specific_button_type for the contract.",
+            additionalProperties: true
+          }
+        },
+        required: ["itemId", "values"],
+        additionalProperties: false
+      },
+      execute: (input) => {
+        const { itemId, values } = input ?? {};
+        if (typeof itemId !== "string" || itemId.length === 0) {
+          return "configure_button failed: `itemId` must be a non-empty string.";
+        }
+        if (!values || typeof values !== "object" || Array.isArray(values)) {
+          return "configure_button failed: `values` must be an object of action fields.";
+        }
+        for (const k of ACTION_HARNESS_KEYS) {
+          if (k in values) {
+            return `configure_button failed: do not pass \`${k}\` \u2014 it is fixed by the button type.`;
+          }
+        }
+        const c = readContainer();
+        const loc = locateButton(c, itemId);
+        if (!loc || !isButton(loc.node)) {
+          return `configure_button failed: no button with id "${itemId}". Call list_action_items to see ids.`;
+        }
+        const action = loc.node.action;
+        const entry = findButton(action.type, action.compatibilityDate) ?? activeButtons().find((b) => b.type === action.type);
+        if (!entry) {
+          return `configure_button failed: this button's type "${action.type}" is no longer available.`;
+        }
+        const schema = publicActionSchema(entry, deps.configure);
+        const { type: _t, compatibilityDate: _c, ...current } = action;
+        const verdict = decode(schema, { ...current, ...values });
+        if (!verdict.ok) {
+          return `configure_button failed for "${entry.type}". Fix these and call configure_button again:
+${verdict.report}`;
+        }
+        const triggerReport = validateTriggerRows(verdict.value, deps.eventTargets?.(), deps.configure);
+        if (triggerReport !== null) {
+          return `configure_button failed for "${entry.type}". Fix these and call configure_button again:
+${triggerReport}`;
+        }
+        for (const v of Object.values(verdict.value)) {
+          if (!Array.isArray(v) || v.length === 0) continue;
+          if (!v.every((x) => x && typeof x === "object" && typeof x.target === "string" && typeof x.operation === "string")) continue;
+          v.forEach((row, i) => {
+            if (typeof row.id !== "string" || row.id.length === 0) {
+              v[i] = { ...row, id: deps.genUuid() };
+            }
+          });
+        }
+        loc.replace({ ...loc.node, action: { type: entry.type, compatibilityDate: entry.compatibilityDate, ...verdict.value } });
+        deps.write(c);
+        return { id: itemId, buttonType: entry.type };
+      }
+    },
+    {
+      name: "set_action_item",
+      description: "Set a button item's shell (chrome) fields \u2014 everything but its action: `title` (label), `icon`, `variant`, `hideTitle` (icon-only), and the CEL `hidden` / `disabled` conditions (each an expression returning bool). Pass `itemId` plus only the fields to change. Use configure_button for the button's behaviour; use this for how it looks. On a CEL error the tool returns the issue; fix and call again.",
+      inputJsonSchema: {
+        type: "object",
+        properties: {
+          itemId: { type: "string", description: "The button item id (from list_action_items)." },
+          title: { type: "string", description: "Button label." },
+          icon: { type: "string", description: "Iconify icon id, e.g. `fluent:search-20-regular`." },
+          variant: { type: "string", enum: ["default", "primary", "destructive", "ghost", "link"] },
+          hideTitle: { type: "boolean", description: "Show only the icon." },
+          hidden: { type: "string", description: "CEL bool expression; true \u2192 button hidden." },
+          disabled: { type: "string", description: "CEL bool expression; true \u2192 button visible but disabled." }
+        },
+        required: ["itemId"],
+        additionalProperties: false
+      },
+      execute: (input) => {
+        const raw = input ?? {};
+        const { itemId } = raw;
+        if (typeof itemId !== "string" || itemId.length === 0) {
+          return "set_action_item failed: `itemId` must be a non-empty string.";
+        }
+        const c = readContainer();
+        const loc = locateButton(c, itemId);
+        if (!loc || !isButton(loc.node)) {
+          return `set_action_item failed: no button with id "${itemId}". Call list_action_items to see ids.`;
+        }
+        for (const k of ["hidden", "disabled"]) {
+          const v = raw[k];
+          if (v === void 0) continue;
+          if (typeof v !== "string") return `set_action_item failed: \`${k}\` must be a string CEL expression.`;
+          if (v.length === 0) continue;
+          const res = Schema.decodeUnknownEither(CelBool)(v);
+          if (res._tag === "Left") {
+            const msg = ParseResult.ArrayFormatter.formatErrorSync(res.left)[0]?.message ?? "invalid";
+            return `set_action_item failed. Fix this and call again:
+- ${k}: ${msg}`;
+          }
+        }
+        const next = { ...loc.node };
+        if (typeof raw.title === "string") next.title = toLocale(raw.title);
+        if (typeof raw.icon === "string") next.icon = raw.icon;
+        if (typeof raw.variant === "string") next.variant = raw.variant;
+        if (typeof raw.hideTitle === "boolean") next.hideTitle = raw.hideTitle;
+        for (const k of ["hidden", "disabled"]) {
+          const v = raw[k];
+          if (typeof v !== "string") continue;
+          if (v.length === 0) Reflect.deleteProperty(next, k);
+          else next[k] = v;
+        }
+        loc.replace(next);
+        deps.write(c);
+        return { id: itemId };
+      }
+    },
+    {
+      name: "delete_action_items",
+      description: "Delete one or more items by id \u2014 a top-level button, a dropdown, or a dropdown sub-item. Get ids from list_action_items. On any unknown id the whole call is rejected without writing. Deleting the last item of a group leaves the (empty) group; delete it separately with delete_action_groups.",
+      inputJsonSchema: {
+        type: "object",
+        properties: {
+          ids: {
+            type: "array",
+            items: { type: "string", minLength: 1 },
+            minItems: 1,
+            description: "Item ids to delete. Get them from list_action_items first."
+          }
+        },
+        required: ["ids"],
+        additionalProperties: false
+      },
+      execute: (input) => {
+        const raw = input ?? {};
+        const ids = raw.ids;
+        if (!Array.isArray(ids) || ids.length === 0) {
+          return "delete failed: `ids` must be a non-empty array of item ids.";
+        }
+        for (const id of ids) {
+          if (typeof id !== "string" || id.length === 0) {
+            return "delete failed: every `ids` entry must be a non-empty string.";
+          }
+        }
+        const seen = /* @__PURE__ */ new Set();
+        for (const id of ids) {
+          if (seen.has(id)) return `delete failed: duplicate id "${id}" in input \u2014 dedupe and call again.`;
+          seen.add(id);
+        }
+        const c = readContainer();
+        const items = itemsOf(c);
+        const known = /* @__PURE__ */ new Set();
+        for (const it of items) {
+          known.add(it.id);
+          if (isDropdown(it)) for (const s of it.items) known.add(s.id);
+        }
+        for (const id of ids) {
+          if (!known.has(id)) {
+            return `delete failed: item id "${id}" is not present. Call list_action_items to see current ids.`;
+          }
+        }
+        const drop = new Set(ids);
+        const nextItems = items.filter((it) => !drop.has(it.id)).map((it) => {
+          if (!isDropdown(it)) return it;
+          const subs = it.items.filter((s) => !drop.has(s.id));
+          return subs.length === it.items.length ? it : { ...it, items: subs };
+        });
+        commit(c, { items: nextItems });
+        return { deleted: ids, count: ids.length };
+      }
+    }
+  ];
+}