evolcore 0.0.1 → 0.0.2

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

@@ -0,0 +1,227 @@
+/**
+ * model-catalog: 模型目录与单模型元数据。
+ *
+ * 目录来源（按序回退）：
+ *   {baseUrl}/v1/models  →  {baseUrl}/models  →  内置 mock catalog
+ *
+ * baseUrl/apiKey 复用 baseagent 凭据解析链（与发消息同源），命令不接收 url/key 参数。
+ * 单模型详情（info）现阶段全部为 mock，{baseUrl}/models 接口补全字段后自动接真实数据。
+ *
+ * 详见 docs/model-command-design.md。
+ */
+import { resolveAnthropicConfig, resolveOpenaiConfig } from '../../agents/baseagent.js';
+import { activeBaseagent } from './config-scope.js';
+import { resolveEffective } from '../../config/config-manager.js';
+/** 取指定 baseagent 的 baseUrl + apiKey（复用现有解析链）。 */
+function resolveCreds(self, ba) {
+    const baseagent = ba || activeBaseagent(self);
+    // baseagents 现在在 config.json 中
+    const config = self ? resolveEffective({ self }, { cache: true }) : { baseagents: {} };
+    const block = (config.baseagents || {});
+    try {
+        if (baseagent === 'codex') {
+            const c = block.codex;
+            const r = resolveOpenaiConfig({ agents: { codex: c } }, c);
+            return { baseUrl: r.baseUrl, apiKey: r.apiKey };
+        }
+        const c = block.claude;
+        const r = resolveAnthropicConfig({ agents: { claude: c } }, c);
+        return { baseUrl: r.baseUrl, apiKey: r.apiKey };
+    }
+    catch {
+        return {};
+    }
+}
+/** 从对象/字符串条目里提取 id（兼容 id/name/model 字段）。 */
+function pickId(item) {
+    if (typeof item === 'string')
+        return item;
+    if (item && typeof item === 'object') {
+        const v = item.id ?? item.name ?? item.model;
+        return typeof v === 'string' ? v : undefined;
+    }
+    return undefined;
+}
+/** 从对象条目里提取厂商（兼容 owned_by/owner/provider）。 */
+function pickOwner(item) {
+    if (item && typeof item === 'object') {
+        const v = item.owned_by ?? item.owner ?? item.provider;
+        return typeof v === 'string' ? v : undefined;
+    }
+    return undefined;
+}
+/**
+ * 通用容错解析：
+ *   - 容器：json.data[] | json.models[] | json.data.models[] | 裸数组
+ *   - 条目：字符串 或 {id|name|model, owned_by|owner|provider, created}
+ */
+function genericParse(json) {
+    const arr = Array.isArray(json) ? json
+        : Array.isArray(json?.data) ? json.data
+            : Array.isArray(json?.models) ? json.models
+                : Array.isArray(json?.data?.models) ? json.data.models
+                    : [];
+    const out = [];
+    for (const item of arr) {
+        const id = pickId(item);
+        if (!id)
+            continue;
+        out.push({ id, owned_by: pickOwner(item), created: typeof item?.created === 'number' ? item.created : undefined });
+    }
+    return out;
+}
+/**
+ * 网关专用 parser 注册表（扩展点）。
+ * 当前为空：ModelGate 是标准 OpenAI list 风格，genericParse 已覆盖。
+ * 示例（接入异形网关时取消注释并按实际格式实现）：
+ *   {
+ *     name: 'some-gateway',
+ *     match: (url) => url.includes('some-gateway.example.com'),
+ *     parse: (json) => (json?.result?.modelList ?? []).map((m: any) => ({ id: m.code, owned_by: m.vendor })),
+ *   }
+ */
+const GATEWAY_PARSERS = [];
+/** 选择 parser 并解析（专用优先，否则通用容错）。 */
+export function parseModelList(json, url) {
+    for (const rule of GATEWAY_PARSERS) {
+        try {
+            if (rule.match(url, json))
+                return rule.parse(json);
+        }
+        catch { /* 专用 parser 失败则继续尝试通用解析 */ }
+    }
+    return genericParse(json);
+}
+async function fetchModelList(url, apiKey) {
+    try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 5000);
+        const resp = await fetch(url, {
+            signal: controller.signal,
+            headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+        });
+        clearTimeout(timer);
+        if (!resp.ok)
+            return null;
+        const json = await resp.json();
+        const entries = parseModelList(json, url);
+        return entries.length > 0 ? entries : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** 内置 mock catalog（接口未就绪时的兜底；实测可用模型，见 docs 附录 A）。 */
+const MOCK_CATALOG = [
+    { id: 'claude-opus-4-7', owned_by: 'anthropic' },
+    { id: 'claude-opus-4-6', owned_by: 'anthropic' },
+    { id: 'claude-sonnet-4-6', owned_by: 'anthropic' },
+    { id: 'claude-haiku-4-5-20251001', owned_by: 'anthropic' },
+    { id: 'deepseek-v4-pro', owned_by: 'deepseek' },
+    { id: 'deepseek-v4-flash', owned_by: 'deepseek' },
+    { id: 'kimi-k2.6', owned_by: 'moonshot' },
+    { id: 'kimi-k2.5', owned_by: 'moonshot' },
+    { id: 'glm-5.1', owned_by: 'zhipu' },
+    { id: 'glm-5', owned_by: 'zhipu' },
+    { id: 'glm-4.7', owned_by: 'zhipu' },
+    { id: 'MiniMax-M2.7', owned_by: 'minimax' },
+];
+export function modelMatches(agent, candidate, current) {
+    if (!current)
+        return false;
+    if (candidate === current)
+        return true;
+    const resolve = typeof agent?.resolveModelId === 'function'
+        ? (value) => agent.resolveModelId(value) ?? value
+        : (value) => value;
+    const resolvedCandidate = resolve(candidate);
+    const resolvedCurrent = resolve(current);
+    return candidate === resolvedCurrent || resolvedCandidate === current || resolvedCandidate === resolvedCurrent;
+}
+/**
+ * 远端模型目录接口（临时）。本地 baseUrl 的 /v1/models、/models 尚未实现，
+ * 自动降级到此接口拉取真实可用模型列表；待本地接口就绪后此级自然不再命中。
+ */
+const REMOTE_CATALOG_URL = 'https://mg-new.evolai.cn/claude-proxy/models';
+/**
+ * 各 baseagent 的稳定别名（cc/SDK 自动解析到最新版本）。
+ * 这些是一等公民——defaults.json 默认就存别名（如 "opus"），必须可选可校验。
+ */
+const KNOWN_ALIASES = {
+    claude: ['opus', 'sonnet', 'haiku'],
+    codex: [],
+    gemini: [],
+};
+/** 把别名作为虚拟条目并入目录头部（owned_by 标 alias，便于展示与校验）。 */
+function withAliases(models, ba) {
+    const aliases = KNOWN_ALIASES[ba] || [];
+    const existing = new Set(models.map(m => m.id));
+    const aliasEntries = aliases
+        .filter(a => !existing.has(a))
+        .map(a => ({ id: a, owned_by: 'alias' }));
+    return [...aliasEntries, ...models];
+}
+/** 拉取模型目录：v1/models → models → 远端接口 → mock，并并入别名。 */
+export async function getCatalog(self, ba) {
+    const baseagent = ba || activeBaseagent(self);
+    const { baseUrl, apiKey } = resolveCreds(self, baseagent);
+    if (baseUrl) {
+        const base = baseUrl.replace(/\/+$/, '');
+        const v1 = await fetchModelList(`${base}/v1/models`, apiKey);
+        if (v1)
+            return { models: withAliases(v1, baseagent), source: 'v1/models' };
+        const plain = await fetchModelList(`${base}/models`, apiKey);
+        if (plain)
+            return { models: withAliases(plain, baseagent), source: 'models' };
+    }
+    // 本地接口未实现 → 降级到远端目录接口（无需鉴权）
+    const remote = await fetchModelList(REMOTE_CATALOG_URL, apiKey);
+    if (remote)
+        return { models: withAliases(remote, baseagent), source: 'remote' };
+    return { models: withAliases(MOCK_CATALOG, baseagent), source: 'mock' };
+}
+/** claude 系判定：完整 ID 或别名（opus/sonnet/haiku）。 */
+function isClaudeFamily(id) {
+    return /^claude-/.test(id) || ['opus', 'sonnet', 'haiku'].includes(id);
+}
+/** 单模型详情（现阶段 mock）。 */
+export async function getModelInfo(modelId, self, ba) {
+    const cat = await getCatalog(self, ba);
+    const entry = cat.models.find(m => m.id === modelId);
+    const claudeFamily = isClaudeFamily(modelId);
+    // 远端目录把所有模型的 owned_by 标成网关名 'ModelGate'，别名标成 'alias'，
+    // 两者都不是真实厂商 → 回退到按 ID 推断。
+    const NON_VENDOR = new Set(['alias', 'ModelGate', '']);
+    const rawOwner = entry?.owned_by;
+    const owner = claudeFamily
+        ? 'anthropic'
+        : (rawOwner && !NON_VENDOR.has(rawOwner) ? rawOwner : inferOwner(modelId));
+    return {
+        id: modelId,
+        owned_by: owner,
+        context_window: claudeFamily ? 200000 : 128000,
+        max_output_tokens: 8192,
+        pricing: { input_per_mtok: null, output_per_mtok: null, currency: 'USD' },
+        modalities: ['text'],
+        supports_effort: claudeFamily,
+        status: entry ? 'available' : 'unknown',
+        mocked: true,
+    };
+}
+function inferOwner(id) {
+    if (/^claude-/.test(id))
+        return 'anthropic';
+    if (/^gpt-/.test(id))
+        return 'openai';
+    if (/^gemini-/.test(id))
+        return 'google';
+    if (/^deepseek-/.test(id))
+        return 'deepseek';
+    if (/^kimi-/.test(id))
+        return 'moonshot';
+    if (/^glm-/.test(id))
+        return 'zhipu';
+    if (/^MiniMax-/i.test(id))
+        return 'minimax';
+    return 'unknown';
+}

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

@@ -0,0 +1,182 @@
+import { resolveAnthropicConfig, resolveOpenaiConfig } from '../../agents/baseagent.js';
+import { resolveEffective, resolveEffectiveFieldWithSource } from '../../config/config-manager.js';
+import { constrainResolvedModelForRole } from './model-permission.js';
+import { getCatalog } from './model-catalog.js';
+async function fetchWithTimeout(url, opts, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...opts, signal: controller.signal });
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function resolveGatewayCreds(self, baseagent) {
+    try {
+        const config = self ? resolveEffective({ self }, { cache: true }) : { baseagents: {} };
+        const block = config.baseagents || {};
+        if (baseagent === 'codex') {
+            const codexCfg = block.codex || {};
+            const resolved = resolveOpenaiConfig({ agents: { codex: codexCfg } }, codexCfg);
+            return { baseUrl: resolved.baseUrl, apiKey: resolved.apiKey };
+        }
+        if (baseagent === 'claude') {
+            const claudeCfg = block.claude || {};
+            const resolved = resolveAnthropicConfig({ agents: { claude: claudeCfg } }, claudeCfg);
+            return { baseUrl: resolved.baseUrl, apiKey: resolved.apiKey };
+        }
+    }
+    catch {
+        return {};
+    }
+    return {};
+}
+async function responseError(resp) {
+    let message = `HTTP ${resp.status}`;
+    try {
+        const body = await resp.json();
+        message = body?.error?.message || body?.detail || body?.message || message;
+    }
+    catch {
+        // Keep the HTTP status when the gateway has no JSON error body.
+    }
+    return String(message).slice(0, 80);
+}
+export async function probeModel(baseUrl, apiKey, modelId, timeoutMs) {
+    const base = baseUrl.replace(/\/+$/, '');
+    const authHeaders = apiKey
+        ? { 'x-api-key': apiKey, Authorization: `Bearer ${apiKey}` }
+        : {};
+    const deadline = Date.now() + timeoutMs;
+    const remainingMs = () => Math.max(0, deadline - Date.now());
+    const anthropicStartedAt = Date.now();
+    const anthropic = await fetchWithTimeout(`${base}/v1/messages`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'anthropic-version': '2023-06-01', ...authHeaders },
+        body: JSON.stringify({ model: modelId, max_tokens: 5, messages: [{ role: 'user', content: 'ok' }] }),
+    }, Math.min(5000, remainingMs()));
+    const anthropicMs = Date.now() - anthropicStartedAt;
+    if (anthropic?.ok)
+        return { ok: true, ms: anthropicMs, style: 'anthropic' };
+    if (anthropic) {
+        const error = await responseError(anthropic);
+        if (anthropic.status === 401 || anthropic.status === 403) {
+            return { ok: false, ms: anthropicMs, error, style: 'anthropic' };
+        }
+    }
+    if (remainingMs() <= 0) {
+        return { ok: false, ms: Date.now() - anthropicStartedAt, error: '探测超时', style: 'unknown' };
+    }
+    const openaiStartedAt = Date.now();
+    const openai = await fetchWithTimeout(`${base}/v1/chat/completions`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...authHeaders },
+        body: JSON.stringify({ model: modelId, max_tokens: 5, messages: [{ role: 'user', content: 'ok' }] }),
+    }, Math.min(5000, remainingMs()));
+    const openaiMs = Date.now() - openaiStartedAt;
+    if (openai?.ok) {
+        try {
+            const body = await openai.json();
+            if (body?.choices || body?.id)
+                return { ok: true, ms: openaiMs, style: 'openai' };
+        }
+        catch {
+            // A successful but non-standard response cannot prove model availability.
+        }
+    }
+    if (openai && openai.status >= 400 && openai.status < 500) {
+        return { ok: false, ms: openaiMs, error: await responseError(openai), style: 'openai' };
+    }
+    return { ok: false, ms: 0, error: '网关不支持标准探测（无法确认可用性）', style: 'unknown' };
+}
+export async function runModelCheck(input) {
+    const steps = [];
+    const log = (step) => {
+        steps.push(step);
+        input.onStep?.(step);
+    };
+    const { baseUrl, apiKey } = resolveGatewayCreds(input.self, input.baseagent);
+    if (!baseUrl) {
+        log({ label: '网关地址', ok: false, detail: '未配置受支持的自定义网关，跳过 API 探测' });
+    }
+    else {
+        const startedAt = Date.now();
+        const ping = await fetchWithTimeout(`${baseUrl.replace(/\/+$/, '')}/v1/models`, {
+            method: 'GET',
+            headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+        }, 4000);
+        const elapsed = Date.now() - startedAt;
+        log(ping
+            ? { label: '网关连通', ok: true, detail: baseUrl, ms: elapsed }
+            : { label: '网关连通', ok: false, detail: `${baseUrl} 无法连接（DNS/TCP 失败）`, ms: elapsed });
+    }
+    const catalog = await getCatalog(input.self, input.baseagent);
+    const modelIds = catalog.models.filter(model => model.owned_by !== 'alias').map(model => model.id);
+    log(catalog.source === 'mock'
+        ? { label: '模型列表', ok: false, detail: `无法获取远端列表，使用内置 mock（${modelIds.length} 个）` }
+        : { label: '模型列表', ok: true, detail: `来源: ${catalog.source}，共 ${modelIds.length} 个模型` });
+    const selector = { self: input.self, peerKey: input.peerKey };
+    const modelResolution = resolveEffectiveFieldWithSource(`baseagents.${input.baseagent}.model`, selector, { cache: true });
+    const modelDecision = constrainResolvedModelForRole({
+        selfAid: input.self,
+        role: input.role,
+        baseagent: input.baseagent,
+        model: modelResolution.value,
+    });
+    const configuredModel = modelDecision.model;
+    const configuredModelSource = modelDecision.constrained
+        ? 'role'
+        : modelResolution.source?.target;
+    log(configuredModel
+        ? { label: '配置模型', ok: true, detail: `${configuredModel}（来源: ${configuredModelSource ?? '未知'}）` }
+        : { label: '配置模型', ok: true, detail: '未配置（将使用 base agent 默认模型）' });
+    const probeResults = [];
+    if (baseUrl) {
+        const aliases = new Map();
+        for (const entry of catalog.models) {
+            if (entry.owned_by !== 'alias')
+                continue;
+            const matched = catalog.models.find(model => model.owned_by !== 'alias' && model.id.includes(entry.id));
+            if (matched)
+                aliases.set(entry.id, matched.id);
+        }
+        const resolvedConfiguredModel = configuredModel ? aliases.get(configuredModel) ?? configuredModel : undefined;
+        const targets = [
+            ...(resolvedConfiguredModel ? [{ display: configuredModel, probe: resolvedConfiguredModel }] : []),
+            ...modelIds.filter(id => id !== resolvedConfiguredModel).map(id => ({ display: id, probe: id })),
+        ];
+        for (let index = 0; index < targets.length; index += 2) {
+            const batch = await Promise.all(targets.slice(index, index + 2).map(async (target) => {
+                const result = await probeModel(baseUrl, apiKey, target.probe, 10_000);
+                return { id: target.display, ...result };
+            }));
+            for (const result of batch) {
+                probeResults.push(result);
+                log({ label: result.id.slice(0, 20), ok: result.ok, detail: result.ok ? '可用' : (result.error ?? '不可用'), ms: result.ms });
+            }
+        }
+    }
+    const availableModels = probeResults.filter(result => result.ok).map(result => result.id);
+    const configModelAvailable = configuredModel
+        ? probeResults.find(result => result.id === configuredModel)?.ok
+        : undefined;
+    return { steps, configuredModel, configuredModelSource, availableModels, configModelAvailable, catalogSource: catalog.source };
+}
+export function formatModelCheck(result) {
+    const lines = ['网关诊断'];
+    for (const step of result.steps) {
+        const elapsed = step.ms === undefined ? '' : ` (${step.ms}ms)`;
+        lines.push(`[${step.ok ? '✓' : '✗'}] ${step.label.padEnd(14)} ${step.detail}${elapsed}`);
+    }
+    if (result.configuredModel && result.configModelAvailable === false) {
+        lines.push(`⚠️ 当前配置的模型 ${result.configuredModel} 不可用`);
+    }
+    else if (result.configuredModel && result.configModelAvailable === true) {
+        lines.push(`✓ 当前配置的模型 ${result.configuredModel} 可用`);
+    }
+    return lines.join('\n');
+}

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

@@ -0,0 +1,90 @@
+import { getFieldPermission } from '../../config/roles.js';
+export function isModelAllowedByPatterns(model, allowedModels) {
+    if (allowedModels.includes('*'))
+        return true;
+    return allowedModels.some(pattern => pattern.endsWith('*')
+        ? model.startsWith(pattern.slice(0, -1))
+        : model === pattern);
+}
+function normalizeBaseagent(baseagent) {
+    return (baseagent || 'claude').trim() || 'claude';
+}
+export function getRoleModelPermission(role, baseagent, selfAid) {
+    const ba = normalizeBaseagent(baseagent);
+    if (!role)
+        return { allowOverride: false, constrained: true };
+    const selected = getFieldPermission(role, `baseagents.${ba}.model`, selfAid);
+    if (!selected || !Array.isArray(selected.allowedModels)) {
+        return { allowOverride: true, constrained: false };
+    }
+    return {
+        defaultModel: typeof selected.default === 'string' ? selected.default : undefined,
+        allowOverride: selected.allowOverride !== false,
+        allowedModels: selected.allowedModels,
+        constrained: true,
+    };
+}
+export function resolveCandidateModel(model, resolveModelId) {
+    return resolveModelId?.(model) || model;
+}
+export function isModelAllowedForRoleBaseagent(role, baseagent, model, resolveModelId, selfAid) {
+    const permission = getRoleModelPermission(role, baseagent, selfAid);
+    if (!permission.constrained)
+        return true;
+    const allowed = permission.allowedModels || [];
+    const resolved = resolveCandidateModel(model, resolveModelId);
+    return isModelAllowedByPatterns(model, allowed) || isModelAllowedByPatterns(resolved, allowed);
+}
+export function filterModelsForRole(role, baseagent, models, resolveModelId, selfAid) {
+    const permission = getRoleModelPermission(role, baseagent, selfAid);
+    if (!permission.constrained)
+        return models;
+    return models.filter(model => isModelAllowedForRoleBaseagent(role, baseagent, model, resolveModelId, selfAid));
+}
+export function validateModelSelectionForRole(opts) {
+    const permission = getRoleModelPermission(opts.role, opts.baseagent, opts.selfAid);
+    const resolvedModel = resolveCandidateModel(opts.requestedModel, opts.resolveModelId);
+    const catalogModel = opts.models?.includes(resolvedModel)
+        ? resolvedModel
+        : opts.models?.includes(opts.requestedModel)
+            ? opts.requestedModel
+            : undefined;
+    if (opts.models && opts.models.length > 0 && !catalogModel) {
+        return {
+            ok: false,
+            code: 'INVALID_VALUE',
+            message: `无效模型: ${opts.requestedModel}`,
+        };
+    }
+    const targetModel = catalogModel || resolvedModel;
+    if (!permission.constrained)
+        return { ok: true, model: targetModel };
+    if (!permission.allowOverride) {
+        return {
+            ok: false,
+            code: 'MODEL_OVERRIDE_DISABLED',
+            message: `当前角色不允许切换模型，固定使用: ${permission.defaultModel || '角色默认模型'}`,
+        };
+    }
+    if (!isModelAllowedForRoleBaseagent(opts.role, opts.baseagent, targetModel, opts.resolveModelId, opts.selfAid)) {
+        return {
+            ok: false,
+            code: 'MODEL_NOT_ALLOWED',
+            message: `当前角色不允许使用模型: ${opts.requestedModel}`,
+        };
+    }
+    return { ok: true, model: targetModel };
+}
+export function constrainResolvedModelForRole(opts) {
+    const permission = getRoleModelPermission(opts.role, opts.baseagent, opts.selfAid);
+    if (!permission.constrained)
+        return { model: opts.model, constrained: false };
+    if (!permission.allowOverride)
+        return { model: permission.defaultModel || opts.model, constrained: true };
+    if (!opts.model)
+        return { model: permission.defaultModel, constrained: true };
+    if (isModelAllowedForRoleBaseagent(opts.role, opts.baseagent, opts.model, opts.resolveModelId, opts.selfAid)) {
+        return { model: opts.model, constrained: false };
+    }
+    return { model: permission.defaultModel || opts.model, constrained: true };
+}