gpteam 0.1.28 → 0.1.30

package/README.md

@@ -1,20 +1,20 @@
-# GPTeam CLI
+# GPTEAM CLI
 
-Interactive GPTeam API client configurator.
+Interactive GPTEAM API client configurator.
 
 ```bash
 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.
+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.
 
-Production endpoints are shown as the main, Japan, and Hong Kong ingress domains. They are all GPTeam production API entry points backed by the current new backend stack; the CLI no longer describes them as split-routing or secondary-worker nodes. The current node ids are `main`, `jp`, and `hk`. Older scripted values `jp-direct`, `jp-split`, and `hk-split` remain accepted as compatibility aliases.
+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`.
+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`.
 
@@ -29,9 +29,9 @@ The Image MCP exposes an async-first local job flow plus a legacy compatibility
 
 Image MCP results are returned as stable JSON text and MCP `structuredContent`. Successful results include final file path, model, action, size, format, quality, byte size, SHA-256, MIME type, image dimensions, duration, retry count, `job_id`, `trace_id`, and optional `idempotency_key`. Error results use stable `error.code`, `error.message`, `error.retryable`, `error.stage`, `error.upstream_status`, and `error.trace_id` fields while keeping compatibility fields such as `category` and `http_status`.
 
-The MCP supports normal text-to-image generation and image-to-image/edit inputs. Pass `images` as data URLs, HTTPS URLs, or local file paths. For easier tool calling, `image`, `image_path`, `image_paths`, `input_image`, and `input_images` are accepted as aliases. Pass `mask` or `mask_path` the same way for masked edits. `input_fidelity` is accepted for compatibility but is not forwarded to the current GPTeam Image 2 bridge because upstream Codex image edits reject it. The MCP requests GPTeam image endpoints with `stream=true` and reads the final image event, so long image jobs get early stream bytes instead of sitting idle until the final JSON body. File writes create missing directories, avoid overwriting existing files by adding `-v2`, `-v3`, etc., and validate PNG/JPEG/WebP before returning success. `overwrite: true` is available for explicit replacement. `return_revised_prompt` controls whether the upstream revised prompt is included in the result.
+The MCP supports normal text-to-image generation and image-to-image/edit inputs. Pass `images` as data URLs, HTTPS URLs, or local file paths. For easier tool calling, `image`, `image_path`, `image_paths`, `input_image`, and `input_images` are accepted as aliases. Pass `mask` or `mask_path` the same way for masked edits. `input_fidelity` is accepted for compatibility but is not forwarded to the current GPTEAM Image 2 bridge because upstream Codex image edits reject it. The MCP requests GPTEAM image endpoints with `stream=true` and reads the final image event, so long image jobs get early stream bytes instead of sitting idle until the final JSON body. File writes create missing directories, avoid overwriting existing files by adding `-v2`, `-v3`, etc., and validate PNG/JPEG/WebP before returning success. `overwrite: true` is available for explicit replacement. `return_revised_prompt` controls whether the upstream revised prompt is included in the result.
 
-Claude Code is written to `~/.claude/settings.json` under the `env` section, using the GPTeam `/anthropic` base URL. OpenClaw writes `models.providers.gpteam` and also selects `gpteam/<model>` under `agents.defaults.model`, so the chosen model is active without an extra manual step.
+Claude Code is written to `~/.claude/settings.json` under the `env` section, using the GPTEAM `/anthropic` base URL. OpenClaw writes `models.providers.gpteam` and also selects `gpteam/<model>` under `agents.defaults.model`, so the chosen model is active without an extra manual step.
 
 Supported clients:
 

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,
@@ -120,6 +121,7 @@ function measureStream(baseUrl, options) {
     const payload = JSON.stringify({
       model: options.model,
       stream: true,
+      instructions: 'You are a helpful coding assistant.',
       input: options.prompt || '请只回复一句话：节点测速完成。',
       max_output_tokens: options.maxOutputTokens || 648,
       reasoning: options.effort ? { effort: options.effort } : undefined,

package/lib/cli.js

@@ -4,8 +4,8 @@ import { benchmarkNodes, formatMs } from './bench.js';
 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 { INGRESS_NODES, nodeMatchesID } from './nodes.js';
+import { DEFAULT_OPENAI_MODEL_ID, validateApiKey } from './models.js';
+import { INGRESS_NODES, nodeMatchesID, nodesFromCapabilities } from './nodes.js';
 import { createTheme, stripAnsi } from './terminal.js';
 
 export async function runCli(argv = []) {
@@ -25,27 +25,31 @@ 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}`);
-
-    printStep(theme, 2, 5, '选择客户端和模型');
-    const client = await choose(rl, '请选择客户端类型', CLIENTS, args.client, theme);
+    const ingressNodes = nodesFromCapabilities(validation);
+    printStatus(theme, '通过', formatValidationSummary(validation));
+
+    printStep(theme, 2, 5, '选择客户端');
+    const platform = validation.group?.platform || '';
+    const allowedClients = Array.isArray(validation.clients) && validation.clients.length
+      ? validation.clients
+      : clientIDsForPlatform(platform);
+    const clientChoices = filterClientsForCapabilities(CLIENTS, allowedClients);
+    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);
-    const contextLength = await askContextLength(rl, model, args.context);
-    const effort = await choose(rl, '请选择思考深度', model.efforts.map((id) => ({ id, label: id })), args.effort, theme);
-    const maxOutputTokens = Number(args.maxOutputTokens || 648);
+    const model = selectDefaultModel(models, validation.defaultModel || '', platform);
+    const contextLength = Number(model.contextLength || 400000);
+    const maxOutputTokens = Number(model.maxOutputTokens || 648);
 
     printStep(theme, 3, 5, '真实请求测速', 'GET /api/health + POST /v1/responses stream=true');
     printHint(theme, '入口之间并行测速，单入口多轮顺序执行，避免同时打出过多真实请求。');
     printHint(theme, '综合推荐规则：成功率优先，其次按首包、完成、尾延迟和健康检查计算体验分，分数越低越好；完成最快会单独标出。');
-    printHint(theme, `模型：${model.id}，测速输出上限：${maxOutputTokens}`);
-    const results = await benchmarkNodes(INGRESS_NODES, {
+    printHint(theme, `测速模型：${model.id}`);
+    const results = await benchmarkNodes(ingressNodes, {
       apiKey,
       model: model.id,
-      effort: effort.id,
       maxOutputTokens,
       rounds: Number(args.rounds || 3)
     });
@@ -60,10 +64,12 @@ export async function runCli(argv = []) {
     const written = writeClientConfig(client.id, {
       apiKey,
       model: model.id,
-      effort: effort.id,
       contextLength,
       maxOutputTokens: model.maxOutputTokens,
-      node: selectedNode
+      models,
+      platform,
+      node: selectedNode,
+      imageMCP: validation.imageMCP
     });
 
     console.log('');
@@ -71,8 +77,8 @@ 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)) {
-      printHint(theme, '已写入 GPTeam Image MCP。客户端对话里需要生图或图生图时优先调用 create_image_job，再用 get_image_job_status 和 download_image_result 取结果，get_capabilities 可查看支持能力，MCP 使用专用环境变量读取 API key。');
+    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 {
     rl.close();
@@ -143,23 +149,26 @@ export function resultMarker(item, recommended, fastestTotal) {
   return labels.length ? labels.join('/') : '-';
 }
 
-async function chooseModel(rl, models, preferred, theme) {
-  const selected = preferred ? modelByID(models, preferred) : null;
-  if (selected) return selected;
-  printSubTitle(theme, '可用模型');
-  models.forEach((model, index) => {
-    console.log(`  ${theme.info(String(index + 1).padStart(2, ' '))}  ${formatModelLabel(model)}`);
-  });
-  const answer = await askRequired(rl, '请选择模型序号：');
-  const index = Math.max(1, Math.min(models.length, Number(answer) || 1)) - 1;
-  return models[index];
+export function selectDefaultModel(models, preferred, platform) {
+  const available = Array.isArray(models) ? models.filter((model) => model && model.id) : [];
+  if (!available.length) {
+    throw new Error('没有可配置模型，已停止写入客户端配置');
+  }
+  const current = normalizePlatform(platform);
+  const preferredIDs = defaultModelCandidates(current, preferred);
+  for (const id of preferredIDs) {
+    const match = available.find((model) => model.id === id);
+    if (match) return match;
+  }
+  return available[0];
 }
 
-async function askContextLength(rl, model, preferred) {
-  const max = Number(model.contextLength || 400000);
-  if (preferred) return clamp(Number(preferred), 1, max);
-  const answer = await rl.question(`请输入可配置上下文长度（最大 ${max}，输出上限 ${model.maxOutputTokens}，默认 ${max}，回车即选择默认）：`);
-  return clamp(Number(answer || max), 1, max);
+function defaultModelCandidates(platform, preferred) {
+  const ids = [];
+  if (platform === 'gemini') ids.push('gemini-3.1-pro-preview');
+  if (platform === 'openai') ids.push(DEFAULT_OPENAI_MODEL_ID);
+  ids.push(preferred);
+  return [...new Set(ids.map((id) => String(id || '').trim()).filter(Boolean))];
 }
 
 export async function chooseNode(rl, results, preferred, recommendedID, theme = createTheme()) {
@@ -212,15 +221,42 @@ function formatScore(value) {
   return Number.isFinite(value) ? String(Math.round(value)) : '-';
 }
 
-function clamp(value, min, max) {
-  if (!Number.isFinite(value)) return max;
-  return Math.max(min, Math.min(max, Math.floor(value)));
+export function formatModelLabel(model) {
+  return String(model?.id || '');
 }
 
-export function formatModelLabel(model) {
-  const context = Number(model.contextLength || 0);
-  const outputTokens = Number(model.maxOutputTokens || 0);
-  return `${model.id}（可配置上下文 ${context}，输出上限 ${outputTokens}）`;
+export function filterClientsForCapabilities(clients, allowedIDs) {
+  if (!Array.isArray(allowedIDs) || !allowedIDs.length) return clients;
+  const allowed = new Set(allowedIDs.flatMap((id) => {
+    const value = String(id);
+    return value === 'codex' ? ['codex', 'codex-ws'] : [value];
+  }));
+  const filtered = clients.filter((client) => allowed.has(client.id));
+  return filtered.length ? filtered : clients;
+}
+
+export function clientIDsForPlatform(platform) {
+  const current = normalizePlatform(platform);
+  if (current === 'anthropic') return ['claude-code', 'opencode'];
+  if (current === 'gemini') return ['gemini', 'opencode'];
+  if (current === 'ark' || current === 'openai-compatible') return ['opencode'];
+  return ['codex', 'codex-ws', 'claude-code', 'opencode'];
+}
+
+function normalizePlatform(value) {
+  const key = String(value || '').trim().toLowerCase().replace(/[\s_-]+/g, '');
+  if (!key) return 'openai';
+  if (key.includes('anthropic') || key.includes('claude')) return 'anthropic';
+  if (key.includes('gemini') || key.includes('google')) return 'gemini';
+  if (key.includes('ark') || key.includes('volc') || key.includes('doubao') || key.includes('openaicompatible')) return 'ark';
+  return 'openai';
+}
+
+function formatValidationSummary(validation) {
+  const group = validation.group && validation.group.name
+    ? `，分组：${validation.group.name}`
+    : '';
+  return `API key 可用，校验入口：${validation.node.label}${group}`;
 }
 
 export function formatNodeLabel(node) {
@@ -234,7 +270,7 @@ export function assertNodeConfig(node) {
 }
 
 function printBanner(theme) {
-  console.log(theme.brand('GPTeam API 配置助手'));
+  console.log(theme.brand('GPTEAM API 配置助手'));
   console.log(theme.muted('真实请求测速，自动写入客户端配置，旧配置会先备份。'));
 }
 

package/lib/client-install.js

@@ -8,6 +8,13 @@ export const CLIENT_INSTALL_SPECS = {
     installCommand: ['npm', ['i', '-g', '@openai/codex@latest']],
     versionHint: 'codex --version'
   },
+  'codex-ws': {
+    id: 'codex-ws',
+    label: 'Codex (WebSocket)',
+    command: 'codex',
+    installCommand: ['npm', ['i', '-g', '@openai/codex@latest']],
+    versionHint: 'codex --version'
+  },
   opencode: {
     id: 'opencode',
     label: 'OpenCode',
@@ -22,6 +29,13 @@ export const CLIENT_INSTALL_SPECS = {
     installCommand: ['npm', ['i', '-g', '@anthropic-ai/claude-code@latest']],
     versionHint: 'claude --version'
   },
+  gemini: {
+    id: 'gemini',
+    label: 'Gemini CLI',
+    command: 'gemini',
+    installCommand: ['npm', ['i', '-g', '@google/gemini-cli@latest']],
+    versionHint: 'gemini --version'
+  },
   openclaw: {
     id: 'openclaw',
     label: 'OpenClaw',

package/lib/config.js

@@ -2,7 +2,8 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import JSON5 from 'json5';
-import { endpointRoot } from './nodes.js';
+import { DEFAULT_OPENAI_SMALL_MODEL_ID } from './models.js';
+import { endpointAPIBase, endpointRoot } from './nodes.js';
 
 const PROVIDER_ID = 'gpteam';
 const IMAGE_MCP_ID = 'gpteam_image';
@@ -18,15 +19,19 @@ const IMAGE_MCP_ENABLED_TOOLS = [
 
 export const CLIENTS = [
   { id: 'codex', label: 'Codex' },
+  { id: 'codex-ws', label: 'Codex (WebSocket)' },
   { id: 'opencode', label: 'OpenCode' },
   { id: 'claude-code', label: 'Claude Code' },
+  { id: 'gemini', label: 'Gemini CLI' },
   { id: 'openclaw', label: 'OpenClaw（macOS / Linux）' }
 ];
 
 export function writeClientConfig(clientID, settings) {
   if (clientID === 'codex') return writeCodexConfig(settings);
+  if (clientID === 'codex-ws') return writeCodexConfig({ ...settings, websocket: true });
   if (clientID === 'opencode') return writeOpenCodeConfig(settings);
   if (clientID === 'claude-code') return writeClaudeCodeConfig(settings);
+  if (clientID === 'gemini') return writeGeminiCLIConfig(settings);
   if (clientID === 'openclaw') return writeOpenClawConfig(settings);
   throw new Error(`未知客户端：${clientID}`);
 }
@@ -44,8 +49,6 @@ export function writeCodexConfig(settings) {
   const managedRoot = [
     `model = ${tomlString(settings.model)}`,
     `model_provider = "gpteam"`,
-    `model_context_window = ${Number(settings.contextLength)}`,
-    `model_reasoning_effort = ${tomlString(settings.effort)}`,
     'disable_response_storage = true'
   ];
   const managedProvider = [
@@ -56,7 +59,11 @@ export function writeCodexConfig(settings) {
     'requires_openai_auth = true',
     'supports_websockets = true'
   ];
+  const websocketFeature = settings.websocket === true
+    ? ['[features]', 'responses_websockets_v2 = true']
+    : [];
   const mcpCommand = codexImageMCPCommand();
+  const mcpEnv = imageMCPEnv(settings);
   const managedImageMCP = [
     `[mcp_servers.${IMAGE_MCP_ID}]`,
     `command = ${tomlString(mcpCommand.command)}`,
@@ -67,15 +74,17 @@ export function writeCodexConfig(settings) {
     'default_tools_approval_mode = "prompt"',
     '',
     `[mcp_servers.${IMAGE_MCP_ID}.env]`,
-    `GPTEAM_API_KEY = ${tomlString(settings.apiKey)}`,
-    `GPTEAM_BASE_URL = ${tomlString(settings.node.baseUrl)}`,
-    `GPTEAM_CODEX_HOME = ${tomlString(dir)}`
+    `GPTEAM_API_KEY = ${tomlString(mcpEnv.GPTEAM_API_KEY)}`,
+    `GPTEAM_BASE_URL = ${tomlString(mcpEnv.GPTEAM_BASE_URL)}`,
+    `GPTEAM_CODEX_HOME = ${tomlString(dir)}`,
+    ...imageMCPConcurrencyEnvLines(mcpEnv)
   ];
   const next = joinTomlSections([
     managedRoot.join('\n'),
     rootLines.join('\n'),
     rest.join('\n'),
-    managedImageMCP.join('\n'),
+    websocketFeature.join('\n'),
+    imageMCPEnabled(settings) ? managedImageMCP.join('\n') : '',
     managedProvider.join('\n')
   ]);
   assertNoDuplicateTomlKeys(next);
@@ -91,33 +100,30 @@ export function writeOpenCodeConfig(settings) {
   backupIfExists(filePath);
   const config = readJSON(filePath, { $schema: 'https://opencode.ai/config.json' });
   config.provider = config.provider && typeof config.provider === 'object' ? config.provider : {};
+  const providerProfile = openCodeProviderProfile(settings);
   config.provider[PROVIDER_ID] = {
-    npm: '@ai-sdk/openai',
-    name: 'GPTeam',
+    npm: providerProfile.npm,
+    name: 'GPTEAM',
     options: {
       apiKey: settings.apiKey,
-      baseURL: settings.node.baseUrl,
+      baseURL: providerProfile.baseURL,
       setCacheKey: true
     },
-    models: {
-      [settings.model]: {
-        name: settings.model,
-        limit: {
-          context: Number(settings.contextLength),
-          output: Number(settings.maxOutputTokens)
-        },
-        variants: {
-          [settings.effort]: {
-            reasoningEffort: settings.effort,
-            reasoningSummary: 'auto',
-            textVerbosity: 'medium'
-          }
-        }
-      }
-    }
+    models: openCodeModels(settings)
   };
+  const modelEntries = normalizeSettingsModels(settings);
+  const defaultModel = resolveOpenCodeDefaultModel(settings, modelEntries);
+  if (defaultModel) {
+    const smallModel = resolveOpenCodeSmallModel(settings, modelEntries, defaultModel);
+    config.model = `${PROVIDER_ID}/${defaultModel}`;
+    config.small_model = `${PROVIDER_ID}/${smallModel}`;
+  }
   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];
 }
@@ -137,21 +143,39 @@ export function writeClaudeCodeConfig(settings) {
     ANTHROPIC_MODEL: settings.model,
     ANTHROPIC_DEFAULT_HAIKU_MODEL: settings.model,
     ANTHROPIC_DEFAULT_SONNET_MODEL: settings.model,
-    ANTHROPIC_DEFAULT_OPUS_MODEL: settings.model,
-    ANTHROPIC_CUSTOM_HEADERS: `X-Codex-Reasoning-Effort: ${settings.effort}`
+    ANTHROPIC_DEFAULT_OPUS_MODEL: settings.model
   });
+  delete config.env.ANTHROPIC_CUSTOM_HEADERS;
   writeJSON(filePath, config);
   const mcpConfig = readJSON(mcpPath, {});
   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];
 }
 
 export const writeClaudeCodeEnv = writeClaudeCodeConfig;
 
+export function writeGeminiCLIConfig(settings) {
+  const dir = path.join(homeDir(), '.gpteam');
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const filePath = path.join(dir, 'gemini-cli.env');
+  backupIfExists(filePath);
+  const lines = [
+    `export GOOGLE_GEMINI_BASE_URL=${shellString(geminiBaseUrl(settings.node.baseUrl))}`,
+    `export GEMINI_API_KEY=${shellString(settings.apiKey)}`,
+    `export GEMINI_MODEL=${shellString(settings.model)}`
+  ];
+  writeTextAtomic(filePath, `${lines.join('\n')}\n`, 0o600);
+  return [filePath];
+}
+
 export function writeOpenClawConfig(settings) {
   if (process.platform === 'win32') {
     throw new Error('OpenClaw 自动配置当前只支持 macOS / Linux');
@@ -215,6 +239,185 @@ function claudeBaseUrl(baseUrl) {
   return `${root}/anthropic`;
 }
 
+function geminiBaseUrl(baseUrl) {
+  const root = endpointRoot(baseUrl);
+  if (/\/v1beta\/?$/.test(root)) return root.replace(/\/$/, '');
+  return `${root}/v1beta`;
+}
+
+function openCodeProviderProfile(settings) {
+  const platform = normalizePlatform(settings?.platform || settings?.group?.platform);
+  const baseUrl = settings?.node?.baseUrl || '';
+  if (platform === 'anthropic') {
+    return { npm: '@ai-sdk/anthropic', baseURL: claudeBaseUrl(baseUrl) };
+  }
+  if (platform === 'gemini') {
+    return { npm: '@ai-sdk/google', baseURL: geminiBaseUrl(baseUrl) };
+  }
+  if (platform === 'ark' || platform === 'openai-compatible') {
+    return { npm: '@ai-sdk/openai-compatible', baseURL: endpointAPIBase(baseUrl) };
+  }
+  return { npm: '@ai-sdk/openai', baseURL: endpointAPIBase(baseUrl) };
+}
+
+function resolveOpenCodeDefaultModel(settings, entries = normalizeSettingsModels(settings)) {
+  return String(settings.model || entries[0]?.id || '').trim();
+}
+
+function resolveOpenCodeSmallModel(settings, entries, defaultModel) {
+  const platform = normalizePlatform(settings?.platform || settings?.group?.platform);
+  if (platform === 'openai') {
+    const smallModel = findOpenCodeModelID(entries, DEFAULT_OPENAI_SMALL_MODEL_ID);
+    if (smallModel) return smallModel;
+  }
+  return defaultModel;
+}
+
+function findOpenCodeModelID(entries, id) {
+  const target = String(id || '').trim();
+  if (!target) return '';
+  const match = (entries || []).find((model) => String(model?.id || model?.name || '').trim() === target);
+  return match ? target : '';
+}
+
+function openCodeModels(settings) {
+  const entries = normalizeSettingsModels(settings);
+  const out = {};
+  for (const model of entries) {
+    const id = String(model.id || model.name || '').trim();
+    if (!id || out[id]) continue;
+    const limit = {};
+    const context = Number(model.contextLength || model.context_length || model.inputTokenLimit || settings.contextLength);
+    const output = Number(model.maxOutputTokens || model.max_completion_tokens || model.outputTokenLimit || settings.maxOutputTokens);
+    if (Number.isFinite(context) && context > 0) limit.context = Math.floor(context);
+    if (Number.isFinite(output) && output > 0) limit.output = Math.floor(output);
+    const item = {
+      id,
+      name: String(model.displayName || model.display_name || id),
+      tool_call: true,
+      modalities: { input: ['text'], output: ['text'] },
+      ...(Object.keys(limit).length >= 2 ? { limit } : {})
+    };
+    if (openCodeModelSupportsReasoning(model, settings)) {
+      item.reasoning = true;
+      const options = openCodeModelOptions(model, settings);
+      if (Object.keys(options).length > 0) item.options = options;
+      const variants = openCodeModelVariants(model, settings);
+      if (Object.keys(variants).length > 0) item.variants = variants;
+    }
+    out[id] = item;
+  }
+  return out;
+}
+
+function openCodeModelOptions(model, settings) {
+  const platform = normalizePlatform(settings?.platform || settings?.group?.platform);
+  if (platform === 'anthropic') {
+    return { thinking: { type: 'enabled', budgetTokens: openCodeThinkingBudget(model) } };
+  }
+  if (platform === 'openai') {
+    return { reasoningEffort: 'high' };
+  }
+  if (platform === 'gemini') {
+    return openCodeGeminiThinkingOptions(model, 'high');
+  }
+  return {};
+}
+
+function openCodeModelVariants(model, settings) {
+  const platform = normalizePlatform(settings?.platform || settings?.group?.platform);
+  if (platform === 'openai') return openCodeOpenAIVariants(model);
+  if (platform === 'anthropic') return openCodeAnthropicVariants(model);
+  if (platform === 'gemini') return openCodeGeminiVariants(model);
+  return {};
+}
+
+function openCodeOpenAIVariants(model) {
+  return Object.fromEntries(openCodeThinkingLevels(model, ['low', 'medium', 'high', 'xhigh'])
+    .map((level) => [level, { reasoningEffort: level }]));
+}
+
+function openCodeAnthropicVariants(model) {
+  const budgets = { low: 8000, medium: 16000, high: 32000, xhigh: 64000 };
+  return Object.fromEntries(openCodeThinkingLevels(model, ['low', 'medium', 'high', 'xhigh'])
+    .map((level) => [level, { thinking: { type: 'enabled', budgetTokens: budgets[level] || 32000 } }]));
+}
+
+function openCodeGeminiVariants(model) {
+  return Object.fromEntries(openCodeThinkingLevels(model, ['low', 'medium', 'high'])
+    .map((level) => [level, openCodeGeminiThinkingOptions(model, level)]));
+}
+
+function openCodeThinkingLevels(model, fallback) {
+  const levels = Array.isArray(model?.thinking?.levels) ? model.thinking.levels : fallback;
+  const out = [];
+  for (const level of levels) {
+    const normalized = String(level || '').trim().toLowerCase();
+    if (normalized && !out.includes(normalized)) out.push(normalized);
+  }
+  return out;
+}
+
+function openCodeGeminiThinkingOptions(model, level) {
+  const id = String(model?.id || model?.name || '').toLowerCase();
+  if (/gemini-3/.test(id)) return { thinkingConfig: { thinkingLevel: level } };
+  const budgets = { low: 1024, medium: 8192, high: 24576 };
+  return { thinkingConfig: { thinkingBudget: budgets[level] || 24576 } };
+}
+
+function openCodeThinkingBudget(model) {
+  const values = [
+    model?.thinking?.budgetTokens,
+    model?.thinking?.budget_tokens,
+    model?.thinkingBudgetTokens
+  ];
+  for (const value of values) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
+  }
+  return 32000;
+}
+
+function openCodeModelSupportsReasoning(model, settings) {
+  if (model && model.thinking && typeof model.thinking === 'object') return true;
+  const id = String(model?.id || model?.name || '').toLowerCase();
+  const platform = normalizePlatform(settings?.platform || settings?.group?.platform);
+  if (/thinking|reasoning/.test(id)) return true;
+  if (platform === 'openai' && /^(gpt-|codex-)/.test(id)) return true;
+  if (platform === 'anthropic' && /^claude-/.test(id)) return true;
+  if (platform === 'gemini' && /^gemini-(3|2\.5)/.test(id)) return true;
+  return false;
+}
+
+function normalizeSettingsModels(settings) {
+  const models = Array.isArray(settings?.models) ? settings.models : [];
+  const entries = models.length ? models : [{
+    id: settings.model,
+    contextLength: settings.contextLength,
+    maxOutputTokens: settings.maxOutputTokens
+  }];
+  return entries.filter((model) => model && String(model.id || model.name || '').trim());
+}
+
+function normalizePlatform(value) {
+  const key = String(value || '').trim().toLowerCase().replace(/[\s_-]+/g, '');
+  if (!key) return 'openai';
+  if (key.includes('anthropic') || key.includes('claude')) return 'anthropic';
+  if (key.includes('gemini') || key.includes('google')) return 'gemini';
+  if (
+    key.includes('ark') ||
+    key.includes('volc') ||
+    key.includes('doubao') ||
+    key.includes('bytedance') ||
+    key.includes('openaicompatible')
+  ) return 'ark';
+  return 'openai';
+}
+
+function shellString(value) {
+  return `"${String(value || '').replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
 function codexImageMCPCommand() {
   if (process.platform === 'win32') {
     return {
@@ -238,10 +441,34 @@ function imageMCPServer(settings) {
 }
 
 function imageMCPEnv(settings) {
-  return {
+  const env = {
     GPTEAM_API_KEY: String(settings.apiKey || ''),
     GPTEAM_BASE_URL: String(settings.node && settings.node.baseUrl ? settings.node.baseUrl : '')
   };
+  const maxConcurrent = positiveIntString(settings?.imageMCP?.max_concurrent_jobs);
+  if (maxConcurrent) env.GPTEAM_IMAGE_MAX_CONCURRENT = maxConcurrent;
+  const maxQueue = positiveIntString(settings?.imageMCP?.max_queued_jobs, true);
+  if (maxQueue) env.GPTEAM_IMAGE_MAX_QUEUE = maxQueue;
+  return env;
+}
+
+function imageMCPConcurrencyEnvLines(env) {
+  const lines = [];
+  if (env.GPTEAM_IMAGE_MAX_CONCURRENT) {
+    lines.push(`GPTEAM_IMAGE_MAX_CONCURRENT = ${tomlString(env.GPTEAM_IMAGE_MAX_CONCURRENT)}`);
+  }
+  if (env.GPTEAM_IMAGE_MAX_QUEUE) {
+    lines.push(`GPTEAM_IMAGE_MAX_QUEUE = ${tomlString(env.GPTEAM_IMAGE_MAX_QUEUE)}`);
+  }
+  return lines;
+}
+
+function positiveIntString(value, allowZero = false) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return '';
+  const rounded = Math.floor(parsed);
+  if (allowZero ? rounded < 0 : rounded <= 0) return '';
+  return String(rounded);
 }
 
 function openCodeImageMCPConfig(settings) {
@@ -254,6 +481,10 @@ function openCodeImageMCPConfig(settings) {
   };
 }
 
+function imageMCPEnabled(settings) {
+  return settings?.imageMCP?.enabled === true;
+}
+
 function stripCodexManagedConfig(raw) {
   const rootLines = [];
   const rest = [];

package/lib/help.js

@@ -1,9 +1,9 @@
 export const PACKAGE_NAME = 'gpteam';
-export const PACKAGE_VERSION = '0.1.28';
+export const PACKAGE_VERSION = '0.1.30';
 
 export function getHelpText() {
   return [
-    'GPTeam API 配置助手',
+    'GPTEAM API 配置助手',
     '',
     '用法：',
     '  npx gpteam',
@@ -11,17 +11,13 @@ export function getHelpText() {
     '',
     '常用参数：',
     '  --api-key <key>          预填 API key',
-    '  --client <id>            codex / opencode / claude-code / openclaw',
-    '  --model <id>             预选模型，例如 gpt-5.5',
-    '  --context <tokens>       预设可配置上下文长度',
-    '  --effort <level>         按模型支持项预选，常见为 none / low / medium / high / xhigh',
-    '  --node <id>              main / jp / hk（兼容旧参数 jp-direct / jp-split / hk-split）',
+    '  --client <id>            codex / codex-ws / claude-code / opencode / gemini',
+    '  --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/errors.js

@@ -2,7 +2,7 @@ import { formatNetworkError } from '../errors.js';
 
 export class ImageMCPError extends Error {
   constructor(message, options = {}) {
-    super(String(message || 'GPTeam image MCP error'));
+    super(String(message || 'GPTEAM image MCP error'));
     this.name = 'ImageMCPError';
     this.code = String(options.code || 'image_mcp_error');
     this.category = String(options.category || 'unknown');

package/lib/image-mcp/files.js

@@ -77,7 +77,7 @@ export function normalizeImageFormat(value) {
 function decodeBase64Image(value) {
   const text = String(value || '').trim();
   if (!text) {
-    throw new ImageMCPError('GPTeam 图片接口没有返回 b64_json 图片数据。', {
+    throw new ImageMCPError('GPTEAM 图片接口没有返回 b64_json 图片数据。', {
       code: 'image_data_missing',
       category: 'response_invalid',
       stage: 'local',
@@ -86,7 +86,7 @@ function decodeBase64Image(value) {
   }
   const bytes = Buffer.from(text, 'base64');
   if (bytes.length === 0) {
-    throw new ImageMCPError('GPTeam 图片接口返回的图片数据为空。', {
+    throw new ImageMCPError('GPTEAM 图片接口返回的图片数据为空。', {
       code: 'image_data_empty',
       category: 'response_invalid',
       stage: 'local',

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 };
 
@@ -68,15 +68,15 @@ export function buildImageGenerationPayload(input = {}, options = {}) {
   return payload;
 }
 
-export function loadGPTeamCredentials(options = {}) {
+export function loadGPTEAMCredentials(options = {}) {
   const env = options.env || process.env;
   const codexHome = resolveCodexHome(env, options.home || os.homedir());
   const readFile = options.readFile || ((filePath) => fs.readFileSync(filePath, 'utf8'));
   const configText = safeRead(path.join(codexHome, 'config.toml'), readFile);
-  const configuredBaseUrl = parseGPTeamBaseUrl(configText);
+  const configuredBaseUrl = parseGPTEAMBaseUrl(configText);
   const apiKey = firstNonEmpty(env.GPTEAM_API_KEY);
   if (!apiKey) {
-    throw new ImageMCPError('没有找到 GPTeam API key。请在 MCP 配置 env 中设置 GPTEAM_API_KEY，或先运行 npx gpteam 完成本地配置。', {
+    throw new ImageMCPError('没有找到 GPTEAM API key。请在 MCP 配置 env 中设置 GPTEAM_API_KEY，或先运行 npx gpteam 完成本地配置。', {
       code: 'api_key_missing',
       category: 'configuration',
       stage: 'configuration',
@@ -87,16 +87,16 @@ export function loadGPTeamCredentials(options = {}) {
   return { apiKey, baseUrl, codexHome };
 }
 
-export function parseGPTeamBaseUrl(configText) {
-  let inGPTeamProvider = false;
+export function parseGPTEAMBaseUrl(configText) {
+  let inGPTEAMProvider = false;
   for (const rawLine of String(configText || '').split(/\r?\n/)) {
     const line = rawLine.trim();
     const table = line.match(/^\[([^\]]+)\]$/);
     if (table) {
-      inGPTeamProvider = table[1] === 'model_providers.gpteam';
+      inGPTEAMProvider = table[1] === 'model_providers.gpteam';
       continue;
     }
-    if (!inGPTeamProvider) continue;
+    if (!inGPTEAMProvider) continue;
     const match = line.match(/^base_url\s*=\s*"((?:\\"|[^"])*)"/);
     if (match) return unescapeTomlString(match[1]);
   }
@@ -113,7 +113,7 @@ export function normalizeBaseUrl(value) {
 export async function generateImage(input = {}, options = {}) {
   const startedAt = now(options);
   validateImageInput(input, { requirePrompt: true });
-  const credentials = loadGPTeamCredentials(options);
+  const credentials = loadGPTEAMCredentials(options);
   const payload = buildImageGenerationPayload(input, options);
   const fetchImpl = options.fetch || globalThis.fetch;
   if (typeof fetchImpl !== 'function') {
@@ -459,7 +459,7 @@ function imageDataURLToB64(value) {
 }
 
 function missingImageDataError() {
-  return new ImageMCPError('GPTeam 图片接口没有返回 b64_json 图片数据。', {
+  return new ImageMCPError('GPTEAM 图片接口没有返回 b64_json 图片数据。', {
     code: 'image_data_missing',
     category: 'response_invalid',
     stage: 'local',
@@ -469,7 +469,7 @@ function missingImageDataError() {
 
 function imageErrorFromSSEPayload(payload) {
   const error = payload && payload.error;
-  const message = typeof error === 'string' ? error : String(error && error.message || 'GPTeam 图片流返回错误。');
+  const message = typeof error === 'string' ? error : String(error && error.message || 'GPTEAM 图片流返回错误。');
   const code = typeof error === 'object' && error ? String(error.code || payload.code || 'upstream_stream_error') : String(payload.code || 'upstream_stream_error');
   return new ImageMCPError(message, {
     code,
@@ -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

@@ -94,7 +94,7 @@ const imageInputProperties = {
   },
   input_fidelity: {
     type: 'string',
-    description: '兼容字段。当前 GPTeam Image 2 桥接会忽略该字段，因为上游 Codex 图片工具会拒绝 edits 中的该参数。',
+    description: '兼容字段。当前 GPTEAM Image 2 桥接会忽略该字段，因为上游 Codex 图片工具会拒绝 edits 中的该参数。',
     enum: ['low', 'high']
   },
   background: {
@@ -126,7 +126,7 @@ const imageInputProperties = {
 const tools = [
   {
     name: 'create_image_job',
-    description: `推荐常规使用。创建本地后台 GPTeam Image 2 任务并立即返回 job_id。${imageToolPromptingInstruction}`,
+    description: `推荐常规使用。创建本地后台 GPTEAM Image 2 任务并立即返回 job_id。${imageToolPromptingInstruction}`,
     inputSchema: {
       type: 'object',
       properties: imageInputProperties,
@@ -136,12 +136,12 @@ const tools = [
   },
   {
     name: 'get_image_job_status',
-    description: '查询本地 GPTeam Image 2 图片任务状态。',
+    description: '查询本地 GPTEAM Image 2 图片任务状态。',
     inputSchema: jobIDSchema()
   },
   {
     name: 'cancel_image_job',
-    description: '取消仍在 queued 或 running 的本地 GPTeam Image 2 图片任务。取消是 best-effort，上游已开始生成时不保证同步取消。',
+    description: '取消仍在 queued 或 running 的本地 GPTEAM Image 2 图片任务。取消是 best-effort，上游已开始生成时不保证同步取消。',
     inputSchema: jobIDSchema()
   },
   {
@@ -151,7 +151,7 @@ const tools = [
   },
   {
     name: 'get_capabilities',
-    description: '返回 GPTeam Image MCP 能力，包括支持尺寸、格式、质量、异步任务、取消语义、队列上限和参数约束。',
+    description: '返回 GPTEAM Image MCP 能力，包括支持尺寸、格式、质量、异步任务、取消语义、队列上限和参数约束。',
     inputSchema: {
       type: 'object',
       properties: {},
@@ -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,12 +1,10 @@
 import { formatNetworkError } from './errors.js';
+import { nodeAPIBaseUrl } from './nodes.js';
+
+export const DEFAULT_OPENAI_MODEL_ID = 'gpt-5.5';
+export const DEFAULT_OPENAI_SMALL_MODEL_ID = 'gpt-5.4-mini';
 
 export const FALLBACK_MODELS = {
-  'gpt-5.2': {
-    id: 'gpt-5.2',
-    contextLength: 400000,
-    maxOutputTokens: 128000,
-    efforts: ['none', 'low', 'medium', 'high', 'xhigh']
-  },
   'gpt-5.3-codex': {
     id: 'gpt-5.3-codex',
     contextLength: 400000,
@@ -39,26 +37,63 @@ 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),
+    defaultModel: String(payload?.default_model || payload?.defaultModel || models?.default_model || models?.defaultModel || '').trim(),
+    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 +108,60 @@ 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-|doubao-|deepseek-|kimi-|qwen|glm-|moonshot-|yi-|baichuan-|step-|minimax-)/.test(id);
+  if (!owner) return knownTextPrefix || Object.prototype.hasOwnProperty.call(FALLBACK_MODELS, id);
+  return [
+    'openai',
+    'codex',
+    'openai-compatible',
+    'ark',
+    'volcengine',
+    'volc',
+    'doubao',
+    'bytedance',
+    'deepseek',
+    'kimi',
+    'moonshot',
+    'qwen',
+    'aliyun',
+    'zhipu',
+    'glm',
+    'baichuan',
+    'stepfun',
+    'minimax',
+    '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 +192,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 +235,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

@@ -3,22 +3,15 @@ export const INGRESS_NODES = [
     id: 'main',
     aliases: ['jp-direct'],
     label: '主入口',
-    baseUrl: 'https://api.gpteamservices.com/v1',
+    baseUrl: 'https://api.gpteamservices.com',
     healthUrl: 'https://api.gpteamservices.com/api/health'
   },
   {
     id: 'jp',
     aliases: ['jp-split'],
     label: '日本入口',
-    baseUrl: 'https://api-jp.gpteamservices.com/v1',
+    baseUrl: 'https://api-jp.gpteamservices.com',
     healthUrl: 'https://api-jp.gpteamservices.com/api/health'
-  },
-  {
-    id: 'hk',
-    aliases: ['hk-split'],
-    label: '香港入口',
-    baseUrl: 'https://api-hk.gpteamservices.com/v1',
-    healthUrl: 'https://api-hk.gpteamservices.com/api/health'
   }
 ];
 
@@ -31,3 +24,36 @@ export function nodeMatchesID(node, id) {
 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,7 +1,7 @@
 {
   "name": "gpteam",
-  "version": "0.1.28",
-  "description": "GPTeam API interactive client configurator and ingress benchmark CLI.",
+  "version": "0.1.30",
+  "description": "GPTEAM API interactive client configurator and ingress benchmark CLI.",
   "type": "module",
   "bin": {
     "gpteam": "bin/gpteam-api-config.js",