@agent-relay/dashboard 2.0.86 → 2.0.88

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

@@ -25,6 +25,7 @@ import { useRelayConfigStatus } from './RelayConfigProvider';
 import { isDashboardVariant } from '../lib/identity';
 import {
   normalizeRelayDmMessageTargets,
+  getRelayDmParticipantName,
 } from '../lib/relaycastMessageAdapters';
 import { playNotificationSound } from './SettingsProvider';
 import { useSettings } from './SettingsProvider';
@@ -470,7 +471,7 @@ function MessageProviderInner({ children, data, rawData: _rawData, enableReactio
       const currentUserName = currentUser?.displayName.toLowerCase();
       for (const conversation of relayDMsState.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;
@@ -508,12 +509,12 @@ function MessageProviderInner({ children, data, rawData: _rawData, enableReactio
         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;

package/src/providers/RelayConfigProvider.tsx

@@ -9,6 +9,7 @@ interface RelayConfigResponse {
   apiKey?: string;
   agentToken?: string;
   agentName?: string | null;
+  channels?: string[];
 }
 
 export interface RelayConfigProviderProps {
@@ -31,6 +32,9 @@ export function useRelayConfigStatus(): RelayConfigStatus {
   return useContext(RelayConfigStatusContext);
 }
 
+/** Default channels the dashboard agent should subscribe to via WebSocket */
+const DEFAULT_CHANNELS = ['general'];
+
 export function RelayConfigProvider({ children }: RelayConfigProviderProps) {
   const [config, setConfig] = useState<RelayConfigResponse | null>(null);
   const [loaded, setLoaded] = useState(false);
@@ -79,12 +83,23 @@ export function RelayConfigProvider({ children }: RelayConfigProviderProps) {
     };
   }, [configured, config]);
 
+  // Channels to auto-subscribe on WebSocket connect/reconnect.
+  const channels = useMemo(() => {
+    if (!configured) return undefined;
+    const serverChannels = config?.channels;
+    if (Array.isArray(serverChannels) && serverChannels.length > 0) {
+      return serverChannels;
+    }
+    return DEFAULT_CHANNELS;
+  }, [configured, config?.channels]);
+
   return (
     <RelayConfigStatusContext.Provider value={{ configured, loading: !loaded, agentName: config?.agentName ?? null }}>
       <RelayProvider
         baseUrl={providerConfig.baseUrl}
         apiKey={providerConfig.apiKey}
         agentToken={providerConfig.agentToken}
+        channels={channels}
       >
         {/* eslint-disable-next-line @typescript-eslint/no-explicit-any */}
         {children as any}

package/src/providers/SendProvider.tsx

@@ -156,9 +156,18 @@ export function SendProvider({ children, localMessages, localUsername }: SendPro
   }, [localMessages, selectedChannelId, effectiveActiveWorkspaceId, currentUser?.displayName, relayAgentName]);
 
   const effectiveChannelMessages = useMemo(() => {
-    const sourceMessages = usingRelayChannelMessages
-      ? relayMappedChannelMessages
-      : (channelMessages.length > 0 ? channelMessages : localChannelMessages);
+    if (usingRelayChannelMessages) {
+      // Prefer relay SDK messages; fall back to server-fetched messages when
+      // the relay hook returns empty (e.g. agent hasn't joined the channel yet).
+      if (relayMappedChannelMessages.length > 0) {
+        return sortChannelMessagesChronologically(relayMappedChannelMessages);
+      }
+      if (channelMessages.length > 0) {
+        return sortChannelMessagesChronologically(channelMessages);
+      }
+      return [];
+    }
+    const sourceMessages = channelMessages.length > 0 ? channelMessages : localChannelMessages;
     return sortChannelMessagesChronologically(sourceMessages);
   }, [usingRelayChannelMessages, relayMappedChannelMessages, channelMessages, localChannelMessages]);
 
@@ -252,7 +261,12 @@ export function SendProvider({ children, localMessages, localUsername }: SendPro
     if (isWorkspaceFeaturesEnabled && !effectiveActiveWorkspaceId) return;
 
     if (relayConfigured && selectedChannelId.startsWith('#')) {
-      setChannelMessages(relayMappedChannelMessages);
+      // When the relay SDK has messages, use them directly.
+      // Otherwise, keep any server-fetched messages we already have — do NOT
+      // overwrite them with the empty relay array on every re-render.
+      if (relayMappedChannelMessages.length > 0) {
+        setChannelMessages(relayMappedChannelMessages);
+      }
       setHasMoreMessages(false);
       setChannelUnreadState(undefined);
       setChannelsList(prev =>
@@ -260,6 +274,26 @@ export function SendProvider({ children, localMessages, localUsername }: SendPro
           c.id === selectedChannelId ? { ...c, unreadCount: 0, hasMentions: false } : c
         )
       );
+
+      // Fallback: when the relay SDK hook returns empty (e.g. dashboard agent
+      // hasn't joined the channel), fetch from the server API which uses the
+      // workspace API key and has full read access to all channels.
+      if (relayMappedChannelMessages.length === 0 && !relayMessagesState.loading && !fetchedChannelsRef.current.has(selectedChannelId)) {
+        const channelToFetch = selectedChannelId;
+        fetchedChannelsRef.current.add(channelToFetch);
+        (async () => {
+          try {
+            const { getMessages } = await import('../components/channels');
+            const response = await getMessages(effectiveActiveWorkspaceId || 'local', channelToFetch, { limit: 200 });
+            const sortedMessages = sortChannelMessagesChronologically(response.messages);
+            setChannelMessageMap(prev => ({ ...prev, [channelToFetch]: sortedMessages }));
+            setChannelMessages(sortedMessages);
+          } catch (err) {
+            console.error('Failed to fetch channel messages fallback:', err);
+            fetchedChannelsRef.current.delete(channelToFetch);
+          }
+        })();
+      }
       return;
     }