@assistant-ui/core 0.2.8 → 0.2.10

package/src/store/clients/model-context-client.test.ts

@@ -6,6 +6,7 @@ import type {
   ModelContext as ModelContextValue,
   ModelContextProvider,
 } from "../../model-context/types";
+import { mergeModelContexts } from "../../model-context/types";
 
 const tick = () => new Promise<void>((resolve) => setTimeout(resolve, 0));
 
@@ -13,7 +14,7 @@ const provider = (ctx: ModelContextValue): ModelContextProvider => ({
   getModelContext: () => ctx,
 });
 
-const stubTool = (): Tool<any, any> =>
+const toolFixture = (): Tool<any, any> =>
   ({ description: "", parameters: {} as any }) as unknown as Tool<any, any>;
 
 const render = () => {
@@ -51,7 +52,9 @@ describe("ModelContext", () => {
     try {
       sub
         .getValue()
-        .register(provider({ tools: { foo: stubTool(), bar: stubTool() } }));
+        .register(
+          provider({ tools: { foo: toolFixture(), bar: toolFixture() } }),
+        );
       await tick();
 
       expect(sub.getValue().getState().toolNames).toEqual(["bar", "foo"]);
@@ -106,3 +109,85 @@ describe("ModelContext", () => {
     }
   });
 });
+
+describe("mergeModelContexts", () => {
+  it("merges a higher-priority tool override into an existing tool", () => {
+    const execute = async () => ({ ok: true });
+    const merged = mergeModelContexts(
+      new Set([
+        provider({
+          priority: 0,
+          tools: {
+            add_task: {
+              type: "frontend",
+              description: "Add a task",
+              parameters: { type: "object", properties: {} } as any,
+              renderText: { running: "Adding task" },
+            } as Tool<any, any>,
+          },
+        }),
+        provider({
+          priority: 1000,
+          tools: {
+            add_task: {
+              execute,
+            } as unknown as Tool<any, any>,
+          },
+        }),
+      ]),
+    );
+
+    expect(merged.tools?.add_task).toMatchObject({
+      type: "frontend",
+      description: "Add a task",
+    });
+    expect(merged.tools?.add_task?.execute).toBe(execute);
+    expect(merged.tools?.add_task?.parameters).toEqual({
+      type: "object",
+      properties: {},
+    });
+  });
+
+  it("still rejects duplicate tools at the same priority", () => {
+    expect(() =>
+      mergeModelContexts(
+        new Set([
+          provider({ tools: { duplicate: toolFixture() } }),
+          provider({ tools: { duplicate: toolFixture() } }),
+        ]),
+      ),
+    ).toThrow(/already exists/);
+  });
+
+  it("preserves the highest priority when a lower-priority provider reuses the same tool object", () => {
+    const shared = {
+      ...toolFixture(),
+      description: "high priority",
+    } as Tool<any, any>;
+    const execute = async () => ({ ok: true });
+    const merged = mergeModelContexts(
+      new Set([
+        provider({
+          priority: 1000,
+          tools: { shared },
+        }),
+        provider({
+          priority: 0,
+          tools: { shared },
+        }),
+        provider({
+          priority: 500,
+          tools: {
+            shared: {
+              description: "medium priority",
+              execute,
+            } as unknown as Tool<any, any>,
+          },
+        }),
+      ]),
+    );
+
+    expect(merged.tools?.shared?.description).toBe("high priority");
+    expect(merged.tools?.shared?.execute).toBe(execute);
+  });
+});

package/src/store/runtime-clients/thread-list-item-runtime-client.ts

@@ -44,6 +44,7 @@ export const ThreadListItemClient = resource(
       getState: () => state,
       switchTo: runtime.switchTo,
       rename: runtime.rename,
+      updateCustom: runtime.updateCustom,
       archive: runtime.archive,
       unarchive: runtime.unarchive,
       delete: runtime.delete,

package/src/store/scopes/thread-list-item.ts

@@ -14,6 +14,7 @@ export type ThreadListItemMethods = {
   getState(): ThreadListItemState;
   switchTo(options?: { unarchive?: boolean }): void;
   rename(newTitle: string): void;
+  updateCustom(custom: Record<string, unknown> | undefined): void;
   archive(): void;
   unarchive(): void;
   delete(): void;

package/src/tests/RemoteThreadListThreadListRuntimeCore-custom-metadata.test.ts

@@ -1,5 +1,9 @@
 import { describe, it, expect, vi } from "vitest";
-import { createCore, makeAdapter } from "./remote-thread-list-test-helpers";
+import {
+  createCore,
+  deferred,
+  makeAdapter,
+} from "./remote-thread-list-test-helpers";
 
 describe("RemoteThreadListThreadListRuntimeCore custom metadata", () => {
   it("preserves custom field from list() through to threadItems", async () => {
@@ -120,4 +124,68 @@ describe("RemoteThreadListThreadListRuntimeCore custom metadata", () => {
       workspaceId: "ws-1",
     });
   });
+
+  it("updates custom through the adapter with optimistic state", async () => {
+    const updateDeferred = deferred<void>();
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          {
+            status: "regular" as const,
+            remoteId: "thread-6",
+            externalId: "ext-6",
+            title: "Test",
+            custom: { tag: "old" },
+          },
+        ],
+      })),
+      updateCustom: vi.fn(() => updateDeferred.promise),
+    });
+
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+
+    const updateTask = core.updateCustom("thread-6", { tag: "new" });
+
+    await Promise.resolve();
+
+    expect(adapter.updateCustom).toHaveBeenCalledWith("thread-6", {
+      tag: "new",
+    });
+    expect(core.getItemById("thread-6")?.custom).toEqual({ tag: "new" });
+
+    updateDeferred.resolve();
+    await updateTask;
+
+    expect(core.getItemById("thread-6")?.custom).toEqual({ tag: "new" });
+  });
+
+  it("rolls back custom when adapter update fails", async () => {
+    const updateDeferred = deferred<void>();
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          {
+            status: "regular" as const,
+            remoteId: "thread-7",
+            externalId: "ext-7",
+            title: "Test",
+            custom: { tag: "old" },
+          },
+        ],
+      })),
+      updateCustom: vi.fn(() => updateDeferred.promise),
+    });
+
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+
+    const updateTask = core.updateCustom("thread-7", { tag: "new" });
+    expect(core.getItemById("thread-7")?.custom).toEqual({ tag: "new" });
+
+    updateDeferred.reject(new Error("update failed"));
+    await expect(updateTask).rejects.toThrow("update failed");
+
+    expect(core.getItemById("thread-7")?.custom).toEqual({ tag: "old" });
+  });
 });

package/src/tests/thread-list-runtime-getLoadThreadsPromise.test.ts

@@ -41,6 +41,7 @@ const createMockCore = (
   getLoadThreadsPromise: () => loadPromise,
   detach: () => Promise.resolve(),
   rename: () => Promise.resolve(),
+  updateCustom: () => Promise.resolve(),
   archive: () => Promise.resolve(),
   unarchive: () => Promise.resolve(),
   delete: () => Promise.resolve(),