@agent-native/toolkit 0.225.1 → 0.226.0-nightly-20261106182619

package/src/composer/TiptapComposer.tsx

@@ -1,6 +1,7 @@
 import { useComposer, useComposerRuntime } from "@assistant-ui/react";
 import {
   IconCheck,
+  IconSearch,
   IconChevronDown,
   IconBulb,
   IconClock,
@@ -113,7 +114,11 @@ import type {
   ComposerMode,
   AgentComposerLayoutVariant,
 } from "./types.js";
-import { useMentionSearch } from "./use-mention-search.js";
+import {
+  useMentionSearch,
+  loadWorkspaceMentionItems,
+  MentionSearchError,
+} from "./use-mention-search.js";
 import { useSkills } from "./use-skills.js";
 import {
   RealtimeVoiceModeBoundary,
@@ -3229,7 +3234,7 @@ function TiptapComposerSurface({
     settledQuery: settledMentionQuery,
   } = useMentionSearch(
     popover?.type === "@" ? popover.query : "",
-    includeDefaultMentionSearch && (contextMenuOpen || popover?.type === "@"),
+    includeDefaultMentionSearch && popover?.type === "@",
   );
   const mentionQuery = popover?.type === "@" ? popover.query : "";
   const filteredMentionItems = useMemo(
@@ -6455,51 +6460,140 @@ function TiptapComposerSurface({
   const launchersDisabled = disabled || contextControlsDisabled;
 
   const contextLauncherItems = useMemo(() => {
-    const sections = new Map<string, ComposerContextMenuItem[]>();
-    for (const item of filteredMentionItems) {
-      const section = item.section || "Other";
-      const entries = sections.get(section) ?? [];
-      entries.push({
-        id: `mention:${item.id}`,
-        label: item.label,
-        description: item.description,
-        onSelect: () => insertReference(composerReferenceFromMentionItem(item)),
-      });
-      sections.set(section, entries);
-    }
-    const sectionKeys: Record<string, string> = {
-      Agents: "agents",
-      "Connected Agents": "connectedAgents",
-      Files: "files",
-      Other: "other",
+    const excludedTypes = new Set<string>();
+    const visit = (entries: readonly ComposerContextMenuItem[]) => {
+      for (const entry of entries) {
+        if (entry.referenceType) excludedTypes.add(entry.referenceType);
+        if (entry.referencePicker)
+          excludedTypes.add(entry.referencePicker.referenceType);
+        if (entry.children) visit(entry.children);
+      }
+    };
+    visit(contextMenuItems ?? []);
+    const pickerFor = (filter?: { referenceType: string; source: string }) => {
+      const available = new Map<string, MentionItem>();
+      return {
+        identityScope: "workspace" as const,
+        presentation: { type: "dialog" as const, mode: "action" as const },
+        searchPlaceholder: t("agentChat.composer.menu.searchWorkspace", {
+          defaultValue: "Search workspace…",
+        }),
+        load: async ({
+          search,
+          signal,
+        }: {
+          search: string;
+          signal: AbortSignal;
+        }) => {
+          const remote =
+            filter || includeDefaultMentionSearch
+              ? await loadWorkspaceMentionItems(
+                  search,
+                  adapters.resolvePath,
+                  signal,
+                  filter?.source,
+                ).catch((cause: unknown) => {
+                  if (signal.aborted) throw cause;
+                  if (cause instanceof MentionSearchError) throw cause;
+                  throw new Error(
+                    t("agentChat.composer.contextLoadFailed", {
+                      defaultValue: "Could not load context.",
+                    }),
+                    { cause },
+                  );
+                })
+              : [];
+          const entries = [
+            ...mentionItemsForQuery(hostMentionItems, search),
+            ...remote,
+          ].filter((item) =>
+            filter
+              ? item.refType === filter.referenceType &&
+                (!filter.source || item.source === filter.source)
+              : !excludedTypes.has(item.refType),
+          );
+          if (signal.aborted)
+            throw new DOMException("The operation was aborted.", "AbortError");
+          available.clear();
+          for (const item of entries) available.set(item.id, item);
+          return {
+            items: Array.from(available.values()).map((item) => ({
+              id: item.id,
+              title: item.label,
+              ...(item.description === undefined
+                ? {}
+                : { description: item.description }),
+              ...(item.section === undefined
+                ? {}
+                : {
+                    group:
+                      item.section === "Files"
+                        ? "agentChat.mentions.sections.files"
+                        : item.section === "Agents"
+                          ? "agentChat.mentions.sections.agents"
+                          : item.section === "Connected Agents"
+                            ? "agentChat.mentions.sections.connectedAgents"
+                            : item.section,
+                  }),
+              icon: (
+                <MentionItemMedia
+                  {...(item.icon === undefined ? {} : { icon: item.icon })}
+                  {...(item.media === undefined ? {} : { media: item.media })}
+                  size="sm"
+                />
+              ),
+            })),
+          };
+        },
+        onSelect: (item: { id: string }) => {
+          const reference = available.get(item.id);
+          if (!reference)
+            throw new Error(
+              t("agentChat.composer.contextLoadFailed", {
+                defaultValue: "Could not load context.",
+              }),
+            );
+          insertReference(composerReferenceFromMentionItem(reference));
+        },
+      };
     };
+    const resolveEntries = (
+      entries: readonly ComposerContextMenuItem[],
+    ): ComposerContextMenuItem[] =>
+      entries.map((entry) => {
+        if (entry.referencePicker) {
+          const { referencePicker, ...rest } = entry;
+          return { ...rest, picker: pickerFor(referencePicker) };
+        }
+        return entry.children
+          ? { ...entry, children: resolveEntries(entry.children) }
+          : entry;
+      });
     return [
-      ...(contextMenuItems ?? []),
-      ...Array.from(sections)
-        .sort(([left], [right]) => {
-          const order = (section: string) =>
-            section === "Agents"
-              ? 0
-              : section === "Connected Agents"
-                ? 1
-                : section === "Files"
-                  ? 3
-                  : section === "Other"
-                    ? 4
-                    : 2;
-          return order(left) - order(right) || left.localeCompare(right);
-        })
-        .map(([section, children]) => ({
-          id: `mentions:${section}`,
-          label: sectionKeys[section]
-            ? t(`agentChat.mentions.sections.${sectionKeys[section]}`, {
-                defaultValue: section,
-              })
-            : section,
-          children,
-        })),
+      ...resolveEntries(contextMenuItems ?? []),
+      ...(includeDefaultMentionSearch || hostMentionItems.length
+        ? [
+            {
+              id: "composer-workspace-search",
+              section: "context" as const,
+              order: 90,
+              label: t("agentChat.composer.menu.searchWorkspace", {
+                defaultValue: "Search workspace…",
+              }),
+              icon: <IconSearch />,
+              picker: pickerFor(),
+            },
+          ]
+        : []),
     ];
-  }, [contextMenuItems, filteredMentionItems, insertReference, t]);
+  }, [
+    contextMenuItems,
+    hostMentionItems,
+    includeDefaultMentionSearch,
+    adapters.resolvePath,
+    insertReference,
+    t,
+  ]);
 
   const sendButton = (
     <ComposerSendButton
@@ -6786,15 +6880,7 @@ function TiptapComposerSurface({
             attachmentsEnabled={attachmentsEnabled}
             open={contextMenuOpen}
             onOpenChange={setContextMenuOpen}
-            loading={mentionsLoading}
-            error={
-              mentionsError
-                ? t("agentChat.composer.contextLoadFailed", {
-                    defaultValue: "Could not load context.",
-                  })
-                : undefined
-            }
-            onRetry={retryMentions}
+            onSelectIntegration={insertReference}
             onRestoreFocus={
               launchersDisabled
                 ? undefined
@@ -6909,8 +6995,15 @@ function TiptapComposerSurface({
         commands={filteredCommands}
         hint={hint}
         isLoading={popover?.type === "@" ? mentionsLoading : skillsLoading}
-        error={mentionItemsError}
-        onRetry={onRetryMentionItems}
+        error={
+          mentionItemsError ??
+          (mentionsError
+            ? t("agentChat.composer.contextLoadFailed", {
+                defaultValue: "Could not load context.",
+              })
+            : undefined)
+        }
+        onRetry={onRetryMentionItems ?? retryMentions}
         query={popover?.query ?? ""}
         onSelectMention={handleSelectMention}
         onSelectSkill={handleSelectSkill}

package/src/composer/index.ts

@@ -169,3 +169,8 @@ export type {
   Reference,
   SlashCommand,
 } from "./types.js";
+
+export type {
+  WorkspaceComposerMenuOptions,
+  WorkspaceComposerMenuContribution,
+} from "./runtime-adapters.js";

package/src/composer/runtime-adapters.tsx

@@ -8,6 +8,7 @@ import {
   type ReactNode,
 } from "react";
 
+import type { ComposerContextMenuItem } from "./ComposerContextMenu.js";
 import type { MentionItemMedia } from "./types.js";
 
 const referenceEventTargets = new WeakMap<Event, HTMLElement>();
@@ -188,6 +189,20 @@ export interface VoiceContextPack {
   terms?: Array<{ term: string; replacement?: string }>;
 }
 
+export interface WorkspaceComposerMenuOptions {
+  enabled: boolean;
+  onRestoreFocus?: () => void;
+  onSelectIntegration: (reference: AgentComposerReference) => void;
+}
+export interface WorkspaceComposerMenuContribution {
+  scopeKey?: string;
+  items: readonly ComposerContextMenuItem[];
+  loading?: boolean;
+  error?: string;
+  onRetry?: () => void | Promise<unknown>;
+  overlays?: ReactNode;
+}
+
 export interface ComposerRuntimeAdapters {
   resolvePath?: (path: string) => string;
   translate?: ComposerTranslate;
@@ -242,6 +257,9 @@ export interface ComposerRuntimeAdapters {
     isTrustedBuilderMessage?: (event: MessageEvent) => boolean;
   };
   resources?: {
+    useWorkspaceMenu?: (
+      options: WorkspaceComposerMenuOptions,
+    ) => WorkspaceComposerMenuContribution;
     useOrg?: () => {
       data?: { orgId?: string | null; role?: string | null } | null;
     };

package/src/composer/use-composer-panel-placement.ts

@@ -1,8 +1,6 @@
 import { useLayoutEffect, useState, type RefObject } from "react";
 
-// Keep the compact menu's actions reachable in short viewports.
-const MIN_USABLE_PANEL_HEIGHT = 120;
-const MAX_COMPOSER_PANEL_HEIGHT = 280;
+const MAX_COMPOSER_PANEL_HEIGHT = 480;
 
 export function useComposerPanelPlacement(
   triggerRef: RefObject<HTMLElement | null>,
@@ -32,7 +30,7 @@ export function useComposerPanelPlacement(
       const spaceAbove = Math.max(0, button.top - viewportTop - 24);
       const spaceBelow = Math.max(0, viewportBottom - button.bottom - 24);
       const side =
-        spaceAbove < MIN_USABLE_PANEL_HEIGHT && spaceBelow > spaceAbove
+        spaceAbove < MAX_COMPOSER_PANEL_HEIGHT && spaceBelow > spaceAbove
           ? "bottom"
           : "top";
       setPlacement({

package/src/composer/use-mention-search.spec.tsx

@@ -4,7 +4,10 @@ import { act } from "react";
 import { createRoot } from "react-dom/client";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 
-import { useMentionSearch } from "./use-mention-search.js";
+import {
+  useMentionSearch,
+  loadWorkspaceMentionItems,
+} from "./use-mention-search.js";
 
 const resolvePath = (path: string) => `/design${path}`;
 const file = {
@@ -45,6 +48,68 @@ afterEach(async () => {
   vi.unstubAllGlobals();
 });
 describe("shared launcher mention discovery", () => {
+  it("surfaces localized structured source failures and rejects malformed HTTP errors", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi
+        .fn()
+        .mockResolvedValueOnce(
+          new Response(
+            JSON.stringify({
+              error: {
+                code: "mention_source_unavailable",
+                message: "Impossible de charger les références.",
+                source: "dashboards",
+              },
+            }),
+            { status: 503 },
+          ),
+        )
+        .mockResolvedValueOnce(new Response("not json", { status: 503 })),
+    );
+    await expect(
+      loadWorkspaceMentionItems(
+        "",
+        resolvePath,
+        new AbortController().signal,
+        "dashboards",
+      ),
+    ).rejects.toMatchObject({
+      message: "Impossible de charger les références.",
+      code: "mention_source_unavailable",
+      source: "dashboards",
+    });
+    await expect(
+      loadWorkspaceMentionItems(
+        "",
+        resolvePath,
+        new AbortController().signal,
+        "dashboards",
+      ),
+    ).rejects.toThrow("Mention search unavailable");
+  });
+  it("rejects a failed source after earlier batches instead of returning a partial workspace result", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(
+        async () =>
+          new Response(
+            JSON.stringify({ items: [file] }) +
+              "\n" +
+              JSON.stringify({
+                error: {
+                  code: "mention_source_unavailable",
+                  message: "Could not load workspace references.",
+                  source: "dashboards",
+                },
+              }),
+          ),
+      ),
+    );
+    await expect(
+      loadWorkspaceMentionItems("", resolvePath, new AbortController().signal),
+    ).rejects.toThrow("Could not load workspace references.");
+  });
   it("does not load until the launcher opens", async () => {
     const fetch = vi.fn();
     vi.stubGlobal("fetch", fetch);
@@ -66,6 +131,39 @@ describe("shared launcher mention discovery", () => {
     expect(result.error).toBeNull();
     expect(result.isLoading).toBe(false);
   });
+  it.each([false, true])(
+    "keeps healthy streamed batches around a source error (earlier batch: %s)",
+    async (earlier) => {
+      const second = { ...file, id: "file:two", label: "Notes" };
+      const lines = [
+        ...(earlier ? [{ items: [file] }] : []),
+        { error: { message: "Source unavailable" } },
+        { items: [second] },
+      ];
+      vi.stubGlobal(
+        "fetch",
+        vi.fn(
+          async () =>
+            new Response(
+              new ReadableStream({
+                start(controller) {
+                  for (const line of lines)
+                    controller.enqueue(
+                      new TextEncoder().encode(JSON.stringify(line) + "\n"),
+                    );
+                  controller.close();
+                },
+              }),
+            ),
+        ),
+      );
+      await render();
+      expect(result.items).toEqual(earlier ? [file, second] : [second]);
+      expect(result.error?.message).toBe("Source unavailable");
+      expect(result.settledQuery).toBeNull();
+      expect(result.isLoading).toBe(false);
+    },
+  );
   it.each([
     new Response("{}"),
     new Response("{broken"),

package/src/composer/use-mention-search.ts

@@ -3,6 +3,95 @@ import { useState, useEffect, useRef, useCallback } from "react";
 import { useComposerRuntimeAdapters } from "./runtime-adapters.js";
 import type { MentionItem } from "./types.js";
 
+export class MentionSearchError extends Error {
+  constructor(message: string, details: { code?: string; source?: string }) {
+    super(message);
+    Object.assign(this, details);
+  }
+}
+
+function parseMentionBatch(
+  line: string,
+): { items: MentionItem[] } | { error: Error } {
+  const data: unknown = JSON.parse(line);
+  if (
+    data &&
+    typeof data === "object" &&
+    "error" in data &&
+    data.error &&
+    typeof data.error === "object" &&
+    "message" in data.error &&
+    typeof data.error.message === "string"
+  )
+    return {
+      error: new MentionSearchError(data.error.message, {
+        ...("code" in data.error && typeof data.error.code === "string"
+          ? { code: data.error.code }
+          : {}),
+        ...("source" in data.error && typeof data.error.source === "string"
+          ? { source: data.error.source }
+          : {}),
+      }),
+    };
+  if (
+    !data ||
+    typeof data !== "object" ||
+    !("items" in data) ||
+    !Array.isArray(data.items) ||
+    !data.items.every(
+      (item: unknown) =>
+        item &&
+        typeof item === "object" &&
+        "id" in item &&
+        typeof item.id === "string" &&
+        "label" in item &&
+        typeof item.label === "string" &&
+        "refType" in item &&
+        typeof item.refType === "string",
+    )
+  ) {
+    throw new Error("Invalid mention search response");
+  }
+  return { items: data.items as MentionItem[] };
+}
+
+async function mentionResponseError(response: Response): Promise<Error> {
+  const fallback = new Error("Mention search unavailable");
+  const body = await response.text();
+  try {
+    const batch = parseMentionBatch(body);
+    return "error" in batch ? batch.error : fallback;
+  } catch {
+    return fallback;
+  }
+}
+export async function loadWorkspaceMentionItems(
+  query: string,
+  resolvePath: (path: string) => string,
+  signal: AbortSignal,
+  source?: string,
+): Promise<MentionItem[]> {
+  const response = await fetch(
+    resolvePath(
+      `/_agent-native/agent-chat/mentions?q=${encodeURIComponent(query)}${source ? `&source=${encodeURIComponent(source)}` : ""}`,
+    ),
+    { signal },
+  );
+  if (!response.ok) throw await mentionResponseError(response);
+  if (!response.body) throw new Error("Mention search unavailable");
+  const body = await response.text();
+  if (signal.aborted)
+    throw new DOMException("The operation was aborted.", "AbortError");
+  return body
+    .split("\n")
+    .filter((line) => line.trim())
+    .flatMap((line) => {
+      const batch = parseMentionBatch(line);
+      if ("error" in batch) throw batch.error;
+      return batch.items;
+    });
+}
+
 export function useMentionSearch(
   query: string,
   enabled: boolean,
@@ -47,40 +136,26 @@ export function useMentionSearch(
           ),
           { signal: abort.signal },
         );
-        if (!res.ok || !res.body) throw new Error("Mention search unavailable");
+        if (!res.ok) throw await mentionResponseError(res);
+        if (!res.body) throw new Error("Mention search unavailable");
 
         const reader = res.body.getReader();
         const decoder = new TextDecoder();
         let buf = "";
+        const sourceError: { current: Error | null } = { current: null };
         const receive = (line: string) => {
           if (!line.trim()) return;
-          const data: unknown = JSON.parse(line);
-          if (
-            !data ||
-            typeof data !== "object" ||
-            !("items" in data) ||
-            !Array.isArray(data.items) ||
-            !data.items.every(
-              (item: unknown) =>
-                item &&
-                typeof item === "object" &&
-                "id" in item &&
-                typeof item.id === "string" &&
-                "label" in item &&
-                typeof item.label === "string" &&
-                "refType" in item &&
-                typeof item.refType === "string",
-            )
-          ) {
-            throw new Error("Invalid mention search response");
+          const batch = parseMentionBatch(line);
+          if ("error" in batch) {
+            sourceError.current ??= batch.error;
+            return;
           }
-          const batch = data.items as MentionItem[];
           if (id !== requestIdRef.current || abort.signal.aborted) return;
           setItems((previous) => {
             const seen = new Set(previous.map((item) => item.id));
             return [
               ...previous,
-              ...batch.filter((item) => {
+              ...batch.items.filter((item) => {
                 if (seen.has(item.id)) return false;
                 seen.add(item.id);
                 return true;
@@ -106,8 +181,10 @@ export function useMentionSearch(
         }
         // Only a completed search settles its query: a failed one is unknown,
         // not empty, and must not read as "nothing matches".
-        if (id === requestIdRef.current && !abort.signal.aborted)
-          setSettledQuery(query);
+        if (id === requestIdRef.current && !abort.signal.aborted) {
+          if (sourceError.current) setError(sourceError.current);
+          else setSettledQuery(query);
+        }
       } catch (err: unknown) {
         if (abort.signal.aborted) return;
         if (id === requestIdRef.current)

package/src/composer/useComposerContextPicker.ts

@@ -1,5 +1,6 @@
 import {
   useEffect,
+  useCallback,
   useRef,
   useState,
   type ReactNode,
@@ -13,6 +14,8 @@ export interface ComposerContextPickerItem {
   id: string;
   title: string;
   description?: string | null;
+  group?: string;
+  icon?: ReactNode;
   preview?: ReactNode;
   metadata?: ReactNode;
   disabled?: boolean;
@@ -45,8 +48,10 @@ export type ComposerContextPickerFooterAction = {
 export type ComposerContextPickerConfig = {
   footerAction?: ComposerContextPickerFooterAction;
   searchPlaceholder: string;
+  searchable?: boolean;
   selectedIds?: readonly string[];
   scopeKey?: string;
+  identityScope?: "workspace";
   refreshKey?: string | number;
   link?: {
     label?: string;
@@ -84,7 +89,7 @@ export type ComposerContextPickerConfig = {
           | { type: "dialog"; mode: "url" }
           | {
               type: "dialog";
-              mode: "single";
+              mode: "single" | "action";
               layout?: "list" | "gallery";
             };
         onSelect: (
@@ -148,9 +153,17 @@ export function useComposerContextPicker({
   const [chosen, setChosen] = useState<
     ReadonlyMap<string, ComposerContextPickerItem>
   >(() => new Map());
-  const [stage, setStage] = useState<"link" | "results">(
-    config.link || presentation?.mode === "url" ? "link" : "results",
+  const linkMode = Boolean(config.link || presentation?.mode === "url");
+  const [previousLinkMode, setPreviousLinkMode] = useState(linkMode);
+  const [currentStage, setStage] = useState<"link" | "results">(
+    linkMode ? "link" : "results",
   );
+  const stage =
+    previousLinkMode === linkMode
+      ? currentStage
+      : linkMode
+        ? "link"
+        : "results";
   const [link, setLink] = useState("");
   const [location, setLocation] = useState<PickerLocation>({
     search: "",
@@ -174,13 +187,13 @@ export function useComposerContextPicker({
   const keyRef = useRef(key);
   keyRef.current = key;
 
-  const invalidateSelection = () => {
+  const invalidateSelection = useCallback(() => {
     epoch.current++;
     pendingSelection.current?.abort();
     pendingSelection.current = null;
     setSelecting(false);
     setActionError(undefined);
-  };
+  }, []);
   useEffect(
     () => () => {
       epoch.current++;
@@ -189,6 +202,13 @@ export function useComposerContextPicker({
     [],
   );
 
+  useEffect(() => {
+    if (previousLinkMode === linkMode) return;
+    invalidateSelection();
+    setPreviousLinkMode(linkMode);
+    setStage(linkMode ? "link" : "results");
+  }, [previousLinkMode, linkMode, invalidateSelection]);
+
   useEffect(() => {
     if (!remote || stage !== "results") return;
     const abort = new AbortController();