@agent-relay/dashboard 2.0.88 → 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/providers/MessageProvider.tsx

@@ -12,13 +12,11 @@
 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';
@@ -378,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
@@ -442,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,
@@ -467,9 +465,9 @@ 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 = getRelayDmParticipantName(participant);
           if (!name) continue;
@@ -491,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
@@ -500,12 +498,12 @@ 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) => {
@@ -546,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) => {
@@ -839,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