fix(core): Refresh MediaPicker3 thumbnails after AI-driven value changes

The MediaPicker3 thumbnail subcomponent fetches the rendered media on
mount and doesn't re-fetch when its mediaKey prop changes within an
existing picker entry. So when an LLM swaps an image via set_value, the
underlying value is correct (right mediaKey, right entry shape) but the
visible thumbnail keeps showing the previous image until the user saves
and reloads.

Lit re-mounts a subcomponent only when its surrounding entry key
changes, so to force a fresh fetch we re-mint the entry's `key`
(distinct from `mediaKey`) when its content actually changed. The prior
hand-rolled `[0].key = uuidv4()` only fired on string-parsed input and
only touched the first entry; the new path:

- Compares each incoming entry to the same-keyed entry in the current
  staged value.
- Regenerates the key only when the entry exists in the old value AND
  its non-key content differs. This forces re-mount for replaced
  entries.
- Leaves keys alone when content is identical (no churn for entries the
  LLM didn't touch — focal points, crops, etc. stay stable).
- Leaves keys alone for entries whose key isn't in the old value at all
  — those are genuinely new (e.g. minted by `add_item`'s handler) and
  the LLM may reference them via `remove_item({ blockKey })` later, so
  we must not change them.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: mattbrailsford

Umbraco.AI/src/Umbraco.AI.Web.StaticAssets/Client/src/entity-adapter/adapters/value-preparation.ts

@@ -45,13 +45,44 @@ export function prepareValueForEditor(value: unknown, editorAlias?: string, curr
     // Try to parse JSON values
     try {
         valueToSet = JSON.parse(valueToSet as string);
-        if (editorAlias === "Umbraco.MediaPicker3") {
-            (valueToSet as Array<{ key: string }>)[0].key = crypto.randomUUID();
-        }
     } catch {
         // Not JSON, use as-is
     }
 
+    // MediaPicker3: re-mint the entry's `key` when its content changed against the staged value.
+    // The picker's thumbnail subcomponent fetches the resolved media on mount and doesn't re-fetch
+    // when only `mediaKey` changes within the same entry; replacing the entry's `key` forces lit to
+    // unmount and re-mount, which re-fetches the thumbnail. We only regen when the entry's
+    // non-key content actually changed — that way add_item's handler-minted fresh keys stay stable
+    // (so the LLM's subsequent remove_item({blockKey}) still resolves), and unchanged entries
+    // don't churn their per-entry settings (focal point, crops, …).
+    if (editorAlias === "Umbraco.MediaPicker3" && Array.isArray(valueToSet)) {
+        const oldByKey = new Map<string, Record<string, unknown>>();
+        if (Array.isArray(currentValue)) {
+            for (const entry of currentValue as Array<Record<string, unknown>>) {
+                const k = entry?.key;
+                if (typeof k === "string") {
+                    oldByKey.set(k, entry);
+                }
+            }
+        }
+
+        valueToSet = (valueToSet as Array<Record<string, unknown>>).map((entry) => {
+            const key = typeof entry?.key === "string" ? entry.key : undefined;
+            if (!key) {
+                return { ...entry, key: crypto.randomUUID() };
+            }
+            const old = oldByKey.get(key);
+            if (!old) {
+                return entry;
+            }
+            if (JSON.stringify(omitKey(old)) === JSON.stringify(omitKey(entry))) {
+                return entry;
+            }
+            return { ...entry, key: crypto.randomUUID() };
+        });
+    }
+
     // Wrap in TipTap's expected format for RichText properties
     if (editorAlias === "Umbraco.RichText") {
         const current = currentValue as { markup?: string; blocks?: object } | undefined;
@@ -63,3 +94,8 @@ export function prepareValueForEditor(value: unknown, editorAlias?: string, curr
 
     return valueToSet;
 }
+
+function omitKey(entry: Record<string, unknown>): Record<string, unknown> {
+    const { key: _key, ...rest } = entry;
+    return rest;
+}