@assistant-ui/react 0.12.24 → 0.12.26

package/src/unstable/useMentionAdapter.ts

@@ -0,0 +1,220 @@
+"use client";
+
+import { useMemo, type FC } from "react";
+import { useAui } from "@assistant-ui/store";
+import type {
+  Unstable_DirectiveFormatter,
+  Unstable_TriggerAdapter,
+  Unstable_TriggerCategory,
+  Unstable_TriggerItem,
+} from "@assistant-ui/core";
+import { unstable_defaultDirectiveFormatter } from "@assistant-ui/core";
+import type { ReadonlyJSONObject } from "assistant-stream/utils";
+
+/** Icon component shape consumed by `ComposerTriggerPopover`'s `iconMap`. */
+export type Unstable_IconComponent = FC<{ className?: string }>;
+
+export type Unstable_Mention = {
+  readonly id: string;
+  readonly type: string;
+  readonly label: string;
+  readonly description?: string | undefined;
+  /** Shortcut for `metadata.icon`; merged with `metadata` if both are given. */
+  readonly icon?: string | undefined;
+  readonly metadata?: ReadonlyJSONObject | undefined;
+};
+
+export type Unstable_MentionCategory = {
+  readonly id: string;
+  readonly label: string;
+  readonly items: readonly Unstable_Mention[];
+};
+
+export type Unstable_ModelContextToolsOptions = {
+  /** Wrap tools in a dedicated category (drill-down mode). */
+  readonly category?: { readonly id: string; readonly label: string };
+  /** Format tool name for display. */
+  readonly formatLabel?: (toolName: string) => string;
+  /** Default icon key for each tool. */
+  readonly icon?: string;
+};
+
+export type Unstable_UseMentionAdapterOptions = {
+  /** Flat mention list. Ignored when `categories` is set. */
+  readonly items?: readonly Unstable_Mention[];
+  /** Categorized mentions for drill-down navigation. */
+  readonly categories?: readonly Unstable_MentionCategory[];
+  /**
+   * How tools registered via `useAssistantTool` integrate.
+   * - `false`: exclude.
+   * - `true`: include (default when no `items`/`categories`; as a category
+   *   if `categories` is set, flat otherwise).
+   * - object: explicit config.
+   *
+   * Omitted → defaults to `true` iff neither `items` nor `categories`.
+   */
+  readonly includeModelContextTools?:
+    | boolean
+    | Unstable_ModelContextToolsOptions;
+  /** Directive formatter. @default unstable_defaultDirectiveFormatter */
+  readonly formatter?: Unstable_DirectiveFormatter;
+  /** Fires after an item is inserted into the composer. */
+  readonly onInserted?: (item: Unstable_TriggerItem) => void;
+  /** Maps `metadata.icon` / `category.id` string keys to React components. */
+  readonly iconMap?: Record<string, Unstable_IconComponent>;
+  /** Fallback icon when no entry in `iconMap` matches. */
+  readonly fallbackIcon?: Unstable_IconComponent;
+};
+
+export type Unstable_MentionDirective = {
+  readonly formatter: Unstable_DirectiveFormatter;
+  readonly onInserted?: ((item: Unstable_TriggerItem) => void) | undefined;
+};
+
+/**
+ * @deprecated Under active development and might change without notice.
+ *
+ * Creates a spreadable `{ adapter, directive }` bundle for `@` mentions.
+ * Supports tools registered via `useAssistantTool`, explicit items, or both —
+ * flat or categorized.
+ *
+ * @example
+ * ```tsx
+ * const mention = unstable_useMentionAdapter();
+ * <ComposerTriggerPopover char="@" {...mention} />
+ * ```
+ */
+export function unstable_useMentionAdapter(
+  options?: Unstable_UseMentionAdapterOptions,
+): {
+  adapter: Unstable_TriggerAdapter;
+  directive: Unstable_MentionDirective;
+  iconMap?: Record<string, Unstable_IconComponent>;
+  fallbackIcon?: Unstable_IconComponent;
+} {
+  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
+  const aui = useAui();
+
+  const items = options?.items;
+  const categories = options?.categories;
+  const includeTools =
+    options?.includeModelContextTools ?? (!items && !categories);
+  const toolsConfig =
+    typeof includeTools === "object" ? includeTools : undefined;
+  const wantsTools = includeTools !== false;
+  const formatter = options?.formatter;
+  const onInserted = options?.onInserted;
+
+  // biome-ignore lint/correctness/useHookAtTopLevel: intentional conditional/nested hook usage
+  const adapter = useMemo<Unstable_TriggerAdapter>(() => {
+    const getModelContextTools = (): Unstable_TriggerItem[] => {
+      if (!wantsTools) return [];
+      const ctx = aui.thread().getModelContext();
+      const tools = ctx.tools;
+      if (!tools) return [];
+      const formatLabel = toolsConfig?.formatLabel;
+      const defaultIcon = toolsConfig?.icon;
+      return Object.entries(tools).map(([name, tool]) =>
+        toTriggerItem({
+          id: name,
+          type: "tool",
+          label: formatLabel ? formatLabel(name) : name,
+          description: tool.description ?? undefined,
+          icon: defaultIcon,
+        }),
+      );
+    };
+
+    // Categorized: drill-down mode
+    if (categories && categories.length > 0) {
+      const groups = categories.map((cat) => ({
+        id: cat.id,
+        label: cat.label,
+        items: cat.items.map(toTriggerItem),
+      }));
+
+      let toolCategory: {
+        id: string;
+        label: string;
+        items: Unstable_TriggerItem[];
+      } | null = null;
+      if (wantsTools) {
+        const toolItems = getModelContextTools();
+        if (toolItems.length > 0) {
+          toolCategory = {
+            id: toolsConfig?.category?.id ?? "tools",
+            label: toolsConfig?.category?.label ?? "Tools",
+            items: toolItems,
+          };
+        }
+      }
+      const allGroups = toolCategory ? [...groups, toolCategory] : groups;
+
+      return {
+        categories: () => allGroups.map(({ id, label }) => ({ id, label })),
+        categoryItems: (id) => allGroups.find((g) => g.id === id)?.items ?? [],
+        search: (query) => {
+          const lower = query.toLowerCase();
+          return allGroups
+            .flatMap((g) => g.items)
+            .filter((item) => matchesQuery(item, lower));
+        },
+      };
+    }
+
+    // Flat: items + (optionally) tools, all in one search pool
+    const flatItems = (items ?? []).map(toTriggerItem);
+    const getFlatPool = (): Unstable_TriggerItem[] => {
+      if (!wantsTools) return flatItems;
+      const toolItems = getModelContextTools();
+      // Dedupe by id — explicit items win.
+      const seen = new Set(flatItems.map((i) => i.id));
+      return [...flatItems, ...toolItems.filter((t) => !seen.has(t.id))];
+    };
+
+    return {
+      categories: (): readonly Unstable_TriggerCategory[] => [],
+      categoryItems: () => [],
+      search: (query) => {
+        const lower = query.toLowerCase();
+        return getFlatPool().filter((item) => matchesQuery(item, lower));
+      },
+    };
+  }, [aui, items, categories, wantsTools, toolsConfig]);
+
+  // biome-ignore lint/correctness/useHookAtTopLevel: `unstable_` prefix not recognized as hook
+  const directive = useMemo<Unstable_MentionDirective>(
+    () => ({
+      formatter: formatter ?? unstable_defaultDirectiveFormatter,
+      ...(onInserted ? { onInserted } : {}),
+    }),
+    [formatter, onInserted],
+  );
+
+  return {
+    adapter,
+    directive,
+    ...(options?.iconMap ? { iconMap: options.iconMap } : {}),
+    ...(options?.fallbackIcon ? { fallbackIcon: options.fallbackIcon } : {}),
+  };
+}
+
+function toTriggerItem(m: Unstable_Mention): Unstable_TriggerItem {
+  const metadata =
+    m.icon !== undefined ? { ...(m.metadata ?? {}), icon: m.icon } : m.metadata;
+  return {
+    id: m.id,
+    type: m.type,
+    label: m.label,
+    ...(m.description !== undefined ? { description: m.description } : {}),
+    ...(metadata !== undefined ? { metadata } : {}),
+  };
+}
+
+function matchesQuery(item: Unstable_TriggerItem, lower: string): boolean {
+  if (!lower) return true;
+  if (item.id.toLowerCase().includes(lower)) return true;
+  if (item.label.toLowerCase().includes(lower)) return true;
+  if (item.description?.toLowerCase().includes(lower)) return true;
+  return false;
+}

package/src/unstable/useSlashCommandAdapter.ts

@@ -1,83 +1,112 @@
 "use client";
 
-import { useMemo } from "react";
+import { useMemo, useRef } from "react";
 import type {
-  Unstable_SlashCommandAdapter,
-  Unstable_SlashCommandItem,
-  Unstable_TriggerCategory,
+  Unstable_TriggerAdapter,
+  Unstable_TriggerItem,
 } from "@assistant-ui/core";
+import type { Unstable_IconComponent } from "./useMentionAdapter";
 
-export type Unstable_SlashCommandDefinition = {
-  /** Unique command name (e.g. "summarize"). */
-  readonly name: string;
-  /** Display label (e.g. "/summarize"). */
+export type Unstable_SlashCommand = {
+  readonly id: string;
   readonly label?: string | undefined;
-  /** Short description shown in the popover. */
   readonly description?: string | undefined;
-  /** Icon identifier. */
   readonly icon?: string | undefined;
-  /** Action to execute when the command is selected. */
-  readonly execute?: (() => void) | undefined;
+  readonly execute: () => void;
 };
 
 export type Unstable_UseSlashCommandAdapterOptions = {
-  /** List of available slash commands. */
-  commands: readonly Unstable_SlashCommandDefinition[];
+  readonly commands: readonly Unstable_SlashCommand[];
+  /** Strip the trigger text from the composer after executing. @default false */
+  readonly removeOnExecute?: boolean | undefined;
+  /** Maps `metadata.icon` / `category.id` string keys to React components. */
+  readonly iconMap?: Record<string, Unstable_IconComponent>;
+  /** Fallback icon when no entry in `iconMap` matches. */
+  readonly fallbackIcon?: Unstable_IconComponent;
+};
+
+export type Unstable_SlashCommandAction = {
+  readonly onExecute: (item: Unstable_TriggerItem) => void;
+  readonly removeOnExecute?: boolean | undefined;
 };
 
 /**
- * @deprecated This API is still under active development and might change without notice.
+ * @deprecated Under active development and may change without notice.
  *
- * Creates a SlashCommandAdapter from a list of command definitions.
+ * Bundles slash command definitions (with inline `execute` callbacks) into
+ * `{adapter, action}` that plug directly into `ComposerTriggerPopover`.
+ * `execute` stays in the hook closure and is never attached to the returned
+ * `TriggerItem`, keeping items serializable.
  *
  * @example
  * ```tsx
- * const slashAdapter = unstable_useSlashCommandAdapter({
+ * const slash = unstable_useSlashCommandAdapter({
  *   commands: [
- *     { name: "summarize", description: "Summarize the conversation", execute: () => {} },
- *     { name: "translate", description: "Translate text", execute: () => {} },
+ *     { id: "summarize", execute: () => runSummarize(), icon: "FileText" },
+ *     { id: "translate", execute: () => runTranslate(), icon: "Languages" },
  *   ],
  * });
+ *
+ * <ComposerTriggerPopover char="/" {...slash} />
  * ```
  */
 export function unstable_useSlashCommandAdapter(
   options: Unstable_UseSlashCommandAdapterOptions,
-): Unstable_SlashCommandAdapter {
-  const { commands } = options;
+): {
+  adapter: Unstable_TriggerAdapter;
+  action: Unstable_SlashCommandAction;
+  iconMap?: Record<string, Unstable_IconComponent>;
+  fallbackIcon?: Unstable_IconComponent;
+} {
+  const { commands, removeOnExecute } = options;
 
-  return useMemo<Unstable_SlashCommandAdapter>(() => {
-    // Build items lazily at call time so execute callbacks are always fresh
-    const getItems = (): Unstable_SlashCommandItem[] =>
-      commands.map((cmd) => ({
-        id: cmd.name,
-        type: "command",
-        label: cmd.label ?? `/${cmd.name}`,
-        description: cmd.description,
-        icon: cmd.icon,
-        execute: cmd.execute,
-      }));
+  // biome-ignore lint/correctness/useHookAtTopLevel: `unstable_` prefix not recognized as hook
+  const commandsRef = useRef(commands);
+  commandsRef.current = commands;
 
-    return {
-      // No categories — slash commands show items directly via search mode
-      categories(): Unstable_TriggerCategory[] {
-        return [];
+  // biome-ignore lint/correctness/useHookAtTopLevel: `unstable_` prefix not recognized as hook
+  return useMemo(() => {
+    const adapter: Unstable_TriggerAdapter = {
+      categories: () => [],
+      categoryItems: () => [],
+      search: (query: string) => {
+        const lower = query.toLowerCase();
+        return commandsRef.current
+          .filter((c) => matchesQuery(c, lower))
+          .map(toItem);
       },
+    };
 
-      categoryItems(): Unstable_SlashCommandItem[] {
-        return [];
+    const action: Unstable_SlashCommandAction = {
+      onExecute: (item) => {
+        commandsRef.current.find((c) => c.id === item.id)?.execute();
       },
+      ...(removeOnExecute !== undefined ? { removeOnExecute } : {}),
+    };
 
-      search(query: string): Unstable_SlashCommandItem[] {
-        const items = getItems();
-        if (!query) return items;
-        const lower = query.toLowerCase();
-        return items.filter(
-          (item) =>
-            item.id.toLowerCase().includes(lower) ||
-            item.label.toLowerCase().includes(lower) ||
-            item.description?.toLowerCase().includes(lower),
-        );
-      },
+    return {
+      adapter,
+      action,
+      ...(options.iconMap ? { iconMap: options.iconMap } : {}),
+      ...(options.fallbackIcon ? { fallbackIcon: options.fallbackIcon } : {}),
     };
-  }, [commands]);
+  }, [removeOnExecute, options.iconMap, options.fallbackIcon]);
+}
+
+function toItem(cmd: Unstable_SlashCommand): Unstable_TriggerItem {
+  return {
+    id: cmd.id,
+    type: "command",
+    label: cmd.label ?? `/${cmd.id}`,
+    ...(cmd.description !== undefined ? { description: cmd.description } : {}),
+    ...(cmd.icon !== undefined ? { metadata: { icon: cmd.icon } } : {}),
+  };
+}
+
+function matchesQuery(cmd: Unstable_SlashCommand, lower: string): boolean {
+  if (!lower) return true;
+  if (cmd.id.toLowerCase().includes(lower)) return true;
+  if (cmd.label?.toLowerCase().includes(lower)) return true;
+  if (cmd.description?.toLowerCase().includes(lower)) return true;
+  return false;
 }

package/src/utils/Primitive.test.tsx

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { renderToStaticMarkup } from "react-dom/server";
-import { Primitive } from "./Primitive";
+import { Primitive, withRenderProp } from "./Primitive";
 
 const ALL_NODES = [
   "a",
@@ -70,6 +70,12 @@ describe("Primitive", () => {
   });
 
   describe("render prop edge cases", () => {
+    it("preserves a useful displayName on wrapped components", () => {
+      const Wrapped = withRenderProp(Primitive.div);
+
+      expect(Wrapped.displayName).toBe("Primitive.div");
+    });
+
     it("uses render element's own children as fallback", () => {
       const html = renderToStaticMarkup(
         <Primitive.span render={<em>Fallback</em>} />,

package/src/utils/Primitive.tsx

@@ -1,7 +1,9 @@
 import {
   type ComponentPropsWithoutRef,
   type ComponentRef,
+  type ElementType,
   type ForwardRefExoticComponent,
+  type PropsWithoutRef,
   type ReactElement,
   type ReactNode,
   type RefAttributes,
@@ -43,43 +45,74 @@ const NODES = [
 ] as const;
 type PrimitiveNode = (typeof NODES)[number];
 
-type PrimitiveProps<E extends PrimitiveNode> = ComponentPropsWithoutRef<
+type WithRenderPropProps<T extends ElementType> =
+  ComponentPropsWithoutRef<T> & {
+    render?: ReactElement | undefined;
+  };
+
+type PrimitiveProps<E extends PrimitiveNode> = WithRenderPropProps<
   (typeof RadixPrimitive)[E]
-> & {
-  render?: ReactElement | undefined;
-};
+>;
+
+type WithRenderPropRuntimeProps<T extends ElementType> =
+  WithRenderPropProps<T> & {
+    asChild?: boolean | undefined;
+    children?: ReactNode | undefined;
+  };
 
 type PrimitiveRef<E extends PrimitiveNode> = ComponentRef<
   (typeof RadixPrimitive)[E]
 >;
 
-function createPrimitive<E extends PrimitiveNode>(node: E) {
-  const RadixComp = RadixPrimitive[node];
+function withRenderProp<T extends ElementType>(Component: T) {
+  const Wrapped = forwardRef<ComponentRef<T>, WithRenderPropRuntimeProps<T>>(
+    (
+      {
+        render,
+        asChild,
+        children,
+        ...rest
+      }: PropsWithoutRef<WithRenderPropRuntimeProps<T>>,
+      ref,
+    ) => {
+      const Comp = Component as any;
 
-  const Component = forwardRef<PrimitiveRef<E>, PrimitiveProps<E>>(
-    ({ render, asChild, children, ...props }, ref) => {
       if (render && isValidElement(render)) {
-        // render={<Comp p />} + children
-        //   → asChild + <Comp p>{children}</Comp>
         const renderChildren =
           children !== undefined
             ? children
             : ((render.props as Record<string, unknown>).children as ReactNode);
+
         return (
-          <RadixComp asChild {...(props as any)} ref={ref}>
+          <Comp {...(rest as any)} asChild ref={ref}>
             {cloneElement(render, undefined, renderChildren)}
-          </RadixComp>
+          </Comp>
         );
       }
 
       return (
-        <RadixComp asChild={asChild} {...(props as any)} ref={ref}>
+        <Comp {...(rest as any)} asChild={asChild} ref={ref}>
           {children}
-        </RadixComp>
+        </Comp>
       );
     },
   );
 
+  const componentName =
+    typeof Component === "string"
+      ? Component
+      : (Component.displayName ?? Component.name ?? "Component");
+  Wrapped.displayName = componentName;
+
+  return Wrapped as ForwardRefExoticComponent<
+    WithRenderPropProps<T> & RefAttributes<ComponentRef<T>>
+  >;
+}
+
+function createPrimitive<E extends PrimitiveNode>(node: E) {
+  const RadixComp = RadixPrimitive[node];
+  const Component = withRenderProp(RadixComp);
+
   Component.displayName = `Primitive.${node}`;
   return Component as ForwardRefExoticComponent<
     PrimitiveProps<E> & RefAttributes<PrimitiveRef<E>>
@@ -96,5 +129,5 @@ const Primitive = NODES.reduce(
   },
 );
 
-export { Primitive };
-export type { PrimitiveProps };
+export { Primitive, withRenderProp };
+export type { PrimitiveProps, WithRenderPropProps };

package/src/utils/createActionButton.tsx

@@ -1,8 +1,8 @@
 import {
-  ComponentRef,
+  type ComponentRef,
   forwardRef,
-  ComponentPropsWithoutRef,
-  MouseEventHandler,
+  type ComponentPropsWithoutRef,
+  type MouseEventHandler,
 } from "react";
 import { Primitive } from "./Primitive";
 import { composeEventHandlers } from "@radix-ui/primitive";

package/src/utils/hooks/useManagedRef.ts

@@ -1,9 +1,9 @@
 import { useCallback, useRef } from "react";
 
 export const useManagedRef = <TNode>(
-  callback: (node: TNode) => (() => void) | void,
+  callback: (node: TNode) => (() => void) | undefined,
 ) => {
-  const cleanupRef = useRef<(() => void) | void>(undefined);
+  const cleanupRef = useRef<(() => void) | undefined>(undefined);
 
   const ref = useCallback(
     (el: TNode | null) => {

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

@@ -1,4 +1,4 @@
-import {
+import type {
   ReadonlyJSONArray,
   ReadonlyJSONObject,
   ReadonlyJSONValue,

package/src/utils/smooth/SmoothContext.tsx

@@ -1,16 +1,16 @@
 "use client";
 
 import {
-  ComponentType,
+  type ComponentType,
   createContext,
-  FC,
+  type FC,
   forwardRef,
-  PropsWithChildren,
+  type PropsWithChildren,
   useContext,
   useState,
 } from "react";
-import { ReadonlyStore } from "../../context/ReadonlyStore";
-import { create, UseBoundStore } from "zustand";
+import type { ReadonlyStore } from "../../context/ReadonlyStore";
+import { create, type UseBoundStore } from "zustand";
 import type {
   MessagePartStatus,
   ToolCallMessagePartStatus,

package/dist/primitives/composer/mention/ComposerMentionContext.d.ts

@@ -1,25 +0,0 @@
-import { type ReactNode, type FC } from "react";
-import type { Unstable_MentionAdapter, Unstable_DirectiveFormatter } from "@assistant-ui/core";
-import type { TriggerPopoverResourceOutput, SelectItemOverride } from "../trigger/TriggerPopoverResource.js";
-type MentionResourceOutput = TriggerPopoverResourceOutput & {
-    readonly formatter: Unstable_DirectiveFormatter;
-};
-export declare const useMentionContext: () => MentionResourceOutput;
-export declare const useMentionContextOptional: () => MentionResourceOutput | null;
-type MentionInternalContextValue = {
-    registerSelectItemOverride(fn: SelectItemOverride): () => void;
-};
-export declare const useMentionInternalContext: () => MentionInternalContextValue | null;
-export declare namespace ComposerPrimitiveMentionRoot {
-    type Props = {
-        children: ReactNode;
-        adapter?: Unstable_MentionAdapter | undefined;
-        /** Character(s) that trigger the mention popover. @default "@" */
-        trigger?: string | undefined;
-        /** Custom formatter for serializing/parsing mention directives. */
-        formatter?: Unstable_DirectiveFormatter | undefined;
-    };
-}
-export declare const ComposerPrimitiveMentionRoot: FC<ComposerPrimitiveMentionRoot.Props>;
-export {};
-//# sourceMappingURL=ComposerMentionContext.d.ts.map

package/dist/primitives/composer/mention/ComposerMentionContext.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ComposerMentionContext.d.ts","sourceRoot":"","sources":["../../../../src/primitives/composer/mention/ComposerMentionContext.tsx"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,SAAS,EACd,KAAK,EAAE,EACR,MAAM,OAAO,CAAC;AAEf,OAAO,KAAK,EACV,uBAAuB,EACvB,2BAA2B,EAC5B,MAAM,oBAAoB,CAAC;AAG5B,OAAO,KAAK,EACV,4BAA4B,EAC5B,kBAAkB,EAEnB,6CAA0C;AAE3C,KAAK,qBAAqB,GAAG,4BAA4B,GAAG;IAC1D,QAAQ,CAAC,SAAS,EAAE,2BAA2B,CAAC;CACjD,CAAC;AAQF,eAAO,MAAM,iBAAiB,6BAO7B,CAAC;AAEF,eAAO,MAAM,yBAAyB,oCAErC,CAAC;AAMF,KAAK,2BAA2B,GAAG;IACjC,0BAA0B,CAAC,EAAE,EAAE,kBAAkB,GAAG,MAAM,IAAI,CAAC;CAChE,CAAC;AAKF,eAAO,MAAM,yBAAyB,0CAErC,CAAC;AAMF,yBAAiB,4BAA4B,CAAC;IAC5C,KAAY,KAAK,GAAG;QAClB,QAAQ,EAAE,SAAS,CAAC;QACpB,OAAO,CAAC,EAAE,uBAAuB,GAAG,SAAS,CAAC;QAC9C,kEAAkE;QAClE,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;QAC7B,mEAAmE;QACnE,SAAS,CAAC,EAAE,2BAA2B,GAAG,SAAS,CAAC;KACrD,CAAC;CACH;AAED,eAAO,MAAM,4BAA4B,EAAE,EAAE,CAC3C,4BAA4B,CAAC,KAAK,CA4DnC,CAAC"}

package/dist/primitives/composer/mention/ComposerMentionContext.js

@@ -1,74 +0,0 @@
-"use client";
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useState, useCallback, useMemo, useEffect, } from "react";
-import { useAui } from "@assistant-ui/store";
-import { unstable_defaultDirectiveFormatter } from "@assistant-ui/core";
-import { ComposerPrimitiveTriggerPopoverRoot } from "../trigger/TriggerPopoverContext.js";
-// =============================================================================
-// Context — public (provides formatter on top of TriggerPopoverContext)
-// =============================================================================
-const MentionContext = createContext(null);
-export const useMentionContext = () => {
-    const ctx = useContext(MentionContext);
-    if (!ctx)
-        throw new Error("useMentionContext must be used within ComposerPrimitive.MentionRoot");
-    return ctx;
-};
-export const useMentionContextOptional = () => {
-    return useContext(MentionContext);
-};
-const MentionInternalContext = createContext(null);
-export const useMentionInternalContext = () => {
-    return useContext(MentionInternalContext);
-};
-export const ComposerPrimitiveMentionRoot = ({ children, adapter: adapterProp, trigger: triggerChar = "@", formatter: formatterProp, }) => {
-    const aui = useAui();
-    const formatter = formatterProp ?? unstable_defaultDirectiveFormatter;
-    // ---------------------------------------------------------------------------
-    // Runtime adapter (subscribe to state changes instead of useAuiState to avoid
-    // infinite loop — getModelContext() returns a new object on every call)
-    // ---------------------------------------------------------------------------
-    const getRuntimeAdapter = useCallback(() => {
-        try {
-            const runtime = aui.composer().__internal_getRuntime?.();
-            return runtime?._core?.getState()?.getMentionAdapter?.();
-        }
-        catch {
-            return undefined;
-        }
-    }, [aui]);
-    const [runtimeAdapter, setRuntimeAdapter] = useState(getRuntimeAdapter);
-    useEffect(() => {
-        return aui.subscribe(() => {
-            setRuntimeAdapter((prev) => {
-                const next = getRuntimeAdapter();
-                return prev === next ? prev : next;
-            });
-        });
-    }, [aui, getRuntimeAdapter]);
-    const adapter = adapterProp ?? runtimeAdapter;
-    // ---------------------------------------------------------------------------
-    // onSelect behavior for mentions: insert directive text
-    // ---------------------------------------------------------------------------
-    const onSelect = useMemo(() => ({ type: "insertDirective", formatter }), [formatter]);
-    // ---------------------------------------------------------------------------
-    // MentionContext — provides formatter + delegates state to TriggerPopoverContext
-    // We use useAuiState to read trigger popover state via the inner context.
-    // For backward compat, MentionContext wraps TriggerPopoverContext output.
-    // ---------------------------------------------------------------------------
-    return (_jsx(ComposerPrimitiveTriggerPopoverRoot, { adapter: adapter, trigger: triggerChar, onSelect: onSelect, children: _jsx(MentionContextBridge, { formatter: formatter, children: children }) }));
-};
-ComposerPrimitiveMentionRoot.displayName = "ComposerPrimitive.MentionRoot";
-// =============================================================================
-// Bridge — reads TriggerPopoverContext, wraps it as MentionContext
-// =============================================================================
-import { useTriggerPopoverContext } from "../trigger/TriggerPopoverContext.js";
-const MentionContextBridge = ({ formatter, children }) => {
-    const triggerCtx = useTriggerPopoverContext();
-    const mentionValue = useMemo(() => ({ ...triggerCtx, formatter }), [triggerCtx, formatter]);
-    const internalContextValue = useMemo(() => ({
-        registerSelectItemOverride: triggerCtx.registerSelectItemOverride,
-    }), [triggerCtx.registerSelectItemOverride]);
-    return (_jsx(MentionContext.Provider, { value: mentionValue, children: _jsx(MentionInternalContext.Provider, { value: internalContextValue, children: children }) }));
-};
-//# sourceMappingURL=ComposerMentionContext.js.map