anthropic-gateway 1.0.0

package/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Copyright (c) 2026 anthropic-gateway contributors
+
+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 includes a vendored conversion core originally written for
+claude-adapter (https://github.com/shanthropic/claude-adapter), which is also
+MIT-licensed — see vendor/LICENSE.claude-adapter.
+
+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,75 @@
+# anthropic-gateway
+
+A local gateway that speaks the **Anthropic Messages API** and forwards every
+request to **any OpenAI-compatible provider** (kilo, OpenAI, DeepSeek, Groq,
+local servers, ...). It forces every request to a single configured upstream
+model, which makes it work with clients that can only talk to Anthropic —
+including the **Claude Code GUI (desktop app)** via its custom gateway
+(3P / enterprise) mode, Claude Code CLI, or any Anthropic-SDK tool.
+
+```
+Claude Code GUI/CLI  ──(Anthropic format)──▶  anthropic-gateway (127.0.0.1:3080)
+                                                    │  translate + force model
+                                                    ▼
+                                        OpenAI-compatible provider (/v1/chat/completions)
+```
+
+## Install
+
+```bash
+npm install                 # inside this folder, once
+npm i -g .                  # optional: real global install (needs an admin shell
+                            # if node lives under C:\Program Files)
+```
+
+Without admin rights a `C:\Users\<you>\bin\anthropic-gateway.cmd` wrapper is
+used instead — both give you the `anthropic-gateway` command (alias: `ag`).
+Open a **new** terminal after installing so PATH picks it up.
+
+## Quick start
+
+```bash
+anthropic-gateway setup     # interactive wizard (or flags, see below)
+anthropic-gateway start     # run the gateway (keep this console open)
+```
+
+Config, pid and log live in `~/.anthropic-gateway/` (`config.json`,
+`gateway.pid`, `gateway.log`).
+
+Then point your client at:
+
+- Base URL: `http://127.0.0.1:3080`
+- API key / `x-api-key` / `Authorization: Bearer`: the **proxy token** printed by `setup`
+
+### Non-interactive setup
+
+```bash
+anthropic-gateway setup --provider kilo --api-key YOUR_KILO_KEY --model kilo-auto/free --yes
+anthropic-gateway setup --base-url https://api.openai.com/v1 --api-key sk-... --model gpt-5 --port 3090 --token mytoken --yes
+```
+
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `anthropic-gateway setup` | Create/overwrite `~/.anthropic-gateway/config.json`; tests connectivity |
+| `anthropic-gateway start` | Start the gateway |
+| `anthropic-gateway stop` | Stop the gateway |
+| `anthropic-gateway status` | Is the gateway up? |
+| `anthropic-gateway autostart on\|off` | Launch at Windows logon (Startup folder) |
+
+## 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`.
+
+## Using it with Claude Code GUI (desktop app)
+
+1. Keep the gateway running (`anthropic-gateway start`, or `autostart on`).
+2. In Claude desktop: Settings → custom provider / Claude Code Setup →
+   base URL `http://127.0.0.1:<port>`, API key = your proxy token.
+3. Run its connection test, restart Claude, open Claude Code — the model
+   selector lists the `advertisedModels`, and every chat is served by your
+   upstream model.

package/cli.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+"use strict";
+/*
+ * anthropic-gateway CLI
+ *
+ *   node cli.js setup  [--provider kilo|openai|custom] [--base-url ..] [--api-key ..]
+ *                      [--model ..] [--port ..] [--token ..] [--config path] [--yes]
+ *   node cli.js start  [--config path]
+ *   node cli.js stop   [--config path]
+ *   node cli.js status [--config path]
+ *   node cli.js autostart on|off  [--config path]
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const readline = require('readline');
+const { spawn } = require('child_process');
+
+const APP_DIR = __dirname;
+const HOME_DIR =
+  process.env.ANTHROPIC_GATEWAY_HOME || path.join(os.homedir(), '.anthropic-gateway');
+const DEFAULT_CONFIG = path.join(HOME_DIR, 'config.json');
+const PID_FILE = path.join(HOME_DIR, 'gateway.pid');
+const LOG_FILE = path.join(HOME_DIR, 'gateway.log');
+const STARTUP_CMD = path.join(
+  os.homedir(),
+  'AppData/Roaming/Microsoft/Windows/Start Menu/Programs/Startup/anthropic-gateway.cmd'
+);
+
+function ensureHomeDir() {
+  fs.mkdirSync(HOME_DIR, { recursive: true });
+}
+
+const PRESETS = {
+  kilo: { name: 'kilo.imedata.ir', baseUrl: 'https://kilo.imedata.ir/v1', model: 'kilo-auto/free', needsKey: true },
+  openai: { name: 'OpenAI', baseUrl: 'https://api.openai.com/v1', model: '', needsKey: true },
+  custom: { name: 'custom', baseUrl: '', model: '', needsKey: true },
+};
+
+function fail(msg) {
+  console.error('error: ' + msg);
+  process.exit(1);
+}
+
+function ask(rl, q, def) {
+  return new Promise((resolve) => {
+    rl.question(q + (def ? ' [' + def + '] ' : ' '), (a) => resolve(a.trim() === '' ? (def || '') : a.trim()));
+  });
+}
+
+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'));
+}
+
+async function testUpstream(baseUrl, apiKey, model) {
+  const OpenAI = require('openai');
+  const client = new OpenAI({ baseURL: baseUrl, apiKey });
+  const started = Date.now();
+  try {
+    await client.chat.completions.create({
+      model,
+      messages: [{ role: 'user', content: 'Reply with exactly: OK' }],
+      max_tokens: 16,
+    });
+    console.log('  connectivity: OK (' + (Date.now() - started) + ' ms) via ' + model);
+    return true;
+  } catch (e) {
+    console.log('  connectivity FAILED: ' + (e && e.message ? String(e.message).slice(0, 300) : e));
+    return false;
+  }
+}
+
+async function cmdSetup(args) {
+  ensureHomeDir();
+  let cfgPath = DEFAULT_CONFIG;
+  let provider = args.provider || '';
+  let baseUrl = args['base-url'] || '';
+  let apiKey = args['api-key'] || '';
+  let model = args.model || '';
+  let port = args.port ? Number(args.port) : NaN;
+  let token = args.token || '';
+  const yes = !!args.yes;
+
+  if (args.config) cfgPath = path.resolve(args.config);
+
+  const interactive = !yes;
+  const rl = interactive ? readline.createInterface({ input: process.stdin, output: process.stdout }) : null;
+  const q = async (prompt, def) => (interactive ? ask(rl, prompt, def) : def || '');
+
+  if (!provider) provider = await q('Provider preset (kilo | openai | custom):', 'kilo');
+  provider = provider.toLowerCase();
+  const preset = PRESETS[provider] || PRESETS.custom;
+  if (provider !== 'custom') console.log('Using preset: ' + preset.name);
+
+  if (!baseUrl) baseUrl = await q('Upstream base URL (OpenAI-compatible, e.g. https://host/v1):', preset.baseUrl);
+  if (!apiKey) apiKey = await q('API key:', '');
+  if (!model) model = await q('Upstream model id (all requests are sent to this model):', preset.model);
+  if (!Number.isFinite(port)) {
+    const p = await q('Local port:', '3080');
+    port = Number(p);
+  }
+  if (!token) {
+    const want = await q('Proxy token (client auth; enter to auto-generate):', '');
+    token = want || randomToken();
+  }
+  const adv = await q('Advertised model ids (comma separated, shown to Claude Code):', 'claude-sonnet-4-5,claude-haiku-4-5,claude-opus-4-5,sonnet,haiku,opus');
+  if (interactive) rl.close();
+
+  if (!baseUrl || !apiKey || !model) fail('base URL, API key and model are required');
+  if (!Number.isInteger(port) || port < 1 || port > 65535) fail('invalid port');
+
+  const advertisedModels = adv.split(',').map((s) => s.trim()).filter(Boolean);
+  const config = {
+    providerName: preset.name || 'custom',
+    upstreamBaseUrl: baseUrl.replace(/\/+$/, ''),
+    upstreamApiKey: apiKey,
+    upstreamModel: model,
+    port,
+    proxyTokens: [token],
+    toolFormat: 'native',
+    advertisedModels,
+    logFile: LOG_FILE,
+  };
+
+  console.log('Testing upstream connectivity...');
+  const ok = await testUpstream(config.upstreamBaseUrl, config.upstreamApiKey, config.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));
+  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)');
+}
+
+async function cmdStart(args) {
+  ensureHomeDir();
+  const cfgPath = args.config ? path.resolve(args.config) : DEFAULT_CONFIG;
+  const cfg = loadConfig(cfgPath);
+  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));
+  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 {}
+    process.exit(0);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+async function cmdStop() {
+  ensureHomeDir();
+  if (!fs.existsSync(PID_FILE)) fail('no pid file (was it started with "anthropic-gateway start"? or already stopped)');
+  const pid = Number(fs.readFileSync(PID_FILE, 'utf8'));
+  try {
+    process.kill(pid);
+    console.log('stopped pid ' + pid);
+  } catch (e) {
+    console.log('pid ' + pid + ' not running (' + e.message + ')');
+  }
+  try { fs.unlinkSync(PID_FILE); } catch {}
+}
+
+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 {
+    const res = await fetch('http://127.0.0.1:' + cfg.port + '/health');
+    console.log('UP on ' + cfg.port + ' — ' + (await res.text()));
+  } catch {
+    console.log('DOWN — nothing listening on 127.0.0.1:' + cfg.port);
+  }
+}
+
+function startupCmdContents() {
+  const node = process.execPath;
+  return [
+    '@echo off',
+    'start "" /min "' + node + '" "' + path.join(APP_DIR, 'cli.js') + '" start',
+    '',
+  ].join('\r\n');
+}
+
+async function cmdAutostart(mode) {
+  ensureHomeDir();
+  if (mode === 'on') {
+    if (!fs.existsSync(DEFAULT_CONFIG)) fail('config.json missing — run setup first');
+    fs.writeFileSync(STARTUP_CMD, startupCmdContents());
+    console.log('Autostart enabled: ' + STARTUP_CMD);
+  } else if (mode === 'off') {
+    if (fs.existsSync(STARTUP_CMD)) {
+      fs.unlinkSync(STARTUP_CMD);
+      console.log('Autostart disabled');
+    } else {
+      console.log('Autostart was not enabled');
+    }
+  } else {
+    fail('usage: node cli.js autostart on|off');
+  }
+}
+
+function parseFlags(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith('--')) {
+      const k = a.slice(2);
+      const v = argv[i + 1];
+      if (v !== undefined && !v.startsWith('--')) {
+        out[k] = v;
+        i++;
+      } else {
+        out[k] = true;
+      }
+    } else {
+      out._ = out._ || [];
+      out._.push(a);
+    }
+  }
+  return out;
+}
+
+(async () => {
+  const argv = process.argv.slice(2);
+  const flags = parseFlags(argv);
+  const cmd = flags._ && flags._[0];
+  if (!cmd) {
+    console.log(
+      [
+        '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 stop',
+        '  anthropic-gateway status',
+        '  anthropic-gateway autostart on|off',
+      ].join('\n')
+    );
+    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 === 'autostart') await cmdAutostart(flags._[1]);
+  else fail('unknown command: ' + cmd);
+})();

package/config.example.json

@@ -0,0 +1,20 @@
+{
+  "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"
+}

package/lib/server.js

@@ -0,0 +1,132 @@
+"use strict";
+/*
+ * anthropic-gateway server core.
+ * Speaks the Anthropic Messages API locally (/v1/messages, /v1/models, /health)
+ * and forwards every request to any OpenAI-compatible upstream, always using
+ * the configured upstreamModel.
+ *
+ * config fields:
+ *   upstreamBaseUrl   e.g. https://kilo.imedata.ir/v1
+ *   upstreamApiKey    provider key
+ *   upstreamModel     model id sent upstream (all requests use it)
+ *   port              local listen port (default 3080)
+ *   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)
+ *   logFile           optional path to append logs to (default: none, console only)
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const fastify = require('fastify');
+const OpenAI = require('openai');
+const { convertRequestToOpenAI } = require('../vendor/dist/converters/request');
+const { convertResponseToAnthropic, createErrorResponse } = require('../vendor/dist/converters/response');
+const { streamOpenAIToAnthropic } = require('../vendor/dist/converters/streaming');
+const { validateAnthropicRequest, formatValidationErrors } = require('../vendor/dist/utils/validation');
+
+const DEFAULTS = {
+  port: 3080,
+  toolFormat: 'native',
+  advertisedModels: ['claude-sonnet-4-5', 'claude-haiku-4-5', 'claude-opus-4-5'],
+};
+
+function matchesToken(value, expected) {
+  if (typeof value !== 'string') return false;
+  const a = Buffer.from(value);
+  const b = Buffer.from(expected);
+  return a.length === b.length && crypto.timingSafeEqual(a, b);
+}
+
+function makeServer(rawCfg) {
+  const cfg = { ...DEFAULTS, ...rawCfg };
+  if (!Array.isArray(cfg.proxyTokens) || cfg.proxyTokens.length === 0) {
+    throw new Error('config needs at least one proxyTokens entry');
+  }
+  if (!cfg.upstreamBaseUrl || !cfg.upstreamApiKey || !cfg.upstreamModel) {
+    throw new Error('config needs upstreamBaseUrl, upstreamApiKey and upstreamModel');
+  }
+
+  let logStream = null;
+  if (cfg.logFile) {
+    logStream = fs.createWriteStream(cfg.logFile, { flags: 'a' });
+  }
+  function log(line) {
+    const s = '[' + new Date().toISOString() + '] ' + line;
+    console.log(s);
+    if (logStream) logStream.write(s + '\n');
+  }
+
+  const app = fastify({ logger: false });
+  const isAzure = cfg.upstreamBaseUrl.includes('.openai.azure.com');
+  const openai = new OpenAI({ baseURL: cfg.upstreamBaseUrl, apiKey: cfg.upstreamApiKey });
+
+  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('/v1/models', async () => modelsPayload);
+
+  app.post('/v1/messages', async (request, reply) => {
+    const isAuthed = (() => {
+      const h = request.headers;
+      let candidate = null;
+      if (typeof h.authorization === 'string' && h.authorization.startsWith('Bearer ')) {
+        candidate = h.authorization.slice('Bearer '.length);
+      } else if (typeof h['x-api-key'] === 'string') {
+        candidate = h['x-api-key'];
+      }
+      return candidate !== null && cfg.proxyTokens.some((t) => matchesToken(candidate, t));
+    })();
+    if (!isAuthed) {
+      const h = request.headers;
+      log('AUTH-FAIL (auth header present: ' + (!!h.authorization) + ', x-api-key present: ' + (!!h['x-api-key']) + ')');
+      const err = createErrorResponse(new Error('Invalid proxy authentication token'), 401);
+      reply.code(401).send({ error: err.error });
+      return;
+    }
+    const validation = validateAnthropicRequest(request.body);
+    if (!validation.valid) {
+      const err = createErrorResponse(new Error(formatValidationErrors(validation.errors)), 400);
+      reply.code(400).send({ error: err.error });
+      return;
+    }
+    const anthropicRequest = request.body;
+    const clientModel = anthropicRequest.model || 'sonnet';
+    const isStreaming = anthropicRequest.stream ?? false;
+    log('-> ' + clientModel + ' (upstream ' + cfg.upstreamModel + ') stream=' + isStreaming);
+
+    try {
+      const openaiRequest = convertRequestToOpenAI(anthropicRequest, cfg.upstreamModel, cfg.toolFormat, isAzure);
+      if (isStreaming) {
+        const stream = await openai.chat.completions.create({ ...openaiRequest, stream: true });
+        reply.hijack();
+        await streamOpenAIToAnthropic(stream, reply, clientModel, cfg.upstreamBaseUrl);
+      } else {
+        const response = await openai.chat.completions.create({ ...openaiRequest, stream: false });
+        reply.send(convertResponseToAnthropic(response, clientModel));
+      }
+      log('<- ' + clientModel + ' ok');
+    } catch (caught) {
+      const error = caught instanceof Error ? caught : new Error(String(caught));
+      const rawStatus = caught && typeof caught === 'object' && 'status' in caught ? caught.status : undefined;
+      const statusCode = typeof rawStatus === 'number' && rawStatus >= 400 && rawStatus <= 599 ? rawStatus : 500;
+      log('<- upstream error ' + statusCode + ' ' + String(error.message).slice(0, 400));
+      const err = createErrorResponse(error, statusCode);
+      reply.code(err.status).send({ error: err.error });
+    }
+  });
+
+  return {
+    start: async () => {
+      await app.listen({ port: cfg.port, host: '127.0.0.1' });
+      log('anthropic-gateway listening on http://127.0.0.1:' + cfg.port + ' (upstream ' + cfg.upstreamModel + ')');
+      return cfg.port;
+    },
+    stop: async () => {
+      try { await app.close(); } catch {}
+      if (logStream) logStream.end();
+    },
+  };
+}
+
+module.exports = { makeServer, DEFAULTS };

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "anthropic-gateway",
+  "version": "1.0.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": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "openai",
+    "gateway",
+    "proxy",
+    "kilo",
+    "llm",
+    "api"
+  ],
+  "bin": {
+    "anthropic-gateway": "cli.js",
+    "ag": "cli.js"
+  },
+  "files": [
+    "cli.js",
+    "lib/",
+    "vendor/",
+    "config.example.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node cli.js start"
+  },
+  "dependencies": {
+    "fastify": "^4.28.1",
+    "openai": "^4.76.0"
+  }
+}

package/vendor/LICENSE.claude-adapter

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Shanto Islam (shantoislamdev@gmail.com)
+
+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.