@askalf/dario 3.5.0 → 3.6.0

package/README.md

@@ -31,7 +31,9 @@ Install it once, log in once (using your existing Claude Code credentials if you
 
 **Single-account mode is the default.** You don't need an account anywhere, you don't need to wait for anything, and nothing phones home. Install and run.
 
-**Pool mode** (new in v3.5.0) lifts multi-account routing into dario itself. Add two or more Claude subscriptions with `dario accounts add`, and dario starts selecting per request by the account with the most headroom, marking exhausted accounts rejected until they reset. No hosted platform required — you run the pool on your machine, against your own subscriptions. See [Multi-Account Pool Mode](#multi-account-pool-mode) below for the details.
+**Pool mode** (new in v3.5.0) lifts multi-account routing into dario itself. Add two or more Claude subscriptions with `dario accounts add`, and dario starts selecting per request by the account with the most headroom, marking exhausted accounts rejected until they reset. No hosted platform required — you run the pool on your machine, against your own subscriptions. See [Multi-Account Pool Mode](#multi-account-pool-mode) below.
+
+**Multi-provider routing** (new in v3.6.0) lets dario speak to more than just Claude. Configure an OpenAI-compat backend (OpenAI, OpenRouter, Groq, local LiteLLM, Ollama's openai-compat mode) with `dario backend add openai --key=... [--base-url=...]`, and GPT-family model names at `/v1/chat/completions` route to that backend while Claude model names keep flowing through the Claude subscription path. Point your tool at `http://localhost:3456` once and use any model from any provider. See [Multi-Provider Routing](#multi-provider-routing) below.
 
 Separately, [askalf](https://askalf.org) is the hosted platform that does the things a local proxy on your machine can't — browser and desktop control, scheduling, persistent memory, 24/7 hosted fleets. Different problem, different tool. Dario does not depend on askalf, and askalf is not required to use any dario feature.
 
@@ -79,6 +81,8 @@ No separate API key. No Extra Usage charges. No rebuilding your workflow around
 
 **Use dario pool mode if** you're running multi-agent workloads and hitting per-subscription rate limits — add 2–N accounts with `dario accounts add` and dario handles headroom-aware routing across them, all on your machine, against your own subscriptions. No hosted stack to sign up for. See [Multi-Account Pool Mode](#multi-account-pool-mode).
 
+**Use dario multi-provider routing if** you want one local endpoint that speaks to Claude subscriptions *and* OpenAI / OpenRouter / Groq / a local LiteLLM / anything else OpenAI-compat. `dario backend add openai --key=...`, point your tool at `http://localhost:3456`, and every model from every provider flows through the same URL. See [Multi-Provider Routing](#multi-provider-routing).
+
 **Use the Anthropic API directly if** you need platform-native primitives, vendor-managed production usage, high-scale control, or SLAs your subscription tier doesn't cover. Dario isn't trying to replace the API — it's trying to unlock the subscription you already bought.
 
 **Don't use dario if** you want a subprocess bridge that shells out to `claude --print` under the hood. Those tools (openclaw-claude-bridge and similar) work well for single-team single-machine workloads that can accept a one-subscription rate ceiling and a one-machine deployment. Dario is the API-path alternative, which trades that simplicity for pooling-friendly behavior on the wire. Different tradeoffs, different tool.
@@ -203,6 +207,51 @@ Pool mode v3.5.0 ships **headroom-aware selection across requests**. It does not
 
 ---
 
+## Multi-Provider Routing
+
+*New in v3.6.0.* Dario is no longer Claude-only. Configure an OpenAI-compat backend once, and GPT-family model names at `/v1/chat/completions` route to that backend while Claude model names keep flowing through the Claude subscription path. Works with **any** OpenAI-compat provider — OpenAI, OpenRouter, Groq, a local LiteLLM instance, Ollama's openai-compat mode, whatever — via a configurable `--base-url`.
+
+```bash
+# OpenAI itself (default base URL)
+dario backend add openai --key=sk-proj-...
+
+# Groq
+dario backend add groq --key=gsk_... --base-url=https://api.groq.com/openai/v1
+
+# OpenRouter
+dario backend add openrouter --key=sk-or-... --base-url=https://openrouter.ai/api/v1
+
+# Local LiteLLM / Ollama / any openai-compat server
+dario backend add local --key=anything --base-url=http://127.0.0.1:4000/v1
+
+# Inspect
+dario backend list
+```
+
+### How it routes
+
+After the proxy starts, every request at `/v1/chat/completions` is checked:
+
+| Request model | Route |
+|---|---|
+| `gpt-*`, `o1-*`, `o3-*`, `o4-*`, `chatgpt-*`, `text-davinci-*`, `text-embedding-*` | OpenAI-compat backend (if configured) |
+| `claude-*` (or the shortcut `opus`/`sonnet`/`haiku`) | Claude subscription path |
+| Anything else on `/v1/chat/completions` | Claude subscription path with existing OpenAI-compat translation |
+
+Point any tool that speaks the OpenAI Chat Completions API at `http://localhost:3456/v1` once, and both GPT and Claude models work through the same base URL. Cursor, Continue, Aider, any OpenAI SDK — they don't need to know anything changed.
+
+### Why this matters
+
+Dario's earlier layers (template replay, framework scrubbing, pool routing) keep the Claude subscription path defensible against Anthropic's classifier. Multi-provider routing changes the *game board*: when dario also speaks OpenAI and OpenAI-compat, a squeeze on the Claude side stops being an existential issue — traffic for affected workloads shifts to another backend, and dario is still useful. The moment Anthropic ships their own "bring your subscription to the API" feature, dario's Claude backend simplifies and keeps working. Either way, dario is still the local router between every model and every tool on your machine.
+
+### Not yet in this release
+
+- **Cross-format translation** (Anthropic → OpenAI). Requests at `/v1/messages` with GPT-family model names fall through to the existing Claude-side handling (which maps them to Claude equivalents). Full Anthropic → OpenAI request translation, including tool_use format conversion, lands in a follow-up.
+- **Per-model routing rules.** v3.6.0 supports one active openai-compat backend. Per-model selection (`llama-*` → Groq, `mixtral-*` → OpenRouter) ships next.
+- **Fallback rules.** "If Claude 429s, use Gemini" is a follow-up goal. v3.6.0 ships the routing plumbing; fallback logic layers on top.
+
+---
+
 ## Dario and askalf
 
 Dario is fully useful on its own — single-account mode is the default, pool mode (above) scales to as many Claude subscriptions as you want to add, and neither mode requires an account anywhere. Everything dario does is open-source and self-hosted.
@@ -238,6 +287,9 @@ Pool mode in dario covers the "I want multi-account routing on my own machine wi
 | `dario accounts list` | List accounts in the multi-account pool |
 | `dario accounts add <alias>` | Add a new account to the pool (runs OAuth flow) |
 | `dario accounts remove <alias>` | Remove an account from the pool |
+| `dario backend list` | List configured OpenAI-compat backends |
+| `dario backend add <name> --key=<k> [--base-url=<u>]` | Add an OpenAI-compat backend |
+| `dario backend remove <name>` | Remove an OpenAI-compat backend |
 | `dario help` | Full command reference |
 
 ### Proxy options

package/dist/cli.js

@@ -38,6 +38,7 @@ import { homedir } from 'node:os';
 import { startAutoOAuthFlow, getStatus, refreshTokens, loadCredentials } from './oauth.js';
 import { startProxy, sanitizeError } from './proxy.js';
 import { listAccountAliases, loadAllAccounts, addAccountViaOAuth, removeAccount } from './accounts.js';
+import { listBackends, saveBackend, removeBackend } from './openai-backend.js';
 const args = process.argv.slice(2);
 const command = args[0] ?? 'proxy';
 async function login() {
@@ -251,6 +252,96 @@ async function accounts() {
     console.error('Usage: dario accounts [list|add <alias>|remove <alias>]');
     process.exit(1);
 }
+async function backend() {
+    const sub = args[1];
+    if (!sub || sub === 'list') {
+        const all = await listBackends();
+        console.log('');
+        console.log('  dario — Backends');
+        console.log('  ────────────────');
+        console.log('');
+        if (all.length === 0) {
+            console.log('  No secondary backends configured.');
+            console.log('');
+            console.log('  Dario\'s Claude subscription path runs unchanged. To add an');
+            console.log('  OpenAI-compat backend (OpenAI, OpenRouter, Groq, local LiteLLM,');
+            console.log('  etc.), run:');
+            console.log('    dario backend add openai --key=sk-...');
+            console.log('    dario backend add openai --key=sk-... --base-url=https://api.groq.com/openai/v1');
+            console.log('');
+            return;
+        }
+        console.log(`  ${all.length} backend${all.length === 1 ? '' : 's'} configured`);
+        console.log('');
+        for (const b of all) {
+            const redacted = b.apiKey.length > 8
+                ? `${b.apiKey.slice(0, 3)}...${b.apiKey.slice(-4)}`
+                : '***';
+            console.log(`    ${b.name.padEnd(16)} ${b.provider.padEnd(10)} ${b.baseUrl.padEnd(40)} ${redacted}`);
+        }
+        console.log('');
+        return;
+    }
+    if (sub === 'add') {
+        const name = args[2];
+        if (!name || name.startsWith('--')) {
+            console.error('');
+            console.error('  Usage: dario backend add <name> --key=<api-key> [--base-url=<url>]');
+            console.error('');
+            console.error('  Examples:');
+            console.error('    dario backend add openai --key=sk-proj-...');
+            console.error('    dario backend add groq   --key=gsk_... --base-url=https://api.groq.com/openai/v1');
+            console.error('    dario backend add openrouter --key=sk-or-... --base-url=https://openrouter.ai/api/v1');
+            console.error('');
+            process.exit(1);
+        }
+        if (!/^[a-zA-Z0-9._-]+$/.test(name)) {
+            console.error('[dario] Invalid backend name. Use letters, numbers, dot, underscore, dash only.');
+            process.exit(1);
+        }
+        const keyArg = args.find(a => a.startsWith('--key='));
+        const baseUrlArg = args.find(a => a.startsWith('--base-url='));
+        const apiKey = keyArg ? keyArg.split('=').slice(1).join('=') : '';
+        const baseUrl = baseUrlArg ? baseUrlArg.split('=').slice(1).join('=') : 'https://api.openai.com/v1';
+        if (!apiKey) {
+            console.error('[dario] --key=<api-key> is required.');
+            process.exit(1);
+        }
+        const creds = {
+            provider: 'openai', // v3.6.0: only openai-compat backends are supported
+            name,
+            apiKey,
+            baseUrl,
+        };
+        await saveBackend(creds);
+        console.log('');
+        console.log(`  Backend "${name}" added (openai-compat, ${baseUrl}).`);
+        console.log('  Restart \`dario proxy\` to pick up the new routing.');
+        console.log('');
+        return;
+    }
+    if (sub === 'remove' || sub === 'rm') {
+        const name = args[2];
+        if (!name) {
+            console.error('');
+            console.error('  Usage: dario backend remove <name>');
+            console.error('');
+            process.exit(1);
+        }
+        const ok = await removeBackend(name);
+        if (ok) {
+            console.log(`[dario] Backend "${name}" removed.`);
+        }
+        else {
+            console.error(`[dario] No backend "${name}" found.`);
+            process.exit(1);
+        }
+        return;
+    }
+    console.error(`[dario] Unknown backend subcommand: ${sub}`);
+    console.error('Usage: dario backend [list|add <name> --key=...|remove <name>]');
+    process.exit(1);
+}
 async function help() {
     console.log(`
   dario — Use your Claude subscription as an API.
@@ -264,6 +355,10 @@ async function help() {
     dario accounts list      List accounts in the multi-account pool
     dario accounts add NAME  Add a new account to the pool (runs OAuth flow)
     dario accounts remove N  Remove an account from the pool
+    dario backend list       List configured OpenAI-compat backends
+    dario backend add NAME --key=sk-... [--base-url=...]
+                             Add an OpenAI-compat backend (OpenAI, OpenRouter, Groq, etc.)
+    dario backend remove N   Remove an OpenAI-compat backend
 
   Proxy options:
     --model=MODEL            Force a model for all requests
@@ -319,6 +414,7 @@ const commands = {
     refresh,
     logout,
     accounts,
+    backend,
     help,
     version,
     '--help': help,

package/dist/index.d.ts

@@ -13,3 +13,5 @@ export { listAccountAliases, loadAccount, loadAllAccounts, saveAccount, removeAc
 export type { AccountCredentials } from './accounts.js';
 export { Analytics } from './analytics.js';
 export type { RequestRecord, AnalyticsSummary } from './analytics.js';
+export { listBackends, saveBackend, removeBackend, getOpenAIBackend, isOpenAIModel, } from './openai-backend.js';
+export type { BackendCredentials } from './openai-backend.js';

package/dist/index.js

@@ -12,3 +12,8 @@ export { startProxy, sanitizeError } from './proxy.js';
 export { AccountPool, parseRateLimits } from './pool.js';
 export { listAccountAliases, loadAccount, loadAllAccounts, saveAccount, removeAccount, refreshAccountToken, addAccountViaOAuth, getAccountsDir, } from './accounts.js';
 export { Analytics } from './analytics.js';
+// Multi-provider backends (v3.6.0+). Secondary OpenAI-compat providers
+// (OpenAI, OpenRouter, Groq, local LiteLLM, etc.) configured via
+// `dario backend add`. The Claude subscription path is unchanged — these
+// are additional routes for non-Claude models.
+export { listBackends, saveBackend, removeBackend, getOpenAIBackend, isOpenAIModel, } from './openai-backend.js';

package/dist/openai-backend.d.ts

@@ -0,0 +1,19 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export interface BackendCredentials {
+    provider: string;
+    name: string;
+    apiKey: string;
+    baseUrl: string;
+}
+export declare function listBackends(): Promise<BackendCredentials[]>;
+export declare function saveBackend(creds: BackendCredentials): Promise<void>;
+export declare function removeBackend(name: string): Promise<boolean>;
+/** Get the first openai-compat backend (v3.6.0 supports exactly one). */
+export declare function getOpenAIBackend(): Promise<BackendCredentials | null>;
+export declare function isOpenAIModel(model: string): boolean;
+/**
+ * Forward a client request to the configured OpenAI-compat backend.
+ * Pass-through: the client is already speaking OpenAI format, we just swap
+ * the API key and the target URL. No template, no identity, no scrubbing.
+ */
+export declare function forwardToOpenAI(req: IncomingMessage, res: ServerResponse, body: Buffer, backend: BackendCredentials, corsOrigin: string, securityHeaders: Record<string, string>, upstreamTimeoutMs: number, verbose: boolean): Promise<void>;

package/dist/openai-backend.js

@@ -0,0 +1,170 @@
+/**
+ * OpenAI-compatible backend.
+ *
+ * When `dario backend add openai --key=sk-...` has been run, requests to
+ * `/v1/chat/completions` with a GPT-style model name are forwarded to the
+ * configured OpenAI-compat endpoint instead of being routed through the
+ * Claude template path. The Claude backend is unchanged.
+ *
+ * The `--base-url` flag is accepted so the same command works for any
+ * OpenAI-compatible provider (OpenAI, OpenRouter, Groq, LiteLLM, a local
+ * Ollama exposing OpenAI compat, etc.). Only one openai-compat backend can
+ * be active at a time in v3.6.0; multi-backend-per-provider routing lands
+ * in a follow-up release.
+ */
+import { readFile, writeFile, mkdir, unlink, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const DARIO_DIR = join(homedir(), '.dario');
+const BACKENDS_DIR = join(DARIO_DIR, 'backends');
+async function ensureDir() {
+    await mkdir(BACKENDS_DIR, { recursive: true, mode: 0o700 });
+}
+export async function listBackends() {
+    try {
+        await ensureDir();
+        const files = await readdir(BACKENDS_DIR);
+        const jsonFiles = files.filter(f => f.endsWith('.json'));
+        const results = [];
+        for (const f of jsonFiles) {
+            try {
+                const raw = await readFile(join(BACKENDS_DIR, f), 'utf-8');
+                results.push(JSON.parse(raw));
+            }
+            catch { /* skip unreadable */ }
+        }
+        return results;
+    }
+    catch {
+        return [];
+    }
+}
+export async function saveBackend(creds) {
+    await ensureDir();
+    const path = join(BACKENDS_DIR, `${creds.name}.json`);
+    await writeFile(path, JSON.stringify(creds, null, 2), { mode: 0o600 });
+}
+export async function removeBackend(name) {
+    const path = join(BACKENDS_DIR, `${name}.json`);
+    try {
+        await unlink(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Get the first openai-compat backend (v3.6.0 supports exactly one). */
+export async function getOpenAIBackend() {
+    const all = await listBackends();
+    return all.find(b => b.provider === 'openai') ?? null;
+}
+// Model names that should route to the OpenAI backend when one is configured.
+// Deliberately narrow — OpenAI and reasoning-series only. Custom GPT-shaped
+// names from other providers (llama-*, mixtral-*) don't match by default;
+// users pass them through as-is on the OpenAI-compat endpoint and they'll
+// reach the configured baseUrl, which is correct for OpenRouter/Groq/etc.
+const OPENAI_MODEL_PATTERNS = [
+    /^gpt-/i,
+    /^o1-/i,
+    /^o3-/i,
+    /^o4-/i,
+    /^chatgpt-/i,
+    /^text-davinci/i,
+    /^text-embedding-/i,
+];
+export function isOpenAIModel(model) {
+    return OPENAI_MODEL_PATTERNS.some(p => p.test(model));
+}
+/**
+ * Forward a client request to the configured OpenAI-compat backend.
+ * Pass-through: the client is already speaking OpenAI format, we just swap
+ * the API key and the target URL. No template, no identity, no scrubbing.
+ */
+export async function forwardToOpenAI(req, res, body, backend, corsOrigin, securityHeaders, upstreamTimeoutMs, verbose) {
+    const target = `${backend.baseUrl.replace(/\/$/, '')}/chat/completions`;
+    const clientBeta = req.headers['anthropic-beta'];
+    // Headers: drop anything Anthropic-specific, keep only the essentials
+    // OpenAI-compat endpoints care about. Streaming is driven by the body, not
+    // a header, so we don't need to parse it here.
+    const headers = {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${backend.apiKey}`,
+        'Accept': req.headers.accept?.toString() ?? 'application/json',
+    };
+    // Some openai-compat providers (OpenRouter) want their own custom headers
+    // for attribution. If the client sent an x-title or http-referer, forward
+    // those through so the upstream provider sees them.
+    for (const h of ['x-title', 'http-referer', 'x-openrouter-app']) {
+        const v = req.headers[h];
+        if (typeof v === 'string')
+            headers[h] = v;
+    }
+    // Drop Anthropic-specific headers entirely
+    void clientBeta;
+    const abort = new AbortController();
+    const timeout = setTimeout(() => abort.abort(), upstreamTimeoutMs);
+    try {
+        if (verbose) {
+            console.log(`[dario] → openai backend: ${target}`);
+        }
+        const upstream = await fetch(target, {
+            method: 'POST',
+            headers,
+            body: body.length > 0 ? new Uint8Array(body) : undefined,
+            signal: abort.signal,
+        });
+        const respHeaders = {
+            'Content-Type': upstream.headers.get('content-type') ?? 'application/json',
+            'Access-Control-Allow-Origin': corsOrigin,
+            ...securityHeaders,
+        };
+        // Forward rate-limit + request-id headers from the upstream
+        for (const [key, value] of upstream.headers.entries()) {
+            if (key.startsWith('x-ratelimit') ||
+                key.startsWith('openai-') ||
+                key === 'request-id' ||
+                key === 'x-request-id') {
+                respHeaders[key] = value;
+            }
+        }
+        res.writeHead(upstream.status, respHeaders);
+        if (upstream.body) {
+            const reader = upstream.body.getReader();
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    if (value)
+                        res.write(Buffer.from(value));
+                }
+            }
+            finally {
+                reader.releaseLock();
+            }
+        }
+        res.end();
+    }
+    catch (err) {
+        clearTimeout(timeout);
+        if (!res.headersSent) {
+            res.writeHead(502, { 'Content-Type': 'application/json', ...securityHeaders });
+            res.end(JSON.stringify({
+                error: 'Upstream OpenAI-compat backend error',
+                message: err instanceof Error ? err.message : String(err),
+                backend: backend.name,
+            }));
+        }
+        else {
+            try {
+                res.end();
+            }
+            catch { /* already closed */ }
+        }
+        return;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}

package/dist/proxy.js

@@ -10,6 +10,7 @@ import { buildCCRequest, reverseMapResponse } from './cc-template.js';
 import { AccountPool, parseRateLimits } from './pool.js';
 import { Analytics } from './analytics.js';
 import { loadAllAccounts, loadAccount, refreshAccountToken } from './accounts.js';
+import { getOpenAIBackend, isOpenAIModel, forwardToOpenAI } from './openai-backend.js';
 const ANTHROPIC_API = 'https://api.anthropic.com';
 const DEFAULT_PORT = 3456;
 const MAX_BODY_BYTES = 10 * 1024 * 1024; // 10 MB — generous for large prompts, prevents abuse
@@ -324,6 +325,16 @@ export async function startProxy(opts = {}) {
     const host = opts.host ?? process.env.DARIO_HOST ?? DEFAULT_HOST;
     const verbose = opts.verbose ?? false;
     const passthrough = opts.passthrough ?? false;
+    // Multi-provider backends (v3.6.0+). Loaded once at startup; the CLI
+    // `dario backend add openai --key=…` writes to ~/.dario/backends/.
+    // Routing: a GPT-family model arriving on /v1/chat/completions is
+    // dispatched to the openai-compat backend when one is configured,
+    // otherwise it falls through to the existing Claude-side handling
+    // (which used to map gpt-* names to Claude equivalents).
+    let openaiBackend = await getOpenAIBackend();
+    if (openaiBackend) {
+        console.log(`  OpenAI-compat backend: ${openaiBackend.name} → ${openaiBackend.baseUrl}`);
+    }
     // Multi-account pool — activated when ~/.dario/accounts/ has 2+ entries.
     // Single-account dario keeps its existing code path unchanged.
     const accountsList = await loadAllAccounts();
@@ -590,6 +601,27 @@ export async function startProxy(opts = {}) {
                 clearTimeout(bodyTimeout);
             }
             const body = Buffer.concat(chunks);
+            // Multi-provider routing (v3.6.0+). When an OpenAI-compat backend is
+            // configured and the request is on /v1/chat/completions with a
+            // GPT-family model, forward it straight through to the backend
+            // instead of running it through the Claude template path. Requests
+            // on /v1/messages or with Claude-family models fall through to
+            // existing behavior.
+            if (openaiBackend && isOpenAI && body.length > 0) {
+                try {
+                    const peek = JSON.parse(body.toString());
+                    const rawModel = (peek.model || '').toString();
+                    if (rawModel && isOpenAIModel(rawModel)) {
+                        if (verbose) {
+                            console.log(`[dario] #${requestCount} ${req.method} ${urlPath} (model: ${rawModel}) → openai backend`);
+                        }
+                        requestCount++;
+                        await forwardToOpenAI(req, res, body, openaiBackend, corsOrigin, SECURITY_HEADERS, UPSTREAM_TIMEOUT_MS, verbose);
+                        return;
+                    }
+                }
+                catch { /* not JSON — fall through to existing path */ }
+            }
             // Parse body once, apply OpenAI translation, model override, and sanitization
             let finalBody = body.length > 0 ? body : undefined;
             let ccToolMap = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "description": "Use your Claude subscription as an API. No API key needed. Local proxy for Claude Max/Pro subscriptions.",
   "type": "module",
   "bin": {