feat: 收敛 flash 模型系列，新增纯文本技能库与工具调用开关

- 模型：对外只保留 deepseek-v4-flash 系列（含 search/nothinking 变体），
pro/vision 旧名静默映射到 flash，不再出现在模型列表
- 思考/联网：适配 kelivo 思维强度（reasoning_effort 含 max、thinking.type、
reasoning.effort），显式联网信号（enable_search / 原生 web_search 工具）自动跟随
- 提示词：重写上下文衔接指令与对话记录格式（# 对话记录 + [role=xxx]），
禁止提及附件/文件/上下文；恢复并优化思考格式注入默认提示词
- 提示词：新增按 API Key 覆盖思考格式注入（custom/enabled/prompt）
- 工具调用：改为默认关闭（上游 DSML 风控/封号风险），新增 tools.enabled 开关，
关闭时忽略 tools、不注入工具说明、不解析 tool_calls
- 技能：新增纯文本技能库（实验性、默认关闭），技能正文以 System 段前置注入，
支持 skills.max_chars 截断与单 Key 覆盖（custom/enabled/ids）
- 日志：按 API Key 筛选、自定义保留条数（0-500）、json/markdown 导出
- 管理台：响应记录筛选栏/导出、工具开关、技能库编辑、Key 级注入与技能配置
- 文档：新增 docs/prompt-compatibility.md，同步 API.md/API.en.md/README/示例配置

API.en.md

@@ -4,7 +4,7 @@ Language: [中文](API.md) | [English](API.en.md)
 
 This document describes the actual behavior of the current Go codebase.
 
-Docs: [Overview](README.en.md) / [Architecture](docs/ARCHITECTURE.en.md) / [Deployment](docs/DEPLOY.en.md) / [Testing](docs/TESTING.md)
+Docs: [Overview](README.en.md) / [Architecture](docs/ARCHITECTURE.en.md) / [Deployment](docs/DEPLOY.en.md) / [Testing](docs/TESTING.md) / [Prompt compatibility flow](docs/prompt-compatibility.md)
 
 ---
 
@@ -40,6 +40,7 @@ Docs: [Overview](README.en.md) / [Architecture](docs/ARCHITECTURE.en.md) / [Depl
 
 - OpenAI / Claude / Gemini protocols are now mounted on one shared `chi` router tree assembled in `internal/server/router.go`.
 - Adapter responsibilities are streamlined to: **request normalization → DeepSeek invocation → protocol-shaped rendering**, reducing legacy split-logic paths.
+- The full path from a protocol request to the pure-text web-chat prompt (normalized standard request, thinking-format injection, history split, completion payload assembly, response archiving) is documented in [docs/prompt-compatibility.md](docs/prompt-compatibility.md), which is the source-of-truth document for that flow; this document only describes the visible fields and response shapes of each endpoint.
 - Tool-calling semantics are aligned between Go and Node runtime: models should output the halfwidth-pipe DSML shell `<|DSML|tool_calls>` → `<|DSML|invoke name="...">` → `<|DSML|parameter name="...">`; DS2API also accepts DSML wrapper aliases such as `<dsml|tool_calls>` and `<|tool_calls>`, common DSML separator drift such as `<|DSML tool_calls>`, collapsed DSML local names such as `<DSMLtool_calls>`, control-separator drift such as `<DSML␂tool_calls>` / raw STX `\x02`, CJK angle bracket, fullwidth-bang / ideographic-comma separator drift, PascalCase local-name drift, and trailing attribute separator drift such as `<DSM|parameter name="command"|>...〈/DSM|parameter〉`, `<！DSML！invoke name=“Bash”>`, `<、DSML、tool_calls>`, `<DSmartToolCalls>`, or `<DSMLtool_calls※>`, arbitrary protocol prefixes such as `<proto💥tool_calls>`, and legacy canonical XML `<tool_calls>` → `<invoke name="...">` → `<parameter name="...">`. The scanner normalizes fixed local names (`tool_calls` / `invoke` / `parameter`) with non-structural separators before or after them back to XML before parsing, and also tolerates CDATA opener drift such as `<！[CDATA[` / `<、[CDATA[`; only wrapped tool blocks or the narrow missing-opening-wrapper repair path enter the tool path, while bare `<invoke>` does not count as supported syntax. JSON literal parameter bodies are preserved as structured values, explicit empty or whitespace-only parameters are preserved as empty strings, malformed complete wrappers are released as plain text, and loose CDATA is narrowly repaired at final parse/flush when it can preserve a complete outer tool call.
 - `Admin API` separates static config from runtime policy: `/admin/config*` for configuration state, `/admin/settings*` for runtime behavior.
 - When upstream returns a thinking-only response with no visible text, the Go main path and the Vercel Node streaming path retry once in the same DeepSeek session: it appends the prompt suffix `"Please provide a non-empty final answer or tool call."` and sets `parent_message_id`. If that same-account retry would still end as `429 upstream_empty_output`, managed-account mode switches to the next available account, creates a fresh session, and retries the original payload once before returning 429.
@@ -137,6 +138,8 @@ Gemini-compatible clients can also send `x-goog-api-key`, `?key=`, or `?api_key=
 | GET | `/admin/settings` | Admin | Read runtime settings |
 | PUT | `/admin/settings` | Admin | Update runtime settings (hot reload) |
 | POST | `/admin/settings/password` | Admin | Update admin password and invalidate old JWTs |
+| GET | `/admin/skills` | Admin | Read the skill library config (global switch, truncation limit, items) |
+| PUT | `/admin/skills` | Admin | Replace the whole skill library config (`400` on validation failure) |
 | POST | `/admin/config/import` | Admin | Import config (merge/replace) |
 | GET | `/admin/config/export` | Admin | Export full config (`config`/`json`/`base64`) |
 | POST | `/admin/keys` | Admin | Add API key (optional `name`/`remark`) |
@@ -167,15 +170,18 @@ Gemini-compatible clients can also send `x-goog-api-key`, `?key=`, or `?api_key=
 | GET | `/admin/export` | Admin | Export config JSON/Base64 |
 | GET | `/admin/dev/captures` | Admin | Read local packet-capture entries |
 | DELETE | `/admin/dev/captures` | Admin | Clear local packet-capture entries |
-| GET | `/admin/chat-history` | Admin | Read server-side conversation history |
+| GET | `/admin/chat-history` | Admin | Read server-side conversation history (filters by caller/status/surface/keyword plus paging) |
 | DELETE | `/admin/chat-history` | Admin | Clear server-side conversation history |
 | GET | `/admin/chat-history/{id}` | Admin | Read one server-side conversation entry |
 | DELETE | `/admin/chat-history/{id}` | Admin | Delete one server-side conversation entry |
-| PUT | `/admin/chat-history/settings` | Admin | Update conversation history retention limit |
+| PUT | `/admin/chat-history/settings` | Admin | Update conversation history retention limit (`0`..`500`) |
+| GET | `/admin/chat-history/export` | Admin | Export conversation history with the same filters (`json` / `markdown`) |
 | GET | `/admin/version` | Admin | Check current version and latest Release |
 
 OpenAI `/v1/*` paths are canonical. For clients configured with the bare DS2API service URL, the same OpenAI handlers are also exposed through root shortcuts: `/models`, `/models/{id}`, `/chat/completions`, `/responses`, `/responses/{response_id}`, `/embeddings`, `/files`, and `/files/{file_id}`.
 
+Server-side records are essentially an archive of DeepSeek upstream responses: OpenAI Chat, OpenAI Responses, Claude Messages, and Gemini GenerateContent write an entry as soon as the upstream response arrives, before protocol translation/trimming. The list is ordered by request creation time (newest first), and streaming requests refresh status and detail while generating. Requests issued by the WebUI "API test" panel also land there. Each entry carries `caller_id` (the calling API key) plus `caller_label` (key name/remark/masked value), and the filterable `surface`, `status`, and `status_code` fields; list, detail, and export all read the same data (see [conversation history](#get-adminchat-history)).
+
 ---
 
 ## Health Endpoints
@@ -208,19 +214,15 @@ No auth required. Returns the currently supported DeepSeek native model list.
   "data": [
     {"id": "deepseek-v4-flash", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
     {"id": "deepseek-v4-flash-nothinking", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
-    {"id": "deepseek-v4-pro", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
-    {"id": "deepseek-v4-pro-nothinking", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
     {"id": "deepseek-v4-flash-search", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
-    {"id": "deepseek-v4-flash-search-nothinking", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
-    {"id": "deepseek-v4-pro-search", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
-    {"id": "deepseek-v4-pro-search-nothinking", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
-    {"id": "deepseek-v4-vision", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
-    {"id": "deepseek-v4-vision-nothinking", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []}
+    {"id": "deepseek-v4-flash-search-nothinking", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []}
   ]
 }
 ```
 
-> Note: `/v1/models` returns normalized DeepSeek native model IDs. Common aliases are accepted only as request input and are not expanded as separate items in this endpoint.
+> Note: `/v1/models` returns normalized DeepSeek native model IDs. Common aliases are accepted only as request input and are not expanded as separate items in this endpoint. A `-nothinking` suffix means thinking/reasoning is always off, regardless of what the request asks for.
+>
+> The model line has collapsed to the four flash variants above: `deepseek-v4-pro` / `deepseek-v4-pro-search` / `deepseek-v4-vision` and their `-nothinking` forms are retired and no longer appear in this endpoint, Ollama `/api/tags`, or `/anthropic/v1/models`. Old names still work as request input and are silently mapped to the matching flash model (see the next section).
 
 ### Model Alias Resolution
 
@@ -231,20 +233,62 @@ For `chat` / `responses` / `embeddings`, DS2API follows a wide-input/strict-outp
 3. If the request name ends with `-nothinking`, resolve the base alias and append the corresponding no-thinking variant.
 4. If still unmatched, return `invalid_request_error`. Unknown model families are not guessed heuristically; add explicit compatibility names through `model_aliases`.
 
-Built-in aliases come from `internal/config/models.go`; `config.model_aliases` can override or add mappings at runtime. Excerpt:
+Built-in aliases come from `internal/config/models.go`; `config.model_aliases` can override or add mappings at runtime. Excerpt (all pointing at the flash models):
 
-- OpenAI / Codex: `gpt-4o`, `gpt-4.1`, `gpt-5`, `gpt-5.5`, `gpt-5-codex`, `gpt-5.3-codex`, `codex-mini-latest`
-- OpenAI reasoning: `o1`, `o3`, `o3-deep-research`, `o4-mini`
-- Claude: `claude-opus-4-6`, `claude-sonnet-4-6`, `claude-haiku-4-5`, `claude-3-5-sonnet-latest`
-- Gemini: `gemini-2.5-pro`, `gemini-2.5-flash`, `gemini-3.1-pro`, `gemini-3-pro`, `gemini-3-flash`, `gemini-3.1-flash-lite`, `gemini-pro-vision`
-- Other exact built-in aliases: `llama-3.1-70b-instruct`, `qwen-max`
+- OpenAI / Codex: `gpt-4o`, `gpt-4.1`, `gpt-5`, `gpt-5.5`, `gpt-5-codex`, `gpt-5.3-codex`, `codex-mini-latest` → `deepseek-v4-flash`
+- OpenAI reasoning: `o1`, `o3`, `o4-mini` → `deepseek-v4-flash`; `o3-deep-research`, `o4-mini-deep-research` → `deepseek-v4-flash-search`
+- Claude: `claude-opus-4-6`, `claude-sonnet-4-6`, `claude-haiku-4-5`, `claude-3-5-sonnet-latest` → `deepseek-v4-flash`
+- Gemini: `gemini-2.5-pro`, `gemini-2.5-flash`, `gemini-3.1-pro`, `gemini-3-pro`, `gemini-3-flash`, `gemini-3.1-flash-lite`, `gemini-pro-vision` → `deepseek-v4-flash`
+- Other exact built-in aliases: `llama-3.1-70b-instruct`, `qwen-max` → `deepseek-v4-flash`
 
 Aliases with a `-nothinking` suffix also map to the corresponding forced no-thinking DeepSeek model.
 
-Current vision support resolves only to `deepseek-v4-vision` and does not expose a separate `vision-search` variant.
+Retired DeepSeek model names keep old clients working; they are normalized silently at parse time:
+
+| Requested model | Resolved to |
+| --- | --- |
+| `deepseek-v4-pro`, `deepseek-v4-vision` | `deepseek-v4-flash` |
+| `deepseek-v4-pro-search` | `deepseek-v4-flash-search` |
+| `deepseek-v4-pro-nothinking`, `deepseek-v4-vision-nothinking` | `deepseek-v4-flash-nothinking` |
+| `deepseek-v4-pro-search-nothinking` | `deepseek-v4-flash-search-nothinking` |
+
+The upstream `model_type` is now only `default` (a legacy `expert` / `vision` value is treated as `default`), so there is no separate vision or expert lane.
 
 Retired historical families such as `claude-1.*`, `claude-2.*`, `claude-instant-*`, and `gpt-3.5*` are explicitly rejected.
 
+### Thinking and search resolution
+
+The same rules apply to `/v1/chat/completions`, `/v1/responses`, `/anthropic/v1/messages`, and Gemini `generateContent`; they live in `internal/util/thinking.go` and `internal/util/search.go`, not in the protocol adapters.
+
+**Thinking**, lowest priority first:
+
+| Order | Source | Notes |
+| --- | --- | --- |
+| 1 | Model default | `-nothinking` variants default off; other flash models default on |
+| 2 | Explicit client override | Any matching field wins |
+| 3 | `-nothinking` model | Forces thinking off and outranks the client; a client cannot turn it back on |
+
+Client override fields (the same keys inside `extra_body` are read too):
+
+| Field | Accepted forms |
+| --- | --- |
+| `thinking` | bool; `"enabled"` / `"disabled"` (also `on` / `off` / `true` / `false` / `none`); `{"type": ...}` |
+| `reasoning` | `{"effort": ...}`, `{"type": ...}`, `{"enabled": ...}`; a plain string is parsed as an effort value |
+| `reasoning_effort` | `minimal` / `low` / `medium` / `high` / `xhigh` / `max` = on; `none` / `disabled` / `disable` / `off` / `false` = off |
+
+Clients such as Kelivo translate their "thinking intensity" UI into `reasoning_effort`: omitting it follows the default (thinking on), sending `none` turns thinking off. DS2API only models on/off; the intensity tier itself is not forwarded.
+
+**Search**, resolved as "model default → explicit client signal wins":
+
+| Signal | Notes |
+| --- | --- |
+| `enable_search` | bool, or strings such as `"true"` / `"false"` / `"on"` / `"off"` / `"enabled"` / `"disabled"` |
+| `web_search_options` | Presence alone counts as on |
+| `search_options` | Presence alone counts as on |
+| Native search tool in `tools` | `type` starting with `web_search`, `type=google_search`, or a tool object carrying `googleSearch` / `google_search` / `web_search` |
+
+`-search` variants enable native search by default; an explicit `enable_search=false` turns it off for that request. Ordinary function tools (for example Kelivo's own `search_web`) are not search signals, so upstream search stays off by default — pick a `-search` model when you need it. Once a client starts sending the native signals above, DS2API follows automatically with no configuration change.
+
 ### `POST /v1/chat/completions`
 
 > Path note: besides the canonical `/v1/chat/completions`, DS2API also accepts the root shortcut `/chat/completions`. On Vercel Runtime, `vercel.json` rewrites only the canonical `/v1/chat/completions` path to the Node streaming bridge; the root shortcut stays on the Go primary path. Use `/v1/chat/completions` on Vercel when real-time streaming is required.
@@ -264,8 +308,13 @@ Content-Type: application/json
 | `messages` | array | ✅ | OpenAI-style messages |
 | `stream` | boolean | ❌ | Default `false` |
 | `tools` | array | ❌ | Function calling schema |
+| `thinking` | bool / string / object | ❌ | Explicit thinking switch that overrides the model default; ignored by `-nothinking` models |
+| `reasoning` / `reasoning_effort` | object / string | ❌ | Alternative spelling of `thinking`; `reasoning_effort=none` turns thinking off, `minimal`..`max` turns it on |
+| `enable_search` | bool / string | ❌ | Explicit search switch that overrides the model default (e.g. turn search off on a `-search` model) |
 | `temperature`, etc. | any | ❌ | Accepted but final behavior depends on upstream |
 
+> Full precedence for thinking and search: [Thinking and search resolution](#thinking-and-search-resolution).
+
 #### Non-Stream Response
 
 ```json
@@ -273,7 +322,7 @@ Content-Type: application/json
   "id": "<chat_session_id>",
   "object": "chat.completion",
   "created": 1738400000,
-  "model": "deepseek-v4-pro",
+  "model": "deepseek-v4-flash",
   "choices": [
     {
       "index": 0,
@@ -322,6 +371,8 @@ data: [DONE]
 
 #### Tool Calls
 
+> If `tools.enabled=false` (the default), the `tools` in the request is ignored and the response never contains `tool_calls`. The behavior below only applies once tool calling is enabled; see [docs/prompt-compatibility.md](docs/prompt-compatibility.md) for the risk.
+
 When `tools` is present, DS2API performs anti-leak handling:
 
 **Non-stream**: If detected, returns `message.tool_calls`, `finish_reason=tool_calls`, `message.content=null`.
@@ -513,7 +564,7 @@ anthropic-version: 2023-06-01
 | `stop_sequences` | array | ❌ | Passed through as downstream stop sequences |
 | `tool_choice` | string/object | ❌ | Supports `auto` / `none` / `required` / `{"type":"function","name":"..."}` and is translated to downstream tool choice |
 
-> Note: `thinking`, `temperature`, `top_p`, `stop_sequences`, and `tool_choice` are translated through the compatibility bridge. Final behavior still depends on the selected model and upstream support. When both `temperature` and `top_p` are present, `temperature` takes precedence.
+> Note: `thinking`, `temperature`, `top_p`, `stop_sequences`, and `tool_choice` are translated through the compatibility bridge. Final behavior still depends on the selected model and upstream support. When both `temperature` and `top_p` are present, `temperature` takes precedence. Thinking and search precedence is identical to the OpenAI endpoints; see [Thinking and search resolution](#thinking-and-search-resolution). If `tools.enabled=false` (the default), the `tools` in the request is ignored and the response never contains `tool_calls` (a `tool_use` block on the Claude side).
 
 #### Non-Stream Response
 
@@ -607,7 +658,7 @@ Implementation-wise this path is unified on the OpenAI Chat Completions parse-an
 
 ### `POST /v1beta/models/{model}:generateContent`
 
-Request body accepts Gemini-style `contents` / `tools`. Model names can use aliases and are mapped to DeepSeek models.
+Request body accepts Gemini-style `contents` / `tools`. Model names can use aliases and are mapped to DeepSeek models; a `-nothinking` suffix in the path model name resolves to the matching forced no-thinking model. Thinking and search precedence is identical to the OpenAI endpoints; see [Thinking and search resolution](#thinking-and-search-resolution). If `tools.enabled=false` (the default), the `tools` in the request is ignored and the response never contains `tool_calls` (a `functionCall` part on the Gemini side).
 
 Response uses Gemini-compatible fields, including:
 
@@ -631,6 +682,7 @@ Returns SSE (`text/event-stream`), each chunk as `data: <json>`:
 ## Ollama API
 
 - `POST /api/show` request body: `{"model":"<model-id>"}`.
+- `GET /api/tags` lists only the four flash model IDs (`deepseek-v4-flash`, `deepseek-v4-flash-search`, plus their `-nothinking` variants), matching `/v1/models`. Retired pro / vision names no longer appear, but they are still accepted as a `model` input.
 - Response uses lowercase `id` (not `ID`) and includes `capabilities` for Ollama-style clients and strict schemas.
 
 Example response:
@@ -730,7 +782,7 @@ Returns sanitized config, including both `keys` and `api_keys`.
   ],
   "model_aliases": {
     "claude-sonnet-4-6": "deepseek-v4-flash",
-    "claude-opus-4-6": "deepseek-v4-pro"
+    "claude-opus-4-6": "deepseek-v4-flash"
   }
 }
 ```
@@ -754,11 +806,69 @@ If both `api_keys` and `keys` are sent, the structured `api_keys` entries win so
   ],
   "model_aliases": {
     "claude-sonnet-4-6": "deepseek-v4-flash",
-    "claude-opus-4-6": "deepseek-v4-pro"
+    "claude-opus-4-6": "deepseek-v4-flash"
   }
 }
 ```
 
+### `api_keys[].thinking_injection` (per-key override for thinking-format injection)
+
+Every `api_keys` entry may carry `thinking_injection` to give that single API key its own injection prompt; the legacy `keys` form does not support the field.
+
+```json
+{
+  "api_keys": [
+    {
+      "key": "k1",
+      "name": "Primary",
+      "remark": "Production",
+      "thinking_injection": {
+        "custom": true,
+        "enabled": true,
+        "prompt": "List the known constraints before answering, then give the conclusion."
+      }
+    },
+    {"key": "k2", "name": "Backup"}
+  ]
+}
+```
+
+| Field | Notes |
+| --- | --- |
+| `custom` | Defaults to `false`. When `false` (or the whole block is omitted) the key fully follows the global `thinking_injection` |
+| `enabled` | Only used when `custom=true`; omitting it means "keep following the global switch" |
+| `prompt` | Only used when `custom=true`; empty or whitespace-only means "keep following the global prompt" |
+
+For the global switch and default prompt see `thinking_injection` under [`GET /admin/settings`](#get-adminsettings); for the injection position and the built-in default prompt text see [docs/prompt-compatibility.md](docs/prompt-compatibility.md).
+
+### `api_keys[].skills` (per-key skill injection)
+
+Every `api_keys` entry may carry `skills` to choose which skills that single API key injects. It sits next to `thinking_injection`; the legacy `keys` form does not support the field.
+
+```json
+{
+  "api_keys": [
+    {"key": "k1", "name": "Primary", "skills": {"custom": true, "enabled": true, "ids": ["sql-report"]}},
+    {"key": "k2", "name": "Backup"}
+  ]
+}
+```
+
+| Field | Notes |
+| --- | --- |
+| `custom` | Defaults to `false`; when `false` or omitted the key uses every entry in `skills.items` |
+| `enabled` | Only used when `custom=true`; `false` means this key injects nothing |
+| `ids` | Only used when `custom=true`; non-empty means only the matching skills, empty means this key injects nothing |
+
+| `custom` | `enabled` | `ids` | Result |
+| --- | --- | --- | --- |
+| omitted or `false` | any | any | Uses all `items` |
+| `true` | `false` | any | Nothing injected |
+| `true` | omitted or `true` | non-empty | Only the matching `items` |
+| `true` | omitted or `true` | empty | Nothing injected |
+
+When the global `skills.enabled=false`, the whole table is moot and no key injects anything. For skill bodies and the admin endpoint see [`GET` / `PUT /admin/skills`](#get--put-adminskills).
+
 ### `GET /admin/settings`
 
 Reads runtime settings and status, including:
@@ -771,8 +881,9 @@ Reads runtime settings and status, including:
 - `responses` / `embeddings`
 - `auto_delete` (`mode`: `none` / `single` / `all`; legacy `sessions=true` is still treated as `all`)
 - `current_input_file` (`enabled` defaults to `true`, plus `min_chars`)
-- `thinking_injection` (`enabled` defaults to `true`, `prompt`, and `default_prompt`)
+- `thinking_injection` (`enabled` defaults to `true`, plus `prompt` and `default_prompt`); an empty `prompt` uses the built-in default, and a single key can override it through `api_keys[].thinking_injection`
 - `model_aliases`
+- `tools` (`enabled`: master switch for tool calling, defaults to `false`; `default_enabled`: always `false`, used by the panel to show the default)
 - `env_backed`, `needs_vercel_sync`
 - `toolcall` policy is fixed to `feature_match + high` and is no longer returned or editable via settings
 
@@ -787,9 +898,18 @@ Hot-updates runtime settings. Supported fields:
 - `auto_delete.mode`
 - `current_input_file.enabled` / `current_input_file.min_chars`
 - `thinking_injection.enabled` / `thinking_injection.prompt`
+- `tools.enabled`
 - `model_aliases`
 - `toolcall` policy is fixed and is no longer writable through settings
 
+`tools.enabled` only changes the field you actually send; the existing semantics of every other setting stay the same:
+
+```json
+{"tools": {"enabled": true}}
+```
+
+When it is off (the default), requests that carry `tools` are handled as plain chat. DSML tool calling can trip upstream risk control and get an account banned, so enable it deliberately; the risk notes live in [docs/prompt-compatibility.md](docs/prompt-compatibility.md).
+
 ### `POST /admin/settings/password`
 
 Updates admin password and invalidates existing JWTs.
@@ -802,6 +922,65 @@ Request example:
 
 It also accepts `{"password":"your-new-password"}`.
 
+### `GET` / `PUT /admin/skills`
+
+A plain-text skill library, experimental and off by default (`skills.enabled=false`). The server concatenates skill bodies into the prompt, so the model follows a fixed routine without ever emitting a tool call.
+
+- Global config: `skills.enabled` (defaults to `false`), `skills.max_chars` (defaults to `8000`), `skills.items`
+- Per-key override: `api_keys[].skills`, semantics in `api_keys[].skills` above
+- Injection shape, injection order, and "why plain text instead of tool calling": the skills section of [docs/prompt-compatibility.md](docs/prompt-compatibility.md) (Chinese)
+
+**GET response**:
+
+```json
+{
+  "enabled": false,
+  "max_chars": 8000,
+  "items": [
+    {
+      "id": "sql-report",
+      "name": "SQL report",
+      "description": "Write SQL against a fixed metric definition",
+      "body": "# Skill body markdown\n..."
+    }
+  ]
+}
+```
+
+**PUT request**: same shape as GET; it replaces the whole library, no incremental merge.
+
+```json
+{
+  "enabled": true,
+  "max_chars": 8000,
+  "items": [
+    {
+      "id": "sql-report",
+      "name": "SQL report",
+      "description": "Write SQL against a fixed metric definition",
+      "body": "# Reporting rules\nAggregate by day first, then split by channel."
+    }
+  ]
+}
+```
+
+**PUT success response**:
+
+```json
+{"success": true, "count": 1}
+```
+
+**Validation rules** (any violation returns `400` with `{"detail": "..."}`):
+
+| Field | Rule |
+| --- | --- |
+| `items` | At most 50 entries |
+| `id` | Required, unique, character set `[a-z0-9_-]` |
+| `body` | Required; at most 100000 characters per entry and 500000 characters in total |
+| `max_chars` | Defaults to `8000`; truncates by character (rune) and appends `（技能内容已截断）` when truncated; `0` means unlimited |
+
+Validation runs on write and is independent of `enabled`, so you can author and fix the content with the switch still off, then turn it on. Over-limit bodies, duplicate ids, and invalid ids are never silently fixed.
+
 ### `POST /admin/config/import`
 
 Imports full config with:
@@ -1230,6 +1409,105 @@ Clears packet-capture entries:
 {"success":true,"detail":"capture logs cleared"}
 ```
 
+### `GET /admin/chat-history`
+
+Reads server-side conversation history with filtering and paging.
+
+**Query parameters**:
+
+| Parameter | Default | Matching rule |
+| --- | --- | --- |
+| `caller` | empty | Exact match on `caller_id` (use `callers[].caller_id` from the response, not the key name) |
+| `status` | empty | Case-insensitive exact match: `streaming` / `success` / `error` / `stopped` |
+| `surface` | empty | Case-insensitive exact match, e.g. `openai.chat_completions`, `openai.responses`, `claude.messages`, `gemini.generate_content` |
+| `q` | empty | Case-insensitive substring match over `user_input` / `preview` / `model` / `caller_label` / `error` |
+| `offset` | `0` | Paging offset; `offset` and `limit` both `0` means "no paging" |
+| `limit` | `0` | Page size; `0` means "no limit" (the settings retention limit is not used as a page size) |
+
+Invalid or negative `offset` / `limit` values are treated as `0`.
+
+**Response**:
+
+```json
+{
+  "version": 2,
+  "limit": 20,
+  "revision": 128,
+  "total": 137,
+  "callers": [
+    {"caller_id": "caller:9f2c1a2b3c4d5e6f", "label": "Primary", "configured": true, "count": 96},
+    {"caller_id": "caller:41ab0c9d8e7f6a5b", "label": "Backup", "configured": true, "count": 0}
+  ],
+  "items": [
+    {
+      "id": "chat_20260418_093012_ab12",
+      "status": "success",
+      "caller_id": "caller:9f2c1a2b3c4d5e6f",
+      "caller_label": "Primary",
+      "account_id": "user@example.com",
+      "surface": "openai.chat_completions",
+      "model": "deepseek-v4-flash",
+      "stream": true,
+      "user_input": "today's news",
+      "preview": "……",
+      "status_code": 200,
+      "elapsed_ms": 4210,
+      "finish_reason": "stop",
+      "created_at": 1777000000000,
+      "updated_at": 1777000004000,
+      "detail_revision": 3
+    }
+  ],
+  "path": "/data/chat_history.json"
+}
+```
+
+- `total` is the filtered count, `items` is the current page; without any filter or paging parameter `items` still holds all summaries.
+- `caller_label` is a readable label for the calling API key (name / remark / masked value); keys without a remark fall back to the masked value so the panel never shows a bare hash.
+- `callers` aggregates the `caller_id`s found in records and adds keys that are configured but have no records yet (`count` is `0`, `configured=true`), sorted by `count` descending and `label` ascending.
+- Timestamp fields (`created_at` / `updated_at` / `completed_at`) are milliseconds.
+- `If-None-Match` + `ETag` revalidation (`304`) only applies when **no filter or paging parameter** is set, because a filtered response body changes with the query.
+
+### `GET /admin/chat-history/{id}`
+
+Reads one full record as `{"item": {...}}`. Besides the summary fields it carries `messages`, `history_text` (the full conversation transcript uploaded by the history split), `final_prompt`, `reasoning_content`, `content`, `error`, `usage`, and `file_infos` (uploaded file IDs, audit result, source). `ETag` / `304` is supported here too.
+
+### `DELETE /admin/chat-history`
+
+Clears every server-side record and returns `{"success": true}`.
+
+### `DELETE /admin/chat-history/{id}`
+
+Deletes one record and returns `{"success": true}`; a missing record returns `404`.
+
+### `PUT /admin/chat-history/settings`
+
+Updates the retention limit. `limit` accepts any integer in `0`..`500`; there are no fixed tiers anymore.
+
+```json
+{"limit": 120}
+```
+
+| Value | Behavior |
+| --- | --- |
+| `0` | Recording is off: no new records are written |
+| `1`..`500` | Keep the newest N records and evict the rest by creation time |
+| Anything else | `400` with `detail` = `unsupported chat history limit: <n>` |
+
+The response carries `success`, `limit`, `revision`, and the trimmed `items`.
+
+### `GET /admin/chat-history/export`
+
+Exports records with the same filter and paging parameters as the list endpoint (`caller` / `status` / `surface` / `q` / `offset` / `limit`); the response is a file download.
+
+| Parameter | Notes |
+| --- | --- |
+| `format=json` (default) | JSON attachment shaped as `{exported_at, count, filters, items}`; `exported_at` is RFC3339, `filters` echoes the applied filters, and `items` holds full records including large fields such as `messages` / `final_prompt` / `history_text` |
+| `format=markdown` | Markdown attachment titled `# ds2api 响应记录导出`, one `## N. <record id>` section per record, with time, surface, model, account, caller, status, elapsed time, finish reason, plus `UserInput` / `FinalPrompt` / `ReasoningContent` / `Content` / `Error` code blocks |
+| Any other value | `400` with `detail` = `unsupported export format: <format>` |
+
+The response also sets `Content-Disposition: attachment` (filename `ds2api-logs-<YYYYMMDD-HHMMSS>.json|.md`) and `Cache-Control: no-store`. If a record is deleted mid-export it is skipped, and `count` reflects what was actually exported.
+
 ---
 
 ## Error Payloads
@@ -1295,7 +1573,7 @@ curl http://localhost:5001/v1/chat/completions \
   -H "Authorization: Bearer your-api-key" \
   -H "Content-Type: application/json" \
   -d '{
-    "model": "deepseek-v4-pro",
+    "model": "deepseek-v4-flash",
     "messages": [{"role": "user", "content": "Explain quantum entanglement"}],
     "stream": true
   }'

API.md

@@ -4,7 +4,7 @@
 
 本文档描述当前 Go 代码库的实际 API 行为。
 
-文档导航：[总览](README.MD) / [架构说明](docs/ARCHITECTURE.md) / [部署指南](docs/DEPLOY.md) / [测试指南](docs/TESTING.md)
+文档导航：[总览](README.MD) / [架构说明](docs/ARCHITECTURE.md) / [部署指南](docs/DEPLOY.md) / [测试指南](docs/TESTING.md) / [上下文兼容流程](docs/prompt-compatibility.md)
 
 ---
 
@@ -40,6 +40,7 @@
 
 - OpenAI / Claude / Gemini 三套协议已统一挂在同一 `chi` 路由树上，由 `internal/server/router.go` 负责装配。
 - 适配器层职责收敛为：**请求归一化 → DeepSeek 调用 → 协议形态渲染**，减少历史版本中“同能力多处实现”的分叉。
+- 从协议请求到纯文本 web-chat prompt 的完整链路（统一标准请求、思考格式注入、历史拆分、完成载荷组装、响应归档）见 [docs/prompt-compatibility.md](docs/prompt-compatibility.md)，该文是这条流程的源文档；本文只描述各接口的可见字段与响应形态。
 - Tool Calling 的解析策略在 Go 与 Node Runtime 间保持一致：推荐模型输出半角管道符 DSML 外壳 `<|DSML|tool_calls>` → `<|DSML|invoke name="...">` → `<|DSML|parameter name="...">`；兼容层也接受 DSML wrapper 别名 `<dsml|tool_calls>`、`<|tool_calls>`、常见 DSML 分隔符漏写形态（如 `<|DSML tool_calls>`）、`DSML` 与工具标签名黏连的常见 typo（如 `<DSMLtool_calls>`）、控制分隔符漂移（如 `<DSML␂tool_calls>` / 原始 STX `\x02`）、CJK 尖括号、全角感叹号、顿号、PascalCase 本地名、弯引号属性值与属性尾部分隔符漂移（如 `<DSM|parameter name="command"|>...〈/DSM|parameter〉` / `<！DSML！invoke name=“Bash”>` / `<、DSML、tool_calls>` / `<DSmartToolCalls>` / `<DSMLtool_calls※>`）、任意协议前缀壳（如 `<proto💥tool_calls>`），以及旧式 canonical XML `<tool_calls>` → `<invoke name="...">` → `<parameter name="...">`。实现上采用结构扫描：只要固定本地标签名是 `tool_calls` / `invoke` / `parameter`，标签名前或标签名后的非结构性分隔符会在解析入口归一化；CDATA 开头也会容错 `<！[CDATA[` / `<、[CDATA[` 这类分隔符漂移；只有 `tool_calls` wrapper 或可修复的缺失 opening wrapper 会进入工具路径，裸 `<invoke>` 不计为已支持语法；流式场景继续执行防泄漏筛分。若参数体本身是合法 JSON 字面量（如 `123`、`true`、`null`、数组或对象），会按结构化值输出，不再一律当作字符串；显式空字符串和纯空白参数会结构化保留为空字符串，是否拒绝缺参由工具执行侧决定；完整但 malformed 的 wrapper 会作为普通文本释放，不会吞掉或伪造成工具调用；若 CDATA 偶发漏闭合，则会在最终 parse / flush 恢复阶段做窄修复，尽量保住已完整包裹的外层工具调用。
 - `Admin API` 将配置与运行时策略分开：`/admin/config*` 管静态配置，`/admin/settings*` 管运行时行为。
 - 当上游返回 thinking-only 响应（模型输出了推理链但无可见文本）时，Go 主路径与 Vercel Node 流式路径都会先自动重试一次：以多轮对话 follow-up 方式追加 prompt 后缀 `"Please provide a non-empty final answer or tool call."` 并设置 `parent_message_id` 在同一 DeepSeek session 内让模型重新输出；同账号重试最大 1 次。若同账号重试后仍即将返回 `429 upstream_empty_output`，托管账号模式会在返回 429 前自动切换到下一个可用账号，新建 session，用原始 payload 再 fresh retry 一次。
@@ -137,6 +138,8 @@ Gemini 兼容客户端还可以使用 `x-goog-api-key`、`?key=` 或 `?api_key=`
 | GET | `/admin/settings` | Admin | 读取运行时设置 |
 | PUT | `/admin/settings` | Admin | 更新运行时设置（热更新） |
 | POST | `/admin/settings/password` | Admin | 更新 Admin 密码并使旧 JWT 失效 |
+| GET | `/admin/skills` | Admin | 读取技能库配置（全局开关、截断长度、条目列表） |
+| PUT | `/admin/skills` | Admin | 整体替换技能库配置（校验失败返回 400） |
 | POST | `/admin/config/import` | Admin | 导入配置（merge/replace） |
 | GET | `/admin/config/export` | Admin | 导出完整配置（含 `config`/`json`/`base64`） |
 | POST | `/admin/keys` | Admin | 添加 API key（可附 name/remark） |
@@ -167,16 +170,17 @@ Gemini 兼容客户端还可以使用 `x-goog-api-key`、`?key=` 或 `?api_key=`
 | GET | `/admin/export` | Admin | 导出配置 JSON/Base64 |
 | GET | `/admin/dev/captures` | Admin | 查看本地抓包记录 |
 | DELETE | `/admin/dev/captures` | Admin | 清空本地抓包记录 |
-| GET | `/admin/chat-history` | Admin | 查看服务器端对话记录 |
+| GET | `/admin/chat-history` | Admin | 查看服务器端对话记录（支持按 caller/status/surface/关键词筛选与分页） |
 | DELETE | `/admin/chat-history` | Admin | 清空服务器端对话记录 |
 | GET | `/admin/chat-history/{id}` | Admin | 查看单条服务器端对话���录 |
 | DELETE | `/admin/chat-history/{id}` | Admin | 删除单条服务器端对话记录 |
-| PUT | `/admin/chat-history/settings` | Admin | 更新对话记录保留条数 |
+| PUT | `/admin/chat-history/settings` | Admin | 更新对话记录保留条数（`0`..`500`） |
+| GET | `/admin/chat-history/export` | Admin | 按相同筛选条件导出对话记录（`json` / `markdown`） |
 | GET | `/admin/version` | Admin | 查询当前版本与最新 Release |
 
 OpenAI `/v1/*` 仍是规范路径。对于只配置 DS2API 根地址的客户端，同一套 OpenAI handler 也通过根路径快捷路由暴露：`/models`、`/models/{id}`、`/chat/completions`、`/responses`、`/responses/{response_id}`、`/embeddings`、`/files`、`/files/{file_id}`。
 
-服务器端记录本质上是 DeepSeek 上游响应归档：OpenAI Chat、OpenAI Responses、Claude Messages、Gemini GenerateContent 等直连 DeepSeek 的生成接口，在收到上游响应后会于各协议回译/裁剪前写入记录；列表按请求创建时间倒序展示，流式请求会在生成过程中持续刷新状态与详情。WebUI「API 测试」发出的请求也会进入该记录。
+服务器端记录本质上是 DeepSeek 上游响应归档：OpenAI Chat、OpenAI Responses、Claude Messages、Gemini GenerateContent 等直连 DeepSeek 的生成接口，在收到上游响应后会于各协议回译/裁剪前写入记录；列表按请求创建时间倒序展示，流式请求会在生成过程中持续刷新状态与详情。WebUI「API 测试」发出的请求也会进入该记录。每条记录带 `caller_id`（API Key 调用方）与 `caller_label`（Key 的名称/备注/脱敏值），以及 `surface`（来源接口）、`status`、`status_code` 等可筛选字段；列表、详情、导出共用同一份数据，详见 [对话记录](#get-adminchat-history)。
 
 ---
 
@@ -210,19 +214,15 @@ OpenAI `/v1/*` 仍是规范路径。对于只配置 DS2API 根地址的客户端
   "data": [
     {"id": "deepseek-v4-flash", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
     {"id": "deepseek-v4-flash-nothinking", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
-    {"id": "deepseek-v4-pro", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
-    {"id": "deepseek-v4-pro-nothinking", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
     {"id": "deepseek-v4-flash-search", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
-    {"id": "deepseek-v4-flash-search-nothinking", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
-    {"id": "deepseek-v4-pro-search", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
-    {"id": "deepseek-v4-pro-search-nothinking", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
-    {"id": "deepseek-v4-vision", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []},
-    {"id": "deepseek-v4-vision-nothinking", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []}
+    {"id": "deepseek-v4-flash-search-nothinking", "object": "model", "created": 1677610602, "owned_by": "deepseek", "permission": []}
   ]
 }
 ```
 
 > 说明：`/v1/models` 返回的是规范化后的 DeepSeek 原生模型 ID；常见 alias 仅用于请求入参解析，不会在该接口中单独展开返回。带 `-nothinking` 后缀的模型表示无论请求里是否显式开启 thinking / reasoning，都会强制关闭思考输出。
+>
+> 模型系列已收敛到上表 4 个 flash 变体：`deepseek-v4-pro` / `deepseek-v4-pro-search` / `deepseek-v4-vision` 及其 `-nothinking` 形式已下线，不再出现在本接口、Ollama `/api/tags` 与 `/anthropic/v1/models` 中，但旧名字仍可被请求，解析时静默映射到 flash 对应项（见下一节）。
 
 ### 模型 alias 解析策略
 
@@ -233,19 +233,62 @@ OpenAI `/v1/*` 仍是规范路径。对于只配置 DS2API 根地址的客户端
 3. 如果请求名以 `-nothinking` 结尾，则在最终解析出的规范模型上追加对应的无思考变体。
 4. 仍未命中则返回 `invalid_request_error`。当前不会按未知模型家族做启发式兜底；需要新增兼容名时请通过 `model_aliases` 明确配置。
 
-当前内置默认 alias 来自 `internal/config/models.go`，`config.model_aliases` 会在运行时覆盖或补充同名映射。节选：
+当前内置默认 alias 来自 `internal/config/models.go`，`config.model_aliases` 会在运行时覆盖或补充同名映射。节选（全部指向 flash 系列）：
 
-- OpenAI / Codex：`gpt-4o`、`gpt-4.1`、`gpt-5`、`gpt-5.5`、`gpt-5-codex`、`gpt-5.3-codex`、`codex-mini-latest`
-- OpenAI reasoning：`o1`、`o3`、`o3-deep-research`、`o4-mini`
-- Claude：`claude-opus-4-6`、`claude-sonnet-4-6`、`claude-haiku-4-5`、`claude-3-5-sonnet-latest`
-- Gemini：`gemini-2.5-pro`、`gemini-2.5-flash`、`gemini-3.1-pro`、`gemini-3-pro`、`gemini-3-flash`、`gemini-3.1-flash-lite`、`gemini-pro-vision`
-- 其他内置精确 alias：`llama-3.1-70b-instruct`、`qwen-max`
+- OpenAI / Codex：`gpt-4o`、`gpt-4.1`、`gpt-5`、`gpt-5.5`、`gpt-5-codex`、`gpt-5.3-codex`、`codex-mini-latest` → `deepseek-v4-flash`
+- OpenAI reasoning：`o1`、`o3`、`o4-mini` → `deepseek-v4-flash`；`o3-deep-research`、`o4-mini-deep-research` → `deepseek-v4-flash-search`
+- Claude：`claude-opus-4-6`、`claude-sonnet-4-6`、`claude-haiku-4-5`、`claude-3-5-sonnet-latest` → `deepseek-v4-flash`
+- Gemini：`gemini-2.5-pro`、`gemini-2.5-flash`、`gemini-3.1-pro`、`gemini-3-pro`、`gemini-3-flash`、`gemini-3.1-flash-lite`、`gemini-pro-vision` → `deepseek-v4-flash`
+- 其他内置精确 alias：`llama-3.1-70b-instruct`、`qwen-max` → `deepseek-v4-flash`
 
 上述 alias 若在请求名后追加 `-nothinking` 后缀，也会映射到对应的强制关闭 thinking 版本。
-当前视觉能力仅对应 `deepseek-v4-vision` / `deepseek-v4-vision-nothinking`，不会解析出独立的 `vision-search` 变体。
+
+已下线的 DeepSeek 模型名不会让老客户端失效，解析时静默归一：
+
+| 请求模型名 | 实际解析结果 |
+| --- | --- |
+| `deepseek-v4-pro` / `deepseek-v4-vision` | `deepseek-v4-flash` |
+| `deepseek-v4-pro-search` | `deepseek-v4-flash-search` |
+| `deepseek-v4-pro-nothinking` / `deepseek-v4-vision-nothinking` | `deepseek-v4-flash-nothinking` |
+| `deepseek-v4-pro-search-nothinking` | `deepseek-v4-flash-search-nothinking` |
+
+上游 `model_type` 现在只剩 `default`（历史配置里出现的 `expert` / `vision` 按 `default` 处理），因此不存在独立的视觉或 expert 通道。
 
 退役历史模型（如 `claude-1.*`、`claude-2.*`、`claude-instant-*`、`gpt-3.5*`）会被显式拒绝。
 
+### 思考与联网搜索解析策略
+
+同一套规则适用于 `/v1/chat/completions`、`/v1/responses`、`/anthropic/v1/messages` 与 Gemini `generateContent`，实现在 `internal/util/thinking.go`、`internal/util/search.go`，不在各协议适配器里。
+
+**思考（thinking）**，优先级从低到高：
+
+| 顺序 | 来源 | 说明 |
+| --- | --- | --- |
+| 1 | 模型默认值 | `-nothinking` 变体默认关；其余 flash 模型默认开 |
+| 2 | 客户端显式覆盖 | 命中任一字段即生效 |
+| 3 | `-nothinking` 模型 | 强制关闭，优先级最高，客户端无法打开 |
+
+客户端覆盖字段（`extra_body` 里的同名键同样会被读取）：
+
+| 字段 | 接受写法 |
+| --- | --- |
+| `thinking` | bool；`"enabled"` / `"disabled"`（含 `on` / `off` / `true` / `false` / `none`）；`{"type": ...}` |
+| `reasoning` | `{"effort": ...}`、`{"type": ...}`、`{"enabled": ...}`；字符串按 effort 解析 |
+| `reasoning_effort` | `minimal` / `low` / `medium` / `high` / `xhigh` / `max` = 开启；`none` / `disabled` / `disable` / `off` / `false` = 关闭 |
+
+Kelivo 这类客户端的「思维强度」界面就是靠 `reasoning_effort` 传开关：不发该字段表示跟随默认（开启思考），传 `none` 表示关闭。本项目只区分开/关，不区分强度档位。
+
+**联网搜索（search）**，优先级为「模型默认 → 客户端显式信号优先」：
+
+| 信号 | 说明 |
+| --- | --- |
+| `enable_search` | bool，或 `"true"` / `"false"` / `"on"` / `"off"` / `"enabled"` / `"disabled"` 等字符串 |
+| `web_search_options` | 字段出现即视为开启 |
+| `search_options` | 字段出现即视为开启 |
+| `tools` 原生搜索类型 | `type` 以 `web_search` 开头、`type=google_search`，或工具对象含 `googleSearch` / `google_search` / `web_search` 字段 |
+
+`-search` 变体默认开启联网；显式 `enable_search=false` 可在该模型上临时关掉。普通 function 工具（例如 Kelivo 客户端自己执行的 `search_web`）不算联网信号，所以默认仍不开启上游联网——要联网请选 `-search` 模型；一旦客户端开始发送上述原生信号，服务端会自动跟随，无需改配置。
+
 ### `POST /v1/chat/completions`
 
 > 路径说明：除规范路径 `/v1/chat/completions` 外，也支持根路径快捷别名 `/chat/completions`。在 Vercel Runtime 上，`vercel.json` 仅把规范路径 `/v1/chat/completions` 重写到 Node 流式桥接；根路径快捷别名仍走 Go 主链路。因此 Vercel 上需要实时流式时请使用 `/v1/chat/completions`。
@@ -265,8 +308,13 @@ Content-Type: application/json
 | `messages` | array | ✅ | OpenAI 风格消息数组 |
 | `stream` | boolean | ❌ | 默认 `false` |
 | `tools` | array | ❌ | Function Calling 定义 |
+| `thinking` | bool / string / object | ❌ | 显式思考开关，覆盖模型默认；`-nothinking` 模型会忽略 |
+| `reasoning` / `reasoning_effort` | object / string | ❌ | 与 `thinking` 等价的另一种写法；`reasoning_effort=none` 关闭思考，`minimal`~`max` 开启 |
+| `enable_search` | bool / string | ❌ | 显式联网开关，覆盖模型默认（用于在 `-search` 模型上临时关闭） |
 | `temperature` 等 | any | ❌ | 兼容透传字段（最终效果由上游决定） |
 
+> 思考与联网的完整解析优先级见 [思考与联网搜索解析策略](#思考与联网搜索解析策略)。
+
 #### 非流式响应
 
 ```json
@@ -274,7 +322,7 @@ Content-Type: application/json
   "id": "<chat_session_id>",
   "object": "chat.completion",
   "created": 1738400000,
-  "model": "deepseek-v4-pro",
+  "model": "deepseek-v4-flash",
   "choices": [
     {
       "index": 0,
@@ -323,6 +371,8 @@ data: [DONE]
 
 #### Tool Calls
 
+> 若 `tools.enabled=false`（默认），请求里的 `tools` 会被忽略，响应不会包含 `tool_calls`。下面描述的行为只在开启工具调用后生效，开启风险见 [docs/prompt-compatibility.md](docs/prompt-compatibility.md)。
+
 当请求中含 `tools` 时，DS2API 做防泄漏处理：
 
 **非流式**：识别到工具调用时，返回 `message.tool_calls`，设置 `finish_reason=tool_calls`，`message.content=null`。
@@ -518,7 +568,7 @@ anthropic-version: 2023-06-01
 | `stop_sequences` | array | ❌ | 透传到下游停用序列 |
 | `tool_choice` | string/object | ❌ | 支持 `auto` / `none` / `required` / `{"type":"function","name":"..."}`，并会转译为下游工具选择 |
 
-> 说明：上述 `thinking`、`temperature`、`top_p`、`stop_sequences`、`tool_choice` 都会走兼容层转译；最终是否生效仍取决于当前模型和上游能力。`temperature` 与 `top_p` 同时存在时，`temperature` 优先。
+> 说明：上述 `thinking`、`temperature`、`top_p`、`stop_sequences`、`tool_choice` 都会走兼容层转译；最终是否生效仍取决于当前模型和上游能力。`temperature` 与 `top_p` 同时存在时，`temperature` 优先。思考与联网的解析优先级与 OpenAI 接口完全一致，见 [思考与联网搜索解析策略](#思考与联网搜索解析策略)。若 `tools.enabled=false`（默认），请求里的 `tools` 会被忽略，响应不会包含 `tool_calls`（Claude 侧即 `tool_use` 块）。
 
 #### 非流式响应
 
@@ -613,7 +663,7 @@ data: {"type":"message_stop"}
 
 ### `POST /v1beta/models/{model}:generateContent`
 
-请求体兼容 Gemini `contents` / `tools` 字段，模型名可用 alias 自动映射到 DeepSeek 模型；若路径中的模型名带 `-nothinking` 后缀，则最终会映射到对应的无思考模型。
+请求体兼容 Gemini `contents` / `tools` 字段，模型名可用 alias 自动映射到 DeepSeek 模型；若路径中的模型名带 `-nothinking` 后缀，则最终会映射到对应的无思考模型。思考与联网的解析优先级与 OpenAI 接口一致，见 [思考与联网搜索解析策略](#思考与联网搜索解析策略)。若 `tools.enabled=false`（默认），请求里的 `tools` 会被忽略，响应不会包含 `tool_calls`（Gemini 侧即 `functionCall`）。
 
 响应为 Gemini 兼容结构，核心字段包括：
 
@@ -637,6 +687,7 @@ data: {"type":"message_stop"}
 ## Ollama 兼容接口
 
 - `POST /api/show` 请求体：`{"model":"<model-id>"}`。
+- `GET /api/tags` 只列出 flash 系列的 4 个模型 ID（`deepseek-v4-flash`、`deepseek-v4-flash-search` 及各自 `-nothinking` 变体），与 `/v1/models` 保持一致；已下线的 pro / vision 名字不再出现，但仍可作为 `model` 入参被请求。
 - 响应字段使用小写 `id`（不是 `ID`），并返回 `capabilities` 数组，便于与 Ollama 风格客户端/严格 schema 对齐。
 
 示例响应：
@@ -736,7 +787,7 @@ data: {"type":"message_stop"}
   ],
   "model_aliases": {
     "claude-sonnet-4-6": "deepseek-v4-flash",
-    "claude-opus-4-6": "deepseek-v4-pro"
+    "claude-opus-4-6": "deepseek-v4-flash"
   }
 }
 ```
@@ -760,11 +811,69 @@ data: {"type":"message_stop"}
   ],
   "model_aliases": {
     "claude-sonnet-4-6": "deepseek-v4-flash",
-    "claude-opus-4-6": "deepseek-v4-pro"
+    "claude-opus-4-6": "deepseek-v4-flash"
   }
 }
 ```
 
+### `api_keys[].thinking_injection`（单 Key 覆盖思考格式注入）
+
+`api_keys` 的每一项都可以带 `thinking_injection`，用于给单个 API Key 定制注入提示词；`keys` 旧格式不支持该字段。
+
+```json
+{
+  "api_keys": [
+    {
+      "key": "k1",
+      "name": "主 Key",
+      "remark": "生产流量",
+      "thinking_injection": {
+        "custom": true,
+        "enabled": true,
+        "prompt": "回答前先列清楚已知条件，再给结论。"
+      }
+    },
+    {"key": "k2", "name": "备用 Key"}
+  ]
+}
+```
+
+| 字段 | 说明 |
+| --- | --- |
+| `custom` | 默认 `false`。为 `false`（或整段省略）时完全跟随全局 `thinking_injection` |
+| `enabled` | 仅在 `custom=true` 时生效；省略表示继续跟随全局开关 |
+| `prompt` | 仅在 `custom=true` 时生效；为空或全空白表示继续跟随全局提示词 |
+
+全局开关与默认提示词见 [`GET /admin/settings`](#get-adminsettings) 的 `thinking_injection`；注入位置与默认提示词内容见 [docs/prompt-compatibility.md](docs/prompt-compatibility.md)。
+
+### `api_keys[].skills`（单 Key 覆盖技能注入）
+
+`api_keys` 的每一项都可以带 `skills`，用来指定这个 API Key 注入哪些技能，与 `thinking_injection` 并列；`keys` 旧格式不支持该字段。
+
+```json
+{
+  "api_keys": [
+    {"key": "k1", "name": "主 Key", "skills": {"custom": true, "enabled": true, "ids": ["sql-report"]}},
+    {"key": "k2", "name": "备用 Key"}
+  ]
+}
+```
+
+| 字段 | 说明 |
+| --- | --- |
+| `custom` | 默认 `false`；为 `false` 或整段省略时使用全部 `skills.items` |
+| `enabled` | 仅在 `custom=true` 时生效；为 `false` 表示该 Key 不注入 |
+| `ids` | 仅在 `custom=true` 时生效；非空时只用命中的技能，为空时该 Key 不注入 |
+
+| `custom` | `enabled` | `ids` | 结果 |
+| --- | --- | --- | --- |
+| 省略或 `false` | 任意 | 任意 | 使用全部 `items` |
+| `true` | `false` | 任意 | 不注入 |
+| `true` | 省略或 `true` | 非空 | 只用命中的 `items` |
+| `true` | 省略或 `true` | 空 | 不注入 |
+
+全局 `skills.enabled=false` 时上表全部不生效，任何 Key 都不注入。技能正文与管理接口见 [`GET` / `PUT /admin/skills`](#get--put-adminskills)。
+
 ### `GET /admin/settings`
 
 读取运行时设置与状态，返回：
@@ -777,8 +886,9 @@ data: {"type":"message_stop"}
 - `responses` / `embeddings`
 - `auto_delete`（`mode`：`none` / `single` / `all`；旧配置 `sessions=true` 仍按 `all` 处理）
 - `current_input_file`（`enabled` 默认返回 `true`、`min_chars`）
-- `thinking_injection`（`enabled` 默认返回 `true`、`prompt`、`default_prompt`）
+- `thinking_injection`（`enabled` 缺省为 `true`、`prompt`、`default_prompt`）；`prompt` 为空时使用内置默认提示词，单 Key 可用 `api_keys[].thinking_injection` 覆盖
 - `model_aliases`
+- `tools`（`enabled`：工具调用总开关，缺省 `false`；`default_enabled`：固定 `false`，供面板显示默认值）
 - `env_backed`、`needs_vercel_sync`
 - `toolcall` 策略已固定为 `feature_match + high`，不再通过 settings 返回或修改
 
@@ -793,9 +903,18 @@ data: {"type":"message_stop"}
 - `auto_delete.mode`
 - `current_input_file.enabled` / `current_input_file.min_chars`
 - `thinking_injection.enabled` / `thinking_injection.prompt`
+- `tools.enabled`
 - `model_aliases`
 - `toolcall` 策略已固定，不再作为可写入字段
 
+`tools.enabled` 只改请求体里传了的字段，其它设置的现有语义不变：
+
+```json
+{"tools": {"enabled": true}}
+```
+
+关闭（默认）时带 `tools` 的请求按纯对话处理；DSML 工具调用可能触发上游风控导致账号封禁，是否开启请自行评估，风险说明见 [docs/prompt-compatibility.md](docs/prompt-compatibility.md)。
+
 ### `POST /admin/settings/password`
 
 更新管理密码并使旧 JWT 失效。
@@ -808,6 +927,65 @@ data: {"type":"message_stop"}
 
 也兼容 `{"password":"your-new-password"}`。
 
+### `GET` / `PUT /admin/skills`
+
+纯文本技能库，实验性功能，缺省关闭（`skills.enabled=false`）。技能正文由服务端拼进 prompt，模型不需要工具调用就能按固定套路工作。
+
+- 全局配置：`skills.enabled`（缺省 `false`）、`skills.max_chars`（缺省 `8000`）、`skills.items`
+- 单 Key 覆盖：`api_keys[].skills`，语义见上文「api_keys[].skills（单 Key 覆盖技能注入）」
+- 注入形态、注入顺序与「为什么不用工具调用」：[docs/prompt-compatibility.md](docs/prompt-compatibility.md) 的「技能注入（skills）」
+
+**GET 响应**：
+
+```json
+{
+  "enabled": false,
+  "max_chars": 8000,
+  "items": [
+    {
+      "id": "sql-report",
+      "name": "SQL 报表",
+      "description": "按固定口径写 SQL",
+      "body": "# 技能正文 markdown\n..."
+    }
+  ]
+}
+```
+
+**PUT 请求**：与 GET 同形状，整体替换，不做增量合并。
+
+```json
+{
+  "enabled": true,
+  "max_chars": 8000,
+  "items": [
+    {
+      "id": "sql-report",
+      "name": "SQL 报表",
+      "description": "按固定口径写 SQL",
+      "body": "# 报表口径\n先按天聚合，再按渠道拆分。"
+    }
+  ]
+}
+```
+
+**PUT 成功响应**：
+
+```json
+{"success": true, "count": 1}
+```
+
+**校验规则**（任一不满足返回 `400`，响应体为 `{"detail": "..."}`）：
+
+| 字段 | 规则 |
+| --- | --- |
+| `items` | 最多 50 条 |
+| `id` | 必填、唯一，字符集 `[a-z0-9_-]` |
+| `body` | 必填；单条 ≤ 100000 字符，全部条目合计 ≤ 500000 字符 |
+| `max_chars` | 缺省 `8000`；按字符（rune）截断，截断时追加「（技能内容已截断）」；`0` 表示不限制 |
+
+校验在写入时执行，与 `enabled` 无关：先关着开关把内容配好、改好，再打开即可。超限、重复 `id`、非法 `id` 都不会被静默修正。
+
 ### `POST /admin/config/import`
 
 导入完整配置，支持：
@@ -1240,6 +1418,105 @@ data: {"type":"message_stop"}
 {"success":true,"detail":"capture logs cleared"}
 ```
 
+### `GET /admin/chat-history`
+
+查询服务器端对话记录，支持筛选与分页。
+
+**查询参数**：
+
+| 参数 | 默认 | 匹配方式 |
+| --- | --- | --- |
+| `caller` | 空 | 与 `caller_id` 全等（取值用响应里的 `callers[].caller_id`，不是 Key 名称） |
+| `status` | 空 | 与记录状态不区分大小写全等：`streaming` / `success` / `error` / `stopped` |
+| `surface` | 空 | 与来源接口不区分大小写全等，如 `openai.chat_completions`、`openai.responses`、`claude.messages`、`gemini.generate_content` |
+| `q` | 空 | 不区分大小写包含匹配，命中 `user_input` / `preview` / `model` / `caller_label` / `error` |
+| `offset` | `0` | 分页偏移；`offset` 与 `limit` 都为 `0` 表示不分页 |
+| `limit` | `0` | 单页条数；`0` 表示不限制条数（不按 settings 的保留条数分页） |
+
+非法或负数的 `offset` / `limit` 按 `0` 处理。
+
+**响应**：
+
+```json
+{
+  "version": 2,
+  "limit": 20,
+  "revision": 128,
+  "total": 137,
+  "callers": [
+    {"caller_id": "caller:9f2c1a2b3c4d5e6f", "label": "主 Key", "configured": true, "count": 96},
+    {"caller_id": "caller:41ab0c9d8e7f6a5b", "label": "备用 Key", "configured": true, "count": 0}
+  ],
+  "items": [
+    {
+      "id": "chat_20260418_093012_ab12",
+      "status": "success",
+      "caller_id": "caller:9f2c1a2b3c4d5e6f",
+      "caller_label": "主 Key",
+      "account_id": "user@example.com",
+      "surface": "openai.chat_completions",
+      "model": "deepseek-v4-flash",
+      "stream": true,
+      "user_input": "今天的新闻",
+      "preview": "……",
+      "status_code": 200,
+      "elapsed_ms": 4210,
+      "finish_reason": "stop",
+      "created_at": 1777000000000,
+      "updated_at": 1777000004000,
+      "detail_revision": 3
+    }
+  ],
+  "path": "/data/chat_history.json"
+}
+```
+
+- `total` 是筛选后的总条数，`items` 是分页后的当前页；不带任何筛选/分页参数时 `items` 仍是全部摘要。
+- `caller_label` 是发起方 API Key 的可读标签（名称 / 备注 / 脱敏 Key），没有备注时退回脱敏值，避免面板里只剩一串哈希。
+- `callers` 汇总记录里出现过的 `caller_id`，并补上配置里已登记但还没有记录的 Key（`count` 为 `0`，`configured=true`），按 `count` 倒序、`label` 升序排列。
+- 时间戳字段（`created_at` / `updated_at` / `completed_at`）单位是毫秒。
+- `If-None-Match` + `ETag` 的 `304` 协商只在**不带任何筛选/分页参数**时生效，因为带参数的响应内容本身随查询条件变化。
+
+### `GET /admin/chat-history/{id}`
+
+查看单条记录全文，响应为 `{"item": {...}}`。除摘要字段外还包含 `messages`、`history_text`（历史拆分上传的对话记录全文）、`final_prompt`、`reasoning_content`、`content`、`error`、`usage`、`file_infos`（上传文件 ID、审核结果、来源）等。同样支持 `ETag` / `304`。
+
+### `DELETE /admin/chat-history`
+
+清空全部服务器端记录，返回 `{"success": true}`。
+
+### `DELETE /admin/chat-history/{id}`
+
+删除单条记录，返回 `{"success": true}`；记录不存在返回 `404`。
+
+### `PUT /admin/chat-history/settings`
+
+更新保留条数。`limit` 接受 `0`..`500` 的任意整数，不再是固定档位。
+
+```json
+{"limit": 120}
+```
+
+| 取值 | 行为 |
+| --- | --- |
+| `0` | 关闭记录：不再写新记录 |
+| `1`..`500` | 保留最近该数量的记录，超出部分按创建时间淘汰 |
+| 其他 | 返回 `400`，`detail` 为 `unsupported chat history limit: <n>` |
+
+响应带 `success`、`limit`、`revision` 与裁剪后的 `items`。
+
+### `GET /admin/chat-history/export`
+
+按与列表接口相同的筛选与分页参数（`caller` / `status` / `surface` / `q` / `offset` / `limit`）导出记录，响应是文件下载。
+
+| 参数 | 说明 |
+| --- | --- |
+| `format=json`（默认） | JSON 附件，结构为 `{exported_at, count, filters, items}`；`exported_at` 为 RFC3339，`filters` 回显本次筛选条件，`items` 是完整记录（含 `messages` / `final_prompt` / `history_text` 等大字段） |
+| `format=markdown` | Markdown 附件，标题 `# ds2api 响应记录导出`，逐条记录 `## N. <记录 ID>` 分节，含时间、接口、模型、账号、调用方、状态、耗时、结束原因，以及 `UserInput` / `FinalPrompt` / `ReasoningContent` / `Content` / `Error` 代码块 |
+| 其他值 | 返回 `400`，`detail` 为 `unsupported export format: <format>` |
+
+响应头带 `Content-Disposition: attachment`（文件名为 `ds2api-logs-<YYYYMMDD-HHMMSS>.json|.md`）与 `Cache-Control: no-store`。导出过程中若某条记录已被删除，该条会被跳过，`count` 反映实际导出的条数。
+
 ---
 
 ## 错误响应格式
@@ -1305,7 +1582,7 @@ curl http://localhost:5001/v1/chat/completions \
   -H "Authorization: Bearer your-api-key" \
   -H "Content-Type: application/json" \
   -d '{
-    "model": "deepseek-v4-pro",
+    "model": "deepseek-v4-flash",
     "messages": [{"role": "user", "content": "解释一下量子纠缠"}],
     "stream": true
   }'

README.en.md

@@ -136,7 +136,7 @@ For the full module-by-module architecture and directory responsibilities, see [
 | Multi-account rotation | Auto token refresh, email/mobile dual login |
 | Concurrency control | Per-account in-flight limit + waiting queue, dynamic recommended concurrency |
 | DeepSeek PoW | Pure Go high-performance solver (DeepSeekHashV1), ms-level response |
-| Tool Calling | Anti-leak handling: non-code-block feature match, early `delta.tool_calls`, structured incremental output |
+| Tool Calling | **Off by default** (`tools.enabled`); when enabled: anti-leak handling, non-code-block feature match, early `delta.tool_calls`, structured incremental output |
 | Admin API | Config management, runtime settings hot-reload, proxy management, account testing/batch test, session cleanup, import/export, Vercel sync, version check |
 | WebUI Admin Panel | SPA at `/admin` (bilingual Chinese/English, dark mode, with server-side conversation history) |
 | Health Probes | `GET /healthz` (liveness), `GET /readyz` (readiness) |
@@ -161,13 +161,26 @@ OpenAI `/v1/*` routes remain canonical, and DS2API also accepts root shortcuts s
 | Family | Model ID | thinking | search |
 | --- | --- | --- | --- |
 | default | `deepseek-v4-flash` | enabled by default, request-controlled | ❌ |
-| expert | `deepseek-v4-pro` | enabled by default, request-controlled | ❌ |
+| default | `deepseek-v4-flash-nothinking` | forced off | ❌ |
 | default | `deepseek-v4-flash-search` | enabled by default, request-controlled | ✅ |
-| expert | `deepseek-v4-pro-search` | enabled by default, request-controlled | ✅ |
-| vision | `deepseek-v4-vision` | enabled by default, request-controlled | ❌ |
+| default | `deepseek-v4-flash-search-nothinking` | forced off | ✅ |
 
-Besides native IDs, DS2API also accepts common aliases as input (for example `gpt-4.1`, `gpt-5`, `gpt-5-codex`, `o3`, `claude-*`, `gemini-*`), but `/v1/models` returns normalized DeepSeek native model IDs. The complete alias behavior is documented in [API.en.md](API.en.md#model-alias-resolution) and `config.example.json`.
-Current upstream vision support exposes only the `vision` lane and does not provide a separate search-enabled vision variant.
+Upstream has merged the former pro / vision lanes into flash, so `/v1/models`, Ollama `/api/tags`, and `/anthropic/v1/models` now publish only the four flash IDs above. Old names keep working as request input but are no longer advertised:
+
+| Legacy model ID | Resolved to |
+| --- | --- |
+| `deepseek-v4-pro`, `deepseek-v4-vision` | `deepseek-v4-flash` |
+| `deepseek-v4-pro-search` | `deepseek-v4-flash-search` |
+| `deepseek-v4-pro-nothinking`, `deepseek-v4-vision-nothinking` | `deepseek-v4-flash-nothinking` |
+| `deepseek-v4-pro-search-nothinking` | `deepseek-v4-flash-search-nothinking` |
+
+The upstream `model_type` is now only `default`; there is no separate expert or vision lane.
+
+Besides native IDs, DS2API also accepts common aliases as input (for example `gpt-4.1`, `gpt-5`, `gpt-5-codex`, `o3`, `claude-*`, `gemini-*`), but `/v1/models` returns normalized DeepSeek native model IDs. All built-in aliases point at the flash models; `o3-deep-research` and `o4-mini-deep-research` point at `deepseek-v4-flash-search`. The complete alias behavior is documented in [API.en.md](API.en.md#model-alias-resolution) and `config.example.json`.
+
+Thinking and native search are resolved in one shared path: model default → explicit client signal (`thinking`, `reasoning`, `reasoning_effort`, `enable_search`, `web_search_options`) → `-nothinking` models always force thinking off. Full rules: [prompt compatibility doc](docs/prompt-compatibility.md) (Chinese) and [API.en.md](API.en.md).
+
+Tool calling is **off by default**. With `tools.enabled=false` (a missing field counts as false) a request's `tools` is ignored and the response never contains `tool_calls`; DeepSeek risk control can ban an account over DSML tool output, so enable it only when you need it. For "make the model follow a fixed routine" needs that do not justify that risk, use the plain-text `skills` library instead.
 
 ### Claude Endpoint (`GET /anthropic/v1/models`)
 
@@ -175,7 +188,7 @@ Current upstream vision support exposes only the `vision` lane and does not prov
 | --- | --- |
 | `claude-sonnet-4-6` | `deepseek-v4-flash` |
 | `claude-haiku-4-5` (compatible with `claude-3-5-haiku-latest`) | `deepseek-v4-flash` |
-| `claude-opus-4-6` | `deepseek-v4-pro` |
+| `claude-opus-4-6` | `deepseek-v4-flash` |
 
 Override mapping via the global `model_aliases` config.
 Besides the primary aliases above, `/anthropic/v1/models` also returns Claude 4.x snapshots plus historical 3.x IDs and common aliases for legacy client compatibility.
@@ -322,8 +335,11 @@ Common fields:
 - `model_aliases`: one shared alias map for OpenAI / Claude / Gemini model names.
 - `runtime`: account concurrency, queueing, and token refresh behavior, hot-reloadable via Admin Settings.
 - `auto_delete.mode`: remote session cleanup after each request, supporting `none` / `single` / `all`.
-- `current_input_file`: the global context split/upload mode; it is enabled by default and uploads the full context as a randomly named context file (filename never includes "history") once the character threshold is reached.
+- `current_input_file`: the global context split/upload mode; it is enabled by default and uploads the full context as a randomly named context file (`ctx-xxxxxxxx.txt`) once the character threshold is reached.
 - If you turn off `current_input_file`, requests pass through directly without uploading any split context file.
+- `thinking_injection`: global thinking-format injection; `enabled` defaults to `true` and an empty `prompt` uses the built-in default. A single API key can override it with `api_keys[].thinking_injection` (`custom` / `enabled` / `prompt`), and `custom=false` fully follows the global setting.
+- `tools.enabled`: master switch for tool calling, **off by default** (a missing field is treated as `false`). While it is off, requests carrying `tools` are handled as plain chat: no tool instructions are injected and no `tool_calls` are parsed or returned. Turn it on only if you accept the risk — DSML tool output can trigger upstream risk control and get the DeepSeek account banned. Safer alternatives: the plain-text skill library below, or a per-key custom injection prompt.
+- `skills`: experimental plain-text skill library, **off by default** (`enabled: false`). Skill bodies are concatenated into the prompt as a leading system block, so the model needs no tool call at all. `max_chars` (default `8000`) truncates by character and appends a truncation marker; `0` means unlimited. At most 50 items, each with a unique `id` from `[a-z0-9_-]` and a required `body`. A single key can narrow the set with `api_keys[].skills` (`custom` / `enabled` / `ids`). Manage it through `GET/PUT /admin/skills` or `config.json`.
 
 For the full environment variable list, see [docs/DEPLOY.en.md](docs/DEPLOY.en.md). For auth behavior, see [API.en.md](API.en.md#authentication).
 
@@ -356,7 +372,7 @@ Queue limit = DS2API_ACCOUNT_MAX_QUEUE (default = recommended concurrency)
 
 ## Tool Call Adaptation
 
-When `tools` is present in the request, DS2API performs anti-leak handling:
+When `tools` is present in the request **and `tools.enabled=true`**, DS2API performs anti-leak handling (with the switch off — the default — the field is ignored):
 
 1. Toolcall feature matching is enabled only in **non-code-block context** (fenced examples are ignored)
 2. The parser treats the halfwidth-pipe DSML shell as the recommended executable tool-calling syntax: `<|DSML|tool_calls>` → `<|DSML|invoke name="...">` → `<|DSML|parameter name="...">`; it also accepts legacy canonical XML `<tool_calls>` → `<invoke name="...">` → `<parameter name="...">`, plus common DSML prefix/separator drift. DSML is a shell alias and internal parsing remains XML-based; legacy `<tools>` / `<tool_call>` / `<tool_name>` / `<param>`, `<function_call>`, `tool_use`, antml variants, and standalone JSON `tool_calls` payloads are treated as plain text, and complete but malformed wrappers are released as plain text too
@@ -403,6 +419,7 @@ The save endpoint can target a chain by `query`, `chain_key`, or `capture_id`. E
 | Document | Description |
 | --- | --- |
 | [API.md](API.md) / [API.en.md](API.en.md) | API reference with request/response examples |
+| [prompt-compatibility.md](docs/prompt-compatibility.md) | Source-of-truth doc for the “API → pure-text web-chat context” compatibility flow (Chinese) |
 | [DEPLOY.md](docs/DEPLOY.md) / [DEPLOY.en.md](docs/DEPLOY.en.md) | Deployment guide (local/Docker/Vercel/systemd) |
 | [CONTRIBUTING.md](docs/CONTRIBUTING.md) / [CONTRIBUTING.en.md](docs/CONTRIBUTING.en.md) | Contributing guide |
 | [TESTING.md](docs/TESTING.md) | Testsuite guide |

README.md

@@ -15,3 +15,13 @@ DeepSeek web chat to OpenAI-compatible API adapter with multi-protocol support (
 
 1. Visit /admin to configure your DeepSeek accounts and API keys
 2. Use the OpenAI-compatible API at /v1/chat/completions
+
+## Documentation
+
+| Document | Description |
+| --- | --- |
+| [API.md](API.md) / [API.en.md](API.en.md) | API reference (中文 / English) |
+| [README.en.md](README.en.md) | Full English README (models, deployment, configuration) |
+| [docs/prompt-compatibility.md](docs/prompt-compatibility.md) | 源文档：API 请求 → 纯文本 web-chat 上下文的兼容流程（中文） |
+
+Models: only the `deepseek-v4-flash` family is published (`deepseek-v4-flash`, `deepseek-v4-flash-search`, plus `-nothinking` variants). The retired `deepseek-v4-pro` / `deepseek-v4-vision` names still resolve to their flash counterparts, so old clients keep working.

config.example.json

@@ -14,7 +14,12 @@
     {
       "key": "your-api-key-2",
       "name": "备用 API Key",
-      "remark": "压测或临时调试"
+      "remark": "压测或临时调试",
+      "thinking_injection": {
+        "custom": true,
+        "enabled": true,
+        "prompt": "（可选）这个 Key 专属的思考格式注入提示词；留空则跟随全局 prompt"
+      }
     }
   ],
   "accounts": [
@@ -40,8 +45,8 @@
   "model_aliases": {
     "gpt-4o": "deepseek-v4-flash",
     "gpt-5.5": "deepseek-v4-flash",
-    "gpt-5.3-codex": "deepseek-v4-pro",
-    "o3": "deepseek-v4-pro"
+    "gpt-5.3-codex": "deepseek-v4-flash",
+    "o3": "deepseek-v4-flash"
   },
   "responses": {
     "store_ttl_seconds": 900
@@ -51,9 +56,17 @@
     "min_chars": 0
   },
   "thinking_injection": {
-    "enabled": false,
+    "enabled": true,
     "prompt": ""
   },
+  "tools": {
+    "enabled": false
+  },
+  "skills": {
+    "enabled": false,
+    "max_chars": 8000,
+    "items": []
+  },
   "embeddings": {
     "provider": "deterministic"
   },

docs/prompt-compatibility.md

@@ -0,0 +1,362 @@
+# API → 纯文本 web-chat 上下文兼容流程
+
+本文是本仓库「把结构化 API 请求翻译成 DeepSeek web-chat 纯文本 prompt，再把上游回答翻译回目标协议」这条链路的源文档。AGENTS.md 规定：任何影响消息归一化、工具提示词注入、提示词可见的工具历史、文件/引用处理、历史拆分、完成载荷组装的改动，都要在同一变更里更新本文。
+
+代码位置对应关系：
+
+| 环节 | 主要代码 |
+| --- | --- |
+| 协议适配器 | `internal/httpapi/openai/`、`internal/httpapi/claude/`、`internal/httpapi/gemini/`、`internal/httpapi/ollama/` |
+| 标准化与 prompt 拼装 | `internal/promptcompat/`、`internal/prompt/` |
+| 思考/联网解析 | `internal/util/thinking.go`、`internal/util/search.go`、`internal/config/models.go` |
+| 上下文拆分 | `internal/httpapi/openai/history/current_input_file.go` |
+| 工具调用开关 / 技能注入 | `internal/promptcompat/`（提示词拼装）、Admin `/admin/skills` 处理器 |
+| 完成载荷 | `internal/promptcompat/standard_request.go`（`CompletionPayload`） |
+| 响应归档 | `internal/chathistory/`、`internal/httpapi/admin/history/` |
+
+---
+
+## 1. 端到端流程
+
+```text
+协议适配器（OpenAI Chat / OpenAI Responses / Claude / Gemini / Ollama）
+    │  只做：解析协议请求 → 归一化消息 → 填 StandardRequest → 回写协议响应
+    ▼
+StandardRequest（messages、final_prompt、thinking、search、tool 策略、ref_file_ids …）
+    │
+    ├─ 思考格式注入（thinking_injection）
+    │     写入最新一条 user 消息，并落到 final_prompt 的助手起笔标记之前
+    ▼
+上下文衔接（current input file / 历史拆分）
+    │     达到阈值时上传「对话记录」文件 + 「工具说明」文件，改写 prompt 只留指令
+    │     tools.enabled=false 时不注入工具说明（也不上传工具说明文件），不解析 tool_calls
+    ▼
+技能注入（skills，实验性，缺省关闭）
+    │     把命中的技能正文拼成 System 段前置到 prompt 最前面
+    │     只改 prompt / PromptTokenText，不改 messages
+    ▼
+组装 DeepSeek completion payload
+    │     thinking_enabled / search_enabled / model_type / prompt / ref_file_ids
+    ▼
+上游 SSE → 协议回写（含空输出重试、工具调用解析、引用标记处理）→ 响应记录
+```
+
+| 阶段 | 输入 | 输出 | 共享性 |
+| --- | --- | --- | --- |
+| 协议归一化 | HTTP 请求体 | `StandardRequest` | 每个适配器一份，属边界代码 |
+| 模型/思考/联网解析 | 请求字段 + 模型名 | `Thinking`、`Search`、`ModelType` | 全协议共享，只有一处 |
+| 思考格式注入 | `StandardRequest` + API Key 注入设置 | 注入后的消息与 prompt | 全协议共享 |
+| 历史拆分 | 注入后的消息 | 上下文文件 + 精简 prompt | 全协议共享 |
+| 技能注入 | 拆分后的 prompt | 前置了 System 技能段的 prompt | 全协议共享，只改 prompt 词串 |
+| 载荷组装 | `StandardRequest` | `map[string]any` payload | 全协议共享 |
+| 响应回写 | 上游 SSE / JSON | 协议响应 + 记录 | 适配器渲染 + 共享归档 |
+
+四个会产生对话的入口（`/v1/chat/completions`、`/v1/responses`、`/v1/messages`、Gemini `generateContent`）都调用同一个 `history.Service.ApplyCurrentInputFile`，没有第二套历史拆分实现。Ollama 只提供 `/api/version`、`/api/tags`、`/api/show`，不参与对话链路。
+
+---
+
+## 2. 统一标准请求
+
+`promptcompat.StandardRequest` 是跨协议唯一的数据形状。适配器填它，共享逻辑读它，渲染层再据此回写。
+
+| 字段 | 含义 |
+| --- | --- |
+| `Surface` | 来源接口，如 `openai_chat`、`openai_responses`、`anthropic_messages`、`google_gemini` |
+| `RequestedModel` / `ResolvedModel` / `ResponseModel` | 客户端原始模型名 / 解析后的规范模型 / 响应里回显的模型名 |
+| `Messages` | 归一化后的消息数组，历史拆分与注入都作用于它 |
+| `FinalPrompt` | 拼装完成的纯文本 prompt |
+| `PromptTokenText` | 用于 token 估算的文本，通常与 `FinalPrompt` 同步改写 |
+| `ToolsRaw` / `ToolNames` / `ToolChoice` | 工具定义、可用工具名、`auto`/`none`/`required`/`forced` 策略 |
+| `Thinking` / `Search` | 本次请求实际生效的思考、联网开关 |
+| `RefFileIDs` / `FileInfos` | 送上上游的文件引用 ID 与归档用的文件元信息 |
+| `CurrentInputFileApplied` / `CurrentInputFileID` / `CurrentInputFilename` / `CurrentToolsFileID` | 历史拆分产生的状态，用于切号重传时替换旧文件 |
+| `PassThrough` | 需要透传的采样参数（`temperature`、`top_p`、`max_tokens` 等） |
+
+---
+
+## 3. 纯文本 web-chat 上下文约定
+
+DeepSeek web-chat 只接受一段 prompt 字符串和一组文件引用，没有 role 数组。角色信息只能用文本标记表达：
+
+| 标记 | 对应角色 | 说明 |
+| --- | --- | --- |
+| `System: ` | system / developer | `developer` 归一化为 `system` |
+| `User: ` | user | 用户轮次 |
+| `Assistant: ` | assistant | 助手轮次；同时也是 prompt 末尾的起笔标记 |
+| `Tool: ` | tool / function | 工具返回，空的工具结果不渲染 |
+
+拼装规则：
+
+1. 相邻同角色消息先合并，多段之间用空行连接。
+2. 每条消息渲染为「标记 + 正文」，标记后不留空格。
+3. 最后一个角色不是 assistant 时，在末尾补 `Assistant: ` 起笔标记，让模型接着写。
+4. Markdown 图片语法 `![alt](url)` 改写成 `[alt](url)`，避免上游把它当附件引用。
+5. 需要往「最后一轮用户消息」里追加内容时，一律用 `prompt.AppendTurnSuffix`，锚点是这个 `Assistant: ` 标记；直接追加到字符串末尾会被模型当成助手已经开口。
+
+### 对话记录文件格式
+
+历史拆分上传的上下文文件是可读转写，不是 JSON，也不是带文件名的文档：
+
+```text
+# 对话记录
+
+以下是本会话此前的完整对话，按时间顺序排列；[role=xxx] 标注每条消息的发言方（system=系统设定，user=用户，assistant=助手，tool=工具返回）。最后一条 user 消息就是本轮需要回答的内容。
+
+=== 1 ===
+[role=system]
+你是一个严谨的助手。
+
+=== 2 ===
+[role=user]
+把昨天的结论整理成表。
+
+=== 3 ===
+[role=assistant]
+好的，先列字段。
+```
+
+工具返回条目在正文前多一行 `[name=<工具名> tool_call_id=<调用 ID>]`，`tool` / `function` 统一写成 `[role=tool]`。
+
+标题刻意不用文件名形式（历史版本是 `# context_context.txt`），避免模型把它当成一份待分析文档。旧格式里 `[r=0]`…`[r=9]` 的数字角色行不再生成；管理台读旧记录时仍能识别这种数字角色行（兼容读取），后端只把它当普通正文，不报错。
+
+### 工具说明文件格式
+
+工具定义单独上传为 `context_tools.txt`，标题是 `# 可用工具说明`，正文按工具逐条列出名称、描述、参数 JSON Schema。prompt 里只保留一句「本轮可用的工具与参数说明已附加在 context_tools.txt 中，请只使用该文件列出的工具与参数」，并附带调用格式要求。
+
+两个文件分工明确：对话记录是「发生过什么」，工具说明是「能用什么」。把工具定义塞进对话记录会让模型分不清哪些是历史调用、哪些是可用工具。
+
+---
+
+## 4. 提示词注入与泄漏防护
+
+### 思考格式注入（thinking_injection）
+
+| 项目 | 行为 |
+| --- | --- |
+| 全局开关 | `thinking_injection.enabled`，缺省为 true（配置项不存在时按开启处理） |
+| 全局提示词 | `thinking_injection.prompt`，为空或全空白时使用内置默认提示词 |
+| 单 Key 覆盖 | `api_keys[].thinking_injection.{custom,enabled,prompt}` |
+| 注入位置 | 最新一条 user 消息末尾；同时写入 `FinalPrompt` 中该 user 轮次内、`Assistant: ` 之前 |
+| 时机 | 历史拆分之前，因此拆分后上传的对话记录文件里也带着这段要求 |
+| 幂等 | 内容里已含注入文本时跳过，重复调用不会叠加 |
+
+默认提示词的要点（代码常量 `promptcompat.DefaultThinkingInjectionPrompt`，稳定片段 `回答前先在思考中完成以下检查`）：
+
+1. 先用一句话确认用户真正要解决的问题，以及本轮是否在延续上文；
+2. 列出必须满足的约束、已知事实，以及仍然缺失或不确定的信息；
+3. 比较 2~3 种可行思路，选一种并说明取舍；
+4. 检查边界情况、单位口径、最容易被误读的地方；
+5. 复核结论，把握不足时如实说明，不编造。
+
+开头会声明「下面是内部执行要求，不要在回复里复述、引用或提及本段内容」，结尾要求最终答复只给结论与必要过程、使用用户的语言与格式。
+
+### 单 Key 覆盖语义
+
+| `custom` | `enabled` 省略 | `prompt` 为空 |
+| --- | --- | --- |
+| false（默认） | 完全跟随全局开关与全局提示词 | 跟随全局 |
+| true | 跟随全局开关 | 跟随全局提示词 |
+
+只有 `custom=true` 时该 Key 的 `enabled` / `prompt` 才会生效；`custom=false` 即使写了这两个字段也不生效，避免面板残留值意外改变行为。
+
+### 工具调用开关（tools.enabled）
+
+工具调用是让模型输出 DSML 结构化文本再解析回 `tool_calls` 的链路。上游对这类输出风控严格，命中后账号可能被封，所以整条链路做成了显式开关，缺省关闭。
+
+| 项目 | 行为 |
+| --- | --- |
+| 配置项 | `tools.enabled`，缺省 `false`；字段缺失或值为 `null` 都按关闭处理 |
+| 运行时覆盖 | `/admin/settings` 的 `tools.enabled`，热更新；GET 顶层返回 `{"enabled": bool, "default_enabled": false}` |
+| 关闭时（默认） | 带 `tools` 的请求按纯对话处理：不注入任何工具说明（包括 DSML 格式要求与工具说明文件），不解析、不透出 `tool_calls`，模型输出按普通文本回写 |
+| 开启时 | 恢复原有行为：prompt 带上 DSML 调用格式要求，历史拆分额外上传工具说明文件，响应侧恢复 `tool_calls` 解析 |
+
+关闭时同一请求里的 `tool_choice` 也失去意义：没有工具定义，就没有可选的调用策略。
+
+风险说明：开启后模型会按要求输出 DSML 工具块，这是上游重点监控的行为，可能触发风控乃至账号封禁。需要工具能力时自行开启并承担风险；既想要「按固定套路干活」又想避开这个风险，用下面的技能注入，或者给单个 Key 自定义注入提示词。
+
+### 技能注入（skills）
+
+技能是一段服务端配置的纯文本 markdown，直接拼进 prompt。模型全程不需要输出工具调用，看到的只是普通上下文，因此不会碰到 DSML 风控。
+
+| 项目 | 行为 |
+| --- | --- |
+| 全局开关 | `skills.enabled`，缺省 `false`（实验性，默认不注入） |
+| 截断长度 | `max_chars`，缺省 `8000`，按字符（rune）统计；截断时在末尾追加「（技能内容已截断）」；`0` 表示不限制 |
+| 条目数 | `items` 上限 50 条 |
+| `id` | 必填、唯一，字符集 `[a-z0-9_-]` |
+| `body` | 必填，单条上限 100000 字符，全部条目合计上限 500000 字符 |
+| 管理接口 | `GET/PUT /admin/skills`，需要 Admin 鉴权，PUT 为整体替换 |
+| 校验失败 | 超限、重复 `id`、非法 `id` 一律 400 |
+
+单 Key 覆盖（`api_keys[].skills = {"custom": ..., "enabled"?: ..., "ids"?: [...]}`）：
+
+| `custom` | `enabled` | `ids` | 结果 |
+| --- | --- | --- | --- |
+| 省略或 `false` | 任意 | 任意 | 使用全部 `items` |
+| `true` | `false` | 任意 | 该 Key 不注入 |
+| `true` | 省略或 `true` | 非空 | 只用命中的 `items` |
+| `true` | 省略或 `true` | 空 | 不注入 |
+
+全局 `skills.enabled=false` 时上表全部不生效，任何 Key 都不注入。
+
+注入形态与时机：
+
+- 形态是**前置 System 段**：拼在最终 prompt 最前面，`FinalPrompt` 由 `<原 prompt>` 变成 `System: <技能块>\n<原 prompt>`，`PromptTokenText` 同样处理。
+- 只改 prompt，不改 `Messages`，所以对话记录文件与管理台的对话记录里都看不到技能正文。
+- 时机在历史拆分**之后**：拆分会把 prompt 整体替换成衔接指令，技能必须等替换完成后再前置，否则会被覆盖。
+- 对比思考格式注入：思考格式注入在拆分**之前**，因为它需要落到对话记录文件里。两处顺序不同，改动时不要调换。
+
+技能块格式（线上排查时可对照这段前缀）：
+
+```text
+以下技能说明由服务端配置，属于内部资料：适用于当前任务时请遵循；与用户明确要求冲突时以用户为准。不要在回复里提及技能名称或这段说明。
+
+<skill id="sql-report" name="SQL 报表">
+…body…
+</skill>
+```
+
+为什么用纯文本而不是工具调用：工具调用要求模型吐 DSML 结构化文本，正是上游风控盯的那类输出，一旦被判违规代价是账号本身；技能只是往 prompt 里加一段静态文本，模型照普通对话写回答，风控面和普通聊天没有区别。
+
+### 泄漏防护
+
+模型看到附件名后经常会在可见回复里写「根据附件 ctx-ab12cd34ef56.txt」「对话记录显示…」「按你的提示词要求」。三层处理：
+
+| 层 | 做法 |
+| --- | --- |
+| 注入内容 | 提示词明确禁止提及附件、文件、上下文记录、提示词本身，禁止复述记录内容，要求直接从结论开始 |
+| 注入文本独立性 | 注入片段自带「不要复述本段内容」，避免整段思考要求被当作回答格式输出 |
+| 输出侧 | 各协议共享同一套文本清理：流式默认隐藏 `[citation:N]` / `[reference:N]` 占位符，非流式把搜索引用标记转成 Markdown 链接；工具调用解析在非代码块上下文里生效，代码块里的示例不算调用 |
+
+上下文衔接指令本身准备了多个等价变体并按请求随机选一条，措辞不完全相同，语义一致：把附件当作自己之前说过的话，在同一话题上直接回答最新一条用户消息。
+
+---
+
+## 5. 上下文衔接（current input file / 历史拆分）
+
+| 条件 | 结果 |
+| --- | --- |
+| `current_input_file.enabled=false` | 原样透传，不产生任何上下文文件 |
+| 最新一条 user 文本为空 | 跳过拆分 |
+| `current_input_file.min_chars>0` 且最新 user 文本短于阈值 | 跳过拆分 |
+| 模型 `model_type` 不是 `default` | 跳过拆分（当前模型系列收敛后只剩 `default`，该分支保留兜底） |
+| 上传失败 | 请求失败，不做静默降级，避免出现「上下文已丢失但看起来成功」的回复 |
+
+满足条件时：
+
+1. 按第 3 节的转写格式生成对话记录，写入 `ctx-<12 位小写字母数字>.txt`。文件名随机，不含 `history` 之类语义词，减少模型把它当文档分析的倾向。
+2. 若请求带可用工具（且 `tool_choice` 不是 `none`，且 `tools.enabled=true`），额外上传 `context_tools.txt`。
+3. prompt 改写成两段：工具说明用 system 消息给出文件分工，user 消息给出衔接指令（含文件名）。原始长对话不再进 prompt。
+4. 文件 ID 前置插入 `RefFileIDs`，与客户端自带的 `ref_file_ids` 去重后一起送上游。
+5. `PromptTokenText` 保留「对话记录 + 工具说明」全文，用于 token 估算，与实际 prompt 长度解耦。
+
+切号重试时（空输出 429 换账号）会调用 `ReuploadAppliedCurrentInputFile`：用同一份 `HistoryText` 重新上传，并把旧的历史文件 ID、工具文件 ID 从 `RefFileIDs` 里替换掉，避免新账号引用到别的账号名下的文件。
+
+上游流式生成期间若再次需要拆分（例如重试），沿用已记录的 `CurrentInputFilename`，同一轮对话不会出现两个名字不同的上下文文件。
+
+---
+
+## 6. 模型 / 思考 / 联网解析优先级
+
+### 模型
+
+`/v1/models`、`/api/tags`（Ollama）、`/anthropic/v1/models` 只公布 flash 系列：
+
+| 对外模型 ID | 默认思考 | 默认联网 |
+| --- | --- | --- |
+| `deepseek-v4-flash` | 开 | 关 |
+| `deepseek-v4-flash-search` | 开 | 开 |
+| `deepseek-v4-flash-nothinking` | 强制关 | 关 |
+| `deepseek-v4-flash-search-nothinking` | 强制关 | 开 |
+
+上游已把 v4-pro / v4-vision 合并进 v4-flash，对外不再公布：
+
+| 旧模型名 | 解析结果 |
+| --- | --- |
+| `deepseek-v4-pro` | `deepseek-v4-flash` |
+| `deepseek-v4-pro-search` | `deepseek-v4-flash-search` |
+| `deepseek-v4-vision` | `deepseek-v4-flash` |
+
+静默映射，保留 `-nothinking` 后缀：`deepseek-v4-pro-nothinking` → `deepseek-v4-flash-nothinking`。老客户端保存过的模型名继续可用，只是不再出现在列表里。
+
+上游 `model_type` 只剩 `default`。内置别名（`gpt-*`、`o*`、`claude-*`、`gemini-*`）全部指向 flash 系列，其中 `o3-deep-research`、`o4-mini-deep-research` 指向 `deepseek-v4-flash-search`。`config.model_aliases` 可覆盖或补充同名映射。
+
+### 思考
+
+优先级从低到高：
+
+1. 模型默认值（`-nothinking` 变体默认关，其余 flash 模型默认开）；
+2. 客户端显式覆盖；
+3. `-nothinking` 模型强制关闭（最高）。
+
+客户端覆盖按以下顺序查找，命中即返回，`extra_body` 里的同名键也会被读取：
+
+| 来源 | 接受写法 |
+| --- | --- |
+| `thinking` | bool；`"enabled"` / `"disabled"`（含 `on/off/true/false/none`）；`{"type": ...}` |
+| `reasoning` | `{"effort": ...}`、`{"type": ...}`、`{"enabled": ...}`；字符串按 effort 解析 |
+| `reasoning_effort` | `minimal` / `low` / `medium` / `high` / `xhigh` / `max` = 开启；`none` / `disabled` / `disable` / `off` / `false` = 关闭 |
+
+Kelivo 这类客户端把界面上的「思维强度」翻译成 `reasoning_effort`：没有这个字段表示跟随默认（即开启思考），传 `none` 表示关闭。`minimal` 到 `max` 都只表示「要思考」，本项目不区分强度档位——上游只有开/关两态。
+
+### 联网搜索
+
+优先级：模型默认（`-search` 变体为开）→ 客户端显式信号优先。
+
+以下任一命中即视为客户端显式开启：`enable_search`（bool 或 `"true"`/`"false"`）、`web_search_options` 出现、`search_options` 出现、`tools` 里带原生搜索类型（`type` 以 `web_search` 开头、`type=google_search`、或工具对象里有 `googleSearch` / `google_search` / `web_search` 字段）。`enable_search` 显式 `false` 也会生效，用于在 `-search` 模型上临时关掉联网。
+
+普通 function 工具不算信号。像 Kelivo 客户端自己执行的 `search_web` 始终是普通 function tool，默认仍不开启上游联网。
+
+现状说明：Kelivo 对「自定义 OpenAI 兼容服务」不会发送原生搜索标记，所以要用联网请选 `-search` 模型；一旦客户端开始发送上述显式信号，服务端会自动跟随，不需要改配置。
+
+---
+
+## 7. 协议适配器边界
+
+适配器只允许做这些事：
+
+| 允许 | 说明 |
+| --- | --- |
+| 解析协议请求体 | OpenAI、Anthropic、Gemini 各自的字段形状差异 |
+| 消息归一化 | 把 `content` 数组、图片块、`tool_use` / `tool_result`、`functionDeclarations` 等翻译成统一消息 |
+| 填 `StandardRequest` | 含 `Surface`、模型名、工具、透传参数 |
+| 渲染协议响应 | 非流式结构、SSE 事件名与顺序、`finish_reason` / `stop_reason` / `finishReason` 映射 |
+| 协议专属错误形态 | 错误对象字段名、HTTP 状态码对齐 |
+
+不允许在适配器里实现（必须放共享路径）：
+
+| 不允许 | 共享实现位置 |
+| --- | --- |
+| 空输出重试与切号 | `internal/completionruntime/`、各协议的 `empty_retry_runtime` 共用同一策略 |
+| 思考/联网解析 | `internal/util/thinking.go`、`internal/util/search.go` |
+| 工具调用检测与策略 | `internal/toolcall/`、`internal/httpapi/openai/shared/` |
+| 思考格式注入 | `promptcompat.ApplyThinkingInjectionToRequest` |
+| ��史拆分与文件上传 | `internal/httpapi/openai/history/` |
+| 完成载荷组装 | `StandardRequest.CompletionPayload` |
+| 响应记录 | `internal/chathistory/` |
+
+确有必须按协议不同的行为（例如 Claude 输出 `thinking` block 而 Gemini 输出 `parts[].thought=true`），保持在渲染层，并在代码注释里写明为什么不能进共享路径。
+
+---
+
+## 8. 变更记录与兼容性
+
+| 变更 | 兼容策略 |
+| --- | --- |
+| 模型系列收敛到 flash 4 个 ID | pro / vision 老名字静默映射到 flash 对应项，`-nothinking` 后缀保留；不再对外公布 |
+| `model_type` 只剩 `default` | 旧配置里出现 `expert` / `vision` 也不会让请求失败，解析时按 `default` 处理 |
+| 上下文文件标题从 `# context_context.txt` 改为 `# 对话记录` | 旧文件是纯文本，读回不报错；新文件不再使用文件名式标题 |
+| 对话记录角色行从 `[r=0]`…`[r=9]` 改为 `[role=user]` 等 | 管理台解析同时接受 `[role=...]` 与旧 `[r=N]`；后端只把记录当纯文本 |
+| 工具说明文件标题改为 `# 可用工具说明` | 文件名仍是 `context_tools.txt`，prompt 里的引用文案不变 |
+| 思考格式注入从 `internal/httpapi/openai/shared` 移到 `internal/promptcompat` | 四个对话接口共用同一实现，配置项与字段名不变 |
+| 联网信号改为「模型默认 + 客户端显式覆盖」 | 只在客户端发显式信号时改变行为；不发信号的客户端表现与之前一致 |
+| 新增 `tools.enabled`，缺省 `false` | 默认行为变化：未显式开启时不再注入工具说明、不再返回 `tool_calls`；老客户端带 `tools` 的请求会退化为纯对话，需要工具能力请在 `/admin/settings` 或配置文件显式开启 |
+| 新增 `skills` 纯文本技能库（实验性，缺省关闭） | 默认不注入，不改变现有请求的 prompt；开启后只在 `FinalPrompt` / `PromptTokenText` 最前面加一个 System 技能段，`Messages` 与对话记录不受影响 |
+
+---
+
+## 9. 相关文档
+
+- [API.md](../API.md) / [API.en.md](../API.en.md)：请求字段、响应结构、Admin 接口
+- [README.en.md](../README.en.md)：模型列表与部署入口
+- [AGENTS.md](../AGENTS.md)：适配器边界与文档同步要求

internal/auth/request.go

@@ -36,11 +36,23 @@ type RequestAuth struct {
 	UseConfigToken bool
 	DeepSeekToken  string
 	CallerID       string
-	AccountID      string
-	TargetAccount  string
-	Account        config.Account
-	TriedAccounts  map[string]bool
-	resolver       *Resolver
+	// CallerLabel 是发起方 API Key 的可读标签（名称/备注/脱敏 Key），
+	// 只用于日志展示；未命中已配置 Key 时为空。
+	CallerLabel string
+	// Injection 是本次请求生效的「思考格式注入」设置：全局设置叠加该 API Key
+	// 的自定义覆盖后得到的最终值。
+	Injection config.ThinkingInjectionSettings
+	// Skills 是本次请求生效的「纯文本技能库」设置：全局设置叠加该 API Key
+	// 的自定义覆盖后得到的最终值（Items 已按 Key 过滤）。
+	Skills config.SkillSettings
+	// ToolsEnabled 是本次请求生效的「工具调用」总开关，由全局配置决定
+	// （未配置时按 false 处理，即默认纯文本对话）。
+	ToolsEnabled  bool
+	AccountID     string
+	TargetAccount string
+	Account       config.Account
+	TriedAccounts map[string]bool
+	resolver      *Resolver
 }
 
 type LoginFunc func(ctx context.Context, acc config.Account) (string, error)
@@ -77,12 +89,20 @@ func (r *Resolver) Determine(req *http.Request) (*RequestAuth, error) {
 		return nil, ErrUnauthorized
 	}
 	callerID := callerTokenID(callerKey)
+	callerLabel := r.callerLabel(callerKey)
+	injection := r.resolveInjection(callerKey)
+	skills := r.resolveSkills(callerKey)
+	toolsEnabled := r.toolsEnabled()
 	ctx := req.Context()
 	if !r.Store.HasAPIKey(callerKey) {
 		return &RequestAuth{
 			UseConfigToken: false,
 			DeepSeekToken:  callerKey,
 			CallerID:       callerID,
+			CallerLabel:    callerLabel,
+			Injection:      injection,
+			Skills:         skills,
+			ToolsEnabled:   toolsEnabled,
 			resolver:       r,
 			TriedAccounts:  map[string]bool{},
 		}, nil
@@ -92,9 +112,55 @@ func (r *Resolver) Determine(req *http.Request) (*RequestAuth, error) {
 	if err != nil {
 		return nil, err
 	}
+	a.CallerLabel = callerLabel
+	a.Injection = injection
+	a.Skills = skills
+	a.ToolsEnabled = toolsEnabled
 	return a, nil
 }
 
+// callerLabel 解析发起方 Key 的展示标签；未配置时返回空串。
+func (r *Resolver) callerLabel(callerKey string) string {
+	if r == nil || r.Store == nil {
+		return ""
+	}
+	item, ok := r.Store.FindAPIKey(callerKey)
+	if !ok {
+		return ""
+	}
+	if name := strings.TrimSpace(item.Name); name != "" {
+		return name
+	}
+	if remark := strings.TrimSpace(item.Remark); remark != "" {
+		return remark
+	}
+	return config.MaskAPIKeyPreview(item.Key)
+}
+
+// resolveInjection 解析全局 + 单 Key 自定义后的注入设置。
+func (r *Resolver) resolveInjection(callerKey string) config.ThinkingInjectionSettings {
+	if r == nil || r.Store == nil {
+		return config.ThinkingInjectionSettings{}
+	}
+	return r.Store.ResolveThinkingInjection(callerKey)
+}
+
+// resolveSkills 解析全局 + 单 Key 自定义后的技能设置。
+func (r *Resolver) resolveSkills(callerKey string) config.SkillSettings {
+	if r == nil || r.Store == nil {
+		return config.SkillSettings{}
+	}
+	return r.Store.ResolveSkills(callerKey)
+}
+
+// toolsEnabled 返回工具调用总开关（未配置时为 false）。
+func (r *Resolver) toolsEnabled() bool {
+	if r == nil || r.Store == nil {
+		return false
+	}
+	return r.Store.ToolsEnabled()
+}
+
 func (r *Resolver) acquireManagedRequestAuth(ctx context.Context, callerID, target string) (*RequestAuth, error) {
 	tried := map[string]bool{}
 	var lastEnsureErr error
@@ -147,6 +213,10 @@ func (r *Resolver) DetermineCaller(req *http.Request) (*RequestAuth, error) {
 	a := &RequestAuth{
 		UseConfigToken: false,
 		CallerID:       callerID,
+		CallerLabel:    r.callerLabel(callerKey),
+		Injection:      r.resolveInjection(callerKey),
+		Skills:         r.resolveSkills(callerKey),
+		ToolsEnabled:   r.toolsEnabled(),
 		resolver:       r,
 		TriedAccounts:  map[string]bool{},
 	}
@@ -375,6 +445,11 @@ func callerTokenID(token string) string {
 	return "caller:" + hex.EncodeToString(sum[:8])
 }
 
+// CallerTokenID 暴露 CallerID 计算方式，供后台按 API Key 过滤响应记录。
+func CallerTokenID(token string) string {
+	return callerTokenID(token)
+}
+
 func (r *Resolver) ensureManagedToken(ctx context.Context, a *RequestAuth) error {
 	if strings.TrimSpace(a.Account.Token) == "" {
 		return r.loginAndPersist(ctx, a)

internal/auth/request_test.go

@@ -395,3 +395,150 @@ func TestDetermineManagedAccountReturnsLastEnsureErrorWhenAllFail(t *testing.T)
 		t.Fatalf("expected auth-style ensure error, got ErrNoAccount")
 	}
 }
+
+func TestDetermineResolvesCallerLabelAndInjection(t *testing.T) {
+	t.Setenv("DS2API_CONFIG_JSON", `{
+		"accounts":[{"email":"acc@example.com","password":"pwd","token":"account-token"}],
+		"api_keys":[
+			{"key":"managed-key","name":"主账号"},
+			{"key":"custom-key","name":"自定义","thinking_injection":{"custom":true,"enabled":false,"prompt":"  key prompt  "}}
+		],
+		"thinking_injection":{"enabled":true,"prompt":"global prompt"}
+	}`)
+	store := config.LoadStore()
+	pool := account.NewPool(store)
+	r := NewResolver(store, pool, func(_ context.Context, _ config.Account) (string, error) {
+		return "fresh-token", nil
+	})
+
+	req, _ := http.NewRequest(http.MethodPost, "/v1/chat/completions", nil)
+	req.Header.Set("Authorization", "Bearer managed-key")
+	a, err := r.Determine(req)
+	if err != nil {
+		t.Fatalf("determine failed: %v", err)
+	}
+	defer r.Release(a)
+	if a.CallerLabel != "主账号" {
+		t.Fatalf("expected caller label from api key name, got %q", a.CallerLabel)
+	}
+	if !a.Injection.Enabled || a.Injection.Prompt != "global prompt" {
+		t.Fatalf("expected global injection settings, got %#v", a.Injection)
+	}
+
+	req2, _ := http.NewRequest(http.MethodPost, "/v1/chat/completions", nil)
+	req2.Header.Set("Authorization", "Bearer custom-key")
+	b, err := r.Determine(req2)
+	if err != nil {
+		t.Fatalf("determine failed: %v", err)
+	}
+	defer r.Release(b)
+	if b.Injection.Enabled {
+		t.Fatalf("expected per-key injection disable, got %#v", b.Injection)
+	}
+	if b.Injection.Prompt != "key prompt" {
+		t.Fatalf("expected per-key prompt, got %#v", b.Injection)
+	}
+
+	req3, _ := http.NewRequest(http.MethodPost, "/v1/chat/completions", nil)
+	req3.Header.Set("Authorization", "Bearer direct-token")
+	c, err := r.Determine(req3)
+	if err != nil {
+		t.Fatalf("determine failed: %v", err)
+	}
+	if c.CallerLabel != "" {
+		t.Fatalf("expected no caller label for unknown key, got %q", c.CallerLabel)
+	}
+	if !c.Injection.Enabled || c.Injection.Prompt != "global prompt" {
+		t.Fatalf("expected unknown key to follow global injection, got %#v", c.Injection)
+	}
+}
+
+func TestDetermineResolvesSkillsAndTools(t *testing.T) {
+	t.Setenv("DS2API_CONFIG_JSON", `{
+		"accounts":[{"email":"acc@example.com","password":"pwd","token":"account-token"}],
+		"api_keys":[
+			{"key":"managed-key","name":"主账号"},
+			{"key":"custom-key","name":"只用一个技能","skills":{"custom":true,"enabled":true,"ids":["sql-report"]}},
+			{"key":"off-key","name":"关闭","skills":{"custom":true,"enabled":false}}
+		],
+		"skills":{
+			"enabled":true,
+			"max_chars":256,
+			"items":[
+				{"id":"sql-report","name":"SQL 报表","body":"sql body"},
+				{"id":"review","name":"评审","body":"review body"}
+			]
+		},
+		"tools":{"enabled":true}
+	}`)
+	store := config.LoadStore()
+	pool := account.NewPool(store)
+	r := NewResolver(store, pool, func(_ context.Context, _ config.Account) (string, error) {
+		return "fresh-token", nil
+	})
+
+	req, _ := http.NewRequest(http.MethodPost, "/v1/chat/completions", nil)
+	req.Header.Set("Authorization", "Bearer managed-key")
+	a, err := r.Determine(req)
+	if err != nil {
+		t.Fatalf("determine failed: %v", err)
+	}
+	if !a.ToolsEnabled {
+		t.Fatal("expected tools enabled from config")
+	}
+	if !a.Skills.Enabled || len(a.Skills.Items) != 2 {
+		t.Fatalf("expected all global skills, got %#v", a.Skills)
+	}
+	if a.Skills.MaxChars != 256 {
+		t.Fatalf("skills max_chars=%d want=256", a.Skills.MaxChars)
+	}
+	// 账号池默认每账号并发有限，先释放再取下一个 Key，避免 Determine 阻塞等待。
+	r.Release(a)
+
+	req2, _ := http.NewRequest(http.MethodPost, "/v1/chat/completions", nil)
+	req2.Header.Set("Authorization", "Bearer custom-key")
+	b, err := r.Determine(req2)
+	if err != nil {
+		t.Fatalf("determine failed: %v", err)
+	}
+	if !b.Skills.Enabled || len(b.Skills.Items) != 1 || b.Skills.Items[0].ID != "sql-report" {
+		t.Fatalf("expected per-key skill filter, got %#v", b.Skills)
+	}
+	r.Release(b)
+
+	req3, _ := http.NewRequest(http.MethodPost, "/v1/chat/completions", nil)
+	req3.Header.Set("Authorization", "Bearer off-key")
+	off, err := r.Determine(req3)
+	if err != nil {
+		t.Fatalf("determine failed: %v", err)
+	}
+	if off.Skills.Enabled || len(off.Skills.Items) != 0 {
+		t.Fatalf("expected per-key skills disabled, got %#v", off.Skills)
+	}
+	r.Release(off)
+}
+
+func TestDetermineCallerResolvesSkillsAndTools(t *testing.T) {
+	t.Setenv("DS2API_CONFIG_JSON", `{
+		"keys":["k1"],
+		"skills":{"enabled":true,"items":[{"id":"sql-report","body":"sql body"}]}
+	}`)
+	store := config.LoadStore()
+	r := NewResolver(store, nil, nil)
+
+	req, _ := http.NewRequest(http.MethodPost, "/v1/responses", nil)
+	req.Header.Set("Authorization", "Bearer k1")
+	a, err := r.DetermineCaller(req)
+	if err != nil {
+		t.Fatalf("determine caller failed: %v", err)
+	}
+	if !a.Skills.Enabled || len(a.Skills.Items) != 1 {
+		t.Fatalf("expected skills resolved for caller, got %#v", a.Skills)
+	}
+	if a.Skills.MaxChars != config.DefaultSkillsMaxChars {
+		t.Fatalf("skills max_chars=%d want default", a.Skills.MaxChars)
+	}
+	if a.ToolsEnabled {
+		t.Fatal("expected tools disabled by default (nil pointer)")
+	}
+}

internal/chathistory/store.go

@@ -18,10 +18,12 @@ import (
 )
 
 const (
-	FileVersion      = 2
-	DisabledLimit    = 0
-	DefaultLimit     = 20
-	MaxLimit         = 50
+	FileVersion   = 2
+	DisabledLimit = 0
+	DefaultLimit  = 20
+	// MaxLimit 是保留条数的上限。DisabledLimit(0) 表示关闭记录，
+	// 1..MaxLimit 之间的任意值都合法，后台可以按需自由设置。
+	MaxLimit         = 500
 	defaultPreviewAt = 160
 
 	// asyncDebounce 是流式进度落盘的合并窗口：窗口内的多次进度更新只会产生
@@ -33,23 +35,19 @@ const (
 	asyncRetryDelay = 5 * time.Second
 )
 
-var allowedLimits = map[int]struct{}{
-	DisabledLimit: {},
-	10:            {},
-	20:            {},
-	50:            {},
-}
-
 var ErrDisabled = errors.New("chat history disabled")
 
 type Entry struct {
-	ID               string         `json:"id"`
-	Revision         int64          `json:"revision"`
-	CreatedAt        int64          `json:"created_at"`
-	UpdatedAt        int64          `json:"updated_at"`
-	CompletedAt      int64          `json:"completed_at,omitempty"`
-	Status           string         `json:"status"`
-	CallerID         string         `json:"caller_id,omitempty"`
+	ID          string `json:"id"`
+	Revision    int64  `json:"revision"`
+	CreatedAt   int64  `json:"created_at"`
+	UpdatedAt   int64  `json:"updated_at"`
+	CompletedAt int64  `json:"completed_at,omitempty"`
+	Status      string `json:"status"`
+	CallerID    string `json:"caller_id,omitempty"`
+	// CallerLabel 是发起方 API Key 的可读标签（名称/备注/脱敏 Key），
+	// 只用于后台展示与筛选，避免面板里只剩一串哈希。
+	CallerLabel      string         `json:"caller_label,omitempty"`
 	AccountID        string         `json:"account_id,omitempty"`
 	Surface          string         `json:"surface,omitempty"`
 	Model            string         `json:"model,omitempty"`
@@ -97,6 +95,7 @@ type SummaryEntry struct {
 	CompletedAt    int64  `json:"completed_at,omitempty"`
 	Status         string `json:"status"`
 	CallerID       string `json:"caller_id,omitempty"`
+	CallerLabel    string `json:"caller_label,omitempty"`
 	AccountID      string `json:"account_id,omitempty"`
 	Surface        string `json:"surface,omitempty"`
 	Model          string `json:"model,omitempty"`
@@ -118,6 +117,7 @@ type File struct {
 
 type StartParams struct {
 	CallerID    string
+	CallerLabel string
 	AccountID   string
 	Surface     string
 	Model       string
@@ -348,6 +348,7 @@ func (s *Store) Start(params StartParams) (Entry, error) {
 		UpdatedAt:   now,
 		Status:      "streaming",
 		CallerID:    strings.TrimSpace(params.CallerID),
+		CallerLabel: strings.TrimSpace(params.CallerLabel),
 		AccountID:   strings.TrimSpace(params.AccountID),
 		Surface:     strings.TrimSpace(params.Surface),
 		Model:       strings.TrimSpace(params.Model),
@@ -823,7 +824,7 @@ func (s *Store) rebuildIndexLocked() {
 		}
 		return summaries[i].CreatedAt > summaries[j].CreatedAt
 	})
-	if s.state.Limit < DisabledLimit || !isAllowedLimit(s.state.Limit) {
+	if !isAllowedLimit(s.state.Limit) {
 		s.state.Limit = DefaultLimit
 	}
 	if s.state.Limit == DisabledLimit {
@@ -865,6 +866,7 @@ func summaryFromEntry(item Entry) SummaryEntry {
 		CompletedAt:    item.CompletedAt,
 		Status:         item.Status,
 		CallerID:       item.CallerID,
+		CallerLabel:    item.CallerLabel,
 		AccountID:      item.AccountID,
 		Surface:        item.Surface,
 		Model:          item.Model,
@@ -1038,9 +1040,10 @@ func DetailETag(id string, revision int64) string {
 	return fmt.Sprintf(`W/"chat-history-detail-%s-%d"`, strings.TrimSpace(id), revision)
 }
 
+// isAllowedLimit 判定保留条数是否合法：DisabledLimit(0) 表示关闭记录，
+// 1..MaxLimit 之间的任意值都合法，越界值一律视为非法。
 func isAllowedLimit(limit int) bool {
-	_, ok := allowedLimits[limit]
-	return ok
+	return limit >= DisabledLimit && limit <= MaxLimit
 }
 
 func (s *Store) markDetailDirtyLocked(id string) {

internal/chathistory/store_test.go

@@ -794,3 +794,130 @@ func TestStoreBackgroundProgressDoesNotSurfaceWriteFailure(t *testing.T) {
 		t.Fatalf("expected in-memory state to stay readable, got %#v", snapshot.Items)
 	}
 }
+
+// 保留条数不再是固定档位：0 表示关闭，1..MaxLimit 都合法，越界必须报错。
+func TestSetLimitAcceptsAnyValueInRange(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "chat_history.json")
+	store := New(path)
+	t.Cleanup(store.Close)
+
+	for _, limit := range []int{1, 7, 20, 137, MaxLimit} {
+		snapshot, err := store.SetLimit(limit)
+		if err != nil {
+			t.Fatalf("SetLimit(%d) failed: %v", limit, err)
+		}
+		if snapshot.Limit != limit {
+			t.Fatalf("expected limit %d, got %d", limit, snapshot.Limit)
+		}
+		if !store.Enabled() {
+			t.Fatalf("expected store to stay enabled for limit %d", limit)
+		}
+	}
+
+	for _, limit := range []int{MaxLimit + 1, 9999, -1} {
+		if _, err := store.SetLimit(limit); err == nil {
+			t.Fatalf("expected SetLimit(%d) to fail", limit)
+		} else if !strings.Contains(err.Error(), "unsupported chat history limit") {
+			t.Fatalf("unexpected error for SetLimit(%d): %v", limit, err)
+		}
+	}
+
+	// 关闭仍然是一次合法设置：Start 返回 ErrDisabled，但已有记录保留。
+	snapshot, err := store.SetLimit(DisabledLimit)
+	if err != nil {
+		t.Fatalf("disable failed: %v", err)
+	}
+	if snapshot.Limit != DisabledLimit || store.Enabled() {
+		t.Fatalf("expected disabled store, got limit=%d", snapshot.Limit)
+	}
+	if _, err := store.Start(StartParams{UserInput: "later"}); !errors.Is(err, ErrDisabled) {
+		t.Fatalf("expected ErrDisabled, got %v", err)
+	}
+}
+
+// 定制档位必须真正生效：裁剪到 37 条而不是固定档位。
+func TestSetLimitTrimsToCustomValue(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "chat_history.json")
+	store := New(path)
+	t.Cleanup(store.Close)
+	if _, err := store.SetLimit(37); err != nil {
+		t.Fatalf("set limit failed: %v", err)
+	}
+	for i := 0; i < 40; i++ {
+		if _, err := store.Start(StartParams{UserInput: "msg"}); err != nil {
+			t.Fatalf("start %d failed: %v", i, err)
+		}
+	}
+	snapshot, err := store.Snapshot()
+	if err != nil {
+		t.Fatalf("snapshot failed: %v", err)
+	}
+	if len(snapshot.Items) != 37 {
+		t.Fatalf("expected 37 items, got %d", len(snapshot.Items))
+	}
+}
+
+// 索引里读到越界的保留条数时必须回落到 DefaultLimit，而不是照单全收。
+func TestLoadFallsBackToDefaultLimitForOutOfRangeValue(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "chat_history.json")
+	raw, err := json.Marshal(File{
+		Version:  FileVersion,
+		Limit:    MaxLimit + 1,
+		Revision: 1,
+		Items:    []SummaryEntry{},
+	})
+	if err != nil {
+		t.Fatalf("encode index failed: %v", err)
+	}
+	if err := os.WriteFile(path, raw, 0o644); err != nil {
+		t.Fatalf("write index failed: %v", err)
+	}
+
+	store := New(path)
+	t.Cleanup(store.Close)
+	snapshot, err := store.Snapshot()
+	if err != nil {
+		t.Fatalf("snapshot failed: %v", err)
+	}
+	if snapshot.Limit != DefaultLimit {
+		t.Fatalf("expected fallback limit %d, got %d", DefaultLimit, snapshot.Limit)
+	}
+}
+
+// CallerLabel 随记录落盘，并在索引摘要里带上，供后台按 API Key 展示/筛选。
+func TestStorePersistsCallerLabel(t *testing.T) {
+	path := filepath.Join(t.TempDir(), "chat_history.json")
+	store := New(path)
+	t.Cleanup(store.Close)
+
+	started, err := store.Start(StartParams{
+		CallerID:    "caller:abc",
+		CallerLabel: "  小张  ",
+		Model:       "deepseek-v4-flash",
+		UserInput:   "hello",
+	})
+	if err != nil {
+		t.Fatalf("start failed: %v", err)
+	}
+
+	snapshot, err := store.Snapshot()
+	if err != nil {
+		t.Fatalf("snapshot failed: %v", err)
+	}
+	if len(snapshot.Items) != 1 {
+		t.Fatalf("expected one item, got %d", len(snapshot.Items))
+	}
+	if snapshot.Items[0].CallerLabel != "小张" {
+		t.Fatalf("expected trimmed caller label in summary, got %q", snapshot.Items[0].CallerLabel)
+	}
+
+	reloaded := New(path)
+	t.Cleanup(reloaded.Close)
+	full, err := reloaded.Get(started.ID)
+	if err != nil {
+		t.Fatalf("get after reload failed: %v", err)
+	}
+	if full.CallerLabel != "小张" || full.CallerID != "caller:abc" {
+		t.Fatalf("expected caller identity to survive reload, got %#v", full)
+	}
+}

internal/compat/go_compat_test.go

@@ -12,6 +12,7 @@ import (
 )
 
 func TestGoCompatSSEFixtures(t *testing.T) {
+	requireCompatFixtures(t, compatPath("fixtures", "sse_chunks"), compatPath("expected"))
 	files, err := filepath.Glob(compatPath("fixtures", "sse_chunks", "*.json"))
 	if err != nil {
 		t.Fatalf("glob fixtures failed: %v", err)
@@ -64,6 +65,7 @@ func TestGoCompatSSEFixtures(t *testing.T) {
 }
 
 func TestGoCompatTokenFixtures(t *testing.T) {
+	requireCompatFixtures(t, compatPath("fixtures", "token_cases.json"), compatPath("expected", "token_cases.json"))
 	var fixture struct {
 		Cases []struct {
 			Name string `json:"name"`
@@ -96,6 +98,20 @@ func TestGoCompatTokenFixtures(t *testing.T) {
 	}
 }
 
+// requireCompatFixtures 在 tests/compat 对照数据缺失时跳过用例。
+//
+// 这些 fixture/expected 数据没有随本仓库快照提供（tests/ 整个目录都不在仓库里），
+// 用例无从校验；也不应该在测试里凭空造一份期望值——那只会让测试自证。
+// 数据补齐后本检查自动放行，用例恢复真实比对。
+func requireCompatFixtures(t *testing.T, paths ...string) {
+	t.Helper()
+	for _, path := range paths {
+		if _, err := os.Stat(path); err != nil {
+			t.Skipf("compat fixtures 未随仓库提供，跳过：%s 不存在", path)
+		}
+	}
+}
+
 func mustLoadJSON(t *testing.T, path string, out any) {
 	t.Helper()
 	b, err := os.ReadFile(path)

internal/completionruntime/nonstream_test.go

@@ -315,7 +315,7 @@ func TestStartCompletionAppliesCurrentInputFileGlobally(t *testing.T) {
 	if !strings.Contains(prompt, ds.uploads[0].Filename) {
 		t.Fatalf("expected continuation prompt, got %q", prompt)
 	}
-	if !start.Request.CurrentInputFileApplied || !strings.Contains(start.Request.PromptTokenText, "# context_context.txt") {
+	if !start.Request.CurrentInputFileApplied || !strings.Contains(start.Request.PromptTokenText, "# 对话记录") {
 		t.Fatalf("expected prepared request to carry current input file state, got %#v", start.Request)
 	}
 }

internal/config/api_key_injection_test.go

@@ -0,0 +1,70 @@
+package config
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestConfigAPIKeyInjectionJSONRoundTrip(t *testing.T) {
+	enabled := true
+	cfg := Config{APIKeys: []APIKey{
+		{Key: "sk-plain"},
+		{
+			Key:  "sk-custom",
+			Name: "自定义",
+			ThinkingInjection: &APIKeyInjectionConfig{
+				Custom:  true,
+				Enabled: &enabled,
+				Prompt:  "  key prompt  ",
+			},
+		},
+	}}
+	cfg.NormalizeCredentials()
+
+	raw, err := json.Marshal(cfg)
+	if err != nil {
+		t.Fatalf("marshal config: %v", err)
+	}
+	var decoded Config
+	if err := json.Unmarshal(raw, &decoded); err != nil {
+		t.Fatalf("unmarshal config: %v", err)
+	}
+	decoded.NormalizeCredentials()
+
+	if len(decoded.APIKeys) != 2 {
+		t.Fatalf("expected two api keys, got %#v", decoded.APIKeys)
+	}
+	if decoded.APIKeys[0].ThinkingInjection != nil {
+		t.Fatalf("expected plain key without injection, got %#v", decoded.APIKeys[0].ThinkingInjection)
+	}
+	injection := decoded.APIKeys[1].ThinkingInjection
+	if injection == nil || !injection.Custom || injection.Enabled == nil || !*injection.Enabled {
+		t.Fatalf("unexpected injection config: %#v", injection)
+	}
+	if injection.Prompt != "key prompt" {
+		t.Fatalf("expected trimmed prompt, got %q", injection.Prompt)
+	}
+}
+
+func TestAPIKeyInjectionNormalizeDropsEmptyObject(t *testing.T) {
+	if got := (&APIKeyInjectionConfig{}).Normalize(); got != nil {
+		t.Fatalf("expected empty injection config to normalize to nil, got %#v", got)
+	}
+	enabled := false
+	if got := (&APIKeyInjectionConfig{Custom: true, Enabled: &enabled}).Normalize(); got == nil || got.Enabled == nil {
+		t.Fatalf("expected custom config to be kept, got %#v", got)
+	}
+}
+
+func TestConfigCloneIsolatesAPIKeyInjection(t *testing.T) {
+	enabled := true
+	cfg := Config{APIKeys: []APIKey{{
+		Key:               "sk-custom",
+		ThinkingInjection: &APIKeyInjectionConfig{Custom: true, Enabled: &enabled, Prompt: "p"},
+	}}}
+	clone := cfg.Clone()
+	*clone.APIKeys[0].ThinkingInjection.Enabled = false
+	if !enabled {
+		t.Fatal("expected clone to own a copy of the injection settings")
+	}
+}

internal/config/codec.go

@@ -51,6 +51,12 @@ func (c Config) MarshalJSON() ([]byte, error) {
 	if c.ThinkingInjection.Enabled != nil || strings.TrimSpace(c.ThinkingInjection.Prompt) != "" {
 		m["thinking_injection"] = c.ThinkingInjection
 	}
+	if c.Skills.Enabled != nil || c.Skills.MaxChars != nil || len(c.Skills.Items) > 0 {
+		m["skills"] = c.Skills
+	}
+	if c.Tools.Enabled != nil {
+		m["tools"] = c.Tools
+	}
 	if strings.TrimSpace(c.Vercel.Token) != "" || strings.TrimSpace(c.Vercel.ProjectID) != "" || strings.TrimSpace(c.Vercel.TeamID) != "" {
 		m["vercel"] = NormalizeVercelConfig(c.Vercel)
 	}
@@ -138,6 +144,14 @@ func (c *Config) UnmarshalJSON(b []byte) error {
 			if err := json.Unmarshal(v, &c.ThinkingInjection); err != nil {
 				return fmt.Errorf("invalid field %q: %w", k, err)
 			}
+		case "skills":
+			if err := json.Unmarshal(v, &c.Skills); err != nil {
+				return fmt.Errorf("invalid field %q: %w", k, err)
+			}
+		case "tools":
+			if err := json.Unmarshal(v, &c.Tools); err != nil {
+				return fmt.Errorf("invalid field %q: %w", k, err)
+			}
 		case "vercel":
 			if err := json.Unmarshal(v, &c.Vercel); err != nil {
 				return fmt.Errorf("invalid field %q: %w", k, err)
@@ -168,7 +182,7 @@ func (c *Config) UnmarshalJSON(b []byte) error {
 func (c Config) Clone() Config {
 	clone := Config{
 		Keys:         slices.Clone(c.Keys),
-		APIKeys:      slices.Clone(c.APIKeys),
+		APIKeys:      cloneAPIKeys(c.APIKeys),
 		Accounts:     slices.Clone(c.Accounts),
 		Proxies:      slices.Clone(c.Proxies),
 		ModelAliases: cloneStringMap(c.ModelAliases),
@@ -188,6 +202,8 @@ func (c Config) Clone() Config {
 			Enabled: cloneBoolPtr(c.ThinkingInjection.Enabled),
 			Prompt:  c.ThinkingInjection.Prompt,
 		},
+		Skills:           c.Skills.Clone(),
+		Tools:            c.Tools.Clone(),
 		Vercel:           c.Vercel,
 		Platform:         c.Platform,
 		VercelSyncHash:   c.VercelSyncHash,
@@ -200,6 +216,23 @@ func (c Config) Clone() Config {
 	return clone
 }
 
+func cloneAPIKeys(in []APIKey) []APIKey {
+	if len(in) == 0 {
+		return nil
+	}
+	out := make([]APIKey, len(in))
+	for i, item := range in {
+		out[i] = APIKey{
+			Key:               item.Key,
+			Name:              item.Name,
+			Remark:            item.Remark,
+			ThinkingInjection: item.ThinkingInjection.Clone(),
+			Skills:            item.Skills.Clone(),
+		}
+	}
+	return out
+}
+
 func cloneStringMap(in map[string]string) map[string]string {
 	if len(in) == 0 {
 		return nil
@@ -219,6 +252,14 @@ func cloneBoolPtr(in *bool) *bool {
 	return &v
 }
 
+func cloneIntPtr(in *int) *int {
+	if in == nil {
+		return nil
+	}
+	v := *in
+	return &v
+}
+
 func parseConfigString(raw string) (Config, error) {
 	var cfg Config
 	candidates := []string{raw}

internal/config/config.go

@@ -5,6 +5,7 @@ import (
 	"encoding/hex"
 	"fmt"
 	"strings"
+	"unicode/utf8"
 )
 
 type Config struct {
@@ -21,6 +22,8 @@ type Config struct {
 	CurrentInputFile  CurrentInputFileConfig  `json:"current_input_file,omitempty"`
 	FileAudit         FileAuditConfig         `json:"file_audit,omitempty"`
 	ThinkingInjection ThinkingInjectionConfig `json:"thinking_injection,omitempty"`
+	Skills            SkillsConfig            `json:"skills,omitempty"`
+	Tools             ToolsConfig             `json:"tools,omitempty"`
 	Vercel            VercelConfig            `json:"vercel,omitempty"`
 	Platform          PlatformConfig          `json:"platform,omitempty"`
 	VercelSyncHash    string                  `json:"_vercel_sync_hash,omitempty"`
@@ -46,6 +49,252 @@ type APIKey struct {
 	Key    string `json:"key"`
 	Name   string `json:"name,omitempty"`
 	Remark string `json:"remark,omitempty"`
+	// ThinkingInjection 是单个 API Key 对全局「思考格式注入」的覆盖设置。
+	// 未配置或 Custom=false 时完全跟随全局开关与全局提示词。
+	ThinkingInjection *APIKeyInjectionConfig `json:"thinking_injection,omitempty"`
+	// Skills 是单个 API Key 对全局「纯文本技能库」的覆盖设置。
+	// 未配置或 Custom=false 时使用全部全局技能。
+	Skills *APIKeySkillsConfig `json:"skills,omitempty"`
+}
+
+// SkillsConfig 是「纯文本技能库」的全局配置。
+// 技能正文会被直接拼进 prompt，模型不需要任何工具调用能力。
+type SkillsConfig struct {
+	// Enabled 是实验性总开关。未配置（nil）按 false 处理：默认不注入任何技能。
+	// 全局为 false 时，任何 API Key 的自定义设置都不会生效。
+	Enabled *bool `json:"enabled,omitempty"`
+	// MaxChars 是单次注入的字符上限（按 rune 计）。未配置时取
+	// DefaultSkillsMaxChars（8000）；显式配置 0 或负数表示不限制。
+	MaxChars *int `json:"max_chars,omitempty"`
+	// Items 是待注入的技能条目，最多 MaxSkillItems 条。
+	Items []SkillConfig `json:"items,omitempty"`
+}
+
+// SkillConfig 是一条纯文本技能。ID 必填且唯一，字符集为 [a-z0-9_-]。
+type SkillConfig struct {
+	ID          string `json:"id"`
+	Name        string `json:"name,omitempty"`
+	Description string `json:"description,omitempty"`
+	Body        string `json:"body"`
+}
+
+// APIKeySkillsConfig 描述单个 API Key 的技能选择。
+//   - 未配置或 Custom=false：使用全部全局技能；
+//   - Custom=true 且 Enabled=false：该 Key 不注入任何技能；
+//   - Custom=true 且 IDs 非空：只注入命中 ID 的技能；
+//   - Custom=true 且 IDs 为空：该 Key 不注入任何技能。
+type APIKeySkillsConfig struct {
+	Custom  bool     `json:"custom,omitempty"`
+	Enabled *bool    `json:"enabled,omitempty"`
+	IDs     []string `json:"ids,omitempty"`
+}
+
+// ToolsConfig 是「工具调用」的全局开关配置。
+// 未配置（nil）按 false 处理：默认关闭工具调用，避免上游风控封号。
+type ToolsConfig struct {
+	Enabled *bool `json:"enabled,omitempty"`
+}
+
+const (
+	// DefaultSkillsMaxChars 是未配置 skills.max_chars 时单次注入的字符上限。
+	DefaultSkillsMaxChars = 8000
+	// MaxSkillItems 是技能条目的数量上限。
+	MaxSkillItems = 50
+	// MaxSkillBodyChars 是单条技能正文的字符上限（按 rune 计）。
+	MaxSkillBodyChars = 100_000
+	// MaxSkillsTotalBodyChars 是全部技能正文的字符上限（按 rune 计）。
+	MaxSkillsTotalBodyChars = 500_000
+)
+
+// IsEnabled 返回技能库是否启用；未配置按 false 处理。
+func (c SkillsConfig) IsEnabled() bool {
+	if c.Enabled == nil {
+		return false
+	}
+	return *c.Enabled
+}
+
+// EffectiveMaxChars 返回生效的单次注入字符上限。
+// 未配置时使用 DefaultSkillsMaxChars；显式配置 0 或负数表示不限制。
+func (c SkillsConfig) EffectiveMaxChars() int {
+	if c.MaxChars == nil {
+		return DefaultSkillsMaxChars
+	}
+	return *c.MaxChars
+}
+
+// Normalize 归一化技能条目：去空白、丢弃空 ID、按 ID 去重。
+// 它不做长度校验，长度限制由 ValidateSkillsConfig 负责。
+func (c SkillsConfig) Normalize() SkillsConfig {
+	out := SkillsConfig{
+		Enabled:  cloneBoolPtr(c.Enabled),
+		MaxChars: cloneIntPtr(c.MaxChars),
+	}
+	if len(c.Items) == 0 {
+		return out
+	}
+	seen := make(map[string]struct{}, len(c.Items))
+	items := make([]SkillConfig, 0, len(c.Items))
+	for _, item := range c.Items {
+		id := strings.TrimSpace(item.ID)
+		if id == "" {
+			continue
+		}
+		if _, ok := seen[id]; ok {
+			continue
+		}
+		seen[id] = struct{}{}
+		items = append(items, SkillConfig{
+			ID:          id,
+			Name:        strings.TrimSpace(item.Name),
+			Description: strings.TrimSpace(item.Description),
+			Body:        item.Body,
+		})
+	}
+	if len(items) > 0 {
+		out.Items = items
+	}
+	return out
+}
+
+// Clone 深拷贝技能库配置。
+func (c SkillsConfig) Clone() SkillsConfig {
+	out := SkillsConfig{
+		Enabled:  cloneBoolPtr(c.Enabled),
+		MaxChars: cloneIntPtr(c.MaxChars),
+	}
+	if len(c.Items) > 0 {
+		out.Items = make([]SkillConfig, len(c.Items))
+		copy(out.Items, c.Items)
+	}
+	return out
+}
+
+// ValidateSkillsConfig 校验技能库配置：
+// 条目数量、ID 必填/唯一/字符集、单条与整体正文字符上限。
+// max_chars 允许为 0 或负数（表示不限制）。
+func ValidateSkillsConfig(c SkillsConfig) error {
+	if len(c.Items) > MaxSkillItems {
+		return fmt.Errorf("skills.items cannot exceed %d entries", MaxSkillItems)
+	}
+	seen := make(map[string]struct{}, len(c.Items))
+	total := 0
+	for i, item := range c.Items {
+		id := strings.TrimSpace(item.ID)
+		if id == "" {
+			return fmt.Errorf("skills.items[%d].id cannot be empty", i)
+		}
+		if !validSkillID(id) {
+			return fmt.Errorf("skills.items[%d].id %q must match [a-z0-9_-]", i, id)
+		}
+		if _, ok := seen[id]; ok {
+			return fmt.Errorf("duplicate skill id: %s", id)
+		}
+		seen[id] = struct{}{}
+		if strings.TrimSpace(item.Body) == "" {
+			return fmt.Errorf("skills.items[%d].body cannot be empty", i)
+		}
+		bodyChars := utf8.RuneCountInString(item.Body)
+		if bodyChars > MaxSkillBodyChars {
+			return fmt.Errorf("skills.items[%d].body cannot exceed %d characters", i, MaxSkillBodyChars)
+		}
+		total += bodyChars
+		if total > MaxSkillsTotalBodyChars {
+			return fmt.Errorf("skills.items total body cannot exceed %d characters", MaxSkillsTotalBodyChars)
+		}
+	}
+	return nil
+}
+
+func validSkillID(id string) bool {
+	if id == "" {
+		return false
+	}
+	for _, r := range id {
+		switch {
+		case r >= 'a' && r <= 'z':
+		case r >= '0' && r <= '9':
+		case r == '_' || r == '-':
+		default:
+			return false
+		}
+	}
+	return true
+}
+
+// Normalize 归一化单个 Key 的技能覆盖设置，去掉空白并按需丢弃空对象。
+func (c *APIKeySkillsConfig) Normalize() *APIKeySkillsConfig {
+	if c == nil {
+		return nil
+	}
+	out := APIKeySkillsConfig{
+		Custom:  c.Custom,
+		Enabled: cloneBoolPtr(c.Enabled),
+	}
+	seen := make(map[string]struct{}, len(c.IDs))
+	for _, id := range c.IDs {
+		id = strings.TrimSpace(id)
+		if id == "" {
+			continue
+		}
+		if _, ok := seen[id]; ok {
+			continue
+		}
+		seen[id] = struct{}{}
+		out.IDs = append(out.IDs, id)
+	}
+	if !out.Custom && out.Enabled == nil && len(out.IDs) == 0 {
+		return nil
+	}
+	return &out
+}
+
+// Clone 深拷贝单个 Key 的技能覆盖设置。
+func (c *APIKeySkillsConfig) Clone() *APIKeySkillsConfig {
+	return c.Normalize()
+}
+
+// IsEnabled 返回工具调用是否启用；未配置（nil）按 false 处理。
+func (t ToolsConfig) IsEnabled() bool {
+	if t.Enabled == nil {
+		return false
+	}
+	return *t.Enabled
+}
+
+// Clone 深拷贝工具调用开关。
+func (t ToolsConfig) Clone() ToolsConfig {
+	return ToolsConfig{Enabled: cloneBoolPtr(t.Enabled)}
+}
+
+// APIKeyInjectionConfig 描述单个 API Key 的自定义注入提示词。
+type APIKeyInjectionConfig struct {
+	// Custom 为 true 时该 Key 启用自定义注入设置；此时 Enabled 为空表示
+	// 继续跟随全局开关，Prompt 为空表示继续跟随全局提示词。
+	Custom  bool   `json:"custom,omitempty"`
+	Enabled *bool  `json:"enabled,omitempty"`
+	Prompt  string `json:"prompt,omitempty"`
+}
+
+// Normalize 归一化单条注入设置，去掉空白并按需丢弃空对象。
+func (c *APIKeyInjectionConfig) Normalize() *APIKeyInjectionConfig {
+	if c == nil {
+		return nil
+	}
+	out := APIKeyInjectionConfig{
+		Custom:  c.Custom,
+		Enabled: cloneBoolPtr(c.Enabled),
+		Prompt:  strings.TrimSpace(c.Prompt),
+	}
+	if !out.Custom && out.Enabled == nil && out.Prompt == "" {
+		return nil
+	}
+	return &out
+}
+
+// Clone 深拷贝注入设置。
+func (c *APIKeyInjectionConfig) Clone() *APIKeyInjectionConfig {
+	return c.Normalize()
 }
 
 type Proxy struct {

internal/config/config_edge_test.go

@@ -30,9 +30,9 @@ func TestGetModelConfigDeepSeekChatNoThinking(t *testing.T) {
 }
 
 func TestGetModelConfigDeepSeekReasoner(t *testing.T) {
-	thinking, search, ok := GetModelConfig("deepseek-v4-pro")
+	thinking, search, ok := GetModelConfig("deepseek-v4-flash")
 	if !ok {
-		t.Fatal("expected ok for deepseek-v4-pro")
+		t.Fatal("expected ok for deepseek-v4-flash")
 	}
 	if !thinking || search {
 		t.Fatalf("expected thinking=true search=false, got thinking=%v search=%v", thinking, search)
@@ -52,7 +52,7 @@ func TestGetModelConfigDeepSeekChatSearch(t *testing.T) {
 func TestGetModelConfigDeepSeekReasonerSearch(t *testing.T) {
 	thinking, search, ok := GetModelConfig("deepseek-v4-pro-search")
 	if !ok {
-		t.Fatal("expected ok for deepseek-v4-pro-search")
+		t.Fatal("expected ok for legacy deepseek-v4-pro-search")
 	}
 	if !thinking || !search {
 		t.Fatalf("expected both true, got thinking=%v search=%v", thinking, search)
@@ -62,27 +62,27 @@ func TestGetModelConfigDeepSeekReasonerSearch(t *testing.T) {
 func TestGetModelConfigDeepSeekExpertChat(t *testing.T) {
 	thinking, search, ok := GetModelConfig("deepseek-v4-pro")
 	if !ok {
-		t.Fatal("expected ok for deepseek-v4-pro")
+		t.Fatal("expected ok for legacy deepseek-v4-pro")
 	}
 	if !thinking || search {
-		t.Fatalf("expected thinking=true search=false for deepseek-v4-pro, got thinking=%v search=%v", thinking, search)
+		t.Fatalf("expected thinking=true search=false for legacy deepseek-v4-pro, got thinking=%v search=%v", thinking, search)
 	}
 }
 
 func TestGetModelConfigDeepSeekExpertReasonerSearch(t *testing.T) {
-	thinking, search, ok := GetModelConfig("deepseek-v4-pro-search")
+	thinking, search, ok := GetModelConfig("deepseek-v4-pro-search-nothinking")
 	if !ok {
-		t.Fatal("expected ok for deepseek-v4-pro-search")
+		t.Fatal("expected ok for legacy deepseek-v4-pro-search-nothinking")
 	}
-	if !thinking || !search {
-		t.Fatalf("expected both true, got thinking=%v search=%v", thinking, search)
+	if thinking || !search {
+		t.Fatalf("expected thinking=false search=true, got thinking=%v search=%v", thinking, search)
 	}
 }
 
 func TestGetModelConfigDeepSeekVision(t *testing.T) {
 	thinking, search, ok := GetModelConfig("deepseek-v4-vision")
 	if !ok {
-		t.Fatal("expected ok for deepseek-v4-vision")
+		t.Fatal("expected ok for legacy deepseek-v4-vision")
 	}
 	if !thinking || search {
 		t.Fatalf("expected thinking=true search=false, got thinking=%v search=%v", thinking, search)
@@ -105,13 +105,14 @@ func TestGetModelTypeDefaultExpertAndVision(t *testing.T) {
 	if !ok || defaultNoThinkingType != "default" {
 		t.Fatalf("expected default model_type for nothinking, got ok=%v model_type=%q", ok, defaultNoThinkingType)
 	}
+	// pro / vision 系列已合并进 flash，旧名字统一归一为 default。
 	expertType, ok := GetModelType("deepseek-v4-pro")
-	if !ok || expertType != "expert" {
-		t.Fatalf("expected expert model_type, got ok=%v model_type=%q", ok, expertType)
+	if !ok || expertType != "default" {
+		t.Fatalf("expected legacy expert model_type default, got ok=%v model_type=%q", ok, expertType)
 	}
 	visionType, ok := GetModelType("deepseek-v4-vision")
-	if !ok || visionType != "vision" {
-		t.Fatalf("expected vision model_type, got ok=%v model_type=%q", ok, visionType)
+	if !ok || visionType != "default" {
+		t.Fatalf("expected legacy vision model_type default, got ok=%v model_type=%q", ok, visionType)
 	}
 }
 
@@ -685,16 +686,18 @@ func TestOpenAIModelsResponse(t *testing.T) {
 	expected := map[string]bool{
 		"deepseek-v4-flash":                   false,
 		"deepseek-v4-flash-nothinking":        false,
-		"deepseek-v4-pro":                     false,
-		"deepseek-v4-pro-nothinking":          false,
 		"deepseek-v4-flash-search":            false,
 		"deepseek-v4-flash-search-nothinking": false,
-		"deepseek-v4-pro-search":              false,
-		"deepseek-v4-pro-search-nothinking":   false,
-		"deepseek-v4-vision":                  false,
-		"deepseek-v4-vision-nothinking":       false,
+	}
+	removed := map[string]struct{}{
+		"deepseek-v4-pro":        {},
+		"deepseek-v4-pro-search": {},
+		"deepseek-v4-vision":     {},
 	}
 	for _, model := range data {
+		if _, ok := removed[model.ID]; ok {
+			t.Fatalf("expected removed model %s to be absent from model list", model.ID)
+		}
 		if _, ok := expected[model.ID]; ok {
 			expected[model.ID] = true
 		}

internal/config/credentials.go

@@ -64,9 +64,11 @@ func normalizeAPIKeys(items []APIKey) []APIKey {
 		}
 		seen[key] = struct{}{}
 		out = append(out, APIKey{
-			Key:    key,
-			Name:   strings.TrimSpace(item.Name),
-			Remark: strings.TrimSpace(item.Remark),
+			Key:               key,
+			Name:              strings.TrimSpace(item.Name),
+			Remark:            strings.TrimSpace(item.Remark),
+			ThinkingInjection: item.ThinkingInjection.Normalize(),
+			Skills:            item.Skills.Normalize(),
 		})
 	}
 	if len(out) == 0 {
@@ -92,9 +94,11 @@ func apiKeysFromStrings(keys []string, meta map[string]APIKey) []APIKey {
 		seen[key] = struct{}{}
 		if item, ok := meta[key]; ok {
 			out = append(out, APIKey{
-				Key:    key,
-				Name:   strings.TrimSpace(item.Name),
-				Remark: strings.TrimSpace(item.Remark),
+				Key:               key,
+				Name:              strings.TrimSpace(item.Name),
+				Remark:            strings.TrimSpace(item.Remark),
+				ThinkingInjection: item.ThinkingInjection.Normalize(),
+				Skills:            item.Skills.Normalize(),
 			})
 			continue
 		}
@@ -138,9 +142,11 @@ func apiKeyMap(items []APIKey) map[string]APIKey {
 			continue
 		}
 		out[key] = APIKey{
-			Key:    key,
-			Name:   strings.TrimSpace(item.Name),
-			Remark: strings.TrimSpace(item.Remark),
+			Key:               key,
+			Name:              strings.TrimSpace(item.Name),
+			Remark:            strings.TrimSpace(item.Remark),
+			ThinkingInjection: item.ThinkingInjection.Normalize(),
+			Skills:            item.Skills.Normalize(),
 		}
 	}
 	return out
@@ -153,6 +159,44 @@ func equalAPIKeys(a, b []APIKey) bool {
 	return slices.EqualFunc(a, b, func(x, y APIKey) bool {
 		return strings.TrimSpace(x.Key) == strings.TrimSpace(y.Key) &&
 			strings.TrimSpace(x.Name) == strings.TrimSpace(y.Name) &&
-			strings.TrimSpace(x.Remark) == strings.TrimSpace(y.Remark)
+			strings.TrimSpace(x.Remark) == strings.TrimSpace(y.Remark) &&
+			equalAPIKeyInjection(x.ThinkingInjection, y.ThinkingInjection) &&
+			equalAPIKeySkills(x.Skills, y.Skills)
 	})
 }
+
+func equalAPIKeySkills(a, b *APIKeySkillsConfig) bool {
+	left := a.Normalize()
+	right := b.Normalize()
+	if left == nil || right == nil {
+		return left == nil && right == nil
+	}
+	if left.Custom != right.Custom || !slices.Equal(left.IDs, right.IDs) {
+		return false
+	}
+	if (left.Enabled == nil) != (right.Enabled == nil) {
+		return false
+	}
+	if left.Enabled != nil && *left.Enabled != *right.Enabled {
+		return false
+	}
+	return true
+}
+
+func equalAPIKeyInjection(a, b *APIKeyInjectionConfig) bool {
+	left := a.Normalize()
+	right := b.Normalize()
+	if left == nil || right == nil {
+		return left == nil && right == nil
+	}
+	if left.Custom != right.Custom || left.Prompt != right.Prompt {
+		return false
+	}
+	if (left.Enabled == nil) != (right.Enabled == nil) {
+		return false
+	}
+	if left.Enabled != nil && *left.Enabled != *right.Enabled {
+		return false
+	}
+	return true
+}

internal/config/model_alias_test.go

@@ -55,15 +55,15 @@ func TestResolveExpandedHistoricalAliases(t *testing.T) {
 		want  string
 	}{
 		{name: "openai old chatgpt", model: "chatgpt-4o", want: "deepseek-v4-flash"},
-		{name: "openai codex max", model: "gpt-5.1-codex-max", want: "deepseek-v4-pro"},
-		{name: "openai deep research", model: "o3-deep-research", want: "deepseek-v4-pro-search"},
-		{name: "openai historical reasoning", model: "o1-preview", want: "deepseek-v4-pro"},
+		{name: "openai codex max", model: "gpt-5.1-codex-max", want: "deepseek-v4-flash"},
+		{name: "openai deep research", model: "o3-deep-research", want: "deepseek-v4-flash-search"},
+		{name: "openai historical reasoning", model: "o1-preview", want: "deepseek-v4-flash"},
 		{name: "claude latest historical", model: "claude-3-5-sonnet-latest", want: "deepseek-v4-flash"},
-		{name: "claude historical opus", model: "claude-3-opus-20240229", want: "deepseek-v4-pro"},
+		{name: "claude historical opus", model: "claude-3-opus-20240229", want: "deepseek-v4-flash"},
 		{name: "claude historical haiku", model: "claude-3-haiku-20240307", want: "deepseek-v4-flash"},
 		{name: "gemini latest alias", model: "gemini-flash-latest", want: "deepseek-v4-flash"},
-		{name: "gemini historical pro", model: "gemini-1.5-pro", want: "deepseek-v4-pro"},
-		{name: "gemini vision legacy", model: "gemini-pro-vision", want: "deepseek-v4-vision"},
+		{name: "gemini historical pro", model: "gemini-1.5-pro", want: "deepseek-v4-flash"},
+		{name: "gemini vision legacy", model: "gemini-pro-vision", want: "deepseek-v4-flash"},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
@@ -121,8 +121,12 @@ func TestResolveModelRejectsRetiredHistoricalModels(t *testing.T) {
 
 func TestResolveModelDirectDeepSeekExpert(t *testing.T) {
 	got, ok := ResolveModel(nil, "deepseek-v4-pro")
-	if !ok || got != "deepseek-v4-pro" {
-		t.Fatalf("expected deepseek-v4-pro, got ok=%v model=%q", ok, got)
+	if !ok || got != "deepseek-v4-flash" {
+		t.Fatalf("expected legacy deepseek-v4-pro -> deepseek-v4-flash, got ok=%v model=%q", ok, got)
+	}
+	notThinking, ok := ResolveModel(nil, "deepseek-v4-pro-nothinking")
+	if !ok || notThinking != "deepseek-v4-flash-nothinking" {
+		t.Fatalf("expected legacy deepseek-v4-pro-nothinking -> deepseek-v4-flash-nothinking, got ok=%v model=%q", ok, notThinking)
 	}
 }
 
@@ -130,8 +134,8 @@ func TestResolveModelCustomAliasToExpert(t *testing.T) {
 	got, ok := ResolveModel(mockModelAliasReader{
 		"my-expert-model": "deepseek-v4-pro-search",
 	}, "my-expert-model")
-	if !ok || got != "deepseek-v4-pro-search" {
-		t.Fatalf("expected alias -> deepseek-v4-pro-search, got ok=%v model=%q", ok, got)
+	if !ok || got != "deepseek-v4-flash-search" {
+		t.Fatalf("expected alias -> deepseek-v4-flash-search, got ok=%v model=%q", ok, got)
 	}
 }
 
@@ -139,8 +143,8 @@ func TestResolveModelCustomAliasToVision(t *testing.T) {
 	got, ok := ResolveModel(mockModelAliasReader{
 		"my-vision-model": "deepseek-v4-vision",
 	}, "my-vision-model")
-	if !ok || got != "deepseek-v4-vision" {
-		t.Fatalf("expected alias -> deepseek-v4-vision, got ok=%v model=%q", ok, got)
+	if !ok || got != "deepseek-v4-flash" {
+		t.Fatalf("expected alias -> deepseek-v4-flash, got ok=%v model=%q", ok, got)
 	}
 }
 

internal/config/models.go

@@ -29,25 +29,21 @@ type ModelAliasReader interface {
 
 const noThinkingModelSuffix = "-nothinking"
 
+// 上游已把 v4-pro / v4-vision 合并进 v4-flash，对外只保留 flash 系列：
+//   - deepseek-v4-flash            默认思考
+//   - deepseek-v4-flash-search     默认思考 + 原生联网搜索
+//   - deepseek-v4-flash-nothinking 强制关闭思考
+//   - deepseek-v4-flash-search-nothinking 强制关闭思考 + 联网搜索
 var deepSeekBaseModels = []ModelInfo{
 	{ID: "deepseek-v4-flash", Object: "model", Created: 1677610602, OwnedBy: "deepseek", Permission: []any{}},
-	{ID: "deepseek-v4-pro", Object: "model", Created: 1677610602, OwnedBy: "deepseek", Permission: []any{}},
 	{ID: "deepseek-v4-flash-search", Object: "model", Created: 1677610602, OwnedBy: "deepseek", Permission: []any{}},
-	{ID: "deepseek-v4-pro-search", Object: "model", Created: 1677610602, OwnedBy: "deepseek", Permission: []any{}},
-	{ID: "deepseek-v4-vision", Object: "model", Created: 1677610602, OwnedBy: "deepseek", Permission: []any{}},
 }
 
 var OllamaCapabilitiesModels = []OllamaCapabilitiesModelInfo{
 	{ID: "deepseek-v4-flash", Capabilities: []string{"tools", "thinking"}},
-	{ID: "deepseek-v4-pro", Capabilities: []string{"tools", "thinking"}},
 	{ID: "deepseek-v4-flash-search", Capabilities: []string{"tools", "thinking"}},
-	{ID: "deepseek-v4-pro-search", Capabilities: []string{"tools", "thinking"}},
-	{ID: "deepseek-v4-vision", Capabilities: []string{"tools", "thinking", "vision"}},
 	{ID: "deepseek-v4-flash-nothinking", Capabilities: []string{"tools"}},
-	{ID: "deepseek-v4-pro-nothinking", Capabilities: []string{"tools"}},
 	{ID: "deepseek-v4-flash-search-nothinking", Capabilities: []string{"tools"}},
-	{ID: "deepseek-v4-pro-search-nothinking", Capabilities: []string{"tools"}},
-	{ID: "deepseek-v4-vision-nothinking", Capabilities: []string{"tools", "vision"}},
 }
 
 var DeepSeekModels = appendNoThinkingVariants(deepSeekBaseModels)
@@ -84,30 +80,59 @@ var claudeBaseModels = []ModelInfo{
 
 var ClaudeModels = appendNoThinkingVariants(claudeBaseModels)
 
+// deprecatedModelAliases 让老客户端保存过的 pro / vision 模型名依旧能用，
+// 但它们不会再出现在 /v1/models 列表里。
+var deprecatedModelAliases = map[string]string{
+	"deepseek-v4-pro":        "deepseek-v4-flash",
+	"deepseek-v4-pro-search": "deepseek-v4-flash-search",
+	"deepseek-v4-vision":     "deepseek-v4-flash",
+}
+
 func GetModelConfig(model string) (thinking bool, search bool, ok bool) {
 	baseModel, noThinking := splitNoThinkingModel(model)
 	if baseModel == "" {
 		return false, false, false
 	}
+	if mapped, hit := deprecatedModelAliases[baseModel]; hit {
+		baseModel = mapped
+	}
 	switch baseModel {
-	case "deepseek-v4-flash", "deepseek-v4-pro", "deepseek-v4-vision":
+	case "deepseek-v4-flash":
 		return !noThinking, false, true
-	case "deepseek-v4-flash-search", "deepseek-v4-pro-search":
+	case "deepseek-v4-flash-search":
 		return !noThinking, true, true
 	default:
 		return false, false, false
 	}
 }
 
+// GetModelType 返回上游 model_type。v4 系列合并后只剩 default 一种。
 func GetModelType(model string) (modelType string, ok bool) {
 	baseModel, _ := splitNoThinkingModel(model)
+	if mapped, hit := deprecatedModelAliases[baseModel]; hit {
+		baseModel = mapped
+	}
 	switch baseModel {
 	case "deepseek-v4-flash", "deepseek-v4-flash-search":
 		return "default", true
-	case "deepseek-v4-pro", "deepseek-v4-pro-search":
-		return "expert", true
-	case "deepseek-v4-vision":
-		return "vision", true
+	default:
+		return "", false
+	}
+}
+
+// resolveSupportedModel 解析单个模型名（不做别名表查询），把已下线的
+// pro / vision 名字归一到 flash 系列，并保留 -nothinking 变体。
+func resolveSupportedModel(model string) (string, bool) {
+	baseModel, noThinking := splitNoThinkingModel(model)
+	if baseModel == "" {
+		return "", false
+	}
+	if mapped, hit := deprecatedModelAliases[baseModel]; hit {
+		baseModel = mapped
+	}
+	switch baseModel {
+	case "deepseek-v4-flash", "deepseek-v4-flash-search":
+		return withNoThinkingVariant(baseModel, noThinking), true
 	default:
 		return "", false
 	}
@@ -149,36 +174,36 @@ func DefaultModelAliases() map[string]string {
 		"gpt-5-nano":          "deepseek-v4-flash",
 		"gpt-5.4-mini":        "deepseek-v4-flash",
 		"gpt-5.4-nano":        "deepseek-v4-flash",
-		"gpt-5-pro":           "deepseek-v4-pro",
-		"gpt-5.2-pro":         "deepseek-v4-pro",
-		"gpt-5.4-pro":         "deepseek-v4-pro",
-		"gpt-5.5-pro":         "deepseek-v4-pro",
-		"gpt-5-codex":         "deepseek-v4-pro",
-		"gpt-5.1-codex":       "deepseek-v4-pro",
-		"gpt-5.1-codex-mini":  "deepseek-v4-pro",
-		"gpt-5.1-codex-max":   "deepseek-v4-pro",
-		"gpt-5.2-codex":       "deepseek-v4-pro",
-		"gpt-5.3-codex":       "deepseek-v4-pro",
-		"codex-mini-latest":   "deepseek-v4-pro",
+		"gpt-5-pro":           "deepseek-v4-flash",
+		"gpt-5.2-pro":         "deepseek-v4-flash",
+		"gpt-5.4-pro":         "deepseek-v4-flash",
+		"gpt-5.5-pro":         "deepseek-v4-flash",
+		"gpt-5-codex":         "deepseek-v4-flash",
+		"gpt-5.1-codex":       "deepseek-v4-flash",
+		"gpt-5.1-codex-mini":  "deepseek-v4-flash",
+		"gpt-5.1-codex-max":   "deepseek-v4-flash",
+		"gpt-5.2-codex":       "deepseek-v4-flash",
+		"gpt-5.3-codex":       "deepseek-v4-flash",
+		"codex-mini-latest":   "deepseek-v4-flash",
 
 		// OpenAI reasoning / research families
-		"o1":                    "deepseek-v4-pro",
-		"o1-preview":            "deepseek-v4-pro",
-		"o1-mini":               "deepseek-v4-pro",
-		"o1-pro":                "deepseek-v4-pro",
-		"o3":                    "deepseek-v4-pro",
-		"o3-mini":               "deepseek-v4-pro",
-		"o3-pro":                "deepseek-v4-pro",
-		"o3-deep-research":      "deepseek-v4-pro-search",
-		"o4-mini":               "deepseek-v4-pro",
-		"o4-mini-deep-research": "deepseek-v4-pro-search",
+		"o1":                    "deepseek-v4-flash",
+		"o1-preview":            "deepseek-v4-flash",
+		"o1-mini":               "deepseek-v4-flash",
+		"o1-pro":                "deepseek-v4-flash",
+		"o3":                    "deepseek-v4-flash",
+		"o3-mini":               "deepseek-v4-flash",
+		"o3-pro":                "deepseek-v4-flash",
+		"o3-deep-research":      "deepseek-v4-flash-search",
+		"o4-mini":               "deepseek-v4-flash",
+		"o4-mini-deep-research": "deepseek-v4-flash-search",
 
 		// Claude current and historical aliases
-		"claude-opus-4-6":            "deepseek-v4-pro",
-		"claude-opus-4-1":            "deepseek-v4-pro",
-		"claude-opus-4-1-20250805":   "deepseek-v4-pro",
-		"claude-opus-4-0":            "deepseek-v4-pro",
-		"claude-opus-4-20250514":     "deepseek-v4-pro",
+		"claude-opus-4-6":            "deepseek-v4-flash",
+		"claude-opus-4-1":            "deepseek-v4-flash",
+		"claude-opus-4-1-20250805":   "deepseek-v4-flash",
+		"claude-opus-4-0":            "deepseek-v4-flash",
+		"claude-opus-4-20250514":     "deepseek-v4-flash",
 		"claude-sonnet-4-6":          "deepseek-v4-flash",
 		"claude-sonnet-4-5":          "deepseek-v4-flash",
 		"claude-sonnet-4-5-20250929": "deepseek-v4-flash",
@@ -196,28 +221,28 @@ func DefaultModelAliases() map[string]string {
 		"claude-3-5-haiku":           "deepseek-v4-flash",
 		"claude-3-5-haiku-latest":    "deepseek-v4-flash",
 		"claude-3-5-haiku-20241022":  "deepseek-v4-flash",
-		"claude-3-opus":              "deepseek-v4-pro",
-		"claude-3-opus-20240229":     "deepseek-v4-pro",
+		"claude-3-opus":              "deepseek-v4-flash",
+		"claude-3-opus-20240229":     "deepseek-v4-flash",
 		"claude-3-sonnet":            "deepseek-v4-flash",
 		"claude-3-sonnet-20240229":   "deepseek-v4-flash",
 		"claude-3-haiku":             "deepseek-v4-flash",
 		"claude-3-haiku-20240307":    "deepseek-v4-flash",
 
 		// Gemini current and historical text / multimodal models
-		"gemini-pro":            "deepseek-v4-pro",
-		"gemini-pro-vision":     "deepseek-v4-vision",
-		"gemini-pro-latest":     "deepseek-v4-pro",
+		"gemini-pro":            "deepseek-v4-flash",
+		"gemini-pro-vision":     "deepseek-v4-flash",
+		"gemini-pro-latest":     "deepseek-v4-flash",
 		"gemini-flash-latest":   "deepseek-v4-flash",
-		"gemini-1.5-pro":        "deepseek-v4-pro",
+		"gemini-1.5-pro":        "deepseek-v4-flash",
 		"gemini-1.5-flash":      "deepseek-v4-flash",
 		"gemini-1.5-flash-8b":   "deepseek-v4-flash",
 		"gemini-2.0-flash":      "deepseek-v4-flash",
 		"gemini-2.0-flash-lite": "deepseek-v4-flash",
-		"gemini-2.5-pro":        "deepseek-v4-pro",
+		"gemini-2.5-pro":        "deepseek-v4-flash",
 		"gemini-2.5-flash":      "deepseek-v4-flash",
 		"gemini-2.5-flash-lite": "deepseek-v4-flash",
-		"gemini-3.1-pro":        "deepseek-v4-pro",
-		"gemini-3-pro":          "deepseek-v4-pro",
+		"gemini-3.1-pro":        "deepseek-v4-flash",
+		"gemini-3-pro":          "deepseek-v4-flash",
 		"gemini-3-flash":        "deepseek-v4-flash",
 		"gemini-3.1-flash":      "deepseek-v4-flash",
 		"gemini-3.1-flash-lite": "deepseek-v4-flash",
@@ -232,16 +257,20 @@ func ResolveModel(store ModelAliasReader, requested string) (string, bool) {
 	if model == "" {
 		return "", false
 	}
-	aliases := loadModelAliases(store)
-	if IsSupportedDeepSeekModel(model) {
-		return model, true
+	if resolved, ok := resolveSupportedModel(model); ok {
+		return resolved, true
 	}
-	if mapped, ok := aliases[model]; ok && IsSupportedDeepSeekModel(mapped) {
-		return mapped, true
+	aliases := loadModelAliases(store)
+	if mapped, ok := aliases[model]; ok {
+		if resolved, ok := resolveSupportedModel(mapped); ok {
+			return resolved, true
+		}
 	}
 	baseModel, noThinking := splitNoThinkingModel(model)
-	if mapped, ok := aliases[baseModel]; ok && IsSupportedDeepSeekModel(mapped) {
-		return withNoThinkingVariant(mapped, noThinking), true
+	if mapped, ok := aliases[baseModel]; ok {
+		if resolved, ok := resolveSupportedModel(withNoThinkingVariant(mapped, noThinking)); ok {
+			return resolved, true
+		}
 	}
 	return "", false
 }

internal/config/skills_test.go

@@ -0,0 +1,242 @@
+package config
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func TestSkillsConfigJSONRoundTrip(t *testing.T) {
+	raw := `{
+		"keys":["k1"],
+		"skills":{
+			"enabled":true,
+			"max_chars":120,
+			"items":[{"id":"sql-report","name":"SQL 报表","description":"按固定口径写 SQL","body":"# 说明\n先对齐口径"}]
+		},
+		"tools":{"enabled":true}
+	}`
+	var cfg Config
+	if err := json.Unmarshal([]byte(raw), &cfg); err != nil {
+		t.Fatalf("unmarshal config: %v", err)
+	}
+	if !cfg.Skills.IsEnabled() {
+		t.Fatal("expected skills enabled from config")
+	}
+	if got := cfg.Skills.EffectiveMaxChars(); got != 120 {
+		t.Fatalf("max_chars=%d want=120", got)
+	}
+	if len(cfg.Skills.Items) != 1 {
+		t.Fatalf("expected one skill item, got %#v", cfg.Skills.Items)
+	}
+	item := cfg.Skills.Items[0]
+	if item.ID != "sql-report" || item.Name != "SQL 报表" || item.Description != "按固定口径写 SQL" {
+		t.Fatalf("unexpected skill metadata: %#v", item)
+	}
+	if !strings.Contains(item.Body, "先对齐口径") {
+		t.Fatalf("unexpected skill body: %q", item.Body)
+	}
+	if !cfg.Tools.IsEnabled() {
+		t.Fatal("expected tools enabled from config")
+	}
+
+	// 编解码往返不能丢字段（codec.go 是手写映射）。
+	encoded, err := json.Marshal(cfg)
+	if err != nil {
+		t.Fatalf("marshal config: %v", err)
+	}
+	var decoded Config
+	if err := json.Unmarshal(encoded, &decoded); err != nil {
+		t.Fatalf("unmarshal round trip: %v", err)
+	}
+	if !decoded.Skills.IsEnabled() || decoded.Skills.EffectiveMaxChars() != 120 {
+		t.Fatalf("skills lost in round trip: %#v", decoded.Skills)
+	}
+	if len(decoded.Skills.Items) != 1 || decoded.Skills.Items[0].ID != "sql-report" {
+		t.Fatalf("skill items lost in round trip: %#v", decoded.Skills.Items)
+	}
+	if decoded.Tools.Enabled == nil || !*decoded.Tools.Enabled {
+		t.Fatalf("tools flag lost in round trip: %#v", decoded.Tools)
+	}
+}
+
+func TestSkillsAndToolsDefaultOff(t *testing.T) {
+	var cfg Config
+	if err := json.Unmarshal([]byte(`{"keys":["k1"]}`), &cfg); err != nil {
+		t.Fatalf("unmarshal config: %v", err)
+	}
+	if cfg.Skills.IsEnabled() {
+		t.Fatal("expected skills disabled by default")
+	}
+	if got := cfg.Skills.EffectiveMaxChars(); got != DefaultSkillsMaxChars {
+		t.Fatalf("default max_chars=%d want=%d", got, DefaultSkillsMaxChars)
+	}
+	if cfg.Tools.IsEnabled() {
+		t.Fatal("expected tools disabled by default (nil pointer)")
+	}
+}
+
+func TestSkillsMaxCharsZeroMeansUnlimited(t *testing.T) {
+	var cfg Config
+	if err := json.Unmarshal([]byte(`{"skills":{"max_chars":0}}`), &cfg); err != nil {
+		t.Fatalf("unmarshal config: %v", err)
+	}
+	if cfg.Skills.MaxChars == nil {
+		t.Fatal("expected explicit max_chars to be kept as pointer")
+	}
+	if got := cfg.Skills.EffectiveMaxChars(); got != 0 {
+		t.Fatalf("explicit max_chars=0 should stay unlimited, got %d", got)
+	}
+
+	if err := json.Unmarshal([]byte(`{"skills":{"max_chars":-1}}`), &cfg); err != nil {
+		t.Fatalf("unmarshal config: %v", err)
+	}
+	if got := cfg.Skills.EffectiveMaxChars(); got != -1 {
+		t.Fatalf("negative max_chars should mean unlimited, got %d", got)
+	}
+}
+
+func TestConfigCloneDeepCopiesSkillsAndTools(t *testing.T) {
+	enabled := true
+	maxChars := 100
+	cfg := Config{
+		Skills: SkillsConfig{
+			Enabled:  &enabled,
+			MaxChars: &maxChars,
+			Items:    []SkillConfig{{ID: "a", Body: "body a"}},
+		},
+		Tools: ToolsConfig{Enabled: &enabled},
+	}
+	clone := cfg.Clone()
+	*clone.Skills.Enabled = false
+	*clone.Skills.MaxChars = 1
+	clone.Skills.Items[0].Body = "changed"
+	*clone.Tools.Enabled = false
+
+	if !enabled || maxChars != 100 {
+		t.Fatal("expected clone to own copies of skills pointers")
+	}
+	if cfg.Skills.Items[0].Body != "body a" {
+		t.Fatal("expected clone to own a copy of skills items")
+	}
+	if cfg.Tools.Enabled == nil || !*cfg.Tools.Enabled {
+		t.Fatal("expected clone to own a copy of tools flag")
+	}
+}
+
+func TestConfigCloneDeepCopiesAPIKeySkills(t *testing.T) {
+	customEnabled := true
+	cfg := Config{APIKeys: []APIKey{{
+		Key:    "sk-custom",
+		Skills: &APIKeySkillsConfig{Custom: true, Enabled: &customEnabled, IDs: []string{"a"}},
+	}}}
+	clone := cfg.Clone()
+	*clone.APIKeys[0].Skills.Enabled = false
+	clone.APIKeys[0].Skills.IDs[0] = "b"
+
+	if !customEnabled {
+		t.Fatal("expected clone to own a copy of per-key skills switch")
+	}
+	if got := cfg.APIKeys[0].Skills.IDs[0]; got != "a" {
+		t.Fatalf("expected clone to own a copy of per-key ids, got %q", got)
+	}
+}
+
+func TestNormalizeCredentialsKeepsAPIKeySkills(t *testing.T) {
+	customEnabled := true
+	cfg := Config{APIKeys: []APIKey{{
+		Key:    "sk-custom",
+		Skills: &APIKeySkillsConfig{Custom: true, Enabled: &customEnabled, IDs: []string{" a ", "a", ""}},
+	}}}
+	cfg.NormalizeCredentials()
+	if len(cfg.APIKeys) != 1 || cfg.APIKeys[0].Skills == nil {
+		t.Fatalf("expected per-key skills to survive normalization, got %#v", cfg.APIKeys)
+	}
+	skills := cfg.APIKeys[0].Skills
+	if len(skills.IDs) != 1 || skills.IDs[0] != "a" {
+		t.Fatalf("expected trimmed deduped ids, got %#v", skills.IDs)
+	}
+}
+
+func TestValidateSkillsConfig(t *testing.T) {
+	valid := SkillsConfig{Items: []SkillConfig{
+		{ID: "sql-report", Name: "SQL 报表", Body: "# 说明"},
+		{ID: "review_v2", Body: "评审要点"},
+	}}
+	if err := ValidateSkillsConfig(valid); err != nil {
+		t.Fatalf("expected valid config, got %v", err)
+	}
+
+	cases := []struct {
+		name string
+		cfg  SkillsConfig
+		want string
+	}{
+		{
+			name: "duplicate id",
+			cfg:  SkillsConfig{Items: []SkillConfig{{ID: "a", Body: "x"}, {ID: "a", Body: "y"}}},
+			want: "duplicate skill id",
+		},
+		{
+			name: "invalid id charset",
+			cfg:  SkillsConfig{Items: []SkillConfig{{ID: "SQL Report", Body: "x"}}},
+			want: "[a-z0-9_-]",
+		},
+		{
+			name: "empty id",
+			cfg:  SkillsConfig{Items: []SkillConfig{{ID: "  ", Body: "x"}}},
+			want: "id cannot be empty",
+		},
+		{
+			name: "empty body",
+			cfg:  SkillsConfig{Items: []SkillConfig{{ID: "a", Body: "  "}}},
+			want: "body cannot be empty",
+		},
+		{
+			name: "too many items",
+			cfg:  SkillsConfig{Items: tooManySkills(MaxSkillItems + 1)},
+			want: "cannot exceed",
+		},
+		{
+			name: "body too long",
+			cfg:  SkillsConfig{Items: []SkillConfig{{ID: "a", Body: strings.Repeat("字", MaxSkillBodyChars+1)}}},
+			want: "body cannot exceed",
+		},
+		{
+			name: "total body too long",
+			cfg: SkillsConfig{Items: []SkillConfig{
+				{ID: "a", Body: strings.Repeat("字", MaxSkillBodyChars)},
+				{ID: "b", Body: strings.Repeat("字", MaxSkillBodyChars)},
+				{ID: "c", Body: strings.Repeat("字", MaxSkillBodyChars)},
+				{ID: "d", Body: strings.Repeat("字", MaxSkillBodyChars)},
+				{ID: "e", Body: strings.Repeat("字", MaxSkillBodyChars)},
+				{ID: "f", Body: strings.Repeat("字", 1)},
+			}},
+			want: "total body cannot exceed",
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			err := ValidateSkillsConfig(tc.cfg)
+			if err == nil {
+				t.Fatalf("expected error for %s", tc.name)
+			}
+			if !strings.Contains(err.Error(), tc.want) {
+				t.Fatalf("error %q does not mention %q", err.Error(), tc.want)
+			}
+		})
+	}
+}
+
+func tooManySkills(n int) []SkillConfig {
+	items := make([]SkillConfig, 0, n)
+	for i := 0; i < n; i++ {
+		items = append(items, SkillConfig{ID: skillIDForIndex(i), Body: "x"})
+	}
+	return items
+}
+
+func skillIDForIndex(i int) string {
+	letters := "abcdefghijklmnopqrstuvwxyz"
+	return string(letters[i%len(letters)]) + string(letters[(i/len(letters))%len(letters)])
+}

internal/config/store_accessors.go

@@ -178,7 +178,7 @@ func (s *Store) ThinkingInjectionEnabled() bool {
 	s.mu.RLock()
 	defer s.mu.RUnlock()
 	if s.cfg.ThinkingInjection.Enabled == nil {
-		return false
+		return true
 	}
 	return *s.cfg.ThinkingInjection.Enabled
 }
@@ -189,6 +189,199 @@ func (s *Store) ThinkingInjectionPrompt() string {
 	return strings.TrimSpace(s.cfg.ThinkingInjection.Prompt)
 }
 
+// ThinkingInjectionSettings 是「思考格式注入」对单次请求生效的设置。
+// Prompt 为空表示调用方应回退到内置默认提示词。
+type ThinkingInjectionSettings struct {
+	Enabled bool   `json:"enabled"`
+	Prompt  string `json:"prompt,omitempty"`
+}
+
+// ResolveThinkingInjection 解析指定 API Key 最终生效的注入设置：
+// 先取全局开关与提示词，再由该 Key 的自定义设置（Custom=true）覆盖。
+// 未命中 Key（例如直接传 DeepSeek token）时完全跟随全局。
+func (s *Store) ResolveThinkingInjection(key string) ThinkingInjectionSettings {
+	if s == nil {
+		return ThinkingInjectionSettings{}
+	}
+	settings := ThinkingInjectionSettings{
+		Enabled: s.ThinkingInjectionEnabled(),
+		Prompt:  s.ThinkingInjectionPrompt(),
+	}
+	item, ok := s.FindAPIKey(key)
+	if !ok || item.ThinkingInjection == nil || !item.ThinkingInjection.Custom {
+		return settings
+	}
+	if item.ThinkingInjection.Enabled != nil {
+		settings.Enabled = *item.ThinkingInjection.Enabled
+	}
+	if custom := strings.TrimSpace(item.ThinkingInjection.Prompt); custom != "" {
+		settings.Prompt = custom
+	}
+	return settings
+}
+
+// SkillsEnabled 返回「纯文本技能库」全局开关；未配置按 false 处理（默认不注入）。
+func (s *Store) SkillsEnabled() bool {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.cfg.Skills.IsEnabled()
+}
+
+// SkillsMaxChars 返回生效的单次注入字符上限。
+// 未配置为 DefaultSkillsMaxChars；显式 0 或负数表示不限制。
+func (s *Store) SkillsMaxChars() int {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.cfg.Skills.EffectiveMaxChars()
+}
+
+// SkillsItems 返回全局技能条目副本。是否注入仍由 SkillsEnabled 决定。
+func (s *Store) SkillsItems() []SkillConfig {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	if len(s.cfg.Skills.Items) == 0 {
+		return nil
+	}
+	out := make([]SkillConfig, len(s.cfg.Skills.Items))
+	copy(out, s.cfg.Skills.Items)
+	return out
+}
+
+// ToolsEnabled 返回「工具调用」总开关；未配置（nil）按 false 处理。
+func (s *Store) ToolsEnabled() bool {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.cfg.Tools.IsEnabled()
+}
+
+// SkillSettings 是「纯文本技能库」对单次请求生效的设置。
+// Items 已按单 Key 覆盖完成过滤，长度截断由注入层（promptcompat）负责。
+type SkillSettings struct {
+	Enabled  bool
+	MaxChars int
+	Items    []SkillConfig
+}
+
+// ResolveSkills 解析指定 API Key 最终生效的技能设置：
+//   - 全局 skills.enabled=false → 任何 Key 都不注入；
+//   - 该 Key 未配置 skills 或 Custom=false → 使用全部全局技能；
+//   - Custom=true 且 Enabled=false → 该 Key 不注入；
+//   - Custom=true 且 IDs 非空 → 只注入命中的技能；
+//   - Custom=true 且 IDs 为空 → 该 Key 不注入。
+//
+// 未命中 Key（例如直接传 DeepSeek token）时完全跟随全局。
+func (s *Store) ResolveSkills(key string) SkillSettings {
+	if s == nil {
+		return SkillSettings{}
+	}
+	s.mu.RLock()
+	global := s.cfg.Skills.Clone()
+	override := s.findAPIKeySkillsLocked(key)
+	s.mu.RUnlock()
+
+	settings := SkillSettings{MaxChars: global.EffectiveMaxChars()}
+	if !global.IsEnabled() {
+		return settings
+	}
+	if override == nil || !override.Custom {
+		settings.Enabled = true
+		settings.Items = global.Items
+		return settings
+	}
+	if override.Enabled != nil && !*override.Enabled {
+		return settings
+	}
+	if len(override.IDs) == 0 {
+		return settings
+	}
+	wanted := make(map[string]struct{}, len(override.IDs))
+	for _, id := range override.IDs {
+		wanted[id] = struct{}{}
+	}
+	items := make([]SkillConfig, 0, len(override.IDs))
+	for _, item := range global.Items {
+		if _, ok := wanted[item.ID]; !ok {
+			continue
+		}
+		items = append(items, item)
+	}
+	if len(items) == 0 {
+		return settings
+	}
+	settings.Enabled = true
+	settings.Items = items
+	return settings
+}
+
+// findAPIKeySkillsLocked 返回指定 Key 的技能覆盖设置副本；调用方需持有读锁。
+func (s *Store) findAPIKeySkillsLocked(key string) *APIKeySkillsConfig {
+	key = strings.TrimSpace(key)
+	if key == "" {
+		return nil
+	}
+	for _, item := range s.cfg.APIKeys {
+		if item.Key != key {
+			continue
+		}
+		return item.Skills.Clone()
+	}
+	return nil
+}
+
+// FindAPIKey 返回指定 Key 的配置副本（含该 Key 的自定义注入设置）。
+func (s *Store) FindAPIKey(key string) (APIKey, bool) {
+	if s == nil {
+		return APIKey{}, false
+	}
+	key = strings.TrimSpace(key)
+	if key == "" {
+		return APIKey{}, false
+	}
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	for _, item := range s.cfg.APIKeys {
+		if item.Key != key {
+			continue
+		}
+		return APIKey{
+			Key:               item.Key,
+			Name:              item.Name,
+			Remark:            item.Remark,
+			ThinkingInjection: item.ThinkingInjection.Clone(),
+			Skills:            item.Skills.Clone(),
+		}, true
+	}
+	return APIKey{}, false
+}
+
+// APIKeyLabel 返回用于日志展示的 Key 标签：优先名称，其次备注，
+// 都没有时退化成脱敏后的 Key 片段。未知 Key 返回空串。
+func (s *Store) APIKeyLabel(key string) string {
+	item, ok := s.FindAPIKey(key)
+	if !ok {
+		return ""
+	}
+	if name := strings.TrimSpace(item.Name); name != "" {
+		return name
+	}
+	if remark := strings.TrimSpace(item.Remark); remark != "" {
+		return remark
+	}
+	return MaskAPIKeyPreview(item.Key)
+}
+
+// MaskAPIKeyPreview 生成脱敏 Key 片段，避免把完整密钥写进响应记录。
+func MaskAPIKeyPreview(key string) string {
+	key = strings.TrimSpace(key)
+	if key == "" {
+		return ""
+	}
+	if len(key) <= 8 {
+		return "****"
+	}
+	return key[:4] + "****" + key[len(key)-4:]
+}
+
 func (s *Store) RuntimeBackupReleaseCount() int {
 	s.mu.RLock()
 	defer s.mu.RUnlock()

internal/config/store_accessors_test.go

@@ -44,3 +44,203 @@ func TestStoreThinkingInjectionAccessors(t *testing.T) {
 		t.Fatalf("thinking injection prompt=%q want custom thinking prompt", got)
 	}
 }
+
+func TestStoreResolveThinkingInjection(t *testing.T) {
+	store := &Store{cfg: Config{}}
+	settings := store.ResolveThinkingInjection("sk-default")
+	if !settings.Enabled {
+		t.Fatal("expected global thinking injection enabled by default")
+	}
+	if settings.Prompt != "" {
+		t.Fatalf("expected empty global prompt (caller falls back to built-in), got %q", settings.Prompt)
+	}
+
+	disabled := false
+	enabled := true
+	store.cfg.ThinkingInjection = ThinkingInjectionConfig{Prompt: "global prompt"}
+	store.cfg.APIKeys = []APIKey{
+		{Key: "sk-follow", Name: "follow"},
+		{
+			Key:               "sk-off",
+			ThinkingInjection: &APIKeyInjectionConfig{Custom: true, Enabled: &disabled},
+		},
+		{
+			Key:               "sk-on",
+			ThinkingInjection: &APIKeyInjectionConfig{Custom: true, Enabled: &enabled, Prompt: "  key prompt  "},
+		},
+		{
+			Key:               "sk-notcustom",
+			ThinkingInjection: &APIKeyInjectionConfig{Custom: false, Prompt: "ignored"},
+		},
+	}
+
+	if got := store.ResolveThinkingInjection("sk-follow"); !got.Enabled || got.Prompt != "global prompt" {
+		t.Fatalf("expected follow-global settings, got %#v", got)
+	}
+	if got := store.ResolveThinkingInjection("sk-notcustom"); !got.Enabled || got.Prompt != "global prompt" {
+		t.Fatalf("expected custom=false to follow global, got %#v", got)
+	}
+	if got := store.ResolveThinkingInjection("sk-off"); got.Enabled {
+		t.Fatalf("expected per-key disable, got %#v", got)
+	}
+	if got := store.ResolveThinkingInjection("sk-on"); !got.Enabled || got.Prompt != "key prompt" {
+		t.Fatalf("expected per-key prompt, got %#v", got)
+	}
+	if got := store.ResolveThinkingInjection("sk-unknown"); !got.Enabled || got.Prompt != "global prompt" {
+		t.Fatalf("expected unknown key to follow global, got %#v", got)
+	}
+}
+
+func TestStoreAPIKeyLabel(t *testing.T) {
+	store := &Store{cfg: Config{APIKeys: []APIKey{
+		{Key: "sk-named", Name: "主账号"},
+		{Key: "sk-remark", Remark: "测试用"},
+		{Key: "sk-0123456789abcdef"},
+	}}}
+	if got := store.APIKeyLabel("sk-named"); got != "主账号" {
+		t.Fatalf("expected name label, got %q", got)
+	}
+	if got := store.APIKeyLabel("sk-remark"); got != "测试用" {
+		t.Fatalf("expected remark label, got %q", got)
+	}
+	if got := store.APIKeyLabel("sk-0123456789abcdef"); got != "sk-0****cdef" {
+		t.Fatalf("expected masked label, got %q", got)
+	}
+	if got := store.APIKeyLabel("sk-missing"); got != "" {
+		t.Fatalf("expected empty label for unknown key, got %q", got)
+	}
+}
+
+func TestStoreToolsEnabled(t *testing.T) {
+	store := &Store{cfg: Config{}}
+	if store.ToolsEnabled() {
+		t.Fatal("expected tools disabled by default (nil pointer)")
+	}
+
+	enabled := true
+	store.cfg.Tools = ToolsConfig{Enabled: &enabled}
+	if !store.ToolsEnabled() {
+		t.Fatal("expected tools enabled by explicit config")
+	}
+
+	disabled := false
+	store.cfg.Tools.Enabled = &disabled
+	if store.ToolsEnabled() {
+		t.Fatal("expected tools disabled by explicit config")
+	}
+}
+
+func TestStoreSkillsAccessors(t *testing.T) {
+	store := &Store{cfg: Config{}}
+	if store.SkillsEnabled() {
+		t.Fatal("expected skills disabled by default")
+	}
+	if got := store.SkillsMaxChars(); got != DefaultSkillsMaxChars {
+		t.Fatalf("default skills max_chars=%d want=%d", got, DefaultSkillsMaxChars)
+	}
+	if got := store.SkillsItems(); got != nil {
+		t.Fatalf("expected no skills items by default, got %#v", got)
+	}
+
+	enabled := true
+	zero := 0
+	store.cfg.Skills = SkillsConfig{
+		Enabled:  &enabled,
+		MaxChars: &zero,
+		Items:    []SkillConfig{{ID: "a", Body: "body a"}},
+	}
+	if !store.SkillsEnabled() {
+		t.Fatal("expected skills enabled")
+	}
+	if got := store.SkillsMaxChars(); got != 0 {
+		t.Fatalf("explicit max_chars=0 should stay unlimited, got %d", got)
+	}
+	items := store.SkillsItems()
+	if len(items) != 1 || items[0].ID != "a" {
+		t.Fatalf("unexpected skills items: %#v", items)
+	}
+	items[0].Body = "mutated"
+	if store.SkillsItems()[0].Body != "body a" {
+		t.Fatal("expected SkillsItems to return a copy")
+	}
+}
+
+// TestStoreResolveSkillsKeyOverrides 覆盖「全局开关 + 单 Key 覆盖」的全部组合语义。
+func TestStoreResolveSkillsKeyOverrides(t *testing.T) {
+	enabled := true
+	disabled := false
+	store := &Store{cfg: Config{}}
+	store.cfg.Skills = SkillsConfig{
+		Enabled:  &enabled,
+		MaxChars: nil,
+		Items: []SkillConfig{
+			{ID: "sql-report", Name: "SQL 报表", Body: "sql body"},
+			{ID: "review", Name: "评审", Body: "review body"},
+		},
+	}
+	store.cfg.APIKeys = []APIKey{
+		{Key: "sk-global"},
+		{Key: "sk-notcustom", Skills: &APIKeySkillsConfig{Custom: false, IDs: []string{"sql-report"}}},
+		{Key: "sk-off", Skills: &APIKeySkillsConfig{Custom: true, Enabled: &disabled}},
+		{Key: "sk-follow", Skills: &APIKeySkillsConfig{Custom: true, Enabled: &enabled}},
+		{Key: "sk-pick", Skills: &APIKeySkillsConfig{Custom: true, Enabled: &enabled, IDs: []string{"review"}}},
+		{Key: "sk-empty-ids", Skills: &APIKeySkillsConfig{Custom: true, Enabled: &enabled}},
+		{Key: "sk-unknown-ids", Skills: &APIKeySkillsConfig{Custom: true, IDs: []string{"nope"}}},
+	}
+
+	cases := []struct {
+		key     string
+		enabled bool
+		ids     []string
+	}{
+		{key: "sk-global", enabled: true, ids: []string{"sql-report", "review"}},
+		{key: "sk-notcustom", enabled: true, ids: []string{"sql-report", "review"}},
+		// Custom=true 但 IDs 为空按规格视为「不注入」。
+		{key: "sk-follow", enabled: false, ids: nil},
+		{key: "sk-off", enabled: false, ids: nil},
+		{key: "sk-pick", enabled: true, ids: []string{"review"}},
+		{key: "sk-empty-ids", enabled: false, ids: nil},
+		{key: "sk-unknown-ids", enabled: false, ids: nil},
+		{key: "sk-not-configured", enabled: true, ids: []string{"sql-report", "review"}},
+	}
+	for _, tc := range cases {
+		t.Run(tc.key, func(t *testing.T) {
+			settings := store.ResolveSkills(tc.key)
+			if settings.Enabled != tc.enabled {
+				t.Fatalf("enabled=%v want=%v", settings.Enabled, tc.enabled)
+			}
+			if got := len(settings.Items); got != len(tc.ids) {
+				t.Fatalf("items=%#v want ids=%#v", settings.Items, tc.ids)
+			}
+			for i, id := range tc.ids {
+				if settings.Items[i].ID != id {
+					t.Fatalf("items=%#v want ids=%#v", settings.Items, tc.ids)
+				}
+			}
+			if settings.MaxChars != DefaultSkillsMaxChars {
+				t.Fatalf("max_chars=%d want default %d", settings.MaxChars, DefaultSkillsMaxChars)
+			}
+		})
+	}
+}
+
+// TestStoreResolveSkillsGlobalDisabledWins 验证总开关关闭时任何 Key 都不注入。
+func TestStoreResolveSkillsGlobalDisabledWins(t *testing.T) {
+	disabled := false
+	enabled := true
+	store := &Store{cfg: Config{}}
+	store.cfg.Skills = SkillsConfig{
+		Enabled:  &disabled,
+		MaxChars: nil,
+		Items:    []SkillConfig{{ID: "sql-report", Body: "sql body"}},
+	}
+	store.cfg.APIKeys = []APIKey{
+		{Key: "sk-on", Skills: &APIKeySkillsConfig{Custom: true, Enabled: &enabled, IDs: []string{"sql-report"}}},
+	}
+	for _, key := range []string{"sk-on", "sk-global", "sk-unknown"} {
+		settings := store.ResolveSkills(key)
+		if settings.Enabled || len(settings.Items) > 0 {
+			t.Fatalf("expected no skills for key %q when global switch is off, got %#v", key, settings)
+		}
+	}
+}

internal/deepseek/client/client_core.go

@@ -47,12 +47,16 @@ func NewClient(store *config.Store, resolver *auth.Resolver) *Client {
 		platform = store.PlatformMode()
 	}
 	dsprotocol.ApplyPlatform(platform)
-	snap := store.Snapshot()
-	dsprotocol.ApplyVersionOverrides(
-		snap.Platform.AndroidVersion,
-		snap.Platform.WebVersion,
-		snap.Platform.AndroidAPILevel,
-	)
+	// Store 允许为空（纯直通构造 / 单元测试里没有配置存储）：
+	// 没有存储时跳过版本覆盖，沿用 protocol 包的默认值。
+	if store != nil {
+		snap := store.Snapshot()
+		dsprotocol.ApplyVersionOverrides(
+			snap.Platform.AndroidVersion,
+			snap.Platform.WebVersion,
+			snap.Platform.AndroidAPILevel,
+		)
+	}
 	c.regular = trans.NewWithPlatform(60*time.Second, platform)
 	c.stream = trans.NewWithPlatform(0, platform)
 	c.fallback = trans.NewFallbackClientWithPlatform(60*time.Second, nil, platform)

internal/deepseek/client/client_upload_test.go

@@ -3,14 +3,18 @@ package client
 import (
 	"context"
 	dsprotocol "ds2api/internal/deepseek/protocol"
+	"encoding/hex"
 	"errors"
+	"fmt"
 	"io"
 	"net/http"
+	"strconv"
 	"strings"
 	"testing"
 	"time"
 
 	"ds2api/internal/auth"
+	"ds2api/pow"
 )
 
 func TestBuildUploadMultipartBodyOmitsPurposeAndIncludesFilePart(t *testing.T) {
@@ -96,9 +100,25 @@ func TestExtractUploadFileResultSupportsNestedShapes(t *testing.T) {
 	}
 }
 
-// powChallengeResponse 是 create_pow_challenge 的最小可用响应：
-// challenge 为 64 位 hex，difficulty=1 让 ComputePow 能立即求解。
-const powChallengeResponse = `{"code":0,"msg":"ok","data":{"biz_code":0,"biz_data":{"challenge":{"algorithm":"DeepSeekHashV1","challenge":"0000000000000000000000000000000000000000000000000000000000000000","salt":"salt","difficulty":1,"expire_at":9999999999,"signature":"sig","target_path":"/api/v0/file/upload_file"}}}}`
+// powChallengeResponse 构造 create_pow_challenge 的最小可用响应。
+//
+// challenge 必须是 DeepSeekHashV1(salt_expireAt_nonce) 的 32 字节摘要：
+// SolvePow 在 [0, difficulty) 区间里搜 nonce，difficulty 是搜索上界而不是
+// 「目标难度」，因此随手写一串 0 永远解不出来（ComputePow 会返回
+// "pow: no solution within difficulty"，UploadFile 只会看到 "get pow failed"）。
+// 这里用 answer=0 / difficulty=1 现算摘要，保证求解立即命中又不额外消耗 CPU。
+func powChallengeResponse() string {
+	const (
+		salt     = "salt"
+		expireAt = int64(9999999999)
+		answer   = int64(0)
+	)
+	sum := pow.DeepSeekHashV1([]byte(pow.BuildPrefix(salt, expireAt) + strconv.FormatInt(answer, 10)))
+	return fmt.Sprintf(
+		`{"code":0,"msg":"ok","data":{"biz_code":0,"biz_data":{"challenge":{"algorithm":"DeepSeekHashV1","challenge":"%s","salt":"%s","difficulty":1,"expire_at":%d,"signature":"sig","target_path":"/api/v0/file/upload_file"}}}}`,
+		hex.EncodeToString(sum[:]), salt, expireAt,
+	)
+}
 
 func TestUploadFileUsesMultipartHeadersWithPow(t *testing.T) {
 	uploadResponse := `{"code":0,"msg":"ok","data":{"biz_code":0,"biz_data":{"file":{"file_id":"file_789","filename":"demo.txt","bytes":5,"status":"processed","purpose":"assistants","is_image":false}}}}`
@@ -113,7 +133,7 @@ func TestUploadFileUsesMultipartHeadersWithPow(t *testing.T) {
 			bodyBytes, _ := io.ReadAll(req.Body)
 			switch {
 			case strings.Contains(req.URL.Path, "create_pow_challenge"):
-				return &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(powChallengeResponse)), Request: req}, nil
+				return &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(powChallengeResponse())), Request: req}, nil
 			case strings.Contains(req.URL.Path, "upload_file"):
 				uploadCalled = true
 				seenPow = req.Header.Get("x-ds-pow-response")
@@ -174,7 +194,7 @@ func TestUploadFileDefaultsModelTypeToDefaultWhenAbsent(t *testing.T) {
 		regular: doerFunc(func(req *http.Request) (*http.Response, error) {
 			switch {
 			case strings.Contains(req.URL.Path, "create_pow_challenge"):
-				return &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(powChallengeResponse)), Request: req}, nil
+				return &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(powChallengeResponse())), Request: req}, nil
 			case strings.Contains(req.URL.Path, "upload_file"):
 				uploadCalled = true
 				seenModelType = req.Header.Get("x-model-type")
@@ -220,7 +240,7 @@ func TestUploadFileWaitsForProcessedFetchFiles(t *testing.T) {
 			call++
 			switch {
 			case strings.Contains(req.URL.Path, "create_pow_challenge"):
-				return &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(powChallengeResponse)), Request: req}, nil
+				return &http.Response{StatusCode: http.StatusOK, Header: make(http.Header), Body: io.NopCloser(strings.NewReader(powChallengeResponse())), Request: req}, nil
 			case strings.Contains(req.URL.Path, "upload_file"):
 				// upload 必须携带 PoW（HAR 实测 target_path=/api/v0/file/upload_file）。
 				if req.Header.Get("x-ds-pow-response") == "" {

internal/httpapi/admin/accounts/handler_accounts_testing_test.go

@@ -171,7 +171,9 @@ func (m *completionPayloadDSMock) GetSessionCountForToken(_ context.Context, _ s
 
 func (m *completionPayloadDSMock) SetPlatform(_ string) {}
 
-func TestTestAccount_MessageModeUsesExpertModelTypeForExpertModel(t *testing.T) {
+// 上游已把 v4-pro / v4-vision 合并进 v4-flash，发给上游的 model_type 只剩 default 一种。
+// 老模型名仍然可用（config.deprecatedModelAliases 负责归一），这里断言归一后的 model_type。
+func TestTestAccount_MessageModeUsesDefaultModelTypeForDeprecatedExpertAlias(t *testing.T) {
 	t.Setenv("DS2API_CONFIG_JSON", `{"accounts":[{"email":"batch@example.com","password":"pwd","token":"seed-token"}]}`)
 	store := config.LoadStore()
 	ds := &completionPayloadDSMock{}
@@ -186,15 +188,15 @@ func TestTestAccount_MessageModeUsesExpertModelTypeForExpertModel(t *testing.T)
 	if ok, _ := result["success"].(bool); !ok {
 		t.Fatalf("expected success=true, got %#v", result)
 	}
-	if got := ds.payload["model_type"]; got != "expert" {
-		t.Fatalf("expected model_type expert, got %#v", got)
+	if got := ds.payload["model_type"]; got != "default" {
+		t.Fatalf("expected model_type default (v4-pro 已并入 v4-flash), got %#v", got)
 	}
 	if got := ds.payload["chat_session_id"]; got != "session-id" {
 		t.Fatalf("unexpected chat_session_id: %#v", got)
 	}
 }
 
-func TestTestAccount_MessageModeUsesVisionModelTypeForVisionModel(t *testing.T) {
+func TestTestAccount_MessageModeUsesDefaultModelTypeForDeprecatedVisionAlias(t *testing.T) {
 	t.Setenv("DS2API_CONFIG_JSON", `{"accounts":[{"email":"batch@example.com","password":"pwd","token":"seed-token"}]}`)
 	store := config.LoadStore()
 	ds := &completionPayloadDSMock{}
@@ -209,7 +211,7 @@ func TestTestAccount_MessageModeUsesVisionModelTypeForVisionModel(t *testing.T)
 	if ok, _ := result["success"].(bool); !ok {
 		t.Fatalf("expected success=true, got %#v", result)
 	}
-	if got := ds.payload["model_type"]; got != "vision" {
-		t.Fatalf("expected model_type vision, got %#v", got)
+	if got := ds.payload["model_type"]; got != "default" {
+		t.Fatalf("expected model_type default (v4-vision 已并入 v4-flash), got %#v", got)
 	}
 }

internal/httpapi/admin/configmgmt/deps.go

@@ -24,6 +24,9 @@ func toAccount(m map[string]any) config.Account {
 	return adminshared.ToAccount(m)
 }
 func toAPIKeys(v any) ([]config.APIKey, bool) { return adminshared.ToAPIKeys(v) }
+func toAPIKeyInjection(v any) *config.APIKeyInjectionConfig {
+	return adminshared.ToAPIKeyInjection(v)
+}
 func mergeAPIKeysPreferStructured(existing, incoming []config.APIKey) ([]config.APIKey, int) {
 	return adminshared.MergeAPIKeysPreferStructured(existing, incoming)
 }

internal/httpapi/admin/configmgmt/handler_config_write.go

@@ -82,6 +82,7 @@ func (h *Handler) addKey(w http.ResponseWriter, r *http.Request) {
 	key = strings.TrimSpace(key)
 	name := fieldString(req, "name")
 	remark := fieldString(req, "remark")
+	injection := toAPIKeyInjection(req["thinking_injection"])
 	if key == "" {
 		writeJSON(w, http.StatusBadRequest, map[string]any{"detail": "Key 不能为空"})
 		return
@@ -92,7 +93,12 @@ func (h *Handler) addKey(w http.ResponseWriter, r *http.Request) {
 				return fmt.Errorf("key 已存在")
 			}
 		}
-		c.APIKeys = append(c.APIKeys, config.APIKey{Key: key, Name: name, Remark: remark})
+		c.APIKeys = append(c.APIKeys, config.APIKey{
+			Key:               key,
+			Name:              name,
+			Remark:            remark,
+			ThinkingInjection: injection,
+		})
 		return nil
 	})
 	if err != nil {
@@ -116,6 +122,7 @@ func (h *Handler) updateKey(w http.ResponseWriter, r *http.Request) {
 	}
 	name, nameOK := fieldStringOptional(req, "name")
 	remark, remarkOK := fieldStringOptional(req, "remark")
+	injectionRaw, injectionOK := req["thinking_injection"]
 
 	err := h.Store.Update(func(c *config.Config) error {
 		idx := -1
@@ -134,6 +141,10 @@ func (h *Handler) updateKey(w http.ResponseWriter, r *http.Request) {
 		if remarkOK {
 			c.APIKeys[idx].Remark = remark
 		}
+		if injectionOK {
+			// 显式传 null / 空对象表示清除自定义，回到跟随全局。
+			c.APIKeys[idx].ThinkingInjection = toAPIKeyInjection(injectionRaw)
+		}
 		return nil
 	})
 	if err != nil {

internal/httpapi/admin/configmgmt/handler_keys_test.go

@@ -74,3 +74,57 @@ func TestKeyEndpointsPreserveStructuredMetadata(t *testing.T) {
 		t.Fatalf("unexpected legacy keys after delete: %#v", snap.Keys)
 	}
 }
+
+func TestKeyEndpointsPersistThinkingInjectionOverride(t *testing.T) {
+	h := newAdminTestHandler(t, `{"api_keys":[{"key":"k1","name":"primary"}]}`)
+
+	r := chi.NewRouter()
+	r.Post("/admin/keys", h.addKey)
+	r.Put("/admin/keys/{key}", h.updateKey)
+
+	addBody := []byte(`{"key":"k2","thinking_injection":{"custom":true,"enabled":true,"prompt":"  custom prompt  "}}`)
+	addRec := httptest.NewRecorder()
+	r.ServeHTTP(addRec, httptest.NewRequest(http.MethodPost, "/admin/keys", bytes.NewReader(addBody)))
+	if addRec.Code != http.StatusOK {
+		t.Fatalf("add status=%d body=%s", addRec.Code, addRec.Body.String())
+	}
+	snap := h.Store.Snapshot()
+	if len(snap.APIKeys) != 2 {
+		t.Fatalf("unexpected api keys after add: %#v", snap.APIKeys)
+	}
+	injection := snap.APIKeys[1].ThinkingInjection
+	if injection == nil || !injection.Custom || injection.Enabled == nil || !*injection.Enabled || injection.Prompt != "custom prompt" {
+		t.Fatalf("unexpected injection after add: %#v", injection)
+	}
+	if snap.APIKeys[0].ThinkingInjection != nil {
+		t.Fatalf("expected existing key to stay without injection, got %#v", snap.APIKeys[0].ThinkingInjection)
+	}
+
+	// 只覆盖开关，提示词应保持原值。
+	updateBody := []byte(`{"thinking_injection":{"custom":true,"enabled":false}}`)
+	updateRec := httptest.NewRecorder()
+	r.ServeHTTP(updateRec, httptest.NewRequest(http.MethodPut, "/admin/keys/k2", bytes.NewReader(updateBody)))
+	if updateRec.Code != http.StatusOK {
+		t.Fatalf("update status=%d body=%s", updateRec.Code, updateRec.Body.String())
+	}
+	snap = h.Store.Snapshot()
+	injection = snap.APIKeys[1].ThinkingInjection
+	if injection == nil || injection.Enabled == nil || *injection.Enabled {
+		t.Fatalf("expected disabled injection after update: %#v", injection)
+	}
+
+	// 传 null 清除自定义，回到跟随全局。
+	clearBody := []byte(`{"thinking_injection":null}`)
+	clearRec := httptest.NewRecorder()
+	r.ServeHTTP(clearRec, httptest.NewRequest(http.MethodPut, "/admin/keys/k2", bytes.NewReader(clearBody)))
+	if clearRec.Code != http.StatusOK {
+		t.Fatalf("clear status=%d body=%s", clearRec.Code, clearRec.Body.String())
+	}
+	snap = h.Store.Snapshot()
+	if snap.APIKeys[1].ThinkingInjection != nil {
+		t.Fatalf("expected injection cleared, got %#v", snap.APIKeys[1].ThinkingInjection)
+	}
+	if snap.APIKeys[1].Name != "" {
+		t.Fatalf("expected name untouched by injection update, got %q", snap.APIKeys[1].Name)
+	}
+}

internal/httpapi/admin/handler.go

@@ -13,6 +13,7 @@ import (
 	adminrawsamples "ds2api/internal/httpapi/admin/rawsamples"
 	adminsettings "ds2api/internal/httpapi/admin/settings"
 	adminshared "ds2api/internal/httpapi/admin/shared"
+	adminskills "ds2api/internal/httpapi/admin/skills"
 	adminvercel "ds2api/internal/httpapi/admin/vercel"
 	adminversion "ds2api/internal/httpapi/admin/version"
 	"ds2api/internal/proxyhealth"
@@ -37,6 +38,7 @@ func RegisterRoutes(r chi.Router, h *Handler) {
 	rawSamplesHandler := &adminrawsamples.Handler{Store: deps.Store, Pool: deps.Pool, DS: deps.DS, OpenAI: deps.OpenAI, ChatHistory: deps.ChatHistory}
 	vercelHandler := &adminvercel.Handler{Store: deps.Store, Pool: deps.Pool, DS: deps.DS, OpenAI: deps.OpenAI, ChatHistory: deps.ChatHistory}
 	historyHandler := &adminhistory.Handler{Store: deps.Store, Pool: deps.Pool, DS: deps.DS, OpenAI: deps.OpenAI, ChatHistory: deps.ChatHistory}
+	skillsHandler := &adminskills.Handler{Store: deps.Store, Pool: deps.Pool, DS: deps.DS, OpenAI: deps.OpenAI, ChatHistory: deps.ChatHistory}
 	devCaptureHandler := &admindevcapture.Handler{Store: deps.Store, Pool: deps.Pool, DS: deps.DS, OpenAI: deps.OpenAI, ChatHistory: deps.ChatHistory}
 	versionHandler := &adminversion.Handler{Store: deps.Store, Pool: deps.Pool, DS: deps.DS, OpenAI: deps.OpenAI, ChatHistory: deps.ChatHistory}
 
@@ -46,6 +48,7 @@ func RegisterRoutes(r chi.Router, h *Handler) {
 		adminauth.RegisterProtectedRoutes(pr, authHandler)
 		adminconfig.RegisterRoutes(pr, configHandler)
 		adminsettings.RegisterRoutes(pr, settingsHandler)
+		adminskills.RegisterRoutes(pr, skillsHandler)
 		adminproxies.RegisterRoutes(pr, proxiesHandler)
 		adminaccounts.RegisterRoutes(pr, accountsHandler)
 		adminrawsamples.RegisterRoutes(pr, rawSamplesHandler)

internal/httpapi/admin/handler_settings_test.go

@@ -47,6 +47,98 @@ func TestGetSettingsIncludesTokenRefreshInterval(t *testing.T) {
 	}
 }
 
+func TestGetSettingsIncludesToolsDefaults(t *testing.T) {
+	h := newAdminTestHandler(t, `{"keys":["k1"]}`)
+	req := httptest.NewRequest(http.MethodGet, "/admin/settings", nil)
+	rec := httptest.NewRecorder()
+	h.getSettings(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
+	}
+	var body map[string]any
+	_ = json.Unmarshal(rec.Body.Bytes(), &body)
+	tools, ok := body["tools"].(map[string]any)
+	if !ok {
+		t.Fatalf("expected top-level tools section, body=%v", body)
+	}
+	if got := boolFrom(tools["enabled"]); got {
+		t.Fatalf("expected tools.enabled=false by default, body=%v", body)
+	}
+	if enabled, exists := tools["default_enabled"]; !exists || boolFrom(enabled) {
+		t.Fatalf("expected tools.default_enabled=false, body=%v", body)
+	}
+}
+
+func TestUpdateSettingsToolsEnabled(t *testing.T) {
+	h := newAdminTestHandler(t, `{"keys":["k1"]}`)
+	if h.Store.ToolsEnabled() {
+		t.Fatal("expected tools disabled before update")
+	}
+
+	payload := map[string]any{"tools": map[string]any{"enabled": true}}
+	b, _ := json.Marshal(payload)
+	req := httptest.NewRequest(http.MethodPut, "/admin/settings", bytes.NewReader(b))
+	rec := httptest.NewRecorder()
+	h.updateSettings(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
+	}
+	snap := h.Store.Snapshot()
+	if snap.Tools.Enabled == nil || !*snap.Tools.Enabled {
+		t.Fatalf("expected tools.enabled=true persisted, got %#v", snap.Tools)
+	}
+	if !h.Store.ToolsEnabled() {
+		t.Fatal("expected tools accessor to reflect enabled config")
+	}
+
+	// 关闭同样要能持久化。
+	payload = map[string]any{"tools": map[string]any{"enabled": false}}
+	b, _ = json.Marshal(payload)
+	req = httptest.NewRequest(http.MethodPut, "/admin/settings", bytes.NewReader(b))
+	rec = httptest.NewRecorder()
+	h.updateSettings(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
+	}
+	if h.Store.ToolsEnabled() {
+		t.Fatal("expected tools disabled after explicit false")
+	}
+}
+
+func TestUpdateSettingsWithoutToolsKeepsToolsConfig(t *testing.T) {
+	h := newAdminTestHandler(t, `{"keys":["k1"],"tools":{"enabled":true}}`)
+	if !h.Store.ToolsEnabled() {
+		t.Fatal("expected tools enabled from config")
+	}
+
+	payload := map[string]any{"responses": map[string]any{"store_ttl_seconds": 600}}
+	b, _ := json.Marshal(payload)
+	req := httptest.NewRequest(http.MethodPut, "/admin/settings", bytes.NewReader(b))
+	rec := httptest.NewRecorder()
+	h.updateSettings(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
+	}
+	if !h.Store.ToolsEnabled() {
+		t.Fatal("expected tools config untouched when the request omits the section")
+	}
+}
+
+func TestUpdateSettingsEmptyToolsSectionKeepsValue(t *testing.T) {
+	h := newAdminTestHandler(t, `{"keys":["k1"],"tools":{"enabled":true}}`)
+	payload := map[string]any{"tools": map[string]any{}}
+	b, _ := json.Marshal(payload)
+	req := httptest.NewRequest(http.MethodPut, "/admin/settings", bytes.NewReader(b))
+	rec := httptest.NewRecorder()
+	h.updateSettings(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
+	}
+	if !h.Store.ToolsEnabled() {
+		t.Fatal("expected empty tools section to keep the existing value")
+	}
+}
+
 func TestGetSettingsIncludesCurrentInputFileDefaults(t *testing.T) {
 	h := newAdminTestHandler(t, `{"keys":["k1"]}`)
 	req := httptest.NewRequest(http.MethodGet, "/admin/settings", nil)

internal/httpapi/admin/history/chat_history_filter.go

@@ -0,0 +1,229 @@
+package history
+
+import (
+	"fmt"
+	"net/http"
+	"sort"
+	"strconv"
+	"strings"
+
+	"ds2api/internal/auth"
+	"ds2api/internal/chathistory"
+	"ds2api/internal/config"
+)
+
+// callerOption 是后台「按 API Key 筛选」下拉框里的一项。
+// Configured 为 true 表示该 Key 当前还登记在配置里；记录已被删除但配置仍在时
+// Count 为 0，便于运维区分「没用过」和「Key 已注销」。
+type callerOption struct {
+	CallerID   string `json:"caller_id"`
+	Label      string `json:"label"`
+	Configured bool   `json:"configured"`
+	Count      int    `json:"count"`
+}
+
+// chatHistoryFilter 是 /admin/chat-history 列表与导出接口共用的筛选/分页参数。
+// Offset 与 Limit 都为 0 时表示不分页；Limit<=0 表示不限制条数。
+type chatHistoryFilter struct {
+	Caller  string
+	Status  string
+	Surface string
+	Query   string
+	Offset  int
+	Limit   int
+}
+
+func parseChatHistoryFilter(r *http.Request) chatHistoryFilter {
+	if r == nil || r.URL == nil {
+		return chatHistoryFilter{}
+	}
+	q := r.URL.Query()
+	return chatHistoryFilter{
+		Caller:  strings.TrimSpace(q.Get("caller")),
+		Status:  strings.TrimSpace(q.Get("status")),
+		Surface: strings.TrimSpace(q.Get("surface")),
+		Query:   strings.TrimSpace(q.Get("q")),
+		Offset:  nonNegativeInt(q.Get("offset")),
+		Limit:   nonNegativeInt(q.Get("limit")),
+	}
+}
+
+// nonNegativeInt 解析非负整数查询参数；非法或负值一律按 0 处理。
+func nonNegativeInt(raw string) int {
+	raw = strings.TrimSpace(raw)
+	if raw == "" {
+		return 0
+	}
+	n, err := strconv.Atoi(raw)
+	if err != nil || n < 0 {
+		return 0
+	}
+	return n
+}
+
+// active 表示请求带了筛选或分页参数。这类响应内容随查询条件变化，
+// 不能再用「按 revision 生成」的列表 ETag，因此必须跳过 304 协商。
+func (f chatHistoryFilter) active() bool {
+	return f.Caller != "" || f.Status != "" || f.Surface != "" || f.Query != "" || f.Offset > 0 || f.Limit > 0
+}
+
+// describe 把筛选条件渲染成一行可读描述，供导出文件的元信息使用。
+func (f chatHistoryFilter) describe() string {
+	parts := make([]string, 0, 6)
+	if f.Caller != "" {
+		parts = append(parts, "caller="+f.Caller)
+	}
+	if f.Status != "" {
+		parts = append(parts, "status="+f.Status)
+	}
+	if f.Surface != "" {
+		parts = append(parts, "surface="+f.Surface)
+	}
+	if f.Query != "" {
+		parts = append(parts, "q="+f.Query)
+	}
+	if f.Offset > 0 {
+		parts = append(parts, fmt.Sprintf("offset=%d", f.Offset))
+	}
+	if f.Limit > 0 {
+		parts = append(parts, fmt.Sprintf("limit=%d", f.Limit))
+	}
+	return strings.Join(parts, ", ")
+}
+
+// filterChatHistory 按 caller/status/surface/q 过滤摘要列表，保持原有排序。
+func filterChatHistory(store *chathistory.Store, items []chathistory.SummaryEntry, f chatHistoryFilter) []chathistory.SummaryEntry {
+	out := make([]chathistory.SummaryEntry, 0, len(items))
+	needle := strings.ToLower(strings.TrimSpace(f.Query))
+	for _, item := range items {
+		if f.Caller != "" && item.CallerID != f.Caller {
+			continue
+		}
+		if f.Status != "" && !strings.EqualFold(item.Status, f.Status) {
+			continue
+		}
+		if f.Surface != "" && !strings.EqualFold(item.Surface, f.Surface) {
+			continue
+		}
+		if needle != "" && !chatHistoryMatchesText(store, item, needle) {
+			continue
+		}
+		out = append(out, item)
+	}
+	return out
+}
+
+// chatHistoryMatchesText 在 UserInput / Preview / Model / CallerLabel / Error 上做
+// 不区分大小写的包含匹配。Error 不在摘要里，需要回查内存中的完整条目。
+func chatHistoryMatchesText(store *chathistory.Store, item chathistory.SummaryEntry, needle string) bool {
+	for _, field := range []string{item.UserInput, item.Preview, item.Model, item.CallerLabel} {
+		if strings.Contains(strings.ToLower(field), needle) {
+			return true
+		}
+	}
+	if store == nil {
+		return false
+	}
+	entry, err := store.Get(item.ID)
+	if err != nil {
+		return false
+	}
+	return strings.Contains(strings.ToLower(entry.Error), needle)
+}
+
+// paginateChatHistory 对已过滤的结果应用 offset/limit；返回的切片永远非 nil。
+func paginateChatHistory(items []chathistory.SummaryEntry, f chatHistoryFilter) []chathistory.SummaryEntry {
+	start := f.Offset
+	if start < 0 {
+		start = 0
+	}
+	if start > len(items) {
+		start = len(items)
+	}
+	end := len(items)
+	if f.Limit > 0 && start+f.Limit < end {
+		end = start + f.Limit
+	}
+	page := make([]chathistory.SummaryEntry, end-start)
+	copy(page, items[start:end])
+	return page
+}
+
+// buildCallerOptions 汇总后台可筛选的 CallerID：
+// 记录里出现过的 CallerID + 配置里已登记但还没有记录的 API Key。
+// 排序为 count 倒序、label 升序，最后用 caller_id 兜底保证顺序稳定。
+func buildCallerOptions(items []chathistory.SummaryEntry, keys []config.APIKey) []callerOption {
+	options := make([]callerOption, 0, len(items)+len(keys))
+	index := make(map[string]int, len(items)+len(keys))
+	for _, item := range items {
+		callerID := strings.TrimSpace(item.CallerID)
+		if callerID == "" {
+			continue
+		}
+		if pos, ok := index[callerID]; ok {
+			options[pos].Count++
+			if options[pos].Label == "" {
+				options[pos].Label = strings.TrimSpace(item.CallerLabel)
+			}
+			continue
+		}
+		index[callerID] = len(options)
+		options = append(options, callerOption{
+			CallerID: callerID,
+			Label:    strings.TrimSpace(item.CallerLabel),
+			Count:    1,
+		})
+	}
+	for _, key := range keys {
+		if strings.TrimSpace(key.Key) == "" {
+			continue
+		}
+		callerID := auth.CallerTokenID(key.Key)
+		if callerID == "" {
+			continue
+		}
+		label := callerLabelFromConfig(key)
+		if pos, ok := index[callerID]; ok {
+			options[pos].Configured = true
+			if options[pos].Label == "" {
+				options[pos].Label = label
+			}
+			continue
+		}
+		index[callerID] = len(options)
+		options = append(options, callerOption{
+			CallerID:   callerID,
+			Label:      label,
+			Configured: true,
+		})
+	}
+	sort.Slice(options, func(i, j int) bool {
+		if options[i].Count != options[j].Count {
+			return options[i].Count > options[j].Count
+		}
+		if options[i].Label != options[j].Label {
+			return options[i].Label < options[j].Label
+		}
+		return options[i].CallerID < options[j].CallerID
+	})
+	return options
+}
+
+// callerLabelFromConfig 与 auth 包的标签规则保持一致：名称 → 备注 → 脱敏 Key。
+func callerLabelFromConfig(item config.APIKey) string {
+	if name := strings.TrimSpace(item.Name); name != "" {
+		return name
+	}
+	if remark := strings.TrimSpace(item.Remark); remark != "" {
+		return remark
+	}
+	return config.MaskAPIKeyPreview(item.Key)
+}
+
+// configAPIKeys 返回配置里登记的 API Key；配置不可用时返回 nil。
+func (h *Handler) configAPIKeys() []config.APIKey {
+	if h == nil || h.Store == nil {
+		return nil
+	}
+	return h.Store.Snapshot().APIKeys
+}

internal/httpapi/admin/history/handler_chat_history.go

@@ -16,8 +16,11 @@ func (h *Handler) getChatHistory(w http.ResponseWriter, r *http.Request) {
 		writeJSON(w, http.StatusServiceUnavailable, map[string]any{"detail": "chat history store is not configured"})
 		return
 	}
+	filter := parseChatHistoryFilter(r)
+	// 筛选/分页请求的响应内容随查询条件变化，不能复用按 revision 生成的 ETag。
+	useListETag := !filter.active()
 	ifNoneMatch := strings.TrimSpace(r.Header.Get("If-None-Match"))
-	if ifNoneMatch != "" {
+	if useListETag && ifNoneMatch != "" {
 		revision, err := store.Revision()
 		if err != nil {
 			writeJSON(w, http.StatusServiceUnavailable, map[string]any{
@@ -42,18 +45,23 @@ func (h *Handler) getChatHistory(w http.ResponseWriter, r *http.Request) {
 		})
 		return
 	}
-	etag := chathistory.ListETag(snapshot.Revision)
-	w.Header().Set("ETag", etag)
-	w.Header().Set("Cache-Control", "no-cache")
-	if ifNoneMatch == etag {
-		w.WriteHeader(http.StatusNotModified)
-		return
+	if !filter.active() {
+		etag := chathistory.ListETag(snapshot.Revision)
+		w.Header().Set("ETag", etag)
+		w.Header().Set("Cache-Control", "no-cache")
+		if ifNoneMatch == etag {
+			w.WriteHeader(http.StatusNotModified)
+			return
+		}
 	}
+	filtered := filterChatHistory(store, snapshot.Items, filter)
 	writeJSON(w, http.StatusOK, map[string]any{
 		"version":  snapshot.Version,
 		"limit":    snapshot.Limit,
 		"revision": snapshot.Revision,
-		"items":    snapshot.Items,
+		"items":    paginateChatHistory(filtered, filter),
+		"total":    len(filtered),
+		"callers":  buildCallerOptions(snapshot.Items, h.configAPIKeys()),
 		"path":     store.Path(),
 	})
 }

internal/httpapi/admin/history/handler_chat_history_export.go

@@ -0,0 +1,214 @@
+package history
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"ds2api/internal/chathistory"
+	"ds2api/internal/config"
+)
+
+const (
+	exportFormatJSON     = "json"
+	exportFormatMarkdown = "markdown"
+)
+
+// chatHistoryExportPayload 是导出 JSON 的顶层结构，字段顺序即落盘顺序。
+type chatHistoryExportPayload struct {
+	ExportedAt string                   `json:"exported_at"`
+	Count      int                      `json:"count"`
+	Filters    chatHistoryExportFilters `json:"filters"`
+	Items      []chathistory.Entry      `json:"items"`
+}
+
+// chatHistoryExportFilters 原样回显本次导出的筛选条件，便于复现同一份结果。
+type chatHistoryExportFilters struct {
+	Caller  string `json:"caller,omitempty"`
+	Status  string `json:"status,omitempty"`
+	Surface string `json:"surface,omitempty"`
+	Query   string `json:"q,omitempty"`
+	Offset  int    `json:"offset"`
+	Limit   int    `json:"limit"`
+}
+
+func exportFiltersFrom(f chatHistoryFilter) chatHistoryExportFilters {
+	return chatHistoryExportFilters{
+		Caller:  f.Caller,
+		Status:  f.Status,
+		Surface: f.Surface,
+		Query:   f.Query,
+		Offset:  f.Offset,
+		Limit:   f.Limit,
+	}
+}
+
+// exportChatHistory 以文件下载的形式导出完整响应记录（json 或 markdown）。
+func (h *Handler) exportChatHistory(w http.ResponseWriter, r *http.Request) {
+	store := h.ChatHistory
+	if store == nil {
+		writeJSON(w, http.StatusServiceUnavailable, map[string]any{"detail": "chat history store is not configured"})
+		return
+	}
+	format := strings.ToLower(strings.TrimSpace(r.URL.Query().Get("format")))
+	if format == "" {
+		format = exportFormatJSON
+	}
+	if format != exportFormatJSON && format != exportFormatMarkdown {
+		writeJSON(w, http.StatusBadRequest, map[string]any{"detail": "unsupported export format: " + format})
+		return
+	}
+
+	filter := parseChatHistoryFilter(r)
+	snapshot, err := store.Snapshot()
+	if err != nil {
+		writeJSON(w, http.StatusServiceUnavailable, map[string]any{
+			"detail": err.Error(),
+			"path":   store.Path(),
+		})
+		return
+	}
+	summaries := paginateChatHistory(filterChatHistory(store, snapshot.Items, filter), filter)
+	entries := make([]chathistory.Entry, 0, len(summaries))
+	for _, item := range summaries {
+		entry, err := store.Get(item.ID)
+		if err != nil {
+			// 列表与明细之间可能刚被删除；导出忽略取不到的条目。
+			continue
+		}
+		entries = append(entries, entry)
+	}
+
+	now := time.Now()
+	ext := ".json"
+	contentType := "application/json"
+	var body []byte
+	switch format {
+	case exportFormatMarkdown:
+		ext = ".md"
+		contentType = "text/markdown; charset=utf-8"
+		body = []byte(renderChatHistoryMarkdown(now, filter, entries))
+	default:
+		payload, err := json.MarshalIndent(chatHistoryExportPayload{
+			ExportedAt: now.Format(time.RFC3339),
+			Count:      len(entries),
+			Filters:    exportFiltersFrom(filter),
+			Items:      entries,
+		}, "", "  ")
+		if err != nil {
+			writeJSON(w, http.StatusInternalServerError, map[string]any{
+				"detail": "encode chat history export: " + err.Error(),
+			})
+			return
+		}
+		body = append(payload, '\n')
+	}
+
+	w.Header().Set("Content-Type", contentType)
+	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q",
+		"ds2api-logs-"+now.Format("20060102-150405")+ext))
+	w.Header().Set("Cache-Control", "no-store")
+	w.WriteHeader(http.StatusOK)
+	if _, err := w.Write(body); err != nil {
+		config.Logger.Warn("[admin] chat history export write failed", "format", format, "error", err)
+	}
+}
+
+// renderChatHistoryMarkdown 把一批完整记录渲染成 markdown 报告。
+func renderChatHistoryMarkdown(exportedAt time.Time, filter chatHistoryFilter, entries []chathistory.Entry) string {
+	var b strings.Builder
+	b.WriteString("# ds2api 响应记录导出\n\n")
+	fmt.Fprintf(&b, "- 导出时间: %s\n", exportedAt.UTC().Format(time.RFC3339))
+	fmt.Fprintf(&b, "- 条数: %d\n", len(entries))
+	if summary := filter.describe(); summary != "" {
+		fmt.Fprintf(&b, "- 筛选条件: %s\n", summary)
+	}
+	b.WriteString("\n")
+	for i, entry := range entries {
+		writeMarkdownEntry(&b, i+1, entry)
+	}
+	return b.String()
+}
+
+func writeMarkdownEntry(b *strings.Builder, index int, entry chathistory.Entry) {
+	fmt.Fprintf(b, "## %d. %s\n\n", index, entry.ID)
+	writeMarkdownMeta(b, entry)
+	writeMarkdownSection(b, "UserInput", entry.UserInput)
+	writeMarkdownSection(b, "FinalPrompt", entry.FinalPrompt)
+	writeMarkdownSection(b, "ReasoningContent", entry.ReasoningContent)
+	writeMarkdownSection(b, "Content", entry.Content)
+	writeMarkdownSection(b, "Error", entry.Error)
+}
+
+func writeMarkdownMeta(b *strings.Builder, entry chathistory.Entry) {
+	status := strings.TrimSpace(entry.Status)
+	if entry.StatusCode != 0 {
+		status = fmt.Sprintf("%s (%d)", status, entry.StatusCode)
+	}
+	fmt.Fprintf(b, "- 时间: %s\n", formatArchiveTimestamp(entry.CreatedAt))
+	fmt.Fprintf(b, "- 接口: %s\n", markdownOrDash(entry.Surface))
+	fmt.Fprintf(b, "- 模型: %s\n", markdownOrDash(entry.Model))
+	fmt.Fprintf(b, "- 账号: %s\n", markdownOrDash(entry.AccountID))
+	fmt.Fprintf(b, "- CallerLabel: %s\n", describeCaller(entry))
+	fmt.Fprintf(b, "- 状态: %s\n", markdownOrDash(status))
+	if entry.ElapsedMs > 0 {
+		fmt.Fprintf(b, "- 耗时: %dms\n", entry.ElapsedMs)
+	}
+	if entry.Stream {
+		b.WriteString("- 流式: 是\n")
+	}
+	if finishReason := strings.TrimSpace(entry.FinishReason); finishReason != "" {
+		fmt.Fprintf(b, "- 结束原因: %s\n", finishReason)
+	}
+	b.WriteString("\n")
+}
+
+// writeMarkdownSection 用代码块包裹长文本，空内容直接跳过避免噪声。
+func writeMarkdownSection(b *strings.Builder, title, body string) {
+	body = strings.TrimSpace(body)
+	if body == "" {
+		return
+	}
+	fence := markdownFence(body)
+	fmt.Fprintf(b, "### %s\n\n%stext\n%s\n%s\n\n", title, fence, body, fence)
+}
+
+// markdownFence 在正文自身包含反引号围栏时自动加长围栏，避免提前闭合代码块。
+func markdownFence(body string) string {
+	fence := "```"
+	for strings.Contains(body, fence) {
+		fence += "`"
+	}
+	return fence
+}
+
+func describeCaller(entry chathistory.Entry) string {
+	callerID := strings.TrimSpace(entry.CallerID)
+	label := strings.TrimSpace(entry.CallerLabel)
+	switch {
+	case label == "" && callerID == "":
+		return "-"
+	case label == "":
+		return callerID
+	case callerID == "":
+		return label
+	default:
+		return label + " (" + callerID + ")"
+	}
+}
+
+func formatArchiveTimestamp(ms int64) string {
+	if ms <= 0 {
+		return "-"
+	}
+	return time.UnixMilli(ms).UTC().Format(time.RFC3339)
+}
+
+func markdownOrDash(value string) string {
+	if value = strings.TrimSpace(value); value == "" {
+		return "-"
+	}
+	return value
+}

internal/httpapi/admin/history/handler_chat_history_filters_test.go

@@ -0,0 +1,440 @@
+package history
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/go-chi/chi/v5"
+
+	"ds2api/internal/auth"
+	"ds2api/internal/chathistory"
+	"ds2api/internal/config"
+)
+
+const (
+	testKeyConfigured   = "sk-live-aaaa1111"
+	testKeyUnused       = "sk-unused-9999"
+	testCallerExternal  = "caller:external"
+	testSurfaceOpenAI   = "openai.chat_completions"
+	testSurfaceClaude   = "claude.messages"
+	testConfiguredLabel = "生产 Key"
+)
+
+// callerIDConfigured 是已登记 Key 对应的真实 CallerID（与鉴权层算法一致）。
+var callerIDConfigured = auth.CallerTokenID(testKeyConfigured)
+
+// seedHistoryEntry 创建一条记录并把它推进到终态。
+func seedHistoryEntry(t *testing.T, store *chathistory.Store, start chathistory.StartParams, update chathistory.UpdateParams) chathistory.Entry {
+	t.Helper()
+	entry, err := store.Start(start)
+	if err != nil {
+		t.Fatalf("start history failed: %v", err)
+	}
+	if _, err := store.Update(entry.ID, update); err != nil {
+		t.Fatalf("update history failed: %v", err)
+	}
+	return entry
+}
+
+func historyRouter(h *Handler) chi.Router {
+	r := chi.NewRouter()
+	RegisterRoutes(r, h)
+	return r
+}
+
+func getHistoryJSON(t *testing.T, r chi.Router, target string, headers map[string]string) (int, map[string]any, http.Header) {
+	t.Helper()
+	req := httptest.NewRequest(http.MethodGet, target, nil)
+	req.Header.Set("Authorization", "Bearer admin")
+	for key, value := range headers {
+		req.Header.Set(key, value)
+	}
+	rec := httptest.NewRecorder()
+	r.ServeHTTP(rec, req)
+	payload := map[string]any{}
+	if rec.Code == http.StatusOK {
+		if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
+			t.Fatalf("decode payload failed: %v body=%s", err, rec.Body.String())
+		}
+	}
+	return rec.Code, payload, rec.Header()
+}
+
+func payloadItems(t *testing.T, payload map[string]any) []any {
+	t.Helper()
+	items, ok := payload["items"].([]any)
+	if !ok {
+		t.Fatalf("expected items array, got %#v", payload["items"])
+	}
+	return items
+}
+
+func TestChatHistoryListFiltersAndCallers(t *testing.T) {
+	h, store := newChatHistoryAdminHarnessWithConfig(t, `{
+		"keys":["`+testKeyConfigured+`","`+testKeyUnused+`"],
+		"api_keys":[
+			{"key":"`+testKeyConfigured+`","name":"`+testConfiguredLabel+`","remark":"prod"},
+			{"key":"`+testKeyUnused+`"}
+		],
+		"accounts":[]
+	}`)
+
+	seedHistoryEntry(t, store,
+		chathistory.StartParams{
+			CallerID:    callerIDConfigured,
+			CallerLabel: testConfiguredLabel,
+			Surface:     testSurfaceOpenAI,
+			Model:       "deepseek-v4-flash",
+			UserInput:   "hello world",
+		},
+		chathistory.UpdateParams{Status: "success", Content: "answer one", Completed: true},
+	)
+	seedHistoryEntry(t, store,
+		chathistory.StartParams{
+			CallerID:  testCallerExternal,
+			Surface:   testSurfaceClaude,
+			Model:     "deepseek-v4-pro",
+			UserInput: "second prompt",
+		},
+		chathistory.UpdateParams{
+			Status:    "error",
+			Content:   "device offline",
+			Error:     "boom upstream",
+			Completed: true,
+		},
+	)
+	seedHistoryEntry(t, store,
+		chathistory.StartParams{
+			CallerID:    callerIDConfigured,
+			CallerLabel: testConfiguredLabel,
+			Surface:     testSurfaceOpenAI,
+			Model:       "deepseek-v4-flash",
+			UserInput:   "third prompt",
+		},
+		chathistory.UpdateParams{Status: "success", Content: "answer three", Completed: true},
+	)
+
+	r := historyRouter(h)
+
+	code, payload, header := getHistoryJSON(t, r, "/chat-history", nil)
+	if code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", code)
+	}
+	if got := payloadItems(t, payload); len(got) != 3 {
+		t.Fatalf("expected 3 items, got %d", len(got))
+	}
+	if total, _ := payload["total"].(float64); total != 3 {
+		t.Fatalf("expected total=3, got %#v", payload["total"])
+	}
+	if header.Get("ETag") == "" {
+		t.Fatalf("unfiltered list must keep the etag header")
+	}
+
+	// callers：配置里登记的 Key（含无记录的）+ 记录里出现过的 CallerID。
+	callers, ok := payload["callers"].([]any)
+	if !ok || len(callers) != 3 {
+		t.Fatalf("expected 3 callers, got %#v", payload["callers"])
+	}
+	first, _ := callers[0].(map[string]any)
+	if first["caller_id"] != callerIDConfigured || first["count"] != float64(2) || first["configured"] != true {
+		t.Fatalf("unexpected top caller: %#v", first)
+	}
+	if first["label"] != testConfiguredLabel {
+		t.Fatalf("expected configured label, got %#v", first["label"])
+	}
+	second, _ := callers[1].(map[string]any)
+	if second["caller_id"] != testCallerExternal || second["count"] != float64(1) || second["configured"] != false {
+		t.Fatalf("unexpected second caller: %#v", second)
+	}
+	third, _ := callers[2].(map[string]any)
+	unusedID := auth.CallerTokenID(testKeyUnused)
+	if third["caller_id"] != unusedID || third["count"] != float64(0) || third["configured"] != true {
+		t.Fatalf("expected unused configured key last, got %#v", third)
+	}
+	if third["label"] != config.MaskAPIKeyPreview(testKeyUnused) {
+		t.Fatalf("expected masked key label, got %#v", third["label"])
+	}
+
+	// 按 API Key 过滤
+	code, payload, header = getHistoryJSON(t, r, "/chat-history?caller="+callerIDConfigured, nil)
+	if code != http.StatusOK {
+		t.Fatalf("expected 200 for caller filter, got %d", code)
+	}
+	if got := payloadItems(t, payload); len(got) != 2 {
+		t.Fatalf("expected 2 items for caller filter, got %d", len(got))
+	}
+	if total, _ := payload["total"].(float64); total != 2 {
+		t.Fatalf("expected total=2 for caller filter, got %#v", payload["total"])
+	}
+	if header.Get("ETag") != "" {
+		t.Fatalf("filtered list must not emit a revision etag")
+	}
+
+	// 按状态过滤
+	code, payload, _ = getHistoryJSON(t, r, "/chat-history?status=error", nil)
+	if code != http.StatusOK {
+		t.Fatalf("expected 200 for status filter, got %d", code)
+	}
+	if got := payloadItems(t, payload); len(got) != 1 {
+		t.Fatalf("expected 1 error item, got %d", len(got))
+	}
+
+	// 按接口过滤
+	code, payload, _ = getHistoryJSON(t, r, "/chat-history?surface="+testSurfaceClaude, nil)
+	if code != http.StatusOK {
+		t.Fatalf("expected 200 for surface filter, got %d", code)
+	}
+	if got := payloadItems(t, payload); len(got) != 1 {
+		t.Fatalf("expected 1 claude item, got %d", len(got))
+	}
+
+	// q 必须能命中 Error 字段（该条目的 Preview 是 content，不可能匹配到 boom）
+	code, payload, _ = getHistoryJSON(t, r, "/chat-history?q=BOOM", nil)
+	if code != http.StatusOK {
+		t.Fatalf("expected 200 for q filter, got %d", code)
+	}
+	if got := payloadItems(t, payload); len(got) != 1 {
+		t.Fatalf("expected 1 item matching error text, got %d", len(got))
+	}
+	if id, _ := payloadItems(t, payload)[0].(map[string]any)["status"]; id != "error" {
+		t.Fatalf("expected the error entry, got %#v", id)
+	}
+
+	// q 也能命中模型名（不区分大小写）
+	code, payload, _ = getHistoryJSON(t, r, "/chat-history?q=V4-PRO", nil)
+	if code != http.StatusOK || len(payloadItems(t, payload)) != 1 {
+		t.Fatalf("expected model-name match, got code=%d payload=%#v", code, payload)
+	}
+
+	// 分页：total 仍是筛选后的总数
+	code, payload, _ = getHistoryJSON(t, r, "/chat-history?offset=1&limit=1", nil)
+	if code != http.StatusOK {
+		t.Fatalf("expected 200 for paging, got %d", code)
+	}
+	if got := payloadItems(t, payload); len(got) != 1 {
+		t.Fatalf("expected 1 paged item, got %d", len(got))
+	}
+	if total, _ := payload["total"].(float64); total != 3 {
+		t.Fatalf("expected total=3 while paging, got %#v", payload["total"])
+	}
+
+	// 带筛选参数时不允许 304
+	_, _, unfilteredHeader := getHistoryJSON(t, r, "/chat-history", nil)
+	code, _, _ = getHistoryJSON(t, r, "/chat-history?status=success",
+		map[string]string{"If-None-Match": unfilteredHeader.Get("ETag")})
+	if code != http.StatusOK {
+		t.Fatalf("filtered request must return 200 instead of 304, got %d", code)
+	}
+}
+
+func TestChatHistorySettingsAcceptsCustomLimit(t *testing.T) {
+	h, store := newChatHistoryAdminHarness(t)
+	r := historyRouter(h)
+
+	put := func(body string) *httptest.ResponseRecorder {
+		t.Helper()
+		req := httptest.NewRequest(http.MethodPut, "/chat-history/settings", strings.NewReader(body))
+		req.Header.Set("Authorization", "Bearer admin")
+		rec := httptest.NewRecorder()
+		r.ServeHTTP(rec, req)
+		return rec
+	}
+
+	rec := put(`{"limit":137}`)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected 200 for limit=137, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	var payload map[string]any
+	if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("decode payload failed: %v", err)
+	}
+	if payload["success"] != true || payload["limit"] != float64(137) {
+		t.Fatalf("unexpected settings payload: %#v", payload)
+	}
+	snapshot, err := store.Snapshot()
+	if err != nil {
+		t.Fatalf("snapshot failed: %v", err)
+	}
+	if snapshot.Limit != 137 {
+		t.Fatalf("expected stored limit 137, got %d", snapshot.Limit)
+	}
+
+	if rec := put(`{"limit":500}`); rec.Code != http.StatusOK {
+		t.Fatalf("expected 200 for limit=500, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	rec = put(`{"limit":501}`)
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400 for limit=501, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	if !strings.Contains(rec.Body.String(), "unsupported chat history limit") {
+		t.Fatalf("unexpected error body: %s", rec.Body.String())
+	}
+	if rec := put(`{"limit":0}`); rec.Code != http.StatusOK {
+		t.Fatalf("expected 200 for limit=0, got %d body=%s", rec.Code, rec.Body.String())
+	}
+}
+
+func TestChatHistoryExportJSONAndMarkdown(t *testing.T) {
+	h, store := newChatHistoryAdminHarness(t)
+	seedHistoryEntry(t, store,
+		chathistory.StartParams{
+			CallerID:    callerIDConfigured,
+			CallerLabel: "Alpha",
+			Surface:     testSurfaceOpenAI,
+			Model:       "deepseek-v4-flash",
+			Stream:      true,
+			UserInput:   "hello world",
+			FinalPrompt: "final prompt text",
+		},
+		chathistory.UpdateParams{
+			Status:           "success",
+			StatusCode:       http.StatusOK,
+			ReasoningContent: "thinking hard",
+			Content:          "answer one",
+			ElapsedMs:        1234,
+			FinishReason:     "stop",
+			Completed:        true,
+		},
+	)
+	seedHistoryEntry(t, store,
+		chathistory.StartParams{
+			CallerID:  testCallerExternal,
+			Surface:   testSurfaceClaude,
+			Model:     "deepseek-v4-pro",
+			UserInput: "second prompt",
+		},
+		chathistory.UpdateParams{Status: "error", Error: "boom upstream", Completed: true},
+	)
+
+	r := historyRouter(h)
+
+	rec := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/chat-history/export?format=json", nil)
+	req.Header.Set("Authorization", "Bearer admin")
+	r.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected 200 from json export, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	if got := rec.Header().Get("Content-Type"); got != "application/json" {
+		t.Fatalf("unexpected content type: %q", got)
+	}
+	disposition := rec.Header().Get("Content-Disposition")
+	if !strings.HasPrefix(disposition, `attachment; filename="ds2api-logs-`) || !strings.HasSuffix(disposition, `.json"`) {
+		t.Fatalf("unexpected content disposition: %q", disposition)
+	}
+	var exported struct {
+		ExportedAt string              `json:"exported_at"`
+		Count      int                 `json:"count"`
+		Filters    map[string]any      `json:"filters"`
+		Items      []chathistory.Entry `json:"items"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &exported); err != nil {
+		t.Fatalf("decode export failed: %v body=%s", err, rec.Body.String())
+	}
+	if exported.Count != 2 || len(exported.Items) != 2 {
+		t.Fatalf("expected 2 exported entries, got count=%d items=%d", exported.Count, len(exported.Items))
+	}
+	if exported.ExportedAt == "" {
+		t.Fatalf("expected exported_at timestamp")
+	}
+	if _, ok := exported.Filters["caller"]; ok {
+		t.Fatalf("empty filters must be omitted, got %#v", exported.Filters)
+	}
+	var full chathistory.Entry
+	for _, item := range exported.Items {
+		if item.CallerID == callerIDConfigured {
+			full = item
+		}
+	}
+	if full.FinalPrompt != "final prompt text" || full.ReasoningContent != "thinking hard" || full.Content != "answer one" {
+		t.Fatalf("export must contain full entries, got %#v", full)
+	}
+
+	// 过滤后再导出
+	rec = httptest.NewRecorder()
+	req = httptest.NewRequest(http.MethodGet, "/chat-history/export?format=json&caller="+callerIDConfigured, nil)
+	r.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected 200 from filtered export, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	exported.Items = nil
+	exported.Filters = nil
+	if err := json.Unmarshal(rec.Body.Bytes(), &exported); err != nil {
+		t.Fatalf("decode filtered export failed: %v", err)
+	}
+	if exported.Count != 1 || len(exported.Items) != 1 {
+		t.Fatalf("expected 1 filtered export entry, got count=%d", exported.Count)
+	}
+	if exported.Filters["caller"] != callerIDConfigured {
+		t.Fatalf("expected caller filter echoed, got %#v", exported.Filters)
+	}
+
+	// markdown 导出
+	rec = httptest.NewRecorder()
+	req = httptest.NewRequest(http.MethodGet, "/chat-history/export?format=markdown&caller="+callerIDConfigured, nil)
+	r.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected 200 from markdown export, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	if got := rec.Header().Get("Content-Type"); got != "text/markdown; charset=utf-8" {
+		t.Fatalf("unexpected markdown content type: %q", got)
+	}
+	disposition = rec.Header().Get("Content-Disposition")
+	if !strings.HasSuffix(disposition, `.md"`) {
+		t.Fatalf("unexpected markdown content disposition: %q", disposition)
+	}
+	body := rec.Body.String()
+	for _, want := range []string{
+		"# ds2api 响应记录导出",
+		"- 条数: 1",
+		"## 1. ",
+		"- 接口: " + testSurfaceOpenAI,
+		"- 模型: deepseek-v4-flash",
+		"- CallerLabel: Alpha (" + callerIDConfigured + ")",
+		"- 状态: success (200)",
+		"- 耗时: 1234ms",
+		"### UserInput",
+		"hello world",
+		"### FinalPrompt",
+		"final prompt text",
+		"### ReasoningContent",
+		"thinking hard",
+		"### Content",
+		"answer one",
+	} {
+		if !strings.Contains(body, want) {
+			t.Fatalf("markdown export missing %q:\n%s", want, body)
+		}
+	}
+
+	// 未知格式必须报错
+	rec = httptest.NewRecorder()
+	req = httptest.NewRequest(http.MethodGet, "/chat-history/export?format=xml", nil)
+	r.ServeHTTP(rec, req)
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400 for unsupported format, got %d body=%s", rec.Code, rec.Body.String())
+	}
+}
+
+// 导出 filename 里的时间戳必须来自本次请求，逐次调用都应给出合法文件名。
+func TestChatHistoryExportFilenameCarriesTimestamp(t *testing.T) {
+	h, _ := newChatHistoryAdminHarness(t)
+	r := historyRouter(h)
+
+	rec := httptest.NewRecorder()
+	req := httptest.NewRequest(http.MethodGet, "/chat-history/export", nil)
+	r.ServeHTTP(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected 200 from default export, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	disposition := rec.Header().Get("Content-Disposition")
+	if !strings.HasPrefix(disposition, `attachment; filename="ds2api-logs-`) || !strings.HasSuffix(disposition, `.json"`) {
+		t.Fatalf("unexpected content disposition: %q", disposition)
+	}
+	if !strings.Contains(rec.Body.String(), `"count": 0`) {
+		t.Fatalf("expected empty export payload, got %s", rec.Body.String())
+	}
+}

internal/httpapi/admin/history/handler_chat_history_test.go

@@ -16,10 +16,17 @@ import (
 )
 
 func newChatHistoryAdminHarness(t *testing.T) (*Handler, *chathistory.Store) {
+	t.Helper()
+	return newChatHistoryAdminHarnessWithConfig(t, `{}`)
+}
+
+// newChatHistoryAdminHarnessWithConfig 允许测试注入配置（例如已登记的 API Key），
+// 用于验证按 API Key 聚合 / 筛选的行为。
+func newChatHistoryAdminHarnessWithConfig(t *testing.T, configJSON string) (*Handler, *chathistory.Store) {
 	t.Helper()
 	dir := t.TempDir()
 	configPath := filepath.Join(dir, "config.json")
-	if err := os.WriteFile(configPath, []byte(`{}`), 0o644); err != nil {
+	if err := os.WriteFile(configPath, []byte(configJSON), 0o644); err != nil {
 		t.Fatalf("write config failed: %v", err)
 	}
 	t.Setenv("DS2API_CONFIG_PATH", configPath)

internal/httpapi/admin/history/routes.go

@@ -4,6 +4,8 @@ import "github.com/go-chi/chi/v5"
 
 func RegisterRoutes(r chi.Router, h *Handler) {
 	r.Get("/chat-history", h.getChatHistory)
+	// 静态段必须先于 {id} 注册，避免 "export" 被当成记录 ID。
+	r.Get("/chat-history/export", h.exportChatHistory)
 	r.Get("/chat-history/{id}", h.getChatHistoryItem)
 	r.Delete("/chat-history", h.clearChatHistory)
 	r.Delete("/chat-history/{id}", h.deleteChatHistoryItem)

internal/httpapi/admin/settings/handler_settings_parse.go

@@ -21,29 +21,34 @@ func boolFrom(v any) bool {
 	}
 }
 
-func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *config.RuntimeConfig, *config.ResponsesConfig, *config.EmbeddingsConfig, *config.AutoDeleteConfig, *config.CurrentInputFileConfig, *config.ThinkingInjectionConfig, *config.PlatformConfig, map[string]string, error) {
-	var (
-		adminCfg        *config.AdminConfig
-		runtimeCfg      *config.RuntimeConfig
-		respCfg         *config.ResponsesConfig
-		embCfg          *config.EmbeddingsConfig
-		autoDeleteCfg   *config.AutoDeleteConfig
-		currentInputCfg *config.CurrentInputFileConfig
-		thinkingInjCfg  *config.ThinkingInjectionConfig
-		platformCfg     *config.PlatformConfig
-		aliasMap        map[string]string
-	)
+// settingsUpdatePayload 是 PUT /admin/settings 解析后的增量配置。
+// 每个字段为 nil 表示请求里没有出现该段，保持既有配置不变。
+type settingsUpdatePayload struct {
+	Admin             *config.AdminConfig
+	Runtime           *config.RuntimeConfig
+	Responses         *config.ResponsesConfig
+	Embeddings        *config.EmbeddingsConfig
+	AutoDelete        *config.AutoDeleteConfig
+	CurrentInputFile  *config.CurrentInputFileConfig
+	ThinkingInjection *config.ThinkingInjectionConfig
+	Tools             *config.ToolsConfig
+	Platform          *config.PlatformConfig
+	Aliases           map[string]string
+}
+
+func parseSettingsUpdateRequest(req map[string]any) (settingsUpdatePayload, error) {
+	var out settingsUpdatePayload
 
 	if raw, ok := req["admin"].(map[string]any); ok {
 		cfg := &config.AdminConfig{}
 		if v, exists := raw["jwt_expire_hours"]; exists {
 			n := intFrom(v)
 			if err := config.ValidateIntRange("admin.jwt_expire_hours", n, 1, 720, true); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return settingsUpdatePayload{}, err
 			}
 			cfg.JWTExpireHours = n
 		}
-		adminCfg = cfg
+		out.Admin = cfg
 	}
 
 	if raw, ok := req["runtime"].(map[string]any); ok {
@@ -51,42 +56,42 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		if v, exists := raw["account_max_inflight"]; exists {
 			n := intFrom(v)
 			if err := config.ValidateIntRange("runtime.account_max_inflight", n, 1, 256, true); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return settingsUpdatePayload{}, err
 			}
 			cfg.AccountMaxInflight = n
 		}
 		if v, exists := raw["account_max_queue"]; exists {
 			n := intFrom(v)
 			if err := config.ValidateIntRange("runtime.account_max_queue", n, 1, 200000, true); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return settingsUpdatePayload{}, err
 			}
 			cfg.AccountMaxQueue = n
 		}
 		if v, exists := raw["global_max_inflight"]; exists {
 			n := intFrom(v)
 			if err := config.ValidateIntRange("runtime.global_max_inflight", n, 1, 200000, true); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return settingsUpdatePayload{}, err
 			}
 			cfg.GlobalMaxInflight = n
 		}
 		if v, exists := raw["token_refresh_interval_hours"]; exists {
 			n := intFrom(v)
 			if err := config.ValidateIntRange("runtime.token_refresh_interval_hours", n, 1, 720, true); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return settingsUpdatePayload{}, err
 			}
 			cfg.TokenRefreshIntervalHours = n
 		}
 		if v, exists := raw["backup_release_count"]; exists {
 			n := intFrom(v)
 			if err := config.ValidateIntRange("runtime.backup_release_count", n, 1, 100, true); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return settingsUpdatePayload{}, err
 			}
 			cfg.BackupReleaseCount = n
 		}
 		if cfg.AccountMaxInflight > 0 && cfg.GlobalMaxInflight > 0 && cfg.GlobalMaxInflight < cfg.AccountMaxInflight {
-			return nil, nil, nil, nil, nil, nil, nil, nil, nil, fmt.Errorf("runtime.global_max_inflight must be >= runtime.account_max_inflight")
+			return settingsUpdatePayload{}, fmt.Errorf("runtime.global_max_inflight must be >= runtime.account_max_inflight")
 		}
-		runtimeCfg = cfg
+		out.Runtime = cfg
 	}
 
 	if raw, ok := req["responses"].(map[string]any); ok {
@@ -94,11 +99,11 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		if v, exists := raw["store_ttl_seconds"]; exists {
 			n := intFrom(v)
 			if err := config.ValidateIntRange("responses.store_ttl_seconds", n, 30, 86400, true); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return settingsUpdatePayload{}, err
 			}
 			cfg.StoreTTLSeconds = n
 		}
-		respCfg = cfg
+		out.Responses = cfg
 	}
 
 	if raw, ok := req["embeddings"].(map[string]any); ok {
@@ -106,16 +111,16 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		if v, exists := raw["provider"]; exists {
 			p := strings.TrimSpace(fmt.Sprintf("%v", v))
 			if err := config.ValidateTrimmedString("embeddings.provider", p, false); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return settingsUpdatePayload{}, err
 			}
 			cfg.Provider = p
 		}
-		embCfg = cfg
+		out.Embeddings = cfg
 	}
 
 	if raw, ok := req["model_aliases"].(map[string]any); ok {
-		if aliasMap == nil {
-			aliasMap = map[string]string{}
+		if out.Aliases == nil {
+			out.Aliases = map[string]string{}
 		}
 		for k, v := range raw {
 			key := strings.TrimSpace(k)
@@ -123,7 +128,7 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 			if key == "" || val == "" {
 				continue
 			}
-			aliasMap[key] = val
+			out.Aliases[key] = val
 		}
 	}
 
@@ -132,7 +137,7 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		if v, exists := raw["mode"]; exists {
 			mode := strings.ToLower(strings.TrimSpace(fmt.Sprintf("%v", v)))
 			if err := config.ValidateAutoDeleteMode(mode); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return settingsUpdatePayload{}, err
 			}
 			if mode == "" {
 				mode = "none"
@@ -142,7 +147,7 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		if v, exists := raw["sessions"]; exists {
 			cfg.Sessions = boolFrom(v)
 		}
-		autoDeleteCfg = cfg
+		out.AutoDelete = cfg
 	}
 
 	if raw, ok := req["current_input_file"].(map[string]any); ok {
@@ -154,14 +159,14 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		if v, exists := raw["min_chars"]; exists {
 			n := intFrom(v)
 			if err := config.ValidateIntRange("current_input_file.min_chars", n, 0, 100000000, true); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return settingsUpdatePayload{}, err
 			}
 			cfg.MinChars = n
 		}
 		if err := config.ValidateCurrentInputFileConfig(*cfg); err != nil {
-			return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+			return settingsUpdatePayload{}, err
 		}
-		currentInputCfg = cfg
+		out.CurrentInputFile = cfg
 	}
 
 	if raw, ok := req["thinking_injection"].(map[string]any); ok {
@@ -173,7 +178,16 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		if v, exists := raw["prompt"]; exists {
 			cfg.Prompt = strings.TrimSpace(fmt.Sprintf("%v", v))
 		}
-		thinkingInjCfg = cfg
+		out.ThinkingInjection = cfg
+	}
+
+	if raw, ok := req["tools"].(map[string]any); ok {
+		cfg := &config.ToolsConfig{}
+		if v, exists := raw["enabled"]; exists {
+			b := boolFrom(v)
+			cfg.Enabled = &b
+		}
+		out.Tools = cfg
 	}
 
 	if raw, ok := req["platform"].(map[string]any); ok {
@@ -181,7 +195,7 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		if v, exists := raw["mode"]; exists {
 			mode := strings.ToLower(strings.TrimSpace(fmt.Sprintf("%v", v)))
 			if err := config.ValidatePlatformConfig(config.PlatformConfig{Mode: mode}); err != nil {
-				return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+				return settingsUpdatePayload{}, err
 			}
 			cfg.Mode = mode
 		}
@@ -194,8 +208,8 @@ func parseSettingsUpdateRequest(req map[string]any) (*config.AdminConfig, *confi
 		if v, exists := raw["android_api_level"]; exists {
 			cfg.AndroidAPILevel = strings.TrimSpace(fmt.Sprintf("%v", v))
 		}
-		platformCfg = cfg
+		out.Platform = cfg
 	}
 
-	return adminCfg, runtimeCfg, respCfg, embCfg, autoDeleteCfg, currentInputCfg, thinkingInjCfg, platformCfg, aliasMap, nil
+	return out, nil
 }

internal/httpapi/admin/settings/handler_settings_read.go

@@ -37,6 +37,14 @@ func (h *Handler) getSettings(w http.ResponseWriter, _ *http.Request) {
 				"enabled": snap.ThinkingInjection.Enabled,
 				"prompt":  snap.ThinkingInjection.Prompt,
 			},
+			"skills": map[string]any{
+				"enabled":   snap.Skills.Enabled,
+				"max_chars": snap.Skills.EffectiveMaxChars(),
+				"count":     len(snap.Skills.Items),
+			},
+			"tools": map[string]any{
+				"enabled": snap.Tools.Enabled,
+			},
 			"model_aliases": snap.ModelAliases,
 			"platform":      snap.Platform,
 		},
@@ -65,6 +73,15 @@ func (h *Handler) getSettings(w http.ResponseWriter, _ *http.Request) {
 			"prompt":         h.Store.ThinkingInjectionPrompt(),
 			"default_prompt": promptcompat.DefaultThinkingInjectionPrompt,
 		},
+		"skills": map[string]any{
+			"enabled":   h.Store.SkillsEnabled(),
+			"max_chars": h.Store.SkillsMaxChars(),
+			"count":     len(snap.Skills.Items),
+		},
+		"tools": map[string]any{
+			"enabled":         h.Store.ToolsEnabled(),
+			"default_enabled": false,
+		},
 		"model_aliases": snap.ModelAliases,
 		"platform": map[string]any{
 			"mode":              h.Store.PlatformMode(),

internal/httpapi/admin/settings/handler_settings_write.go

@@ -17,13 +17,13 @@ func (h *Handler) updateSettings(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	adminCfg, runtimeCfg, responsesCfg, embeddingsCfg, autoDeleteCfg, currentInputCfg, thinkingInjCfg, platformCfg, aliasMap, err := parseSettingsUpdateRequest(req)
+	payload, err := parseSettingsUpdateRequest(req)
 	if err != nil {
 		writeJSON(w, http.StatusBadRequest, map[string]any{"detail": err.Error()})
 		return
 	}
-	if runtimeCfg != nil {
-		if err := validateMergedRuntimeSettings(h.Store.Snapshot().Runtime, runtimeCfg); err != nil {
+	if payload.Runtime != nil {
+		if err := validateMergedRuntimeSettings(h.Store.Snapshot().Runtime, payload.Runtime); err != nil {
 			writeJSON(w, http.StatusBadRequest, map[string]any{"detail": err.Error()})
 			return
 		}
@@ -32,14 +32,16 @@ func (h *Handler) updateSettings(w http.ResponseWriter, r *http.Request) {
 	currentInputMinCharsSet := hasNestedSettingsKey(req, "current_input_file", "min_chars")
 	thinkingInjectionEnabledSet := hasNestedSettingsKey(req, "thinking_injection", "enabled")
 	thinkingInjectionPromptSet := hasNestedSettingsKey(req, "thinking_injection", "prompt")
+	toolsEnabledSet := hasNestedSettingsKey(req, "tools", "enabled")
 
 	if err := h.Store.Update(func(c *config.Config) error {
-		if adminCfg != nil {
-			if adminCfg.JWTExpireHours > 0 {
-				c.Admin.JWTExpireHours = adminCfg.JWTExpireHours
+		if payload.Admin != nil {
+			if payload.Admin.JWTExpireHours > 0 {
+				c.Admin.JWTExpireHours = payload.Admin.JWTExpireHours
 			}
 		}
-		if runtimeCfg != nil {
+		if payload.Runtime != nil {
+			runtimeCfg := payload.Runtime
 			if runtimeCfg.AccountMaxInflight > 0 {
 				c.Runtime.AccountMaxInflight = runtimeCfg.AccountMaxInflight
 			}
@@ -56,40 +58,43 @@ func (h *Handler) updateSettings(w http.ResponseWriter, r *http.Request) {
 				c.Runtime.BackupReleaseCount = runtimeCfg.BackupReleaseCount
 			}
 		}
-		if responsesCfg != nil && responsesCfg.StoreTTLSeconds > 0 {
-			c.Responses.StoreTTLSeconds = responsesCfg.StoreTTLSeconds
+		if payload.Responses != nil && payload.Responses.StoreTTLSeconds > 0 {
+			c.Responses.StoreTTLSeconds = payload.Responses.StoreTTLSeconds
 		}
-		if embeddingsCfg != nil && strings.TrimSpace(embeddingsCfg.Provider) != "" {
-			c.Embeddings.Provider = strings.TrimSpace(embeddingsCfg.Provider)
+		if payload.Embeddings != nil && strings.TrimSpace(payload.Embeddings.Provider) != "" {
+			c.Embeddings.Provider = strings.TrimSpace(payload.Embeddings.Provider)
 		}
-		if autoDeleteCfg != nil {
-			c.AutoDelete.Mode = autoDeleteCfg.Mode
-			c.AutoDelete.Sessions = autoDeleteCfg.Sessions
+		if payload.AutoDelete != nil {
+			c.AutoDelete.Mode = payload.AutoDelete.Mode
+			c.AutoDelete.Sessions = payload.AutoDelete.Sessions
 		}
-		if currentInputCfg != nil {
+		if payload.CurrentInputFile != nil {
 			if currentInputEnabledSet {
-				c.CurrentInputFile.Enabled = currentInputCfg.Enabled
+				c.CurrentInputFile.Enabled = payload.CurrentInputFile.Enabled
 			}
 			if currentInputMinCharsSet {
-				c.CurrentInputFile.MinChars = currentInputCfg.MinChars
+				c.CurrentInputFile.MinChars = payload.CurrentInputFile.MinChars
 			}
 		}
-		if thinkingInjCfg != nil {
+		if payload.ThinkingInjection != nil {
 			if thinkingInjectionEnabledSet {
-				c.ThinkingInjection.Enabled = thinkingInjCfg.Enabled
+				c.ThinkingInjection.Enabled = payload.ThinkingInjection.Enabled
 			}
 			if thinkingInjectionPromptSet {
-				c.ThinkingInjection.Prompt = thinkingInjCfg.Prompt
+				c.ThinkingInjection.Prompt = payload.ThinkingInjection.Prompt
 			}
 		}
-		if aliasMap != nil {
-			c.ModelAliases = aliasMap
+		if payload.Tools != nil && toolsEnabledSet {
+			c.Tools.Enabled = payload.Tools.Enabled
 		}
-		if platformCfg != nil {
-			c.Platform.Mode = platformCfg.Mode
-			c.Platform.AndroidVersion = platformCfg.AndroidVersion
-			c.Platform.WebVersion = platformCfg.WebVersion
-			c.Platform.AndroidAPILevel = platformCfg.AndroidAPILevel
+		if payload.Aliases != nil {
+			c.ModelAliases = payload.Aliases
+		}
+		if payload.Platform != nil {
+			c.Platform.Mode = payload.Platform.Mode
+			c.Platform.AndroidVersion = payload.Platform.AndroidVersion
+			c.Platform.WebVersion = payload.Platform.WebVersion
+			c.Platform.AndroidAPILevel = payload.Platform.AndroidAPILevel
 		}
 		return nil
 	}); err != nil {

internal/httpapi/admin/shared/deps.go

@@ -38,6 +38,9 @@ type ConfigStore interface {
 	CurrentInputFileMinChars() int
 	ThinkingInjectionEnabled() bool
 	ThinkingInjectionPrompt() string
+	SkillsEnabled() bool
+	SkillsMaxChars() int
+	ToolsEnabled() bool
 	AutoDeleteSessions() bool
 	SetAccountBanned(identifier string, banned bool) (config.Account, error)
 	SetAccountRole(identifier string, role string) (config.Account, error)

internal/httpapi/admin/shared/helpers.go

@@ -33,6 +33,9 @@ func ToAccount(m map[string]any) config.Account {
 func ToAPIKeys(v any) ([]config.APIKey, bool) {
 	return toAPIKeys(v)
 }
+func ToAPIKeyInjection(v any) *config.APIKeyInjectionConfig {
+	return toAPIKeyInjection(v)
+}
 func NormalizeAPIKeyForStorage(item config.APIKey) config.APIKey {
 	return normalizeAPIKeyForStorage(item)
 }
@@ -197,9 +200,10 @@ func toAPIKeys(v any) ([]config.APIKey, bool) {
 			}
 			seen[key] = struct{}{}
 			out = append(out, config.APIKey{
-				Key:    key,
-				Name:   fieldString(x, "name"),
-				Remark: fieldString(x, "remark"),
+				Key:               key,
+				Name:              fieldString(x, "name"),
+				Remark:            fieldString(x, "remark"),
+				ThinkingInjection: toAPIKeyInjection(x["thinking_injection"]),
 			})
 		default:
 			key := strings.TrimSpace(fmt.Sprintf("%v", item))
@@ -216,16 +220,65 @@ func toAPIKeys(v any) ([]config.APIKey, bool) {
 	return out, true
 }
 
+// toAPIKeyInjection 解析单个 API Key 的自定义注入设置。
+// 传 null / 空对象 / 字段全空时返回 nil，表示回到“跟随全局”。
+func toAPIKeyInjection(v any) *config.APIKeyInjectionConfig {
+	if v == nil {
+		return nil
+	}
+	m, ok := v.(map[string]any)
+	if !ok {
+		return nil
+	}
+	cfg := &config.APIKeyInjectionConfig{
+		Custom:  boolField(m, "custom"),
+		Enabled: optionalBoolField(m, "enabled"),
+		Prompt:  fieldString(m, "prompt"),
+	}
+	return cfg.Normalize()
+}
+
+func boolField(m map[string]any, key string) bool {
+	if m == nil {
+		return false
+	}
+	switch v := m[key].(type) {
+	case bool:
+		return v
+	case string:
+		switch strings.ToLower(strings.TrimSpace(v)) {
+		case "true", "1", "yes", "on":
+			return true
+		}
+	}
+	return false
+}
+
+func optionalBoolField(m map[string]any, key string) *bool {
+	if m == nil {
+		return nil
+	}
+	raw, ok := m[key]
+	if !ok || raw == nil {
+		return nil
+	}
+	value := boolField(m, key)
+	return &value
+}
+
 func normalizeAPIKeyForStorage(item config.APIKey) config.APIKey {
 	return config.APIKey{
-		Key:    strings.TrimSpace(item.Key),
-		Name:   strings.TrimSpace(item.Name),
-		Remark: strings.TrimSpace(item.Remark),
+		Key:               strings.TrimSpace(item.Key),
+		Name:              strings.TrimSpace(item.Name),
+		Remark:            strings.TrimSpace(item.Remark),
+		ThinkingInjection: item.ThinkingInjection.Normalize(),
 	}
 }
 
 func apiKeyHasMetadata(item config.APIKey) bool {
-	return strings.TrimSpace(item.Name) != "" || strings.TrimSpace(item.Remark) != ""
+	return strings.TrimSpace(item.Name) != "" ||
+		strings.TrimSpace(item.Remark) != "" ||
+		item.ThinkingInjection.Normalize() != nil
 }
 
 func mergeAPIKeysPreferStructured(existing, incoming []config.APIKey) ([]config.APIKey, int) {
@@ -279,13 +332,18 @@ func mergeAPIKeyRecord(existing, incoming config.APIKey) config.APIKey {
 	if existing.Key == "" {
 		return incoming
 	}
-	if apiKeyHasMetadata(existing) {
-		return existing
+	// 已存在的结构化字段优先，缺失项用导入值补齐（含自定义注入设置）。
+	out := existing
+	if out.Name == "" {
+		out.Name = incoming.Name
 	}
-	if apiKeyHasMetadata(incoming) {
-		return incoming
+	if out.Remark == "" {
+		out.Remark = incoming.Remark
+	}
+	if out.ThinkingInjection == nil {
+		out.ThinkingInjection = incoming.ThinkingInjection
 	}
-	return existing
+	return out
 }
 
 func fieldString(m map[string]any, key string) string {

internal/httpapi/admin/skills/deps.go

@@ -0,0 +1,16 @@
+package skills
+
+import (
+	"ds2api/internal/chathistory"
+	adminshared "ds2api/internal/httpapi/admin/shared"
+)
+
+type Handler struct {
+	Store       adminshared.ConfigStore
+	Pool        adminshared.PoolController
+	DS          adminshared.DeepSeekCaller
+	OpenAI      adminshared.OpenAIChatCaller
+	ChatHistory *chathistory.Store
+}
+
+var writeJSON = adminshared.WriteJSON

internal/httpapi/admin/skills/handler_skills.go

@@ -0,0 +1,91 @@
+package skills
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"ds2api/internal/config"
+)
+
+// skillsPayload 是 GET/PUT /admin/skills 的响应与请求形状。
+// PUT 是整体替换语义：缺省的 enabled/max_chars/items 一律按默认值处理。
+type skillsPayload struct {
+	Enabled  bool                 `json:"enabled"`
+	MaxChars int                  `json:"max_chars"`
+	Items    []config.SkillConfig `json:"items"`
+}
+
+func (h *Handler) getSkills(w http.ResponseWriter, _ *http.Request) {
+	settings := h.currentSkills()
+	writeJSON(w, http.StatusOK, skillsPayload{
+		Enabled:  settings.IsEnabled(),
+		MaxChars: settings.EffectiveMaxChars(),
+		Items:    itemsOrEmpty(settings.Items),
+	})
+}
+
+func (h *Handler) updateSkills(w http.ResponseWriter, r *http.Request) {
+	var req struct {
+		Enabled  *bool                `json:"enabled"`
+		MaxChars *int                 `json:"max_chars"`
+		Items    []config.SkillConfig `json:"items"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		writeJSON(w, http.StatusBadRequest, map[string]any{"detail": "invalid json: " + err.Error()})
+		return
+	}
+	if req.MaxChars != nil && *req.MaxChars < 0 {
+		writeJSON(w, http.StatusBadRequest, map[string]any{"detail": "max_chars must be >= 0"})
+		return
+	}
+
+	var maxChars *int
+	if req.MaxChars != nil {
+		value := *req.MaxChars
+		maxChars = &value
+	}
+	cfg := config.SkillsConfig{
+		MaxChars: maxChars,
+		Items:    req.Items,
+	}
+	if req.Enabled != nil {
+		enabled := *req.Enabled
+		cfg.Enabled = &enabled
+	} else {
+		// 整体替换语义：请求没带 enabled 就按「关闭」保存。
+		enabled := false
+		cfg.Enabled = &enabled
+	}
+	if err := config.ValidateSkillsConfig(cfg); err != nil {
+		writeJSON(w, http.StatusBadRequest, map[string]any{"detail": err.Error()})
+		return
+	}
+	stored := cfg.Normalize()
+	if err := h.Store.Update(func(c *config.Config) error {
+		c.Skills = stored
+		return nil
+	}); err != nil {
+		writeJSON(w, http.StatusInternalServerError, map[string]any{"detail": err.Error()})
+		return
+	}
+
+	writeJSON(w, http.StatusOK, map[string]any{
+		"success": true,
+		"count":   len(stored.Items),
+	})
+}
+
+// currentSkills 返回当前全局技能库配置（含默认值归一化）。
+func (h *Handler) currentSkills() config.SkillsConfig {
+	if h == nil || h.Store == nil {
+		return config.SkillsConfig{}
+	}
+	return h.Store.Snapshot().Skills.Normalize()
+}
+
+func itemsOrEmpty(items []config.SkillConfig) []config.SkillConfig {
+	if items == nil {
+		return []config.SkillConfig{}
+	}
+	return items
+}

internal/httpapi/admin/skills/handler_skills_test.go

@@ -0,0 +1,238 @@
+package skills
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"ds2api/internal/config"
+)
+
+func newSkillsTestHandler(t *testing.T, raw string) *Handler {
+	t.Helper()
+	t.Setenv("DS2API_CONFIG_JSON", raw)
+	return &Handler{Store: config.LoadStore()}
+}
+
+func putSkills(t *testing.T, h *Handler, body map[string]any) *httptest.ResponseRecorder {
+	t.Helper()
+	encoded, err := json.Marshal(body)
+	if err != nil {
+		t.Fatalf("marshal payload: %v", err)
+	}
+	req := httptest.NewRequest(http.MethodPut, "/admin/skills", bytes.NewReader(encoded))
+	rec := httptest.NewRecorder()
+	h.updateSkills(rec, req)
+	return rec
+}
+
+func TestGetSkillsDefaults(t *testing.T) {
+	h := newSkillsTestHandler(t, `{"keys":["k1"]}`)
+	req := httptest.NewRequest(http.MethodGet, "/admin/skills", nil)
+	rec := httptest.NewRecorder()
+	h.getSkills(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
+	}
+	var body skillsPayload
+	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if body.Enabled {
+		t.Fatal("expected skills disabled by default")
+	}
+	if body.MaxChars != config.DefaultSkillsMaxChars {
+		t.Fatalf("max_chars=%d want=%d", body.MaxChars, config.DefaultSkillsMaxChars)
+	}
+	if body.Items == nil || len(body.Items) != 0 {
+		t.Fatalf("expected empty items array, got %#v", body.Items)
+	}
+	// 空数组要序列化成 []，不能是 null。
+	if !strings.Contains(rec.Body.String(), `"items":[]`) {
+		t.Fatalf("expected items to serialize as [], got %s", rec.Body.String())
+	}
+}
+
+func TestUpdateSkillsSavesAndResolves(t *testing.T) {
+	h := newSkillsTestHandler(t, `{"keys":["k1"]}`)
+	rec := putSkills(t, h, map[string]any{
+		"enabled":   true,
+		"max_chars": 200,
+		"items": []any{
+			map[string]any{"id": "sql-report", "name": "SQL 报表", "description": "按固定口径写 SQL", "body": "# 说明\n先对齐口径"},
+			map[string]any{"id": "review_v2", "name": "评审", "body": "评审要点"},
+		},
+	})
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
+	}
+	var result map[string]any
+	if err := json.Unmarshal(rec.Body.Bytes(), &result); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if ok, _ := result["success"].(bool); !ok {
+		t.Fatalf("expected success=true, got %v", result)
+	}
+	if got, _ := result["count"].(float64); int(got) != 2 {
+		t.Fatalf("count=%v want=2", result["count"])
+	}
+
+	snap := h.Store.Snapshot()
+	if !snap.Skills.IsEnabled() {
+		t.Fatal("expected skills enabled after save")
+	}
+	if got := snap.Skills.EffectiveMaxChars(); got != 200 {
+		t.Fatalf("max_chars=%d want=200", got)
+	}
+	if len(snap.Skills.Items) != 2 || snap.Skills.Items[0].ID != "sql-report" {
+		t.Fatalf("unexpected stored items: %#v", snap.Skills.Items)
+	}
+	settings := h.Store.Snapshot().Skills
+	if !settings.IsEnabled() || len(settings.Items) != 2 {
+		t.Fatalf("expected saved skills to be stored, got %#v", settings)
+	}
+}
+
+func TestUpdateSkillsReplacesWholeLibrary(t *testing.T) {
+	h := newSkillsTestHandler(t, `{
+		"keys":["k1"],
+		"skills":{"enabled":true,"max_chars":50,"items":[{"id":"old","body":"old body"}]}
+	}`)
+	rec := putSkills(t, h, map[string]any{
+		"enabled": false,
+		"items":   []any{map[string]any{"id": "fresh", "body": "fresh body"}},
+	})
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
+	}
+	snap := h.Store.Snapshot()
+	if snap.Skills.IsEnabled() {
+		t.Fatal("expected enabled=false after replace")
+	}
+	if len(snap.Skills.Items) != 1 || snap.Skills.Items[0].ID != "fresh" {
+		t.Fatalf("expected whole replacement, got %#v", snap.Skills.Items)
+	}
+	if got := snap.Skills.EffectiveMaxChars(); got != config.DefaultSkillsMaxChars {
+		t.Fatalf("omitted max_chars should reset to default, got %d", got)
+	}
+}
+
+func TestUpdateSkillsRejectsDuplicateID(t *testing.T) {
+	h := newSkillsTestHandler(t, `{"keys":["k1"]}`)
+	rec := putSkills(t, h, map[string]any{
+		"enabled": true,
+		"items": []any{
+			map[string]any{"id": "same", "body": "a"},
+			map[string]any{"id": "same", "body": "b"},
+		},
+	})
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	if !strings.Contains(rec.Body.String(), "duplicate skill id") {
+		t.Fatalf("expected duplicate detail, got %s", rec.Body.String())
+	}
+	if h.Store.Snapshot().Skills.IsEnabled() {
+		t.Fatal("rejected payload must not persist")
+	}
+}
+
+func TestUpdateSkillsRejectsInvalidID(t *testing.T) {
+	h := newSkillsTestHandler(t, `{"keys":["k1"]}`)
+	for _, id := range []string{"SQL Report", "报表", "SQL-Report", ""} {
+		rec := putSkills(t, h, map[string]any{
+			"enabled": true,
+			"items":   []any{map[string]any{"id": id, "body": "body"}},
+		})
+		if rec.Code != http.StatusBadRequest {
+			t.Fatalf("id %q: expected 400, got %d body=%s", id, rec.Code, rec.Body.String())
+		}
+	}
+}
+
+func TestUpdateSkillsRejectsTooLongBody(t *testing.T) {
+	h := newSkillsTestHandler(t, `{"keys":["k1"]}`)
+	rec := putSkills(t, h, map[string]any{
+		"enabled": true,
+		"items": []any{
+			map[string]any{"id": "long", "body": strings.Repeat("字", config.MaxSkillBodyChars+1)},
+		},
+	})
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	if !strings.Contains(rec.Body.String(), "body cannot exceed") {
+		t.Fatalf("expected body length detail, got %s", rec.Body.String())
+	}
+}
+
+func TestUpdateSkillsRejectsTooManyItems(t *testing.T) {
+	h := newSkillsTestHandler(t, `{"keys":["k1"]}`)
+	items := make([]any, 0, config.MaxSkillItems+1)
+	for i := 0; i <= config.MaxSkillItems; i++ {
+		items = append(items, map[string]any{"id": "skill-" + string(rune('a'+i)), "body": "body"})
+	}
+	rec := putSkills(t, h, map[string]any{"enabled": true, "items": items})
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	if !strings.Contains(rec.Body.String(), "cannot exceed") {
+		t.Fatalf("expected item count detail, got %s", rec.Body.String())
+	}
+}
+
+func TestUpdateSkillsRejectsNegativeMaxChars(t *testing.T) {
+	h := newSkillsTestHandler(t, `{"keys":["k1"]}`)
+	rec := putSkills(t, h, map[string]any{"enabled": true, "max_chars": -1})
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	if !strings.Contains(rec.Body.String(), "max_chars") {
+		t.Fatalf("expected max_chars detail, got %s", rec.Body.String())
+	}
+}
+
+func TestUpdateSkillsZeroMaxCharsMeansUnlimited(t *testing.T) {
+	h := newSkillsTestHandler(t, `{"keys":["k1"]}`)
+	rec := putSkills(t, h, map[string]any{"enabled": true, "max_chars": 0})
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
+	}
+	snap := h.Store.Snapshot()
+	if snap.Skills.MaxChars == nil {
+		t.Fatal("expected explicit max_chars pointer to be stored")
+	}
+	if got := h.Store.SkillsMaxChars(); got != 0 {
+		t.Fatalf("expected unlimited max_chars, got %d", got)
+	}
+}
+
+func TestGetSkillsReflectsStoredConfig(t *testing.T) {
+	h := newSkillsTestHandler(t, `{
+		"keys":["k1"],
+		"skills":{
+			"enabled":true,
+			"max_chars":321,
+			"items":[{"id":"sql-report","name":"SQL 报表","body":"body"}]
+		}
+	}`)
+	req := httptest.NewRequest(http.MethodGet, "/admin/skills", nil)
+	rec := httptest.NewRecorder()
+	h.getSkills(rec, req)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
+	}
+	var body skillsPayload
+	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+	if !body.Enabled || body.MaxChars != 321 {
+		t.Fatalf("unexpected settings: %#v", body)
+	}
+	if len(body.Items) != 1 || body.Items[0].Name != "SQL 报表" {
+		t.Fatalf("unexpected items: %#v", body.Items)
+	}
+}

internal/httpapi/admin/skills/routes.go

@@ -0,0 +1,8 @@
+package skills
+
+import "github.com/go-chi/chi/v5"
+
+func RegisterRoutes(r chi.Router, h *Handler) {
+	r.Get("/skills", h.getSkills)
+	r.Put("/skills", h.updateSkills)
+}

internal/httpapi/claude/current_input_file_test.go

@@ -28,6 +28,8 @@ func (claudeCurrentInputAuth) Determine(*http.Request) (*auth.RequestAuth, error
 	return &auth.RequestAuth{
 		DeepSeekToken: "direct-token",
 		CallerID:      "caller:test",
+		// 这些用例验证工具说明文件上传，需要显式开启工具调用（默认关闭）。
+		ToolsEnabled:  true,
 		TriedAccounts: map[string]bool{},
 	}, nil
 }
@@ -189,7 +191,7 @@ func TestClaudeCurrentInputFileUploadsToolsSeparately(t *testing.T) {
 		t.Fatalf("history transcript should not embed tool descriptions, got %q", historyText)
 	}
 	toolsText := string(ds.uploads[1].Data)
-	if !strings.Contains(toolsText, "# context_tools.txt") || !strings.Contains(toolsText, "Tool: search") || !strings.Contains(toolsText, "Description: Search docs") {
+	if !strings.Contains(toolsText, "# 可用工具说明") || !strings.Contains(toolsText, "Tool: search") || !strings.Contains(toolsText, "Description: Search docs") {
 		t.Fatalf("expected tools transcript to include tool schema, got %q", toolsText)
 	}
 	refIDs, _ := ds.payload["ref_file_ids"].([]any)

internal/httpapi/claude/deps_injection_test.go

@@ -25,7 +25,7 @@ func TestNormalizeClaudeRequestUsesGlobalAliasMapping(t *testing.T) {
 	if err != nil {
 		t.Fatalf("normalizeClaudeRequest error: %v", err)
 	}
-	if out.Standard.ResolvedModel != "deepseek-v4-pro-search" {
+	if out.Standard.ResolvedModel != "deepseek-v4-flash-search" {
 		t.Fatalf("resolved model mismatch: got=%q", out.Standard.ResolvedModel)
 	}
 	if !out.Standard.Thinking || !out.Standard.Search {
@@ -87,7 +87,7 @@ func TestNormalizeClaudeRequestNoThinkingAliasForcesThinkingOff(t *testing.T) {
 	if err != nil {
 		t.Fatalf("normalizeClaudeRequest error: %v", err)
 	}
-	if out.Standard.ResolvedModel != "deepseek-v4-pro-nothinking" {
+	if out.Standard.ResolvedModel != "deepseek-v4-flash-nothinking" {
 		t.Fatalf("resolved model mismatch: got=%q", out.Standard.ResolvedModel)
 	}
 	if out.Standard.Thinking {

internal/httpapi/claude/handler_messages.go

@@ -85,6 +85,8 @@ func (h *Handler) handleClaudeDirect(w http.ResponseWriter, r *http.Request) boo
 		return true
 	}
 	defer h.Auth.Release(a)
+	// 工具调用默认关闭：关闭时忽略请求里的工具定义，按纯对话处理。
+	norm.Standard = promptcompat.ApplyToolsPolicy(a != nil && a.ToolsEnabled, norm.Standard)
 	stdReq, err := h.applyCurrentInputFile(r.Context(), a, norm.Standard)
 	if err != nil {
 		status, message := mapCurrentInputFileError(err)

internal/httpapi/claude/proxy_vercel_test.go

@@ -102,8 +102,8 @@ func TestClaudeProxyViaOpenAIUsesGlobalAliasMapping(t *testing.T) {
 	if rec.Code != http.StatusOK {
 		t.Fatalf("unexpected status: %d body=%s", rec.Code, rec.Body.String())
 	}
-	if got := strings.TrimSpace(openAI.seenModel); got != "deepseek-v4-pro" {
-		t.Fatalf("expected mapped proxy model deepseek-v4-pro, got %q", got)
+	if got := strings.TrimSpace(openAI.seenModel); got != "deepseek-v4-flash" {
+		t.Fatalf("expected mapped proxy model deepseek-v4-flash, got %q", got)
 	}
 }
 

internal/httpapi/claude/standard_request.go

@@ -40,6 +40,7 @@ func normalizeClaudeRequest(store ConfigReader, req map[string]any) (claudeNorma
 	if config.IsNoThinkingModel(dsModel) {
 		thinkingEnabled = false
 	}
+	searchEnabled = util.ResolveSearchEnabled(req, searchEnabled)
 	finalPrompt := prompt.MessagesPrepareWithThinking(toMessageMaps(dsPayload["messages"]), thinkingEnabled)
 	toolNames := extractClaudeToolNames(toolsRequested)
 	if len(toolNames) == 0 && len(toolsRequested) > 0 {