@assistant-ui/core 0.3.13 → 0.3.15

package/src/react/runtimes/RemoteThreadResource.test.ts

@@ -0,0 +1,141 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { AssistantRuntimeImpl } from "../../runtime/api/assistant-runtime";
+import type { ThreadListItemRuntime } from "../../runtime/api/thread-list-item-runtime";
+import { LocalRuntimeCore } from "../../runtimes/local/local-runtime-core";
+import type { AppendMessage } from "../../types/message";
+import { subscribeToTitleGeneration } from "./RemoteThreadResource";
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("subscribeToTitleGeneration", () => {
+  it("reports title generation failures", async () => {
+    const error = new Error("title unavailable");
+    const core = new LocalRuntimeCore(
+      {
+        adapters: {
+          chatModel: {
+            async run() {
+              return { content: [{ type: "text", text: "done" }] };
+            },
+          },
+        },
+        unstable_humanToolNames: [],
+      },
+      undefined,
+    );
+    const runtime = new AssistantRuntimeImpl(core);
+    const itemRuntime = {
+      generateTitle: vi.fn(async () => {
+        throw error;
+      }),
+    } as unknown as ThreadListItemRuntime;
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => undefined);
+
+    subscribeToTitleGeneration(runtime.thread, itemRuntime);
+    const message: AppendMessage = {
+      parentId: null,
+      sourceId: null,
+      runConfig: {},
+      role: "user",
+      content: [{ type: "text", text: "hello" }],
+      attachments: [],
+      metadata: { custom: {} },
+      createdAt: new Date(),
+    };
+
+    await expect(
+      core.threads.getMainThreadRuntimeCore().append(message),
+    ).resolves.toBeUndefined();
+
+    await vi.waitFor(() => {
+      expect(itemRuntime.generateTitle).toHaveBeenCalledOnce();
+      expect(consoleError).toHaveBeenCalledWith(
+        "[assistant-ui] Thread title generation failed",
+        error,
+      );
+    });
+  });
+
+  it("waits for the first message before generating", async () => {
+    const core = new LocalRuntimeCore(
+      {
+        adapters: {
+          chatModel: {
+            async run() {
+              return { content: [{ type: "text", text: "done" }] };
+            },
+          },
+        },
+        unstable_humanToolNames: [],
+      },
+      undefined,
+    );
+    const runtime = new AssistantRuntimeImpl(core);
+    const itemRuntime = {
+      generateTitle: vi.fn(async () => {}),
+    } as unknown as ThreadListItemRuntime;
+
+    subscribeToTitleGeneration(runtime.thread, itemRuntime);
+    expect(itemRuntime.generateTitle).not.toHaveBeenCalled();
+
+    const message: AppendMessage = {
+      parentId: null,
+      sourceId: null,
+      runConfig: {},
+      role: "user",
+      content: [{ type: "text", text: "hello" }],
+      attachments: [],
+      metadata: { custom: {} },
+      createdAt: new Date(),
+      startRun: false,
+    };
+    await core.threads.getMainThreadRuntimeCore().append(message);
+
+    await vi.waitFor(() => {
+      expect(itemRuntime.generateTitle).toHaveBeenCalledOnce();
+    });
+  });
+
+  it("generates immediately when a message already exists", async () => {
+    const core = new LocalRuntimeCore(
+      {
+        adapters: {
+          chatModel: {
+            async run() {
+              return { content: [{ type: "text", text: "done" }] };
+            },
+          },
+        },
+        unstable_humanToolNames: [],
+      },
+      undefined,
+    );
+    const runtime = new AssistantRuntimeImpl(core);
+    const itemRuntime = {
+      generateTitle: vi.fn(async () => {}),
+    } as unknown as ThreadListItemRuntime;
+
+    const message: AppendMessage = {
+      parentId: null,
+      sourceId: null,
+      runConfig: {},
+      role: "user",
+      content: [{ type: "text", text: "hello" }],
+      attachments: [],
+      metadata: { custom: {} },
+      createdAt: new Date(),
+      startRun: false,
+    };
+    await core.threads.getMainThreadRuntimeCore().append(message);
+
+    subscribeToTitleGeneration(runtime.thread, itemRuntime);
+
+    await vi.waitFor(() => {
+      expect(itemRuntime.generateTitle).toHaveBeenCalledOnce();
+    });
+  });
+});

package/src/react/runtimes/RemoteThreadResource.ts

@@ -0,0 +1,233 @@
+import { useCallback, useEffect, useEffectEvent, useMemo, useRef } from "react";
+import { resource } from "@assistant-ui/tap";
+import {
+  useAssistantContextProvider,
+  useConfiguredAui,
+} from "@assistant-ui/store/client";
+import { ThreadListItemClient } from "../../store/internal";
+import type { AssistantRuntime } from "../../runtime/api/assistant-runtime";
+import type { ThreadListRuntimeCore } from "../../runtime/interfaces/thread-list-runtime-core";
+import type { ThreadRuntimeCore } from "../../runtime/interfaces/thread-runtime-core";
+import type { ThreadRuntimeImpl } from "../../runtime/api/thread-runtime";
+import {
+  ThreadListItemRuntimeImpl,
+  type ThreadListItemRuntime,
+} from "../../runtime/api/thread-list-item-runtime";
+import {
+  SKIP_UPDATE,
+  ShallowMemoizeSubject,
+} from "../../subscribable/subscribable";
+import {
+  useRuntimeAdaptersProvider,
+  type RuntimeAdapters,
+} from "./RuntimeAdapterProvider";
+import { isSilentRuntimeAction } from "../../utils/silent-runtime-action";
+
+export type RemoteThreadListHook = () => AssistantRuntime;
+
+export type RemoteThreadResourceProps = {
+  threadId: string;
+  generation: number;
+  parentList: ThreadListRuntimeCore;
+  runtimeHook: RemoteThreadListHook;
+  parentClient: Parameters<typeof useConfiguredAui>[0];
+  adapters: RuntimeAdapters | null;
+  publish: (
+    threadId: string,
+    runtime: ThreadRuntimeCore,
+    generation: number,
+  ) => void;
+};
+
+export const isTitleSourceMessage = (message: {
+  status?: { type: string } | undefined;
+}) => message.status?.type !== "running";
+
+export const subscribeToTitleGeneration = (
+  threadRuntime: AssistantRuntime["thread"],
+  itemRuntime: ThreadListItemRuntime,
+) => {
+  const generate = () =>
+    void itemRuntime.generateTitle().catch((error: unknown) => {
+      if (isSilentRuntimeAction(error)) return;
+      console.error("[assistant-ui] Thread title generation failed", error);
+    });
+
+  const hasTitleSource = () =>
+    threadRuntime.getState().messages.some(isTitleSourceMessage);
+
+  if (hasTitleSource()) {
+    generate();
+    return () => {};
+  }
+
+  const unsubscribe = threadRuntime.subscribe(() => {
+    if (!hasTitleSource()) return;
+    unsubscribe();
+    generate();
+  });
+  return unsubscribe;
+};
+
+const useRemoteThreadBinder = ({
+  threadId,
+  generation,
+  runtimeHook,
+  publish,
+  itemRuntime,
+}: {
+  threadId: string;
+  generation: number;
+  runtimeHook: RemoteThreadListHook;
+  publish: RemoteThreadResourceProps["publish"];
+  itemRuntime: ThreadListItemRuntime;
+}) => {
+  const runtime = runtimeHook();
+  const threadBinding = (runtime?.thread as ThreadRuntimeImpl | undefined)
+    ?.__internal_threadBinding;
+
+  const updateRuntime = useCallback(() => {
+    if (!threadBinding) return;
+    publish(threadId, threadBinding.getState(), generation);
+  }, [threadId, generation, threadBinding, publish]);
+
+  const isMounted = useRef(false);
+  if (!isMounted.current) {
+    updateRuntime();
+  }
+
+  useEffect(() => {
+    if (!threadBinding) return undefined;
+    isMounted.current = true;
+    updateRuntime();
+    return threadBinding.outerSubscribe(updateRuntime);
+  }, [threadBinding, updateRuntime]);
+
+  const initPromiseRef = useRef<Promise<unknown> | undefined>(undefined);
+  const hasInitializedRef = useRef(false);
+  const titleDisposeRef = useRef<(() => void) | undefined>(undefined);
+  const titleAliveRef = useRef(false);
+
+  const handleInitialize = useEffectEvent(() => {
+    if (hasInitializedRef.current) return;
+
+    const state = itemRuntime.getState();
+    if (state.status !== "new") return;
+    hasInitializedRef.current = true;
+
+    const initPromise = itemRuntime.initialize();
+    initPromiseRef.current = initPromise;
+
+    // The title needs the thread to exist and its first message, so it arms
+    // when initialization resolves rather than at the first runEnd; waiting
+    // for the run would leave the thread on "New Chat" for the whole
+    // response, and forever when the run never completes.
+    void initPromise.then(
+      () => {
+        if (!titleAliveRef.current) return;
+        titleDisposeRef.current?.();
+        titleDisposeRef.current = subscribeToTitleGeneration(
+          runtime.thread,
+          itemRuntime,
+        );
+      },
+      () => {
+        if (initPromiseRef.current === initPromise) {
+          initPromiseRef.current = undefined;
+          hasInitializedRef.current = false;
+        }
+      },
+    );
+  });
+
+  const getInitializePromise = useEffectEvent(() => {
+    handleInitialize();
+    return initPromiseRef.current;
+  });
+
+  useEffect(() => {
+    if (!threadBinding) return;
+    const runtimeCore = threadBinding.getState();
+    const setGetInitializePromise = (runtimeCore as Record<string, unknown>)
+      .__internal_setGetInitializePromise;
+    if (typeof setGetInitializePromise === "function") {
+      setGetInitializePromise.call(runtimeCore, getInitializePromise);
+    }
+  }, [threadBinding]);
+  useEffect(() => {
+    if (!runtime?.threads?.main) return undefined;
+    hasInitializedRef.current = false;
+    titleAliveRef.current = true;
+    const unsubscribe = runtime.threads.main.unstable_on(
+      "initialize",
+      handleInitialize,
+    );
+    return () => {
+      titleAliveRef.current = false;
+      unsubscribe();
+      titleDisposeRef.current?.();
+      titleDisposeRef.current = undefined;
+    };
+  }, [runtime]);
+
+  return runtime;
+};
+
+const useRemoteThreadResource = ({
+  threadId,
+  generation,
+  parentList,
+  runtimeHook,
+  parentClient,
+  adapters,
+  publish,
+}: RemoteThreadResourceProps) => {
+  const itemRuntime = useMemo(
+    () =>
+      new ThreadListItemRuntimeImpl(
+        new ShallowMemoizeSubject({
+          path: {
+            ref: `threadItems[threadId=${threadId}]`,
+            threadSelector: { type: "threadId", threadId },
+          },
+          getState: () => {
+            const data = parentList.getItemById(threadId);
+            if (!data) return SKIP_UPDATE;
+            return {
+              id: data.id,
+              remoteId: data.remoteId,
+              externalId: data.externalId,
+              title: data.title,
+              lastMessageAt: data.lastMessageAt,
+              custom: data.custom,
+              status: data.status,
+              isMain: data.id === parentList.mainThreadId,
+              isRunning:
+                parentList.unstable_isThreadRunning?.(data.id) ?? false,
+            };
+          },
+          subscribe: (callback) => parentList.subscribe(callback),
+        }),
+        parentList,
+      ),
+    [parentList, threadId],
+  );
+
+  const { client } = useConfiguredAui(parentClient, {
+    threadListItem: ThreadListItemClient({ runtime: itemRuntime }),
+  });
+
+  return useAssistantContextProvider(client, function useThreadClient() {
+    return useRuntimeAdaptersProvider(adapters, function useBoundRuntime() {
+      return useRemoteThreadBinder({
+        threadId,
+        generation,
+        runtimeHook,
+        publish,
+        itemRuntime,
+      });
+    });
+  });
+};
+
+export const RemoteThreadResource = resource(useRemoteThreadResource);

package/src/react/runtimes/RuntimeAdapterProvider.tsx

@@ -1,21 +1,13 @@
+import { type FC, type ReactNode, useContext, useMemo } from "react";
+import type { RuntimeAdapters } from "../../runtimes/remote-thread-list/types";
 import {
-  createContext,
-  type FC,
-  type ReactNode,
-  useContext,
-  useMemo,
-} from "react";
-import type { ThreadHistoryAdapter } from "../../adapters/thread-history";
-import type { AttachmentAdapter } from "../../adapters/attachment";
-import type { ModelContextProvider } from "../../model-context/types";
+  RuntimeAdaptersContext,
+  useRuntimeAdapters,
+  useRuntimeAdaptersProvider,
+} from "./useRuntimeAdapters";
 
-export type RuntimeAdapters = {
-  modelContext?: ModelContextProvider | undefined;
-  history?: ThreadHistoryAdapter | undefined;
-  attachments?: AttachmentAdapter | undefined;
-};
-
-const RuntimeAdaptersContext = createContext<RuntimeAdapters | null>(null);
+export type { RuntimeAdapters };
+export { useRuntimeAdapters, useRuntimeAdaptersProvider };
 
 export namespace RuntimeAdapterProvider {
   export type Props = {
@@ -39,7 +31,3 @@ export const RuntimeAdapterProvider: FC<RuntimeAdapterProvider.Props> = ({
     </RuntimeAdaptersContext.Provider>
   );
 };
-
-export const useRuntimeAdapters = () => {
-  return useContext(RuntimeAdaptersContext);
-};

package/src/react/runtimes/assistant-transport/commandQueue.ts

@@ -0,0 +1,68 @@
+import { useState, useCallback, useRef, useEffect } from "react";
+import type {
+  AssistantTransportCommand,
+  CommandQueueState,
+  QueuedCommand,
+} from "./types";
+
+export const createInitialQueueState = (): CommandQueueState => ({
+  queued: [],
+  inTransit: [],
+});
+
+export const useCommandQueue = (opts: { onQueue: () => void }) => {
+  const onQueueRef = useRef(opts.onQueue);
+  useEffect(() => {
+    onQueueRef.current = opts.onQueue;
+  });
+
+  const [, rerender] = useState(0);
+  const queueStateRef = useRef<CommandQueueState>(createInitialQueueState());
+
+  const enqueue = (
+    command: AssistantTransportCommand,
+    options?: { schedule?: boolean },
+  ) => {
+    queueStateRef.current = {
+      queued: [...queueStateRef.current.queued, command],
+      inTransit: queueStateRef.current.inTransit,
+    };
+    rerender((prev) => prev + 1);
+
+    if (options?.schedule !== false) onQueueRef.current();
+  };
+
+  const flush = (): QueuedCommand[] => {
+    if (queueStateRef.current.queued.length === 0) return [];
+
+    const queued = queueStateRef.current.queued;
+    queueStateRef.current = {
+      queued: [],
+      inTransit: [...queueStateRef.current.inTransit, ...queued],
+    };
+    rerender((prev) => prev + 1);
+
+    return queued;
+  };
+
+  const markDelivered = () => {
+    queueStateRef.current = { ...queueStateRef.current, inTransit: [] };
+    rerender((prev) => prev + 1);
+  };
+
+  const reset = useCallback(() => {
+    queueStateRef.current = createInitialQueueState();
+    rerender((prev) => prev + 1);
+  }, []);
+
+  return {
+    // live getter — callbacks firing between renders must not see a stale snapshot
+    get state() {
+      return queueStateRef.current;
+    },
+    enqueue,
+    flush,
+    markDelivered,
+    reset,
+  };
+};