fix(desktop): include allowlisted relay agents in autocomplete

Carry relay-agent respond-to allowlist metadata through the directory model and treat allowlisted-to-current-user agents as reachable autocomplete candidates.

Co-authored-by: Pinky <44b8e82baa6e0e254e0208d68f335c283c94e7b78dd1fa10d5a49d3f13dd0435@sprout-oss.stage.blox.sqprod.co>
Signed-off-by: Wes <wesbillman@users.noreply.github.com>

Author: wesbillman

desktop/src-tauri/src/managed_agents/types.rs

@@ -1,6 +1,5 @@
-use std::{collections::BTreeMap, path::PathBuf, process::Child};
-
 use serde::{Deserialize, Serialize};
+use std::{collections::BTreeMap, path::PathBuf, process::Child};
 
 #[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
 #[serde(tag = "type", rename_all = "snake_case")]
@@ -80,8 +79,9 @@ pub struct RelayAgentInfo {
     pub status: String,
     #[serde(default)]
     pub respond_to: Option<RespondTo>,
+    #[serde(default)]
+    pub respond_to_allowlist: Vec<String>,
 }
-
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ManagedAgentRecord {
     pub pubkey: String,

desktop/src-tauri/src/nostr_convert.rs

@@ -940,6 +940,26 @@ mod tests {
         );
     }
 
+    #[test]
+    fn agents_preserves_allowlist_metadata_for_directory_parse() {
+        let e = ev(
+            10100,
+            r#"{"name":"Scout","respond_to":"allowlist","respond_to_allowlist":["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]}"#,
+            vec![],
+        );
+        let v = agents_from_events(std::slice::from_ref(&e));
+        let agents = v.get("agents").cloned().unwrap();
+        let parsed: Vec<crate::managed_agents::RelayAgentInfo> =
+            serde_json::from_value(agents).unwrap();
+
+        assert_eq!(parsed.len(), 1);
+        assert_eq!(
+            parsed[0].respond_to,
+            Some(crate::managed_agents::RespondTo::Allowlist)
+        );
+        assert_eq!(parsed[0].respond_to_allowlist, vec!["a".repeat(64)]);
+    }
+
     #[test]
     fn relay_members_dedupes_and_defaults_role() {
         let pk1 = "a".repeat(64);

desktop/src/features/agents/lib/agentAutocompleteEligibility.test.mjs

@@ -45,44 +45,93 @@ test("getSharedChannelIds: includes only active joined channels", () => {
   );
 });
 
-test("relayAgentIsSharedWithUser: requires anyone response and a shared channel", () => {
+test("relayAgentIsSharedWithUser: accepts shared anyone agents and rejects unshared ones", () => {
   const sharedChannelIds = new Set(["general"]);
 
   assert.equal(
     relayAgentIsSharedWithUser(
-      { respondTo: "anyone", channelIds: ["general"] },
+      { respondTo: "anyone", respondToAllowlist: [], channelIds: ["general"] },
       sharedChannelIds,
     ),
     true,
   );
   assert.equal(
     relayAgentIsSharedWithUser(
-      { respondTo: "owner-only", channelIds: ["general"] },
+      {
+        respondTo: "owner-only",
+        respondToAllowlist: [],
+        channelIds: ["general"],
+      },
       sharedChannelIds,
     ),
     false,
   );
   assert.equal(
     relayAgentIsSharedWithUser(
-      { respondTo: "anyone", channelIds: ["other"] },
+      { respondTo: "anyone", respondToAllowlist: [], channelIds: ["other"] },
       sharedChannelIds,
     ),
     false,
   );
 });
 
+test("relayAgentIsSharedWithUser: accepts allowlist agents for the current user", () => {
+  const sharedChannelIds = new Set(["general"]);
+
+  assert.equal(
+    relayAgentIsSharedWithUser(
+      {
+        respondTo: "allowlist",
+        respondToAllowlist: [OTHER_OWNER_PUBKEY, CURRENT_PUBKEY.toUpperCase()],
+        channelIds: ["other"],
+      },
+      sharedChannelIds,
+      CURRENT_PUBKEY,
+    ),
+    true,
+  );
+  assert.equal(
+    relayAgentIsSharedWithUser(
+      {
+        respondTo: "allowlist",
+        respondToAllowlist: [OTHER_OWNER_PUBKEY],
+        channelIds: ["general"],
+      },
+      sharedChannelIds,
+      CURRENT_PUBKEY,
+    ),
+    false,
+  );
+});
+
 test("getMentionableAgentPubkeys: keeps managed agents and shared relay agents", () => {
   const result = getMentionableAgentPubkeys({
     managedAgentPubkeys: [PUB_A],
+    currentPubkey: CURRENT_PUBKEY,
     relayAgents: [
-      { pubkey: PUB_B, respondTo: "anyone", channelIds: ["general"] },
-      { pubkey: PUB_C, respondTo: "owner-only", channelIds: ["general"] },
-      { pubkey: PUB_D, respondTo: "anyone", channelIds: ["other"] },
+      {
+        pubkey: PUB_B,
+        respondTo: "anyone",
+        respondToAllowlist: [],
+        channelIds: ["general"],
+      },
+      {
+        pubkey: PUB_C,
+        respondTo: "allowlist",
+        respondToAllowlist: [CURRENT_PUBKEY],
+        channelIds: ["other"],
+      },
+      {
+        pubkey: PUB_D,
+        respondTo: "anyone",
+        respondToAllowlist: [],
+        channelIds: ["other"],
+      },
     ],
     sharedChannelIds: new Set(["general"]),
   });
 
-  assert.deepEqual(result, new Set([PUB_A, PUB_B]));
+  assert.deepEqual(result, new Set([PUB_A, PUB_B, PUB_C]));
 });
 
 test("coalesceAgentAutocompleteCandidates: merges agents with the same persona id", () => {

desktop/src/features/agents/lib/agentAutocompleteEligibility.ts

@@ -10,21 +10,33 @@ export function getSharedChannelIds(channels: readonly Channel[] | undefined) {
 }
 
 export function relayAgentIsSharedWithUser(
-  agent: Pick<RelayAgent, "channelIds" | "respondTo">,
+  agent: Pick<RelayAgent, "channelIds" | "respondTo" | "respondToAllowlist">,
   sharedChannelIds: ReadonlySet<string>,
+  currentPubkey?: string | null,
 ) {
+  const normalizedCurrentPubkey = currentPubkey
+    ? normalizePubkey(currentPubkey)
+    : null;
+
+  if (agent.respondTo === "allowlist" && normalizedCurrentPubkey) {
+    return agent.respondToAllowlist
+      .map((pubkey) => normalizePubkey(pubkey))
+      .includes(normalizedCurrentPubkey);
+  }
+
   return (
-    // RelayAgent does not expose respondTo allowlists yet, so only shared "anyone" agents are safely mentionable.
     agent.respondTo === "anyone" &&
     agent.channelIds.some((channelId) => sharedChannelIds.has(channelId))
   );
 }
 
 export function getMentionableAgentPubkeys({
+  currentPubkey,
   managedAgentPubkeys,
   relayAgents,
   sharedChannelIds,
 }: {
+  currentPubkey?: string | null;
   managedAgentPubkeys: Iterable<string>;
   relayAgents: readonly RelayAgent[] | undefined;
   sharedChannelIds: ReadonlySet<string>;
@@ -34,7 +46,7 @@ export function getMentionableAgentPubkeys({
   );
 
   for (const agent of relayAgents ?? []) {
-    if (relayAgentIsSharedWithUser(agent, sharedChannelIds)) {
+    if (relayAgentIsSharedWithUser(agent, sharedChannelIds, currentPubkey)) {
       pubkeys.add(normalizePubkey(agent.pubkey));
     }
   }

desktop/src/features/channels/ui/MembersSidebar.tsx

@@ -286,6 +286,7 @@ export function MembersSidebar({
     );
     const sharedChannelIds = getSharedChannelIds(channelsQuery.data);
     const eligibleAgentPubkeys = getMentionableAgentPubkeys({
+      currentPubkey,
       managedAgentPubkeys: (managedAgentsQuery.data ?? []).map(
         (agent) => agent.pubkey,
       ),

desktop/src/features/messages/lib/useMentions.ts

@@ -227,11 +227,17 @@ export function useMentions(
   const mentionableAgentPubkeys = React.useMemo(
     () =>
       getMentionableAgentPubkeys({
+        currentPubkey,
         managedAgentPubkeys,
         relayAgents: relayAgentsQuery.data,
         sharedChannelIds,
       }),
-    [managedAgentPubkeys, relayAgentsQuery.data, sharedChannelIds],
+    [
+      currentPubkey,
+      managedAgentPubkeys,
+      relayAgentsQuery.data,
+      sharedChannelIds,
+    ],
   );
   const personaNameByPubkey = React.useMemo(() => {
     const agents = managedAgentsQuery.data ?? [];

desktop/src/features/pulse/ui/PulseView.tsx

@@ -111,6 +111,7 @@ export function PulseView({ currentPubkey }: PulseViewProps) {
               ? "online"
               : "offline",
           respondTo: agent.respondTo,
+          respondToAllowlist: agent.respondToAllowlist,
         });
       }
     }

desktop/src/features/sidebar/ui/NewDirectMessageDialog.tsx

@@ -337,6 +337,7 @@ export function NewDirectMessageDialog({
       ? normalizePubkey(currentPubkey)
       : null;
     const eligibleAgentPubkeys = getMentionableAgentPubkeys({
+      currentPubkey,
       managedAgentPubkeys: (managedAgentsQuery.data ?? []).map(
         (agent) => agent.pubkey,
       ),

desktop/src/shared/api/tauri.ts

@@ -1,5 +1,4 @@
 import { invoke as tauriInvoke } from "@tauri-apps/api/core";
-
 import type {
   AddChannelMembersInput,
   AddChannelMembersResult,
@@ -189,8 +188,8 @@ type RawRelayAgent = {
   capabilities: string[];
   status: RelayAgent["status"];
   respond_to?: RelayAgent["respondTo"];
+  respond_to_allowlist?: string[];
 };
-
 export type RawManagedAgent = {
   pubkey: string;
   name: string;
@@ -846,6 +845,7 @@ function fromRawRelayAgent(agent: RawRelayAgent): RelayAgent {
     capabilities: agent.capabilities,
     status: agent.status,
     respondTo: agent.respond_to ?? null,
+    respondToAllowlist: agent.respond_to_allowlist ?? [],
   };
 }
 

desktop/src/shared/api/types.ts

@@ -265,6 +265,7 @@ export type RelayAgent = {
   capabilities: string[];
   status: "online" | "away" | "offline";
   respondTo: RespondToMode | null;
+  respondToAllowlist: string[];
 };
 
 export type ManagedAgentBackend =