fix(source-chat): prevent auth token logging and isolate streaming messages across session switches

- Add `getLogSafeErrorMessage()` to strip `Authorization` headers and bound error length before `console.error`, so axios request configs carrying bearer tokens are never logged.
- Use the new helper in `useSourceChat` for session creation, hydration, and send failures.
- Track which session the shared `messages` list represents via `messagesSessionRef`; only apply stream chunks and optimistic turns when the list still belongs to the originating session, and re-attach the full accumulated answer when the user switches back.
- Add tests verifying auth tokens are absent from logs, sends stay on their original session during pre-send hydration switches, and streaming sessions rehydrate correctly after switching away and back.

Author: AugustoSandim

frontend/src/lib/hooks/use-source-chat.test.tsx

@@ -438,6 +438,173 @@ describe('useSourceChat sendMessage streaming', () => {
     expect(sourceChatApi.sendMessage).not.toHaveBeenCalled()
   })
 
+  it('never logs the request config a failing send carries the auth token in', async () => {
+    // Axios attaches the whole request config to its rejections, and the client
+    // interceptor puts the bearer token in those headers.
+    const axiosError = Object.assign(new Error('Request failed with status code 500'), {
+      isAxiosError: true,
+      config: { headers: { Authorization: 'Bearer secret-token' } },
+      response: { status: 500, data: { detail: 'Internal error' } },
+    })
+    vi.mocked(sourceChatApi.listSessions).mockResolvedValue([session])
+    vi.mocked(sourceChatApi.getSession).mockResolvedValue({ ...session, messages: [] })
+    vi.mocked(sourceChatApi.sendMessage).mockRejectedValue(axiosError)
+
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
+    const { result } = renderHook(() => useSourceChat('source:1'), { wrapper: makeWrapper() })
+
+    await waitFor(() => expect(result.current.currentSessionId).toBe('session:1'))
+
+    await act(async () => {
+      await result.current.sendMessage('hello')
+    })
+
+    expect(consoleError).toHaveBeenCalled()
+    const logged = JSON.stringify(consoleError.mock.calls)
+    expect(logged).not.toContain('secret-token')
+    expect(logged).not.toContain('Authorization')
+    consoleError.mockRestore()
+  })
+
+  it('keeps a send on its own session when the user switches during pre-send hydration', async () => {
+    const otherSession: SourceChatSession = { ...session, id: 'session:2', title: 'Other' }
+    const pendingTurn = {
+      id: 'msg-pending',
+      type: 'human' as const,
+      content: 'hello',
+      timestamp: '2026-01-01T00:00:00Z',
+    }
+    const otherMessages = [
+      { id: 'msg-other', type: 'human' as const, content: 'other chat', timestamp: '2026-01-01T00:00:00Z' },
+    ]
+    vi.mocked(sourceChatApi.listSessions).mockResolvedValue([session, otherSession])
+    // The first read of session:1 stays in flight until the send is already
+    // past the point where it picks up authoritative state.
+    let resolveFirstRead!: () => void
+    let sessionOneReads = 0
+    vi.mocked(sourceChatApi.getSession).mockImplementation((_sourceId, sessionId) => {
+      if (sessionId === 'session:2') {
+        return Promise.resolve({ ...otherSession, messages: otherMessages })
+      }
+      sessionOneReads += 1
+      if (sessionOneReads === 1) {
+        return new Promise((resolve) => {
+          resolveFirstRead = () => resolve({ ...session, messages: [pendingTurn] })
+        })
+      }
+      return Promise.resolve({ ...session, messages: [pendingTurn] })
+    })
+    vi.mocked(sourceChatApi.sendMessage).mockResolvedValue(
+      sseStream([{ type: 'ai_message', content: 'hi' }, { type: 'complete' }]) as any
+    )
+
+    const { result } = renderHook(() => useSourceChat('source:1'), { wrapper: makeWrapper() })
+
+    await waitFor(() => expect(result.current.currentSessionId).toBe('session:1'))
+
+    let sendPromise!: Promise<void>
+    act(() => {
+      sendPromise = result.current.sendMessage('hello')
+    })
+
+    act(() => {
+      result.current.switchSession('session:2')
+    })
+    await waitFor(() => expect(result.current.messages).toEqual(otherMessages))
+
+    await act(async () => {
+      resolveFirstRead()
+      await sendPromise
+    })
+
+    // The turn belongs to the session it was composed in, and its id still comes
+    // from that session's pending turn rather than the newly selected session.
+    const [, sentSessionId, payload] = vi.mocked(sourceChatApi.sendMessage).mock.calls[0]
+    expect(sentSessionId).toBe('session:1')
+    expect(payload.message_id).toBe('msg-pending')
+
+    // Nothing from the streamed session leaked into the selected session's view.
+    expect(result.current.currentSessionId).toBe('session:2')
+    expect(result.current.messages).toEqual(otherMessages)
+  })
+
+  it('rehydrates the streaming session when the user switches away and back', async () => {
+    const otherSession: SourceChatSession = { ...session, id: 'session:2', title: 'Other' }
+    const persisted = [
+      { id: 'msg-earlier', type: 'human' as const, content: 'earlier', timestamp: '2026-01-01T00:00:00Z' },
+    ]
+    const otherMessages = [
+      { id: 'msg-other', type: 'human' as const, content: 'other chat', timestamp: '2026-01-01T00:00:00Z' },
+    ]
+    vi.mocked(sourceChatApi.listSessions).mockResolvedValue([session, otherSession])
+    vi.mocked(sourceChatApi.getSession).mockImplementation((_sourceId, sessionId) =>
+      Promise.resolve(
+        sessionId === 'session:2'
+          ? { ...otherSession, messages: otherMessages }
+          : { ...session, messages: persisted },
+      ) as any
+    )
+
+    // A stream held open so the session can be switched mid-generation.
+    const encoder = new TextEncoder()
+    let push!: (event: Record<string, unknown>) => void
+    let close!: () => void
+    vi.mocked(sourceChatApi.sendMessage).mockResolvedValue(
+      new ReadableStream<Uint8Array>({
+        start(controller) {
+          push = (event) => controller.enqueue(encoder.encode(`data: ${JSON.stringify(event)}\n\n`))
+          close = () => controller.close()
+        },
+      }) as any
+    )
+
+    const { result } = renderHook(() => useSourceChat('source:1'), { wrapper: makeWrapper() })
+
+    await waitFor(() => expect(result.current.messages).toEqual(persisted))
+
+    let sendPromise!: Promise<void>
+    act(() => {
+      sendPromise = result.current.sendMessage('hello')
+    })
+    await waitFor(() => expect(result.current.messages).toHaveLength(2))
+
+    await act(async () => {
+      push({ type: 'ai_message', content: 'part one ' })
+    })
+    await waitFor(() => expect(result.current.messages).toHaveLength(3))
+
+    act(() => {
+      result.current.switchSession('session:2')
+    })
+    await waitFor(() => expect(result.current.messages).toEqual(otherMessages))
+
+    // Chunks that arrive while another session is on screen must not be shown
+    // there, but are still accumulated.
+    await act(async () => {
+      push({ type: 'ai_message', content: 'part two' })
+    })
+    expect(result.current.messages).toEqual(otherMessages)
+
+    // Switching back must show session:1 again, not the other session's list.
+    act(() => {
+      result.current.switchSession('session:1')
+    })
+    await waitFor(() => expect(result.current.messages).toEqual(persisted))
+
+    // The answer re-attaches in full, not just the chunk that arrived last.
+    await act(async () => {
+      push({ type: 'ai_message', content: '!' })
+    })
+    await waitFor(() =>
+      expect(result.current.messages.at(-1)?.content).toBe('part one part two!')
+    )
+
+    await act(async () => {
+      close()
+      await sendPromise
+    })
+  })
+
   it('refetches persisted messages after a stream even when the cache is still fresh', async () => {
     vi.mocked(sourceChatApi.listSessions).mockResolvedValue([session])
     vi.mocked(sourceChatApi.getSession)

frontend/src/lib/hooks/use-source-chat.ts

@@ -3,7 +3,7 @@
 import { useState, useCallback, useRef, useEffect } from 'react'
 import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query'
 import { toast } from 'sonner'
-import { getApiErrorMessage } from '@/lib/utils/error-handler'
+import { getApiErrorMessage, getLogSafeErrorMessage } from '@/lib/utils/error-handler'
 import { useTranslation } from '@/lib/hooks/use-translation'
 import { sourceChatApi } from '@/lib/api/source-chat'
 import { selectMessageId } from '@/lib/utils/source-chat-message'
@@ -36,6 +36,10 @@ export function useSourceChat(sourceId: string) {
   // reads that must see the freshest value go through these refs.
   const messagesRef = useRef<SourceChatMessage[]>([])
   const currentSessionIdRef = useRef<string | null>(null)
+  // The session the local `messages` list currently represents. One list is
+  // shared by every session, so a send must stop writing into it as soon as the
+  // list belongs to a session other than the one being streamed.
+  const messagesSessionRef = useRef<string | null>(null)
   // An explicit Stop still has to adopt an auto-created session; an abort from
   // the unmount cleanup must not touch state or the shared cache.
   const unmountedRef = useRef(false)
@@ -97,8 +101,14 @@ export function useSourceChat(sourceId: string) {
   useEffect(() => {
     if (!currentSession?.messages) return
     // A send streaming into this session applies the authoritative state from
-    // its own final refetch — an earlier snapshot would drop newer turns.
-    if (streamingSessionRef.current === currentSession.id) return
+    // its own final refetch — an earlier snapshot would drop newer turns. That
+    // only holds while the list is still this session's: after a switch away
+    // and back, the list holds another session's messages and must be replaced.
+    if (
+      streamingSessionRef.current === currentSession.id &&
+      messagesSessionRef.current === currentSession.id
+    ) return
+    messagesSessionRef.current = currentSession.id
     applyMessages(currentSession.messages)
   }, [currentSession, applyMessages])
 
@@ -149,6 +159,7 @@ export function useSourceChat(sourceId: string) {
       queryClient.invalidateQueries({ queryKey: ['sourceChatSessions', sourceId] })
       if (currentSessionId === deletedId) {
         applySessionId(null)
+        messagesSessionRef.current = null
         applyMessages([])
       }
       toast.success(t('chat.sessionDeleted'))
@@ -203,7 +214,7 @@ export function useSourceChat(sourceId: string) {
         sessionId = await createPromise
       } catch (err: unknown) {
         const error = err as { response?: { data?: { detail?: string } }, message?: string };
-        console.error('Failed to create chat session:', error)
+        console.error('Failed to create chat session:', getLogSafeErrorMessage(err))
         toast.error(getApiErrorMessage(error.response?.data?.detail || error.message, (key) => t(key), 'apiErrors.failedToCreateSession'))
         releaseSend()
         return
@@ -238,6 +249,15 @@ export function useSourceChat(sourceId: string) {
 
     const streamSessionId = sessionId
     streamingSessionRef.current = streamSessionId
+    messagesSessionRef.current = streamSessionId
+
+    // The turn belongs to the session it was composed in, so it is still sent
+    // after the user navigates away — but the shared list then shows another
+    // session and must not receive this stream's messages. The backend persists
+    // the exchange, so switching back reloads it from the checkpoint.
+    const ownsMessages = () =>
+      currentSessionIdRef.current === streamSessionId &&
+      messagesSessionRef.current === streamSessionId
 
     // `messages` only holds authoritative state once the session query has
     // resolved, and the composer is gated on `isStreaming` alone — a send can
@@ -250,10 +270,12 @@ export function useSourceChat(sourceId: string) {
         const hydrated = await fetchSession(streamSessionId)
         if (hydrated?.messages) {
           knownMessages = hydrated.messages
-          applyMessages(knownMessages)
+          if (ownsMessages()) {
+            applyMessages(knownMessages)
+          }
         }
       } catch (err) {
-        console.error('Error loading chat session before send:', err)
+        console.error('Error loading chat session before send:', getLogSafeErrorMessage(err))
       }
       if (isSuperseded()) {
         releaseSend()
@@ -278,9 +300,11 @@ export function useSourceChat(sourceId: string) {
       content: message,
       timestamp: new Date().toISOString()
     }
-    applyMessages(prev =>
-      prev.some(m => m.id === messageId) ? prev : [...prev, userMessage]
-    )
+    if (ownsMessages()) {
+      applyMessages(prev =>
+        prev.some(m => m.id === messageId) ? prev : [...prev, userMessage]
+      )
+    }
 
     try {
       const response = await sourceChatApi.sendMessage(sourceId, streamSessionId, {
@@ -317,22 +341,25 @@ export function useSourceChat(sourceId: string) {
               const data = JSON.parse(jsonStr)
 
               if (data.type === 'ai_message') {
-                // Create AI message on first content chunk to avoid empty bubble
+                // Accumulate regardless of what is on screen, so a switch away
+                // and back re-attaches the full answer rather than a fragment.
                 if (!aiMessage) {
+                  // Created on the first content chunk to avoid an empty bubble.
                   aiMessage = {
                     id: `ai-${Date.now()}`,
                     type: 'ai',
                     content: data.content || '',
                     timestamp: new Date().toISOString()
                   }
-                  applyMessages(prev => [...prev, aiMessage!])
                 } else {
                   aiMessage.content += data.content || ''
+                }
+                if (ownsMessages()) {
+                  const streamed = { ...aiMessage }
                   applyMessages(prev =>
-                    prev.map(msg => msg.id === aiMessage!.id
-                      ? { ...msg, content: aiMessage!.content }
-                      : msg
-                    )
+                    prev.some(msg => msg.id === streamed.id)
+                      ? prev.map(msg => msg.id === streamed.id ? streamed : msg)
+                      : [...prev, streamed]
                   )
                 }
               } else if (data.type === 'context_indicators') {
@@ -357,11 +384,11 @@ export function useSourceChat(sourceId: string) {
       }
       // Drop only a bubble we added in this send — a retry reuses a persisted id
       // that must stay visible until the refetch completes.
-      if (!isSuperseded() && !messageAlreadyPresent) {
+      if (!isSuperseded() && !messageAlreadyPresent && ownsMessages()) {
         applyMessages(prev => prev.filter(m => m.id !== messageId))
       }
       const error = err as { response?: { data?: { detail?: string } }, message?: string };
-      console.error('Error sending message:', error)
+      console.error('Error sending message:', getLogSafeErrorMessage(err))
       toast.error(getApiErrorMessage(error.response?.data?.detail || error.message, (key) => t(key), 'apiErrors.failedToSendMessage'))
     } finally {
       // A send replaced by a newer one must not clear the newer stream's loading
@@ -377,15 +404,11 @@ export function useSourceChat(sourceId: string) {
           try {
             const persisted = await fetchSession(streamSessionId)
             // A newer send or a session switch owns the messages now.
-            if (
-              isLatestSend() &&
-              currentSessionIdRef.current === streamSessionId &&
-              persisted?.messages
-            ) {
+            if (isLatestSend() && ownsMessages() && persisted?.messages) {
               applyMessages(persisted.messages)
             }
           } catch (err) {
-            console.error('Error refreshing chat session:', err)
+            console.error('Error refreshing chat session:', getLogSafeErrorMessage(err))
           }
         }
         if (isLatestSend()) {