@victor-software-house/pi-openai-proxy 4.0.5 → 4.1.0

package/dist/index.mjs

@@ -1283,31 +1283,25 @@ async function piStream(model, context, request, options) {
 }
 //#endregion
 //#region src/server/routes.ts
-/**
-* Build a ModelExposureConfig from the server config.
-*/
-function buildExposureConfig(config) {
+function fileConfigReader() {
+	const file = loadConfigFromFile();
 	return {
-		publicModelIdMode: config.publicModelIdMode,
-		modelExposureMode: config.modelExposureMode,
-		scopedProviders: config.scopedProviders,
-		customModels: config.customModels,
-		providerPrefixes: config.providerPrefixes
+		publicModelIdMode: file.publicModelIdMode,
+		modelExposureMode: file.modelExposureMode,
+		scopedProviders: file.scopedProviders,
+		customModels: file.customModels,
+		providerPrefixes: file.providerPrefixes
 	};
 }
-/**
-* Compute or refresh the model exposure from the current registry and config.
-* Returns the exposure result or throws on config errors.
-*/
-function getExposure(config) {
-	const outcome = computeModelExposure(getAvailableModels(), getAllModels(), buildExposureConfig(config));
-	if (!outcome.ok) throw new Error(`Model exposure configuration error: ${outcome.message}`);
-	return outcome;
-}
-function createRoutes(config) {
+function createRoutes(config, configReader = fileConfigReader) {
+	function getExposure() {
+		const outcome = computeModelExposure(getAvailableModels(), getAllModels(), configReader());
+		if (!outcome.ok) throw new Error(`Model exposure configuration error: ${outcome.message}`);
+		return outcome;
+	}
 	const routes = new Hono();
 	routes.get("/v1/models", (c) => {
-		const exposure = getExposure(config);
+		const exposure = getExposure();
 		return c.json(buildModelList(exposure.models));
 	});
 	routes.get("/v1/models/*", (c) => {
@@ -1316,7 +1310,7 @@ function createRoutes(config) {
 		const modelIdEncoded = rawPath.slice(11);
 		if (modelIdEncoded.length === 0) return c.json(modelNotFound(""), 404);
 		const modelId = decodeURIComponent(modelIdEncoded);
-		const resolved = resolveExposedModel(getExposure(config), modelId);
+		const resolved = resolveExposedModel(getExposure(), modelId);
 		if (resolved === void 0) return c.json(modelNotFound(modelId), 404);
 		return c.json(toOpenAIModel(resolved));
 	});
@@ -1336,7 +1330,7 @@ function createRoutes(config) {
 			return c.json(invalidRequest(validation.message, validation.param ?? void 0), 400);
 		}
 		const request = validation.data;
-		const resolved = resolveExposedModel(getExposure(config), request.model);
+		const resolved = resolveExposedModel(getExposure(), request.model);
 		if (resolved === void 0) return c.json(modelNotFound(request.model), 404);
 		const model = resolved.model;
 		const canonicalModelId = resolved.canonicalId;
@@ -1422,13 +1416,13 @@ function createRoutes(config) {
 }
 //#endregion
 //#region src/server/app.ts
-function createApp(config) {
+function createApp(config, configReader) {
 	const app = new Hono();
 	app.use("*", requestIdMiddleware());
 	app.use("*", disconnectMiddleware());
 	app.use("*", bodySizeLimitMiddleware(config));
 	app.use("/v1/*", proxyAuthMiddleware(config));
-	app.route("/", createRoutes(config));
+	app.route("/", createRoutes(config, configReader));
 	return app;
 }
 //#endregion

package/extensions/proxy.ts

@@ -614,6 +614,40 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 		};
 	}
 
+	// --- Dynamic descriptions ---
+
+	const ID_MODE_DESCRIPTIONS: Record<string, string> = {
+		"collision-prefixed": "Short names; adds provider/ prefix only when models collide",
+		universal: "Short names only; fails if any model name is shared by two providers",
+		"always-prefixed": "Always provider/model-id for every model",
+	};
+
+	const EXPOSURE_MODE_DESCRIPTIONS: Record<string, string> = {
+		scoped: "Expose models from pi's configured auth (default)",
+		all: "Expose all registered models, including those without auth",
+		custom: "Expose only manually selected models",
+	};
+
+	function idModeDescription(): string {
+		return ID_MODE_DESCRIPTIONS[config.publicModelIdMode] ?? "";
+	}
+
+	function exposureModeDescription(): string {
+		return EXPOSURE_MODE_DESCRIPTIONS[config.modelExposureMode] ?? "";
+	}
+
+	function customModelsDescription(): string {
+		if (config.modelExposureMode === "custom") return "Press Enter to open model selector";
+		return "Switch exposure mode to 'custom' to select models";
+	}
+
+	function authDescription(): string {
+		if (config.authToken.length > 0) {
+			return `Token: ${config.authToken.slice(0, 8)}... (use /proxy show to copy)`;
+		}
+		return "Require bearer token for all requests";
+	}
+
 	function buildSettingItems(): SettingItem[] {
 		return [
 			// --- Server ---
@@ -641,10 +675,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 			{
 				id: "authToken",
 				label: "Proxy auth",
-				description:
-					config.authToken.length > 0
-						? `Token: ${config.authToken.slice(0, 8)}... (use /proxy show to copy)`
-						: "Require bearer token for all requests",
+				description: authDescription(),
 				currentValue: config.authToken.length > 0 ? "enabled" : "disabled",
 				values: ["disabled", "enabled"],
 			},
@@ -672,32 +703,50 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 			// --- Model exposure ---
 			{
 				id: "publicModelIdMode",
-				label: "Public ID mode",
-				description: "How public model IDs are generated from canonical provider/model-id",
+				label: "Model ID format",
+				description: idModeDescription(),
 				currentValue: config.publicModelIdMode,
 				values: ["collision-prefixed", "universal", "always-prefixed"],
 			},
 			{
 				id: "modelExposureMode",
 				label: "Exposure mode",
-				description:
-					"scoped = pi's available models, all = all registered, custom = manual selection",
+				description: exposureModeDescription(),
 				currentValue: config.modelExposureMode,
 				values: ["scoped", "all", "custom"],
 			},
 			{
 				id: "customModels",
 				label: "Select models",
-				description:
-					config.modelExposureMode === "custom"
-						? "Press Enter to open model selector"
-						: "Switch exposure mode to 'custom' to select models",
+				description: customModelsDescription(),
 				currentValue: customModelsDisplay(),
 				submenu: config.modelExposureMode === "custom" ? buildModelSelectorSubmenu : undefined,
 			},
 		];
 	}
 
+	/**
+	 * Update descriptions on items that change dynamically based on the current value.
+	 */
+	function refreshDescriptions(items: SettingItem[]): void {
+		for (const item of items) {
+			switch (item.id) {
+				case "publicModelIdMode":
+					item.description = idModeDescription();
+					break;
+				case "modelExposureMode":
+					item.description = exposureModeDescription();
+					break;
+				case "customModels":
+					item.description = customModelsDescription();
+					break;
+				case "authToken":
+					item.description = authDescription();
+					break;
+			}
+		}
+	}
+
 	const VALID_ID_MODES = new Set<string>(["collision-prefixed", "universal", "always-prefixed"]);
 
 	function isPublicModelIdMode(v: string): v is PublicModelIdMode {
@@ -821,8 +870,9 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 							ctx.ui.notify(`Auth token: ${lastGeneratedToken}`, "info");
 						}
 
-						// Update display value in-place (no rebuild, preserves selection)
+						// Update display value and descriptions in-place (preserves selection)
 						settingsList.updateValue(id, getDisplayValue(id));
+						refreshDescriptions(items);
 
 						// When exposure mode changes, update the "Select models" item
 						if (id === "modelExposureMode") {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@victor-software-house/pi-openai-proxy",
-	"version": "4.0.5",
+	"version": "4.1.0",
 	"description": "OpenAI-compatible HTTP proxy for pi's multi-provider model registry",
 	"license": "MIT",
 	"author": "Victor Software House",