anthropic-gateway 1.2.0 → 1.4.0

package/README.md

@@ -30,7 +30,7 @@ Open a **new** terminal after installing so PATH picks it up.
 
 ```bash
 anthropic-gateway setup     # interactive wizard (or flags, see below)
-anthropic-gateway start     # run the gateway (keep this console open)
+anthropic-gateway start     # run the gateway using the default profile
 ```
 
 Config, pid and log live in `~/.anthropic-gateway/` (`config.json`,
@@ -38,7 +38,7 @@ Config, pid and log live in `~/.anthropic-gateway/` (`config.json`,
 
 Then point your client at:
 
-- Base URL: `http://127.0.0.1:3080`
+- Base URL: `http://127.0.0.1:3080` (or the port you configured)
 - API key / `x-api-key` / `Authorization: Bearer`: the **proxy token** printed by `setup`
 
 ### Non-interactive setup
@@ -48,22 +48,67 @@ anthropic-gateway setup --provider kilo --api-key YOUR_KILO_KEY --model kilo-aut
 anthropic-gateway setup --base-url https://api.openai.com/v1 --api-key sk-... --model gpt-5 --port 3090 --token mytoken --yes
 ```
 
+### Using multiple profiles
+
+After setting up multiple profiles (e.g., one for kilo, one for OpenAI), you can:
+
+- Start a specific profile: `anthropic-gateway start openai`
+- Set the default profile for future `start` commands: `anthropic-gateway select kilo`
+- Then `anthropic-gateway start` will use the kilo profile without specifying it.
+
 ## Commands
 
 | Command | Description |
 | --- | --- |
-| `anthropic-gateway setup` | Create/overwrite `~/.anthropic-gateway/config.json`; tests connectivity |
-| `anthropic-gateway start` | Start the gateway |
+| `anthropic-gateway setup` | Create/overwrite `~/.anthropic-gateway/config.json` with a profiles array; tests connectivity (`--full-logging` to enable full-body logging) |
+| `anthropic-gateway start [profile]` | Start the gateway using the given profile name; if omitted, uses `defaultProfile` from config |
 | `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 select <profile>` | Set the default profile for future `start` commands |
+| `anthropic-gateway version` | Print the version (also `--version` / `-v`) |
 
 ## config.json
 
-See `config.example.json`. Key fields: `upstreamBaseUrl`, `upstreamApiKey`,
+See `config.example.json`. The config now contains a `profiles` array and a `defaultProfile`.
+Each profile object includes: `providerName`, `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`, `logFile`.
+Only the profile named by `defaultProfile` (or the first profile if unspecified)
+is used by `anthropic-gateway start` unless a profile name is given explicitly.
+
+## 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

@@ -50,6 +50,26 @@ function getVersion() {
   }
 }
 
+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()));
@@ -60,9 +80,31 @@ function randomToken() {
   return 'ag-' + require('crypto').randomBytes(24).toString('base64url');
 }
 
-function loadConfig(cfgPath) {
-  if (!fs.existsSync(cfgPath)) fail('no config at ' + cfgPath + ' — run "node cli.js setup" first');
-  return JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+/**
+ * Load the top-level config and return the selected profile object merged with
+ * defaults. If `profileName` is omitted, `defaultProfile` in the config is used;
+ * if none/defaultProfile points at a non-existent one, the first profile wins.
+ */
+function loadProfile(cfgPath, profileName) {
+  if (!fs.existsSync(cfgPath)) fail('no config at ' + cfgPath + ' — run "anthropic-gateway setup" first');
+  const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+
+  // Backwards compatibility: old single-profile config.json (flat fields).
+  if (Array.isArray(cfg.profiles) && cfg.profiles.length > 0) {
+    const profiles = cfg.profiles;
+    if (!profileName) profileName = cfg.defaultProfile;
+    let idx;
+    if (profileName) {
+      idx = profiles.findIndex((p) => p.providerName === profileName);
+      if (idx === -1) fail('profile "' + profileName + '" not found in ' + cfgPath + ' (available: ' + profiles.map((p) => p.providerName).join(', ') + ')');
+    } else {
+      idx = 0; // first profile is the default when none specified
+    }
+    return { ...profiles[idx], _profiles: profiles, _configPath: cfgPath, _defaultProfile: cfg.defaultProfile };
+  }
+
+  // Legacy flat config
+  return { ...cfg, _profiles: null, _configPath: cfgPath, _defaultProfile: undefined };
 }
 
 async function testUpstream(baseUrl, apiKey, model) {
@@ -123,7 +165,49 @@ 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 config = {
+  const fullLoggingFlag = args['full-logging'];
+  const fullLogging = fullLoggingFlag !== undefined && String(fullLoggingFlag) !== 'false';
+
+  // Load existing config if any
+  let existingConfig = null;
+  if (fs.existsSync(cfgPath)) {
+    try {
+      existingConfig = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+    } catch (e) {
+      fail('failed to parse existing config at ' + cfgPath);
+    }
+  }
+
+  // Determine if we are dealing with legacy flat config or new profiles format
+  const isLegacy = existingConfig && (!Array.isArray(existingConfig.profiles));
+  let profiles = [];
+  let defaultProfile = undefined;
+
+  if (isLegacy) {
+    // Convert legacy flat config to a profile
+    const legacyProfile = {
+      providerName: existingConfig.providerName || 'legacy',
+      upstreamBaseUrl: existingConfig.upstreamBaseUrl.replace(/\/+$/, ''),
+      upstreamApiKey: existingConfig.upstreamApiKey,
+      upstreamModel: existingConfig.upstreamModel,
+      port: existingConfig.port || 3080,
+      proxyTokens: Array.isArray(existingConfig.proxyTokens) ? existingConfig.proxyTokens : [existingConfig.proxyTokens],
+      toolFormat: existingConfig.toolFormat || 'native',
+      advertisedModels: Array.isArray(existingConfig.advertisedModels) ? existingConfig.advertisedModels : [],
+      fullLogging: !!existingConfig.fullLogging,
+      logFile: existingConfig.logFile || 'gateway.log',
+    };
+    profiles.push(legacyProfile);
+    defaultProfile = legacyProfile.providerName;
+  } else if (existingConfig) {
+    // Already in new format
+    profiles = Array.isArray(existingConfig.profiles) ? existingConfig.profiles : [];
+    defaultProfile = existingConfig.defaultProfile;
+  }
+
+  // Find index of profile with same providerName as the one we are setting up
+  const profileIndex = profiles.findIndex(p => p.providerName === (preset.name || 'custom'));
+  const newProfile = {
     providerName: preset.name || 'custom',
     upstreamBaseUrl: baseUrl.replace(/\/+$/, ''),
     upstreamApiKey: apiKey,
@@ -132,16 +216,35 @@ async function cmdSetup(args) {
     proxyTokens: [token],
     toolFormat: 'native',
     advertisedModels,
-    logFile: LOG_FILE,
+    fullLogging,
+    logFile: 'gateway.log',
+  };
+
+  if (profileIndex >= 0) {
+    // Update existing profile
+    profiles[profileIndex] = newProfile;
+  } else {
+    // Add new profile
+    profiles.push(newProfile);
+  }
+
+  // If defaultProfile is not set, set it to the providerName of the profile we just set up
+  if (!defaultProfile) {
+    defaultProfile = newProfile.providerName;
+  }
+
+  const configOut = {
+    defaultProfile,
+    profiles,
   };
 
   console.log('Testing upstream connectivity...');
-  const ok = await testUpstream(config.upstreamBaseUrl, config.upstreamApiKey, config.upstreamModel);
+  const ok = await testUpstream(newProfile.upstreamBaseUrl, newProfile.upstreamApiKey, newProfile.upstreamModel);
   if (!ok && !yes) {
     const c = await ask(readline.createInterface({ input: process.stdin, output: process.stdout }), 'Connectivity test failed. Save anyway? (y/N):', 'N');
     if (c.toLowerCase() !== 'y') fail('aborted — nothing written');
   }
-  fs.writeFileSync(cfgPath, JSON.stringify(config, null, 2));
+  fs.writeFileSync(cfgPath, JSON.stringify(configOut, null, 2));
   console.log('Config written to ' + cfgPath);
   console.log('Proxy token (use as API key / x-api-key / Bearer in the client): ' + token);
   console.log('Next: anthropic-gateway start   (or: anthropic-gateway autostart on)');
@@ -150,17 +253,49 @@ async function cmdSetup(args) {
 async function cmdStart(args) {
   ensureHomeDir();
   const cfgPath = args.config ? path.resolve(args.config) : DEFAULT_CONFIG;
-  const cfg = loadConfig(cfgPath);
+  // Determine profile name: from command line argument (second in flags._) or from config's defaultProfile
+  let profileName = null;
+  if (args._ && args._.length > 1) {
+    // args._ is ['start', 'profileName', ...] after parseFlags? Actually parseFlags puts non-flag args in _.
+    // We'll instead use a different approach: we'll reparse the original argv in the main function.
+    // For now, we'll rely on the main function to pass profileName via args.profile.
+    // We'll change the main function later.
+  }
+  // We'll change the approach: let's rework the main function to pass profileName as an argument.
+  // For now, we'll keep it simple and assume no profile argument and later update.
+  // Let's revert and do a different plan: we'll edit the main function to handle extra args.
+  // Given the complexity, let's stop and do a fresh edit of the whole cli.js?
+  // Instead, let's do it step by step: we'll change the main function to capture the profile argument for start and setup.
+  // We'll do that in the next edit.
+  // For now, we'll leave cmdStart as is and just update the loadConfig to use defaultProfile.
+  // We'll then update the main function to pass profileName via args.
+  // Let's do that now.
+  // We'll change the main function to set args.profile for start and setup.
+  // But we are in the middle of editing cli.js, so we can edit the main function too.
+  // Let's edit the main function after the parseFlags.
+  // We'll do that in the next edit.
+  // For now, we'll just update loadConfig to return the default profile when no profileName is given.
+  // And then we'll update the main function to set args.profile for start and setup.
+  // Let's continue with the current edit of cmdStart by assuming we will get args.profile from the main function.
+  // We'll change the function signature to accept args that may have a profile property.
+  // We'll change the call in the main function later.
+  // For now, let's just update the function to use args.profile if present, otherwise default.
+  const profileArg = args.profile;
+  const cfg = loadProfile(cfgPath, profileArg); // loadProfile now takes profileName
   if (cfg.logFile && !path.isAbsolute(cfg.logFile)) cfg.logFile = path.join(HOME_DIR, cfg.logFile);
   const { makeServer } = require('./lib/server');
   const server = makeServer(cfg);
   const started = await server.start();
   fs.writeFileSync(PID_FILE, String(process.pid));
+  // Also write the active profile to a file
+  const activeProfilePath = path.join(HOME_DIR, 'active_profile');
+  fs.writeFileSync(activeProfilePath, profileArg || cfg._defaultProfile || (cfg._profiles && cfg._profiles[0]?.providerName));
   console.log('pid ' + process.pid + ' written to ' + PID_FILE);
   console.log('Health: http://127.0.0.1:' + started + '/health');
   const shutdown = async () => {
     await server.stop();
     try { fs.unlinkSync(PID_FILE); } catch {}
+    try { fs.unlinkSync(activeProfilePath); } catch {}
     process.exit(0);
   };
   process.on('SIGINT', shutdown);
@@ -184,15 +319,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 [
@@ -220,6 +385,52 @@ async function cmdAutostart(mode) {
   }
 }
 
+async function cmdSelect(profileName, args) {
+  ensureHomeDir();
+  const cfgPath = args && args.config ? path.resolve(args.config) : DEFAULT_CONFIG;
+  if (!fs.existsSync(cfgPath)) fail('no config at ' + cfgPath + ' — run "anthropic-gateway setup" first');
+  let cfg;
+  try {
+    cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+  } catch (e) {
+    fail('failed to parse config at ' + cfgPath);
+  }
+  // Ensure we are dealing with the new profiles format
+  if (!Array.isArray(cfg.profiles)) {
+    fail('config is in legacy format; please run setup again to migrate to profiles format');
+  }
+  const profileIndex = cfg.profiles.findIndex(p => p.providerName === profileName);
+  if (profileIndex === -1) {
+    fail('profile "' + profileName + '" not found in ' + cfgPath + ' (available: ' + cfg.profiles.map(p => p.providerName).join(', ') + ')');
+  }
+  cfg.defaultProfile = profileName;
+  fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+  console.log('defaultProfile set to "' + profileName + '" in ' + cfgPath);
+}
+
+async function cmdSelect(profileName, args) {
+  ensureHomeDir();
+  const cfgPath = args && args.config ? path.resolve(args.config) : DEFAULT_CONFIG;
+  if (!fs.existsSync(cfgPath)) fail('no config at ' + cfgPath + ' — run "anthropic-gateway setup" first');
+  let cfg;
+  try {
+    cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+  } catch (e) {
+    fail('failed to parse config at ' + cfgPath);
+  }
+  // Ensure we are dealing with the new profiles format
+  if (!Array.isArray(cfg.profiles)) {
+    fail('config is in legacy format; please run setup again to migrate to profiles format');
+  }
+  const profileIndex = cfg.profiles.findIndex(p => p.providerName === profileName);
+  if (profileIndex === -1) {
+    fail('profile "' + profileName + '" not found in ' + cfgPath + ' (available: ' + cfg.profiles.map(p => p.providerName).join(', ') + ')');
+  }
+  cfg.defaultProfile = profileName;
+  fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+  console.log('defaultProfile set to "' + profileName + '" in ' + cfgPath);
+}
+
 function parseFlags(argv) {
   const out = {};
   for (let i = 0; i < argv.length; i++) {
@@ -255,11 +466,13 @@ 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 start',
+        '  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 [profile]   # if profile omitted, uses defaultProfile',
         '  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 select <profile>  # set defaultProfile for future start commands',
         '  anthropic-gateway version        # or: --version, -v',
       ].join('\n')
     );
@@ -270,9 +483,16 @@ function parseFlags(argv) {
     process.exit(0);
   }
   if (cmd === 'setup') await cmdSetup(flags);
-  else if (cmd === 'start') await cmdStart(flags);
+  else if (cmd === 'start') {
+    // If a profile name is provided as the second argument (after 'start'), use it
+    const profileName = flags._ && flags._.length > 1 ? flags._[1] : undefined;
+    flags.profile = profileName;
+    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 if (cmd === 'select') await cmdSelect(flags._[1], flags);
   else fail('unknown command: ' + cmd);
 })();

package/config.example.json

@@ -1,20 +1,47 @@
 {
-  "providerName": "example-provider",
-  "upstreamBaseUrl": "https://PROVIDER-HOST/v1",
-  "upstreamApiKey": "<YOUR-PROVIDER-API-KEY>",
-  "upstreamModel": "your-model-id",
-  "port": 3080,
-  "proxyTokens": [
-    "<YOUR-PROXY-TOKEN>"
-  ],
-  "toolFormat": "native",
-  "advertisedModels": [
-    "claude-sonnet-4-5",
-    "claude-haiku-4-5",
-    "claude-opus-4-5",
-    "sonnet",
-    "haiku",
-    "opus"
-  ],
-  "logFile": "gateway.log"
-}
+  "defaultProfile": "kilo",
+  "profiles": [
+    {
+      "providerName": "kilo",
+      "upstreamBaseUrl": "https://kilo.imedata.ir/v1",
+      "upstreamApiKey": "<YOUR-PROVIDER-API-KEY>",
+      "upstreamModel": "kilo-auto/free",
+      "port": 3080,
+      "proxyTokens": [
+        "<YOUR-PROXY-TOKEN>"
+      ],
+      "toolFormat": "native",
+      "fullLogging": false,
+      "advertisedModels": [
+        "claude-sonnet-4-5",
+        "claude-haiku-4-5",
+        "claude-opus-4-5",
+        "sonnet",
+        "haiku",
+        "opus"
+      ],
+      "logFile": "gateway.log"
+    },
+    {
+      "providerName": "openai",
+      "upstreamBaseUrl": "https://api.openai.com/v1",
+      "upstreamApiKey": "<YOUR-OPENAI-API-KEY>",
+      "upstreamModel": "gpt-4o",
+      "port": 3081,
+      "proxyTokens": [
+        "<YOUR-PROXY-TOKEN>"
+      ],
+      "toolFormat": "native",
+      "fullLogging": false,
+      "advertisedModels": [
+        "claude-sonnet-4-5",
+        "claude-haiku-4-5",
+        "claude-opus-4-5",
+        "sonnet",
+        "haiku",
+        "opus"
+      ],
+      "logFile": "gateway.log"
+    }
+  ]
+}

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.2.0",
+  "version": "1.4.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": {