gpteam 0.1.0

package/README.md

@@ -0,0 +1,23 @@
+# GPTeam CLI
+
+Interactive GPTeam API client configurator.
+
+```bash
+npx gpteam
+```
+
+The CLI asks for an API key, detects available models, benchmarks all production ingress endpoints with real API requests, then writes the selected client configuration after backing up existing files.
+
+Supported clients:
+
+- Codex
+- OpenCode
+- Claude Code
+- OpenClaw on macOS and Linux
+
+Useful non-interactive smoke checks:
+
+```bash
+npx gpteam --help
+npx gpteam --version
+```

package/bin/gpteam-api-config.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { runCli } from '../lib/cli.js';
+
+runCli(process.argv.slice(2)).catch((error) => {
+  console.error(`\n配置失败：${error && error.message ? error.message : error}`);
+  process.exitCode = 1;
+});

package/lib/bench.js

@@ -0,0 +1,162 @@
+import dns from 'node:dns';
+import https from 'node:https';
+import { performance } from 'node:perf_hooks';
+import { inspectSSEBody } from './sse.js';
+
+export async function benchmarkNodes(nodes, options) {
+  const rounds = options.rounds || 3;
+  const results = [];
+  for (const node of nodes) {
+    const samples = [];
+    for (let index = 0; index < rounds; index += 1) {
+      samples.push(await benchmarkNode(node, options));
+    }
+    results.push(summarizeNode(node, samples));
+  }
+  return results.sort((a, b) => scoreResult(a) - scoreResult(b));
+}
+
+export async function benchmarkNode(node, options) {
+  const health = await measureHealth(node.healthUrl);
+  const stream = await measureStream(node.baseUrl, options);
+  return {
+    ok: health.ok && stream.ok,
+    health,
+    stream,
+    error: health.error || stream.error || ''
+  };
+}
+
+export function summarizeNode(node, samples) {
+  const successful = samples.filter((sample) => sample.ok);
+  const streams = successful.map((sample) => sample.stream);
+  return {
+    node,
+    samples,
+    successRate: samples.length ? successful.length / samples.length : 0,
+    firstEventMs: median(streams.map((item) => item.firstEventMs).filter(Number.isFinite)),
+    totalMs: median(streams.map((item) => item.totalMs).filter(Number.isFinite)),
+    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)),
+    error: samples.find((sample) => sample.error)?.error || ''
+  };
+}
+
+export function formatMs(value) {
+  if (!Number.isFinite(value)) return '-';
+  if (value < 1000) return `${Math.round(value)}ms`;
+  return `${(value / 1000).toFixed(2)}s`;
+}
+
+function scoreResult(result) {
+  if (!result.successRate) return Number.MAX_SAFE_INTEGER;
+  return (result.firstEventMs || 999999) + (result.totalMs || 999999) - result.successRate * 1000;
+}
+
+async function measureHealth(url) {
+  const started = performance.now();
+  try {
+    const response = await fetch(url, { headers: { 'User-Agent': 'gpteam-api-config/0.1' } });
+    await response.arrayBuffer();
+    return {
+      ok: response.ok,
+      status: response.status,
+      totalMs: performance.now() - started,
+      error: response.ok ? '' : `health HTTP ${response.status}`
+    };
+  } catch (error) {
+    return { ok: false, status: 0, totalMs: performance.now() - started, error: error.message };
+  }
+}
+
+function measureStream(baseUrl, options) {
+  return new Promise((resolve) => {
+    const url = new URL(`${baseUrl.replace(/\/$/, '')}/responses`);
+    const started = performance.now();
+    const timings = { dnsMs: NaN, tcpMs: NaN, tlsMs: NaN, firstEventMs: NaN };
+    const payload = JSON.stringify({
+      model: options.model,
+      stream: true,
+      input: options.prompt || '请只回复一句话：节点测速完成。',
+      max_output_tokens: options.maxOutputTokens || 648,
+      reasoning: options.effort ? { effort: options.effort } : undefined,
+      metadata: { gpteam_config_probe: '1' }
+    });
+
+    const request = https.request({
+      protocol: url.protocol,
+      hostname: url.hostname,
+      port: url.port || 443,
+      path: url.pathname,
+      method: 'POST',
+      timeout: options.timeoutMs || 45000,
+      headers: {
+        Authorization: `Bearer ${options.apiKey}`,
+        'Content-Type': 'application/json',
+        Accept: 'text/event-stream',
+        'Content-Length': Buffer.byteLength(payload),
+        'User-Agent': 'gpteam-api-config/0.1'
+      },
+      lookup(hostname, opts, callback) {
+        const before = performance.now();
+        dns.lookup(hostname, opts, (error, address, family) => {
+          timings.dnsMs = performance.now() - before;
+          callback(error, address, family);
+        });
+      }
+    }, (response) => {
+      let body = '';
+      response.on('data', (chunk) => {
+        if (!Number.isFinite(timings.firstEventMs)) {
+          const text = chunk.toString('utf8');
+          if (text.includes('data:') || text.trim()) timings.firstEventMs = performance.now() - started;
+        }
+        body += chunk.toString('utf8');
+      });
+      response.on('end', () => {
+        const semantic = inspectSSEBody(body);
+        const ok = response.statusCode >= 200
+          && response.statusCode < 300
+          && semantic.ok
+          && Number.isFinite(timings.firstEventMs);
+        resolve({
+          ok,
+          status: response.statusCode,
+          ...timings,
+          totalMs: performance.now() - started,
+          error: ok ? '' : semantic.error || `stream HTTP ${response.statusCode}`
+        });
+      });
+    });
+
+    request.on('socket', (socket) => {
+      const socketStarted = performance.now();
+      socket.on('connect', () => {
+        timings.tcpMs = performance.now() - socketStarted;
+      });
+      socket.on('secureConnect', () => {
+        timings.tlsMs = performance.now() - socketStarted;
+      });
+    });
+    request.on('timeout', () => request.destroy(new Error('stream timeout')));
+    request.on('error', (error) => {
+      resolve({
+        ok: false,
+        status: 0,
+        ...timings,
+        totalMs: performance.now() - started,
+        error: error.message
+      });
+    });
+    request.end(payload);
+  });
+}
+
+function median(values) {
+  if (!values.length) return NaN;
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+}

package/lib/cli.js

@@ -0,0 +1,190 @@
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { benchmarkNodes, formatMs } from './bench.js';
+import { CLIENTS, writeClientConfig } from './config.js';
+import { getHelpText, PACKAGE_NAME, PACKAGE_VERSION } from './help.js';
+import { fetchModels, modelByID, normalizeModels } from './models.js';
+import { describeSplit, INGRESS_NODES } from './nodes.js';
+
+export async function runCli(argv = []) {
+  const normalizedArgv = normalizeSubcommand(argv);
+  const args = parseArgs(normalizedArgv);
+  if (args.help || args.h) {
+    console.log(getHelpText());
+    return;
+  }
+  if (args.version || args.v) {
+    console.log(`${PACKAGE_NAME} ${PACKAGE_VERSION}`);
+    return;
+  }
+  const rl = readline.createInterface({ input, output });
+  try {
+    console.log('GPTeam API 配置助手');
+    console.log('会先做真实 API 测速，再写入客户端配置；旧配置会自动备份。\n');
+
+    const apiKey = args.key || args.apiKey || await askRequired(rl, '请输入 API key：');
+    const client = await choose(rl, '请选择客户端类型', CLIENTS, args.client);
+    const models = await loadModels(apiKey);
+    const model = await chooseModel(rl, models, args.model);
+    const contextLength = await askContextLength(rl, model, args.context);
+    const effort = await choose(rl, '请选择思考深度', model.efforts.map((id) => ({ id, label: id })), args.effort);
+    const maxOutputTokens = Number(args.maxOutputTokens || 648);
+
+    console.log('\n开始真实测速：GET /api/health + POST /v1/responses stream=true');
+    console.log(`模型：${model.id}，测速输出上限：${maxOutputTokens}`);
+    const results = await benchmarkNodes(INGRESS_NODES, {
+      apiKey,
+      model: model.id,
+      effort: effort.id,
+      maxOutputTokens,
+      rounds: Number(args.rounds || 3)
+    });
+    printResults(results);
+
+    const recommended = results.find((item) => item.successRate > 0) || results[0];
+    const selectedNode = await chooseNode(rl, results, args.node, recommended && recommended.node.id);
+    const written = writeClientConfig(client.id, {
+      apiKey,
+      model: model.id,
+      effort: effort.id,
+      contextLength,
+      maxOutputTokens: model.maxOutputTokens,
+      node: selectedNode
+    });
+
+    console.log('\n已写入配置：');
+    for (const filePath of written) console.log(`- ${filePath}`);
+    console.log(`入口：${selectedNode.label}（${describeSplit(selectedNode)}） ${selectedNode.baseUrl}`);
+  } finally {
+    rl.close();
+  }
+}
+
+export function parseArgs(argv) {
+  const result = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const item = argv[index];
+    if (!item.startsWith('--')) continue;
+    const [key, inline] = item.slice(2).split('=', 2);
+    if (inline !== undefined) {
+      result[toCamel(key)] = inline;
+      continue;
+    }
+    const next = argv[index + 1];
+    if (!next || next.startsWith('--')) {
+      result[toCamel(key)] = true;
+      continue;
+    }
+    result[toCamel(key)] = next;
+    index += 1;
+  }
+  return result;
+}
+
+export function printResults(results) {
+  const recommended = results.find((item) => item.successRate > 0);
+  const rows = results.map((item) => [
+    `${item.node.label}（${describeSplit(item.node)}）`,
+    formatMs(item.dnsMs),
+    formatMs(item.tcpMs),
+    formatMs(item.tlsMs),
+    formatMs(item.firstEventMs),
+    formatMs(item.totalMs),
+    `${Math.round(item.successRate * 100)}%`,
+    formatMs(item.healthMs),
+    item === recommended ? '推荐' : '-'
+  ]);
+  const header = ['节点', 'DNS', 'TCP', 'TLS', '首包', '完成', '成功率', '健康检查', '推荐'];
+  const widths = header.map((name, i) => Math.max(displayWidth(name), ...rows.map((row) => displayWidth(row[i]))) + 2);
+  console.log('');
+  console.log(formatRow(header, widths));
+  for (const row of rows) console.log(formatRow(row, widths));
+}
+
+async function loadModels(apiKey) {
+  for (const node of INGRESS_NODES) {
+    try {
+      return await fetchModels(node.baseUrl, apiKey);
+    } catch {
+      // 继续尝试下一个入口，全部失败时用本地兜底模型表。
+    }
+  }
+  return normalizeModels({ data: [] });
+}
+
+async function chooseModel(rl, models, preferred) {
+  const selected = preferred ? modelByID(models, preferred) : null;
+  if (selected) return selected;
+  console.log('\n可用模型：');
+  models.forEach((model, index) => {
+    console.log(`${index + 1}. ${model.id}（上下文 ${model.contextLength}，输出 ${model.maxOutputTokens}）`);
+  });
+  const answer = await askRequired(rl, '请选择模型序号：');
+  const index = Math.max(1, Math.min(models.length, Number(answer) || 1)) - 1;
+  return models[index];
+}
+
+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);
+}
+
+async function chooseNode(rl, results, preferred, recommendedID) {
+  const nodes = results.map((item) => item.node);
+  const preferredNode = nodes.find((node) => node.id === preferred);
+  if (preferredNode) return preferredNode;
+  if (recommendedID) {
+    console.log(`\n推荐入口：${recommendedID}`);
+  }
+  return (await choose(rl, '请选择最终写入的入口', nodes.map((node) => ({
+    id: node.id,
+    label: `${node.label}（${describeSplit(node)}）`
+  })))).raw;
+}
+
+async function choose(rl, title, items, preferred) {
+  const found = items.find((item) => item.id === preferred);
+  if (found) return { ...found, raw: found };
+  console.log(`\n${title}：`);
+  items.forEach((item, index) => console.log(`${index + 1}. ${item.label}`));
+  const answer = await askRequired(rl, '请输入序号：');
+  const index = Math.max(1, Math.min(items.length, Number(answer) || 1)) - 1;
+  const item = items[index];
+  return { ...item, raw: item };
+}
+
+async function askRequired(rl, prompt) {
+  for (;;) {
+    const answer = (await rl.question(prompt)).trim();
+    if (answer) return answer;
+  }
+}
+
+function formatRow(cells, widths) {
+  return cells.map((cell, index) => padCell(cell, widths[index])).join('');
+}
+
+function padCell(value, width) {
+  const text = String(value);
+  return text + ' '.repeat(Math.max(1, width - displayWidth(text)));
+}
+
+function displayWidth(value) {
+  return Array.from(String(value)).reduce((sum, char) => sum + (char.charCodeAt(0) > 255 ? 2 : 1), 0);
+}
+
+function clamp(value, min, max) {
+  if (!Number.isFinite(value)) return max;
+  return Math.max(min, Math.min(max, Math.floor(value)));
+}
+
+function toCamel(value) {
+  return value.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+
+function normalizeSubcommand(argv) {
+  if (argv[0] === 'config') return argv.slice(1);
+  return argv;
+}

package/lib/config.js

@@ -0,0 +1,172 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { endpointRoot } from './nodes.js';
+
+export const CLIENTS = [
+  { id: 'codex', label: 'Codex' },
+  { id: 'opencode', label: 'OpenCode' },
+  { id: 'claude-code', label: 'Claude Code' },
+  { id: 'openclaw', label: 'OpenClaw（macOS / Linux）' }
+];
+
+export function writeClientConfig(clientID, settings) {
+  if (clientID === 'codex') return writeCodexConfig(settings);
+  if (clientID === 'opencode') return writeOpenCodeConfig(settings);
+  if (clientID === 'claude-code') return writeClaudeCodeEnv(settings);
+  if (clientID === 'openclaw') return writeOpenClawConfig(settings);
+  throw new Error(`未知客户端：${clientID}`);
+}
+
+export function writeCodexConfig(settings) {
+  const dir = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const configPath = path.join(dir, 'config.toml');
+  const authPath = path.join(dir, 'auth.json');
+  backupIfExists(configPath);
+  backupIfExists(authPath);
+
+  const raw = fs.existsSync(configPath) ? fs.readFileSync(configPath, 'utf8') : '';
+  const cleaned = stripCodexManagedConfig(raw);
+  const managed = [
+    `model = ${tomlString(settings.model)}`,
+    `model_provider = "gpteam"`,
+    `model_context_window = ${Number(settings.contextLength)}`,
+    `model_reasoning_effort = ${tomlString(settings.effort)}`,
+    'disable_response_storage = true',
+    '',
+    '[model_providers.gpteam]',
+    'name = "gpteam"',
+    `base_url = ${tomlString(settings.node.baseUrl)}`,
+    'wire_api = "responses"',
+    'requires_openai_auth = true',
+    'supports_websockets = false'
+  ].join('\n');
+  const next = `${managed}\n\n${cleaned.trim()}`.trim() + '\n';
+  fs.writeFileSync(configPath, next, { encoding: 'utf8', mode: 0o600 });
+  fs.writeFileSync(authPath, `${JSON.stringify({ OPENAI_API_KEY: settings.apiKey }, null, 2)}\n`, {
+    encoding: 'utf8',
+    mode: 0o600
+  });
+  return [configPath, authPath];
+}
+
+export function writeOpenCodeConfig(settings) {
+  const dir = path.join(os.homedir(), '.config', 'opencode');
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const filePath = path.join(dir, 'opencode.json');
+  backupIfExists(filePath);
+  const config = readJSON(filePath, { $schema: 'https://opencode.ai/config.json' });
+  config.provider = config.provider && typeof config.provider === 'object' ? config.provider : {};
+  config.provider.gpteam = {
+    npm: '@ai-sdk/openai',
+    options: {
+      apiKey: settings.apiKey,
+      baseURL: settings.node.baseUrl
+    },
+    models: {
+      [settings.model]: {
+        name: settings.model,
+        limit: {
+          context: Number(settings.contextLength),
+          output: Number(settings.maxOutputTokens)
+        },
+        variants: {
+          [settings.effort]: {
+            reasoningEffort: settings.effort,
+            reasoningSummary: settings.effort === 'high' || settings.effort === 'xhigh' ? 'detailed' : 'auto',
+            textVerbosity: 'medium'
+          }
+        }
+      }
+    }
+  };
+  writeJSON(filePath, config);
+  return [filePath];
+}
+
+export function writeClaudeCodeEnv(settings) {
+  const dir = path.join(os.homedir(), '.gpteam');
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const filePath = path.join(dir, 'claude-code.env');
+  backupIfExists(filePath);
+  const root = endpointRoot(settings.node.baseUrl);
+  const lines = [
+    '# GPTeam Claude Code environment.',
+    `export ANTHROPIC_AUTH_TOKEN=${shellQuote(settings.apiKey)}`,
+    `export ANTHROPIC_BASE_URL=${shellQuote(root)}`,
+    `export ANTHROPIC_MODEL=${shellQuote(settings.model)}`,
+    `export CODEX_REASONING_EFFORT=${shellQuote(settings.effort)}`,
+    '',
+    '# 使用方式：source ~/.gpteam/claude-code.env'
+  ];
+  fs.writeFileSync(filePath, `${lines.join('\n')}\n`, { encoding: 'utf8', mode: 0o600 });
+  return [filePath];
+}
+
+export function writeOpenClawConfig(settings) {
+  if (process.platform === 'win32') {
+    throw new Error('OpenClaw 自动配置当前只支持 macOS / Linux');
+  }
+  const dir = path.join(os.homedir(), '.openclaw');
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const filePath = path.join(dir, 'openclaw.json');
+  backupIfExists(filePath);
+  const config = readJSON(filePath, {});
+  config.models = config.models && typeof config.models === 'object' ? config.models : {};
+  config.models.mode = config.models.mode || 'merge';
+  config.models.providers = config.models.providers && typeof config.models.providers === 'object'
+    ? config.models.providers
+    : {};
+  config.models.providers.gpteam = {
+    baseUrl: settings.node.baseUrl,
+    apiKey: settings.apiKey,
+    api: 'openai-responses',
+    models: [{
+      id: settings.model,
+      name: settings.model,
+      reasoning: true,
+      contextWindow: Number(settings.contextLength),
+      maxTokens: Number(settings.maxOutputTokens)
+    }]
+  };
+  writeJSON(filePath, config);
+  return [filePath];
+}
+
+function stripCodexManagedConfig(raw) {
+  return String(raw || '')
+    .replace(/^\s*model\s*=.*\n?/gm, '')
+    .replace(/^\s*model_provider\s*=.*\n?/gm, '')
+    .replace(/^\s*model_context_window\s*=.*\n?/gm, '')
+    .replace(/^\s*model_reasoning_effort\s*=.*\n?/gm, '')
+    .replace(/^\s*\[model_providers\.gpteam\][\s\S]*?(?=^\s*\[[^\]]+\]|$)/gm, '')
+    .trim();
+}
+
+function backupIfExists(filePath) {
+  if (!fs.existsSync(filePath)) return;
+  const stamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..+/, '').replace('T', '-');
+  fs.copyFileSync(filePath, `${filePath}.bak-${stamp}`);
+}
+
+function readJSON(filePath, fallback) {
+  if (!fs.existsSync(filePath)) return fallback;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function writeJSON(filePath, value) {
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+}
+
+function tomlString(value) {
+  return `"${String(value).replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`;
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}

package/lib/help.js

@@ -0,0 +1,26 @@
+export const PACKAGE_NAME = 'gpteam';
+export const PACKAGE_VERSION = '0.1.0';
+
+export function getHelpText() {
+  return [
+    'GPTeam API 配置助手',
+    '',
+    '用法：',
+    '  npx gpteam',
+    '  npx gpteam config',
+    '',
+    '常用参数：',
+    '  --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>              jp-direct / jp-split / hk-split / us-split',
+    '  --rounds <n>             每个入口测速轮数，默认 3',
+    '  --max-output-tokens <n>  测速输出上限，默认 648',
+    '  --help                  显示帮助',
+    '  --version               显示版本',
+    '',
+    '说明：测速会真实请求 GET /api/health 和流式 POST /v1/responses，旧配置写入前会自动备份。'
+  ].join('\n');
+}

package/lib/models.js

@@ -0,0 +1,100 @@
+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,
+    maxOutputTokens: 128000,
+    efforts: ['low', 'medium', 'high', 'xhigh']
+  },
+  'gpt-5.3-codex-spark': {
+    id: 'gpt-5.3-codex-spark',
+    contextLength: 128000,
+    maxOutputTokens: 128000,
+    efforts: ['low', 'medium', 'high', 'xhigh']
+  },
+  'gpt-5.4': {
+    id: 'gpt-5.4',
+    contextLength: 1050000,
+    maxOutputTokens: 128000,
+    efforts: ['low', 'medium', 'high', 'xhigh']
+  },
+  'gpt-5.4-mini': {
+    id: 'gpt-5.4-mini',
+    contextLength: 400000,
+    maxOutputTokens: 128000,
+    efforts: ['low', 'medium', 'high', 'xhigh']
+  },
+  'gpt-5.5': {
+    id: 'gpt-5.5',
+    contextLength: 272000,
+    maxOutputTokens: 128000,
+    efforts: ['low', 'medium', 'high', 'xhigh']
+  }
+};
+
+export function normalizeModels(payload) {
+  const items = Array.isArray(payload && payload.data) ? payload.data : [];
+  const result = new Map();
+
+  for (const item of items) {
+    const id = String(item.id || item.name || '').trim();
+    if (!id || !id.startsWith('gpt-')) continue;
+    if (id.includes('image')) 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;
+    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)
+    });
+  }
+
+  if (!result.size) {
+    for (const model of Object.values(FALLBACK_MODELS)) {
+      result.set(model.id, {
+        id: model.id,
+        displayName: model.id,
+        contextLength: model.contextLength,
+        maxOutputTokens: model.maxOutputTokens,
+        efforts: model.efforts
+      });
+    }
+  }
+
+  return Array.from(result.values()).sort((a, b) => a.id.localeCompare(b.id));
+}
+
+export async function fetchModels(baseUrl, apiKey) {
+  const response = await fetch(`${baseUrl.replace(/\/$/, '')}/models`, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'User-Agent': 'gpteam-api-config/0.1'
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`/v1/models 返回 HTTP ${response.status}`);
+  }
+  return normalizeModels(await response.json());
+}
+
+export function modelByID(models, id) {
+  return models.find((model) => model.id === id) || models[0];
+}
+
+function normalizeEfforts(levels) {
+  const out = [];
+  for (const level of levels || []) {
+    const normalized = String(level || '').trim().toLowerCase();
+    if (!normalized || out.includes(normalized)) continue;
+    out.push(normalized);
+  }
+  return out.length ? out : ['medium'];
+}

package/lib/nodes.js

@@ -0,0 +1,42 @@
+export const INGRESS_NODES = [
+  {
+    id: 'jp-direct',
+    label: '日本主机直连',
+    region: 'JP',
+    split: false,
+    baseUrl: 'https://api.gpteamservices.com/v1',
+    healthUrl: 'https://api.gpteamservices.com/api/health'
+  },
+  {
+    id: 'jp-split',
+    label: '日本入口',
+    region: 'JP',
+    split: true,
+    baseUrl: 'https://api-jp.gpteamservices.com/v1',
+    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'
+  },
+  {
+    id: 'us-split',
+    label: '美国入口',
+    region: 'US',
+    split: true,
+    baseUrl: 'https://api-us.gpteamservices.com/v1',
+    healthUrl: 'https://api-us.gpteamservices.com/api/health'
+  }
+];
+
+export function describeSplit(node) {
+  return node.split ? '分流' : '不分流';
+}
+
+export function endpointRoot(baseUrl) {
+  return String(baseUrl || '').replace(/\/v1\/?$/, '').replace(/\/$/, '');
+}

package/lib/sse.js

@@ -0,0 +1,42 @@
+export function inspectSSEBody(body) {
+  const text = String(body || '');
+  let sawData = false;
+  let sawDone = false;
+  let sawCompleted = false;
+
+  for (const line of text.split(/\r?\n/)) {
+    if (!line.startsWith('data:')) continue;
+    const data = line.slice(5).trim();
+    if (!data) continue;
+    sawData = true;
+    if (data === '[DONE]') {
+      sawDone = true;
+      continue;
+    }
+    const parsed = parseJSON(data);
+    if (!parsed) continue;
+    const type = String(parsed.type || '');
+    if (type === 'response.completed') sawCompleted = true;
+    if (isFailureSSE(parsed, type)) {
+      return { ok: false, error: `stream semantic failure ${type || 'error'}` };
+    }
+  }
+
+  if (!sawData) return { ok: false, error: 'stream empty response' };
+  return { ok: sawDone || sawCompleted || sawData, error: '' };
+}
+
+function parseJSON(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+function isFailureSSE(parsed, type) {
+  if (['response.failed', 'response.incomplete', 'response.canceled', 'response.cancelled', 'error'].includes(type)) {
+    return true;
+  }
+  return parsed && typeof parsed === 'object' && parsed.error && typeof parsed.error === 'object';
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "gpteam",
+  "version": "0.1.0",
+  "description": "GPTeam API interactive client configurator and ingress benchmark CLI.",
+  "type": "module",
+  "bin": {
+    "gpteam": "bin/gpteam-api-config.js",
+    "gpteam-api-config": "bin/gpteam-api-config.js"
+  },
+  "files": [
+    "bin",
+    "lib"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}