@victor-software-house/pi-openai-proxy 4.5.0 → 4.6.0

package/dist/config.d.mts

@@ -1,3 +1,3 @@
 
-import { a as ZedSyncConfig, c as isModelExposureMode, d as normalizeConfig, f as saveConfigToFile, i as PublicModelIdMode, l as isPublicModelIdMode, n as ModelExposureMode, o as configToEnv, r as ProxyConfig, s as getConfigPath, t as DEFAULT_CONFIG, u as loadConfigFromFile } from "./schema-B2x0rLJN.mjs";
+import { a as ZedSyncConfig, c as isModelExposureMode, d as normalizeConfig, f as saveConfigToFile, i as PublicModelIdMode, l as isPublicModelIdMode, n as ModelExposureMode, o as configToEnv, r as ProxyConfig, s as getConfigPath, t as DEFAULT_CONFIG, u as loadConfigFromFile } from "./schema-CrOJW-mE.mjs";
 export { DEFAULT_CONFIG, ModelExposureMode, ProxyConfig, PublicModelIdMode, ZedSyncConfig, configToEnv, getConfigPath, isModelExposureMode, isPublicModelIdMode, loadConfigFromFile, normalizeConfig, saveConfigToFile };

package/dist/config.mjs

@@ -1,3 +1,3 @@
 #!/usr/bin/env bun
-import { a as isPublicModelIdMode, c as saveConfigToFile, i as isModelExposureMode, n as configToEnv, o as loadConfigFromFile, r as getConfigPath, s as normalizeConfig, t as DEFAULT_CONFIG } from "./schema-IE4WK0Dj.mjs";
+import { a as isPublicModelIdMode, c as saveConfigToFile, i as isModelExposureMode, n as configToEnv, o as loadConfigFromFile, r as getConfigPath, s as normalizeConfig, t as DEFAULT_CONFIG } from "./schema-quaXHZsz.mjs";
 export { DEFAULT_CONFIG, configToEnv, getConfigPath, isModelExposureMode, isPublicModelIdMode, loadConfigFromFile, normalizeConfig, saveConfigToFile };

package/dist/exposure.d.mts

@@ -1,5 +1,5 @@
 
-import { i as PublicModelIdMode, n as ModelExposureMode } from "./schema-B2x0rLJN.mjs";
+import { i as PublicModelIdMode, n as ModelExposureMode } from "./schema-CrOJW-mE.mjs";
 import { Api, Model } from "@mariozechner/pi-ai";
 
 //#region src/openai/model-exposure.d.ts
@@ -16,7 +16,13 @@ interface ExposedModel {
 interface ModelExposureConfig {
   readonly publicModelIdMode: PublicModelIdMode;
   readonly modelExposureMode: ModelExposureMode;
-  readonly scopedProviders: readonly string[];
+  /**
+   * Canonical model IDs from pi's global `enabledModels` setting.
+   * Read from `SettingsManager.getEnabledModels()` at request time.
+   * Undefined or empty means no filter (all available models exposed).
+   * Used only when modelExposureMode is "scoped".
+   */
+  readonly enabledModels: readonly string[] | undefined;
   readonly customModels: readonly string[];
   readonly providerPrefixes: Readonly<Record<string, string>>;
 }
@@ -38,12 +44,11 @@ type ModelExposureOutcome = ModelExposureResult | ModelExposureError;
  * Compute the full model-exposure result from config and available models.
  *
  * @param available - Models with auth configured (pi's getAvailable())
- * @param allRegistered - All registered models regardless of auth (pi's getAll())
  * @param config - Model exposure configuration
  *
  * Call this at startup and whenever config or the model registry changes.
  */
-declare function computeModelExposure(available: readonly Model<Api>[], allRegistered: readonly Model<Api>[], config: ModelExposureConfig): ModelExposureOutcome;
+declare function computeModelExposure(available: readonly Model<Api>[], config: ModelExposureConfig): ModelExposureOutcome;
 /**
  * Resolve a model ID from an incoming request against the exposure result.
  *

package/dist/exposure.mjs

@@ -1,14 +1,16 @@
 #!/usr/bin/env bun
 //#region src/openai/model-exposure.ts
-function filterExposedModels(available, allRegistered, config) {
+function filterExposedModels(available, config) {
 	switch (config.modelExposureMode) {
+		case "all": return [...available];
 		case "scoped": {
-			if (config.scopedProviders.length === 0) return [...available];
-			const allowed = new Set(config.scopedProviders);
-			return available.filter((m) => allowed.has(m.provider));
+			const enabled = config.enabledModels;
+			if (enabled === void 0 || enabled.length === 0) return [...available];
+			const allowed = new Set(enabled);
+			return available.filter((m) => allowed.has(`${m.provider}/${m.id}`));
 		}
-		case "all": return [...allRegistered];
 		case "custom": {
+			if (config.customModels.length === 0) return [...available];
 			const allowed = new Set(config.customModels);
 			return available.filter((m) => allowed.has(`${m.provider}/${m.id}`));
 		}
@@ -127,13 +129,12 @@ function validatePrefixUniqueness(models, prefixes, mode) {
 * Compute the full model-exposure result from config and available models.
 *
 * @param available - Models with auth configured (pi's getAvailable())
-* @param allRegistered - All registered models regardless of auth (pi's getAll())
 * @param config - Model exposure configuration
 *
 * Call this at startup and whenever config or the model registry changes.
 */
-function computeModelExposure(available, allRegistered, config) {
-	const exposed = filterExposedModels(available, allRegistered, config);
+function computeModelExposure(available, config) {
+	const exposed = filterExposedModels(available, config);
 	const prefixError = validatePrefixUniqueness(exposed, config.providerPrefixes, config.publicModelIdMode);
 	if (prefixError !== void 0) return {
 		ok: false,

package/dist/index.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env bun
-import { l as isRecord, o as loadConfigFromFile, r as getConfigPath } from "./schema-IE4WK0Dj.mjs";
+import { l as isRecord, o as loadConfigFromFile, r as getConfigPath } from "./schema-quaXHZsz.mjs";
 import { computeModelExposure, resolveExposedModel } from "./exposure.mjs";
 import * as z from "zod";
-import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
+import { AuthStorage, ModelRegistry, SettingsManager } from "@mariozechner/pi-coding-agent";
 import { randomBytes } from "node:crypto";
 import { Type } from "@sinclair/typebox";
 import { completeSimple, streamSimple } from "@mariozechner/pi-ai";
@@ -38,7 +38,6 @@ function loadConfig(cli = {}) {
 		upstreamTimeoutMs,
 		publicModelIdMode: file.publicModelIdMode,
 		modelExposureMode: file.modelExposureMode,
-		scopedProviders: file.scopedProviders,
 		customModels: file.customModels,
 		providerPrefixes: file.providerPrefixes
 	};
@@ -47,19 +46,25 @@ function loadConfig(cli = {}) {
 //#region src/pi/registry.ts
 let registry;
 let authStorage;
+let settingsManager;
 /**
-* Initialize the registry. Call once at startup.
+* Initialize the registry and settings. Call once at startup.
 * Returns the load error if models.json failed to parse, or undefined on success.
 */
 function initRegistry() {
 	authStorage = AuthStorage.create();
 	registry = new ModelRegistry(authStorage);
+	settingsManager = SettingsManager.create();
 	return registry.getError();
 }
 function getRegistry() {
 	if (registry === void 0) throw new Error("ModelRegistry not initialized. Call initRegistry() first.");
 	return registry;
 }
+function getSettingsManager() {
+	if (settingsManager === void 0) throw new Error("SettingsManager not initialized. Call initRegistry() first.");
+	return settingsManager;
+}
 /**
 * Get all models available (have auth configured).
 */
@@ -67,10 +72,16 @@ function getAvailableModels() {
 	return getRegistry().getAvailable();
 }
 /**
-* Get all registered models (regardless of auth state).
+* Get the `enabledModels` patterns from pi's global settings.
+*
+* These are the canonical model IDs (e.g. "anthropic/claude-sonnet-4-6")
+* persisted by the `/scoped-models` TUI when the user presses Ctrl+S.
+*
+* Returns undefined when no filter is configured (all models enabled).
 */
-function getAllModels() {
-	return getRegistry().getAll();
+function getEnabledModels() {
+	getSettingsManager().reload();
+	return getSettingsManager().getEnabledModels();
 }
 //#endregion
 //#region src/server/errors.ts
@@ -1307,14 +1318,14 @@ function fileConfigReader() {
 	return {
 		publicModelIdMode: file.publicModelIdMode,
 		modelExposureMode: file.modelExposureMode,
-		scopedProviders: file.scopedProviders,
+		enabledModels: getEnabledModels(),
 		customModels: file.customModels,
 		providerPrefixes: file.providerPrefixes
 	};
 }
 function createRoutes(config, configReader = fileConfigReader) {
 	function getExposure() {
-		const outcome = computeModelExposure(getAvailableModels(), getAllModels(), configReader());
+		const outcome = computeModelExposure(getAvailableModels(), configReader());
 		if (!outcome.ok) throw new Error(`Model exposure configuration error: ${outcome.message}`);
 		return outcome;
 	}

package/dist/{schema-B2x0rLJN.d.mts → schema-CrOJW-mE.d.mts}

@@ -12,10 +12,12 @@ import * as z from "zod";
 type PublicModelIdMode = "collision-prefixed" | "universal" | "always-prefixed";
 /**
  * Which models are exposed on the public HTTP API.
+ * All modes only expose auth-configured models (pi's getAvailable()).
  *
- * - "all": every available model
- * - "scoped": all available models from selected providers only
- * - "custom": explicit allowlist of canonical model IDs
+ * - "all": every available model, no filter
+ * - "scoped": delegates to pi's global `enabledModels` setting (from `/scoped-models` Ctrl+S)
+ * - "custom": same per-model filtering as "scoped" but independently managed
+ *   via the proxy's own `customModels` config
  */
 type ModelExposureMode = "all" | "scoped" | "custom";
 interface ProxyConfig {
@@ -35,10 +37,8 @@ interface ProxyConfig {
   readonly lifetime: "detached" | "session";
   /** How public model IDs are generated. Default: "collision-prefixed" */
   readonly publicModelIdMode: PublicModelIdMode;
-  /** Which models are exposed. Default: "all" */
+  /** Which models are exposed. Default: "scoped" */
   readonly modelExposureMode: ModelExposureMode;
-  /** Provider keys to expose when modelExposureMode is "scoped". */
-  readonly scopedProviders: readonly string[];
   /** Canonical model IDs to expose when modelExposureMode is "custom". */
   readonly customModels: readonly string[];
   /** Provider key -> custom public prefix label. Default prefix = provider key. */

package/dist/{schema-IE4WK0Dj.mjs → schema-quaXHZsz.mjs}

@@ -36,7 +36,6 @@ const DEFAULT_CONFIG = {
 	lifetime: "detached",
 	publicModelIdMode: "collision-prefixed",
 	modelExposureMode: "scoped",
-	scopedProviders: [],
 	customModels: [],
 	providerPrefixes: {},
 	zed: {
@@ -93,7 +92,6 @@ function normalizeConfig(raw) {
 		lifetime: v["lifetime"] === "session" ? "session" : "detached",
 		publicModelIdMode: typeof rawPublicIdMode === "string" && isPublicModelIdMode(rawPublicIdMode) ? rawPublicIdMode : DEFAULT_CONFIG.publicModelIdMode,
 		modelExposureMode: typeof rawExposureMode === "string" && isModelExposureMode(rawExposureMode) ? rawExposureMode : DEFAULT_CONFIG.modelExposureMode,
-		scopedProviders: normalizeStringArray(v["scopedProviders"]),
 		customModels: normalizeStringArray(v["customModels"]),
 		providerPrefixes: normalizeStringRecord(v["providerPrefixes"]),
 		zed: parseZedSyncConfig(v["zed"])

package/extensions/proxy.ts

@@ -31,6 +31,7 @@ import {
 	type ExtensionContext,
 	getSettingsListTheme,
 	ModelRegistry,
+	SettingsManager,
 } from "@mariozechner/pi-coding-agent";
 import {
 	type Component,
@@ -68,6 +69,17 @@ interface RuntimeStatus {
 	models: number;
 }
 
+interface ProbeBody {
+	data: unknown[];
+}
+
+function isProbeBody(value: unknown): value is ProbeBody {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	if (!("data" in value)) return false;
+	const v: { data: unknown } = value;
+	return Array.isArray(v.data);
+}
+
 // ---------------------------------------------------------------------------
 // Extension
 // ---------------------------------------------------------------------------
@@ -83,22 +95,23 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 
 	const cachedAuth = AuthStorage.create();
 	const cachedRegistry = new ModelRegistry(cachedAuth);
+	const settingsManager = SettingsManager.create();
 
 	function getAvailableModels(): Model<Api>[] {
 		cachedRegistry.refresh();
 		return cachedRegistry.getAvailable();
 	}
 
-	function getAllRegisteredModels(): Model<Api>[] {
-		cachedRegistry.refresh();
-		return cachedRegistry.getAll();
+	function getEnabledModels(): readonly string[] | undefined {
+		settingsManager.reload();
+		return settingsManager.getEnabledModels();
 	}
 
 	function buildExposureConfig(): ModelExposureConfig {
 		return {
 			publicModelIdMode: config.publicModelIdMode,
 			modelExposureMode: config.modelExposureMode,
-			scopedProviders: config.scopedProviders,
+			enabledModels: getEnabledModels(),
 			customModels: config.customModels,
 			providerPrefixes: config.providerPrefixes,
 		};
@@ -124,6 +137,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 
 	pi.on("session_start", async (_event, ctx) => {
 		config = loadConfigFromFile();
+		maybeAutoSyncZed(ctx);
 		await refreshStatus(ctx);
 	});
 
@@ -274,8 +288,12 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 				headers,
 			});
 			if (res.ok) {
-				const body = (await res.json()) as { data?: unknown[] };
-				return { reachable: true, models: body.data?.length ?? 0 };
+				const body: unknown = await res.json();
+				let modelCount = 0;
+				if (isProbeBody(body)) {
+					modelCount = body.data.length;
+				}
+				return { reachable: true, models: modelCount };
 			}
 		} catch {
 			// not reachable
@@ -464,8 +482,11 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 			`exposure: ${config.modelExposureMode}`,
 		];
 
-		if (config.modelExposureMode === "scoped" && config.scopedProviders.length > 0) {
-			exposureLines.push(`providers: ${config.scopedProviders.join(", ")}`);
+		if (config.modelExposureMode === "scoped") {
+			const enabledModels = getEnabledModels();
+			if (enabledModels !== undefined && enabledModels.length > 0) {
+				exposureLines.push(`enabled: ${String(enabledModels.length)} pi model(s)`);
+			}
 		}
 		if (config.modelExposureMode === "custom" && config.customModels.length > 0) {
 			exposureLines.push(`models: ${String(config.customModels.length)} custom`);
@@ -479,8 +500,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 
 		// Public ID preview (first 5 exposed models)
 		const models = getAvailableModels();
-		const allModels = getAllRegisteredModels();
-		const outcome = computeModelExposure(models, allModels, buildExposureConfig());
+		const outcome = computeModelExposure(models, buildExposureConfig());
 		if (outcome.ok && outcome.models.length > 0) {
 			const preview = outcome.models.slice(0, 5).map((m) => m.publicId);
 			const suffix =
@@ -500,8 +520,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 	function showModels(ctx: ExtensionContext): void {
 		config = loadConfigFromFile();
 		const models = getAvailableModels();
-		const allModels = getAllRegisteredModels();
-		const outcome = computeModelExposure(models, allModels, buildExposureConfig());
+		const outcome = computeModelExposure(models, buildExposureConfig());
 
 		if (!outcome.ok) {
 			ctx.ui.notify(`Model exposure error: ${outcome.message}`, "warning");
@@ -548,8 +567,6 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 		const models = getAvailableModels();
 		const issues: string[] = [];
 
-		const allModels = getAllRegisteredModels();
-
 		// Check available models
 		if (models.length === 0) {
 			issues.push("No models have auth configured. The proxy will expose 0 models.");
@@ -569,7 +586,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 		}
 
 		// Run the full exposure computation to catch ID/prefix errors
-		const outcome = computeModelExposure(models, allModels, buildExposureConfig());
+		const outcome = computeModelExposure(models, buildExposureConfig());
 		if (!outcome.ok) {
 			issues.push(outcome.message);
 		}
@@ -592,8 +609,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 	 */
 	function runZedSync(dryRun: boolean): { ok: boolean; message: string } {
 		const available = getAvailableModels();
-		const allModels = getAllRegisteredModels();
-		const outcome = computeModelExposure(available, allModels, buildExposureConfig());
+		const outcome = computeModelExposure(available, buildExposureConfig());
 		if (!outcome.ok) {
 			return { ok: false, message: `Model exposure error: ${outcome.message}` };
 		}
@@ -709,12 +725,40 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 		// Accesses private fields via bracket notation for provider jumping.
 		// Pinned to pi-tui behavior as of @mariozechner/pi-coding-agent ^0.62.0.
 		// Remove when SettingsList exposes a jumpTo/setSelectedIndex method.
+
+		// Isolated unsafe accessor for SettingsList private fields.
+		// Consolidated here so jumpProvider itself is fully type-safe.
+		function listGet(key: string): unknown {
+			return Reflect.get(list, key);
+		}
+		function listSet(key: string, value: unknown): void {
+			Reflect.set(list, key, value);
+		}
+
+		function getSettingsListItems(): SettingItem[] {
+			const rawSearch = listGet("searchEnabled");
+			const raw =
+				typeof rawSearch === "boolean" && rawSearch ? listGet("filteredItems") : listGet("items");
+			if (!Array.isArray(raw)) return [];
+			const result: SettingItem[] = [];
+			for (const item of raw) {
+				if (isSettingItem(item)) result.push(item);
+			}
+			return result;
+		}
+
+		function isSettingItem(value: unknown): value is SettingItem {
+			if (value === null || typeof value !== "object") return false;
+			if (!("id" in value)) return false;
+			const v: { id: unknown } = value;
+			return typeof v.id === "string";
+		}
+
 		function jumpProvider(direction: "prev" | "next"): void {
-			const sl = list as unknown as Record<string, unknown>;
-			const idx = sl["selectedIndex"] as number;
-			const display = (
-				(sl["searchEnabled"] as boolean) ? sl["filteredItems"] : sl["items"]
-			) as SettingItem[];
+			const rawIdx = listGet("selectedIndex");
+			if (typeof rawIdx !== "number") return;
+			const idx = rawIdx;
+			const display = getSettingsListItems();
 			if (display.length === 0) return;
 
 			const current = display[idx];
@@ -750,7 +794,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 					}
 				}
 			}
-			sl["selectedIndex"] = target;
+			listSet("selectedIndex", target);
 		}
 
 		return {
@@ -878,7 +922,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 				label: "Select models",
 				description: customModelsDescription(),
 				currentValue: customModelsDisplay(),
-				submenu: config.modelExposureMode === "custom" ? buildModelSelectorSubmenu : undefined,
+				...(config.modelExposureMode === "custom" ? { submenu: buildModelSelectorSubmenu } : {}),
 			},
 			// --- Zed sync ---
 			{

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@victor-software-house/pi-openai-proxy",
-	"version": "4.5.0",
+	"version": "4.6.0",
 	"description": "OpenAI-compatible HTTP proxy for pi's multi-provider model registry",
 	"license": "MIT",
 	"author": "Victor Software House",
@@ -62,7 +62,7 @@
 		"typecheck": "tsc --noEmit",
 		"lint": "bun run lint:biome && bun run lint:oxlint",
 		"lint:biome": "biome check .",
-		"lint:oxlint": "oxlint --import-plugin --type-aware --tsconfig=./tsconfig.json src/",
+		"lint:oxlint": "oxlint --import-plugin --type-aware --tsconfig=./tsconfig.json .",
 		"lint:fix": "biome check --write .",
 		"format": "biome format --write .",
 		"test": "bun test",