@victor-software-house/pi-openai-proxy 4.4.1 → 4.5.1

package/dist/config.d.mts

@@ -1,3 +1,3 @@
 
-import { a as configToEnv, c as isPublicModelIdMode, d as saveConfigToFile, i as PublicModelIdMode, l as loadConfigFromFile, n as ModelExposureMode, o as getConfigPath, r as ProxyConfig, s as isModelExposureMode, t as DEFAULT_CONFIG, u as normalizeConfig } from "./schema-BTAG6Urs.mjs";
-export { DEFAULT_CONFIG, ModelExposureMode, ProxyConfig, PublicModelIdMode, configToEnv, getConfigPath, isModelExposureMode, isPublicModelIdMode, loadConfigFromFile, normalizeConfig, saveConfigToFile };
+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-x6mps-hM.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-BTAG6Urs.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,9 +1,9 @@
 #!/usr/bin/env bun
-import { l as isRecord, o as loadConfigFromFile, r as getConfigPath } from "./schema-x6mps-hM.mjs";
+import { l as isRecord, o as loadConfigFromFile, r as getConfigPath } from "./schema-quaXHZsz.mjs";
 import { computeModelExposure, resolveExposedModel } from "./exposure.mjs";
-import { AuthStorage, ModelRegistry } from "@mariozechner/pi-coding-agent";
-import { randomBytes } from "node:crypto";
 import * as z from "zod";
+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";
 import { Hono } from "hono";
@@ -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-BTAG6Urs.d.mts → schema-CrOJW-mE.d.mts}

@@ -1,12 +1,7 @@
 
+import * as z from "zod";
+
 //#region src/config/schema.d.ts
-/**
- * Proxy configuration schema -- single source of truth.
- *
- * Used by both the proxy server and the pi extension.
- * The server reads the JSON config file as defaults, with env vars and CLI args as overrides.
- * The pi extension reads and writes the JSON config file via the /proxy config panel.
- */
 /**
  * How public model IDs are generated from canonical provider/model-id pairs.
  *
@@ -17,10 +12,12 @@
 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 {
@@ -40,15 +37,20 @@ 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. */
   readonly providerPrefixes: Readonly<Record<string, string>>;
+  /** Zed editor sync settings. */
+  readonly zed: ZedSyncConfig;
 }
+declare const ZedSyncConfigSchema: z.ZodObject<{
+  providerName: z.ZodDefault<z.ZodString>;
+  autoSync: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+type ZedSyncConfig = z.infer<typeof ZedSyncConfigSchema>;
 declare const DEFAULT_CONFIG: Readonly<ProxyConfig>;
 declare function isPublicModelIdMode(value: string): value is PublicModelIdMode;
 declare function isModelExposureMode(value: string): value is ModelExposureMode;
@@ -58,4 +60,4 @@ declare function loadConfigFromFile(): ProxyConfig;
 declare function saveConfigToFile(config: ProxyConfig): void;
 declare function configToEnv(config: ProxyConfig): Record<string, string>;
 //#endregion
-export { configToEnv as a, isPublicModelIdMode as c, saveConfigToFile as d, PublicModelIdMode as i, loadConfigFromFile as l, ModelExposureMode as n, getConfigPath as o, ProxyConfig as r, isModelExposureMode as s, DEFAULT_CONFIG as t, normalizeConfig as u };
+export { ZedSyncConfig as a, isModelExposureMode as c, normalizeConfig as d, saveConfigToFile as f, PublicModelIdMode as i, isPublicModelIdMode as l, ModelExposureMode as n, configToEnv as o, ProxyConfig as r, getConfigPath as s, DEFAULT_CONFIG as t, loadConfigFromFile as u };

package/dist/{schema-x6mps-hM.mjs → schema-quaXHZsz.mjs}

@@ -1,6 +1,7 @@
 #!/usr/bin/env bun
 import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
+import * as z from "zod";
 //#region src/utils/guards.ts
 /**
 * Shared type guard utilities.
@@ -21,6 +22,10 @@ function isRecord(value) {
 * The server reads the JSON config file as defaults, with env vars and CLI args as overrides.
 * The pi extension reads and writes the JSON config file via the /proxy config panel.
 */
+const ZedSyncConfigSchema = z.object({
+	providerName: z.string().trim().min(1, { error: "Provider name must not be empty" }).default("Pi Proxy"),
+	autoSync: z.boolean({ error: "autoSync must be a boolean" }).default(false)
+});
 const DEFAULT_CONFIG = {
 	host: "127.0.0.1",
 	port: 4141,
@@ -31,9 +36,12 @@ const DEFAULT_CONFIG = {
 	lifetime: "detached",
 	publicModelIdMode: "collision-prefixed",
 	modelExposureMode: "scoped",
-	scopedProviders: [],
 	customModels: [],
-	providerPrefixes: {}
+	providerPrefixes: {},
+	zed: {
+		providerName: "Pi Proxy",
+		autoSync: false
+	}
 };
 function clampInt(raw, min, max, fallback) {
 	if (typeof raw !== "number" || !Number.isFinite(raw)) return fallback;
@@ -84,11 +92,16 @@ 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"])
+		providerPrefixes: normalizeStringRecord(v["providerPrefixes"]),
+		zed: parseZedSyncConfig(v["zed"])
 	};
 }
+function parseZedSyncConfig(raw) {
+	const result = ZedSyncConfigSchema.safeParse(isRecord(raw) ? raw : {});
+	if (result.success) return result.data;
+	return ZedSyncConfigSchema.parse({});
+}
 function getConfigPath() {
 	return resolve(process.env.PI_CODING_AGENT_DIR ?? resolve(process.env.HOME ?? "~", ".pi", "agent"), "proxy-config.json");
 }

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,
 		};
@@ -274,8 +287,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 +481,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 +499,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 +519,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 +566,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 +585,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);
 		}
@@ -587,27 +603,22 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 
 	// --- Zed sync ---
 
-	function handleZedSync(ctx: ExtensionContext, args: string): void {
-		config = loadConfigFromFile();
-
-		const dryRun = args.includes("--dry-run");
-
-		// Compute exposed models (same as /proxy models)
+	/**
+	 * Run Zed sync and return the result. Shared by the command and auto-sync.
+	 */
+	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) {
-			ctx.ui.notify(`Model exposure error: ${outcome.message}`, "error");
-			return;
+			return { ok: false, message: `Model exposure error: ${outcome.message}` };
 		}
 
 		if (outcome.models.length === 0) {
-			ctx.ui.notify("No models exposed. Nothing to sync.", "warning");
-			return;
+			return { ok: false, message: "No models exposed. Nothing to sync." };
 		}
 
 		const syncOptions: ZedSyncOptions = {
-			providerName: "Pi Proxy",
+			providerName: config.zed.providerName,
 			apiUrl: `http://${config.host}:${String(config.port)}/v1`,
 			dryRun,
 		};
@@ -615,14 +626,30 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 		const result = syncToZed(outcome.models, syncOptions);
 
 		if (!result.ok) {
-			ctx.ui.notify(result.error ?? "Zed sync failed", "error");
-			return;
+			return { ok: false, message: result.error ?? "Zed sync failed" };
 		}
 
-		const msg = dryRun
-			? `Zed sync dry-run: ${result.summary}\n${result.configPath}`
-			: `Zed sync complete: ${result.summary}\n${result.configPath}`;
-		ctx.ui.notify(msg, "info");
+		const prefix = dryRun ? "[dry-run] " : "";
+		return { ok: true, message: `${prefix}${result.summary} (${result.configPath})` };
+	}
+
+	function handleZedSync(ctx: ExtensionContext, args: string): void {
+		config = loadConfigFromFile();
+		const dryRun = args.includes("--dry-run");
+		const result = runZedSync(dryRun);
+		ctx.ui.notify(`Zed sync: ${result.message}`, result.ok ? "info" : "error");
+	}
+
+	/**
+	 * Trigger auto-sync to Zed if enabled. Called after config save.
+	 */
+	function maybeAutoSyncZed(ctx: ExtensionContext): void {
+		if (!config.zed.autoSync) return;
+		const result = runZedSync(false);
+		if (result.ok) {
+			ctx.ui.notify(`Zed auto-sync: ${result.message}`, "info");
+		}
+		// Silent on failure during auto-sync -- don't spam the user
 	}
 
 	async function waitForReady(timeoutMs: number): Promise<RuntimeStatus> {
@@ -697,12 +724,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];
@@ -738,7 +793,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 					}
 				}
 			}
-			sl["selectedIndex"] = target;
+			listSet("selectedIndex", target);
 		}
 
 		return {
@@ -866,7 +921,22 @@ 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 ---
+			{
+				id: "zed.autoSync",
+				label: "Zed auto-sync",
+				description: "Sync models to Zed settings.json when config changes",
+				currentValue: config.zed.autoSync ? "on" : "off",
+				values: ["off", "on"],
+			},
+			{
+				id: "zed.providerName",
+				label: "Zed provider name",
+				description: "Provider label in Zed's openai_compatible section",
+				currentValue: config.zed.providerName,
+				values: ["Pi Proxy"],
 			},
 		];
 	}
@@ -958,6 +1028,14 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 			case "customModels":
 				// Handled by submenu -- no cycling
 				break;
+			case "zed.autoSync":
+				config = { ...config, zed: { ...config.zed, autoSync: value === "on" } };
+				break;
+			case "zed.providerName":
+				if (value.length > 0) {
+					config = { ...config, zed: { ...config.zed, providerName: value } };
+				}
+				break;
 		}
 		saveConfigToFile(config);
 		config = loadConfigFromFile();
@@ -988,6 +1066,10 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 				return config.modelExposureMode;
 			case "customModels":
 				return customModelsDisplay();
+			case "zed.autoSync":
+				return config.zed.autoSync ? "on" : "off";
+			case "zed.providerName":
+				return config.zed.providerName;
 			default:
 				return "";
 		}
@@ -1023,6 +1105,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 							settingsList.updateValue("customModels", customModelsDisplay());
 						}
 
+						maybeAutoSyncZed(ctx);
 						tui.requestRender();
 					},
 					() => done(undefined),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@victor-software-house/pi-openai-proxy",
-	"version": "4.4.1",
+	"version": "4.5.1",
 	"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",