feat(prompt): 新增 prompt_style 风格档位与自定义模型列表

- 新增 prompt_style：v2（缺省）/ legacy。legacy 把衔接指令换回 ce5a019 的
短文案，且不注入内置执行契约（自己配置的思考提示词仍然生效），用于恢复
旧版「几乎不加约束」的手感；未知值回落 v2，后台 PUT 传错返回 400
- 新增 model_profiles 自定义模型列表（缺省空，最多 50 条）：id + base +
name/remark + 该模型专属 prompt；模型解析优先于内置别名映射，
/v1/models 一并列出（owned_by=ds2api）
- 模型提示词与全局 prompt_profile 互斥（命中优先，否则回落），与技能层合成
单个 System 段；注入点仍在历史拆分之后，不动 Messages
- 新增 GET/PUT /admin/model_profiles（整体替换语义 + 字符集/基模/上限校验）
- /admin/settings 增加 prompt_style 与 model_profiles 摘要
- 后台新增「自定义模型」板块与「内置提示词风格」下拉，中英文案同步
- 同步 prompt-compatibility.md / prompt-design.md / API(.*).md /
README.en.md / config.example.json

API.en.md

@@ -867,6 +867,53 @@ Every `api_keys` entry may carry `prompt_profile` to pick a preset or body for t
 
 When the global `prompt_profile.enabled` is `false`, none of the above applies to any key.
 
+### `prompt_style` (built-in prompt style, global)
+
+A top-level string. It only switches the built-in texts; anything you configure yourself is unaffected.
+
+```json
+{"prompt_style": "legacy"}
+```
+
+| Value | Behaviour |
+| --- | --- |
+| `v2` (default, empty string also means this) | After a history split the continuation prompt carries an "execution requirements" block (honour earlier requirements item by item) and the built-in execution contract (thinking injection) is injected |
+| `legacy` | Continuation goes back to the short pre-`ce5a019` wording and the built-in contract is **not** injected; a `thinking_injection.prompt` you configured explicitly is still injected |
+
+An unknown value never breaks config loading: it falls back to `v2` with a warning. `PUT /admin/settings` rejects unknown values with 400.
+
+### `model_profiles` (custom model list, global)
+
+Expose several public model names on top of the same flash base model, each carrying its own prompt. Whichever name the client sends decides the prompt; entries never affect each other.
+
+```json
+{
+  "model_profiles": [
+    {
+      "id": "deepseek-writer",
+      "base": "deepseek-v4-flash",
+      "name": "Writing",
+      "remark": "Long-form and rewrites",
+      "prompt": "## Writing rules\n…"
+    }
+  ]
+}
+```
+
+| Field | Notes |
+| --- | --- |
+| `id` | Required public model name. Charset `[A-Za-z0-9._-]`, 1-64 characters, must not collide with a built-in model name (e.g. `deepseek-v4-flash`), unique across entries (case-insensitive) |
+| `base` | Required base model: `deepseek-v4-flash` / `-search` / `-nothinking` / `-search-nothinking` |
+| `name` / `remark` | Optional, only for readability in the panel and in exports |
+| `prompt` | Optional prompt that applies to this model only, max 20000 characters; empty adds no extra spec |
+
+Resolution and injection:
+
+- Model resolution prefers custom entries over built-in aliases: a matching `id` calls upstream with its `base` (`/v1/models`, `/v1/models/{id}`, `/v1/chat/completions`, Claude and Gemini entries all share the same resolver).
+- `/v1/models` lists the custom models too, with `owned_by` = `ds2api`.
+- The prompt is injected at the same point as `prompt_profile` (after history splitting, before the skill layer) and the two are **mutually exclusive**: a non-empty model `prompt` wins, otherwise the global `prompt_profile` applies.
+- At most 50 entries. See [`GET` / `PUT /admin/model_profiles`](#get--put-adminmodel_profiles).
+
 ### `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.
@@ -909,6 +956,8 @@ Reads runtime settings and status, including:
 - `current_input_file` (`enabled` defaults to `true`, plus `min_chars`)
 - `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`
 - `prompt_profile` (`enabled` defaults to `false`, `enabled_default` always `false`, plus `name`, `prompt` and `presets`); `presets` is the built-in `[{name, body}]` list, so the panel can show the body a blank input falls back to
+- `prompt_style` (`mode`: effective style `v2` / `legacy`; `modes`: allowed values; `default`: `v2`; `value_raw`: the value stored in config)
+- `model_profiles` (`count`, `max_count`, `base_models`, `max_id_chars`, `max_prompt_chars`); the entries themselves are managed through `/admin/model_profiles`
 - `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`
@@ -926,6 +975,7 @@ Hot-updates runtime settings. Supported fields:
 - `current_input_file.enabled` / `current_input_file.min_chars`
 - `thinking_injection.enabled` / `thinking_injection.prompt`
 - `prompt_profile.enabled` / `prompt_profile.name` / `prompt_profile.prompt`
+- `prompt_style`
 - `tools.enabled`
 - `model_aliases`
 - `toolcall` policy is fixed and is no longer writable through settings
@@ -938,6 +988,14 @@ Hot-updates runtime settings. Supported fields:
 
 For the injection position, layering order and preset bodies see [docs/prompt-compatibility.md](docs/prompt-compatibility.md) and [docs/prompt-design.md](docs/prompt-design.md).
 
+`prompt_style` is a top-level string (not an object); it accepts `v2` / `legacy` / an empty string (empty means back to v2):
+
+```json
+{"prompt_style": "legacy"}
+```
+
+The custom model list does not go through settings — use `/admin/model_profiles` below, which replaces the whole list.
+
 `tools.enabled` only changes the field you actually send; the existing semantics of every other setting stay the same:
 
 ```json
@@ -1017,6 +1075,41 @@ A plain-text skill library, experimental and off by default (`skills.enabled=fal
 
 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.
 
+### `GET` / `PUT /admin/model_profiles`
+
+The custom model list (public name + base model + per-model prompt). Like the skill library it is a standalone endpoint with whole-list replacement semantics: the `items` you send become the final list, and an empty array clears it.
+
+**GET response**:
+
+```json
+{
+  "items": [
+    {"id": "deepseek-writer", "base": "deepseek-v4-flash", "name": "Writing", "remark": "long-form", "prompt": "## Writing rules\n…"}
+  ],
+  "base_models": ["deepseek-v4-flash", "deepseek-v4-flash-search", "deepseek-v4-flash-nothinking", "deepseek-v4-flash-search-nothinking"],
+  "max_count": 50,
+  "max_id_chars": 64,
+  "max_prompt_chars": 20000
+}
+```
+
+**PUT request**:
+
+```json
+{"items": [{"id": "deepseek-writer", "base": "deepseek-v4-flash", "prompt": "…"}]}
+```
+
+**Validation** (any failure returns `400` with `{"detail": "..."}`):
+
+| Field | Rule |
+| --- | --- |
+| `items` | At most 50 entries |
+| `id` | Required, unique (case-insensitive), charset `[A-Za-z0-9._-]`, 1-64 characters, must not shadow a built-in model name |
+| `base` | Required, one of the four `deepseek-v4-flash` names |
+| `prompt` | Optional, ≤ 20000 characters |
+
+Saving takes effect immediately: `/v1/models` and model-name resolution pick up the new entries without a restart.
+
 ### `POST /admin/config/import`
 
 Imports full config with:

API.md

@@ -872,6 +872,53 @@ data: {"type":"message_stop"}
 
 全局 `prompt_profile.enabled=false` 时上表全部不生效，任何 Key 都不注入。
 
+### `prompt_style`（内置提示词风格，全局）
+
+顶层字符串字段，只影响内置文案，不影响你自己配置的提示词：
+
+```json
+{"prompt_style": "legacy"}
+```
+
+| 值 | 行为 |
+| --- | --- |
+| `v2`（缺省，也接受空串） | 历史拆分后的衔接指令带「执行要求」（上文要求逐条满足）并注入内置执行契约（思考注入） |
+| `legacy` | 衔接指令换回 ce5a019 时代的短文案，且**不注入内置执行契约**；显式配置过 `thinking_injection.prompt` 时仍然注入自定义内容 |
+
+未知值不会让配置加载失败：按 `v2` 处理并打一条告警。后台 `PUT /admin/settings` 传未知值直接返回 400。
+
+### `model_profiles`（自定义模型列表，全局）
+
+给同一个 flash 基模挂出多个对外模型名，每个名字带自己的提示词。客户端请求里写哪个模型名，就用哪一份提示词，互不影响。
+
+```json
+{
+  "model_profiles": [
+    {
+      "id": "deepseek-writer",
+      "base": "deepseek-v4-flash",
+      "name": "写作",
+      "remark": "长文与改稿",
+      "prompt": "## 写作要求\n…"
+    }
+  ]
+}
+```
+
+| 字段 | 说明 |
+| --- | --- |
+| `id` | 必填，对外模型名。字符集 `[A-Za-z0-9._-]`，长度 1-64，不可与内置模型名（如 `deepseek-v4-flash`）冲突，条目间不可重复（大小写不敏感） |
+| `base` | 必填，基模，只能是 `deepseek-v4-flash` / `-search` / `-nothinking` / `-search-nothinking` |
+| `name` / `remark` | 可选，仅用于后台与导出可读性 |
+| `prompt` | 可选，该模型专属提示词，上限 20000 字符；为空表示不额外注入 |
+
+解析与注入语义：
+
+- 模型名解析优先于内置别名映射：`id` 命中自定义模型时按它的 `base` 调用上游（`/v1/models`、`/v1/models/{id}`、`/v1/chat/completions`、Claude / Gemini 入口共用同一套解析）。
+- `/v1/models` 会把自定义模型一起列出来，`owned_by` 为 `ds2api`。
+- 提示词注入点与 `prompt_profile` 相同（历史拆分之后、技能层之前），两者**互斥**：该模型配了非空 `prompt` 就用它，否则回落到全局 `prompt_profile`。
+- 数量上限 50 条。接口见 [`GET` / `PUT /admin/model_profiles`](#get--put-adminmodel_profiles)。
+
 ### `api_keys[].skills`（单 Key 覆盖技能注入）
 
 `api_keys` 的每一项都可以带 `skills`，用来指定这个 API Key 注入哪些技能，与 `thinking_injection` 并列；`keys` 旧格式不支持该字段。
@@ -908,12 +955,14 @@ data: {"type":"message_stop"}
 - `admin`（`has_password_hash`、`jwt_expire_hours`、`jwt_valid_after_unix`、`default_password_warning`）
 - `runtime`（`account_max_inflight`、`account_max_queue`、`global_max_inflight`、`token_refresh_interval_hours`）
 - `runtime.token_refresh_interval_hours` 的语义是「会话体检间隔」：到期只做一次无密码复核（`GET /api/v0/users/current`），只有服务端明确拒绝会话时才回退到密码登录
-- `config_snapshot`：原始配置快照（`admin` / `runtime` / `responses` / `embeddings` / `auto_delete` / `current_input_file` / `thinking_injection` / `prompt_profile` / `model_aliases`），用于区分环境变量覆盖前的配置
+- `config_snapshot`：原始配置快照（`admin` / `runtime` / `responses` / `embeddings` / `auto_delete` / `current_input_file` / `thinking_injection` / `prompt_profile` / `prompt_style` / `model_profiles` / `model_aliases`），用于区分环境变量覆盖前的配置
 - `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`）；`prompt` 为空时使用内置默认提示词，单 Key 可用 `api_keys[].thinking_injection` 覆盖
 - `prompt_profile`（`enabled` 缺省 `false`、`enabled_default` 固定 `false`、`name`、`prompt`、`presets`）；`presets` 是 `[{name, body}]` 的内置预设清单，`body` 为该预设正文，供面板在输入框里显示「留空时使用的默认正文」
+- `prompt_style`（`mode`：生效风格 `v2` / `legacy`；`modes`：可选值；`default`：`v2`；`value_raw`：配置里原样存的值）
+- `model_profiles`（`count`、`max_count`、`base_models`、`max_id_chars`、`max_prompt_chars`）；条目本身用 `/admin/model_profiles` 读写
 - `model_aliases`
 - `tools`（`enabled`：工具调用总开关，缺省 `false`；`default_enabled`：固定 `false`，供面板显示默认值）
 - `env_backed`、`needs_vercel_sync`
@@ -931,6 +980,7 @@ data: {"type":"message_stop"}
 - `current_input_file.enabled` / `current_input_file.min_chars`
 - `thinking_injection.enabled` / `thinking_injection.prompt`
 - `prompt_profile.enabled` / `prompt_profile.name` / `prompt_profile.prompt`
+- `prompt_style`
 - `tools.enabled`
 - `model_aliases`
 - `toolcall` 策略已固定，不再作为可写入字段
@@ -943,6 +993,14 @@ data: {"type":"message_stop"}
 
 注入位置、拼接顺序与预设正文见 [docs/prompt-compatibility.md](docs/prompt-compatibility.md) 与 [docs/prompt-design.md](docs/prompt-design.md)。
 
+`prompt_style` 是顶层字符串（不是对象），只接受 `v2` / `legacy` / 空串（空串等于回到 v2）：
+
+```json
+{"prompt_style": "legacy"}
+```
+
+自定义模型列表不走 settings，用下面的 `/admin/model_profiles` 整体替换。
+
 `tools.enabled` 只改请求体里传了的字段，其它设置的现有语义不变：
 
 ```json
@@ -1022,6 +1080,41 @@ data: {"type":"message_stop"}
 
 校验在写入时执行，与 `enabled` 无关：先关着开关把内容配好、改好，再打开即可。超限、重复 `id`、非法 `id` 都不会被静默修正。
 
+### `GET` / `PUT /admin/model_profiles`
+
+自定义模型列表（模型名 + 基模 + 该模型专属提示词）。与技能库同样是独立接口、整体替换语义：PUT 请求里的 `items` 就是最终列表，传空数组表示清空。
+
+**GET 响应**：
+
+```json
+{
+  "items": [
+    {"id": "deepseek-writer", "base": "deepseek-v4-flash", "name": "写作", "remark": "长文", "prompt": "## 写作要求\n…"}
+  ],
+  "base_models": ["deepseek-v4-flash", "deepseek-v4-flash-search", "deepseek-v4-flash-nothinking", "deepseek-v4-flash-search-nothinking"],
+  "max_count": 50,
+  "max_id_chars": 64,
+  "max_prompt_chars": 20000
+}
+```
+
+**PUT 请求**：
+
+```json
+{"items": [{"id": "deepseek-writer", "base": "deepseek-v4-flash", "prompt": "…"}]}
+```
+
+**校验规则**（任一条不满足返回 `400`，响应体为 `{"detail": "..."}`）：
+
+| 字段 | 规则 |
+| --- | --- |
+| `items` | 最多 50 条 |
+| `id` | 必填、唯一（大小写不敏感），字符集 `[A-Za-z0-9._-]`，长度 1-64，不可与内置模型名冲突 |
+| `base` | 必填，只能是 `deepseek-v4-flash` 系列的四个名字之一 |
+| `prompt` | 可空；≤ 20000 字符 |
+
+保存后立即生效：`/v1/models` 列表与模型名解析都会包含新条目，无需重启。
+
 ### `POST /admin/config/import`
 
 导入完整配置，支持：

README.en.md

@@ -339,6 +339,8 @@ Common fields:
 - If you turn off `current_input_file`, requests pass through directly without uploading any split context file.
 - `thinking_injection`: global thinking-format injection (the "execution contract"); `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. When a request triggers history splitting, the contract is re-applied to the visible prompt so it never gets buried in the uploaded transcript.
 - `prompt_profile`: prompt-profile layer, **off by default** (`enabled: false`). It prepends one server-side spec block (`name`: `default` / `writing`, or a custom `prompt` up to 20000 characters) to the final prompt, merged with the skill block into a single `System:` section. Presets defer to the user/client persona when they conflict. A single key can override it with `api_keys[].prompt_profile` (`custom` / `enabled` / `name` / `prompt`).
+- `prompt_style`: built-in prompt style, `v2` (default) or `legacy`. `v2` keeps the requirement-carrying continuation prompt and injects the built-in execution contract; `legacy` restores the short pre-`ce5a019` continuation wording and injects no built-in contract (a `thinking_injection.prompt` you set yourself still applies). Switch to `legacy` when replies feel too short or too customer-service-like.
+- `model_profiles`: custom model list (empty by default), at most 50 entries. Each entry maps a public model name (`id`) to a flash-family `base` plus an optional per-model `prompt` (max 20000 characters). Custom names take precedence over built-in aliases, show up in `/v1/models`, and their prompt replaces — never stacks with — `prompt_profile`. Managed through `GET/PUT /admin/model_profiles`.
 - `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`.
 

config.example.json

@@ -65,6 +65,9 @@
     "name": "default",
     "prompt": ""
   },
+  "prompt_style": "v2",
+  "_prompt_style_comment": "内置提示词风格：v2（缺省，衔接指令带执行要求并注入执行契约）/ legacy（旧版短文案，不注入执行契约）",
+  "model_profiles": [],
   "tools": {
     "enabled": false
   },

docs/prompt-compatibility.md

@@ -32,8 +32,9 @@ StandardRequest（messages、final_prompt、thinking、search、tool 策略、re
     │     tools.enabled=false 时不注入工具说明（也不上传工具说明文件），不解析 tool_calls
     │     只有本轮真的发生了拆分，才把执行契约重新贴回可见 prompt（见第 4 节）
     ▼
-prompt 级叠加（提示词特化层 → 技能层）
-    │     prompt_profile（缺省关闭）与 skills（缺省关闭）合并成一个 System 段前置到 prompt 最前面
+prompt 级叠加（模型提示词 / 特化层 → 技能层）
+    │     自定义模型带提示词时用它，否则用 prompt_profile（两者互斥，都缺省关闭）
+    │     skills（缺省关闭）在内层；全部合并成一个 System 段前置到 prompt 最前面
     │     只改 prompt / PromptTokenText，不改 messages
     ▼
 组装 DeepSeek completion payload
@@ -237,10 +238,38 @@ DeepSeek web-chat 只接受一段 prompt 字符串和一组文件引用，没有
 
 ### System 段拼接（ApplySystemOverlays）
 
-`promptcompat.ApplySystemOverlays` 是 prompt 级叠加的唯一入口：多个非空片段用空行连接、共用**一个** `System: ` 前缀，顺序固定为 **特化层 → 技能层**（外层通用规范在前，更贴近当前任务的技能在后）。单片段时的输出与旧版技能注入逐字节一致。
+`promptcompat.ApplySystemOverlays` 是 prompt 级叠加的唯一入口：多个非空片段用空行连接、共用**一个** `System: ` 前缀，顺序固定为 **模型提示词 / 特化层（二选一）→ 技能层**（外层通用规范在前，更贴近当前任务的技能在后）。单片段时的输出与旧版技能注入逐字节一致。
 
 只改 `FinalPrompt` 与 `PromptTokenText`，不动 `Messages`，所以特化层与技能正文都不会出现在对话记录里。
 
+### 提示词风格（prompt_style）
+
+顶层字段，只切换**内置文案**，不改你自己配置的提示词：
+
+| 值 | 衔接指令（第 3 节） | 内置执行契约（第 4 节） |
+| --- | --- | --- |
+| `v2`（缺省） | 开头变体 + 「执行要求」 | 注入 |
+| `legacy` | ce5a019 时代的短文案 | **不注入**；若显式配置了 `thinking_injection.prompt`，照样注入该自定义内容 |
+
+两点需要知道：
+
+- `legacy` 的短衔接指令保留了防泄漏要求，只把那三句原文里偏弱的第二句统一成「不要提及文件、上下文或提示词本身」——防泄漏不属于风格约束，不该因为切旧版而放松。
+- 对话记录文件的格式（标题 `# 对话记录`、`[role=...]` 行）不随风格变化。与旧版的实际差距主要来自「有没有执行契约」和「衔接指令有多长」。
+
+### 模型专属提示词（model_profiles）
+
+自定义模型条目把「对外模型名 → 基模 + 提示词」绑在一起，适合把不同风格并排放给客户端选，而不是反复改全局开关。
+
+| 项目 | 行为 |
+| --- | --- |
+| 配置 | 顶层 `model_profiles`，数组，最多 50 条 |
+| 解析优先 | 自定义模型名优先于内置别名映射；命中后按其 `base` 调上游 |
+| 列表 | `/v1/models` 一并列出，`owned_by=ds2api`；Claude / Gemini 的模型列表接口不列 |
+| 注入点 | 与 `prompt_profile` 相同（拆分之后、技能之前） |
+| 与特化层关系 | **互斥**：该模型 `prompt` 非空就用它，否则回落到全局 `prompt_profile` |
+| 生效范围 | 只对该模型名生效；客户端换回 `deepseek-v4-flash` 就等于关掉它 |
+| 管理接口 | `GET/PUT /admin/model_profiles`，整体替换语义 |
+
 ### 技能注入（skills）
 
 技能是一段服务端配置的纯文本 markdown，直接拼进 prompt。模型全程不需要输出工具调用，看到的只是普通上下文，因此不会碰到 DSML 风控。
@@ -378,6 +407,14 @@ Kelivo 这类客户端把界面上的「思维强度」翻译成 `reasoning_effo
 
 现状说明：Kelivo 对「自定义 OpenAI 兼容服务」不会发送原生搜索标记，所以要用联网请选 `-search` 模型；一旦客户端开始发送上述显式信号，服务端会自动跟随，不需要改配置。
 
+### 自定义模型（model_profiles）
+
+`model_profiles` 里的模型名与内置模型走同一套解析：`config.ResolveModel` 先查自定义条目，再退回内置模型与别名映射。因此：
+
+- `-nothinking` / `-search` 这类后缀语义仍然只作用于**基模**：`base` 直接写完整名字（如 `deepseek-v4-flash-search-nothinking`），自定义模型名本身不再二次解释后缀。
+- 思考与联网的默认值同样按解析后的基模决定，因此「某个自定义模型强制关思考」的做法是给它选 `-nothinking` 基模，而不是在条目上加开关。
+- `/v1/models` 会列出全部内置模型 + 自定义模型；`/anthropic/v1/models` 与 Ollama `/api/tags` 仍只列内置模型。
+
 ---
 
 ## 7. 协议适配器边界
@@ -429,6 +466,8 @@ Kelivo 这类客户端把界面上的「思维强度」翻译成 `reasoning_effo
 | 修复：历史拆分后执行契约被埋在附件里 | 拆分发生时把契约重贴到可见 `FinalPrompt`（只改 prompt，不改 `Messages` / `PromptTokenText`）。关闭思考注入或未发生拆分时行为不变 |
 | 新增 `prompt_profile` 提示词特化层（缺省关闭） | 默认不注入，现有请求逐字节不变；开启后只改 `FinalPrompt` / `PromptTokenText`，`Messages` 与对话记录不受影响 |
 | 技能注入改为走 `ApplySystemOverlays` | 单片段输出与旧实现逐字节一致；只有与特化层同时开启时才合并成一个 `System:` 段 |
+| 新增 `prompt_style`（`v2` 缺省 / `legacy`） | 缺省仍是 `v2`，现有请求不变；切 `legacy` 时衔接指令回到短文案且不注入内置执行契约（自定义思考提示词仍生效）。未知值回落 `v2`，不会让配置加载失败 |
+| 新增 `model_profiles` 自定义模型列表（缺省空） | 空列表时行为与之前完全一致；条目只影响请求里出现该模型名的调用，其他请求不受影响。自定义模型名优先于内置别名映射 |
 
 ---
 

docs/prompt-design.md

@@ -43,11 +43,26 @@ L4 技能层        前置 System 段：<skill> 正文块               BuildSki
 
 | 层 | 生效方式 | 缺省 | 改哪里 |
 | --- | --- | --- | --- |
-| L1 | 永远生效（历史拆分触发时） | 开 | `prompt_texts.go` 的 `currentInputContinuationOpenings` / `currentInputContinuationRequirements` |
-| L2 | `thinking_injection.enabled` | 开 | `thinking_injection.go` 的 `DefaultThinkingInjectionPrompt` |
-| L3 | `prompt_profile.enabled` | 关 | `prompt_texts.go` 的 `promptProfileDefaultBody` / `promptProfileWritingBody` |
+| L1 | 永远生效（历史拆分触发时） | 开 | `prompt_texts.go` 的 `currentInputContinuationOpenings` / `currentInputContinuationRequirements`（旧版见 `legacyContinuationOpenings`） |
+| L2 | `thinking_injection.enabled` × 风格 | 开 | `thinking_injection.go` 的 `DefaultThinkingInjectionPrompt`、`ResolveThinkingInjectionPrompt` |
+| L3 | `prompt_profile.enabled`，或自定义模型的 `prompt` | 关 | `prompt_texts.go` 的 `promptProfileDefaultBody` / `promptProfileWritingBody` |
 | L4 | `skills.enabled` | 关 | 后台「技能库」或配置文件 `skills.items` |
 
+另有一个**风格档位** `prompt_style`（`v2` 缺省 / `legacy`），它不改层次结构，只决定 L1 用哪版文案、以及是否注入 L2 的内置契约：
+
+| 风格 | L1 | L2 内置契约 |
+| --- | --- | --- |
+| `v2`（缺省） | 开头变体 + 「执行要求」 | 注入 |
+| `legacy` | 下面这段短文案 | **不注入**（你自己配的 `thinking_injection.prompt` 仍会注入） |
+
+```text
+已附上下文文件「ctx-xxxxxxxxxxxx.txt」。请直接回答最新问题，不要提及文件、上下文或提示词本身。
+```
+
+为什么保留旧版：`v2` 的约束对「做事」有效，但对闲聊会压掉模型的默认表达。实践反馈是——切到 `v2` 后回答变短、更像客服；旧版因为几乎不加约束，回答更长更放得开。两者都留着，由用户按场景选，而不是替他决定。
+
+---
+
 ---
 
 ## 3. 各层文案
@@ -215,6 +230,29 @@ L4 技能层        前置 System 段：<skill> 正文块               BuildSki
 
 差别：`preset` 是全局开关、作用于所有请求；`skills` 条目可被单个 API Key 挑选（`api_keys[].skills.ids`），适合「只有某个项目要长文规范」的场景。
 
+### 用法 C：自定义模型（把多套风格并排放给客户端）
+
+给同一个 flash 基模挂多个对外模型名，每个名字带自己的提示词。客户端在模型列表里就能直接选风格，不用来回改全局配置，回滚也只是换回原模型名。
+
+```json
+{
+  "model_profiles": [
+    {"id": "deepseek-writer", "base": "deepseek-v4-flash", "name": "写作", "prompt": "<writing 预设正文>"},
+    {"id": "deepseek-chat", "base": "deepseek-v4-flash", "name": "日常对话", "prompt": ""}
+  ]
+}
+```
+
+规则：模型命中且 `prompt` 非空时，**不会**再叠加全局 `prompt_profile`（两者互斥）；`prompt` 留空则回落到全局特化层。基模带 `-nothinking` / `-search` 后缀时，思考与联网默认值跟着基模走。后台在「自定义模型」板块维护，接口是 `GET/PUT /admin/model_profiles`。
+
+三种用法怎么选：
+
+| 需求 | 用哪个 |
+| --- | --- |
+| 所有请求统一换一套规范 | 用法 A（全局 preset） |
+| 只有某个项目/某个 Key 要额外规范 | 用法 B（skills 按 Key 挑） |
+| 想让客户端自己选风格，或要能一键退回原样 | 用法 C（自定义模型） |
+
 ---
 
 ## 7. 调优建议
@@ -227,6 +265,7 @@ L4 技能层        前置 System 段：<skill> 正文块               BuildSki
 4. **会不会被当成输出格式？** 凡是要模型「先列清单/先核对」的，都要补一句「内部完成、不要输出」。
 5. **会不会盖掉用户设定？** 任何前置 System 段都要声明与服务端规范冲突时以用户为准。
 6. **会不会泄漏？** 不要出现「附件」「文件」「上下文记录」「提示词」这类可以在回复里被复述的名词，除非紧跟着禁止提及。
+7. **要不要更放得开？** 如果你觉得回答太短、太像客服，不是文案该继续加约束，而是把 `prompt_style` 切到 `legacy`：它去掉执行契约、缩短衔接指令，让模型回到自己的默认风格。反过来，只有明确要「上文要求逐条兑现」时才留在 `v2`。
 
 参考的外部实践（写法上的依据，不是直接抄）：
 

internal/auth/request.go

@@ -45,6 +45,9 @@ type RequestAuth struct {
 	// PromptProfile 是本次请求生效的「提示词特化层」设置：全局设置叠加该 API Key
 	// 的自定义覆盖后得到的最终值。
 	PromptProfile config.PromptProfileSettings
+	// PromptStyle 是本次请求生效的内置提示词风格：v2（缺省）或 legacy。
+	// 只有全局开关，没有单 Key 覆盖。
+	PromptStyle string
 	// Skills 是本次请求生效的「纯文本技能库」设置：全局设置叠加该 API Key
 	// 的自定义覆盖后得到的最终值（Items 已按 Key 过滤）。
 	Skills config.SkillSettings
@@ -95,6 +98,7 @@ func (r *Resolver) Determine(req *http.Request) (*RequestAuth, error) {
 	callerLabel := r.callerLabel(callerKey)
 	injection := r.resolveInjection(callerKey)
 	promptProfile := r.resolvePromptProfile(callerKey)
+	promptStyle := r.promptStyle()
 	skills := r.resolveSkills(callerKey)
 	toolsEnabled := r.toolsEnabled()
 	ctx := req.Context()
@@ -106,6 +110,7 @@ func (r *Resolver) Determine(req *http.Request) (*RequestAuth, error) {
 			CallerLabel:    callerLabel,
 			Injection:      injection,
 			PromptProfile:  promptProfile,
+			PromptStyle:    promptStyle,
 			Skills:         skills,
 			ToolsEnabled:   toolsEnabled,
 			resolver:       r,
@@ -120,6 +125,7 @@ func (r *Resolver) Determine(req *http.Request) (*RequestAuth, error) {
 	a.CallerLabel = callerLabel
 	a.Injection = injection
 	a.PromptProfile = promptProfile
+	a.PromptStyle = promptStyle
 	a.Skills = skills
 	a.ToolsEnabled = toolsEnabled
 	return a, nil
@@ -159,6 +165,14 @@ func (r *Resolver) resolvePromptProfile(callerKey string) config.PromptProfileSe
 	return r.Store.ResolvePromptProfile(callerKey)
 }
 
+// promptStyle 返回全局生效的内置提示词风格；未配置时按 v2 处理。
+func (r *Resolver) promptStyle() string {
+	if r == nil || r.Store == nil {
+		return config.PromptStyleV2
+	}
+	return r.Store.PromptStyleMode()
+}
+
 // resolveSkills 解析全局 + 单 Key 自定义后的技能设置。
 func (r *Resolver) resolveSkills(callerKey string) config.SkillSettings {
 	if r == nil || r.Store == nil {
@@ -230,6 +244,7 @@ func (r *Resolver) DetermineCaller(req *http.Request) (*RequestAuth, error) {
 		CallerLabel:    r.callerLabel(callerKey),
 		Injection:      r.resolveInjection(callerKey),
 		PromptProfile:  r.resolvePromptProfile(callerKey),
+		PromptStyle:    r.promptStyle(),
 		Skills:         r.resolveSkills(callerKey),
 		ToolsEnabled:   r.toolsEnabled(),
 		resolver:       r,

internal/config/codec.go

@@ -54,6 +54,12 @@ func (c Config) MarshalJSON() ([]byte, error) {
 	if c.PromptProfile.Enabled != nil || strings.TrimSpace(c.PromptProfile.Name) != "" || strings.TrimSpace(c.PromptProfile.Prompt) != "" {
 		m["prompt_profile"] = c.PromptProfile
 	}
+	if strings.TrimSpace(c.PromptStyle) != "" {
+		m["prompt_style"] = c.PromptStyle
+	}
+	if len(c.ModelProfiles) > 0 {
+		m["model_profiles"] = c.ModelProfiles
+	}
 	if c.Skills.Enabled != nil || c.Skills.MaxChars != nil || len(c.Skills.Items) > 0 {
 		m["skills"] = c.Skills
 	}
@@ -151,6 +157,14 @@ func (c *Config) UnmarshalJSON(b []byte) error {
 			if err := json.Unmarshal(v, &c.PromptProfile); err != nil {
 				return fmt.Errorf("invalid field %q: %w", k, err)
 			}
+		case "prompt_style":
+			if err := json.Unmarshal(v, &c.PromptStyle); err != nil {
+				return fmt.Errorf("invalid field %q: %w", k, err)
+			}
+		case "model_profiles":
+			if err := json.Unmarshal(v, &c.ModelProfiles); 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)
@@ -210,6 +224,8 @@ func (c Config) Clone() Config {
 			Prompt:  c.ThinkingInjection.Prompt,
 		},
 		PromptProfile:    c.PromptProfile.Clone(),
+		PromptStyle:      c.PromptStyle,
+		ModelProfiles:    cloneModelProfiles(c.ModelProfiles),
 		Skills:           c.Skills.Clone(),
 		Tools:            c.Tools.Clone(),
 		Vercel:           c.Vercel,
@@ -224,6 +240,16 @@ func (c Config) Clone() Config {
 	return clone
 }
 
+// cloneModelProfiles 深拷贝自定义模型列表（字段均为值类型，复制切片即可）。
+func cloneModelProfiles(in []ModelProfileConfig) []ModelProfileConfig {
+	if len(in) == 0 {
+		return nil
+	}
+	out := make([]ModelProfileConfig, len(in))
+	copy(out, in)
+	return out
+}
+
 func cloneAPIKeys(in []APIKey) []APIKey {
 	if len(in) == 0 {
 		return nil

internal/config/config.go

@@ -23,13 +23,17 @@ type Config struct {
 	FileAudit         FileAuditConfig         `json:"file_audit,omitempty"`
 	ThinkingInjection ThinkingInjectionConfig `json:"thinking_injection,omitempty"`
 	PromptProfile     PromptProfileConfig     `json:"prompt_profile,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"`
-	VercelSyncTime    int64                   `json:"_vercel_sync_time,omitempty"`
-	AdditionalFields  map[string]any          `json:"-"`
+	// PromptStyle 是内置提示词风格档位：v2（缺省）/ legacy。
+	PromptStyle string `json:"prompt_style,omitempty"`
+	// ModelProfiles 是自定义模型列表：对外模型名 + 基模 + 该模型专属提示词。
+	ModelProfiles    []ModelProfileConfig `json:"model_profiles,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"`
+	VercelSyncTime   int64                `json:"_vercel_sync_time,omitempty"`
+	AdditionalFields map[string]any       `json:"-"`
 }
 
 type Account struct {
@@ -392,6 +396,33 @@ func (c *Config) NormalizeCredentials() {
 		Logger.Warn("[config] unknown prompt_profile.name, falling back to default",
 			"name", name, "allowed", strings.Join(PromptProfileNames(), ", "))
 	}
+	c.normalizePromptStyle()
+	c.ModelProfiles = NormalizeModelProfiles(c.ModelProfiles)
+}
+
+// normalizePromptStyle 归一化提示词风格档位；写错时回落 v2 并提示一次。
+func (c *Config) normalizePromptStyle() {
+	if c == nil {
+		return
+	}
+	raw := strings.TrimSpace(c.PromptStyle)
+	if raw == "" {
+		c.PromptStyle = ""
+		return
+	}
+	if !IsKnownPromptStyle(raw) && Logger != nil {
+		Logger.Warn("[config] unknown prompt_style, falling back to v2",
+			"value", raw, "allowed", strings.Join(PromptStyleNames(), ", "))
+	}
+	c.PromptStyle = NormalizePromptStyle(raw)
+}
+
+// PromptStyleMode 返回生效的提示词风格；未配置时按 v2 处理。
+func (c *Config) PromptStyleMode() string {
+	if c == nil {
+		return PromptStyleV2
+	}
+	return NormalizePromptStyle(c.PromptStyle)
 }
 
 // DropInvalidAccounts removes accounts that cannot be addressed by admin APIs

internal/config/model_profile.go

@@ -0,0 +1,207 @@
+package config
+
+import (
+	"fmt"
+	"strings"
+	"unicode/utf8"
+)
+
+// 内置提示词风格档位。
+//
+// 「风格」只决定两件事：历史拆分后的衔接指令用哪一版文案、以及是否注入内置执行契约。
+// 它不涉及特化层（prompt_profile）与技能层，那些仍然是独立开关。
+const (
+	// PromptStyleV2 是当前版本：衔接指令带「执行要求」，并注入内置执行契约。
+	PromptStyleV2 = "v2"
+	// PromptStyleLegacy 是旧版：衔接指令用短文案，且不注入内置执行契约
+	// （调用方显式配置过 thinking_injection.prompt 时仍然注入）。
+	PromptStyleLegacy = "legacy"
+)
+
+// PromptStyleNames 返回可选风格名，顺序固定，供后台下拉与文档对照。
+func PromptStyleNames() []string {
+	return []string{PromptStyleV2, PromptStyleLegacy}
+}
+
+// NormalizePromptStyle 归一化风格名：空或未知一律回落 v2。
+//
+// 配置文件里写错不会让加载失败（与 model_type 未知回落 default 一致），
+// 只有后台 PUT 会显式报 400。
+func NormalizePromptStyle(style string) string {
+	switch strings.ToLower(strings.TrimSpace(style)) {
+	case PromptStyleLegacy:
+		return PromptStyleLegacy
+	default:
+		return PromptStyleV2
+	}
+}
+
+// IsKnownPromptStyle 判断是否为可选风格名。
+func IsKnownPromptStyle(style string) bool {
+	switch strings.ToLower(strings.TrimSpace(style)) {
+	case PromptStyleV2, PromptStyleLegacy:
+		return true
+	default:
+		return false
+	}
+}
+
+// 自定义模型条目（model_profiles）的限制。
+const (
+	// MaxModelProfiles 是自定义模型条目的数量上限。
+	MaxModelProfiles = 50
+	// MaxModelProfileIDChars 是自定义模型名的字符上限。
+	MaxModelProfileIDChars = 64
+)
+
+// ModelProfileConfig 是一条自定义模型：对外名称 + 基模 + 该模型专属提示词。
+//
+// 用途：同一个 flash 基模可以挂出多个「模型名」，每个名字带自己的提示词，
+// 客户端按模型名选用，互不影响，比改全局开关更好回滚。
+type ModelProfileConfig struct {
+	// ID 是对外模型名，客户端在请求里写的就是它。
+	ID string `json:"id"`
+	// Base 是实际调用上游的基模，必须是当前支持的 flash 系列之一。
+	Base string `json:"base"`
+	// Name 是展示名（可选），仅用于后台与 /v1/models 的可读性。
+	Name string `json:"name,omitempty"`
+	// Remark 是备注（可选）。
+	Remark string `json:"remark,omitempty"`
+	// Prompt 是该模型专属的提示词正文；为空表示不额外注入（回落到全局 prompt_profile）。
+	Prompt string `json:"prompt,omitempty"`
+}
+
+// ModelProfileReader 由配置中心实现，供模型解析与列表接口读取自定义模型。
+type ModelProfileReader interface {
+	ModelProfiles() []ModelProfileConfig
+}
+
+// SupportedBaseModels 返回可作为基模的模型名。
+//
+// 只列 flash 系列：pro / vision 已经并进 flash，作为基模没有意义。
+func SupportedBaseModels() []string {
+	return []string{
+		"deepseek-v4-flash",
+		"deepseek-v4-flash-search",
+		"deepseek-v4-flash-nothinking",
+		"deepseek-v4-flash-search-nothinking",
+	}
+}
+
+// Normalize 归一化单条自定义模型：裁剪空白、基模转小写。
+func (m ModelProfileConfig) Normalize() ModelProfileConfig {
+	return ModelProfileConfig{
+		ID:     strings.TrimSpace(m.ID),
+		Base:   strings.ToLower(strings.TrimSpace(m.Base)),
+		Name:   strings.TrimSpace(m.Name),
+		Remark: strings.TrimSpace(m.Remark),
+		Prompt: TruncatePromptProfileText(m.Prompt),
+	}
+}
+
+// Clone 深拷贝（字段全是值类型，等价于 Normalize）。
+func (m ModelProfileConfig) Clone() ModelProfileConfig {
+	return m.Normalize()
+}
+
+// IsValidModelProfileID 判断模型名是否符合字符集要求：字母、数字、点、下划线、短横线。
+func IsValidModelProfileID(id string) bool {
+	id = strings.TrimSpace(id)
+	if id == "" || utf8.RuneCountInString(id) > MaxModelProfileIDChars {
+		return false
+	}
+	for _, r := range id {
+		switch {
+		case r >= 'a' && r <= 'z':
+		case r >= 'A' && r <= 'Z':
+		case r >= '0' && r <= '9':
+		case r == '.', r == '_', r == '-':
+		default:
+			return false
+		}
+	}
+	return true
+}
+
+// FindModelProfile 按模型名查找自定义模型，大小写不敏感。
+func FindModelProfile(profiles []ModelProfileConfig, id string) (ModelProfileConfig, bool) {
+	wanted := strings.ToLower(strings.TrimSpace(id))
+	if wanted == "" {
+		return ModelProfileConfig{}, false
+	}
+	for _, profile := range profiles {
+		if strings.ToLower(strings.TrimSpace(profile.ID)) == wanted {
+			return profile, true
+		}
+	}
+	return ModelProfileConfig{}, false
+}
+
+// NormalizeModelProfiles 归一化自定义模型列表：裁剪、去重（按模型名，先到先得）。
+func NormalizeModelProfiles(items []ModelProfileConfig) []ModelProfileConfig {
+	if len(items) == 0 {
+		return nil
+	}
+	out := make([]ModelProfileConfig, 0, len(items))
+	seen := make(map[string]struct{}, len(items))
+	for _, item := range items {
+		normalized := item.Normalize()
+		if normalized.ID == "" {
+			continue
+		}
+		key := strings.ToLower(normalized.ID)
+		if _, ok := seen[key]; ok {
+			continue
+		}
+		seen[key] = struct{}{}
+		out = append(out, normalized)
+	}
+	if len(out) == 0 {
+		return nil
+	}
+	return out
+}
+
+// ValidateModelProfiles 严格校验自定义模型列表，供后台写入使用。
+func ValidateModelProfiles(items []ModelProfileConfig) error {
+	if len(items) > MaxModelProfiles {
+		return fmt.Errorf("model_profiles cannot exceed %d entries", MaxModelProfiles)
+	}
+	baseModels := make(map[string]struct{}, 4)
+	for _, base := range SupportedBaseModels() {
+		baseModels[base] = struct{}{}
+	}
+	seen := make(map[string]struct{}, len(items))
+	for i, raw := range items {
+		// 长度上限要拿原始值判断：Normalize 会先截断，截断后再比永远不超限。
+		if utf8.RuneCountInString(strings.TrimSpace(raw.Prompt)) > MaxPromptProfileChars {
+			return fmt.Errorf("model_profiles[%d].prompt cannot exceed %d characters",
+				i, MaxPromptProfileChars)
+		}
+		item := raw.Normalize()
+		if item.ID == "" {
+			return fmt.Errorf("model_profiles[%d].id cannot be empty", i)
+		}
+		if !IsValidModelProfileID(item.ID) {
+			return fmt.Errorf("model_profiles[%d].id %q must be 1-%d characters of [A-Za-z0-9._-]",
+				i, item.ID, MaxModelProfileIDChars)
+		}
+		key := strings.ToLower(item.ID)
+		if _, ok := seen[key]; ok {
+			return fmt.Errorf("duplicate model_profiles id: %s", item.ID)
+		}
+		seen[key] = struct{}{}
+		// 不允许覆盖内置模型名：这会静默改变 flash 系列的行为。
+		if _, builtin := resolveSupportedModel(item.ID); builtin {
+			return fmt.Errorf("model_profiles id %q shadows a built-in model name", item.ID)
+		}
+		if item.Base == "" {
+			return fmt.Errorf("model_profiles[%d].base cannot be empty", i)
+		}
+		if _, ok := baseModels[item.Base]; !ok {
+			return fmt.Errorf("model_profiles[%d].base must be one of %s",
+				i, strings.Join(SupportedBaseModels(), ", "))
+		}
+	}
+	return nil
+}

internal/config/model_profile_test.go

@@ -0,0 +1,222 @@
+package config
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func TestPromptStyleDefaultsToV2(t *testing.T) {
+	var cfg Config
+	if got := cfg.PromptStyleMode(); got != PromptStyleV2 {
+		t.Fatalf("prompt style=%q want %q", got, PromptStyleV2)
+	}
+	store := &Store{cfg: Config{}}
+	if got := store.PromptStyleMode(); got != PromptStyleV2 {
+		t.Fatalf("store prompt style=%q want %q", got, PromptStyleV2)
+	}
+	cfg.PromptStyle = "legacy"
+	if got := cfg.PromptStyleMode(); got != PromptStyleLegacy {
+		t.Fatalf("prompt style=%q want legacy", got)
+	}
+	// 未知风格不报错，回落 v2（与 model_type 未知回落 default 一致）。
+	cfg.PromptStyle = "v3"
+	if got := cfg.PromptStyleMode(); got != PromptStyleV2 {
+		t.Fatalf("unknown style must fall back to v2, got %q", got)
+	}
+}
+
+func TestNormalizeCredentialsKeepsKnownPromptStyle(t *testing.T) {
+	cfg := Config{PromptStyle: "  LEGACY  "}
+	cfg.NormalizeCredentials()
+	if cfg.PromptStyle != PromptStyleLegacy {
+		t.Fatalf("expected legacy style normalized to lower case, got %q", cfg.PromptStyle)
+	}
+}
+
+func TestModelProfilesRoundTrip(t *testing.T) {
+	raw := `{
+		"prompt_style": "legacy",
+		"model_profiles": [
+			{"id": "deepseek-writer", "base": "deepseek-v4-flash", "name": "写作", "remark": "长文", "prompt": "  writing spec  "},
+			{"id": "deepseek-quiet", "base": "deepseek-v4-flash-nothinking"}
+		]
+	}`
+	var cfg Config
+	if err := json.Unmarshal([]byte(raw), &cfg); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+	cfg.NormalizeCredentials()
+	if len(cfg.ModelProfiles) != 2 {
+		t.Fatalf("expected 2 profiles, got %#v", cfg.ModelProfiles)
+	}
+	first := cfg.ModelProfiles[0]
+	if first.Prompt != "writing spec" {
+		t.Fatalf("expected trimmed prompt, got %q", first.Prompt)
+	}
+	if first.Base != "deepseek-v4-flash" {
+		t.Fatalf("unexpected base %q", first.Base)
+	}
+
+	encoded, err := json.Marshal(cfg)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+	var decoded Config
+	if err := json.Unmarshal(encoded, &decoded); err != nil {
+		t.Fatalf("re-unmarshal: %v", err)
+	}
+	decoded.NormalizeCredentials()
+	if len(decoded.ModelProfiles) != 2 || decoded.PromptStyle != PromptStyleLegacy {
+		t.Fatalf("profiles lost in round trip: %#v style=%q", decoded.ModelProfiles, decoded.PromptStyle)
+	}
+}
+
+func TestNormalizeModelProfilesDedupesAndDropsEmpty(t *testing.T) {
+	items := NormalizeModelProfiles([]ModelProfileConfig{
+		{ID: "  a  ", Base: " deepseek-v4-flash "},
+		{ID: "A", Base: "deepseek-v4-flash-search"},
+		{ID: "", Base: "deepseek-v4-flash"},
+		{ID: "b", Base: "deepseek-v4-flash"},
+	})
+	if len(items) != 2 {
+		t.Fatalf("expected 2 profiles after dedupe, got %#v", items)
+	}
+	if items[0].ID != "a" || items[0].Base != "deepseek-v4-flash" {
+		t.Fatalf("unexpected first profile: %#v", items[0])
+	}
+	if items[1].ID != "b" {
+		t.Fatalf("unexpected second profile: %#v", items[1])
+	}
+	if got := NormalizeModelProfiles(nil); got != nil {
+		t.Fatalf("expected nil for empty input, got %#v", got)
+	}
+}
+
+func TestValidateModelProfiles(t *testing.T) {
+	ok := []ModelProfileConfig{{ID: "deepseek-writer", Base: "deepseek-v4-flash"}}
+	if err := ValidateModelProfiles(ok); err != nil {
+		t.Fatalf("expected valid profiles, got %v", err)
+	}
+	cases := []struct {
+		name  string
+		items []ModelProfileConfig
+		want  string
+	}{
+		{name: "empty id", items: []ModelProfileConfig{{Base: "deepseek-v4-flash"}}, want: "id cannot be empty"},
+		{name: "bad charset", items: []ModelProfileConfig{{ID: "bad id", Base: "deepseek-v4-flash"}}, want: "must be 1-64"},
+		{name: "duplicate", items: []ModelProfileConfig{
+			{ID: "a", Base: "deepseek-v4-flash"},
+			{ID: "A", Base: "deepseek-v4-flash"},
+		}, want: "duplicate"},
+		{name: "shadows builtin", items: []ModelProfileConfig{{ID: "deepseek-v4-flash", Base: "deepseek-v4-flash"}}, want: "shadows a built-in"},
+		{name: "missing base", items: []ModelProfileConfig{{ID: "a"}}, want: "base cannot be empty"},
+		{name: "bad base", items: []ModelProfileConfig{{ID: "a", Base: "deepseek-v4-pro"}}, want: "base must be one of"},
+		{name: "too many", items: makeManyProfiles(MaxModelProfiles + 1), want: "cannot exceed"},
+		{name: "prompt too long", items: []ModelProfileConfig{
+			{ID: "a", Base: "deepseek-v4-flash", Prompt: strings.Repeat("字", MaxPromptProfileChars+1)},
+		}, want: "prompt cannot exceed"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			err := ValidateModelProfiles(tc.items)
+			if err == nil || !strings.Contains(err.Error(), tc.want) {
+				t.Fatalf("error=%v want contains %q", err, tc.want)
+			}
+		})
+	}
+}
+
+func makeManyProfiles(n int) []ModelProfileConfig {
+	items := make([]ModelProfileConfig, 0, n)
+	for i := 0; i < n; i++ {
+		items = append(items, ModelProfileConfig{
+			ID:   "m" + string(rune('a'+i%26)) + string(rune('a'+i/26)),
+			Base: "deepseek-v4-flash",
+		})
+	}
+	return items
+}
+
+func TestResolveModelUsesModelProfiles(t *testing.T) {
+	store := &Store{cfg: Config{
+		ModelProfiles: []ModelProfileConfig{
+			{ID: "deepseek-writer", Base: "deepseek-v4-flash"},
+			{ID: "DeepSeek-Quiet", Base: "deepseek-v4-flash-nothinking"},
+		},
+	}}
+	if got, ok := ResolveModel(store, "deepseek-writer"); !ok || got != "deepseek-v4-flash" {
+		t.Fatalf("resolved=%q ok=%v", got, ok)
+	}
+	// 大小写不敏感。
+	if got, ok := ResolveModel(store, "deepseek-quiet"); !ok || got != "deepseek-v4-flash-nothinking" {
+		t.Fatalf("resolved=%q ok=%v", got, ok)
+	}
+	// 内置模型与别名解析不受影响。
+	if got, ok := ResolveModel(store, "deepseek-v4-flash"); !ok || got != "deepseek-v4-flash" {
+		t.Fatalf("builtin resolved=%q ok=%v", got, ok)
+	}
+	if _, ok := ResolveModel(store, "not-a-model"); ok {
+		t.Fatal("expected unknown model to fail")
+	}
+}
+
+func TestStoreResolveModelPrompt(t *testing.T) {
+	store := &Store{cfg: Config{ModelProfiles: []ModelProfileConfig{
+		{ID: "deepseek-writer", Base: "deepseek-v4-flash", Prompt: " writing spec "},
+		{ID: "deepseek-plain", Base: "deepseek-v4-flash"},
+	}}}
+	if body, ok := store.ResolveModelPrompt("deepseek-writer"); !ok || body != "writing spec" {
+		t.Fatalf("body=%q ok=%v", body, ok)
+	}
+	// 没有提示词的条目不算命中，调用方应回落到全局特化层。
+	if _, ok := store.ResolveModelPrompt("deepseek-plain"); ok {
+		t.Fatal("expected empty prompt to be treated as no match")
+	}
+	if _, ok := store.ResolveModelPrompt("deepseek-v4-flash"); ok {
+		t.Fatal("expected builtin model to have no model prompt")
+	}
+}
+
+func TestOpenAIModelsIncludeProfiles(t *testing.T) {
+	store := &Store{cfg: Config{ModelProfiles: []ModelProfileConfig{
+		{ID: "deepseek-writer", Base: "deepseek-v4-flash", Name: "写作"},
+	}}}
+	models := OpenAIModelsFor(store)
+	found := false
+	for _, model := range models {
+		if model.ID == "deepseek-writer" {
+			found = true
+			if model.OwnedBy != "ds2api" {
+				t.Fatalf("unexpected owned_by %q", model.OwnedBy)
+			}
+		}
+		if model.ID == "deepseek-v4-flash" {
+			if model.OwnedBy != "deepseek" {
+				t.Fatalf("builtin must keep its owned_by, got %q", model.OwnedBy)
+			}
+		}
+	}
+	if !found {
+		t.Fatalf("expected custom model in list, got %#v", models)
+	}
+	info, ok := OpenAIModelByID(store, "deepseek-writer")
+	if !ok || info.ID != "deepseek-writer" {
+		t.Fatalf("expected profile by id, got %#v ok=%v", info, ok)
+	}
+	if _, ok := OpenAIModelByID(store, "not-a-model"); ok {
+		t.Fatal("expected unknown model to be missing")
+	}
+}
+
+func TestModelProfilesCloneIsIndependent(t *testing.T) {
+	cfg := Config{ModelProfiles: []ModelProfileConfig{{ID: "a", Base: "deepseek-v4-flash"}}}
+	clone := cfg.Clone()
+	if len(clone.ModelProfiles) != 1 {
+		t.Fatalf("clone lost profiles: %#v", clone.ModelProfiles)
+	}
+	clone.ModelProfiles[0].ID = "b"
+	if cfg.ModelProfiles[0].ID != "a" {
+		t.Fatal("mutating the clone must not affect the original")
+	}
+}

internal/config/models.go

@@ -257,6 +257,10 @@ func ResolveModel(store ModelAliasReader, requested string) (string, bool) {
 	if model == "" {
 		return "", false
 	}
+	// 自定义模型优先：用户在后台显式建的模型名应当盖过内置别名映射。
+	if base, ok := resolveModelProfileBase(store, model); ok {
+		return resolveSupportedModel(base)
+	}
 	if resolved, ok := resolveSupportedModel(model); ok {
 		return resolved, true
 	}
@@ -275,6 +279,46 @@ func ResolveModel(store ModelAliasReader, requested string) (string, bool) {
 	return "", false
 }
 
+// modelProfilesOf 返回配置里的自定义模型列表；store 不实现 ModelProfileReader 时返回 nil。
+func modelProfilesOf(store any) []ModelProfileConfig {
+	reader, ok := store.(ModelProfileReader)
+	if !ok || reader == nil {
+		return nil
+	}
+	return reader.ModelProfiles()
+}
+
+// resolveModelProfileBase 把自定义模型名解析成基模。
+func resolveModelProfileBase(store any, model string) (string, bool) {
+	profile, ok := FindModelProfile(modelProfilesOf(store), model)
+	if !ok {
+		return "", false
+	}
+	base := lower(strings.TrimSpace(profile.Base))
+	if base == "" {
+		return "", false
+	}
+	return base, true
+}
+
+// OpenAIModelsFor 返回 /v1/models 的模型列表：内置 flash 系列 + 自定义模型。
+func OpenAIModelsFor(store ModelAliasReader) []ModelInfo {
+	profiles := modelProfilesOf(store)
+	out := make([]ModelInfo, 0, len(DeepSeekModels)+len(profiles))
+	out = append(out, DeepSeekModels...)
+	for _, profile := range profiles {
+		info := ModelInfo{
+			ID:         profile.ID,
+			Object:     "model",
+			Created:    1677610602,
+			OwnedBy:    "ds2api",
+			Permission: []any{},
+		}
+		out = append(out, info)
+	}
+	return out
+}
+
 func lower(s string) string {
 	b := []byte(s)
 	for i, c := range b {
@@ -289,7 +333,22 @@ func OpenAIModelsResponse() map[string]any {
 	return map[string]any{"object": "list", "data": DeepSeekModels}
 }
 
+// OpenAIModelsResponseFor 返回含自定义模型的列表响应；handler 用这个版本。
+func OpenAIModelsResponseFor(store ModelAliasReader) map[string]any {
+	return map[string]any{"object": "list", "data": OpenAIModelsFor(store)}
+}
+
 func OpenAIModelByID(store ModelAliasReader, id string) (ModelInfo, bool) {
+	// 自定义模型按原样返回自己的名字，不要暴露背后的 flash 基模。
+	if profile, ok := FindModelProfile(modelProfilesOf(store), id); ok {
+		return ModelInfo{
+			ID:         profile.ID,
+			Object:     "model",
+			Created:    1677610602,
+			OwnedBy:    "ds2api",
+			Permission: []any{},
+		}, true
+	}
 	canonical, ok := ResolveModel(store, id)
 	if !ok {
 		return ModelInfo{}, false

internal/config/store_accessors.go

@@ -335,6 +335,41 @@ func (s *Store) PromptProfileEnabled() bool {
 	return s.cfg.PromptProfile.IsEnabled()
 }
 
+// PromptStyleMode 返回生效的内置提示词风格：v2（缺省）或 legacy。
+func (s *Store) PromptStyleMode() string {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return s.cfg.PromptStyleMode()
+}
+
+// ModelProfiles 返回自定义模型列表副本。
+func (s *Store) ModelProfiles() []ModelProfileConfig {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	return cloneModelProfiles(s.cfg.ModelProfiles)
+}
+
+// ResolveModelPrompt 返回某个模型名对应的专属提示词。
+//
+// 按客户端请求里的模型名（大小写不敏感）匹配自定义模型条目；命中且正文非空时
+// ok=true。未命中或正文为空时调用方应回落到全局 prompt_profile。
+func (s *Store) ResolveModelPrompt(modelID string) (string, bool) {
+	if s == nil {
+		return "", false
+	}
+	s.mu.RLock()
+	profile, ok := FindModelProfile(s.cfg.ModelProfiles, modelID)
+	s.mu.RUnlock()
+	if !ok {
+		return "", false
+	}
+	body := strings.TrimSpace(profile.Prompt)
+	if body == "" {
+		return "", false
+	}
+	return body, true
+}
+
 // PromptProfileSettings 是「提示词特化层」对单次请求生效的设置。
 // Prompt 为空表示使用 Name 指向的内置预设正文。
 type PromptProfileSettings struct {

internal/httpapi/admin/handler.go

@@ -9,6 +9,7 @@ import (
 	adminconfig "ds2api/internal/httpapi/admin/configmgmt"
 	admindevcapture "ds2api/internal/httpapi/admin/devcapture"
 	adminhistory "ds2api/internal/httpapi/admin/history"
+	adminmodelprofiles "ds2api/internal/httpapi/admin/modelprofiles"
 	adminproxies "ds2api/internal/httpapi/admin/proxies"
 	adminrawsamples "ds2api/internal/httpapi/admin/rawsamples"
 	adminsettings "ds2api/internal/httpapi/admin/settings"
@@ -39,6 +40,7 @@ func RegisterRoutes(r chi.Router, h *Handler) {
 	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}
+	modelProfilesHandler := &adminmodelprofiles.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}
 
@@ -49,6 +51,7 @@ func RegisterRoutes(r chi.Router, h *Handler) {
 		adminconfig.RegisterRoutes(pr, configHandler)
 		adminsettings.RegisterRoutes(pr, settingsHandler)
 		adminskills.RegisterRoutes(pr, skillsHandler)
+		adminmodelprofiles.RegisterRoutes(pr, modelProfilesHandler)
 		adminproxies.RegisterRoutes(pr, proxiesHandler)
 		adminaccounts.RegisterRoutes(pr, accountsHandler)
 		adminrawsamples.RegisterRoutes(pr, rawSamplesHandler)

internal/httpapi/admin/handler_settings_prompt_style_test.go

@@ -0,0 +1,87 @@
+package admin
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"ds2api/internal/config"
+)
+
+func TestGetSettingsIncludesPromptStyleDefaults(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("expected 200, got %d", rec.Code)
+	}
+	var body map[string]any
+	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+		t.Fatalf("decode body: %v", err)
+	}
+	style, ok := body["prompt_style"].(map[string]any)
+	if !ok {
+		t.Fatalf("expected prompt_style in settings response, got %#v", body["prompt_style"])
+	}
+	// 默认必须是 v2：不配置就不改变行为。
+	if mode, _ := style["mode"].(string); mode != config.PromptStyleV2 {
+		t.Fatalf("expected default mode v2, got %#v", style["mode"])
+	}
+	modes, ok := style["modes"].([]any)
+	if !ok || len(modes) != len(config.PromptStyleNames()) {
+		t.Fatalf("expected %d modes, got %#v", len(config.PromptStyleNames()), style["modes"])
+	}
+	profiles, ok := body["model_profiles"].(map[string]any)
+	if !ok {
+		t.Fatalf("expected model_profiles summary, got %#v", body["model_profiles"])
+	}
+	if count, _ := profiles["count"].(float64); count != 0 {
+		t.Fatalf("expected empty model list, got %#v", profiles["count"])
+	}
+}
+
+func TestUpdateSettingsPromptStyle(t *testing.T) {
+	h := newAdminTestHandler(t, `{"keys":["k1"]}`)
+	rec := putSettings(t, h, map[string]any{"prompt_style": "legacy"})
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	if got := h.Store.PromptStyleMode(); got != config.PromptStyleLegacy {
+		t.Fatalf("prompt style=%q want legacy", got)
+	}
+}
+
+func TestUpdateSettingsPromptStyleRejectsUnknown(t *testing.T) {
+	h := newAdminTestHandler(t, `{"keys":["k1"]}`)
+	rec := putSettings(t, h, map[string]any{"prompt_style": "v3"})
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	if got := h.Store.PromptStyleMode(); got != config.PromptStyleV2 {
+		t.Fatalf("rejected payload must not be applied, got %q", got)
+	}
+}
+
+func TestUpdateSettingsWithoutPromptStyleKeepsValue(t *testing.T) {
+	h := newAdminTestHandler(t, `{"keys":["k1"],"prompt_style":"legacy"}`)
+	rec := putSettings(t, h, map[string]any{"runtime": map[string]any{"account_max_inflight": 3}})
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	if got := h.Store.PromptStyleMode(); got != config.PromptStyleLegacy {
+		t.Fatalf("expected legacy preserved, got %q", got)
+	}
+}
+
+func TestUpdateSettingsEmptyPromptStyleFallsBackToV2(t *testing.T) {
+	h := newAdminTestHandler(t, `{"keys":["k1"],"prompt_style":"legacy"}`)
+	rec := putSettings(t, h, map[string]any{"prompt_style": ""})
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	if got := h.Store.PromptStyleMode(); got != config.PromptStyleV2 {
+		t.Fatalf("empty style should fall back to v2, got %q", got)
+	}
+}

internal/httpapi/admin/modelprofiles/deps.go

@@ -0,0 +1,16 @@
+package modelprofiles
+
+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/modelprofiles/handler_model_profiles.go

@@ -0,0 +1,67 @@
+package modelprofiles
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"ds2api/internal/config"
+)
+
+// modelProfilesPayload 是 GET/PUT /admin/model_profiles 的响应形状。
+// PUT 是整体替换语义：请求里的 items 就是最终列表。
+type modelProfilesPayload struct {
+	Items          []config.ModelProfileConfig `json:"items"`
+	BaseModels     []string                    `json:"base_models"`
+	MaxCount       int                         `json:"max_count"`
+	MaxIDChars     int                         `json:"max_id_chars"`
+	MaxPromptChars int                         `json:"max_prompt_chars"`
+}
+
+func (h *Handler) getModelProfiles(w http.ResponseWriter, _ *http.Request) {
+	items := h.currentModelProfiles()
+	writeJSON(w, http.StatusOK, modelProfilesPayload{
+		Items:          items,
+		BaseModels:     config.SupportedBaseModels(),
+		MaxCount:       config.MaxModelProfiles,
+		MaxIDChars:     config.MaxModelProfileIDChars,
+		MaxPromptChars: config.MaxPromptProfileChars,
+	})
+}
+
+func (h *Handler) updateModelProfiles(w http.ResponseWriter, r *http.Request) {
+	var req struct {
+		Items []config.ModelProfileConfig `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 err := config.ValidateModelProfiles(req.Items); err != nil {
+		writeJSON(w, http.StatusBadRequest, map[string]any{"detail": err.Error()})
+		return
+	}
+	stored := config.NormalizeModelProfiles(req.Items)
+	if err := h.Store.Update(func(c *config.Config) error {
+		c.ModelProfiles = 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),
+	})
+}
+
+// currentModelProfiles 返回当前自定义模型列表（已归一化，永不为 nil）。
+func (h *Handler) currentModelProfiles() []config.ModelProfileConfig {
+	if h == nil || h.Store == nil {
+		return []config.ModelProfileConfig{}
+	}
+	items := config.NormalizeModelProfiles(h.Store.Snapshot().ModelProfiles)
+	if items == nil {
+		return []config.ModelProfileConfig{}
+	}
+	return items
+}

internal/httpapi/admin/modelprofiles/handler_model_profiles_test.go

@@ -0,0 +1,140 @@
+package modelprofiles
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"ds2api/internal/config"
+)
+
+func newTestHandler(t *testing.T, raw string) *Handler {
+	t.Helper()
+	t.Setenv("DS2API_CONFIG_JSON", raw)
+	return &Handler{Store: config.LoadStore()}
+}
+
+func TestGetModelProfilesReturnsItemsAndLimits(t *testing.T) {
+	h := newTestHandler(t, `{
+		"keys": ["k1"],
+		"model_profiles": [
+			{"id": "deepseek-writer", "base": "deepseek-v4-flash", "name": "写作", "prompt": "writing spec"}
+		]
+	}`)
+	rec := httptest.NewRecorder()
+	h.getModelProfiles(rec, httptest.NewRequest(http.MethodGet, "/admin/model_profiles", nil))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	var body modelProfilesPayload
+	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
+		t.Fatalf("decode body: %v", err)
+	}
+	if len(body.Items) != 1 || body.Items[0].ID != "deepseek-writer" {
+		t.Fatalf("unexpected items: %#v", body.Items)
+	}
+	if len(body.BaseModels) == 0 {
+		t.Fatal("expected base model options")
+	}
+	if body.MaxCount != config.MaxModelProfiles {
+		t.Fatalf("max_count=%d want %d", body.MaxCount, config.MaxModelProfiles)
+	}
+	if body.MaxPromptChars != config.MaxPromptProfileChars {
+		t.Fatalf("max_prompt_chars=%d want %d", body.MaxPromptChars, config.MaxPromptProfileChars)
+	}
+}
+
+func TestGetModelProfilesEmptyReturnsArray(t *testing.T) {
+	h := newTestHandler(t, `{"keys": ["k1"]}`)
+	rec := httptest.NewRecorder()
+	h.getModelProfiles(rec, httptest.NewRequest(http.MethodGet, "/admin/model_profiles", nil))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d", rec.Code)
+	}
+	if !bytes.Contains(rec.Body.Bytes(), []byte(`"items":[]`)) {
+		t.Fatalf("expected empty array rather than null, got %s", rec.Body.String())
+	}
+}
+
+func putProfiles(t *testing.T, h *Handler, payload map[string]any) *httptest.ResponseRecorder {
+	t.Helper()
+	b, _ := json.Marshal(payload)
+	rec := httptest.NewRecorder()
+	h.updateModelProfiles(rec, httptest.NewRequest(http.MethodPut, "/admin/model_profiles", bytes.NewReader(b)))
+	return rec
+}
+
+func TestUpdateModelProfilesReplacesList(t *testing.T) {
+	h := newTestHandler(t, `{"keys": ["k1"]}`)
+	rec := putProfiles(t, h, map[string]any{
+		"items": []map[string]any{
+			{"id": "deepseek-writer", "base": "deepseek-v4-flash", "name": "写作", "prompt": "  spec  "},
+		},
+	})
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	items := h.Store.ModelProfiles()
+	if len(items) != 1 {
+		t.Fatalf("expected 1 profile, got %#v", items)
+	}
+	if items[0].Prompt != "spec" {
+		t.Fatalf("expected trimmed prompt, got %q", items[0].Prompt)
+	}
+	// 保存后解析立即生效。
+	if resolved, ok := config.ResolveModel(h.Store, "deepseek-writer"); !ok || resolved != "deepseek-v4-flash" {
+		t.Fatalf("resolved=%q ok=%v", resolved, ok)
+	}
+}
+
+func TestUpdateModelProfilesValidatesInput(t *testing.T) {
+	h := newTestHandler(t, `{"keys": ["k1"]}`)
+	cases := []struct {
+		name  string
+		items []map[string]any
+	}{
+		{name: "empty id", items: []map[string]any{{"base": "deepseek-v4-flash"}}},
+		{name: "bad base", items: []map[string]any{{"id": "a", "base": "gpt-4o"}}},
+		{name: "builtin shadow", items: []map[string]any{{"id": "deepseek-v4-flash", "base": "deepseek-v4-flash"}}},
+		{name: "duplicate", items: []map[string]any{
+			{"id": "a", "base": "deepseek-v4-flash"},
+			{"id": "a", "base": "deepseek-v4-flash"},
+		}},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			rec := putProfiles(t, h, map[string]any{"items": tc.items})
+			if rec.Code != http.StatusBadRequest {
+				t.Fatalf("expected 400, got %d body=%s", rec.Code, rec.Body.String())
+			}
+			if len(h.Store.ModelProfiles()) != 0 {
+				t.Fatal("rejected payload must not be persisted")
+			}
+		})
+	}
+}
+
+func TestUpdateModelProfilesRejectsInvalidJSON(t *testing.T) {
+	h := newTestHandler(t, `{"keys": ["k1"]}`)
+	rec := httptest.NewRecorder()
+	h.updateModelProfiles(rec, httptest.NewRequest(http.MethodPut, "/admin/model_profiles", bytes.NewReader([]byte("{"))))
+	if rec.Code != http.StatusBadRequest {
+		t.Fatalf("expected 400, got %d", rec.Code)
+	}
+}
+
+func TestUpdateModelProfilesCanClearList(t *testing.T) {
+	h := newTestHandler(t, `{
+		"keys": ["k1"],
+		"model_profiles": [{"id": "deepseek-writer", "base": "deepseek-v4-flash"}]
+	}`)
+	rec := putProfiles(t, h, map[string]any{"items": []map[string]any{}})
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
+	}
+	if len(h.Store.ModelProfiles()) != 0 {
+		t.Fatalf("expected empty list, got %#v", h.Store.ModelProfiles())
+	}
+}

internal/httpapi/admin/modelprofiles/routes.go

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

internal/httpapi/admin/settings/handler_settings_parse.go

@@ -33,6 +33,7 @@ type settingsUpdatePayload struct {
 	CurrentInputFile  *config.CurrentInputFileConfig
 	ThinkingInjection *config.ThinkingInjectionConfig
 	PromptProfile     *config.PromptProfileConfig
+	PromptStyle       *string
 	Tools             *config.ToolsConfig
 	Platform          *config.PlatformConfig
 	Aliases           map[string]string
@@ -214,6 +215,17 @@ func parseSettingsUpdateRequest(req map[string]any) (settingsUpdatePayload, erro
 		out.PromptProfile = cfg
 	}
 
+	if raw, exists := req["prompt_style"]; exists {
+		style := strings.ToLower(strings.TrimSpace(fmt.Sprintf("%v", raw)))
+		if style != "" && !config.IsKnownPromptStyle(style) {
+			return settingsUpdatePayload{}, fmt.Errorf(
+				"prompt_style must be one of %s",
+				strings.Join(config.PromptStyleNames(), ", "),
+			)
+		}
+		out.PromptStyle = &style
+	}
+
 	if raw, ok := req["tools"].(map[string]any); ok {
 		cfg := &config.ToolsConfig{}
 		if v, exists := raw["enabled"]; exists {

internal/httpapi/admin/settings/handler_settings_read.go

@@ -42,6 +42,8 @@ func (h *Handler) getSettings(w http.ResponseWriter, _ *http.Request) {
 				"name":    snap.PromptProfile.Name,
 				"prompt":  snap.PromptProfile.Prompt,
 			},
+			"prompt_style":   snap.PromptStyle,
+			"model_profiles": snap.ModelProfiles,
 			"skills": map[string]any{
 				"enabled":   snap.Skills.Enabled,
 				"max_chars": snap.Skills.EffectiveMaxChars(),
@@ -85,6 +87,19 @@ func (h *Handler) getSettings(w http.ResponseWriter, _ *http.Request) {
 			"prompt":          snap.PromptProfile.Prompt,
 			"presets":         promptProfilePresetsPayload(),
 		},
+		"prompt_style": map[string]any{
+			"mode":      snap.PromptStyleMode(),
+			"modes":     config.PromptStyleNames(),
+			"default":   config.PromptStyleV2,
+			"value_raw": snap.PromptStyle,
+		},
+		"model_profiles": map[string]any{
+			"count":            len(h.Store.ModelProfiles()),
+			"max_count":        config.MaxModelProfiles,
+			"base_models":      config.SupportedBaseModels(),
+			"max_id_chars":     config.MaxModelProfileIDChars,
+			"max_prompt_chars": config.MaxPromptProfileChars,
+		},
 		"skills": map[string]any{
 			"enabled":   h.Store.SkillsEnabled(),
 			"max_chars": h.Store.SkillsMaxChars(),

internal/httpapi/admin/settings/handler_settings_write.go

@@ -35,6 +35,7 @@ func (h *Handler) updateSettings(w http.ResponseWriter, r *http.Request) {
 	promptProfileEnabledSet := hasNestedSettingsKey(req, "prompt_profile", "enabled")
 	promptProfileNameSet := hasNestedSettingsKey(req, "prompt_profile", "name")
 	promptProfilePromptSet := hasNestedSettingsKey(req, "prompt_profile", "prompt")
+	promptStyleSet := hasTopLevelSettingsKey(req, "prompt_style")
 	toolsEnabledSet := hasNestedSettingsKey(req, "tools", "enabled")
 
 	if err := h.Store.Update(func(c *config.Config) error {
@@ -98,6 +99,9 @@ func (h *Handler) updateSettings(w http.ResponseWriter, r *http.Request) {
 				c.PromptProfile.Prompt = payload.PromptProfile.Prompt
 			}
 		}
+		if payload.PromptStyle != nil && promptStyleSet {
+			c.PromptStyle = *payload.PromptStyle
+		}
 		if payload.Tools != nil && toolsEnabledSet {
 			c.Tools.Enabled = payload.Tools.Enabled
 		}
@@ -170,3 +174,9 @@ func hasNestedSettingsKey(req map[string]any, section, key string) bool {
 	_, exists := raw[key]
 	return exists
 }
+
+// hasTopLevelSettingsKey 判断顶层是否出现某个简单字段（如 prompt_style）。
+func hasTopLevelSettingsKey(req map[string]any, key string) bool {
+	_, exists := req[key]
+	return exists
+}

internal/httpapi/admin/shared/deps.go

@@ -39,6 +39,9 @@ type ConfigStore interface {
 	ThinkingInjectionEnabled() bool
 	ThinkingInjectionPrompt() string
 	PromptProfileEnabled() bool
+	PromptStyleMode() string
+	ModelAliases() map[string]string
+	ModelProfiles() []config.ModelProfileConfig
 	SkillsEnabled() bool
 	SkillsMaxChars() int
 	ToolsEnabled() bool

internal/httpapi/openai/history/current_input_file.go

@@ -37,23 +37,23 @@ type Service struct {
 }
 
 func (s Service) ApplyCurrentInputFile(ctx context.Context, a *auth.RequestAuth, stdReq promptcompat.StandardRequest) (promptcompat.StandardRequest, error) {
-	// 思考格式注入会写进最新一条用户消息，必须发生在历史拆分之前，
-	// 否则拆分后上传的上下文文件里就缺了这段要求。
+	// 执行契约会写进最新一条用户消息，必须发生在历史拆分之前，
+	// 否则拆分后上传的上下文文件里就缺了这段要求（旧版风格不注入内置契约）。
 	stdReq = applyThinkingInjection(a, stdReq)
 	appliedBefore := stdReq.CurrentInputFileApplied
 	stdReq, err := s.applyCurrentInputFile(ctx, a, stdReq)
 	if err != nil {
 		return stdReq, err
 	}
-	// 拆分发生时会用衔接指令整段替换 FinalPrompt，拆之前注入的思考要求因此只剩
-	// 在附件里。这里把同一段要求贴回可见 prompt，否则「执行契约」在长对话中
-	// 实际上等于没注入。只在本轮新发生拆分时贴一次，避免切号重传重复叠加。
+	// 拆分发生时会用衔接指令整段替换 FinalPrompt，拆之前注入的契约因此只剩
+	// 在附件里。这里把同一段文本贴回可见 prompt，否则它在长对话中实际上
+	// 等于没注入。只在本轮新发生拆分时贴一次，避免切号重传重复叠加。
 	if !appliedBefore && stdReq.CurrentInputFileApplied {
 		stdReq = applyThinkingInjectionToVisiblePrompt(a, stdReq)
 	}
-	// 纯文本增强（提示词特化层、技能库）都是 prompt 级叠加，必须放在历史拆分
-	// 之后：拆分会把 prompt 整段替换成上下文文件说明，提前写入会被覆盖。
-	return applyOverlays(a, stdReq), nil
+	// 纯文本增强（模型提示词 / 提示词特化层 / 技能库）都是 prompt 级叠加，必须
+	// 放在历史拆分之后：拆分会把 prompt 整段替换成上下文文件说明，提前写入会被覆盖。
+	return s.applyOverlays(a, stdReq), nil
 }
 
 func (s Service) applyCurrentInputFile(ctx context.Context, a *auth.RequestAuth, stdReq promptcompat.StandardRequest) (promptcompat.StandardRequest, error) {
@@ -142,13 +142,15 @@ func (s Service) applyCurrentInputFile(ctx context.Context, a *auth.RequestAuth,
 	} else if len(stdReq.ToolNames) == 0 && len(toolNames) > 0 {
 		stdReq.ToolNames = toolNames
 	}
+	style := promptStyleOf(a)
+	continuation := currentInputFilePrompt(style, filename, hasToolsFile)
 	promptMessages = append(promptMessages, map[string]any{
 		"role":    "user",
-		"content": currentInputFilePrompt(filename, hasToolsFile),
+		"content": continuation,
 	})
 	finalPrompt, _ := promptcompat.BuildOpenAIPrompt(promptMessages, nil, "", stdReq.ToolChoice, stdReq.Thinking)
 	if strings.TrimSpace(finalPrompt) == "" {
-		finalPrompt = currentInputFilePrompt(filename, hasToolsFile)
+		finalPrompt = continuation
 	}
 
 	promptTokenText := historyText
@@ -235,40 +237,82 @@ func (s Service) ReuploadAppliedCurrentInputFile(ctx context.Context, a *auth.Re
 	return stdReq, nil
 }
 
+// promptStyleOf 返回本次请求生效的内置提示词风格；旧版风格不注入内置执行契约。
+func promptStyleOf(a *auth.RequestAuth) string {
+	if a == nil {
+		return config.PromptStyleV2
+	}
+	return config.NormalizePromptStyle(a.PromptStyle)
+}
+
 // applyThinkingInjection 应用本次请求生效的「思考格式注入」设置。
 // 设置已在鉴权阶段完成全局 + 单 Key 自定义的合并，这里只负责落盘到请求里。
 func applyThinkingInjection(a *auth.RequestAuth, stdReq promptcompat.StandardRequest) promptcompat.StandardRequest {
 	if a == nil {
 		return stdReq
 	}
-	return promptcompat.ApplyThinkingInjectionToRequest(stdReq, a.Injection.Enabled, a.Injection.Prompt)
+	return promptcompat.ApplyThinkingInjectionToRequest(
+		stdReq, promptStyleOf(a), a.Injection.Enabled, a.Injection.Prompt)
 }
 
 // applyThinkingInjectionToVisiblePrompt 在历史拆分替换掉 prompt 之后，
-// 把思考契约重新贴到可见 prompt 上（只改 FinalPrompt）。
+// 把执行契约重新贴到可见 prompt 上（只改 FinalPrompt）。
 func applyThinkingInjectionToVisiblePrompt(a *auth.RequestAuth, stdReq promptcompat.StandardRequest) promptcompat.StandardRequest {
 	if a == nil {
 		return stdReq
 	}
-	return promptcompat.ReapplyThinkingInjectionToPrompt(stdReq, a.Injection.Enabled, a.Injection.Prompt)
+	return promptcompat.ReapplyThinkingInjectionToPrompt(
+		stdReq, promptStyleOf(a), a.Injection.Enabled, a.Injection.Prompt)
 }
 
-// applyOverlays 把 prompt 级叠加层（提示词特化层、纯文本技能库）合进最终 prompt。
+// modelPromptReader 由配置中心实现，用于读取自定义模型条目的专属提示词。
+// 用可选接口而不是写进 CurrentInputConfigReader，是为了不打断测试里的轻量假实现。
+type modelPromptReader interface {
+	ResolveModelPrompt(modelID string) (string, bool)
+}
+
+// applyOverlays 把 prompt 级叠加层（模型专属提示词 / 提示词特化层 / 技能库）合进最终 prompt��
 //
-// 两段合成一个 System 段，顺序固定：特化层在外层（通用规范），技能在内层
-// （更贴近当前任务）。设置已在鉴权阶段完成全局 + 单 Key 自定义的合并与过滤。
-func applyOverlays(a *auth.RequestAuth, stdReq promptcompat.StandardRequest) promptcompat.StandardRequest {
-	if a == nil {
-		return stdReq
-	}
+// 分段规则：
+//   - 外层规范二选一：命中的自定义模型若带提示词，就用它的，否则回落到全局 prompt_profile；
+//   - 内层是技能库（更贴近当前任务）；
+//   - 全部合成一个 System 段。
+func (s Service) applyOverlays(a *auth.RequestAuth, stdReq promptcompat.StandardRequest) promptcompat.StandardRequest {
 	blocks := make([]string, 0, 2)
-	blocks = append(blocks, promptcompat.PromptProfileBlock(a.PromptProfile))
-	if a.Skills.Enabled && len(a.Skills.Items) > 0 {
+	if body := s.modelProfilePrompt(stdReq); body != "" {
+		blocks = append(blocks, body)
+	} else if a != nil {
+		blocks = append(blocks, promptcompat.PromptProfileBlock(a.PromptProfile))
+	}
+	if a != nil && a.Skills.Enabled && len(a.Skills.Items) > 0 {
 		blocks = append(blocks, promptcompat.BuildSkillsPrompt(a.Skills.Items, a.Skills.MaxChars))
 	}
 	return promptcompat.ApplySystemOverlays(stdReq, blocks...)
 }
 
+// modelProfilePrompt 返回客户端所选自定义模型自带的提示词；没有则返回空串。
+//
+// 用 RequestedModel 而不是 ResolvedModel：解析后的模型名已经是 flash 基模，
+// 拿不回「客户端到底选了哪个自定义模型」。
+func (s Service) modelProfilePrompt(stdReq promptcompat.StandardRequest) string {
+	if s.Store == nil {
+		return ""
+	}
+	reader, ok := s.Store.(modelPromptReader)
+	if !ok {
+		return ""
+	}
+	modelID := strings.TrimSpace(stdReq.RequestedModel)
+	if modelID == "" {
+		return ""
+	}
+	body, ok := reader.ResolveModelPrompt(modelID)
+	if !ok {
+		return ""
+	}
+	return strings.TrimSpace(body)
+}
+
 func latestUserInputForFile(messages []any) (int, string) {
 	for i := len(messages) - 1; i >= 0; i-- {
 		msg, ok := messages[i].(map[string]any)
@@ -288,8 +332,8 @@ func latestUserInputForFile(messages []any) (int, string) {
 	return -1, ""
 }
 
-func currentInputFilePrompt(filename string, hasToolsFile bool) string {
-	return promptcompat.BuildCurrentInputContinuationPrompt(filename, hasToolsFile)
+func currentInputFilePrompt(style, filename string, hasToolsFile bool) string {
+	return promptcompat.BuildCurrentInputContinuationPrompt(style, filename, hasToolsFile)
 }
 
 func randomContextFilename() string {

internal/httpapi/openai/history/current_input_file_overlay_test.go

@@ -0,0 +1,182 @@
+package history
+
+import (
+	"context"
+	"strings"
+	"testing"
+
+	"ds2api/internal/auth"
+	"ds2api/internal/config"
+	"ds2api/internal/promptcompat"
+)
+
+// overlayTestStore 让历史拆分保持开启，并可按模型名返回专属提示词。
+type overlayTestStore struct {
+	enabled      bool
+	minChars     int
+	modelPrompts map[string]string
+}
+
+func (s overlayTestStore) CurrentInputFileEnabled() bool { return s.enabled }
+func (s overlayTestStore) CurrentInputFileMinChars() int { return s.minChars }
+
+func (s overlayTestStore) ResolveModelPrompt(modelID string) (string, bool) {
+	for id, prompt := range s.modelPrompts {
+		if strings.EqualFold(strings.TrimSpace(id), strings.TrimSpace(modelID)) {
+			if strings.TrimSpace(prompt) == "" {
+				return "", false
+			}
+			return prompt, true
+		}
+	}
+	return "", false
+}
+
+func overlayTestRequest(requestedModel string) promptcompat.StandardRequest {
+	return promptcompat.StandardRequest{
+		RequestedModel: requestedModel,
+		ResolvedModel:  "deepseek-v4-flash",
+		Messages: []any{
+			map[string]any{"role": "user", "content": "先看这个仓库"},
+			map[string]any{"role": "assistant", "content": "看完了"},
+			map[string]any{"role": "user", "content": "按刚才的结论写三段"},
+		},
+		FinalPrompt:     "User: 按刚才的结论写三段\nAssistant: ",
+		PromptTokenText: "User: 按刚才的结论写三段\nAssistant: ",
+	}
+}
+
+// 选中带提示词的自定义模型时，用模型自己的提示词，不再叠加全局特化层。
+func TestModelProfilePromptWinsOverGlobalProfile(t *testing.T) {
+	svc := Service{
+		Store: overlayTestStore{
+			enabled:      true,
+			modelPrompts: map[string]string{"deepseek-writer": "model spec"},
+		},
+		DS: &skillsTestUploader{},
+	}
+	a := &auth.RequestAuth{
+		PromptProfile: config.PromptProfileSettings{Enabled: true, Name: config.PromptProfileNameWriting},
+	}
+	out, err := svc.ApplyCurrentInputFile(context.Background(), a, overlayTestRequest("deepseek-writer"))
+	if err != nil {
+		t.Fatalf("apply current input file failed: %v", err)
+	}
+	if !strings.Contains(out.FinalPrompt, "model spec") {
+		t.Fatalf("expected model prompt in final prompt, got %q", out.FinalPrompt)
+	}
+	globalBody := promptcompat.BuildPromptProfilePrompt(config.PromptProfileNameWriting, "")
+	if strings.Contains(out.FinalPrompt, globalBody) {
+		t.Fatalf("global prompt profile must not stack with the model prompt, got %q", out.FinalPrompt)
+	}
+	if got := strings.Count(out.FinalPrompt, "System: "); got != 1 {
+		t.Fatalf("expected one System marker, got %d", got)
+	}
+}
+
+// 模型名没命中（或该模型没配提示词）时回落到全局特化层。
+func TestModelProfilePromptFallsBackToGlobalProfile(t *testing.T) {
+	cases := []struct {
+		name         string
+		requested    string
+		modelPrompts map[string]string
+	}{
+		{name: "unknown model", requested: "deepseek-v4-flash"},
+		{name: "model without prompt", requested: "deepseek-plain", modelPrompts: map[string]string{"deepseek-plain": "   "}},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			svc := Service{
+				Store: overlayTestStore{enabled: true, modelPrompts: tc.modelPrompts},
+				DS:    &skillsTestUploader{},
+			}
+			a := &auth.RequestAuth{
+				PromptProfile: config.PromptProfileSettings{Enabled: true, Name: config.PromptProfileNameWriting},
+			}
+			out, err := svc.ApplyCurrentInputFile(context.Background(), a, overlayTestRequest(tc.requested))
+			if err != nil {
+				t.Fatalf("apply current input file failed: %v", err)
+			}
+			if !strings.Contains(out.FinalPrompt, promptcompat.BuildPromptProfilePrompt(config.PromptProfileNameWriting, "")) {
+				t.Fatalf("expected global profile fallback, got %q", out.FinalPrompt)
+			}
+		})
+	}
+}
+
+// 模型提示词与技能层合并成一个 System 段，顺序：模型 → 技能。
+func TestModelProfilePromptCombinesWithSkills(t *testing.T) {
+	svc := Service{
+		Store: overlayTestStore{
+			enabled:      true,
+			modelPrompts: map[string]string{"deepseek-writer": "model spec"},
+		},
+		DS: &skillsTestUploader{},
+	}
+	a := &auth.RequestAuth{
+		Skills: config.SkillSettings{
+			Enabled: true,
+			Items:   []config.SkillConfig{{ID: "sql-report", Body: "sql body"}},
+		},
+	}
+	out, err := svc.ApplyCurrentInputFile(context.Background(), a, overlayTestRequest("deepseek-writer"))
+	if err != nil {
+		t.Fatalf("apply current input file failed: %v", err)
+	}
+	if got := strings.Count(out.FinalPrompt, "System: "); got != 1 {
+		t.Fatalf("expected one System marker, got %d in %q", got, out.FinalPrompt)
+	}
+	modelIdx := strings.Index(out.FinalPrompt, "model spec")
+	skillIdx := strings.Index(out.FinalPrompt, `<skill id="sql-report">`)
+	if modelIdx < 0 || skillIdx < 0 || modelIdx > skillIdx {
+		t.Fatalf("unexpected layer order in %q", out.FinalPrompt)
+	}
+}
+
+// 旧版风格：历史拆分后既不带「执行要求」，也不注入内置执行契约。
+func TestLegacyStyleKeepsSplitPromptMinimal(t *testing.T) {
+	svc := Service{Store: overlayTestStore{enabled: true}, DS: &skillsTestUploader{}}
+	a := &auth.RequestAuth{
+		Injection:   config.ThinkingInjectionSettings{Enabled: true},
+		PromptStyle: config.PromptStyleLegacy,
+	}
+	out, err := svc.ApplyCurrentInputFile(context.Background(), a, overlayTestRequest("deepseek-v4-flash"))
+	if err != nil {
+		t.Fatalf("apply current input file failed: %v", err)
+	}
+	if !out.CurrentInputFileApplied {
+		t.Fatal("expected history split to be applied")
+	}
+	if strings.Contains(out.FinalPrompt, "## 执行要求") {
+		t.Fatalf("legacy prompt must not carry the requirement block, got %q", out.FinalPrompt)
+	}
+	if strings.Contains(out.FinalPrompt, promptcompat.ThinkingInjectionMarker) {
+		t.Fatalf("legacy prompt must not carry the built-in contract, got %q", out.FinalPrompt)
+	}
+	if !strings.Contains(out.FinalPrompt, out.CurrentInputFilename) {
+		t.Fatalf("expected continuation to reference the context file, got %q", out.FinalPrompt)
+	}
+	// 对话记录文件里也不应出现契约：旧版风格下压根没注入。
+	if strings.Contains(out.HistoryText, promptcompat.ThinkingInjectionMarker) {
+		t.Fatalf("legacy transcript must not carry the contract, got %q", out.HistoryText)
+	}
+}
+
+// 旧版风格 + 用户自定义提示词：自定义内容仍然注入并重贴到可见 prompt。
+func TestLegacyStyleStillHonoursCustomInjection(t *testing.T) {
+	svc := Service{Store: overlayTestStore{enabled: true}, DS: &skillsTestUploader{}}
+	a := &auth.RequestAuth{
+		Injection:   config.ThinkingInjectionSettings{Enabled: true, Prompt: "custom contract"},
+		PromptStyle: config.PromptStyleLegacy,
+	}
+	out, err := svc.ApplyCurrentInputFile(context.Background(), a, overlayTestRequest("deepseek-v4-flash"))
+	if err != nil {
+		t.Fatalf("apply current input file failed: %v", err)
+	}
+	if !strings.Contains(out.FinalPrompt, "custom contract") {
+		t.Fatalf("expected custom contract in the visible prompt, got %q", out.FinalPrompt)
+	}
+	if !strings.HasSuffix(out.FinalPrompt, "Assistant: ") {
+		t.Fatalf("prompt must still end with the assistant marker, got %q", out.FinalPrompt)
+	}
+}

internal/httpapi/openai/history/current_input_file_prompt_test.go

@@ -3,14 +3,16 @@ package history
 import (
 	"strings"
 	"testing"
+
+	"ds2api/internal/config"
 )
 
 // 续接指令的正文已经收敛到 promptcompat（唯一来源），这里只钉住 history 这一层
-// 的委托行为：文件名插值、反泄漏说明、工具说明文件分支。
+// 的委托行为：文件名插值、反泄漏说明、工具说明文件分支、风格切换。
 func TestCurrentInputFilePromptDelegatesToPromptcompat(t *testing.T) {
 	const filename = "ctx-abc123def456.txt"
 	for i := 0; i < 16; i++ {
-		prompt := currentInputFilePrompt(filename, false)
+		prompt := currentInputFilePrompt(config.PromptStyleV2, filename, false)
 		if !strings.Contains(prompt, filename) {
 			t.Fatalf("expected filename in prompt, got %q", prompt)
 		}
@@ -32,16 +34,16 @@ func TestCurrentInputFilePromptDelegatesToPromptcompat(t *testing.T) {
 }
 
 func TestCurrentInputFilePromptMentionsToolsFileWhenPresent(t *testing.T) {
-	prompt := currentInputFilePrompt("ctx-abc123def456.txt", true)
+	prompt := currentInputFilePrompt(config.PromptStyleV2, "ctx-abc123def456.txt", true)
 	if !strings.Contains(prompt, "context_tools.txt") {
 		t.Fatalf("expected tools file reference, got %q", prompt)
 	}
 }
 
 func TestCurrentInputFilePromptMatchesPromptcompatBuilder(t *testing.T) {
-	// 防止有人把文案又抄回 history 包：包装函数的输出必须以 promptcompat
+	// 防止有人把文案又抄回 history 包：v2 包装函数的输出必须以 promptcompat
 	// 共享要求块收尾，说明只有一份文案在生效。
-	prompt := currentInputFilePrompt("ctx-1.txt", false)
+	prompt := currentInputFilePrompt(config.PromptStyleV2, "ctx-1.txt", false)
 	if !strings.HasSuffix(prompt, "直接从正文开始。") {
 		t.Fatalf("expected the shared requirement block at the tail, got %q", prompt)
 	}
@@ -49,3 +51,22 @@ func TestCurrentInputFilePromptMatchesPromptcompatBuilder(t *testing.T) {
 		t.Fatalf("expected a single requirement block, got %q", prompt)
 	}
 }
+
+// 旧版风格：短文案、没有「执行要求」，仍然带反泄漏说明。
+func TestCurrentInputFilePromptLegacyStyleIsShortAndLeakSafe(t *testing.T) {
+	for i := 0; i < 16; i++ {
+		prompt := currentInputFilePrompt(config.PromptStyleLegacy, "ctx-1.txt", false)
+		if strings.Contains(prompt, "## 执行要求") {
+			t.Fatalf("legacy prompt must not carry the requirement block, got %q", prompt)
+		}
+		if !strings.Contains(prompt, "ctx-1.txt") {
+			t.Fatalf("expected filename in legacy prompt, got %q", prompt)
+		}
+		if !strings.Contains(prompt, "不要") {
+			t.Fatalf("expected a no-leak clause in legacy prompt, got %q", prompt)
+		}
+		if len([]rune(prompt)) > 120 {
+			t.Fatalf("legacy prompt should stay short, got %q", prompt)
+		}
+	}
+}

internal/httpapi/openai/shared/models.go

@@ -14,7 +14,7 @@ type ModelsHandler struct {
 }
 
 func (h *ModelsHandler) ListModels(w http.ResponseWriter, _ *http.Request) {
-	WriteJSON(w, http.StatusOK, config.OpenAIModelsResponse())
+	WriteJSON(w, http.StatusOK, config.OpenAIModelsResponseFor(h.Store))
 }
 
 func (h *ModelsHandler) GetModel(w http.ResponseWriter, r *http.Request) {

internal/promptcompat/prompt_texts.go

@@ -57,12 +57,37 @@ const currentInputContinuationRequirements = "\n\n## 执行要求\n" +
 // 工具说明文件当前不再生成（见 tool_prompt.go），这里保留兜底措辞。
 const currentInputContinuationToolsHint = "\n本轮可用的工具与参数说明在 context_tools.txt 中，只能使用该文件列出的工具。"
 
+// legacyContinuationOpenings 是「旧版」风格的衔接指令。
+//
+// 这三句取自 ce5a019 之前的原文，刻意保持极短：旧版手感来自「几乎不加约束」，
+// 模型按自己的默认风格作答，不会被要求先清点要求再动笔。
+//
+// 唯一做的规范化：旧文案里只有第一句明确写了「不要提及文件/上下文/提示词」，
+// 第二句只写了「避免说明你在使用上下文文件」。这里统一成同一句防泄漏要求，
+// 措辞强度一致，长度基本不变——防泄漏不属于「风格约束」，不该因为切旧版而放松。
+var legacyContinuationOpenings = []string{
+	"已附上下文文件「%s」。请直接回答最新问题，不要提及文件、上下文或提示词本身。",
+	"请从文件 %s 继续处理本轮任务，给出答案，不要提及文件、上下文或提示词本身。",
+	"上下文已存入 %s，请将其视为唯一上下文并直接答复；不要复述提示或提到文件。",
+}
+
+// legacyContinuationToolsHint 是旧版在带工具说明文件时的补充说明。
+const legacyContinuationToolsHint = " 可用工具与参数说明在 context_tools.txt 中，仅可依据该文件调用工具。"
+
 // BuildCurrentInputContinuationPrompt 构造历史拆分后唯一可见的用户轮次指令。
 //
-// filename 是上传到上游的对话记录文件名；hasToolsFile 表示本轮是否额外上传了
-// 工具说明文件（当前恒为 false，见 tool_prompt.go）。
-func BuildCurrentInputContinuationPrompt(filename string, hasToolsFile bool) string {
+// style 决定用哪一版文案：config.PromptStyleLegacy 用旧版短文案，其余（含空值
+// 与未知值）一律按 v2 处理。filename 是上传到上游的对话记录文件名；
+// hasToolsFile 表示本轮是否额外上传了工具说明文件（当前恒为 false，见 tool_prompt.go）。
+func BuildCurrentInputContinuationPrompt(style, filename string, hasToolsFile bool) string {
 	filename = strings.TrimSpace(filename)
+	if config.NormalizePromptStyle(style) == config.PromptStyleLegacy {
+		text := strings.ReplaceAll(pickPromptVariant(legacyContinuationOpenings), "%s", filename)
+		if hasToolsFile {
+			text += legacyContinuationToolsHint
+		}
+		return text
+	}
 	opening := pickPromptVariant(currentInputContinuationOpenings)
 	text := strings.ReplaceAll(opening, "%s", filename) + currentInputContinuationRequirements
 	if hasToolsFile {

internal/promptcompat/prompt_texts_test.go

@@ -11,7 +11,7 @@ func TestBuildCurrentInputContinuationPromptMentionsFilenameAndRequirements(t *t
 	const filename = "ctx-abc123def456.txt"
 	seenOpenings := map[string]struct{}{}
 	for i := 0; i < 64; i++ {
-		prompt := BuildCurrentInputContinuationPrompt(filename, false)
+		prompt := BuildCurrentInputContinuationPrompt(config.PromptStyleV2, filename, false)
 		if !strings.Contains(prompt, filename) {
 			t.Fatalf("expected filename in prompt, got %q", prompt)
 		}
@@ -73,7 +73,7 @@ func TestBuildCurrentInputContinuationPromptSharesRequirementBlock(t *testing.T)
 }
 
 func TestBuildCurrentInputContinuationPromptMentionsToolsFileWhenPresent(t *testing.T) {
-	prompt := BuildCurrentInputContinuationPrompt("ctx-abc123def456.txt", true)
+	prompt := BuildCurrentInputContinuationPrompt(config.PromptStyleV2, "ctx-abc123def456.txt", true)
 	if !strings.Contains(prompt, "context_tools.txt") {
 		t.Fatalf("expected tools file reference, got %q", prompt)
 	}
@@ -82,7 +82,7 @@ func TestBuildCurrentInputContinuationPromptMentionsToolsFileWhenPresent(t *test
 func TestBuildCurrentInputContinuationPromptTrimsFilename(t *testing.T) {
 	// 调用方保证 filename 非空（随机 ctx-*.txt 兜底），这里只要求两侧空白被裁掉，
 	// 不要出现「附件「 ctx-1.txt 」里」这种带空格的怪句子。
-	prompt := BuildCurrentInputContinuationPrompt("  ctx-1.txt  ", false)
+	prompt := BuildCurrentInputContinuationPrompt(config.PromptStyleV2, "  ctx-1.txt  ", false)
 	if !strings.Contains(prompt, "「ctx-1.txt」") {
 		t.Fatalf("expected trimmed filename inside the quotes, got %q", prompt)
 	}

internal/promptcompat/thinking_injection.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"strings"
 
+	"ds2api/internal/config"
 	"ds2api/internal/prompt"
 )
 
@@ -33,15 +34,25 @@ const (
 
 // resolveThinkingInjectionPrompt 返回本次请求实际生效的注入文本。
 // 未启用时 ok=false；提示词为空或全空白时回落到内置默认提示词。
-func resolveThinkingInjectionPrompt(enabled bool, injectionPrompt string) (string, bool) {
+// ResolveThinkingInjectionPrompt 返回本次请求实际生效的注入文本。
+//
+// 判定顺序：
+//  1. 开关关闭 → 不注入；
+//  2. 显式配置了自定义提示词 → 注入自定义内容（任何风格都尊重用户意图）；
+//  3. 旧版风格（config.PromptStyleLegacy）→ 不注入内置执行契约，这正是旧版
+//     「几乎不加约束」的手感；
+//  4. 其余情况 → 注入内置默认执行契约。
+func ResolveThinkingInjectionPrompt(style string, enabled bool, injectionPrompt string) (string, bool) {
 	if !enabled {
 		return "", false
 	}
-	injectionPrompt = strings.TrimSpace(injectionPrompt)
-	if injectionPrompt == "" {
-		injectionPrompt = DefaultThinkingInjectionPrompt
+	if custom := strings.TrimSpace(injectionPrompt); custom != "" {
+		return custom, true
+	}
+	if config.NormalizePromptStyle(style) == config.PromptStyleLegacy {
+		return "", false
 	}
-	return injectionPrompt, true
+	return DefaultThinkingInjectionPrompt, true
 }
 
 // AppendThinkingInjectionToLatestUser 使用内置默认提示词注入。
@@ -52,9 +63,10 @@ func AppendThinkingInjectionToLatestUser(messages []any) ([]any, bool) {
 // ApplyThinkingInjectionToRequest 把注入提示词写入标准请求：
 // 既追加到最新一条 user 消息（历史拆分时会被带进上下文文件），
 // 也追加到已经拼装好的最终 prompt（落在助手起笔标记之前）。
-// 未启用、提示词为空或已经注入过时原样返回。
-func ApplyThinkingInjectionToRequest(stdReq StandardRequest, enabled bool, injectionPrompt string) StandardRequest {
-	injectionPrompt, ok := resolveThinkingInjectionPrompt(enabled, injectionPrompt)
+// style 决定是否注入内置执行契约（旧版风格不注入）。未启用、没有可注入内容
+// 或已经注入过时原样返回。
+func ApplyThinkingInjectionToRequest(stdReq StandardRequest, style string, enabled bool, injectionPrompt string) StandardRequest {
+	injectionPrompt, ok := ResolveThinkingInjectionPrompt(style, enabled, injectionPrompt)
 	if !ok {
 		return stdReq
 	}
@@ -79,8 +91,8 @@ func ApplyThinkingInjectionToRequest(stdReq StandardRequest, enabled bool, injec
 // 这里刻意只改 FinalPrompt：
 //   - 不改 Messages：拆分后它们就是那条衔接指令，改它会让存档与记录失真；
 //   - 不改 PromptTokenText：对话记录文件里已经有一份，重复计入会高估 token。
-func ReapplyThinkingInjectionToPrompt(stdReq StandardRequest, enabled bool, injectionPrompt string) StandardRequest {
-	injectionPrompt, ok := resolveThinkingInjectionPrompt(enabled, injectionPrompt)
+func ReapplyThinkingInjectionToPrompt(stdReq StandardRequest, style string, enabled bool, injectionPrompt string) StandardRequest {
+	injectionPrompt, ok := ResolveThinkingInjectionPrompt(style, enabled, injectionPrompt)
 	if !ok {
 		return stdReq
 	}

internal/promptcompat/thinking_injection_test.go

@@ -3,6 +3,8 @@ package promptcompat
 import (
 	"strings"
 	"testing"
+
+	"ds2api/internal/config"
 )
 
 func TestAppendThinkingInjectionToLatestUserStringContent(t *testing.T) {
@@ -103,7 +105,7 @@ func TestApplyThinkingInjectionToRequestPatchesPromptAndMessages(t *testing.T) {
 		FinalPrompt:     "User: hello\nAssistant: ",
 		PromptTokenText: "User: hello\nAssistant: ",
 	}
-	out := ApplyThinkingInjectionToRequest(stdReq, true, "think first")
+	out := ApplyThinkingInjectionToRequest(stdReq, config.PromptStyleV2, true, "think first")
 	if !strings.Contains(out.FinalPrompt, "User: hello\nthink first\nAssistant: ") {
 		t.Fatalf("expected injection before assistant marker, got %q", out.FinalPrompt)
 	}
@@ -121,7 +123,7 @@ func TestApplyThinkingInjectionToRequestDisabled(t *testing.T) {
 		Messages:    []any{map[string]any{"role": "user", "content": "hello"}},
 		FinalPrompt: "User: hello\nAssistant: ",
 	}
-	out := ApplyThinkingInjectionToRequest(stdReq, false, "think first")
+	out := ApplyThinkingInjectionToRequest(stdReq, config.PromptStyleV2, false, "think first")
 	if out.FinalPrompt != stdReq.FinalPrompt {
 		t.Fatalf("expected disabled injection to leave prompt untouched, got %q", out.FinalPrompt)
 	}
@@ -141,7 +143,7 @@ func TestReapplyThinkingInjectionToPromptPatchesVisiblePromptOnly(t *testing.T)
 		FinalPrompt:     "User: 接着上文写完\nAssistant: ",
 		PromptTokenText: "附件全文",
 	}
-	out := ReapplyThinkingInjectionToPrompt(stdReq, true, "think first")
+	out := ReapplyThinkingInjectionToPrompt(stdReq, config.PromptStyleV2, true, "think first")
 	if !strings.Contains(out.FinalPrompt, "User: 接着上文写完\nthink first\nAssistant: ") {
 		t.Fatalf("expected contract before the assistant marker, got %q", out.FinalPrompt)
 	}
@@ -161,8 +163,8 @@ func TestReapplyThinkingInjectionToPromptPatchesVisiblePromptOnly(t *testing.T)
 
 func TestReapplyThinkingInjectionToPromptIsIdempotent(t *testing.T) {
 	stdReq := StandardRequest{FinalPrompt: "User: hi\nAssistant: ", PromptTokenText: "token"}
-	once := ReapplyThinkingInjectionToPrompt(stdReq, true, DefaultThinkingInjectionPrompt)
-	twice := ReapplyThinkingInjectionToPrompt(once, true, DefaultThinkingInjectionPrompt)
+	once := ReapplyThinkingInjectionToPrompt(stdReq, config.PromptStyleV2, true, DefaultThinkingInjectionPrompt)
+	twice := ReapplyThinkingInjectionToPrompt(once, config.PromptStyleV2, true, DefaultThinkingInjectionPrompt)
 	if strings.Count(twice.FinalPrompt, DefaultThinkingInjectionPrompt) != 1 {
 		t.Fatalf("expected single injection, got %q", twice.FinalPrompt)
 	}
@@ -170,19 +172,51 @@ func TestReapplyThinkingInjectionToPromptIsIdempotent(t *testing.T) {
 
 func TestReapplyThinkingInjectionToPromptSkipsWhenDisabled(t *testing.T) {
 	stdReq := StandardRequest{FinalPrompt: "User: hi\nAssistant: "}
-	out := ReapplyThinkingInjectionToPrompt(stdReq, false, "think first")
+	out := ReapplyThinkingInjectionToPrompt(stdReq, config.PromptStyleV2, false, "think first")
 	if out.FinalPrompt != stdReq.FinalPrompt {
 		t.Fatalf("expected disabled reapply to be a no-op, got %q", out.FinalPrompt)
 	}
 }
 
 func TestReapplyThinkingInjectionToPromptEmptyPromptUsesBuiltinDefault(t *testing.T) {
-	out := ReapplyThinkingInjectionToPrompt(StandardRequest{FinalPrompt: "User: hi\nAssistant: "}, true, "   ")
+	out := ReapplyThinkingInjectionToPrompt(StandardRequest{FinalPrompt: "User: hi\nAssistant: "}, config.PromptStyleV2, true, "   ")
 	if !strings.Contains(out.FinalPrompt, ThinkingInjectionMarker) {
 		t.Fatalf("expected built-in default contract, got %q", out.FinalPrompt)
 	}
 }
 
+// 旧版风格：不注入内置执行契约；用户显式配置的自定义提示词仍然生效。
+func TestLegacyStyleSkipsBuiltinContract(t *testing.T) {
+	stdReq := StandardRequest{
+		Messages:        []any{map[string]any{"role": "user", "content": "hello"}},
+		FinalPrompt:     "User: hello\nAssistant: ",
+		PromptTokenText: "User: hello\nAssistant: ",
+	}
+	out := ApplyThinkingInjectionToRequest(stdReq, config.PromptStyleLegacy, true, "")
+	if strings.Contains(out.FinalPrompt, ThinkingInjectionMarker) {
+		t.Fatalf("legacy style must not inject the built-in contract, got %q", out.FinalPrompt)
+	}
+	if strings.Contains(out.FinalPrompt, ThinkingInjectionMarker) {
+		t.Fatalf("legacy style must not touch the prompt at all, got %q", out.FinalPrompt)
+	}
+	msg, _ := out.Messages[0].(map[string]any)
+	if msg["content"] != "hello" {
+		t.Fatalf("legacy style must not patch messages, got %#v", msg)
+	}
+
+	// 自定义提示词优先于风格：旧版风格下用户自己的要求依然注入。
+	custom := ApplyThinkingInjectionToRequest(stdReq, config.PromptStyleLegacy, true, "custom contract")
+	if !strings.Contains(custom.FinalPrompt, "custom contract") {
+		t.Fatalf("expected custom prompt to win over legacy style, got %q", custom.FinalPrompt)
+	}
+
+	// 未知风格按 v2 处理。
+	unknown := ApplyThinkingInjectionToRequest(stdReq, "nope", true, "")
+	if !strings.Contains(unknown.FinalPrompt, ThinkingInjectionMarker) {
+		t.Fatalf("unknown style must fall back to v2 contract, got %q", unknown.FinalPrompt)
+	}
+}
+
 // 执行契约必须做到三件事：上文真提过要求时逐条对上、语气跟着对方走、回复里不复述本段。
 func TestDefaultThinkingInjectionPromptCoversRequirementRecall(t *testing.T) {
 	for _, want := range []string{

webui/src/features/settings/BehaviorSection.jsx

@@ -83,6 +83,29 @@ export default function BehaviorSection({ t, form, setForm }) {
                     />
                     <p className="text-xs text-muted-foreground">{t('settings.thinkingInjectionPromptHelp')}</p>
                 </div>
+                <div className="text-sm space-y-2 md:col-span-2">
+                    <label htmlFor="prompt-style" className="text-muted-foreground">
+                        {t('settings.promptStyleTitle')}
+                    </label>
+                    <select
+                        id="prompt-style"
+                        value={form.prompt_style?.mode || 'v2'}
+                        onChange={(e) => setForm((prev) => ({
+                            ...prev,
+                            prompt_style: { ...prev.prompt_style, mode: e.target.value },
+                        }))}
+                        className="w-full bg-background border border-border rounded-lg px-3 py-2"
+                    >
+                        {(form.prompt_style?.modes || ['v2', 'legacy']).map((mode) => (
+                            <option key={mode} value={mode}>
+                                {mode === 'legacy'
+                                    ? t('settings.promptStyleLegacy')
+                                    : t('settings.promptStyleV2')}
+                            </option>
+                        ))}
+                    </select>
+                    <p className="text-xs text-muted-foreground">{t('settings.promptStyleHelp')}</p>
+                </div>
             </div>
         </div>
     )

webui/src/features/settings/ModelProfilesSection.jsx

@@ -0,0 +1,275 @@
+import { useCallback, useEffect, useState } from 'react'
+import { ChevronDown, ChevronUp, Plus, Save, Trash2 } from 'lucide-react'
+
+import { fetchModelProfiles, putModelProfiles } from './settingsApi'
+
+const FALLBACK_BASE_MODELS = [
+    'deepseek-v4-flash',
+    'deepseek-v4-flash-search',
+    'deepseek-v4-flash-nothinking',
+    'deepseek-v4-flash-search-nothinking',
+]
+
+function emptyProfile() {
+    return { id: '', base: FALLBACK_BASE_MODELS[0], name: '', remark: '', prompt: '' }
+}
+
+function normalizeItems(data) {
+    const items = Array.isArray(data?.items) ? data.items : []
+    return items.map((item) => ({
+        id: String(item?.id || ''),
+        base: String(item?.base || FALLBACK_BASE_MODELS[0]),
+        name: String(item?.name || ''),
+        remark: String(item?.remark || ''),
+        prompt: String(item?.prompt || ''),
+    }))
+}
+
+export default function ModelProfilesSection({ t, apiFetch, onMessage }) {
+    const [loading, setLoading] = useState(false)
+    const [saving, setSaving] = useState(false)
+    const [items, setItems] = useState([])
+    const [baseModels, setBaseModels] = useState(FALLBACK_BASE_MODELS)
+    const [maxCount, setMaxCount] = useState(50)
+    const [maxPromptChars, setMaxPromptChars] = useState(20000)
+    const [expandedRows, setExpandedRows] = useState({})
+    const [error, setError] = useState('')
+
+    const loadProfiles = useCallback(async () => {
+        setLoading(true)
+        try {
+            const { res, data } = await fetchModelProfiles(apiFetch)
+            if (!res.ok) {
+                setError(data?.detail || t('settings.modelProfilesLoadFailed'))
+                return
+            }
+            setItems(normalizeItems(data))
+            if (Array.isArray(data?.base_models) && data.base_models.length > 0) {
+                setBaseModels(data.base_models)
+            }
+            if (Number(data?.max_count) > 0) {
+                setMaxCount(Number(data.max_count))
+            }
+            if (Number(data?.max_prompt_chars) > 0) {
+                setMaxPromptChars(Number(data.max_prompt_chars))
+            }
+            setError('')
+        } catch (_e) {
+            setError(t('settings.modelProfilesLoadFailed'))
+        } finally {
+            setLoading(false)
+        }
+    }, [apiFetch, t])
+
+    useEffect(() => {
+        loadProfiles()
+    }, [loadProfiles])
+
+    const updateItem = useCallback((index, patch) => {
+        setItems((prev) => prev.map((item, i) => (i === index ? { ...item, ...patch } : item)))
+    }, [])
+
+    const removeItem = useCallback((index) => {
+        setItems((prev) => prev.filter((_item, i) => i !== index))
+        setExpandedRows({})
+    }, [])
+
+    const addItem = useCallback(() => {
+        setItems((prev) => (prev.length >= maxCount ? prev : [...prev, emptyProfile()]))
+    }, [maxCount])
+
+    const toggleRow = useCallback((index) => {
+        setExpandedRows((prev) => ({ ...prev, [index]: !prev[index] }))
+    }, [])
+
+    const validate = useCallback(() => {
+        const seen = new Set()
+        for (let i = 0; i < items.length; i += 1) {
+            const item = items[i]
+            const id = String(item.id || '').trim()
+            if (!id) {
+                return t('settings.modelProfilesIdRequired', { index: i + 1 })
+            }
+            if (!/^[A-Za-z0-9._-]{1,64}$/.test(id)) {
+                return t('settings.modelProfilesIdInvalid', { id })
+            }
+            const key = id.toLowerCase()
+            if (seen.has(key)) {
+                return t('settings.modelProfilesIdDuplicate', { id })
+            }
+            seen.add(key)
+            if (!String(item.base || '').trim()) {
+                return t('settings.modelProfilesBaseRequired', { id })
+            }
+            if (String(item.prompt || '').length > maxPromptChars) {
+                return t('settings.modelProfilesPromptTooLong', { id, count: maxPromptChars })
+            }
+        }
+        return ''
+    }, [items, maxPromptChars, t])
+
+    const save = useCallback(async () => {
+        const message = validate()
+        if (message) {
+            setError(message)
+            onMessage?.('error', message)
+            return
+        }
+        setSaving(true)
+        try {
+            const payload = {
+                items: items.map((item) => ({
+                    id: String(item.id || '').trim(),
+                    base: String(item.base || '').trim(),
+                    name: String(item.name || '').trim(),
+                    remark: String(item.remark || '').trim(),
+                    prompt: String(item.prompt || ''),
+                })),
+            }
+            const { res, data } = await putModelProfiles(apiFetch, payload)
+            if (!res.ok) {
+                const detail = data?.detail || t('settings.modelProfilesSaveFailed')
+                setError(detail)
+                onMessage?.('error', detail)
+                return
+            }
+            setError('')
+            onMessage?.('success', t('settings.modelProfilesSaveSuccess', { count: items.length }))
+            await loadProfiles()
+        } catch (_e) {
+            setError(t('settings.modelProfilesSaveFailed'))
+            onMessage?.('error', t('settings.modelProfilesSaveFailed'))
+        } finally {
+            setSaving(false)
+        }
+    }, [apiFetch, items, loadProfiles, maxPromptChars, onMessage, t, validate])
+
+    return (
+        <div className="bg-card border border-border rounded-xl p-5 space-y-4">
+            <div className="space-y-1">
+                <div className="flex items-center justify-between gap-3">
+                    <h3 className="font-semibold">{t('settings.modelProfilesTitle')}</h3>
+                    <span className="text-xs text-muted-foreground">
+                        {t('settings.modelProfilesCount', { count: items.length })}
+                    </span>
+                </div>
+                <p className="text-xs text-muted-foreground">{t('settings.modelProfilesDesc')}</p>
+            </div>
+
+            {error && <p className="text-xs text-destructive">{error}</p>}
+
+            {loading && <p className="text-xs text-muted-foreground">{t('actions.loading')}</p>}
+
+            {!loading && items.length === 0 && (
+                <p className="text-xs text-muted-foreground">{t('settings.modelProfilesEmpty')}</p>
+            )}
+
+            <div className="space-y-3">
+                {items.map((item, index) => {
+                    const expanded = Boolean(expandedRows[index])
+                    return (
+                        <div key={`${index}-${item.id}`} className="rounded-lg border border-border bg-background/60 p-4 space-y-3">
+                            <div className="grid grid-cols-1 md:grid-cols-4 gap-3">
+                                <label className="text-xs space-y-1">
+                                    <span className="text-muted-foreground block">{t('settings.modelProfilesId')}</span>
+                                    <input
+                                        type="text"
+                                        value={item.id}
+                                        onChange={(e) => updateItem(index, { id: e.target.value })}
+                                        placeholder={t('settings.modelProfilesIdPlaceholder')}
+                                        className="w-full bg-background border border-border rounded-lg px-3 py-2 text-sm"
+                                    />
+                                </label>
+                                <label className="text-xs space-y-1">
+                                    <span className="text-muted-foreground block">{t('settings.modelProfilesBase')}</span>
+                                    <select
+                                        value={item.base}
+                                        onChange={(e) => updateItem(index, { base: e.target.value })}
+                                        className="w-full bg-background border border-border rounded-lg px-3 py-2 text-sm"
+                                    >
+                                        {baseModels.map((model) => (
+                                            <option key={model} value={model}>{model}</option>
+                                        ))}
+                                    </select>
+                                </label>
+                                <label className="text-xs space-y-1">
+                                    <span className="text-muted-foreground block">{t('settings.modelProfilesName')}</span>
+                                    <input
+                                        type="text"
+                                        value={item.name}
+                                        onChange={(e) => updateItem(index, { name: e.target.value })}
+                                        placeholder={t('settings.modelProfilesNamePlaceholder')}
+                                        className="w-full bg-background border border-border rounded-lg px-3 py-2 text-sm"
+                                    />
+                                </label>
+                                <label className="text-xs space-y-1">
+                                    <span className="text-muted-foreground block">{t('settings.modelProfilesRemark')}</span>
+                                    <input
+                                        type="text"
+                                        value={item.remark}
+                                        onChange={(e) => updateItem(index, { remark: e.target.value })}
+                                        className="w-full bg-background border border-border rounded-lg px-3 py-2 text-sm"
+                                    />
+                                </label>
+                            </div>
+                            <div className="flex items-center justify-between gap-2">
+                                <button
+                                    type="button"
+                                    onClick={() => toggleRow(index)}
+                                    className="text-xs text-muted-foreground hover:text-foreground flex items-center gap-1"
+                                >
+                                    {expanded ? <ChevronUp className="w-3.5 h-3.5" /> : <ChevronDown className="w-3.5 h-3.5" />}
+                                    {expanded ? t('settings.skillsCollapse') : t('settings.modelProfilesPrompt')}
+                                </button>
+                                <button
+                                    type="button"
+                                    onClick={() => removeItem(index)}
+                                    className="text-xs text-destructive hover:opacity-80 flex items-center gap-1"
+                                >
+                                    <Trash2 className="w-3.5 h-3.5" />
+                                    {t('settings.modelProfilesRemove')}
+                                </button>
+                            </div>
+                            {expanded && (
+                                <div className="space-y-1">
+                                    <textarea
+                                        rows={8}
+                                        value={item.prompt}
+                                        onChange={(e) => updateItem(index, { prompt: e.target.value })}
+                                        placeholder={t('settings.modelProfilesPromptPlaceholder')}
+                                        className="w-full bg-background border border-border rounded-lg px-3 py-2 resize-y min-h-32 text-sm leading-6"
+                                    />
+                                    <p className="text-xs text-muted-foreground">
+                                        {t('settings.modelProfilesPromptHint')}
+                                    </p>
+                                </div>
+                            )}
+                        </div>
+                    )
+                })}
+            </div>
+
+            <div className="flex flex-wrap items-center gap-2">
+                <button
+                    type="button"
+                    onClick={addItem}
+                    disabled={items.length >= maxCount}
+                    className="h-9 px-3 rounded-lg border border-border bg-background text-sm hover:bg-secondary/70 disabled:opacity-50 flex items-center gap-1"
+                >
+                    <Plus className="w-4 h-4" />
+                    {t('settings.modelProfilesAdd')}
+                </button>
+                <button
+                    type="button"
+                    onClick={save}
+                    disabled={saving}
+                    className="h-9 px-3 rounded-lg bg-primary text-primary-foreground text-sm hover:bg-primary/90 disabled:opacity-50 flex items-center gap-1"
+                >
+                    <Save className="w-4 h-4" />
+                    {saving ? t('settings.skillsSaving') : t('settings.modelProfilesSave')}
+                </button>
+                <span className="text-xs text-muted-foreground">{t('settings.modelProfilesHint')}</span>
+            </div>
+        </div>
+    )
+}

webui/src/features/settings/SettingsContainer.jsx

@@ -9,6 +9,7 @@ import BehaviorSection from './BehaviorSection'
 import PromptProfileSection from './PromptProfileSection'
 import ToolCallsSection from './ToolCallsSection'
 import SkillsSection from './SkillsSection'
+import ModelProfilesSection from './ModelProfilesSection'
 import CurrentInputFileSection from './CurrentInputFileSection'
 import FileAuditSection from './FileAuditSection'
 import AutoDeleteSection from './AutoDeleteSection'
@@ -106,6 +107,8 @@ export default function SettingsContainer({ onRefresh, onMessage, authFetch, onF
 
             <ToolCallsSection t={t} form={form} setForm={setForm} />
 
+            <ModelProfilesSection t={t} apiFetch={apiFetch} onMessage={onMessage} />
+
             <SkillsSection t={t} apiFetch={apiFetch} onMessage={onMessage} />
 
             <CurrentInputFileSection t={t} form={form} setForm={setForm} />

webui/src/features/settings/settingsApi.js

@@ -69,3 +69,25 @@ export async function putSkills(apiFetch, payload) {
     }
     return { res, data }
 }
+
+// 自定义模型列表是独立接口：整体读取、整体覆盖。
+export async function fetchModelProfiles(apiFetch) {
+    const res = await apiFetch('/admin/model_profiles')
+    const data = await res.json()
+    return { res, data }
+}
+
+export async function putModelProfiles(apiFetch, payload) {
+    const res = await apiFetch('/admin/model_profiles', {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+    })
+    let data = {}
+    try {
+        data = await res.json()
+    } catch (_e) {
+        data = {}
+    }
+    return { res, data }
+}

webui/src/features/settings/useSettingsForm.js

@@ -20,6 +20,7 @@ const DEFAULT_FORM = {
     current_input_file: { enabled: true, min_chars: 0 },
     thinking_injection: { enabled: true, prompt: '', default_prompt: '' },
     prompt_profile: { enabled: false, name: 'default', prompt: '', presets: [] },
+    prompt_style: { mode: 'v2', modes: ['v2', 'legacy'] },
     tools: { enabled: false },
     model_aliases_text: '{}',
 }
@@ -63,6 +64,7 @@ function fromServerForm(data) {
     const currentInputSource = snapshot.current_input_file || data.current_input_file || {}
     const thinkingSource = snapshot.thinking_injection || data.thinking_injection || {}
     const promptProfileSource = snapshot.prompt_profile || data.prompt_profile || {}
+    const promptStyleSource = data.prompt_style || {}
     const toolsSource = snapshot.tools || data.tools || {}
     const modelAliasesSource = snapshot.model_aliases || data.model_aliases || {}
     const currentInputFileEnabled = currentInputSource?.enabled ?? true
@@ -107,6 +109,12 @@ function fromServerForm(data) {
             prompt: promptProfileSource?.prompt || '',
             presets: Array.isArray(data.prompt_profile?.presets) ? data.prompt_profile.presets : [],
         },
+        prompt_style: {
+            mode: promptStyleSource?.mode || 'v2',
+            modes: Array.isArray(promptStyleSource?.modes) && promptStyleSource.modes.length > 0
+                ? promptStyleSource.modes
+                : ['v2', 'legacy'],
+        },
         // 工具调用默认关闭：上游风控严格，加工具说明有封号风险。
         tools: {
             enabled: Boolean(toolsSource?.enabled),
@@ -148,6 +156,7 @@ function toServerPayload(form) {
             name: String(form.prompt_profile?.name || 'default').trim() || 'default',
             prompt: String(form.prompt_profile?.prompt || '').trim(),
         },
+        prompt_style: String(form.prompt_style?.mode || 'v2').trim() || 'v2',
         tools: {
             enabled: Boolean(form.tools?.enabled),
         },

webui/src/locales/en.json

@@ -477,6 +477,10 @@
         "thinkingInjectionPrompt": "Thinking format prompt",
         "thinkingInjectionRestoreDefault": "Restore built-in default",
         "thinkingInjectionPromptHelp": "Leave empty to use the built-in default prompt shown as the input placeholder.",
+        "promptStyleTitle": "Built-in prompt style",
+        "promptStyleV2": "v2 (current: continuation carries requirements, contract injected)",
+        "promptStyleLegacy": "legacy (short continuation, no built-in contract)",
+        "promptStyleHelp": "The legacy feel comes from adding almost no constraints: the model answers in its own default style, so replies tend to be longer and looser. Pick v2 when you want earlier requirements honoured item by item; switch to legacy when replies feel too short and too customer-service-like. A custom thinking-injection prompt you write yourself still applies under either style.",
         "promptProfileTitle": "Prompt profile (optional)",
         "promptProfileDesc": "Prepends a server-side spec block to the final prompt, layered above thinking injection and the skill library. Off by default; when off, existing requests keep exactly the same prompt.",
         "promptProfileEnabled": "Enable prompt profile",
@@ -488,6 +492,31 @@
         "promptProfilePrompt": "Custom body",
         "promptProfileRestoreDefault": "Restore built-in preset",
         "promptProfilePromptHelp": "Leave empty to use the selected preset's built-in body, shown as the placeholder. Custom text is capped at 20000 characters; when it conflicts with a user or client role definition, the user's setting wins.",
+        "modelProfilesTitle": "Custom models",
+        "modelProfilesDesc": "Expose several model names on top of the same flash base model, each with its own prompt. Clients pick a name, entries do not affect each other, and rollback is simpler than flipping a global switch. When the selected model carries a prompt it wins; otherwise the prompt profile above applies.",
+        "modelProfilesCount": "{count} total",
+        "modelProfilesEmpty": "No custom models yet. Click \"Add model\" to create one, e.g. id deepseek-writer, base flash, prompt with your writing spec.",
+        "modelProfilesLoadFailed": "Failed to load custom models",
+        "modelProfilesSave": "Save model list",
+        "modelProfilesSaveSuccess": "Custom models saved ({count})",
+        "modelProfilesSaveFailed": "Failed to save custom models",
+        "modelProfilesId": "Model name (public id)",
+        "modelProfilesIdPlaceholder": "e.g. deepseek-writer",
+        "modelProfilesIdRequired": "Model #{index} has no name yet",
+        "modelProfilesIdInvalid": "Model name \"{id}\" may only use letters, digits, dot, underscore and hyphen, 1-64 characters",
+        "modelProfilesIdDuplicate": "Model name \"{id}\" is duplicated",
+        "modelProfilesBase": "Base model",
+        "modelProfilesBaseRequired": "Model \"{id}\" has no base model",
+        "modelProfilesName": "Display name (optional)",
+        "modelProfilesNamePlaceholder": "e.g. Writing only",
+        "modelProfilesRemark": "Remark (optional)",
+        "modelProfilesPrompt": "Prompt for this model (expand to edit)",
+        "modelProfilesPromptPlaceholder": "Prompt body that only applies to this model; leave empty to add no extra spec",
+        "modelProfilesPromptHint": "Leave empty to add no extra spec for this model; the prompt profile or default behaviour then applies.",
+        "modelProfilesPromptTooLong": "Prompt for \"{id}\" exceeds {count} characters",
+        "modelProfilesAdd": "Add model",
+        "modelProfilesRemove": "Remove",
+        "modelProfilesHint": "The model list is saved on its own; the Save settings button below does not submit it.",
         "toolsTitle": "Tool calling (experimental)",
         "toolsWarning": "Upstream is strict about DSML tool calls and may ban the account, so this is off by default.",
         "toolsEnabled": "Enable tool calling",

webui/src/locales/zh.json

@@ -477,6 +477,10 @@
         "thinkingInjectionPrompt": "思考格式提示词",
         "thinkingInjectionRestoreDefault": "恢复内置默认提示词",
         "thinkingInjectionPromptHelp": "留空时使用内置默认提示词；默认内容会显示在输入框占位文本中。",
+        "promptStyleTitle": "内置提示词风格",
+        "promptStyleV2": "v2（当前版：衔接指令带执行要求，注入执行契约）",
+        "promptStyleLegacy": "legacy（旧版：短衔接指令，不注入执行契约）",
+        "promptStyleHelp": "旧版手感来自「几乎不加约束」：模型按自己的默认风格作答，回答更长更放得开。需要「上文要求逐条满足」选 v2；觉得回答太短、太像客服就切 legacy。你自己填的思考注入提示词在任何风格下都生效。",
         "promptProfileTitle": "提示词特化层（可选）",
         "promptProfileDesc": "在最终 prompt 最前面补一段服务端规范，与思考注入、技能库分层叠加。默认关闭，关闭时现有请求的 prompt 保持不变。",
         "promptProfileEnabled": "启用提示词特化层",
@@ -488,6 +492,31 @@
         "promptProfilePrompt": "自定义正文",
         "promptProfileRestoreDefault": "恢复内置预设",
         "promptProfilePromptHelp": "留空时使用所选预设的内置正文，占位文本里就是该正文；自定义内容上限 20000 字符。与用户或客户端设定的角色冲突时以用户设定为准。",
+        "modelProfilesTitle": "自定义模型（模型列表）",
+        "modelProfilesDesc": "给同一个 flash 基模挂出多个对外模型名，每个名字带自己的提示词。客户端按模型名选用，互不影响，比改全局开关更好回滚。命中带提示词的模型时优先用它，没命中才回落到上面的提示词特化层。",
+        "modelProfilesCount": "共 {count} 个",
+        "modelProfilesEmpty": "还没有自定义模型。点「添加模型」建一个，例如 id 填 deepseek-writer、基模选 flash、提示词填写作规范。",
+        "modelProfilesLoadFailed": "加载自定义模型失败",
+        "modelProfilesSave": "保存模型列表",
+        "modelProfilesSaveSuccess": "自定义模型已保存（{count} 个）",
+        "modelProfilesSaveFailed": "保存自定义模型失败",
+        "modelProfilesId": "模型名（对外 id）",
+        "modelProfilesIdPlaceholder": "例如：deepseek-writer",
+        "modelProfilesIdRequired": "第 {index} 个模型还没填模型名",
+        "modelProfilesIdInvalid": "模型名「{id}」只能用字母、数字、点、下划线和短横线，长度 1-64",
+        "modelProfilesIdDuplicate": "模型名「{id}」重复了",
+        "modelProfilesBase": "基模",
+        "modelProfilesBaseRequired": "模型「{id}」还没选基模",
+        "modelProfilesName": "展示名（可选）",
+        "modelProfilesNamePlaceholder": "例如：写作专用",
+        "modelProfilesRemark": "备注（可选）",
+        "modelProfilesPrompt": "该模型的提示词（展开编辑）",
+        "modelProfilesPromptPlaceholder": "该模型专属的提示词正文；留空表示不加额外规范",
+        "modelProfilesPromptHint": "留空则该模型不加额外规范，回落到提示词特化层或默认行为。",
+        "modelProfilesPromptTooLong": "模型「{id}」的提示词超过 {count} 字符",
+        "modelProfilesAdd": "添加模型",
+        "modelProfilesRemove": "删除",
+        "modelProfilesHint": "模型列表单独保存，不随下方「保存设置」提交。",
         "toolsTitle": "工具调用（实验性）",
         "toolsWarning": "上游对 DSML 工具调用风控严格，触发后可能封号，因此默认关闭。",
         "toolsEnabled": "启用工具调用",