@@ -16,6 +16,7 @@ execu
 Execu
 torch
 huggingface
+apos
 bbox
 bboxes
 chatbots
@@ -33,6 +34,7 @@ microcontrollers
 notimestamps
 seqs
 smollm
+minicpm
 llms
 qwen
 XNNPACK
 
@@ -12,6 +12,7 @@ import {
   Alert,
   Image as RNImage,
   Modal,
+  Switch,
 } from 'react-native';
 import { Skia } from '@shopify/react-native-skia';
 import RNBlobUtil from 'react-native-blob-util';
@@ -22,7 +23,12 @@ import ScreenWrapper from '../../components/ScreenWrapper';
 import { ModelPicker, type ModelOption } from '../../components/ModelPicker';
 import { Button } from '../../components/Button';
 import { getImage, skImageToBuffer } from '../../utils';
-import { LLM_MODELS, type LLMModelConfig, type LLMBackend } from '../../constants/llm';
+import {
+  LLM_MODELS,
+  parseMiniCpmToolCalls,
+  type LLMModelConfig,
+  type LLMBackend,
+} from '../../constants/llm';
 
 type Turn = {
   role: 'user' | 'assistant' | 'tool';
@@ -93,12 +99,23 @@ function LLMContent() {
     [activeModel]
   );
 
+  const [enableThinking, setEnableThinking] = useState(false);
+  const thinkingRef = useRef(enableThinking);
+  const supportsThinkingSwitch = activeModel.supportsThinkingSwitch !== false;
+  const toolOpts = useMemo(() => {
+    if (activeModel.toolOpts?.parseToolCalls !== parseMiniCpmToolCalls) return activeModel.toolOpts;
+    return {
+      ...activeModel.toolOpts,
+      parseToolCalls: (text: string) => parseMiniCpmToolCalls(text, thinkingRef.current),
+    };
+  }, [activeModel]);
+
   const { isReady, downloadProgress, error, sendMessage, stop, resource, getKVCacheState } =
     useLLMChatSession(activeModel.model, {
       initialMessages,
       generationConfig: activeModel.generationConfig,
       stopRegex: activeModel.stopRegex,
-      toolOpts: activeModel.toolOpts,
+      toolOpts,
       preventLoad: !isDownloadStarted,
     });
 
@@ -286,9 +303,13 @@ function LLMContent() {
         payload = textMessage;
       }
 
-      const result = await sendMessage(payload, (token) => {
-        setStreamingResponse((prev) => (prev !== null ? prev + token : token));
-      });
+      const result = await sendMessage(
+        payload,
+        (token) => {
+          setStreamingResponse((prev) => (prev !== null ? prev + token : token));
+        },
+        { enableThinking: supportsThinkingSwitch ? enableThinking : undefined }
+      );
 
       let assistantIdx = 0;
       const generatedTurns: Turn[] = result.messages
@@ -343,6 +364,20 @@ function LLMContent() {
           selectedValue={selectedModelId}
           onValueChange={handleModelChange}
         />
+        <View style={styles.thinkingRow}>
+          <Text style={styles.thinkingLabel}>
+            {supportsThinkingSwitch ? 'Thinking' : 'Thinking (always on)'}
+          </Text>
+          <Switch
+            accessibilityLabel="Thinking"
+            value={supportsThinkingSwitch ? enableThinking : true}
+            onValueChange={(value) => {
+              thinkingRef.current = value;
+              setEnableThinking(value);
+            }}
+            disabled={isGenerating || !supportsThinkingSwitch}
+          />
+        </View>
         {resource && (
           <TouchableOpacity
             style={styles.unlinkButton}
@@ -674,6 +709,13 @@ const styles = StyleSheet.create({
     marginBottom: 8,
     marginLeft: 4,
   },
+  thinkingRow: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    marginBottom: 8,
+  },
+  thinkingLabel: { color: '#212529', fontSize: 14, fontWeight: '600' },
   unlinkButtonText: {
     color: '#e03131',
     fontSize: 12,
 
@@ -284,6 +284,80 @@ export function parseLfmToolCalls(text: string): llm.ToolParserResult | undefine
   return { toolCalls, textContent: textContent || undefined };
 }
 
+function decodeMiniCpmArgument(value: string): string {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('<![CDATA[') && trimmed.endsWith(']]>')) {
+    return trimmed.slice(9, -3);
+  }
+  const entities: Record<string, string> = {
+    amp: '&',
+    lt: '<',
+    gt: '>',
+    quot: '"',
+    apos: "'",
+  };
+  return trimmed.replace(/&(#x[\da-f]+|#\d+|amp|lt|gt|quot|apos);/gi, (_, entity: string) => {
+    if (entity.startsWith('#')) {
+      const code = entity.slice(1).toLowerCase();
+      return String.fromCodePoint(
+        code.startsWith('x') ? parseInt(code.slice(1), 16) : Number(code)
+      );
+    }
+    return entities[entity.toLowerCase()]!;
+  });
+}
+
+export function parseMiniCpmToolCalls(
+  text: string,
+  enableThinking = true
+): llm.ToolParserResult | undefined {
+  const thinkingEnd = text.lastIndexOf('</think>');
+  if (thinkingEnd === -1 && (enableThinking || text.includes('<think>'))) return undefined;
+  const answer = thinkingEnd === -1 ? text : text.slice(thinkingEnd + '</think>'.length);
+  const callRegex =
+    /<function\s+name=(["'])([^"']+)\1\s*>((?:<!\[CDATA\[[\s\S]*?\]\]>|[\s\S])*?)<\/function>/g;
+  const toolCalls: llm.ToolCall[] = [];
+
+  for (const match of answer.matchAll(callRegex)) {
+    const name = match[2]!;
+    const body = match[3]!;
+    const tool = TOOLS.find((candidate) => candidate.function.name === name);
+    if (!tool) return undefined;
+    const params = tool.function.parameters;
+    const paramRegex =
+      /<param\s+name=(["'])([^"']+)\1\s*>((?:<!\[CDATA\[[\s\S]*?\]\]>|[\s\S])*?)<\/param>/g;
+    const args: Record<string, unknown> = {};
+
+    try {
+      for (const param of body.matchAll(paramRegex)) {
+        const key = param[2]!;
+        const schema = params?.properties?.[key] as { type?: string } | undefined;
+        if (!schema || Object.prototype.hasOwnProperty.call(args, key)) return undefined;
+        const value = decodeMiniCpmArgument(param[3]!);
+        const parsed = schema.type === 'string' ? value : JSON.parse(value);
+        if (schema.type === 'number' && (typeof parsed !== 'number' || !Number.isFinite(parsed))) {
+          return undefined;
+        }
+        args[key] = parsed;
+      }
+    } catch {
+      return undefined;
+    }
+    if (body.replace(paramRegex, '').trim()) return undefined;
+    if (params?.required?.some((key) => !Object.prototype.hasOwnProperty.call(args, key))) {
+      return undefined;
+    }
+    toolCalls.push({ type: 'function', function: { name, arguments: args } });
+  }
+
+  if (toolCalls.length === 0) return undefined;
+  const textContent = answer
+    .replace(callRegex, '')
+    .replace(/<\|im_end\|>/g, '')
+    .trim();
+  return { toolCalls, textContent: textContent || undefined };
+}
+
 export const QWEN_TOOL_STOP_REGEX = /(?:<\/tool_call>|<\|im_end\|>)/;
 
 export function parseQwenToolCalls(text: string): llm.ToolParserResult | undefined {
@@ -375,6 +449,14 @@ export function parseLlamaToolCalls(text: string): llm.ToolParserResult | undefi
 
 // --- Model Family Generation Configurations ---
 
+/** Sampling defaults recommended by the MiniCPM5-2B model card. */
+export const MINICPM5_GENERATION_CONFIG: llm.LLMGenerationConfig = {
+  temperature: 1.0,
+  topP: 0.95,
+  minP: 0.0,
+  maxNewTokens: 512,
+};
+
 /**
  * Liquid AI LFM 2.5 recommended generation parameters.
  * Sampling parameters are specified in the official Liquid AI GGUF model cards
@@ -532,6 +614,11 @@ export const LFM_TOOL_OPTS: LLMToolOpts = {
   parseToolCalls: parseLfmToolCalls,
 };
 
+export const MINICPM5_TOOL_OPTS: LLMToolOpts = {
+  tools: TOOLS,
+  parseToolCalls: parseMiniCpmToolCalls,
+};
+
 export const GEMMA_TOOL_OPTS: LLMToolOpts = {
   tools: TOOLS,
   parseToolCalls: parseGemmaToolCalls,
@@ -566,14 +653,37 @@ export interface LLMModelConfig {
   stopRegex?: RegExp;
   toolOpts: LLMToolOpts | undefined;
   iosOnly?: boolean;
+  supportsThinkingSwitch?: boolean;
 }
 
 // --- Quantized LLM Models List ---
 
 export const LLM_MODELS: LLMModelConfig[] = [
+  // MiniCPM5
+  {
+    id: 'minicpm-5-2b-xnnpack',
+    name: 'MiniCPM5 2B',
+    backend: 'xnnpack',
+    model: models.llm.MINICPM5_2B.XNNPACK_8DA4W,
+    generationConfig: MINICPM5_GENERATION_CONFIG,
+    systemPrompt: `${DEFAULT_SYSTEM_PROMPT}. Always reply in the language of the user's latest message.`,
+    toolOpts: MINICPM5_TOOL_OPTS,
+  },
+  {
+    id: 'minicpm-5-2b-mlx',
+    name: 'MiniCPM5 2B',
+    backend: 'mlx',
+    model: models.llm.MINICPM5_2B.MLX_INT4,
+    generationConfig: MINICPM5_GENERATION_CONFIG,
+    systemPrompt: `${DEFAULT_SYSTEM_PROMPT}. Always reply in the language of the user's latest message.`,
+    toolOpts: MINICPM5_TOOL_OPTS,
+    iosOnly: true,
+  },
+
   // LFM 2.5 family
   {
     id: 'lfm-2.5-2.6b-xnnpack',
+    supportsThinkingSwitch: false,
     name: 'LFM 2.5 2.6B',
     backend: 'xnnpack',
     model: models.llm.LFM2_5_2_6B.XNNPACK_8DA4W,
@@ -584,6 +694,7 @@ export const LLM_MODELS: LLMModelConfig[] = [
   },
   {
     id: 'lfm-2.5-2.6b-mlx',
+    supportsThinkingSwitch: false,
     name: 'LFM 2.5 2.6B',
     backend: 'mlx',
     model: models.llm.LFM2_5_2_6B.MLX_INT4,
@@ -1107,7 +1218,7 @@ export const LLM_MODELS: LLMModelConfig[] = [
     backend: 'xnnpack',
     model: models.llm.BIELIK_V3_1_5B.XNNPACK_8DA4W,
     generationConfig: BIELIK_V3_GENERATION_CONFIG,
-    // eslint-disable-next-line @cspell/spellchecker
+    // cspell:disable-next-line
     systemPrompt: 'Jesteś pomocnym asystentem AI mówiącym po polsku.',
     stopRegex: undefined,
     toolOpts: undefined,
 
@@ -151,6 +151,21 @@ type LLMChatTurnResult = {
 
 Under the hood, [`createChatPreprocessor`](../../06-api-reference/react-native-executorch/namespaces/llm/functions/createChatPreprocessor.md) renders [`ChatMessage[]`](../../06-api-reference/react-native-executorch/namespaces/llm/type-aliases/ChatMessage.md) arrays using the model's official Jinja2 template from `tokenizer_config.json` (formatting special tokens, roles, and generation headers).
 
+For models that support answering without thinking, set
+`generationConfig: { enableThinking: false }` in `useLLMChatSession` or
+`createLLMChatSession`. Override it per turn with
+`session.sendMessage(message, onToken, { enableThinking: true })`. Direct
+preprocessor users can pass `enableThinking` in the options to `render()` or
+`process()`.
+
+This exposes `enable_thinking` to Jinja. The template must honor this switch;
+a template that always appends `<think>` needs to be corrected separately. Omit
+the option to preserve the template's default. The raw runner accepts already
+formatted prompts and ignores this field. When thinking is disabled, tool parsers
+must accept answers without a generated `</think>` tag. Switching thinking modes
+between turns assumes the template preserves previously cached messages; use
+`resetOnTurn: true` if the switch also changes how earlier messages are rendered.
+
 To keep multi-turn chat responsive without re-encoding past history on every message, the preprocessor uses incremental prompt diffing:
 
 1. It verifies that the rendered prefix of previously committed turns is an exact substring match of the newly updated conversation.
@@ -381,6 +396,7 @@ The library provides ready-to-use models from the [Software Mansion HuggingFace
 | **Microsoft Phi-4 Mini** | [`3.8B`](../../06-api-reference/variables/models.md#llmphi4_mini)                                                                                                                                                  | 2.62 GB – 7.15 GB | XNNPACK (CPU), MLX (Apple)                   | High-density reasoning model for STEM problem solving & coding.             |
 | **HuggingFace SmolLM2**  | [`135M`](../../06-api-reference/variables/models.md#llmsmollm2_135m), [`360M`](../../06-api-reference/variables/models.md#llmsmollm2_360m), [`1.7B`](../../06-api-reference/variables/models.md#llmsmollm2_1_7b)   | 158 MB – 1.83 GB  | XNNPACK (CPU), MLX (Apple)                   | Smallest footprint family, for constrained devices and fast drafting.       |
 | **SpeakLeash Bielik v3** | [`1.5B`](../../06-api-reference/variables/models.md#llmbielik_v3_1_5b)                                                                                                                                             | 923 MB – 2.97 GB  | XNNPACK (CPU)                                | Bilingual Polish & English instruction model.                               |
+| **OpenBMB MiniCPM5**     | [`2B`](../../06-api-reference/variables/models.md#llmminicpm5_2b)                                                                                                                                                  | 1.36 GB – 1.42 GB | XNNPACK (CPU), MLX (Apple)                   | Compact reasoning model with thinking and tool calling.                     |
 
 :::tip Using Custom Models
 To use your own fine-tuned LLM `.pte` model, pass an [`LLMModel`](../../06-api-reference/type-aliases/LLMModel.md) configuration object to [`useLLMChatSession`](../../06-api-reference/functions/useLLMChatSession.md) or [`createLLMChatSession`](../../06-api-reference/functions/createLLMChatSession.md):