@askalf/dario 1.2.1 → 2.0.0

package/README.md

@@ -16,9 +16,9 @@
 
 <p align="center">
   <a href="#quick-start">Quick Start</a> &bull;
-  <a href="#how-it-works">How It Works</a> &bull;
-  <a href="#usage-examples">Examples</a> &bull;
+  <a href="#openai-compatibility">OpenAI Compat</a> &bull;
   <a href="#cli-backend">CLI Backend</a> &bull;
+  <a href="#usage-examples">Examples</a> &bull;
   <a href="#faq">FAQ</a>
 </p>
 
@@ -157,6 +157,37 @@ Combine with `--cli` for rate-limit-proof Opus:
 dario proxy --cli --model=opus
 ```
 
+## OpenAI Compatibility
+
+Dario speaks both Anthropic and OpenAI API formats. Any tool built for OpenAI works with your Claude subscription — Cursor, Continue, LiteLLM, anything.
+
+```bash
+# Use with any OpenAI SDK or tool
+export OPENAI_BASE_URL=http://localhost:3456/v1
+export OPENAI_API_KEY=dario
+```
+
+```python
+from openai import OpenAI
+
+client = OpenAI(base_url="http://localhost:3456/v1", api_key="dario")
+response = client.chat.completions.create(
+    model="claude-opus-4-6",  # or use "gpt-4" — auto-maps to Opus
+    messages=[{"role": "user", "content": "Hello!"}]
+)
+```
+
+Model mapping (automatic):
+
+| OpenAI model | Maps to |
+|---|---|
+| `gpt-4`, `gpt-4o`, `o1`, `o3` | `claude-opus-4-6` |
+| `o1-mini`, `o3-mini` | `claude-sonnet-4-6` |
+| `gpt-3.5-turbo`, `gpt-4o-mini` | `claude-haiku-4-5` |
+| Any `claude-*` model | Passed through directly |
+
+Streaming, system prompts, temperature, and stop sequences all translate automatically.
+
 ## Usage Examples
 
 ### curl
@@ -290,7 +321,8 @@ ANTHROPIC_BASE_URL=http://localhost:3456 ANTHROPIC_API_KEY=dario your-tool-here
 
 ### Direct API Mode
 - All Claude models (Opus 4.6, Sonnet 4.6, Haiku 4.5)
-- Streaming and non-streaming
+- **OpenAI-compatible** (`/v1/chat/completions`) — works with any OpenAI SDK or tool
+- Streaming and non-streaming (both Anthropic and OpenAI SSE formats)
 - Tool use / function calling
 - System prompts and multi-turn conversations
 - Prompt caching and extended thinking
@@ -307,7 +339,9 @@ ANTHROPIC_BASE_URL=http://localhost:3456 ANTHROPIC_API_KEY=dario your-tool-here
 
 | Path | Description |
 |------|-------------|
-| `POST /v1/messages` | Anthropic Messages API (main endpoint) |
+| `POST /v1/messages` | Anthropic Messages API |
+| `POST /v1/chat/completions` | OpenAI-compatible Chat API |
+| `GET /v1/models` | Model list (works with both SDKs) |
 | `GET /health` | Proxy health + OAuth status + request count |
 | `GET /status` | Detailed OAuth token status |
 

package/dist/proxy.js

@@ -55,6 +55,128 @@ const MODEL_ALIASES = {
     'sonnet': 'claude-sonnet-4-6',
     'haiku': 'claude-haiku-4-5',
 };
+// OpenAI model name → Anthropic model name
+const OPENAI_MODEL_MAP = {
+    'gpt-4': 'claude-opus-4-6',
+    'gpt-4o': 'claude-opus-4-6',
+    'gpt-4-turbo': 'claude-opus-4-6',
+    'gpt-4o-mini': 'claude-haiku-4-5',
+    'gpt-3.5-turbo': 'claude-haiku-4-5',
+    'o1': 'claude-opus-4-6',
+    'o1-mini': 'claude-sonnet-4-6',
+    'o1-preview': 'claude-opus-4-6',
+    'o3': 'claude-opus-4-6',
+    'o3-mini': 'claude-sonnet-4-6',
+};
+/**
+ * Translate OpenAI chat completion request → Anthropic Messages request.
+ */
+function openaiToAnthropic(body, modelOverride) {
+    const messages = body.messages;
+    if (!messages)
+        return body;
+    // Extract system messages
+    const systemMessages = messages.filter(m => m.role === 'system');
+    const nonSystemMessages = messages.filter(m => m.role !== 'system');
+    // Map model name
+    const requestModel = String(body.model || '');
+    const model = modelOverride || OPENAI_MODEL_MAP[requestModel] || requestModel;
+    const result = {
+        model,
+        messages: nonSystemMessages.map(m => ({
+            role: m.role === 'assistant' ? 'assistant' : 'user',
+            content: m.content,
+        })),
+        max_tokens: body.max_tokens ?? body.max_completion_tokens ?? 8192,
+    };
+    if (systemMessages.length > 0) {
+        result.system = systemMessages.map(m => typeof m.content === 'string' ? m.content : JSON.stringify(m.content)).join('\n');
+    }
+    if (body.stream)
+        result.stream = true;
+    if (body.temperature != null)
+        result.temperature = body.temperature;
+    if (body.top_p != null)
+        result.top_p = body.top_p;
+    if (body.stop)
+        result.stop_sequences = Array.isArray(body.stop) ? body.stop : [body.stop];
+    return result;
+}
+/**
+ * Translate Anthropic Messages response → OpenAI chat completion response.
+ */
+function anthropicToOpenai(body) {
+    const content = body.content;
+    const text = content?.find(c => c.type === 'text')?.text ?? '';
+    const usage = body.usage;
+    return {
+        id: `chatcmpl-${(body.id || '').replace('msg_', '')}`,
+        object: 'chat.completion',
+        created: Math.floor(Date.now() / 1000),
+        model: body.model,
+        choices: [{
+                index: 0,
+                message: { role: 'assistant', content: text },
+                finish_reason: body.stop_reason === 'end_turn' ? 'stop' : body.stop_reason === 'max_tokens' ? 'length' : 'stop',
+            }],
+        usage: {
+            prompt_tokens: usage?.input_tokens ?? 0,
+            completion_tokens: usage?.output_tokens ?? 0,
+            total_tokens: (usage?.input_tokens ?? 0) + (usage?.output_tokens ?? 0),
+        },
+    };
+}
+/**
+ * Translate Anthropic SSE stream → OpenAI SSE stream.
+ */
+function translateStreamChunk(line) {
+    if (!line.startsWith('data: '))
+        return null;
+    const json = line.slice(6).trim();
+    if (json === '[DONE]')
+        return 'data: [DONE]\n\n';
+    try {
+        const event = JSON.parse(json);
+        if (event.type === 'content_block_delta') {
+            const delta = event.delta;
+            if (delta?.type === 'text_delta' && delta.text) {
+                return `data: ${JSON.stringify({
+                    id: 'chatcmpl-dario',
+                    object: 'chat.completion.chunk',
+                    created: Math.floor(Date.now() / 1000),
+                    model: 'claude',
+                    choices: [{ index: 0, delta: { content: delta.text }, finish_reason: null }],
+                })}\n\n`;
+            }
+        }
+        if (event.type === 'message_stop') {
+            return `data: ${JSON.stringify({
+                id: 'chatcmpl-dario',
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: 'claude',
+                choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+            })}\n\ndata: [DONE]\n\n`;
+        }
+    }
+    catch { /* skip unparseable */ }
+    return null;
+}
+/**
+ * OpenAI-compatible models list.
+ */
+function openaiModelsList() {
+    const models = ['claude-opus-4-6', 'claude-sonnet-4-6', 'claude-haiku-4-5'];
+    return {
+        object: 'list',
+        data: models.map(id => ({
+            id,
+            object: 'model',
+            created: 1700000000,
+            owned_by: 'anthropic',
+        })),
+    };
+}
 function sanitizeError(err) {
     const msg = err instanceof Error ? err.message : String(err);
     // Never leak tokens in error messages
@@ -197,20 +319,28 @@ export async function startProxy(opts = {}) {
             res.end(JSON.stringify(s));
             return;
         }
+        // OpenAI-compatible models list
+        if (urlPath === '/v1/models' && req.method === 'GET') {
+            requestCount++;
+            res.writeHead(200, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': CORS_ORIGIN });
+            res.end(JSON.stringify(openaiModelsList()));
+            return;
+        }
+        // Detect OpenAI-format requests
+        const isOpenAI = urlPath === '/v1/chat/completions';
         // Allowlisted API paths — only these are proxied (prevents SSRF)
         const allowedPaths = {
             '/v1/messages': `${ANTHROPIC_API}/v1/messages`,
-            '/v1/models': `${ANTHROPIC_API}/v1/models`,
             '/v1/complete': `${ANTHROPIC_API}/v1/complete`,
         };
-        const targetBase = allowedPaths[urlPath];
+        const targetBase = isOpenAI ? `${ANTHROPIC_API}/v1/messages` : allowedPaths[urlPath];
         if (!targetBase) {
             res.writeHead(403, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ error: 'Forbidden', message: 'Path not allowed' }));
             return;
         }
-        // Only allow POST (Messages API) and GET (models)
-        if (req.method !== 'POST' && req.method !== 'GET') {
+        // Only allow POST (Messages/Chat API) and GET (models)
+        if (req.method !== 'POST') {
             res.writeHead(405, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ error: 'Method not allowed' }));
             return;
@@ -243,9 +373,18 @@ export async function startProxy(opts = {}) {
                 res.end(cliResult.body);
                 return;
             }
-            // Override model in request body if --model flag was set
+            // Translate OpenAI → Anthropic format if needed
             let finalBody = body.length > 0 ? body : undefined;
-            if (modelOverride && body.length > 0) {
+            if (isOpenAI && body.length > 0) {
+                try {
+                    const parsed = JSON.parse(body.toString());
+                    const translated = openaiToAnthropic(parsed, modelOverride);
+                    finalBody = Buffer.from(JSON.stringify(translated));
+                }
+                catch { /* not JSON, send as-is */ }
+            }
+            else if (modelOverride && body.length > 0) {
+                // Override model in request body if --model flag was set
                 try {
                     const parsed = JSON.parse(body.toString());
                     parsed.model = modelOverride;
@@ -321,12 +460,33 @@ export async function startProxy(opts = {}) {
             if (isStream && upstream.body) {
                 // Stream SSE chunks through
                 const reader = upstream.body.getReader();
+                const decoder = new TextDecoder();
                 try {
+                    let buffer = '';
                     while (true) {
                         const { done, value } = await reader.read();
                         if (done)
                             break;
-                        res.write(value);
+                        if (isOpenAI) {
+                            // Translate Anthropic SSE → OpenAI SSE
+                            buffer += decoder.decode(value, { stream: true });
+                            const lines = buffer.split('\n');
+                            buffer = lines.pop() ?? '';
+                            for (const line of lines) {
+                                const translated = translateStreamChunk(line);
+                                if (translated)
+                                    res.write(translated);
+                            }
+                        }
+                        else {
+                            res.write(value);
+                        }
+                    }
+                    // Flush remaining buffer
+                    if (isOpenAI && buffer.trim()) {
+                        const translated = translateStreamChunk(buffer);
+                        if (translated)
+                            res.write(translated);
                     }
                 }
                 catch (err) {
@@ -338,7 +498,19 @@ export async function startProxy(opts = {}) {
             else {
                 // Buffer and forward
                 const responseBody = await upstream.text();
-                res.end(responseBody);
+                if (isOpenAI && upstream.status >= 200 && upstream.status < 300) {
+                    // Translate Anthropic response → OpenAI format
+                    try {
+                        const parsed = JSON.parse(responseBody);
+                        res.end(JSON.stringify(anthropicToOpenai(parsed)));
+                    }
+                    catch {
+                        res.end(responseBody);
+                    }
+                }
+                else {
+                    res.end(responseBody);
+                }
                 // Quick token estimate for logging
                 if (verbose && responseBody) {
                     try {

package/package.json

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