Stop cancelled Ask requests and keep a half-saved chat

- Ask listens for cancellation before it reads the session, so leaving Ask
  during a token refresh no longer sends the question.
- When a new chat is created but its messages fail to save, Ask keeps the
  chat, so the next save adds to it instead of creating a second chat.
- A failed link import shows only translated text and logs the raw error.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: Programcode

apps/mobile/src/app/add-link.tsx

@@ -45,7 +45,8 @@ export default function AddLinkSheet() {
       setDraft(imported);
       setTitle(imported.title);
     } catch (cause) {
-      setError(`${t('libraryPage.importFailed')}: ${cause instanceof Error ? cause.message : t('libraryPage.importFailedDesc')}`);
+      console.warn('Could not import the source:', cause instanceof Error ? cause.message : cause);
+      setError(`${t('libraryPage.importFailed')}. ${t('libraryPage.importFailedDesc')}`);
     } finally {
       setBusy(null);
     }

apps/mobile/src/app/ask.tsx

@@ -26,7 +26,7 @@ import {
 import { fetchAskConfig, type AskConfig } from '@/lib/ask-config';
 import { buildAskDebateContext } from '@/lib/ask-context';
 import { useAuth } from '@/lib/auth';
-import { fetchChat, saveChat, type ChatMessage, type ChatRecord } from '@/lib/chats';
+import { ChatSaveError, fetchChat, saveChat, type ChatMessage, type ChatRecord } from '@/lib/chats';
 import { useDebates } from '@/lib/debate-context';
 import { useSettings } from '@/lib/settings';
 import { fetchSources, type Source } from '@/lib/sources';
@@ -161,7 +161,9 @@ export default function AskScreen() {
         if (next && owner === conversation.current) setRecord(next);
       } catch (cause) {
         console.warn('Could not save the chat:', cause instanceof Error ? cause.message : cause);
-        if (owner === conversation.current) setNotice(t('debate.recordFailed'));
+        if (owner !== conversation.current) return;
+        if (cause instanceof ChatSaveError) setRecord(cause.record);
+        setNotice(t('debate.recordFailed'));
       }
     });
     // eslint-disable-next-line react-hooks/exhaustive-deps

apps/mobile/src/lib/ask.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it, vi } from 'vitest';
+
+const session = vi.hoisted(() => ({ resolve: (_token: string) => {} }));
+const fetchMock = vi.hoisted(() => vi.fn());
+
+vi.mock('./supabase', () => ({
+  supabase: { auth: { getSession: () => new Promise((resolve) => (session.resolve = (token) => resolve({ data: { session: { access_token: token } } }))) } },
+}));
+vi.mock('expo/fetch', () => ({ fetch: fetchMock }));
+
+import { askOnce } from './ask';
+
+describe('askOnce', () => {
+  it('never sends the request when Ask is left while the session is still being read', async () => {
+    const controller = new AbortController();
+    const request = askOnce({
+      message: 'Why ban homework?',
+      history: [],
+      options: { citationMode: false, webSearch: false, prosConsMode: false, argumentMapMode: false },
+      config: { model: 'test-model', temperature: 0.3, reasoningEffort: 'low' },
+      language: 'en',
+    }, controller.signal);
+    controller.abort();
+    session.resolve('token');
+    await expect(request).rejects.toMatchObject({ name: 'AbortError' });
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});

apps/mobile/src/lib/ask.ts

@@ -173,15 +173,19 @@ function parseOutput(output: unknown, resolvedModel?: string): AskOutput {
 
 /** One POST with the website's headers, a 200 s timeout and the caller's abort. */
 async function post(path: string, body: Record<string, unknown>, signal: AbortSignal | undefined, run: (response: Awaited<ReturnType<typeof fetch>>) => Promise<AskOutput>): Promise<AskOutput> {
-  if (signal?.aborted) throw abortError();
-  const token = await accessToken();
-  const json = JSON.stringify(body);
-  if (utf8Length(json) > MAX_REQUEST_BODY_BYTES) throw new AskError('tooLarge', 'Request is too large');
+  // The deadline and the caller's abort start before the session read, so
+  // leaving Ask while the token refreshes never sends the request.
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
   const abortForCaller = () => controller.abort();
   signal?.addEventListener('abort', abortForCaller);
+  if (signal?.aborted) controller.abort();
   try {
+    if (controller.signal.aborted) throw abortError();
+    const token = await accessToken();
+    if (controller.signal.aborted) throw abortError();
+    const json = JSON.stringify(body);
+    if (utf8Length(json) > MAX_REQUEST_BODY_BYTES) throw new AskError('tooLarge', 'Request is too large');
     const response = await fetch(`${supabaseProject.url}/functions/v1/${path}`, {
       method: 'POST',
       headers: { Authorization: `Bearer ${token}`, apikey: supabaseProject.anonKey, 'Content-Type': 'application/json' },

apps/mobile/src/lib/chats.ts

@@ -31,6 +31,14 @@ export interface ChatRecord {
   persisted: number;
 }
 
+/** A failed message write, with the record to keep: the chat may have been created before it failed. */
+export class ChatSaveError extends Error {
+  constructor(message: string, readonly record: ChatRecord) {
+    super(message);
+    this.name = 'ChatSaveError';
+  }
+}
+
 interface MessageRow {
   id: string;
   role: 'user' | 'assistant';
@@ -109,6 +117,7 @@ export async function saveChat(userId: string, record: ChatRecord, messages: Cha
     output: message.output || null,
     created_at: new Date(message.timestamp).toISOString(),
   })));
-  if (error) throw new Error(error.message);
+  // The chat exists now; keep it so the next save adds these messages to it instead of creating another.
+  if (error) throw new ChatSaveError(error.message, { chatId, debateId, persisted: record.persisted });
   return { chatId, debateId, persisted: messages.length };
 }