@agent-relay/dashboard 2.0.87 → 2.0.89

package/src/components/hooks/useAllDMs.ts

@@ -0,0 +1,88 @@
+/**
+ * useAllDMs Hook
+ *
+ * Fetches ALL DM conversations in the workspace using the workspace-level API
+ * (`allDmConversations`). Unlike the SDK's built-in `useDMs` which only returns
+ * conversations the dashboard agent participates in, this hook returns agent-to-agent
+ * DMs as well, making them visible in the DM sidebar.
+ *
+ * Listens for `dm.received` and `group_dm.received` WebSocket events to
+ * automatically refetch when new DMs arrive.
+ */
+
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useRelay, useEvent } from '@relaycast/react';
+import { useRelayConfigStatus } from '../../providers/RelayConfigProvider';
+
+export interface AllDmConversation {
+  id: string;
+  channelId?: string;
+  type: string;
+  participants: string[];
+  lastMessage: {
+    text: string;
+    agentName: string;
+    createdAt: string;
+  } | null;
+  messageCount: number;
+  unreadCount?: number;
+}
+
+interface UseAllDMsResult {
+  conversations: AllDmConversation[];
+  loading: boolean;
+  error: Error | null;
+  refetch: () => void;
+}
+
+export function useAllDMs(): UseAllDMsResult {
+  const { configured } = useRelayConfigStatus();
+  const [conversations, setConversations] = useState<AllDmConversation[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+  const fetchingRef = useRef(false);
+
+  // useRelay() throws if not inside RelayProvider, but we always are.
+  // When relay is not configured, the provider uses dummy credentials and
+  // allDmConversations will fail — we guard with `configured`.
+  let relay: ReturnType<typeof useRelay> | null = null;
+  try {
+    relay = useRelay();
+  } catch {
+    // Not inside RelayProvider — relay stays null
+  }
+
+  const fetchConversations = useCallback(async () => {
+    if (!configured || !relay || fetchingRef.current) return;
+    fetchingRef.current = true;
+    try {
+      const data = await relay.allDmConversations();
+      setConversations(Array.isArray(data) ? data as AllDmConversation[] : []);
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+      fetchingRef.current = false;
+    }
+  }, [configured, relay]);
+
+  // Initial fetch
+  useEffect(() => {
+    if (!configured) {
+      setLoading(false);
+      return;
+    }
+    void fetchConversations();
+  }, [configured, fetchConversations]);
+
+  // Refetch when DM events arrive via WebSocket
+  useEvent('dm.received', () => {
+    void fetchConversations();
+  });
+  useEvent('group_dm.received', () => {
+    void fetchConversations();
+  });
+
+  return { conversations, loading, error, refetch: fetchConversations };
+}

package/src/components/hooks/useDirectMessage.ts

@@ -41,10 +41,22 @@ export function useDirectMessage({
     for (const msg of messages) {
       const { from, to } = msg;
       if (!from || !to) continue;
+      // Messages involving the selected human
       if (from === humanName && agentNameSet.has(to)) derived.add(to);
       if (to === humanName && agentNameSet.has(from)) derived.add(from);
       if (selectedDmAgents.includes(from) && agentNameSet.has(to)) derived.add(to);
       if (selectedDmAgents.includes(to) && agentNameSet.has(from)) derived.add(from);
+      // Include agents from DM messages (non-channel messages) so agent-to-agent
+      // DMs are visible in the DM view — but only if the message involves the
+      // current human or an already-selected DM agent to avoid cross-conversation leakage.
+      if (!to.startsWith('#')) {
+        const involvesHuman = (from === humanName || to === humanName);
+        const involvesSelected = selectedDmAgents.includes(from) || selectedDmAgents.includes(to);
+        if (involvesHuman || involvesSelected) {
+          if (agentNameSet.has(from)) derived.add(from);
+          if (agentNameSet.has(to)) derived.add(to);
+        }
+      }
     }
 
     const participants = new Set<string>([...selectedDmAgents, ...derived]);

package/src/lib/relaycastMessageAdapters.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type { Message } from '../types';
-import { normalizeRelayDmMessageTargets } from './relaycastMessageAdapters.js';
+import { getRelayDmParticipantName, normalizeRelayDmMessageTargets } from './relaycastMessageAdapters.js';
 
 function setRelayUsername(value?: string): void {
   const storage = (globalThis as { localStorage?: Storage }).localStorage;
@@ -93,6 +93,35 @@ describe('normalizeRelayDmMessageTargets', () => {
     expect(normalized[0]?.to).toBe('Natty');
   });
 
+  it('maps dm_* targets to object participants using agent_name', () => {
+    const messages: Message[] = [
+      {
+        id: 'msg-2a',
+        from: 'Natty',
+        to: 'dm_7b62c72644b9316e7e10a992',
+        content: 'hello',
+        timestamp: '2026-02-24T12:00:06.000Z',
+      },
+    ];
+
+    const normalized = normalizeRelayDmMessageTargets(messages, [
+      {
+        id: 'dm_7b62c72644b9316e7e10a992',
+        participants: [{ agent_name: 'Natty' }, { agent_name: 'test-broker-new' }],
+      },
+    ]);
+
+    expect(normalized[0]?.to).toBe('test-broker-new');
+  });
+
+  it('normalizes participant names using getRelayDmParticipantName', () => {
+    expect(getRelayDmParticipantName({ agent_name: 'Lead', name: 'ignored' })).toBe('Lead');
+    expect(getRelayDmParticipantName({ agentName: 'Codex-Worker' })).toBe('Codex-Worker');
+    expect(getRelayDmParticipantName('Test-Broker')).toBe('Test-Broker');
+    expect(getRelayDmParticipantName({ username: 'human-user' })).toBe('human-user');
+    expect(getRelayDmParticipantName(123)).toBeNull();
+  });
+
   it('leaves non-dm and unknown dm targets unchanged', () => {
     const messages: Message[] = [
       {

package/src/lib/relaycastMessageAdapters.ts

@@ -12,6 +12,30 @@ type RelayDmConversationLike = {
   participants: unknown[];
 };
 
+export function getRelayDmParticipantName(participant: unknown): string | null {
+  if (typeof participant === 'string') {
+    return normalizeRelayIdentity(participant);
+  }
+
+  if (participant === null || typeof participant !== 'object') {
+    return null;
+  }
+
+  const record = participant as Record<string, unknown>;
+  const rawName = (
+    record.agent_name
+    ?? record.agentName
+    ?? record.name
+    ?? record.username
+  );
+
+  if (typeof rawName !== 'string') {
+    return null;
+  }
+
+  return normalizeRelayIdentity(rawName);
+}
+
 function normalizeRelayIdentity(value: string): string {
   const trimmed = value.trim();
   if (!trimmed) return '';
@@ -39,8 +63,7 @@ function resolveDmRecipient(
   const senderKey = normalizeRelayIdentity(sender).toLowerCase();
 
   for (const participant of participants) {
-    if (typeof participant !== 'string') continue;
-    const normalized = normalizeRelayIdentity(participant);
+    const normalized = getRelayDmParticipantName(participant);
     if (!normalized) continue;
     if (normalized.toLowerCase() !== senderKey) {
       return normalized;
@@ -48,11 +71,9 @@ function resolveDmRecipient(
   }
 
   for (const participant of participants) {
-    if (typeof participant !== 'string') continue;
-    const normalized = normalizeRelayIdentity(participant);
-    if (normalized) {
-      return normalized;
-    }
+    const normalized = getRelayDmParticipantName(participant);
+    if (!normalized) continue;
+    return normalized;
   }
 
   return null;

package/src/providers/ChannelProvider.tsx

@@ -118,9 +118,20 @@ export function ChannelProvider({ children }: ChannelProviderProps) {
 
   // Relay channel state
   const relayChannelsState = useRelayChannels();
+  const relayChannelsLoading = relayChannelsState.loading;
+  const relayChannelsRaw = relayChannelsState.channels;
+
+  // Stabilize the mapped channels array — only recompute when the serialized
+  // channel list actually changes (avoids infinite re-render loops from new
+  // array references returned by the relay hook on every render).
+  const relayChannelsKey = useMemo(
+    () => JSON.stringify(relayChannelsRaw.map(c => c.name + ':' + (c.topic ?? '') + ':' + (c.isArchived ?? false) + ':' + (c.memberCount ?? 0))),
+    [relayChannelsRaw],
+  );
   const relayMappedChannels = useMemo(
-    () => relayChannelsState.channels.map(mapRelayChannelToDashboard),
-    [relayChannelsState.channels],
+    () => relayChannelsRaw.map(mapRelayChannelToDashboard),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [relayChannelsKey],
   );
 
   // Channel list state
@@ -225,7 +236,7 @@ export function ChannelProvider({ children }: ChannelProviderProps) {
       const activeChannels = relayMappedChannels.filter((channel) => channel.status !== 'archived');
       const archivedChannels = relayMappedChannels.filter((channel) => channel.status === 'archived');
       setChannelListsFromResponse({ channels: activeChannels, archivedChannels });
-      setIsChannelsLoading(relayChannelsState.loading);
+      setIsChannelsLoading(relayChannelsLoading);
       return;
     }
 
@@ -253,7 +264,7 @@ export function ChannelProvider({ children }: ChannelProviderProps) {
     fetchChannels();
   }, [
     relayConfigured,
-    relayChannelsState,
+    relayChannelsLoading,
     relayMappedChannels,
     effectiveActiveWorkspaceId,
     isWorkspaceFeaturesEnabled,

package/src/providers/MessageProvider.tsx

@@ -12,19 +12,18 @@
 import React, { createContext, useContext, useState, useCallback, useEffect, useMemo, useRef } from 'react';
 import type { Message } from '../types';
 import type { HumanUser } from '../components/MentionAutocomplete';
-import {
-  useDMs as useRelayDMs,
-} from '@relaycast/react';
 import { useMessages as useMessagesHook } from '../components/hooks/useMessages';
 import { useThread } from '../components/hooks/useThread';
 import { usePresence, type UserPresence } from '../components/hooks/usePresence';
 import { useDirectMessage } from '../components/hooks/useDirectMessage';
+import { useAllDMs } from '../components/hooks/useAllDMs';
 import { useCloudWorkspace } from './CloudWorkspaceProvider';
 import { useAgentContext } from './AgentProvider';
 import { useRelayConfigStatus } from './RelayConfigProvider';
 import { isDashboardVariant } from '../lib/identity';
 import {
   normalizeRelayDmMessageTargets,
+  getRelayDmParticipantName,
 } from '../lib/relaycastMessageAdapters';
 import { playNotificationSound } from './SettingsProvider';
 import { useSettings } from './SettingsProvider';
@@ -377,14 +376,14 @@ function MessageProviderInner({ children, data, rawData: _rawData, enableReactio
   // Relay DMs and message normalization
   // ---------------------------------------------------------------------------
 
-  const relayDMsState = useRelayDMs();
+  const allDMsState = useAllDMs();
   const normalizedRelayMessages = useMemo(() => {
     const sourceMessages = data?.messages ?? [];
-    if (!relayConfigured || relayDMsState.conversations.length === 0) {
+    if (!relayConfigured || allDMsState.conversations.length === 0) {
       return sourceMessages;
     }
-    return normalizeRelayDmMessageTargets(sourceMessages, relayDMsState.conversations);
-  }, [data?.messages, relayConfigured, relayDMsState.conversations]);
+    return normalizeRelayDmMessageTargets(sourceMessages, allDMsState.conversations);
+  }, [data?.messages, relayConfigured, allDMsState.conversations]);
 
   // ---------------------------------------------------------------------------
   // Core message hook
@@ -441,7 +440,7 @@ function MessageProviderInner({ children, data, rawData: _rawData, enableReactio
   const { visibleMessages: dedupedVisibleMessages, participantAgents: dmParticipantAgents } = useDirectMessage({
     currentHuman,
     currentUserName: currentUser?.displayName ?? null,
-    messages,
+    messages: currentHuman ? normalizedRelayMessages : messages,
     agents,
     selectedDmAgents,
     removedDmAgents,
@@ -466,11 +465,11 @@ function MessageProviderInner({ children, data, rawData: _rawData, enableReactio
       });
     }
 
-    if (relayConfigured && relayDMsState.conversations.length > 0) {
+    if (relayConfigured && allDMsState.conversations.length > 0) {
       const currentUserName = currentUser?.displayName.toLowerCase();
-      for (const conversation of relayDMsState.conversations) {
+      for (const conversation of allDMsState.conversations) {
         for (const participant of conversation.participants) {
-          const name = typeof participant === 'string' ? participant : participant.agentName;
+          const name = getRelayDmParticipantName(participant);
           if (!name) continue;
           const lowered = name.toLowerCase();
           if (currentUserName && lowered === currentUserName) continue;
@@ -490,7 +489,7 @@ function MessageProviderInner({ children, data, rawData: _rawData, enableReactio
     }
 
     return Array.from(seenUsers.values());
-  }, [normalizedRelayMessages, agents, currentUser, relayDMsState.conversations, relayConfigured, relayAgentName]);
+  }, [normalizedRelayMessages, agents, currentUser, allDMsState.conversations, relayConfigured, relayAgentName]);
 
   // ---------------------------------------------------------------------------
   // Human unread counts
@@ -499,21 +498,21 @@ function MessageProviderInner({ children, data, rawData: _rawData, enableReactio
   const humanUnreadCounts = useMemo(() => {
     if (!currentUser) return {};
 
-    if (relayConfigured && relayDMsState.conversations.length > 0) {
+    if (relayConfigured && allDMsState.conversations.length > 0) {
       const counts: Record<string, number> = {};
       const currentUserName = currentUser.displayName.toLowerCase();
       const agentNames = new Set(agents.filter((a) => !a.isHuman).map((a) => a.name.toLowerCase()));
 
-      for (const conversation of relayDMsState.conversations) {
+      for (const conversation of allDMsState.conversations) {
         if (!conversation.unreadCount) continue;
 
         const match = conversation.participants.find((p) => {
-          const name = typeof p === 'string' ? p : p.agentName;
+          const name = getRelayDmParticipantName(p);
           if (!name) return false;
           const lowered = name.toLowerCase();
           return lowered !== currentUserName && !agentNames.has(lowered);
         });
-        const participantName = match ? (typeof match === 'string' ? match : match.agentName) : null;
+        const participantName = match ? getRelayDmParticipantName(match) : null;
 
         if (participantName) {
           counts[participantName] = (counts[participantName] || 0) + conversation.unreadCount;
@@ -545,7 +544,7 @@ function MessageProviderInner({ children, data, rawData: _rawData, enableReactio
     }
 
     return counts;
-  }, [combinedAgents, currentUser, normalizedRelayMessages, dmSeenAt, relayDMsState.conversations, agents, relayConfigured]);
+  }, [combinedAgents, currentUser, normalizedRelayMessages, dmSeenAt, allDMsState.conversations, agents, relayConfigured]);
 
   const markDmSeen = useCallback((username: string) => {
     setDmSeenAt((prev) => {
@@ -838,16 +837,16 @@ function MessageProviderInnerWithSend({ children, data, rawData, enableReactions
   // Since SendProvider only needs them for local (non-cloud) channel message rendering,
   // we derive them here at this level too.
   const { configured: relayConfigured } = useRelayConfigStatus();
-  const relayDMsState = useRelayDMs();
+  const allDMsState = useAllDMs();
   const { currentUser } = useCloudWorkspace();
 
   const normalizedRelayMessages = useMemo(() => {
     const sourceMessages = data?.messages ?? [];
-    if (!relayConfigured || relayDMsState.conversations.length === 0) {
+    if (!relayConfigured || allDMsState.conversations.length === 0) {
       return sourceMessages;
     }
-    return normalizeRelayDmMessageTargets(sourceMessages, relayDMsState.conversations);
-  }, [data?.messages, relayConfigured, relayDMsState.conversations]);
+    return normalizeRelayDmMessageTargets(sourceMessages, allDMsState.conversations);
+  }, [data?.messages, relayConfigured, allDMsState.conversations]);
 
   const [localUsername] = useState<string | null>(
     typeof window !== 'undefined' ? localStorage.getItem('relay_username') : null

package/src/providers/RelayConfigProvider.tsx

@@ -84,8 +84,6 @@ export function RelayConfigProvider({ children }: RelayConfigProviderProps) {
   }, [configured, config]);
 
   // Channels to auto-subscribe on WebSocket connect/reconnect.
-  // This ensures the dashboard receives real-time messages even after
-  // WebSocket reconnects (useMessages effect deps don't re-trigger on reconnect).
   const channels = useMemo(() => {
     if (!configured) return undefined;
     const serverChannels = config?.channels;