@blokkli/editor 2.0.0-alpha.62 → 2.0.0-alpha.63

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

@@ -12,10 +12,13 @@
 <script setup>
 import { useBlokkli, ref, onMounted } from "#imports";
 import { DiffApproval } from "#blokkli/editor/components";
+import { splitIntoSegments } from "#blokkli/editor/helpers/diff";
 import {
   skippedFieldsMessage,
   appendAgentNote,
-  rejectedWithoutReasonMessage
+  rejectedWithoutReasonMessage,
+  partialRejectionGuidance,
+  decideFieldUpdates
 } from "../fieldDiffApproval";
 const props = defineProps({
   context: { type: null, required: true },
@@ -95,12 +98,18 @@ onMounted(async () => {
     const uuid = result.key.substring(0, separatorIndex);
     const fieldName = result.key.substring(separatorIndex + 1);
     const source = byKey.get(result.key);
+    const segments = source ? splitIntoSegments(
+      source.value,
+      result.translatedText,
+      source.fieldType
+    ) ?? void 0 : void 0;
     return {
       id: id++,
       uuid,
       fieldName,
       fieldLabel: source ? resolveFieldLabel(source.entityType, source.entityBundle, fieldName) : fieldName,
-      value: result.translatedText
+      value: result.translatedText,
+      segments
     };
   });
   phase.value = "approving";
@@ -108,49 +117,42 @@ onMounted(async () => {
 async function onApply(data) {
   const targetLanguage = entityContext.value.language;
   const items = approvalItems.value;
-  const rejectedByUser = {};
-  const accepted = [];
-  for (const item of items) {
-    if (data.selected[item.id]) {
-      accepted.push(item);
-      continue;
-    }
-    const fields = rejectedByUser[item.uuid] ?? {};
-    fields[item.fieldName] = {
-      reasonForRejection: data.reasons[item.id] || ""
-    };
-    rejectedByUser[item.uuid] = fields;
-  }
-  if (accepted.length) {
+  const { updates, rejectedByUser, acceptedCount, totalCount } = decideFieldUpdates(items, data.selected, data.reasons);
+  if (updates.length) {
     await state.mutateWithLoadingState(
       () => adapter.importTranslationsBatched({
-        items: accepted.map((item) => ({
+        items: updates.map((u) => ({
           langcode: targetLanguage,
-          uuid: item.uuid,
-          fieldName: item.fieldName,
-          fieldValue: item.value
+          uuid: u.uuid,
+          fieldName: u.fieldName,
+          fieldValue: u.fieldValue
         }))
       })
     );
   }
-  const acceptedCount = accepted.length;
-  const label = acceptedCount === items.length ? $t(
+  const label = acceptedCount === totalCount ? $t(
     "aiAgentAutoTranslateAllApplied",
     "All @count translations applied"
   ).replace("@count", String(acceptedCount)) : $t(
     "aiAgentAutoTranslateSomeApplied",
     "@applied of @total translations applied"
-  ).replace("@applied", String(acceptedCount)).replace("@total", String(items.length));
-  const _details = accepted.map((item) => ({
+  ).replace("@applied", String(acceptedCount)).replace("@total", String(totalCount));
+  const updatesByItem = new Map(
+    updates.map((u) => [`${u.uuid}:${u.fieldName}`, u.fieldValue])
+  );
+  const _details = items.filter((item) => updatesByItem.has(`${item.uuid}:${item.fieldName}`)).map((item) => ({
     fieldLabel: item.fieldLabel,
     before: "",
-    after: item.value
+    after: updatesByItem.get(`${item.uuid}:${item.fieldName}`)
   }));
   emitDone({
     acceptedCount,
     rejectedByUser,
     label,
-    agentMessage: rejectedWithoutReasonMessage(rejectedByUser),
+    agentMessage: appendAgentNote(
+      partialRejectionGuidance(rejectedByUser),
+      rejectedWithoutReasonMessage(rejectedByUser)
+    ),
     historyIndex: state.currentMutationIndex.value,
     _details
   });

package/dist/modules/agent/runtime/app/tools/auto_translate_paragraphs/Component.vue.d.ts

@@ -9,6 +9,17 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
         acceptedCount: number;
         rejectedByUser: Record<string, Record<string, {
             reasonForRejection: string;
+            partial?: {
+                accepted: number;
+                total: number;
+                rejectedSegments: {
+                    tag: string;
+                    beforeHtml: string;
+                    afterHtml: string;
+                    status: "deleted" | "matched" | "inserted";
+                    reasonForRejection: string;
+                }[];
+            } | undefined;
         }>>;
         label: string;
         agentMessage?: string | undefined;
@@ -19,6 +30,17 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
         acceptedCount: number;
         rejectedByUser: Record<string, Record<string, {
             reasonForRejection: string;
+            partial?: {
+                accepted: number;
+                total: number;
+                rejectedSegments: {
+                    tag: string;
+                    beforeHtml: string;
+                    afterHtml: string;
+                    status: "deleted" | "matched" | "inserted";
+                    reasonForRejection: string;
+                }[];
+            } | undefined;
         }>>;
         label: string;
         agentMessage?: string | undefined;

package/dist/modules/agent/runtime/app/tools/auto_translate_paragraphs/index.d.ts

@@ -19,6 +19,21 @@ export declare const resultSchema: z.ZodObject<{
     acceptedCount: z.ZodNumber;
     rejectedByUser: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
         reasonForRejection: z.ZodString;
+        partial: z.ZodOptional<z.ZodObject<{
+            accepted: z.ZodNumber;
+            total: z.ZodNumber;
+            rejectedSegments: z.ZodArray<z.ZodObject<{
+                tag: z.ZodString;
+                beforeHtml: z.ZodString;
+                afterHtml: z.ZodString;
+                status: z.ZodEnum<{
+                    deleted: "deleted";
+                    matched: "matched";
+                    inserted: "inserted";
+                }>;
+                reasonForRejection: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
     label: z.ZodString;
     agentMessage: z.ZodOptional<z.ZodString>;

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

@@ -9,6 +9,17 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
         acceptedCount: number;
         rejectedByUser: Record<string, Record<string, {
             reasonForRejection: string;
+            partial?: {
+                accepted: number;
+                total: number;
+                rejectedSegments: {
+                    tag: string;
+                    beforeHtml: string;
+                    afterHtml: string;
+                    status: "deleted" | "matched" | "inserted";
+                    reasonForRejection: string;
+                }[];
+            } | undefined;
         }>>;
         label: string;
         agentMessage?: string | undefined;
@@ -19,6 +30,17 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
         acceptedCount: number;
         rejectedByUser: Record<string, Record<string, {
             reasonForRejection: string;
+            partial?: {
+                accepted: number;
+                total: number;
+                rejectedSegments: {
+                    tag: string;
+                    beforeHtml: string;
+                    afterHtml: string;
+                    status: "deleted" | "matched" | "inserted";
+                    reasonForRejection: string;
+                }[];
+            } | undefined;
         }>>;
         label: string;
         agentMessage?: string | undefined;

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

@@ -52,11 +52,13 @@
 <script setup>
 import { useBlokkli, ref, onMounted, onBeforeUnmount } from "#imports";
 import { Icon, DiffApproval } from "#blokkli/editor/components";
+import { splitIntoSegments } from "#blokkli/editor/helpers/diff";
 import ToolCard from "../../features/agent/Panel/ToolCard/index.vue";
 import { applyOperations } from "../helpers";
 import {
   applyFieldDiffs,
   rejectedWithoutReasonMessage,
+  partialRejectionGuidance,
   skippedFieldsMessage,
   appendAgentNote
 } from "../fieldDiffApproval";
@@ -110,12 +112,21 @@ function transitionToApproval() {
     }
     if (override.originalValue === finalValue) continue;
     const itemId = idCounter++;
+    const field = props.params.fields.find(
+      (f) => f.uuid === fs.uuid && f.fieldName === fs.fieldName
+    );
+    const segments = field ? splitIntoSegments(
+      override.originalValue,
+      finalValue,
+      field.fieldType
+    ) ?? void 0 : void 0;
     items.push({
       id: itemId,
       uuid: fs.uuid,
       fieldName: fs.fieldName,
       fieldLabel: fs.fieldLabel,
-      value: finalValue
+      value: finalValue,
+      segments
     });
     beforeValues.set(itemId, override.originalValue);
   }
@@ -172,7 +183,7 @@ function rejectAllFromApproval() {
 }
 async function applySelected(data) {
   const { selected, reasons } = data;
-  const { acceptedCount, rejectedByUser, label } = await applyFieldDiffs(
+  const { acceptedCount, rejectedByUser, label, appliedByItemId } = await applyFieldDiffs(
     blokkli,
     props.context.adapter,
     completedItems.value,
@@ -180,40 +191,72 @@ async function applySelected(data) {
     reasons
   );
   const parts = [];
-  const acceptedItems = completedItems.value.filter((item) => selected[item.id]);
-  if (acceptedItems.length > 0) {
+  const fullyAccepted = completedItems.value.filter(
+    (item) => appliedByItemId[item.id] !== void 0 && !rejectedByUser[item.uuid]?.[item.fieldName]
+  );
+  if (fullyAccepted.length > 0) {
     parts.push("Accepted fields:");
-    for (const item of acceptedItems) {
-      const truncated = item.value.length > 200 ? item.value.slice(0, 200) + "..." : item.value;
+    for (const item of fullyAccepted) {
+      const written = appliedByItemId[item.id];
+      const truncated = written.length > 200 ? written.slice(0, 200) + "..." : written;
       parts.push(`- ${item.uuid} "${item.fieldName}": ${truncated}`);
     }
   }
-  const rejectedItems = completedItems.value.filter(
-    (item) => !selected[item.id]
+  const partials = completedItems.value.map((item) => {
+    const entry = rejectedByUser[item.uuid]?.[item.fieldName];
+    if (!entry?.partial || appliedByItemId[item.id] === void 0) return null;
+    return { item, entry };
+  }).filter(
+    (p) => p !== null
+  );
+  if (partials.length > 0) {
+    parts.push("Partially accepted fields:");
+    for (const { item, entry } of partials) {
+      const { accepted, total, rejectedSegments } = entry.partial;
+      parts.push(
+        `- ${item.uuid} "${item.fieldName}": ${accepted}/${total} chunks accepted`
+      );
+      for (const seg of rejectedSegments) {
+        const reasonText = seg.reasonForRejection ? ` (reason: ${seg.reasonForRejection})` : " (no reason given)";
+        parts.push(`  \xB7 rejected <${seg.tag}> (${seg.status})${reasonText}`);
+      }
+    }
+  }
+  const fullyRejected = completedItems.value.map((item) => {
+    const entry = rejectedByUser[item.uuid]?.[item.fieldName];
+    if (!entry || entry.partial || appliedByItemId[item.id] !== void 0) {
+      return null;
+    }
+    return { item, entry };
+  }).filter(
+    (p) => p !== null
   );
-  if (rejectedItems.length > 0) {
+  if (fullyRejected.length > 0) {
     parts.push("Rejected fields:");
-    for (const item of rejectedItems) {
-      const reason = reasons[item.id] || "";
-      const reasonText = reason ? ` (reason: ${reason})` : " (no reason given)";
+    for (const { item, entry } of fullyRejected) {
+      const reasonText = entry.reasonForRejection ? ` (reason: ${entry.reasonForRejection})` : " (no reason given)";
       parts.push(`- ${item.uuid} "${item.fieldName}"${reasonText}`);
     }
   }
   let agentMessage = parts.join("\n");
+  const partialNote = partialRejectionGuidance(rejectedByUser);
+  if (partialNote) agentMessage += "\n\n" + partialNote;
   const followUp = rejectedWithoutReasonMessage(rejectedByUser);
   if (followUp) agentMessage += "\n" + followUp;
-  const _details = completedItems.value.filter((item) => selected[item.id]).map((item) => {
+  const _details = completedItems.value.filter((item) => appliedByItemId[item.id] !== void 0).map((item) => {
     const fs = findFieldState(item.uuid, item.fieldName);
+    const isPartial = !!rejectedByUser[item.uuid]?.[item.fieldName]?.partial;
     const hadRetries = fs ? fs.allOperations.length > 0 : false;
-    const operations = fs?.mode === "patch" && !hadRetries ? [...fs.operations] : [];
+    const operations = fs?.mode === "patch" && !hadRetries && !isPartial ? [...fs.operations] : [];
     return {
       fieldLabel: item.fieldLabel,
       before: fs?.originalBaseValue || beforeValues.get(item.id) || "",
-      after: item.value,
+      after: appliedByItemId[item.id],
       mode: fs?.mode || "full",
       operations
     };
   });
+  const anyRejection = Object.keys(rejectedByUser).length > 0;
   emitDone({
     acceptedCount,
     rejectedByUser,
@@ -224,7 +267,7 @@ async function applySelected(data) {
     _usage: streamUsage.value,
     // Let the agent respond if anything was rejected or skipped, so it can
     // retry the skipped references.
-    _skipLlmResponse: rejectedItems.length === 0 && !skippedNote
+    _skipLlmResponse: !anyRejection && !skippedNote
   });
 }
 onMounted(async () => {

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

@@ -9,6 +9,17 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
         acceptedCount: number;
         rejectedByUser: Record<string, Record<string, {
             reasonForRejection: string;
+            partial?: {
+                accepted: number;
+                total: number;
+                rejectedSegments: {
+                    tag: string;
+                    beforeHtml: string;
+                    afterHtml: string;
+                    status: "deleted" | "matched" | "inserted";
+                    reasonForRejection: string;
+                }[];
+            } | undefined;
         }>>;
         label: string;
         agentMessage?: string | undefined;
@@ -19,6 +30,17 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {
         acceptedCount: number;
         rejectedByUser: Record<string, Record<string, {
             reasonForRejection: string;
+            partial?: {
+                accepted: number;
+                total: number;
+                rejectedSegments: {
+                    tag: string;
+                    beforeHtml: string;
+                    afterHtml: string;
+                    status: "deleted" | "matched" | "inserted";
+                    reasonForRejection: string;
+                }[];
+            } | undefined;
         }>>;
         label: string;
         agentMessage?: string | undefined;

package/dist/modules/agent/runtime/app/tools/delegate_text_rewrite/index.d.ts

@@ -41,6 +41,21 @@ export declare const resultSchema: z.ZodObject<{
     acceptedCount: z.ZodNumber;
     rejectedByUser: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
         reasonForRejection: z.ZodString;
+        partial: z.ZodOptional<z.ZodObject<{
+            accepted: z.ZodNumber;
+            total: z.ZodNumber;
+            rejectedSegments: z.ZodArray<z.ZodObject<{
+                tag: z.ZodString;
+                beforeHtml: z.ZodString;
+                afterHtml: z.ZodString;
+                status: z.ZodEnum<{
+                    deleted: "deleted";
+                    matched: "matched";
+                    inserted: "inserted";
+                }>;
+                reasonForRejection: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
     label: z.ZodString;
     agentMessage: z.ZodOptional<z.ZodString>;

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

@@ -1,10 +1,29 @@
 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, {
+export type RejectedSegment = {
+    tag: string;
+    beforeHtml: string;
+    afterHtml: string;
+    status: 'matched' | 'inserted' | 'deleted';
     reasonForRejection: string;
-}>>;
+};
+export type FieldRejection = {
+    reasonForRejection: string;
+    /**
+     * Present when the user evaluated a segmented field chunk-by-chunk. When
+     * `accepted > 0` the field was updated with a hybrid value; when
+     * `accepted === 0` every chunk was rejected and the field stayed at its
+     * original value.
+     */
+    partial?: {
+        accepted: number;
+        total: number;
+        rejectedSegments: RejectedSegment[];
+    };
+};
+/** Map of paragraph UUID → field name → rejection details. */
+export type RejectedByUser = Record<string, Record<string, FieldRejection>>;
 /**
  * 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
@@ -26,24 +45,75 @@ export declare function skippedFieldsMessage(skipped: SkippedField[]): string |
  * 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;
+export type DecidedUpdate = {
+    itemId: number;
+    uuid: string;
+    fieldName: string;
+    fieldValue: string;
+};
+export type FieldDecisionResult = {
+    /**
+     * One entry per accepted item, with the value that should be written. For
+     * segmented items this is the reassembled hybrid (accepted chunks + original
+     * chunks for rejected ones); for unsegmented items it's `item.value`.
+     */
+    updates: DecidedUpdate[];
     rejectedByUser: RejectedByUser;
+    /**
+     * Number of accepted toggle units across the whole batch. For unsegmented
+     * fields this is "field accepted" / "field rejected"; for segmented fields
+     * each changed chunk counts as one unit.
+     */
+    acceptedCount: number;
+    /** Total number of toggle units the user could have selected. */
+    totalCount: number;
+};
+/**
+ * Walk the approval items and decide, per field, what gets written and what
+ * gets reported as rejected. Pure: does no IO and does not depend on the
+ * adapter. The caller picks the mutation strategy (entity vs. batch update,
+ * translation import, …).
+ *
+ * `selected` and `reasons` are keyed by `ApprovalUnit.key` — the stringified
+ * item id for unsegmented items, `${itemId}:${segmentId}` for segmented.
+ */
+export declare function decideFieldUpdates(items: ApprovalItem[], selected: Record<string, boolean>, reasons: Record<string, string>): FieldDecisionResult;
+export type FieldDiffApplyResult = FieldDecisionResult & {
     label: string;
+    /**
+     * The value that was actually written for each accepted item, keyed by
+     * `ApprovalItem.id`. Used by the caller to build the `_details` panel
+     * (agent-facing audit log).
+     */
+    appliedByItemId: Record<number, 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.
+ * Apply the user's accept/reject decisions for a batch of field diffs through
+ * `updateFieldValueBatched`. Shared by `update_text_fields` and
+ * `delegate_text_rewrite`. The translation tool calls `decideFieldUpdates`
+ * directly because it imports through a different adapter method.
+ */
+export declare function applyFieldDiffs(app: BlokkliApp, adapter: FullBlokkliAdapter<any>, items: ApprovalItem[], selected: Record<string, boolean>, reasons: Record<string, string>): Promise<FieldDiffApplyResult>;
+/**
+ * Inline guidance the agent should follow when ANY field in this result came
+ * back with `partial` set AND at least one chunk was accepted — i.e. the
+ * field was updated with a hybrid value. Returns undefined when there were
+ * no such hybrids.
  *
- * 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.
+ * Scoping a follow-up to the rejected chunks (instead of rewriting the field
+ * whole) is non-obvious — without this hint the model tends to re-propose
+ * the entire field and clobber the accepted chunks. The guidance only
+ * appears when a hybrid was actually written, so it costs nothing on the
+ * normal "all accepted" or "all rejected" paths.
  */
-export declare function applyFieldDiffs(app: BlokkliApp, adapter: FullBlokkliAdapter<any>, items: ApprovalItem[], selected: Record<number, boolean>, reasons: Record<number, string>): Promise<FieldDiffApplyResult>;
+export declare function partialRejectionGuidance(rejected: RejectedByUser): string | undefined;
 /**
  * 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).
+ * or chunks without a reason. Returns undefined when every rejection had a
+ * reason (or there were none).
+ *
+ * Partial rejections are surfaced at chunk granularity so the agent knows to
+ * offer alternatives for the specific paragraph or list item, not the whole
+ * field.
  */
-export declare function rejectedWithoutReasonMessage(rejectedByUser: RejectedByUser): string | undefined;
+export declare function rejectedWithoutReasonMessage(rejected: RejectedByUser): string | undefined;