@assistant-ui/react 0.12.14 → 0.12.16

package/src/legacy-runtime/runtime-cores/remote-thread-list/useRemoteThreadListRuntime.ts

@@ -1,82 +1,3 @@
 "use client";
 
-import { useState, useEffect, useMemo, useRef, useCallback } from "react";
-import {
-  BaseAssistantRuntimeCore,
-  AssistantRuntimeImpl,
-  type RemoteThreadListOptions,
-} from "@assistant-ui/core/internal";
-import type {
-  AssistantRuntimeCore,
-  AssistantRuntime,
-} from "@assistant-ui/core";
-import { RemoteThreadListThreadListRuntimeCore } from "./RemoteThreadListThreadListRuntimeCore";
-import { useAui } from "@assistant-ui/store";
-
-class RemoteThreadListRuntimeCore
-  extends BaseAssistantRuntimeCore
-  implements AssistantRuntimeCore
-{
-  public readonly threads;
-
-  constructor(options: RemoteThreadListOptions) {
-    super();
-    this.threads = new RemoteThreadListThreadListRuntimeCore(
-      options,
-      this._contextProvider,
-    );
-  }
-
-  public get RenderComponent() {
-    return this.threads.__internal_RenderComponent;
-  }
-}
-
-const useRemoteThreadListRuntimeImpl = (
-  options: RemoteThreadListOptions,
-): AssistantRuntime => {
-  const [runtime] = useState(() => new RemoteThreadListRuntimeCore(options));
-  useEffect(() => {
-    runtime.threads.__internal_setOptions(options);
-    runtime.threads.__internal_load();
-  }, [runtime, options]);
-  return useMemo(() => new AssistantRuntimeImpl(runtime), [runtime]);
-};
-
-export const useRemoteThreadListRuntime = (
-  options: RemoteThreadListOptions,
-): AssistantRuntime => {
-  const runtimeHookRef = useRef(options.runtimeHook);
-  runtimeHookRef.current = options.runtimeHook;
-
-  const stableRuntimeHook = useCallback(() => {
-    return runtimeHookRef.current();
-  }, []);
-
-  const stableOptions = useMemo<RemoteThreadListOptions>(
-    () => ({
-      adapter: options.adapter,
-      allowNesting: options.allowNesting,
-      runtimeHook: stableRuntimeHook,
-    }),
-    [options.adapter, options.allowNesting, stableRuntimeHook],
-  );
-
-  const aui = useAui();
-  const isNested = aui.threadListItem.source !== null;
-
-  if (isNested) {
-    if (!stableOptions.allowNesting) {
-      throw new Error(
-        "useRemoteThreadListRuntime cannot be nested inside another RemoteThreadListRuntime. " +
-          "Set allowNesting: true to allow nesting (the inner runtime will become a no-op).",
-      );
-    }
-
-    // If allowNesting is true and already inside a thread list context,
-    // just call the runtimeHook directly (no-op behavior)
-    return stableRuntimeHook();
-  }
-
-  return useRemoteThreadListRuntimeImpl(stableOptions);
-};
+export { useRemoteThreadListRuntime } from "@assistant-ui/core/react";

package/src/primitives/actionBar/ActionBarInteractionContext.ts

@@ -0,0 +1,13 @@
+"use client";
+
+import { createContext, useContext } from "react";
+
+export type ActionBarInteractionContextValue = {
+  acquireInteractionLock: () => () => void;
+};
+
+export const ActionBarInteractionContext =
+  createContext<ActionBarInteractionContextValue | null>(null);
+
+export const useActionBarInteractionContext = () =>
+  useContext(ActionBarInteractionContext);

package/src/primitives/actionBar/ActionBarRoot.tsx

@@ -1,11 +1,19 @@
 "use client";
 
 import { Primitive } from "@radix-ui/react-primitive";
-import { type ComponentRef, forwardRef, ComponentPropsWithoutRef } from "react";
+import {
+  type ComponentRef,
+  forwardRef,
+  ComponentPropsWithoutRef,
+  useCallback,
+  useMemo,
+  useState,
+} from "react";
 import {
   useActionBarFloatStatus,
   HideAndFloatStatus,
 } from "./useActionBarFloatStatus";
+import { ActionBarInteractionContext } from "./ActionBarInteractionContext";
 
 type PrimitiveDivProps = ComponentPropsWithoutRef<typeof Primitive.div>;
 
@@ -60,22 +68,44 @@ export const ActionBarPrimitiveRoot = forwardRef<
   ActionBarPrimitiveRoot.Element,
   ActionBarPrimitiveRoot.Props
 >(({ hideWhenRunning, autohide, autohideFloat, ...rest }, ref) => {
+  const [interactionCount, setInteractionCount] = useState(0);
+
+  const acquireInteractionLock = useCallback(() => {
+    let released = false;
+
+    setInteractionCount((count) => count + 1);
+
+    return () => {
+      if (released) return;
+      released = true;
+      setInteractionCount((count) => Math.max(0, count - 1));
+    };
+  }, []);
+
+  const interactionContext = useMemo(
+    () => ({ acquireInteractionLock }),
+    [acquireInteractionLock],
+  );
+
   const hideAndfloatStatus = useActionBarFloatStatus({
     hideWhenRunning,
     autohide,
     autohideFloat,
+    forceVisible: interactionCount > 0,
   });
 
   if (hideAndfloatStatus === HideAndFloatStatus.Hidden) return null;
 
   return (
-    <Primitive.div
-      {...(hideAndfloatStatus === HideAndFloatStatus.Floating
-        ? { "data-floating": "true" }
-        : null)}
-      {...rest}
-      ref={ref}
-    />
+    <ActionBarInteractionContext.Provider value={interactionContext}>
+      <Primitive.div
+        {...(hideAndfloatStatus === HideAndFloatStatus.Floating
+          ? { "data-floating": "true" }
+          : null)}
+        {...rest}
+        ref={ref}
+      />
+    </ActionBarInteractionContext.Provider>
   );
 });
 

package/src/primitives/actionBar/useActionBarFloatStatus.ts

@@ -12,24 +12,27 @@ export type UseActionBarFloatStatusProps = {
   hideWhenRunning?: boolean | undefined;
   autohide?: "always" | "not-last" | "never" | undefined;
   autohideFloat?: "always" | "single-branch" | "never" | undefined;
+  forceVisible?: boolean | undefined;
 };
 
 export const useActionBarFloatStatus = ({
   hideWhenRunning,
   autohide,
   autohideFloat,
+  forceVisible,
 }: UseActionBarFloatStatusProps) => {
   return useAuiState((s) => {
     if (hideWhenRunning && s.thread.isRunning) return HideAndFloatStatus.Hidden;
 
     const autohideEnabled =
       autohide === "always" || (autohide === "not-last" && !s.message.isLast);
+    const isVisibleByInteraction = forceVisible || s.message.isHovering;
 
     // normal status
     if (!autohideEnabled) return HideAndFloatStatus.Normal;
 
     // hidden status
-    if (!s.message.isHovering) return HideAndFloatStatus.Hidden;
+    if (!isVisibleByInteraction) return HideAndFloatStatus.Hidden;
 
     // floating status
     if (

package/src/primitives/actionBarMore/ActionBarMoreRoot.tsx

@@ -1,8 +1,9 @@
 "use client";
 
-import { FC } from "react";
+import { FC, useCallback, useEffect, useRef } from "react";
 import { DropdownMenu as DropdownMenuPrimitive } from "radix-ui";
 import { ScopedProps, useDropdownMenuScope } from "./scope";
+import { useActionBarInteractionContext } from "../actionBar/ActionBarInteractionContext";
 
 export namespace ActionBarMorePrimitiveRoot {
   export type Props = DropdownMenuPrimitive.DropdownMenuProps;
@@ -12,11 +13,60 @@ export const ActionBarMorePrimitiveRoot: FC<
   ActionBarMorePrimitiveRoot.Props
 > = ({
   __scopeActionBarMore,
+  open,
+  onOpenChange,
   ...rest
 }: ScopedProps<ActionBarMorePrimitiveRoot.Props>) => {
   const scope = useDropdownMenuScope(__scopeActionBarMore);
+  const actionBarInteraction = useActionBarInteractionContext();
+  const releaseInteractionLockRef = useRef<(() => void) | null>(null);
+  const isControlled = open !== undefined;
 
-  return <DropdownMenuPrimitive.Root {...scope} {...rest} />;
+  const setInteractionOpen = useCallback(
+    (nextOpen: boolean) => {
+      if (nextOpen) {
+        if (releaseInteractionLockRef.current) return;
+        releaseInteractionLockRef.current =
+          actionBarInteraction?.acquireInteractionLock() ?? null;
+        return;
+      }
+
+      releaseInteractionLockRef.current?.();
+      releaseInteractionLockRef.current = null;
+    },
+    [actionBarInteraction],
+  );
+
+  const handleOpenChange = useCallback(
+    (nextOpen: boolean) => {
+      if (!isControlled) {
+        setInteractionOpen(nextOpen);
+      }
+      onOpenChange?.(nextOpen);
+    },
+    [isControlled, setInteractionOpen, onOpenChange],
+  );
+
+  useEffect(() => {
+    if (!isControlled) return;
+    setInteractionOpen(Boolean(open));
+  }, [isControlled, open, setInteractionOpen]);
+
+  useEffect(() => {
+    return () => {
+      releaseInteractionLockRef.current?.();
+      releaseInteractionLockRef.current = null;
+    };
+  }, []);
+
+  return (
+    <DropdownMenuPrimitive.Root
+      {...scope}
+      {...rest}
+      {...(open !== undefined ? { open } : null)}
+      onOpenChange={handleOpenChange}
+    />
+  );
 };
 
 ActionBarMorePrimitiveRoot.displayName = "ActionBarMorePrimitive.Root";

package/src/tests/BaseComposerRuntimeCore.test.ts

@@ -181,11 +181,10 @@ describe("BaseComposerRuntimeCore", () => {
     expect(composer.quote).toBeUndefined();
   });
 
-  it("send with empty text produces empty content array", async () => {
+  it("send with empty text is a no-op", async () => {
     await composer.send();
 
-    expect(composer.sentMessages).toHaveLength(1);
-    expect(composer.sentMessages[0]!.content).toEqual([]);
+    expect(composer.sentMessages).toHaveLength(0);
   });
 
   it("addAttachment throws when no adapter", async () => {

package/src/tests/external-message-converter.test.ts

@@ -158,6 +158,86 @@ describe("convertExternalMessages", () => {
       expect(toolCallParts).toHaveLength(1);
       expect((toolCallParts[0] as any).result).toEqual({ data: "result" });
     });
+
+    it("should merge duplicate tool calls by toolCallId across assistant messages", () => {
+      const messages = [
+        {
+          id: "msg1",
+          role: "assistant" as const,
+          content: [
+            {
+              type: "tool-call" as const,
+              toolCallId: "tc1",
+              toolName: "search",
+              args: { query: "old" },
+              argsText: '{"query":"old"',
+            },
+          ],
+        },
+        {
+          id: "msg2",
+          role: "assistant" as const,
+          content: [
+            {
+              type: "tool-call" as const,
+              toolCallId: "tc1",
+              toolName: "search",
+              args: { query: "new" },
+              argsText: '{"query":"new"}',
+            },
+          ],
+        },
+      ];
+
+      const callback: useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      > = (msg) => msg;
+
+      const result = convertExternalMessages(messages, callback, false, {});
+
+      expect(result).toHaveLength(1);
+      expect(result[0]!.role).toBe("assistant");
+      const toolCallParts = result[0]!.content.filter(
+        (p) => p.type === "tool-call",
+      );
+      expect(toolCallParts).toHaveLength(1);
+      expect((toolCallParts[0] as any).args).toEqual({ query: "new" });
+      expect((toolCallParts[0] as any).argsText).toBe('{"query":"new"}');
+    });
+
+    it("should ignore orphaned tool results without throwing", () => {
+      const messages = [
+        {
+          id: "msg1",
+          role: "assistant" as const,
+          content: "First response",
+        },
+        {
+          role: "tool" as const,
+          toolCallId: "missing-tool-call",
+          toolName: "search",
+          result: { data: "orphan result" },
+        },
+        {
+          id: "msg2",
+          role: "assistant" as const,
+          content: "Second response",
+        },
+      ];
+
+      const callback: useExternalMessageConverter.Callback<
+        (typeof messages)[number]
+      > = (msg) => msg;
+
+      const result = convertExternalMessages(messages, callback, false, {});
+      expect(result).toHaveLength(1);
+      expect(result[0]!.role).toBe("assistant");
+
+      const textParts = result[0]!.content.filter((p) => p.type === "text");
+      expect(textParts).toHaveLength(2);
+      expect((textParts[0] as any).text).toBe("First response");
+      expect((textParts[1] as any).text).toBe("Second response");
+    });
   });
 
   describe("synthetic error message", () => {

package/src/utils/createActionButton.tsx

@@ -41,8 +41,8 @@ export const createActionButton = <TProps,>(
     const callback = useActionButton(forwardedProps as TProps) ?? undefined;
     return (
       <Primitive.button
-        type="button"
         {...primitiveProps}
+        type="button"
         ref={forwardedRef}
         disabled={primitiveProps.disabled || !callback}
         onClick={composeEventHandlers(primitiveProps.onClick, callback)}

package/src/utils/json/is-json-equal.ts

@@ -0,0 +1,48 @@
+import type { ReadonlyJSONValue } from "assistant-stream/utils";
+import { isJSONValue, isRecord } from "./is-json";
+
+const MAX_JSON_DEPTH = 100;
+
+const isJSONValueEqualAtDepth = (
+  a: ReadonlyJSONValue,
+  b: ReadonlyJSONValue,
+  currentDepth: number,
+): boolean => {
+  if (a === b) return true;
+  if (currentDepth > MAX_JSON_DEPTH) return false;
+
+  if (a == null || b == null) return false;
+
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((item, index) =>
+      isJSONValueEqualAtDepth(
+        item,
+        b[index] as ReadonlyJSONValue,
+        currentDepth + 1,
+      ),
+    );
+  }
+
+  if (Array.isArray(b)) return false;
+  if (!isRecord(a) || !isRecord(b)) return false;
+
+  const aKeys = Object.keys(a);
+  const bKeys = Object.keys(b);
+  if (aKeys.length !== bKeys.length) return false;
+
+  return aKeys.every(
+    (key) =>
+      Object.hasOwn(b, key) &&
+      isJSONValueEqualAtDepth(
+        a[key] as ReadonlyJSONValue,
+        b[key] as ReadonlyJSONValue,
+        currentDepth + 1,
+      ),
+  );
+};
+
+export const isJSONValueEqual = (a: unknown, b: unknown): boolean => {
+  if (!isJSONValue(a) || !isJSONValue(b)) return false;
+  return isJSONValueEqualAtDepth(a, b, 0);
+};

package/src/utils/json/is-json.ts

@@ -4,6 +4,10 @@ import {
   ReadonlyJSONValue,
 } from "assistant-stream/utils";
 
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return value != null && typeof value === "object" && !Array.isArray(value);
+}
+
 export function isJSONValue(
   value: unknown,
   currentDepth: number = 0,
@@ -30,7 +34,7 @@ export function isJSONValue(
     return value.every((item) => isJSONValue(item, currentDepth + 1));
   }
 
-  if (typeof value === "object") {
+  if (isRecord(value)) {
     return Object.entries(value).every(
       ([key, val]) =>
         typeof key === "string" && isJSONValue(val, currentDepth + 1),
@@ -46,8 +50,7 @@ export function isJSONArray(value: unknown): value is ReadonlyJSONArray {
 
 export function isJSONObject(value: unknown): value is ReadonlyJSONObject {
   return (
-    value != null &&
-    typeof value === "object" &&
+    isRecord(value) &&
     Object.entries(value).every(
       ([key, val]) => typeof key === "string" && isJSONValue(val),
     )