feat(api): Switch to newline-delimited JSON streaming instead of SSE

docs/API/SEARCH.md

@@ -32,7 +32,8 @@ The API accepts a JSON object in the request body, where you define the focus mo
   "history": [
     ["human", "Hi, how are you?"],
     ["assistant", "I am doing well, how can I help you today?"]
-  ]
+  ],
+  "stream": false
 }
 ```
 
@@ -71,11 +72,13 @@ The API accepts a JSON object in the request body, where you define the focus mo
   ]
   ```
 
+- **`stream`** (boolean, optional): When set to `true`, enables streaming responses. Default is `false`.
+
 ### Response
 
 The response from the API includes both the final message and the sources used to generate that message.
 
-#### Example Response
+#### Standard Response (stream: false)
 
 ```json
 {
@@ -100,6 +103,28 @@ The response from the API includes both the final message and the sources used t
 }
 ```
 
+#### Streaming Response (stream: true)
+
+When streaming is enabled, the API returns a stream of newline-delimited JSON objects. Each line contains a complete, valid JSON object. The response has Content-Type: application/json.
+
+Example of streamed response objects:
+
+```
+{"type":"init","data":"Stream connected"}
+{"type":"sources","data":[{"pageContent":"...","metadata":{"title":"...","url":"..."}},...]}
+{"type":"response","data":"Perplexica is an "}
+{"type":"response","data":"innovative, open-source "}
+{"type":"response","data":"AI-powered search engine..."}
+{"type":"done"}
+```
+
+Clients should process each line as a separate JSON object. The different message types include:
+
+- **`init`**: Initial connection message
+- **`sources`**: All sources used for the response
+- **`response`**: Chunks of the generated answer text
+- **`done`**: Indicates the stream is complete
+
 ### Fields in the Response
 
 - **`message`** (string): The search result, generated based on the query and focus mode.

src/app/api/search/route.ts

@@ -166,6 +166,7 @@ export const POST = async (req: Request) => {
 
     const encoder = new TextEncoder();
     
+    // Create an AbortController to handle cancellation
     const abortController = new AbortController();
     const { signal } = abortController;
     
@@ -173,37 +174,43 @@ export const POST = async (req: Request) => {
       start(controller) {
         let sources: any[] = [];
 
-        controller.enqueue(encoder.encode("data: " + JSON.stringify({
+        // Send an initial message to keep the connection alive
+        controller.enqueue(encoder.encode(JSON.stringify({
           type: 'init',
           data: 'Stream connected'
-        }) + "\n\n"));
+        }) + '\n'));
 
+        // Set up cleanup function for when client disconnects
         signal.addEventListener('abort', () => {
+          // Remove all listeners from emitter to prevent memory leaks
           emitter.removeAllListeners();
           
+          // Close the controller if it's still active
           try {
             controller.close();
           } catch (error) {
+            // Controller might already be closed
           }
         });
 
         emitter.on('data', (data: string) => {
+          // Check if request has been cancelled before processing
           if (signal.aborted) return;
           
           try {
             const parsedData = JSON.parse(data);
             
             if (parsedData.type === 'response') {
-              controller.enqueue(encoder.encode("data: " + JSON.stringify({
+              controller.enqueue(encoder.encode(JSON.stringify({
                 type: 'response',
                 data: parsedData.data
-              }) + "\n\n"));
+              }) + '\n'));
             } else if (parsedData.type === 'sources') {
               sources = parsedData.data;
-              controller.enqueue(encoder.encode("data: " + JSON.stringify({
+              controller.enqueue(encoder.encode(JSON.stringify({
                 type: 'sources',
                 data: sources
-              }) + "\n\n"));
+              }) + '\n'));
             }
           } catch (error) {
             controller.error(error);
@@ -211,21 +218,22 @@ export const POST = async (req: Request) => {
         });
 
         emitter.on('end', () => {
+          // Check if request has been cancelled before processing
           if (signal.aborted) return;
           
-          controller.enqueue(encoder.encode("data: " + JSON.stringify({
+          controller.enqueue(encoder.encode(JSON.stringify({
             type: 'done'
-          }) + "\n\n"));
+          }) + '\n'));
           controller.close();
         });
 
         emitter.on('error', (error: any) => {
+          // Check if request has been cancelled before processing
           if (signal.aborted) return;
           
           controller.error(error);
         });
       },
-      
       cancel() {
         abortController.abort();
       }
@@ -233,7 +241,7 @@ export const POST = async (req: Request) => {
 
     return new Response(stream, {
       headers: {
-        'Content-Type': 'text/event-stream',
+        'Content-Type': 'application/json',
         'Cache-Control': 'no-cache, no-transform',
         'Connection': 'keep-alive',
       },