refactor(parse-once): single-grammar reasoning + tool-call parsing, native-first for Gemma

__tests__/integration/chat/reasoningPipeline.test.tsx

@@ -0,0 +1,123 @@
+/**
+ * INTEGRATION — the reasoning pipeline through its REAL seams, end to end.
+ *
+ * This is the test that proves the parse-once refactor actually works for a user, not that a
+ * mock returned what it was told. It drives the REAL chatStore (streaming → finalize) and the
+ * REAL ChatMessage render, with NOTHING mocked in the parse path, and asserts the observable
+ * outcome: reasoning is captured, the visible answer is clean, and raw model markup NEVER
+ * reaches the screen. It reproduces the two bugs this refactor closes:
+ *   - DR1  — remote channel reasoning leaking into the answer (streamed-split flow)
+ *   - OD14 / tool-call leak — raw <tool_call>/<function=…> markup shown as text
+ * for every format in the single-source grammar. A wall of green unit tests could not catch a
+ * wiring bug between stream → store → render; this can.
+ */
+import React from 'react';
+import { render } from '@testing-library/react-native';
+import { useChatStore } from '../../../src/stores/chatStore';
+import { ChatMessage } from '../../../src/components/ChatMessage';
+import { REASONING_DELIMITERS } from '../../../src/utils/messageContent';
+import { ThinkTagParser } from '../../../src/services/providers/openAICompatibleStream';
+import { resetStores, getChatState } from '../../utils/testHelpers';
+import type { Message } from '../../../src/types';
+
+const REASONING = 'let me weigh the options carefully';
+const ANSWER = 'Here is the clean answer.';
+
+/** Read the single assistant message the store just finalized into the active conversation. */
+function finalizedMessage(convId: string): Message {
+  const msg = getChatState()
+    .conversations.find(c => c.id === convId)
+    ?.messages.at(-1);
+  if (!msg) throw new Error('no finalized message');
+  return msg;
+}
+
+describe('reasoning pipeline — stream → finalize → render, real seams', () => {
+  beforeEach(() => resetStores());
+
+  describe.each(REASONING_DELIMITERS)(
+    'format opened by %j',
+    ({ open, close }) => {
+      const raw = `${open}${REASONING}${close}${ANSWER}`;
+
+      it('LOCAL flow: inline-tagged content is split into reasoning + clean answer, and renders both', () => {
+        const store = useChatStore.getState();
+        const convId = store.createConversation('local-model');
+        store.startStreaming(convId);
+        // Local (llama.rn) path: raw tokens accumulate in streamingMessage; reasoning is extracted
+        // at finalize by the ONE shared parser.
+        store.appendToStreamingMessage(raw);
+        store.finalizeStreamingMessage(convId);
+
+        const msg = finalizedMessage(convId);
+        expect(msg.reasoningContent).toBe(REASONING);
+        expect(msg.content).toBe(ANSWER);
+        // The stored answer carries none of the opener/closer markup.
+        expect(msg.content).not.toContain(open.trim());
+        expect(msg.content).not.toContain(close.trim());
+
+        const { getByText, queryByText } = render(
+          <ChatMessage message={msg} />,
+        );
+        expect(getByText(ANSWER)).toBeTruthy(); // clean answer is visible
+        expect(getByText(new RegExp(REASONING.slice(0, 20)))).toBeTruthy(); // reasoning survived into the block
+        expect(
+          queryByText(
+            new RegExp(open.trim().replace(/[.*+?^${}()|[\]\\]/g, '\\$&')),
+          ),
+        ).toBeNull(); // no raw markup on screen
+      });
+
+      it('REMOTE flow: ThinkTagParser split → store → finalize keeps reasoning out of the answer (DR1)', () => {
+        const store = useChatStore.getState();
+        const convId = store.createConversation('remote-model');
+        store.startStreaming(convId);
+        // Remote (OpenAI-compatible) path: the streaming parser routes reasoning vs answer live,
+        // feeding the two store channels. Same grammar, different seam.
+        const parser = new ThinkTagParser();
+        parser.process(
+          raw,
+          t => useChatStore.getState().appendToStreamingMessage(t),
+          r => useChatStore.getState().appendToStreamingReasoningContent(r),
+        );
+        store.finalizeStreamingMessage(convId);
+
+        const msg = finalizedMessage(convId);
+        expect(msg.reasoningContent).toBe(REASONING);
+        expect(msg.content).toBe(ANSWER);
+
+        const { getByText, queryByText } = render(
+          <ChatMessage message={msg} />,
+        );
+        expect(getByText(ANSWER)).toBeTruthy();
+        expect(
+          queryByText(
+            new RegExp(open.trim().replace(/[.*+?^${}()|[\]\\]/g, '\\$&')),
+          ),
+        ).toBeNull();
+      });
+    },
+  );
+
+  it('tool-call markup never reaches the stored answer or the screen (OD14 / leak class)', () => {
+    const store = useChatStore.getState();
+    const convId = store.createConversation('local-model');
+    store.startStreaming(convId);
+    // A model that emits its answer wrapped around raw tool-call markup. After finalize the
+    // stored content — and everything rendered — must be free of that markup.
+    store.appendToStreamingMessage(
+      'Sure, checking that.<tool_call><function=get_weather><parameter=city>NYC</parameter></function></tool_call>',
+    );
+    store.finalizeStreamingMessage(convId);
+
+    const msg = finalizedMessage(convId);
+    expect(msg.content).not.toContain('<tool_call>');
+    expect(msg.content).not.toContain('<function=');
+    expect(msg.content).not.toContain('<parameter=');
+
+    const { queryByText } = render(<ChatMessage message={msg} />);
+    expect(queryByText(/<tool_call>/)).toBeNull();
+    expect(queryByText(/<function=/)).toBeNull();
+    expect(queryByText(/<parameter=/)).toBeNull();
+  });
+});

__tests__/rntl/components/ChatMessage.test.tsx

@@ -28,6 +28,7 @@ import {
 
 // Mock the stripControlTokens utility
 jest.mock('../../../src/utils/messageContent', () => ({
+  ...jest.requireActual('../../../src/utils/messageContent'),
   stripControlTokens: (content: string) => content,
 }));
 

__tests__/rntl/components/ChatMessageAccordionPersistence.test.tsx

@@ -25,6 +25,7 @@ import { createMessage } from '../../utils/factories';
 import type { Message } from '../../../src/types';
 
 jest.mock('../../../src/utils/messageContent', () => ({
+  ...jest.requireActual('../../../src/utils/messageContent'),
   stripControlTokens: (content: string) => content,
 }));
 

__tests__/rntl/components/ChatMessageToolCallLeak.test.tsx

@@ -0,0 +1,29 @@
+import React from 'react';
+import { render } from '@testing-library/react-native';
+import { ChatMessage } from '../../../src/components/ChatMessage';
+import { createMessage } from '../../utils/factories';
+
+// On-device regression: raw tool-call markup (<tool_call>/<function=NAME>/<parameter=X>) leaked
+// as visible text below the thinking block. Terminal-artifact: assert the user sees NO markup,
+// across BOTH the separate-reasoning-channel path and the inline-<think> path.
+describe('ChatMessage — tool-call markup never renders as visible text', () => {
+  const rawBlock =
+    '<tool_call>\n<function=search_knowledge_base>\n<parameter=query>\nAchilles of Troy\n</parameter>\n</function>\n</tool_call>';
+
+  it('reasoningContent path (separate channel): markup hidden, thinking + tool chip shown', () => {
+    const m = createMessage({ role: 'assistant', content: rawBlock,
+      reasoningContent: 'The user wants to know about Achilles.',
+      toolCalls: [{ id: 't1', name: 'search_knowledge_base', arguments: '{"query":"Achilles of Troy"}' }] } as any);
+    const { queryByText, getByText } = render(<ChatMessage message={m} />);
+    expect(queryByText(/<function=|<parameter=|<tool_call>/)).toBeNull();
+    expect(getByText(/The user wants to know about Achilles\./)).toBeTruthy();
+  });
+
+  it('inline <think> path: markup hidden after the reasoning block', () => {
+    const m = createMessage({ role: 'assistant',
+      content: `<think>reasoning here</think>\n${rawBlock}`,
+      toolCalls: [{ id: 't1', name: 'search_knowledge_base', arguments: '{}' }] } as any);
+    const { queryByText } = render(<ChatMessage message={m} />);
+    expect(queryByText(/<function=|<parameter=|<tool_call>/)).toBeNull();
+  });
+});

__tests__/rntl/components/ChatMessageTools.test.tsx

@@ -17,6 +17,7 @@ import type { Message } from '../../../src/types';
 
 // Mock stripControlTokens utility
 jest.mock('../../../src/utils/messageContent', () => ({
+  ...jest.requireActual('../../../src/utils/messageContent'),
   stripControlTokens: (content: string) => content,
 }));
 
@@ -142,6 +143,44 @@ describe('ChatMessage — Tool message rendering', () => {
       expect(getByTestId('tool-call-message')).toBeTruthy();
     });
 
+    it('renders the pre-tool-call thinking block from message.reasoningContent (OD14 — the on-device disappearing-thinking bug)', () => {
+      // A tool-using turn: the model reasoned, then emitted a tool call. runToolLoop
+      // attaches that reasoning to the intermediate tool-call message as reasoningContent
+      // (content is empty). The tool-call renderer MUST show that thinking block, or the
+      // first round of chain-of-thought visibly disappears when the tool fires (the exact
+      // TestFlight report). This is a RENDER assertion — the object carrying the field is
+      // not enough; it must actually paint a thinking-block.
+      const message = makeMessage({
+        role: 'assistant',
+        content: '',
+        reasoningContent: 'I should search the knowledge base first.',
+        toolCalls: [{ id: 'tc-1', name: 'search_knowledge_base', arguments: '{"q":"achilles"}' }],
+      });
+
+      const { getByTestId, getByText } = render(<ChatMessage message={message} />);
+
+      expect(getByTestId('tool-call-message')).toBeTruthy();
+      // Assert the ACTUAL reasoning text is on screen (the collapsed block shows an 80-char
+      // preview of parsedContent.thinking), not merely that a block element mounted — the
+      // whole point is the user SEES the pre-tool-call thinking, not that a testID exists.
+      expect(getByText(/I should search the knowledge base first\./)).toBeTruthy();
+    });
+
+    it('renders the thinking block from inline <think> in a tool-call message content', () => {
+      // Some models stream reasoning inline as <think> in the content rather than the
+      // separate reasoning channel. The tool-call renderer must extract it too.
+      const message = makeMessage({
+        role: 'assistant',
+        content: '<think>Let me check the docs.</think>',
+        toolCalls: [{ id: 'tc-1', name: 'read_url', arguments: '{"url":"x"}' }],
+      });
+
+      const { getByText } = render(<ChatMessage message={message} />);
+
+      // The inline <think> reasoning text must actually render, not just a container.
+      expect(getByText(/Let me check the docs\./)).toBeTruthy();
+    });
+
     it('shows "Using web_search" text with arguments preview', () => {
       const message = makeMessage({
         role: 'assistant',

__tests__/rntl/components/MessageAttachmentsAudio.test.tsx

@@ -13,6 +13,7 @@ import { ChatMessage } from '../../../src/components/ChatMessage';
 import { createUserMessage, createAudioAttachment } from '../../utils/factories';
 
 jest.mock('../../../src/utils/messageContent', () => ({
+  ...jest.requireActual('../../../src/utils/messageContent'),
   stripControlTokens: (content: string) => content,
 }));
 

__tests__/rntl/components/ToolAccordionStreaming.test.tsx

@@ -27,6 +27,7 @@ import { createToolResultMessage } from '../../utils/factories';
 import { useAccordionStore, useAccordionExpanded } from '../../../src/stores/accordionStore';
 
 jest.mock('../../../src/utils/messageContent', () => ({
+  ...jest.requireActual('../../../src/utils/messageContent'),
   stripControlTokens: (content: string) => content,
 }));
 

__tests__/unit/audio/turnSpeech.test.ts

@@ -8,6 +8,7 @@
 jest.mock('@offgrid/core/utils/logger', () => ({ __esModule: true, default: { log: jest.fn(), warn: jest.fn(), error: jest.fn() } }));
 jest.mock('../../../pro/audio/ttsLog', () => ({ smLog: jest.fn() }));
 jest.mock('@offgrid/core/utils/messageContent', () => ({
+  ...jest.requireActual('@offgrid/core/utils/messageContent'),
   stripControlTokens: (s: string) => s,
   stripMarkdownForSpeech: (s: string) => s,
 }));

__tests__/unit/components/ChatMessage/parseModelOutput.contract.test.ts

@@ -0,0 +1,30 @@
+import { parseModelOutput } from '../../../../src/components/ChatMessage/utils';
+
+// Contract: parseModelOutput().answer is GUARANTEED free of reasoning + tool-call markup for
+// EVERY format the app can emit. This invariant makes the tool-call-leak class impossible —
+// if a new markup format is added to the parser, add it here.
+const MARKUP = /<think>|<\/think>|<\|channel|<tool_call>|<\|tool_call|<function=|<parameter=|<invoke|<function_call/;
+
+describe('parseModelOutput — answer is clean by construction (the anti-leak contract)', () => {
+  const toolBlock = '<tool_call>\n<function=search_kb>\n<parameter=query>\nAchilles\n</parameter>\n</function>\n</tool_call>';
+  const cases: Array<[string, string, string | null]> = [
+    ['inline <think>', `<think>reasoning</think>\nThe answer.`, null],
+    ['inline <think> + tool block', `<think>r</think>\n${toolBlock}`, null],
+    ['separate channel + tool block in content', toolBlock, 'the reasoning'],
+    ['Gemma channel', `<|channel>thought\nreasoning\n<channel|>The answer.`, null],
+    ['Qwen channel', `<|channel|>analysis<|message|>reasoning<|channel|>final<|message|>The answer.`, null],
+    ['gemma tool token', `Sure. <|tool_call>{"name":"x"}<tool_call|>`, null],
+    ['answer only', `Just a plain answer.`, null],
+    ['reasoning only (no answer)', `<think>only reasoning, no answer</think>`, null],
+  ];
+  it.each(cases)('%s: answer carries no markup', (_label, content, reasoning) => {
+    const { answer } = parseModelOutput(content, reasoning);
+    expect(answer).not.toMatch(MARKUP);
+  });
+
+  it('reasoning-only message does NOT duplicate reasoning into answer', () => {
+    const { reasoning, answer } = parseModelOutput('<think>abc</think>', null);
+    expect(reasoning).toContain('abc');
+    expect(answer).toBe('');
+  });
+});

__tests__/unit/hooks/useWhisperTranscription.test.ts

@@ -264,32 +264,19 @@ describe('useWhisperTranscription', () => {
     expect(result.current.isTranscribing).toBe(false);
   });
 
-  it('auto-loads model when downloadedModelId exists and model not loaded', async () => {
+  it('does NOT eager-load whisper on mount — it loads on demand, so it never fights a residency eviction', async () => {
+    // Regression for the eviction race: an eager mount effect keyed on isModelLoaded reloaded
+    // whisper the instant the residency manager evicted it for a text model. Loading is now
+    // on-demand (startRecording) + fits-gated launch preload (modelPreloader), never here.
     mockWhisperStoreState.downloadedModelId = 'whisper-base';
     mockWhisperStoreState.isModelLoaded = false;
     mockWhisperService.isModelLoaded.mockReturnValue(false);
     mockLoadModel.mockResolvedValue(undefined);
 
     renderHook(() => useWhisperTranscription());
-
-    // The useEffect runs asynchronously
-    await act(async () => {
-      // Let the effect run
-    });
-
-    expect(mockLoadModel).toHaveBeenCalled();
-  });
-
-  it('does not auto-load model when model is already loaded', async () => {
-    mockWhisperStoreState.downloadedModelId = 'whisper-base';
-    mockWhisperStoreState.isModelLoaded = true;
-    mockWhisperService.isModelLoaded.mockReturnValue(true);
-
-    renderHook(() => useWhisperTranscription());
-
     await act(async () => {});
 
-    expect(mockLoadModel).not.toHaveBeenCalled();
+    expect(mockLoadModel).not.toHaveBeenCalled(); // no eager load — eviction sticks
   });
 
   it('returns isModelLoaded true when store or service reports loaded', () => {
@@ -534,24 +521,4 @@ describe('useWhisperTranscription', () => {
     expect(result.current.isTranscribing).toBe(false);
   });
 
-  // ========================================================================
-  // auto-load: error is swallowed gracefully (lines 41-43)
-  // ========================================================================
-  it('swallows auto-load error and does not propagate', async () => {
-    mockWhisperStoreState.downloadedModelId = 'whisper-base';
-    mockWhisperStoreState.isModelLoaded = false;
-    mockWhisperService.isModelLoaded.mockReturnValue(false);
-    mockLoadModel.mockRejectedValue(new Error('Network error'));
-
-    let thrownError: unknown;
-    try {
-      const { unmount } = renderHook(() => useWhisperTranscription());
-      await act(async () => {});
-      unmount();
-    } catch (err) {
-      thrownError = err;
-    }
-
-    expect(thrownError).toBeUndefined();
-  });
 });

__tests__/unit/services/activeModelService.loaders.branches.test.ts

@@ -167,7 +167,7 @@ describe('doLoadTextModel — mmproj clear branch', () => {
 
     await doLoadTextModel(ctx);
 
-    expect(logger.warn).toHaveBeenCalledWith('[ActiveModel] Error unloading previous model, continuing:', expect.any(Error));
+    expect(logger.warn).toHaveBeenCalledWith('[ActiveModel] llama unload during model switch failed, continuing:', expect.any(Error));
     expect(ctx.onError).toHaveBeenCalled(); // reset before reassignment
     expect(ctx.onLoaded).toHaveBeenCalled();
   });
@@ -204,7 +204,7 @@ describe('doLoadLiteRTModel branches', () => {
 
     await doLoadTextModel(ctx);
 
-    expect(logger.warn).toHaveBeenCalledWith('[LiteRT] Error unloading previous model, continuing:', expect.any(Error));
+    expect(logger.warn).toHaveBeenCalledWith('[ActiveModel] LiteRT unload during model switch failed, continuing:', expect.any(Error));
     expect(ctx.onError).toHaveBeenCalled();
     expect(ToastAndroid.showWithGravity).toHaveBeenCalled();
   });