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

package/dist/modules/agent/runtime/app/tools/delegate_text_rewrite/Component.vue

@@ -5,19 +5,27 @@
     :title="streamingTitle"
     @cancel="onCancel"
   >
-    <div class="bk-delegate-text-rewrite-progress">
+    <div class="_bk_flex _bk_flex-col _bk_gap-3 _bk_px-10 _bk_py-10">
       <div
         v-for="field in fieldStates"
         :key="field.uuid + field.fieldName"
-        class="bk-delegate-text-rewrite-progress-item"
+        class="_bk_flex _bk_items-center _bk_gap-5 _bk_text-sm _bk_text-mono-600"
         :class="{
-  'bk-is-active': field.status === 'streaming',
-  'bk-is-done': field.status === 'done'
+  '_bk_text-accent-700 _bk_font-medium': field.status === 'streaming',
+  '_bk_text-lime-dark': field.status === 'done'
 }"
       >
-        <Icon v-if="field.status === 'done'" name="bk_mdi_check" />
-        <Icon v-else-if="field.status === 'streaming'" name="bk_mdi_edit" />
-        <Icon v-else name="bk_mdi_hourglass_empty" />
+        <Icon
+          v-if="field.status === 'done'"
+          name="bk_mdi_check"
+          class="_bk_size-15"
+        />
+        <Icon
+          v-else-if="field.status === 'streaming'"
+          name="bk_mdi_edit"
+          class="_bk_size-15"
+        />
+        <Icon v-else name="bk_mdi_hourglass_empty" class="_bk_size-15" />
         <span>{{ field.fieldLabel }}</span>
       </div>
     </div>
@@ -26,13 +34,15 @@
   <DiffApproval
     v-else-if="phase === 'approval' && completedItems.length > 0"
     :items="completedItems"
+    show-reason
     @apply="applySelected"
+    @cancel="rejectAllFromApproval"
   />
 
   <ToolCard
     v-if="phase === 'error'"
     icon="bk_mdi_error"
-    :title="$t('aiAgentDelegateRewriteError', 'Rewriting failed')"
+    :title="$t('rewritingFailed', 'Rewriting failed')"
     @cancel="finishWithError"
   >
     <p>{{ errorMessage }}</p>
@@ -40,512 +50,51 @@
 </template>
 
 <script setup>
-import { useBlokkli, ref, reactive, onMounted, onBeforeUnmount } from "#imports";
+import { useBlokkli, ref, onMounted, onBeforeUnmount } from "#imports";
 import { Icon, DiffApproval } from "#blokkli/editor/components";
 import ToolCard from "../../features/agent/Panel/ToolCard/index.vue";
-import { itemEntityType } from "#blokkli-build/config";
-import { routeStream } from "#blokkli-build/agent-client";
-import { useEditableFieldOverride } from "#blokkli/editor/composables";
 import { applyOperations } from "../helpers";
+import {
+  applyFieldDiffs,
+  rejectedWithoutReasonMessage,
+  skippedFieldsMessage,
+  appendAgentNote
+} from "../fieldDiffApproval";
+import { useFieldRewriteStream } from "./useFieldRewriteStream";
 const props = defineProps({
   context: { type: null, required: true },
   params: { type: Object, required: true }
 });
 const emit = defineEmits(["done"]);
-const {
-  $t,
-  state,
-  blocks,
-  context: editorContext,
-  types,
-  eventBus
-} = useBlokkli();
-const phase = ref("streaming");
-const errorMessage = ref("");
-const streamUsage = ref();
-const MAX_READABILITY_RETRIES = 10;
-const isFixReadability = props.params.template === "fix_readability";
-const retryAttempt = ref(0);
-const streamingTitle = ref(
-  $t("aiAgentDelegateRewriteStreaming", "Rewriting @count fields...").replace(
-    "@count",
-    String(props.params.fields.length)
-  )
-);
-const fieldStates = reactive(
-  props.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;
-const completedItems = ref([]);
-const beforeValues = /* @__PURE__ */ new Map();
-function resolveHost(uuid) {
-  if (uuid === editorContext.value.entityUuid) {
-    return {
-      type: editorContext.value.entityType,
-      bundle: editorContext.value.entityBundle,
-      uuid
-    };
-  }
-  const block = blocks.getBlock(uuid);
-  if (!block) return null;
-  return { type: itemEntityType, bundle: block.bundle, uuid };
-}
-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;
-}
-for (const field of props.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
+const blokkli = useBlokkli();
+const { $t, state } = blokkli;
+const skippedNote = skippedFieldsMessage(props.params.skipped);
+function emitDone(result) {
+  emit("done", {
+    ...result,
+    agentMessage: appendAgentNote(result.agentMessage, skippedNote)
   });
 }
-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 = props.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 = props.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 props.context.app.readability.analyzeFieldValues(textFields);
-  const bandOrder = { easy: 0, ok: 1, hard: 2 };
-  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 }));
-    let worstBandValue = -1;
-    let worstScore;
-    for (const chunk of chunks) {
-      if (chunk.band === null || chunk.score === null) continue;
-      const value = bandOrder[chunk.band] ?? 0;
-      if (value > worstBandValue) {
-        worstBandValue = value;
-        worstScore = chunk.score;
-      }
-    }
-    const worstLevel = worstBandValue >= 2 ? "hard" : worstBandValue >= 1 ? "ok" : "good";
-    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: props.params.template,
-        templateParams,
-        fields: requestFields,
-        pageContext: props.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();
-      emit("done", {
-        acceptedCount: 0,
-        rejectedByUser: {},
-        label: $t("aiAgentDelegateRewriteCancelled", "Rewriting cancelled"),
-        agentMessage: "Rewriting was cancelled by the user.",
-        _usage: streamUsage.value
-      });
-      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(
-      "aiAgentDelegateRewriteChecking",
-      "Checking readability..."
-    );
-    const analysis = await analyzeReadability();
-    const failing = [];
-    const passing = [];
-    for (const fs of fieldStates) {
-      if (fs.status !== "done") continue;
-      const field = props.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)..."
-    ).replace("@count", String(failing.length)).replace("@attempt", String(retryAttempt.value + 1));
-    let retryToken = authToken;
-    if (props.context.adapter.getAgentAuthToken) {
-      const fresh = await props.context.adapter.getAgentAuthToken();
-      if (fresh) retryToken = fresh;
-    }
-    const retrySuccess = await fetchStream(retryToken, retryFields, {
-      issues: retryIssues,
-      scoreLabel: props.context.app.readability.scoreLabel.value,
-      scoreReference: props.context.app.readability.getAgentContext(),
-      retryFields: retryFieldsData,
-      passingFields: passingFieldsData
-    });
-    if (!retrySuccess) return;
-  }
-}
-async function startStreaming() {
-  let authToken = null;
-  if (props.context.adapter.getAgentAuthToken) {
-    authToken = await props.context.adapter.getAgentAuthToken();
-  }
-  if (!authToken) {
-    phase.value = "error";
-    errorMessage.value = "Failed to get authentication token";
-    return;
-  }
-  const requestFields = props.params.fields.map((f) => ({
-    uuid: f.uuid,
-    fieldName: f.fieldName,
-    currentValue: f.currentValue,
-    fieldType: f.fieldType
-  }));
-  const success = await fetchStream(
-    authToken,
-    requestFields,
-    props.params.templateParams
-  );
-  if (!success) return;
-  if (isFixReadability) {
-    await readabilityRetryLoop(authToken);
-    if (phase.value !== "streaming") return;
-  }
-  transitionToApproval();
-}
+const completedItems = ref([]);
+const beforeValues = /* @__PURE__ */ new Map();
+const stream = useFieldRewriteStream({
+  context: props.context,
+  params: props.params,
+  onComplete: () => transitionToApproval()
+});
+const {
+  phase,
+  errorMessage,
+  streamingTitle,
+  streamUsage,
+  fieldStates,
+  findFieldState,
+  findOverride,
+  start,
+  restoreAll,
+  abort,
+  dispose
+} = stream;
 function transitionToApproval() {
   let idCounter = 0;
   const items = [];
@@ -572,7 +121,7 @@ function transitionToApproval() {
   }
   if (items.length === 0) {
     restoreAll();
-    emit("done", {
+    emitDone({
       acceptedCount: 0,
       rejectedByUser: {},
       label: $t("aiAgentDelegateRewriteNoChanges", "No changes detected"),
@@ -585,17 +134,10 @@ function transitionToApproval() {
   completedItems.value = items;
   phase.value = "approval";
 }
-function restoreAll() {
-  for (const override of overrides) {
-    override.restore();
-  }
-}
 function onCancel() {
-  if (abortController) {
-    abortController.abort();
-  }
+  abort();
   restoreAll();
-  emit("done", {
+  emitDone({
     acceptedCount: 0,
     rejectedByUser: {},
     label: $t("aiAgentDelegateRewriteCancelled", "Rewriting cancelled"),
@@ -605,54 +147,38 @@ function onCancel() {
 }
 function finishWithError() {
   restoreAll();
-  emit("done", {
+  emitDone({
     acceptedCount: 0,
     rejectedByUser: {},
-    label: $t("aiAgentDelegateRewriteFailed", "Rewriting failed"),
+    label: $t("rewritingFailed", "Rewriting failed"),
     agentMessage: `Rewriting failed: ${errorMessage.value}`,
     _usage: streamUsage.value
   });
 }
-async function applySelected(data) {
-  const { selected, reasons } = data;
+function rejectAllFromApproval() {
   const rejectedByUser = {};
-  const entityUuid = editorContext.value.entityUuid;
-  const batchItems = [];
-  const entityItems = [];
   for (const item of completedItems.value) {
-    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
-      });
-    }
+    const fields = rejectedByUser[item.uuid] ?? {};
+    fields[item.fieldName] = { reasonForRejection: "" };
+    rejectedByUser[item.uuid] = fields;
   }
-  await state.mutateWithLoadingState(
-    () => props.context.adapter.updateFieldValueBatched({
-      items: batchItems,
-      entityItems
-    })
+  emitDone({
+    acceptedCount: 0,
+    rejectedByUser,
+    label: $t("aiAgentDelegateRewriteAllRejected", "All changes rejected"),
+    agentMessage: "All proposed changes were rejected by the user. Ask the user what they would like to change instead.",
+    _usage: streamUsage.value
+  });
+}
+async function applySelected(data) {
+  const { selected, reasons } = data;
+  const { acceptedCount, rejectedByUser, label } = await applyFieldDiffs(
+    blokkli,
+    props.context.adapter,
+    completedItems.value,
+    selected,
+    reasons
   );
-  const acceptedCount = batchItems.length + entityItems.length;
-  const label = acceptedCount === completedItems.value.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(completedItems.value.length));
   const parts = [];
   const acceptedItems = completedItems.value.filter((item) => selected[item.id]);
   if (acceptedItems.length > 0) {
@@ -674,21 +200,8 @@ async function applySelected(data) {
     }
   }
   let agentMessage = parts.join("\n");
-  const rejectedWithoutReason = [];
-  for (const [uuid, fields] of Object.entries(rejectedByUser)) {
-    for (const [fieldName, v] of Object.entries(fields)) {
-      if (!v?.reasonForRejection) {
-        rejectedWithoutReason.push({ uuid, fieldName });
-      }
-    }
-  }
-  if (rejectedWithoutReason.length === 1 || rejectedWithoutReason.length === 2) {
-    const fieldList = rejectedWithoutReason.map((r) => `"${r.fieldName}" of paragraph ${r.uuid}`).join(" and ");
-    agentMessage += `
-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.`;
-  } else if (rejectedWithoutReason.length > 2) {
-    agentMessage += "\nSome changes were rejected without a reason. Ask the user what they would like to change instead.";
-  }
+  const followUp = rejectedWithoutReasonMessage(rejectedByUser);
+  if (followUp) agentMessage += "\n" + followUp;
   const _details = completedItems.value.filter((item) => selected[item.id]).map((item) => {
     const fs = findFieldState(item.uuid, item.fieldName);
     const hadRetries = fs ? fs.allOperations.length > 0 : false;
@@ -701,7 +214,7 @@ The user rejected ${fieldList} without a reason. Use the ask_question tool to pr
       operations
     };
   });
-  emit("done", {
+  emitDone({
     acceptedCount,
     rejectedByUser,
     label,
@@ -709,38 +222,27 @@ The user rejected ${fieldList} without a reason. Use the ask_question tool to pr
     historyIndex: state.currentMutationIndex.value,
     _details,
     _usage: streamUsage.value,
-    _skipLlmResponse: rejectedItems.length === 0
+    // Let the agent respond if anything was rejected or skipped, so it can
+    // retry the skipped references.
+    _skipLlmResponse: rejectedItems.length === 0 && !skippedNote
   });
 }
-async function _rejectAll() {
-  await state.flushDirty();
-  const rejectedByUser = {};
-  for (const item of completedItems.value) {
-    const fields = rejectedByUser[item.uuid] ?? {};
-    fields[item.fieldName] = { reasonForRejection: "" };
-    rejectedByUser[item.uuid] = fields;
+onMounted(async () => {
+  const { cancelled } = await start();
+  if (cancelled) {
+    emitDone({
+      acceptedCount: 0,
+      rejectedByUser: {},
+      label: $t("aiAgentDelegateRewriteCancelled", "Rewriting cancelled"),
+      agentMessage: "Rewriting was cancelled by the user.",
+      _usage: streamUsage.value
+    });
   }
-  emit("done", {
-    acceptedCount: 0,
-    rejectedByUser,
-    label: $t("aiAgentBatchRewriteAllRejected", "All changes rejected"),
-    agentMessage: "All changes were rejected by the user. Ask the user what they would like to change instead.",
-    _usage: streamUsage.value
-  });
-}
-onMounted(() => {
-  startStreaming();
 });
 onBeforeUnmount(() => {
-  if (abortController) {
-    abortController.abort();
-  }
+  dispose();
   if (phase.value === "streaming") {
     restoreAll();
   }
-  state.flushDirty();
-  if (markupFlushTimer) {
-    clearTimeout(markupFlushTimer);
-  }
 });
 </script>