@autotask/atools-tool 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 aak1247
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# atools-tool
+
+ATools CLI for OpenClaw:
+
+- proxy compatibility for sub2api-style upstreams
+- one-click installer
+- interactive OpenClaw model config
+
+## Expected Usage
+
+```bash
+atools-tool <command>
+```
+
+Available command:
+
+```bash
+atools-tool config-openclaw
+```
+
+Interactive flow:
+
+1. Select default model: `gpt-5.2` / `gpt-5.3-codex` / `gpt-5.4`
+2. Configure reasoning: `off` / `on`
+3. Configure thinking strength: `off|minimal|low|medium|high|xhigh`
+4. Input API key (leave empty to keep current key)
+
+## Install (npm)
+
+```bash
+npm i -g atools-tool
+```
+
+Optional installer command:
+
+```bash
+atools-tool-install --help
+```
+
+## Proxy Command
+
+```bash
+atools-tool serve --port 18888 --upstream https://sub2api.atools.live
+```
+
+## Repo Install
+
+```bash
+git clone https://github.com/aak1247/sub2api-openclaw-proxy.git
+cd sub2api-openclaw-proxy
+./install.sh
+```
+
+## Bootstrap Install
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/aak1247/sub2api-openclaw-proxy/main/bootstrap-install.sh | bash
+```
+
+## What Installer Changes
+
+- patches `~/.openclaw/openclaw.json`
+- patches `~/.openclaw/agents/main/agent/models.json`
+- patches `~/.openclaw/agents/main/agent/auth-profiles.json` (if API key is available)
+- creates/enables `~/.config/systemd/user/openclaw-atools-proxy.service`
+- restarts `openclaw-gateway.service` (unless `--no-restart`)
+
+Default proxy log:
+
+```text
+/tmp/openclaw/atools-compat-proxy.log
+```
+
+## Uninstall
+
+```bash
+./scripts/uninstall.sh
+```
+
+## License
+
+MIT

package/bin/cli.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+import { createProxyServer } from '../lib/proxy-server.mjs';
+import { runConfigOpenclaw } from '../lib/config-openclaw.mjs';
+
+function parseArgs(argv) {
+  const out = {
+    cmd: 'serve',
+    openclawHome: undefined,
+    port: undefined,
+    upstream: undefined,
+    fallbackUpstream: undefined,
+    fallbackApiKey: undefined,
+    maxReqBytes: undefined,
+    logFile: undefined,
+    retryMax: undefined,
+    retryBaseMs: undefined
+  };
+
+  if (argv[0] && !argv[0].startsWith('-')) {
+    out.cmd = argv.shift();
+  }
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    const next = () => argv[++i];
+
+    if (a === '--port') out.port = Number(next());
+    else if (a === '--openclaw-home') out.openclawHome = next();
+    else if (a === '--upstream') out.upstream = next();
+    else if (a === '--fallback-upstream') out.fallbackUpstream = next();
+    else if (a === '--fallback-api-key') out.fallbackApiKey = next();
+    else if (a === '--max-req-bytes') out.maxReqBytes = Number(next());
+    else if (a === '--log-file') out.logFile = next();
+    else if (a === '--retry-max') out.retryMax = Number(next());
+    else if (a === '--retry-base-ms') out.retryBaseMs = Number(next());
+    else if (a === '--help' || a === '-h') out.help = true;
+    else throw new Error(`unknown arg: ${a}`);
+  }
+  return out;
+}
+
+function printHelp() {
+  process.stdout.write(`atools-tool
+
+Usage:
+  atools-tool <command> [options]
+
+Commands:
+  serve            Run proxy service
+  config-openclaw  Interactive OpenClaw model/reasoning/thinking/key setup
+
+Options:
+  --openclaw-home <path> OpenClaw home dir (default: ~/.openclaw)
+  --port <number>          Listen port (default: 18888)
+  --upstream <url>         Upstream base URL (default: https://sub2api.atools.live)
+  --fallback-upstream <url> Fallback base URL on primary 5xx
+  --fallback-api-key <key> Override Bearer key for fallback upstream
+  --max-req-bytes <number> Compact requests larger than this threshold (default: 68000)
+  --log-file <path>        Log file (default: /tmp/openclaw/atools-compat-proxy.log)
+  --retry-max <number>     Retry attempts on 5xx for /responses (default: 6)
+  --retry-base-ms <number> Retry base backoff ms (default: 300)
+  -h, --help               Show help
+`);
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  if (args.cmd === 'config-openclaw') {
+    await runConfigOpenclaw({ openclawHome: args.openclawHome });
+    return;
+  }
+
+  if (args.cmd !== 'serve') {
+    throw new Error(`unsupported command: ${args.cmd}`);
+  }
+
+  const { port, upstream, fallbackUpstream, logFile } = await createProxyServer(args);
+  const fallbackNote = fallbackUpstream ? `, fallback=${fallbackUpstream}` : '';
+  process.stdout.write(`atools-tool listening on http://127.0.0.1:${port}, upstream=${upstream}${fallbackNote}, log=${logFile}\n`);
+}
+
+main().catch((err) => {
+  process.stderr.write(`${String(err?.stack || err)}\n`);
+  process.exit(1);
+});

package/bin/install.mjs

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runInstallCli } from '../lib/install.mjs';
+
+runInstallCli();

package/lib/config-openclaw.mjs

@@ -0,0 +1,174 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import process from 'node:process';
+import readline from 'node:readline/promises';
+
+const PROVIDER = 'sub2api';
+const MODEL_OPTIONS = ['gpt-5.2', 'gpt-5.3-codex', 'gpt-5.4'];
+const THINKING_OPTIONS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh'];
+
+function readJson(filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`missing file: ${filePath}`);
+  }
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function writeJson(filePath, data) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+}
+
+function backup(filePath) {
+  if (!fs.existsSync(filePath)) return;
+  const d = new Date();
+  const p = (n) => String(n).padStart(2, '0');
+  const stamp = `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+  fs.copyFileSync(filePath, `${filePath}.bak.${stamp}`);
+}
+
+async function askChoice(rl, question, options, defaultIndex = 0) {
+  while (true) {
+    process.stdout.write(`\n${question}\n`);
+    options.forEach((item, idx) => {
+      const mark = idx === defaultIndex ? ' (default)' : '';
+      process.stdout.write(`${idx + 1}. ${item}${mark}\n`);
+    });
+    const input = (await rl.question('请选择编号: ')).trim();
+    if (!input) return options[defaultIndex];
+    const n = Number(input);
+    if (Number.isInteger(n) && n >= 1 && n <= options.length) {
+      return options[n - 1];
+    }
+    process.stdout.write('输入无效，请重新输入。\n');
+  }
+}
+
+async function askKey(rl, currentKey) {
+  const masked = currentKey ? `${currentKey.slice(0, 6)}...${currentKey.slice(-4)}` : '未设置';
+  process.stdout.write(`\n4) 输入 API Key（当前: ${masked}）\n`);
+  process.stdout.write('留空表示保持当前 key\n');
+  const input = (await rl.question('请输入 key: ')).trim();
+  return input || currentKey || '';
+}
+
+function ensureModel(providerObj, modelId, reasoning) {
+  providerObj.models = providerObj.models || [];
+  let model = providerObj.models.find((m) => m && m.id === modelId);
+  if (!model) {
+    model = {
+      id: modelId,
+      name: modelId,
+      api: 'openai-responses',
+      reasoning: false,
+      input: ['text'],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 200000,
+      maxTokens: 8192
+    };
+    providerObj.models.push(model);
+  }
+  model.reasoning = reasoning;
+  model.contextWindow = model.contextWindow || 200000;
+  model.maxTokens = model.maxTokens || 8192;
+  model.api = model.api || 'openai-responses';
+}
+
+export async function runConfigOpenclaw({ openclawHome } = {}) {
+  const home = openclawHome || process.env.OPENCLAW_HOME || path.join(os.homedir(), '.openclaw');
+  const openclawJsonPath = path.join(home, 'openclaw.json');
+  const modelsJsonPath = path.join(home, 'agents/main/agent/models.json');
+  const authProfilesPath = path.join(home, 'agents/main/agent/auth-profiles.json');
+
+  const openclawCfg = readJson(openclawJsonPath);
+  const modelsCfg = readJson(modelsJsonPath);
+  let authCfg = fs.existsSync(authProfilesPath)
+    ? readJson(authProfilesPath)
+    : { version: 1, profiles: {}, lastGood: {}, usageStats: {} };
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  try {
+    process.stdout.write(`OpenClaw Home: ${home}\n`);
+
+    const selectedModel = await askChoice(rl, '1) 选择默认模型', MODEL_OPTIONS, 1);
+    const reasoningSwitch = await askChoice(rl, '2) 配置推理开关', ['off', 'on'], 0);
+    const selectedThinking = await askChoice(rl, '3) 思考强度', THINKING_OPTIONS, 2);
+    const reasoning = reasoningSwitch === 'on';
+    const currentKey =
+      openclawCfg?.models?.providers?.[PROVIDER]?.apiKey ||
+      modelsCfg?.providers?.[PROVIDER]?.apiKey ||
+      authCfg?.profiles?.[`${PROVIDER}:default`]?.key ||
+      '';
+    const selectedKey = await askKey(rl, currentKey);
+
+    openclawCfg.models = openclawCfg.models || {};
+    openclawCfg.models.providers = openclawCfg.models.providers || {};
+    openclawCfg.models.providers[PROVIDER] = openclawCfg.models.providers[PROVIDER] || {};
+    openclawCfg.models.providers[PROVIDER].api = 'openai-responses';
+    openclawCfg.models.providers[PROVIDER].authHeader = true;
+    if (selectedKey) {
+      openclawCfg.models.providers[PROVIDER].apiKey = selectedKey;
+      openclawCfg.models.providers[PROVIDER].auth = 'api-key';
+    }
+    ensureModel(openclawCfg.models.providers[PROVIDER], selectedModel, reasoning);
+
+    openclawCfg.agents = openclawCfg.agents || {};
+    openclawCfg.agents.defaults = openclawCfg.agents.defaults || {};
+    openclawCfg.agents.defaults.model = openclawCfg.agents.defaults.model || {};
+    openclawCfg.agents.defaults.model.primary = `${PROVIDER}/${selectedModel}`;
+    openclawCfg.agents.defaults.thinkingDefault = selectedThinking;
+    openclawCfg.agents.defaults.models = openclawCfg.agents.defaults.models || {};
+    openclawCfg.agents.defaults.models[`${PROVIDER}/${selectedModel}`] =
+      openclawCfg.agents.defaults.models[`${PROVIDER}/${selectedModel}`] || { alias: `ATools ${selectedModel}` };
+
+    modelsCfg.providers = modelsCfg.providers || {};
+    modelsCfg.providers[PROVIDER] = modelsCfg.providers[PROVIDER] || {};
+    modelsCfg.providers[PROVIDER].api = 'openai-responses';
+    modelsCfg.providers[PROVIDER].authHeader = true;
+    if (selectedKey) {
+      modelsCfg.providers[PROVIDER].apiKey = selectedKey;
+      modelsCfg.providers[PROVIDER].auth = 'api-key';
+    }
+    ensureModel(modelsCfg.providers[PROVIDER], selectedModel, reasoning);
+
+    authCfg.version = authCfg.version || 1;
+    authCfg.profiles = authCfg.profiles || {};
+    authCfg.lastGood = authCfg.lastGood || {};
+    authCfg.usageStats = authCfg.usageStats || {};
+    if (selectedKey) {
+      authCfg.profiles[`${PROVIDER}:default`] = {
+        type: 'api_key',
+        provider: PROVIDER,
+        key: selectedKey
+      };
+      authCfg.lastGood[PROVIDER] = `${PROVIDER}:default`;
+      authCfg.usageStats[`${PROVIDER}:default`] = authCfg.usageStats[`${PROVIDER}:default`] || {
+        errorCount: 0,
+        lastUsed: Date.now()
+      };
+    }
+
+    backup(openclawJsonPath);
+    backup(modelsJsonPath);
+    backup(authProfilesPath);
+    writeJson(openclawJsonPath, openclawCfg);
+    writeJson(modelsJsonPath, modelsCfg);
+    writeJson(authProfilesPath, authCfg);
+
+    process.stdout.write('\n配置已更新:\n');
+    process.stdout.write(`- 默认模型: ${PROVIDER}/${selectedModel}\n`);
+    process.stdout.write(`- 推理开关: ${reasoning ? 'on' : 'off'}\n`);
+    process.stdout.write(`- 思考强度: ${selectedThinking}\n`);
+    process.stdout.write(`- API Key: ${selectedKey ? `${selectedKey.slice(0, 6)}...${selectedKey.slice(-4)}` : '未设置'}\n`);
+    process.stdout.write(`- 已写入: ${openclawJsonPath}\n`);
+    process.stdout.write(`- 已写入: ${modelsJsonPath}\n`);
+    process.stdout.write(`- 已写入: ${authProfilesPath}\n`);
+  } finally {
+    rl.close();
+  }
+}

package/lib/install.mjs

@@ -0,0 +1,405 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const DEFAULT_PROVIDER = 'sub2api';
+const DEFAULT_MODEL = 'gpt-5.3-codex';
+const DEFAULT_PORT = 18888;
+const DEFAULT_UPSTREAM = 'https://sub2api.atools.live';
+const DEFAULT_FALLBACK_UPSTREAM = 'https://gmn.chuangzuoli.com/v1';
+const DEFAULT_LOG_FILE = '/tmp/openclaw/atools-compat-proxy.log';
+const DEFAULT_SERVICE_NAME = 'openclaw-atools-proxy.service';
+const OPENCLAW_GATEWAY_SERVICE = 'openclaw-gateway.service';
+
+function info(msg) {
+  process.stdout.write(`[atools-tool] ${msg}\n`);
+}
+
+function fail(msg) {
+  process.stderr.write(`[atools-tool] ERROR: ${msg}\n`);
+}
+
+function nowStamp() {
+  const d = new Date();
+  const p = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+
+function readJsonIfExists(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function writeJson(filePath, data) {
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+}
+
+function backup(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const dest = `${filePath}.bak.${nowStamp()}`;
+  fs.copyFileSync(filePath, dest);
+  return dest;
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function parseArgs(argv) {
+  const out = {
+    openclawHome: process.env.OPENCLAW_HOME || path.join(os.homedir(), '.openclaw'),
+    provider: DEFAULT_PROVIDER,
+    model: DEFAULT_MODEL,
+    port: DEFAULT_PORT,
+    upstream: DEFAULT_UPSTREAM,
+    fallbackUpstream: DEFAULT_FALLBACK_UPSTREAM,
+    maxReqBytes: 68000,
+    logFile: DEFAULT_LOG_FILE,
+    serviceName: DEFAULT_SERVICE_NAME,
+    apiKey: process.env.SUB_OAI_KEY || '',
+    fallbackApiKey: process.env.FALLBACK_OAI_KEY || '',
+    dryRun: false,
+    noRestart: false
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    const next = () => argv[++i];
+
+    if (a === '--openclaw-home') out.openclawHome = next();
+    else if (a === '--provider') out.provider = next();
+    else if (a === '--model') out.model = next();
+    else if (a === '--port') out.port = Number(next());
+    else if (a === '--upstream') out.upstream = next();
+    else if (a === '--fallback-upstream') out.fallbackUpstream = next();
+    else if (a === '--max-req-bytes') out.maxReqBytes = Number(next());
+    else if (a === '--log-file') out.logFile = next();
+    else if (a === '--service-name') out.serviceName = next();
+    else if (a === '--api-key') out.apiKey = next();
+    else if (a === '--fallback-api-key') out.fallbackApiKey = next();
+    else if (a === '--dry-run') out.dryRun = true;
+    else if (a === '--no-restart') out.noRestart = true;
+    else if (a === '--help' || a === '-h') {
+      out.help = true;
+    } else {
+      throw new Error(`unknown arg: ${a}`);
+    }
+  }
+
+  if (!Number.isFinite(out.port) || out.port <= 0) {
+    throw new Error(`invalid --port: ${out.port}`);
+  }
+  return out;
+}
+
+function renderSystemdService({
+  serviceName,
+  nodeBin,
+  cliPath,
+  port,
+  upstream,
+  fallbackUpstream,
+  maxReqBytes,
+  fallbackApiKey,
+  logFile
+}) {
+  const fallbackEnv = fallbackUpstream
+    ? `Environment=SUB2API_FALLBACK_UPSTREAM=${fallbackUpstream}\nEnvironment=SUB2API_FALLBACK_API_KEY=${fallbackApiKey || ''}\n`
+    : '';
+  return `[Unit]
+Description=OpenClaw ATools Compatibility Proxy
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+ExecStart=${nodeBin} ${cliPath} serve --port ${port} --upstream ${upstream} --log-file ${logFile}
+Restart=always
+RestartSec=2
+Environment=HOME=${os.homedir()}
+Environment=TMPDIR=/tmp
+Environment=SUB2API_COMPAT_PORT=${port}
+Environment=SUB2API_UPSTREAM=${upstream}
+Environment=SUB2API_COMPAT_LOG=${logFile}
+Environment=SUB2API_COMPAT_MAX_REQ_BYTES=${maxReqBytes}
+Environment="SUB2API_COMPAT_USER_AGENT=codex_cli_rs/0.101.0 (Ubuntu 24.4.0; x86_64) WindowsTerminal"
+${fallbackEnv}
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+function detectApiKey(openclawHome, explicitKey) {
+  if (explicitKey) return explicitKey;
+  const authPath = path.join(openclawHome, 'agents/main/agent/auth-profiles.json');
+  const auth = readJsonIfExists(authPath);
+  return auth?.profiles?.['sub2api:default']?.key || '';
+}
+
+function detectFallbackApiKey(openclawHome, explicitKey) {
+  if (explicitKey) return explicitKey;
+  const cfgPath = path.join(openclawHome, 'openclaw.json');
+  const cfg = readJsonIfExists(cfgPath);
+  return cfg?.models?.providers?.gmn?.apiKey || '';
+}
+
+function patchOpenclawConfig(openclawHome, provider, model, port, dryRun) {
+  const cfgPath = path.join(openclawHome, 'openclaw.json');
+  const cfg = readJsonIfExists(cfgPath);
+  if (!cfg) {
+    throw new Error(`missing openclaw config: ${cfgPath}`);
+  }
+
+  const baseUrl = `http://127.0.0.1:${port}/v1`;
+  cfg.models = cfg.models || {};
+  cfg.models.providers = cfg.models.providers || {};
+  cfg.models.providers[provider] = cfg.models.providers[provider] || {};
+
+  const providerObj = cfg.models.providers[provider];
+  providerObj.baseUrl = baseUrl;
+  providerObj.api = 'openai-responses';
+  providerObj.authHeader = true;
+  providerObj.headers = providerObj.headers || {};
+  providerObj.headers['User-Agent'] = 'codex_cli_rs/0.101.0 (Ubuntu 24.4.0; x86_64) WindowsTerminal';
+  providerObj.headers.Accept = 'application/json';
+  providerObj.models = providerObj.models || [];
+
+  let exists = providerObj.models.find((m) => m && m.id === model);
+  if (!exists) {
+    exists = {
+      id: model,
+      name: model,
+      api: 'openai-responses',
+      reasoning: false,
+      input: ['text'],
+      cost: { input: 1.75, output: 14, cacheRead: 0.175, cacheWrite: 0.175 },
+      contextWindow: 200000,
+      maxTokens: 8192
+    };
+    providerObj.models.push(exists);
+  }
+  exists.contextWindow = 200000;
+  exists.maxTokens = 8192;
+  exists.reasoning = false;
+
+  cfg.agents = cfg.agents || {};
+  cfg.agents.defaults = cfg.agents.defaults || {};
+  cfg.agents.defaults.model = cfg.agents.defaults.model || {};
+  cfg.agents.defaults.model.primary = `${provider}/${model}`;
+  cfg.agents.defaults.thinkingDefault = 'low';
+  cfg.agents.defaults.models = cfg.agents.defaults.models || {};
+  cfg.agents.defaults.models[`${provider}/${model}`] = cfg.agents.defaults.models[`${provider}/${model}`] || { alias: model };
+
+  if (dryRun) {
+    info(`dry-run: would patch ${cfgPath}`);
+    return;
+  }
+  const bak = backup(cfgPath);
+  if (bak) info(`backup created: ${bak}`);
+  writeJson(cfgPath, cfg);
+  info(`patched: ${cfgPath}`);
+}
+
+function patchAgentModels(openclawHome, provider, model, port, apiKey, dryRun) {
+  const modelsPath = path.join(openclawHome, 'agents/main/agent/models.json');
+  const models = readJsonIfExists(modelsPath);
+  if (!models) {
+    throw new Error(`missing agent models config: ${modelsPath}`);
+  }
+
+  const baseUrl = `http://127.0.0.1:${port}/v1`;
+  models.providers = models.providers || {};
+  models.providers[provider] = models.providers[provider] || {};
+  const providerObj = models.providers[provider];
+
+  providerObj.baseUrl = baseUrl;
+  providerObj.api = 'openai-responses';
+  providerObj.authHeader = true;
+  providerObj.headers = providerObj.headers || {};
+  providerObj.headers['User-Agent'] = 'codex_cli_rs/0.101.0 (Ubuntu 24.4.0; x86_64) WindowsTerminal';
+  providerObj.headers.Accept = 'application/json';
+  providerObj.models = providerObj.models || [];
+
+  let exists = providerObj.models.find((m) => m && m.id === model);
+  if (!exists) {
+    exists = {
+      id: model,
+      name: model,
+      api: 'openai-responses',
+      reasoning: false,
+      input: ['text'],
+      cost: { input: 1.75, output: 14, cacheRead: 0.175, cacheWrite: 0.175 },
+      contextWindow: 200000,
+      maxTokens: 8192
+    };
+    providerObj.models.push(exists);
+  }
+  exists.contextWindow = 200000;
+  exists.maxTokens = 8192;
+  exists.reasoning = false;
+
+  if (apiKey) {
+    providerObj.apiKey = apiKey;
+  }
+
+  if (dryRun) {
+    info(`dry-run: would patch ${modelsPath}`);
+    return;
+  }
+  const bak = backup(modelsPath);
+  if (bak) info(`backup created: ${bak}`);
+  writeJson(modelsPath, models);
+  info(`patched: ${modelsPath}`);
+}
+
+function patchAuthProfiles(openclawHome, provider, apiKey, dryRun) {
+  if (!apiKey) {
+    info('no api key provided/detected, skip auth-profiles patch');
+    return;
+  }
+
+  const authPath = path.join(openclawHome, 'agents/main/agent/auth-profiles.json');
+  const auth = readJsonIfExists(authPath) || { version: 1, profiles: {}, lastGood: {}, usageStats: {} };
+
+  auth.profiles = auth.profiles || {};
+  auth.lastGood = auth.lastGood || {};
+  auth.usageStats = auth.usageStats || {};
+
+  auth.profiles[`${provider}:default`] = {
+    type: 'api_key',
+    provider,
+    key: apiKey
+  };
+  auth.lastGood[provider] = `${provider}:default`;
+  auth.usageStats[`${provider}:default`] = auth.usageStats[`${provider}:default`] || { errorCount: 0, lastUsed: Date.now() };
+
+  if (dryRun) {
+    info(`dry-run: would patch ${authPath}`);
+    return;
+  }
+
+  ensureDir(path.dirname(authPath));
+  if (fs.existsSync(authPath)) {
+    const bak = backup(authPath);
+    if (bak) info(`backup created: ${bak}`);
+  }
+  writeJson(authPath, auth);
+  info(`patched: ${authPath}`);
+}
+
+function runSystemctl(args, { dryRun } = {}) {
+  if (dryRun) {
+    info(`dry-run: systemctl --user ${args.join(' ')}`);
+    return;
+  }
+  execFileSync('systemctl', ['--user', ...args], { stdio: 'inherit' });
+}
+
+function installService({ serviceName, content, dryRun }) {
+  const serviceDir = path.join(os.homedir(), '.config/systemd/user');
+  const servicePath = path.join(serviceDir, serviceName);
+  ensureDir(serviceDir);
+
+  if (dryRun) {
+    info(`dry-run: would write ${servicePath}`);
+  } else {
+    if (fs.existsSync(servicePath)) {
+      const bak = backup(servicePath);
+      if (bak) info(`backup created: ${bak}`);
+    }
+    fs.writeFileSync(servicePath, content, 'utf8');
+    info(`wrote: ${servicePath}`);
+  }
+
+  runSystemctl(['daemon-reload'], { dryRun });
+  runSystemctl(['enable', '--now', serviceName], { dryRun });
+}
+
+function restartOpenclawGateway({ noRestart, dryRun }) {
+  if (noRestart) {
+    info('skip gateway restart (--no-restart)');
+    return;
+  }
+
+  try {
+    runSystemctl(['restart', OPENCLAW_GATEWAY_SERVICE], { dryRun });
+  } catch {
+    info(`gateway service not restarted (service may not exist): ${OPENCLAW_GATEWAY_SERVICE}`);
+  }
+}
+
+function printHelp() {
+  process.stdout.write(`atools-tool-install
+
+Usage:
+  atools-tool-install [options]
+
+Options:
+  --openclaw-home <path>   Default: ~/.openclaw
+  --provider <name>        Default: sub2api
+  --model <id>             Default: gpt-5.3-codex
+  --port <number>          Default: 18888
+  --upstream <url>         Default: https://sub2api.atools.live
+  --fallback-upstream <url> Default: https://gmn.chuangzuoli.com/v1
+  --max-req-bytes <number> Default: 68000
+  --log-file <path>        Default: /tmp/openclaw/atools-compat-proxy.log
+  --service-name <name>    Default: openclaw-atools-proxy.service
+  --api-key <key>          Prefer explicit key; fallback env SUB_OAI_KEY then auth-profiles
+  --fallback-api-key <key> Prefer explicit key; fallback env FALLBACK_OAI_KEY then openclaw gmn key
+  --no-restart             Do not restart openclaw-gateway.service
+  --dry-run                Print actions without changing files
+  -h, --help               Show help
+`);
+}
+
+export async function runInstall(rawArgs = process.argv.slice(2)) {
+  const args = parseArgs(rawArgs);
+
+  if (args.help) {
+    printHelp();
+    return;
+  }
+
+  const nodeBin = process.execPath;
+  const cliPath = fileURLToPath(new URL('../bin/cli.mjs', import.meta.url));
+  const apiKey = detectApiKey(args.openclawHome, args.apiKey);
+  const fallbackApiKey = detectFallbackApiKey(args.openclawHome, args.fallbackApiKey);
+
+  info(`openclawHome=${args.openclawHome}`);
+  info(`provider/model=${args.provider}/${args.model}`);
+  info(`proxy=http://127.0.0.1:${args.port}/v1 -> ${args.upstream}`);
+  if (args.fallbackUpstream) {
+    info(`fallback=${args.fallbackUpstream}`);
+  }
+
+  patchOpenclawConfig(args.openclawHome, args.provider, args.model, args.port, args.dryRun);
+  patchAgentModels(args.openclawHome, args.provider, args.model, args.port, apiKey, args.dryRun);
+  patchAuthProfiles(args.openclawHome, args.provider, apiKey, args.dryRun);
+
+  const serviceContent = renderSystemdService({
+    serviceName: args.serviceName,
+    nodeBin,
+    cliPath,
+    port: args.port,
+    upstream: args.upstream,
+    fallbackUpstream: args.fallbackUpstream,
+    maxReqBytes: args.maxReqBytes,
+    fallbackApiKey,
+    logFile: args.logFile
+  });
+
+  installService({ serviceName: args.serviceName, content: serviceContent, dryRun: args.dryRun });
+  restartOpenclawGateway({ noRestart: args.noRestart, dryRun: args.dryRun });
+
+  info('done');
+  info(`check proxy logs: ${args.logFile}`);
+}
+
+export function runInstallCli() {
+  runInstall().catch((err) => {
+    fail(String(err?.stack || err?.message || err));
+    process.exit(1);
+  });
+}

package/lib/proxy-server.mjs

@@ -0,0 +1,281 @@
+import http from 'node:http';
+import fs from 'node:fs';
+
+const DEFAULT_PORT = 18888;
+const DEFAULT_UPSTREAM = 'https://sub2api.atools.live';
+const DEFAULT_LOG = '/tmp/openclaw/atools-compat-proxy.log';
+const DEFAULT_USER_AGENT = 'codex_cli_rs/0.101.0 (Ubuntu 24.4.0; x86_64) WindowsTerminal';
+const DEFAULT_FALLBACK_UPSTREAM = '';
+const DEFAULT_FALLBACK_API_KEY = '';
+const DEFAULT_MAX_REQ_BYTES = 68000;
+const DEFAULT_DROP_TOOLS_ON_COMPACT = false;
+
+function ensureParentDir(filePath) {
+  const dir = filePath.replace(/\/[^/]*$/, '');
+  if (dir) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function appendLog(logFile, obj) {
+  try {
+    ensureParentDir(logFile);
+    const line = `${new Date().toISOString()} ${JSON.stringify(obj)}\n`;
+    fs.appendFileSync(logFile, line);
+  } catch {
+    // ignore logging failures
+  }
+}
+
+function normalizeContent(content) {
+  const toInputText = (text) => ({ type: 'input_text', text: String(text ?? '') });
+
+  if (typeof content === 'string') return [toInputText(content)];
+
+  if (Array.isArray(content)) {
+    return content.map((part) => {
+      if (typeof part === 'string') return toInputText(part);
+      if (!part || typeof part !== 'object') return toInputText('');
+
+      if (part.type === 'text' || part.type === 'output_text') {
+        return toInputText(part.text);
+      }
+      if (part.type === 'input_text') {
+        return { ...part, text: String(part.text ?? '') };
+      }
+      return part;
+    });
+  }
+
+  if (content && typeof content === 'object' && 'text' in content) {
+    return [toInputText(content.text)];
+  }
+
+  return [toInputText('')];
+}
+
+function normalizeResponsesPayload(payload) {
+  if (!payload || typeof payload !== 'object') return payload;
+  const out = { ...payload };
+
+  // Some upstream gateways reject/unstable with this field.
+  if ('previous_response_id' in out) delete out.previous_response_id;
+
+  if (typeof out.input === 'string') {
+    out.input = [{ role: 'user', content: normalizeContent(out.input) }];
+  } else if (Array.isArray(out.input)) {
+    out.input = out.input.map((item) => {
+      if (!item || typeof item !== 'object') return item;
+      if ('role' in item || item.type === 'message') {
+        const role = typeof item.role === 'string' ? item.role : 'user';
+        return { role, content: normalizeContent(item.content) };
+      }
+      return item;
+    });
+  }
+
+  return out;
+}
+
+function trimTextPart(part, maxChars) {
+  if (!part || typeof part !== 'object') return part;
+  if (part.type !== 'input_text') return part;
+  const text = String(part.text ?? '');
+  return { ...part, text: text.length > maxChars ? text.slice(0, maxChars) : text };
+}
+
+function compactResponsesPayload(payload, { dropToolsOnCompact = DEFAULT_DROP_TOOLS_ON_COMPACT } = {}) {
+  if (!payload || typeof payload !== 'object') return payload;
+  const out = { ...payload };
+
+  if (dropToolsOnCompact && Array.isArray(out.tools)) delete out.tools;
+  if (typeof out.instructions === 'string' && out.instructions.length > 4000) {
+    out.instructions = out.instructions.slice(0, 4000);
+  }
+
+  if (Array.isArray(out.input)) {
+    const normalized = out.input.map((item) => {
+      if (!item || typeof item !== 'object') return item;
+      if ('role' in item || item.type === 'message') {
+        return {
+          role: typeof item.role === 'string' ? item.role : 'user',
+          content: normalizeContent(item.content).map((part) => trimTextPart(part, 4000))
+        };
+      }
+      return item;
+    });
+    const systemMsgs = normalized.filter((m) => m && typeof m === 'object' && (m.role === 'system' || m.role === 'developer')).slice(-1);
+    const userMsgs = normalized.filter((m) => m && typeof m === 'object' && m.role === 'user').slice(-2);
+    const merged = [...systemMsgs, ...userMsgs];
+    out.input = merged.length > 0 ? merged : normalized.slice(-1);
+  }
+
+  if ('previous_response_id' in out) delete out.previous_response_id;
+  return out;
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function forward(url, req, headers, body) {
+  return fetch(url, {
+    method: req.method,
+    headers,
+    body: ['GET', 'HEAD'].includes(req.method || '') ? undefined : body,
+    redirect: 'manual'
+  });
+}
+
+function buildHeaders(baseHeaders, bodyLen, apiKeyOverride = '') {
+  const headers = { ...baseHeaders };
+  headers['content-type'] = 'application/json';
+  headers['content-length'] = String(bodyLen);
+  if (apiKeyOverride) {
+    headers.authorization = `Bearer ${apiKeyOverride}`;
+  }
+  return headers;
+}
+
+export async function createProxyServer(options = {}) {
+  const port = Number(options.port ?? process.env.SUB2API_COMPAT_PORT ?? DEFAULT_PORT);
+  const upstream = options.upstream ?? process.env.SUB2API_UPSTREAM ?? DEFAULT_UPSTREAM;
+  const logFile = options.logFile ?? process.env.SUB2API_COMPAT_LOG ?? DEFAULT_LOG;
+  const retryMax = Number(options.retryMax ?? process.env.SUB2API_COMPAT_RETRY_MAX ?? 6);
+  const retryBaseMs = Number(options.retryBaseMs ?? process.env.SUB2API_COMPAT_RETRY_BASE_MS ?? 300);
+  const userAgent = options.userAgent ?? process.env.SUB2API_COMPAT_USER_AGENT ?? DEFAULT_USER_AGENT;
+  const fallbackUpstream = options.fallbackUpstream ?? process.env.SUB2API_FALLBACK_UPSTREAM ?? DEFAULT_FALLBACK_UPSTREAM;
+  const fallbackApiKey = options.fallbackApiKey ?? process.env.SUB2API_FALLBACK_API_KEY ?? DEFAULT_FALLBACK_API_KEY;
+  const maxReqBytes = Number(options.maxReqBytes ?? process.env.SUB2API_COMPAT_MAX_REQ_BYTES ?? DEFAULT_MAX_REQ_BYTES);
+  const dropToolsOnCompact = options.dropToolsOnCompact
+    ?? ['1', 'true', 'yes', 'on'].includes(String(process.env.SUB2API_COMPAT_DROP_TOOLS_ON_COMPACT || '').toLowerCase());
+
+  const server = http.createServer(async (req, res) => {
+    const startAt = Date.now();
+    try {
+      const url = new URL(req.url || '/', upstream);
+      const fallbackUrl = fallbackUpstream ? new URL(req.url || '/', fallbackUpstream) : null;
+      const chunks = [];
+      for await (const c of req) chunks.push(c);
+      const rawBody = Buffer.concat(chunks);
+
+      const baseHeaders = { ...req.headers };
+      delete baseHeaders.host;
+      delete baseHeaders.connection;
+      baseHeaders['user-agent'] = userAgent;
+
+      const isResponsesPath = req.method === 'POST' && url.pathname.endsWith('/responses');
+      let body = rawBody;
+      let compactBody = null;
+
+      if (isResponsesPath && rawBody.length > 0) {
+        try {
+          const parsed = JSON.parse(rawBody.toString('utf8'));
+          const normalized = normalizeResponsesPayload(parsed);
+          body = Buffer.from(JSON.stringify(normalized));
+          const compacted = compactResponsesPayload(normalized, { dropToolsOnCompact });
+          const compactBuf = Buffer.from(JSON.stringify(compacted));
+          if (compactBuf.length + 512 < body.length) {
+            compactBody = compactBuf;
+          }
+        } catch {
+          // Keep original body if parse fails.
+        }
+      }
+
+      let resp;
+      let attempts = 0;
+      let via = 'primary';
+      let primaryStatus = null;
+      let fallbackStatus = null;
+      let compacted = false;
+      const maxAttempts = isResponsesPath ? retryMax : 1;
+      while (attempts < maxAttempts) {
+        attempts += 1;
+        const shouldCompactNow = Boolean(compactBody && (attempts > 1 || body.length > maxReqBytes));
+        const requestBody = shouldCompactNow ? compactBody : body;
+        compacted = shouldCompactNow;
+        const primaryHeaders = isResponsesPath ? buildHeaders(baseHeaders, requestBody.length) : baseHeaders;
+        const fallbackHeaders = isResponsesPath
+          ? buildHeaders(baseHeaders, requestBody.length, fallbackApiKey)
+          : (fallbackApiKey ? { ...baseHeaders, authorization: `Bearer ${fallbackApiKey}` } : baseHeaders);
+
+        const primaryResp = await forward(url, req, primaryHeaders, requestBody);
+        primaryStatus = primaryResp.status;
+        if (primaryResp.status < 500) {
+          resp = primaryResp;
+          via = 'primary';
+          break;
+        }
+
+        if (fallbackUrl) {
+          const fbResp = await forward(fallbackUrl, req, fallbackHeaders, requestBody);
+          fallbackStatus = fbResp.status;
+          if (fbResp.status < 500) {
+            resp = fbResp;
+            via = 'fallback';
+            break;
+          }
+          resp = fbResp;
+          via = 'fallback';
+        } else {
+          resp = primaryResp;
+          via = 'primary';
+        }
+
+        if (attempts < maxAttempts) {
+          await sleep(retryBaseMs * attempts);
+        }
+      }
+
+      res.statusCode = resp.status;
+      resp.headers.forEach((value, key) => {
+        if (key.toLowerCase() === 'transfer-encoding') return;
+        res.setHeader(key, value);
+      });
+
+      const outBuffer = Buffer.from(await resp.arrayBuffer());
+      appendLog(logFile, {
+        method: req.method,
+        path: url.pathname,
+        status: resp.status,
+        attempts,
+        via,
+        primaryStatus,
+        fallbackStatus,
+        compacted,
+        reqBytes: rawBody.length,
+        upstreamReqBytes: compactBody && compacted ? compactBody.length : body.length,
+        respBytes: outBuffer.length,
+        durationMs: Date.now() - startAt
+      });
+      res.end(outBuffer);
+    } catch (err) {
+      const message = String(err?.message || err);
+      appendLog(logFile, {
+        method: req.method,
+        path: req.url,
+        status: 502,
+        error: message,
+        durationMs: Date.now() - startAt
+      });
+      res.statusCode = 502;
+      res.setHeader('content-type', 'application/json');
+      res.end(JSON.stringify({ error: 'compat-proxy-failed', message }));
+    }
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(port, '127.0.0.1', () => resolve());
+  });
+
+  return {
+    server,
+    port,
+    upstream,
+    fallbackUpstream,
+    logFile,
+    close: () => new Promise((resolve, reject) => server.close((err) => (err ? reject(err) : resolve())))
+  };
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@autotask/atools-tool",
+  "version": "0.1.2",
+  "description": "ATools CLI for OpenClaw proxy compatibility and interactive model configuration",
+  "type": "module",
+  "license": "MIT",
+  "author": "aak1247",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aak1247/sub2api-openclaw-proxy.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://github.com/aak1247/sub2api-openclaw-proxy#readme",
+  "bugs": {
+    "url": "https://github.com/aak1247/sub2api-openclaw-proxy/issues"
+  },
+  "keywords": [
+    "openclaw",
+    "atools",
+    "sub2api",
+    "openai-responses",
+    "proxy",
+    "codex"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "atools-tool": "bin/cli.mjs",
+    "atools-tool-install": "bin/install.mjs"
+  },
+  "scripts": {
+    "start": "node ./bin/cli.mjs serve",
+    "config:openclaw": "node ./bin/cli.mjs config-openclaw",
+    "install:local": "node ./bin/install.mjs",
+    "pack:check": "npm pack"
+  },
+  "files": [
+    "bin",
+    "lib",
+    "scripts",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/scripts/install.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+cd "$SCRIPT_DIR"
+
+if ! command -v node >/dev/null 2>&1; then
+  echo "[atools-tool] ERROR: node is required" >&2
+  exit 1
+fi
+
+node ./bin/install.mjs "$@"

package/scripts/uninstall.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SERVICE_NAME="${1:-openclaw-atools-proxy.service}"
+
+systemctl --user disable --now "$SERVICE_NAME" || true
+rm -f "$HOME/.config/systemd/user/$SERVICE_NAME"
+systemctl --user daemon-reload || true
+systemctl --user restart openclaw-gateway.service || true
+
+echo "[atools-tool] removed $SERVICE_NAME"