@blokkli/editor 2.0.0-alpha.58 → 2.0.0-alpha.59

package/dist/modules/agent/runtime/app/tools/delegate_text_rewrite/useFieldRewriteStream.js

@@ -0,0 +1,502 @@
+import { useBlokkli, ref, reactive } from "#imports";
+import { routeStream } from "#blokkli-build/agent-client";
+import { useEditableFieldOverride } from "#blokkli/editor/composables";
+import { applyOperations, resolveHost as resolveBlockHost } from "../helpers.js";
+import { worstReadability } from "../readability.js";
+export function useFieldRewriteStream(options) {
+  const { context, params, onComplete } = options;
+  const blokkli = useBlokkli();
+  const { $t, types, eventBus } = blokkli;
+  const phase = ref("streaming");
+  const errorMessage = ref("");
+  const streamUsage = ref();
+  const MAX_READABILITY_RETRIES = 10;
+  const isFixReadability = params.template === "fix_readability";
+  const retryAttempt = ref(0);
+  const streamingTitle = ref(
+    $t("aiAgentDelegateRewriteStreaming", "Rewriting @count fields", {
+      more: true
+    }).replace("@count", String(params.fields.length))
+  );
+  function resolveHost(uuid) {
+    const host = resolveBlockHost(blokkli, uuid);
+    return host ? { type: host.entityType, bundle: host.bundle, uuid: host.uuid } : null;
+  }
+  function resolveFieldLabel(uuid, fieldName) {
+    const host = resolveHost(uuid);
+    if (!host) return fieldName;
+    const config = types.editableFieldConfig.forName(
+      host.type,
+      host.bundle,
+      fieldName
+    );
+    return config?.label || fieldName;
+  }
+  const fieldStates = reactive(
+    params.fields.map((f) => ({
+      uuid: f.uuid,
+      fieldName: f.fieldName,
+      fieldLabel: resolveFieldLabel(f.uuid, f.fieldName),
+      status: "pending",
+      mode: null,
+      fullValue: "",
+      operations: [],
+      allOperations: [],
+      currentSearch: "",
+      baseValue: f.currentValue,
+      originalBaseValue: f.currentValue
+    }))
+  );
+  const overrides = [];
+  let abortController = null;
+  let cancelled = false;
+  for (const field of params.fields) {
+    const host = resolveHost(field.uuid);
+    if (!host) continue;
+    const override = useEditableFieldOverride(field.fieldName, host);
+    overrides.push({
+      uuid: field.uuid,
+      fieldName: field.fieldName,
+      element: override.element,
+      setValue: override.setValue,
+      restore: override.restore,
+      originalValue: override.originalValue
+    });
+  }
+  function findOverride(uuid, fieldName) {
+    return overrides.find((o) => o.uuid === uuid && o.fieldName === fieldName);
+  }
+  function findFieldState(uuid, fieldName) {
+    return fieldStates.find((f) => f.uuid === uuid && f.fieldName === fieldName);
+  }
+  let markupBuffer = "";
+  let markupBufferField = null;
+  let markupFlushTimer = null;
+  function flushMarkupBuffer() {
+    if (markupBufferField && markupBuffer) {
+      const override = findOverride(
+        markupBufferField.uuid,
+        markupBufferField.fieldName
+      );
+      if (override) {
+        override.setValue(markupBuffer);
+      }
+    }
+    if (markupFlushTimer) {
+      clearTimeout(markupFlushTimer);
+      markupFlushTimer = null;
+    }
+  }
+  function getFieldType(uuid, fieldName) {
+    const field = params.fields.find(
+      (f) => f.uuid === uuid && f.fieldName === fieldName
+    );
+    return field?.fieldType || "plain";
+  }
+  function applyDelta(uuid, fieldName, value) {
+    const fieldType = getFieldType(uuid, fieldName);
+    if (fieldType === "markup") {
+      markupBuffer = value;
+      markupBufferField = { uuid, fieldName };
+      if (value.endsWith(">")) {
+        flushMarkupBuffer();
+      } else {
+        if (markupFlushTimer) clearTimeout(markupFlushTimer);
+        markupFlushTimer = setTimeout(flushMarkupBuffer, 100);
+      }
+    } else {
+      const override = findOverride(uuid, fieldName);
+      if (override) {
+        override.setValue(value);
+      }
+    }
+  }
+  function computePatchPreview(baseValue, operations, currentSearch, partialReplace) {
+    let result = applyOperations(baseValue, operations);
+    if (currentSearch && partialReplace) {
+      const idx = result.indexOf(currentSearch);
+      if (idx !== -1) {
+        result = result.slice(0, idx) + partialReplace + result.slice(idx + currentSearch.length);
+      }
+    }
+    return result;
+  }
+  function getProposedValue(fs) {
+    if (fs.status !== "done") return fs.baseValue;
+    if (fs.mode === "patch") {
+      return applyOperations(fs.baseValue, fs.operations);
+    }
+    return fs.fullValue;
+  }
+  async function analyzeReadability() {
+    const textFields = [];
+    for (const fs of fieldStates) {
+      if (fs.status !== "done") continue;
+      const field = params.fields.find(
+        (f) => f.uuid === fs.uuid && f.fieldName === fs.fieldName
+      );
+      if (!field) continue;
+      textFields.push({
+        uuid: fs.uuid,
+        fieldName: fs.fieldName,
+        value: getProposedValue(fs),
+        fieldType: field.fieldType,
+        entityType: field.entityType,
+        entityBundle: field.entityBundle
+      });
+    }
+    const rawAnalysis = await context.app.readability.analyzeFieldValues(textFields);
+    const fieldMap = /* @__PURE__ */ new Map();
+    for (const fs of fieldStates) {
+      const key = fs.uuid + ":" + fs.fieldName;
+      const analysisKey = fs.uuid + "/" + fs.fieldName;
+      const fieldResult = rawAnalysis[analysisKey];
+      const chunks = fieldResult?.chunks ?? [];
+      const issues = chunks.filter(
+        (c) => c.score !== null && (c.band === "hard" || c.band === "ok")
+      ).map((c) => ({ text: c.text, impact: c.impact, score: c.score }));
+      const worst = worstReadability(chunks);
+      const worstLevel = worst?.level ?? "good";
+      const worstScore = worst?.score;
+      fieldMap.set(key, { issues, worstLevel, worstScore });
+    }
+    return fieldMap;
+  }
+  function addUsage(usage) {
+    if (!streamUsage.value) {
+      streamUsage.value = { ...usage };
+    } else {
+      streamUsage.value.inputTokens += usage.inputTokens;
+      streamUsage.value.outputTokens += usage.outputTokens;
+      streamUsage.value.cacheCreationInputTokens += usage.cacheCreationInputTokens;
+      streamUsage.value.cacheReadInputTokens += usage.cacheReadInputTokens;
+    }
+  }
+  function findBlockElementForText(fieldElement, text) {
+    const blockTags = /* @__PURE__ */ new Set([
+      "P",
+      "H1",
+      "H2",
+      "H3",
+      "H4",
+      "H5",
+      "H6",
+      "LI",
+      "BLOCKQUOTE"
+    ]);
+    for (const child of fieldElement.children) {
+      if (blockTags.has(child.tagName) && child.textContent?.includes(text.slice(0, 40))) {
+        return child;
+      }
+    }
+    return fieldElement;
+  }
+  let lastScrollTarget = "";
+  function scrollToFieldText(uuid, fieldName, text) {
+    const override = findOverride(uuid, fieldName);
+    if (!override?.element) {
+      eventBus.emit("scrollIntoView", { uuid, immediate: false });
+      return;
+    }
+    const target = text && override.element ? findBlockElementForText(override.element, text) : override.element;
+    const key = uuid + ":" + fieldName + ":" + (target?.textContent?.slice(0, 20) || "");
+    if (key === lastScrollTarget) return;
+    lastScrollTarget = key;
+    eventBus.emit("scrollIntoView", { element: target, immediate: false });
+  }
+  function handleSSEEvent(eventType, data) {
+    try {
+      const parsed = JSON.parse(data);
+      switch (eventType) {
+        case "field_start": {
+          const fs = findFieldState(parsed.uuid, parsed.fieldName);
+          if (fs) {
+            fs.status = "streaming";
+            fs.mode = parsed.mode || "full";
+          }
+          lastScrollTarget = "";
+          scrollToFieldText(parsed.uuid, parsed.fieldName);
+          break;
+        }
+        case "field_delta": {
+          const fs = findFieldState(parsed.uuid, parsed.fieldName);
+          if (fs) fs.fullValue = parsed.value;
+          applyDelta(parsed.uuid, parsed.fieldName, parsed.value);
+          break;
+        }
+        case "replace_delta": {
+          const fs = findFieldState(parsed.uuid, parsed.fieldName);
+          if (fs) {
+            if (parsed.search !== fs.currentSearch) {
+              scrollToFieldText(parsed.uuid, parsed.fieldName, parsed.search);
+            }
+            fs.currentSearch = parsed.search;
+            const preview = computePatchPreview(
+              fs.baseValue,
+              fs.operations,
+              parsed.search,
+              parsed.value
+            );
+            applyDelta(parsed.uuid, parsed.fieldName, preview);
+          }
+          break;
+        }
+        case "operation_end": {
+          const fs = findFieldState(parsed.uuid, parsed.fieldName);
+          if (fs) {
+            fs.operations.push({
+              search: parsed.search,
+              replace: parsed.replace
+            });
+            fs.currentSearch = "";
+            const value = applyOperations(fs.baseValue, fs.operations);
+            applyDelta(parsed.uuid, parsed.fieldName, value);
+          }
+          break;
+        }
+        case "field_end": {
+          if (markupBufferField && markupBufferField.uuid === parsed.uuid && markupBufferField.fieldName === parsed.fieldName) {
+            flushMarkupBuffer();
+          }
+          const fs = findFieldState(parsed.uuid, parsed.fieldName);
+          if (fs) {
+            fs.status = "done";
+            const override = findOverride(parsed.uuid, parsed.fieldName);
+            if (override) {
+              let finalValue;
+              if (fs.mode === "patch") {
+                finalValue = applyOperations(fs.baseValue, fs.operations);
+              } else {
+                finalValue = fs.fullValue;
+              }
+              override.setValue(finalValue);
+            }
+          }
+          break;
+        }
+        case "error": {
+          phase.value = "error";
+          errorMessage.value = parsed.message || "Stream error";
+          break;
+        }
+        case "done": {
+          if (parsed.usage) {
+            addUsage(parsed.usage);
+          }
+          break;
+        }
+      }
+    } catch {
+    }
+  }
+  async function fetchStream(authToken, requestFields, templateParams) {
+    abortController = new AbortController();
+    try {
+      const response = await fetch(routeStream, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          authToken,
+          template: params.template,
+          templateParams,
+          fields: requestFields,
+          pageContext: context.pageContext
+        }),
+        signal: abortController.signal
+      });
+      if (!response.ok || !response.body) {
+        phase.value = "error";
+        errorMessage.value = `Server returned ${response.status}`;
+        return false;
+      }
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        let eventType = "";
+        let eventData = "";
+        for (const line of lines) {
+          if (line.startsWith("event: ")) {
+            eventType = line.slice(7);
+          } else if (line.startsWith("data: ")) {
+            eventData = line.slice(6);
+          } else if (line === "" && eventType && eventData) {
+            handleSSEEvent(eventType, eventData);
+            eventType = "";
+            eventData = "";
+          }
+        }
+      }
+      flushMarkupBuffer();
+      return true;
+    } catch (error) {
+      if (abortController?.signal.aborted) {
+        restoreAll();
+        cancelled = true;
+        return false;
+      }
+      phase.value = "error";
+      errorMessage.value = error instanceof Error ? error.message : "Unknown error";
+      return false;
+    }
+  }
+  async function readabilityRetryLoop(authToken) {
+    for (let attempt = 0; attempt < MAX_READABILITY_RETRIES; attempt++) {
+      streamingTitle.value = $t(
+        "checkingReadability",
+        "Checking readability..."
+      );
+      const analysis = await analyzeReadability();
+      const failing = [];
+      const passing = [];
+      for (const fs of fieldStates) {
+        if (fs.status !== "done") continue;
+        const field = params.fields.find(
+          (f) => f.uuid === fs.uuid && f.fieldName === fs.fieldName
+        );
+        if (!field) continue;
+        const key = fs.uuid + ":" + fs.fieldName;
+        const entry = analysis.get(key);
+        const level = entry?.worstLevel ?? "good";
+        const score = entry?.worstScore;
+        const issues = entry?.issues ?? [];
+        const proposedValue = getProposedValue(fs);
+        const check = {
+          fs,
+          fieldType: field.fieldType,
+          proposedValue,
+          level,
+          score,
+          issues
+        };
+        if (level === "hard" || level === "ok") {
+          failing.push(check);
+        } else {
+          passing.push(check);
+        }
+      }
+      if (failing.length === 0) break;
+      if (attempt === MAX_READABILITY_RETRIES - 1) break;
+      const retryFieldsData = failing.map((f, i) => ({
+        fieldIndex: i,
+        fieldLabel: f.fs.fieldLabel,
+        originalValue: f.fs.originalBaseValue,
+        previousAttempt: f.proposedValue,
+        score: f.score
+      }));
+      const passingFieldsData = passing.map((p) => ({
+        fieldLabel: p.fs.fieldLabel,
+        value: p.proposedValue,
+        score: p.score
+      }));
+      for (const f of failing) {
+        f.fs.allOperations.push(...f.fs.operations);
+        f.fs.status = "pending";
+        f.fs.mode = null;
+        f.fs.baseValue = f.proposedValue;
+        f.fs.fullValue = "";
+        f.fs.operations = [];
+        f.fs.currentSearch = "";
+      }
+      retryAttempt.value = attempt + 1;
+      const retryFields = failing.map((f) => ({
+        uuid: f.fs.uuid,
+        fieldName: f.fs.fieldName,
+        currentValue: f.proposedValue,
+        fieldType: f.fieldType
+      }));
+      const retryIssues = [];
+      for (let i = 0; i < failing.length; i++) {
+        for (const issue of failing[i].issues) {
+          retryIssues.push({
+            fieldIndex: i,
+            text: issue.text,
+            impact: issue.impact || "critical",
+            score: issue.score ?? 0
+          });
+        }
+      }
+      streamingTitle.value = $t(
+        "aiAgentDelegateRewriteRetrying",
+        "Retrying @count fields (attempt @attempt)",
+        { more: true }
+      ).replace("@count", String(failing.length)).replace("@attempt", String(retryAttempt.value + 1));
+      let retryToken = authToken;
+      if (context.adapter.getAgentAuthToken) {
+        const fresh = await context.adapter.getAgentAuthToken();
+        if (fresh) retryToken = fresh;
+      }
+      const retrySuccess = await fetchStream(retryToken, retryFields, {
+        issues: retryIssues,
+        scoreLabel: context.app.readability.scoreLabel.value,
+        scoreReference: context.app.readability.getAgentContext(),
+        retryFields: retryFieldsData,
+        passingFields: passingFieldsData
+      });
+      if (!retrySuccess) return;
+    }
+  }
+  function restoreAll() {
+    for (const override of overrides) {
+      override.restore();
+    }
+  }
+  async function start() {
+    let authToken = null;
+    if (context.adapter.getAgentAuthToken) {
+      authToken = await context.adapter.getAgentAuthToken();
+    }
+    if (!authToken) {
+      phase.value = "error";
+      errorMessage.value = "Failed to get authentication token";
+      return { cancelled };
+    }
+    const requestFields = params.fields.map((f) => ({
+      uuid: f.uuid,
+      fieldName: f.fieldName,
+      currentValue: f.currentValue,
+      fieldType: f.fieldType
+    }));
+    const success = await fetchStream(
+      authToken,
+      requestFields,
+      params.templateParams
+    );
+    if (!success) return { cancelled };
+    if (isFixReadability) {
+      await readabilityRetryLoop(authToken);
+      if (phase.value !== "streaming") return { cancelled };
+    }
+    onComplete();
+    return { cancelled };
+  }
+  function abort() {
+    if (abortController) {
+      abortController.abort();
+    }
+  }
+  function dispose() {
+    abort();
+    if (markupFlushTimer) {
+      clearTimeout(markupFlushTimer);
+    }
+  }
+  return {
+    phase,
+    errorMessage,
+    streamingTitle,
+    streamUsage,
+    fieldStates,
+    findFieldState,
+    findOverride,
+    start,
+    restoreAll,
+    abort,
+    dispose
+  };
+}

package/dist/modules/agent/runtime/app/tools/delete_paragraphs/index.js

@@ -10,13 +10,13 @@ const paramsSchema = z.object({
 });
 export default defineBlokkliAgentTool({
   name: "delete_paragraphs",
-  description: "Delete one or more paragraphs from the page. Requires user approval before the paragraphs are actually deleted.",
+  description: "Delete one or more paragraphs from the page.",
   category: "mutation",
   lazy: true,
   prunedSummary: (r) => r.success ? "deleted paragraphs" : "rejected",
   modes: ["editing"],
   label($t) {
-    return $t("aiAgentDeleteBlocksRunning", "Deleting blocks...");
+    return $t("aiAgentDeleteBlocksRunning", "Deleting blocks", { more: true });
   },
   paramsSchema,
   resultSchema: mutationResultSchema,

package/dist/modules/agent/runtime/app/tools/detach_reusable_paragraph/index.js

@@ -13,11 +13,13 @@ export default defineBlokkliAgentTool({
   name: "detach_reusable_paragraph",
   description: "Detach one or more library paragraphs to create editable copies. IMPORTANT: The original library paragraph UUIDs will no longer exist after detaching. The result includes newParagraphs containing the UUIDs and bundles of the newly created editable paragraph. Use these new UUIDs for any subsequent operations.",
   category: "mutation",
-  prunedSummary: (r) => r.success ? `detached ${r.newParagraphs?.length || 0} paragraphs` : "rejected",
+  prunedSummary: (r) => r.success ? "detached paragraphs" : "rejected",
   lazy: true,
   modes: ["editing"],
   label($t) {
-    return $t("aiAgentDetachLibraryBlockRunning", "Detaching library block...");
+    return $t("aiAgentDetachLibraryBlockRunning", "Detaching library block", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema: mutationResultSchema,

package/dist/modules/agent/runtime/app/tools/duplicate_paragraphs/index.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { defineBlokkliAgentTool } from "#blokkli/agent/app/composables";
 import { mutationResultSchema, parentSchema, positionSchema } from "../schemas.js";
-import { resolvePosition } from "../helpers.js";
+import { resolvePosition, resolveHost } from "../helpers.js";
 import {
   validateBlocksExist,
   validateSameField,
@@ -11,7 +11,6 @@ import {
   requireNoRestrictedAncestor
 } from "../../helpers/validation.js";
 import { getFieldKey } from "#blokkli/helpers";
-import { itemEntityType } from "#blokkli-build/config";
 const paramsSchema = z.object({
   uuids: z.array(z.string()).min(1).describe("Paragraph UUIDs to duplicate"),
   parent: parentSchema.optional().describe("Target parent field. If omitted, duplicates in same field."),
@@ -27,13 +26,15 @@ export default defineBlokkliAgentTool({
   modes: ["editing"],
   lazy: true,
   label($t) {
-    return $t("aiAgentDuplicateBlocksRunning", "Duplicating blocks...");
+    return $t("aiAgentDuplicateBlocksRunning", "Duplicating blocks", {
+      more: true
+    });
   },
   paramsSchema,
   resultSchema: mutationResultSchema,
   requiredAdapterMethods: ["duplicateBlocks"],
   execute(ctx, params) {
-    const { $t, types, context, blocks } = ctx.app;
+    const { $t, types } = ctx.app;
     const blocksResult = validateBlocksExist(ctx.app, params.uuids);
     if ("error" in blocksResult) return blocksResult;
     const denied = requireBundlePermission(
@@ -50,12 +51,11 @@ export default defineBlokkliAgentTool({
           error: "Duplicating to another field is not supported by this adapter"
         };
       }
-      const isRootEntity = params.parent.uuid === context.value.entityUuid;
-      const entityType = isRootEntity ? context.value.entityType : itemEntityType;
-      const targetBundle = isRootEntity ? context.value.entityBundle : blocks.getBlock(params.parent.uuid)?.bundle;
-      if (!targetBundle) {
+      const host = resolveHost(ctx.app, params.parent.uuid);
+      if (!host) {
         return { error: "Target parent not found." };
       }
+      const { entityType, bundle: targetBundle, isRoot: isRootEntity } = host;
       if (!isRootEntity && ctx.app.permissions.blockHasRestrictedAncestor(params.parent.uuid)) {
         return {
           error: "Permission denied: target parent is inside a block with restricted editing permissions"

package/dist/modules/agent/runtime/app/tools/fieldDiffApproval.d.ts

@@ -0,0 +1,49 @@
+import type { BlokkliApp } from '#blokkli/editor/types/app';
+import type { FullBlokkliAdapter } from '#blokkli/editor/adapter';
+import type { ApprovalItem } from '#blokkli/editor/components/DiffApproval/types';
+/** Map of rejected paragraph UUID → field name → rejection details. */
+export type RejectedByUser = Record<string, Record<string, {
+    reasonForRejection: string;
+}>>;
+/**
+ * A field reference (uuid + field name) that was dropped before applying,
+ * because the paragraph or the field does not exist. Reported back to the agent
+ * so it can correct the reference instead of silently getting no change.
+ */
+export type SkippedField = {
+    uuid: string;
+    fieldName: string;
+    reason: string;
+};
+/**
+ * Build the agent-facing note listing skipped field references. Returns
+ * undefined when nothing was skipped. Shared by `update_text_fields` and
+ * `delegate_text_rewrite`, which both drop references that don't resolve.
+ */
+export declare function skippedFieldsMessage(skipped: SkippedField[]): string | undefined;
+/**
+ * Append a secondary note to an agent message, tolerating undefined on either
+ * side. Used to add the skipped-fields note to every terminal `agentMessage`.
+ */
+export declare function appendAgentNote(message: string | undefined, note: string | undefined): string | undefined;
+export type FieldDiffApplyResult = {
+    acceptedCount: number;
+    rejectedByUser: RejectedByUser;
+    label: string;
+};
+/**
+ * Apply the user's accept/reject decisions for a batch of field diffs: split
+ * the accepted items into entity-level vs block-level updates, run the batched
+ * mutation, and return the accepted count, rejection map, and a summary label.
+ *
+ * Shared by `update_text_fields` and `delegate_text_rewrite`, which both render
+ * the same diff-approval UI and report the same accepted/rejected outcome. Each
+ * caller layers its own `agentMessage` / details / usage on top of the result.
+ */
+export declare function applyFieldDiffs(app: BlokkliApp, adapter: FullBlokkliAdapter<any>, items: ApprovalItem[], selected: Record<number, boolean>, reasons: Record<number, string>): Promise<FieldDiffApplyResult>;
+/**
+ * The follow-up instruction to give the agent when the user rejected fields
+ * without a reason. Returns undefined when every rejection had a reason (or
+ * there were none).
+ */
+export declare function rejectedWithoutReasonMessage(rejectedByUser: RejectedByUser): string | undefined;

package/dist/modules/agent/runtime/app/tools/fieldDiffApproval.js

@@ -0,0 +1,64 @@
+export function skippedFieldsMessage(skipped) {
+  if (!skipped.length) return void 0;
+  const list = skipped.map((s) => `"${s.uuid}" ${s.fieldName} (${s.reason})`).join(", ");
+  return `Skipped ${skipped.length} field update(s) for references that don't exist: ${list}. Use get_page_structure or find_paragraphs to get valid paragraph UUIDs and field names.`;
+}
+export function appendAgentNote(message, note) {
+  if (!note) return message;
+  if (!message) return note;
+  return `${message}
+
+${note}`;
+}
+export async function applyFieldDiffs(app, adapter, items, selected, reasons) {
+  const { $t, state, context } = app;
+  const entityUuid = context.value.entityUuid;
+  const rejectedByUser = {};
+  const batchItems = [];
+  const entityItems = [];
+  for (const item of items) {
+    if (!selected[item.id]) {
+      const fields = rejectedByUser[item.uuid] ?? {};
+      fields[item.fieldName] = { reasonForRejection: reasons[item.id] || "" };
+      rejectedByUser[item.uuid] = fields;
+      continue;
+    }
+    if (item.uuid === entityUuid) {
+      entityItems.push({ fieldName: item.fieldName, fieldValue: item.value });
+    } else {
+      batchItems.push({
+        uuid: item.uuid,
+        fieldName: item.fieldName,
+        fieldValue: item.value
+      });
+    }
+  }
+  await state.mutateWithLoadingState(
+    () => adapter.updateFieldValueBatched({ items: batchItems, entityItems })
+  );
+  const acceptedCount = batchItems.length + entityItems.length;
+  const label = acceptedCount === items.length ? $t(
+    "aiAgentBatchRewriteAllApplied",
+    "All @count changes applied"
+  ).replace("@count", String(acceptedCount)) : $t(
+    "aiAgentBatchRewriteSomeApplied",
+    "@applied of @total changes applied"
+  ).replace("@applied", String(acceptedCount)).replace("@total", String(items.length));
+  return { acceptedCount, rejectedByUser, label };
+}
+export function rejectedWithoutReasonMessage(rejectedByUser) {
+  const rejected = [];
+  for (const [uuid, fields] of Object.entries(rejectedByUser)) {
+    for (const [fieldName, v] of Object.entries(fields)) {
+      if (!v?.reasonForRejection) rejected.push({ uuid, fieldName });
+    }
+  }
+  if (rejected.length === 1 || rejected.length === 2) {
+    const fieldList = rejected.map((r) => `"${r.fieldName}" of paragraph ${r.uuid}`).join(" and ");
+    return `The user rejected ${fieldList} without a reason. Use the ask_question tool to present the user with 2 or more alternative texts for each rejected field.`;
+  }
+  if (rejected.length > 2) {
+    return "Some changes were rejected without a reason. Ask the user what they would like to change instead.";
+  }
+  return void 0;
+}