@sunflower0305/claude-proxy 1.1.0 → 1.1.1

package/README.md

@@ -1,6 +1,7 @@
 # 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)
@@ -39,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:
 
@@ -87,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:
 
@@ -121,20 +122,21 @@ app.listen(8080);
 
 ## Release Verification
 
-`v1.0.0` was verified on April 15, 2026 after publishing `@sunflower0305/claude-proxy` to npm.
+`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`
-- 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`
+- 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:
 
-- 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
+- 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
@@ -148,15 +150,32 @@ npm run dev
 
 ## CI And Releases
 
-GitHub Actions currently provides a CI baseline only:
+GitHub Actions provides separate CI and CD workflows:
 
-- 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
+- `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`
 
-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.
+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:
 
@@ -171,7 +190,7 @@ 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).
+Release notes for `v1.1.0` are available in [docs/releases/1.1.0.md](docs/releases/1.1.0.md).
 
 ## License
 

package/dist/proxy.js

@@ -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.1",
   "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}`;
-        },
-    };
-}