@athenaintel/react 0.57.2 → 0.59.0

package/dist/chat-ui/mentions/suggestions/data/sources/index.d.ts

@@ -8,15 +8,25 @@
  * - FETCHERS: Call GraphQL API (assets, folders, team, etc.)
  * - TRANSFORMERS: Return static/local data (root categories, host-provided items)
  */
-import type { MenuItem, MentionTool, SourceFn, WebpageMention } from "../types";
-import { type MentionAuthContext } from "../api-client";
+import type { MenuItem, MentionChatAgent, MentionTool, SourceFn, WebpageMention } from "../types";
+import { type MentionAuthContext, type WorkspaceMember, type PersonMentionCandidate } from "../api-client";
+/** The scope of the composer's Agents section (Olympus's `CHAT_AGENTS_SCOPE`). */
+export declare const CHAT_AGENTS_SCOPE = "athena_chat_agents";
 export interface RootCategoriesConfig {
     categories: string[];
     getWebpages: () => readonly WebpageMention[];
+    /**
+     * The agents the Agents category offers now: the category shows only while
+     * there is one to name (it hides once eight are named, or for a viewer who is
+     * offered none).
+     */
+    getChatAgents?: () => readonly MentionChatAgent[];
 }
-export declare function buildRootMenuItems({ categories, webpages, }: {
+export declare function buildRootMenuItems({ categories, webpages, hasChatAgents, }: {
     categories: readonly string[];
     webpages: readonly WebpageMention[];
+    /** Whether the Agents category has an agent to offer (it shows only then). */
+    hasChatAgents?: boolean;
 }): MenuItem[];
 export declare const transformRootCategories: SourceFn<RootCategoriesConfig>;
 export interface AssetsConfig {
@@ -45,25 +55,65 @@ export interface TypedAssetsConfig {
     limit?: number;
 }
 export declare const fetchTypedAssets: SourceFn<TypedAssetsConfig>;
+/** Loads the Team list; browsing Team and every root search read one fetch. */
+export type TeamLoader = () => Promise<MenuItem[]>;
 export interface TeamConfig {
     auth: MentionAuthContext;
     /** Shared member loader, so browsing Team and searching read one fetch. */
-    loadTeam?: () => Promise<MenuItem[]>;
+    loadTeam?: TeamLoader;
 }
+export interface TeamLoaderOptions {
+    /**
+     * Whether the viewer is an Athena admin, read at each load: while Person is in
+     * preview the ranked people are an admin's alone, as in Olympus.
+     */
+    getIsAdmin?: () => boolean;
+}
+/**
+ * Where a Team item names the saved person asset it stands for: a root search
+ * drops that asset's own row, since the person is already listed once, as
+ * themselves (Olympus's `SAVED_PERSON_ASSET_ID_EXTRA`).
+ */
+export declare const SAVED_PERSON_ASSET_ID_EXTRA = "savedPersonAssetId";
+type MemberWithEmail = WorkspaceMember & {
+    email: string;
+};
+type TeamEntry = {
+    kind: "member";
+    member: MemberWithEmail;
+    savedName: string | null;
+    savedPersonAssetId: string | null;
+} | {
+    kind: "saved";
+    person: PersonMentionCandidate;
+};
 /**
- * One workspace-member fetch per store: every keystroke of a root search
- * reads the same list. A failed fetch is forgotten so the next one retries.
+ * One ordered Team list, as Olympus ranks it: the viewer's people in their
+ * order (most recently talked to first) — a member under the name the viewer
+ * saved them as, a saved person who is not a member as themselves — then the
+ * members the ranking did not reach. Without people the members keep their
+ * order.
  */
-export declare function createTeamLoader(auth: MentionAuthContext): () => Promise<MenuItem[]>;
+export declare function rankTeam({ members, people, }: {
+    members: readonly MemberWithEmail[];
+    people: readonly PersonMentionCandidate[];
+}): TeamEntry[];
+/**
+ * One Team fetch per store (and per admin answer): every keystroke of a root
+ * search reads the same list. A failed fetch is forgotten so the next one
+ * retries.
+ */
+export declare function createTeamLoader(auth: MentionAuthContext, { getIsAdmin }?: TeamLoaderOptions): TeamLoader;
 export declare const fetchTeam: SourceFn<TeamConfig>;
 /**
- * Add workspace members to a root search's first page, so `@<name>` finds
- * people beside assets (the cache filters them by the query). Like
+ * Add the Team list to a root search's first page, so `@<name>` finds people
+ * and groups beside assets (the cache filters them by the query), and drop the
+ * asset row of a saved person Team lists, on every page. Like
  * `withProvidedTools`, `consumedCount` stays the server's row count so the
  * members never advance the asset offset; a failed member fetch leaves the
  * asset results alone.
  */
-export declare function withTeam<TConfig>(source: SourceFn<TConfig>, loadTeam: () => Promise<MenuItem[]>): SourceFn<TConfig>;
+export declare function withTeam<TConfig>(source: SourceFn<TConfig>, loadTeam: TeamLoader): SourceFn<TConfig>;
 export interface ToolCatalogConfig {
     auth: MentionAuthContext;
 }
@@ -97,5 +147,33 @@ export declare function withProvidedTools<TConfig>(source: SourceFn<TConfig>, ge
  * root search's host tools), unfiltered; none for a source that holds no such items.
  */
 export declare function offlineItemsOf(sourceFn: SourceFn): MenuItem[];
+export interface ChatAgentsConfig {
+    /** Reactive getter for the agents offered now. */
+    getAgents: () => readonly MentionChatAgent[];
+}
+/**
+ * The menu item that names `agent`: choosing it names the agent for the
+ * message (a chip on the composer's To line) and never writes a mention into
+ * the text.
+ */
+export declare function chatAgentMenuItem(agent: MentionChatAgent): MenuItem;
+/** The agent an `agent` item names, or `null` for any other item. */
+export declare function chatAgentFromMenuItem(item: MenuItem): MentionChatAgent | null;
+/**
+ * The agents the composer offers (`MentionChatAgents.getAgents`): the person's
+ * own assistant and the collab agents the agent picker lists, minus those
+ * already named. agora checks every name a message carries, so nothing here
+ * gates.
+ */
+export declare const transformChatAgents: SourceFn<ChatAgentsConfig>;
+/**
+ * Prepend the agents offered now to a root search, so typing an agent's name
+ * after `@` finds it beside assets (the cache filters them by the query).
+ * `consumedCount` stays the wrapped source's row count, so the agents never
+ * advance the next page's offset. The agents are the host's own list: while
+ * Athena can't be reached, a search still finds them.
+ */
+export declare function withChatAgents<TConfig>(source: SourceFn<TConfig>, getAgents: () => readonly MentionChatAgent[]): SourceFn<TConfig>;
 /** Whether a scope's source asks Athena for its items (a fetcher, not a transformer). */
 export declare function sourceAsksAthena(sourceFn: SourceFn): boolean;
+export {};

package/dist/chat-ui/mentions/suggestions/data/sources/index.js

@@ -1,5 +1,6 @@
 import { MentionMenuSection } from "../types.js";
-import { fetchGraphQL, SIMPLE_SEARCH_QUERY, PAGINATED_ASSETS_QUERY, TOOL_CATALOG_QUERY, WORKSPACE_MEMBERS_QUERY } from "../api-client.js";
+import { fetchGraphQL, SIMPLE_SEARCH_QUERY, PAGINATED_ASSETS_QUERY, TOOL_CATALOG_QUERY, WORKSPACE_MEMBERS_QUERY, WORKSPACE_GROUPS_QUERY, PERSON_MENTION_CANDIDATES_QUERY } from "../api-client.js";
+import { filterItems } from "../utils/filter-items.js";
 import { assetTypeToThumb, assetTypeToIcon } from "./asset-type-icons.js";
 function assetToMenuItem(asset) {
   const isFolder = asset.athenaOriginalType === "folder";
@@ -43,6 +44,7 @@ async function querySimpleSearch(auth, opts) {
     hasMore: assets.length === opts.limit
   };
 }
+const CHAT_AGENTS_SCOPE = "athena_chat_agents";
 const CATEGORY_DEFS = {
   favorites: { name: "Favorites", icon: "star", scope: "favorites" },
   assets: { name: "Assets", icon: "file-text", scope: "athena_assets" },
@@ -60,6 +62,7 @@ const CATEGORY_DEFS = {
   tools: { name: "Tools", icon: "wrench", scope: "tools" },
   toolkits: { name: "Toolkits", icon: "package", scope: "toolkits" },
   team: { name: "Team", icon: "users", scope: "team" },
+  agents: { name: "Agents", icon: "bot", scope: CHAT_AGENTS_SCOPE },
   drives: { name: "Drives", icon: "hard-drive", scope: "drive_catalogs" }
 };
 function webpageDescription(webpage) {
@@ -90,10 +93,11 @@ function webpageToMenuItem(webpage) {
 }
 function buildRootMenuItems({
   categories,
-  webpages
+  webpages,
+  hasChatAgents = false
 }) {
   const webpageItems = webpages.map(webpageToMenuItem);
-  const categoryItems = categories.filter((cat) => CATEGORY_DEFS[cat]).map((cat) => {
+  const categoryItems = categories.filter((cat) => CATEGORY_DEFS[cat]).filter((cat) => cat !== "agents" || hasChatAgents).map((cat) => {
     const def = CATEGORY_DEFS[cat];
     return {
       id: cat,
@@ -109,10 +113,12 @@ function buildRootMenuItems({
   return [...webpageItems, ...categoryItems];
 }
 const transformRootCategories = async (context) => {
+  var _a;
   const { sourceConfig } = context;
   const items = buildRootMenuItems({
     categories: sourceConfig.categories,
-    webpages: sourceConfig.getWebpages()
+    webpages: sourceConfig.getWebpages(),
+    hasChatAgents: (((_a = sourceConfig.getChatAgents) == null ? void 0 : _a.call(sourceConfig).length) ?? 0) > 0
   });
   return { items, pagination: { hasMore: false } };
 };
@@ -217,8 +223,56 @@ const fetchTypedAssets = async (context) => {
     pagination: { hasMore: result.hasMore }
   };
 };
-function memberToMenuItem(member) {
-  const displayName = [member.firstName, member.lastName].filter(Boolean).join(" ").trim() || member.email;
+const SAVED_PERSON_ASSET_ID_EXTRA = "savedPersonAssetId";
+const PERSON_CANDIDATES_LIMIT = 500;
+function normalizeEmail(email) {
+  return (email ?? "").trim().toLowerCase();
+}
+function rankTeam({
+  members,
+  people
+}) {
+  if (people.length === 0) {
+    return members.map((member) => ({
+      kind: "member",
+      member,
+      savedName: null,
+      savedPersonAssetId: null
+    }));
+  }
+  const membersByEmail = new Map(
+    members.map((member) => [normalizeEmail(member.email), member])
+  );
+  const placed = /* @__PURE__ */ new Set();
+  const entries = [];
+  for (const person of people) {
+    const member = membersByEmail.get(normalizeEmail(person.email));
+    if (member) {
+      if (placed.has(member)) continue;
+      placed.add(member);
+      entries.push({
+        kind: "member",
+        member,
+        savedName: person.savedPersonAssetId ? person.displayName : null,
+        savedPersonAssetId: person.savedPersonAssetId ?? null
+      });
+    } else if (person.savedPersonAssetId) {
+      entries.push({ kind: "saved", person });
+    }
+  }
+  for (const member of members) {
+    if (!placed.has(member)) {
+      entries.push({ kind: "member", member, savedName: null, savedPersonAssetId: null });
+    }
+  }
+  return entries;
+}
+function memberToMenuItem({
+  member,
+  savedName,
+  savedPersonAssetId
+}) {
+  const displayName = savedName || [member.firstName, member.lastName].filter(Boolean).join(" ").trim() || member.email;
   return {
     id: member.email,
     name: displayName,
@@ -227,11 +281,42 @@ function memberToMenuItem(member) {
     thumbnailUrl: member.avatarUrl || void 0,
     visibleInScopes: /* @__PURE__ */ new Set(),
     email: member.email,
-    extra: { isAdmin: member.isAdmin }
+    extra: {
+      isAdmin: member.isAdmin,
+      ...savedPersonAssetId ? { [SAVED_PERSON_ASSET_ID_EXTRA]: savedPersonAssetId } : {}
+    }
   };
 }
-async function queryTeam(auth) {
-  if (!auth.workspaceId) return [];
+function savedPersonToMenuItem(person) {
+  return {
+    id: person.email,
+    name: person.displayName,
+    type: "user",
+    fallbackIcon: "user",
+    thumbnailUrl: person.photoUrl || void 0,
+    visibleInScopes: /* @__PURE__ */ new Set(),
+    email: person.email,
+    ...person.savedPersonAssetId ? { extra: { [SAVED_PERSON_ASSET_ID_EXTRA]: person.savedPersonAssetId } } : {}
+  };
+}
+function groupMemberCount(count) {
+  return count === 1 ? "1 member" : `${count} members`;
+}
+function groupToMenuItem(group) {
+  return {
+    id: group.id,
+    name: group.name,
+    type: "group",
+    fallbackIcon: "users",
+    description: groupMemberCount(group.memberCount),
+    visibleInScopes: /* @__PURE__ */ new Set(),
+    extra: {
+      memberCount: group.memberCount,
+      ...group.slug ? { slug: group.slug } : {}
+    }
+  };
+}
+async function queryMembers(auth) {
   const data = await fetchGraphQL(
     auth,
     WORKSPACE_MEMBERS_QUERY,
@@ -239,21 +324,65 @@ async function queryTeam(auth) {
   );
   return (data.getUsersInWorkspace || []).filter(
     (member) => Boolean(member.email)
-  ).map(memberToMenuItem);
+  );
+}
+async function queryGroups(auth) {
+  try {
+    const data = await fetchGraphQL(
+      auth,
+      WORKSPACE_GROUPS_QUERY,
+      { workspaceId: auth.workspaceId }
+    );
+    return (data.getWorkspaceGroups || []).filter((group) => group.archivedAt == null);
+  } catch {
+    return [];
+  }
 }
-function createTeamLoader(auth) {
+async function queryPeople(auth) {
+  try {
+    const data = await fetchGraphQL(
+      auth,
+      PERSON_MENTION_CANDIDATES_QUERY,
+      { limit: PERSON_CANDIDATES_LIMIT }
+    );
+    return data.personMentionCandidates || [];
+  } catch {
+    return [];
+  }
+}
+async function queryTeam(auth, { isAdmin }) {
+  const { workspaceId } = auth;
+  if (!workspaceId) return [];
+  const scoped = { ...auth, workspaceId };
+  const [members, groups, people] = await Promise.all([
+    queryMembers(scoped),
+    queryGroups(scoped),
+    isAdmin ? queryPeople(auth) : Promise.resolve([])
+  ]);
+  return [
+    ...rankTeam({ members, people }).map(
+      (entry) => entry.kind === "member" ? memberToMenuItem(entry) : savedPersonToMenuItem(entry.person)
+    ),
+    ...groups.map(groupToMenuItem)
+  ];
+}
+function createTeamLoader(auth, { getIsAdmin = () => false } = {}) {
   let pending = null;
   return () => {
-    pending ?? (pending = queryTeam(auth).catch((error) => {
-      pending = null;
-      throw error;
-    }));
-    return pending;
+    const isAdmin = getIsAdmin();
+    if ((pending == null ? void 0 : pending.isAdmin) !== isAdmin) {
+      const team = queryTeam(auth, { isAdmin }).catch((error) => {
+        if ((pending == null ? void 0 : pending.team) === team) pending = null;
+        throw error;
+      });
+      pending = { isAdmin, team };
+    }
+    return pending.team;
   };
 }
 const fetchTeam = async (context) => {
   const { auth, loadTeam } = context.sourceConfig;
-  const items = await (loadTeam ? loadTeam() : queryTeam(auth));
+  const items = await (loadTeam ? loadTeam() : queryTeam(auth, { isAdmin: false }));
   return { items, pagination: { hasMore: false } };
 };
 const TEAM_WAIT_MS = 1500;
@@ -266,19 +395,47 @@ function withinTeamWait(members) {
     () => clearTimeout(timer)
   );
 }
+function savedPeopleListedAsPeople(team) {
+  var _a;
+  const rows = /* @__PURE__ */ new Map();
+  for (const item of team) {
+    const assetId = (_a = item.extra) == null ? void 0 : _a[SAVED_PERSON_ASSET_ID_EXTRA];
+    if (item.type === "user" && typeof assetId === "string") rows.set(assetId, item);
+  }
+  return rows;
+}
+function withoutListedSavedPeople({
+  items,
+  listed,
+  query
+}) {
+  if (listed.size === 0) return items;
+  return items.filter((item) => {
+    if (item.type === "user") return true;
+    const person = listed.get(item.id);
+    if (!person) return true;
+    return filterItems([item], query).length > 0 && filterItems([person], query).length === 0;
+  });
+}
 function withTeam(source, loadTeam) {
   return keepOfflineItems(source, async (context) => {
     var _a, _b, _c;
     const meta = context.fetchState.meta || {};
     const isFirstPage = (meta.validatedCount || 0) === 0;
+    const query = ((_a = context.query) == null ? void 0 : _a.trim()) ?? "";
     const [result, team] = await Promise.all([
       source(context),
-      isFirstPage && ((_a = context.query) == null ? void 0 : _a.trim()) ? withinTeamWait(loadTeam()) : Promise.resolve([])
+      query ? withinTeamWait(loadTeam()) : Promise.resolve([])
     ]);
     if (team.length === 0) return result;
+    const items = withoutListedSavedPeople({
+      items: result.items,
+      listed: savedPeopleListedAsPeople(team),
+      query
+    });
     return {
       ...result,
-      items: [...team, ...result.items],
+      items: isFirstPage ? [...team, ...items] : items,
       pagination: {
         ...result.pagination,
         hasMore: ((_b = result.pagination) == null ? void 0 : _b.hasMore) ?? false,
@@ -404,15 +561,71 @@ function offlineItemsOf(sourceFn) {
   var _a;
   return ((_a = OFFLINE_ITEMS.get(sourceFn)) == null ? void 0 : _a()) ?? [];
 }
+const CHAT_AGENT_ITEM_ID_PREFIX = "agent:";
+function chatAgentMenuItem(agent) {
+  return {
+    id: `${CHAT_AGENT_ITEM_ID_PREFIX}${agent.ref}`,
+    name: agent.name,
+    type: "agent",
+    fallbackIcon: agent.icon || "bot",
+    visibleInScopes: /* @__PURE__ */ new Set(),
+    extra: { agentRef: agent.ref, agentAssetId: agent.assetId }
+  };
+}
+function chatAgentFromMenuItem(item) {
+  var _a, _b;
+  if (item.type !== "agent") return null;
+  const ref = (_a = item.extra) == null ? void 0 : _a.agentRef;
+  if (typeof ref !== "string" || !ref) return null;
+  const assetId = (_b = item.extra) == null ? void 0 : _b.agentAssetId;
+  return {
+    ref,
+    name: item.name,
+    assetId: typeof assetId === "string" && assetId ? assetId : null,
+    icon: item.fallbackIcon
+  };
+}
+const transformChatAgents = async (context) => {
+  const items = context.sourceConfig.getAgents().map(chatAgentMenuItem);
+  return { items, pagination: { hasMore: false, totalCount: items.length } };
+};
+function withChatAgents(source, getAgents) {
+  const wrapped = async (context) => {
+    var _a, _b;
+    const result = await source(context);
+    const agents = getAgents().map(chatAgentMenuItem);
+    if (agents.length === 0) return result;
+    return {
+      ...result,
+      items: [...agents, ...result.items],
+      pagination: {
+        ...result.pagination,
+        hasMore: ((_a = result.pagination) == null ? void 0 : _a.hasMore) ?? false,
+        consumedCount: ((_b = result.pagination) == null ? void 0 : _b.consumedCount) ?? result.items.length
+      }
+    };
+  };
+  const inner = OFFLINE_ITEMS.get(source);
+  OFFLINE_ITEMS.set(wrapped, () => [
+    ...getAgents().map(chatAgentMenuItem),
+    ...(inner == null ? void 0 : inner()) ?? []
+  ]);
+  return wrapped;
+}
 const LOCAL_SOURCES = /* @__PURE__ */ new Set([
   transformRootCategories,
-  transformProvidedTools
+  transformProvidedTools,
+  transformChatAgents
 ]);
 function sourceAsksAthena(sourceFn) {
   return !LOCAL_SOURCES.has(sourceFn);
 }
 export {
+  CHAT_AGENTS_SCOPE,
+  SAVED_PERSON_ASSET_ID_EXTRA,
   buildRootMenuItems,
+  chatAgentFromMenuItem,
+  chatAgentMenuItem,
   createTeamLoader,
   fetchAssets,
   fetchDrives,
@@ -426,9 +639,12 @@ export {
   fetchTypedAssets,
   offlineItemsOf,
   providedToolMenuItems,
+  rankTeam,
   sourceAsksAthena,
+  transformChatAgents,
   transformProvidedTools,
   transformRootCategories,
+  withChatAgents,
   withProvidedTools,
   withTeam
 };