@assistant-ui/react 0.12.10 → 0.12.12

package/src/client/InMemoryThreadList.ts

@@ -3,15 +3,14 @@ import {
   type ClientOutput,
   tapClientLookup,
   Derived,
-  attachDefaultPeers,
+  attachTransformScopes,
   tapClientResource,
 } from "@assistant-ui/store";
 import { withKey } from "@assistant-ui/tap";
 import type { ResourceElement } from "@assistant-ui/tap";
-import type { ThreadState } from "../types/scopes/thread";
-import { Suggestions } from "./Suggestions";
-import { ModelContext } from "./ModelContextClient";
-import { Tools } from "./Tools";
+
+import { ModelContext, Suggestions } from "@assistant-ui/core/store";
+import { Tools, DataRenderers } from "@assistant-ui/core/react";
 
 export type InMemoryThreadListProps = {
   thread: (threadId: string) => ResourceElement<ClientOutput<"thread">>;
@@ -47,18 +46,15 @@ const ThreadListItemClient = resource(
     );
 
     return {
-      state,
-      methods: {
-        getState: () => state,
-        switchTo: onSwitchTo,
-        rename: () => {},
-        archive: onArchive,
-        unarchive: onUnarchive,
-        delete: onDelete,
-        generateTitle: () => {},
-        initialize: async () => ({ remoteId: data.id, externalId: undefined }),
-        detach: () => {},
-      },
+      getState: () => state,
+      switchTo: onSwitchTo,
+      rename: () => {},
+      archive: onArchive,
+      unarchive: onUnarchive,
+      delete: onDelete,
+      generateTitle: () => {},
+      initialize: async () => ({ remoteId: data.id, externalId: undefined }),
+      detach: () => {},
     };
   },
 );
@@ -139,7 +135,6 @@ export const InMemoryThreadList = resource(
     const state = tapMemo(() => {
       const regularThreads = threads.filter((t) => t.status === "regular");
       const archivedThreads = threads.filter((t) => t.status === "archived");
-      const mainThreadState = mainThreadClient.state as ThreadState;
 
       return {
         mainThreadId,
@@ -148,50 +143,68 @@ export const InMemoryThreadList = resource(
         threadIds: regularThreads.map((t) => t.id),
         archivedThreadIds: archivedThreads.map((t) => t.id),
         threadItems: threadListItems.state,
-        main: mainThreadState,
+        main: mainThreadClient.state,
       };
     }, [mainThreadId, threads, threadListItems.state, mainThreadClient.state]);
 
     return {
-      state,
-      methods: {
-        getState: () => state,
-        switchToThread: handleSwitchToThread,
-        switchToNewThread: handleSwitchToNewThread,
-        item: (selector) => {
-          if (selector === "main") {
-            const index = threads.findIndex((t) => t.id === mainThreadId);
-            return threadListItems.get({ index: index === -1 ? 0 : index });
-          }
-          if ("id" in selector) {
-            const index = threads.findIndex((t) => t.id === selector.id);
-            return threadListItems.get({ index });
-          }
-          return threadListItems.get(selector);
-        },
-        thread: () => mainThreadClient.methods,
+      getState: () => state,
+      switchToThread: handleSwitchToThread,
+      switchToNewThread: handleSwitchToNewThread,
+      item: (selector) => {
+        if (selector === "main") {
+          const index = threads.findIndex((t) => t.id === mainThreadId);
+          return threadListItems.get({ index: index === -1 ? 0 : index });
+        }
+        if ("id" in selector) {
+          const index = threads.findIndex((t) => t.id === selector.id);
+          return threadListItems.get({ index });
+        }
+        return threadListItems.get(selector);
       },
+      thread: () => mainThreadClient.methods,
     };
   },
 );
 
-attachDefaultPeers(InMemoryThreadList, {
-  thread: Derived({
-    source: "threads",
-    query: { type: "main" },
-    get: (aui) => aui.threads().thread("main"),
-  }),
-  threadListItem: Derived({
-    source: "threads",
-    query: { type: "main" },
-    get: (aui) => aui.threads().item("main"),
-  }),
-  composer: Derived({
-    source: "thread",
-    query: {},
-    get: (aui) => aui.threads().thread("main").composer,
-  }),
-  modelContext: ModelContext(),
-  tools: Tools({}),
-  suggestions: Suggestions(),
+attachTransformScopes(InMemoryThreadList, (scopes, parent) => {
+  const result = {
+    ...scopes,
+    thread:
+      scopes.thread ??
+      Derived({
+        source: "threads",
+        query: { type: "main" },
+        get: (aui) => aui.threads().thread("main"),
+      }),
+    threadListItem:
+      scopes.threadListItem ??
+      Derived({
+        source: "threads",
+        query: { type: "main" },
+        get: (aui) => aui.threads().item("main"),
+      }),
+    composer:
+      scopes.composer ??
+      Derived({
+        source: "thread",
+        query: {},
+        get: (aui) => aui.threads().thread("main").composer(),
+      }),
+  };
+
+  if (!result.modelContext && parent.modelContext.source === null) {
+    result.modelContext = ModelContext();
+  }
+  if (!result.tools && parent.tools.source === null) {
+    result.tools = Tools({});
+  }
+  if (!result.dataRenderers && parent.dataRenderers.source === null) {
+    result.dataRenderers = DataRenderers();
+  }
+  if (!result.suggestions && parent.suggestions.source === null) {
+    result.suggestions = Suggestions();
+  }
+
+  return result;
 });

package/src/client/index.ts

@@ -1,6 +1,12 @@
-export { ModelContext as ModelContextClient } from "./ModelContextClient";
-export { Tools } from "./Tools";
-export { Suggestions, type SuggestionConfig } from "./Suggestions";
+// Re-export shared clients from core/react
+export { Tools, DataRenderers } from "@assistant-ui/core/react";
+
+// Re-export moved clients from core (matching previous public API)
+export { ModelContext as ModelContextClient } from "@assistant-ui/core/store";
+export { Suggestions, type SuggestionConfig } from "@assistant-ui/core/store";
+export { ChainOfThoughtClient } from "@assistant-ui/core/store";
+
+// Local clients (React-specific)
 export {
   ExternalThread,
   type ExternalThreadProps,
@@ -10,4 +16,3 @@ export {
   InMemoryThreadList,
   type InMemoryThreadListProps,
 } from "./InMemoryThreadList";
-export { ChainOfThoughtClient } from "./ChainOfThoughtClient";

package/src/context/providers/AttachmentByIndexProvider.tsx

@@ -1,36 +1,6 @@
 "use client";
 
-import { type FC, type PropsWithChildren } from "react";
-import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
-
-export const MessageAttachmentByIndexProvider: FC<
-  PropsWithChildren<{
-    index: number;
-  }>
-> = ({ index, children }) => {
-  const aui = useAui({
-    attachment: Derived({
-      source: "message",
-      query: { type: "index", index },
-      get: (aui) => aui.message().attachment({ index }),
-    }),
-  });
-
-  return <AuiProvider value={aui}>{children}</AuiProvider>;
-};
-
-export const ComposerAttachmentByIndexProvider: FC<
-  PropsWithChildren<{
-    index: number;
-  }>
-> = ({ index, children }) => {
-  const aui = useAui({
-    attachment: Derived({
-      source: "composer",
-      query: { type: "index", index },
-      get: (aui) => aui.composer().attachment({ index }),
-    }),
-  });
-
-  return <AuiProvider value={aui}>{children}</AuiProvider>;
-};
+export {
+  MessageAttachmentByIndexProvider,
+  ComposerAttachmentByIndexProvider,
+} from "@assistant-ui/core/react";

package/src/context/providers/ChainOfThoughtByIndicesProvider.tsx

@@ -1,36 +1,3 @@
 "use client";
 
-import { type FC, type PropsWithChildren } from "react";
-import { useAui, useAuiState, AuiProvider } from "@assistant-ui/store";
-import { ChainOfThoughtClient } from "../../client/ChainOfThoughtClient";
-import type { ChainOfThoughtPart } from "../../types/scopes/chainOfThought";
-
-export const ChainOfThoughtByIndicesProvider: FC<
-  PropsWithChildren<{
-    startIndex: number;
-    endIndex: number;
-  }>
-> = ({ startIndex, endIndex, children }) => {
-  const parts = useAuiState((s) => s.message.parts).slice(
-    startIndex,
-    endIndex + 1,
-  ) as ChainOfThoughtPart[];
-
-  const parentAui = useAui();
-
-  const aui = useAui({
-    chainOfThought: ChainOfThoughtClient({
-      parts,
-      getMessagePart: ({ index }) => {
-        if (index < 0 || index >= parts.length) {
-          throw new Error(
-            `ChainOfThought part index ${index} is out of bounds (0..${parts.length - 1})`,
-          );
-        }
-        return parentAui.message().part({ index: startIndex + index });
-      },
-    }),
-  });
-
-  return <AuiProvider value={aui}>{children}</AuiProvider>;
-};
+export { ChainOfThoughtByIndicesProvider } from "@assistant-ui/core/react";

package/src/context/providers/ChainOfThoughtPartByIndexProvider.tsx

@@ -1,20 +1,3 @@
 "use client";
 
-import { type FC, type PropsWithChildren } from "react";
-import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
-
-export const ChainOfThoughtPartByIndexProvider: FC<
-  PropsWithChildren<{
-    index: number;
-  }>
-> = ({ index, children }) => {
-  const aui = useAui({
-    part: Derived({
-      source: "chainOfThought",
-      query: { type: "index", index },
-      get: (aui) => aui.chainOfThought().part({ index }),
-    }),
-  });
-
-  return <AuiProvider value={aui}>{children}</AuiProvider>;
-};
+export { ChainOfThoughtPartByIndexProvider } from "@assistant-ui/core/react";

package/src/context/providers/MessageByIndexProvider.tsx

@@ -1,25 +1,3 @@
 "use client";
 
-import { type FC, type PropsWithChildren } from "react";
-import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
-
-export const MessageByIndexProvider: FC<
-  PropsWithChildren<{
-    index: number;
-  }>
-> = ({ index, children }) => {
-  const aui = useAui({
-    message: Derived({
-      source: "thread",
-      query: { type: "index", index },
-      get: (aui) => aui.thread().message({ index }),
-    }),
-    composer: Derived({
-      source: "message",
-      query: {},
-      get: (aui) => aui.thread().message({ index }).composer,
-    }),
-  });
-
-  return <AuiProvider value={aui}>{children}</AuiProvider>;
-};
+export { MessageByIndexProvider } from "@assistant-ui/core/react";

package/src/context/providers/MessageProvider.tsx

@@ -3,9 +3,9 @@
 import { type FC, type PropsWithChildren } from "react";
 import { useAui, AuiProvider } from "@assistant-ui/store";
 import {
-  ThreadMessageClientProps,
+  type ThreadMessageClientProps,
   ThreadMessageClient,
-} from "../../client/ThreadMessageClient";
+} from "@assistant-ui/core/store";
 
 export const MessageProvider: FC<
   PropsWithChildren<ThreadMessageClientProps>

package/src/context/providers/PartByIndexProvider.tsx

@@ -1,20 +1,3 @@
 "use client";
 
-import { type FC, type PropsWithChildren } from "react";
-import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
-
-export const PartByIndexProvider: FC<
-  PropsWithChildren<{
-    index: number;
-  }>
-> = ({ index, children }) => {
-  const aui = useAui({
-    part: Derived({
-      source: "message",
-      query: { type: "index", index },
-      get: (aui) => aui.message().part({ index }),
-    }),
-  });
-
-  return <AuiProvider value={aui}>{children}</AuiProvider>;
-};
+export { PartByIndexProvider } from "@assistant-ui/core/react";

package/src/context/providers/SuggestionByIndexProvider.tsx

@@ -1,23 +1,6 @@
 "use client";
 
-import { type FC, type PropsWithChildren } from "react";
-import { AuiProvider, Derived, useAui } from "@assistant-ui/store";
-
-export type SuggestionByIndexProviderProps = PropsWithChildren<{
-  index: number;
-}>;
-
-export const SuggestionByIndexProvider: FC<SuggestionByIndexProviderProps> = ({
-  index,
-  children,
-}) => {
-  const aui = useAui({
-    suggestion: Derived({
-      source: "suggestions",
-      query: { index },
-      get: (aui) => aui.suggestions().suggestion({ index }),
-    }),
-  });
-
-  return <AuiProvider value={aui}>{children}</AuiProvider>;
-};
+export {
+  SuggestionByIndexProvider,
+  type SuggestionByIndexProviderProps,
+} from "@assistant-ui/core/react";

package/src/context/providers/TextMessagePartProvider.tsx

@@ -1,51 +1,3 @@
 "use client";
 
-import { type FC, type PropsWithChildren } from "react";
-import { useAui, AuiProvider, type ClientOutput } from "@assistant-ui/store";
-import { PartState } from "../../types/scopes";
-import { resource, tapMemo } from "@assistant-ui/tap";
-
-const TextMessagePartClient = resource(
-  ({
-    text,
-    isRunning,
-  }: {
-    text: string;
-    isRunning: boolean;
-  }): ClientOutput<"part"> => {
-    const state = tapMemo<PartState>(
-      () => ({
-        type: "text",
-        text,
-        status: isRunning ? { type: "running" } : { type: "complete" },
-      }),
-      [text, isRunning],
-    );
-
-    return {
-      state,
-      methods: {
-        getState: () => state,
-        addToolResult: () => {
-          throw new Error("Not supported");
-        },
-        resumeToolCall: () => {
-          throw new Error("Not supported");
-        },
-      },
-    };
-  },
-);
-
-export const TextMessagePartProvider: FC<
-  PropsWithChildren<{
-    text: string;
-    isRunning?: boolean;
-  }>
-> = ({ text, isRunning = false, children }) => {
-  const aui = useAui({
-    part: TextMessagePartClient({ text, isRunning }),
-  });
-
-  return <AuiProvider value={aui}>{children}</AuiProvider>;
-};
+export { TextMessagePartProvider } from "@assistant-ui/core/react";

package/src/context/providers/ThreadListItemProvider.tsx

@@ -1,35 +1,6 @@
 "use client";
 
-import { type FC, type PropsWithChildren } from "react";
-import { useAui, AuiProvider, Derived } from "@assistant-ui/store";
-import type { ThreadListItemRuntime } from "../../legacy-runtime/runtime/ThreadListItemRuntime";
-import { ThreadListItemClient } from "../../legacy-runtime/client/ThreadListItemRuntimeClient";
-
-export const ThreadListItemByIndexProvider: FC<
-  PropsWithChildren<{
-    index: number;
-    archived: boolean;
-  }>
-> = ({ index, archived, children }) => {
-  const aui = useAui({
-    threadListItem: Derived({
-      source: "threads",
-      query: { type: "index", index, archived },
-      get: (aui) => aui.threads().item({ index, archived }),
-    }),
-  });
-
-  return <AuiProvider value={aui}>{children}</AuiProvider>;
-};
-
-export const ThreadListItemRuntimeProvider: FC<
-  PropsWithChildren<{
-    runtime: ThreadListItemRuntime;
-  }>
-> = ({ runtime, children }) => {
-  const aui = useAui({
-    threadListItem: ThreadListItemClient({ runtime }),
-  });
-
-  return <AuiProvider value={aui}>{children}</AuiProvider>;
-};
+export {
+  ThreadListItemByIndexProvider,
+  ThreadListItemRuntimeProvider,
+} from "@assistant-ui/core/react";

package/src/context/providers/index.ts

@@ -12,3 +12,4 @@ export {
 } from "./AttachmentByIndexProvider";
 export { TextMessagePartProvider } from "./TextMessagePartProvider";
 export { MessageProvider } from "./MessageProvider";
+export { ChainOfThoughtByIndicesProvider } from "./ChainOfThoughtByIndicesProvider";

package/src/context/react/utils/useRuntimeState.ts

@@ -1,5 +1,5 @@
+import type { Unsubscribe } from "@assistant-ui/core";
 import { useDebugValue, useSyncExternalStore } from "react";
-import { Unsubscribe } from "../../../types";
 import { ensureBinding } from "./ensureBinding";
 
 export type SubscribableRuntime<TState> = {

package/src/context/stores/{ThreadViewport.tsx → ThreadViewport.ts}

@@ -1,7 +1,7 @@
 "use client";
 
 import { create } from "zustand";
-import type { Unsubscribe } from "../../types/Unsubscribe";
+import type { Unsubscribe } from "@assistant-ui/core";
 
 export type SizeHandle = {
   /** Update the height */

package/src/devtools/DevToolsHooks.ts

@@ -1,5 +1,5 @@
+import type { Unsubscribe } from "@assistant-ui/core";
 import { AssistantClient } from "@assistant-ui/store";
-import { Unsubscribe } from "../types";
 
 export interface EventLog {
   time: Date;

package/src/hooks/useMessageQuote.ts

@@ -1,7 +1,7 @@
 "use client";
 
 import { useAuiState } from "@assistant-ui/store";
-import type { QuoteInfo } from "../types/QuoteTypes";
+import type { QuoteInfo } from "@assistant-ui/core";
 
 /**
  * Hook that returns the quote info for the current message, if any.

package/src/hooks/useMessageTiming.ts

@@ -0,0 +1,24 @@
+"use client";
+
+import { useAuiState } from "@assistant-ui/store";
+import type { MessageTiming } from "@assistant-ui/core";
+
+/**
+ * Hook that returns timing information for the current assistant message.
+ *
+ * Reads from `message.metadata.timing`.
+ *
+ * @example
+ * ```tsx
+ * function MessageStats() {
+ *   const timing = useMessageTiming();
+ *   if (!timing) return null;
+ *   return <span>{timing.tokensPerSecond?.toFixed(1)} tok/s</span>;
+ * }
+ * ```
+ */
+export const useMessageTiming = (): MessageTiming | undefined => {
+  return useAuiState((s) =>
+    s.message.role === "assistant" ? s.message.metadata?.timing : undefined,
+  );
+};

package/src/index.ts

@@ -1,4 +1,4 @@
-import "./types/store-augmentation";
+import "@assistant-ui/core/react"; // store-augmentation side-effect (tools, dataRenderers scopes)
 
 // Re-export from @assistant-ui/store
 export {

package/src/internal.ts

@@ -1,18 +1,27 @@
-export type { ThreadRuntimeCore } from "./legacy-runtime/runtime-cores/core/ThreadRuntimeCore";
-export type { ThreadListRuntimeCore } from "./legacy-runtime/runtime-cores/core/ThreadListRuntimeCore";
-export { DefaultThreadComposerRuntimeCore } from "./legacy-runtime/runtime-cores/composer/DefaultThreadComposerRuntimeCore";
-export { CompositeContextProvider } from "./utils/CompositeContextProvider";
-export { MessageRepository } from "./legacy-runtime/runtime-cores/utils/MessageRepository";
-export { BaseAssistantRuntimeCore } from "./legacy-runtime/runtime-cores/core/BaseAssistantRuntimeCore";
-export { generateId } from "./utils/idUtils";
-export { AssistantRuntimeImpl } from "./legacy-runtime/runtime/AssistantRuntime";
+// Re-export from @assistant-ui/core
+export type {
+  ThreadRuntimeCore,
+  ThreadListRuntimeCore,
+} from "@assistant-ui/core";
+
+// Re-export from @assistant-ui/core/internal
 export {
+  DefaultThreadComposerRuntimeCore,
+  CompositeContextProvider,
+  MessageRepository,
+  BaseAssistantRuntimeCore,
+  generateId,
+  AssistantRuntimeImpl,
   ThreadRuntimeImpl,
-  type ThreadRuntimeCoreBinding,
-  type ThreadListItemRuntimeBinding,
-} from "./legacy-runtime/runtime/ThreadRuntime";
-export { fromThreadMessageLike } from "./legacy-runtime/runtime-cores/external-store/ThreadMessageLike";
-export { getAutoStatus } from "./legacy-runtime/runtime-cores/external-store/auto-status";
+  fromThreadMessageLike,
+  getAutoStatus,
+} from "@assistant-ui/core/internal";
+export type {
+  ThreadRuntimeCoreBinding,
+  ThreadListItemRuntimeBinding,
+} from "@assistant-ui/core/internal";
+
+// React-specific (stay in react)
 export { splitLocalRuntimeOptions } from "./legacy-runtime/runtime-cores/local/LocalRuntimeOptions";
 export {
   useToolInvocations,

package/src/legacy-runtime/AssistantRuntimeProvider.tsx

@@ -1,10 +1,9 @@
 "use client";
 
 import { FC, memo, PropsWithChildren, useEffect } from "react";
-import { useAui, AuiProvider, AssistantClient } from "@assistant-ui/store";
+import { AssistantClient, useAui } from "@assistant-ui/store";
 import { AssistantRuntime } from "./runtime/AssistantRuntime";
-import { AssistantRuntimeCore } from "./runtime-cores/core/AssistantRuntimeCore";
-import { RuntimeAdapter } from "./RuntimeAdapter";
+import { AssistantProviderBase } from "@assistant-ui/core/react";
 import { ThreadPrimitiveViewportProvider } from "../context/providers/ThreadViewportProvider";
 import { DevToolsProviderApi } from "../devtools";
 
@@ -22,33 +21,28 @@ export namespace AssistantRuntimeProvider {
   }>;
 }
 
-const getRenderComponent = (runtime: AssistantRuntime) => {
-  return (runtime as { _core?: AssistantRuntimeCore })._core?.RenderComponent;
-};
-
-export const AssistantRuntimeProviderImpl: FC<
-  AssistantRuntimeProvider.Props
-> = ({ children, aui: parent = null, runtime }) => {
-  const aui = useAui({ threads: RuntimeAdapter(runtime) }, { parent: parent });
-
+const DevToolsRegistration: FC = () => {
+  const aui = useAui();
   useEffect(() => {
     if (typeof process === "undefined" || process.env.NODE_ENV === "production")
       return;
     return DevToolsProviderApi.register(aui);
   }, [aui]);
+  return null;
+};
 
-  const RenderComponent = getRenderComponent(runtime);
-
+export const AssistantRuntimeProviderImpl: FC<
+  AssistantRuntimeProvider.Props
+> = ({ children, aui, runtime }) => {
   return (
-    <AuiProvider value={aui}>
-      {RenderComponent && <RenderComponent />}
-
+    <AssistantProviderBase runtime={runtime} aui={aui ?? null}>
+      <DevToolsRegistration />
       {/* TODO temporarily allow accessing viewport state from outside the viewport */}
       {/* TODO figure out if this behavior should be deprecated, since it is quite hacky */}
       <ThreadPrimitiveViewportProvider>
         {children}
       </ThreadPrimitiveViewportProvider>
-    </AuiProvider>
+    </AssistantProviderBase>
   );
 };