@sunflower0305/claude-proxy 1.0.0 → 1.1.1

package/.env.example

@@ -14,9 +14,9 @@ KIMI_API_KEY=your-kimi-key
 # Optional model overrides
 QWEN_MODEL=qwen-plus
 DEEPSEEK_MODEL=deepseek-chat
-GLM_MODEL=glm-5
+GLM_MODEL=glm-5.1
 MINIMAX_MODEL=MiniMax-M2.7-highspeed
-KIMI_MODEL=kimi-k2.5
+KIMI_MODEL=kimi-k2.6
 
 # Optional upstream Anthropic-compatible base URL overrides
 # QWEN_ANTHROPIC_BASE_URL=https://dashscope.aliyuncs.com/apps/anthropic

package/README.md

@@ -1,5 +1,11 @@
 # claude-proxy
 
+[![CI](https://github.com/sunflower0305/claude-proxy/actions/workflows/ci.yml/badge.svg)](https://github.com/sunflower0305/claude-proxy/actions/workflows/ci.yml)
+[![CD](https://github.com/sunflower0305/claude-proxy/actions/workflows/cd.yml/badge.svg)](https://github.com/sunflower0305/claude-proxy/actions/workflows/cd.yml)
+[![Coverage Status](https://coveralls.io/repos/github/sunflower0305/claude-proxy/badge.svg?branch=master)](https://coveralls.io/github/sunflower0305/claude-proxy?branch=master)
+[![npm version](https://img.shields.io/npm/v/%40sunflower0305%2Fclaude-proxy)](https://www.npmjs.com/package/@sunflower0305/claude-proxy)
+[![License](https://img.shields.io/github/license/sunflower0305/claude-proxy)](https://github.com/sunflower0305/claude-proxy/blob/master/LICENSE)
+
 `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`.
@@ -34,17 +40,17 @@ 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. |
+| 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. |
+| `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:
 
@@ -82,12 +88,12 @@ const client = new Anthropic({
 
 ## 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 |
+| 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:
 
@@ -114,6 +120,25 @@ const app = createApp();
 app.listen(8080);
 ```
 
+## Release Verification
+
+`v1.1.0` was verified on April 21, 2026 after publishing `@sunflower0305/claude-proxy` to npm.
+
+Verified items:
+
+- `npm view @sunflower0305/claude-proxy version dist-tags --json` confirmed `version: 1.1.0` and `latest: 1.1.0`
+- `npm install @sunflower0305/claude-proxy` completed successfully in a clean temporary directory
+- the published `claude-proxy` CLI started correctly from the installed package
+- `GET /health` and `GET /v1/models` returned `200 OK`
+- local end-to-end proxying against a mock Anthropic-compatible upstream passed for both non-streaming and streaming `POST /v1/messages`
+
+Observed behavior during verification:
+
+- smoke-test startup succeeded with `PROVIDER=qwen`
+- the published artifact returned the expected `health` payload with `provider: qwen` and `model: qwen-plus`
+- the published artifact returned the expected Claude-facing model list from `GET /v1/models`
+- the published package included the expected CLI entrypoint, `dist/` build output, `README.md`, `LICENSE`, and `.env.example`
+
 ## Development
 
 From source:
@@ -123,6 +148,35 @@ npm install
 npm run dev
 ```
 
+## CI And Releases
+
+GitHub Actions provides separate CI and CD workflows:
+
+- `CI` runs on branch pushes and pull requests
+- `CD` runs when you push a `vX.Y.Z` tag and can also be re-run manually with `workflow_dispatch`
+
+The `CD` workflow:
+
+- checks that the tag exactly matches `package.json.version`
+- requires `docs/releases/<version>.md` to exist before publishing
+- runs `npm run build`, `npm run test:proxy-local`, `npm run test:coverage`, and `npm pack --dry-run`
+- fails fast if the npm version already exists
+- publishes the package to npm using the `NPM_TOKEN` repository secret
+- creates or updates the GitHub Release from `docs/releases/<version>.md`
+
+Required repository secret:
+
+- `NPM_TOKEN`: npm automation token with permission to publish `@sunflower0305/claude-proxy`
+
+Release flow:
+
+1. bump `package.json`, `CHANGELOG.md`, and `docs/releases/<version>.md`
+2. commit the release prep
+3. create and push the matching `vX.Y.Z` tag
+4. let the `CD` workflow publish npm and GitHub Release
+
+The package still relies on `prepack` and `prepublishOnly` in `package.json` to build and verify the artifact before release.
+
 Build and local package verification:
 
 ```bash
@@ -136,6 +190,8 @@ Local integration test:
 npm run test:proxy-local
 ```
 
+Release notes for `v1.1.0` are available in [docs/releases/1.1.0.md](docs/releases/1.1.0.md).
+
 ## License
 
 MIT

package/dist/proxy.js

@@ -53,7 +53,7 @@ const PROVIDERS = {
         baseUrl: pickEnv("GLM_ANTHROPIC_BASE_URL") ||
             "https://open.bigmodel.cn/api/anthropic",
         apiKey: process.env.GLM_API_KEY || "",
-        model: pickEnv("GLM_MODEL") || "glm-5",
+        model: pickEnv("GLM_MODEL") || "glm-5.1",
     },
     minimax: {
         baseUrl: pickEnv("MINIMAX_ANTHROPIC_BASE_URL") ||
@@ -64,43 +64,17 @@ const PROVIDERS = {
     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",
+        model: pickEnv("KIMI_MODEL") || "kimi-k2.6",
     },
 };
 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");
+function getInitialProvider() {
+    return isProviderKey(process.env.PROVIDER) ? process.env.PROVIDER : "qwen";
 }
-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 getProviderConfig(provider) {
+    return PROVIDERS[provider] || PROVIDERS.qwen;
 }
 function getHeaderValue(value) {
     if (Array.isArray(value))
@@ -148,15 +122,15 @@ function createProxyError(message) {
         },
     };
 }
-function createRequestTrace(requestedModel, targetModel, stream) {
-    return {
-        requestId: `req-${++requestSequence}`,
-        provider: currentProvider,
-        requestedModel: String(requestedModel || getConfig().model),
-        targetModel,
-        stream,
-        startedAt: Date.now(),
-    };
+function inferProviderFromModel(model) {
+    if (!model)
+        return undefined;
+    const normalizedModel = model.toLowerCase();
+    for (const key of Object.keys(PROVIDERS)) {
+        if (normalizedModel.includes(key))
+            return key;
+    }
+    return undefined;
 }
 function logTimingEvent(trace, phase, extra = {}) {
     console.log(`[ProxyTiming] ${JSON.stringify({
@@ -171,132 +145,167 @@ function logTimingEvent(trace, phase, extra = {}) {
         ...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,
-        });
+export function createApp() {
+    let currentProvider = getInitialProvider();
+    let requestSequence = 0;
+    function getConfig(provider = currentProvider) {
+        return getProviderConfig(provider);
     }
-    catch (error) {
-        console.error("Request error:", error);
-        logTimingEvent(trace, "error", { message: error?.message || String(error) });
-        res.status(500).json(createProxyError(error.message));
+    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;
     }
-}
-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", {
+    function createRequestTrace(requestedModel, targetModel, stream) {
+        return {
+            requestId: `req-${++requestSequence}`,
+            provider: currentProvider,
+            requestedModel: String(requestedModel || getConfig().model),
+            targetModel,
+            stream,
+            startedAt: Date.now(),
+        };
+    }
+    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);
+        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,
-                bytes: 0,
-                no_body: true,
+                content_type: upstream.headers.get("content-type") || "",
             });
-            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", {
+            const payload = Buffer.from(await upstream.arrayBuffer());
+            copyUpstreamHeaders(upstream, res);
+            res.status(upstream.status).send(payload);
+            logTimingEvent(trace, "completed", {
                 status: upstream.status,
-                chunk_bytes: chunkSize,
+                bytes: payload.byteLength,
             });
-        });
-        upstreamStream.on("error", (error) => {
-            if (clientClosed)
-                return;
-            console.error("Upstream stream error:", error);
+        }
+        catch (error) {
+            console.error("Request error:", error);
             logTimingEvent(trace, "error", {
-                status: upstream.status,
                 message: error?.message || String(error),
             });
-            if (!res.writableEnded)
-                res.end();
+            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;
+        logTimingEvent(trace, "start");
+        res.on("close", () => {
+            if (streamCompleted)
+                return;
+            clientClosed = true;
+            abortController.abort();
+            logTimingEvent(trace, "client_aborted");
         });
-        upstreamStream.pipe(res);
-        await new Promise((resolve, reject) => {
-            upstreamStream.on("end", () => {
+        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,
                 });
-                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;
+            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());
+            });
         }
-        console.error("Request error:", error);
-        logTimingEvent(trace, "error", { message: error?.message || String(error) });
-        if (!res.headersSent) {
-            res.status(500).json(createProxyError(error.message));
-            return;
+        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();
         }
-        if (!res.writableEnded)
-            res.end();
     }
-}
-export function createApp() {
     const app = express();
     app.use(cors());
     app.use(express.json({ limit: "50mb" }));
@@ -329,7 +338,7 @@ export function createApp() {
     app.get("/v1/models", (_req, res) => {
         res.json({
             data: [
-                { id: "claude-opus-4-6", object: "model" },
+                { id: "claude-opus-4-7", object: "model" },
                 { id: "claude-sonnet-4-6", object: "model" },
                 { id: "claude-haiku-4-5", object: "model" },
             ],
@@ -346,22 +355,7 @@ export function createApp() {
     });
     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";
-            }
-        }
+        const targetProvider = provider ?? inferProviderFromModel(model);
         if (!isProviderKey(targetProvider)) {
             res.status(400).json({
                 error: `Unknown provider: ${targetProvider}`,
@@ -394,26 +388,33 @@ function isMainModule() {
     if (!entryPath)
         return false;
     try {
-        return realpathSync(entryPath) === realpathSync(fileURLToPath(import.meta.url));
+        return (realpathSync(entryPath) === realpathSync(fileURLToPath(import.meta.url)));
     }
     catch {
         return false;
     }
 }
 if (isMainModule()) {
+    const initialProvider = getInitialProvider();
+    const initialConfig = getProviderConfig(initialProvider);
+    if (!initialConfig.apiKey) {
+        console.warn(`Warning: API key not configured for provider: ${initialProvider}`);
+        console.warn("Please set the appropriate environment variable in .env");
+    }
+    console.log(`Using ${initialProvider} as backend`);
+    console.log(`Model: ${initialConfig.model}`);
     app.listen(PORT, () => {
-        const cfg = getConfig();
         console.log(`
-╔════════════════════════════════════════════════╗
-║         claude-proxy                           ║
-╠════════════════════════════════════════════════╣
+╔═══════════════════════════════════════════════════════╗
+║                claude-proxy                           ║
+╠═══════════════════════════════════════════════════════╣
 ║  http://localhost:${PORT}
-║  Backend: ${currentProvider} (${cfg.model})
-╠════════════════════════════════════════════════╣
-║  Set these env vars in your app:               ║
+║  Backend: ${initialProvider} (${initialConfig.model})
+╠═══════════════════════════════════════════════════════╣
+║  Set these env vars in your app:                      ║
 ║  ANTHROPIC_BASE_URL=http://localhost:${PORT}
-║  ANTHROPIC_API_KEY=any-string-works            ║
-╚════════════════════════════════════════════════╝
+║  ANTHROPIC_API_KEY=any-string-works                   ║
+╚═══════════════════════════════════════════════════════╝
   `);
     });
 }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@sunflower0305/claude-proxy",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "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"
+    "claude-proxy": "dist/proxy.js"
   },
   "exports": {
     ".": {
@@ -54,6 +54,7 @@
     "prepack": "npm run build",
     "prepublishOnly": "npm run test:proxy-local",
     "test": "vitest run",
+    "test:coverage": "vitest run tests/integration/proxy-local.test.ts --coverage --coverage.reporter=lcov --coverage.reporter=text --pool threads",
     "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",
@@ -65,6 +66,7 @@
     "express": "^4.21.0"
   },
   "devDependencies": {
+    "@vitest/coverage-v8": "^3.2.4",
     "@types/cors": "^2.8.17",
     "@types/express": "^4.17.21",
     "@types/node": "^22.0.0",