@sunflower0305/claude-proxy 1.0.0 → 1.1.0

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,10 @@
 # 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)
+[![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`.
@@ -114,6 +119,24 @@ const app = createApp();
 app.listen(8080);
 ```
 
+## Release Verification
+
+`v1.0.0` was verified on April 15, 2026 after publishing `@sunflower0305/claude-proxy` to npm.
+
+Verified items:
+
+- `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`
+- end-to-end proxying against a local mock Anthropic-compatible upstream passed for both non-streaming and streaming `POST /v1/messages`
+- end-to-end proxying against the real Qwen Anthropic-compatible upstream passed for both non-streaming and streaming `POST /v1/messages`
+
+Observed behavior during verification:
+
+- model remapping worked as expected, including `claude-sonnet-4-6 -> qwen-plus`
+- the real Qwen verification returned a valid assistant response for both buffered JSON and SSE streaming modes
+- the published package included the expected CLI entrypoint, `dist/` build output, `README.md`, `LICENSE`, and `.env.example`
+
 ## Development
 
 From source:
@@ -123,6 +146,18 @@ npm install
 npm run dev
 ```
 
+## CI And Releases
+
+GitHub Actions currently provides a CI baseline only:
+
+- install dependencies with `pnpm`
+- run `npm run build`
+- run `npm run test:proxy-local`
+- run `npm run test:coverage`
+- upload `coverage/lcov.info` to Coveralls without blocking the workflow if the upload service is temporarily unavailable
+
+Publishing to npm remains a manual step. 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 +171,8 @@ Local integration test:
 npm run test:proxy-local
 ```
 
+Release notes for `v1.0.0` are available in [docs/releases/1.0.0.md](/Users/joe/ai/claude-proxy/docs/releases/1.0.0.md).
+
 ## License
 
 MIT

package/dist/app.d.ts

@@ -0,0 +1,3 @@
+import express from "express";
+import { type ProxyRuntime } from "./runtime";
+export declare function createApp(runtime?: ProxyRuntime): express.Express;

package/dist/app.js

@@ -0,0 +1,79 @@
+import cors from "cors";
+import express from "express";
+import { handleMessagesRequest } from "./messages";
+import { isProviderKey } from "./providers";
+import { createRuntime } from "./runtime";
+const SUPPORTED_MODELS = [
+    { id: "claude-opus-4-6", object: "model" },
+    { id: "claude-sonnet-4-6", object: "model" },
+    { id: "claude-haiku-4-5", object: "model" },
+];
+export function createApp(runtime = createRuntime()) {
+    const app = express();
+    app.use(cors());
+    app.use(express.json({ limit: "50mb" }));
+    app.get("/", (_req, res) => {
+        const config = runtime.getCurrentConfig();
+        res.json({
+            name: "claude-proxy",
+            status: "running",
+            provider: runtime.getCurrentProvider(),
+            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) => {
+        await handleMessagesRequest(req, res, runtime);
+    });
+    app.get("/health", (_req, res) => {
+        const config = runtime.getCurrentConfig();
+        res.json({
+            status: "ok",
+            provider: runtime.getCurrentProvider(),
+            model: config.model,
+        });
+    });
+    app.get("/v1/models", (_req, res) => {
+        res.json({ data: SUPPORTED_MODELS });
+    });
+    app.get("/api/provider", (_req, res) => {
+        const config = runtime.getCurrentConfig();
+        res.json({
+            provider: runtime.getCurrentProvider(),
+            model: config.model,
+            baseUrl: config.baseUrl,
+            availableProviders: [...runtime.providerKeys],
+        });
+    });
+    app.post("/api/provider", (req, res) => {
+        const { provider, model } = (req.body ?? {});
+        const targetProvider = provider ?? runtime.inferProviderFromModel(model);
+        if (!isProviderKey(targetProvider)) {
+            res.status(400).json({
+                error: `Unknown provider: ${targetProvider}`,
+                available: [...runtime.providerKeys],
+            });
+            return;
+        }
+        const targetConfig = runtime.getConfig(targetProvider);
+        if (!targetConfig.apiKey) {
+            res.status(400).json({
+                error: `API key not set for: ${targetProvider}`,
+            });
+            return;
+        }
+        const switchResult = runtime.setCurrentProvider(targetProvider);
+        console.log(`Provider: ${switchResult.previousProvider} -> ${switchResult.provider}`);
+        res.json({
+            success: true,
+            provider: switchResult.provider,
+            model: switchResult.config.model,
+        });
+    });
+    return app;
+}

package/dist/messages.d.ts

@@ -0,0 +1,3 @@
+import type express from "express";
+import type { ProxyRuntime } from "./runtime";
+export declare function handleMessagesRequest(req: express.Request, res: express.Response, runtime: ProxyRuntime): Promise<void>;

package/dist/messages.js

@@ -0,0 +1,221 @@
+import { Readable } from "node:stream";
+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 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 toErrorMessage(error) {
+    if (error instanceof Error && error.message)
+        return error.message;
+    return String(error);
+}
+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,
+    })}`);
+}
+function prepareUpstreamRequest(req, runtime, stream) {
+    const config = runtime.getCurrentConfig();
+    const targetModel = runtime.getTargetModel(req.body?.model);
+    return {
+        apiKey: config.apiKey,
+        providerModel: config.model,
+        requestBody: buildUpstreamBody(req.body, targetModel),
+        requestedModel: req.body?.model,
+        targetModel,
+        trace: runtime.createRequestTrace(req.body?.model, targetModel, stream),
+        upstreamUrl: getUpstreamUrl(config.baseUrl),
+    };
+}
+async function handleNonStreamingRequest(req, res, runtime) {
+    const prepared = prepareUpstreamRequest(req, runtime, false);
+    console.log(`\n[${new Date().toISOString()}] ${String(prepared.requestedModel || prepared.providerModel)} -> ${prepared.targetModel} (non-streaming)`);
+    logTimingEvent(prepared.trace, "start");
+    try {
+        const upstream = await fetch(prepared.upstreamUrl, {
+            method: "POST",
+            headers: buildUpstreamHeaders(req, false, prepared.apiKey),
+            body: JSON.stringify(prepared.requestBody),
+        });
+        logTimingEvent(prepared.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(prepared.trace, "completed", {
+            status: upstream.status,
+            bytes: payload.byteLength,
+        });
+    }
+    catch (error) {
+        const message = toErrorMessage(error);
+        console.error("Request error:", error);
+        logTimingEvent(prepared.trace, "error", { message });
+        res.status(500).json(createProxyError(message));
+    }
+}
+async function handleStreamingRequest(req, res, runtime) {
+    const prepared = prepareUpstreamRequest(req, runtime, true);
+    const abortController = new AbortController();
+    let clientClosed = false;
+    let streamCompleted = false;
+    let sawFirstChunk = false;
+    console.log(`\n[${new Date().toISOString()}] ${String(prepared.requestedModel || prepared.providerModel)} -> ${prepared.targetModel} (streaming)`);
+    logTimingEvent(prepared.trace, "start");
+    res.on("close", () => {
+        if (streamCompleted)
+            return;
+        clientClosed = true;
+        abortController.abort();
+        logTimingEvent(prepared.trace, "client_aborted");
+    });
+    try {
+        const upstream = await fetch(prepared.upstreamUrl, {
+            method: "POST",
+            headers: buildUpstreamHeaders(req, true, prepared.apiKey),
+            body: JSON.stringify(prepared.requestBody),
+            signal: abortController.signal,
+        });
+        logTimingEvent(prepared.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(prepared.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(prepared.trace, "first_chunk", {
+                status: upstream.status,
+                chunk_bytes: chunkSize,
+            });
+        });
+        upstreamStream.on("error", (error) => {
+            if (clientClosed)
+                return;
+            console.error("Upstream stream error:", error);
+            logTimingEvent(prepared.trace, "error", {
+                status: upstream.status,
+                message: toErrorMessage(error),
+            });
+            if (!res.writableEnded)
+                res.end();
+        });
+        upstreamStream.pipe(res);
+        await new Promise((resolve, reject) => {
+            upstreamStream.on("end", () => {
+                streamCompleted = true;
+                logTimingEvent(prepared.trace, "completed", {
+                    status: upstream.status,
+                });
+                resolve();
+            });
+            upstreamStream.on("error", reject);
+            res.on("close", () => resolve());
+        });
+    }
+    catch (error) {
+        const wasAborted = error instanceof Error && error.name === "AbortError"
+            ? true
+            : abortController.signal.aborted;
+        if (clientClosed || wasAborted) {
+            console.warn("[Proxy] Client disconnected, streaming aborted");
+            return;
+        }
+        const message = toErrorMessage(error);
+        console.error("Request error:", error);
+        logTimingEvent(prepared.trace, "error", { message });
+        if (!res.headersSent) {
+            res.status(500).json(createProxyError(message));
+            return;
+        }
+        if (!res.writableEnded)
+            res.end();
+    }
+}
+export async function handleMessagesRequest(req, res, runtime) {
+    if (req.body?.stream) {
+        await handleStreamingRequest(req, res, runtime);
+        return;
+    }
+    await handleNonStreamingRequest(req, res, runtime);
+}

package/dist/providers.d.ts

@@ -0,0 +1,11 @@
+export interface ProviderConfig {
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+}
+export declare const PROVIDER_KEYS: readonly ["deepseek", "qwen", "glm", "minimax", "kimi"];
+export type ProviderKey = (typeof PROVIDER_KEYS)[number];
+export type ProviderMap = Record<ProviderKey, ProviderConfig>;
+export declare const DEFAULT_PROVIDER: ProviderKey;
+export declare function isProviderKey(value: string | undefined): value is ProviderKey;
+export declare function loadProviders(env?: NodeJS.ProcessEnv): ProviderMap;

package/dist/providers.js

@@ -0,0 +1,53 @@
+export const PROVIDER_KEYS = [
+    "deepseek",
+    "qwen",
+    "glm",
+    "minimax",
+    "kimi",
+];
+export const DEFAULT_PROVIDER = "qwen";
+function pickEnv(env, ...keys) {
+    for (const key of keys) {
+        const value = env[key]?.trim();
+        if (value)
+            return value;
+    }
+    return undefined;
+}
+export function isProviderKey(value) {
+    return Boolean(value && PROVIDER_KEYS.includes(value));
+}
+export function loadProviders(env = process.env) {
+    return {
+        deepseek: {
+            baseUrl: pickEnv(env, "DEEPSEEK_ANTHROPIC_BASE_URL") ||
+                "https://api.deepseek.com/anthropic",
+            apiKey: env.DEEPSEEK_API_KEY || "",
+            model: pickEnv(env, "DEEPSEEK_MODEL") || "deepseek-chat",
+        },
+        qwen: {
+            baseUrl: pickEnv(env, "QWEN_ANTHROPIC_BASE_URL") ||
+                "https://dashscope.aliyuncs.com/apps/anthropic",
+            apiKey: env.QWEN_API_KEY || "",
+            model: pickEnv(env, "QWEN_MODEL") || "qwen-plus",
+        },
+        glm: {
+            baseUrl: pickEnv(env, "GLM_ANTHROPIC_BASE_URL") ||
+                "https://open.bigmodel.cn/api/anthropic",
+            apiKey: env.GLM_API_KEY || "",
+            model: pickEnv(env, "GLM_MODEL") || "glm-5",
+        },
+        minimax: {
+            baseUrl: pickEnv(env, "MINIMAX_ANTHROPIC_BASE_URL") ||
+                "https://api.minimaxi.com/anthropic",
+            apiKey: env.MINIMAX_API_KEY || "",
+            model: pickEnv(env, "MINIMAX_MODEL") || "MiniMax-M2.7-highspeed",
+        },
+        kimi: {
+            baseUrl: pickEnv(env, "KIMI_ANTHROPIC_BASE_URL") ||
+                "https://api.moonshot.cn/anthropic",
+            apiKey: env.KIMI_API_KEY || "",
+            model: pickEnv(env, "KIMI_MODEL") || "kimi-k2.5",
+        },
+    };
+}

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" }));
@@ -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                           ║
-╠════════════════════════════════════════════════╣
-║  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            ║
-╚════════════════════════════════════════════════╝
+╔═══════════════════════════════════════════════════════╗
+║                     claude-proxy                      ║
+╠═══════════════════════════════════════════════════════╣
+║  http://localhost:${PORT}                             ║
+║  Backend: ${initialProvider} (${initialConfig.model}) ║
+╠═══════════════════════════════════════════════════════╣
+║  Set these env vars in your app:                      ║
+║  ANTHROPIC_BASE_URL=http://localhost:${PORT}          ║
+║  ANTHROPIC_API_KEY=any-string-works                   ║
+╚═══════════════════════════════════════════════════════╝
   `);
     });
 }

package/dist/runtime.d.ts

@@ -0,0 +1,27 @@
+import { type ProviderConfig, type ProviderKey, type ProviderMap } from "./providers";
+export interface RequestTrace {
+    requestId: string;
+    provider: ProviderKey;
+    requestedModel: string;
+    targetModel: string;
+    stream: boolean;
+    startedAt: number;
+}
+export interface ProxyRuntime {
+    readonly providerKeys: readonly ProviderKey[];
+    getCurrentProvider(): ProviderKey;
+    getCurrentConfig(): ProviderConfig;
+    getConfig(provider?: ProviderKey): ProviderConfig;
+    getTargetModel(requestedModel: unknown): string;
+    inferProviderFromModel(model: string | undefined): ProviderKey | undefined;
+    setCurrentProvider(provider: ProviderKey): {
+        previousProvider: ProviderKey;
+        provider: ProviderKey;
+        config: ProviderConfig;
+    };
+    createRequestTrace(requestedModel: unknown, targetModel: string, stream: boolean): RequestTrace;
+    getStartupWarning(): string | undefined;
+}
+export declare function resolveTargetModel(requestedModel: unknown, currentModel: string): string;
+export declare function inferProviderFromModel(model: string | undefined): ProviderKey | undefined;
+export declare function createRuntime(env?: NodeJS.ProcessEnv, providers?: ProviderMap): ProxyRuntime;

package/dist/runtime.js

@@ -0,0 +1,83 @@
+import { DEFAULT_PROVIDER, PROVIDER_KEYS, isProviderKey, loadProviders, } from "./providers";
+export function resolveTargetModel(requestedModel, currentModel) {
+    if (typeof requestedModel !== "string" || !requestedModel) {
+        return currentModel;
+    }
+    const normalizedModel = requestedModel.toLowerCase();
+    if (normalizedModel === "opus" ||
+        normalizedModel === "sonnet" ||
+        normalizedModel === "haiku") {
+        return currentModel;
+    }
+    if (normalizedModel.startsWith("claude-") &&
+        (normalizedModel.includes("-opus") ||
+            normalizedModel.includes("-sonnet") ||
+            normalizedModel.includes("-haiku"))) {
+        return currentModel;
+    }
+    return requestedModel;
+}
+export function inferProviderFromModel(model) {
+    const normalizedModel = model?.toLowerCase();
+    if (!normalizedModel)
+        return undefined;
+    if (normalizedModel.includes("kimi"))
+        return "kimi";
+    if (normalizedModel.includes("qwen"))
+        return "qwen";
+    if (normalizedModel.includes("deepseek"))
+        return "deepseek";
+    if (normalizedModel.includes("glm"))
+        return "glm";
+    if (normalizedModel.includes("minimax"))
+        return "minimax";
+    return undefined;
+}
+export function createRuntime(env = process.env, providers = loadProviders(env)) {
+    let currentProvider = isProviderKey(env.PROVIDER)
+        ? env.PROVIDER
+        : DEFAULT_PROVIDER;
+    let requestSequence = 0;
+    function getConfig(provider = currentProvider) {
+        return providers[provider] || providers[DEFAULT_PROVIDER];
+    }
+    return {
+        providerKeys: PROVIDER_KEYS,
+        getCurrentProvider() {
+            return currentProvider;
+        },
+        getCurrentConfig() {
+            return getConfig();
+        },
+        getConfig,
+        getTargetModel(requestedModel) {
+            return resolveTargetModel(requestedModel, getConfig().model);
+        },
+        inferProviderFromModel,
+        setCurrentProvider(provider) {
+            const previousProvider = currentProvider;
+            currentProvider = provider;
+            return {
+                previousProvider,
+                provider: currentProvider,
+                config: getConfig(),
+            };
+        },
+        createRequestTrace(requestedModel, targetModel, stream) {
+            const config = getConfig();
+            return {
+                requestId: `req-${++requestSequence}`,
+                provider: currentProvider,
+                requestedModel: String(requestedModel || config.model),
+                targetModel,
+                stream,
+                startedAt: Date.now(),
+            };
+        },
+        getStartupWarning() {
+            if (getConfig().apiKey)
+                return undefined;
+            return `Warning: API key not configured for provider: ${currentProvider}`;
+        },
+    };
+}

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@sunflower0305/claude-proxy",
-  "version": "1.0.0",
+  "version": "1.1.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"
+    "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",