@assistant-ui/core 0.3.11 → 0.3.13

package/src/store/clients/runtime-adapter.ts

@@ -1,7 +1,6 @@
 import type { AssistantClient, ScopesConfig } from "@assistant-ui/store";
 import { Derived } from "@assistant-ui/store/client";
 import { ModelContext } from "./model-context-client";
-import { Suggestions } from "./suggestions";
 
 export const baseRuntimeAdapterTransformScopes = (
   scopes: ScopesConfig,
@@ -27,6 +26,10 @@ export const baseRuntimeAdapterTransformScopes = (
     scopes.modelContext = ModelContext();
   }
   if (!scopes.suggestions && parent.suggestions.source === null) {
-    scopes.suggestions = Suggestions();
+    scopes.suggestions = Derived({
+      source: "thread",
+      query: {},
+      get: (aui) => aui.thread.suggestions(),
+    });
   }
 };

package/src/store/clients/single-thread-list.ts

@@ -0,0 +1,116 @@
+import { useMemo, useState } from "react";
+import { resource } from "@assistant-ui/tap";
+import type { ClientElement, ClientOutput } from "@assistant-ui/store";
+import { useClientResource } from "@assistant-ui/store/client";
+
+const RESOLVED_PROMISE = Promise.resolve();
+const THREAD_ID = "default";
+
+const useSingleThreadListItem = ({
+  isRunning,
+}: {
+  isRunning: boolean;
+}): ClientOutput<"threadListItem"> => {
+  const [custom, setCustom] = useState<Record<string, unknown> | undefined>();
+
+  return {
+    getState: () => ({
+      id: THREAD_ID,
+      remoteId: undefined,
+      externalId: undefined,
+      title: undefined,
+      status: "regular",
+      custom,
+      isRunning,
+    }),
+    switchTo: () => {},
+    rename: () => {},
+    updateCustom: setCustom,
+    archive: () => {},
+    unarchive: () => {},
+    delete: () => {},
+    generateTitle: () => {},
+    initialize: async () => ({ remoteId: THREAD_ID, externalId: undefined }),
+    detach: () => {},
+  };
+};
+
+const SingleThreadListItem = resource(useSingleThreadListItem);
+
+type SingleThreadListProps = {
+  thread: ClientElement<"thread">;
+};
+
+/**
+ * A minimal threads scope that wraps a single thread.
+ * Automatically provided by ExternalThread when no threads scope exists.
+ * Mounts the provided thread resource element.
+ */
+const useSingleThreadList = ({
+  thread,
+}: SingleThreadListProps): ClientOutput<"threads"> => {
+  const threadClient = useClientResource(thread);
+  const itemClient = useClientResource(
+    SingleThreadListItem({ isRunning: threadClient.state.isRunning }),
+  );
+
+  const state = useMemo(
+    () => ({
+      mainThreadId: THREAD_ID,
+      newThreadId: null,
+      isLoading: false,
+      isLoadingMore: false,
+      hasMore: false,
+      threadIds: [THREAD_ID],
+      archivedThreadIds: [],
+      threadItems: [itemClient.state],
+      main: threadClient.state,
+    }),
+    [itemClient.state, threadClient.state],
+  );
+
+  return {
+    getState: () => state,
+    switchToThread: () => {
+      throw new Error("SingleThreadList does not support switchToThread");
+    },
+    switchToNewThread: () => {
+      throw new Error("SingleThreadList does not support switchToNewThread");
+    },
+    getLoadThreadsPromise: () => RESOLVED_PROMISE,
+    reload: () => RESOLVED_PROMISE,
+    reloadMainThread: () =>
+      threadClient.methods.unstable_refetchThread?.() ?? RESOLVED_PROMISE,
+    loadMore: () => RESOLVED_PROMISE,
+    item: (selector) => {
+      if (
+        selector !== "main" &&
+        !(
+          typeof selector === "object" &&
+          "id" in selector &&
+          selector.id === THREAD_ID
+        ) &&
+        !(
+          typeof selector === "object" &&
+          "index" in selector &&
+          selector.index === 0
+        )
+      ) {
+        throw new Error(
+          `SingleThreadList: unknown item selector ${JSON.stringify(selector)}`,
+        );
+      }
+      return itemClient.methods;
+    },
+    thread: (selector) => {
+      if (selector !== "main" && selector !== THREAD_ID) {
+        throw new Error(
+          `SingleThreadList: unknown thread selector ${JSON.stringify(selector)}`,
+        );
+      }
+      return threadClient.methods;
+    },
+  };
+};
+
+export const SingleThreadList = resource(useSingleThreadList);

package/src/store/clients/suggestions.ts

@@ -1,9 +1,10 @@
-import { useState } from "react";
+import { useMemo, useState } from "react";
 import { resource, withKey } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
 import { useClientLookup } from "@assistant-ui/store/client";
 import type { SuggestionsState } from "../scopes/suggestions";
 import type { SuggestionState } from "../scopes/suggestion";
+import type { ThreadSuggestion } from "../../runtime/interfaces/thread-runtime-core";
 
 export type SuggestionConfig =
   | string
@@ -19,7 +20,24 @@ const useSuggestionClient = (
 
 const SuggestionClient = resource(useSuggestionClient);
 
-const useSuggestionsResource = (
+const useSuggestionsClient = (
+  state: SuggestionsState,
+): ClientOutput<"suggestions"> => {
+  const suggestionClients = useClientLookup(
+    state.suggestions.map((suggestion, index) =>
+      withKey(index, SuggestionClient(suggestion), [suggestion]),
+    ),
+  );
+
+  return {
+    getState: () => state,
+    suggestion: ({ index }: { index: number }) => {
+      return suggestionClients.get({ index });
+    },
+  };
+};
+
+const useStaticSuggestions = (
   suggestions?: SuggestionConfig[],
 ): ClientOutput<"suggestions"> => {
   const [state] = useState<SuggestionsState>(() => {
@@ -43,18 +61,26 @@ const useSuggestionsResource = (
     };
   });
 
-  const suggestionClients = useClientLookup(
-    state.suggestions.map((suggestion, index) =>
-      withKey(index, SuggestionClient(suggestion), [suggestion]),
-    ),
+  return useSuggestionsClient(state);
+};
+
+export const Suggestions = resource(useStaticSuggestions);
+
+const useThreadSuggestions = (
+  suggestions: readonly ThreadSuggestion[],
+): ClientOutput<"suggestions"> => {
+  const state = useMemo<SuggestionsState>(
+    () => ({
+      suggestions: suggestions.map((s) => ({
+        title: s.prompt,
+        label: "",
+        prompt: s.prompt,
+      })),
+    }),
+    [suggestions],
   );
 
-  return {
-    getState: () => state,
-    suggestion: ({ index }: { index: number }) => {
-      return suggestionClients.get({ index });
-    },
-  };
+  return useSuggestionsClient(state);
 };
 
-export const Suggestions = resource(useSuggestionsResource);
+export const ThreadSuggestions = resource(useThreadSuggestions);

package/src/store/index.ts

@@ -109,6 +109,12 @@ export type {
 } from "../react/model-context/toolbox";
 
 // clients
+export {
+  ExternalThread,
+  type ExternalThreadProps,
+  type ExternalThreadMessage,
+} from "./clients/external-thread";
+export { SingleThreadList } from "./clients/single-thread-list";
 export { NoOpComposerClient } from "./clients/no-op-composer-client";
 export { Suggestions, type SuggestionConfig } from "./clients/suggestions";
 export { ChainOfThoughtClient } from "./clients/chain-of-thought-client";

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

@@ -1,12 +1,8 @@
-import type { Unsubscribe } from "../../types/unsubscribe";
-import { useEffect, useMemo } from "react";
+import { useEffect, useMemo, useRef } from "react";
 import { resource } from "@assistant-ui/tap";
 import type { ClientOutput } from "@assistant-ui/store";
 import { useAssistantEmit } from "@assistant-ui/store/client";
-import type {
-  ThreadListItemEventType,
-  ThreadListItemRuntime,
-} from "../../runtime/api/thread-list-item-runtime";
+import type { ThreadListItemRuntime } from "../../runtime/api/thread-list-item-runtime";
 import { useSubscribable } from "./useSubscribable";
 
 const useThreadListItemClient = ({
@@ -28,29 +24,18 @@ const useThreadListItemClient = ({
   }, [runtimeState, mainThreadIsRunning]);
   const emit = useAssistantEmit();
 
-  // Bind thread list item events to event manager
+  // Emitted after the flush that rebinds the derived scopes; the runtime's own
+  // synchronous notification would be delivered against the pre-switch binding.
+  const { isMain, id: threadId } = runtimeState;
+  const selectionRef = useRef({ isMain, threadId });
   useEffect(() => {
-    const unsubscribers: Unsubscribe[] = [];
-
-    // Subscribe to thread list item events
-    const threadListItemEvents: ThreadListItemEventType[] = [
-      "switchedTo",
-      "switchedAway",
-    ];
-
-    for (const event of threadListItemEvents) {
-      const unsubscribe = runtime.unstable_on(event, () => {
-        emit(`threadListItem.${event}`, {
-          threadId: runtime.getState()!.id,
-        });
-      });
-      unsubscribers.push(unsubscribe);
-    }
-
-    return () => {
-      for (const unsub of unsubscribers) unsub();
-    };
-  }, [runtime, emit]);
+    const previous = selectionRef.current;
+    if (previous.isMain === isMain && previous.threadId === threadId) return;
+    selectionRef.current = { isMain, threadId };
+    emit(isMain ? "threadListItem.switchedTo" : "threadListItem.switchedAway", {
+      threadId,
+    });
+  }, [isMain, threadId, emit]);
 
   return {
     getState: () => state,

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

@@ -12,6 +12,7 @@ import {
 } from "@assistant-ui/store/client";
 import { ComposerClient } from "./composer-runtime-client";
 import { MessageClient } from "./message-runtime-client";
+import { ThreadSuggestions } from "../clients/suggestions";
 import { useSubscribable } from "./useSubscribable";
 import type { ThreadState } from "../scopes/thread";
 
@@ -78,6 +79,9 @@ const useThreadClient = ({
       threadIdRef,
     }),
   );
+  const suggestions = useClientResource(
+    ThreadSuggestions(runtimeState.suggestions),
+  );
   const messages = useClientLookup(
     runtimeState.messages.map((m) =>
       withKey(m.id, MessageClientById({ runtime, id: m.id, threadIdRef }), [
@@ -109,6 +113,7 @@ const useThreadClient = ({
   return {
     getState: () => state,
     composer: () => composer.methods,
+    suggestions: () => suggestions.methods,
     append: runtime.append,
     deleteMessage: runtime.deleteMessage,
     startRun: runtime.startRun,

package/src/store/scopes/suggestions.ts

@@ -15,6 +15,12 @@ export type SuggestionsMethods = {
   suggestion(query: { index: number }): SuggestionMethods;
 };
 
+export type SuggestionsMeta = {
+  source: "thread";
+  query: Record<string, never>;
+};
+
 export type SuggestionsClientSchema = {
   methods: SuggestionsMethods;
+  meta: SuggestionsMeta;
 };

package/src/store/scopes/thread.ts

@@ -17,6 +17,7 @@ import type {
 import type { ModelContext } from "../../model-context/types";
 import type { MessageMethods, MessageState } from "./message";
 import type { ComposerMethods, ComposerState } from "./composer";
+import type { SuggestionsMethods } from "./suggestions";
 
 export type ThreadState = {
   /**
@@ -71,6 +72,10 @@ export type ThreadMethods = {
    * The thread composer runtime.
    */
   composer(): ComposerMethods;
+  /**
+   * The suggestions shown for this thread.
+   */
+  suggestions(): SuggestionsMethods;
   /**
    * Append a new message to the thread.
    *
@@ -100,6 +105,18 @@ export type ThreadMethods = {
    */
   resumeRun(config: CreateResumeRunConfig): void;
   cancelRun(): void;
+  /**
+   * Re-fetch this thread's state from its backing store, in place: the tap
+   * thread's refetch hook, which `threads.reloadMainThread()` prefers and
+   * whose rejection it propagates. `capabilities.refetchThread` is the
+   * portable feature-detection signal; a legacy-bridged thread reports it
+   * there while routing the refetch through its runtime, not this method.
+   * The method-shorthand optionality is load-bearing: an explicit
+   * `| undefined` stops `ThreadMethods` satisfying `ClientMethods` and
+   * collapses the client schema, which only a workspace-level app typecheck
+   * surfaces.
+   */
+  unstable_refetchThread?(): Promise<void>;
   getModelContext(): ModelContext;
   export(): ExportedMessageRepository;
   import(repository: ExportedMessageRepository): void;