evolcore 0.0.21 → 0.0.23

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

@@ -0,0 +1,308 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { appendRequestPath, appendV1RequestPath } from '../../agents/request-identity.js';
+import { atomicReadJson, atomicWriteJson } from '../../utils/atomic-write.js';
+export const CATALOG_TTL_MS = 5 * 60_000;
+export const CATALOG_STALE_MS = 24 * 60 * 60_000;
+export const TRANSPORT_EFFORTS = {
+    claude: ['low', 'medium', 'high', 'xhigh', 'max'],
+    codex: ['none', 'minimal', 'low', 'medium', 'high', 'xhigh'],
+    ecagent: ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'],
+    gemini: [],
+};
+function stable(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stable).join(',')}]`;
+    if (value && typeof value === 'object')
+        return `{${Object.entries(value).filter(([, v]) => v !== undefined).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${stable(v)}`).join(',')}}`;
+    return JSON.stringify(value) ?? 'null';
+}
+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]));
+    return catalogHash({ scope: context.scope, baseagent: context.baseagent, provider: context.provider,
+        baseUrl: context.baseUrl?.replace(/\/+$/, ''), apiKey: context.apiKey,
+        headers, queryParams: context.queryParams ?? {}, configUnavailable: context.configUnavailable });
+}
+const strings = (value) => Array.isArray(value)
+    ? [...new Set(value.filter((v) => typeof v === 'string' && !!v.trim()).map(v => v.trim()))] : undefined;
+function rows(json) {
+    if (Array.isArray(json))
+        return json;
+    for (const candidate of [json?.data, json?.models, json?.data?.models])
+        if (Array.isArray(candidate))
+            return candidate;
+    throw new Error('Unrecognized model list response');
+}
+/** Normalize documented list containers; an empty array is a successful catalog. */
+export function parseModelList(json, _url) {
+    const out = new Map();
+    const items = rows(json);
+    for (const item of items) {
+        const rawId = typeof item === 'string' ? item : item?.id ?? item?.slug ?? item?.name ?? item?.model;
+        if (typeof rawId !== 'string' || !rawId.trim())
+            continue;
+        const id = rawId.trim();
+        if (out.has(id))
+            continue;
+        const rawLevels = item?.reasoningLevels ?? item?.supportedReasoningEfforts ?? item?.supported_reasoning_levels;
+        const levels = Array.isArray(rawLevels) ? strings(rawLevels.map(v => typeof v === 'string' ? v : v?.reasoningEffort ?? v?.effort)) : undefined;
+        const owner = item?.owned_by ?? item?.owner ?? item?.provider;
+        out.set(id, {
+            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 } : {}),
+            ...(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) } : {}),
+            ...(typeof item?.capabilities?.tool_calling === 'boolean' ? { supportsTools: item.capabilities.tool_calling } : {}),
+            ...(typeof (item?.context_window ?? item?.contextWindow) === 'number' ? { contextWindow: item.context_window ?? item.contextWindow } : {}),
+            ...(typeof item?.max_output_tokens === 'number' ? { maxOutputTokens: item.max_output_tokens } : {}),
+        });
+    }
+    if (items.length && !out.size)
+        throw new Error('Model list contains no valid IDs');
+    return [...out.values()];
+}
+const BUILTIN_IDS = {
+    codex: ['gpt-5.5', 'gpt-5.4', 'gpt-5.4-mini', 'gpt-5.3-codex', 'gpt-5.2'],
+    claude: ['claude-opus-4-7', 'claude-opus-4-6', 'claude-sonnet-4-6', 'claude-haiku-4-5-20251001', 'deepseek-v4-pro', 'deepseek-v4-flash', 'kimi-k2.6', 'kimi-k2.5', 'glm-5.1', 'glm-5', 'glm-4.7', 'MiniMax-M2.7'],
+    ecagent: ['claude-sonnet-4-6'],
+    gemini: ['gemini-2.5-pro', 'gemini-2.5-flash', 'gemini-2.5-flash-lite'],
+};
+export function builtinCatalog(baseagent) {
+    return (BUILTIN_IDS[baseagent] ?? []).map(id => ({ id, verification: 'unverified',
+        ...(baseagent === 'codex' ? { reasoningLevels: ['low', 'medium', 'high', 'xhigh'] } : {}),
+        ...(/^claude-(opus|sonnet|haiku)-/.test(id) && baseagent === 'claude' ? { reasoningLevels: [...TRANSPORT_EFFORTS.claude] } : {}),
+    }));
+}
+export function deriveAliases(models, baseagent) {
+    if (baseagent !== 'claude')
+        return {};
+    const best = {};
+    for (const { id } of models) {
+        const match = id.match(/^claude-(opus|sonnet|haiku)-(\d+)(?:-(\d+))?/);
+        if (!match)
+            continue;
+        const [, family, major, minor = '0'] = match;
+        const current = best[family];
+        if (!current || +major > current.major || (+major === current.major && +minor > current.minor))
+            best[family] = { id, major: +major, minor: +minor };
+    }
+    return Object.fromEntries(Object.entries(best).map(([family, info]) => [family, info.id]));
+}
+/** Missing capability metadata is unknown. Never classify by vendor or model name. */
+function compatible(model, baseagent) {
+    if (model.supportsTools === false)
+        return false;
+    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) {
+    const available = models.filter(m => compatible(m, baseagent)).map(m => ({ ...m,
+        ...(m.reasoningLevels ? { reasoningLevels: m.reasoningLevels.filter(e => TRANSPORT_EFFORTS[baseagent]?.includes(e)) } : {}),
+    }));
+    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];
+}
+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));
+    return entry?.reasoningLevels?.filter(e => TRANSPORT_EFFORTS[baseagent]?.includes(e)) ?? [];
+}
+export function assertCatalogSelectable(snapshot) {
+    if (snapshot.diagnostics.some(d => d.code === 'AUTH_FAILED'))
+        throw new Error('模型网关鉴权失败（401/403），请检查当前连接凭据');
+}
+class GatewayError extends Error {
+    status;
+    constructor(status) {
+        super(status ? `Model gateway HTTP ${status}` : 'Model gateway unavailable or invalid response');
+        this.status = status;
+    }
+}
+async function gatewayModels(context, fetcher) {
+    const urls = [...new Set([appendV1RequestPath(context.baseUrl, 'models', context.queryParams), appendRequestPath(context.baseUrl, 'models', context.queryParams)])];
+    let last;
+    for (const url of urls) {
+        try {
+            const models = [];
+            const seen = new Set();
+            let next = url;
+            // Bound the whole route, including response bodies and pagination.
+            const signal = AbortSignal.timeout(4000);
+            for (let page = 0; page < 100; page++) {
+                if (seen.has(next))
+                    throw new GatewayError();
+                seen.add(next);
+                const headers = new Headers(context.headers);
+                if (context.apiKey && !headers.has('authorization')) {
+                    headers.set('authorization', `Bearer ${context.apiKey}`);
+                }
+                if (context.apiKey && context.baseagent === 'claude' && !headers.has('x-api-key')) {
+                    headers.set('x-api-key', context.apiKey);
+                }
+                if (context.baseagent === '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);
+                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));
+                next = parsed.toString();
+            }
+            throw new GatewayError();
+        }
+        catch (error) {
+            if (error instanceof GatewayError && [401, 403].includes(error.status))
+                throw error;
+            last = error;
+        }
+    }
+    throw last ?? new GatewayError();
+}
+/** One instance per daemon. Offline clients use the same persistence format. */
+export class ModelCatalogService {
+    options;
+    cache = new Map();
+    successes = new Map();
+    inflight = new Map();
+    constructor(options = {}) {
+        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; }
+    previous(context) {
+        const key = this.key(context);
+        let snapshot = this.successes.get(key);
+        if (!snapshot) {
+            try {
+                const file = this.file(context);
+                const saved = file ? atomicReadJson(file) : undefined;
+                if (saved?.version === 1 && saved.snapshot && Array.isArray(saved.snapshot.models) && ['gateway', 'native'].includes(saved.snapshot.source))
+                    snapshot = saved.snapshot;
+            }
+            catch { /* A missing/corrupt cache is a cold load. */ }
+            if (snapshot)
+                this.successes.set(key, snapshot);
+        }
+        return snapshot && this.now() - Date.parse(snapshot.fetchedAt) <= CATALOG_STALE_MS ? snapshot : undefined;
+    }
+    peek(context) {
+        return structuredClone(this.cache.get(this.key(context))?.snapshot ?? this.previous(context) ?? this.make(context, 'builtin', 'fallback', this.legacyBuiltins(context), [{ code: 'BUILTIN', message: '内置候选，未经当前连接验证' }]));
+    }
+    async get(context, refresh = false) {
+        const key = this.key(context);
+        const cached = this.cache.get(key);
+        if (!refresh && cached && cached.retryAt > this.now())
+            return structuredClone(cached.snapshot);
+        const previous = this.previous(context);
+        if (!refresh && previous && this.now() - Date.parse(previous.fetchedAt) < CATALOG_TTL_MS && !cached) {
+            this.cache.set(key, { snapshot: previous, retryAt: Date.parse(previous.fetchedAt) + CATALOG_TTL_MS });
+            return structuredClone(previous);
+        }
+        let pending = this.inflight.get(key);
+        if (!pending) {
+            pending = this.load(context, previous).then(snapshot => {
+                this.cache.set(key, { snapshot, retryAt: this.now() + (snapshot.freshness === 'fresh' ? CATALOG_TTL_MS : 30_000) });
+                return snapshot;
+            }).finally(() => this.inflight.delete(key));
+            this.inflight.set(key, pending);
+        }
+        if (!refresh && previous)
+            return structuredClone({ ...previous, freshness: 'stale', diagnostics: [...(cached?.snapshot.diagnostics ?? []), { code: 'STALE_CACHE', message: '显示同一连接的最近成功目录，正在刷新' }] });
+        return structuredClone(await pending);
+    }
+    clear() { this.cache.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 };
+    }
+    save(context, snapshot) {
+        this.successes.set(this.key(context), snapshot);
+        try {
+            const file = this.file(context);
+            if (file) {
+                fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+                atomicWriteJson(file, { version: 1, snapshot });
+            }
+        }
+        catch { /* Persistence failure does not discard a live result. */ }
+    }
+    legacyBuiltins(context) {
+        const models = builtinCatalog(context.baseagent);
+        if (context.baseagent !== 'claude' || !context.baseUrl || !this.options.legacyAliasFile)
+            return models;
+        try {
+            const legacy = atomicReadJson(this.options.legacyAliasFile());
+            const key = createHash('sha256').update(context.baseUrl.trim().replace(/\/+$/, '')).digest('hex');
+            const aliases = legacy?.gateways?.[key]?.aliases ?? {};
+            // The legacy cache did not identify credentials. Import only unverified
+            // suggestions; never let it attest gateway membership for another key.
+            for (const [family, id] of Object.entries(aliases))
+                if (typeof id === 'string' && /^(opus|sonnet|haiku)$/.test(family) && new RegExp(`^claude-${family}-[A-Za-z0-9._-]+$`).test(id) && !models.some(m => m.id === id))
+                    models.unshift({ id, verification: 'unverified', reasoningLevels: [...TRANSPORT_EFFORTS.claude] });
+        }
+        catch { /* No legacy data. */ }
+        return models;
+    }
+    async load(context, previous) {
+        const diagnostics = [];
+        if (context.configUnavailable)
+            diagnostics.push({ code: 'CONFIG_UNAVAILABLE', message: '当前连接配置或凭据不完整' });
+        if (context.baseUrl && !context.configUnavailable) {
+            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 metadata = new Map((native ?? builtinCatalog(context.baseagent)).map(m => [m.id, m]));
+                const enriched = models.map(m => ({ ...m, ...(m.reasoningLevels === undefined && metadata.get(m.id)?.reasoningLevels ? { reasoningLevels: metadata.get(m.id).reasoningLevels } : {}) }));
+                const result = this.make(context, 'gateway', 'fresh', enriched, diagnostics);
+                this.save(context, result);
+                return result;
+            }
+            catch (error) {
+                const status = error instanceof GatewayError ? error.status : undefined;
+                const auth = status === 401 || status === 403;
+                diagnostics.push({ code: auth ? 'AUTH_FAILED' : 'GATEWAY_UNAVAILABLE', message: auth ? '当前模型网关鉴权失败' : '当前模型网关不可用或响应格式不支持', ...(status ? { status } : {}) });
+                if (previous?.source === 'gateway')
+                    return { ...previous, freshness: 'stale', diagnostics: [...diagnostics, { code: 'STALE_CACHE', message: '使用同一连接的最近成功目录' }] };
+                if (auth)
+                    return this.make(context, 'gateway', 'fallback', [], diagnostics);
+            }
+        }
+        if (previous)
+            return { ...previous, freshness: 'stale', diagnostics: [...diagnostics, { code: 'STALE_CACHE', message: '使用同一连接的最近成功目录' }] };
+        if (!context.configUnavailable && this.options.native) {
+            try {
+                const native = await this.options.native(context);
+                if (native !== null) {
+                    const result = this.make(context, 'native', context.baseUrl ? 'fallback' : 'fresh', context.baseUrl ? native.map(m => ({ ...m, verification: 'unverified' })) : native, diagnostics);
+                    // A native catalog cannot certify membership of a failed gateway.
+                    if (!context.baseUrl)
+                        this.save(context, result);
+                    return result;
+                }
+            }
+            catch { /* Native failure continues to builtin. */ }
+            if (context.baseagent === 'codex')
+                diagnostics.push({ code: 'NATIVE_UNAVAILABLE', message: 'Codex 原生目录暂不可用' });
+        }
+        return this.make(context, 'builtin', 'fallback', this.legacyBuiltins(context), [...diagnostics, { code: 'BUILTIN', message: '内置候选，未经当前连接验证' }]);
+    }
+}