pi-cliproxyapi-autoconnect 1.2.0 → 1.2.1

package/README.md

@@ -289,6 +289,11 @@ CLIProxyAPI 官方建议调大 nginx 的 `proxy_read_timeout`，Cloudflare 免
 
 ## 更新日志
 
+### 1.2.1
+
+- pi TUI 内的登录提示、地址选择、错误信息和 `/cliproxy` 输出全部改为英文。
+- provider 显示名仍为 `CLIProxy`，`/login` 入口、`/cliproxy` 命令和模型前缀 `cliproxy/` 不变。
+
 ### 1.2.0
 
 - 包名从 `pi-cliproxy` 改为 `pi-cliproxyapi-autoconnect`；provider ID、`cliproxy.json`、`/cliproxy` 命令和模型前缀 `cliproxy/` 保持不变。

package/index.ts

@@ -51,7 +51,7 @@ import { getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent"
 
 const PROVIDER_ID = "cliproxy";
 const PROVIDER_NAME = "CLIProxy";
-const AUTH_NAME = "CLIProxy（域名 + API Key）";
+const AUTH_NAME = "CLIProxy (domain + API key)";
 const CONFIG_FILE_NAME = "cliproxy.json";
 const CONFIG_VERSION = 2;
 const REQUEST_TIMEOUT_MS = 10_000;
@@ -65,9 +65,9 @@ let lastRefreshError: string | undefined;
 type SupportedApi = "openai-completions" | "anthropic-messages" | "google-generative-ai";
 
 const PROVIDER_APIS: Readonly<Record<SupportedApi, string>> = {
-	"openai-completions": "OpenAI 兼容",
-	"anthropic-messages": "Anthropic 兼容",
-	"google-generative-ai": "Gemini 兼容",
+	"openai-completions": "OpenAI compatible",
+	"anthropic-messages": "Anthropic compatible",
+	"google-generative-ai": "Gemini compatible",
 };
 
 // =============================================================================
@@ -480,7 +480,7 @@ function isLocalHostname(hostname: string): boolean {
  */
 function normalizeDomain(input: string): NormalizedDomain {
 	const original = input.trim();
-	if (!original) throw new Error("未输入绑定域名");
+	if (!original) throw new Error("Domain is required.");
 	const implicitScheme = !/^[a-z][a-z\d+.-]*:\/\//iu.test(original);
 	const withScheme = implicitScheme
 		? `${isLocalHostname(original.split("/")[0]?.split(":")[0] ?? "") ? "http" : "https"}://${original}`
@@ -489,10 +489,10 @@ function normalizeDomain(input: string): NormalizedDomain {
 	try {
 		parsed = new URL(withScheme);
 	} catch {
-		throw new Error(`无法解析域名："${input}"。示例：proxy.example.com 或 https://proxy.example.com`);
+		throw new Error(`Could not parse domain: "${input}". Example: proxy.example.com or https://proxy.example.com`);
 	}
 	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-		throw new Error(`仅支持 http/https 地址，收到：${parsed.protocol}`);
+		throw new Error(`Only http/https URLs are supported; received: ${parsed.protocol}`);
 	}
 	parsed.username = "";
 	parsed.password = "";
@@ -527,7 +527,7 @@ function geminiBaseUrl(rootUrl: string): string {
 
 function abortSignalWithTimeout(signal: AbortSignal, timeoutMs: number): { signal: AbortSignal; cleanup: () => void } {
 	const controller = new AbortController();
-	const timer = setTimeout(() => controller.abort(new Error("请求超时")), timeoutMs);
+	const timer = setTimeout(() => controller.abort(new Error("Request timed out")), timeoutMs);
 	const onAbort = () => controller.abort(signal.reason);
 	if (signal.aborted) controller.abort(signal.reason);
 	else signal.addEventListener("abort", onAbort, { once: true });
@@ -549,12 +549,12 @@ async function safeText(response: Response): Promise<string> {
 }
 
 function describeFetchError(error: unknown, ownSignal: AbortSignal, outerSignal: AbortSignal): string {
-	if (outerSignal.aborted) return "已取消";
-	if (ownSignal.aborted) return "请求超时";
+	if (outerSignal.aborted) return "Cancelled";
+	if (ownSignal.aborted) return "Request timed out";
 	if (error instanceof Error) {
 		const cause = error.cause;
 		if (cause instanceof Error && cause.message && cause.message !== error.message) {
-			return `${error.message}（${cause.message}）`;
+			return `${error.message} (${cause.message})`;
 		}
 		return error.message;
 	}
@@ -572,7 +572,7 @@ function failureKindForStatus(status: number): FetchFailure["kind"] {
 function makeHttpFailure(status: number, body: string): FetchFailure {
 	return {
 		ok: false,
-		error: `HTTP ${status}${body ? `：${body}` : ""}`,
+		error: `HTTP ${status}${body ? `: ${body}` : ""}`,
 		kind: failureKindForStatus(status),
 		status,
 	};
@@ -587,8 +587,8 @@ async function probeCliproxy(rootUrl: string, signal: AbortSignal): Promise<stri
 		});
 		if (!response.ok) return undefined;
 		const body = (await response.json().catch(() => undefined)) as { status?: unknown } | undefined;
-		if (body?.status === "ok") return "已探测到 CLIProxyAPI（/healthz 正常）";
-		return "已探测到 /healthz，但响应不是 CLIProxyAPI 格式";
+		if (body?.status === "ok") return "Detected CLIProxyAPI (/healthz OK)";
+		return "Detected /healthz, but the response is not CLIProxyAPI format";
 	} catch {
 		return undefined;
 	} finally {
@@ -638,7 +638,7 @@ async function fetchOpenAIModels(baseUrl: string, apiKey: string, signal: AbortS
 			headers: {
 				Accept: "application/json",
 				Authorization: `Bearer ${apiKey}`,
-				"User-Agent": "pi-cliproxyapi-autoconnect/1.2",
+				"User-Agent": "pi-cliproxyapi-autoconnect/1.2.1",
 			},
 			signal: requestSignal,
 		});
@@ -648,7 +648,7 @@ async function fetchOpenAIModels(baseUrl: string, apiKey: string, signal: AbortS
 		}
 		const payload = await response.json().catch(() => undefined);
 		const models = parseOpenAIModelList(payload);
-		if (!models) return { ok: false, error: "响应不是 OpenAI 兼容的模型列表（缺少 data 数组）", kind: "format" };
+		if (!models) return { ok: false, error: "Response is not an OpenAI-compatible model list (missing data array)", kind: "format" };
 		return { ok: true, models };
 	} catch (error) {
 		return { ok: false, error: describeFetchError(error, requestSignal, signal), kind: "network" };
@@ -662,7 +662,7 @@ async function fetchGeminiModels(baseUrl: string, apiKey: string, signal: AbortS
 	const { signal: requestSignal, cleanup } = abortSignalWithTimeout(signal, REQUEST_TIMEOUT_MS);
 	try {
 		const response = await fetch(url, {
-			headers: { Accept: "application/json", "User-Agent": "pi-cliproxyapi-autoconnect/1.2" },
+			headers: { Accept: "application/json", "User-Agent": "pi-cliproxyapi-autoconnect/1.2.1" },
 			signal: requestSignal,
 		});
 		if (!response.ok) {
@@ -671,7 +671,7 @@ async function fetchGeminiModels(baseUrl: string, apiKey: string, signal: AbortS
 		}
 		const payload = await response.json().catch(() => undefined);
 		const models = parseOpenAIModelList(payload);
-		if (!models) return { ok: false, error: "响应不是 Gemini 兼容的模型列表（缺少 models 数组）", kind: "format" };
+		if (!models) return { ok: false, error: "Response is not a Gemini-compatible model list (missing models array)", kind: "format" };
 		return { ok: true, models };
 	} catch (error) {
 		return { ok: false, error: describeFetchError(error, requestSignal, signal), kind: "network" };
@@ -703,7 +703,7 @@ async function fetchAnthropicModels(baseUrl: string, apiKey: string, signal: Abo
 				// Anthropic's x-api-key header; sending both is harmless upstream.
 				Authorization: `Bearer ${apiKey}`,
 				"anthropic-version": "2023-06-01",
-				"User-Agent": "pi-cliproxyapi-autoconnect/1.2",
+				"User-Agent": "pi-cliproxyapi-autoconnect/1.2.1",
 			},
 			signal: requestSignal,
 		});
@@ -712,7 +712,7 @@ async function fetchAnthropicModels(baseUrl: string, apiKey: string, signal: Abo
 			if (response.status === 404 || response.status === 405 || response.status === 501) {
 				return {
 					ok: false,
-					error: `Anthropic 兼容接口没有可用的模型列表（HTTP ${response.status}）`,
+					error: `The Anthropic-compatible endpoint does not expose a usable model list (HTTP ${response.status})`,
 					kind: "unsupported",
 					status: response.status,
 				};
@@ -721,7 +721,7 @@ async function fetchAnthropicModels(baseUrl: string, apiKey: string, signal: Abo
 		}
 		const payload = await response.json().catch(() => undefined);
 		const models = parseOpenAIModelList(payload);
-		if (!models) return { ok: false, error: "响应不是 Anthropic 兼容的模型列表（缺少 data 数组）", kind: "format" };
+		if (!models) return { ok: false, error: "Response is not an Anthropic-compatible model list (missing data array)", kind: "format" };
 		return { ok: true, models };
 	} catch (error) {
 		return { ok: false, error: describeFetchError(error, requestSignal, signal), kind: "network" };
@@ -833,9 +833,9 @@ function isAuthFailure(failure: FetchFailure | undefined): boolean {
 
 function authFailureMessage(failure: FetchFailure): string {
 	if (failure.error.includes("unsafe_example_api_key")) {
-		return "CLIProxy 服务端仍在使用示例 API Key（unsafe_example_api_key），请先修改服务端 access.api-keys 并重启 CLIProxyAPI。";
+		return "CLIProxyAPI is still using the example API key (unsafe_example_api_key). Update access.api-keys on the server and restart CLIProxyAPI.";
 	}
-	return `API Key 验证失败：${failure.error}`;
+	return `API key verification failed: ${failure.error}`;
 }
 
 function normalizeApiKey(value: string): string {
@@ -844,7 +844,7 @@ function normalizeApiKey(value: string): string {
 
 function compactMessage(value: string, maxLength = 180): string {
 	const singleLine = value.replace(/\s+/gu, " ").trim();
-	return singleLine.length > maxLength ? `${singleLine.slice(0, maxLength)}…` : singleLine;
+	return singleLine.length > maxLength ? `${singleLine.slice(0, maxLength)}...` : singleLine;
 }
 
 /**
@@ -870,7 +870,7 @@ function summarizeDiscoveryAttempts(attempts: DiscoveryAttempt[]): string {
 	return attempts
 		.map(
 			({ candidate, failure }) =>
-				`${PROVIDER_APIS[candidate.api]} ${candidate.baseUrl}：${compactMessage(failure.error)}`,
+				`${PROVIDER_APIS[candidate.api]} ${candidate.baseUrl}: ${compactMessage(failure.error)}`,
 		)
 		.join("\n");
 }
@@ -905,10 +905,10 @@ async function autoDiscoverModels(
 async function runLogin(interaction: ProviderAuthInteraction): Promise<ApiKeyCredential> {
 	const domainInput = await interaction.prompt({
 		type: "text",
-		message: "CLIProxy 绑定域名（例如 proxy.example.com 或 https://proxy.example.com）",
+		message: "CLIProxy bound domain (for example proxy.example.com or https://proxy.example.com)",
 		placeholder: "proxy.example.com",
 	});
-	if (!domainInput.trim()) throw new Error("未输入绑定域名");
+	if (!domainInput.trim()) throw new Error("Domain is required.");
 
 	const { rootUrl: initialRootUrl, implicitScheme } = normalizeDomain(domainInput);
 	const promptForApiKey = async (message: string): Promise<string> => {
@@ -919,10 +919,10 @@ async function runLogin(interaction: ProviderAuthInteraction): Promise<ApiKeyCre
 				placeholder: "sk-...",
 			}),
 		);
-		if (!value) throw new Error("未输入 API Key");
+		if (!value) throw new Error("API key is required.");
 		return value;
 	};
-	let apiKey = await promptForApiKey("CLIProxy API Key（保存在 pi 的 auth.json）");
+	let apiKey = await promptForApiKey("CLIProxy API key (stored in pi's auth.json)");
 
 	// A bare host may be either http or https; only try the alternate scheme
 	// automatically when the user did not spell one out.
@@ -944,7 +944,7 @@ async function runLogin(interaction: ProviderAuthInteraction): Promise<ApiKeyCre
 		autoDiscoverModels(candidates, apiKey, interaction.signal, (candidate, index, total) => {
 			interaction.notify({
 				type: "progress",
-				message: `正在尝试 ${PROVIDER_APIS[candidate.api]}：${candidate.baseUrl}（${index + 1}/${total}）…`,
+				message: `Trying ${PROVIDER_APIS[candidate.api]}: ${candidate.baseUrl} (${index + 1}/${total})...`,
 			});
 		});
 
@@ -962,9 +962,9 @@ async function runLogin(interaction: ProviderAuthInteraction): Promise<ApiKeyCre
 		if (authFailure) {
 			interaction.notify({
 				type: "info",
-				message: `所有兼容地址都未能通过鉴权：${compactMessage(authFailure.error)}\n请重新输入一次 API Key。`,
+				message: `All compatible endpoints failed authentication: ${compactMessage(authFailure.error)}\nEnter the API key again.`,
 			});
-			apiKey = await promptForApiKey("重新输入 CLIProxy API Key");
+			apiKey = await promptForApiKey("Re-enter the CLIProxy API key");
 			outcome = await discover();
 			authFailure = outcome.ok ? undefined : firstAuthFailure(outcome.attempts);
 			if (authFailure) throw new Error(authFailureMessage(authFailure));
@@ -979,7 +979,7 @@ async function runLogin(interaction: ProviderAuthInteraction): Promise<ApiKeyCre
 		lastError = undefined;
 		interaction.notify({
 			type: "info",
-			message: `自动选择 ${PROVIDER_APIS[api]}：${baseUrl}（${models.length} 个模型）。`,
+			message: `Selected ${PROVIDER_APIS[api]}: ${baseUrl} (${models.length} models).`,
 		});
 	} else if (outcome.empty) {
 		// Every address answered, but no upstream credentials are available.
@@ -988,26 +988,26 @@ async function runLogin(interaction: ProviderAuthInteraction): Promise<ApiKeyCre
 		baseUrl = outcome.empty.baseUrl;
 		api = outcome.empty.api;
 		models = [];
-		lastError = "所有兼容地址均返回空模型列表";
+		lastError = "All compatible endpoints returned an empty model list";
 	} else {
 		const responding = outcome.attempts.find(({ failure }) => failure.kind !== "network");
 		activeRoot = responding?.candidate.rootUrl ?? initialRootUrl;
-		lastError = summarizeDiscoveryAttempts(outcome.attempts) || "未知错误";
+		lastError = summarizeDiscoveryAttempts(outcome.attempts) || "Unknown error";
 
 		const diagnostic = await probeCliproxy(activeRoot, interaction.signal);
 		interaction.notify({
 			type: "info",
-			message: `已自动尝试 ${outcome.attempts.length} 个兼容地址，均未获取到模型列表：\n${lastError}${diagnostic ? `\n${diagnostic}` : ""}`,
+			message: `Tried ${outcome.attempts.length} compatible endpoints, but none returned a model list:\n${lastError}${diagnostic ? `\n${diagnostic}` : ""}`,
 		});
 
 		const choice = await interaction.prompt({
 			type: "select",
-			message: "请选择 CLIProxy 兼容地址",
+			message: "Select a CLIProxy-compatible endpoint",
 			options: [
-				{ id: "retry-openai", label: `重试 OpenAI 兼容地址：${openAIBaseUrl(activeRoot)}` },
-				{ id: "anthropic", label: `Anthropic 兼容地址：${anthropicBaseUrl(activeRoot)}` },
-				{ id: "gemini", label: `Gemini 兼容地址：${geminiBaseUrl(activeRoot)}` },
-				{ id: "custom", label: "自定义兼容地址…" },
+				{ id: "retry-openai", label: `Retry OpenAI compatible: ${openAIBaseUrl(activeRoot)}` },
+				{ id: "anthropic", label: `Anthropic compatible: ${anthropicBaseUrl(activeRoot)}` },
+				{ id: "gemini", label: `Gemini compatible: ${geminiBaseUrl(activeRoot)}` },
+				{ id: "custom", label: "Custom compatible endpoint..." },
 			],
 		});
 
@@ -1035,7 +1035,7 @@ async function runLogin(interaction: ProviderAuthInteraction): Promise<ApiKeyCre
 				if (anthropic.kind === "unsupported") {
 					interaction.notify({
 						type: "info",
-						message: "该 Anthropic 兼容地址没有模型列表端点，请在下一步手动输入模型 ID。",
+						message: "This Anthropic-compatible endpoint has no model list endpoint. Enter model IDs manually in the next step.",
 					});
 				}
 			}
@@ -1054,18 +1054,18 @@ async function runLogin(interaction: ProviderAuthInteraction): Promise<ApiKeyCre
 			const customInput = (
 				await interaction.prompt({
 					type: "text",
-					message: "自定义兼容地址（完整 base URL，例如 https://proxy.example.com/v1）",
+					message: "Custom compatible endpoint (full base URL, for example https://proxy.example.com/v1)",
 					placeholder: "https://proxy.example.com/v1",
 				})
 			).trim();
-			if (!customInput) throw new Error("未输入自定义地址");
+			if (!customInput) throw new Error("A custom endpoint is required.");
 			const protocolChoice = await interaction.prompt({
 				type: "select",
-				message: "该地址使用的兼容协议",
+				message: "Compatible protocol for this endpoint",
 				options: [
-					{ id: "openai", label: "OpenAI 兼容（/v1/chat/completions）" },
-					{ id: "anthropic", label: "Anthropic 兼容（/v1/messages）" },
-					{ id: "gemini", label: "Gemini 兼容（/v1beta）" },
+					{ id: "openai", label: "OpenAI compatible (/v1/chat/completions)" },
+					{ id: "anthropic", label: "Anthropic compatible (/v1/messages)" },
+					{ id: "gemini", label: "Gemini compatible (/v1beta)" },
 				],
 			});
 			api =
@@ -1089,7 +1089,7 @@ async function runLogin(interaction: ProviderAuthInteraction): Promise<ApiKeyCre
 	if (models.length === 0) {
 		const manual = await interaction.prompt({
 			type: "text",
-			message: "未获取到模型列表。可手动输入模型 ID（逗号或空格分隔，留空则暂不添加模型）",
+			message: "No model list was retrieved. Enter model IDs manually (comma or space separated; leave empty to add none for now)",
 			placeholder: "claude-sonnet-4-5, gemini-2.5-pro",
 		});
 		models = parseManualModelIds(manual);
@@ -1120,19 +1120,19 @@ async function runLogin(interaction: ProviderAuthInteraction): Promise<ApiKeyCre
 		writeConfig(config);
 	} catch (error) {
 		throw new Error(
-			`CLIProxy 配置写入失败：${error instanceof Error ? error.message : String(error)}（${configPath()}）`,
+			`Failed to write CLIProxy config: ${error instanceof Error ? error.message : String(error)} (${configPath()})`,
 		);
 	}
 
 	if (models.length > 0) {
 		interaction.notify({
 			type: "info",
-			message: `CLIProxy 配置已保存：${baseUrl}（${models.length} 个模型，${PROVIDER_APIS[api]}）。`,
+			message: `CLIProxy config saved: ${baseUrl} (${models.length} models, ${PROVIDER_APIS[api]}).`,
 		});
 	} else {
 		interaction.notify({
 			type: "info",
-			message: `CLIProxy 配置已保存：${baseUrl}，但暂未导入任何模型。可使用 /cliproxy refresh 重试。`,
+			message: `CLIProxy config saved: ${baseUrl}, but no models were imported. Use /cliproxy refresh to retry.`,
 		});
 	}
 
@@ -1183,7 +1183,7 @@ async function refreshProviderModels(context: RefreshModelsContext): Promise<rea
 			writeConfig({
 				...config,
 				updatedAt: Date.now(),
-				lastError: "上游返回的模型列表为空（保留手动模型）",
+				lastError: "Upstream returned an empty model list (manual models kept)",
 			});
 		} catch {
 			// Best effort.
@@ -1197,7 +1197,7 @@ async function refreshProviderModels(context: RefreshModelsContext): Promise<rea
 		models: enriched,
 		source: "auto",
 		updatedAt: Date.now(),
-		...(enriched.length === 0 ? { lastError: "上游返回的模型列表为空" } : {}),
+		...(enriched.length === 0 ? { lastError: "Upstream returned an empty model list" } : {}),
 	};
 	if (enriched.length > 0) delete updated.lastError;
 	try {
@@ -1254,14 +1254,14 @@ export default function (pi: ExtensionAPI): void {
 	pi.registerProvider(buildProvider(readConfig()));
 
 	pi.registerCommand("cliproxy", {
-		description: "查看 CLIProxy 配置，或执行 /cliproxy refresh 刷新模型列表",
+		description: "Show CLIProxy config, or run /cliproxy refresh to refresh models",
 		handler: async (args, ctx) => {
 			const subcommand = args.trim().toLowerCase();
 			const config = readConfig();
 
 			if (subcommand === "refresh") {
 				if (!config) {
-					ctx.ui.notify("尚未配置 CLIProxy。请运行 /login 并选择“Sign in with an API key” → CLIProxy。", "warning");
+					ctx.ui.notify("CLIProxy is not configured. Run /login and choose \"Sign in with an API key\" -> CLIProxy.", "warning");
 					return;
 				}
 				let refreshError: string | undefined;
@@ -1277,20 +1277,20 @@ export default function (pi: ExtensionAPI): void {
 				}
 				const count = ctx.modelRegistry.getAll().filter((model) => model.provider === PROVIDER_ID).length;
 				if (refreshError) {
-					ctx.ui.notify(`CLIProxy 模型刷新失败：${refreshError}`, "error");
+					ctx.ui.notify(`CLIProxy model refresh failed: ${refreshError}`, "error");
 				} else if (lastRefreshError) {
-					ctx.ui.notify(`CLIProxy 模型刷新失败，继续使用缓存（共 ${count} 个）：${lastRefreshError}`, "warning");
+					ctx.ui.notify(`CLIProxy model refresh failed; using cached models (${count}): ${lastRefreshError}`, "warning");
 				} else if (count === 0) {
-					ctx.ui.notify("CLIProxy 已刷新，但仍未获取到模型。请检查 API Key 或运行 /login 重新配置。", "warning");
+					ctx.ui.notify("CLIProxy refreshed, but no models were found. Check the API key or run /login again.", "warning");
 				} else {
-					ctx.ui.notify(`CLIProxy 模型已刷新，共 ${count} 个。`, "info");
+					ctx.ui.notify(`CLIProxy models refreshed: ${count}.`, "info");
 				}
 				return;
 			}
 
 			if (!config) {
 				ctx.ui.notify(
-					`尚未配置 CLIProxy。\n请运行 /login → “Sign in with an API key” → CLIProxy，输入绑定域名和 API Key。\n配置将写入：${configPath()}`,
+					`CLIProxy is not configured.\nRun /login -> "Sign in with an API key" -> CLIProxy and enter the bound domain and API key.\nConfig will be written to: ${configPath()}`,
 					"info",
 				);
 				return;
@@ -1299,13 +1299,13 @@ export default function (pi: ExtensionAPI): void {
 			const count = ctx.modelRegistry.getAll().filter((model) => model.provider === PROVIDER_ID).length;
 			const lastError = lastRefreshError ?? config.lastError;
 			const lines = [
-				`CLIProxy：${config.baseUrl}`,
-				`协议：${PROVIDER_APIS[config.api]}（${config.api}）`,
-				`模型：${count} 个${config.models.length !== count ? `（缓存 ${config.models.length} 个）` : ""}`,
-				`配置：${configPath()}`,
-				lastError ? `最近错误：${lastError}` : undefined,
-				"重新配置：/login → “Sign in with an API key” → CLIProxy",
-				"刷新模型：/cliproxy refresh",
+				`CLIProxy: ${config.baseUrl}`,
+				`Protocol: ${PROVIDER_APIS[config.api]} (${config.api})`,
+				`Models: ${count}${config.models.length !== count ? ` (${config.models.length} cached)` : ""}`,
+				`Config: ${configPath()}`,
+				lastError ? `Last error: ${lastError}` : undefined,
+				"Reconfigure: /login -> \"Sign in with an API key\" -> CLIProxy",
+				"Refresh models: /cliproxy refresh",
 			].filter((line): line is string => Boolean(line));
 			ctx.ui.notify(lines.join("\n"), "info");
 		},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-cliproxyapi-autoconnect",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "CLIProxyAPI 自动连接插件 for pi：/login 输入绑定域名 + API Key，自动探测 OpenAI/Gemini/Anthropic 兼容地址并注册模型。",
   "type": "module",
   "license": "MIT",