anymodel 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 antonoly
+
+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,142 @@
+# anymodel
+
+**Run Claude Code with any AI model — OpenRouter, Ollama, or any LLM provider.**
+
+[![npm version](https://img.shields.io/npm/v/anymodel)](https://www.npmjs.com/package/anymodel)
+[![license](https://img.shields.io/npm/l/anymodel)](https://github.com/antonoly/anymodel/blob/main/LICENSE)
+[![node](https://img.shields.io/node/v/anymodel)](https://nodejs.org)
+
+Use Claude Code's powerful agentic coding with **any model** — GPT-4o, Gemini, Llama, Mistral, DeepSeek, and hundreds more. anymodel is a lightweight proxy that sits between Claude Code and your preferred AI provider, translating requests on the fly.
+
+**Zero dependencies.** Just Node.js.
+
+## Quick Start
+
+```bash
+npx anymodel
+```
+
+That's it. anymodel auto-detects your available provider and starts a local proxy.
+
+## Usage
+
+```bash
+# Auto-detect provider (checks OPENROUTER_API_KEY, then local Ollama)
+npx anymodel
+
+# Explicitly use OpenRouter
+npx anymodel openrouter
+
+# Use local Ollama
+npx anymodel ollama
+
+# Specify a model
+npx anymodel --model google/gemini-2.5-flash
+
+# Custom port
+npx anymodel --port 8080
+
+# Combine options
+npx anymodel openrouter --model deepseek/deepseek-r1 --port 3000
+```
+
+Then in another terminal:
+
+```bash
+ANTHROPIC_BASE_URL=http://localhost:9090 claude
+```
+
+## How It Works
+
+```
+┌─────────────┐     ┌──────────────┐     ┌──────────────────┐
+│  Claude Code │────>│   anymodel   │────>│  OpenRouter /     │
+│              │<────│  :9090       │<────│  Ollama / etc.    │
+└─────────────┘     └──────────────┘     └──────────────────┘
+                           │
+                           │ (non-/v1/messages)
+                           v
+                    ┌──────────────┐
+                    │  Anthropic   │
+                    │  API         │
+                    └──────────────┘
+```
+
+anymodel intercepts `/v1/messages` requests from Claude Code and routes them to your chosen provider. All other requests (auth, config) pass through to Anthropic's API unchanged.
+
+The proxy automatically:
+- Strips Anthropic-specific fields (`cache_control`, `betas`, `metadata`, `thinking`, etc.)
+- Normalizes `tool_choice` format for cross-provider compatibility
+- Retries failed requests with exponential backoff (3 attempts, max 8s delay)
+- Streams responses back in real-time
+
+## Supported Providers
+
+| Provider | Command | Requirements |
+|----------|---------|-------------|
+| [OpenRouter](https://openrouter.ai) | `anymodel openrouter` | `OPENROUTER_API_KEY` |
+| [Ollama](https://ollama.ai) | `anymodel ollama` | Ollama running locally |
+
+### OpenRouter
+
+Access 200+ models through a single API. [Get your API key](https://openrouter.ai/keys).
+
+```bash
+export OPENROUTER_API_KEY=sk-or-v1-...
+npx anymodel openrouter --model google/gemini-2.5-flash
+```
+
+Popular models: `google/gemini-2.5-flash`, `deepseek/deepseek-r1`, `meta-llama/llama-4-maverick`, `openai/gpt-4o`
+
+### Ollama
+
+Run models locally with zero cloud dependency.
+
+```bash
+ollama serve
+npx anymodel ollama --model llama3
+```
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `OPENROUTER_API_KEY` | OpenRouter API key | — |
+| `OPENROUTER_MODEL` | Default model override | passthrough |
+| `PROXY_PORT` | Proxy listen port | `9090` |
+
+### .env File
+
+anymodel auto-loads a `.env` file from the current directory:
+
+```env
+OPENROUTER_API_KEY=sk-or-v1-...
+OPENROUTER_MODEL=google/gemini-2.5-flash
+```
+
+## CLI Reference
+
+```
+anymodel [provider] [options]
+
+Providers:
+  openrouter    Route through OpenRouter
+  ollama        Route through local Ollama
+
+Options:
+  --model, -m   Model to use (e.g., google/gemini-2.5-flash)
+  --port, -p    Proxy port (default: 9090)
+  --help, -h    Show help
+```
+
+## Links
+
+- [anymodel.dev](https://anymodel.dev) — Project homepage
+- [OpenRouter](https://openrouter.ai) — Multi-model API gateway
+- [GitHub](https://github.com/antonoly/anymodel) — Source code
+
+## License
+
+MIT

package/cli.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+// anymodel CLI — Run Claude Code with any AI model
+// Usage:
+//   npx anymodel                          # auto-detect provider
+//   npx anymodel openrouter               # use OpenRouter
+//   npx anymodel ollama                   # use local Ollama
+//   npx anymodel --model google/gemini-2.5-flash --port 8080
+
+import { createProxy, loadEnv } from './proxy.mjs';
+
+const PROVIDERS = ['openrouter', 'ollama'];
+
+export function parseArgs(argv) {
+  const opts = { provider: 'auto', port: 9090, model: null, help: false };
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === '--help' || arg === '-h') {
+      opts.help = true;
+    } else if (arg === '--model' || arg === '-m') {
+      opts.model = argv[++i] || null;
+    } else if (arg === '--port' || arg === '-p') {
+      opts.port = parseInt(argv[++i], 10) || 9090;
+    } else if (!arg.startsWith('-') && PROVIDERS.includes(arg)) {
+      opts.provider = arg;
+    }
+  }
+
+  return opts;
+}
+
+export async function detectProvider() {
+  if (process.env.OPENROUTER_API_KEY) return 'openrouter';
+
+  const { default: ollama } = await import('./providers/ollama.mjs');
+  if (await ollama.detect()) return 'ollama';
+
+  return null;
+}
+
+function printHelp() {
+  console.log(`
+\x1b[35m  anymodel\x1b[0m — Run Claude Code with any AI model
+
+  \x1b[1mUsage:\x1b[0m
+    anymodel [provider] [options]
+
+  \x1b[1mProviders:\x1b[0m
+    openrouter    Route through OpenRouter (needs OPENROUTER_API_KEY)
+    ollama        Route through local Ollama instance
+
+  \x1b[1mOptions:\x1b[0m
+    --model, -m   Model to use (e.g., google/gemini-2.5-flash)
+    --port, -p    Proxy port (default: 9090)
+    --help, -h    Show this help
+
+  \x1b[1mExamples:\x1b[0m
+    anymodel                                    # auto-detect provider
+    anymodel openrouter                         # use OpenRouter
+    anymodel ollama --model llama3              # use Ollama with llama3
+    anymodel --model google/gemini-2.5-flash    # specific model via OpenRouter
+
+  \x1b[1mEnvironment:\x1b[0m
+    OPENROUTER_API_KEY   Your OpenRouter API key (https://openrouter.ai/keys)
+    OPENROUTER_MODEL     Default model override
+    PROXY_PORT           Default port override
+
+  https://anymodel.dev
+`);
+}
+
+async function main() {
+  loadEnv();
+
+  const opts = parseArgs(process.argv.slice(2));
+
+  if (opts.help) {
+    printHelp();
+    process.exit(0);
+  }
+
+  // Resolve provider
+  let providerName = opts.provider;
+  if (providerName === 'auto') {
+    providerName = await detectProvider();
+    if (!providerName) {
+      console.error('\x1b[31mError: Could not auto-detect a provider.\x1b[0m');
+      console.error('');
+      console.error('  Set OPENROUTER_API_KEY for OpenRouter:');
+      console.error('    export OPENROUTER_API_KEY=sk-or-...');
+      console.error('    Get your key at https://openrouter.ai/keys');
+      console.error('');
+      console.error('  Or start Ollama for local models:');
+      console.error('    ollama serve');
+      console.error('');
+      process.exit(1);
+    }
+    console.log(`\x1b[36m[AUTO]\x1b[0m Detected provider: ${providerName}`);
+  }
+
+  // Validate OpenRouter has API key
+  if (providerName === 'openrouter' && !process.env.OPENROUTER_API_KEY) {
+    console.error('\x1b[31mError: OPENROUTER_API_KEY environment variable is required\x1b[0m');
+    console.error('Get your key at https://openrouter.ai/keys');
+    process.exit(1);
+  }
+
+  // Load provider
+  const { default: provider } = await import(`./providers/${providerName}.mjs`);
+
+  // Model override: CLI flag > env var > none
+  const model = opts.model || process.env.OPENROUTER_MODEL || null;
+  const port = opts.port || parseInt(process.env.PROXY_PORT, 10) || 9090;
+
+  createProxy(provider, { port, model });
+}
+
+// Only run main when executed directly (not imported for testing)
+const isMain = process.argv[1] && (
+  process.argv[1].endsWith('/cli.mjs') ||
+  process.argv[1].endsWith('\\cli.mjs') ||
+  process.argv[1].endsWith('/anymodel')
+);
+if (isMain) main();

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "anymodel",
+  "version": "1.0.0",
+  "description": "Run Claude Code with any AI model — OpenRouter, Ollama, or any LLM provider",
+  "type": "module",
+  "bin": { "anymodel": "./cli.mjs" },
+  "main": "proxy.mjs",
+  "files": ["cli.mjs", "proxy.mjs", "providers/", "README.md", "LICENSE"],
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "start": "node cli.mjs"
+  },
+  "keywords": ["claude", "claude-code", "openrouter", "ollama", "llm", "proxy", "ai", "cli"],
+  "author": "antonoly",
+  "license": "MIT",
+  "repository": { "type": "git", "url": "https://github.com/antonoly/anymodel" },
+  "homepage": "https://anymodel.dev",
+  "engines": { "node": ">=18.0.0" }
+}

package/providers/ollama.mjs

@@ -0,0 +1,37 @@
+// Ollama provider for anymodel
+// Routes requests to local Ollama instance (OpenAI-compatible endpoint)
+
+import http from 'http';
+
+export default {
+  name: 'ollama',
+
+  buildRequest(url, payload) {
+    return {
+      hostname: 'localhost',
+      port: 11434,
+      path: url,
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'content-length': Buffer.byteLength(payload),
+      },
+    };
+  },
+
+  displayInfo(model) {
+    return model ? `(${model} @ localhost:11434)` : '(localhost:11434)';
+  },
+
+  // Check if Ollama is running locally
+  detect() {
+    return new Promise(resolve => {
+      const req = http.get('http://localhost:11434', res => {
+        res.resume();
+        resolve(true);
+      });
+      req.on('error', () => resolve(false));
+      req.setTimeout(1000, () => { req.destroy(); resolve(false); });
+    });
+  },
+};

package/providers/openrouter.mjs

@@ -0,0 +1,27 @@
+// OpenRouter provider for anymodel
+// Routes requests to openrouter.ai/api with Bearer auth
+
+export default {
+  name: 'openrouter',
+
+  buildRequest(url, payload, apiKey) {
+    return {
+      hostname: 'openrouter.ai',
+      port: 443,
+      path: '/api' + url,
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        'authorization': `Bearer ${apiKey}`,
+        'anthropic-version': '2023-06-01',
+        'content-length': Buffer.byteLength(payload),
+        'http-referer': 'https://github.com/antonoly/anymodel',
+        'x-title': 'anymodel',
+      },
+    };
+  },
+
+  displayInfo(model) {
+    return model ? `(${model})` : '(passthrough model)';
+  },
+};

package/proxy.mjs

@@ -0,0 +1,245 @@
+// Core proxy server for anymodel
+// Routes /v1/messages → provider, everything else → api.anthropic.com
+
+import http from 'http';
+import https from 'https';
+import { readFileSync } from 'fs';
+
+const pkg = JSON.parse(readFileSync(new URL('package.json', import.meta.url), 'utf8'));
+
+export const MAX_RETRIES = 3;
+
+// ANSI colors
+const C = {
+  cyan: s => `\x1b[36m${s}\x1b[0m`,
+  green: s => `\x1b[32m${s}\x1b[0m`,
+  red: s => `\x1b[31m${s}\x1b[0m`,
+  yellow: s => `\x1b[33m${s}\x1b[0m`,
+  magenta: s => `\x1b[35m${s}\x1b[0m`,
+  bold: s => `\x1b[1m${s}\x1b[0m`,
+};
+
+// Strip Anthropic-specific fields that break non-Anthropic providers
+export function sanitizeBody(body) {
+  delete body.betas;
+  delete body.metadata;
+  delete body.speed;
+  delete body.output_config;
+  delete body.context_management;
+  delete body.thinking;
+
+  // Strip cache_control from system blocks
+  if (Array.isArray(body.system)) {
+    body.system = body.system.map(block => {
+      if (block && typeof block === 'object' && block.cache_control) {
+        const { cache_control, ...rest } = block;
+        return rest;
+      }
+      return block;
+    });
+  }
+
+  // Strip cache_control from message content blocks
+  if (Array.isArray(body.messages)) {
+    for (const msg of body.messages) {
+      if (Array.isArray(msg.content)) {
+        msg.content = msg.content.map(block => {
+          if (block && typeof block === 'object' && block.cache_control) {
+            const { cache_control, ...rest } = block;
+            return rest;
+          }
+          return block;
+        });
+      }
+    }
+  }
+
+  // Strip Anthropic-only tool fields
+  if (Array.isArray(body.tools)) {
+    body.tools = body.tools.map(tool => {
+      const { cache_control, defer_loading, eager_input_streaming, strict, ...rest } = tool;
+      return rest;
+    });
+  }
+
+  // Normalize tool_choice: providers expect object, Claude Code may send string
+  if (typeof body.tool_choice === 'string') {
+    body.tool_choice = { type: body.tool_choice };
+  }
+
+  return body;
+}
+
+// Calculate exponential backoff delay, capped at 8s
+export function calcDelay(attempt) {
+  return Math.min(1000 * Math.pow(2, attempt - 1), 8000);
+}
+
+// Check if a URL path should be routed to the provider
+export function isProviderRoute(url) {
+  return url.startsWith('/v1/messages');
+}
+
+export function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+// Load .env file if present (from given dir, or cwd)
+export function loadEnv(dir) {
+  try {
+    const envPath = dir ? `${dir}/.env` : `${process.cwd()}/.env`;
+    const envFile = readFileSync(envPath, 'utf8');
+    for (const line of envFile.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) continue;
+      const eq = trimmed.indexOf('=');
+      if (eq > 0) {
+        const key = trimmed.slice(0, eq).trim();
+        let val = trimmed.slice(eq + 1).trim();
+        // Strip surrounding quotes
+        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+          val = val.slice(1, -1);
+        }
+        if (!process.env[key]) process.env[key] = val;
+      }
+    }
+  } catch {}
+}
+
+function sendRequest(provider, url, payload) {
+  const opts = provider.buildRequest(url, payload, process.env.OPENROUTER_API_KEY);
+
+  return new Promise((resolve, reject) => {
+    const transport = opts.port === 443 || opts.protocol === 'https:' ? https : http;
+    const req = transport.request(opts, upstream => resolve(upstream));
+    req.on('error', reject);
+    req.write(payload);
+    req.end();
+  });
+}
+
+async function handleMessages(req, res, provider, model) {
+  const chunks = [];
+  req.on('data', c => chunks.push(c));
+  await new Promise(r => req.on('end', r));
+  const raw = Buffer.concat(chunks);
+
+  let parsed;
+  try {
+    parsed = JSON.parse(raw.toString());
+  } catch {
+    res.writeHead(400, { 'content-type': 'application/json' });
+    res.end(JSON.stringify({ error: { type: 'invalid_request', message: 'Invalid JSON' } }));
+    return;
+  }
+
+  const originalModel = parsed.model;
+  if (model) parsed.model = model;
+
+  sanitizeBody(parsed);
+
+  const payload = JSON.stringify(parsed);
+  const modelDisplay = model ? `${originalModel} \u2192 ${model}` : originalModel;
+  console.log(`${C.cyan(`[${provider.name.toUpperCase()}]`)} ${req.method} ${req.url} model=${modelDisplay} stream=${parsed.stream}`);
+
+  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const upstream = await sendRequest(provider, req.url, payload);
+
+      if (upstream.statusCode === 429 || upstream.statusCode >= 500) {
+        const errChunks = [];
+        upstream.on('data', c => errChunks.push(c));
+        await new Promise(r => upstream.on('end', r));
+        const errBody = Buffer.concat(errChunks).toString();
+
+        const delay = calcDelay(attempt);
+        console.log(`${C.red(`[${provider.name.toUpperCase()}]`)} ${upstream.statusCode} on attempt ${attempt}/${MAX_RETRIES}, retrying in ${delay}ms`);
+        console.log(`${C.red(`[${provider.name.toUpperCase()}]`)} ${errBody.slice(0, 200)}`);
+
+        if (attempt === MAX_RETRIES) {
+          res.writeHead(upstream.statusCode, upstream.headers);
+          res.end(errBody);
+          return;
+        }
+        await sleep(delay);
+        continue;
+      }
+
+      if (upstream.statusCode !== 200) {
+        const errChunks = [];
+        upstream.on('data', c => errChunks.push(c));
+        await new Promise(r => upstream.on('end', r));
+        const errBody = Buffer.concat(errChunks).toString();
+        console.log(`${C.red(`[${provider.name.toUpperCase()}]`)} ${upstream.statusCode}: ${errBody.slice(0, 300)}`);
+        res.writeHead(upstream.statusCode, upstream.headers);
+        res.end(errBody);
+        return;
+      }
+
+      console.log(`${C.green(`[${provider.name.toUpperCase()}]`)} 200 \u2190 streaming response (attempt ${attempt})`);
+      res.writeHead(200, upstream.headers);
+      upstream.pipe(res);
+      return;
+
+    } catch (e) {
+      console.error(`${C.red(`[${provider.name.toUpperCase()}]`)} Connection error on attempt ${attempt}: ${e.message}`);
+      if (attempt === MAX_RETRIES) {
+        res.writeHead(502, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({ error: { type: 'proxy_error', message: e.message } }));
+        return;
+      }
+      await sleep(calcDelay(attempt));
+    }
+  }
+}
+
+function proxyToAnthropic(req, res) {
+  const body = [];
+  req.on('data', c => body.push(c));
+  req.on('end', () => {
+    const opts = {
+      hostname: 'api.anthropic.com',
+      port: 443,
+      path: req.url,
+      method: req.method,
+      headers: { ...req.headers, host: 'api.anthropic.com' },
+    };
+    const pr = https.request(opts, upstream => {
+      res.writeHead(upstream.statusCode, upstream.headers);
+      upstream.pipe(res);
+    });
+    pr.on('error', e => { res.writeHead(502); res.end(e.message); });
+    if (body.length) pr.write(Buffer.concat(body));
+    pr.end();
+  });
+}
+
+export function createProxy(provider, { port = 9090, model } = {}) {
+  const server = http.createServer((req, res) => {
+    if (isProviderRoute(req.url)) {
+      handleMessages(req, res, provider, model);
+    } else {
+      console.log(`${C.yellow('[ANTHROPIC]')} ${req.method} ${req.url}`);
+      proxyToAnthropic(req, res);
+    }
+  });
+
+  server.listen(port, () => {
+    console.log('');
+    console.log(C.magenta(`  anymodel v${pkg.version}`));
+    console.log('');
+    console.log(`  ${C.cyan('\u2194')}  Proxy on :${port}`);
+    console.log(`     /v1/messages \u2192 ${C.bold(provider.name)} ${provider.displayInfo(model)}`);
+    console.log(`     everything else \u2192 api.anthropic.com`);
+    console.log(`     Retries: ${MAX_RETRIES} with exponential backoff`);
+    if (model) {
+      console.log(`     Model override: ${C.cyan(model)}`);
+    }
+    console.log('');
+    console.log(`  ${C.green('Run in another terminal:')}`);
+    console.log(`  ${C.bold(`ANTHROPIC_BASE_URL=http://localhost:${port} claude`)}`);
+    console.log('');
+  });
+
+  return server;
+}