@victor-software-house/pi-openai-proxy 4.9.3 → 4.9.4

package/dist/index.mjs

@@ -4,7 +4,6 @@ import { computeModelExposure, resolveExposedModel } from "./exposure.mjs";
 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";
 import { stream } from "hono/streaming";
@@ -53,8 +52,8 @@ let settingsManager;
 */
 function initRegistry() {
 	authStorage = AuthStorage.create();
-	registry = new ModelRegistry(authStorage);
-	settingsManager = SettingsManager.create();
+	registry = ModelRegistry.create(authStorage);
+	settingsManager = SettingsManager.create(process.cwd());
 	return registry.getError();
 }
 function getRegistry() {
@@ -89,9 +88,10 @@ async function getRequestAuth(model) {
 *
 * Returns undefined when no filter is configured (all models enabled).
 */
-function getEnabledModels() {
-	getSettingsManager().reload();
-	return getSettingsManager().getEnabledModels();
+async function getEnabledModels() {
+	const manager = getSettingsManager();
+	await manager.reload();
+	return manager.getEnabledModels();
 }
 //#endregion
 //#region src/server/errors.ts
@@ -761,6 +761,328 @@ async function* streamToSSE(events, requestId, model, includeUsage) {
 	yield encodeDone();
 }
 //#endregion
+//#region node_modules/typebox/build/system/memory/metrics.mjs
+/** TypeBox instantiation metrics */
+const Metrics = {
+	assign: 0,
+	create: 0,
+	clone: 0,
+	discard: 0,
+	update: 0
+};
+//#endregion
+//#region node_modules/typebox/build/guard/guard.mjs
+/** Returns true if this value is an array */
+function IsArray(value) {
+	return Array.isArray(value);
+}
+/** Returns true if this value is bigint */
+function IsBigInt(value) {
+	return IsEqual(typeof value, "bigint");
+}
+/** Returns true if this value is a boolean */
+function IsBoolean(value) {
+	return IsEqual(typeof value, "boolean");
+}
+/** Returns true if this value is null */
+function IsNull(value) {
+	return IsEqual(value, null);
+}
+/** Returns true if this value is number */
+function IsNumber(value) {
+	return Number.isFinite(value);
+}
+/** Returns true if this value is an object */
+function IsObject(value) {
+	return IsEqual(typeof value, "object") && !IsNull(value);
+}
+/** Returns true if this value is string */
+function IsString(value) {
+	return IsEqual(typeof value, "string");
+}
+function IsEqual(left, right) {
+	return left === right;
+}
+/** Returns true if the PropertyKey is Unsafe (ref: prototype-pollution). */
+function IsUnsafePropertyKey(key) {
+	return IsEqual(key, "__proto__") || IsEqual(key, "constructor") || IsEqual(key, "prototype");
+}
+/** Returns true if this value has this property key */
+function HasPropertyKey(value, key) {
+	return IsUnsafePropertyKey(key) ? Object.prototype.hasOwnProperty.call(value, key) : key in value;
+}
+/** Returns property keys for this object via `Object.getOwnPropertyKeys({ ... })` */
+function Keys(value) {
+	return Object.getOwnPropertyNames(value);
+}
+//#endregion
+//#region node_modules/typebox/build/system/memory/clone.mjs
+function IsGuard(value) {
+	return IsObject(value) && HasPropertyKey(value, "~guard");
+}
+function FromGuard(value) {
+	return value;
+}
+function FromArray(value) {
+	return value.map((value) => FromValue(value));
+}
+function FromObject(value) {
+	const result = {};
+	const descriptors = Object.getOwnPropertyDescriptors(value);
+	for (const key of Object.keys(descriptors)) {
+		const descriptor = descriptors[key];
+		if (HasPropertyKey(descriptor, "value")) Object.defineProperty(result, key, {
+			...descriptor,
+			value: FromValue(descriptor.value)
+		});
+	}
+	return result;
+}
+function FromRegExp(value) {
+	return new RegExp(value.source, value.flags);
+}
+function FromUnknown(value) {
+	return value;
+}
+function FromValue(value) {
+	return value instanceof RegExp ? FromRegExp(value) : IsGuard(value) ? FromGuard(value) : IsArray(value) ? FromArray(value) : IsObject(value) ? FromObject(value) : FromUnknown(value);
+}
+/**
+* Clones a value using the TypeBox type cloning strategy. This function preserves non-enumerable
+* properties from the source value. This is to ensure cloned types retain discriminable
+* hidden properties.
+*/
+function Clone(value) {
+	Metrics.clone += 1;
+	return FromValue(value);
+}
+//#endregion
+//#region node_modules/typebox/build/system/settings/settings.mjs
+const settings = {
+	immutableTypes: false,
+	maxErrors: 8,
+	useAcceleration: true,
+	exactOptionalPropertyTypes: false,
+	enumerableKind: false,
+	correctiveParse: false
+};
+/** Gets current system settings */
+function Get() {
+	return settings;
+}
+//#endregion
+//#region node_modules/typebox/build/system/memory/create.mjs
+function MergeHidden(left, right) {
+	for (const key of Object.keys(right)) Object.defineProperty(left, key, {
+		configurable: true,
+		writable: true,
+		enumerable: false,
+		value: right[key]
+	});
+	return left;
+}
+function Merge(left, right) {
+	return {
+		...left,
+		...right
+	};
+}
+/**
+* Creates an object with hidden, enumerable, and optional property sets. This function
+* ensures types are instantiated according to configuration rules for enumerable and
+* non-enumerable properties.
+*/
+function Create(hidden, enumerable, options = {}) {
+	Metrics.create += 1;
+	const settings = Get();
+	const withOptions = Merge(enumerable, options);
+	const withHidden = settings.enumerableKind ? Merge(withOptions, hidden) : MergeHidden(withOptions, hidden);
+	return settings.immutableTypes ? Object.freeze(withHidden) : withHidden;
+}
+//#endregion
+//#region node_modules/typebox/build/system/memory/update.mjs
+/**
+* Updates a value with new properties while preserving property enumerability. Use this function to modify
+* existing types without altering their configuration.
+*/
+function Update(current, hidden, enumerable) {
+	Metrics.update += 1;
+	const settings = Get();
+	const result = Clone(current);
+	for (const key of Object.keys(hidden)) Object.defineProperty(result, key, {
+		configurable: true,
+		writable: true,
+		enumerable: settings.enumerableKind,
+		value: hidden[key]
+	});
+	for (const key of Object.keys(enumerable)) Object.defineProperty(result, key, {
+		configurable: true,
+		enumerable: true,
+		writable: true,
+		value: enumerable[key]
+	});
+	return result;
+}
+//#endregion
+//#region node_modules/typebox/build/type/types/schema.mjs
+function IsSchema(value) {
+	return IsObject(value);
+}
+//#endregion
+//#region node_modules/typebox/build/type/types/_optional.mjs
+/** Adds Optional to the given type. */
+function OptionalAdd(type) {
+	return Update(type, { "~optional": true }, {});
+}
+/** Applies an Optional modifier to the given type. */
+function Optional(type) {
+	return OptionalAdd(type);
+}
+/** Returns true if the given value is TOptional */
+function IsOptional(value) {
+	return IsSchema(value) && HasPropertyKey(value, "~optional");
+}
+//#endregion
+//#region node_modules/typebox/build/type/types/array.mjs
+/** Creates an Array type. */
+function _Array_(items, options) {
+	return Create({ "~kind": "Array" }, {
+		type: "array",
+		items
+	}, options);
+}
+//#endregion
+//#region node_modules/typebox/build/type/types/properties.mjs
+/** Creates a RequiredArray derived from the given TProperties value. */
+function RequiredArray(properties) {
+	return Keys(properties).filter((key) => !IsOptional(properties[key]));
+}
+//#endregion
+//#region node_modules/typebox/build/type/types/object.mjs
+/** Creates an Object type. */
+function _Object_(properties, options = {}) {
+	const requiredKeys = RequiredArray(properties);
+	const required = requiredKeys.length > 0 ? { required: requiredKeys } : {};
+	return Create({ "~kind": "Object" }, {
+		type: "object",
+		...required,
+		properties
+	}, options);
+}
+//#endregion
+//#region node_modules/typebox/build/type/types/union.mjs
+/** Creates a Union type. */
+function Union(anyOf, options = {}) {
+	return Create({ "~kind": "Union" }, { anyOf }, options);
+}
+//#endregion
+//#region node_modules/typebox/build/type/types/unknown.mjs
+/** Creates an Unknown type. */
+function Unknown(options) {
+	return Create({ ["~kind"]: "Unknown" }, {}, options);
+}
+//#endregion
+//#region node_modules/typebox/build/system/hashing/hash.mjs
+var ByteMarker;
+(function(ByteMarker) {
+	ByteMarker[ByteMarker["Array"] = 0] = "Array";
+	ByteMarker[ByteMarker["BigInt"] = 1] = "BigInt";
+	ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
+	ByteMarker[ByteMarker["Date"] = 3] = "Date";
+	ByteMarker[ByteMarker["Constructor"] = 4] = "Constructor";
+	ByteMarker[ByteMarker["Function"] = 5] = "Function";
+	ByteMarker[ByteMarker["Null"] = 6] = "Null";
+	ByteMarker[ByteMarker["Number"] = 7] = "Number";
+	ByteMarker[ByteMarker["Object"] = 8] = "Object";
+	ByteMarker[ByteMarker["RegExp"] = 9] = "RegExp";
+	ByteMarker[ByteMarker["String"] = 10] = "String";
+	ByteMarker[ByteMarker["Symbol"] = 11] = "Symbol";
+	ByteMarker[ByteMarker["TypeArray"] = 12] = "TypeArray";
+	ByteMarker[ByteMarker["Undefined"] = 13] = "Undefined";
+})(ByteMarker || (ByteMarker = {}));
+const [Prime, Size] = [BigInt("1099511628211"), BigInt("18446744073709551616")];
+Array.from({ length: 256 }).map((_, i) => BigInt(i));
+const F64 = new Float64Array(1);
+new DataView(F64.buffer);
+new Uint8Array(F64.buffer);
+new TextEncoder();
+//#endregion
+//#region node_modules/typebox/build/type/types/boolean.mjs
+/** Creates a Boolean type. */
+function Boolean(options) {
+	return Create({ "~kind": "Boolean" }, { type: "boolean" }, options);
+}
+//#endregion
+//#region node_modules/typebox/build/type/types/integer.mjs
+const IntegerPattern = "-?(?:0|[1-9][0-9]*)";
+/** Creates a Integer type. */
+function Integer(options) {
+	return Create({ "~kind": "Integer" }, { type: "integer" }, options);
+}
+//#endregion
+//#region node_modules/typebox/build/type/types/literal.mjs
+var InvalidLiteralValue = class extends Error {
+	constructor(value) {
+		super(`Invalid Literal value`);
+		Object.defineProperty(this, "cause", {
+			value: { value },
+			writable: false,
+			configurable: false,
+			enumerable: false
+		});
+	}
+};
+function LiteralTypeName(value) {
+	return IsBigInt(value) ? "bigint" : IsBoolean(value) ? "boolean" : IsNumber(value) ? "number" : IsString(value) ? "string" : (() => {
+		throw new InvalidLiteralValue(value);
+	})();
+}
+/** Creates a Literal type. */
+function Literal(value, options) {
+	return Create({ "~kind": "Literal" }, {
+		type: LiteralTypeName(value),
+		const: value
+	}, options);
+}
+//#endregion
+//#region node_modules/typebox/build/type/types/null.mjs
+/** Creates a Null type. */
+function Null(options) {
+	return Create({ "~kind": "Null" }, { type: "null" }, options);
+}
+//#endregion
+//#region node_modules/typebox/build/type/types/number.mjs
+const NumberPattern = "-?(?:0|[1-9][0-9]*)(?:.[0-9]+)?";
+/** Creates a Number type. */
+function Number$1(options) {
+	return Create({ "~kind": "Number" }, { type: "number" }, options);
+}
+//#endregion
+//#region node_modules/typebox/build/type/types/string.mjs
+/** Creates a String type. */
+function String$1(options) {
+	return Create({ "~kind": "String" }, { type: "string" }, options);
+}
+//#endregion
+//#region node_modules/typebox/build/type/types/record.mjs
+const IntegerKey = `^${IntegerPattern}$`;
+`${NumberPattern}`;
+//#endregion
+//#region node_modules/typebox/build/type/script/token/internal/char.mjs
+function Range(start, end) {
+	return Array.from({ length: end - start + 1 }, (_, i) => String.fromCharCode(start + i));
+}
+const Alpha = [...Range(97, 122), ...Range(65, 90)];
+const Digit = ["0", ...Range(49, 57)];
+[...Digit];
+[...[
+	...Alpha,
+	"_",
+	"$"
+], ...Digit];
+[...Digit];
+new RegExp(IntegerKey);
+//#endregion
 //#region src/openai/json-schema-to-typebox.ts
 /**
 * JSON Schema -> TypeBox conversion for OpenAI function tool parameters.
@@ -829,7 +1151,7 @@ function jsonSchemaToTypebox(schema, path = "") {
 	if (typeof rawType !== "string") {
 		if (Object.keys(schema).length === 0 || Object.keys(schema).length === 1 && description !== void 0) return {
 			ok: true,
-			schema: Type.Unknown(opts)
+			schema: Unknown(opts)
 		};
 		return {
 			ok: false,
@@ -841,23 +1163,23 @@ function jsonSchemaToTypebox(schema, path = "") {
 		case "object": return convertObject(schema, path, opts);
 		case "string": return {
 			ok: true,
-			schema: Type.String(opts)
+			schema: String$1(opts)
 		};
 		case "number": return {
 			ok: true,
-			schema: Type.Number(opts)
+			schema: Number$1(opts)
 		};
 		case "integer": return {
 			ok: true,
-			schema: Type.Integer(opts)
+			schema: Integer(opts)
 		};
 		case "boolean": return {
 			ok: true,
-			schema: Type.Boolean(opts)
+			schema: Boolean(opts)
 		};
 		case "null": return {
 			ok: true,
-			schema: Type.Null(opts)
+			schema: Null(opts)
 		};
 		case "array": return convertArray(schema, path, opts);
 		default: return {
@@ -894,7 +1216,7 @@ function convertAnyOf(branches, path, opts) {
 	}
 	return {
 		ok: true,
-		schema: Type.Union(converted, opts)
+		schema: Union(converted, opts)
 	};
 }
 function convertEnum(values, path, opts) {
@@ -912,10 +1234,9 @@ function convertEnum(values, path, opts) {
 		message: `Empty enum at ${path || "root"}`,
 		path
 	};
-	const literals = stringValues.map((v) => Type.Literal(v));
 	return {
 		ok: true,
-		schema: Type.Union(literals, opts)
+		schema: Union(stringValues.map((v) => Literal(v)), opts)
 	};
 }
 function convertNullableType(typeArray, schema, path, opts) {
@@ -938,7 +1259,7 @@ function convertNullableType(typeArray, schema, path, opts) {
 	if (!innerResult.ok) return innerResult;
 	return {
 		ok: true,
-		schema: Type.Union([innerResult.schema, Type.Null()], opts)
+		schema: Union([innerResult.schema, Null()], opts)
 	};
 }
 function convertObject(schema, path, opts) {
@@ -952,7 +1273,7 @@ function convertObject(schema, path, opts) {
 	};
 	if (rawProperties === void 0) return {
 		ok: true,
-		schema: Type.Object({}, opts)
+		schema: _Object_({}, opts)
 	};
 	if (!isRecord(rawProperties)) return {
 		ok: false,
@@ -968,24 +1289,24 @@ function convertObject(schema, path, opts) {
 		const result = jsonSchemaToTypebox(propSchema, path.length > 0 ? `${path}.${key}` : key);
 		if (!result.ok) return result;
 		if (requiredSet.has(key)) typeboxProperties[key] = result.schema;
-		else typeboxProperties[key] = Type.Optional(result.schema);
+		else typeboxProperties[key] = Optional(result.schema);
 	}
 	return {
 		ok: true,
-		schema: Type.Object(typeboxProperties, opts)
+		schema: _Object_(typeboxProperties, opts)
 	};
 }
 function convertArray(schema, path, opts) {
 	const items = schema["items"];
 	if (items === void 0) return {
 		ok: true,
-		schema: Type.Array(Type.Unknown(), opts)
+		schema: _Array_(Unknown(), opts)
 	};
 	const itemResult = jsonSchemaToTypebox(items, path.length > 0 ? `${path}.items` : "items");
 	if (!itemResult.ok) return itemResult;
 	return {
 		ok: true,
-		schema: Type.Array(itemResult.schema, opts)
+		schema: _Array_(itemResult.schema, opts)
 	};
 }
 //#endregion
@@ -1008,7 +1329,7 @@ function convertTools(openaiTools) {
 				param: result.path
 			};
 			parameters = result.schema;
-		} else parameters = Type.Object({});
+		} else parameters = _Object_({});
 		piTools.push({
 			name: fn.name,
 			description: fn.description ?? "",
@@ -1631,19 +1952,19 @@ async function piStream(model, context, request, options) {
 }
 //#endregion
 //#region src/server/routes.ts
-function fileConfigReader() {
+async function fileConfigReader() {
 	const file = loadConfigFromFile();
 	return {
 		publicModelIdMode: file.publicModelIdMode,
 		modelExposureMode: file.modelExposureMode,
-		enabledModels: getEnabledModels(),
+		enabledModels: await getEnabledModels(),
 		customModels: file.customModels,
 		providerPrefixes: file.providerPrefixes
 	};
 }
 function createRoutes(config, configReader = fileConfigReader) {
-	function getExposure() {
-		const outcome = computeModelExposure(getAvailableModels(), configReader());
+	async function getExposure() {
+		const outcome = computeModelExposure(getAvailableModels(), await configReader());
 		if (!outcome.ok) throw new Error(`Model exposure configuration error: ${outcome.message}`);
 		return outcome;
 	}
@@ -1657,17 +1978,17 @@ function createRoutes(config, configReader = fileConfigReader) {
 		return mapped;
 	}
 	const routes = new Hono();
-	routes.get("/v1/models", (c) => {
-		const exposure = getExposure();
+	routes.get("/v1/models", async (c) => {
+		const exposure = await getExposure();
 		return c.json(buildModelList(exposure.models));
 	});
-	routes.get("/v1/models/*", (c) => {
+	routes.get("/v1/models/*", async (c) => {
 		const rawPath = c.req.path;
 		if (!rawPath.startsWith("/v1/models/")) return c.json(modelNotFound(""), 404);
 		const modelIdEncoded = rawPath.slice(11);
 		if (modelIdEncoded.length === 0) return c.json(modelNotFound(""), 404);
 		const modelId = decodeURIComponent(modelIdEncoded);
-		const resolved = resolveExposedModel(getExposure(), modelId);
+		const resolved = resolveExposedModel(await getExposure(), modelId);
 		if (resolved === void 0) return c.json(modelNotFound(modelId), 404);
 		return c.json(toOpenAIModel(resolved));
 	});
@@ -1687,7 +2008,7 @@ function createRoutes(config, configReader = fileConfigReader) {
 			return c.json(invalidRequest(validation.message, validation.param ?? void 0), 400);
 		}
 		const request = validation.data;
-		const resolved = resolveExposedModel(getExposure(), request.model);
+		const resolved = resolveExposedModel(await getExposure(), request.model);
 		if (resolved === void 0) return c.json(modelNotFound(request.model), 404);
 		const model = resolved.model;
 		const canonicalModelId = resolved.canonicalId;

package/extensions/proxy.ts

@@ -94,24 +94,24 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 	// --- Model registry access (cached, refreshed per call) ---
 
 	const cachedAuth = AuthStorage.create();
-	const cachedRegistry = new ModelRegistry(cachedAuth);
-	const settingsManager = SettingsManager.create();
+	const cachedRegistry = ModelRegistry.create(cachedAuth);
+	const settingsManager = SettingsManager.create(process.cwd());
 
 	function getAvailableModels(): Model<Api>[] {
 		cachedRegistry.refresh();
 		return cachedRegistry.getAvailable();
 	}
 
-	function getEnabledModels(): readonly string[] | undefined {
-		settingsManager.reload();
+	async function getEnabledModels(): Promise<readonly string[] | undefined> {
+		await settingsManager.reload();
 		return settingsManager.getEnabledModels();
 	}
 
-	function buildExposureConfig(): ModelExposureConfig {
+	async function buildExposureConfig(): Promise<ModelExposureConfig> {
 		return {
 			publicModelIdMode: config.publicModelIdMode,
 			modelExposureMode: config.modelExposureMode,
-			enabledModels: getEnabledModels(),
+			enabledModels: await getEnabledModels(),
 			customModels: config.customModels,
 			providerPrefixes: config.providerPrefixes,
 		};
@@ -137,7 +137,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 
 	pi.on("session_start", async (_event, ctx) => {
 		config = loadConfigFromFile();
-		maybeAutoSyncZed(ctx);
+		await maybeAutoSyncZed(ctx);
 		await refreshStatus(ctx);
 	});
 
@@ -193,16 +193,16 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 					await showStatus(ctx);
 					return;
 				case "verify":
-					verifyExposure(ctx);
+					await verifyExposure(ctx);
 					return;
 				case "models":
-					showModels(ctx);
+					await showModels(ctx);
 					return;
 				case "zed-sync":
-					handleZedSync(ctx, args);
+					await handleZedSync(ctx, args);
 					return;
 				case "show":
-					showConfig(ctx);
+					await showConfig(ctx);
 					return;
 				case "path":
 					ctx.ui.notify(getConfigPath(), "info");
@@ -460,7 +460,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 		await refreshStatus(ctx);
 	}
 
-	function showConfig(ctx: ExtensionContext): void {
+	async function showConfig(ctx: ExtensionContext): Promise<void> {
 		config = loadConfigFromFile();
 		const authDisplay =
 			config.authToken.length > 0 ? `enabled (token: ${config.authToken})` : "disabled";
@@ -483,7 +483,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 		];
 
 		if (config.modelExposureMode === "scoped") {
-			const enabledModels = getEnabledModels();
+			const enabledModels = await getEnabledModels();
 			if (enabledModels !== undefined && enabledModels.length > 0) {
 				exposureLines.push(`enabled: ${String(enabledModels.length)} pi model(s)`);
 			}
@@ -500,7 +500,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 
 		// Public ID preview (first 5 exposed models)
 		const models = getAvailableModels();
-		const outcome = computeModelExposure(models, buildExposureConfig());
+		const outcome = computeModelExposure(models, await buildExposureConfig());
 		if (outcome.ok && outcome.models.length > 0) {
 			const preview = outcome.models.slice(0, 5).map((m) => m.publicId);
 			const suffix =
@@ -517,10 +517,10 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 
 	// --- /proxy models ---
 
-	function showModels(ctx: ExtensionContext): void {
+	async function showModels(ctx: ExtensionContext): Promise<void> {
 		config = loadConfigFromFile();
 		const models = getAvailableModels();
-		const outcome = computeModelExposure(models, buildExposureConfig());
+		const outcome = computeModelExposure(models, await buildExposureConfig());
 
 		if (!outcome.ok) {
 			ctx.ui.notify(`Model exposure error: ${outcome.message}`, "warning");
@@ -562,7 +562,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 
 	// --- /proxy verify ---
 
-	function verifyExposure(ctx: ExtensionContext): void {
+	async function verifyExposure(ctx: ExtensionContext): Promise<void> {
 		config = loadConfigFromFile();
 		const models = getAvailableModels();
 		const issues: string[] = [];
@@ -586,7 +586,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 		}
 
 		// Run the full exposure computation to catch ID/prefix errors
-		const outcome = computeModelExposure(models, buildExposureConfig());
+		const outcome = computeModelExposure(models, await buildExposureConfig());
 		if (!outcome.ok) {
 			issues.push(outcome.message);
 		}
@@ -607,9 +607,9 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 	/**
 	 * Run Zed sync and return the result. Shared by the command and auto-sync.
 	 */
-	function runZedSync(dryRun: boolean): { ok: boolean; message: string } {
+	async function runZedSync(dryRun: boolean): Promise<{ ok: boolean; message: string }> {
 		const available = getAvailableModels();
-		const outcome = computeModelExposure(available, buildExposureConfig());
+		const outcome = computeModelExposure(available, await buildExposureConfig());
 		if (!outcome.ok) {
 			return { ok: false, message: `Model exposure error: ${outcome.message}` };
 		}
@@ -634,19 +634,19 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 		return { ok: true, message: `${prefix}${result.summary} (${result.configPath})` };
 	}
 
-	function handleZedSync(ctx: ExtensionContext, args: string): void {
+	async function handleZedSync(ctx: ExtensionContext, args: string): Promise<void> {
 		config = loadConfigFromFile();
 		const dryRun = args.includes("--dry-run");
-		const result = runZedSync(dryRun);
+		const result = await 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 {
+	async function maybeAutoSyncZed(ctx: ExtensionContext): Promise<void> {
 		if (!config.zed.autoSync) return;
-		const result = runZedSync(false);
+		const result = await runZedSync(false);
 		if (result.ok) {
 			ctx.ui.notify(`Zed auto-sync: ${result.message}`, "info");
 		}
@@ -1106,7 +1106,7 @@ export default function proxyExtension(pi: ExtensionAPI): void {
 							settingsList.updateValue("customModels", customModelsDisplay());
 						}
 
-						maybeAutoSyncZed(ctx);
+						void maybeAutoSyncZed(ctx);
 						tui.requestRender();
 					},
 					() => done(undefined),

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@victor-software-house/pi-openai-proxy",
-	"version": "4.9.3",
+	"version": "4.9.4",
 	"description": "OpenAI-compatible HTTP proxy for pi's multi-provider model registry",
 	"license": "MIT",
 	"author": "Victor Software House",
@@ -72,9 +72,8 @@
 		"prepublishOnly": "bun test && bun run build"
 	},
 	"dependencies": {
-		"@mariozechner/pi-ai": "^0.63.1",
-		"@mariozechner/pi-coding-agent": "^0.63.1",
-		"@sinclair/typebox": "^0.34.0",
+		"@mariozechner/pi-ai": "^0.73.0",
+		"@mariozechner/pi-coding-agent": "^0.73.0",
 		"citty": "^0.1.6",
 		"hono": "^4.12.8",
 		"jsonc-parser": "^3.3.1",
@@ -98,6 +97,7 @@
 		"oxlint-tsgolint": "^0.17.1",
 		"semantic-release": "^25.0.3",
 		"tsdown": "^0.21.4",
+		"typebox": "^1.1.38",
 		"typescript": "^5.9.3"
 	}
 }