Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

route aliases by configured provider

Raine Virta0c81d92a26a8
diff --git a/README.md b/README.md
index 2c3c4d6..00fb453 100644
--- a/README.md
+++ b/README.md
@@ -453,6 +453,7 @@ directory the auth tokens use, deliberately not `~/Library`) and at
```json
{
"port": 18765,
+ "aliasProvider": "kimi",
"codex": {
"originator": "claude-code-proxy",
"userAgent": "claude-code-proxy/dev",
@@ -479,6 +480,7 @@ directory the auth tokens use, deliberately not `~/Library`) and at
| `XDG_STATE_HOME` | — | `~/.local/state` | Base dir for `proxy.log` |
| `CCP_LOG_STDERR` | `log.stderr` | unset | Also mirror log lines to stderr |
| `CCP_LOG_VERBOSE` | `log.verbose` | unset | Log full request/response bodies + every SSE event |
+| `CCP_ALIAS_PROVIDER` | `aliasProvider` | `kimi` | Route Anthropic-style aliases (`haiku`, `sonnet`, `opus`, `claude-*`) through `kimi` or `codex` |
| `CCP_KIMI_OAUTH_HOST` | `kimi.oauthHost` | `https://auth.kimi.com` | Override Kimi's OAuth host (debugging only) |
| `CCP_KIMI_BASE_URL` | `kimi.baseUrl` | `https://api.kimi.com/coding/v1` | Override Kimi's API base URL |
| `CCP_CODEX_MODEL` | `codex.model` | unset | Force all Codex requests to this model (`gpt-5.2`, `gpt-5.3-codex`, `gpt-5.4`, `gpt-5.4-mini`, `gpt-5.5`) |
diff --git a/src/cli.ts b/src/cli.ts
index 68be8a9..a9887a8 100755
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -1,7 +1,7 @@
#!/usr/bin/env bun
import { startServer } from "./server.ts"
import { createLogger, logDir } from "./log.ts"
-import { port as configPort, getConfig } from "./config.ts"
+import { port as configPort, getConfig, aliasProvider as configAliasProvider } from "./config.ts"
import { configDir } from "./paths.ts"
import { existsSync } from "node:fs"
import { join } from "node:path"
@@ -35,10 +35,7 @@ async function main() {
printConfigSummary()
console.log()
console.log("Providers are selected per-request by ANTHROPIC_MODEL:")
- for (const p of allProviders()) {
- const models = [...p.supportedModels].join(", ")
- console.log(` ${p.name}: ${models}`)
- }
+ printSupportedModels()
console.log()
console.log("Configure Claude Code (pick a model from above):")
console.log(` export ANTHROPIC_BASE_URL="http://localhost:${port}"`)
@@ -108,6 +105,19 @@ Models: ${models}
process.exit(2)
}
+function printSupportedModels(): void {
+ const groups = new Map<string, string[]>()
+ for (const { model, provider } of allSupportedModels()) {
+ const models = groups.get(provider) ?? []
+ models.push(model)
+ groups.set(provider, models)
+ }
+ for (const provider of listProviders()) {
+ const models = groups.get(provider) ?? []
+ console.log(` ${provider}: ${models.join(", ")}`)
+ }
+}
+
function printConfigSummary(): void {
const cfg = getConfig()
const fromFile = cfg.file
@@ -140,6 +150,9 @@ function printConfigSummary(): void {
if (cfg.env.CCP_CODEX_BASE_URL) overrides.push("CCP_CODEX_BASE_URL (env)")
else if (fromFile.codex?.baseUrl) overrides.push("codex.baseUrl (config)")
+ if (cfg.env.CCP_ALIAS_PROVIDER) overrides.push(`CCP_ALIAS_PROVIDER=${configAliasProvider()} (env)`)
+ else if (fromFile.aliasProvider) overrides.push(`aliasProvider=${fromFile.aliasProvider} (config)`)
+
if (cfg.env.CCP_LOG_VERBOSE !== undefined) overrides.push("CCP_LOG_VERBOSE (env)")
else if (fromFile.log?.verbose) overrides.push("log.verbose (config)")
diff --git a/src/config.test.ts b/src/config.test.ts
index de64414..5450115 100644
--- a/src/config.test.ts
+++ b/src/config.test.ts
@@ -11,6 +11,7 @@ import {
codexEffort,
codexServiceTier,
codexBaseUrl,
+ aliasProvider,
kimiUserAgent,
kimiOauthHost,
kimiBaseUrl,
@@ -47,6 +48,7 @@ describe("config defaults", () => {
expect(codexEffort()).toBeUndefined()
expect(codexServiceTier()).toBeUndefined()
expect(codexBaseUrl("default-codex-url")).toBe("default-codex-url")
+ expect(aliasProvider()).toBe("kimi")
expect(kimiUserAgent("default-kimi-ua")).toBe("default-kimi-ua")
expect(kimiOauthHost()).toBe("https://auth.kimi.com")
expect(kimiBaseUrl()).toBe("https://api.kimi.com/coding/v1")
@@ -90,6 +92,12 @@ describe("file overrides default", () => {
)
})
+ it("aliasProvider from config.json", () => {
+ writeFileSync(configPath, JSON.stringify({ aliasProvider: "codex" }))
+ setEnv({})
+ expect(aliasProvider()).toBe("codex")
+ })
+
it("kimi.oauthHost from config.json", () => {
writeFileSync(
configPath,
@@ -137,6 +145,12 @@ describe("env overrides file", () => {
expect(codexBaseUrl("default")).toBe("http://127.0.0.1:2455/env")
})
+ it("CCP_ALIAS_PROVIDER env wins over config", () => {
+ writeFileSync(configPath, JSON.stringify({ aliasProvider: "kimi" }))
+ setEnv({ CCP_ALIAS_PROVIDER: "codex" })
+ expect(aliasProvider()).toBe("codex")
+ })
+
it("CCP_USER_AGENT env (generic fallback) is preferred over file", () => {
writeFileSync(
configPath,
@@ -172,6 +186,18 @@ describe("empty-string semantics", () => {
expect(codexServiceTier()).toBe("flex")
})
+ it("empty CCP_ALIAS_PROVIDER env falls through to file value", () => {
+ writeFileSync(configPath, JSON.stringify({ aliasProvider: "codex" }))
+ setEnv({ CCP_ALIAS_PROVIDER: "" })
+ expect(aliasProvider()).toBe("codex")
+ })
+
+ it("invalid CCP_ALIAS_PROVIDER env falls through to file value", () => {
+ writeFileSync(configPath, JSON.stringify({ aliasProvider: "codex" }))
+ setEnv({ CCP_ALIAS_PROVIDER: "openai" })
+ expect(aliasProvider()).toBe("codex")
+ })
+
it("empty PORT env falls through to file value", () => {
writeFileSync(configPath, JSON.stringify({ port: 33333 }))
setEnv({ PORT: "" })
@@ -213,6 +239,12 @@ describe("malformed config", () => {
expect(codexUserAgent("default")).toBe("good")
})
+ it("ignores invalid aliasProvider values", () => {
+ writeFileSync(configPath, JSON.stringify({ aliasProvider: "openai" }))
+ setEnv({})
+ expect(aliasProvider()).toBe("kimi")
+ })
+
it("returns defaults when file is missing entirely", () => {
setEnv({})
expect(port()).toBe(18765)
diff --git a/src/config.ts b/src/config.ts
index 221ba4b..fe18539 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -9,8 +9,11 @@ import { configDir } from "./paths.ts"
// from either env or the file are treated as "unset" so they fall through
// to the next layer (matches existing CCP_CODEX_MODEL behavior).
+export type AliasProvider = "codex" | "kimi"
+
export interface FileConfig {
port?: number
+ aliasProvider?: AliasProvider
codex?: {
originator?: string
userAgent?: string
@@ -57,6 +60,13 @@ function warnInvalid(key: string, expected: string, got: unknown): void {
)
}
+function parseAliasProvider(key: string, value: unknown): AliasProvider | undefined {
+ if (value === undefined) return undefined
+ if (value === "codex" || value === "kimi") return value
+ warnInvalid(key, '"codex" or "kimi"', value)
+ return undefined
+}
+
function validate(raw: unknown): FileConfig {
if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {}
const r = raw as Record<string, unknown>
@@ -67,6 +77,8 @@ function validate(raw: unknown): FileConfig {
else warnInvalid("port", "number", r.port)
}
+ out.aliasProvider = parseAliasProvider("aliasProvider", r.aliasProvider)
+
const validateStringSection = <K extends "codex" | "kimi" | "log">(
key: K,
keys: ReadonlyArray<keyof NonNullable<FileConfig[K]>>,
@@ -211,6 +223,11 @@ export function codexBaseUrl(defaultValue: string): string {
return c.env.CCP_CODEX_BASE_URL ?? c.file.codex?.baseUrl ?? defaultValue
}
+export function aliasProvider(): AliasProvider {
+ const c = getConfig()
+ return parseAliasProvider("CCP_ALIAS_PROVIDER", emptyOrUnset(c.env.CCP_ALIAS_PROVIDER)) ?? c.file.aliasProvider ?? "kimi"
+}
+
export function kimiUserAgent(defaultValue: string): string {
const c = getConfig()
return (
diff --git a/src/providers/codex/translate/model-allowlist.test.ts b/src/providers/codex/translate/model-allowlist.test.ts
index 2137d69..9ede655 100644
--- a/src/providers/codex/translate/model-allowlist.test.ts
+++ b/src/providers/codex/translate/model-allowlist.test.ts
@@ -2,8 +2,14 @@ import { describe, expect, it, afterEach } from "bun:test"
import { mkdtempSync, writeFileSync, rmSync } from "node:fs"
import { tmpdir } from "node:os"
import { join } from "node:path"
-import { resolveModel, resolveModelRequest } from "./model-allowlist.ts"
+import {
+ ALLOWED_MODELS,
+ MODEL_ALIASES,
+ resolveModel,
+ resolveModelRequest,
+} from "./model-allowlist.ts"
import { loadConfig } from "../../../config.ts"
+import { ANTHROPIC_STYLE_ALIASES } from "../../registry.ts"
afterEach(() => {
loadConfig({ forceReload: true })
@@ -74,4 +80,16 @@ describe("resolveModel", () => {
loadConfig({ env: {}, forceReload: true })
expect(resolveModelRequest("gpt-4.1-fast")).toEqual({ model: "gpt-4.1-fast" })
})
+
+ it("resolves every shared Anthropic-style alias to an allowed model", () => {
+ loadConfig({ env: {}, forceReload: true })
+
+ for (const alias of ANTHROPIC_STYLE_ALIASES) {
+ expect(ALLOWED_MODELS.has(resolveModel(alias))).toBe(true)
+ }
+ })
+
+ it("keeps the shared alias routing set aligned with Codex model aliases", () => {
+ expect([...ANTHROPIC_STYLE_ALIASES].sort()).toEqual([...MODEL_ALIASES.keys()].sort())
+ })
})
diff --git a/src/providers/kimi/index.ts b/src/providers/kimi/index.ts
index 56ddbce..e54397a 100644
--- a/src/providers/kimi/index.ts
+++ b/src/providers/kimi/index.ts
@@ -203,13 +203,6 @@ export const kimiProvider: Provider = {
"kimi-for-coding",
"kimi-k2.6",
"k2.6",
- "haiku",
- "claude-haiku-4-5",
- "claude-haiku-4-5-20251001",
- "sonnet",
- "claude-sonnet-4-6",
- "opus",
- "claude-opus-4-7",
]),
handleMessages,
handleCountTokens,
diff --git a/src/providers/registry.test.ts b/src/providers/registry.test.ts
index bd318f5..c220630 100644
--- a/src/providers/registry.test.ts
+++ b/src/providers/registry.test.ts
@@ -1,7 +1,25 @@
-import { describe, expect, it } from "bun:test"
-import { providerForModel } from "./registry.ts"
+import { afterEach, describe, expect, it } from "bun:test"
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import {
+ allSupportedModels,
+ ANTHROPIC_STYLE_ALIASES,
+ providerForModel,
+} from "./registry.ts"
+import { loadConfig } from "../config.ts"
import { normalizeIncomingModel } from "../server.ts"
+afterEach(() => {
+ loadConfig({ forceReload: true })
+})
+
+function providersFor(model: string): string[] {
+ return allSupportedModels()
+ .filter((entry) => entry.model === model)
+ .map((entry) => entry.provider)
+}
+
describe("provider routing", () => {
it("routes fast Codex model aliases after context suffix normalization", () => {
const model = normalizeIncomingModel("gpt-5.4-fast[1m]")
@@ -9,4 +27,63 @@ describe("provider routing", () => {
expect(model).toBe("gpt-5.4-fast")
expect(providerForModel(model)?.name).toBe("codex")
})
+
+ it("routes Anthropic-style aliases to Kimi by default", () => {
+ loadConfig({ env: {}, forceReload: true })
+
+ expect(providerForModel("sonnet")?.name).toBe("kimi")
+ })
+
+ it("routes every Anthropic-style alias to Codex when env selects Codex", () => {
+ loadConfig({ env: { CCP_ALIAS_PROVIDER: "codex" }, forceReload: true })
+
+ for (const alias of ANTHROPIC_STYLE_ALIASES) {
+ expect(providerForModel(alias)?.name).toBe("codex")
+ }
+ })
+
+ it("routes aliases to Codex when config file selects Codex", () => {
+ const dir = mkdtempSync(join(tmpdir(), "ccp-alias-provider-"))
+ const path = join(dir, "config.json")
+ writeFileSync(path, JSON.stringify({ aliasProvider: "codex" }))
+ try {
+ loadConfig({ configPath: path, env: {}, forceReload: true })
+ expect(providerForModel("claude-opus-4-7")?.name).toBe("codex")
+ } finally {
+ rmSync(dir, { recursive: true, force: true })
+ }
+ })
+
+ it("lets env override config file alias provider", () => {
+ const dir = mkdtempSync(join(tmpdir(), "ccp-alias-provider-"))
+ const path = join(dir, "config.json")
+ writeFileSync(path, JSON.stringify({ aliasProvider: "codex" }))
+ try {
+ loadConfig({ configPath: path, env: { CCP_ALIAS_PROVIDER: "kimi" }, forceReload: true })
+ expect(providerForModel("haiku")?.name).toBe("kimi")
+ } finally {
+ rmSync(dir, { recursive: true, force: true })
+ }
+ })
+
+ it("lists aliases only under the active alias provider", () => {
+ loadConfig({ env: { CCP_ALIAS_PROVIDER: "codex" }, forceReload: true })
+
+ expect(providersFor("sonnet")).toEqual(["codex"])
+ })
+
+ it("does not duplicate supported model entries", () => {
+ for (const env of [{}, { CCP_ALIAS_PROVIDER: "codex" }]) {
+ loadConfig({ env, forceReload: true })
+ const models = allSupportedModels().map(({ model }) => model)
+ expect(new Set(models).size).toBe(models.length)
+ }
+ })
+
+ it("keeps concrete model routing unchanged", () => {
+ loadConfig({ env: { CCP_ALIAS_PROVIDER: "codex" }, forceReload: true })
+
+ expect(providerForModel("kimi-for-coding")?.name).toBe("kimi")
+ expect(providerForModel("gpt-5.4-fast")?.name).toBe("codex")
+ })
})
diff --git a/src/providers/registry.ts b/src/providers/registry.ts
index 25de82b..653d556 100644
--- a/src/providers/registry.ts
+++ b/src/providers/registry.ts
@@ -1,7 +1,18 @@
+import { aliasProvider } from "../config.ts"
import type { Provider } from "./types.ts"
import { codexProvider } from "./codex/index.ts"
import { kimiProvider } from "./kimi/index.ts"
+export const ANTHROPIC_STYLE_ALIASES = new Set([
+ "haiku",
+ "claude-haiku-4-5",
+ "claude-haiku-4-5-20251001",
+ "sonnet",
+ "claude-sonnet-4-6",
+ "opus",
+ "claude-opus-4-7",
+])
+
const PROVIDERS: Record<string, Provider> = {
codex: codexProvider,
kimi: kimiProvider,
@@ -25,11 +36,8 @@ export function allProviders(): Provider[] {
return Object.values(PROVIDERS)
}
-// Look up the single provider that claims the given model id. Returns
-// undefined when no provider declares it (the caller should surface an
-// error). Cross-provider aliases like `haiku` / `sonnet` are deliberately
-// NOT resolvable here — users must use a concrete, provider-owned model id.
export function providerForModel(model: string): Provider | undefined {
+ if (ANTHROPIC_STYLE_ALIASES.has(model)) return getProvider(aliasProvider())
for (const p of allProviders()) {
if (p.supportedModels.has(model)) return p
}
@@ -38,8 +46,12 @@ export function providerForModel(model: string): Provider | undefined {
export function allSupportedModels(): Array<{ model: string; provider: string }> {
const out: Array<{ model: string; provider: string }> = []
+ const activeAliasProvider = aliasProvider()
for (const p of allProviders()) {
for (const m of p.supportedModels) out.push({ model: m, provider: p.name })
+ if (p.name === activeAliasProvider) {
+ for (const m of ANTHROPIC_STYLE_ALIASES) out.push({ model: m, provider: p.name })
+ }
}
return out
}
diff --git a/src/providers/types.ts b/src/providers/types.ts
index d3bb3d7..1031f83 100644
--- a/src/providers/types.ts
+++ b/src/providers/types.ts
@@ -19,11 +19,8 @@ export interface CliHandlers {
export interface Provider {
name: string
- // Unambiguous model identifiers this provider claims. The server uses
- // these to dispatch a request body's `model` field to the right
- // provider when multiple are registered. Cross-provider aliases like
- // `haiku`/`sonnet` are deliberately excluded — they fall back to the
- // default provider.
+ // Unambiguous model identifiers this provider claims. Cross-provider
+ // Anthropic-style aliases are resolved by registry-level alias routing.
supportedModels: Set<string>
handleMessages(body: AnthropicRequest, ctx: RequestContext): Promise<Response>
handleCountTokens(body: AnthropicRequest, ctx: RequestContext): Promise<Response>