@assistant-ui/core 0.2.9 → 0.2.10

package/src/react/runtimes/cloud/useCloudThreadListAdapter.tsx

@@ -14,6 +14,7 @@ import { InMemoryThreadListAdapter } from "../../../runtimes/remote-thread-list/
 import { useAssistantCloudThreadHistoryAdapter } from "./AssistantCloudThreadHistoryAdapter";
 import { RuntimeAdapterProvider } from "../RuntimeAdapterProvider";
 import { CloudFileAttachmentAdapter } from "./CloudFileAttachmentAdapter";
+import { isRecord } from "../../../utils/json/is-json";
 
 type ThreadData = {
   externalId: string | undefined;
@@ -26,6 +27,9 @@ type CloudThreadListAdapterOptions = {
   delete?: ((threadId: string) => Promise<void>) | undefined;
 };
 
+const toCustom = (value: unknown): Record<string, unknown> | undefined =>
+  isRecord(value) ? value : undefined;
+
 const baseUrl =
   typeof process !== "undefined" &&
   process?.env?.NEXT_PUBLIC_ASSISTANT_BASE_URL;
@@ -91,6 +95,7 @@ export const useCloudThreadListAdapter = (
           remoteId: t.id,
           title: t.title,
           externalId: t.external_id ?? undefined,
+          custom: toCustom(t.metadata),
         })),
       };
     },
@@ -110,6 +115,9 @@ export const useCloudThreadListAdapter = (
     rename: async (threadId, newTitle) => {
       return cloud.threads.update(threadId, { title: newTitle });
     },
+    updateCustom: async (threadId, custom) => {
+      return cloud.threads.update(threadId, { metadata: custom ?? null });
+    },
     archive: async (threadId) => {
       return cloud.threads.update(threadId, { is_archived: true });
     },
@@ -146,6 +154,7 @@ export const useCloudThreadListAdapter = (
         remoteId: thread.id,
         title: thread.title,
         externalId: thread.external_id ?? undefined,
+        custom: toCustom(thread.metadata),
       };
     },
 

package/src/runtime/api/thread-list-item-runtime.ts

@@ -38,6 +38,7 @@ export type ThreadListItemRuntime = {
 
   switchTo(options?: { unarchive?: boolean }): Promise<void>;
   rename(newTitle: string): Promise<void>;
+  updateCustom(custom: Record<string, unknown> | undefined): Promise<void>;
   archive(): Promise<void>;
   unarchive(): Promise<void>;
   delete(): Promise<void>;
@@ -74,6 +75,7 @@ export class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {
   protected __internal_bindMethods() {
     this.switchTo = this.switchTo.bind(this);
     this.rename = this.rename.bind(this);
+    this.updateCustom = this.updateCustom.bind(this);
     this.archive = this.archive.bind(this);
     this.unarchive = this.unarchive.bind(this);
     this.delete = this.delete.bind(this);
@@ -100,6 +102,19 @@ export class ThreadListItemRuntimeImpl implements ThreadListItemRuntime {
     return this._threadListBinding.rename(state.id, newTitle);
   }
 
+  public updateCustom(
+    custom: Record<string, unknown> | undefined,
+  ): Promise<void> {
+    const state = this._core.getState();
+    if (!this._threadListBinding.updateCustom) {
+      throw new Error(
+        "Thread list runtime does not support updating custom metadata",
+      );
+    }
+
+    return this._threadListBinding.updateCustom(state.id, custom);
+  }
+
   public archive(): Promise<void> {
     const state = this._core.getState();
 

package/src/runtime/interfaces/thread-list-runtime-core.ts

@@ -44,6 +44,10 @@ export type ThreadListRuntimeCore = {
 
   detach(threadId: string): Promise<void>;
   rename(threadId: string, newTitle: string): Promise<void>;
+  updateCustom?(
+    threadId: string,
+    custom: Record<string, unknown> | undefined,
+  ): Promise<void>;
   archive(threadId: string): Promise<void>;
   unarchive(threadId: string): Promise<void>;
   delete(threadId: string): Promise<void>;

package/src/runtimes/external-store/external-store-adapter.ts

@@ -24,6 +24,7 @@ export type ExternalStoreThreadData<TState extends "regular" | "archived"> = {
   remoteId?: string | undefined;
   externalId?: string | undefined;
   title?: string | undefined;
+  custom?: Record<string, unknown> | undefined;
 };
 
 export type ExternalStoreThreadListAdapter = {
@@ -46,6 +47,12 @@ export type ExternalStoreThreadListAdapter = {
     threadId: string,
     newTitle: string,
   ) => (Promise<void> | void) | undefined;
+  onUpdateCustom?:
+    | ((
+        threadId: string,
+        custom: Record<string, unknown> | undefined,
+      ) => Promise<void> | void)
+    | undefined;
   onArchive?: ((threadId: string) => Promise<void> | void) | undefined;
   onUnarchive?: ((threadId: string) => Promise<void> | void) | undefined;
   onDelete?: ((threadId: string) => Promise<void> | void) | undefined;

package/src/runtimes/external-store/external-store-thread-list-runtime-core.ts

@@ -197,6 +197,19 @@ export class ExternalStoreThreadListRuntimeCore implements ThreadListRuntimeCore
     await onRename(threadId, newTitle);
   }
 
+  public async updateCustom(
+    threadId: string,
+    custom: Record<string, unknown> | undefined,
+  ): Promise<void> {
+    const onUpdateCustom = this.adapter.onUpdateCustom;
+    if (!onUpdateCustom)
+      throw new Error(
+        "External store adapter does not support updating custom metadata",
+      );
+
+    await onUpdateCustom(threadId, custom);
+  }
+
   public async detach(): Promise<void> {
     // no-op
   }

package/src/runtimes/remote-thread-list/adapter/in-memory.ts

@@ -17,6 +17,10 @@ export class InMemoryThreadListAdapter implements RemoteThreadListAdapter {
     return Promise.resolve();
   }
 
+  updateCustom(): Promise<void> {
+    return Promise.resolve();
+  }
+
   archive(): Promise<void> {
     return Promise.resolve();
   }

package/src/runtimes/remote-thread-list/types.ts

@@ -29,6 +29,10 @@ export type RemoteThreadListAdapter = {
   list(params?: RemoteThreadListPageOptions): Promise<RemoteThreadListResponse>;
 
   rename(remoteId: string, newTitle: string): Promise<void>;
+  updateCustom?(
+    remoteId: string,
+    custom: Record<string, unknown> | undefined,
+  ): Promise<void>;
   archive(remoteId: string): Promise<void>;
   unarchive(remoteId: string): Promise<void>;
   delete(remoteId: string): Promise<void>;

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(),