Scenario 1: Provider compatibility, search hardening, Venice.ai

.gitignore

@@ -22,6 +22,7 @@ dist/
 
 # Config files
 config.toml
+.claude/settings.local.json
 
 # Log files
 logs/

src/app/api/chat/route.ts

@@ -101,6 +101,9 @@ const ensureChatExists = async (input: {
 };
 
 export const POST = async (req: Request) => {
+  let safeClose: (() => void) | undefined;
+  let disconnect: (() => void) | undefined;
+
   try {
     const reqBody = (await req.json()) as Body;
 
@@ -155,57 +158,66 @@ export const POST = async (req: Request) => {
     const responseStream = new TransformStream();
     const writer = responseStream.writable.getWriter();
     const encoder = new TextEncoder();
+    const keepAliveMs = 15_000;
+    let streamClosed = false;
+    let keepAliveInterval: ReturnType<typeof setInterval> | undefined;
+
+    const safeWrite = (payload: Record<string, unknown>) => {
+      if (streamClosed) return;
+
+      writer.write(encoder.encode(JSON.stringify(payload) + '\n')).catch((error) => {
+        console.warn('Failed to write chat stream payload:', error);
+        streamClosed = true;
+        if (keepAliveInterval) {
+          clearInterval(keepAliveInterval);
+        }
+      });
+    };
+
+    safeClose = () => {
+      if (streamClosed) return;
+
+      streamClosed = true;
 
-    const disconnect = session.subscribe((event: string, data: any) => {
+      if (keepAliveInterval) {
+        clearInterval(keepAliveInterval);
+      }
+
+      writer.close().catch((error) => {
+        console.warn('Failed to close chat stream:', error);
+      });
+    };
+
+    disconnect = session.subscribe((event: string, data: any) => {
       if (event === 'data') {
         if (data.type === 'block') {
-          writer.write(
-            encoder.encode(
-              JSON.stringify({
-                type: 'block',
-                block: data.block,
-              }) + '\n',
-            ),
-          );
+          safeWrite({
+            type: 'block',
+            block: data.block,
+          });
         } else if (data.type === 'updateBlock') {
-          writer.write(
-            encoder.encode(
-              JSON.stringify({
-                type: 'updateBlock',
-                blockId: data.blockId,
-                patch: data.patch,
-              }) + '\n',
-            ),
-          );
+          safeWrite({
+            type: 'updateBlock',
+            blockId: data.blockId,
+            patch: data.patch,
+          });
         } else if (data.type === 'researchComplete') {
-          writer.write(
-            encoder.encode(
-              JSON.stringify({
-                type: 'researchComplete',
-              }) + '\n',
-            ),
-          );
+          safeWrite({
+            type: 'researchComplete',
+          });
         }
       } else if (event === 'end') {
-        writer.write(
-          encoder.encode(
-            JSON.stringify({
-              type: 'messageEnd',
-            }) + '\n',
-          ),
-        );
-        writer.close();
+        safeWrite({
+          type: 'messageEnd',
+        });
+        safeClose?.();
         session.removeAllListeners();
       } else if (event === 'error') {
-        writer.write(
-          encoder.encode(
-            JSON.stringify({
-              type: 'error',
-              data: data.data,
-            }) + '\n',
-          ),
-        );
-        writer.close();
+        safeWrite({
+          type: 'error',
+          data: data.data,
+        });
+        safeClose?.();
         session.removeAllListeners();
       }
     });
@@ -233,10 +245,18 @@ export const POST = async (req: Request) => {
     });
 
     req.signal.addEventListener('abort', () => {
-      disconnect();
-      writer.close();
+      disconnect?.();
+      safeClose?.();
     });
 
+    // Start keepalives only after setup succeeds
+    if (!streamClosed) {
+      keepAliveInterval = setInterval(() => {
+        safeWrite({ type: 'keepAlive' });
+      }, keepAliveMs);
+      safeWrite({ type: 'keepAlive' });
+    }
+
     return new Response(responseStream.readable, {
       headers: {
         'Content-Type': 'text/event-stream',
@@ -245,6 +265,8 @@ export const POST = async (req: Request) => {
       },
     });
   } catch (err) {
+    disconnect?.();
+    safeClose?.();
     console.error('An error occurred while processing chat request:', err);
     return Response.json(
       { message: 'An error occurred while processing chat request' },

src/app/api/reconnect/[id]/route.ts

@@ -4,6 +4,9 @@ export const POST = async (
   req: Request,
   { params }: { params: Promise<{ id: string }> },
 ) => {
+  let safeClose: (() => void) | undefined;
+  let disconnect: (() => void) | undefined;
+
   try {
     const { id } = await params;
 
@@ -16,66 +19,91 @@ export const POST = async (
     const responseStream = new TransformStream();
     const writer = responseStream.writable.getWriter();
     const encoder = new TextEncoder();
+    const keepAliveMs = 15_000;
+    let streamClosed = false;
+    let keepAliveInterval: ReturnType<typeof setInterval> | undefined;
+
+    const safeWrite = (payload: Record<string, unknown>) => {
+      if (streamClosed) return;
+
+      writer.write(encoder.encode(JSON.stringify(payload) + '\n')).catch((error) => {
+        console.warn('Failed to write reconnect stream payload:', error);
+        streamClosed = true;
+        if (keepAliveInterval) {
+          clearInterval(keepAliveInterval);
+        }
+      });
+    };
 
-    const disconnect = session.subscribe((event, data) => {
+    safeClose = () => {
+      if (streamClosed) return;
+
+      streamClosed = true;
+
+      if (keepAliveInterval) {
+        clearInterval(keepAliveInterval);
+      }
+
+      writer.close().catch((error) => {
+        console.warn('Failed to close reconnect stream:', error);
+      });
+    };
+
+    disconnect = session.subscribe((event, data) => {
       if (event === 'data') {
         if (data.type === 'block') {
-          writer.write(
-            encoder.encode(
-              JSON.stringify({
-                type: 'block',
-                block: data.block,
-              }) + '\n',
-            ),
-          );
+          safeWrite({
+            type: 'block',
+            block: data.block,
+          });
         } else if (data.type === 'updateBlock') {
-          writer.write(
-            encoder.encode(
-              JSON.stringify({
-                type: 'updateBlock',
-                blockId: data.blockId,
-                patch: data.patch,
-              }) + '\n',
-            ),
-          );
+          safeWrite({
+            type: 'updateBlock',
+            blockId: data.blockId,
+            patch: data.patch,
+          });
         } else if (data.type === 'researchComplete') {
-          writer.write(
-            encoder.encode(
-              JSON.stringify({
-                type: 'researchComplete',
-              }) + '\n',
-            ),
-          );
+          safeWrite({
+            type: 'researchComplete',
+          });
         }
       } else if (event === 'end') {
-        writer.write(
-          encoder.encode(
-            JSON.stringify({
-              type: 'messageEnd',
-            }) + '\n',
-          ),
-        );
-        writer.close();
-        disconnect();
+        safeWrite({
+          type: 'messageEnd',
+        });
+        safeClose?.();
+        if (disconnect) {
+          disconnect();
+        } else {
+          queueMicrotask(() => disconnect?.());
+        }
       } else if (event === 'error') {
-        writer.write(
-          encoder.encode(
-            JSON.stringify({
-              type: 'error',
-              data: data.data,
-            }) + '\n',
-          ),
-        );
-        writer.close();
-        disconnect();
+        safeWrite({
+          type: 'error',
+          data: data.data,
+        });
+        safeClose?.();
+        if (disconnect) {
+          disconnect();
+        } else {
+          queueMicrotask(() => disconnect?.());
+        }
       }
     });
 
     req.signal.addEventListener('abort', () => {
-      disconnect();
-      writer.close();
+      disconnect?.();
+      safeClose?.();
     });
 
+    // Start keepalives only after setup succeeds
+    if (!streamClosed) {
+      keepAliveInterval = setInterval(() => {
+        safeWrite({ type: 'keepAlive' });
+      }, keepAliveMs);
+      safeWrite({ type: 'keepAlive' });
+    }
+
     return new Response(responseStream.readable, {
       headers: {
         'Content-Type': 'text/event-stream',
@@ -84,6 +112,8 @@ export const POST = async (
       },
     });
   } catch (err) {
+    disconnect?.();
+    safeClose?.();
     console.error('Error in reconnecting to session stream: ', err);
     return Response.json(
       { message: 'An error has occurred.' },

src/lib/agents/media/video.ts

@@ -43,19 +43,31 @@ const searchVideos = async (
     schema: schema,
   });
 
-  const searchRes = await searchSearxng(res.query, {
-    engines: ['youtube'],
-  });
+  let searchRes;
+  try {
+    searchRes = await searchSearxng(res.query, {
+      engines: ['youtube'],
+    });
+  } catch (error) {
+    console.error('Video search failed:', error instanceof Error ? error.message : error);
+    return [];
+  }
 
   const videos: VideoSearchResult[] = [];
 
   searchRes.results.forEach((result) => {
     if (result.thumbnail && result.url && result.title && result.iframe_src) {
+      // Normalize embed URL - some SearXNG instances return
+      // youtube-nocookie.com which doesn't resolve on all networks
+      const embedUrl = result.iframe_src.replace(
+        'www.youtube-nocookie.com/embed',
+        'www.youtube.com/embed',
+      );
       videos.push({
         img_src: result.thumbnail,
         url: result.url,
         title: result.title,
-        iframe_src: result.iframe_src,
+        iframe_src: embedUrl,
       });
     }
   });