@xopcai/xopc 0.0.162 → 0.0.163

package/dist/src/gateway/hono/routes/models.js

@@ -1,25 +1,26 @@
-import { init_schema, parseModelRef } from "../../../config/schema.js";
 import { resolveModelsJsonPath } from "../../../config/paths.js";
 import { init_resolve_config_value, testApiKeyResolution } from "../../../config/resolve-config-value.js";
 import { init_models_json, loadModelsJson, saveModelsJson, validateModelsConfig } from "../../../config/models-json.js";
+import { getModelCatalogStore, init_model_catalog_store } from "../../../providers/model-catalog-store.js";
 import { getModelRegistry } from "../../../providers/model-registry.js";
 import { CredentialResolver, init_credentials } from "../../../auth/credentials.js";
 import "../../../providers/constants.js";
 import { getProviderRegistry, init_plugin_registry } from "../../../providers/plugin-registry.js";
-import { PROVIDER_META, getAllModels, getAllProviders, getAvailableModels, getProviderAuthState, init_providers, isProviderConfigured, resolveModel } from "../../../providers/index.js";
-import { getImageGenerationProvider } from "../../../agent/image/generation/provider-registry.js";
-import { listImageGenerationProvidersSummary } from "../../../agent/image/generation/runtime.js";
+import { PROVIDER_META, getAllModels, getAllProviders, getAvailableModels, getProviderAuthState, init_providers, isProviderConfigured } from "../../../providers/index.js";
+import { SessionConfigStore } from "../../../session/config-store.js";
 import { getDomesticProviderPreset, getDomesticProviderPresetIds } from "../../../providers/domestic-presets.js";
 import { getOnboardingFeaturedProviders, getProviderHint, getRecommendedModelsForProvider, isRecommendedModel, sortModelsForPicker, sortProvidersForPicker } from "../../../providers/presentation.js";
-import { resolveCurrentImageModelCapabilities, resolveImageGenerationCapabilities, resolveImageUnderstandingCapabilities } from "../../image-capabilities.js";
-import { respondStartupUnavailable } from "../lib/startup-unavailable.js";
+import { getAgentImageGenerationConfig, getImageGenerationCatalog, prepareImageGenerationSetup, verifyImageGenerationCredential } from "../../image-generation-setup.js";
 import { discoverProviderModels, isProviderApiDiscoverable } from "../../../providers/model-discovery.js";
+import { XopcCloudHttpError } from "../../../providers/xopc-cloud-connection.js";
+import { respondStartupUnavailable } from "../lib/startup-unavailable.js";
+import { auditModelReferences } from "../../../providers/model-reference-auditor.js";
 //#region src/gateway/hono/routes/models.ts
 init_models_json();
-init_schema();
 init_resolve_config_value();
 init_providers();
 init_credentials();
+init_model_catalog_store();
 init_plugin_registry();
 function readModelsJsonProviderApiKey(providerId) {
 	const { config } = loadModelsJson(resolveModelsJsonPath());
@@ -31,14 +32,6 @@ function readStringRecord(value) {
 	const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
 	return entries.length > 0 ? Object.fromEntries(entries) : void 0;
 }
-/** Plaintext key only when persisted under `cfg.providers.<id>.apiKey` (not env / credential store). */
-function readProviderApiKeyFromConfigFileOnly(cfg, providerId) {
-	const id = providerId.trim().toLowerCase();
-	const bucket = cfg.providers?.[id];
-	if (!bucket || typeof bucket !== "object" || Array.isArray(bucket)) return void 0;
-	const k = bucket.apiKey;
-	return typeof k === "string" && k.trim() ? k.trim() : void 0;
-}
 /** Extension id from manifest `providers[]` (e.g. provider `demo` → extension `demo-provider`). */
 function resolveExtensionIdForProvider(service, providerId) {
 	const loader = service.getExtensionLoader();
@@ -70,7 +63,85 @@ function mapPluginModel(providerId, model, available) {
 	};
 }
 function registerModelsRoutes(authenticated, deps) {
-	const { service, strictRateLimitMiddleware } = deps;
+	const { service, strictRateLimitMiddleware, xopcCloudPollRateLimitMiddleware } = deps;
+	const catalogSync = service.getModelCatalogSync();
+	const xopcCloud = catalogSync.getXopcCloudConnection();
+	authenticated.post("/api/models/xopc-cloud/connect", strictRateLimitMiddleware, async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const clientType = body.clientType === "electron" || body.clientType === "cli" ? body.clientType : "web";
+		try {
+			return c.json({
+				ok: true,
+				payload: await xopcCloud.start(clientType)
+			}, 201);
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: { message: error instanceof Error ? error.message : "Connection failed" }
+			}, 502);
+		}
+	});
+	authenticated.post("/api/models/xopc-cloud/connect/:requestId/poll", xopcCloudPollRateLimitMiddleware, async (c) => {
+		try {
+			const result = await xopcCloud.poll(c.req.param("requestId"));
+			if (result.status === "pending") return c.json({
+				ok: true,
+				payload: result
+			}, 202);
+			service.emit("model-catalog.updated", { modelCount: getModelRegistry().getAll().length });
+			return c.json({
+				ok: true,
+				payload: result
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: { message: error instanceof Error ? error.message : "Connection failed" }
+			}, 400);
+		}
+	});
+	authenticated.post("/api/models/xopc-cloud/refresh", strictRateLimitMiddleware, async (c) => {
+		try {
+			const result = await catalogSync.refreshNow();
+			return c.json({
+				ok: true,
+				payload: result
+			});
+		} catch (error) {
+			const status = error instanceof XopcCloudHttpError && error.status === 401 ? 401 : error instanceof XopcCloudHttpError && error.status === 403 ? 403 : 502;
+			return c.json({
+				ok: false,
+				error: {
+					message: error instanceof Error ? error.message : "Refresh failed",
+					...error instanceof XopcCloudHttpError && error.code ? { code: error.code } : {}
+				}
+			}, status);
+		}
+	});
+	authenticated.get("/api/models/catalog/status", (c) => c.json({
+		ok: true,
+		payload: catalogSync.getStatus()
+	}));
+	authenticated.get("/api/models/catalog", async (c) => {
+		const catalog = getModelCatalogStore().load();
+		const sessionConfigs = await new SessionConfigStore("").getAll();
+		const references = auditModelReferences(service.currentConfig, sessionConfigs, { catalog });
+		return c.json({
+			ok: true,
+			payload: {
+				sources: catalog.sources,
+				sync: catalogSync.getStatus(),
+				references
+			}
+		});
+	});
+	authenticated.post("/api/models/catalog/refresh", strictRateLimitMiddleware, async (c) => {
+		const result = await catalogSync.refreshAll();
+		return c.json({
+			ok: true,
+			payload: result
+		});
+	});
 	authenticated.get("/api/models-json", async (c) => {
 		const path = resolveModelsJsonPath();
 		const { config, error } = loadModelsJson(path);
@@ -216,142 +287,93 @@ function registerModelsRoutes(authenticated, deps) {
 			payload: { models }
 		});
 	});
-	authenticated.get("/api/image/capabilities", async (c) => {
-		const config = service.currentConfig;
-		const agentId = c.req.query("agentId")?.trim() || void 0;
-		const imageGenerationProviders = await resolveImageGenerationCapabilities(config);
-		const imageUnderstandingProviders = await resolveImageUnderstandingCapabilities(config);
+	authenticated.get("/api/image-generation/catalog", (c) => {
 		return c.json({
 			ok: true,
-			payload: {
-				current: resolveCurrentImageModelCapabilities(config, agentId),
-				imageGeneration: { providers: imageGenerationProviders },
-				imageUnderstanding: { providers: imageUnderstandingProviders }
-			}
+			payload: { providers: getImageGenerationCatalog(service.currentConfig) }
 		});
 	});
-	authenticated.post("/api/image/validate-model", strictRateLimitMiddleware, async (c) => {
-		let body;
+	authenticated.get("/api/agents/:agentId/image-generation", (c) => {
 		try {
-			body = await c.req.json();
-		} catch {
+			return c.json({
+				ok: true,
+				payload: getAgentImageGenerationConfig(service.currentConfig, c.req.param("agentId"))
+			});
+		} catch (error) {
 			return c.json({
 				ok: false,
-				error: "Invalid JSON"
-			}, 400);
+				error: { message: error instanceof Error ? error.message : String(error) }
+			}, 404);
 		}
-		const modelRef = body.modelRef;
-		if (!modelRef || typeof modelRef !== "string") return c.json({
+	});
+	authenticated.post("/api/agents/:agentId/image-generation/setup", strictRateLimitMiddleware, async (c) => {
+		const body = await c.req.json().catch(() => null);
+		if (!body || typeof body.providerId !== "string") return c.json({
 			ok: false,
-			error: "modelRef is required"
+			error: { message: "providerId is required" }
 		}, 400);
-		const parsed = parseModelRef(modelRef);
-		if (!parsed) return c.json({
-			ok: true,
-			payload: {
-				valid: false,
-				reason: "invalid_format",
-				message: "Model reference must be in \"provider/model\" format"
-			}
-		});
-		if (!await isProviderConfigured(parsed.provider)) return c.json({
-			ok: true,
-			payload: {
-				valid: false,
-				reason: "provider_not_configured",
-				message: `Provider "${parsed.provider}" is not configured. Set the API key first.`,
-				provider: parsed.provider
-			}
+		const prepared = prepareImageGenerationSetup(service.currentConfig, c.req.param("agentId"), {
+			providerId: body.providerId,
+			...typeof body.modelId === "string" ? { modelId: body.modelId } : {},
+			...body.region === "cn" || body.region === "intl" ? { region: body.region } : {},
+			...typeof body.baseUrl === "string" ? { baseUrl: body.baseUrl } : {}
 		});
-		try {
-			resolveModel(modelRef);
-		} catch {
+		if (prepared.ok === false) return c.json({
+			ok: false,
+			error: { message: prepared.error }
+		}, 400);
+		const resolver = new CredentialResolver();
+		const previousKey = await resolver.revealGatewayStoredApiKey(prepared.providerId);
+		const suppliedKey = typeof body.apiKey === "string" ? body.apiKey.trim() : "";
+		if (!(suppliedKey || await resolver.resolveApiKey(prepared.providerId))) return c.json({
+			ok: false,
+			error: { message: "API key is required" }
+		}, 400);
+		const verification = suppliedKey ? await verifyImageGenerationCredential({
+			providerId: prepared.providerId,
+			apiKey: suppliedKey,
+			baseUrl: typeof body.baseUrl === "string" ? body.baseUrl : void 0
+		}) : {
+			verified: false,
+			supported: false
+		};
+		if (verification.supported && !verification.verified) return c.json({
+			ok: false,
+			error: { message: verification.message ?? "Credential verification failed" }
+		}, 400);
+		if (suppliedKey) await resolver.saveApiKey(prepared.providerId, suppliedKey, { profileName: "default" });
+		const saved = await service.saveConfig(prepared.config);
+		if (!saved.saved) {
+			if (suppliedKey) if (previousKey) await resolver.saveApiKey(prepared.providerId, previousKey, { profileName: "default" });
+			else await resolver.deleteProfile(`${prepared.providerId}:default`);
 			return c.json({
-				ok: true,
-				payload: {
-					valid: false,
-					reason: "model_not_found",
-					message: `Model not found in registry: ${modelRef}`,
-					provider: parsed.provider,
-					model: parsed.model
-				}
-			});
+				ok: false,
+				error: { message: saved.error ?? "Failed to save configuration" }
+			}, 500);
 		}
 		return c.json({
 			ok: true,
 			payload: {
-				valid: true,
-				provider: parsed.provider,
-				model: parsed.model
-			}
-		});
-	});
-	authenticated.get("/api/image/providers", (c) => {
-		const cfg = deps.service.currentConfig;
-		const providers = listImageGenerationProvidersSummary(cfg).map((p) => {
-			const provider = getImageGenerationProvider(p.id, cfg);
-			let configured = false;
-			try {
-				configured = provider?.isConfigured?.({ cfg }) === true;
-			} catch {
-				configured = false;
+				agent: getAgentImageGenerationConfig(service.currentConfig, c.req.param("agentId")),
+				providers: getImageGenerationCatalog(service.currentConfig),
+				verification
 			}
-			return {
-				...p,
-				configured
-			};
-		});
-		return c.json({
-			ok: true,
-			payload: { providers }
 		});
 	});
-	authenticated.post("/api/image/providers/:id/test", (c) => {
-		const id = c.req.param("id");
-		const cfg = deps.service.currentConfig;
-		const provider = getImageGenerationProvider(id, cfg);
-		if (!provider) return c.json({
+	authenticated.post("/api/image-generation/providers/:providerId/verify", strictRateLimitMiddleware, async (c) => {
+		const body = await c.req.json().catch(() => null);
+		if (!body || typeof body.apiKey !== "string") return c.json({
 			ok: false,
-			error: { message: `Image generation provider not found: ${id}` }
-		}, 404);
-		let configured = false;
-		let reason;
-		try {
-			configured = provider.isConfigured?.({ cfg }) === true;
-			if (!configured) reason = "Missing API key (set via config or environment).";
-		} catch (err) {
-			reason = err instanceof Error ? err.message : String(err);
-		}
-		return c.json({
-			ok: true,
-			payload: {
-				id: provider.id,
-				configured,
-				...reason ? { reason } : {},
-				defaultModel: provider.defaultModel ?? null
-			}
+			error: { message: "apiKey is required" }
+		}, 400);
+		const result = await verifyImageGenerationCredential({
+			providerId: c.req.param("providerId"),
+			apiKey: body.apiKey,
+			baseUrl: typeof body.baseUrl === "string" ? body.baseUrl : void 0
 		});
-	});
-	/**
-	* POST /api/image/providers/:id/reveal-api-key — return `cfg.providers.<id>.apiKey` plaintext for the
-	* gateway console (same auth as PATCH /api/config). Does not resolve env vars or credential files.
-	*/
-	authenticated.post("/api/image/providers/:id/reveal-api-key", strictRateLimitMiddleware, async (c) => {
-		const rawId = c.req.param("id");
-		const cfg = deps.service.currentConfig;
-		const provider = getImageGenerationProvider(rawId, cfg);
-		if (!provider) return c.json({
-			ok: false,
-			error: { message: `Image generation provider not found: ${rawId}` }
-		}, 404);
-		const apiKey = readProviderApiKeyFromConfigFileOnly(cfg, provider.id);
 		return c.json({
 			ok: true,
-			payload: {
-				id: provider.id,
-				apiKey: apiKey ?? null,
-				source: apiKey ? "config" : "none"
-			}
+			payload: result
 		});
 	});
 	authenticated.get("/api/providers", async (c) => {

package/dist/src/gateway/image-generation-setup.d.ts

@@ -0,0 +1,40 @@
+import { listImageGenerationProvidersSummary } from '../agent/image/generation/provider-registry.js';
+import { type Config } from '../config/schema.js';
+export type ImageGenerationSetupInput = {
+    providerId: string;
+    modelId?: string;
+    region?: 'cn' | 'intl';
+    baseUrl?: string;
+};
+export type ImageGenerationCatalogItem = ReturnType<typeof listImageGenerationProvidersSummary>[number] & {
+    configured: boolean;
+    requiresRegion: boolean;
+};
+export declare function getImageGenerationCatalog(config: Config): ImageGenerationCatalogItem[];
+export declare function getAgentImageGenerationConfig(config: Config, agentIdRaw: string): {
+    agentId: string;
+    model: {
+        primary: string;
+        fallbacks?: string[];
+        timeoutMs?: number;
+        autoProviderFallback?: boolean;
+    };
+};
+export declare function prepareImageGenerationSetup(config: Config, agentIdRaw: string, input: ImageGenerationSetupInput): {
+    ok: true;
+    config: Config;
+    providerId: string;
+    modelId: string;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function verifyImageGenerationCredential(input: {
+    providerId: string;
+    apiKey: string;
+    baseUrl?: string;
+}): Promise<{
+    verified: boolean;
+    supported: boolean;
+    message?: string;
+}>;

package/dist/src/gateway/image-generation-setup.js

@@ -0,0 +1,130 @@
+import { ConfigSchema, init_schema } from "../config/schema.js";
+import { init_agent_scope, normalizeAgentId } from "../agent/agent-scope.js";
+import { resolveEffectiveAgentManifestForAgent } from "../config/agent-profile.js";
+import { fetchWithTimeoutGuarded } from "../media-shared/http/provider-http.js";
+import "../media-shared/http/index.js";
+import { getImageGenerationProvider, listImageGenerationProvidersSummary } from "../agent/image/generation/provider-registry.js";
+//#region src/gateway/image-generation-setup.ts
+init_agent_scope();
+init_schema();
+function getImageGenerationCatalog(config) {
+	return listImageGenerationProvidersSummary().map((summary) => {
+		const provider = getImageGenerationProvider(summary.id);
+		return {
+			...summary,
+			configured: provider.isConfigured({ cfg: config }),
+			requiresRegion: summary.id === "dashscope" || summary.id === "minimax"
+		};
+	});
+}
+function getAgentImageGenerationConfig(config, agentIdRaw) {
+	const agentId = normalizeAgentId(agentIdRaw);
+	if (!config.agents.list.some((entry) => entry.enabled !== false && normalizeAgentId(entry.id) === agentId)) throw new Error(`Agent not found: ${agentId}`);
+	return {
+		agentId,
+		model: resolveEffectiveAgentManifestForAgent(config, agentId).models.imageGenerationModel ?? null
+	};
+}
+function prepareImageGenerationSetup(config, agentIdRaw, input) {
+	const agentId = normalizeAgentId(agentIdRaw);
+	if (!config.agents.list.some((entry) => entry.enabled !== false && normalizeAgentId(entry.id) === agentId)) return {
+		ok: false,
+		error: `Agent not found: ${agentId}`
+	};
+	const providerId = input.providerId.trim();
+	const provider = getImageGenerationProvider(providerId);
+	if (!provider) return {
+		ok: false,
+		error: `Unknown image provider: ${providerId}`
+	};
+	const modelId = input.modelId?.trim() || provider.defaultModel;
+	if (!provider.models.includes(modelId)) return {
+		ok: false,
+		error: `Unknown ${providerId} image model: ${modelId}`
+	};
+	if ((providerId === "dashscope" || providerId === "minimax") && input.region !== "cn" && input.region !== "intl") return {
+		ok: false,
+		error: `${providerId} requires region "cn" or "intl"`
+	};
+	const next = structuredClone(config);
+	const index = next.agents.list.findIndex((entry) => entry.enabled !== false && normalizeAgentId(entry.id) === agentId);
+	if (index < 0) return {
+		ok: false,
+		error: `Agent not found: ${agentId}`
+	};
+	const connection = {
+		...input.region ? { region: input.region } : {},
+		...input.baseUrl?.trim() ? { baseUrl: input.baseUrl.trim() } : {}
+	};
+	next.providers = {
+		...next.providers ?? {},
+		[providerId]: {
+			...next.providers?.[providerId] ?? {},
+			...connection
+		}
+	};
+	const entry = next.agents.list[index];
+	entry.models.imageGenerationModel = { primary: `${providerId}/${modelId}` };
+	const parsed = ConfigSchema.safeParse(next);
+	if (!parsed.success) return {
+		ok: false,
+		error: parsed.error.issues.map((issue) => issue.message).join("; ")
+	};
+	return {
+		ok: true,
+		config: next,
+		providerId,
+		modelId
+	};
+}
+async function verifyImageGenerationCredential(input) {
+	const apiKey = input.apiKey.trim();
+	if (!apiKey) return {
+		verified: false,
+		supported: true,
+		message: "API key is required"
+	};
+	if (!getImageGenerationProvider(input.providerId)) return {
+		verified: false,
+		supported: true,
+		message: `Unknown image provider: ${input.providerId}`
+	};
+	let url;
+	let headers = {};
+	if (input.providerId === "openai") {
+		url = `${input.baseUrl?.trim().replace(/\/+$/, "") || "https://api.openai.com/v1"}/models`;
+		headers = { Authorization: `Bearer ${apiKey}` };
+	} else if (input.providerId === "google") url = `${input.baseUrl?.trim().replace(/\/+$/, "") || "https://generativelanguage.googleapis.com"}/v1beta/models?pageSize=1&key=${encodeURIComponent(apiKey)}`;
+	else return {
+		verified: false,
+		supported: false
+	};
+	try {
+		const response = await fetchWithTimeoutGuarded(url, {
+			timeoutMs: 1e4,
+			label: `${input.providerId} credential verification`,
+			allowPrivateNetwork: false,
+			init: {
+				headers,
+				redirect: "error"
+			}
+		});
+		if (response.ok) return {
+			verified: true,
+			supported: true
+		};
+		return {
+			verified: false,
+			supported: true,
+			message: `Provider returned HTTP ${response.status}`
+		};
+	} catch (error) {
+		return {
+			verified: false,
+			supported: true,
+			message: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+//#endregion
+export { getAgentImageGenerationConfig, getImageGenerationCatalog, prepareImageGenerationSetup, verifyImageGenerationCredential };

package/dist/src/gateway/rate-limit/buckets.d.ts

@@ -35,6 +35,7 @@ declare class BucketRegistry {
     private authFailureLimiter?;
     private authFailureSignature?;
     private strictApiLimiter?;
+    private xopcCloudPollLimiter?;
     private channelApiLimiter?;
     private tunnelMutateLimiter?;
     private pairingExchangeLimiter?;
@@ -48,6 +49,8 @@ declare class BucketRegistry {
     authFailure(cfg: ResolvedAuthRateLimitConfig): FailureLimiter;
     /** Sensitive admin / mutation endpoints — 15 req / 60 s per client IP. */
     strictApi(): RateLimiter;
+    /** XOPC Cloud authorization polling — 60 req / 60 s per client IP. */
+    xopcCloudPoll(): RateLimiter;
     /** Channel mutation/action endpoints — 20 req / 60 s per client IP. */
     channelApi(): RateLimiter;
     /** Tunnel mutation calls — 12 req / 5 min per gateway-token fingerprint. */

package/dist/src/gateway/rate-limit/buckets.js

@@ -47,6 +47,7 @@ var BucketRegistry = class {
 	authFailureLimiter;
 	authFailureSignature;
 	strictApiLimiter;
+	xopcCloudPollLimiter;
 	channelApiLimiter;
 	tunnelMutateLimiter;
 	pairingExchangeLimiter;
@@ -79,6 +80,14 @@ var BucketRegistry = class {
 		});
 		return this.strictApiLimiter;
 	}
+	/** XOPC Cloud authorization polling — 60 req / 60 s per client IP. */
+	xopcCloudPoll() {
+		if (!this.xopcCloudPollLimiter) this.xopcCloudPollLimiter = new RateLimiter({
+			maxRequests: 60,
+			windowMs: 6e4
+		});
+		return this.xopcCloudPollLimiter;
+	}
 	/** Channel mutation/action endpoints — 20 req / 60 s per client IP. */
 	channelApi() {
 		if (!this.channelApiLimiter) this.channelApiLimiter = new RateLimiter({
@@ -123,6 +132,7 @@ var BucketRegistry = class {
 	destroyAll() {
 		this.authFailureLimiter?.destroy();
 		this.strictApiLimiter?.destroy();
+		this.xopcCloudPollLimiter?.destroy();
 		this.channelApiLimiter?.destroy();
 		this.tunnelMutateLimiter?.destroy();
 		this.pairingExchangeLimiter?.destroy();
@@ -130,6 +140,7 @@ var BucketRegistry = class {
 		this.sharePublicLongLimiter?.destroy();
 		this.authFailureLimiter = void 0;
 		this.strictApiLimiter = void 0;
+		this.xopcCloudPollLimiter = void 0;
 		this.channelApiLimiter = void 0;
 		this.tunnelMutateLimiter = void 0;
 		this.pairingExchangeLimiter = void 0;
@@ -141,6 +152,7 @@ var BucketRegistry = class {
 	resetAllForTests() {
 		this.authFailureLimiter?.resetForTests();
 		this.strictApiLimiter?.resetForTests();
+		this.xopcCloudPollLimiter?.resetForTests();
 		this.channelApiLimiter?.resetForTests();
 		this.tunnelMutateLimiter?.resetForTests();
 		this.pairingExchangeLimiter?.resetForTests();

package/dist/src/gateway/service.d.ts

@@ -7,6 +7,7 @@ import { ExtensionLoader } from '../extensions/index.js';
 import { SessionIndex } from '../session/index.js';
 import type { Config } from '../config/schema.js';
 import { type ResolvedGatewayAuth } from './auth.js';
+import { ModelCatalogSyncService } from '../providers/model-catalog-sync-service.js';
 import { AgentRunRelay } from './agent-run-relay.js';
 import { type EnqueueGoalRunOptions } from '../goals/index.js';
 import { ProjectService } from '../projects/index.js';
@@ -41,9 +42,11 @@ export declare class GatewayService {
     private startTime;
     private workspacePath;
     private readonly configCoordinator;
+    private readonly modelCatalogSync;
     private auth;
     private readonly sse;
     getConfig(): Config;
+    getModelCatalogSync(): ModelCatalogSyncService;
     get browserRecipes(): BrowserRecipeService;
     private stopGatewayUpdateCheck;
     /** When set (e.g. by `GatewayServer`), `triggerGatewayProcessRestart` can stop HTTP then exit. */

package/dist/src/gateway/service.js

@@ -74,6 +74,7 @@ import { isGatewayStrictSecurityEnabled } from "./rate-limit/env-flags.js";
 import "./rate-limit/index.js";
 import { assertGatewayRuntimeConfig } from "./runtime-config.js";
 import { auditGatewayConfig } from "./security/audit.js";
+import { ModelCatalogSyncService } from "../providers/model-catalog-sync-service.js";
 import { runBootstrapMigrationsSync } from "../migrations/runner.js";
 import { MobileNotificationService } from "../mobile/notification-service.js";
 import { LocalAppService } from "../local-apps/service.js";
@@ -124,11 +125,18 @@ var GatewayService = class {
 	startTime = Date.now();
 	workspacePath;
 	configCoordinator;
+	modelCatalogSync = new ModelCatalogSyncService({
+		onUpdated: (modelCount) => this.emit("model-catalog.updated", { modelCount }),
+		getConfig: () => this.config
+	});
 	auth;
 	sse = new GatewaySseHub();
 	getConfig() {
 		return this.config;
 	}
+	getModelCatalogSync() {
+		return this.modelCatalogSync;
+	}
 	get browserRecipes() {
 		if (!this.browserRecipeService) this.browserRecipeService = createRuntimeBrowserRecipeService({
 			getConfig: () => this.config,
@@ -582,6 +590,7 @@ var GatewayService = class {
 				phase: "sidecars.model_prewarm"
 			}, `Model registry prewarm failed: ${em}`);
 		}
+		this.modelCatalogSync.start();
 		if (!this.extensionLoader || areExtensionsGloballyDisabled(this.config)) return;
 		try {
 			if (trace) await trace.measure("extensions.deferred-load", () => this.loadDeferredExtensions());
@@ -827,6 +836,7 @@ var GatewayService = class {
 			this.stopGatewayUpdateCheck();
 			this.stopGatewayUpdateCheck = null;
 		}
+		this.modelCatalogSync.stop();
 		await this.configCoordinator.stopHotReloader();
 		this.heartbeatService?.stop();
 		this.connectorSupervisor?.stop();

package/dist/src/media-shared/http/private-network.d.ts

@@ -2,7 +2,7 @@
  * SSRF / private-network protection for provider HTTP calls.
  *
  * Provider URLs are mostly user-controllable (cfg.providers.<id>.baseUrl,
- * imageBaseUrl, etc.). Without a guard a malicious config could make xopc
+ * custom provider base URLs. Without a guard a malicious config could make xopc
  * fetch internal services (169.254.x.x metadata, 127.0.0.1, RFC1918, …).
  *
  * Policy:

package/dist/src/media-shared/http/private-network.js

@@ -4,7 +4,7 @@ import { isIP } from "node:net";
 * SSRF / private-network protection for provider HTTP calls.
 *
 * Provider URLs are mostly user-controllable (cfg.providers.<id>.baseUrl,
-* imageBaseUrl, etc.). Without a guard a malicious config could make xopc
+* custom provider base URLs. Without a guard a malicious config could make xopc
 * fetch internal services (169.254.x.x metadata, 127.0.0.1, RFC1918, …).
 *
 * Policy: