pi-model-manager 0.1.0

package/models-json-sync.ts

@@ -0,0 +1,386 @@
+// models-json-sync.ts
+//
+// 将插件自有 state 中的接入/模型同步到 Pi 原生配置：
+// - models.json 承载模型定义，供 /model、--list-models、workflow 子代理等原生路径读取。
+// - settings.json 的 enabledModels 只在用户已经启用模型范围过滤时追加新模型；未配置时保持“全部启用”。
+
+import {
+	CONFIG_DIR_NAME,
+	getAgentDir,
+	ModelRegistry,
+	ModelRuntime,
+	SettingsManager,
+	type ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { minimatch } from "minimatch";
+import { atomicWriteText } from "./atomic-write.ts";
+import { cloneJson, formatUnknownError, isObjectRecord, stringifyJson, stripJsonNoise } from "./common.ts";
+import {
+	deleteProviderInDoc,
+	readModelsJsonSnapshot,
+	renameModelInDoc,
+	renameProviderInDoc,
+	setProviderInDoc,
+	writeModelsJsonSnapshot,
+	type ModelsJsonDocument,
+	type ModelsJsonModelEntry,
+	type ModelsJsonProviderEntry,
+} from "./models-json-manager.ts";
+import { buildModelRequestHeaders } from "./provider-registrar.ts";
+import type {
+	BuiltInClientHeaderProfileId,
+	StateDocument,
+	StoredClientHeaderCapture,
+	StoredModel,
+	StoredProvider,
+	StoredRequestHeaderProfile,
+} from "./types.ts";
+
+const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
+
+export interface NativeModelVerification {
+	ok: boolean;
+	warnings: string[];
+}
+
+export interface EnabledModelUpdate {
+	mode: "all-enabled" | "updated" | "unchanged";
+	scope?: "global" | "project";
+}
+
+function copyRecord(value: unknown): Record<string, unknown> | undefined {
+	return isObjectRecord(value) ? cloneJson(value) : undefined;
+}
+
+function copyStringRecord(value: unknown): Record<string, string> | undefined {
+	if (!isObjectRecord(value)) return undefined;
+	const record: Record<string, string> = {};
+	for (const [key, item] of Object.entries(value)) {
+		if (typeof item === "string") record[key] = item;
+	}
+	return Object.keys(record).length > 0 ? record : undefined;
+}
+
+function copyCost(value: StoredModel["cost"]): ModelsJsonModelEntry["cost"] {
+	return cloneJson(value);
+}
+
+function copyInput(value: StoredModel["input"]): ModelsJsonModelEntry["input"] {
+	return [...value];
+}
+
+function buildModelsJsonModelEntry(
+	provider: StoredProvider,
+	model: StoredModel,
+	requestHeaderProfiles: Record<string, StoredRequestHeaderProfile>,
+	clientHeaderCaptures: Partial<Record<BuiltInClientHeaderProfileId, StoredClientHeaderCapture>>,
+	existing?: ModelsJsonModelEntry,
+): ModelsJsonModelEntry {
+	const next: ModelsJsonModelEntry = existing ? { ...existing } : { id: model.id };
+	next.id = model.id;
+	if (model.name) next.name = model.name;
+	else delete next.name;
+	if (model.api) next.api = model.api;
+	else delete next.api;
+	if (model.baseUrl) next.baseUrl = model.baseUrl;
+	else delete next.baseUrl;
+	next.reasoning = model.reasoning;
+	if (model.thinkingLevelMap) next.thinkingLevelMap = { ...model.thinkingLevelMap };
+	else delete next.thinkingLevelMap;
+	next.input = copyInput(model.input);
+	next.contextWindow = model.contextWindow;
+	next.maxTokens = model.maxTokens;
+	next.cost = copyCost(model.cost);
+	const headers = buildModelRequestHeaders(provider, model, requestHeaderProfiles, clientHeaderCaptures);
+	if (headers) next.headers = headers;
+	else delete next.headers;
+	if (model.compat) next.compat = copyRecord(model.compat);
+	else delete next.compat;
+	return next;
+}
+
+export function buildModelsJsonProviderEntry(
+	provider: StoredProvider,
+	requestHeaderProfiles: Record<string, StoredRequestHeaderProfile> = {},
+	clientHeaderCaptures: Partial<Record<BuiltInClientHeaderProfileId, StoredClientHeaderCapture>> = {},
+	existing?: ModelsJsonProviderEntry,
+): ModelsJsonProviderEntry {
+	const next: ModelsJsonProviderEntry = existing ? { ...existing } : {};
+	if (provider.name) next.name = provider.name;
+	else delete next.name;
+	next.baseUrl = provider.baseUrl;
+	next.api = provider.api;
+	if (provider.apiKey) next.apiKey = provider.apiKey;
+	else delete next.apiKey;
+	if (provider.authHeader !== undefined) next.authHeader = provider.authHeader;
+	else delete next.authHeader;
+	const providerHeaders = copyStringRecord(provider.headers);
+	if (providerHeaders) next.headers = providerHeaders;
+	else delete next.headers;
+	if (provider.compat) next.compat = copyRecord(provider.compat);
+	else delete next.compat;
+	if (provider.modelOverrides) next.modelOverrides = cloneJson(provider.modelOverrides);
+	else delete next.modelOverrides;
+	const existingModels = new Map((existing?.models ?? []).map((model) => [model.id, model]));
+	next.models = provider.models.map((model) => buildModelsJsonModelEntry(
+		provider,
+		model,
+		requestHeaderProfiles,
+		clientHeaderCaptures,
+		existingModels.get(model.id),
+	));
+	return next;
+}
+
+export function buildSynchronizedModelsDocument(
+	document: StateDocument,
+	sourceDocument: ModelsJsonDocument,
+	removedProviderIds: string[] = [],
+): ModelsJsonDocument {
+	let nextDocument = sourceDocument;
+	for (const providerId of removedProviderIds) {
+		nextDocument = deleteProviderInDoc(nextDocument, providerId);
+	}
+	for (const [providerId, provider] of Object.entries(document.providers)) {
+		if (provider.models.length === 0) {
+			nextDocument = deleteProviderInDoc(nextDocument, providerId);
+			continue;
+		}
+		const entry = buildModelsJsonProviderEntry(
+			provider,
+			document.requestHeaderProfiles,
+			document.clientHeaderCaptures,
+			nextDocument.providers[providerId],
+		);
+		nextDocument = setProviderInDoc(nextDocument, providerId, entry);
+	}
+	return nextDocument;
+}
+
+export async function syncStateToModelsJson(document: StateDocument, removedProviderIds: string[] = []): Promise<void> {
+	const snapshot = await readModelsJsonSnapshot();
+	const nextDocument = buildSynchronizedModelsDocument(document, snapshot.document, removedProviderIds);
+	await writeModelsJsonSnapshot(snapshot, nextDocument);
+}
+
+export async function syncProviderRenameToModelsJson(
+	document: StateDocument,
+	oldProviderId: string,
+	newProviderId: string,
+): Promise<void> {
+	const snapshot = await readModelsJsonSnapshot();
+	const renamedDocument = renameProviderInDoc(snapshot.document, oldProviderId, newProviderId);
+	const nextDocument = buildSynchronizedModelsDocument(document, renamedDocument);
+	await writeModelsJsonSnapshot(snapshot, nextDocument);
+}
+
+export async function syncModelRenameToModelsJson(
+	document: StateDocument,
+	providerId: string,
+	oldModelId: string,
+	newModelId: string,
+): Promise<void> {
+	const snapshot = await readModelsJsonSnapshot();
+	const renamedDocument = renameModelInDoc(snapshot.document, providerId, oldModelId, newModelId);
+	const nextDocument = buildSynchronizedModelsDocument(document, renamedDocument);
+	await writeModelsJsonSnapshot(snapshot, nextDocument);
+}
+
+
+function splitThinkingSuffix(pattern: string): { base: string; suffix: string } {
+	const index = pattern.lastIndexOf(":");
+	if (index < 0) return { base: pattern, suffix: "" };
+	const maybeLevel = pattern.slice(index + 1);
+	if (!THINKING_LEVELS.has(maybeLevel)) return { base: pattern, suffix: "" };
+	return { base: pattern.slice(0, index), suffix: pattern.slice(index) };
+}
+
+function dedupeModelPatterns(patterns: string[]): string[] {
+	const seen = new Set<string>();
+	const next: string[] = [];
+	for (const pattern of patterns) {
+		const base = splitThinkingSuffix(pattern).base.toLowerCase();
+		if (seen.has(base)) continue;
+		seen.add(base);
+		next.push(pattern);
+	}
+	return next;
+}
+
+function enabledModelPatternMatches(pattern: string, fullModelId: string): boolean {
+	const slashIndex = fullModelId.indexOf("/");
+	const modelId = slashIndex >= 0 ? fullModelId.slice(slashIndex + 1) : fullModelId;
+	return minimatch(fullModelId, pattern, { nocase: true })
+		|| minimatch(modelId, pattern, { nocase: true });
+}
+
+function sameModelPatternBase(left: string, right: string): boolean {
+	return left.toLowerCase() === right.toLowerCase();
+}
+
+function upsertEnabledModelPattern(patterns: string[], fullModelId: string, replacedFullModelId?: string): string[] {
+	let covered = patterns.some((pattern) => enabledModelPatternMatches(splitThinkingSuffix(pattern).base, fullModelId));
+	const next = patterns.map((pattern) => {
+		const { base, suffix } = splitThinkingSuffix(pattern);
+		if (replacedFullModelId && sameModelPatternBase(base, replacedFullModelId)) {
+			covered = true;
+			return `${fullModelId}${suffix}`;
+		}
+		return pattern;
+	});
+	if (!covered) next.push(fullModelId);
+	return dedupeModelPatterns(next);
+}
+
+function removeEnabledModelPattern(patterns: string[], fullModelId: string): string[] {
+	return patterns.filter((pattern) => !sameModelPatternBase(splitThinkingSuffix(pattern).base, fullModelId));
+}
+
+async function atomicWriteJson(path: string, value: unknown): Promise<void> {
+	await atomicWriteText(path, stringifyJson(value));
+}
+
+async function readSettingsFile(path: string): Promise<Record<string, unknown>> {
+	const source = await readFile(path, "utf8");
+	const parsed = JSON.parse(stripJsonNoise(source));
+	if (!isObjectRecord(parsed)) throw new Error(`${path} 根节点必须是对象`);
+	return parsed;
+}
+
+async function updateProjectEnabledModels(cwd: string, update: (patterns: string[]) => string[]): Promise<EnabledModelUpdate> {
+	const path = join(cwd, CONFIG_DIR_NAME, "settings.json");
+	const settings = await readSettingsFile(path);
+	const current = settings.enabledModels;
+	if (!Array.isArray(current)) return { mode: "all-enabled" };
+	const patterns = current.filter((item): item is string => typeof item === "string");
+	if (patterns.length === 0) return { mode: "all-enabled" };
+	const next = update(patterns);
+	if (JSON.stringify(next) === JSON.stringify(patterns)) return { mode: "unchanged", scope: "project" };
+	settings.enabledModels = next;
+	await atomicWriteJson(path, settings);
+	return { mode: "updated", scope: "project" };
+}
+
+async function flushGlobalSettingsWrite(settings: SettingsManager): Promise<void> {
+	await settings.flush();
+	const errors = settings.drainErrors();
+	if (errors.length > 0) {
+		const detail = errors.map((entry) => `${entry.scope}: ${entry.error.message}`).join("; ");
+		throw new Error(`settings.json enabledModels 写入失败：${detail}`);
+	}
+}
+
+async function updateGlobalEnabledModels(cwd: string, update: (patterns: string[]) => string[]): Promise<EnabledModelUpdate> {
+	const settings = SettingsManager.create(cwd, getAgentDir());
+	const current = settings.getGlobalSettings().enabledModels;
+	if (!Array.isArray(current) || current.length === 0) return { mode: "all-enabled" };
+	const patterns = current.filter((item): item is string => typeof item === "string");
+	if (patterns.length === 0) return { mode: "all-enabled" };
+	const next = update(patterns);
+	if (JSON.stringify(next) === JSON.stringify(patterns)) return { mode: "unchanged", scope: "global" };
+	settings.setEnabledModels(next);
+	await flushGlobalSettingsWrite(settings);
+	return { mode: "updated", scope: "global" };
+}
+
+export async function enableModelForNextPiStart(
+	cwd: string,
+	fullModelId: string,
+	replacedFullModelId?: string,
+): Promise<EnabledModelUpdate> {
+	const settings = SettingsManager.create(cwd, getAgentDir());
+	const projectEnabled = settings.getProjectSettings().enabledModels;
+	const update = (patterns: string[]) => upsertEnabledModelPattern(patterns, fullModelId, replacedFullModelId);
+	if (Array.isArray(projectEnabled)) {
+		return updateProjectEnabledModels(cwd, update);
+	}
+	return updateGlobalEnabledModels(cwd, update);
+}
+
+export async function removeModelFromNextPiStart(cwd: string, fullModelId: string): Promise<EnabledModelUpdate> {
+	const settings = SettingsManager.create(cwd, getAgentDir());
+	const projectEnabled = settings.getProjectSettings().enabledModels;
+	const update = (patterns: string[]) => removeEnabledModelPattern(patterns, fullModelId);
+	if (Array.isArray(projectEnabled)) {
+		return updateProjectEnabledModels(cwd, update);
+	}
+	return updateGlobalEnabledModels(cwd, update);
+}
+
+function replaceEnabledProviderPatterns(
+	patterns: string[],
+	oldProviderId: string,
+	newProviderId: string,
+): string[] {
+	const oldPrefix = `${oldProviderId}/`;
+	let changed = false;
+	const next = patterns.map((pattern) => {
+		const { base, suffix } = splitThinkingSuffix(pattern);
+		if (!base.toLowerCase().startsWith(oldPrefix.toLowerCase())) return pattern;
+		changed = true;
+		return `${newProviderId}/${base.slice(oldPrefix.length)}${suffix}`;
+	});
+	return changed ? dedupeModelPatterns(next) : patterns;
+}
+
+
+export async function replaceProviderInEnabledModelsForNextPiStart(
+	cwd: string,
+	oldProviderId: string,
+	newProviderId: string,
+): Promise<EnabledModelUpdate> {
+	if (oldProviderId === newProviderId) return { mode: "unchanged" };
+	const settings = SettingsManager.create(cwd, getAgentDir());
+	const projectEnabled = settings.getProjectSettings().enabledModels;
+	const update = (patterns: string[]) => replaceEnabledProviderPatterns(patterns, oldProviderId, newProviderId);
+	if (Array.isArray(projectEnabled)) {
+		return updateProjectEnabledModels(cwd, update);
+	}
+	return updateGlobalEnabledModels(cwd, update);
+}
+
+async function verifyRegistryModel(
+	label: string,
+	registry: ModelRegistry,
+	providerId: string,
+	modelId: string,
+): Promise<string[]> {
+	const warnings: string[] = [];
+	const model = registry.find(providerId, modelId);
+	if (!model) {
+		warnings.push(`${label} 未找到模型 ${providerId}/${modelId}`);
+		return warnings;
+	}
+	if (!registry.hasConfiguredAuth(model)) {
+		warnings.push(`${label} 找到模型 ${providerId}/${modelId}，但 API key 未配置或不可解析`);
+		return warnings;
+	}
+	const auth = await registry.getApiKeyAndHeaders(model);
+	if (!auth.ok) warnings.push(`${label} 请求认证解析失败：${auth.error}`);
+	return warnings;
+}
+
+// 当前 registry 已在持久化边界 reload；独立 runtime 校验保证下次启动仍可从原生 models.json 解析。
+export async function verifyNativeModelAvailable(
+	ctx: ExtensionCommandContext,
+	providerId: string,
+	modelId: string,
+): Promise<NativeModelVerification> {
+	const warnings: string[] = [];
+	warnings.push(...await verifyRegistryModel("当前会话 registry", ctx.modelRegistry, providerId, modelId));
+	try {
+		const agentDir = getAgentDir();
+		const runtime = await ModelRuntime.create({
+			authPath: join(agentDir, "auth.json"),
+			modelsPath: join(agentDir, "models.json"),
+			allowModelNetwork: false,
+		});
+		const registry = new ModelRegistry(runtime);
+		warnings.push(...await verifyRegistryModel("原生 models.json registry", registry, providerId, modelId));
+	} catch (error) {
+		warnings.push(`原生 models.json registry 校验失败：${formatUnknownError(error)}`);
+	}
+	return { ok: warnings.length === 0, warnings };
+}

package/openai-responses-payload.ts

@@ -0,0 +1,80 @@
+// openai-responses-payload.ts
+//
+// 将 pi 内置 openai-responses 的 system/developer input 形态调整为标准
+// OpenAI Responses wire format：顶层 instructions + 纯对话 input。
+
+import { isObjectRecord } from "./common.ts";
+import type { StateDocument } from "./types.ts";
+
+type ActiveModelRef = {
+	provider: string;
+	id: string;
+	api: string;
+};
+
+type PayloadRecord = Record<string, unknown>;
+
+function isPayloadRecord(payload: unknown): payload is PayloadRecord {
+	return isObjectRecord(payload);
+}
+
+function isPromptRole(role: unknown): role is "developer" | "system" {
+	return role === "developer" || role === "system";
+}
+
+function extractTextInstruction(content: unknown): string | undefined {
+	if (typeof content === "string") {
+		const trimmed = content.trim();
+		return trimmed ? content : undefined;
+	}
+	if (!Array.isArray(content)) return undefined;
+
+	const parts: string[] = [];
+	for (const item of content) {
+		if (!isObjectRecord(item)) return undefined;
+		const type = item.type;
+		if (type !== "input_text" && type !== "text") return undefined;
+		if (typeof item.text !== "string") return undefined;
+		if (item.text.trim()) parts.push(item.text);
+	}
+	const instruction = parts.join("\n");
+	return instruction.trim() ? instruction : undefined;
+}
+
+function hasNonEmptyInstructions(payload: PayloadRecord): boolean {
+	return typeof payload.instructions === "string" && payload.instructions.trim().length > 0;
+}
+
+export function normalizeOpenAIResponsesInstructionsPayload(payload: unknown): PayloadRecord | undefined {
+	if (!isPayloadRecord(payload)) return undefined;
+	if (hasNonEmptyInstructions(payload)) return undefined;
+
+	const input = payload.input;
+	if (!Array.isArray(input) || input.length === 0) return undefined;
+
+	const leadingItem = input[0];
+	if (!isObjectRecord(leadingItem) || !isPromptRole(leadingItem.role)) return undefined;
+
+	const instructions = extractTextInstruction(leadingItem.content);
+	if (!instructions) return undefined;
+
+	return {
+		...payload,
+		instructions,
+		input: input.slice(1),
+	};
+}
+
+export function normalizeManagedOpenAIResponsesPayload(
+	payload: unknown,
+	model: ActiveModelRef | undefined,
+	state: StateDocument,
+): PayloadRecord | undefined {
+	if (!model || model.api !== "openai-responses") return undefined;
+	if (!isPayloadRecord(payload) || payload.model !== model.id) return undefined;
+
+	const storedModel = state.providers[model.provider]?.models.find((candidate) => candidate.id === model.id);
+	if (!storedModel) return undefined;
+
+	return normalizeOpenAIResponsesInstructionsPayload(payload);
+}

package/openai-service-tier.ts

@@ -0,0 +1,36 @@
+// openai-service-tier.ts
+//
+// 模型级 OpenAI Responses service_tier 注入。
+
+import type { StateDocument } from "./types.ts";
+
+type ActiveModelRef = {
+	provider: string;
+	id: string;
+	api: string;
+};
+
+type PayloadRecord = Record<string, unknown>;
+
+function isPayloadRecord(payload: unknown): payload is PayloadRecord {
+	return typeof payload === "object" && payload !== null && !Array.isArray(payload);
+}
+
+export function injectOpenAIServiceTier(
+	payload: unknown,
+	model: ActiveModelRef | undefined,
+	state: StateDocument,
+): PayloadRecord | undefined {
+	if (!model || model.api !== "openai-responses") return undefined;
+	if (!isPayloadRecord(payload)) return undefined;
+	if (payload.model !== model.id) return undefined;
+	if ("service_tier" in payload) return undefined;
+
+	const storedModel = state.providers[model.provider]?.models.find((candidate) => candidate.id === model.id);
+	if (storedModel?.openAIServiceTier !== "priority") return undefined;
+
+	return {
+		...payload,
+		service_tier: "priority",
+	};
+}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "pi-model-manager",
+  "version": "0.1.0",
+  "description": "A TUI model and provider manager for Pi with native models.json persistence, request-header profiles, proxy routing, and protocol compatibility.",
+  "type": "module",
+  "main": "./index.ts",
+  "files": [
+    "NOTICE",
+    "README.en.md",
+    "index.ts",
+    "state-store.ts",
+    "state-metadata-store.ts",
+    "state-cache.ts",
+    "state-document.ts",
+    "openai-responses-payload.ts",
+    "openai-service-tier.ts",
+    "claude-code-compat.ts",
+    "builtin-model-catalog.ts",
+    "models-json-manager.ts",
+    "models-json-sync.ts",
+    "provider-registrar.ts",
+    "local-proxy-service.ts",
+    "request-pipeline.ts",
+    "model-mutations.ts",
+    "header-profile-mutations.ts",
+    "models-json-mutations.ts",
+    "rescue.ts",
+    "atomic-write.ts",
+    "common.ts",
+    "config-value-reference.ts",
+    "configuration-persistence.ts",
+    "compat-settings.ts",
+    "runtime-base-url.ts",
+    "types.ts",
+    "tui/",
+    "presets/"
+  ],
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "pi",
+    "model-manager",
+    "provider-manager",
+    "models-json",
+    "client-headers",
+    "openai",
+    "anthropic"
+  ],
+  "author": "Qihuanxishini",
+  "license": "AGPL-3.0-only",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Qihuanxishini/pi-model-manager.git"
+  },
+  "homepage": "https://github.com/Qihuanxishini/pi-model-manager#readme",
+  "bugs": {
+    "url": "https://github.com/Qihuanxishini/pi-model-manager/issues"
+  },
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "image": "https://raw.githubusercontent.com/Qihuanxishini/pi-model-manager/main/assets/pi-model-manager-preview.png"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": ">=0.82.0",
+    "@earendil-works/pi-tui": ">=0.75.0"
+  },
+  "dependencies": {
+    "http-proxy-agent": "9.1.0",
+    "https-proxy-agent": "9.1.0",
+    "minimatch": "10.2.5"
+  }
+}

package/presets/builtin-client-headers.ts

@@ -0,0 +1,23 @@
+// 由私有 request-capture-service 根据真实客户端请求生成；公开插件仅消费这些脱敏后的内置值。
+
+export const CLAUDE_CODE_CLIENT_HEADERS: Record<string, string> = {
+	"user-agent": "claude-cli/2.1.219 (external, sdk-cli)",
+	"x-stainless-arch": "x64",
+	"x-stainless-lang": "js",
+	"x-stainless-os": "Windows",
+	"x-stainless-package-version": "0.94.0",
+	"x-stainless-retry-count": "0",
+	"x-stainless-runtime": "node",
+	"x-stainless-runtime-version": "v26.3.0",
+	"x-stainless-timeout": "300",
+	"anthropic-beta": "claude-code-20250219,interleaved-thinking-2025-05-14,thinking-token-count-2026-05-13,context-management-2025-06-27,prompt-caching-scope-2026-01-05,mid-conversation-system-2026-04-07,effort-2025-11-24",
+	"anthropic-dangerous-direct-browser-access": "true",
+	"anthropic-version": "2023-06-01",
+	"x-app": "cli",
+};
+
+export const CODEX_CLI_CLIENT_HEADERS: Record<string, string> = {
+	"user-agent": "codex-tui/0.145.0 (Windows 10.0.26200; x86_64) WindowsTerminal (codex-tui; 0.145.0)",
+	"originator": "codex-tui",
+	"x-codex-beta-features": "remote_compaction_v2",
+};