@xopcai/xopc 0.0.162 → 0.0.164

package/dist/src/providers/auth-runtime/resolve-auth.d.ts

@@ -6,8 +6,7 @@
  *
  * Resolution order matches `resolveApiKeyForProvider`:
  *   1. AuthProfileStore (per-agent profile — may be OAuth)
- *   2. cfg.providers.<id>.apiKey
- *   3. PROVIDER_ENV_MAP[providerId] env vars
+ *   2. Environment variables
  *
  * Returns:
  *   - `mode: 'oauth' | 'azure-key' | 'api-key'`
@@ -19,8 +18,8 @@ export interface ProviderAuthResolution {
     apiKey?: string;
     mode: ProviderAuthMode;
     profileId?: string;
-    /** Source bucket: 'store' | 'config' | 'env' | 'none'. */
-    source: 'store' | 'config' | 'env' | 'none';
+    /** Source bucket. */
+    source: 'store' | 'env' | 'none';
     /** Vendor metadata copied from the matched profile (azure resource etc.). */
     meta?: Record<string, unknown>;
 }

package/dist/src/providers/auth-runtime/resolve-auth.js

@@ -1,7 +1,9 @@
+import { init_sync_provider_auth, resolveProviderApiKeyForAgentSync } from "../../auth/sync-provider-auth.js";
 import { getApiKeyFromEnv, init_env_keys } from "../env-keys.js";
 import { getDefaultAuthProfileStore } from "./auth-profile-store.js";
 //#region src/providers/auth-runtime/resolve-auth.ts
 init_env_keys();
+init_sync_provider_auth();
 function resolveAuthProfileForProvider(options) {
 	const { providerId } = options;
 	if (!providerId) return {
@@ -20,22 +22,28 @@ function resolveAuthProfileForProvider(options) {
 			meta: profile.meta
 		};
 	}
-	const cfgKey = readCfgApiKey(options.cfg, providerId);
-	if (cfgKey) {
+	if (!options.store && !options.envReader) {
+		const storedKey = resolveProviderApiKeyForAgentSync(providerId, options.agentId, options.cfg);
+		if (storedKey) {
+			const azure = readCfgAzureMeta(options.cfg, providerId);
+			return {
+				apiKey: storedKey,
+				mode: azure ? "azure-key" : "api-key",
+				source: "store",
+				meta: azure
+			};
+		}
+	}
+	const envKey = options.envReader ? readFromCustomEnv(options.envReader, providerId) : getApiKeyFromEnv(providerId);
+	if (envKey) {
 		const azure = readCfgAzureMeta(options.cfg, providerId);
 		return {
-			apiKey: cfgKey,
+			apiKey: envKey,
 			mode: azure ? "azure-key" : "api-key",
-			source: "config",
+			source: "env",
 			meta: azure
 		};
 	}
-	const envKey = options.envReader ? readFromCustomEnv(options.envReader, providerId) : getApiKeyFromEnv(providerId);
-	if (envKey) return {
-		apiKey: envKey,
-		mode: "api-key",
-		source: "env"
-	};
 	return {
 		apiKey: void 0,
 		mode: "api-key",
@@ -49,14 +57,6 @@ function pickProfile(store, providerId, profileName) {
 		return;
 	}
 }
-function readCfgApiKey(cfg, providerId) {
-	const providers = cfg?.providers;
-	if (!providers || typeof providers !== "object") return void 0;
-	const entry = providers[providerId];
-	if (!entry || typeof entry !== "object") return void 0;
-	const apiKey = entry.apiKey;
-	return typeof apiKey === "string" && apiKey.length > 0 ? apiKey : void 0;
-}
 function readCfgAzureMeta(cfg, providerId) {
 	const providers = cfg?.providers;
 	if (!providers || typeof providers !== "object") return void 0;

package/dist/src/providers/domestic-presets.d.ts

@@ -30,6 +30,8 @@ export interface DomesticProviderPreset {
     models: DomesticProviderModelPreset[];
     aliases: string[];
     quirks?: string[];
+    onboardingIcon?: string;
+    requiresModelDiscovery?: boolean;
 }
 export declare const DOMESTIC_PROVIDER_PRESETS: readonly [{
     readonly id: "dashscope-cn";

package/dist/src/providers/index.js

@@ -1,5 +1,6 @@
 import { __esmMin, __exportAll } from "../../_virtual/_rolldown/runtime.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
+import { getOAuthProviderIds, init_registry } from "../auth/oauth/registry.js";
 import { hasProviderAuthOnDiskSync, init_sync_provider_auth } from "../auth/sync-provider-auth.js";
 import { PROVIDER_ENV_MAP, getApiKeyFromEnv, init_env_keys } from "./env-keys.js";
 import { ModelRegistry, getModelRegistry, init_model_registry, prewarmModelRegistry, resetModelRegistry } from "./model-registry.js";
@@ -136,6 +137,7 @@ function getAllProviders() {
 	for (const p of getProviders()) providers.add(p);
 	for (const m of registry.getAll()) providers.add(m.provider);
 	for (const plugin of getProviderRegistry().listAll()) providers.add(plugin.id);
+	for (const provider of getOAuthProviderIds()) providers.add(provider);
 	return Array.from(providers);
 }
 async function getApiKey(provider, credentialOptions) {
@@ -310,12 +312,19 @@ var init_providers = __esmMin((() => {
 	init_model_registry();
 	init_credentials();
 	init_sync_provider_auth();
+	init_registry();
 	init_env_keys();
 	init_constants();
 	init_model_supplements();
 	init_plugin_registry();
 	OPENAI_CODEX_CANONICAL_BASE_URL = "https://chatgpt.com/backend-api/codex";
 	PROVIDER_META = {
+		"xopc-cloud": {
+			name: "XOPC Model Service",
+			category: "oauth",
+			supportsOAuth: true,
+			supportsApiKey: false
+		},
 		"openai": {
 			name: "OpenAI",
 			category: "common",

package/dist/src/providers/model-catalog-store.d.ts

@@ -0,0 +1,33 @@
+export interface CatalogModel {
+    id: string;
+    name: string;
+    availability: 'available' | 'unavailable';
+    maxOutputTokens: number | null;
+}
+export interface CatalogSource {
+    providerId: string;
+    baseUrl: string;
+    api: 'openai-completions' | 'openai-responses';
+    etag: string | null;
+    recommendedModel: string | null;
+    lastSuccessAt: number;
+    models: CatalogModel[];
+}
+export interface ModelCatalogSnapshot {
+    sources: Record<string, CatalogSource>;
+}
+export type AvailableCatalogModel = Omit<CatalogModel, 'availability'>;
+export declare class ModelCatalogStore {
+    private sources;
+    load(): ModelCatalogSnapshot;
+    getSource(sourceId: string): CatalogSource | undefined;
+    saveSource(sourceId: string, source: CatalogSource): void;
+    removeSource(sourceId: string): boolean;
+    replaceSourceModels(sourceId: string, source: Omit<CatalogSource, 'models'>, models: AvailableCatalogModel[]): {
+        addedCount: number;
+        unavailableCount: number;
+    };
+    private cloneSource;
+}
+export declare function getModelCatalogStore(): ModelCatalogStore;
+export declare function resetModelCatalogStore(): void;

package/dist/src/providers/model-catalog-store.js

@@ -0,0 +1,63 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+//#region src/providers/model-catalog-store.ts
+function getModelCatalogStore() {
+	globalModelCatalogStore ??= new ModelCatalogStore();
+	return globalModelCatalogStore;
+}
+function resetModelCatalogStore() {
+	globalModelCatalogStore = void 0;
+}
+var ModelCatalogStore, globalModelCatalogStore;
+var init_model_catalog_store = __esmMin((() => {
+	ModelCatalogStore = class {
+		sources = {};
+		load() {
+			return { sources: Object.fromEntries(Object.entries(this.sources).map(([id, source]) => [id, this.cloneSource(source)])) };
+		}
+		getSource(sourceId) {
+			const source = this.sources[sourceId];
+			return source ? this.cloneSource(source) : void 0;
+		}
+		saveSource(sourceId, source) {
+			this.sources = {
+				...this.sources,
+				[sourceId]: this.cloneSource(source)
+			};
+		}
+		removeSource(sourceId) {
+			if (!this.sources[sourceId]) return false;
+			const { [sourceId]: _removed, ...sources } = this.sources;
+			this.sources = sources;
+			return true;
+		}
+		replaceSourceModels(sourceId, source, models) {
+			const previous = this.getSource(sourceId);
+			const nextIds = new Set(models.map((model) => model.id));
+			const previousAvailableIds = new Set((previous?.models ?? []).filter((model) => model.availability === "available").map((model) => model.id));
+			const unavailable = (previous?.models ?? []).filter((model) => !nextIds.has(model.id)).map((model) => ({
+				...model,
+				availability: "unavailable"
+			}));
+			this.saveSource(sourceId, {
+				...source,
+				models: [...models.map((model) => ({
+					...model,
+					availability: "available"
+				})), ...unavailable]
+			});
+			return {
+				addedCount: models.filter((model) => !previousAvailableIds.has(model.id)).length,
+				unavailableCount: unavailable.length
+			};
+		}
+		cloneSource(source) {
+			return {
+				...source,
+				models: source.models.map((model) => ({ ...model }))
+			};
+		}
+	};
+}));
+//#endregion
+init_model_catalog_store();
+export { ModelCatalogStore, getModelCatalogStore, init_model_catalog_store, resetModelCatalogStore };

package/dist/src/providers/model-catalog-sync-service.d.ts

@@ -0,0 +1,40 @@
+import type { Config } from '../config/schema.js';
+import { type ModelsJsonConfig } from '../config/models-json.js';
+import { type ModelCatalogStore } from './model-catalog-store.js';
+import { discoverProviderModels } from './model-discovery.js';
+import { XopcCloudModelSource } from './xopc-cloud-model-source.js';
+export interface ModelCatalogSyncStatus {
+    running: boolean;
+    refreshing: boolean;
+    lastAttemptAt?: number;
+    lastSuccessAt?: number;
+    lastError?: string;
+    sourceErrors?: Record<string, string>;
+}
+export declare class ModelCatalogSyncService {
+    private readonly options;
+    private readonly xopcCloud;
+    private timer;
+    private refreshPromise;
+    private refreshAllPromise;
+    private status;
+    constructor(options?: {
+        intervalMs?: number;
+        onUpdated?: (modelCount: number) => void;
+        xopcCloud?: XopcCloudModelSource;
+        getConfig?: () => Config;
+        catalogStore?: ModelCatalogStore;
+        loadProviders?: () => ModelsJsonConfig['providers'];
+        discoverModels?: typeof discoverProviderModels;
+        refreshModels?: () => void;
+        getModelCount?: () => number;
+    });
+    start(): void;
+    stop(): void;
+    getStatus(): ModelCatalogSyncStatus;
+    refreshNow(): Promise<Awaited<ReturnType<XopcCloudModelSource['refresh']>>>;
+    refreshAll(): Promise<{
+        updatedSources: string[];
+    }>;
+    private refreshAllSources;
+}

package/dist/src/providers/model-catalog-sync-service.js

@@ -0,0 +1,132 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { init_models_json, loadModelsJson } from "../config/models-json.js";
+import { getModelCatalogStore, init_model_catalog_store } from "./model-catalog-store.js";
+import { getModelRegistry, init_model_registry } from "./model-registry.js";
+import { discoverProviderModels, isProviderApiDiscoverable } from "./model-discovery.js";
+import { XopcCloudModelSource } from "./xopc-cloud-model-source.js";
+//#region src/providers/model-catalog-sync-service.ts
+init_logger();
+init_models_json();
+init_model_catalog_store();
+init_model_registry();
+const log = createLogger("ModelCatalogSync");
+const DEFAULT_INTERVAL_MS = 360 * 6e4;
+var ModelCatalogSyncService = class {
+	xopcCloud;
+	timer = null;
+	refreshPromise = null;
+	refreshAllPromise = null;
+	status = {
+		running: false,
+		refreshing: false
+	};
+	constructor(options = {}) {
+		this.options = options;
+		this.xopcCloud = options.xopcCloud ?? new XopcCloudModelSource();
+	}
+	start() {
+		if (this.status.running) return;
+		const settings = this.options.getConfig?.().modelCatalog;
+		if (settings?.enabled === false) return;
+		this.status.running = true;
+		if (settings?.refreshOnStartup !== false) queueMicrotask(() => void this.refreshAll().catch(() => {}));
+		const intervalMs = this.options.intervalMs ?? (settings?.intervalHours ?? 6) * 60 * 6e4;
+		this.timer = setInterval(() => void this.refreshAll().catch(() => {}), intervalMs || DEFAULT_INTERVAL_MS);
+		this.timer.unref();
+	}
+	stop() {
+		if (this.timer) clearInterval(this.timer);
+		this.timer = null;
+		this.status.running = false;
+	}
+	getStatus() {
+		return { ...this.status };
+	}
+	refreshNow() {
+		if (this.refreshPromise) return this.refreshPromise;
+		this.status.refreshing = true;
+		this.status.lastAttemptAt = Date.now();
+		this.refreshPromise = this.xopcCloud.refresh().then((result) => {
+			if (result.status === "updated") {
+				this.status.lastSuccessAt = Date.now();
+				this.status.lastError = void 0;
+				this.options.onUpdated?.(result.modelCount ?? 0);
+			}
+			return result;
+		}).catch((err) => {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			this.status.lastError = errorMessage;
+			log.warn({
+				err,
+				errorMessage
+			}, `Model catalog refresh failed: ${errorMessage}`);
+			throw err;
+		}).finally(() => {
+			this.status.refreshing = false;
+			this.refreshPromise = null;
+		});
+		return this.refreshPromise;
+	}
+	refreshAll() {
+		if (this.refreshAllPromise) return this.refreshAllPromise;
+		this.status.refreshing = true;
+		this.refreshAllPromise = this.refreshAllSources().finally(() => {
+			this.status.refreshing = false;
+			this.refreshAllPromise = null;
+		});
+		return this.refreshAllPromise;
+	}
+	async refreshAllSources() {
+		const updatedSources = [];
+		const sourceErrors = {};
+		try {
+			if ((await this.refreshNow()).status === "updated") updatedSources.push("xopc-cloud");
+		} catch (err) {
+			sourceErrors["xopc-cloud"] = err instanceof Error ? err.message : String(err);
+		}
+		this.status.refreshing = true;
+		const providers = this.options.loadProviders?.() ?? loadModelsJson().config.providers;
+		const discoverable = Object.entries(providers).filter(([, provider]) => provider.modelDiscovery?.enabled === true && typeof provider.baseUrl === "string" && isProviderApiDiscoverable(provider.api));
+		const catalogStore = this.options.catalogStore ?? getModelCatalogStore();
+		const enabledSourceIds = new Set(discoverable.map(([providerId]) => `provider:${providerId}`));
+		const removedSource = Object.keys(catalogStore.load().sources).filter((sourceId) => sourceId.startsWith("provider:") && !enabledSourceIds.has(sourceId)).map((sourceId) => catalogStore.removeSource(sourceId)).some(Boolean);
+		const results = await Promise.all(discoverable.map(async ([providerId, provider]) => {
+			try {
+				const models = await (this.options.discoverModels ?? discoverProviderModels)({
+					providerId,
+					baseUrl: provider.baseUrl,
+					apiKey: provider.apiKey,
+					api: provider.api,
+					headers: provider.headers
+				});
+				catalogStore.replaceSourceModels(`provider:${providerId}`, {
+					providerId,
+					baseUrl: provider.baseUrl,
+					api: provider.api === "openai-responses" ? "openai-responses" : "openai-completions",
+					etag: null,
+					recommendedModel: null,
+					lastSuccessAt: Date.now()
+				}, models.map((model) => ({
+					id: model.id,
+					name: model.name ?? model.id,
+					maxOutputTokens: null
+				})));
+				return providerId;
+			} catch (err) {
+				sourceErrors[providerId] = err instanceof Error ? err.message : String(err);
+				return null;
+			}
+		}));
+		for (const providerId of results) if (providerId) updatedSources.push(providerId);
+		if (results.some(Boolean) || removedSource) {
+			(this.options.refreshModels ?? (() => getModelRegistry().refresh()))();
+			this.status.lastSuccessAt = Date.now();
+			this.options.onUpdated?.(this.options.getModelCount?.() ?? getModelRegistry().getAll().length);
+		}
+		this.status.sourceErrors = Object.keys(sourceErrors).length > 0 ? sourceErrors : void 0;
+		return { updatedSources };
+	}
+};
+//#endregion
+export { ModelCatalogSyncService };

package/dist/src/providers/model-reference-auditor.d.ts

@@ -0,0 +1,14 @@
+import type { Config } from '../config/schema.js';
+import type { SessionAgentConfig } from '../session/config-types.js';
+import { type ModelCatalogSnapshot } from './model-catalog-store.js';
+import { type ModelRegistry } from './model-registry.js';
+export interface ModelReferenceHealth {
+    ref: string;
+    availability: 'available' | 'unavailable';
+    locations: string[];
+    suggestedRef?: string;
+}
+export declare function auditModelReferences(config: Config, sessionConfigs?: ReadonlyMap<string, SessionAgentConfig>, deps?: {
+    registry?: ModelRegistry;
+    catalog?: ModelCatalogSnapshot;
+}): ModelReferenceHealth[];

package/dist/src/providers/model-reference-auditor.js

@@ -0,0 +1,71 @@
+import { getModelCatalogStore, init_model_catalog_store } from "./model-catalog-store.js";
+import { getModelRegistry, init_model_registry } from "./model-registry.js";
+//#region src/providers/model-reference-auditor.ts
+init_model_catalog_store();
+init_model_registry();
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function addRef(out, value, location) {
+	if (typeof value === "string" && value.trim()) out.push({
+		ref: value.trim(),
+		location
+	});
+}
+function collectToolModel(out, value, location) {
+	const model = asRecord(value);
+	if (!model) return;
+	addRef(out, model.primary, `${location}.primary`);
+	if (Array.isArray(model.fallbacks)) model.fallbacks.forEach((ref, index) => addRef(out, ref, `${location}.fallbacks[${index}]`));
+}
+function collectModelPolicy(out, value, location) {
+	const policy = asRecord(value);
+	if (!policy) return;
+	const roles = asRecord(policy.roles);
+	for (const [roleId, roleValue] of Object.entries(roles ?? {})) {
+		const role = asRecord(roleValue);
+		if (!role) continue;
+		addRef(out, role.model, `${location}.roles.${roleId}.model`);
+		if (Array.isArray(role.fallbacks)) role.fallbacks.forEach((ref, index) => addRef(out, ref, `${location}.roles.${roleId}.fallbacks[${index}]`));
+	}
+	collectToolModel(out, policy.imageModel, `${location}.imageModel`);
+	collectToolModel(out, policy.imageGenerationModel, `${location}.imageGenerationModel`);
+}
+function collectReferences(config, sessionConfigs) {
+	const out = [];
+	for (const [presetId, preset] of Object.entries(config.agents.capabilityPresets)) collectModelPolicy(out, preset.models, `agents.capabilityPresets.${presetId}.models`);
+	for (const agent of config.agents.list) collectModelPolicy(out, agent.models, `agents.list.${agent.id}.models`);
+	for (const [sessionKey, sessionConfig] of sessionConfigs) addRef(out, sessionConfig.modelOverride, `sessions.${sessionKey}.modelOverride`);
+	return out;
+}
+function suggestedRef(ref, catalog) {
+	const providerId = ref.split("/")[0];
+	const source = Object.values(catalog.sources).find((entry) => entry.providerId === providerId);
+	if (!source) return void 0;
+	const available = new Set(source.models.filter((model) => model.availability === "available").map((model) => model.id));
+	if (source.recommendedModel && available.has(source.recommendedModel)) return `${providerId}/${source.recommendedModel}`;
+	const first = source.models.find((model) => model.availability === "available");
+	return first ? `${providerId}/${first.id}` : void 0;
+}
+function auditModelReferences(config, sessionConfigs = /* @__PURE__ */ new Map(), deps = {}) {
+	const registry = deps.registry ?? getModelRegistry();
+	const catalog = deps.catalog ?? getModelCatalogStore().load();
+	const grouped = /* @__PURE__ */ new Map();
+	for (const reference of collectReferences(config, sessionConfigs)) {
+		const locations = grouped.get(reference.ref) ?? [];
+		locations.push(reference.location);
+		grouped.set(reference.ref, locations);
+	}
+	return [...grouped.entries()].map(([ref, locations]) => {
+		const availability = registry.resolve(ref) ? "available" : "unavailable";
+		const suggestion = availability === "unavailable" ? suggestedRef(ref, catalog) : void 0;
+		return {
+			ref,
+			availability,
+			locations,
+			...suggestion ? { suggestedRef: suggestion } : {}
+		};
+	}).sort((a, b) => a.ref.localeCompare(b.ref));
+}
+//#endregion
+export { auditModelReferences };

package/dist/src/providers/model-registry.d.ts

@@ -10,11 +10,13 @@
  * - Hot reload support
  */
 import { type Api, type Model } from '@earendil-works/pi-ai/compat';
+import { type ModelCatalogStore } from './model-catalog-store.js';
 /**
  * Model Registry - manages all models (built-in + custom)
  */
 export declare class ModelRegistry {
     private modelsJsonPath;
+    private catalogStore;
     private models;
     private customProviderApiKeys;
     private loadError;
@@ -22,7 +24,7 @@ export declare class ModelRegistry {
     private prewarmPromise;
     private _availableModelsCache;
     private _authStatusCache;
-    constructor(modelsJsonPath?: string);
+    constructor(modelsJsonPath?: string, catalogStore?: ModelCatalogStore);
     isLoaded(): boolean;
     /** Synchronously materialize the catalog (idempotent). */
     ensureLoaded(): void;
@@ -69,6 +71,7 @@ export declare class ModelRegistry {
      * Clears caches to ensure fresh data
      */
     private loadModels;
+    private loadRemoteModels;
     /**
      * Load built-in models and apply provider/model overrides
      */

package/dist/src/providers/model-registry.js

@@ -5,6 +5,7 @@ import { resolveModelsJsonPath } from "../config/paths.js";
 import { init_resolve_config_value, resolveConfigValue, resolveHeaders } from "../config/resolve-config-value.js";
 import { getDefaultModelValues, init_models_json, validateModelsConfig } from "../config/models-json.js";
 import { getApiKeyFromEnv, init_env_keys } from "./env-keys.js";
+import { getModelCatalogStore, init_model_catalog_store } from "./model-catalog-store.js";
 import { existsSync, readFileSync } from "fs";
 import { getModels, getProviders } from "@earendil-works/pi-ai/compat";
 //#region src/providers/model-registry.ts
@@ -94,6 +95,7 @@ var init_model_registry = __esmMin((() => {
 	init_models_json();
 	init_logger();
 	init_env_keys();
+	init_model_catalog_store();
 	log = createLogger("ModelRegistry");
 	ModelRegistry = class {
 		models = [];
@@ -103,8 +105,9 @@ var init_model_registry = __esmMin((() => {
 		prewarmPromise = null;
 		_availableModelsCache;
 		_authStatusCache = /* @__PURE__ */ new Map();
-		constructor(modelsJsonPath = resolveModelsJsonPath()) {
+		constructor(modelsJsonPath = resolveModelsJsonPath(), catalogStore = getModelCatalogStore()) {
 			this.modelsJsonPath = modelsJsonPath;
+			this.catalogStore = catalogStore;
 		}
 		isLoaded() {
 			return this.loaded;
@@ -213,13 +216,41 @@ var init_model_registry = __esmMin((() => {
 			}
 			this.customProviderApiKeys = apiKeyConfigs;
 			const builtInModels = this.loadBuiltInModels(overrides, modelOverrides);
-			this.models = this.mergeCustomModels(builtInModels, customModels);
+			const remoteModels = this.loadRemoteModels();
+			this.models = this.mergeCustomModels(this.mergeCustomModels(builtInModels, remoteModels), customModels);
 			log.debug({
 				builtIn: builtInModels.length,
+				remote: remoteModels.length,
 				custom: customModels.length,
 				total: this.models.length
 			}, "Models loaded");
 		}
+		loadRemoteModels() {
+			let sources;
+			try {
+				sources = this.catalogStore.load().sources;
+			} catch (err) {
+				log.warn({ err }, "Failed to load remote model catalog");
+				return [];
+			}
+			return Object.values(sources).flatMap((source) => source.models.filter((model) => model.availability === "available").map((model) => ({
+				id: model.id,
+				name: model.name,
+				api: source.api,
+				provider: source.providerId,
+				baseUrl: source.baseUrl,
+				reasoning: false,
+				input: ["text"],
+				cost: {
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0
+				},
+				contextWindow: 128e3,
+				maxTokens: model.maxOutputTokens ?? 16384
+			})));
+		}
 		/**
 		* Load built-in models and apply provider/model overrides
 		*/

package/dist/src/providers/presentation.js

@@ -5,6 +5,7 @@ import { getDomesticProviderPreset, getDomesticProviderPresetIds } from "./domes
 init_providers();
 init_plugin_registry();
 const FEATURED_PROVIDER_ORDER = [
+	"xopc-cloud",
 	"deepseek",
 	"openai",
 	"anthropic",
@@ -34,6 +35,7 @@ const FEATURED_PROVIDER_ORDER = [
 	"minimax-cn"
 ];
 const PROVIDER_HINTS = {
+	"xopc-cloud": "Official XOPC model service with models discovered from your account.",
 	openai: "Frontier OpenAI models from the official API.",
 	anthropic: "Claude models for coding, long context, and reasoning.",
 	xai: "Grok models from xAI.",

package/dist/src/providers/xopc-cloud-model-source.d.ts

@@ -0,0 +1,30 @@
+import { type CredentialResolver } from '../auth/credentials.js';
+import { type ModelCatalogStore } from './model-catalog-store.js';
+export type XopcCloudModelRefreshResult = {
+    status: 'skipped';
+    reason: 'not_configured';
+} | {
+    status: 'updated';
+    modelCount: number;
+    models: string[];
+};
+export declare class XopcCloudModelError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    constructor(message: string, status: number, code?: string);
+}
+export declare class XopcCloudModelSource {
+    private readonly fetchImpl;
+    private readonly routerUrl;
+    private readonly credentials;
+    private readonly catalogStore;
+    private readonly refreshModels;
+    constructor(options?: {
+        fetchImpl?: typeof fetch;
+        routerUrl?: string;
+        credentials?: Pick<CredentialResolver, 'resolveApiKey'>;
+        catalogStore?: ModelCatalogStore;
+        refreshModels?: () => void;
+    });
+    refresh(): Promise<XopcCloudModelRefreshResult>;
+}