@sunflower0305/claude-proxy 1.0.0

package/.env.example

@@ -0,0 +1,26 @@
+# Choose your provider: qwen | deepseek | glm | minimax | kimi
+PROVIDER=qwen
+
+# Proxy server port (default: 8080)
+PROXY_PORT=8080
+
+# API keys - set the one(s) you need
+QWEN_API_KEY=your-qwen-api-key
+DEEPSEEK_API_KEY=your-deepseek-key
+GLM_API_KEY=your-glm-key
+MINIMAX_API_KEY=your-minimax-key
+KIMI_API_KEY=your-kimi-key
+
+# Optional model overrides
+QWEN_MODEL=qwen-plus
+DEEPSEEK_MODEL=deepseek-chat
+GLM_MODEL=glm-5
+MINIMAX_MODEL=MiniMax-M2.7-highspeed
+KIMI_MODEL=kimi-k2.5
+
+# Optional upstream Anthropic-compatible base URL overrides
+# QWEN_ANTHROPIC_BASE_URL=https://dashscope.aliyuncs.com/apps/anthropic
+# DEEPSEEK_ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
+# GLM_ANTHROPIC_BASE_URL=https://open.bigmodel.cn/api/anthropic
+# MINIMAX_ANTHROPIC_BASE_URL=https://api.minimaxi.com/anthropic
+# KIMI_ANTHROPIC_BASE_URL=https://api.moonshot.cn/anthropic

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 sunflower0305
+
+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,141 @@
+# claude-proxy
+
+`claude-proxy` is published on npm as `@sunflower0305/claude-proxy`. It is a lightweight Express proxy that lets Claude Code or the Claude Agent SDK talk to domestic Chinese LLM providers through Anthropic-compatible `/v1/messages` endpoints.
+
+It currently supports `qwen`, `deepseek`, `glm`, `minimax`, and `kimi`.
+
+## Install
+
+Run without installing:
+
+```bash
+npx @sunflower0305/claude-proxy
+```
+
+Or install globally:
+
+```bash
+npm install -g @sunflower0305/claude-proxy
+claude-proxy
+```
+
+## Configure
+
+The proxy reads configuration from environment variables. You can export them in your shell or create a `.env` file in the directory where you run `claude-proxy`.
+
+Example `.env`:
+
+```dotenv
+PROVIDER=qwen
+PROXY_PORT=8080
+QWEN_API_KEY=your-qwen-api-key
+QWEN_MODEL=qwen-plus
+```
+
+Available variables:
+
+| Variable | Purpose |
+| --- | --- |
+| `PROVIDER` | Active provider. Defaults to `qwen`. |
+| `PROXY_PORT` | Local server port. Defaults to `8080`. |
+| `QWEN_API_KEY` | API key for Qwen. |
+| `DEEPSEEK_API_KEY` | API key for DeepSeek. |
+| `GLM_API_KEY` | API key for GLM. |
+| `MINIMAX_API_KEY` | API key for MiniMax. |
+| `KIMI_API_KEY` | API key for Kimi. |
+| `QWEN_ANTHROPIC_BASE_URL`, `DEEPSEEK_ANTHROPIC_BASE_URL`, `GLM_ANTHROPIC_BASE_URL`, `MINIMAX_ANTHROPIC_BASE_URL`, `KIMI_ANTHROPIC_BASE_URL` | Override the upstream Anthropic-compatible base URL for a provider. |
+| `QWEN_MODEL`, `DEEPSEEK_MODEL`, `GLM_MODEL`, `MINIMAX_MODEL`, `KIMI_MODEL` | Override the default upstream model for a provider. |
+
+You can use the bundled example as a starting point:
+
+```bash
+cp node_modules/@sunflower0305/claude-proxy/.env.example .env
+```
+
+If you installed globally, create `.env` manually or export the variables in your shell before starting the proxy.
+
+## Start The Proxy
+
+```bash
+claude-proxy
+```
+
+When the server starts, it listens on `http://localhost:8080` by default.
+
+Point Claude Code or the Claude Agent SDK at the proxy:
+
+```bash
+export ANTHROPIC_BASE_URL=http://localhost:8080
+export ANTHROPIC_API_KEY=any-string-works
+```
+
+Example SDK usage:
+
+```ts
+import Anthropic from "@anthropic-ai/sdk";
+
+const client = new Anthropic({
+  baseURL: "http://localhost:8080",
+  apiKey: "any-string",
+});
+```
+
+## Runtime Endpoints
+
+| Method | Path | Description |
+| --- | --- | --- |
+| `POST` | `/v1/messages` | Main Anthropic Messages API proxy endpoint |
+| `GET` | `/v1/models` | Lists supported Claude-facing model ids |
+| `GET` | `/health` | Health check |
+| `GET` / `POST` | `/api/provider` | Read or switch the active provider |
+
+Health check:
+
+```bash
+curl http://localhost:8080/health
+```
+
+Switch provider at runtime:
+
+```bash
+curl -X POST http://localhost:8080/api/provider \
+  -H "Content-Type: application/json" \
+  -d '{"provider":"deepseek"}'
+```
+
+## Library Usage
+
+The package also keeps the programmatic Express entrypoint:
+
+```ts
+import { createApp } from "@sunflower0305/claude-proxy";
+
+const app = createApp();
+app.listen(8080);
+```
+
+## Development
+
+From source:
+
+```bash
+npm install
+npm run dev
+```
+
+Build and local package verification:
+
+```bash
+npm run build
+env npm_config_cache=/tmp/claude-proxy-npm-cache npm pack --dry-run
+```
+
+Local integration test:
+
+```bash
+npm run test:proxy-local
+```
+
+## License
+
+MIT

package/dist/proxy.d.ts

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+/**
+ * Claude Proxy
+ *
+ * Proxies Anthropic Messages API requests to provider-native
+ * Anthropic-compatible endpoints without translating protocols.
+ *
+ * Usage:
+ *   export ANTHROPIC_BASE_URL=http://localhost:8080
+ *   export ANTHROPIC_API_KEY=any-key-works
+ */
+import "dotenv/config";
+import express from "express";
+export declare function createApp(): express.Express;
+export declare const app: express.Express;

package/dist/proxy.js

@@ -0,0 +1,419 @@
+#!/usr/bin/env node
+/**
+ * Claude Proxy
+ *
+ * Proxies Anthropic Messages API requests to provider-native
+ * Anthropic-compatible endpoints without translating protocols.
+ *
+ * Usage:
+ *   export ANTHROPIC_BASE_URL=http://localhost:8080
+ *   export ANTHROPIC_API_KEY=any-key-works
+ */
+import "dotenv/config";
+import cors from "cors";
+import express from "express";
+import { realpathSync } from "node:fs";
+import { Readable } from "node:stream";
+import { fileURLToPath } from "node:url";
+const DEFAULT_ANTHROPIC_VERSION = "2023-06-01";
+const HOP_BY_HOP_RESPONSE_HEADERS = new Set([
+    "connection",
+    "content-encoding",
+    "content-length",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+]);
+function pickEnv(...keys) {
+    for (const key of keys) {
+        const value = process.env[key]?.trim();
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+const PROVIDERS = {
+    deepseek: {
+        baseUrl: pickEnv("DEEPSEEK_ANTHROPIC_BASE_URL") ||
+            "https://api.deepseek.com/anthropic",
+        apiKey: process.env.DEEPSEEK_API_KEY || "",
+        model: pickEnv("DEEPSEEK_MODEL") || "deepseek-chat",
+    },
+    qwen: {
+        baseUrl: pickEnv("QWEN_ANTHROPIC_BASE_URL") ||
+            "https://dashscope.aliyuncs.com/apps/anthropic",
+        apiKey: process.env.QWEN_API_KEY || "",
+        model: pickEnv("QWEN_MODEL") || "qwen-plus",
+    },
+    glm: {
+        baseUrl: pickEnv("GLM_ANTHROPIC_BASE_URL") ||
+            "https://open.bigmodel.cn/api/anthropic",
+        apiKey: process.env.GLM_API_KEY || "",
+        model: pickEnv("GLM_MODEL") || "glm-5",
+    },
+    minimax: {
+        baseUrl: pickEnv("MINIMAX_ANTHROPIC_BASE_URL") ||
+            "https://api.minimaxi.com/anthropic",
+        apiKey: process.env.MINIMAX_API_KEY || "",
+        model: pickEnv("MINIMAX_MODEL") || "MiniMax-M2.7-highspeed",
+    },
+    kimi: {
+        baseUrl: pickEnv("KIMI_ANTHROPIC_BASE_URL") || "https://api.moonshot.cn/anthropic",
+        apiKey: process.env.KIMI_API_KEY || "",
+        model: pickEnv("KIMI_MODEL") || "kimi-k2.5",
+    },
+};
+function isProviderKey(value) {
+    return Boolean(value && value in PROVIDERS);
+}
+let currentProvider = isProviderKey(process.env.PROVIDER)
+    ? process.env.PROVIDER
+    : "qwen";
+let requestSequence = 0;
+function getConfig(provider = currentProvider) {
+    return PROVIDERS[provider] || PROVIDERS.qwen;
+}
+const initialConfig = getConfig();
+if (!initialConfig.apiKey) {
+    console.warn(`Warning: API key not configured for provider: ${currentProvider}`);
+    console.warn("Please set the appropriate environment variable in .env");
+}
+console.log(`Using ${currentProvider} as backend`);
+console.log(`Model: ${initialConfig.model}`);
+function getTargetModel(requestedModel) {
+    if (typeof requestedModel !== "string" || !requestedModel) {
+        return getConfig().model;
+    }
+    const normalizedModel = requestedModel.toLowerCase();
+    if (normalizedModel === "opus" ||
+        normalizedModel === "sonnet" ||
+        normalizedModel === "haiku") {
+        return getConfig().model;
+    }
+    if (normalizedModel.startsWith("claude-") &&
+        (normalizedModel.includes("-opus") ||
+            normalizedModel.includes("-sonnet") ||
+            normalizedModel.includes("-haiku"))) {
+        return getConfig().model;
+    }
+    return requestedModel;
+}
+function getHeaderValue(value) {
+    if (Array.isArray(value))
+        return value.join(",");
+    return value;
+}
+function buildUpstreamHeaders(req, stream, apiKey) {
+    const headers = {
+        "content-type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": getHeaderValue(req.headers["anthropic-version"]) ||
+            DEFAULT_ANTHROPIC_VERSION,
+        accept: getHeaderValue(req.headers.accept) ||
+            (stream ? "text/event-stream" : "application/json"),
+    };
+    const anthropicBeta = getHeaderValue(req.headers["anthropic-beta"]);
+    if (anthropicBeta) {
+        headers["anthropic-beta"] = anthropicBeta;
+    }
+    return headers;
+}
+function getUpstreamUrl(baseUrl) {
+    return `${baseUrl.replace(/\/$/, "")}/v1/messages`;
+}
+function buildUpstreamBody(body, targetModel) {
+    const normalized = typeof body === "object" && body !== null
+        ? { ...body }
+        : {};
+    normalized.model = targetModel;
+    return normalized;
+}
+function copyUpstreamHeaders(upstream, res) {
+    for (const [key, value] of upstream.headers.entries()) {
+        if (HOP_BY_HOP_RESPONSE_HEADERS.has(key.toLowerCase()))
+            continue;
+        res.setHeader(key, value);
+    }
+}
+function createProxyError(message) {
+    return {
+        type: "error",
+        error: {
+            type: "internal_error",
+            message,
+        },
+    };
+}
+function createRequestTrace(requestedModel, targetModel, stream) {
+    return {
+        requestId: `req-${++requestSequence}`,
+        provider: currentProvider,
+        requestedModel: String(requestedModel || getConfig().model),
+        targetModel,
+        stream,
+        startedAt: Date.now(),
+    };
+}
+function logTimingEvent(trace, phase, extra = {}) {
+    console.log(`[ProxyTiming] ${JSON.stringify({
+        request_id: trace.requestId,
+        provider: trace.provider,
+        requested_model: trace.requestedModel,
+        target_model: trace.targetModel,
+        stream: trace.stream,
+        phase,
+        elapsed_ms: Date.now() - trace.startedAt,
+        at: new Date().toISOString(),
+        ...extra,
+    })}`);
+}
+async function handleNonStreamingRequest(req, res) {
+    const config = getConfig();
+    const targetModel = getTargetModel(req.body?.model);
+    const requestBody = buildUpstreamBody(req.body, targetModel);
+    const trace = createRequestTrace(req.body?.model, targetModel, false);
+    console.log(`\n[${new Date().toISOString()}] ${String(req.body?.model || config.model)} -> ${targetModel} (non-streaming)`);
+    logTimingEvent(trace, "start");
+    try {
+        const upstream = await fetch(getUpstreamUrl(config.baseUrl), {
+            method: "POST",
+            headers: buildUpstreamHeaders(req, false, config.apiKey),
+            body: JSON.stringify(requestBody),
+        });
+        logTimingEvent(trace, "upstream_headers", {
+            status: upstream.status,
+            content_type: upstream.headers.get("content-type") || "",
+        });
+        const payload = Buffer.from(await upstream.arrayBuffer());
+        copyUpstreamHeaders(upstream, res);
+        res.status(upstream.status).send(payload);
+        logTimingEvent(trace, "completed", {
+            status: upstream.status,
+            bytes: payload.byteLength,
+        });
+    }
+    catch (error) {
+        console.error("Request error:", error);
+        logTimingEvent(trace, "error", { message: error?.message || String(error) });
+        res.status(500).json(createProxyError(error.message));
+    }
+}
+async function handleStreamingRequest(req, res) {
+    const config = getConfig();
+    const targetModel = getTargetModel(req.body?.model);
+    const requestBody = buildUpstreamBody(req.body, targetModel);
+    const trace = createRequestTrace(req.body?.model, targetModel, true);
+    const abortController = new AbortController();
+    let clientClosed = false;
+    let streamCompleted = false;
+    let sawFirstChunk = false;
+    console.log(`\n[${new Date().toISOString()}] ${String(req.body?.model || config.model)} -> ${targetModel} (streaming)`);
+    logTimingEvent(trace, "start");
+    res.on("close", () => {
+        if (streamCompleted)
+            return;
+        clientClosed = true;
+        abortController.abort();
+        logTimingEvent(trace, "client_aborted");
+    });
+    try {
+        const upstream = await fetch(getUpstreamUrl(config.baseUrl), {
+            method: "POST",
+            headers: buildUpstreamHeaders(req, true, config.apiKey),
+            body: JSON.stringify(requestBody),
+            signal: abortController.signal,
+        });
+        logTimingEvent(trace, "upstream_headers", {
+            status: upstream.status,
+            content_type: upstream.headers.get("content-type") || "",
+        });
+        copyUpstreamHeaders(upstream, res);
+        res.status(upstream.status);
+        if (!upstream.body) {
+            streamCompleted = true;
+            res.end();
+            logTimingEvent(trace, "completed", {
+                status: upstream.status,
+                bytes: 0,
+                no_body: true,
+            });
+            return;
+        }
+        const upstreamStream = Readable.fromWeb(upstream.body);
+        upstreamStream.on("data", (chunk) => {
+            if (sawFirstChunk)
+                return;
+            sawFirstChunk = true;
+            const chunkSize = Buffer.isBuffer(chunk)
+                ? chunk.byteLength
+                : Buffer.byteLength(String(chunk));
+            logTimingEvent(trace, "first_chunk", {
+                status: upstream.status,
+                chunk_bytes: chunkSize,
+            });
+        });
+        upstreamStream.on("error", (error) => {
+            if (clientClosed)
+                return;
+            console.error("Upstream stream error:", error);
+            logTimingEvent(trace, "error", {
+                status: upstream.status,
+                message: error?.message || String(error),
+            });
+            if (!res.writableEnded)
+                res.end();
+        });
+        upstreamStream.pipe(res);
+        await new Promise((resolve, reject) => {
+            upstreamStream.on("end", () => {
+                streamCompleted = true;
+                logTimingEvent(trace, "completed", {
+                    status: upstream.status,
+                });
+                resolve();
+            });
+            upstreamStream.on("error", reject);
+            res.on("close", () => resolve());
+        });
+    }
+    catch (error) {
+        const wasAborted = error?.name === "AbortError" || abortController.signal.aborted;
+        if (clientClosed || wasAborted) {
+            console.warn("[Proxy] Client disconnected, streaming aborted");
+            return;
+        }
+        console.error("Request error:", error);
+        logTimingEvent(trace, "error", { message: error?.message || String(error) });
+        if (!res.headersSent) {
+            res.status(500).json(createProxyError(error.message));
+            return;
+        }
+        if (!res.writableEnded)
+            res.end();
+    }
+}
+export function createApp() {
+    const app = express();
+    app.use(cors());
+    app.use(express.json({ limit: "50mb" }));
+    app.get("/", (_req, res) => {
+        const config = getConfig();
+        res.json({
+            name: "claude-proxy",
+            status: "running",
+            provider: currentProvider,
+            model: config.model,
+            endpoints: {
+                messages: "POST /v1/messages",
+                health: "GET /health",
+                models: "GET /v1/models",
+                provider: "GET|POST /api/provider",
+            },
+        });
+    });
+    app.post("/v1/messages", async (req, res) => {
+        if (req.body?.stream) {
+            await handleStreamingRequest(req, res);
+            return;
+        }
+        await handleNonStreamingRequest(req, res);
+    });
+    app.get("/health", (_req, res) => {
+        const config = getConfig();
+        res.json({ status: "ok", provider: currentProvider, model: config.model });
+    });
+    app.get("/v1/models", (_req, res) => {
+        res.json({
+            data: [
+                { id: "claude-opus-4-6", object: "model" },
+                { id: "claude-sonnet-4-6", object: "model" },
+                { id: "claude-haiku-4-5", object: "model" },
+            ],
+        });
+    });
+    app.get("/api/provider", (_req, res) => {
+        const config = getConfig();
+        res.json({
+            provider: currentProvider,
+            model: config.model,
+            baseUrl: config.baseUrl,
+            availableProviders: Object.keys(PROVIDERS),
+        });
+    });
+    app.post("/api/provider", (req, res) => {
+        const { provider, model } = (req.body ?? {});
+        let targetProvider = provider;
+        if (!targetProvider && model) {
+            const normalizedModel = model.toLowerCase();
+            if (normalizedModel.includes("kimi")) {
+                targetProvider = "kimi";
+            }
+            else if (normalizedModel.includes("qwen"))
+                targetProvider = "qwen";
+            else if (normalizedModel.includes("deepseek"))
+                targetProvider = "deepseek";
+            else if (normalizedModel.includes("glm"))
+                targetProvider = "glm";
+            else if (normalizedModel.includes("minimax")) {
+                targetProvider = "minimax";
+            }
+        }
+        if (!isProviderKey(targetProvider)) {
+            res.status(400).json({
+                error: `Unknown provider: ${targetProvider}`,
+                available: Object.keys(PROVIDERS),
+            });
+            return;
+        }
+        const targetConfig = getConfig(targetProvider);
+        if (!targetConfig.apiKey) {
+            res.status(400).json({
+                error: `API key not set for: ${targetProvider}`,
+            });
+            return;
+        }
+        const oldProvider = currentProvider;
+        currentProvider = targetProvider;
+        console.log(`Provider: ${oldProvider} -> ${currentProvider}`);
+        res.json({
+            success: true,
+            provider: currentProvider,
+            model: targetConfig.model,
+        });
+    });
+    return app;
+}
+export const app = createApp();
+const PORT = parseInt(process.env.PROXY_PORT || "8080", 10);
+function isMainModule() {
+    const entryPath = process.argv[1];
+    if (!entryPath)
+        return false;
+    try {
+        return realpathSync(entryPath) === realpathSync(fileURLToPath(import.meta.url));
+    }
+    catch {
+        return false;
+    }
+}
+if (isMainModule()) {
+    app.listen(PORT, () => {
+        const cfg = getConfig();
+        console.log(`
+╔════════════════════════════════════════════════╗
+║         claude-proxy                           ║
+╠════════════════════════════════════════════════╣
+║  http://localhost:${PORT}
+║  Backend: ${currentProvider} (${cfg.model})
+╠════════════════════════════════════════════════╣
+║  Set these env vars in your app:               ║
+║  ANTHROPIC_BASE_URL=http://localhost:${PORT}
+║  ANTHROPIC_API_KEY=any-string-works            ║
+╚════════════════════════════════════════════════╝
+  `);
+    });
+}

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "@sunflower0305/claude-proxy",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "A proxy that lets Claude Agent SDK use domestic Chinese LLMs (DeepSeek, Qwen, GLM, MiniMax) as backend",
+  "license": "MIT",
+  "main": "./dist/proxy.js",
+  "types": "./dist/proxy.d.ts",
+  "bin": {
+    "claude-proxy": "./dist/proxy.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/proxy.d.ts",
+      "import": "./dist/proxy.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE",
+    ".env.example"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sunflower0305/claude-proxy.git"
+  },
+  "homepage": "https://github.com/sunflower0305/claude-proxy#readme",
+  "bugs": {
+    "url": "https://github.com/sunflower0305/claude-proxy/issues"
+  },
+  "keywords": [
+    "anthropic",
+    "claude",
+    "proxy",
+    "express",
+    "llm",
+    "qwen",
+    "deepseek",
+    "glm",
+    "minimax",
+    "kimi"
+  ],
+  "scripts": {
+    "dev": "tsx watch src/proxy.ts",
+    "build": "tsc",
+    "start": "node dist/proxy.js",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run test:proxy-local",
+    "test": "vitest run",
+    "test:proxy-local": "vitest run tests/integration/proxy-local.test.ts",
+    "test:provider-anthropic": "node --experimental-strip-types tests/integration/provider-anthropic.ts",
+    "test:provider-cli-e2e": "node --experimental-strip-types tests/integration/provider-cli-e2e.ts",
+    "report:provider-cli-e2e": "node --experimental-strip-types tests/integration/report-provider-cli-e2e.ts"
+  },
+  "dependencies": {
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.5",
+    "express": "^4.21.0"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/node": "^22.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.5.0",
+    "vitest": "^3.2.4"
+  }
+}