@xopcai/xopc 0.0.162 → 0.0.163

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

@@ -4,8 +4,7 @@
  *
  * Resolution order:
  *   1. AuthProfileStore (per-agent / per-profile; noop in Step 1)
- *   2. cfg.providers.<id>.apiKey
- *   3. PROVIDER_ENV_MAP[providerId] env vars (or `<PROVIDER>_API_KEY` fallback)
+ *   2. PROVIDER_ENV_MAP[providerId] env vars (or `<PROVIDER>_API_KEY` fallback)
  *
  * Distinct from `src/providers/index.ts#getApiKeySync` which is keyed to the
  * LLM model registry. Capability providers care only about per-vendor API
@@ -21,7 +20,6 @@ import type { ResolveApiKeyOptions } from './types.js';
  *
  * Resolution order (matches spec §8.4):
  *   1. AuthProfileStore (per-agent profile — may be OAuth)
- *   2. cfg.providers.<id>.apiKey
- *   3. PROVIDER_ENV_MAP[providerId] env vars
+ *   2. PROVIDER_ENV_MAP[providerId] env vars
  */
 export declare function resolveApiKeyForProvider(options: ResolveApiKeyOptions): string | undefined;

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

@@ -6,8 +6,7 @@ import { resolveAuthProfileForProvider } from "./resolve-auth.js";
 *
 * Resolution order:
 *   1. AuthProfileStore (per-agent / per-profile; noop in Step 1)
-*   2. cfg.providers.<id>.apiKey
-*   3. PROVIDER_ENV_MAP[providerId] env vars (or `<PROVIDER>_API_KEY` fallback)
+*   2. PROVIDER_ENV_MAP[providerId] env vars (or `<PROVIDER>_API_KEY` fallback)
 *
 * Distinct from `src/providers/index.ts#getApiKeySync` which is keyed to the
 * LLM model registry. Capability providers care only about per-vendor API
@@ -22,8 +21,7 @@ import { resolveAuthProfileForProvider } from "./resolve-auth.js";
 *
 * Resolution order (matches spec §8.4):
 *   1. AuthProfileStore (per-agent profile — may be OAuth)
-*   2. cfg.providers.<id>.apiKey
-*   3. PROVIDER_ENV_MAP[providerId] env vars
+*   2. PROVIDER_ENV_MAP[providerId] env vars
 */
 function resolveApiKeyForProvider(options) {
 	return resolveAuthProfileForProvider(options).apiKey;

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,8 +30,30 @@ export interface DomesticProviderPreset {
     models: DomesticProviderModelPreset[];
     aliases: string[];
     quirks?: string[];
+    onboardingIcon?: string;
+    requiresModelDiscovery?: boolean;
 }
 export declare const DOMESTIC_PROVIDER_PRESETS: readonly [{
+    readonly id: "xopc-cloud";
+    readonly displayName: "XOPC Model Service";
+    readonly description: "Official XOPC OpenAI-compatible model service. Available models are loaded from your account.";
+    readonly docsUrl: "https://console.xopc.ai/models";
+    readonly apiKeyUrl: "https://console.xopc.ai/models";
+    readonly envVars: ["XOPC_MODEL_API_KEY"];
+    readonly api: "openai-completions";
+    readonly baseUrlPresets: [{
+        readonly id: "official";
+        readonly label: "XOPC Official";
+        readonly baseUrl: "https://router.xopc.ai/v1";
+    }];
+    readonly defaultBaseUrlPreset: "official";
+    readonly defaultModel: "";
+    readonly models: [];
+    readonly aliases: ["xopc", "xopc cloud", "xopc models"];
+    readonly onboardingIcon: "☁️";
+    readonly requiresModelDiscovery: true;
+    readonly quirks: ["Connect through XOPC Console; credentials and available models are configured automatically."];
+}, {
     readonly id: "dashscope-cn";
     readonly displayName: "Alibaba Bailian / DashScope China";
     readonly description: "Alibaba Bailian Qwen models through the China DashScope OpenAI-compatible endpoint.";

package/dist/src/providers/domestic-presets.js

@@ -87,6 +87,31 @@ const MINIMAX_MODELS = [
 	}
 ];
 const DOMESTIC_PROVIDER_PRESETS = [
+	{
+		id: "xopc-cloud",
+		displayName: "XOPC Model Service",
+		description: "Official XOPC OpenAI-compatible model service. Available models are loaded from your account.",
+		docsUrl: "https://console.xopc.ai/models",
+		apiKeyUrl: "https://console.xopc.ai/models",
+		envVars: ["XOPC_MODEL_API_KEY"],
+		api: "openai-completions",
+		baseUrlPresets: [{
+			id: "official",
+			label: "XOPC Official",
+			baseUrl: "https://router.xopc.ai/v1"
+		}],
+		defaultBaseUrlPreset: "official",
+		defaultModel: "",
+		models: [],
+		aliases: [
+			"xopc",
+			"xopc cloud",
+			"xopc models"
+		],
+		onboardingIcon: "☁️",
+		requiresModelDiscovery: true,
+		quirks: ["Connect through XOPC Console; credentials and available models are configured automatically."]
+	},
 	{
 		id: "dashscope-cn",
 		displayName: "Alibaba Bailian / DashScope China",

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
      */