Merge pull request #1339 from danielaskdd/main

Merge PR #1331 and fix lintings

lightrag_webui/src/api/lightrag.ts

@@ -244,10 +244,10 @@ export const checkHealth = async (): Promise<
   try {
     const response = await axiosInstance.get('/health')
     return response.data
-  } catch (e) {
+  } catch (error) {
     return {
       status: 'error',
-      message: errorMessage(e)
+      message: errorMessage(error)
     }
   }
 }
@@ -277,65 +277,100 @@ export const queryTextStream = async (
   onChunk: (chunk: string) => void,
   onError?: (error: string) => void
 ) => {
+  const apiKey = useSettingsStore.getState().apiKey;
+  const token = localStorage.getItem('LIGHTRAG-API-TOKEN');
+  const headers: HeadersInit = {
+    'Content-Type': 'application/json',
+    'Accept': 'application/x-ndjson',
+  };
+  if (token) {
+    headers['Authorization'] = `Bearer ${token}`;
+  }
+  if (apiKey) {
+    headers['X-API-Key'] = apiKey;
+  }
+
   try {
-    let buffer = ''
+    const response = await fetch(`${backendBaseUrl}/query/stream`, {
-    await axiosInstance
+      method: 'POST',
-      .post('/query/stream', request, {
+      headers: headers,
-        responseType: 'text',
+      body: JSON.stringify(request),
-        headers: {
+    });
-          Accept: 'application/x-ndjson'
+
-        },
+    if (!response.ok) {
-        transformResponse: [
+      // Handle HTTP errors (e.g., 4xx, 5xx)
-          (data: string) => {
+      let errorBody = 'Unknown error';
-            // Accumulate the data and process complete lines
+      try {
-            buffer += data
+        errorBody = await response.text(); // Try to get error details from body
-            const lines = buffer.split('\n')
+      } catch { /* ignore */ }
-            // Keep the last potentially incomplete line in the buffer
+      throw new Error(`HTTP error ${response.status}: ${response.statusText}\n${errorBody}`);
-            buffer = lines.pop() || ''
+    }
+
+    if (!response.body) {
+      throw new Error('Response body is null');
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break; // Stream finished
+      }
+
+      // Decode the chunk and add to buffer
+      buffer += decoder.decode(value, { stream: true }); // stream: true handles multi-byte chars split across chunks
+
+      // Process complete lines (NDJSON)
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || ''; // Keep potentially incomplete line in buffer
 
       for (const line of lines) {
         if (line.trim()) {
           try {
-                  const parsed = JSON.parse(line)
+            const parsed = JSON.parse(line);
             if (parsed.response) {
-                    onChunk(parsed.response)
+              console.log('Received chunk:', parsed.response); // Log for debugging
+              onChunk(parsed.response);
             } else if (parsed.error && onError) {
-                    onError(parsed.error)
+              onError(parsed.error);
-                  }
-                } catch (e) {
-                  console.error('Error parsing stream chunk:', e)
-                  if (onError) onError('Error parsing server response')
-                }
-              }
-            }
-            return data
-          }
-        ]
-      })
-      .catch((error) => {
-        if (onError) onError(errorMessage(error))
-      })
-
-    // Process any remaining data in the buffer
-    if (buffer.trim()) {
-      try {
-        const parsed = JSON.parse(buffer)
-        if (parsed.response) {
-          onChunk(parsed.response)
-        } else if (parsed.error && onError) {
-          onError(parsed.error)
-        }
-      } catch (e) {
-        console.error('Error parsing final chunk:', e)
-        if (onError) onError('Error parsing server response')
-      }
             }
           } catch (error) {
-    const message = errorMessage(error)
+            console.error('Error parsing stream chunk:', line, error);
-    console.error('Stream request failed:', message)
+            if (onError) onError(`Error parsing server response: ${line}`);
-    if (onError) onError(message)
           }
-}
+        }
+      }
+    }
+
+    // Process any remaining data in the buffer after the stream ends
+    if (buffer.trim()) {
+      try {
+        const parsed = JSON.parse(buffer);
+        if (parsed.response) {
+          onChunk(parsed.response);
+        } else if (parsed.error && onError) {
+          onError(parsed.error);
+        }
+      } catch (error) {
+        console.error('Error parsing final chunk:', buffer, error);
+        if (onError) onError(`Error parsing final server response: ${buffer}`);
+      }
+    }
+
+  } catch (error) {
+    const message = errorMessage(error);
+    console.error('Stream request failed:', message);
+    if (onError) {
+      onError(message);
+    } else {
+      // If no specific onError handler, maybe throw or log more prominently
+      console.error('Unhandled stream error:', message);
+    }
+  }
+};
 
 export const insertText = async (text: string): Promise<DocActionResponse> => {
   const response = await axiosInstance.post('/documents/text', { text })

lightrag_webui/src/features/RetrievalTesting.tsx

@@ -60,6 +60,7 @@ export default function RetrievalTesting() {
           }
           return newMessages
         })
+        scrollToBottom()
       }
 
       // Prepare query parameters