WebSockets or SSE connection management

Oct 13, 2025 by recoveryshake.com 131 views

Overview

In this article, we will explore the implementation of a streaming drawer component that displays real-time content from Large Language Model (LLM) responses and workflow progress during resolution plan generation. The component will be designed to slide in from the right side of the screen, contain a header with a title and close button, and manage its state (open/closed). We will also create a reusable MessageStream component that displays streaming messages in a scrollable list, supports different message types, and auto-scrolls to the bottom for new messages.

Technical Requirements

1. Component Structure

Create a reusable `StreamingDrawer` component

Slides in from the right side of the screen
Contains header with title and close button
Manages drawer state (open/closed)

interface DrawerProps {
  isOpen: boolean
  onClose: () => void
  title: string
  children: React.ReactNode
}

Create a reusable `MessageStream` component

Displays streaming messages in a scrollable list
Supports different message types (system, LLM, error)
Auto-scrolls to bottom for new messages
Can be used independently of the drawer

interface Message {
  id: string
  type: 'system' | 'llm' | 'error'
  content: string
  timestamp: Date
}

interface MessageStreamProps {
  messages: Message[]
  isLoading?: boolean
}

2. Streaming Infrastructure

Set up WebSocket or SSE connection management

Establish a connection to the LLM service
Handle connection establishment and closure

Implement message queue system for handling streaming data

Store incoming messages in a queue
Process messages in the queue

Add proper error handling and reconnection logic

Handle errors that occur during connection establishment or message processing
Reconnect to the LLM service when the connection is lost

Create types for different message formats

Define types for system, LLM, and error messages

3. Integration Points

Integrate with `GenerateResolutionPlanController`

Connect the streaming drawer to the resolution plan generation workflow
Display LLM responses and workflow progress in the streaming drawer

Add drawer trigger mechanism

Trigger the drawer to open when a new LLM response is received
Trigger the drawer to close when the user interacts with it

Connect streaming data to message display

Display incoming messages in the streaming drawer
Update the message list when new messages are received

Handle drawer state management

Manage the drawer's open and closed states
Update the drawer's state when the user interacts with it

4. UI/UX Considerations

Smooth drawer animation

Animate the drawer's opening and closing smoothly
Use a transition effect to make the animation more visually appealing

Loading states and progress indicators

Display a loading indicator when the drawer is opening or closing
Display a progress indicator when the LLM service is processing a request

Clear message formatting and typography

Use a clear and readable font for the message content
Use a consistent formatting style for the message list

Proper spacing and layout within drawer

Use proper spacing between the header and the message list
Use a consistent layout for the message list

Mobile responsiveness

Ensure the drawer is responsive on mobile devices
Adjust the layout and spacing to fit the smaller screen size

Implementation Details

Drawer Component

import React, { useState, useEffect } from 'react';

interface DrawerProps {
  isOpen: boolean
  onClose: () => void
  title: string
  children: React.ReactNode
}

const Drawer: React.FC<DrawerProps> = ({ isOpen, onClose, title, children }) => {
  const [drawerState, setDrawerState] = useState(isOpen);

  useEffect(() => {
    setDrawerState(isOpen);
  }, [isOpen]);

  return (
    <div className={`drawer ${drawerState ? 'open' : 'closed'}`}>
      <header>
        <h2>{title}</h2>
        <button onClick={onClose}>Close</button>
      </header>
      <main>{children}</main>
    </div>
  );
};

export default Drawer;

Message Stream Component

import React, { useState, useEffect } from 'react';

interface Message {
  id: string
  type: 'system' | 'llm' | 'error'
  content: string
  timestamp: Date
}

interface MessageStreamProps {
  messages: Message[]
  isLoading?: boolean
}

const MessageStream: React.FC<MessageStreamProps> = ({ messages, isLoading }) => {
  const [messageList, setMessageList] = useState(messages);

  useEffect(() => {
    setMessageList(messages);
  }, [messages]);

  return (
    <div className="message-stream">
      {messageList.map((message, index) => (
        <div key={index} className={`message ${message.type}`}>
          <span>{message.content}</span>
          <span>{message.timestamp.toLocaleString()}</span>
        </div>
      ))}
      {isLoading && <div className="loading-indicator">Loading...</div>}
    </div>
  );
};

export default MessageStream;

Streaming Connection

import { useState, useEffect } from 'react';

const StreamingConnection = () => {
  const [connectionState, setConnectionState] = useState('disconnected');
  const [messages, setMessages] = useState([]);

  useEffect(() => {
    // Establish connection to LLM service
    // Handle connection establishment and closure
    // Process incoming messages
  }, []);

  return (
    <div className="streaming-connection">
      <div className="connection-state">{connectionState}</div>
      <div className="message-list">
        {messages.map((message, index) => (
          <div key={index} className={`message ${message.type}`}>
            <span>{message.content}</span>
            <span>{message.timestamp.toLocaleString()}</span>
          </div>
        ))}
      </div>
    </div>
  );
};

export default StreamingConnection;

Acceptance Criteria

Drawer smoothly slides in from right when triggered
Messages appear in real-time as they stream in
Different message types are visually distinct
Auto-scrolling works correctly
Drawer can be closed and reopened without losing state
Mobile experience is fully functional
No memory leaks from streaming connections
Error states are properly handled and displayed

Dependencies

Current SSE implementation in GenerateResolutionPlanController
UI component library (shadcn/ui)
Implement Streaming Drawer with Real-time LLM Response Display: Q&A ====================================================================

Q: What is a streaming drawer, and why do we need it?

A: A streaming drawer is a UI component that displays real-time content from Large Language Model (LLM) responses and workflow progress during resolution plan generation. We need it to provide a seamless and interactive experience for users, allowing them to track the progress of their requests and receive updates in real-time.

Q: How does the streaming drawer work?

A: The streaming drawer works by establishing a connection to the LLM service using WebSockets or Server-Sent Events (SSE). It then receives and displays incoming messages in real-time, using a scrollable list to keep the messages organized. The drawer also manages its state (open/closed) and provides a smooth animation effect when opening and closing.

Q: What are the key features of the streaming drawer?

A: The key features of the streaming drawer include:

Real-time updates: The drawer receives and displays incoming messages in real-time, keeping users informed about the progress of their requests.
Smooth animation: The drawer provides a smooth animation effect when opening and closing, creating a seamless user experience.
Auto-scrolling: The drawer auto-scrolls to the bottom when new messages are received, ensuring that users always see the latest updates.
Different message types: The drawer supports different message types (system, LLM, error), allowing users to distinguish between different types of messages.
Mobile responsiveness: The drawer is fully responsive on mobile devices, providing a consistent user experience across different screen sizes.

Q: How do we integrate the streaming drawer with the LLM service?

A: To integrate the streaming drawer with the LLM service, we need to establish a connection to the service using WebSockets or SSE. We then need to process incoming messages and display them in the drawer. We also need to handle errors and reconnection logic to ensure that the drawer remains functional even in the event of connection loss.

Q: What are the technical requirements for implementing the streaming drawer?

A: The technical requirements for implementing the streaming drawer include:

WebSockets or SSE connection management: Establish a connection to the LLM service using WebSockets or SSE.
Message queue system: Implement a message queue system to handle incoming messages.
Error handling and reconnection logic: Handle errors and implement reconnection logic to ensure that the drawer remains functional.
Types for different message formats: Define types for different message formats (system, LLM, error).

Q: What are the UI/UX considerations for implementing the streaming drawer?

A: The UI/UX considerations for implementing the streaming drawer include:

Smooth animation: Provide a smooth animation effect when opening and closing the drawer.
Loading states and progress indicators: Display loading indicators and progress bars to keep users informed about the progress of their requests.
Clear message formatting and typography: Use clear and readable fonts and formatting styles for the message content.
Proper spacing and layout within drawer: Use proper spacing and layout to keep the message list organized and easy to read.

Q: What are the acceptance criteria for implementing the streaming drawer?

A: The acceptance criteria for implementing the streaming drawer include:

Drawer smoothly slides in from right when triggered
Messages appear in real-time as they stream in
Different message types are visually distinct
Auto-scrolling works correctly
Drawer can be closed and reopened without losing state
Mobile experience is fully functional
No memory leaks from streaming connections
Error states are properly handled and displayed

Q: What are the dependencies for implementing the streaming drawer?

A: The dependencies for implementing the streaming drawer include:

Current SSE implementation in GenerateResolutionPlanController
UI component library (shadcn/ui)