@sunflower0305/claude-proxy 1.1.0 → 1.1.2

package/.env.example

@@ -1,5 +1,5 @@
 # Choose your provider: qwen | deepseek | glm | minimax | kimi
-PROVIDER=qwen
+PROVIDER=deepseek
 
 # Proxy server port (default: 8080)
 PROXY_PORT=8080
@@ -13,7 +13,7 @@ KIMI_API_KEY=your-kimi-key
 
 # Optional model overrides
 QWEN_MODEL=qwen-plus
-DEEPSEEK_MODEL=deepseek-chat
+DEEPSEEK_MODEL=deepseek-v4-pro
 GLM_MODEL=glm-5.1
 MINIMAX_MODEL=MiniMax-M2.7-highspeed
 KIMI_MODEL=kimi-k2.6

package/README.md

@@ -1,8 +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)
+[![npm downloads](https://img.shields.io/npm/dm/%40sunflower0305%2Fclaude-proxy)](https://www.npmjs.com/package/@sunflower0305/claude-proxy)
+[![GitHub stars](https://img.shields.io/github/stars/sunflower0305/claude-proxy?cacheSeconds=60)](https://github.com/sunflower0305/claude-proxy/stargazers)
 [![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.
@@ -31,25 +34,35 @@ The proxy reads configuration from environment variables. You can export them in
 Example `.env`:
 
 ```dotenv
-PROVIDER=qwen
+PROVIDER=deepseek
 PROXY_PORT=8080
-QWEN_API_KEY=your-qwen-api-key
-QWEN_MODEL=qwen-plus
+DEEPSEEK_API_KEY=your-deepseek-api-key
+DEEPSEEK_MODEL=deepseek-v4-pro
 ```
 
 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 `deepseek`.                            |
+| `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.                 |
+
+Provider defaults:
+
+| Provider | Model env | Default model |
+| --- | --- | --- |
+| **`deepseek` (default)** | `DEEPSEEK_MODEL` | **`deepseek-v4-pro`** |
+| `qwen` | `QWEN_MODEL` | `qwen-plus` |
+| `glm` | `GLM_MODEL` | `glm-5.1` |
+| `minimax` | `MINIMAX_MODEL` | `MiniMax-M2.7-highspeed` |
+| `kimi` | `KIMI_MODEL` | `kimi-k2.6` |
 
 You can use the bundled example as a starting point:
 
@@ -87,12 +100,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:
 
@@ -105,7 +118,7 @@ Switch provider at runtime:
 ```bash
 curl -X POST http://localhost:8080/api/provider \
   -H "Content-Type: application/json" \
-  -d '{"provider":"deepseek"}'
+  -d '{"provider":"qwen"}'
 ```
 
 ## Library Usage
@@ -119,24 +132,6 @@ 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:
@@ -146,33 +141,6 @@ 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
-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
-```
-
-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/proxy.js

@@ -41,7 +41,7 @@ const PROVIDERS = {
         baseUrl: pickEnv("DEEPSEEK_ANTHROPIC_BASE_URL") ||
             "https://api.deepseek.com/anthropic",
         apiKey: process.env.DEEPSEEK_API_KEY || "",
-        model: pickEnv("DEEPSEEK_MODEL") || "deepseek-chat",
+        model: pickEnv("DEEPSEEK_MODEL") || "deepseek-v4-pro",
     },
     qwen: {
         baseUrl: pickEnv("QWEN_ANTHROPIC_BASE_URL") ||
@@ -71,10 +71,10 @@ function isProviderKey(value) {
     return Boolean(value && value in PROVIDERS);
 }
 function getInitialProvider() {
-    return isProviderKey(process.env.PROVIDER) ? process.env.PROVIDER : "qwen";
+    return isProviderKey(process.env.PROVIDER) ? process.env.PROVIDER : "deepseek";
 }
 function getProviderConfig(provider) {
-    return PROVIDERS[provider] || PROVIDERS.qwen;
+    return PROVIDERS[provider] || PROVIDERS.deepseek;
 }
 function getHeaderValue(value) {
     if (Array.isArray(value))
@@ -338,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" },
             ],
@@ -406,13 +406,13 @@ if (isMainModule()) {
     app.listen(PORT, () => {
         console.log(`
 ╔═══════════════════════════════════════════════════════╗
-║                     claude-proxy                      ║
+║                claude-proxy                           ║
 ╠═══════════════════════════════════════════════════════╣
-║  http://localhost:${PORT}                             ║
-║  Backend: ${initialProvider} (${initialConfig.model}) ║
+║  http://localhost:${PORT}
+║  Backend: ${initialProvider} (${initialConfig.model})
 ╠═══════════════════════════════════════════════════════╣
 ║  Set these env vars in your app:                      ║
-║  ANTHROPIC_BASE_URL=http://localhost:${PORT}          ║
+║  ANTHROPIC_BASE_URL=http://localhost:${PORT}
 ║  ANTHROPIC_API_KEY=any-string-works                   ║
 ╚═══════════════════════════════════════════════════════╝
   `);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sunflower0305/claude-proxy",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "type": "module",
   "description": "A proxy that lets Claude Agent SDK use domestic Chinese LLMs (DeepSeek, Qwen, GLM, MiniMax) as backend",
   "license": "MIT",

package/dist/app.d.ts

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

package/dist/app.js

@@ -1,79 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,221 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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/runtime.d.ts

@@ -1,27 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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}`;
-        },
-    };
-}