@mndrk/agx 2.0.19 → 2.0.21

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/hooks/useGroupChat.ts

@@ -1,7 +1,7 @@
 "use client";
 
 import { useState, useCallback, useRef } from "react";
-import type { GroupMessage, ChatEvent } from "@/lib/types";
+import type { GroupMessage } from "@/lib/types";
 
 export interface LogEntry {
   timestamp: number;
@@ -14,6 +14,10 @@ function buildThreadQuery(threadId: string): string {
   return `threadId=${encodeURIComponent(threadId)}`;
 }
 
+function buildLogsQuery(workspaceId: string): string {
+  return `workspaceId=${encodeURIComponent(workspaceId)}`;
+}
+
 export interface StreamingEntry {
   content: string;
   rootMessageId: string | null;
@@ -21,13 +25,7 @@ export interface StreamingEntry {
 
 export function useGroupChat(threadId: string | null) {
   const [messages, setMessages] = useState<GroupMessage[]>([]);
-  const [streaming, setStreaming] = useState<Record<string, StreamingEntry>>({});
-  const [activeStreams, setActiveStreams] = useState(0);
   const [logs, setLogs] = useState<LogEntry[]>([]);
-  const loading = activeStreams > 0;
-  const abortRefs = useRef<Set<AbortController>>(new Set());
-  // Map from rootMessageId to set of abort controllers for per-thread stop
-  const threadAbortRefs = useRef<Map<string, Set<AbortController>>>(new Map());
   const threadIdRef = useRef<string | null>(threadId);
   const prevThreadIdRef = useRef<string | null>(threadId);
 
@@ -37,11 +35,8 @@ export function useGroupChat(threadId: string | null) {
   // Reset state only when threadId actually changes (not on every render).
   if (prevThreadIdRef.current !== threadId) {
     prevThreadIdRef.current = threadId;
-    // These are safe to call during render in React 18+/19 because
-    // the state values haven't been read yet in this render cycle.
     setMessages([]);
     setLogs([]);
-    setStreaming({});
   }
 
   const loadHistory = useCallback(async (threadIdOverride?: string | null) => {
@@ -57,7 +52,7 @@ export function useGroupChat(threadId: string | null) {
     try {
       const [histRes, logsRes] = await Promise.all([
         fetch(`/api/history?${query}`),
-        fetch(`/api/logs?${query}`),
+        fetch(`/api/logs?${buildLogsQuery(activeThreadId)}`),
       ]);
 
       if (threadIdRef.current !== activeThreadId) {
@@ -83,7 +78,7 @@ export function useGroupChat(threadId: string | null) {
 
     await Promise.all([
       fetch(`/api/history?${query}`, { method: "DELETE" }),
-      fetch(`/api/logs?${query}`, { method: "DELETE" }),
+      fetch(`/api/logs?${buildLogsQuery(activeThreadId)}`, { method: "DELETE" }),
     ]);
 
     if (threadIdRef.current !== activeThreadId) {
@@ -102,7 +97,8 @@ export function useGroupChat(threadId: string | null) {
       rootMessageId?: string | null,
       attachmentIds?: string[],
       attachmentMetas?: import("@/lib/types").Attachment[],
-      activeParticipantIds?: string[]
+      activeParticipantIds?: string[],
+      projectSlug?: string
     ) => {
       const activeThreadId = threadIdOverride?.trim() || threadIdRef.current?.trim();
       if (!activeThreadId) {
@@ -110,7 +106,7 @@ export function useGroupChat(threadId: string | null) {
       }
 
       const now = Date.now();
-      const userMessageId = `user-${now}`;
+      const userMessageId = crypto.randomUUID();
       const userMsg: GroupMessage = {
         id: userMessageId,
         role: "user",
@@ -123,27 +119,9 @@ export function useGroupChat(threadId: string | null) {
         ...(attachmentMetas && attachmentMetas.length > 0 ? { attachments: attachmentMetas } : {}),
       };
       setMessages((prev) => [...prev, userMsg]);
-      setActiveStreams((n) => n + 1);
-
-      const controller = new AbortController();
-      abortRefs.current.add(controller);
-
-      const streamingPids = new Set<string>();
-      // For main chat messages (no explicit root), the user message itself is the root
-      // and all agent replies are children of it.
-      const agentRootId = rootMessageId || userMessageId;
-      // Streaming entries use the user message as root so the typing indicator
-      // renders inside the card that triggered it.
-      const streamingRootId = rootMessageId || userMessageId;
-
-      // Register per-thread abort controller
-      if (!threadAbortRefs.current.has(agentRootId)) {
-        threadAbortRefs.current.set(agentRootId, new Set());
-      }
-      threadAbortRefs.current.get(agentRootId)!.add(controller);
 
       try {
-        const res = await fetch("/api/chat", {
+        await fetch("/api/chat", {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({
@@ -154,145 +132,39 @@ export function useGroupChat(threadId: string | null) {
             rootMessageId: rootMessageId || undefined,
             attachmentIds: attachmentIds?.length ? attachmentIds : undefined,
             activeParticipantIds: Array.isArray(activeParticipantIds) ? activeParticipantIds : undefined,
+            projectSlug: projectSlug?.trim() || undefined,
           }),
-          signal: controller.signal,
         });
-
-        if (!res.ok || !res.body) {
-          return;
-        }
-
-        const reader = res.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-
-          for (const line of lines) {
-            if (!line.startsWith("data: ")) continue;
-            const json = line.slice(6).trim();
-            if (!json) continue;
-
-            try {
-              const event: ChatEvent = JSON.parse(json);
-
-              if (threadIdRef.current !== activeThreadId) {
-                continue;
-              }
-
-              if (event.type === "participant-thinking") {
-                streamingPids.add(event.participantId);
-                setStreaming((prev) => ({
-                  ...prev,
-                  [event.participantId]: { content: "", rootMessageId: streamingRootId },
-                }));
-              } else if (event.type === "participant-error") {
-                setStreaming((prev) => ({
-                  ...prev,
-                  [event.participantId]: {
-                    content: `[Error: ${event.error}]`,
-                    rootMessageId: streamingRootId,
-                  },
-                }));
-              } else if (event.type === "log") {
-                setLogs((prev) => [
-                  ...prev,
-                  {
-                    timestamp: Date.now(),
-                    participantId: event.participantId,
-                    stream: event.stream,
-                    line: event.line,
-                  },
-                ]);
-              } else if (event.type === "message-reactions") {
-                setMessages((prev) =>
-                  prev.map((msg) =>
-                    msg.id === event.messageId
-                      ? { ...msg, reactions: event.reactions }
-                      : msg
-                  )
-                );
-              } else if (event.type === "participant-end") {
-                const content = event.content || "";
-                if (content.trim()) {
-                  const assistantMsg: GroupMessage = {
-                    id: event.messageId || `${event.participantId}-${Date.now()}`,
-                    role: "assistant",
-                    participantId: event.participantId,
-                    content,
-                    timestamp: Date.now(),
-                    rootMessageId: agentRootId,
-                    parentMessageId: agentRootId,
-                    depth: 1,
-                  };
-                  setMessages((prev) => [...prev, assistantMsg]);
-                }
-                setStreaming((prev) => {
-                  const next = { ...prev };
-                  delete next[event.participantId];
-                  return next;
-                });
-              }
-            } catch {
-              // ignore malformed events
-            }
-          }
-        }
       } catch {
-        // aborted or network error
-      } finally {
-        abortRefs.current.delete(controller);
-        threadAbortRefs.current.get(agentRootId)?.delete(controller);
-        if (threadAbortRefs.current.get(agentRootId)?.size === 0) {
-          threadAbortRefs.current.delete(agentRootId);
-        }
-        setActiveStreams((n) => Math.max(0, n - 1));
-
-        if (threadIdRef.current === activeThreadId) {
-          const ownedIds = [...streamingPids];
-          setStreaming((prev) => {
-            const next = { ...prev };
-            for (const id of ownedIds) delete next[id];
-            return next;
-          });
-        }
+        // network error — message was already added optimistically
       }
+
+      return userMessageId;
     },
     []
   );
 
-  const stop = useCallback(() => {
-    for (const c of abortRefs.current) c.abort();
-    abortRefs.current.clear();
-    threadAbortRefs.current.clear();
-    setStreaming({});
-    setActiveStreams(0);
+  const stop = useCallback(async () => {
+    // Kill active agent processes via API
+    const tid = threadIdRef.current?.trim();
+    if (tid) {
+      try {
+        await fetch(`/api/processes?workspaceId=${encodeURIComponent(tid)}`, { method: "DELETE" });
+      } catch {
+        // ignore
+      }
+    }
   }, []);
 
-  const stopThread = useCallback((rootMessageId: string) => {
-    const controllers = threadAbortRefs.current.get(rootMessageId);
-    if (!controllers || controllers.size === 0) return;
-    for (const c of controllers) {
-      c.abort();
-      abortRefs.current.delete(c);
-    }
-    threadAbortRefs.current.delete(rootMessageId);
-    // Remove streaming entries for this thread
-    setStreaming((prev) => {
-      const next = { ...prev };
-      for (const [pid, entry] of Object.entries(next)) {
-        if (entry.rootMessageId === rootMessageId) delete next[pid];
+  const stopThread = useCallback(async (rootMessageId: string) => {
+    const tid = threadIdRef.current?.trim();
+    if (tid) {
+      try {
+        await fetch(`/api/processes?workspaceId=${encodeURIComponent(tid)}&threadId=${encodeURIComponent(rootMessageId)}`, { method: "DELETE" });
+      } catch {
+        // ignore
       }
-      return next;
-    });
-    // Decrement active streams for aborted controllers
-    setActiveStreams((n) => Math.max(0, n - controllers.size));
+    }
   }, []);
 
   const clearLogs = useCallback(async (threadIdOverride?: string | null) => {
@@ -302,7 +174,7 @@ export function useGroupChat(threadId: string | null) {
       return;
     }
 
-    await fetch(`/api/logs?${buildThreadQuery(activeThreadId)}`, { method: "DELETE" }).catch(() => {});
+    await fetch(`/api/logs?${buildLogsQuery(activeThreadId)}`, { method: "DELETE" }).catch(() => {});
 
     if (threadIdRef.current !== activeThreadId) {
       return;
@@ -314,8 +186,6 @@ export function useGroupChat(threadId: string | null) {
   return {
     messages,
     setMessages,
-    streaming,
-    loading,
     logs,
     sendMessage,
     loadHistory,

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/hooks/useMentionAutocomplete.ts

@@ -19,9 +19,16 @@ export interface MentionToken {
   isParallel: boolean;
 }
 
+export interface MentionProject {
+  id: string;
+  name: string;
+  slug: string;
+}
+
 export type MentionItem =
   | { kind: "agent"; participant: Participant; group: string }
-  | { kind: "team"; team: Team; group: string };
+  | { kind: "team"; team: Team; group: string }
+  | { kind: "project"; project: MentionProject; group: string };
 
 export type MentionSuggestion = MentionItem;
 
@@ -30,6 +37,8 @@ export interface UseMentionAutocompleteOptions {
   participants: Participant[];
   /** Teams for the current workspace */
   teams?: Team[];
+  /** Mentionable projects */
+  projects?: MentionProject[];
   /** Maximum number of suggestions to show */
   maxSuggestions?: number;
 }
@@ -141,7 +150,8 @@ export function filterSuggestions(
   participants: Participant[],
   query: string,
   maxSuggestions: number,
-  teams: Team[] = []
+  teams: Team[] = [],
+  projects: MentionProject[] = []
 ): MentionSuggestion[] {
   const lowerQuery = query.toLowerCase();
   const participantById = new Map(participants.map((p) => [p.id, p]));
@@ -180,8 +190,10 @@ export function filterSuggestions(
 
     // Show team + members if the team name matches OR any member matches
     if (teamScore !== null || matchingMembers.length > 0) {
-      // Always show the team itself as mentionable
-      result.push({ kind: "team", team, group: team.name });
+      // Only show the team entry if the team name itself matches the query
+      if (teamScore !== null) {
+        result.push({ kind: "team", team, group: team.name });
+      }
 
       // Show members — if query matches team name, show all members; otherwise only matching ones
       const membersToShow = teamScore !== null && lowerQuery
@@ -200,6 +212,17 @@ export function filterSuggestions(
   }
 
   // 3. Ungrouped agents (not in any visible team)
+  // 3. Projects
+  for (const project of projects) {
+    const projectName = project.name.toLowerCase();
+    const projectSlug = project.slug.toLowerCase();
+    const score = scoreMatch(projectName, projectSlug, lowerQuery);
+    if (score !== null) {
+      result.push({ kind: "project", project, group: "Projects" });
+    }
+  }
+
+  // 4. Ungrouped agents (not in any visible team)
   const ungrouped: { participant: Participant; score: number }[] = [];
   for (const p of participants) {
     if (teamedAgentIds.has(p.id)) continue;
@@ -218,6 +241,7 @@ export function filterSuggestions(
 export function useMentionAutocomplete({
   participants,
   teams = [],
+  projects = [],
   maxSuggestions = 6,
 }: UseMentionAutocompleteOptions): UseMentionAutocompleteReturn {
   const [token, setToken] = useState<MentionToken | null>(null);
@@ -228,8 +252,8 @@ export function useMentionAutocomplete({
   const query = token?.query ?? "";
 
   const filteredSuggestions = useMemo(() => {
-    return filterSuggestions(participants, query, maxSuggestions, teams);
-  }, [participants, query, maxSuggestions, teams]);
+    return filterSuggestions(participants, query, maxSuggestions, teams, projects);
+  }, [participants, query, maxSuggestions, teams, projects]);
 
   const updateTokenFromInput = useCallback((text: string, cursorPos: number) => {
     const newToken = detectMentionToken(text, cursorPos);
@@ -297,7 +321,12 @@ export function useMentionAutocomplete({
         return null;
       }
 
-      const name = suggestion.kind === "team" ? suggestion.team.name : suggestion.participant.name;
+      const name =
+        suggestion.kind === "team"
+          ? suggestion.team.name
+          : suggestion.kind === "project"
+            ? suggestion.project.name
+            : suggestion.participant.name;
       const atPrefix = token.isParallel ? "@@" : "@";
       const replacement = `${atPrefix}${name} `;
 

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/hooks/useProcessPolling.ts

@@ -0,0 +1,148 @@
+"use client";
+
+import { useState, useEffect, useRef, useCallback } from "react";
+import type { AgentProcessEntry } from "@/lib/agent-process-registry";
+import type { GroupMessage } from "@/lib/types";
+import type { StreamingEntry } from "./useGroupChat";
+
+/** Active process states that should show a typing indicator. */
+const ACTIVE_STATES = new Set(["spawning", "running"]);
+
+/**
+ * Polls `/api/processes` and `/api/history?since=` to drive both the
+ * "who's working" indicator and message delivery (replacing SSE).
+ */
+export function useProcessPolling(
+  scope: { workspaceId?: string | null; threadId?: string | null } | null,
+  options?: {
+    intervalMs?: number;
+    messages?: GroupMessage[];
+    setMessages?: React.Dispatch<React.SetStateAction<GroupMessage[]>>;
+  }
+) {
+  const intervalMs = options?.intervalMs ?? 3000;
+  const [activeAgents, setActiveAgents] = useState<Set<string>>(new Set());
+  const [processes, setProcesses] = useState<AgentProcessEntry[]>([]);
+  const [streaming, setStreaming] = useState<Record<string, StreamingEntry>>({});
+  const scopeRef = useRef(scope);
+  scopeRef.current = scope;
+  const messagesRef = useRef(options?.messages ?? []);
+  messagesRef.current = options?.messages ?? [];
+  const setMessagesRef = useRef(options?.setMessages);
+  setMessagesRef.current = options?.setMessages;
+  // Track the latest timestamp we've seen so far for delta fetching
+  const lastTimestampRef = useRef<number>(0);
+
+  // Reset lastTimestamp when messages change externally (e.g. full reload)
+  useEffect(() => {
+    const msgs = options?.messages ?? [];
+    if (msgs.length > 0) {
+      const maxTs = Math.max(...msgs.map((m) => m.timestamp));
+      if (maxTs > lastTimestampRef.current) {
+        lastTimestampRef.current = maxTs;
+      }
+    }
+  }, [options?.messages]);
+
+  const poll = useCallback(async () => {
+    const s = scopeRef.current;
+    if (!s) {
+      setActiveAgents(new Set());
+      setProcesses([]);
+      setStreaming({});
+      return;
+    }
+
+    let processUrl: string | null = null;
+    if (s.threadId) {
+      processUrl = `/api/processes?threadId=${encodeURIComponent(s.threadId)}`;
+    } else if (s.workspaceId) {
+      processUrl = `/api/processes?workspaceId=${encodeURIComponent(s.workspaceId)}`;
+    }
+
+    if (!processUrl) {
+      setActiveAgents(new Set());
+      setProcesses([]);
+      setStreaming({});
+      return;
+    }
+
+    try {
+      // Fetch processes and new messages in parallel
+      const historyThreadId = s.workspaceId || s.threadId;
+      const historyUrl = historyThreadId
+        ? `/api/history?threadId=${encodeURIComponent(historyThreadId)}&since=${lastTimestampRef.current}`
+        : null;
+
+      const fetches: Promise<Response>[] = [fetch(processUrl)];
+      if (historyUrl) fetches.push(fetch(historyUrl));
+
+      const [processRes, historyRes] = await Promise.all(fetches);
+
+      // Stale check
+      const current = scopeRef.current;
+      if (current?.threadId !== s.threadId || current?.workspaceId !== s.workspaceId) return;
+
+      // Update processes
+      if (processRes.ok) {
+        const entries: AgentProcessEntry[] = await processRes.json();
+        setProcesses(entries);
+        const activeIds = new Set(
+          entries.filter((e) => ACTIVE_STATES.has(e.state)).map((e) => e.agentId)
+        );
+        setActiveAgents(activeIds);
+
+        // Build streaming indicators from active processes
+        const newStreaming: Record<string, StreamingEntry> = {};
+        for (const proc of entries) {
+          if (!ACTIVE_STATES.has(proc.state)) continue;
+          const triggerMsg = messagesRef.current.find((m) => m.id === proc.sinceMessageId);
+          const rootId = triggerMsg?.rootMessageId ?? proc.sinceMessageId;
+          newStreaming[proc.agentId] = { content: "", rootMessageId: rootId };
+        }
+        setStreaming(newStreaming);
+      }
+
+      // Merge new messages
+      if (historyRes?.ok && setMessagesRef.current) {
+        const newMessages: GroupMessage[] = await historyRes.json();
+        if (newMessages.length > 0) {
+          const maxTs = Math.max(...newMessages.map((m) => m.timestamp));
+          if (maxTs > lastTimestampRef.current) {
+            lastTimestampRef.current = maxTs;
+          }
+          setMessagesRef.current((prev) => {
+            const existingIds = new Set(prev.map((m) => m.id));
+            const toAdd = newMessages.filter((m) => !existingIds.has(m.id));
+            // Also update any existing messages (e.g. reactions changed)
+            const updated = prev.map((existing) => {
+              const fresh = newMessages.find((m) => m.id === existing.id);
+              return fresh ?? existing;
+            });
+            if (toAdd.length === 0) return updated;
+            return [...updated, ...toAdd].sort((a, b) => a.timestamp - b.timestamp);
+          });
+        }
+      }
+    } catch {
+      // network error — keep previous state
+    }
+  }, []);
+
+  const key = scope?.threadId || scope?.workspaceId || null;
+
+  useEffect(() => {
+    if (!key) {
+      setActiveAgents(new Set());
+      setProcesses([]);
+      setStreaming({});
+      return;
+    }
+
+    poll();
+    const id = setInterval(poll, intervalMs);
+    return () => clearInterval(id);
+  }, [key, intervalMs, poll]);
+
+  return { activeAgents, processes, streaming, poll };
+}

package/cloud-runtime/standalone/Projects/Agents/agx-cloud/hooks/useTasks.ts

@@ -157,54 +157,12 @@ export function useTasks(options: UseTasksOptions = {}) {
     };
   }, [realtimeEnabled, realtimeDisabled]);
 
-  // SSE stream for auto-refreshing tasks
+  // Poll for task updates (replaces SSE stream)
   useEffect(() => {
     if (realtimeDisabled) return;
     if (!realtimeEnabled) return;
-    if (typeof EventSource === "undefined") return;
-
-    let eventSource: EventSource | null = null;
-
-    try {
-      eventSource = new EventSource("/api/tasks/stream");
-    } catch (err) {
-      console.error("Failed to open tasks stream:", err);
-      return;
-    }
-
-    const handleMessage = (event: MessageEvent) => {
-      try {
-        const payload = JSON.parse(event.data);
-        if (!payload?.type || payload.type !== "UPDATE" || !payload.task) {
-          return;
-        }
-        const nextTask = payload.task as Task;
-        setTasks((prev) => {
-          const exists = prev.some((task) => task.id === nextTask.id);
-          const previous = prev.find((task) => task.id === nextTask.id);
-          const hydrated = withDependsOnFallback(nextTask, previous);
-          if (!exists) {
-            return [hydrated, ...prev];
-          }
-          return prev.map((task) => (task.id === nextTask.id ? hydrated : task));
-        });
-      } catch {
-        // ignore malformed data
-      }
-    };
-
-    const handleError = () => {
-      fetchTasks();
-    };
-
-    eventSource.addEventListener("message", handleMessage);
-    eventSource.addEventListener("error", handleError);
-
-    return () => {
-      eventSource?.removeEventListener("message", handleMessage);
-      eventSource?.removeEventListener("error", handleError);
-      eventSource?.close();
-    };
+    const interval = setInterval(fetchTasks, 3000);
+    return () => clearInterval(interval);
   }, [realtimeEnabled, realtimeDisabled, fetchTasks]);
 
   const createTask = useCallback(async (
@@ -597,55 +555,20 @@ export function useTaskTerminalStream(
     if (enabled) fetchOutput();
   }, [enabled, fetchOutput, taskId]);
 
+  // Poll for new logs (replaces SSE stream)
   useEffect(() => {
     if (!taskId) return;
     if (!enabled) return;
 
-    const eventSource = new EventSource(`/api/logs/stream?taskId=${taskId}`);
-    const backfill = () => {
-      const now = Date.now();
-      // Avoid hammering `/api/tasks/:id/logs` if the SSE connection is noisy/flaky.
-      if (now - backfillCooldownRef.current < 5000) return;
-      backfillCooldownRef.current = now;
-      fetchOutput(true);
-    };
-
-    eventSource.onopen = () => {
-      // Catch logs emitted before the SSE connection is fully established.
-      backfill();
-    };
-    eventSource.onmessage = (event) => {
-      try {
-        const message = JSON.parse(event.data);
-        if (message?.type !== "log" || !message.log) return;
-        const log = message.log as TaskLog;
-        const chunk = formatLog(log);
-        if (!chunk) return;
-        setOutput((prev) => prev + chunk);
-        setIsStreaming(true);
-        if (streamTimeoutRef.current) {
-          clearTimeout(streamTimeoutRef.current);
-        }
-        streamTimeoutRef.current = setTimeout(() => {
-          setIsStreaming(false);
-        }, 5000);
-      } catch {
-        // ignore malformed events
-      }
-    };
-    eventSource.onerror = () => {
-      // EventSource auto-reconnects; do an occasional backfill to avoid gaps.
-      backfill();
-    };
-
+    const interval = setInterval(() => fetchOutput(true), 2000);
     return () => {
-      eventSource.close();
+      clearInterval(interval);
       if (streamTimeoutRef.current) {
         clearTimeout(streamTimeoutRef.current);
         streamTimeoutRef.current = null;
       }
     };
-  }, [enabled, fetchOutput, formatLog, taskId]);
+  }, [enabled, fetchOutput, taskId]);
 
   return { output, isLoading, isStreaming };
 }