anthropic-gateway 1.1.0 → 1.3.0

package/README.md

@@ -52,18 +52,51 @@ anthropic-gateway setup --base-url https://api.openai.com/v1 --api-key sk-... --
 
 | Command | Description |
 | --- | --- |
-| `anthropic-gateway setup` | Create/overwrite `~/.anthropic-gateway/config.json`; tests connectivity |
+| `anthropic-gateway setup` | Create/overwrite `~/.anthropic-gateway/config.json`; tests connectivity (`--full-logging` to enable full-body logging) |
 | `anthropic-gateway start` | Start the gateway |
 | `anthropic-gateway stop` | Stop the gateway |
-| `anthropic-gateway status` | Is the gateway up? |
+| `anthropic-gateway status` | Pretty status: version, pid, upstream, uptime, request/token totals, full-logging state |
+| `anthropic-gateway fulllogging on\|off` | Toggle full request/response logging (restart to apply) |
 | `anthropic-gateway autostart on\|off` | Launch at Windows logon (Startup folder) |
+| `anthropic-gateway version` | Print the version (also `--version` / `-v`) |
 
 ## config.json
 
 See `config.example.json`. Key fields: `upstreamBaseUrl`, `upstreamApiKey`,
 `upstreamModel`, `port`, `proxyTokens` (accepts several), `advertisedModels`
 (models shown to Claude Code model discovery — must look Anthropic-ish, e.g.
-`claude-sonnet-4-5` or `sonnet`), `toolFormat`.
+`claude-sonnet-4-5` or `sonnet`), `toolFormat`, `fullLogging`.
+
+## Logging
+
+`gateway.log` (in `~/.anthropic-gateway/`) records, per request, the tokens
+sent/received and a running session total (input / output / total since the
+gateway started).
+
+To also capture the **full request and response bodies** (useful for debugging
+upstream mismatches), enable full logging:
+
+```bash
+anthropic-gateway fulllogging on     # or: setup --full-logging
+anthropic-gateway stop && anthropic-gateway start   # restart to apply
+```
+
+Full bodies are written to the log file only (not the console), so streaming
+stdout stays clean. Turn it off the same way with `fulllogging off`.
+
+`status` shows the same token totals plus version, pid, uptime and the
+full-logging state:
+
+```
+Status                 UP
+Version                1.2.0
+PID                    23628
+Listen                 127.0.0.1:3080
+Upstream model         Qwen/Qwen3.8-27B
+...
+Requests               42
+Tokens (in/out/total)  118300 / 9210 / 127510
+```
 
 ## Using it with Claude Code GUI (desktop app)
 

package/cli.js

@@ -42,6 +42,34 @@ function fail(msg) {
   process.exit(1);
 }
 
+function getVersion() {
+  try {
+    return require(path.join(APP_DIR, 'package.json')).version;
+  } catch {
+    return 'unknown';
+  }
+}
+
+function formatUptime(sec) {
+  if (!Number.isFinite(sec)) return '—';
+  const d = Math.floor(sec / 86400);
+  const h = Math.floor((sec % 86400) / 3600);
+  const m = Math.floor((sec % 3600) / 60);
+  const s = Math.floor(sec % 60);
+  const parts = [];
+  if (d) parts.push(d + 'd');
+  if (h) parts.push(h + 'h');
+  if (m) parts.push(m + 'm');
+  parts.push(s + 's');
+  return parts.join(' ');
+}
+
+function maskKey(key) {
+  const k = String(key || '');
+  if (k.length <= 8) return k ? k[0] + '…' : '—';
+  return k.slice(0, 4) + '…' + k.slice(-4);
+}
+
 function ask(rl, q, def) {
   return new Promise((resolve) => {
     rl.question(q + (def ? ' [' + def + '] ' : ' '), (a) => resolve(a.trim() === '' ? (def || '') : a.trim()));
@@ -115,6 +143,8 @@ async function cmdSetup(args) {
   if (!Number.isInteger(port) || port < 1 || port > 65535) fail('invalid port');
 
   const advertisedModels = adv.split(',').map((s) => s.trim()).filter(Boolean);
+  const fullLoggingFlag = args['full-logging'];
+  const fullLogging = fullLoggingFlag !== undefined && String(fullLoggingFlag) !== 'false';
   const config = {
     providerName: preset.name || 'custom',
     upstreamBaseUrl: baseUrl.replace(/\/+$/, ''),
@@ -124,6 +154,7 @@ async function cmdSetup(args) {
     proxyTokens: [token],
     toolFormat: 'native',
     advertisedModels,
+    fullLogging,
     logFile: LOG_FILE,
   };
 
@@ -176,15 +207,45 @@ async function cmdStatus(args) {
   ensureHomeDir();
   const cfgPath = args.config ? path.resolve(args.config) : DEFAULT_CONFIG;
   let cfg;
-  try { cfg = loadConfig(cfgPath); } catch (e) { console.log('down (no config)'); return; }
+  try { cfg = loadConfig(cfgPath); } catch (e) { console.log('down (no config — run "anthropic-gateway setup")'); return; }
   try {
     const res = await fetch('http://127.0.0.1:' + cfg.port + '/health');
-    console.log('UP on ' + cfg.port + ' — ' + (await res.text()));
+    const h = await res.json();
+    const t = h.totals || { requests: 0, inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    const rows = [
+      ['Status', 'UP'],
+      ['Version', h.version || getVersion()],
+      ['PID', String(h.pid || '—')],
+      ['Listen', '127.0.0.1:' + (h.port || cfg.port)],
+      ['Upstream model', h.upstream || cfg.upstreamModel],
+      ['Upstream URL', h.provider || cfg.upstreamBaseUrl],
+      ['API key', maskKey(cfg.upstreamApiKey)],
+      ['Tool format', h.toolFormat || cfg.toolFormat || 'native'],
+      ['Full logging', h.fullLogging ? 'ON' : 'off'],
+      ['Uptime', formatUptime(h.uptimeSec)],
+      ['Requests', String(t.requests)],
+      ['Tokens (in/out/total)', t.inputTokens + ' / ' + t.outputTokens + ' / ' + t.totalTokens],
+    ];
+    const w = Math.max(...rows.map((r) => r[0].length));
+    for (const [k, v] of rows) console.log(k.padEnd(w) + '  ' + v);
   } catch {
     console.log('DOWN — nothing listening on 127.0.0.1:' + cfg.port);
+    console.log('Start it with: anthropic-gateway start');
   }
 }
 
+async function cmdFullLogging(mode, args) {
+  const m = String(mode || '').toLowerCase();
+  if (m !== 'on' && m !== 'off') fail('usage: node cli.js fulllogging on|off');
+  const cfgPath = args && args.config ? path.resolve(args.config) : DEFAULT_CONFIG;
+  const cfg = loadConfig(cfgPath);
+  cfg.fullLogging = m === 'on';
+  fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+  console.log('fullLogging = ' + cfg.fullLogging + '  (saved to ' + cfgPath + ')');
+  console.log('Restart the gateway to apply: anthropic-gateway stop, then anthropic-gateway start');
+  if (cfg.fullLogging && cfg.logFile) console.log('Full request/response bodies will be appended to ' + cfg.logFile);
+}
+
 function startupCmdContents() {
   const node = process.execPath;
   return [
@@ -235,6 +296,10 @@ function parseFlags(argv) {
 
 (async () => {
   const argv = process.argv.slice(2);
+  if (argv.includes('--version') || argv.includes('-v')) {
+    console.log('anthropic-gateway ' + getVersion());
+    process.exit(0);
+  }
   const flags = parseFlags(argv);
   const cmd = flags._ && flags._[0];
   if (!cmd) {
@@ -243,19 +308,26 @@ function parseFlags(argv) {
         'anthropic-gateway — Anthropic-compatible gateway for OpenAI-compatible providers',
         '',
         'usage:',
-        '  anthropic-gateway setup [--provider kilo|openai|custom] [--base-url URL] [--api-key KEY] [--model ID] [--port N] [--token TOK] [--yes]',
+        '  anthropic-gateway setup [--provider kilo|openai|custom] [--base-url URL] [--api-key KEY] [--model ID] [--port N] [--token TOK] [--full-logging] [--yes]',
         '  anthropic-gateway start',
         '  anthropic-gateway stop',
         '  anthropic-gateway status',
+        '  anthropic-gateway fulllogging on|off   # log full request/response bodies to the log file (restart to apply)',
         '  anthropic-gateway autostart on|off',
+        '  anthropic-gateway version        # or: --version, -v',
       ].join('\n')
     );
     process.exit(0);
   }
+  if (cmd === 'version') {
+    console.log('anthropic-gateway ' + getVersion());
+    process.exit(0);
+  }
   if (cmd === 'setup') await cmdSetup(flags);
   else if (cmd === 'start') await cmdStart(flags);
   else if (cmd === 'stop') await cmdStop();
   else if (cmd === 'status') await cmdStatus(flags);
+  else if (cmd === 'fulllogging') await cmdFullLogging(flags._[1], flags);
   else if (cmd === 'autostart') await cmdAutostart(flags._[1]);
   else fail('unknown command: ' + cmd);
 })();

package/config.example.json

@@ -8,6 +8,7 @@
     "<YOUR-PROXY-TOKEN>"
   ],
   "toolFormat": "native",
+  "fullLogging": false,
   "advertisedModels": [
     "claude-sonnet-4-5",
     "claude-haiku-4-5",

package/lib/server.js

@@ -13,6 +13,8 @@
  *   proxyTokens       string[] — accepted client auth tokens (Bearer or x-api-key)
  *   toolFormat        'native' (default) or 'xml'
  *   advertisedModels  model ids returned by GET /v1/models (for GUI discovery)
+ *   fullLogging       boolean — when true, full request/response bodies are
+ *                     appended to logFile (log-only, not console)
  *   logFile           optional path to append logs to (default: none, console only)
  */
 const fs = require('fs');
@@ -31,6 +33,15 @@ const DEFAULTS = {
   advertisedModels: ['claude-sonnet-4-5', 'claude-haiku-4-5', 'claude-opus-4-5'],
 };
 
+function readVersion() {
+  try {
+    return require('../package.json').version;
+  } catch {
+    return 'unknown';
+  }
+}
+const VERSION = readVersion();
+
 function matchesToken(value, expected) {
   if (typeof value !== 'string') return false;
   const a = Buffer.from(value);
@@ -57,8 +68,10 @@ function makeServer(rawCfg) {
     if (logStream) logStream.write(s + '\n');
   }
 
-  // Token totals for the lifetime of this gateway process (resets on restart).
+  // Per-session stats for the lifetime of this gateway process (reset on restart).
   const totals = { requests: 0, input: 0, output: 0, cached: 0 };
+  const startedAt = Date.now();
+  const fullLogging = !!cfg.fullLogging;
   function recordUsage(input, output, cached) {
     totals.requests += 1;
     totals.input += input;
@@ -68,6 +81,23 @@ function makeServer(rawCfg) {
   function usageSummary() {
     return 'session ' + totals.requests + ' req  in=' + totals.input + ' out=' + totals.output + ' total=' + (totals.input + totals.output);
   }
+  function uptimeSeconds() {
+    return Math.floor((Date.now() - startedAt) / 1000);
+  }
+
+  // Full request/response capture, appended to the log file only (not console,
+  // so streaming stdout stays clean). Off unless fullLogging is set in config.
+  function logFull(kind, data) {
+    if (!fullLogging || !logStream) return;
+    const header = '[FULL ' + kind + '] ' + new Date().toISOString();
+    let body;
+    try {
+      body = typeof data === 'string' ? data : JSON.stringify(data);
+    } catch {
+      body = String(data);
+    }
+    logStream.write('\n' + header + '\n' + body + '\n');
+  }
 
   const app = fastify({ logger: false });
   const isAzure = cfg.upstreamBaseUrl.includes('.openai.azure.com');
@@ -75,7 +105,24 @@ function makeServer(rawCfg) {
 
   const modelsPayload = { data: (cfg.advertisedModels || []).map((id) => ({ id, display_name: id + ' (via ' + cfg.upstreamModel + ')' })) };
 
-  app.get('/health', async () => ({ status: 'ok', gateway: 'anthropic-gateway', upstream: cfg.upstreamModel }));
+  app.get('/health', async () => ({
+    status: 'ok',
+    gateway: 'anthropic-gateway',
+    version: VERSION,
+    pid: process.pid,
+    port: cfg.port,
+    upstream: cfg.upstreamModel,
+    provider: cfg.providerName || cfg.upstreamBaseUrl,
+    toolFormat: cfg.toolFormat,
+    uptimeSec: uptimeSeconds(),
+    fullLogging,
+    totals: {
+      requests: totals.requests,
+      inputTokens: totals.input,
+      outputTokens: totals.output,
+      totalTokens: totals.input + totals.output,
+    },
+  }));
   app.get('/v1/models', async () => modelsPayload);
 
   app.post('/v1/messages', async (request, reply) => {
@@ -109,11 +156,15 @@ function makeServer(rawCfg) {
 
     try {
       const openaiRequest = convertRequestToOpenAI(anthropicRequest, cfg.upstreamModel, cfg.toolFormat, isAzure);
+      logFull('IN request (anthropic)', anthropicRequest);
+      logFull('IN request (openai)', openaiRequest);
       if (isStreaming) {
         const stream = await openai.chat.completions.create({ ...openaiRequest, stream: true, stream_options: { include_usage: true } });
         // Capture token usage from the stream without altering what the vendored
         // converter sees — it just iterates chunks, so a pass-through works.
         const usage = { input: 0, output: 0, cached: 0 };
+        let outText = '';
+        let outTools = [];
         const wrapped = (async function* () {
           for await (const chunk of stream) {
             if (chunk && chunk.usage) {
@@ -121,17 +172,31 @@ function makeServer(rawCfg) {
               usage.output = chunk.usage.completion_tokens ?? usage.output;
               usage.cached = chunk.usage.prompt_tokens_details?.cached_tokens ?? usage.cached;
             }
+            const choice = chunk && chunk.choices && chunk.choices[0];
+            if (choice && choice.delta) {
+              if (choice.delta.content) outText += choice.delta.content;
+              if (choice.delta.tool_calls) {
+                for (const tc of choice.delta.tool_calls) {
+                  const rec = outTools[tc.index] || (outTools[tc.index] = { id: tc.id || '', name: '', arguments: '' });
+                  if (tc.id) rec.id = tc.id;
+                  if (tc.function && tc.function.name) rec.name += tc.function.name;
+                  if (tc.function && tc.function.arguments) rec.arguments += tc.function.arguments;
+                }
+              }
+            }
             yield chunk;
           }
         })();
         reply.hijack();
         await streamOpenAIToAnthropic(wrapped, reply, clientModel, cfg.upstreamBaseUrl);
         recordUsage(usage.input, usage.output, usage.cached);
+        logFull('OUT response (streamed)', { model: clientModel, text: outText, tool_calls: outTools.filter(Boolean), usage });
         log('<- ' + clientModel + ' ok  in=' + usage.input + ' out=' + usage.output + ' total=' + (usage.input + usage.output) + '  | ' + usageSummary());
       } else {
         const response = await openai.chat.completions.create({ ...openaiRequest, stream: false });
         const anthropicResponse = convertResponseToAnthropic(response, clientModel);
         reply.send(anthropicResponse);
+        logFull('OUT response (anthropic)', anthropicResponse);
         const u = anthropicResponse.usage || {};
         recordUsage(u.input_tokens || 0, u.output_tokens || 0, u.cache_read_input_tokens || 0);
         log('<- ' + clientModel + ' ok  in=' + (u.input_tokens || 0) + ' out=' + (u.output_tokens || 0) + ' total=' + ((u.input_tokens || 0) + (u.output_tokens || 0)) + '  | ' + usageSummary());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anthropic-gateway",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Anthropic-compatible local gateway for any OpenAI-compatible model provider — make Claude Code (GUI/CLI) work with kilo, OpenAI, DeepSeek, local models, etc.",
   "license": "MIT",
   "engines": {