@rexvane/piweb 0.3.24 → 0.3.26

package/src/lib/chat/file-path.ts

@@ -0,0 +1,54 @@
+/**
+ * 正文里的文件路径识别（纯函数）。
+ *
+ * 模型回答里经常出现 `src/lib/pi.ts`、`./scripts/dev.mjs` 这类路径，把它们变成可点击的、
+ * 直接用 PiWeb 的文件查看器打开，省掉手动去项目栏里翻。
+ *
+ * 判定刻意保守——宁可少认，也不要把普通文字变成链接（猜错会让用户点开一个「文件不存在」）：
+ *   - 必须有路径分隔符，或看起来像「名字.扩展名」；
+ *   - 排除 URL（http/https/协议相对）、邮箱、纯版本号（v1.2.3 / 1.2.3）、纯数字；
+ *   - 排除以 / 或 ~ 开头的绝对路径与家目录路径：它们不属于当前工作区，点开多半是错的；
+ *   - 排除含空格、通配符、模板占位（< > { } * ?）的片段。
+ *
+ * 只做识别，不校验存在性：校验要为每个候选发一次请求，代价远大于收益；
+ * 查看器本身对不存在的路径会体面地报错（见 FileViewer 的目录兜底与「文件不存在」）。
+ */
+
+/** 有扩展名的相对路径：至少一段目录 + 文件名.扩展名，如 src/lib/pi.ts、scripts/dev.mjs。
+ *  目录段允许方括号——Next.js 的动态路由目录就是 [id] 这种写法，在 PiWeb 自己的代码里很常见。 */
+const RELATIVE_WITH_DIR = /^(?:\.{1,2}\/)?(?:[\w.@[\]-]+\/)+[\w.@[\]-]+\.[A-Za-z][\w]{0,9}$/;
+/** 只有文件名但带扩展名：如 agents.md、vite.config.ts、package.json —— 需要能对上常见代码/文档扩展名 */
+const BARE_FILENAME = /^[\w.@-]+\.[A-Za-z][\w]{0,9}$/;
+/**
+ * 裸文件名允许的扩展名。这里刻意收窄：像 v1.2.3、1.24 这类「数字.数字」在形状上与
+ * 文件名无法区分，靠扩展名列表把它们挡掉。
+ */
+const BARE_EXTENSIONS = new Set([
+	"ts", "tsx", "js", "jsx", "mjs", "cjs", "mts", "cts",
+	"json", "jsonc", "json5", "yml", "yaml", "toml", "ini", "env",
+	"css", "scss", "sass", "less", "html", "htm", "vue", "svelte",
+	"md", "mdx", "txt", "rst", "adoc",
+	"py", "rb", "go", "rs", "java", "kt", "kts", "swift", "c", "h", "cc", "cpp", "hpp", "cs", "php", "lua", "sh", "bash", "zsh", "ps1", "psm1", "bat", "cmd",
+	"sql", "graphql", "gql", "proto", "lock", "patch", "diff", "csv", "tsv", "xml", "svg",
+]);
+/** 明确不是路径的：URL、邮箱、协议相对地址 */
+const NOT_A_PATH = /^(?:[a-z][a-z0-9+.-]*:\/\/|\/\/|mailto:|www\.)/i;
+const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+/** 纯版本号：v1、1.2、v1.2.3、1.2.3-beta.1 */
+const VERSION = /^v?\d+(?:\.\d+)*(?:[-+][\w.]+)?$/;
+
+/** 单个片段是否像项目内的相对文件路径 */
+export function looksLikeFilePath(raw: string): boolean {
+	const value = raw.trim();
+	if (!value || value.length > 260) return false;
+	if (NOT_A_PATH.test(value) || EMAIL.test(value) || VERSION.test(value)) return false;
+	// 绝对路径与家目录路径不属于当前工作区，点开多半是错的
+	if (value.startsWith("/") || value.startsWith("~") || /^[A-Za-z]:[\\/]/.test(value)) return false;
+	// 通配符 / 模板占位 / 反斜杠（Windows 路径在回答里少见，且与转义混淆）。
+	// 方括号不在此列：Next.js 的动态路由目录（[id]）是合法目录名，见上面对 RELATIVE_WITH_DIR 的说明。
+	if (/[*?<>{}|\\]/.test(value)) return false;
+	if (RELATIVE_WITH_DIR.test(value)) return true;
+	if (!BARE_FILENAME.test(value)) return false;
+	const ext = value.slice(value.lastIndexOf(".") + 1).toLowerCase();
+	return BARE_EXTENSIONS.has(ext);
+}

package/src/lib/chat/skill-expansion.ts

@@ -0,0 +1,51 @@
+/**
+ * 技能命令展开的识别。
+ *
+ * 用户在输入框里发 `/skill:name args` 时，pi 会在 `_expandSkillCommand` 里把 SKILL.md 正文
+ * 展开成提示词，格式是：
+ *
+ *   <skill name="computer-use" location="/path/SKILL.md">
+ *   References are relative to /path.
+ *
+ *   ...正文...
+ *   </skill>
+ *   \n\n参数（有参数时才会追加）
+ *
+ * 这段展开文本会作为用户消息存进会话，所以重新打开会话时它依然在。直接渲染就是一大段
+ * SKILL.md 正文；这里把它认出来，只留技能名给界面显示（正文与参数都不展示）。
+ *
+ * 保守起见只在整条消息「以 <skill 开头」时才认，避免把正文里恰好引用了这个标签的普通消息误判。
+ */
+
+export interface ExpandedSkill {
+	/** 技能名（pi 展开时写入的 name 属性） */
+	name: string;
+	/** 用户在技能名后面打的正文（展开后追加在 `</skill>` 之后；没有则为空串） */
+	args: string;
+}
+
+/** 整条消息就是一个技能展开时返回技能名与参数，否则返回 null */
+export function parseExpandedSkill(text: string): ExpandedSkill | null {
+	const trimmed = text.trimStart();
+	if (!trimmed.startsWith("<skill ")) return null;
+	const open = /^<skill\s+([^>]*)>/.exec(trimmed);
+	if (!open) return null;
+	const attrs = open[1];
+	const name = /\bname\s*=\s*"([^"]*)"/.exec(attrs)?.[1]?.trim();
+	if (!name) return null;
+	// 必须能找到对应的闭合标签，才认定这是一次完整的展开（半截内容不认）
+	const close = trimmed.lastIndexOf("</skill>");
+	if (close < 0) return null;
+	// 参数在闭合标签之后，与技能正文同属一条用户消息（pi 不单独发）
+	return { name, args: trimmed.slice(close + "</skill>".length).trim() };
+}
+
+/**
+ * 拿用户消息当标题 / 摘要时用的文本：技能展开还原成用户当初打的 `/skill:name 参数`，
+ * 别的原样返回。会话列表、窗口标题、增长树的轮次标题都走它，不再露出 `<skill name=…>` 和 SKILL.md 正文。
+ */
+export function promptTitleText(text: string): string {
+	const skill = parseExpandedSkill(text);
+	if (!skill) return text;
+	return skill.args ? `/skill:${skill.name} ${skill.args}` : `/skill:${skill.name}`;
+}

package/src/lib/extension-ui.ts

@@ -31,6 +31,28 @@ export interface ExtensionUiBridge {
 
 const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
 
+const plainText = (text: unknown): string => (typeof text === "string" ? text : String(text ?? ""));
+/**
+ * 扩展常写 `ctx.ui.theme.fg("accent", text)` 给状态文字上色；pi 的 noOp 上下文也带 theme。
+ * 缺了它扩展一调就抛 TypeError。Web 不渲染 ANSI，所以给一个原样返回文字、不加任何转义序列的主题。
+ */
+const PLAIN_THEME = {
+	name: "piweb-plain",
+	style: (text: string) => plainText(text),
+	fg: (_color: string, text: string) => plainText(text),
+	bg: (_color: string, text: string) => plainText(text),
+	bold: plainText,
+	italic: plainText,
+	underline: plainText,
+	inverse: plainText,
+	strikethrough: plainText,
+	getFgAnsi: () => "",
+	getBgAnsi: () => "",
+	getColorMode: () => "truecolor",
+	getThinkingBorderColor: () => plainText,
+	getBashModeBorderColor: () => plainText,
+};
+
 export function createExtensionUiBridge(opts: {
 	publish: (evt: WebEvent) => void;
 	hasViewers: () => boolean;
@@ -106,9 +128,11 @@ export function createExtensionUiBridge(opts: {
 		addAutocompleteProvider: () => {},
 		setEditorComponent: () => {},
 		getEditorComponent: () => undefined,
+		theme: PLAIN_THEME,
 		getAllThemes: () => [],
 		getTheme: () => undefined,
-		setTheme: () => {},
+		// 与 pi 的 noOp 同一返回形状：扩展会读 result.success，返回 undefined 会让它们解构时出错
+		setTheme: () => ({ success: false, error: "UI not available" }),
 		getToolsExpanded: () => false,
 		setToolsExpanded: () => {},
 	};

package/src/lib/font.ts

@@ -1,20 +1,18 @@
 /**
- * 字体族偏好：界面字体与代码字体各自独立选择。
+ * 界面字体族偏好。
  * 与字号（piweb.fontSize / piweb.chatFontSize，见 theme.ts applyFontSize）分开，
- * 存 localStorage：piweb.fontUi / piweb.fontMono，
- * 通过覆盖 CSS 变量 --font-ui / --font-mono 生效（变量默认值见 globals.css）。
+ * 存 localStorage：piweb.fontUi，通过覆盖 CSS 变量 --font-ui 生效（默认值见 globals.css）。
+ *
+ * 代码字体（--font-mono）不再可配：固定为系统等宽（见 globals.css 的 --font-mono）。
+ * 原先的 piweb.fontMono 偏好会被清掉，避免旧值残留却已无入口可改。
  *
  * 值有两种写法：
- *   - 预设 id（如 "maple" / "system" / "jetbrains"）
+ *   - 预设 id（如 "maple" / "system" / "noto"）
  *   - 自定义字体栈，前缀 "custom:"（如 "custom:Fira Code, monospace"）
  */
 
-export type FontScope = "ui" | "mono";
-
-export const DEFAULT_FONT_STACK: Record<FontScope, string> = {
-	ui: '"Maple Mono CN", ui-monospace, SFMono-Regular, Menlo, Consolas, "PingFang SC", "Microsoft YaHei", monospace',
-	mono: '"Maple Mono CN", ui-monospace, SFMono-Regular, Menlo, Consolas, monospace',
-};
+export const DEFAULT_FONT_STACK =
+	'"Maple Mono CN", ui-monospace, SFMono-Regular, Menlo, Consolas, "PingFang SC", "Microsoft YaHei", monospace';
 
 export interface FontPreset {
 	id: string;
@@ -22,63 +20,63 @@ export interface FontPreset {
 	label: { zh: string; en: string };
 }
 
-export const FONT_PRESETS: Record<FontScope, FontPreset[]> = {
-	ui: [
-		{ id: "maple", stack: DEFAULT_FONT_STACK.ui, label: { zh: "Maple Mono CN（默认）", en: "Maple Mono CN (default)" } },
-		{ id: "system", stack: 'ui-sans-serif, system-ui, -apple-system, "Segoe UI", "PingFang SC", "Microsoft YaHei", sans-serif', label: { zh: "系统默认", en: "System default" } },
-		{ id: "noto", stack: '"Noto Sans SC", ui-sans-serif, system-ui, "PingFang SC", "Microsoft YaHei", sans-serif', label: { zh: "思源黑体", en: "Noto Sans SC" } },
-	],
-	mono: [
-		{ id: "maple", stack: DEFAULT_FONT_STACK.mono, label: { zh: "Maple Mono CN（默认）", en: "Maple Mono CN (default)" } },
-		{ id: "system", stack: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace", label: { zh: "系统等宽", en: "System monospace" } },
-		{ id: "jetbrains", stack: '"JetBrains Mono", ui-monospace, SFMono-Regular, Menlo, Consolas, monospace', label: { zh: "JetBrains Mono", en: "JetBrains Mono" } },
-		{ id: "fira", stack: '"Fira Code", ui-monospace, SFMono-Regular, Menlo, Consolas, monospace', label: { zh: "Fira Code", en: "Fira Code" } },
-	],
-};
+export const FONT_PRESETS: FontPreset[] = [
+	{ id: "maple", stack: DEFAULT_FONT_STACK, label: { zh: "Maple Mono CN（默认）", en: "Maple Mono CN (default)" } },
+	{ id: "system", stack: 'ui-sans-serif, system-ui, -apple-system, "Segoe UI", "PingFang SC", "Microsoft YaHei", sans-serif', label: { zh: "系统默认", en: "System default" } },
+	{ id: "noto", stack: '"Noto Sans SC", ui-sans-serif, system-ui, "PingFang SC", "Microsoft YaHei", sans-serif', label: { zh: "思源黑体", en: "Noto Sans SC" } },
+];
 
 export const CUSTOM_PREFIX = "custom:";
-const KEY: Record<FontScope, string> = { ui: "piweb.fontUi", mono: "piweb.fontMono" };
-const CSS_VAR: Record<FontScope, string> = { ui: "--font-ui", mono: "--font-mono" };
+const KEY = "piweb.fontUi";
+/** 已废弃的代码字体偏好键：保留常量只为在启动时清掉历史残留 */
+const RETIRED_MONO_KEY = "piweb.fontMono";
+const CSS_VAR = "--font-ui";
 
 /** localStorage 里的原始偏好（预设 id 或 custom: 前缀的字体栈） */
-export function loadFontChoice(scope: FontScope): string | null {
+export function loadFontChoice(): string | null {
 	if (typeof window === "undefined") return null;
 	try {
-		return localStorage.getItem(KEY[scope]);
+		return localStorage.getItem(KEY);
 	} catch {
 		return null;
 	}
 }
 
 /** 把偏好解析成可直接写进 CSS 变量的字体栈；无法识别时回落默认 */
-export function resolveFontStack(scope: FontScope, stored: string | null): string {
-	if (!stored) return DEFAULT_FONT_STACK[scope];
+export function resolveFontStack(stored: string | null): string {
+	if (!stored) return DEFAULT_FONT_STACK;
 	if (stored.startsWith(CUSTOM_PREFIX)) {
 		const custom = stored.slice(CUSTOM_PREFIX.length).trim();
-		return custom || DEFAULT_FONT_STACK[scope];
+		return custom || DEFAULT_FONT_STACK;
 	}
-	return FONT_PRESETS[scope].find((p) => p.id === stored)?.stack ?? DEFAULT_FONT_STACK[scope];
+	return FONT_PRESETS.find((p) => p.id === stored)?.stack ?? DEFAULT_FONT_STACK;
 }
 
 /** 应用并持久化；value 传 null 表示恢复默认（移除内联覆盖 + 清 localStorage） */
-export function applyFontChoice(scope: FontScope, value: string | null): void {
+export function applyFontChoice(value: string | null): void {
 	if (typeof window === "undefined") return;
 	const root = document.documentElement;
 	try {
 		if (!value) {
-			root.style.removeProperty(CSS_VAR[scope]);
-			localStorage.removeItem(KEY[scope]);
+			root.style.removeProperty(CSS_VAR);
+			localStorage.removeItem(KEY);
 			return;
 		}
-		root.style.setProperty(CSS_VAR[scope], resolveFontStack(scope, value));
-		localStorage.setItem(KEY[scope], value);
+		root.style.setProperty(CSS_VAR, resolveFontStack(value));
+		localStorage.setItem(KEY, value);
 	} catch {
 		/* ignore */
 	}
 }
 
-/** 启动 / 系统主题变化 / 跨标签同步时重放两处字体偏好 */
+/** 启动 / 系统主题变化 / 跨标签同步时重放字体偏好 */
 export function applyAllFonts(): void {
-	applyFontChoice("ui", loadFontChoice("ui"));
-	applyFontChoice("mono", loadFontChoice("mono"));
+	// 代码字体设置已移除：清掉旧偏好，并移除可能残留的内联覆盖（--font-mono 现在由 CSS 决定）
+	try {
+		localStorage.removeItem(RETIRED_MONO_KEY);
+		document.documentElement.style.removeProperty("--font-mono");
+	} catch {
+		/* ignore */
+	}
+	applyFontChoice(loadFontChoice());
 }

package/src/lib/git-service.ts

@@ -9,6 +9,7 @@ import path from "node:path";
 import { promisify } from "node:util";
 import { parseNumstat, resolveGitBin } from "./growth-service";
 import { BoundaryError, isPathInside, resolveWorkspacePath } from "./path-security";
+import { utf8Prefix } from "./text-sanitize";
 
 const exec = promisify(execFile);
 
@@ -213,9 +214,10 @@ async function fullDiffStats(root: string, args: string[], noIndex = false): Pro
 	return { stats: { add, del }, binary };
 }
 
+/** 按字节截断时退到字符边界：直接 subarray 会把多字节字符切成半个，patch 末尾多出一个 U+FFFD */
 function truncate(patch: string, stats: GitDiffResult["stats"]): GitDiffResult {
 	if (Buffer.byteLength(patch) <= MAX_DIFF_BYTES) return { patch, truncated: false, binary: false, stats };
-	return { patch: Buffer.from(patch).subarray(0, MAX_DIFF_BYTES).toString("utf8"), truncated: true, binary: false, stats };
+	return { patch: utf8Prefix(Buffer.from(patch), MAX_DIFF_BYTES).toString("utf8"), truncated: true, binary: false, stats };
 }
 
 function assertRepoRelative(root: string, relPath: unknown): string {
@@ -254,7 +256,7 @@ export async function gitDiff(cwdValue: unknown, relPath: unknown, mode: unknown
 			await handle.close();
 		}
 		const head = buffer.subarray(0, bytesRead);
-		const text = head.subarray(0, MAX_DIFF_BYTES).toString("utf8").replace(/\r\n/g, "\n");
+		const text = utf8Prefix(head, MAX_DIFF_BYTES).toString("utf8").replace(/\r\n/g, "\n");
 		const lines = text.split("\n");
 		if (lines[lines.length - 1] === "") lines.pop();
 		const body = lines.map((l) => `+${l}`).join("\n");

package/src/lib/growth-turns.ts

@@ -1,3 +1,5 @@
+import { promptTitleText } from "./chat/skill-expansion";
+
 export interface SessionTurn {
 	id: string;
 	ts: number;
@@ -47,7 +49,7 @@ export function promptsFromEntries(entries: readonly SessionEntry[], fromIndex =
 	for (const entry of entries.slice(Math.max(0, fromIndex))) {
 		if (entry.type !== "message" || entry.message?.role !== "user" || !entry.id) continue;
 		ids.push(entry.id);
-		if (!title) title = textOf(entry.message.content).split("\n").map((line) => line.trim()).find(Boolean) ?? "";
+		if (!title) title = promptTitleText(textOf(entry.message.content)).split("\n").map((line) => line.trim()).find(Boolean) ?? "";
 	}
 	return { ids, title };
 }

package/src/lib/model-draft.ts

@@ -7,11 +7,26 @@ export interface ModelDraft {
 	maxTokens?: number;
 	/** 输入模态里有 image（models.json 的 `input`）。undefined = 源里没写：pi 会当成只文本、把贴图换成占位文字 */
 	vision?: boolean;
+	/**
+	 * 是否推理模型（models.json 的 `reasoning`）。undefined = 源里没写：
+	 * pi 按 false 处理（`definition.reasoning ?? false`），思考档位会整个消失。
+	 */
+	reasoning?: boolean;
 	source?: Readonly<Record<string, unknown>>;
 	/** 来自 modelOverrides：只覆盖内置模型的部分字段。缺省 = models[] 里的定义或新加的行 */
 	origin?: "override";
 }
 
+/** models.json 里 provider 级的自定义请求头：名字 → 值 */
+export function providerHeadersFromConfig(value: unknown): Record<string, string> {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	const out: Record<string, string> = {};
+	for (const [name, raw] of Object.entries(value as Record<string, unknown>)) {
+		if (typeof raw === "string") out[name] = raw;
+	}
+	return out;
+}
+
 /**
  * models.json 里模型的 `input` 字段（pi 用它判断能不能收图）。
  * 没写 → pi 按只文本处理，而且提示语会说是「模型不支持图像」，很容易被当成模型能力问题。
@@ -46,6 +61,8 @@ export function modelDraftFromConfig(value: unknown): ModelDraft {
 		maxTokens: typeof source.maxTokens === "number" ? source.maxTokens : undefined,
 		// 只有源里写了 input 才算「声明过」：没写 ≠ 只文本，而是「会被 pi 当只文本」
 		vision: input ? input.includes("image") : undefined,
+		// 同理：没写 reasoning 不是 false，而是「没声明」——pi 会按 false 处理，体检卡片据此提醒
+		reasoning: typeof source.reasoning === "boolean" ? source.reasoning : undefined,
 		source,
 	};
 }
@@ -55,7 +72,7 @@ function positiveInt(value: unknown): number | undefined {
 }
 
 /** 「获取可用模型」返回的一条 → 表单行：端点报了容量与视觉就带上，没报的留空（不猜） */
-export function modelDraftFromCatalog(entry: { id: string; name?: string; contextWindow?: number; maxTokens?: number; vision?: boolean }): ModelDraft {
+export function modelDraftFromCatalog(entry: { id: string; name?: string; contextWindow?: number; maxTokens?: number; vision?: boolean; reasoning?: boolean }): ModelDraft {
 	const contextWindow = positiveInt(entry.contextWindow);
 	const maxTokens = positiveInt(entry.maxTokens);
 	return {
@@ -64,6 +81,8 @@ export function modelDraftFromCatalog(entry: { id: string; name?: string; contex
 		...(contextWindow === undefined ? {} : { contextWindow }),
 		...(maxTokens === undefined ? {} : { maxTokens }),
 		...(typeof entry.vision === "boolean" ? { vision: entry.vision } : {}),
+		// 端点报了推理能力就带上：不写的话 pi 按 false 处理，思考档位会整个消失
+		...(typeof entry.reasoning === "boolean" ? { reasoning: entry.reasoning } : {}),
 	};
 }
 
@@ -99,6 +118,24 @@ export function formatCapacity(value: number | undefined): string {
 	return String(value);
 }
 
+/**
+ * 请求头名字的合法字符集与长度上限（HTTP 令牌字符）。
+ * 前端与 API 路由共用同一套规则，避免一边放行、一边 400。
+ */
+export const HEADER_NAME_RE = /^[A-Za-z0-9!#$%&'*+.^_`|~-]{1,64}$/;
+/** 请求头条数上限：表单里手填的头不会很多，超过基本是异常输入 */
+export const HEADER_MAX_COUNT = 32;
+
+/** 校验一组自定义请求头；返回错误文案（中文，直接给用户看），没问题返回 null */
+export function validateHeaderEntries(entries: Array<[string, string]>): string | null {
+	if (entries.length > HEADER_MAX_COUNT) return `请求头最多 ${HEADER_MAX_COUNT} 条`;
+	for (const [name, value] of entries) {
+		if (!HEADER_NAME_RE.test(name)) return `请求头名字不合法：${name}`;
+		if (value.length > 4096 || /[\r\n]/.test(value)) return `请求头内容不合法：${name}`;
+	}
+	return null;
+}
+
 export function validateModelDrafts(models: ModelDraft[]): { index: number; reason: "id" | "capacity" } | undefined {
 	const ids = new Set<string>();
 	for (let index = 0; index < models.length; index += 1) {
@@ -139,6 +176,12 @@ export function serializeModelDraft(model: Omit<ModelDraft, "name"> & { name?: s
 	} else if (!Object.is(vision, original?.vision)) {
 		result.input = modelInputFor(vision);
 	}
+	// reasoning 是三态：true/false 是用户或端点明确表态，undefined 表示不表态（沿用源值）。
+	// pi 缺省 false，所以只有显式 true 才有意义，但 false 也要能写下去（推翻源里的 true）。
+	const reasoning = model.reasoning;
+	if (reasoning !== undefined && !Object.is(reasoning, original?.reasoning)) {
+		result.reasoning = reasoning;
+	}
 	return result;
 }
 
@@ -149,6 +192,8 @@ export interface ProviderDraft {
 	api?: string;
 	/** Blank means unchanged. Redacted secrets are restored by the server, never invented here. */
 	apiKey?: string;
+	/** 自定义请求头（models.json 的 `headers`）。undefined = 未加载/不表态，{} = 明确清空 */
+	headers?: Record<string, string>;
 }
 
 export function serializeProviderDraft(
@@ -166,6 +211,19 @@ export function serializeProviderDraft(
 		else delete result[field];
 	}
 	if (draft.apiKey?.trim()) result.apiKey = draft.apiKey.trim();
+	// 请求头：只在表单确实载入过（headers !== undefined）时按整体替换写回。
+	// 空对象 = 用户删光了，要把键去掉；否则保留原文件里没在表单里呈现的头（不认得的字段一律不动）。
+	if (draft.headers !== undefined) {
+		const cleaned: Record<string, string> = {};
+		for (const [name, value] of Object.entries(draft.headers)) {
+			if (typeof value === "string" && value) cleaned[name] = value;
+		}
+		const existing = isRecord(source.headers) ? source.headers : {};
+		const unknown = Object.fromEntries(Object.entries(existing).filter(([, v]) => typeof v !== "string"));
+		const merged = { ...cleaned, ...unknown };
+		if (Object.keys(merged).length) result.headers = merged;
+		else delete result.headers;
+	}
 	const { definitions, overrides } = catalogIds
 		? splitBuiltinModels(draft.models, catalogIds)
 		: { definitions: draft.models.map((model) => serializeModelDraft(model)), overrides: undefined };
@@ -234,7 +292,7 @@ export function isInertProviderConfig(config: Readonly<Record<string, unknown>>)
 	return Object.keys(config).every((field) => INERT_PROVIDER_FIELDS.has(field));
 }
 
-export type CustomModelField = "contextWindow" | "maxTokens" | "input";
+export type CustomModelField = "contextWindow" | "maxTokens" | "input" | "reasoning";
 
 /** 体检的一条：models[] 里有字段没写的模型（已写的值一并带上，界面要显示） */
 export interface CustomModelGap {
@@ -246,6 +304,7 @@ export interface CustomModelGap {
 	contextWindow?: number;
 	maxTokens?: number;
 	vision?: boolean;
+	reasoning?: boolean;
 	missing: CustomModelField[];
 }
 
@@ -266,6 +325,8 @@ export function customModelGaps(providers: Readonly<Record<string, unknown>>): C
 			if (model.contextWindow === undefined) missing.push("contextWindow");
 			if (model.maxTokens === undefined) missing.push("maxTokens");
 			if (!Array.isArray(model.input)) missing.push("input");
+			// reasoning 没写时 pi 按 false 处理，推理模型的思考档位会整个消失，所以也要提醒
+			if (typeof model.reasoning !== "boolean") missing.push("reasoning");
 			if (!missing.length) return;
 			const declared = modelDraftFromConfig(model);
 			gaps.push({
@@ -276,6 +337,7 @@ export function customModelGaps(providers: Readonly<Record<string, unknown>>): C
 				...(declared.contextWindow === undefined ? {} : { contextWindow: declared.contextWindow }),
 				...(declared.maxTokens === undefined ? {} : { maxTokens: declared.maxTokens }),
 				...(declared.vision === undefined ? {} : { vision: declared.vision }),
+				...(declared.reasoning === undefined ? {} : { reasoning: declared.reasoning }),
 				missing,
 			});
 		});
@@ -291,6 +353,7 @@ export interface ModelFieldFill {
 	contextWindow?: number;
 	maxTokens?: number;
 	vision?: boolean;
+	reasoning?: boolean;
 }
 
 /**
@@ -316,6 +379,10 @@ export function fillModelFields(providers: Readonly<Record<string, unknown>>, fi
 			model.input = modelInputFor(fill.vision);
 			touched = true;
 		}
+		if (typeof fill.reasoning === "boolean" && typeof model.reasoning !== "boolean") {
+			model.reasoning = fill.reasoning;
+			touched = true;
+		}
 		if (touched) filled += 1;
 	}
 	return { providers: next, filled };

package/src/lib/models-service.ts

@@ -68,19 +68,52 @@ export interface DiscoveredModel {
 	maxTokens?: number;
 	/** 端点自报的输入模态里有 image */
 	vision?: boolean;
+	/**
+	 * 端点自报「这是推理模型」。对应 models.json 的 `reasoning`。
+	 * 不写时 pi 按 false 处理（provider-composer 的 `definition.reasoning ?? false`），
+	 * 思考档位就整个消失，所以能读到就带上。
+	 */
+	reasoning?: boolean;
 }
 
 function positiveInt(value: unknown): number | undefined {
 	return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
 }
 
+/**
+ * 从模型目录条目里挑出「是否推理模型」。
+ *
+ * 各家命名不同，能读到就带上、读不到留空（不猜——猜错会让非推理模型多出思考档位，
+ * 选中后上游直接 400）。已知的几种形状：
+ * - `reasoning: true` / `supports_reasoning: true`：部分网关直接给布尔；
+ * - `capabilities.reasoning` / `capabilities.thinking.supported`：Anthropic Messages 系的 /models；
+ * - `supported_parameters` 数组里出现 reasoning 相关项：OpenRouter 系。
+ */
+function catalogReasoning(value: Record<string, unknown>): boolean | undefined {
+	const direct = value.reasoning ?? value.supports_reasoning;
+	if (typeof direct === "boolean") return direct;
+	const capabilities = isRecord(value.capabilities) ? value.capabilities : undefined;
+	const fromCapabilities = capabilities?.reasoning;
+	if (typeof fromCapabilities === "boolean") return fromCapabilities;
+	const thinking = isRecord(capabilities?.thinking) ? capabilities.thinking : undefined;
+	if (typeof thinking?.supported === "boolean") return thinking.supported;
+	if (Array.isArray(value.supported_parameters)) {
+		const hit = value.supported_parameters.some(
+			(item) => typeof item === "string" && /^(include_)?reasoning/i.test(item.trim()),
+		);
+		if (hit) return true;
+	}
+	return undefined;
+}
+
 /**
  * 从模型目录条目里挑出能力字段。各家命名不同，能给就读、读不到就留空（不猜，缺的由体检卡片提醒用户填）：
  * - 上下文：`context_window`（本机中转）/ `context_length`（OpenRouter）/ `max_input_tokens`；
  * - 输出上限：`max_output_tokens` / `max_completion_tokens` / `top_provider.max_completion_tokens`；
- * - 视觉：`modalities.input`（本机中转）/ `architecture.input_modalities`（OpenRouter / llama.cpp）。
+ * - 视觉：`modalities.input`（本机中转）/ `architecture.input_modalities`（OpenRouter / llama.cpp）；
+ * - 推理：见 catalogReasoning。
  */
-export function catalogCapabilities(value: Record<string, unknown>): Pick<DiscoveredModel, "contextWindow" | "maxTokens" | "vision"> {
+export function catalogCapabilities(value: Record<string, unknown>): Pick<DiscoveredModel, "contextWindow" | "maxTokens" | "vision" | "reasoning"> {
 	const architecture = isRecord(value.architecture) ? value.architecture : undefined;
 	const modalities = value.modalities ?? architecture?.input_modalities ?? value.input_modalities;
 	const inputList = Array.isArray(modalities)
@@ -99,10 +132,12 @@ export function catalogCapabilities(value: Record<string, unknown>): Pick<Discov
 	const vision = inputList
 		? inputList.some((item) => typeof item === "string" && item.toLowerCase() === "image")
 		: undefined;
+	const reasoning = catalogReasoning(value);
 	return {
 		...(contextWindow === undefined ? {} : { contextWindow }),
 		...(maxTokens === undefined ? {} : { maxTokens }),
 		...(vision === undefined ? {} : { vision }),
+		...(reasoning === undefined ? {} : { reasoning }),
 	};
 }
 
@@ -517,7 +552,7 @@ async function readModelCatalog(response: Response): Promise<unknown> {
 }
 
 /** Fetch a provider's conventional /models catalog without persisting credentials. */
-export async function discoverModels(input: { baseUrl: string; api?: string; apiKey?: string; providerId?: string; allowPrivate?: boolean }): Promise<DiscoveredModel[]> {
+export async function discoverModels(input: { baseUrl: string; api?: string; apiKey?: string; providerId?: string; allowPrivate?: boolean; headers?: Record<string, string> }): Promise<DiscoveredModel[]> {
 	const rawBaseUrl = input.baseUrl.trim();
 	if (!rawBaseUrl) throw new Error("缺少 API 地址");
 	const base = new URL(rawBaseUrl);
@@ -539,6 +574,21 @@ export async function discoverModels(input: { baseUrl: string; api?: string; api
 			throw new Error("已配置的凭证只能用于该 Provider 已配置的 API 地址；新地址请显式填写密钥");
 		}
 	}
+	// 自定义请求头可能带密钥，所以与凭证同一条规矩：只发往显式填了密钥的新地址，
+	// 或该 provider 已配置过的地址。否则一个新主机名就能把用户存好的头骗走。
+	if (input.headers && Object.keys(input.headers).length) {
+		if (!input.apiKey?.trim()) {
+			const rt = await getModelRuntime();
+			const provider = rt.getProviders().find((p) => p.id === input.providerId);
+			const configuredUrls = [provider?.baseUrl, credential?.baseUrl, ...(provider ? rt.getModels(provider.id).map((model) => model.baseUrl) : [])];
+			if (!isTrustedCredentialEndpoint(endpoint, configuredUrls)) {
+				throw new Error("自定义请求头只能用于该 Provider 已配置的 API 地址；新地址请显式填写密钥");
+			}
+		}
+		for (const [name, value] of Object.entries(input.headers)) {
+			if (typeof value === "string" && value) headers[name] = value;
+		}
+	}
 	const apiKey = credential?.key;
 	// OpenAI Codex 的模型目录由 SDK 内置（chatgpt.com 后端无公开 /models），OAuth 令牌无法用于目录探测
 	if (!input.apiKey?.trim() && credential?.oauth && input.providerId === "openai-codex") {

package/src/lib/pi.ts

@@ -292,8 +292,8 @@ function loaderKey(cwd: string): string {
 }
 
 /** 每个热会话必须拥有自己的扩展 runtime；这里只创建，不加入发现缓存。 */
-export async function createSessionResourceLoader(cwd: string): Promise<DefaultResourceLoader> {
-	const settingsManager = getSettingsManager(cwd);
+export async function createSessionResourceLoader(cwd: string, settingsOverride?: SettingsManager): Promise<DefaultResourceLoader> {
+	const settingsManager = settingsOverride ?? getSettingsManager(cwd);
 	settingsManager.setProjectTrusted(resolveProjectTrust(cwd).trusted);
 	const loader = new DefaultResourceLoader({ cwd: path.resolve(cwd), agentDir: getAgentDir(), settingsManager, extensionFactories: BUILTIN_EXTENSIONS });
 	const reload = loader.reload.bind(loader);