evolcore 0.0.35 → 0.0.37

package/dist/core/message/retry-scheduler.js

@@ -6,16 +6,18 @@ export const API_RETRY_DELAYS_MS = [5_000, 10_000, 30_000];
 export const MAX_PROTOCOL_REPLAY_ATTEMPTS = 1;
 export class RetryScheduler {
     resolveModelId;
+    currentProvider;
     protocolReplayAttempts = 0;
     apiRetryAttempts = 0;
     modelFallbackAttempts = 0;
     attemptedModels = new Set();
     candidates;
-    constructor(candidates, currentModel, resolveModelId = model => model) {
+    constructor(candidates, currentModel, resolveModelId = model => model, currentProvider) {
         this.resolveModelId = resolveModelId;
+        this.currentProvider = currentProvider;
         this.candidates = candidates;
         if (currentModel)
-            this.attemptedModels.add(this.key(currentModel));
+            this.attemptedModels.add(this.key(currentModel, currentProvider));
     }
     get protocolReplays() {
         return this.protocolReplayAttempts;
@@ -26,8 +28,8 @@ export class RetryScheduler {
     shouldTimeoutAttempt() {
         return this.apiRetryAttempts > 0;
     }
-    markModelAttempted(model) {
-        this.attemptedModels.add(this.key(model));
+    markModelAttempted(model, provider = this.currentProvider) {
+        this.attemptedModels.add(this.key(model, provider));
     }
     afterProtocolFailure(reason, safeToReplay) {
         if (!reason || !safeToReplay)
@@ -42,10 +44,10 @@ export class RetryScheduler {
         };
     }
     afterModelUnavailable() {
-        const candidate = this.candidates.find(item => !this.attemptedModels.has(this.key(item.model)));
+        const candidate = this.candidates.find(item => !this.attemptedModels.has(this.key(item.model, item.provider ?? this.currentProvider)));
         if (!candidate)
             return { kind: 'exhausted' };
-        this.attemptedModels.add(this.key(candidate.model));
+        this.attemptedModels.add(this.key(candidate.model, candidate.provider ?? this.currentProvider));
         this.modelFallbackAttempts++;
         this.apiRetryAttempts = 0;
         return {
@@ -65,7 +67,8 @@ export class RetryScheduler {
         this.apiRetryAttempts++;
         return { kind: 'api_retry', attempt, maxAttempts: API_RETRY_DELAYS_MS.length, delayMs };
     }
-    key(model) {
-        return this.resolveModelId(model).trim().toLowerCase();
+    key(model, provider) {
+        const resolved = provider === this.currentProvider ? this.resolveModelId(model) : model;
+        return `${provider ?? '<legacy>'}:${resolved.trim().toLowerCase()}`;
     }
 }

package/dist/core/model/catalog-service.js

@@ -14,8 +14,9 @@ export const CATALOG_ROUTE_TIMEOUT_MS = 15_000;
  * v2：保留上下文窗口后缀（`claude-opus-5[1m]` 不再被折叠成基础 ID）。
  * v3：保留 Codex 上游声明的 max effort，重新获取旧快照中过滤掉的能力。
  * v4：统一缺失 effort 元数据时的 transport fallback，并记录来源。
+ * v5：持久化 provider 原始目录，避免相同 provider/path 的不同服务风格相互污染。
  */
-export const CATALOG_SNAPSHOT_VERSION = 4;
+export const CATALOG_SNAPSHOT_VERSION = 6;
 export const CONFIGURABLE_EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max'];
 export const TRANSPORT_EFFORTS = {
     claude: ['low', 'medium', 'high', 'xhigh', 'max'],
@@ -36,10 +37,18 @@ function stable(value) {
 export const catalogHash = (value) => createHash('sha256').update(stable(value)).digest('hex');
 export function catalogContextKey(context) {
     const headers = Object.fromEntries(Object.entries(context.headers ?? {}).map(([k, v]) => [k.toLowerCase(), v]));
+    if (context.providerId)
+        return catalogHash({ providerId: context.providerId, baseUrl: context.baseUrl?.replace(/\/+$/, ''),
+            apiKey: context.apiKey, headers, queryParams: context.queryParams ?? {}, configUnavailable: context.configUnavailable });
     return catalogHash({ scope: context.scope, baseagent: context.baseagent, provider: context.provider,
         baseUrl: context.baseUrl?.replace(/\/+$/, ''), apiKey: context.apiKey, authType: context.authType,
         headers, queryParams: context.queryParams ?? {}, configUnavailable: context.configUnavailable });
 }
+export function catalogStorageKey(context) {
+    if (context.providerId)
+        return catalogHash({ providerId: context.providerId, path: context.catalogPath ?? context.baseUrl?.replace(/\?.*$/u, '') ?? '' });
+    return catalogContextKey(context);
+}
 const strings = (value) => Array.isArray(value)
     ? [...new Set(value.filter((v) => typeof v === 'string' && !!v.trim()).map(v => v.trim()))] : undefined;
 function rows(json) {
@@ -73,7 +82,9 @@ export function parseModelList(json, _url) {
                 id, verification: 'listed',
                 ...(typeof owner === 'string' ? { owned_by: owner } : {}),
                 ...(typeof item?.created === 'number' ? { created: item.created } : {}),
-                ...(typeof (item?.displayName ?? item?.display_name) === 'string' ? { displayName: item.displayName ?? item.display_name } : {}),
+                ...(typeof (item?.name ?? item?.displayName ?? item?.display_name) === 'string'
+                    ? { displayName: item.name ?? item.displayName ?? item.display_name } : {}),
+                ...(typeof (item?.imageIn ?? item?.image_in) === 'boolean' ? { imageIn: item.imageIn ?? item.image_in } : {}),
                 ...(levels ? { reasoningLevels: levels } : {}),
                 ...(typeof (item?.defaultReasoningEffort ?? item?.default_reasoning_level) === 'string' ? { defaultReasoningLevel: item.defaultReasoningEffort ?? item.default_reasoning_level } : {}),
                 ...(strings(item?.protocols ?? item?.supported_protocols) ? { protocols: strings(item.protocols ?? item.supported_protocols) } : {}),
@@ -127,7 +138,9 @@ function compatible(model, baseagent) {
     const protocols = { claude: ['anthropic', 'anthropic-messages', 'messages'], codex: ['openai-responses', 'responses'], ecagent: ['openai', 'openai-completions', 'openai-chat-completions', 'chat-completions'] };
     return !model.protocols || !protocols[baseagent] || model.protocols.some(p => protocols[baseagent].includes(p));
 }
-function adapt(models, baseagent) {
+export function adaptCatalogModels(models, baseagent) {
+    if (!baseagent)
+        return models;
     const available = models.filter(m => compatible(m, baseagent)).map(m => {
         const reasoningLevels = configurableEfforts(baseagent, m.reasoningLevels);
         const effortSource = reasoningLevels.length === 0 ? 'none'
@@ -137,6 +150,22 @@ function adapt(models, baseagent) {
     const aliases = deriveAliases(available, baseagent);
     return [...Object.entries(aliases).filter(([id]) => !available.some(m => m.id === id)).map(([id, aliasFor]) => ({ ...available.find(m => m.id === aliasFor), id, aliasFor, owned_by: 'alias' })), ...available];
 }
+/** Text services do not require Agent tools or aliases; only adapt effort metadata. */
+export function adaptServiceCatalogModels(models, serviceType, style) {
+    if (serviceType !== 'text')
+        return models;
+    const transports = {
+        'openai-compatible': 'ecagent',
+        claude: 'claude', anthropic: 'claude',
+        codex: 'codex', 'openai-responses': 'codex',
+    };
+    return models.map(model => {
+        const reasoningLevels = configurableEfforts(transports[style] ?? '', model.reasoningLevels);
+        const effortSource = !reasoningLevels.length ? 'none'
+            : model.reasoningLevels === undefined ? 'transport-fallback' : 'catalog';
+        return { ...model, reasoningLevels, effortSource };
+    });
+}
 export function resolveCatalogModel(snapshot, model) { return snapshot.models.find(m => m.id === model)?.aliasFor ?? model; }
 export function catalogEfforts(snapshot, model, baseagent) {
     const entry = snapshot.models.find(m => m.id === resolveCatalogModel(snapshot, model));
@@ -154,7 +183,11 @@ class GatewayError extends Error {
     }
 }
 async function gatewayModels(context, fetcher) {
-    const urls = [...new Set([appendV1RequestPath(context.baseUrl, 'models', context.queryParams), appendRequestPath(context.baseUrl, 'models', context.queryParams)])];
+    const configuredStyle = context.style ?? context.baseagent;
+    const style = configuredStyle === 'anthropic' ? 'claude' : configuredStyle === 'openai-responses' ? 'codex' : configuredStyle;
+    const urls = [...new Set(style === 'gemini' || context.providerId
+            ? [appendRequestPath(context.baseUrl, 'models', context.queryParams)]
+            : [appendV1RequestPath(context.baseUrl, 'models', context.queryParams), appendRequestPath(context.baseUrl, 'models', context.queryParams)])];
     let last;
     for (const url of urls) {
         try {
@@ -173,27 +206,29 @@ async function gatewayModels(context, fetcher) {
                     throw new GatewayError();
                 const signal = AbortSignal.timeout(Math.min(CATALOG_PAGE_TIMEOUT_MS, remaining));
                 const headers = new Headers(context.headers);
-                if (context.apiKey && !headers.has('authorization')) {
+                if (context.apiKey && style !== 'gemini' && !headers.has('authorization')) {
                     headers.set('authorization', `Bearer ${context.apiKey}`);
                 }
-                if (context.apiKey && context.baseagent === 'claude' && !headers.has('x-api-key')) {
+                if (context.apiKey && style === 'gemini' && !headers.has('x-goog-api-key'))
+                    headers.set('x-goog-api-key', context.apiKey);
+                if (context.apiKey && style === 'claude' && !headers.has('x-api-key')) {
                     headers.set('x-api-key', context.apiKey);
                 }
-                if (context.baseagent === 'claude' && !headers.has('anthropic-version'))
+                if (style === 'claude' && !headers.has('anthropic-version'))
                     headers.set('anthropic-version', '2023-06-01');
                 const response = await fetcher(next, { signal, headers, redirect: 'error' });
                 if (!response.ok)
                     throw new GatewayError(response.status);
                 const json = await response.json();
-                models.push(...parseModelList(json));
-                const cursor = json?.nextCursor ?? json?.next_cursor ?? (json?.has_more ? json?.last_id : undefined);
+                models.push(...parseModelList(json).map(model => style === 'gemini' ? { ...model, id: model.id.replace(/^models\//u, '') } : model));
+                const cursor = json?.nextPageToken ?? json?.nextCursor ?? json?.next_cursor ?? (json?.has_more ? json?.last_id : undefined);
                 if (!cursor) {
                     if (json?.has_more)
                         throw new GatewayError();
                     return [...new Map(models.map(m => [m.id, m])).values()];
                 }
                 const parsed = new URL(url);
-                parsed.searchParams.set(json?.has_more && !json?.nextCursor && !json?.next_cursor ? 'after_id' : 'cursor', String(cursor));
+                parsed.searchParams.set(json?.nextPageToken ? 'pageToken' : json?.has_more && !json?.nextCursor && !json?.next_cursor ? 'after_id' : 'cursor', String(cursor));
                 next = parsed.toString();
             }
             throw new GatewayError();
@@ -216,8 +251,8 @@ export class ModelCatalogService {
         this.options = options;
     }
     now() { return (this.options.now ?? Date.now)(); }
-    key(context) { return `${this.options.storageDir?.() ?? ''}:${catalogContextKey(context)}`; }
-    file(context) { const dir = this.options.storageDir?.(); return dir ? path.join(dir, `${catalogContextKey(context)}.json`) : undefined; }
+    key(context) { return `${this.options.storageDir?.() ?? ''}:${catalogStorageKey(context)}`; }
+    file(context) { const dir = this.options.storageDir?.(); return dir ? path.join(dir, `${catalogStorageKey(context)}.json`) : undefined; }
     previous(context) {
         const key = this.key(context);
         let snapshot = this.successes.get(key);
@@ -236,7 +271,10 @@ export class ModelCatalogService {
         return snapshot;
     }
     peek(context) {
-        return structuredClone(this.latest.get(this.key(context)) ?? this.previous(context) ?? this.make(context, 'builtin', 'fallback', this.legacyBuiltins(context), [{ code: 'BUILTIN', message: '内置候选，未经当前连接验证' }]));
+        const fallback = context.providerId
+            ? this.make(context, 'gateway', 'fallback', [], [{ code: 'GATEWAY_UNAVAILABLE', message: '当前服务商尚无成功模型目录' }])
+            : this.make(context, 'builtin', 'fallback', this.legacyBuiltins(context), [{ code: 'BUILTIN', message: '内置候选，未经当前连接验证' }]);
+        return this.present(structuredClone(this.latest.get(this.key(context)) ?? this.previous(context) ?? fallback), context);
     }
     async get(context, refresh = false) {
         const key = this.key(context);
@@ -257,18 +295,20 @@ export class ModelCatalogService {
             // while each read also asks the shared background job to refresh it.
             // Explicit refresh callers still await that same in-flight request.
             void pending.catch(() => undefined);
-            return structuredClone(previous);
+            return this.present(structuredClone(previous), context);
         }
-        return structuredClone(await pending);
+        return this.present(structuredClone(await pending), context);
     }
     clear() { this.latest.clear(); this.successes.clear(); }
     make(context, source, freshness, models, diagnostics) {
-        const entries = adapt(models, context.baseagent);
         const fetchedAt = new Date(this.now()).toISOString();
         // A revision identifies the connection's model/capability set.  Fetch time
         // belongs to freshness metadata and must not make an unchanged catalog
         // look like a different resource on every refresh.
-        return { revision: catalogHash({ connection: catalogContextKey(context), source, entries }), source, freshness, fetchedAt, models: entries, diagnostics };
+        return { revision: catalogHash({ connection: catalogContextKey(context), source, models }), source, freshness, fetchedAt, models, diagnostics };
+    }
+    present(snapshot, context) {
+        return { ...snapshot, models: adaptCatalogModels(snapshot.models, context.baseagent) };
     }
     save(context, snapshot) {
         this.successes.set(this.key(context), snapshot);
@@ -306,7 +346,7 @@ export class ModelCatalogService {
             try {
                 const models = await gatewayModels(context, this.options.fetch ?? fetch);
                 // Enrich only IDs the gateway listed. Native models never add/remove membership.
-                const native = context.baseagent === 'codex' && models.length ? await this.options.native?.(context).catch(() => null) : null;
+                const native = !context.providerId && context.baseagent === 'codex' && models.length ? await this.options.native?.(context).catch(() => null) : null;
                 const metadata = new Map((native ?? []).map(m => [m.id, m]));
                 const enriched = models.map(m => ({ ...m, ...(m.reasoningLevels === undefined && metadata.get(m.id)?.reasoningLevels !== undefined ? { reasoningLevels: metadata.get(m.id).reasoningLevels } : {}) }));
                 const result = this.make(context, 'gateway', 'fresh', enriched, diagnostics);
@@ -325,6 +365,8 @@ export class ModelCatalogService {
         }
         if (previous)
             return { ...previous, freshness: 'stale', diagnostics: [...diagnostics, { code: 'STALE_CACHE', message: '使用同一连接的最近成功目录' }] };
+        if (context.providerId)
+            return this.make(context, 'gateway', 'fallback', [], diagnostics);
         if (!context.configUnavailable && this.options.native) {
             try {
                 const native = await this.options.native(context);

package/dist/core/model/model-catalog.js

@@ -11,13 +11,14 @@ import { loadDefaults } from '../../config-store.js';
 import net from 'node:net';
 import fs from 'node:fs';
 import { getWindowsInstanceSocketPathCandidates, resolvePaths } from '../../paths.js';
-import { ModelCatalogService, catalogEfforts, resolveCatalogModel } from './catalog-service.js';
+import { ModelCatalogService, adaptCatalogModels, adaptServiceCatalogModels, catalogEfforts, catalogHash, resolveCatalogModel } from './catalog-service.js';
+import { providerIsConfigured, providerServiceTypeForBaseagent, providerServiceTypesForBaseagent, resolveProviderService, resolveProviderServiceForBaseagent } from '../../config/providers.js';
 export * from './catalog-service.js';
 let daemonOwner = false;
 export function setModelCatalogDaemonOwner(value) { daemonOwner = value; }
 /** Only a refused/missing socket means offline. A busy/rejecting daemon must
  * never cause another process to create an independent online catalog. */
-export async function queryDaemonCatalog(self, baseagent, refresh = false) {
+export async function queryDaemonCatalog(self, baseagent, refresh = false, selection) {
     const paths = resolvePaths();
     let controlToken;
     try {
@@ -41,7 +42,7 @@ export async function queryDaemonCatalog(self, baseagent, refresh = false) {
                     resolve(value);
             };
             connection.setTimeout(25_000, () => finish(new Error('模型目录 daemon 查询超时')));
-            connection.on('connect', () => connection.write(JSON.stringify({ type: 'model.catalog', self, baseagent, refresh, controlToken }) + '\n'));
+            connection.on('connect', () => connection.write(JSON.stringify({ type: 'model.catalog', self, baseagent, refresh, ...selection, controlToken }) + '\n'));
             connection.on('error', (error) => {
                 if (error.code === 'ENOENT' || error.code === 'ECONNREFUSED')
                     finish();
@@ -77,12 +78,72 @@ const service = new ModelCatalogService({
     legacyAliasFile: () => resolvePaths().claudeModelCache,
     native: async (context) => (await import('../../agents/codex/catalog.js')).codexNativeCatalog(context),
 });
+const HOST_BASEAGENTS = ['claude', 'codex', 'ecagent', 'gemini'];
+function resolveProviderCatalogBaseagent(serviceType, requested) {
+    const baseagent = requested ?? (['claude', 'codex', 'gemini'].includes(serviceType) ? serviceType : '');
+    if (baseagent && (!HOST_BASEAGENTS.includes(baseagent)
+        || !providerServiceTypesForBaseagent(baseagent).includes(serviceType))) {
+        throw new Error(`Baseagent ${baseagent} is incompatible with provider service ${serviceType}`);
+    }
+    return baseagent;
+}
+export async function getProviderCatalog(providerId, serviceType, refresh = false, management = false, requestedBaseagent) {
+    const selected = requestedBaseagent
+        ? resolveProviderServiceForBaseagent(providerId, requestedBaseagent, serviceType)
+        : resolveProviderService(providerId, serviceType);
+    const effectiveServiceType = selected.serviceType;
+    const baseagent = resolveProviderCatalogBaseagent(effectiveServiceType, requestedBaseagent);
+    const present = (snapshot) => {
+        if (management)
+            return snapshot;
+        const overridden = applyProviderModelOverrides(snapshot, selected.modelOverrides);
+        return { ...overridden, models: baseagent
+                ? adaptCatalogModels(overridden.models, baseagent)
+                : adaptServiceCatalogModels(overridden.models, effectiveServiceType, selected.style) };
+    };
+    if (!daemonOwner) {
+        const snapshot = await queryDaemonCatalog(undefined, undefined, refresh, { providerId, serviceType: effectiveServiceType });
+        if (snapshot)
+            return present(snapshot);
+    }
+    const provider = selected;
+    const snapshot = await service.get({ ...provider, scope: '<providers>', baseagent: '' }, refresh);
+    return present(snapshot);
+}
+export async function getLocalProviderCatalog(providerId, serviceType, refresh = false) {
+    const provider = resolveProviderService(providerId, serviceType);
+    return service.get({ ...provider, scope: '<providers>', baseagent: '' }, refresh);
+}
+export function previewProviderCatalog(provider, requestedBaseagent) {
+    const baseagent = resolveProviderCatalogBaseagent(provider.serviceType, requestedBaseagent);
+    return new ModelCatalogService().get({ ...provider, scope: '<provider-preview>', baseagent: '' }, true)
+        .then(snapshot => ({ ...snapshot, models: baseagent
+            ? adaptCatalogModels(snapshot.models, baseagent)
+            : adaptServiceCatalogModels(snapshot.models, provider.serviceType, provider.style) }));
+}
 export function resolveCatalogContext(self, ba) {
     const baseagent = ba || activeBaseagent(self);
     const context = { scope: self || '<defaults>', baseagent };
+    const config = self ? resolveEffective({ self }, { cache: true, expand: true }) : { baseagents: loadDefaults()?.baseagents ?? {} };
+    const block = (config.baseagents ?? {});
+    const selected = block[baseagent];
+    if (providerIsConfigured(selected)) {
+        const provider = resolveProviderServiceForBaseagent(selected.provider, baseagent, selected.providerServiceType);
+        Object.assign(context, {
+            provider: provider.providerId,
+            providerId: provider.providerId,
+            providerServiceType: provider.serviceType,
+            catalogPath: provider.catalogPath,
+            style: provider.style,
+            baseUrl: provider.baseUrl,
+            apiKey: provider.apiKey,
+            headers: provider.headers,
+            queryParams: provider.queryParams,
+            modelOverrides: provider.modelOverrides,
+        });
+        return context;
+    }
     try {
-        const config = self ? resolveEffective({ self }, { cache: true, expand: true }) : { baseagents: loadDefaults()?.baseagents ?? {} };
-        const block = (config.baseagents ?? {});
         const cfg = { agents: block };
         const resolved = baseagent === 'codex' ? resolveOpenaiConfig(cfg, block.codex)
             : baseagent === 'claude' ? resolveAnthropicConfig(cfg, block.claude)
@@ -106,7 +167,6 @@ export function resolveCatalogContext(self, ba) {
     }
     return context;
 }
-const HOST_BASEAGENTS = ['claude', 'codex', 'ecagent', 'gemini'];
 /** Query the catalog for a host-level default connection, without Agent scope. */
 export async function getBaseagentCatalog(baseagent, options = {}) {
     if (!HOST_BASEAGENTS.includes(baseagent)) {
@@ -118,7 +178,8 @@ export async function getBaseagentCatalog(baseagent, options = {}) {
 }
 /** Used by the IPC handler and the owner process. Never calls IPC recursively. */
 export async function getLocalCatalog(self, ba, refresh = false) {
-    return service.get(resolveCatalogContext(self, ba), refresh);
+    const context = resolveCatalogContext(self, ba);
+    return applyProviderModelOverrides(await service.get(context, refresh), context.modelOverrides);
 }
 export async function getCatalog(self, ba, refresh = false) {
     if (!daemonOwner) {
@@ -132,16 +193,58 @@ export async function getCatalog(self, ba, refresh = false) {
 export function getRunnerCatalog(baseagent, self, connection) {
     if (self)
         return getCatalog(self, baseagent);
-    return service.get({ ...connection, scope: '<defaults>', baseagent });
+    if (connection.providerId !== undefined) {
+        return getProviderCatalog(connection.providerId, connection.providerServiceType ?? providerServiceTypeForBaseagent(baseagent), false, false, baseagent);
+    }
+    const context = { ...connection, scope: '<defaults>', baseagent };
+    return service.get(context).then(snapshot => applyProviderModelOverrides(snapshot, context.modelOverrides));
 }
 export function peekRunnerCatalog(baseagent, self, connection) {
-    return service.peek(self ? resolveCatalogContext(self, baseagent) : { ...connection, scope: '<defaults>', baseagent });
+    const context = self ? resolveCatalogContext(self, baseagent) : {
+        ...(connection.providerId !== undefined ? resolveProviderServiceForBaseagent(connection.providerId, baseagent, connection.providerServiceType) : connection), scope: '<defaults>', baseagent,
+    };
+    return applyProviderModelOverrides(service.peek(context), context.modelOverrides);
 }
 export async function getModelEfforts(model, self, ba) {
     const baseagent = ba || activeBaseagent(self);
     return catalogEfforts(await getCatalog(self, baseagent), model, baseagent);
 }
 export function clearModelCatalogCache() { service.clear(); }
+export function applyProviderModelOverrides(snapshot, overrides) {
+    if (!overrides || Object.keys(overrides).length === 0)
+        return snapshot;
+    const disabled = new Set(Object.entries(overrides)
+        .filter(([, value]) => value.enabled === false)
+        .map(([modelId]) => modelId));
+    const listed = new Set(snapshot.models.map(model => model.id));
+    const manualModels = Object.entries(overrides)
+        .filter(([id, override]) => override.manual === true && !listed.has(id) && override.enabled !== false)
+        .map(([id, override]) => ({
+        id,
+        verification: 'unverified',
+        manual: true,
+        ...(typeof override.name === 'string' && override.name ? { displayName: override.name } : {}),
+        ...(typeof override.imageIn === 'boolean' ? { imageIn: override.imageIn } : {}),
+    }));
+    const models = [...snapshot.models, ...manualModels]
+        .filter(model => !disabled.has(model.aliasFor ?? model.id))
+        .map(model => {
+        const override = overrides[model.aliasFor ?? model.id];
+        if (!override)
+            return model;
+        const result = { ...model };
+        if (override.name === '')
+            delete result.displayName;
+        else if (typeof override.name === 'string')
+            result.displayName = override.name;
+        if (typeof override.imageIn === 'boolean')
+            result.imageIn = override.imageIn;
+        if (override.manual === true)
+            result.manual = true;
+        return result;
+    });
+    return { ...snapshot, revision: catalogHash({ revision: snapshot.revision, models }), models };
+}
 export function modelMatches(agent, candidate, current) {
     if (!current)
         return false;

package/dist/core/model/model-fallback.js

@@ -1,5 +1,6 @@
-import { catalogEfforts, getCatalog, resolveCatalogModel } from './model-catalog.js';
-import { ConfigTarget, read } from '../../config/config-manager.js';
+import { catalogEfforts, getCatalog, getProviderCatalog, resolveCatalogModel } from './model-catalog.js';
+import { ConfigTarget, read, resolveEffective } from '../../config/config-manager.js';
+import { providerServiceTypeForBaseagent, providerServiceTypeForPurpose, resolveServiceSelection } from '../../config/providers.js';
 export const MAX_FALLBACK_MODELS = 3;
 function isRecord(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value);
@@ -7,21 +8,22 @@ function isRecord(value) {
 function normalizeCandidate(value) {
     if (!isRecord(value) || typeof value.model !== 'string')
         return undefined;
+    if (Object.keys(value).some(key => !['provider', 'model', 'effort'].includes(key)))
+        return undefined;
+    if (value.provider !== undefined && (typeof value.provider !== 'string' || !value.provider.trim()))
+        return undefined;
     const model = value.model.trim();
     if (!model)
         return undefined;
     if (value.effort !== undefined && (typeof value.effort !== 'string' || !value.effort.trim()))
         return undefined;
     return {
+        ...(typeof value.provider === 'string' ? { provider: value.provider.trim() } : {}),
         model,
         ...(typeof value.effort === 'string' ? { effort: value.effort.trim() } : {}),
     };
 }
-/** Read only defaults.json: fallback policy must not participate in H-chain merging. */
-export function configuredFallbackModels(baseagent) {
-    const defaults = read(ConfigTarget.Defaults, undefined, { cache: true });
-    const block = isRecord(defaults?.baseagents) ? defaults.baseagents[baseagent] : undefined;
-    const raw = isRecord(block) ? block.fallbackModels : undefined;
+function configuredFallbacks(raw) {
     if (!Array.isArray(raw))
         return { candidates: [], rejected: [] };
     const candidates = [];
@@ -40,35 +42,101 @@ export function configuredFallbackModels(baseagent) {
     }
     return { candidates, rejected };
 }
-export async function eligibleFallbackModels(input) {
-    const configured = configuredFallbackModels(input.baseagent);
+export function configuredFallbackModels(baseagent) {
+    const defaults = read(ConfigTarget.Defaults, undefined, { cache: true });
+    const block = isRecord(defaults?.baseagents) ? defaults.baseagents[baseagent] : undefined;
+    return configuredFallbacks(isRecord(block) ? block.fallback : undefined);
+}
+async function eligibleCandidates(input) {
     const candidates = [];
-    const rejected = [...configured.rejected];
-    if (!configured.candidates.length)
+    const rejected = [...input.configured.rejected];
+    if (!input.configured.candidates.length)
         return { candidates, rejected };
-    const catalog = await (input.catalog?.() ?? getCatalog(input.selfAid, input.baseagent));
-    const resolve = (model) => resolveCatalogModel(catalog, model);
-    const key = (model) => resolve(model).trim();
-    const seen = new Set();
-    if (input.currentModel)
-        seen.add(key(input.currentModel));
-    for (const candidate of configured.candidates) {
-        const resolvedModel = resolve(candidate.model);
-        const candidateKey = key(candidate.model);
-        if (seen.has(candidateKey)) {
-            rejected.push({ model: candidate.model, reason: candidateKey === key(input.currentModel ?? '') ? 'current_model' : 'duplicate' });
+    const catalogs = new Map();
+    const loadCatalog = (provider) => {
+        const key = provider ?? '<legacy>';
+        if (!catalogs.has(key)) {
+            const serviceType = provider
+                ? input.catalogProviderServiceType ?? (input.catalogBaseagent
+                    ? providerServiceTypeForBaseagent(input.catalogBaseagent)
+                    : input.serviceType)
+                : input.serviceType;
+            catalogs.set(key, provider
+                ? getProviderCatalog(provider, serviceType, false, false, input.catalogBaseagent)
+                : input.catalog?.() ?? getCatalog(input.selfAid, input.serviceType));
+        }
+        return catalogs.get(key);
+    };
+    const identity = (provider, model) => `${provider ?? '<legacy>'}:${model.trim().toLowerCase()}`;
+    let primaryIdentity = input.currentModel ? identity(input.currentProvider, input.currentModel) : undefined;
+    if (input.currentModel) {
+        try {
+            const primaryCatalog = await loadCatalog(input.currentProvider);
+            primaryIdentity = identity(input.currentProvider, resolveCatalogModel(primaryCatalog, input.currentModel));
+        }
+        catch { }
+    }
+    const seen = new Set(primaryIdentity ? [primaryIdentity] : []);
+    for (const candidate of input.configured.candidates) {
+        const provider = candidate.provider ?? input.currentProvider;
+        let catalog;
+        try {
+            catalog = await loadCatalog(provider);
+        }
+        catch {
+            rejected.push({ model: candidate.model, reason: 'not_allowed' });
             continue;
         }
-        if (!input.isAllowed(resolvedModel)) {
+        const resolvedModel = resolveCatalogModel(catalog, candidate.model);
+        const key = identity(provider, resolvedModel);
+        if (seen.has(key)) {
+            rejected.push({ model: candidate.model, reason: key === primaryIdentity ? 'current_model' : 'duplicate' });
+            continue;
+        }
+        const listed = catalog.models.some(entry => entry.id === candidate.model
+            || entry.id === resolvedModel
+            || entry.aliasFor === candidate.model
+            || entry.aliasFor === resolvedModel);
+        if (!listed || !input.isAllowed(resolvedModel)) {
             rejected.push({ model: candidate.model, reason: 'not_allowed' });
             continue;
         }
-        if (candidate.effort && !catalogEfforts(catalog, resolvedModel, input.baseagent).includes(candidate.effort)) {
+        const efforts = input.serviceType === 'text'
+            ? catalog.models.find(entry => entry.id === resolvedModel)?.reasoningLevels ?? []
+            : catalogEfforts(catalog, resolvedModel, input.serviceType);
+        if (candidate.effort && !efforts.includes(candidate.effort)) {
             rejected.push({ model: candidate.model, reason: 'unsupported_effort' });
             continue;
         }
-        seen.add(candidateKey);
-        candidates.push({ ...candidate, model: resolvedModel });
+        seen.add(key);
+        candidates.push({ ...candidate, ...(provider ? { provider } : {}), model: resolvedModel });
     }
     return { candidates, rejected };
 }
+export async function eligibleFallbackModels(input) {
+    const effective = input.selfAid
+        ? resolveEffective({ self: input.selfAid }, { cache: true, expand: true })
+        : read(ConfigTarget.Defaults, undefined, { cache: true });
+    const selection = effective?.baseagents?.[input.baseagent];
+    return eligibleCandidates({
+        ...input,
+        configured: configuredFallbackModels(input.baseagent),
+        serviceType: input.baseagent,
+        catalogBaseagent: input.baseagent,
+        catalogProviderServiceType: selection?.providerServiceType,
+    });
+}
+export async function eligibleServiceFallbackModels(input) {
+    const selection = input.selections?.[input.purpose];
+    const primary = resolveServiceSelection(input.selections, input.purpose);
+    if (!selection || !primary)
+        return { candidates: [], rejected: [] };
+    return eligibleCandidates({
+        configured: configuredFallbacks(selection.fallback),
+        selfAid: input.selfAid,
+        serviceType: providerServiceTypeForPurpose(input.purpose),
+        currentModel: primary.model,
+        currentProvider: primary.providerId,
+        isAllowed: () => true,
+    });
+}