feat(slack): cache user identities and resolve channel names

Add in-memory caches for user identities and channel names on SlackAdapterState
to avoid repeated users.info and conversations.info API calls per message.

Resolve channel names via conversations.info and populate slack_channel_name in
metadata so the dashboard shows real channel names with # prefix. DMs fall back
to dm-{sender_name}. Propagate sender_name through ApiEvent::InboundMessage to
the frontend SSE stream. Clean up formatted_author to use plain display names
instead of the Name (<@id>) format.

Adds channels:read, groups:read, im:read, mpim:read to required Slack scopes.

Author: jamiepine

.gitignore

@@ -8,3 +8,4 @@ interface/dist/
 
 .idea
 list/
+agents/

docs/content/docs/(messaging)/slack-setup.mdx

@@ -37,9 +37,13 @@ In your Slack app settings, go to **OAuth & Permissions** → scroll to **Bot To
 | `reactions:write` | Thinking indicator |
 | `reactions:read` | Read reactions |
 | `channels:history` | Read message history in public channels |
+| `channels:read` | Read public channel metadata (for channel names) |
 | `groups:history` | Same, for private channels |
+| `groups:read` | Read private channel metadata (for channel names) |
 | `im:history` | Same, for DMs |
+| `im:read` | Read DM metadata (for conversation names) |
 | `mpim:history` | Same, for group DMs |
+| `mpim:read` | Read group DM metadata (for conversation names) |
 | `users:read` | Resolve display names |
 | `files:write` | Upload file attachments |
 | `files:read` | Read file metadata |

interface/src/api/client.ts

@@ -28,6 +28,7 @@ export interface InboundMessageEvent {
 	type: "inbound_message";
 	agent_id: string;
 	channel_id: string;
+	sender_name?: string | null;
 	sender_id: string;
 	text: string;
 }

interface/src/hooks/useChannelLiveState.ts

@@ -189,7 +189,7 @@ export function useChannelLiveState(channels: ChannelInfo[]) {
 			type: "message",
 			id: `in-${Date.now()}-${crypto.randomUUID()}`,
 			role: "user",
-			sender_name: event.sender_id,
+			sender_name: event.sender_name ?? event.sender_id,
 			sender_id: event.sender_id,
 			content: event.text,
 			created_at: new Date().toISOString(),

src/api/state.rs

@@ -99,6 +99,7 @@ pub enum ApiEvent {
     InboundMessage {
         agent_id: String,
         channel_id: String,
+        sender_name: Option<String>,
         sender_id: String,
         text: String,
     },

src/conversation/channels.rs

@@ -39,7 +39,7 @@ impl ChannelStore {
         let pool = self.pool.clone();
         let channel_id = channel_id.to_string();
         let platform = extract_platform(&channel_id);
-        let display_name = extract_display_name(&platform, metadata);
+        let display_name = extract_display_name(&platform, &channel_id, metadata);
         let platform_meta = extract_platform_meta(&platform, metadata);
 
         tokio::spawn(async move {
@@ -195,6 +195,7 @@ fn extract_platform(channel_id: &str) -> String {
 /// Pull the best display name from inbound message metadata.
 fn extract_display_name(
     platform: &str,
+    channel_id: &str,
     metadata: &HashMap<String, serde_json::Value>,
 ) -> Option<String> {
     match platform {
@@ -205,7 +206,13 @@ fn extract_display_name(
         "slack" => metadata
             .get("slack_channel_name")
             .and_then(|v| v.as_str())
-            .map(|s| s.to_string()),
+            .map(|name| {
+                if channel_id.contains(":D") || name.starts_with("dm-") {
+                    name.to_string()
+                } else {
+                    format!("#{name}")
+                }
+            }),
         "telegram" => metadata
             .get("display_name")
             .and_then(|v| v.as_str())

src/main.rs

@@ -881,9 +881,17 @@ async fn run(
                     *active.latest_message.write().await = message.clone();
 
                     // Emit inbound message to SSE clients
+                    let sender_name = message.formatted_author.clone().or_else(|| {
+                        message
+                            .metadata
+                            .get("sender_display_name")
+                            .and_then(|v| v.as_str())
+                            .map(|s| s.to_string())
+                    });
                     api_state.event_tx.send(spacebot::api::ApiEvent::InboundMessage {
                         agent_id: agent_id.to_string(),
                         channel_id: conversation_id.clone(),
+                        sender_name,
                         sender_id: message.sender_id.clone(),
                         text: message.content.to_string(),
                     }).ok();

src/messaging/slack.rs

@@ -41,6 +41,10 @@ struct SlackAdapterState {
     /// Maps slash command string (e.g. `"/ask"`) → agent_id.
     /// Built once at start() from the config; read-only afterwards.
     commands: Arc<HashMap<String, String>>,
+    /// Cache of resolved user identities to avoid repeated `users.info` API calls.
+    user_identity_cache: Arc<RwLock<HashMap<String, SlackUserIdentity>>>,
+    /// Cache of resolved channel names to avoid repeated `conversations.info` API calls.
+    channel_name_cache: Arc<RwLock<HashMap<String, String>>>,
 }
 
 #[derive(Debug, Clone)]
@@ -202,6 +206,8 @@ async fn handle_message_event(
         msg_event.sender.user.as_ref(),
         &client,
         &adapter_state.bot_token,
+        &adapter_state.user_identity_cache,
+        &adapter_state.channel_name_cache,
     )
     .await;
 
@@ -282,6 +288,8 @@ async fn handle_app_mention_event(
         Some(&slack_uid),
         &client,
         &adapter_state.bot_token,
+        &adapter_state.user_identity_cache,
+        &adapter_state.channel_name_cache,
     )
     .await;
 
@@ -652,6 +660,8 @@ impl Messaging for SlackAdapter {
             bot_token: self.bot_token.clone(),
             bot_user_id,
             commands: self.commands.clone(),
+            user_identity_cache: Arc::new(RwLock::new(HashMap::new())),
+            channel_name_cache: Arc::new(RwLock::new(HashMap::new())),
         });
 
         let callbacks = SlackSocketModeListenerCallbacks::new()
@@ -1104,11 +1114,10 @@ impl Messaging for SlackAdapter {
                 let author = if is_bot {
                     "bot".to_string()
                 } else if let Some(uid) = user_id {
-                    let display_name = user_identity_by_id
+                    user_identity_by_id
                         .get(&uid)
                         .map(|i| i.display_name.clone())
-                        .unwrap_or_else(|| uid.clone());
-                    format!("{display_name} (<@{uid}>)")
+                        .unwrap_or_else(|| uid.clone())
                 } else {
                     "unknown".to_string()
                 };
@@ -1241,6 +1250,8 @@ async fn build_metadata_and_author(
     slack_user_id: Option<&SlackUserId>,
     client: &Arc<SlackHyperClient>,
     bot_token: &str,
+    user_identity_cache: &Arc<RwLock<HashMap<String, SlackUserIdentity>>>,
+    channel_name_cache: &Arc<RwLock<HashMap<String, String>>>,
 ) -> (HashMap<String, serde_json::Value>, Option<String>) {
     let mut metadata = HashMap::new();
 
@@ -1276,26 +1287,96 @@ async fn build_metadata_and_author(
         );
     }
 
-    // Resolve display name and username
+    let token = SlackApiToken::new(SlackApiTokenValue(bot_token.to_string()));
+    let session = client.open_session(&token);
+
+    // Resolve channel name via cache or conversations.info API.
+    if let Some(name) = channel_name_cache.read().await.get(channel_id).cloned() {
+        metadata.insert(
+            "slack_channel_name".into(),
+            serde_json::Value::String(name),
+        );
+    } else {
+        match session
+            .conversations_info(
+                &SlackApiConversationsInfoRequest::new(SlackChannelId(channel_id.to_string())),
+            )
+            .await
+        {
+            Ok(channel_info) => {
+                if let Some(name) = channel_info.channel.name {
+                    channel_name_cache
+                        .write()
+                        .await
+                        .insert(channel_id.to_string(), name.clone());
+                    metadata.insert(
+                        "slack_channel_name".into(),
+                        serde_json::Value::String(name),
+                    );
+                }
+            }
+            // DM channels (D-prefixed) don't support conversations.info in all cases
+            Err(error) if !channel_id.starts_with('D') => {
+                tracing::warn!(
+                    %error,
+                    channel_id = %channel_id,
+                    "failed to resolve Slack channel name; verify channels:read scope"
+                );
+            }
+            Err(_) => {}
+        }
+    }
+
+    // Resolve user identity via cache or users.info API.
     let mut formatted_author = user_id.map(|u| u.to_string());
 
     if let Some(uid) = slack_user_id {
-        let token = SlackApiToken::new(SlackApiTokenValue(bot_token.to_string()));
-        let session = client.open_session(&token);
-        if let Ok(user_info) = session
+        let cached = user_identity_cache.read().await.get(&uid.0).cloned();
+        let identity = if let Some(identity) = cached {
+            Some(identity)
+        } else if let Ok(user_info) = session
             .users_info(&SlackApiUsersInfoRequest::new(uid.clone()))
             .await
         {
             let identity = resolve_slack_user_identity(&user_info.user, &uid.0);
-            let display_with_mention = format!("{} (<@{}>)", identity.display_name, uid.0);
+            user_identity_cache
+                .write()
+                .await
+                .insert(uid.0.clone(), identity.clone());
+            Some(identity)
+        } else {
+            None
+        };
+
+        if let Some(identity) = identity {
             metadata.insert(
                 "sender_display_name".into(),
-                serde_json::Value::String(display_with_mention.clone()),
+                serde_json::Value::String(identity.display_name.clone()),
+            );
+            metadata.insert(
+                "slack_user_mention".into(),
+                serde_json::Value::String(format!("<@{}>", uid.0)),
             );
-            if let Some(name) = identity.username {
-                metadata.insert("sender_username".into(), serde_json::Value::String(name));
+            if let Some(ref name) = identity.username {
+                metadata.insert(
+                    "sender_username".into(),
+                    serde_json::Value::String(name.clone()),
+                );
             }
-            formatted_author = Some(display_with_mention);
+            formatted_author = Some(identity.display_name.clone());
+        }
+    }
+
+    // For DMs without a resolved channel name, use the sender's display name.
+    if channel_id.starts_with('D') && !metadata.contains_key("slack_channel_name") {
+        if let Some(display_name) = metadata
+            .get("sender_display_name")
+            .and_then(|v| v.as_str())
+        {
+            metadata.insert(
+                "slack_channel_name".into(),
+                serde_json::Value::String(format!("dm-{display_name}")),
+            );
         }
     }
 

src/tools/reply.rs

@@ -108,12 +108,11 @@ async fn convert_mentions(
         if let (Some(name), Some(id), Some(meta_str)) =
             (&msg.sender_name, &msg.sender_id, &msg.metadata)
         {
-            // Parse metadata JSON to get clean display name (without mention syntax)
+            // Parse metadata JSON to get clean display name
             if let Ok(meta) = serde_json::from_str::<HashMap<String, serde_json::Value>>(meta_str) {
                 if let Some(display_name) = meta.get("sender_display_name").and_then(|v| v.as_str())
                 {
-                    // For Slack (from PR #43), sender_display_name includes mention: "Name (<@ID>)"
-                    // Extract just the name part
+                    // Older rows may include mention syntax "Name (<@ID>)"; strip it.
                     let clean_name = display_name.split(" (<@").next().unwrap_or(display_name);
                     name_to_id.insert(clean_name.to_string(), id.clone());
                 }