Merge branch 'pr/703'

feat(models): Update Gemini chat models

src/app/api/search/route.ts

@@ -146,7 +146,10 @@ export const POST = async (req: Request) => {
               }
             } catch (error) {
               reject(
-                Response.json({ message: 'Error parsing data' }, { status: 500 }),
+                Response.json(
+                  { message: 'Error parsing data' },
+                  { status: 500 },
+                ),
               );
             }
           });
@@ -157,7 +160,10 @@ export const POST = async (req: Request) => {
 
           emitter.on('error', (error: any) => {
             reject(
-              Response.json({ message: 'Search error', error }, { status: 500 }),
+              Response.json(
+                { message: 'Search error', error },
+                { status: 500 },
+              ),
             );
           });
         },
@@ -166,7 +172,6 @@ export const POST = async (req: Request) => {
 
     const encoder = new TextEncoder();
 
-    // Create an AbortController to handle cancellation
     const abortController = new AbortController();
     const { signal } = abortController;
 
@@ -174,43 +179,48 @@ export const POST = async (req: Request) => {
       start(controller) {
         let sources: any[] = [];
 
-        // Send an initial message to keep the connection alive
+        controller.enqueue(
-        controller.enqueue(encoder.encode(JSON.stringify({
+          encoder.encode(
-          type: 'init',
+            JSON.stringify({
-          data: 'Stream connected'
+              type: 'init',
-        }) + '\n'));
+              data: 'Stream connected',
+            }) + '\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) {
+          } 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(JSON.stringify({
+              controller.enqueue(
-                type: 'response',
+                encoder.encode(
-                data: parsedData.data
+                  JSON.stringify({
-              }) + '\n'));
+                    type: 'response',
+                    data: parsedData.data,
+                  }) + '\n',
+                ),
+              );
             } else if (parsedData.type === 'sources') {
               sources = parsedData.data;
-              controller.enqueue(encoder.encode(JSON.stringify({
+              controller.enqueue(
-                type: 'sources',
+                encoder.encode(
-                data: sources
+                  JSON.stringify({
-              }) + '\n'));
+                    type: 'sources',
+                    data: sources,
+                  }) + '\n',
+                ),
+              );
             }
           } catch (error) {
             controller.error(error);
@@ -218,17 +228,19 @@ 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(JSON.stringify({
+          controller.enqueue(
-            type: 'done'
+            encoder.encode(
-          }) + '\n'));
+              JSON.stringify({
+                type: 'done',
+              }) + '\n',
+            ),
+          );
           controller.close();
         });
 
         emitter.on('error', (error: any) => {
-          // Check if request has been cancelled before processing
           if (signal.aborted) return;
 
           controller.error(error);
@@ -236,14 +248,14 @@ export const POST = async (req: Request) => {
       },
       cancel() {
         abortController.abort();
-      }
+      },
     });
 
     return new Response(stream, {
       headers: {
-        'Content-Type': 'application/json',
+        'Content-Type': 'text/event-stream',
         'Cache-Control': 'no-cache, no-transform',
-        'Connection': 'keep-alive',
+        Connection: 'keep-alive',
       },
     });
   } catch (err: any) {

src/lib/providers/gemini.ts

@@ -8,6 +8,10 @@ import { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import { Embeddings } from '@langchain/core/embeddings';
 
 const geminiChatModels: Record<string, string>[] = [
+  {
+    displayName: 'Gemini 2.5 Pro Experimental',
+    key: 'gemini-2.5-pro-exp-03-25',
+  },
   {
     displayName: 'Gemini 2.0 Flash',
     key: 'gemini-2.0-flash',
@@ -17,8 +21,8 @@ const geminiChatModels: Record<string, string>[] = [
     key: 'gemini-2.0-flash-lite',
   },
   {
-    displayName: 'Gemini 2.0 Pro Experimental',
+    displayName: 'Gemini 2.0 Flash Thinking Experimental',
-    key: 'gemini-2.0-pro-exp-02-05',
+    key: 'gemini-2.0-flash-thinking-exp-01-21',
   },
   {
     displayName: 'Gemini 1.5 Flash',