gpteam 0.1.27 → 0.1.29

package/README.md

@@ -6,13 +6,15 @@ Interactive GPTeam API client configurator.
 npx gpteam
 ```
 
-The CLI asks for an API key, validates it with `/v1/models`, checks whether the selected client command is installed, detects available models, benchmarks all production ingress endpoints with real API requests, then backs up old files and writes the selected client configuration. The next steps are blocked until the key validation succeeds. Client detection runs before model selection and benchmarking, so a missing local client does not waste API probes.
+The CLI asks for an API key, reads the key-scoped GPTeam capability summary, shows only the available clients and models for that key's group, benchmarks production ingress endpoints with real API requests, then backs up old files and writes the selected client configuration. Legacy servers fall back to `/v1/models` for validation only.
 
 When a selected client is missing, the interactive CLI shows the exact install command and asks before running it. `--install-client` skips that confirmation for scripted setup. Codex, Claude Code, OpenCode, and OpenClaw use npm-based install commands; OpenCode uses the current `opencode-ai` package. Windows is blocked for OpenClaw because GPTeam's OpenClaw config writer currently supports macOS and Linux only.
 
 Recommendation order is deterministic: success rate first, then an experience score. The score weighs first SSE event time, total completion time, p90 completion tail latency, and health-check time, so a node with one very slow probe is not recommended just because its median result looks good. The result table also marks the fastest full completion separately from the balanced recommendation, because deep or long-output model runs may care more about full completion time than first-token responsiveness. Model prompts use "configurable context" wording because the value is written to the client-side Codex `model_context_window`; it must not be confused with a public marketing total-window label.
 
-Client config writing follows the same safety pattern as cc-switch: keep Codex top-level fields separate from provider tables, preserve unrelated sections such as MCP servers, merge OpenCode/OpenClaw providers additively, and stop before writing when an existing JSON/JSON5 config cannot be parsed. GPTeam keeps three proxy-specific extensions on top of that baseline: Codex explicitly disables WebSocket prewarm, Codex/OpenCode/Claude Code write the `gpteam_image` MCP server so Image 2 can be called from chat, and Claude Code writes the reasoning-effort header through `ANTHROPIC_CUSTOM_HEADERS`.
+Production endpoints are `main` and `jp`. Older scripted values `jp-direct` and `jp-split` remain compatibility aliases. The retired Hong Kong ingress is not included in the package, generated configs, help text, or release smoke tests.
+
+Client config writing follows the same safety pattern as cc-switch: keep Codex top-level fields separate from provider tables, preserve unrelated sections such as MCP servers, merge OpenCode/OpenClaw providers additively, and stop before writing when an existing JSON/JSON5 config cannot be parsed. GPTeam keeps three proxy-specific extensions on top of that baseline: Codex enables WebSocket capability for the GPTeam provider, Codex/OpenCode/Claude Code write the `gpteam_image` MCP server so Image 2 can be called from chat, and Claude Code writes the reasoning-effort header through `ANTHROPIC_CUSTOM_HEADERS`.
 
 The Image MCP config uses cc-switch-style per-client env blocks. Codex writes `[mcp_servers.gpteam_image.env]`, OpenCode writes `mcp.gpteam_image.environment`, and Claude Code writes `mcpServers.gpteam_image.env` in `~/.claude.json`. The MCP receives `GPTEAM_API_KEY` and `GPTEAM_BASE_URL` from that MCP config, so it does not depend on Codex `auth.json` or inherited `OPENAI_API_KEY`.
 

package/lib/bench.js

@@ -2,6 +2,7 @@ import dns from 'node:dns';
 import https from 'node:https';
 import { performance } from 'node:perf_hooks';
 import { formatNetworkError } from './errors.js';
+import { nodeAPIBaseUrl } from './nodes.js';
 import { inspectSSEBody } from './sse.js';
 
 const MISSING_LATENCY_MS = 999999;
@@ -29,7 +30,7 @@ export async function benchmarkNodes(nodes, options) {
 
 export async function benchmarkNode(node, options) {
   const health = await measureHealth(node.healthUrl);
-  const stream = await measureStream(node.baseUrl, options);
+  const stream = await measureStream(nodeAPIBaseUrl(node), options);
   return {
     ok: health.ok && stream.ok,
     health,
@@ -41,6 +42,7 @@ export async function benchmarkNode(node, options) {
 export function summarizeNode(node, samples) {
   const successful = samples.filter((sample) => sample.ok);
   const streams = successful.map((sample) => sample.stream);
+  const allStreams = samples.map((sample) => sample.stream).filter(Boolean);
   const firstEvents = streams.map((item) => item.firstEventMs).filter(Number.isFinite);
   const totals = streams.map((item) => item.totalMs).filter(Number.isFinite);
   const summary = {
@@ -51,10 +53,10 @@ export function summarizeNode(node, samples) {
     totalMs: median(totals),
     tailFirstEventMs: percentile(firstEvents, 0.9),
     tailTotalMs: percentile(totals, 0.9),
-    dnsMs: median(streams.map((item) => item.dnsMs).filter(Number.isFinite)),
-    tcpMs: median(streams.map((item) => item.tcpMs).filter(Number.isFinite)),
-    tlsMs: median(streams.map((item) => item.tlsMs).filter(Number.isFinite)),
-    healthMs: median(successful.map((sample) => sample.health.totalMs).filter(Number.isFinite)),
+    dnsMs: median(allStreams.map((item) => item.dnsMs).filter(Number.isFinite)),
+    tcpMs: median(allStreams.map((item) => item.tcpMs).filter(Number.isFinite)),
+    tlsMs: median(allStreams.map((item) => item.tlsMs).filter(Number.isFinite)),
+    healthMs: median(samples.map((sample) => sample.health?.totalMs).filter(Number.isFinite)),
     error: samples.find((sample) => sample.error)?.error || ''
   };
   summary.experienceScore = scoreResult(summary);
@@ -157,16 +159,17 @@ function measureStream(baseUrl, options) {
       });
       response.on('end', () => {
         const semantic = inspectSSEBody(body);
-        const ok = response.statusCode >= 200
-          && response.statusCode < 300
+        const status = response.statusCode || 0;
+        const ok = status >= 200
+          && status < 300
           && semantic.ok
           && Number.isFinite(timings.firstEventMs);
         resolve({
           ok,
-          status: response.statusCode,
+          status,
           ...timings,
           totalMs: performance.now() - started,
-          error: ok ? '' : semantic.error || `stream HTTP ${response.statusCode}`
+          error: ok ? '' : formatStreamProbeError(status, response.headers, body, semantic.error)
         });
       });
     });
@@ -194,6 +197,40 @@ function measureStream(baseUrl, options) {
   });
 }
 
+export function formatStreamProbeError(status, headers, body, semanticError) {
+  const statusCode = Number(status || 0);
+  const contentType = String(headers?.['content-type'] || headers?.['Content-Type'] || '').trim();
+  const detail = responseBodyDetail(body);
+  const parts = [];
+  if (statusCode < 200 || statusCode >= 300) {
+    parts.push(`stream HTTP ${statusCode}`);
+  } else if (semanticError === 'stream empty response' && detail) {
+    parts.push('stream non-SSE response');
+  } else {
+    parts.push(semanticError || `stream HTTP ${statusCode}`);
+  }
+  if (contentType) parts.push(`content-type ${contentType}`);
+  if (detail) parts.push(detail);
+  return parts.join('；');
+}
+
+function responseBodyDetail(body) {
+  const text = String(body || '').replace(/\s+/g, ' ').trim();
+  if (!text) return '';
+  const parsed = parseJSON(text);
+  const message = parsed?.error?.message || parsed?.message || parsed?.error;
+  if (message) return `body ${String(message).slice(0, 180)}`;
+  return `body ${text.slice(0, 180)}`;
+}
+
+function parseJSON(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
 function median(values) {
   if (!values.length) return NaN;
   const sorted = [...values].sort((a, b) => a - b);

package/lib/cli.js

@@ -5,7 +5,7 @@ import { ensureClientInstalled, formatInstallCommand } from './client-install.js
 import { CLIENTS, writeClientConfig } from './config.js';
 import { getHelpText, PACKAGE_NAME, PACKAGE_VERSION } from './help.js';
 import { modelByID, validateApiKey } from './models.js';
-import { describeSplit, INGRESS_NODES } from './nodes.js';
+import { INGRESS_NODES, nodeMatchesID, nodesFromCapabilities } from './nodes.js';
 import { createTheme, stripAnsi } from './terminal.js';
 
 export async function runCli(argv = []) {
@@ -25,12 +25,14 @@ export async function runCli(argv = []) {
     printBanner(theme);
 
     const apiKey = args.key || args.apiKey || await askRequired(rl, '请输入 API key：');
-    printStep(theme, 1, 5, '校验 API key', '请求 /v1/models，校验通过后才继续。');
+    printStep(theme, 1, 5, '校验 API key', '读取 Key 分组能力，校验通过后才继续。');
     const validation = await validateApiKey(INGRESS_NODES, apiKey);
-    printStatus(theme, '通过', `API key 可用，校验入口：${validation.node.label}`);
+    const ingressNodes = nodesFromCapabilities(validation);
+    printStatus(theme, '通过', formatValidationSummary(validation));
 
     printStep(theme, 2, 5, '选择客户端和模型');
-    const client = await choose(rl, '请选择客户端类型', CLIENTS, args.client, theme);
+    const clientChoices = filterClientsForCapabilities(CLIENTS, validation.clients);
+    const client = await choose(rl, '请选择客户端类型', clientChoices, args.client, theme);
     await ensureSelectedClientInstalled(client.id, args, rl, theme);
     const models = validation.models;
     const model = await chooseModel(rl, models, args.model, theme);
@@ -42,7 +44,7 @@ export async function runCli(argv = []) {
     printHint(theme, '入口之间并行测速，单入口多轮顺序执行，避免同时打出过多真实请求。');
     printHint(theme, '综合推荐规则：成功率优先，其次按首包、完成、尾延迟和健康检查计算体验分，分数越低越好；完成最快会单独标出。');
     printHint(theme, `模型：${model.id}，测速输出上限：${maxOutputTokens}`);
-    const results = await benchmarkNodes(INGRESS_NODES, {
+    const results = await benchmarkNodes(ingressNodes, {
       apiKey,
       model: model.id,
       effort: effort.id,
@@ -63,7 +65,8 @@ export async function runCli(argv = []) {
       effort: effort.id,
       contextLength,
       maxOutputTokens: model.maxOutputTokens,
-      node: selectedNode
+      node: selectedNode,
+      imageMCP: validation.imageMCP
     });
 
     console.log('');
@@ -71,7 +74,7 @@ export async function runCli(argv = []) {
     for (const filePath of written) console.log(`- ${filePath}`);
     console.log(`入口：${formatNodeLabel(selectedNode)}`);
     console.log(`地址：${selectedNode.baseUrl}`);
-    if (['codex', 'opencode', 'claude-code'].includes(client.id)) {
+    if (['codex', 'opencode', 'claude-code'].includes(client.id) && validation.imageMCP?.enabled === true) {
       printHint(theme, '已写入 GPTeam Image MCP。客户端对话里需要生图或图生图时优先调用 create_image_job，再用 get_image_job_status 和 download_image_result 取结果，get_capabilities 可查看支持能力，MCP 使用专用环境变量读取 API key。');
     }
   } finally {
@@ -104,7 +107,7 @@ export function printResults(results, theme = createTheme()) {
   const recommended = results.find((item) => item.successRate > 0);
   const fastestTotal = findFastestTotalResult(results);
   const rows = results.map((item) => [
-    `${item.node.label}（${describeSplit(item.node)}）`,
+    formatNodeLabel(item.node),
     formatMs(item.dnsMs),
     formatMs(item.tcpMs),
     formatMs(item.tlsMs),
@@ -164,10 +167,11 @@ async function askContextLength(rl, model, preferred) {
 
 export async function chooseNode(rl, results, preferred, recommendedID, theme = createTheme()) {
   const nodes = results.map((item) => item.node);
-  const preferredNode = nodes.find((node) => node.id === preferred);
+  const preferredNode = nodes.find((node) => nodeMatchesID(node, preferred));
   if (preferredNode) return preferredNode;
   if (recommendedID) {
-    printStatus(theme, '综合推荐', recommendedID);
+    const recommendedNode = nodes.find((node) => nodeMatchesID(node, recommendedID));
+    printStatus(theme, '综合推荐', recommendedNode ? formatNodeLabel(recommendedNode) : recommendedID);
   }
   return (await choose(rl, '请选择最终写入的入口', nodes.map((node) => ({
     id: node.id,
@@ -222,8 +226,22 @@ export function formatModelLabel(model) {
   return `${model.id}（可配置上下文 ${context}，输出上限 ${outputTokens}）`;
 }
 
+export function filterClientsForCapabilities(clients, allowedIDs) {
+  if (!Array.isArray(allowedIDs) || !allowedIDs.length) return clients;
+  const allowed = new Set(allowedIDs.map((id) => String(id)));
+  const filtered = clients.filter((client) => allowed.has(client.id));
+  return filtered.length ? filtered : clients;
+}
+
+function formatValidationSummary(validation) {
+  const group = validation.group && validation.group.name
+    ? `，分组：${validation.group.name}`
+    : '';
+  return `API key 可用，校验入口：${validation.node.label}${group}`;
+}
+
 export function formatNodeLabel(node) {
-  return `${node.label}（${describeSplit(node)}）`;
+  return String(node?.label || node?.id || '');
 }
 
 export function assertNodeConfig(node) {

package/lib/config.js

@@ -75,7 +75,7 @@ export function writeCodexConfig(settings) {
     managedRoot.join('\n'),
     rootLines.join('\n'),
     rest.join('\n'),
-    managedImageMCP.join('\n'),
+    imageMCPEnabled(settings) ? managedImageMCP.join('\n') : '',
     managedProvider.join('\n')
   ]);
   assertNoDuplicateTomlKeys(next);
@@ -117,7 +117,11 @@ export function writeOpenCodeConfig(settings) {
     }
   };
   config.mcp = config.mcp && typeof config.mcp === 'object' ? config.mcp : {};
-  config.mcp[IMAGE_MCP_ID] = openCodeImageMCPConfig(settings);
+  if (imageMCPEnabled(settings)) {
+    config.mcp[IMAGE_MCP_ID] = openCodeImageMCPConfig(settings);
+  } else {
+    delete config.mcp[IMAGE_MCP_ID];
+  }
   writeJSON(filePath, config);
   return [filePath];
 }
@@ -145,7 +149,11 @@ export function writeClaudeCodeConfig(settings) {
   mcpConfig.mcpServers = mcpConfig.mcpServers && typeof mcpConfig.mcpServers === 'object'
     ? mcpConfig.mcpServers
     : {};
-  mcpConfig.mcpServers[IMAGE_MCP_ID] = imageMCPServer(settings);
+  if (imageMCPEnabled(settings)) {
+    mcpConfig.mcpServers[IMAGE_MCP_ID] = imageMCPServer(settings);
+  } else {
+    delete mcpConfig.mcpServers[IMAGE_MCP_ID];
+  }
   writeJSON(mcpPath, mcpConfig);
   return [filePath, mcpPath];
 }
@@ -254,6 +262,10 @@ function openCodeImageMCPConfig(settings) {
   };
 }
 
+function imageMCPEnabled(settings) {
+  return settings?.imageMCP?.enabled === true;
+}
+
 function stripCodexManagedConfig(raw) {
   const rootLines = [];
   const rest = [];

package/lib/help.js

@@ -1,5 +1,5 @@
 export const PACKAGE_NAME = 'gpteam';
-export const PACKAGE_VERSION = '0.1.27';
+export const PACKAGE_VERSION = '0.1.29';
 
 export function getHelpText() {
   return [
@@ -15,13 +15,13 @@ export function getHelpText() {
     '  --model <id>             预选模型，例如 gpt-5.5',
     '  --context <tokens>       预设可配置上下文长度',
     '  --effort <level>         按模型支持项预选，常见为 none / low / medium / high / xhigh',
-    '  --node <id>              jp-direct / jp-split / hk-split',
+    '  --node <id>              main / jp（兼容旧参数 jp-direct / jp-split）',
     '  --rounds <n>             每个入口测速轮数，默认 3',
     '  --max-output-tokens <n>  测速输出上限，默认 648',
     '  --install-client         客户端命令缺失时直接安装，不再二次确认',
     '  --help                  显示帮助',
     '  --version               显示版本',
     '',
-    '说明：输入 key 后会先请求 /v1/models 校验，通过后才继续。选好客户端后会检测本机命令是否可用，缺失时提示安装。Windows 暂不支持自动配置 OpenClaw。测速会请求 GET /api/health 和流式 POST /v1/responses。入口之间并行测速，写新配置前会先备份旧配置。Codex、OpenCode、Claude Code 会写入 GPTeam Image MCP，生图和图生图工具从 MCP env 读取 key，长时间任务优先用 create_image_job 异步任务，get_capabilities 可查看支持能力。'
+    '说明：输入 key 后按分组能力展示可用客户端和模型，再测速并写入配置；旧配置会先备份。Codex、OpenCode、Claude Code 会按权限写入 GPTeam Image MCP。'
   ].join('\n');
 }

package/lib/image-mcp/image.js

@@ -10,7 +10,7 @@ import {
 } from './errors.js';
 import { DEFAULT_IMAGE_FORMAT, localImageToDataURL, normalizeImageFormat, writeImageOutput } from './files.js';
 
-export const DEFAULT_BASE_URL = 'https://api.gpteamservices.com/v1';
+export const DEFAULT_BASE_URL = 'https://api.gpteamservices.com';
 export const DEFAULT_IMAGE_MODEL = 'gpt-image-2';
 export { DEFAULT_IMAGE_FORMAT };
 
@@ -651,7 +651,7 @@ function normalizeIdempotencyKey(value) {
 }
 
 function shapeDownloadResult(result, input = {}) {
-  const includeImage = !input.metadata_only && input.include_image !== false;
+  const includeImage = input.include_image === true && !input.metadata_only;
   const includeRevisedPrompt = input.include_revised_prompt !== false;
   const output = {
     ...result,

package/lib/image-mcp/server.js

@@ -238,13 +238,13 @@ function downloadSchema() {
   const schema = jobIDSchema();
   schema.properties.metadata_only = {
     type: 'boolean',
-    description: 'Return only metadata without MCP image content.',
-    default: false
+    description: '只返回文件路径和元数据，不返回 MCP 图片内容。默认 true，避免大图进入上下文触发频繁 compact。',
+    default: true
   };
   schema.properties.include_image = {
     type: 'boolean',
-    description: 'Include image content when the job succeeded.',
-    default: true
+    description: '显式返回 MCP 图片内容。大图会显著增加上下文，通常保持 false，只使用本地文件路径。',
+    default: false
   };
   schema.properties.include_revised_prompt = {
     type: 'boolean',

package/lib/models.js

@@ -1,4 +1,5 @@
 import { formatNetworkError } from './errors.js';
+import { nodeAPIBaseUrl } from './nodes.js';
 
 export const FALLBACK_MODELS = {
   'gpt-5.2': {
@@ -39,26 +40,62 @@ export const FALLBACK_MODELS = {
   }
 };
 
-export function normalizeModels(payload) {
+class CapabilityEndpointUnavailableError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'CapabilityEndpointUnavailableError';
+    this.capabilityEndpointUnavailable = true;
+  }
+}
+
+export function normalizeModels(payload, options = {}) {
   const items = Array.isArray(payload && payload.data) ? payload.data : [];
+  return normalizeModelItems(items, { fallbackWhenEmpty: options.fallbackWhenEmpty !== false });
+}
+
+export function normalizeCapabilities(payload) {
+  const models = payload && typeof payload === 'object' ? payload.models : {};
+  const chatItems = firstArray(models?.chat, payload?.chat_models, payload?.models_chat);
+  const imageItems = firstArray(models?.image, payload?.image_models, payload?.models_image);
+  return {
+    apiKey: normalizePlainObject(payload?.api_key),
+    user: normalizePlainObject(payload?.user),
+    group: normalizePlainObject(payload?.group),
+    protocols: normalizePlainObject(payload?.protocols),
+    baseUrls: firstArray(payload?.base_urls, payload?.baseURLs),
+    clients: firstArray(payload?.clients),
+    models: normalizeModelItems(chatItems, { fallbackWhenEmpty: false }),
+    imageModels: normalizeModelItems(imageItems, {
+      fallbackWhenEmpty: false,
+      includeImageModels: true
+    }),
+    imageMCP: normalizePlainObject(payload?.image_mcp)
+  };
+}
+
+function normalizeModelItems(items, options = {}) {
   const result = new Map();
 
   for (const item of items) {
     const id = String(item.id || item.name || '').trim();
-    if (!isConfigurableCodexModel(id, item)) continue;
+    if (!isConfigurableTextModel(id, item, options)) continue;
     const fallback = FALLBACK_MODELS[id] || {};
     const thinking = item.thinking && typeof item.thinking === 'object' ? item.thinking : {};
     const levels = Array.isArray(thinking.levels) ? thinking.levels : fallback.efforts;
+    const defaultEffort = String(thinking.default || '').trim().toLowerCase();
+    const efforts = normalizeEfforts(levels);
     result.set(id, {
       id,
       displayName: item.display_name || item.name || id,
       contextLength: Number(item.context_length || item.inputTokenLimit || fallback.contextLength || 400000),
       maxOutputTokens: Number(item.max_completion_tokens || item.outputTokenLimit || fallback.maxOutputTokens || 128000),
-      efforts: normalizeEfforts(levels)
+      efforts: defaultEffort && efforts.includes(defaultEffort)
+        ? [defaultEffort, ...efforts.filter((effort) => effort !== defaultEffort)]
+        : efforts
     });
   }
 
-  if (!result.size) {
+  if (!result.size && options.fallbackWhenEmpty !== false) {
     for (const model of Object.values(FALLBACK_MODELS)) {
       result.set(model.id, {
         id: model.id,
@@ -73,11 +110,45 @@ export function normalizeModels(payload) {
   return Array.from(result.values()).sort((a, b) => a.id.localeCompare(b.id));
 }
 
-function isConfigurableCodexModel(id, item) {
-  if (!id || !id.startsWith('gpt-') || id.includes('image')) return false;
+function isConfigurableTextModel(id, item, options = {}) {
+  if (!id) return false;
+  if (!options.includeImageModels && id.toLowerCase().includes('image')) return false;
   const owner = String(item?.owned_by || item?.provider || item?.type || '').trim().toLowerCase();
-  if (!owner) return Object.prototype.hasOwnProperty.call(FALLBACK_MODELS, id);
-  return owner === 'openai' || owner === 'codex' || owner === 'openai-compatible';
+  const knownTextPrefix = /^(gpt-|claude-|gemini-)/.test(id);
+  if (!owner) return knownTextPrefix || Object.prototype.hasOwnProperty.call(FALLBACK_MODELS, id);
+  return [
+    'openai',
+    'codex',
+    'openai-compatible',
+    'anthropic',
+    'claude',
+    'gemini',
+    'google',
+    'antigravity'
+  ].includes(owner);
+}
+
+export async function fetchCapabilities(baseUrl, apiKey, options = {}) {
+  let response;
+  try {
+    response = await fetch(`${baseUrl.replace(/\/$/, '')}/gpteam/config-capabilities`, {
+      signal: makeTimeoutSignal(options.timeoutMs || 15000),
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        'User-Agent': 'gpteam-api-config/0.1'
+      }
+    });
+  } catch (error) {
+    throw new Error(`/v1/gpteam/config-capabilities 请求失败：${formatNetworkError(error)}`);
+  }
+  if (response.status === 404 || response.status === 405) {
+    throw new CapabilityEndpointUnavailableError('/v1/gpteam/config-capabilities 未部署');
+  }
+  if (!response.ok) {
+    const detail = await readResponseError(response);
+    throw new Error(`/v1/gpteam/config-capabilities 返回 HTTP ${response.status}${detail ? `：${detail}` : ''}`);
+  }
+  return normalizeCapabilities(await response.json());
 }
 
 export async function fetchModels(baseUrl, apiKey, options = {}) {
@@ -108,13 +179,38 @@ export async function validateApiKey(nodes, apiKey) {
 
   const results = await Promise.all(candidates.map(async (node) => {
     try {
-      return { ok: true, node, models: await fetchModels(node.baseUrl, apiKey) };
+      const baseUrl = nodeAPIBaseUrl(node);
+      try {
+        const capabilities = await fetchCapabilities(baseUrl, apiKey);
+        if (!capabilities.models.length) {
+          throw new Error('/v1/gpteam/config-capabilities 没有返回可配置模型');
+        }
+        return {
+          ok: true,
+          node,
+          ...capabilities,
+          capabilities
+        };
+      } catch (error) {
+        if (!error || error.capabilityEndpointUnavailable !== true) {
+          throw error;
+        }
+      }
+      return {
+        ok: true,
+        node,
+        models: await fetchModels(baseUrl, apiKey),
+        imageMCP: { enabled: false }
+      };
     } catch (error) {
       return { ok: false, node, error };
     }
   }));
-  const success = results.find((item) => item.ok);
-  if (success) return { node: success.node, models: success.models };
+  const success = results.find((item) => item.ok && item.capabilities) || results.find((item) => item.ok);
+  if (success) {
+    const { ok, ...result } = success;
+    return result;
+  }
 
   const detail = results
     .map((item) => `${item.node.label || item.node.id || item.node.baseUrl}: ${item.error && item.error.message ? item.error.message : item.error}`)
@@ -126,6 +222,17 @@ export function modelByID(models, id) {
   return models.find((model) => model.id === id) || models[0];
 }
 
+function firstArray(...values) {
+  for (const value of values) {
+    if (Array.isArray(value)) return value;
+  }
+  return [];
+}
+
+function normalizePlainObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
 function normalizeEfforts(levels) {
   const out = [];
   for (const level of levels || []) {

package/lib/nodes.js

@@ -1,34 +1,59 @@
 export const INGRESS_NODES = [
   {
-    id: 'jp-direct',
-    label: '直连',
-    region: 'JP',
-    split: false,
-    baseUrl: 'https://api.gpteamservices.com/v1',
+    id: 'main',
+    aliases: ['jp-direct'],
+    label: '主入口',
+    baseUrl: 'https://api.gpteamservices.com',
     healthUrl: 'https://api.gpteamservices.com/api/health'
   },
   {
-    id: 'jp-split',
+    id: 'jp',
+    aliases: ['jp-split'],
     label: '日本入口',
-    region: 'JP',
-    split: true,
-    baseUrl: 'https://api-jp.gpteamservices.com/v1',
+    baseUrl: 'https://api-jp.gpteamservices.com',
     healthUrl: 'https://api-jp.gpteamservices.com/api/health'
-  },
-  {
-    id: 'hk-split',
-    label: '香港入口',
-    region: 'HK',
-    split: true,
-    baseUrl: 'https://api-hk.gpteamservices.com/v1',
-    healthUrl: 'https://api-hk.gpteamservices.com/api/health'
   }
 ];
 
-export function describeSplit(node) {
-  return node.split ? '分流' : '不分流';
+export function nodeMatchesID(node, id) {
+  const value = String(id || '').trim();
+  if (!value) return false;
+  return node.id === value || (Array.isArray(node.aliases) && node.aliases.includes(value));
 }
 
 export function endpointRoot(baseUrl) {
   return String(baseUrl || '').replace(/\/v1\/?$/, '').replace(/\/$/, '');
 }
+
+export function endpointAPIBase(baseUrl) {
+  const root = endpointRoot(baseUrl);
+  return root ? `${root}/v1` : '';
+}
+
+export function nodeAPIBaseUrl(node) {
+  if (!node) return '';
+  return endpointAPIBase(node.apiBaseUrl || node.baseUrl);
+}
+
+export function nodesFromCapabilities(capabilities, fallbackNodes = INGRESS_NODES) {
+  const entries = Array.isArray(capabilities?.baseUrls) ? capabilities.baseUrls : [];
+  const nodes = entries
+    .map((entry) => capabilityBaseURLToNode(entry))
+    .filter((node) => node && node.baseUrl);
+  return nodes.length ? nodes : fallbackNodes;
+}
+
+function capabilityBaseURLToNode(entry) {
+  if (!entry || typeof entry !== 'object') return null;
+  const id = String(entry.id || '').trim();
+  const baseUrl = endpointRoot(entry.url || entry.base_url || entry.baseUrl);
+  if (!id || !baseUrl) return null;
+  return {
+    id,
+    aliases: Array.isArray(entry.aliases) ? entry.aliases.map((item) => String(item)) : [],
+    label: String(entry.label || id),
+    baseUrl,
+    healthUrl: String(entry.health_url || entry.healthUrl || `${baseUrl}/api/health`),
+    recommended: Boolean(entry.recommended)
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gpteam",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "description": "GPTeam API interactive client configurator and ingress benchmark CLI.",
   "type": "module",
   "bin": {