Skip to content

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

Rust

route requests to providers by model instead of a single-provider default

Raine Virta8422461ad86e
diff --git a/src/cli.ts b/src/cli.ts
index 5b44bb5..f873bf1 100755
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -1,7 +1,12 @@
#!/usr/bin/env bun
import { startServer } from "./server.ts"
import { createLogger, logDir } from "./log.ts"
-import { getProvider, listProviders } from "./providers/registry.ts"
+import {
+ allProviders,
+ allSupportedModels,
+ getProvider,
+ listProviders,
+} from "./providers/registry.ts"
import type { CliHandlers } from "./providers/types.ts"
declare const BUILD_VERSION: string | undefined
@@ -19,21 +24,22 @@ async function main() {
}
if (!first || first === "serve") {
- const providerName = argFlag(rest, "--provider") ?? process.env.CCP_PROVIDER ?? "codex"
- const provider = getProvider(providerName)
const port = Number(process.env.PORT ?? 18765)
- startServer({ port, provider })
- console.log(`Proxy listening on http://localhost:${port} (provider: ${provider.name})`)
+ startServer({ port })
+ console.log(`Proxy listening on http://localhost:${port}`)
console.log(`Logs: ${logDir()}/proxy.log`)
console.log()
- console.log("Configure Claude Code:")
+ 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}`)
+ }
+ console.log()
+ console.log("Configure Claude Code (pick a model from above):")
console.log(` export ANTHROPIC_BASE_URL="http://localhost:${port}"`)
console.log(` export ANTHROPIC_AUTH_TOKEN="anything"`)
- if (provider.name === "codex") {
- console.log(` export ANTHROPIC_MODEL="gpt-5.4"`)
- } else if (provider.name === "kimi") {
- console.log(` export ANTHROPIC_MODEL="kimi-for-coding"`)
- }
+ console.log(` export ANTHROPIC_MODEL="kimi-for-coding" # or gpt-5.4, etc.`)
+ console.log(` export ANTHROPIC_SMALL_FAST_MODEL="kimi-for-coding" # background / title-gen`)
console.log(` export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1"`)
return
}
@@ -77,24 +83,22 @@ async function runProviderCommand(name: string, cli: CliHandlers, args: string[]
}
}
-function argFlag(args: string[], flag: string): string | undefined {
- const i = args.indexOf(flag)
- if (i === -1) return undefined
- return args[i + 1]
-}
-
function usageAndExit(): never {
const providers = listProviders().join("|")
+ const models = allSupportedModels()
+ .map((m) => `${m.model} (${m.provider})`)
+ .join(", ")
console.log(`Usage:
- claude-code-proxy serve [--provider ${providers}] Run proxy (PORT env, default 18765)
- claude-code-proxy <provider> auth login Browser OAuth
- claude-code-proxy <provider> auth device Device-code OAuth
- claude-code-proxy <provider> auth status Show current auth
- claude-code-proxy <provider> auth logout Clear stored auth
- claude-code-proxy --version Show version
+ claude-code-proxy serve Run proxy (PORT env, default 18765)
+ Upstream is chosen per-request from ANTHROPIC_MODEL.
+ claude-code-proxy <provider> auth login Browser OAuth
+ claude-code-proxy <provider> auth device Device-code OAuth
+ claude-code-proxy <provider> auth status Show current auth
+ claude-code-proxy <provider> auth logout Clear stored auth
+ claude-code-proxy --version Show version
Providers: ${providers}
-Default provider: ${process.env.CCP_PROVIDER ?? "codex"} (override with CCP_PROVIDER or --provider)
+Models: ${models}
`)
process.exit(2)
}
diff --git a/src/providers/codex/index.ts b/src/providers/codex/index.ts
index 3a16720..1f43ed1 100644
--- a/src/providers/codex/index.ts
+++ b/src/providers/codex/index.ts
@@ -379,6 +379,7 @@ const cli: CliHandlers = {
export const codexProvider: Provider = {
name: "codex",
+ supportedModels: new Set(["gpt-5.2", "gpt-5.3-codex", "gpt-5.4", "gpt-5.4-mini"]),
handleMessages,
handleCountTokens,
cli,
diff --git a/src/providers/kimi/index.ts b/src/providers/kimi/index.ts
index b02830f..d334f51 100644
--- a/src/providers/kimi/index.ts
+++ b/src/providers/kimi/index.ts
@@ -186,6 +186,7 @@ const cli: CliHandlers = {
export const kimiProvider: Provider = {
name: "kimi",
+ supportedModels: new Set(["kimi-for-coding", "kimi-k2.6", "k2.6"]),
handleMessages,
handleCountTokens,
cli,
diff --git a/src/providers/registry.ts b/src/providers/registry.ts
index f2860da..25de82b 100644
--- a/src/providers/registry.ts
+++ b/src/providers/registry.ts
@@ -7,12 +7,11 @@ const PROVIDERS: Record<string, Provider> = {
kimi: kimiProvider,
}
-export function getProvider(name?: string): Provider {
- const key = name ?? process.env.CCP_PROVIDER ?? "codex"
- const p = PROVIDERS[key]
+export function getProvider(name: string): Provider {
+ const p = PROVIDERS[name]
if (!p) {
throw new Error(
- `Unknown provider: ${key}. Available: ${Object.keys(PROVIDERS).join(", ")}`,
+ `Unknown provider: ${name}. Available: ${Object.keys(PROVIDERS).join(", ")}`,
)
}
return p
@@ -21,3 +20,26 @@ export function getProvider(name?: string): Provider {
export function listProviders(): string[] {
return Object.keys(PROVIDERS)
}
+
+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 {
+ for (const p of allProviders()) {
+ if (p.supportedModels.has(model)) return p
+ }
+ return undefined
+}
+
+export function allSupportedModels(): Array<{ model: string; provider: string }> {
+ const out: Array<{ model: string; provider: string }> = []
+ for (const p of allProviders()) {
+ for (const m of p.supportedModels) out.push({ model: m, provider: p.name })
+ }
+ return out
+}
diff --git a/src/providers/types.ts b/src/providers/types.ts
index 390fb05..bc9733e 100644
--- a/src/providers/types.ts
+++ b/src/providers/types.ts
@@ -16,6 +16,12 @@ 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.
+ supportedModels: Set<string>
handleMessages(body: AnthropicRequest, ctx: RequestContext): Promise<Response>
handleCountTokens(body: AnthropicRequest, ctx: RequestContext): Promise<Response>
cli: CliHandlers
diff --git a/src/server.ts b/src/server.ts
index 66fb0fd..6f2da8c 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -1,12 +1,12 @@
import { createLogger, logDir } from "./log.ts"
import type { AnthropicRequest } from "./anthropic/schema.ts"
import type { Provider, RequestContext } from "./providers/types.ts"
+import { allSupportedModels, providerForModel } from "./providers/registry.ts"
const log = createLogger("server")
export interface ServeOptions {
port: number
- provider: Provider
}
const sessionSeqs = new Map<string, number>()
@@ -19,7 +19,6 @@ function nextSessionSeq(sessionId?: string): number | undefined {
}
export function startServer(opts: ServeOptions): { stop: () => void; port: number } {
- const { provider } = opts
const server = Bun.serve({
hostname: "127.0.0.1",
port: opts.port,
@@ -33,10 +32,9 @@ export function startServer(opts: ServeOptions): { stop: () => void; port: numbe
method: req.method,
path: url.pathname,
query: url.search,
- provider: provider.name,
})
try {
- const resp = await route(req, url, reqId, provider)
+ const resp = await route(req, url, reqId)
log.info("response", { reqId, status: resp.status, ms: Date.now() - start })
return resp
} catch (err) {
@@ -45,16 +43,16 @@ export function startServer(opts: ServeOptions): { stop: () => void; port: numbe
}
},
})
- log.info("server listening", { port: server.port, provider: provider.name, logDir: logDir() })
+ log.info("server listening", { port: server.port, logDir: logDir() })
return {
port: Number(server.port),
stop: () => server.stop(),
}
}
-async function route(req: Request, url: URL, reqId: string, provider: Provider): Promise<Response> {
+async function route(req: Request, url: URL, reqId: string): Promise<Response> {
if (url.pathname === "/healthz") {
- return new Response(JSON.stringify({ ok: true, provider: provider.name }), {
+ return new Response(JSON.stringify({ ok: true }), {
headers: { "content-type": "application/json" },
})
}
@@ -62,32 +60,70 @@ async function route(req: Request, url: URL, reqId: string, provider: Provider):
if (req.method === "POST" && url.pathname === "/v1/messages/count_tokens") {
const body = await parseJsonBody(req)
if (body instanceof Response) return body
- const sessionId = req.headers.get("x-claude-code-session-id") || undefined
- const ctx: RequestContext = {
- reqId,
- sessionId,
- sessionSeq: nextSessionSeq(sessionId),
- signal: req.signal,
- }
+ const provider = routeProvider(body, reqId)
+ if (provider instanceof Response) return provider
+ const ctx = buildCtx(req, reqId)
+ log.info("dispatch", { reqId, provider: provider.name, model: body.model })
return provider.handleCountTokens(body, ctx)
}
if (req.method === "POST" && url.pathname === "/v1/messages") {
const body = await parseJsonBody(req)
if (body instanceof Response) return body
- const sessionId = req.headers.get("x-claude-code-session-id") || undefined
- const ctx: RequestContext = {
- reqId,
- sessionId,
- sessionSeq: nextSessionSeq(sessionId),
- signal: req.signal,
- }
+ const provider = routeProvider(body, reqId)
+ if (provider instanceof Response) return provider
+ const ctx = buildCtx(req, reqId)
+ log.info("dispatch", { reqId, provider: provider.name, model: body.model })
return provider.handleMessages(body, ctx)
}
return jsonError(404, "not_found", `No route for ${req.method} ${url.pathname}`)
}
+function buildCtx(req: Request, reqId: string): RequestContext {
+ const sessionId = req.headers.get("x-claude-code-session-id") || undefined
+ return {
+ reqId,
+ sessionId,
+ sessionSeq: nextSessionSeq(sessionId),
+ signal: req.signal,
+ }
+}
+
+function routeProvider(body: AnthropicRequest, reqId: string): Provider | Response {
+ if (!body.model) {
+ return jsonError(
+ 400,
+ "invalid_request_error",
+ `Missing "model" in request body. ${knownModelsMessage()}`,
+ )
+ }
+ const provider = providerForModel(body.model)
+ if (!provider) {
+ log.warn("unknown model", { reqId, model: body.model })
+ return jsonError(
+ 400,
+ "invalid_request_error",
+ `Unknown model "${body.model}". ${knownModelsMessage()}`,
+ )
+ }
+ return provider
+}
+
+function knownModelsMessage(): string {
+ const groups = new Map<string, string[]>()
+ for (const { model, provider } of allSupportedModels()) {
+ const list = groups.get(provider) ?? []
+ list.push(model)
+ groups.set(provider, list)
+ }
+ const parts: string[] = []
+ for (const [provider, models] of groups) {
+ parts.push(`${provider}: ${models.join(", ")}`)
+ }
+ return `Supported: ${parts.join("; ")}.`
+}
+
async function parseJsonBody(req: Request): Promise<AnthropicRequest | Response> {
try {
return (await req.json()) as AnthropicRequest