@xopcai/xopc 0.0.161 → 0.0.163

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

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+declare const CatalogModelSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    availability: z.ZodEnum<{
+        available: "available";
+        unavailable: "unavailable";
+    }>;
+    maxOutputTokens: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+declare const CatalogSourceSchema: z.ZodObject<{
+    providerId: z.ZodString;
+    baseUrl: z.ZodString;
+    api: z.ZodEnum<{
+        "openai-completions": "openai-completions";
+        "openai-responses": "openai-responses";
+    }>;
+    etag: z.ZodNullable<z.ZodString>;
+    recommendedModel: z.ZodNullable<z.ZodString>;
+    lastSuccessAt: z.ZodNumber;
+    models: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        availability: z.ZodEnum<{
+            available: "available";
+            unavailable: "unavailable";
+        }>;
+        maxOutputTokens: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const ModelCatalogSchema: z.ZodObject<{
+    sources: z.ZodRecord<z.ZodString, z.ZodObject<{
+        providerId: z.ZodString;
+        baseUrl: z.ZodString;
+        api: z.ZodEnum<{
+            "openai-completions": "openai-completions";
+            "openai-responses": "openai-responses";
+        }>;
+        etag: z.ZodNullable<z.ZodString>;
+        recommendedModel: z.ZodNullable<z.ZodString>;
+        lastSuccessAt: z.ZodNumber;
+        models: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            availability: z.ZodEnum<{
+                available: "available";
+                unavailable: "unavailable";
+            }>;
+            maxOutputTokens: z.ZodNullable<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CatalogModel = z.infer<typeof CatalogModelSchema>;
+export type CatalogSource = z.infer<typeof CatalogSourceSchema>;
+export type ModelCatalogSnapshot = z.infer<typeof ModelCatalogSchema>;
+export type AvailableCatalogModel = Omit<CatalogModel, 'availability'>;
+export declare class ModelCatalogStore {
+    private readonly path;
+    constructor(path?: string);
+    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;
+    };
+}
+export declare function getModelCatalogStore(): ModelCatalogStore;
+export declare function resetModelCatalogStore(): void;
+export {};

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

@@ -0,0 +1,102 @@
+import { __esmMin } from "../../_virtual/_rolldown/runtime.js";
+import { init_paths_state, resolveStateDir } from "../config/paths-state.js";
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { init_write_file_atomic, writeTextAtomicSync } from "../infra/write-file-atomic.js";
+import { join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { z } from "zod";
+//#region src/providers/model-catalog-store.ts
+function getModelCatalogStore() {
+	globalModelCatalogStore ??= new ModelCatalogStore();
+	return globalModelCatalogStore;
+}
+function resetModelCatalogStore() {
+	globalModelCatalogStore = void 0;
+}
+var log, CatalogModelSchema, CatalogSourceSchema, ModelCatalogSchema, ModelCatalogStore, globalModelCatalogStore;
+var init_model_catalog_store = __esmMin((() => {
+	init_paths_state();
+	init_write_file_atomic();
+	init_logger();
+	log = createLogger("ModelCatalogStore");
+	CatalogModelSchema = z.object({
+		id: z.string().min(1),
+		name: z.string().min(1),
+		availability: z.enum(["available", "unavailable"]),
+		maxOutputTokens: z.number().positive().nullable()
+	});
+	CatalogSourceSchema = z.object({
+		providerId: z.string().min(1),
+		baseUrl: z.string().url(),
+		api: z.enum(["openai-completions", "openai-responses"]),
+		etag: z.string().nullable(),
+		recommendedModel: z.string().nullable(),
+		lastSuccessAt: z.number().int().nonnegative(),
+		models: z.array(CatalogModelSchema)
+	});
+	ModelCatalogSchema = z.object({ sources: z.record(z.string(), CatalogSourceSchema) });
+	ModelCatalogStore = class {
+		constructor(path = join(resolveStateDir(), "model-catalog.json")) {
+			this.path = path;
+		}
+		load() {
+			if (!existsSync(this.path)) return { sources: {} };
+			try {
+				const parsed = ModelCatalogSchema.safeParse(JSON.parse(readFileSync(this.path, "utf8")));
+				if (parsed.success) return parsed.data;
+				log.warn({
+					path: this.path,
+					errorMessage: parsed.error.message
+				}, "Ignoring invalid model catalog snapshot");
+			} catch (err) {
+				log.warn({
+					err,
+					path: this.path
+				}, "Ignoring unreadable model catalog snapshot");
+			}
+			return { sources: {} };
+		}
+		getSource(sourceId) {
+			return this.load().sources[sourceId];
+		}
+		saveSource(sourceId, source) {
+			const current = this.load();
+			const next = ModelCatalogSchema.parse({ sources: {
+				...current.sources,
+				[sourceId]: source
+			} });
+			writeTextAtomicSync(this.path, `${JSON.stringify(next, null, 2)}\n`, { mode: 384 });
+		}
+		removeSource(sourceId) {
+			const current = this.load();
+			if (!current.sources[sourceId]) return false;
+			const { [sourceId]: _removed, ...sources } = current.sources;
+			writeTextAtomicSync(this.path, `${JSON.stringify({ sources }, null, 2)}\n`, { mode: 384 });
+			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
+			};
+		}
+	};
+}));
+//#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,41 @@
+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 { XopcCloudConnectionService } from './xopc-cloud-connection.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?: XopcCloudConnectionService;
+        getConfig?: () => Config;
+        catalogStore?: ModelCatalogStore;
+        loadProviders?: () => ModelsJsonConfig['providers'];
+        discoverModels?: typeof discoverProviderModels;
+        refreshModels?: () => void;
+        getModelCount?: () => number;
+    });
+    start(): void;
+    stop(): void;
+    getStatus(): ModelCatalogSyncStatus;
+    getXopcCloudConnection(): XopcCloudConnectionService;
+    refreshNow(): Promise<Awaited<ReturnType<XopcCloudConnectionService['refreshCatalog']>>>;
+    refreshAll(): Promise<{
+        updatedSources: string[];
+    }>;
+    private refreshAllSources;
+}

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

@@ -0,0 +1,142 @@
+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 { XopcCloudConnectionService } from "./xopc-cloud-connection.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 XopcCloudConnectionService();
+		try {
+			const lastSuccessAt = getModelCatalogStore().getSource("xopc-cloud")?.lastSuccessAt;
+			if (lastSuccessAt !== void 0) this.status.lastSuccessAt = lastSuccessAt;
+		} catch {}
+	}
+	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 };
+	}
+	getXopcCloudConnection() {
+		return this.xopcCloud;
+	}
+	refreshNow() {
+		if (this.refreshPromise) return this.refreshPromise;
+		this.status.refreshing = true;
+		this.status.lastAttemptAt = Date.now();
+		this.refreshPromise = this.xopcCloud.refreshCatalog().then((result) => {
+			if (result.status === "updated") {
+				this.status.lastSuccessAt = Date.now();
+				this.status.lastError = void 0;
+				this.options.onUpdated?.(result.modelCount ?? 0);
+			} else if (result.status === "unchanged") {
+				this.status.lastSuccessAt = Date.now();
+				this.status.lastError = void 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
 		*/
@@ -282,6 +313,7 @@ var init_model_registry = __esmMin((() => {
 				const modelOverrides = /* @__PURE__ */ new Map();
 				const apiKeyConfigs = /* @__PURE__ */ new Map();
 				for (const [providerName, providerConfig] of Object.entries(config.providers)) {
+					if (providerName === "xopc-cloud") continue;
 					if (providerConfig.baseUrl || providerConfig.headers || providerConfig.apiKey) overrides.set(providerName, {
 						baseUrl: providerConfig.baseUrl,
 						headers: providerConfig.headers,
@@ -309,6 +341,7 @@ var init_model_registry = __esmMin((() => {
 			const models = [];
 			const defaults = getDefaultModelValues();
 			for (const [providerName, providerConfig] of Object.entries(config.providers)) {
+				if (providerName === "xopc-cloud") continue;
 				const modelDefs = providerConfig.models ?? [];
 				if (modelDefs.length === 0) continue;
 				for (const modelDef of modelDefs) {

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-connection.d.ts

@@ -0,0 +1,51 @@
+import { type CredentialResolver } from '../auth/credentials.js';
+import { type ModelCatalogStore } from './model-catalog-store.js';
+export interface XopcCloudConnectionOptions {
+    fetchImpl?: typeof fetch;
+    consoleUrl?: string;
+    routerUrl?: string;
+    deviceIdPath?: string;
+    catalogStore?: ModelCatalogStore;
+    credentials?: Pick<CredentialResolver, 'saveApiKey' | 'revealGatewayStoredApiKey' | 'deleteProfile'>;
+    refreshModels?: () => void;
+    now?: () => number;
+}
+export type XopcCloudPollResult = {
+    status: 'pending';
+} | {
+    status: 'connected';
+    modelCount: number;
+    models: string[];
+    recommendedModel: string | null;
+};
+export declare class XopcCloudHttpError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    constructor(message: string, status: number, code?: string);
+}
+export declare class XopcCloudConnectionService {
+    private readonly pending;
+    private readonly fetchImpl;
+    private readonly consoleUrl;
+    private readonly routerUrl;
+    private readonly deviceIdPath;
+    private readonly catalogStore;
+    private readonly credentials;
+    private readonly refreshModels;
+    private readonly now;
+    constructor(options?: XopcCloudConnectionOptions);
+    start(clientType: 'electron' | 'web' | 'cli'): Promise<{
+        requestId: string;
+        authorizationUrl: string;
+        expiresIn: number;
+        pollInterval: number;
+    }>;
+    poll(requestId: string): Promise<XopcCloudPollResult>;
+    refreshCatalog(): Promise<{
+        status: 'disconnected' | 'unchanged' | 'updated';
+        modelCount?: number;
+    }>;
+    private getOrCreateDeviceId;
+    private fetchCatalog;
+    private install;
+}