fix: sanitize route errors and settle stream aborts

Author: Programcode

src/App.tsx

@@ -100,7 +100,7 @@ export class RouteErrorBoundary extends Component<{ children: ReactNode }, { fai
 
   componentDidCatch(error: Error, info: ErrorInfo) {
     console.error('Route rendering failed', error, info);
-    captureException(error, { boundary: "route" });
+    captureException(new Error("Route rendering failed"), { boundary: "route" });
   }
 
   render() {

src/lib/ai/streaming.ts

@@ -70,6 +70,23 @@ export function consumeSSEChunk(buffer: string, chunk: string): { events: Parsed
   return { events, buffer: rest };
 }
 
+function abortError(): DOMException {
+  return new DOMException('Aborted', 'AbortError');
+}
+
+function waitForCaller<T>(operation: PromiseLike<T>, signal?: AbortSignal): Promise<T> {
+  if (!signal) return Promise.resolve(operation);
+  if (signal.aborted) return Promise.reject(abortError());
+
+  return new Promise<T>((resolve, reject) => {
+    const onAbort = () => reject(abortError());
+    signal.addEventListener('abort', onAbort, { once: true });
+    Promise.resolve(operation)
+      .then(resolve, reject)
+      .finally(() => signal.removeEventListener('abort', onAbort));
+  });
+}
+
 function captureStreamFailure(
   error: unknown,
   provider: string,
@@ -115,14 +132,14 @@ export async function streamAskChat(
   });
 
   if (handlers.signal?.aborted) {
-    const error = new DOMException('Aborted', 'AbortError');
+    const error = abortError();
     captureStreamFailure(error, provider, config.model, startTime, true);
     throw error;
   }
 
   let sessionData: Awaited<ReturnType<typeof supabase.auth.getSession>>['data'];
   try {
-    ({ data: sessionData } = await supabase.auth.getSession());
+    ({ data: sessionData } = await waitForCaller(supabase.auth.getSession(), handlers.signal));
   } catch (error) {
     captureStreamFailure(error, provider, config.model, startTime, Boolean(handlers.signal?.aborted));
     throw error;
@@ -135,9 +152,9 @@ export async function streamAskChat(
     throw error;
   }
   if (handlers.signal?.aborted) {
-    const error = new DOMException('Aborted', 'AbortError');
+    const error = abortError();
     captureStreamFailure(error, provider, config.model, startTime, true);
-    throw new DOMException('Aborted', 'AbortError');
+    throw error;
   }
 
   const controller = new AbortController();
@@ -236,6 +253,7 @@ export async function streamAskChat(
         throw new DOMException('Aborted', 'AbortError');
       }
       const { done, value } = await reader.read();
+      if (handlers.signal?.aborted) throw abortError();
       if (done) break;
 
       const parsed = consumeSSEChunk(buffer, decoder.decode(value, { stream: true }));
@@ -261,9 +279,13 @@ export async function streamAskChat(
     return finalOutput;
   } catch (error) {
     const callerAborted = Boolean(handlers.signal?.aborted);
-    const reportedError = !callerAborted && controller.signal.aborted ? new TimeoutError() : error;
+    const reportedError = callerAborted
+      ? abortError()
+      : controller.signal.aborted
+        ? new TimeoutError()
+        : error;
     captureStreamFailure(reportedError, provider, config.model, startTime, callerAborted);
-    if (handlers.signal?.aborted) throw error;
+    if (callerAborted) throw reportedError;
     if (controller.signal.aborted) throw reportedError;
     throw error;
   } finally {

src/test/ai/streaming.test.ts

@@ -232,10 +232,7 @@ describe('AI streaming helpers', () => {
     });
 
     it('records caller aborts without sending them to Sentry', async () => {
-      let resolveSession!: (result: { data: { session: { access_token: string } } }) => void;
-      supabaseMock.auth.getSession.mockImplementationOnce(() => new Promise((resolve) => {
-        resolveSession = resolve;
-      }));
+      supabaseMock.auth.getSession.mockImplementationOnce(() => new Promise(() => undefined));
       const controller = new AbortController();
       const request = streamAskChat(
         'private question',
@@ -246,7 +243,6 @@ describe('AI streaming helpers', () => {
         { onDelta: () => undefined, signal: controller.signal },
       );
       controller.abort();
-      resolveSession({ data: { session: { access_token: 'test-token' } } });
 
       await expect(request).rejects.toMatchObject({ name: 'AbortError' });
       expect(captureProductEventMock).toHaveBeenNthCalledWith(2, 'ai_request_failed', expect.objectContaining({
@@ -258,5 +254,38 @@ describe('AI streaming helpers', () => {
       }));
       expect(captureExceptionMock).not.toHaveBeenCalled();
     });
+
+    it('does not report success when cancellation settles a pending stream read', async () => {
+      const controller = new AbortController();
+      const encoder = new TextEncoder();
+      const body = new ReadableStream<Uint8Array>({
+        start(streamController) {
+          streamController.enqueue(encoder.encode(
+            'event: final\ndata: {"output":{"response":"answer","followUpQuestions":[],"uncertainties":[]}}\n\n',
+          ));
+          setTimeout(() => controller.abort(), 0);
+        },
+      });
+      mockFetchOnce(body);
+
+      await expect(streamAskChat(
+        'private question',
+        [],
+        'general',
+        streamConfig,
+        streamOptions,
+        { onDelta: () => undefined, signal: controller.signal },
+      )).rejects.toMatchObject({ name: 'AbortError' });
+
+      expect(captureProductEventMock).toHaveBeenLastCalledWith(
+        'ai_request_failed',
+        expect.objectContaining({ errorName: 'AbortError', streaming: true }),
+      );
+      expect(captureProductEventMock).not.toHaveBeenCalledWith(
+        'ai_request_succeeded',
+        expect.anything(),
+      );
+      expect(captureExceptionMock).not.toHaveBeenCalled();
+    });
   });
 });

src/test/app-route-analytics-error-boundary.test.tsx

@@ -107,7 +107,11 @@ describe("App route observability", () => {
       );
 
       expect(screen.getByRole("heading", { name: "Unable to load this page" })).toBeInTheDocument();
-      expect(observability.captureException).toHaveBeenCalledWith(error, { boundary: "route" });
+      expect(observability.captureException).toHaveBeenCalledWith(
+        expect.objectContaining({ name: "Error", message: "Route rendering failed" }),
+        { boundary: "route" },
+      );
+      expect(JSON.stringify(observability.captureException.mock.calls)).not.toContain(error.message);
       expect(observability.captureException.mock.calls[0][1]).not.toHaveProperty("componentStack");
     } finally {
       window.removeEventListener("error", suppressWindowError);