diff --git a/src/_locales/en/main.json b/src/_locales/en/main.json
index 8ad74e6ef..7f666c256 100644
--- a/src/_locales/en/main.json
+++ b/src/_locales/en/main.json
@@ -124,10 +124,18 @@
   "Override provider temperature": "Override provider temperature",
   "The temperature parameter is not sent. The provider or model default is used.": "The temperature parameter is not sent. The provider or model default is used.",
   "The current model does not accept a custom temperature. The parameter will not be sent.": "The current model does not accept a custom temperature. The parameter will not be sent.",
+  "Extra Request Body (JSON)": "Extra Request Body (JSON)",
+  "Merged into the API request body. Must be a JSON object, other values are ignored.": "Merged into the API request body. Must be a JSON object, other values are ignored.",
+  "Invalid JSON object, this value is ignored.": "Invalid JSON object, this value is ignored.",
   "API Url": "API Url",
   "Provider": "Provider",
   "Others": "Others",
   "API Modes": "API Modes",
+  "Test": "Test",
+  "Testing...": "Testing...",
+  "Reachable": "Reachable",
+  "Unreachable": "Unreachable",
+  "Not testable": "Not testable",
   "Disable web mode history for better privacy protection, but it will result in unavailable conversations after a period of time": "Disable web mode history for better privacy protection, but it will result in unavailable conversations after a period of time",
   "Display selection tools next to input box to avoid blocking": "Display selection tools next to input box to avoid blocking",
   "Close All Chats In This Page": "Close All Chats In This Page",
diff --git a/src/_locales/zh-hans/main.json b/src/_locales/zh-hans/main.json
index cfad6d2d1..d2b20e24a 100644
--- a/src/_locales/zh-hans/main.json
+++ b/src/_locales/zh-hans/main.json
@@ -118,10 +118,18 @@
   "Override provider temperature": "覆盖提供商的温度参数",
   "The temperature parameter is not sent. The provider or model default is used.": "不会发送温度参数，将使用提供商或模型的默认值。",
   "The current model does not accept a custom temperature. The parameter will not be sent.": "当前模型不接受自定义温度参数，因此不会发送该参数。",
+  "Extra Request Body (JSON)": "额外请求参数 (JSON)",
+  "Merged into the API request body. Must be a JSON object, other values are ignored.": "会合并进 API 请求体，必须是 JSON 对象，其他类型的值会被忽略。",
+  "Invalid JSON object, this value is ignored.": "不是合法的 JSON 对象，该值会被忽略。",
   "API Url": "API地址",
   "Provider": "提供商",
   "Others": "其他",
   "API Modes": "API模式",
+  "Test": "测试",
+  "Testing...": "测试中…",
+  "Reachable": "可连通",
+  "Unreachable": "无法连通",
+  "Not testable": "无法测试",
   "Disable web mode history for better privacy protection, but it will result in unavailable conversations after a period of time": "禁用网页版模式历史记录以获得更好的隐私保护, 但会导致对话在一段时间后不可用",
   "Display selection tools next to input box to avoid blocking": "将选择浮动工具显示在输入框旁边以避免遮挡",
   "Close All Chats In This Page": "关闭本页所有聊天",
diff --git a/src/_locales/zh-hant/main.json b/src/_locales/zh-hant/main.json
index 3dd20a229..50cadc6f0 100644
--- a/src/_locales/zh-hant/main.json
+++ b/src/_locales/zh-hant/main.json
@@ -118,10 +118,18 @@
   "Override provider temperature": "覆寫供應商的溫度參數",
   "The temperature parameter is not sent. The provider or model default is used.": "不會傳送溫度參數，將使用供應商或模型的預設值。",
   "The current model does not accept a custom temperature. The parameter will not be sent.": "目前的模型不接受自訂溫度參數，因此不會傳送這個參數。",
+  "Extra Request Body (JSON)": "額外請求參數 (JSON)",
+  "Merged into the API request body. Must be a JSON object, other values are ignored.": "會合併進 API 請求主體，必須是 JSON 物件，其他類型的值會被忽略。",
+  "Invalid JSON object, this value is ignored.": "不是合法的 JSON 物件，這個值會被忽略。",
   "API Url": "API 網址",
   "Provider": "供應商",
   "Others": "其他",
   "API Modes": "API 模式",
+  "Test": "測試",
+  "Testing...": "測試中…",
+  "Reachable": "可連線",
+  "Unreachable": "無法連線",
+  "Not testable": "無法測試",
   "Disable web mode history for better privacy protection, but it will result in unavailable conversations after a period of time": "停用網頁版模式歷史記錄以提升隱私保護，但會導致對話記錄在一段時間後無法使用",
   "Display selection tools next to input box to avoid blocking": "將選擇浮動工具顯示在輸入框旁邊以避免遮擋",
   "Close All Chats In This Page": "關閉本頁所有對話",
diff --git a/src/background/index.mjs b/src/background/index.mjs
index 79b4f0c0d..177e7c054 100644
--- a/src/background/index.mjs
+++ b/src/background/index.mjs
@@ -47,10 +47,12 @@ import {
 import { refreshMenu } from './menus.mjs'
 import { registerCommands } from './commands.mjs'
 import { generateAnswersWithBardWebApi } from '../services/apis/bard-web.mjs'
+import { testConnection } from '../services/apis/test-connection.mjs'
 import { generateAnswersWithClaudeWebApi } from '../services/apis/claude-web.mjs'
 import { generateAnswersWithMoonshotWebApi } from '../services/apis/moonshot-web.mjs'
 import { isUsingModelName } from '../utils/model-name-convert.mjs'
 import { redactSensitiveFields } from './redact.mjs'
+import { isTrustedExtensionSender } from './message-sender.mjs'
 import {
   clearProxyReconnectErrorSuppression,
   consumeProxyReconnectErrorSuppression,
@@ -615,6 +617,17 @@ Browser.runtime.onMessage.addListener(async (message, sender) => {
         await deleteConversation(token, message.data.conversationId)
         break
       }
+      case 'TEST_API_CONNECTION': {
+        if (!isTrustedExtensionSender(sender)) {
+          console.warn(
+            '[background] Rejecting TEST_API_CONNECTION message from untrusted sender:',
+            sender,
+          )
+          return { ok: false, elapsedMs: 0, error: 'unauthorized-sender' }
+        }
+        console.log('[background] Processing TEST_API_CONNECTION message')
+        return testConnection(message.data.session)
+      }
       case 'NEW_URL': {
         console.log('[background] Processing NEW_URL message:', message.data)
         await Browser.tabs.create({
@@ -693,13 +706,7 @@ Browser.runtime.onMessage.addListener(async (message, sender) => {
         break
       }
       case 'FETCH': {
-        const senderId = sender?.id
-        const senderUrl = sender?.url || sender?.documentUrl || sender?.origin
-        const extensionOrigin = new URL(Browser.runtime.getURL('/')).origin
-        const isTrustedExtensionSenderWithoutId =
-          !senderId && typeof senderUrl === 'string' && senderUrl.startsWith(`${extensionOrigin}/`)
-
-        if (senderId !== Browser.runtime.id && !isTrustedExtensionSenderWithoutId) {
+        if (!isTrustedExtensionSender(sender)) {
           console.warn('[background] Rejecting FETCH message from untrusted sender:', sender)
           return [null, { message: 'Unauthorized sender' }]
         }
diff --git a/src/background/message-sender.mjs b/src/background/message-sender.mjs
new file mode 100644
index 000000000..8dc0ae6ec
--- /dev/null
+++ b/src/background/message-sender.mjs
@@ -0,0 +1,16 @@
+import Browser from 'webextension-polyfill'
+
+/**
+ * Messages that answer with data or reach stored credentials must come from extension
+ * code. A sender that reports an id is trusted only when it is this extension; extension
+ * pages in some browsers report no id, so their own URL is the fallback signal.
+ * @param {{id?: string, url?: string, documentUrl?: string, origin?: string}} sender
+ * @returns {boolean}
+ */
+export function isTrustedExtensionSender(sender) {
+  if (sender?.id === Browser.runtime.id) return true
+  if (sender?.id) return false
+  const senderUrl = sender?.url || sender?.documentUrl || sender?.origin
+  if (typeof senderUrl !== 'string') return false
+  return senderUrl.startsWith(Browser.runtime.getURL('/'))
+}
diff --git a/src/config/index.mjs b/src/config/index.mjs
index 81c956e46..1f1853fda 100644
--- a/src/config/index.mjs
+++ b/src/config/index.mjs
@@ -855,6 +855,7 @@ export const defaultConfig = {
   maxConversationContextLength: 9,
   temperatureOverrideEnabled: false,
   temperature: 1,
+  extraBody: '',
   customChatGptWebApiUrl: 'https://chatgpt.com',
   customChatGptWebApiPath: '/backend-api/conversation',
   customOpenAiApiUrl: 'https://api.openai.com',
diff --git a/src/popup/sections/AdvancedPart.jsx b/src/popup/sections/AdvancedPart.jsx
index 017b9191f..134535198 100644
--- a/src/popup/sections/AdvancedPart.jsx
+++ b/src/popup/sections/AdvancedPart.jsx
@@ -3,6 +3,7 @@ import { parseFloatWithClamp, parseIntWithClamp } from '../../utils/index.mjs'
 import { getModelValue } from '../../utils/model-name-convert.mjs'
 import { isUsingAzureOpenAiApiModel } from '../../config/index.mjs'
 import { canApplyTemperatureOverride } from '../../services/apis/temperature-params.mjs'
+import { parseExtraBody } from '../../services/apis/extra-body-params.mjs'
 import PropTypes from 'prop-types'
 import { Tab, TabList, TabPanel, Tabs } from 'react-tabs'
 import Browser from 'webextension-polyfill'
@@ -22,6 +23,8 @@ function ApiParams({ config, updateConfig }) {
     ? config.customModelName
     : getModelValue(config)
   const temperatureOverrideAvailable = canApplyTemperatureOverride(selectedModel)
+  const extraBodyValue = typeof config.extraBody === 'string' ? config.extraBody : ''
+  const extraBodyInvalid = extraBodyValue.trim() !== '' && !parseExtraBody(extraBodyValue)
 
   return (
     <>
@@ -89,6 +92,21 @@ function ApiParams({ config, updateConfig }) {
           />
         </label>
       )}
+      <label>
+        {t('Extra Request Body (JSON)')}
+        <textarea
+          value={extraBodyValue}
+          placeholder={'{\n  "reasoning_effort": "high"\n}'}
+          onChange={(e) => {
+            updateConfig({ extraBody: e.target.value })
+          }}
+        />
+      </label>
+      <small>
+        {extraBodyInvalid
+          ? t('Invalid JSON object, this value is ignored.')
+          : t('Merged into the API request body. Must be a JSON object, other values are ignored.')}
+      </small>
     </>
   )
 }
diff --git a/src/popup/sections/ApiModes.jsx b/src/popup/sections/ApiModes.jsx
index 5f39e0fa0..6daf66ceb 100644
--- a/src/popup/sections/ApiModes.jsx
+++ b/src/popup/sections/ApiModes.jsx
@@ -13,6 +13,12 @@ import {
   getCustomOpenAIProviders,
   OPENAI_COMPATIBLE_GROUP_TO_PROVIDER_ID,
 } from '../../services/apis/provider-registry.mjs'
+import { canTestConnectionSession } from '../../services/apis/connection-test-groups.mjs'
+import {
+  getConnectionTestButtonStyle,
+  getConnectionTestLabel,
+  getConnectionTestTitle,
+} from './connection-test-status.mjs'
 import {
   applySelectedProviderToApiMode,
   applyDeletedProviderSecrets,
@@ -72,6 +78,20 @@ const defaultProviderDraftValidation = {
   apiUrl: false,
 }
 
+// Results are keyed by what the mode is, not by where it happens to sit in the list, so
+// reordering or deleting a row cannot attach a result to a different provider.
+function getConnectionTestKey(apiMode) {
+  return [
+    apiMode?.groupName,
+    apiMode?.itemName,
+    apiMode?.customName,
+    apiMode?.providerId,
+    apiMode?.customUrl,
+  ]
+    .map((part) => String(part ?? '').trim())
+    .join('\u0000')
+}
+
 export function ApiModes({ config, updateConfig }) {
   const { t } = useTranslation()
   const [editing, setEditing] = useState(false)
@@ -88,6 +108,7 @@ export function ApiModes({ config, updateConfig }) {
   const [providerSelector, setProviderSelector] = useState(LEGACY_CUSTOM_PROVIDER_ID)
   const [isProviderEditorOpen, setIsProviderEditorOpen] = useState(false)
   const [providerEditingId, setProviderEditingId] = useState('')
+  const [connectionTests, setConnectionTests] = useState({})
   const [providerDraft, setProviderDraft] = useState(defaultProviderDraft)
   const [providerDraftValidation, setProviderDraftValidation] = useState(
     defaultProviderDraftValidation,
@@ -269,6 +290,25 @@ export function ApiModes({ config, updateConfig }) {
     setIsProviderEditorOpen(true)
   }
 
+  const runConnectionTest = async (apiMode) => {
+    const key = getConnectionTestKey(apiMode)
+    // A probe in flight owns the row: a second click would race it for the same result.
+    if (connectionTests[key]?.pending) return
+    setConnectionTests((current) => ({ ...current, [key]: { pending: true } }))
+    let result
+    try {
+      result = await Browser.runtime.sendMessage({
+        type: 'TEST_API_CONNECTION',
+        data: { session: { apiMode } },
+      })
+    } catch (error) {
+      result = { ok: false, error: error?.message ?? String(error) }
+    }
+    setConnectionTests((current) => ({ ...current, [key]: { ...result, pending: false } }))
+  }
+
+  const getConnectionTest = (apiMode) => connectionTests[getConnectionTestKey(apiMode)]
+
   const onSaveProviderEditing = (event) => {
     event.preventDefault()
     const providerName = providerDraft.name.trim()
@@ -629,7 +669,26 @@ export function ApiModes({ config, updateConfig }) {
               />
               {getApiModeDisplayLabel(apiMode, t, effectiveProviders)}
               <div style={{ flexGrow: 1 }} />
-              <div style={{ display: 'flex', gap: '12px' }}>
+              <div style={{ display: 'flex', gap: '12px', alignItems: 'center' }}>
+                {canTestConnectionSession({ apiMode }) && (
+                  <button
+                    type="button"
+                    title={getConnectionTestTitle(getConnectionTest(apiMode), t)}
+                    disabled={Boolean(getConnectionTest(apiMode)?.pending)}
+                    style={{
+                      cursor: 'pointer',
+                      width: 'auto',
+                      marginBottom: 0,
+                      ...getConnectionTestButtonStyle(getConnectionTest(apiMode)),
+                    }}
+                    onClick={(e) => {
+                      e.preventDefault()
+                      runConnectionTest(apiMode)
+                    }}
+                  >
+                    {getConnectionTestLabel(getConnectionTest(apiMode), t)}
+                  </button>
+                )}
                 <div
                   style={{ cursor: 'pointer' }}
                   onClick={(e) => {
diff --git a/src/popup/sections/GeneralPart.jsx b/src/popup/sections/GeneralPart.jsx
index 2bff96d4f..b7b14a9b2 100644
--- a/src/popup/sections/GeneralPart.jsx
+++ b/src/popup/sections/GeneralPart.jsx
@@ -20,6 +20,11 @@ import PropTypes from 'prop-types'
 import { config as menuConfig } from '../../content-script/menu-tools'
 import { PencilIcon } from '@primer/octicons-react'
 import { importDataIntoStorage } from './import-data-cleanup.mjs'
+import {
+  getConnectionTestButtonStyle,
+  getConnectionTestLabel,
+  getConnectionTestTitle,
+} from './connection-test-status.mjs'
 import { resolveOpenAICompatibleRequest } from '../../services/apis/provider-registry.mjs'
 import {
   getApiModeDisplayLabel,
@@ -100,6 +105,35 @@ export function GeneralPart({
 }) {
   const { t, i18n } = useTranslation()
   const [apiModes, setApiModes] = useState([])
+  const [connectionTest, setConnectionTest] = useState(null)
+  // A result describes the endpoint it was actually sent to, so the URL, model and key it
+  // ran with are part of its identity; editing any of them retires the result.
+  const customModelTestSignature = [
+    config.customModelApiUrl,
+    config.customModelName,
+    config.customApiKey,
+  ]
+    .map((part) => String(part ?? ''))
+    .join('\u0000')
+  const customModelTest =
+    connectionTest?.signature === customModelTestSignature ? connectionTest : null
+
+  const runCustomModelConnectionTest = async () => {
+    // Ignore repeat clicks while a probe is running, so a stale result cannot win.
+    if (connectionTest?.pending) return
+    const signature = customModelTestSignature
+    setConnectionTest({ pending: true, signature })
+    let result
+    try {
+      result = await Browser.runtime.sendMessage({
+        type: 'TEST_API_CONNECTION',
+        data: { session: { modelName: 'customModel' } },
+      })
+    } catch (error) {
+      result = { ok: false, error: error?.message ?? String(error) }
+    }
+    setConnectionTest({ ...result, pending: false, signature })
+  }
   const [providerApiKeyDraft, setProviderApiKeyDraft] = useState('')
   const [isOverrideProviderKeyActionPending, setIsOverrideProviderKeyActionPending] =
     useState(false)
@@ -701,15 +735,29 @@ export function GeneralPart({
             </span>
           )}
         {isUsingSpecialCustomModel(config) && (
-          <input
-            type="text"
-            value={config.customModelApiUrl}
-            placeholder={t('Custom Model API Url')}
-            onChange={(e) => {
-              const value = e.target.value
-              updateConfig({ customModelApiUrl: value })
-            }}
-          />
+          <div style={{ display: 'flex', gap: '10px', alignItems: 'center' }}>
+            <input
+              type="text"
+              value={config.customModelApiUrl}
+              placeholder={t('Custom Model API Url')}
+              onChange={(e) => {
+                const value = e.target.value
+                updateConfig({ customModelApiUrl: value })
+              }}
+            />
+            <button
+              type="button"
+              title={getConnectionTestTitle(customModelTest, t)}
+              disabled={Boolean(customModelTest?.pending)}
+              style={{
+                whiteSpace: 'nowrap',
+                ...getConnectionTestButtonStyle(customModelTest),
+              }}
+              onClick={runCustomModelConnectionTest}
+            >
+              {getConnectionTestLabel(customModelTest, t)}
+            </button>
+          </div>
         )}
         {isUsingOllamaApiModel(config) && (
           <div style={{ display: 'flex', gap: '10px' }}>
diff --git a/src/popup/sections/connection-test-status.mjs b/src/popup/sections/connection-test-status.mjs
new file mode 100644
index 000000000..0caf6fc80
--- /dev/null
+++ b/src/popup/sections/connection-test-status.mjs
@@ -0,0 +1,53 @@
+const PENDING_COLOR = '#9a6700'
+const REACHABLE_COLOR = '#2da44e'
+const UNREACHABLE_COLOR = '#d1242f'
+// A mode with no request shape to send is neither up nor down, so it stays neutral.
+const UNSUPPORTED_COLOR = '#57606a'
+
+function getConnectionTestColor(test) {
+  if (test.pending) return PENDING_COLOR
+  if (test.unsupported) return UNSUPPORTED_COLOR
+  return test.ok ? REACHABLE_COLOR : UNREACHABLE_COLOR
+}
+
+/**
+ * The Test button doubles as the result display: only its colour changes, so the row
+ * layout stays stable and no extra status text is rendered next to it.
+ * @param {{pending?: boolean, ok?: boolean, unsupported?: boolean} | undefined} test
+ * @returns {Record<string, string> | undefined}
+ */
+export function getConnectionTestButtonStyle(test) {
+  if (!test) return undefined
+  const color = getConnectionTestColor(test)
+  return { color, borderColor: color }
+}
+
+/**
+ * The button label carries the result, so the row needs no separate status element.
+ * @param {{pending?: boolean, ok?: boolean, unsupported?: boolean, elapsedMs?: number}
+ *   | undefined} test
+ * @param {(key: string) => string} t
+ * @returns {string}
+ */
+export function getConnectionTestLabel(test, t) {
+  if (!test) return t('Test')
+  if (test.pending) return t('Testing...')
+  if (test.unsupported) return t('Not testable')
+  if (test.ok) return `${t('Reachable')} ${test.elapsedMs}ms`
+  return t('Unreachable')
+}
+
+/**
+ * The result detail stays available as the button's tooltip.
+ * @param {{pending?: boolean, ok?: boolean, unsupported?: boolean, error?: string,
+ *   elapsedMs?: number} | undefined} test
+ * @param {(key: string) => string} t
+ * @returns {string}
+ */
+export function getConnectionTestTitle(test, t) {
+  if (!test) return ''
+  if (test.pending) return t('Testing...')
+  if (test.unsupported) return t('Not testable')
+  if (test.ok) return `${t('Reachable')} ${test.elapsedMs}ms`
+  return test.error ? `${t('Unreachable')}: ${test.error}` : t('Unreachable')
+}
diff --git a/src/services/apis/azure-openai-api.mjs b/src/services/apis/azure-openai-api.mjs
index f5e1b4b6d..7eb4850ad 100644
--- a/src/services/apis/azure-openai-api.mjs
+++ b/src/services/apis/azure-openai-api.mjs
@@ -5,6 +5,7 @@ import { fetchSSE } from '../../utils/fetch-sse.mjs'
 import { isEmpty } from 'lodash-es'
 import { getModelValue } from '../../utils/model-name-convert.mjs'
 import { getTemperatureParams } from './temperature-params.mjs'
+import { getExtraBodyParams } from './extra-body-params.mjs'
 
 /**
  * @param {Runtime.Port} port
@@ -42,6 +43,7 @@ export async function generateAnswersWithAzureOpenaiApi(port, question, session)
         max_tokens: config.maxResponseTokenLength,
         // Azure deployment names are opaque aliases, not canonical model identifiers.
         ...getTemperatureParams(config),
+        ...getExtraBodyParams(config),
       }),
       onMessage(message) {
         console.debug('sse message', message)
diff --git a/src/services/apis/claude-api.mjs b/src/services/apis/claude-api.mjs
index 5d298877a..e6e56ee13 100644
--- a/src/services/apis/claude-api.mjs
+++ b/src/services/apis/claude-api.mjs
@@ -5,8 +5,9 @@ import { isEmpty } from 'lodash-es'
 import { getConversationPairs } from '../../utils/get-conversation-pairs.mjs'
 import { getModelValue } from '../../utils/model-name-convert.mjs'
 import { getTemperatureParams } from './temperature-params.mjs'
+import { getExtraBodyParams } from './extra-body-params.mjs'
 
-function getThinkingConfig(model) {
+export function getThinkingConfig(model) {
   if (model === 'claude-sonnet-5') return { type: 'disabled' }
   if (model === 'claude-sonnet-5-5') return { type: 'between_tools' }
 }
@@ -37,6 +38,8 @@ export async function generateAnswersWithClaudeApi(port, question, session) {
   }
   const thinking = getThinkingConfig(model)
   if (thinking) body.thinking = thinking
+  // The user-provided body wins over the built-in defaults above.
+  Object.assign(body, getExtraBodyParams(config))
 
   let answer = ''
   let stopReason = ''
diff --git a/src/services/apis/connection-test-groups.mjs b/src/services/apis/connection-test-groups.mjs
new file mode 100644
index 000000000..42101affa
--- /dev/null
+++ b/src/services/apis/connection-test-groups.mjs
@@ -0,0 +1,26 @@
+import { OPENAI_COMPATIBLE_GROUP_TO_PROVIDER_ID } from '../../config/openai-provider-mappings.mjs'
+
+/**
+ * API modes probed through their own protocol rather than the OpenAI-compatible path.
+ */
+export const NATIVE_CONNECTION_TEST_GROUPS = ['azureOpenAiApiModelKeys', 'claudeApiModelKeys']
+
+/**
+ * Modes the Test action can actually exercise. Browser/cookie modes and the
+ * third-party relay have no request shape we can send, so their rows stay untestable.
+ */
+export const CONNECTION_TESTABLE_GROUPS = new Set([
+  ...Object.keys(OPENAI_COMPATIBLE_GROUP_TO_PROVIDER_ID),
+  ...NATIVE_CONNECTION_TEST_GROUPS,
+])
+
+/**
+ * @param {{apiMode?: object, modelName?: string}} session
+ * @returns {boolean} whether a connection test can be run for this session
+ */
+export function canTestConnectionSession(session) {
+  const groupName = session?.apiMode?.groupName
+  if (groupName) return CONNECTION_TESTABLE_GROUPS.has(groupName)
+  // The custom model on the General tab has no API mode of its own.
+  return session?.modelName === 'customModel'
+}
diff --git a/src/services/apis/extra-body-params.mjs b/src/services/apis/extra-body-params.mjs
new file mode 100644
index 000000000..fc2655700
--- /dev/null
+++ b/src/services/apis/extra-body-params.mjs
@@ -0,0 +1,29 @@
+/**
+ * Parse the user-provided extra request body.
+ * @param {unknown} raw JSON text from the advanced settings textarea
+ * @returns {Record<string, unknown> | null} the parsed object, or null when unusable
+ */
+export function parseExtraBody(raw) {
+  if (typeof raw !== 'string' || !raw.trim()) return null
+  let parsed
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    return null
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null
+  return parsed
+}
+
+/**
+ * Extra fields merged into the API request body.
+ * @param {UserConfig} config
+ * @returns {Record<string, unknown>}
+ */
+export function getExtraBodyParams(config) {
+  const extraBody = parseExtraBody(config?.extraBody)
+  if (!extraBody) return {}
+  // Every API request is read as an SSE stream, so this key stays under extension control.
+  delete extraBody.stream
+  return extraBody
+}
diff --git a/src/services/apis/openai-api.mjs b/src/services/apis/openai-api.mjs
index 86ae062d8..4b781b6f9 100644
--- a/src/services/apis/openai-api.mjs
+++ b/src/services/apis/openai-api.mjs
@@ -16,7 +16,7 @@ function normalizeBaseUrlWithoutVersionSuffix(baseUrl, fallback) {
   return normalizeBaseUrl(baseUrl || fallback).replace(/\/v1$/i, '')
 }
 
-function resolveModelName(session, config) {
+export function resolveModelName(session, config) {
   if (session.modelName === 'customModel' && !session.apiMode) {
     return config.customModelName
   }
@@ -101,7 +101,7 @@ function shouldUseOpenAIRequestShaping(request) {
   return hasNativeOpenAIRequestUrl(request?.requestUrl)
 }
 
-function resolveProviderRequestShapingId(request) {
+export function resolveProviderRequestShapingId(request) {
   if (shouldUseOpenAIRequestShaping(request)) return 'openai'
   return request?.providerId
 }
@@ -144,7 +144,7 @@ function resolveOllamaKeepAliveBaseUrl(request) {
   return normalizeBaseUrlWithoutVersionSuffix(request?.provider?.baseUrl, 'http://127.0.0.1:11434')
 }
 
-function hasNativeOllamaChatApiPath(requestUrl) {
+export function hasNativeOllamaChatApiPath(requestUrl) {
   const normalizedRequestUrl = normalizeBaseUrl(requestUrl)
   if (!normalizedRequestUrl) return false
   try {
diff --git a/src/services/apis/openai-compatible-core.mjs b/src/services/apis/openai-compatible-core.mjs
index 02dfe4a81..724d34a3f 100644
--- a/src/services/apis/openai-compatible-core.mjs
+++ b/src/services/apis/openai-compatible-core.mjs
@@ -4,6 +4,7 @@ import { isEmpty } from 'lodash-es'
 import { getCompletionPromptBase, pushRecord, setAbortController } from './shared.mjs'
 import { getChatCompletionsTokenParams } from './openai-token-params.mjs'
 import { getTemperatureParams } from './temperature-params.mjs'
+import { getExtraBodyParams } from './extra-body-params.mjs'
 
 function buildHeaders(apiKey, extraHeaders = {}) {
   const headers = {
@@ -76,11 +77,15 @@ export async function generateAnswersWithOpenAICompatible({
   session.conversationRecords = conversationRecords
   const safeExtraBody = { ...extraBody }
   delete safeExtraBody.temperature
+  // Merged last so the Advanced setting wins over built-in values, except for
+  // the token-limit key: only the one the request shape expects may be sent.
+  const configuredExtraBody = getExtraBodyParams(config)
   if (endpointType === 'completion') {
     const prompt =
       (await getCompletionPromptBase()) +
       getConversationPairs(conversationRecords.slice(-config.maxConversationContextLength), true) +
       `Human: ${question}\nAI: `
+    delete configuredExtraBody.max_completion_tokens
     requestBody = {
       prompt,
       model,
@@ -89,6 +94,7 @@ export async function generateAnswersWithOpenAICompatible({
       ...getTemperatureParams(config, model),
       stop: '\nHuman',
       ...safeExtraBody,
+      ...configuredExtraBody,
     }
   } else {
     const messages = getConversationPairs(
@@ -104,6 +110,7 @@ export async function generateAnswersWithOpenAICompatible({
     const conflictingTokenParamKey =
       'max_completion_tokens' in tokenParams ? 'max_tokens' : 'max_completion_tokens'
     delete safeExtraBody[conflictingTokenParamKey]
+    delete configuredExtraBody[conflictingTokenParamKey]
     requestBody = {
       messages,
       model,
@@ -111,6 +118,7 @@ export async function generateAnswersWithOpenAICompatible({
       ...tokenParams,
       ...getTemperatureParams(config, model),
       ...safeExtraBody,
+      ...configuredExtraBody,
     }
   }
 
diff --git a/src/services/apis/test-connection.mjs b/src/services/apis/test-connection.mjs
new file mode 100644
index 000000000..ffe6caabe
--- /dev/null
+++ b/src/services/apis/test-connection.mjs
@@ -0,0 +1,203 @@
+import { getUserConfig } from '../../config/index.mjs'
+import { getModelValue } from '../../utils/model-name-convert.mjs'
+import { getThinkingConfig } from './claude-api.mjs'
+import { canTestConnectionSession } from './connection-test-groups.mjs'
+import { getExtraBodyParams } from './extra-body-params.mjs'
+import { getChatCompletionsTokenParams } from './openai-token-params.mjs'
+import { getTemperatureParams } from './temperature-params.mjs'
+import {
+  hasNativeOllamaChatApiPath,
+  resolveModelName,
+  resolveProviderRequestShapingId,
+} from './openai-api.mjs'
+import { resolveOpenAICompatibleRequest } from './provider-registry.mjs'
+
+const TEST_TIMEOUT_MS = 20000
+const TEST_MAX_TOKENS = 1
+const TEST_PROMPT = 'ping'
+const TEST_MESSAGES = [{ role: 'user', content: TEST_PROMPT }]
+const AZURE_API_VERSION = '2024-02-01'
+const ANTHROPIC_API_VERSION = '2023-06-01'
+
+function trimTrailingSlashes(value) {
+  return String(value || '').replace(/\/+$/, '')
+}
+
+/**
+ * Mirror the request the live OpenAI-compatible path builds: same resolved URL, same token
+ * parameter for the resolved provider, same temperature and extra request body, sized down
+ * to a single "ping" with `stream: false`, so a mode that passes here can be talked to.
+ * @returns {{requestUrl: string, headers: Record<string, string>, body: object} | null}
+ */
+function buildOpenAICompatibleTestRequest(config, session) {
+  const request = resolveOpenAICompatibleRequest(config, session)
+  if (!request) return null
+
+  const model = resolveModelName(session, config)
+  // Token parameters are shaped by the resolved provider rather than the raw id, so a
+  // custom provider inheriting OpenAI still gets max_completion_tokens where required.
+  const tokenParams =
+    request.endpointType === 'completion'
+      ? { max_tokens: TEST_MAX_TOKENS }
+      : getChatCompletionsTokenParams(
+          resolveProviderRequestShapingId(request),
+          model,
+          TEST_MAX_TOKENS,
+        )
+  // The live path drops the token key the model family does not use, so the probe has to
+  // strip the same key from the configured body instead of re-adding it through the merge.
+  const conflictingTokenParamKey =
+    'max_completion_tokens' in tokenParams ? 'max_tokens' : 'max_completion_tokens'
+  const configuredExtraBody = getExtraBodyParams(config)
+  delete configuredExtraBody[conflictingTokenParamKey]
+  const baseBody =
+    request.endpointType === 'completion'
+      ? { model, prompt: TEST_PROMPT, ...tokenParams }
+      : { model, messages: TEST_MESSAGES, ...tokenParams }
+
+  return {
+    requestUrl: request.requestUrl,
+    headers: {
+      'Content-Type': 'application/json',
+      ...(request.apiKey ? { Authorization: `Bearer ${request.apiKey}` } : {}),
+    },
+    body: {
+      ...baseBody,
+      ...getTemperatureParams(config, model),
+      ...configuredExtraBody,
+      stream: false,
+    },
+  }
+}
+
+function buildAzureTestRequest(config, session) {
+  const endpoint = trimTrailingSlashes(config.azureEndpoint)
+  const deploymentName = getModelValue(session) || config.azureDeploymentName
+  if (!endpoint || !deploymentName) return null
+
+  return {
+    requestUrl: `${endpoint}/openai/deployments/${deploymentName}/chat/completions?api-version=${AZURE_API_VERSION}`,
+    headers: {
+      'Content-Type': 'application/json',
+      'api-key': config.azureApiKey || '',
+    },
+    body: {
+      messages: TEST_MESSAGES,
+      max_tokens: TEST_MAX_TOKENS,
+      ...getTemperatureParams(config),
+      ...getExtraBodyParams(config),
+      stream: false,
+    },
+  }
+}
+
+/**
+ * Anthropic rejects a `max_tokens` that does not exceed an enabled thinking budget, so a
+ * user-configured thinking budget has to be covered by the probe's token limit.
+ */
+function resolveAnthropicTestMaxTokens(extraBody) {
+  const thinking = extraBody?.thinking
+  if (thinking?.type === 'enabled' && Number.isFinite(thinking.budget_tokens)) {
+    return Math.max(TEST_MAX_TOKENS, thinking.budget_tokens + 1)
+  }
+  return TEST_MAX_TOKENS
+}
+
+function buildAnthropicTestRequest(config, session) {
+  const baseUrl = trimTrailingSlashes(config.customAnthropicApiUrl)
+  const model = getModelValue(session)
+  if (!baseUrl || !model) return null
+
+  const extraBody = getExtraBodyParams(config)
+  const body = {
+    model,
+    messages: TEST_MESSAGES,
+    max_tokens: resolveAnthropicTestMaxTokens(extraBody),
+    ...getTemperatureParams(config, model),
+  }
+  const thinking = getThinkingConfig(model)
+  if (thinking) body.thinking = thinking
+
+  return {
+    requestUrl: `${baseUrl}/v1/messages`,
+    headers: {
+      'Content-Type': 'application/json',
+      'anthropic-version': ANTHROPIC_API_VERSION,
+      'x-api-key': config.anthropicApiKey || '',
+      'anthropic-dangerous-direct-browser-access': true,
+    },
+    body: { ...body, ...extraBody, stream: false },
+  }
+}
+
+async function sendTestRequest({ requestUrl, headers, body }) {
+  const controller = new AbortController()
+  const timeoutId = setTimeout(() => controller.abort(), TEST_TIMEOUT_MS)
+  const startedAt = Date.now()
+
+  try {
+    const response = await fetch(requestUrl, {
+      method: 'POST',
+      signal: controller.signal,
+      // A redirect would send the credentials somewhere else and answer for the wrong
+      // endpoint, so the probe reports it instead of following it.
+      redirect: 'manual',
+      headers,
+      body: JSON.stringify(body),
+    })
+    const elapsedMs = Date.now() - startedAt
+    if (response.type === 'opaqueredirect') {
+      return {
+        ok: false,
+        elapsedMs,
+        error: 'The endpoint redirected the request instead of answering it.',
+      }
+    }
+    if (!response.ok) {
+      const detail = await response.text().catch(() => '')
+      return { ok: false, status: response.status, elapsedMs, error: detail.slice(0, 300) }
+    }
+    return { ok: true, status: response.status, elapsedMs }
+  } catch (error) {
+    return {
+      ok: false,
+      elapsedMs: Date.now() - startedAt,
+      error: error?.name === 'AbortError' ? 'timeout' : error?.message ?? String(error),
+    }
+  } finally {
+    clearTimeout(timeoutId)
+  }
+}
+
+/**
+ * Send the smallest request that still proves the endpoint, key and model work together.
+ * Each provider family is probed through the same request shape its live path uses, so a
+ * session that passes here is one that can be talked to.
+ * @param {object} session a session-shaped selector: `{apiMode}` for a configured mode,
+ *   `{modelName: 'customModel'}` for the custom model on the General tab
+ * @returns {Promise<{ok: boolean, status?: number, elapsedMs: number, error?: string,
+ *   unsupported?: boolean}>} `unsupported` marks a mode with no request shape to send,
+ *   which says nothing about the endpoint or the credentials it was configured with
+ */
+export async function testConnection(session) {
+  if (!canTestConnectionSession(session)) {
+    return { ok: false, unsupported: true, elapsedMs: 0, error: 'unsupported-provider' }
+  }
+
+  const config = await getUserConfig()
+  const groupName = session?.apiMode?.groupName
+  const request =
+    groupName === 'azureOpenAiApiModelKeys'
+      ? buildAzureTestRequest(config, session)
+      : groupName === 'claudeApiModelKeys'
+      ? buildAnthropicTestRequest(config, session)
+      : buildOpenAICompatibleTestRequest(config, session)
+
+  if (!request) return { ok: false, elapsedMs: 0, error: 'unresolved-provider' }
+  // The live path refuses Ollama's native chat endpoint, so a probe against it would
+  // report a mode as reachable that can never hold a conversation.
+  if (hasNativeOllamaChatApiPath(request.requestUrl)) {
+    return { ok: false, unsupported: true, elapsedMs: 0, error: 'unsupported-provider' }
+  }
+  return sendTestRequest(request)
+}
diff --git a/tests/unit/background/message-sender.test.mjs b/tests/unit/background/message-sender.test.mjs
new file mode 100644
index 000000000..73cddc920
--- /dev/null
+++ b/tests/unit/background/message-sender.test.mjs
@@ -0,0 +1,32 @@
+import assert from 'node:assert/strict'
+import { describe, test } from 'node:test'
+import Browser from 'webextension-polyfill'
+import { isTrustedExtensionSender } from '../../../src/background/message-sender.mjs'
+
+const EXTENSION_PAGE_URL = `${Browser.runtime.getURL('/')}popup.html`
+
+describe('isTrustedExtensionSender', () => {
+  test('accepts this extension, including its content scripts on a web page', () => {
+    assert.equal(isTrustedExtensionSender({ id: Browser.runtime.id }), true)
+    assert.equal(
+      isTrustedExtensionSender({ id: Browser.runtime.id, url: 'https://example.com/article' }),
+      true,
+    )
+  })
+
+  test('accepts an extension page that reports no id', () => {
+    assert.equal(isTrustedExtensionSender({ url: EXTENSION_PAGE_URL }), true)
+    assert.equal(isTrustedExtensionSender({ documentUrl: EXTENSION_PAGE_URL }), true)
+  })
+
+  test('rejects web pages, other extensions and empty senders', () => {
+    assert.equal(isTrustedExtensionSender({ url: 'https://example.com/article' }), false)
+    assert.equal(isTrustedExtensionSender({ id: 'another-extension' }), false)
+    assert.equal(
+      isTrustedExtensionSender({ url: 'chrome-extension://another-id/popup.html' }),
+      false,
+    )
+    assert.equal(isTrustedExtensionSender({}), false)
+    assert.equal(isTrustedExtensionSender(undefined), false)
+  })
+})
diff --git a/tests/unit/popup/connection-test-status.test.mjs b/tests/unit/popup/connection-test-status.test.mjs
new file mode 100644
index 000000000..478cd90d9
--- /dev/null
+++ b/tests/unit/popup/connection-test-status.test.mjs
@@ -0,0 +1,42 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import {
+  getConnectionTestButtonStyle,
+  getConnectionTestLabel,
+  getConnectionTestTitle,
+} from '../../../src/popup/sections/connection-test-status.mjs'
+
+const t = (key) => key
+
+test('an untested mode leaves the button unstyled', () => {
+  assert.equal(getConnectionTestButtonStyle(undefined), undefined)
+  assert.equal(getConnectionTestTitle(undefined, t), '')
+  assert.equal(getConnectionTestLabel(undefined, t), 'Test')
+})
+
+test('the button colour carries the result', () => {
+  assert.equal(getConnectionTestButtonStyle({ pending: true }).borderColor, '#9a6700')
+  assert.equal(getConnectionTestButtonStyle({ ok: true }).borderColor, '#2da44e')
+  assert.equal(getConnectionTestButtonStyle({ ok: false }).borderColor, '#d1242f')
+})
+
+test('a mode with no request shape stays neutral instead of reading as a failure', () => {
+  const unsupported = { ok: false, unsupported: true, error: 'unsupported-provider' }
+
+  assert.equal(getConnectionTestButtonStyle(unsupported).borderColor, '#57606a')
+  assert.equal(getConnectionTestLabel(unsupported, t), 'Not testable')
+  assert.equal(getConnectionTestTitle(unsupported, t), 'Not testable')
+})
+
+test('the result detail only lives in the tooltip', () => {
+  assert.equal(getConnectionTestTitle({ pending: true }, t), 'Testing...')
+  assert.equal(getConnectionTestTitle({ ok: true, elapsedMs: 42 }, t), 'Reachable 42ms')
+  assert.equal(getConnectionTestTitle({ ok: false, error: 'boom' }, t), 'Unreachable: boom')
+  assert.equal(getConnectionTestTitle({ ok: false }, t), 'Unreachable')
+})
+
+test('the button label carries the result', () => {
+  assert.equal(getConnectionTestLabel({ pending: true }, t), 'Testing...')
+  assert.equal(getConnectionTestLabel({ ok: true, elapsedMs: 42 }, t), 'Reachable 42ms')
+  assert.equal(getConnectionTestLabel({ ok: false, error: 'boom' }, t), 'Unreachable')
+})
diff --git a/tests/unit/services/apis/connection-test-groups.test.mjs b/tests/unit/services/apis/connection-test-groups.test.mjs
new file mode 100644
index 000000000..af1cc4a63
--- /dev/null
+++ b/tests/unit/services/apis/connection-test-groups.test.mjs
@@ -0,0 +1,42 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { canTestConnectionSession } from '../../../../src/services/apis/connection-test-groups.mjs'
+
+test('OpenAI-compatible API modes can be probed', () => {
+  for (const groupName of [
+    'chatgptApiModelKeys',
+    'gptApiModelKeys',
+    'deepSeekApiModelKeys',
+    'customApiModelKeys',
+    'ollamaApiModelKeys',
+  ]) {
+    assert.equal(canTestConnectionSession({ apiMode: { groupName } }), true, groupName)
+  }
+})
+
+test('Azure and Anthropic modes are probed through their own protocol', () => {
+  assert.equal(
+    canTestConnectionSession({ apiMode: { groupName: 'azureOpenAiApiModelKeys' } }),
+    true,
+  )
+  assert.equal(canTestConnectionSession({ apiMode: { groupName: 'claudeApiModelKeys' } }), true)
+})
+
+test('cookie and third-party modes cannot be probed', () => {
+  for (const groupName of [
+    'chatgptWebModelKeys',
+    'claudeWebModelKeys',
+    'moonshotWebModelKeys',
+    'bingWebModelKeys',
+    'bardWebModelKeys',
+    'githubThirdPartyApiModelKeys',
+  ]) {
+    assert.equal(canTestConnectionSession({ apiMode: { groupName } }), false, groupName)
+  }
+})
+
+test('the custom model on the General tab can be probed', () => {
+  assert.equal(canTestConnectionSession({ modelName: 'customModel' }), true)
+  assert.equal(canTestConnectionSession({ modelName: 'chatgptFree35' }), false)
+  assert.equal(canTestConnectionSession({}), false)
+})
diff --git a/tests/unit/services/apis/test-connection.test.mjs b/tests/unit/services/apis/test-connection.test.mjs
new file mode 100644
index 000000000..a054149bc
--- /dev/null
+++ b/tests/unit/services/apis/test-connection.test.mjs
@@ -0,0 +1,284 @@
+import assert from 'node:assert/strict'
+import { beforeEach, test } from 'node:test'
+import { testConnection } from '../../../../src/services/apis/test-connection.mjs'
+
+const ENDPOINT = 'https://api.example.com/v1/chat/completions'
+
+const MODE = {
+  groupName: 'customApiModelKeys',
+  itemName: 'customModel',
+  isCustom: true,
+  customName: 'my-model',
+  providerId: 'test-provider',
+  customUrl: '',
+}
+
+function captureFetch(t) {
+  const seen = []
+  t.mock.method(globalThis, 'fetch', async (url, options) => {
+    seen.push({ url, options, body: JSON.parse(options.body) })
+    return { ok: true, status: 200, text: async () => '' }
+  })
+  return seen
+}
+
+beforeEach(() => {
+  globalThis.__TEST_BROWSER_SHIM__.replaceStorage({
+    customOpenAIProviders: [
+      { id: 'test-provider', name: 'Test provider', chatCompletionsUrl: ENDPOINT },
+    ],
+    providerSecrets: { 'test-provider': 'secret-key' },
+  })
+})
+
+test('a reachable mode reports success and pings the resolved endpoint', async (t) => {
+  let seen
+  t.mock.method(globalThis, 'fetch', async (url, options) => {
+    seen = { url, body: JSON.parse(options.body) }
+    return { ok: true, status: 200, text: async () => '' }
+  })
+
+  const result = await testConnection({ apiMode: MODE })
+
+  assert.equal(result.ok, true)
+  assert.equal(result.status, 200)
+  assert.equal(typeof result.elapsedMs, 'number')
+  assert.equal(seen.url, ENDPOINT)
+  assert.equal(seen.body.model, 'my-model')
+  assert.equal(seen.body.stream, false)
+})
+
+test('a rejected request surfaces the status and the provider message', async (t) => {
+  t.mock.method(globalThis, 'fetch', async () => ({
+    ok: false,
+    status: 401,
+    text: async () => '{"error":"invalid api key"}',
+  }))
+
+  const result = await testConnection({ apiMode: MODE })
+
+  assert.equal(result.ok, false)
+  assert.equal(result.status, 401)
+  assert.match(result.error, /invalid api key/)
+})
+
+test('a transport failure is reported instead of thrown', async (t) => {
+  t.mock.method(globalThis, 'fetch', async () => {
+    throw new Error('network down')
+  })
+
+  const result = await testConnection({ apiMode: MODE })
+
+  assert.equal(result.ok, false)
+  assert.equal(result.status, undefined)
+  assert.equal(result.error, 'network down')
+})
+
+test('a mode whose provider cannot be resolved is reported, not thrown', async () => {
+  const result = await testConnection({
+    apiMode: {
+      groupName: 'customApiModelKeys',
+      itemName: 'customModel',
+      isCustom: true,
+      customName: 'my-model',
+      providerId: 'missing-provider',
+      customUrl: '',
+    },
+  })
+
+  assert.equal(result.ok, false)
+  assert.equal(result.error, 'unresolved-provider')
+})
+
+test('the custom model on the General tab resolves its own URL and name', async (t) => {
+  globalThis.__TEST_BROWSER_SHIM__.replaceStorage({
+    customModelApiUrl: 'https://custom.example.com/v1/chat/completions',
+    customModelName: 'my-custom-model',
+    customApiKey: 'custom-key',
+  })
+
+  let seen
+  t.mock.method(globalThis, 'fetch', async (url, options) => {
+    seen = { url, options, body: JSON.parse(options.body) }
+    return { ok: true, status: 200, text: async () => '' }
+  })
+
+  const result = await testConnection({ modelName: 'customModel' })
+
+  assert.equal(result.ok, true)
+  assert.equal(seen.url, 'https://custom.example.com/v1/chat/completions')
+  assert.equal(seen.body.model, 'my-custom-model')
+  assert.equal(seen.options.headers.Authorization, 'Bearer custom-key')
+})
+
+test('the configured extra request body is merged into the probe', async (t) => {
+  globalThis.__TEST_BROWSER_SHIM__.replaceStorage({
+    customOpenAIProviders: [
+      { id: 'test-provider', name: 'Test provider', chatCompletionsUrl: ENDPOINT },
+    ],
+    providerSecrets: { 'test-provider': 'secret-key' },
+    extraBody:
+      '{"reasoning_effort":"high","stream":true,"max_tokens":99,"max_completion_tokens":77}',
+  })
+  const seen = captureFetch(t)
+
+  const result = await testConnection({ apiMode: MODE })
+
+  assert.equal(result.ok, true)
+  assert.equal(seen[0].body.reasoning_effort, 'high')
+  assert.equal(seen[0].body.max_tokens, 99)
+  // This mode sends max_tokens, so the chat-only key never rides along.
+  assert.equal('max_completion_tokens' in seen[0].body, false)
+  // A probe never streams, even when the extra body asks for it.
+  assert.equal(seen[0].body.stream, false)
+})
+
+test('the configured temperature override reaches the probe', async (t) => {
+  globalThis.__TEST_BROWSER_SHIM__.replaceStorage({
+    customOpenAIProviders: [
+      { id: 'test-provider', name: 'Test provider', chatCompletionsUrl: ENDPOINT },
+    ],
+    providerSecrets: { 'test-provider': 'secret-key' },
+    temperatureOverrideEnabled: true,
+    temperature: 0.3,
+  })
+  const seen = captureFetch(t)
+
+  const result = await testConnection({ apiMode: MODE })
+
+  assert.equal(result.ok, true)
+  assert.equal(seen[0].body.temperature, 0.3)
+})
+
+test('a completion mode is probed with the completion request shape', async (t) => {
+  const seen = captureFetch(t)
+
+  const result = await testConnection({
+    apiMode: { groupName: 'gptApiModelKeys', itemName: 'gptApiInstruct', isCustom: false },
+  })
+
+  assert.equal(result.ok, true)
+  assert.equal(seen[0].url, 'https://api.openai.com/v1/completions')
+  assert.equal(typeof seen[0].body.prompt, 'string')
+  assert.equal(seen[0].body.messages, undefined)
+  assert.equal(seen[0].body.max_tokens, 1)
+})
+
+test('an OpenAI-derived custom provider is probed with OpenAI request shaping', async (t) => {
+  globalThis.__TEST_BROWSER_SHIM__.replaceStorage({
+    customOpenAIProviders: [
+      {
+        id: 'test-provider',
+        name: 'Test provider',
+        baseUrl: 'https://api.openai.com',
+        sourceProviderId: 'openai',
+      },
+    ],
+    providerSecrets: { 'test-provider': 'secret-key' },
+    extraBody: '{"max_tokens":99}',
+  })
+  const seen = captureFetch(t)
+
+  const result = await testConnection({
+    apiMode: { ...MODE, customName: 'gpt-5' },
+  })
+
+  assert.equal(result.ok, true)
+  assert.equal(seen[0].url, 'https://api.openai.com/v1/chat/completions')
+  assert.equal(seen[0].body.max_completion_tokens, 1)
+  assert.equal(seen[0].body.max_tokens, undefined)
+})
+
+test('an Azure mode is probed with its deployment URL and api-key header', async (t) => {
+  globalThis.__TEST_BROWSER_SHIM__.replaceStorage({
+    azureApiKey: 'azure-key',
+    azureEndpoint: 'https://example.openai.azure.com/',
+    azureDeploymentName: 'my-deployment',
+    extraBody: '{"reasoning_effort":"high"}',
+  })
+  const seen = captureFetch(t)
+
+  const result = await testConnection({
+    apiMode: { groupName: 'azureOpenAiApiModelKeys', itemName: 'azureOpenAi', isCustom: false },
+  })
+
+  assert.equal(result.ok, true)
+  assert.equal(
+    seen[0].url,
+    'https://example.openai.azure.com/openai/deployments/my-deployment/chat/completions?api-version=2024-02-01',
+  )
+  assert.equal(seen[0].options.headers['api-key'], 'azure-key')
+  assert.equal(seen[0].body.reasoning_effort, 'high')
+  assert.equal(seen[0].body.stream, false)
+})
+
+test('an Anthropic mode is probed with the messages endpoint and its headers', async (t) => {
+  globalThis.__TEST_BROWSER_SHIM__.replaceStorage({
+    anthropicApiKey: 'anthropic-key',
+    customAnthropicApiUrl: 'https://api.anthropic.com',
+  })
+  const seen = captureFetch(t)
+
+  const result = await testConnection({
+    apiMode: {
+      groupName: 'claudeApiModelKeys',
+      itemName: 'claudeSonnet5Api',
+      isCustom: false,
+    },
+  })
+
+  assert.equal(result.ok, true)
+  assert.equal(seen[0].url, 'https://api.anthropic.com/v1/messages')
+  assert.equal(seen[0].options.headers['x-api-key'], 'anthropic-key')
+  assert.equal(seen[0].body.model, 'claude-sonnet-5')
+  assert.deepEqual(seen[0].body.thinking, { type: 'disabled' })
+  assert.equal(seen[0].body.stream, false)
+})
+
+test('a cookie/web mode is not probed and reports it as unsupported', async (t) => {
+  const seen = captureFetch(t)
+
+  const result = await testConnection({
+    apiMode: { groupName: 'chatgptWebModelKeys', itemName: 'chatgptPlus4', isCustom: false },
+  })
+
+  assert.equal(result.ok, false)
+  assert.equal(result.error, 'unsupported-provider')
+  assert.equal(result.unsupported, true)
+  assert.equal(seen.length, 0)
+})
+
+test('a native Ollama chat endpoint is reported instead of probed', async (t) => {
+  globalThis.__TEST_BROWSER_SHIM__.replaceStorage({
+    customOpenAIProviders: [
+      {
+        id: 'test-provider',
+        name: 'Test provider',
+        chatCompletionsUrl: 'http://127.0.0.1:11434/api/chat',
+      },
+    ],
+    providerSecrets: { 'test-provider': 'secret-key' },
+  })
+  const seen = captureFetch(t)
+
+  const result = await testConnection({ apiMode: MODE })
+
+  assert.equal(result.ok, false)
+  assert.equal(result.error, 'unsupported-provider')
+  assert.equal(result.unsupported, true)
+  assert.equal(seen.length, 0)
+})
+
+test('a redirected probe is reported as unreachable instead of followed', async (t) => {
+  t.mock.method(globalThis, 'fetch', async () => ({
+    type: 'opaqueredirect',
+    ok: false,
+    status: 0,
+    text: async () => '',
+  }))
+
+  const result = await testConnection({ apiMode: MODE })
+
+  assert.equal(result.ok, false)
+  assert.match(result.error, /redirect/i)
+})
diff --git a/tests/unit/services/extra-body-params.test.mjs b/tests/unit/services/extra-body-params.test.mjs
new file mode 100644
index 000000000..a6d0b771a
--- /dev/null
+++ b/tests/unit/services/extra-body-params.test.mjs
@@ -0,0 +1,32 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import {
+  getExtraBodyParams,
+  parseExtraBody,
+} from '../../../src/services/apis/extra-body-params.mjs'
+
+test('parseExtraBody accepts a JSON object', () => {
+  assert.deepEqual(parseExtraBody('{"thinking":{"type":"enabled","budget_tokens":2048}}'), {
+    thinking: { type: 'enabled', budget_tokens: 2048 },
+  })
+})
+
+test('parseExtraBody rejects anything that is not a JSON object', () => {
+  for (const raw of ['', '   ', 'not json', '[1,2]', '"text"', '42', 'null', null, undefined, {}]) {
+    assert.equal(parseExtraBody(raw), null, `expected null for ${JSON.stringify(raw)}`)
+  }
+})
+
+test('getExtraBodyParams is empty without a usable config value', () => {
+  assert.deepEqual(getExtraBodyParams(undefined), {})
+  assert.deepEqual(getExtraBodyParams({}), {})
+  assert.deepEqual(getExtraBodyParams({ extraBody: '{oops' }), {})
+})
+
+test('getExtraBodyParams forwards user fields and keeps stream under extension control', () => {
+  const config = { extraBody: '{"reasoning_effort":"high","stream":false}' }
+
+  assert.deepEqual(getExtraBodyParams(config), { reasoning_effort: 'high' })
+  // The parsed object is rebuilt per call, so repeated reads stay stripped.
+  assert.deepEqual(getExtraBodyParams(config), { reasoning_effort: 'high' })
+})
diff --git a/tests/unit/services/extra-body-request.test.mjs b/tests/unit/services/extra-body-request.test.mjs
new file mode 100644
index 000000000..f99f83313
--- /dev/null
+++ b/tests/unit/services/extra-body-request.test.mjs
@@ -0,0 +1,141 @@
+import assert from 'node:assert/strict'
+import { beforeEach, test } from 'node:test'
+import { generateAnswersWithOpenAICompatible } from '../../../src/services/apis/openai-compatible-core.mjs'
+import { generateAnswersWithClaudeApi } from '../../../src/services/apis/claude-api.mjs'
+import { generateAnswersWithAzureOpenaiApi } from '../../../src/services/apis/azure-openai-api.mjs'
+import { createFakePort } from '../helpers/port.mjs'
+import { createMockSseResponse } from '../helpers/sse-response.mjs'
+
+const CHAT_CHUNKS = [
+  'data: {"choices":[{"delta":{"content":"hi"},"finish_reason":"stop"}]}\n\n',
+  'data: [DONE]\n\n',
+]
+
+const CLAUDE_CHUNKS = [
+  'data: {"type":"content_block_delta","delta":{"type":"text_delta","text":"hi"}}\n\n',
+  'data: {"type":"message_delta","delta":{"stop_reason":"end_turn"}}\n\n',
+  'data: {"type":"message_stop"}\n\n',
+]
+
+beforeEach(() => {
+  globalThis.__TEST_BROWSER_SHIM__.clearStorage()
+})
+
+async function captureRequestBody(t, chunks, run) {
+  let requestBody
+  t.mock.method(console, 'debug', () => {})
+  t.mock.method(globalThis, 'fetch', async (url, options) => {
+    requestBody = JSON.parse(options.body)
+    return createMockSseResponse(chunks)
+  })
+  await run()
+  return requestBody
+}
+
+function openAiCompatibleRequest({ endpointType = 'chat', model = 'gpt-5', extraBody }) {
+  return {
+    port: createFakePort(),
+    question: 'hi',
+    session: { conversationRecords: [] },
+    endpointType,
+    requestUrl: `https://example.com/v1/${
+      endpointType === 'chat' ? 'chat/completions' : 'completions'
+    }`,
+    model,
+    apiKey: 'key',
+    provider: 'openai',
+    config: {
+      maxConversationContextLength: 9,
+      maxResponseTokenLength: 1000,
+      temperatureOverrideEnabled: false,
+      temperature: 1,
+      extraBody,
+    },
+  }
+}
+
+test('OpenAI-compatible requests send the extra body without losing the SSE stream', async (t) => {
+  const requestBody = await captureRequestBody(t, CHAT_CHUNKS, () =>
+    generateAnswersWithOpenAICompatible(
+      openAiCompatibleRequest({ extraBody: '{"reasoning_effort":"high","stream":false}' }),
+    ),
+  )
+
+  assert.equal(requestBody.reasoning_effort, 'high')
+  assert.equal(requestBody.stream, true)
+  assert.equal(requestBody.model, 'gpt-5')
+})
+
+test('OpenAI-compatible chat requests keep only the token key the model family uses', async (t) => {
+  const requestBody = await captureRequestBody(t, CHAT_CHUNKS, () =>
+    generateAnswersWithOpenAICompatible(
+      openAiCompatibleRequest({ extraBody: '{"max_tokens":123,"max_completion_tokens":456}' }),
+    ),
+  )
+
+  // gpt-5 sends max_completion_tokens, so that is where the override lands.
+  assert.equal(requestBody.max_completion_tokens, 456)
+  assert.equal('max_tokens' in requestBody, false)
+})
+
+test('OpenAI-compatible chat requests drop the unused token key for max_tokens models', async (t) => {
+  const requestBody = await captureRequestBody(t, CHAT_CHUNKS, () =>
+    generateAnswersWithOpenAICompatible(
+      openAiCompatibleRequest({
+        model: 'gpt-4.1',
+        extraBody: '{"max_tokens":123,"max_completion_tokens":456}',
+      }),
+    ),
+  )
+
+  assert.equal(requestBody.max_tokens, 123)
+  assert.equal('max_completion_tokens' in requestBody, false)
+})
+
+test('OpenAI-compatible completion requests stay on max_tokens', async (t) => {
+  const requestBody = await captureRequestBody(t, CHAT_CHUNKS, () =>
+    generateAnswersWithOpenAICompatible(
+      openAiCompatibleRequest({
+        endpointType: 'completion',
+        model: 'gpt-3.5-turbo-instruct',
+        extraBody: '{"max_tokens":123,"max_completion_tokens":456}',
+      }),
+    ),
+  )
+
+  assert.equal(requestBody.max_tokens, 123)
+  assert.equal('max_completion_tokens' in requestBody, false)
+})
+
+test('Azure OpenAI requests send the extra body', async (t) => {
+  globalThis.__TEST_BROWSER_SHIM__.replaceStorage({
+    azureApiKey: 'key',
+    azureEndpoint: 'https://example.openai.azure.com',
+    azureDeploymentName: 'deployment',
+    extraBody: '{"reasoning_effort":"high"}',
+  })
+
+  const requestBody = await captureRequestBody(t, CHAT_CHUNKS, () =>
+    generateAnswersWithAzureOpenaiApi(createFakePort(), 'hi', { conversationRecords: [] }),
+  )
+
+  assert.equal(requestBody.reasoning_effort, 'high')
+})
+
+test('Claude requests let the extra body override the built-in thinking default', async (t) => {
+  globalThis.__TEST_BROWSER_SHIM__.replaceStorage({
+    anthropicApiKey: 'key',
+    extraBody: '{"thinking":{"type":"enabled","budget_tokens":2048}}',
+  })
+
+  const requestBody = await captureRequestBody(t, CLAUDE_CHUNKS, () =>
+    generateAnswersWithClaudeApi(createFakePort(), 'hi', {
+      // This model normally gets thinking forced off.
+      modelName: 'claudeSonnet5Api',
+      conversationRecords: [],
+    }),
+  )
+
+  assert.equal(requestBody.model, 'claude-sonnet-5')
+  assert.deepEqual(requestBody.thinking, { type: 'enabled', budget_tokens: 2048 })
+})