@assistant-ui/core 0.3.20 → 0.3.21

package/src/model-context/interactable-composer-metadata.test.ts

@@ -195,6 +195,88 @@ describe("shallowMergeInteractableState", () => {
       title: "final",
     });
   });
+
+  it("keeps the unwritten fields of the record still streaming", () => {
+    const prev = { title: "old", settings: { name: "n", size: 1 } };
+
+    expect(
+      shallowMergeInteractableState(
+        prev,
+        { settings: {} },
+        { partialPath: ["settings"] },
+      ),
+    ).toEqual({ title: "old", settings: { name: "n", size: 1 } });
+    expect(
+      shallowMergeInteractableState(
+        prev,
+        { settings: { name: "m" } },
+        { partialPath: ["settings", "name"] },
+      ),
+    ).toEqual({ title: "old", settings: { name: "m", size: 1 } });
+  });
+
+  it("replaces a nested record once the parser has closed it", () => {
+    expect(
+      shallowMergeInteractableState(
+        { title: "old", settings: { name: "n", size: 1, stale: true } },
+        { settings: { name: "m", size: 2 }, title: "ne" },
+        { partialPath: ["title"] },
+      ),
+    ).toEqual({ title: "ne", settings: { name: "m", size: 2 } });
+    expect(
+      shallowMergeInteractableState(
+        { settings: { name: "n", size: 1, stale: true } },
+        { settings: { name: "m", size: 2 } },
+      ),
+    ).toEqual({ settings: { name: "m", size: 2 } });
+  });
+
+  it("overlays along the whole partial path", () => {
+    expect(
+      shallowMergeInteractableState(
+        {
+          settings: {
+            name: "n",
+            theme: { fg: "black", bg: "white" },
+            tags: ["a"],
+          },
+        },
+        { settings: { theme: { fg: "r" }, tags: ["b"] } },
+        { partialPath: ["settings", "theme", "fg"] },
+      ),
+    ).toEqual({
+      settings: { name: "n", theme: { fg: "r", bg: "white" }, tags: ["b"] },
+    });
+  });
+
+  it("overlays a streaming array item patch onto the item", () => {
+    const prev = {
+      tasks: [
+        { id: "a", title: "A", meta: { owner: "me", due: "soon" } },
+        { id: "b", title: "B", meta: { owner: "you", due: "later" } },
+      ],
+    };
+
+    expect(
+      shallowMergeInteractableState(
+        prev,
+        {
+          tasks: {
+            update: [
+              { id: "b", meta: { owner: "them" } },
+              { id: "a", meta: { owner: "u" } },
+            ],
+          },
+        },
+        { partialPath: ["tasks", "update", "1", "meta", "owner"] },
+      ),
+    ).toEqual({
+      tasks: [
+        { id: "a", title: "A", meta: { owner: "u", due: "soon" } },
+        { id: "b", title: "B", meta: { owner: "them" } },
+      ],
+    });
+  });
 });
 
 describe("findModelKnownState", () => {

package/src/model-context/interactable-composer-metadata.ts

@@ -75,10 +75,31 @@ const getArrayItemId = (item: unknown): string | number | undefined => {
   return typeof id === "string" || typeof id === "number" ? id : undefined;
 };
 
+/**
+ * Overlays a streamed `value` onto `prev` along the parser's `partialPath`:
+ * the record still being written keeps the fields of `prev` it has not
+ * reached yet, while every field the parser has closed replaces its previous
+ * value, as the final merge will.
+ */
+export function overlayPartialPath(
+  prev: unknown,
+  value: unknown,
+  partialPath: readonly string[] = [],
+): unknown {
+  if (!isRecord(prev) || !isRecord(value)) return value;
+  const next: Record<string, unknown> = { ...prev, ...value };
+  const [key, ...rest] = partialPath;
+  if (key !== undefined && Object.hasOwn(value, key)) {
+    next[key] = overlayPartialPath(prev[key], value[key], rest);
+  }
+  return next;
+}
+
 function applyArrayUpdate(
   prev: unknown[],
   update: Record<string, unknown>,
   mintId?: () => string | undefined,
+  partialPath?: readonly string[],
 ) {
   let next = Array.isArray(update.set) ? [...update.set] : [...prev];
 
@@ -102,11 +123,18 @@ function applyArrayUpdate(
       }
     }
 
+    const streaming =
+      partialPath?.[0] === "update"
+        ? { patch: patches[Number(partialPath[1])], rest: partialPath.slice(2) }
+        : undefined;
     next = next.map((item) => {
       const id = getArrayItemId(item);
       if (id === undefined || !isRecord(item)) return item;
       const patch = patchesById.get(id);
-      return patch ? { ...item, ...patch } : item;
+      if (!patch) return item;
+      return streaming && patch === streaming.patch
+        ? overlayPartialPath(item, patch, streaming.rest)
+        : { ...item, ...patch };
     });
   }
 
@@ -142,6 +170,13 @@ export function shallowMergeInteractableState(
          */
         idFactory?: (field: string) => string | undefined;
         idKeyedFields?: ReadonlySet<string>;
+        /**
+         * The path of the value the argument parser reports as still
+         * streaming. The record there is overlaid onto its previous value
+         * so its unwritten fields hold until the model writes them; omitted
+         * once the arguments are complete.
+         */
+        partialPath?: readonly string[] | undefined;
       }
     | undefined,
 ): unknown {
@@ -149,16 +184,24 @@ export function shallowMergeInteractableState(
   const baseline = isRecord(options?.arrayBaseline)
     ? options.arrayBaseline
     : prev;
+  const partialPath = options?.partialPath;
   const next = Object.entries(prev);
   for (const [key, value] of Object.entries(partial)) {
     const baseValue = baseline[key];
+    const streamingPath =
+      partialPath?.[0] === key ? partialPath.slice(1) : undefined;
     if (Array.isArray(baseValue) && isRecord(value)) {
       const mintId =
         options?.idFactory &&
         (options.idKeyedFields === undefined || options.idKeyedFields.has(key))
           ? () => options.idFactory?.(key)
           : undefined;
-      next.push([key, applyArrayUpdate(baseValue, value, mintId)]);
+      next.push([
+        key,
+        applyArrayUpdate(baseValue, value, mintId, streamingPath),
+      ]);
+    } else if (streamingPath) {
+      next.push([key, overlayPartialPath(prev[key], value, streamingPath)]);
     } else {
       next.push([key, value]);
     }