@cognizant-ai-lab/ui-common 1.3.3

package/dist/components/MultiAgentAccelerator/ThoughtBubbleOverlay.js

@@ -0,0 +1,466 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { styled } from "@mui/material";
+import { Fragment, useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { ChatMessageType } from "../../generated/neuro-san/NeuroSanClient.js";
+// Note: Removed BubblePosition interface - no longer needed for right-side positioning
+// #endregion: Types
+// #region: Constants
+const BUBBLE_DISTANCE_FROM_RIGHT_EDGE = 20; // Fixed distance from right edge
+const BUBBLE_HEIGHT = 78;
+const BUBBLE_HEIGHT_PLUS_SPACING = BUBBLE_HEIGHT + 10;
+const BUBBLE_STACK_OFFSET_TOP = 70;
+const BUBBLE_WIDTH = 260;
+const LAYOUT_BUBBLES_ANIMATION_DELAY_MS = 120; // Delay between each bubble's animation start
+// Constants for connecting lines
+const CONNECTING_LINE_OPACITY = 0.3; // Semi-transparent connecting line
+// #endregion: Constants
+// #region: Styled Components
+const OverlayContainer = styled("div")({
+    position: "absolute",
+    left: 0,
+    top: 0,
+    width: "100%",
+    height: "100%",
+    pointerEvents: "none",
+    zIndex: 10000,
+});
+const ThoughtBubble = styled("div", {
+    shouldForwardProp: (prop) => !["isHovered", "isTruncated", "animationDelay", "bubbleIndex", "isVisible", "isExiting"].includes(prop),
+})(({ theme, isHovered, isTruncated, animationDelay, bubbleIndex, isVisible = true, isExiting = false }) => ({
+    // Colors / theme
+    // TODO: Add dark mode support? For now both light and dark mode use the same bubble style and look fine.
+    background: "linear-gradient(135deg, rgba(255,255,255,0.98) 0%, rgba(250,250,250,0.95) 100%)",
+    border: "var(--bs-border-width) var(--bs-border-style) var(--bs-border-color)",
+    borderRadius: "var(--bs-border-radius-lg)",
+    color: "var(--bs-primary)",
+    fontFamily: theme.typography.fontFamily, // TODO: Easy to pull from theme. Rest we need to revisit.
+    fontSize: "var(--bs-body-font-size-extra-small)",
+    fontWeight: "var(--bs-body-font-weight)",
+    padding: "10px 14px",
+    // Positioning - restore original right-side layout
+    position: "absolute",
+    right: BUBBLE_DISTANCE_FROM_RIGHT_EDGE,
+    top: BUBBLE_STACK_OFFSET_TOP + bubbleIndex * BUBBLE_HEIGHT_PLUS_SPACING, // Stack vertically with spacing
+    transform: "none",
+    // Dimensions
+    // Only expand height when hovered AND text is truncated
+    height: isHovered && isTruncated ? BUBBLE_HEIGHT : "auto",
+    maxHeight: BUBBLE_HEIGHT, // Max 3 lines always
+    minHeight: "auto", // Let height adjust to content
+    minWidth: "100px",
+    width: BUBBLE_WIDTH,
+    // Other styles
+    boxShadow: isHovered
+        ? "0 4px 20px rgba(0,0,0,0.12), 0 2px 6px rgba(0,0,0,0.08)"
+        : "0 2px 12px rgba(0,0,0,0.06), 0 1px 3px rgba(0,0,0,0.08)",
+    zIndex: isHovered ? 10002 : 10000,
+    lineHeight: 1.4,
+    backdropFilter: "blur(12px)",
+    WebkitBackdropFilter: "blur(12px)",
+    transition: `box-shadow 0.2s cubic-bezier(0.4, 0, 0.2, 1),
+            z-index 0.15s cubic-bezier(0.4, 0, 0.2, 1),
+            transform 0.15s cubic-bezier(0.4, 0, 0.2, 1)`,
+    cursor: isTruncated ? "pointer" : "default",
+    userSelect: isHovered && isTruncated ? "text" : "none",
+    animation: isExiting
+        ? "fadeOutDown 0.4s cubic-bezier(0.4, 0, 0.1, 1) both"
+        : `fadeInUp 0.6s cubic-bezier(0.2, 0, 0.2, 1) ${animationDelay}ms both`,
+    opacity: isVisible ? (isExiting ? 0 : 1) : 0,
+    pointerEvents: "auto",
+    wordBreak: "break-word",
+    overflow: "hidden", // Always hide overflow
+    // Enable vertical scrolling only when hovered and truncated
+    overflowY: isHovered && isTruncated ? "auto" : "hidden",
+    whiteSpace: "normal",
+}));
+const TruncatedText = styled("div")(({ isHovered, isTruncated }) => ({
+    display: isHovered && isTruncated ? "block" : "-webkit-box",
+    WebkitLineClamp: isHovered && isTruncated ? "unset" : 3,
+    WebkitBoxOrient: isHovered && isTruncated ? "unset" : "vertical",
+    overflow: "hidden",
+    textOverflow: "ellipsis",
+}));
+// #endregion: Styled Components
+export const ThoughtBubbleOverlay = ({ nodes, edges, showThoughtBubbles = true, isStreaming = false, onBubbleHoverChange, }) => {
+    // hoveredBubbleId: id of currently hovered bubble (or null)
+    const [hoveredBubbleId, setHoveredBubbleId] = useState(null);
+    // truncatedBubbles: set of edge ids whose text overflows the collapsed box
+    const [truncatedBubbles, setTruncatedBubbles] = useState(new Set());
+    // bubbleStates: track animation state of each bubble and when it's entered (used to delay line rendering
+    // until the bubble's entrance animation delay has passed)
+    const [bubbleStates, setBubbleStates] = useState(new Map());
+    // hoverTimeoutRef: used to debounce clearing of hovered state on mouse leave
+    const hoverTimeoutRef = useRef(null);
+    // textRefs: mapping of edge id -> DOM node for measuring scrollHeight/clientHeight
+    const textRefs = useRef(new Map());
+    // animationTimeouts: track timeouts for bubble removal
+    const animationTimeouts = useRef(new Map());
+    // Refs for SVG lines to update without re-rendering
+    const lineRefs = useRef(new Map());
+    // Ref to the overlay container so we can observe layout changes more precisely
+    const overlayRef = useRef(null);
+    // rAF ref for scheduling post-paint updates
+    const rafRef = useRef(null);
+    const mountedRef = useRef(true);
+    // Filter edges with meaningful text (memoized to prevent infinite re-renders)
+    const thoughtBubbleEdges = useMemo(() => edges.filter((e) => {
+        if (typeof e?.data?.text !== "string") {
+            return false;
+        }
+        return e.data.text;
+    }), [edges]);
+    // Find frontman node (depth === 0, similar to isFrontman logic in AgentNode.tsx)
+    const frontmanNode = useMemo(() => {
+        if (!nodes || !Array.isArray(nodes) || nodes.length === 0)
+            return null;
+        return nodes.find((n) => n.data?.depth === 0);
+    }, [nodes]);
+    // Handle bubble lifecycle (appear/disappear animations)
+    useEffect(() => {
+        const currentEdgeIds = new Set(thoughtBubbleEdges.map((e) => e.id));
+        const previousBubbleIds = new Set(bubbleStates.keys());
+        // Find new bubbles that should appear
+        const newBubbles = thoughtBubbleEdges.filter((e) => !previousBubbleIds.has(e.id));
+        // Find bubbles that should disappear
+        const removingBubbles = Array.from(previousBubbleIds).filter((id) => !currentEdgeIds.has(id));
+        setBubbleStates((prev) => {
+            const newState = new Map(prev);
+            // Add new bubbles in entering state. Record when they entered so we can delay showing
+            // connecting lines until the bubble's entrance animation delay.
+            const now = Date.now();
+            newBubbles.forEach((edge) => {
+                newState.set(edge.id, { isVisible: true, isExiting: false, enteredAt: now });
+            });
+            // Mark removing bubbles as exiting
+            removingBubbles.forEach((id) => {
+                const currentState = newState.get(id);
+                if (currentState) {
+                    newState.set(id, { ...currentState, isExiting: true });
+                    // Clear any existing timeout
+                    const existingTimeout = animationTimeouts.current.get(id);
+                    if (existingTimeout) {
+                        clearTimeout(existingTimeout);
+                    }
+                    // Schedule removal after exit animation
+                    const timeout = window.setTimeout(() => {
+                        setBubbleStates((s) => {
+                            const updatedState = new Map(s);
+                            updatedState.delete(id);
+                            return updatedState;
+                        });
+                        animationTimeouts.current.delete(id);
+                    }, 400); // Match exit animation duration (0.4s)
+                    animationTimeouts.current.set(id, timeout);
+                }
+            });
+            return newState;
+        });
+    }, [thoughtBubbleEdges]);
+    // Cleanup timeouts on unmount
+    useEffect(() => {
+        return () => {
+            animationTimeouts.current.forEach((timeout) => clearTimeout(timeout));
+            animationTimeouts.current.clear();
+        };
+    }, []);
+    // Sort edges to prioritize frontman's edges first
+    const sortedEdges = useMemo(() => {
+        if (!frontmanNode)
+            return thoughtBubbleEdges;
+        const frontmanEdges = thoughtBubbleEdges.filter((e) => e.source === frontmanNode.id || e.target === frontmanNode.id);
+        const otherEdges = thoughtBubbleEdges.filter((e) => e.source !== frontmanNode.id && e.target !== frontmanNode.id);
+        return [...frontmanEdges, ...otherEdges];
+    }, [thoughtBubbleEdges, frontmanNode]);
+    // Determine which agents are currently "active" using the same logic as AgentNode.
+    // An agent is active if any current conversation includes that agent's id.
+    const activeAgentIds = useMemo(() => {
+        const set = new Set();
+        if (!nodes || !Array.isArray(nodes))
+            return set;
+        for (const node of nodes) {
+            const getConversations = node.data?.getConversations;
+            if (typeof getConversations === "function") {
+                const convs = getConversations();
+                if (Array.isArray(convs)) {
+                    const hasSelf = convs.some((conv) => Boolean(conv?.agents?.has?.(node.id)));
+                    if (hasSelf) {
+                        set.add(node.id);
+                    }
+                }
+            }
+        }
+        return set;
+    }, [nodes]);
+    // Check truncation after render, but only when nothing is hovered
+    // (to avoid measuring expanded bubbles)
+    useEffect(() => {
+        // Skip truncation check if any bubble is hovered
+        if (hoveredBubbleId !== null)
+            return;
+        const newTruncated = new Set();
+        textRefs.current.forEach((element, edgeId) => {
+            // If scrollHeight > clientHeight then the content overflows (truncated)
+            if (element && element.scrollHeight > element.clientHeight) {
+                newTruncated.add(edgeId);
+            }
+        });
+        setTruncatedBubbles((prev) => {
+            // Only update if something changed
+            if (prev.size !== newTruncated.size)
+                return newTruncated;
+            // Check if the contents are the same
+            for (const id of newTruncated) {
+                if (!prev.has(id))
+                    return newTruncated;
+            }
+            return prev;
+        });
+    }, [hoveredBubbleId, sortedEdges, textRefs]); // Re-check when edges change or hover state changes
+    // Notify parent when hover state changes
+    const handleHoverChange = useCallback((bubbleId) => {
+        // Clear any pending timeout
+        if (hoverTimeoutRef.current) {
+            clearTimeout(hoverTimeoutRef.current);
+            hoverTimeoutRef.current = null;
+        }
+        if (bubbleId === null) {
+            // Delay clearing the hover state when mouse leaves to prevent accidental unhover
+            // "window." to satisfy typescript
+            hoverTimeoutRef.current = window.setTimeout(() => {
+                setHoveredBubbleId(null);
+                if (onBubbleHoverChange) {
+                    onBubbleHoverChange(null);
+                }
+            }, 200); // 200ms delay before clearing hover
+        }
+        else {
+            // Immediately set hover when mouse enters
+            setHoveredBubbleId(bubbleId);
+            if (onBubbleHoverChange) {
+                onBubbleHoverChange(bubbleId);
+            }
+        }
+    }, [onBubbleHoverChange]);
+    // Calculate line coordinates - measurement only. Can be called from rAF/update loop.
+    const calculateLineCoordinates = useCallback((edge, bubbleIndex, agentRectCache) => {
+        // Skip HUMAN conversation types - no lines for human bubbles
+        if (edge.data?.type === ChatMessageType.HUMAN) {
+            return null;
+        }
+        // Get actual bubble DOM position (fresh every time)
+        const bubbleElement = document.querySelector(`[data-bubble-id="${CSS.escape(edge.id)}"]`);
+        let bubbleX;
+        let bubbleY;
+        if (bubbleElement) {
+            const bubbleRect = bubbleElement.getBoundingClientRect();
+            // Use the left edge center of the bubble (where line should start)
+            bubbleX = Math.round(bubbleRect.left);
+            bubbleY = Math.round(bubbleRect.top + bubbleRect.height / 2);
+        }
+        else {
+            // Fallback: calculate approximate viewport position
+            bubbleX = window.innerWidth - BUBBLE_DISTANCE_FROM_RIGHT_EDGE - BUBBLE_WIDTH;
+            bubbleY = BUBBLE_STACK_OFFSET_TOP + bubbleIndex * BUBBLE_HEIGHT_PLUS_SPACING + BUBBLE_HEIGHT / 2;
+        }
+        // Determine which agents to point to. If the edge supplies an `agents` array in
+        // data (provided by AgentFlow), use that. Otherwise fallback to the explicit
+        // edge.target/edge.source pair (single target).
+        let agentIds = Array.isArray(edge.data?.agents)
+            ? edge.data?.agents
+            : [edge.target || edge.source].filter(Boolean);
+        if (agentIds.length === 0)
+            return null;
+        // Filter out any agents that are not currently active (we only draw lines to active agents).
+        // Always apply filtering based on the activeAgentIds set.
+        agentIds = agentIds.filter((id) => activeAgentIds.has(id));
+        if (agentIds.length === 0)
+            return null;
+        // For each agent id, find its visual element and calculate mid-point.
+        const results = [];
+        for (const agentId of agentIds) {
+            // Find the agent element by its data-id attribute
+            const agentElements = document.querySelectorAll(`[data-id="${CSS.escape(agentId)}"].react-flow__node`);
+            const foundAgentEl = agentElements?.[0] || null;
+            let agentX = 0;
+            let agentY = 0;
+            if (foundAgentEl) {
+                // Prefer the cached rect when present; otherwise compute and cache it.
+                const cachedRect = agentRectCache?.get(agentId);
+                const containerRect = cachedRect ?? foundAgentEl.getBoundingClientRect();
+                if (cachedRect == null) {
+                    agentRectCache?.set(agentId, containerRect);
+                }
+                if (containerRect) {
+                    agentX = Math.round(containerRect.left + containerRect.width / 2);
+                    agentY = Math.round(containerRect.top + containerRect.height / 2);
+                }
+            }
+            results.push({ x1: bubbleX, y1: bubbleY, x2: agentX, y2: agentY, targetAgent: agentId });
+        }
+        return results;
+    }, [activeAgentIds]);
+    // Get all bubbles to render (including exiting ones)
+    const allBubbleIds = Array.from(bubbleStates.keys());
+    // Memoize the resolved edges so updateAllLines (and effects depending on it)
+    // doesn't get recreated on every render unnecessarily.
+    const renderableBubbles = useMemo(() => allBubbleIds
+        .map((id) => sortedEdges.find((e) => e.id === id) ?? edges.find((e) => e.id === id))
+        .filter((edge) => edge !== undefined), [allBubbleIds, sortedEdges, edges]);
+    // Update all SVG lines imperatively after paint. This reads DOM (getBoundingClientRect)
+    // and writes attributes on existing <line> elements stored in `lineRefs`.
+    const updateAllLines = useCallback(() => {
+        try {
+            renderableBubbles.forEach((edge, index) => {
+                const bubbleState = bubbleStates.get(edge.id) || { isVisible: true, isExiting: false, enteredAt: 0 };
+                if (!bubbleState.isVisible || bubbleState.isExiting)
+                    return;
+                // Respect the entrance animation delay gating (lines appear only after bubble start)
+                const elapsed = Date.now() - (bubbleState?.enteredAt ?? 0);
+                const animationDelay = index * LAYOUT_BUBBLES_ANIMATION_DELAY_MS;
+                if (elapsed < animationDelay)
+                    return;
+                const coordsArray = calculateLineCoordinates(edge, index);
+                if (!coordsArray || coordsArray.length === 0)
+                    return;
+                for (const coords of coordsArray) {
+                    const lineKey = `${edge.id}-${coords.targetAgent}`;
+                    const lineEl = lineRefs.current.get(lineKey);
+                    if (lineEl) {
+                        // Update attributes imperatively
+                        lineEl.setAttribute("x1", String(coords.x1));
+                        lineEl.setAttribute("y1", String(coords.y1));
+                        lineEl.setAttribute("x2", String(coords.x2));
+                        lineEl.setAttribute("y2", String(coords.y2));
+                    }
+                }
+            });
+        }
+        catch (err) {
+            // Guard against unexpected DOM errors during measurement
+            // Do not throw to avoid breaking the app
+            console.debug("ThoughtBubbleOverlay: updateAllLines error", err);
+        }
+    }, [renderableBubbles, bubbleStates, calculateLineCoordinates]);
+    // Schedule post-paint updates with rAF and ResizeObserver. Also optionally run a
+    // continuous loop while `isStreaming` is true to keep lines in sync during streaming.
+    useEffect(() => {
+        mountedRef.current = true;
+        const schedule = () => {
+            if (rafRef.current != null)
+                return;
+            rafRef.current = requestAnimationFrame(() => {
+                rafRef.current = null;
+                if (!mountedRef.current)
+                    return;
+                updateAllLines();
+            });
+        };
+        // Initial schedule
+        schedule();
+        // Resize observer to detect layout/size changes
+        const ro = new ResizeObserver(() => schedule());
+        try {
+            if (overlayRef.current)
+                ro.observe(overlayRef.current);
+            else
+                ro.observe(document.body);
+        }
+        catch {
+            // Ignore if RO observation fails in some test environments
+        }
+        // Window resize
+        window.addEventListener("resize", schedule);
+        // If streaming, run a continuous rAF loop to keep up with frequent layout updates
+        let streamingRaf = null;
+        const startStreamingLoop = () => {
+            if (streamingRaf != null)
+                return;
+            const loop = () => {
+                updateAllLines();
+                streamingRaf = requestAnimationFrame(loop);
+            };
+            streamingRaf = requestAnimationFrame(loop);
+        };
+        const stopStreamingLoop = () => {
+            if (streamingRaf != null) {
+                cancelAnimationFrame(streamingRaf);
+                streamingRaf = null;
+            }
+        };
+        if (isStreaming)
+            startStreamingLoop();
+        return () => {
+            mountedRef.current = false;
+            if (rafRef.current != null)
+                cancelAnimationFrame(rafRef.current);
+            ro.disconnect();
+            window.removeEventListener("resize", schedule);
+            stopStreamingLoop();
+        };
+    }, [updateAllLines, isStreaming]);
+    // Don't render anything if thought bubbles are disabled
+    // This check is placed after all hooks so hook ordering stays consistent across renders.
+    if (!showThoughtBubbles)
+        return null;
+    return (_jsxs(OverlayContainer, { children: [_jsx("svg", { style: {
+                    position: "fixed",
+                    left: 0,
+                    top: 0,
+                    width: "100vw",
+                    height: "100vh",
+                    pointerEvents: "none",
+                    zIndex: 9998,
+                    opacity: 1,
+                }, children: renderableBubbles.map((edge, index) => {
+                    // Per-bubble staggered animation delay in milliseconds (for line animations)
+                    const animationDelay = index * LAYOUT_BUBBLES_ANIMATION_DELAY_MS;
+                    const bubbleState = bubbleStates.get(edge.id) || { isVisible: true, isExiting: false, enteredAt: 0 };
+                    if (!bubbleState.isVisible)
+                        return null;
+                    // Only render lines after the bubble's entrance animation delay has elapsed.
+                    const elapsed = Date.now() - (bubbleState.enteredAt || 0);
+                    const shouldShowLines = elapsed >= animationDelay;
+                    if (!shouldShowLines)
+                        return null;
+                    // Calculate fresh coordinates for this line (may return multiple targets)
+                    const coordsArray = calculateLineCoordinates(edge, index);
+                    if (!coordsArray || coordsArray.length === 0)
+                        return null;
+                    return (_jsx("g", { children: coordsArray.map((coords) => {
+                            const lineKey = `${edge.id}-${coords.targetAgent}`;
+                            return (_jsx("line", { ref: (el) => {
+                                    if (el) {
+                                        lineRefs.current.set(lineKey, el);
+                                    }
+                                    else {
+                                        lineRefs.current.delete(lineKey);
+                                    }
+                                }, x1: coords.x1, y1: coords.y1, x2: coords.x2, y2: coords.y2, stroke: "var(--thought-bubble-line-color)", strokeWidth: "3", strokeDasharray: "3,3", style: {
+                                    opacity: bubbleState.isExiting ? 0 : CONNECTING_LINE_OPACITY,
+                                    transition: (() => {
+                                        const duration = bubbleState.isExiting ? 400 : 600;
+                                        const delay = bubbleState.isExiting ? 0 : animationDelay;
+                                        return `opacity ${duration}ms cubic-bezier(0.2, 0, 0.2, 1) ${delay}ms`;
+                                    })(),
+                                } }, `line-${lineKey}`));
+                        }) }, `line-group-${edge.id}`));
+                }) }), renderableBubbles.map((edge, index) => {
+                const text = edge.data?.text;
+                if (!text)
+                    return null;
+                // Per-bubble staggered animation delay in milliseconds
+                const animationDelay = index * LAYOUT_BUBBLES_ANIMATION_DELAY_MS;
+                const isHovered = hoveredBubbleId === edge.id;
+                const isTruncated = truncatedBubbles.has(edge.id);
+                const bubbleState = bubbleStates.get(edge.id) || { isVisible: true, isExiting: false };
+                return (_jsx(Fragment, { children: _jsx(ThoughtBubble, { "data-bubble-id": edge.id, isHovered: isHovered, isTruncated: isTruncated, animationDelay: animationDelay, bubbleIndex: index, isVisible: bubbleState.isVisible, isExiting: bubbleState.isExiting, onMouseEnter: () => handleHoverChange(edge.id), onMouseLeave: () => handleHoverChange(null), children: _jsx(TruncatedText, { isHovered: isHovered, isTruncated: isTruncated, ref: (el) => {
+                                // Store/remove this text node in `textRefs` for truncation checks.
+                                if (el) {
+                                    textRefs.current.set(edge.id, el);
+                                }
+                                else {
+                                    textRefs.current.delete(edge.id);
+                                }
+                            }, children: text }) }) }, edge.id));
+            })] }));
+};

package/dist/components/MultiAgentAccelerator/const.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_FRONTMAN_X_POS = 150;
+export declare const DEFAULT_FRONTMAN_Y_POS = 450;
+export declare const BASE_RADIUS = 100;
+export declare const LEVEL_SPACING = 150;
+export declare const BACKGROUND_COLORS: string[];
+export declare const BACKGROUND_COLORS_DARK_IDX = 6;
+export declare const HEATMAP_COLORS: string[];

package/dist/components/MultiAgentAccelerator/const.js

@@ -0,0 +1,39 @@
+/*
+Copyright 2025 Cognizant Technology Solutions Corp, www.cognizant.com.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export const DEFAULT_FRONTMAN_X_POS = 150;
+export const DEFAULT_FRONTMAN_Y_POS = 450;
+// Minimum distance from center
+export const BASE_RADIUS = 100;
+// Distance between depth levels
+export const LEVEL_SPACING = 150;
+// Palette for progressive coloring of nodes based on depth
+export const BACKGROUND_COLORS = [
+    "#f7fbff",
+    "#deebf7",
+    "#c6dbef",
+    "#9ecae1",
+    "#6baed6",
+    "#4292c6",
+    "#2171b5",
+    "#08519c",
+    "#08306b",
+    "#041c45",
+];
+// Zero-based index of the one where colors start to get dark. Used for displaying contrasting text colors.
+export const BACKGROUND_COLORS_DARK_IDX = 6; // Somewhat subjective
+// Palette for heatmap coloring of nodes
+// For now, use same palette as background colors
+export const HEATMAP_COLORS = BACKGROUND_COLORS;

package/dist/const.d.ts

@@ -0,0 +1,10 @@
+export declare const LOGO: string;
+export declare const NEURO_SAN_UI_VERSION: string;
+export declare const CONTACT_US_CONFIRMATION_DIALOG_TITLE = "Contact Us";
+export declare const CONTACT_US_CONFIRMATION_DIALOG_TEXT: string;
+/**
+ * The default user image to use when the user does not have a profile picture.
+ */
+export declare const DEFAULT_USER_IMAGE = "https://www.gravatar.com/avatar/?d=mp";
+export declare const authenticationEnabled: () => boolean;
+export declare const DEFAULT_NEURO_SAN_SERVER_URL = "https://neuro-san-dev.decisionai.ml";

package/dist/const.js

@@ -0,0 +1,30 @@
+/*
+Copyright 2025 Cognizant Technology Solutions Corp, www.cognizant.com.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+// Name to use for application
+export const LOGO = "Neuro® AI";
+export const NEURO_SAN_UI_VERSION = process.env["NEXT_PUBLIC_NEURO_SAN_UI_VERSION"] ?? "Unknown Version";
+export const CONTACT_US_CONFIRMATION_DIALOG_TITLE = "Contact Us";
+export const CONTACT_US_CONFIRMATION_DIALOG_TEXT = "Would you like to send the Cognizant Neuro AI support team an email? " +
+    "You will need to have an email client installed on your device in order " +
+    "to continue. If you don't have an email client, you can still contact us at " +
+    "NeuroAiSupport@cognizant.com using a web based email client.";
+/**
+ * The default user image to use when the user does not have a profile picture.
+ */
+export const DEFAULT_USER_IMAGE = "https://www.gravatar.com/avatar/?d=mp";
+export const authenticationEnabled = () => process.env["NEXT_PUBLIC_ENABLE_AUTHENTICATION"] !== "false";
+// Default "dev URL" for NeuroSan server, to allow for "zero config" execution.
+export const DEFAULT_NEURO_SAN_SERVER_URL = "https://neuro-san-dev.decisionai.ml";

package/dist/controller/agent/Agent.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Controller module for interacting with the Agent LLM API.
+ */
+import { ChatContext, ChatResponse, ConnectivityResponse, FunctionResponse } from "../../generated/neuro-san/NeuroSanClient.js";
+export interface TestConnectionResult {
+    readonly success: boolean;
+    readonly status?: string;
+    readonly version?: string;
+}
+/**
+ * Test connection for a neuro-san server.
+ * @param url The neuro-san server URL.
+ * @returns A boolean indicating whether the connection was successful.
+ */
+export declare function testConnection(url: string): Promise<TestConnectionResult>;
+/**
+ * Get the list of available agent networks from the concierge service.
+ * @param url The neuro-san server URL
+ * @returns A promise that resolves to an array of agent network names.
+ */
+export declare function getAgentNetworks(url: string): Promise<string[]>;
+/**
+ * Send a chat query to the Agent LLM API. This opens a session with the agent network..
+ * @param url The neuro-san server URL
+ * @param signal The AbortSignal to use for the request. Used to cancel the request on user demand
+ * @param userInput The user input to send to the agent.
+ * In practice this "input" will actually be the output from one of the previous agents such as the data generator
+ * or scoping agent.
+ * @param targetAgent The target agent to send the request to. See CombinedAgentType for the list of available agents.
+ * @param callback The callback function to be called when a chunk of data is received from the server.
+ * @param chatContext "Opaque" conversation context for maintaining conversation state with the server. Neuro-san
+ * agents do not use ChatHistory directly, but rather, ChatContext, which is a collection of ChatHistory objects.
+ * @param slyData Data items that should not be send to the LLM. Generated by the server.
+ * @param userId Current user ID in the session.
+ * @returns The response from the agent network.
+ */
+export declare function sendChatQuery(url: string, signal: AbortSignal, userInput: string, targetAgent: string, callback: (chunk: string) => void, chatContext: ChatContext, slyData: Record<string, unknown>, userId: string): Promise<ChatResponse>;
+/**
+ * Gets information on the agent and tool connections within a network
+ * @param url The neuro-san server URL
+ * @param network The network to get connectivity information for
+ * @param userId Current user ID in the session.
+ * @returns The connectivity info as a <code>ConnectivityResponse</code> object
+ * @throws Various exceptions if anything goes wrong such as network issues or invalid agent type.
+ * Caller is responsible for try-catch.
+ */
+export declare function getConnectivity(url: string, network: string, userId: string): Promise<ConnectivityResponse>;
+/**
+ * Get the function of a specified agent meaning its brief description
+ * @param url The neuro-san server URL
+ * @param agent The agent to get the function for
+ * @param userId Current user ID in the session.
+ * @returns The function info as a <code>FunctionResponse</code> object
+ * @throws Various exceptions if anything goes wrong such as network issues or invalid agent type.
+ */
+export declare function getAgentFunction(url: string, agent: string, userId: string): Promise<FunctionResponse>;