Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
add config.json as alternative to env vars
Raine Virta6aa1b8463d14
diff --git a/README.md b/README.mdindex 5f21c55..2bd2e31 100644--- a/README.md+++ b/README.md@@ -427,35 +427,74 @@ The proxy speaks enough of the Anthropic API for Claude Code:## Configuration-Settings are environment variables on the proxy process, not a config file.--| Variable | Default | Purpose |-| ---------------------- | -------------------------------- | ---------------------------------------------------------------------------------------------- |-| `PORT` | `18765` | Proxy listen port |-| `XDG_STATE_HOME` | `~/.local/state` | Base dir for `proxy.log` |-| `CCP_LOG_STDERR` | unset | Also mirror log lines to stderr |-| `CCP_LOG_VERBOSE` | unset | Log full request/response bodies + every SSE event |-| `KIMI_OAUTH_HOST` | `https://auth.kimi.com` | Override Kimi's OAuth host (debugging only) |-| `KIMI_BASE_URL` | `https://api.kimi.com/coding/v1` | Override Kimi's API base URL |-| `CCP_CODEX_MODEL` | unset | Force all Codex requests to this model (`gpt-5.2`, `gpt-5.3-codex`, `gpt-5.4`, `gpt-5.4-mini`) |-| `CCP_CODEX_EFFORT` | unset | Force all Codex requests to this reasoning effort (`none`, `low`, `medium`, `high`, `xhigh`) |-| `CCP_CODEX_ORIGINATOR` | `claude-code-proxy` | Override the `originator` header sent to Codex |-| `CCP_CODEX_USER_AGENT` | `claude-code-proxy/<version>` | Override the `User-Agent` header sent to Codex |-| `CCP_KIMI_USER_AGENT` | `KimiCLI/1.37.0` | Override the `User-Agent` header sent to Kimi |-| `CCP_ORIGINATOR` | `claude-code-proxy` | Fallback for `CCP_CODEX_ORIGINATOR` |-| `CCP_USER_AGENT` | unset | Fallback for `CCP_CODEX_USER_AGENT` and `CCP_KIMI_USER_AGENT` |+Settings can come from either environment variables or a `config.json` file.+Precedence per setting: **env var > config file > built-in default**. The+config file is optional — env-var-only setups continue to work unchanged.++The file lives at `~/.config/claude-code-proxy/config.json` on macOS (the same+directory the auth tokens use, deliberately not `~/Library`) and at+`${XDG_CONFIG_HOME:-$HOME/.config}/claude-code-proxy/config.json` elsewhere.++```json+{+ "port": 18765,+ "codex": {+ "originator": "claude-code-proxy",+ "userAgent": "claude-code-proxy/dev",+ "model": "gpt-5.4",+ "effort": "medium"+ },+ "kimi": {+ "userAgent": "KimiCLI/1.37.0",+ "oauthHost": "https://auth.kimi.com",+ "baseUrl": "https://api.kimi.com/coding/v1"+ },+ "log": {+ "stderr": false,+ "verbose": false+ }+}+```++| Variable | Config key | Default | Purpose |+| ---------------------- | ------------------- | -------------------------------- | ---------------------------------------------------------------------------------------------- |+| `PORT` | `port` | `18765` | Proxy listen port |+| `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 |+| `KIMI_OAUTH_HOST` | `kimi.oauthHost` | `https://auth.kimi.com` | Override Kimi's OAuth host (debugging only) |+| `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`) |+| `CCP_CODEX_EFFORT` | `codex.effort` | unset | Force all Codex requests to this reasoning effort (`none`, `low`, `medium`, `high`, `xhigh`) |+| `CCP_CODEX_ORIGINATOR` | `codex.originator` | `claude-code-proxy` | Override the `originator` header sent to Codex |+| `CCP_CODEX_USER_AGENT` | `codex.userAgent` | `claude-code-proxy/<version>` | Override the `User-Agent` header sent to Codex |+| `CCP_KIMI_USER_AGENT` | `kimi.userAgent` | `KimiCLI/1.37.0` | Override the `User-Agent` header sent to Kimi |+| `CCP_ORIGINATOR` | — | `claude-code-proxy` | Fallback for `CCP_CODEX_ORIGINATOR` |+| `CCP_USER_AGENT` | — | unset | Fallback for `CCP_CODEX_USER_AGENT` and `CCP_KIMI_USER_AGENT` |++A malformed `config.json` is reported on stderr and ignored; defaults are used+in its place. Invalid types for individual keys are warned and skipped without+affecting other keys.### Files- `$XDG_STATE_HOME/claude-code-proxy/proxy.log` — JSON-lines log, rotated at 20MiB. Secrets (`authorization`, `access`, `refresh`, `id_token`,`ChatGPT-Account-Id`, …) are redacted before write.-- `~/.config/claude-code-proxy/codex/auth.json` — codex tokens (non-macOS; macOS- uses Keychain under service `claude-code-proxy.codex`).-- `~/.config/claude-code-proxy/kimi/auth.json` — kimi tokens (non-macOS; macOS- uses Keychain under service `claude-code-proxy.kimi`).-- `~/.config/claude-code-proxy/kimi/device_id` — persistent UUID bound into the- Kimi JWT at login. Reused for the lifetime of the install.+- `~/.config/claude-code-proxy/config.json` (macOS) or+ `${XDG_CONFIG_HOME:-$HOME/.config}/claude-code-proxy/config.json` — optional+ configuration file (see table above).+- `${XDG_CONFIG_HOME:-$HOME/.config}/claude-code-proxy/codex/auth.json` — codex+ tokens (non-macOS; macOS uses Keychain under service+ `claude-code-proxy.codex`). Pre-existing files at the legacy path+ `~/.config/claude-code-proxy/codex/auth.json` are read as a fallback so+ existing logins survive setting `XDG_CONFIG_HOME`.+- `${XDG_CONFIG_HOME:-$HOME/.config}/claude-code-proxy/kimi/auth.json` — kimi+ tokens (non-macOS; macOS uses Keychain under service+ `claude-code-proxy.kimi`). Same legacy-path fallback as above.+- `${XDG_CONFIG_HOME:-$HOME/.config}/claude-code-proxy/kimi/device_id` —+ persistent UUID bound into the Kimi JWT at login. Reused for the lifetime+ of the install.## Limitationsdiff --git a/src/cli.ts b/src/cli.tsindex 3705186..db10f85 100755--- a/src/cli.ts+++ b/src/cli.ts@@ -1,6 +1,7 @@#!/usr/bin/env bunimport { startServer } from "./server.ts"import { createLogger, logDir } from "./log.ts"+import { port as configPort } from "./config.ts"import {allProviders,allSupportedModels,@@ -24,7 +25,7 @@ async function main() {}if (!first || first === "serve") {- const port = Number(process.env.PORT ?? 18765)+ const port = configPort()startServer({ port })console.log(`Proxy listening on http://localhost:${port}`)console.log(`Logs: ${logDir()}/proxy.log`)@@ -89,7 +90,7 @@ function usageAndExit(): never {.map((m) => `${m.model} (${m.provider})`).join(", ")console.log(`Usage:- claude-code-proxy serve Run proxy (PORT env, default 18765)+ claude-code-proxy serve Run proxy (PORT env or config.json port, default 18765)Upstream is chosen per-request from ANTHROPIC_MODEL.claude-code-proxy <provider> auth login Browser OAuthclaude-code-proxy <provider> auth device Device-code OAuthdiff --git a/src/config.test.ts b/src/config.test.tsnew file mode 100644index 0000000..3ab96ba--- /dev/null+++ b/src/config.test.ts@@ -0,0 +1,176 @@+import { describe, expect, it, beforeEach, afterEach } from "bun:test"+import { mkdtempSync, writeFileSync, rmSync } from "node:fs"+import { tmpdir } from "node:os"+import { join } from "node:path"+import {+ loadConfig,+ port,+ codexOriginator,+ codexUserAgent,+ codexModel,+ codexEffort,+ kimiUserAgent,+ kimiOauthHost,+ kimiBaseUrl,+ logVerbose,+ logStderr,+} from "./config.ts"++let dir: string+let configPath: string++function setEnv(env: NodeJS.ProcessEnv) {+ loadConfig({ configPath, env, forceReload: true })+}++beforeEach(() => {+ dir = mkdtempSync(join(tmpdir(), "ccp-config-"))+ configPath = join(dir, "config.json")+})++afterEach(() => {+ rmSync(dir, { recursive: true, force: true })+ // Reset module-level cache to a clean process-env baseline so unrelated+ // tests that import config getters do not see leftover overrides.+ loadConfig({ forceReload: true })+})++describe("config defaults", () => {+ it("returns built-in defaults when no env and no file", () => {+ setEnv({})+ expect(port()).toBe(18765)+ expect(codexOriginator("default-orig")).toBe("default-orig")+ expect(codexUserAgent("default-ua")).toBe("default-ua")+ expect(codexModel()).toBeUndefined()+ expect(codexEffort()).toBeUndefined()+ 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")+ expect(logVerbose()).toBe(false)+ expect(logStderr()).toBe(false)+ })+})++describe("file overrides default", () => {+ it("port from config.json", () => {+ writeFileSync(configPath, JSON.stringify({ port: 11111 }))+ setEnv({})+ expect(port()).toBe(11111)+ })++ it("codex.userAgent from config.json", () => {+ writeFileSync(+ configPath,+ JSON.stringify({ codex: { userAgent: "ccp/file" } }),+ )+ setEnv({})+ expect(codexUserAgent("default")).toBe("ccp/file")+ })++ it("kimi.oauthHost from config.json", () => {+ writeFileSync(+ configPath,+ JSON.stringify({ kimi: { oauthHost: "https://auth.example.com" } }),+ )+ setEnv({})+ expect(kimiOauthHost()).toBe("https://auth.example.com")+ })++ it("log.verbose from config.json", () => {+ writeFileSync(configPath, JSON.stringify({ log: { verbose: true } }))+ setEnv({})+ expect(logVerbose()).toBe(true)+ })+})++describe("env overrides file", () => {+ it("PORT env wins over config port", () => {+ writeFileSync(configPath, JSON.stringify({ port: 11111 }))+ setEnv({ PORT: "22222" })+ expect(port()).toBe(22222)+ })++ it("CCP_CODEX_USER_AGENT env wins over config", () => {+ writeFileSync(+ configPath,+ JSON.stringify({ codex: { userAgent: "from-file" } }),+ )+ setEnv({ CCP_CODEX_USER_AGENT: "from-env" })+ expect(codexUserAgent("default")).toBe("from-env")+ })++ it("CCP_USER_AGENT env (generic fallback) is preferred over file", () => {+ writeFileSync(+ configPath,+ JSON.stringify({ codex: { userAgent: "from-file" } }),+ )+ setEnv({ CCP_USER_AGENT: "generic-env" })+ expect(codexUserAgent("default")).toBe("generic-env")+ expect(kimiUserAgent("default")).toBe("generic-env")+ })++ it("logStderr env-set forces true even when config sets false", () => {+ writeFileSync(configPath, JSON.stringify({ log: { stderr: false } }))+ setEnv({ CCP_LOG_STDERR: "1" })+ expect(logStderr()).toBe(true)+ })+})++describe("empty-string semantics", () => {+ it("empty CCP_CODEX_MODEL env falls through to file value", () => {+ writeFileSync(configPath, JSON.stringify({ codex: { model: "gpt-5.2" } }))+ setEnv({ CCP_CODEX_MODEL: "" })+ expect(codexModel()).toBe("gpt-5.2")+ })++ it("empty CCP_CODEX_MODEL env with no file value returns undefined", () => {+ setEnv({ CCP_CODEX_MODEL: "" })+ expect(codexModel()).toBeUndefined()+ })++ it("empty PORT env falls through to file value", () => {+ writeFileSync(configPath, JSON.stringify({ port: 33333 }))+ setEnv({ PORT: "" })+ expect(port()).toBe(33333)+ })+})++describe("empty env-string compatibility", () => {+ it("empty CCP_CODEX_USER_AGENT env is a valid value (legacy ?? semantics)", () => {+ setEnv({ CCP_CODEX_USER_AGENT: "" })+ expect(codexUserAgent("default-ua")).toBe("")+ })++ it("empty KIMI_OAUTH_HOST env is a valid value (legacy ?? semantics)", () => {+ setEnv({ KIMI_OAUTH_HOST: "" })+ expect(kimiOauthHost()).toBe("")+ })++ it("CCP_LOG_STDERR set to empty string still enables stderr (legacy !! semantics)", () => {+ setEnv({ CCP_LOG_STDERR: "" })+ expect(logStderr()).toBe(true)+ })+})++describe("malformed config", () => {+ it("returns defaults when JSON is invalid", () => {+ writeFileSync(configPath, "{not valid json")+ setEnv({})+ expect(port()).toBe(18765)+ })++ it("ignores wrong-typed values with a warning, keeps other valid ones", () => {+ writeFileSync(+ configPath,+ JSON.stringify({ port: "not-a-number", codex: { userAgent: "good" } }),+ )+ setEnv({})+ expect(port()).toBe(18765)+ expect(codexUserAgent("default")).toBe("good")+ })++ it("returns defaults when file is missing entirely", () => {+ setEnv({})+ expect(port()).toBe(18765)+ })+})diff --git a/src/config.ts b/src/config.tsnew file mode 100644index 0000000..03edea5--- /dev/null+++ b/src/config.ts@@ -0,0 +1,230 @@+import { readFileSync } from "node:fs"+import { join } from "node:path"+import { configDir } from "./paths.ts"++// Config precedence per setting:+// provider-specific env > generic-fallback env (where one exists) > config.json > default+//+// The config file is parsed once on first access and cached. Empty strings+// 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 interface FileConfig {+ port?: number+ codex?: {+ originator?: string+ userAgent?: string+ model?: string+ effort?: string+ }+ kimi?: {+ userAgent?: string+ oauthHost?: string+ baseUrl?: string+ }+ log?: {+ stderr?: boolean+ verbose?: boolean+ }+}++interface LoadedConfig {+ file: FileConfig+ env: NodeJS.ProcessEnv+}++interface LoadOptions {+ configPath?: string+ env?: NodeJS.ProcessEnv+ forceReload?: boolean+}++let cached: LoadedConfig | undefined++// Most env-var consumers historically used `??` semantics — empty string is+// a real value that wins. Only CCP_CODEX_MODEL and CCP_CODEX_EFFORT had+// explicit empty-string-as-unset handling in the legacy code, so only those+// getters use emptyOrUnset.+function emptyOrUnset(v: string | undefined): string | undefined {+ return v === undefined || v === "" ? undefined : v+}++function warnInvalid(key: string, expected: string, got: unknown): void {+ process.stderr.write(+ `claude-code-proxy: ignoring config.json key "${key}": expected ${expected}, got ${typeof got}\n`,+ )+}++function validate(raw: unknown): FileConfig {+ if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {}+ const r = raw as Record<string, unknown>+ const out: FileConfig = {}++ if (r.port !== undefined) {+ if (typeof r.port === "number" && Number.isFinite(r.port)) out.port = r.port+ else warnInvalid("port", "number", r.port)+ }++ const validateStringSection = <K extends "codex" | "kimi" | "log">(+ key: K,+ keys: ReadonlyArray<keyof NonNullable<FileConfig[K]>>,+ types: Record<string, "string" | "boolean">,+ ): NonNullable<FileConfig[K]> | undefined => {+ if (r[key] === undefined) return undefined+ const sec = r[key]+ if (!sec || typeof sec !== "object" || Array.isArray(sec)) {+ warnInvalid(key, "object", sec)+ return undefined+ }+ const acc: Record<string, unknown> = {}+ for (const k of keys) {+ const v = (sec as Record<string, unknown>)[k as string]+ if (v === undefined) continue+ const expected = types[k as string]+ if (expected && typeof v === expected) acc[k as string] = v+ else warnInvalid(`${key}.${String(k)}`, expected ?? "unknown", v)+ }+ return acc as NonNullable<FileConfig[K]>+ }++ const codex = validateStringSection("codex", ["originator", "userAgent", "model", "effort"], {+ originator: "string",+ userAgent: "string",+ model: "string",+ effort: "string",+ })+ if (codex) out.codex = codex++ const kimi = validateStringSection("kimi", ["userAgent", "oauthHost", "baseUrl"], {+ userAgent: "string",+ oauthHost: "string",+ baseUrl: "string",+ })+ if (kimi) out.kimi = kimi++ const log = validateStringSection("log", ["stderr", "verbose"], {+ stderr: "boolean",+ verbose: "boolean",+ })+ if (log) out.log = log++ return out+}++export function loadConfig(opts: LoadOptions = {}): LoadedConfig {+ if (cached && !opts.forceReload && !opts.configPath && !opts.env) {+ return cached+ }+ const env = opts.env ?? process.env+ const path = opts.configPath ?? join(configDir(), "config.json")+ let file: FileConfig = {}+ try {+ const raw = readFileSync(path, "utf8")+ try {+ file = validate(JSON.parse(raw))+ } catch (err) {+ process.stderr.write(+ `claude-code-proxy: failed to parse ${path} (${(err as Error).message}); using defaults\n`,+ )+ }+ } catch (err: unknown) {+ if ((err as NodeJS.ErrnoException).code !== "ENOENT") {+ process.stderr.write(+ `claude-code-proxy: failed to read ${path} (${(err as Error).message}); using defaults\n`,+ )+ }+ }+ const result: LoadedConfig = { file, env }+ // Always update the cache when forceReload is requested (lets tests+ // install a custom env+path under the same singleton other modules read).+ if (opts.forceReload || (!opts.configPath && !opts.env)) cached = result+ return result+}++export function getConfig(): LoadedConfig {+ return cached ?? loadConfig()+}++// Per-setting getters. Each encodes its precedence chain explicitly.++// Preserves legacy `Number(process.env.PORT ?? 18765)` semantics: an env-set+// PORT of empty string parsed to NaN under the old code (effectively broken),+// so we treat it as unset rather than returning NaN.+export function port(): number {+ const c = getConfig()+ const envPort = c.env.PORT+ if (envPort !== undefined && envPort !== "") {+ const n = Number(envPort)+ if (Number.isFinite(n)) return n+ }+ return c.file.port ?? 18765+}++export function codexOriginator(defaultValue: string): string {+ const c = getConfig()+ return (+ c.env.CCP_CODEX_ORIGINATOR ??+ c.env.CCP_ORIGINATOR ??+ c.file.codex?.originator ??+ defaultValue+ )+}++export function codexUserAgent(defaultValue: string): string {+ const c = getConfig()+ return (+ c.env.CCP_CODEX_USER_AGENT ??+ c.env.CCP_USER_AGENT ??+ c.file.codex?.userAgent ??+ defaultValue+ )+}++// Returns undefined when neither env nor file specifies a value. Empty+// string in env is intentionally treated as "unset" (preserves the+// long-standing CCP_CODEX_MODEL escape hatch).+export function codexModel(): string | undefined {+ const c = getConfig()+ return emptyOrUnset(c.env.CCP_CODEX_MODEL) ?? emptyOrUnset(c.file.codex?.model)+}++export function codexEffort(): string | undefined {+ const c = getConfig()+ return emptyOrUnset(c.env.CCP_CODEX_EFFORT) ?? emptyOrUnset(c.file.codex?.effort)+}++export function kimiUserAgent(defaultValue: string): string {+ const c = getConfig()+ return (+ c.env.CCP_KIMI_USER_AGENT ??+ c.env.CCP_USER_AGENT ??+ c.file.kimi?.userAgent ??+ defaultValue+ )+}++export function kimiOauthHost(): string {+ const c = getConfig()+ return c.env.KIMI_OAUTH_HOST ?? c.file.kimi?.oauthHost ?? "https://auth.kimi.com"+}++export function kimiBaseUrl(): string {+ const c = getConfig()+ return c.env.KIMI_BASE_URL ?? c.file.kimi?.baseUrl ?? "https://api.kimi.com/coding/v1"+}++// Additive: error/warn always go to stderr in log.ts; this getter only+// controls whether *all* levels are also mirrored to stderr. Matches the+// pre-existing `!!process.env.CCP_LOG_STDERR` semantics where any value+// (including the empty string) enables it.+export function logStderr(): boolean {+ const c = getConfig()+ if (c.env.CCP_LOG_STDERR !== undefined) return true+ return c.file.log?.stderr ?? false+}++export function logVerbose(): boolean {+ const c = getConfig()+ if (c.env.CCP_LOG_VERBOSE !== undefined) return true+ return c.file.log?.verbose ?? false+}diff --git a/src/log.ts b/src/log.tsindex 10f1d00..169ef20 100644--- a/src/log.ts+++ b/src/log.ts@@ -1,7 +1,8 @@import { mkdir, appendFile, stat, rename } from "node:fs/promises"import { createWriteStream, type WriteStream } from "node:fs"import { join } from "node:path"-import { homedir } from "node:os"+import { stateDir } from "./paths.ts"+import { logStderr, logVerbose } from "./config.ts"const MAX_LOG_BYTES = 20 * 1024 * 1024 // 20 MiBexport const REDACT_KEYS = new Set([@@ -17,11 +18,6 @@ export const REDACT_KEYS = new Set(["x-api-key",])-function stateDir(): string {- const base = process.env.XDG_STATE_HOME || join(homedir(), ".local", "state")- return join(base, "claude-code-proxy")-}-export function logDir(): string {return stateDir()}@@ -61,13 +57,11 @@ async function maybeRotate(): Promise<void> {return rotating}-const VERBOSE = !!process.env.CCP_LOG_VERBOSE-function redact(value: unknown, depth = 0): unknown {if (depth > 6) return "[depth-limit]"if (value == null) return valueif (typeof value === "string") {- if (!VERBOSE && value.length > 4000) return value.slice(0, 4000) + `…[${value.length - 4000} more]`+ if (!logVerbose() && value.length > 4000) return value.slice(0, 4000) + `…[${value.length - 4000} more]`return value}if (typeof value !== "object") return value@@ -100,7 +94,7 @@ async function write(level: Level, service: string, msg: string, fields?: Record} catch {// swallow; also print to stderr for visibility}- if (level === "error" || level === "warn" || process.env.CCP_LOG_STDERR) {+ if (level === "error" || level === "warn" || logStderr()) {process.stderr.write(line + "\n")}}diff --git a/src/paths.test.ts b/src/paths.test.tsnew file mode 100644index 0000000..ca3c55a--- /dev/null+++ b/src/paths.test.ts@@ -0,0 +1,42 @@+import { describe, expect, it } from "bun:test"+import { resolveConfigDir, resolveStateDir } from "./paths.ts"++describe("resolveConfigDir", () => {+ it("uses ~/.config on darwin even when XDG_CONFIG_HOME is set", () => {+ expect(+ resolveConfigDir({ platform: "darwin", env: { XDG_CONFIG_HOME: "/x" }, home: "/home/u" }),+ ).toBe("/home/u/.config/claude-code-proxy")+ })++ it("honors XDG_CONFIG_HOME on linux", () => {+ expect(+ resolveConfigDir({ platform: "linux", env: { XDG_CONFIG_HOME: "/x" }, home: "/home/u" }),+ ).toBe("/x/claude-code-proxy")+ })++ it("falls back to $HOME/.config on linux without XDG_CONFIG_HOME", () => {+ expect(resolveConfigDir({ platform: "linux", env: {}, home: "/home/u" })).toBe(+ "/home/u/.config/claude-code-proxy",+ )+ })+})++describe("resolveStateDir", () => {+ it("honors XDG_STATE_HOME on darwin (preserves pre-existing log.ts behavior)", () => {+ expect(+ resolveStateDir({ platform: "darwin", env: { XDG_STATE_HOME: "/x" }, home: "/home/u" }),+ ).toBe("/x/claude-code-proxy")+ })++ it("falls back to $HOME/.local/state on darwin without XDG_STATE_HOME", () => {+ expect(resolveStateDir({ platform: "darwin", env: {}, home: "/home/u" })).toBe(+ "/home/u/.local/state/claude-code-proxy",+ )+ })++ it("honors XDG_STATE_HOME on linux", () => {+ expect(+ resolveStateDir({ platform: "linux", env: { XDG_STATE_HOME: "/x" }, home: "/home/u" }),+ ).toBe("/x/claude-code-proxy")+ })+})diff --git a/src/paths.ts b/src/paths.tsnew file mode 100644index 0000000..3d40164--- /dev/null+++ b/src/paths.ts@@ -0,0 +1,46 @@+import { homedir } from "node:os"+import { join } from "node:path"++export interface DirResolverEnv {+ platform: NodeJS.Platform+ env: NodeJS.ProcessEnv+ home: string+}++function defaults(): DirResolverEnv {+ return { platform: process.platform, env: process.env, home: homedir() }+}++// macOS deliberately uses ~/.config/<app> rather than honoring XDG_CONFIG_HOME+// (which would redirect to ~/Library/Application Support). This matches where+// auth tokens have always been stored on macOS.+export function resolveConfigDir(deps: DirResolverEnv): string {+ if (deps.platform === "darwin") {+ return join(deps.home, ".config", "claude-code-proxy")+ }+ const base = deps.env.XDG_CONFIG_HOME || join(deps.home, ".config")+ return join(base, "claude-code-proxy")+}++// XDG_STATE_HOME is honored on every platform (including macOS) — that's the+// pre-config.json behavior of log.ts and is documented in the README.+export function resolveStateDir(deps: DirResolverEnv): string {+ const base = deps.env.XDG_STATE_HOME || join(deps.home, ".local", "state")+ return join(base, "claude-code-proxy")+}++// Legacy (pre-config.json) auth/device-id path. Always ~/.config regardless+// of XDG_CONFIG_HOME — this is the directory token stores hardcoded before+// configDir() existed. Used as a read-only fallback so existing logins keep+// working after upgrade.+export function legacyConfigDir(deps: DirResolverEnv = defaults()): string {+ return join(deps.home, ".config", "claude-code-proxy")+}++export function configDir(): string {+ return resolveConfigDir(defaults())+}++export function stateDir(): string {+ return resolveStateDir(defaults())+}diff --git a/src/providers/codex/auth/token-store.ts b/src/providers/codex/auth/token-store.tsindex 889e15e..542c7b4 100644--- a/src/providers/codex/auth/token-store.ts+++ b/src/providers/codex/auth/token-store.ts@@ -1,7 +1,7 @@import { mkdir, readFile, writeFile, unlink, rename } from "node:fs/promises"import { dirname, join } from "node:path"-import { homedir } from "node:os"import { keychainGet, keychainSet, keychainDelete } from "../../../keychain.ts"+import { configDir, legacyConfigDir } from "../../../paths.ts"export interface StoredAuth {access: string@@ -10,8 +10,12 @@ export interface StoredAuth {accountId?: string}-const DIR = join(homedir(), ".config", "claude-code-proxy", "codex")-const FILE = join(DIR, "auth.json")+function file(): string {+ return join(configDir(), "codex", "auth.json")+}+function legacyFile(): string {+ return join(legacyConfigDir(), "codex", "auth.json")+}const KEYCHAIN_SERVICE = "claude-code-proxy.codex"const KEYCHAIN_ACCOUNT = "auth"@@ -22,8 +26,17 @@ export async function loadAuth(): Promise<StoredAuth | undefined> {return JSON.parse(raw) as StoredAuth}+ const primary = file()+ try {+ const raw = await readFile(primary, "utf8")+ return JSON.parse(raw) as StoredAuth+ } catch (err: any) {+ if (err?.code !== "ENOENT") throw err+ }+ const legacy = legacyFile()+ if (legacy === primary) return undefinedtry {- const raw = await readFile(FILE, "utf8")+ const raw = await readFile(legacy, "utf8")return JSON.parse(raw) as StoredAuth} catch (err: any) {if (err?.code === "ENOENT") return undefined@@ -37,10 +50,11 @@ export async function saveAuth(auth: StoredAuth): Promise<void> {return}- await mkdir(dirname(FILE), { recursive: true, mode: 0o700 })- const tmp = `${FILE}.${process.pid}.${Date.now()}.tmp`+ const path = file()+ await mkdir(dirname(path), { recursive: true, mode: 0o700 })+ const tmp = `${path}.${process.pid}.${Date.now()}.tmp`await writeFile(tmp, JSON.stringify(auth, null, 2), { encoding: "utf8", mode: 0o600 })- await rename(tmp, FILE)+ await rename(tmp, path)}export async function clearAuth(): Promise<void> {@@ -49,13 +63,15 @@ export async function clearAuth(): Promise<void> {return}- try {- await unlink(FILE)- } catch (err: any) {- if (err?.code !== "ENOENT") throw err+ for (const path of [file(), legacyFile()]) {+ try {+ await unlink(path)+ } catch (err: any) {+ if (err?.code !== "ENOENT") throw err+ }}}export function authPath(): string {- return process.platform === "darwin" ? "macOS Keychain" : FILE+ return process.platform === "darwin" ? "macOS Keychain" : file()}diff --git a/src/providers/codex/client.ts b/src/providers/codex/client.tsindex 0f2cee0..73f2f03 100644--- a/src/providers/codex/client.ts+++ b/src/providers/codex/client.ts@@ -1,4 +1,5 @@import { CODEX_API_ENDPOINT, ORIGINATOR as ORIGINATOR_DEFAULT } from "./auth/constants.ts"+import { codexOriginator, codexUserAgent } from "../../config.ts"declare const BUILD_VERSION: string | undefinedconst PROXY_VERSION = typeof BUILD_VERSION === "string" ? BUILD_VERSION : "dev"import { forceRefresh, getAuth } from "./auth/manager.ts"@@ -80,10 +81,10 @@ async function doFetch("Content-Type": "application/json",accept: "text/event-stream",authorization: `Bearer ${accessToken}`,- originator: process.env.CCP_CODEX_ORIGINATOR ?? process.env.CCP_ORIGINATOR ?? ORIGINATOR_DEFAULT,+ originator: codexOriginator(ORIGINATOR_DEFAULT),"openai-beta": "responses=experimental",})- const userAgent = process.env.CCP_CODEX_USER_AGENT ?? process.env.CCP_USER_AGENT ?? `claude-code-proxy/${PROXY_VERSION}`+ const userAgent = codexUserAgent(`claude-code-proxy/${PROXY_VERSION}`)if (userAgent) headers.set("User-Agent", userAgent)if (accountId) headers.set("ChatGPT-Account-Id", accountId)if (sessionId) {diff --git a/src/providers/codex/index.ts b/src/providers/codex/index.tsindex 4d12659..b41ff79 100644--- a/src/providers/codex/index.ts+++ b/src/providers/codex/index.ts@@ -15,8 +15,7 @@ import { runBrowserLogin } from "./auth/pkce.ts"import { runDeviceLogin } from "./auth/device.ts"import { persistInitialTokens } from "./auth/manager.ts"import { loadAuth, authPath, clearAuth } from "./auth/token-store.ts"--const VERBOSE = !!process.env.CCP_LOG_VERBOSE+import { logVerbose } from "../../config.ts"interface SessionCountSnapshot {reqId: string@@ -101,7 +100,7 @@ async function handleCountTokens(body: AnthropicRequest, ctx: RequestContext): Ptokens,}}- if (VERBOSE) {+ if (logVerbose()) {log.info("compaction telemetry", {phase: "count_tokens",model: body.model,@@ -140,7 +139,7 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): PromhasContextManagement: contextManagement !== undefined,hasJsonSchemaFormat: body.output_config?.format?.type === "json_schema",})- if (VERBOSE) log.debug("anthropic request body", { body })+ if (logVerbose()) log.debug("anthropic request body", { body })const resolvedModel = resolveModel(body.model)@@ -158,8 +157,8 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom}const translated = translateRequest({ ...body, model: resolvedModel }, { sessionId: ctx.sessionId })- const localInputTokens = VERBOSE ? countTokens(body) : undefined- const translatedInputTokens = VERBOSE ? countTranslatedTokens(translated) : undefined+ const localInputTokens = logVerbose() ? countTokens(body) : undefined+ const translatedInputTokens = logVerbose() ? countTranslatedTokens(translated) : undefinedif (state) {state.lastMessage = {reqId: ctx.reqId,@@ -180,8 +179,8 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): PromhasContextManagement: contextManagement !== undefined,promptCacheKey: translated.prompt_cache_key,})- if (VERBOSE) log.debug("translated request body", { body: translated })- if (VERBOSE) {+ if (logVerbose()) log.debug("translated request body", { body: translated })+ if (logVerbose()) {log.info("compaction telemetry", {phase: "translated_request",requestedModel: body.model,@@ -234,7 +233,7 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): PrommessageId,model: body.model,log: ctx.childLogger("codex.stream"),- onFinish: VERBOSE+ onFinish: logVerbose()? (finish) => {const mappedUsage = finish.usage ? mapUsageToAnthropic(finish.usage) : undefinedlog.info("compaction telemetry", {@@ -277,7 +276,7 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Promtry {const result = await accumulateResponse(upstream.body, { messageId, model: body.model, log: ctx.childLogger("codex.accumulate") })- if (VERBOSE) {+ if (logVerbose()) {const { serverModel, serverReasoningIncluded } = upstreamHeaderSnapshot(upstream.headers)log.info("compaction telemetry", {phase: "upstream_finish",diff --git a/src/providers/codex/translate/model-allowlist.test.ts b/src/providers/codex/translate/model-allowlist.test.tsnew file mode 100644index 0000000..c16fbfc--- /dev/null+++ b/src/providers/codex/translate/model-allowlist.test.ts@@ -0,0 +1,56 @@+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 } from "./model-allowlist.ts"+import { loadConfig } from "../../../config.ts"++afterEach(() => {+ loadConfig({ forceReload: true })+})++describe("resolveModel", () => {+ it("returns alias when no override is set", () => {+ loadConfig({ env: {}, forceReload: true })+ expect(resolveModel("sonnet")).toBe("gpt-5.4")+ })++ it("env CCP_CODEX_MODEL takes precedence", () => {+ loadConfig({ env: { CCP_CODEX_MODEL: "gpt-5.2" }, forceReload: true })+ expect(resolveModel("sonnet")).toBe("gpt-5.2")+ })++ it("config.json codex.model overrides aliases", () => {+ const dir = mkdtempSync(join(tmpdir(), "ccp-model-"))+ const path = join(dir, "config.json")+ writeFileSync(path, JSON.stringify({ codex: { model: "gpt-5.5" } }))+ try {+ loadConfig({ configPath: path, env: {}, forceReload: true })+ expect(resolveModel("sonnet")).toBe("gpt-5.5")+ } finally {+ rmSync(dir, { recursive: true, force: true })+ }+ })++ it("empty CCP_CODEX_MODEL env is treated as unset (no regression)", () => {+ const dir = mkdtempSync(join(tmpdir(), "ccp-model-"))+ const path = join(dir, "config.json")+ writeFileSync(path, JSON.stringify({ codex: { model: "gpt-5.5" } }))+ try {+ loadConfig({+ configPath: path,+ env: { CCP_CODEX_MODEL: "" },+ forceReload: true,+ })+ // Empty env should fall through to file value+ expect(resolveModel("sonnet")).toBe("gpt-5.5")+ } finally {+ rmSync(dir, { recursive: true, force: true })+ }+ })++ it("empty env and no file value falls through to alias", () => {+ loadConfig({ env: { CCP_CODEX_MODEL: "" }, forceReload: true })+ expect(resolveModel("sonnet")).toBe("gpt-5.4")+ })+})diff --git a/src/providers/codex/translate/model-allowlist.ts b/src/providers/codex/translate/model-allowlist.tsindex bc9636a..213b5f1 100644--- a/src/providers/codex/translate/model-allowlist.ts+++ b/src/providers/codex/translate/model-allowlist.ts@@ -1,3 +1,5 @@+import { codexModel } from "../../../config.ts"+export const ALLOWED_MODELS = new Set(["gpt-5.2","gpt-5.3-codex",@@ -17,15 +19,12 @@ export const MODEL_ALIASES = new Map<string, string>([])export function resolveModel(model: string): string {- // The CCP_CODEX_MODEL environment variable overrides the model so that- // regardless of whatever model is requested by the harness, the provided- // model is always used.- if (- process.env.CCP_CODEX_MODEL !== undefined &&- process.env.CCP_CODEX_MODEL !== ""- ) {- return process.env.CCP_CODEX_MODEL- }+ // CCP_CODEX_MODEL (env) or codex.model (config.json) overrides the model+ // so that regardless of whatever model is requested by the harness, the+ // provided model is always used. Empty values fall through to alias+ // resolution.+ const override = codexModel()+ if (override !== undefined) return overridereturn MODEL_ALIASES.get(model) ?? model}diff --git a/src/providers/codex/translate/reducer.ts b/src/providers/codex/translate/reducer.tsindex 81c246d..e151531 100644--- a/src/providers/codex/translate/reducer.ts+++ b/src/providers/codex/translate/reducer.ts@@ -1,7 +1,6 @@import { parseSseStream } from "../../../sse.ts"import type { Logger } from "../../../log.ts"--const VERBOSE = !!process.env.CCP_LOG_VERBOSE+import { logVerbose } from "../../../config.ts"export class UpstreamStreamError extends Error {constructor(@@ -98,7 +97,7 @@ export async function* reduceUpstream(}const t: string = p.type || evt.event || ""- if (VERBOSE) log.debug("upstream event", { type: t, output_index: p.output_index, item_id: p.item_id })+ if (logVerbose()) log.debug("upstream event", { type: t, output_index: p.output_index, item_id: p.item_id })if (t === "codex.rate_limits") {if (p.rate_limits?.limit_reached) {diff --git a/src/providers/codex/translate/request.ts b/src/providers/codex/translate/request.tsindex a7ae079..74c4f5b 100644--- a/src/providers/codex/translate/request.ts+++ b/src/providers/codex/translate/request.ts@@ -6,6 +6,7 @@ import type {AnthropicTextBlock,AnthropicTool,} from "../../../anthropic/schema.ts"+import { codexEffort } from "../../../config.ts"export type Effort = "none" | "low" | "medium" | "high" | "xhigh"@@ -93,8 +94,8 @@ function toCodexEffort(}function resolveEffort(effort?: Effort): Effort | undefined {- const override = process.env.CCP_CODEX_EFFORT- if (override === undefined || override === "") {+ const override = codexEffort()+ if (override === undefined) {return effort}if (!VALID_EFFORTS.has(override as Effort)) {diff --git a/src/providers/kimi/auth/constants.ts b/src/providers/kimi/auth/constants.tsindex 32d5d3d..8c2553f 100644--- a/src/providers/kimi/auth/constants.ts+++ b/src/providers/kimi/auth/constants.ts@@ -1,6 +1,14 @@+import { kimiBaseUrl, kimiOauthHost } from "../../../config.ts"+export const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098"-export const OAUTH_HOST = process.env.KIMI_OAUTH_HOST ?? "https://auth.kimi.com"-export const API_BASE_URL = process.env.KIMI_BASE_URL ?? "https://api.kimi.com/coding/v1"+// Read lazily so config.json values apply. KIMI_OAUTH_HOST / KIMI_BASE_URL+// env vars still work (env wins over file in the getter).+export function oauthHost(): string {+ return kimiOauthHost()+}+export function apiBaseUrl(): string {+ return kimiBaseUrl()+}// Masquerade as kimi-cli so the server accepts us. Bumping this in lockstep// with kimi-cli releases may become necessary.export const KIMI_CLI_VERSION = "1.37.0"diff --git a/src/providers/kimi/auth/device-id.ts b/src/providers/kimi/auth/device-id.tsindex f42ac7d..570e9d9 100644--- a/src/providers/kimi/auth/device-id.ts+++ b/src/providers/kimi/auth/device-id.ts@@ -1,22 +1,30 @@import { mkdir, readFile, writeFile, chmod } from "node:fs/promises"import { dirname, join } from "node:path"-import { homedir } from "node:os"+import { configDir, legacyConfigDir } from "../../../paths.ts"-const PATH = join(homedir(), ".config", "claude-code-proxy", "kimi", "device_id")+function path(): string {+ return join(configDir(), "kimi", "device_id")+}+function legacyPath(): string {+ return join(legacyConfigDir(), "kimi", "device_id")+}export async function getDeviceId(): Promise<string> {- try {- const raw = await readFile(PATH, "utf8")- const trimmed = raw.trim()- if (trimmed) return trimmed- } catch (err: any) {- if (err?.code !== "ENOENT") throw err+ for (const candidate of [path(), legacyPath()]) {+ try {+ const raw = await readFile(candidate, "utf8")+ const trimmed = raw.trim()+ if (trimmed) return trimmed+ } catch (err: any) {+ if (err?.code !== "ENOENT") throw err+ }}const id = crypto.randomUUID().replace(/-/g, "")- await mkdir(dirname(PATH), { recursive: true })- await writeFile(PATH, id, { encoding: "utf8", mode: 0o600 })+ const target = path()+ await mkdir(dirname(target), { recursive: true })+ await writeFile(target, id, { encoding: "utf8", mode: 0o600 })try {- await chmod(PATH, 0o600)+ await chmod(target, 0o600)} catch {}return id}diff --git a/src/providers/kimi/auth/headers.ts b/src/providers/kimi/auth/headers.tsindex 1439a51..21ecb53 100644--- a/src/providers/kimi/auth/headers.ts+++ b/src/providers/kimi/auth/headers.ts@@ -1,6 +1,7 @@import { hostname, release, arch, platform } from "node:os"import { KIMI_CLI_VERSION } from "./constants.ts"import { getDeviceId } from "./device-id.ts"+import { kimiUserAgent } from "../../../config.ts"function deviceModel(): string {const a = arch()@@ -25,6 +26,6 @@ export async function commonHeaders(): Promise<Record<string, string>> {"X-Msh-Device-Model": asciiOnly(deviceModel()),"X-Msh-Os-Version": asciiOnly(release()),"X-Msh-Device-Id": deviceId,- "User-Agent": process.env.CCP_KIMI_USER_AGENT ?? process.env.CCP_USER_AGENT ?? `KimiCLI/${KIMI_CLI_VERSION}`,+ "User-Agent": kimiUserAgent(`KimiCLI/${KIMI_CLI_VERSION}`),}}diff --git a/src/providers/kimi/auth/login.ts b/src/providers/kimi/auth/login.tsindex 48a8901..43c018e 100644--- a/src/providers/kimi/auth/login.ts+++ b/src/providers/kimi/auth/login.ts@@ -1,4 +1,4 @@-import { CLIENT_ID, OAUTH_HOST } from "./constants.ts"+import { CLIENT_ID, oauthHost } from "./constants.ts"import { commonHeaders } from "./headers.ts"export interface TokenResponse {@@ -24,7 +24,7 @@ const POLL_SAFETY_MARGIN_MS = 500export async function runDeviceLogin(): Promise<TokenResponse> {const headers = await commonHeaders()- const initResp = await fetch(`${OAUTH_HOST}/api/oauth/device_authorization`, {+ const initResp = await fetch(`${oauthHost()}/api/oauth/device_authorization`, {method: "POST",headers: { ...headers, "Content-Type": "application/x-www-form-urlencoded" },body: new URLSearchParams({ client_id: CLIENT_ID }).toString(),@@ -39,7 +39,7 @@ export async function runDeviceLogin(): Promise<TokenResponse> {console.log(`Code: ${auth.user_code}\n`)while (true) {- const resp = await fetch(`${OAUTH_HOST}/api/oauth/token`, {+ const resp = await fetch(`${oauthHost()}/api/oauth/token`, {method: "POST",headers: { ...headers, "Content-Type": "application/x-www-form-urlencoded" },body: new URLSearchParams({diff --git a/src/providers/kimi/auth/manager.ts b/src/providers/kimi/auth/manager.tsindex 2dfbbe6..dff90e4 100644--- a/src/providers/kimi/auth/manager.ts+++ b/src/providers/kimi/auth/manager.ts@@ -1,4 +1,4 @@-import { CLIENT_ID, OAUTH_HOST, REFRESH_MARGIN_MS } from "./constants.ts"+import { CLIENT_ID, oauthHost, REFRESH_MARGIN_MS } from "./constants.ts"import { commonHeaders } from "./headers.ts"import { extractUserId } from "./jwt.ts"import type { TokenResponse } from "./login.ts"@@ -92,7 +92,7 @@ async function refreshNow(current: StoredAuth): Promise<StoredAuth> {for (let attempt = 0; attempt < MAX_REFRESH_ATTEMPTS; attempt++) {let resp: Responsetry {- resp = await fetch(`${OAUTH_HOST}/api/oauth/token`, {+ resp = await fetch(`${oauthHost()}/api/oauth/token`, {method: "POST",headers: { ...headers, "Content-Type": "application/x-www-form-urlencoded" },body: new URLSearchParams({diff --git a/src/providers/kimi/auth/token-store.ts b/src/providers/kimi/auth/token-store.tsindex 0e75bf6..6bae7d3 100644--- a/src/providers/kimi/auth/token-store.ts+++ b/src/providers/kimi/auth/token-store.ts@@ -1,7 +1,7 @@import { mkdir, readFile, writeFile, unlink, rename } from "node:fs/promises"import { dirname, join } from "node:path"-import { homedir } from "node:os"import { keychainGet, keychainSet, keychainDelete } from "../../../keychain.ts"+import { configDir, legacyConfigDir } from "../../../paths.ts"export interface StoredAuth {access: string@@ -11,8 +11,12 @@ export interface StoredAuth {userId?: string}-const DIR = join(homedir(), ".config", "claude-code-proxy", "kimi")-const FILE = join(DIR, "auth.json")+function file(): string {+ return join(configDir(), "kimi", "auth.json")+}+function legacyFile(): string {+ return join(legacyConfigDir(), "kimi", "auth.json")+}const KEYCHAIN_SERVICE = "claude-code-proxy.kimi"const KEYCHAIN_ACCOUNT = "auth"@@ -23,8 +27,17 @@ export async function loadAuth(): Promise<StoredAuth | undefined> {return JSON.parse(raw) as StoredAuth}+ const primary = file()+ try {+ const raw = await readFile(primary, "utf8")+ return JSON.parse(raw) as StoredAuth+ } catch (err: any) {+ if (err?.code !== "ENOENT") throw err+ }+ const legacy = legacyFile()+ if (legacy === primary) return undefinedtry {- const raw = await readFile(FILE, "utf8")+ const raw = await readFile(legacy, "utf8")return JSON.parse(raw) as StoredAuth} catch (err: any) {if (err?.code === "ENOENT") return undefined@@ -38,10 +51,11 @@ export async function saveAuth(auth: StoredAuth): Promise<void> {return}- await mkdir(dirname(FILE), { recursive: true, mode: 0o700 })- const tmp = `${FILE}.${process.pid}.${Date.now()}.tmp`+ const path = file()+ await mkdir(dirname(path), { recursive: true, mode: 0o700 })+ const tmp = `${path}.${process.pid}.${Date.now()}.tmp`await writeFile(tmp, JSON.stringify(auth, null, 2), { encoding: "utf8", mode: 0o600 })- await rename(tmp, FILE)+ await rename(tmp, path)}export async function clearAuth(): Promise<void> {@@ -50,13 +64,15 @@ export async function clearAuth(): Promise<void> {return}- try {- await unlink(FILE)- } catch (err: any) {- if (err?.code !== "ENOENT") throw err+ for (const path of [file(), legacyFile()]) {+ try {+ await unlink(path)+ } catch (err: any) {+ if (err?.code !== "ENOENT") throw err+ }}}export function authPath(): string {- return process.platform === "darwin" ? "macOS Keychain" : FILE+ return process.platform === "darwin" ? "macOS Keychain" : file()}diff --git a/src/providers/kimi/client.ts b/src/providers/kimi/client.tsindex 07d27b7..ca1ff0a 100644--- a/src/providers/kimi/client.ts+++ b/src/providers/kimi/client.ts@@ -1,4 +1,4 @@-import { API_BASE_URL } from "./auth/constants.ts"+import { apiBaseUrl } from "./auth/constants.ts"import { commonHeaders } from "./auth/headers.ts"import { forceRefresh, getAuth, KimiAuthUnauthorizedError } from "./auth/manager.ts"import type { Logger } from "../../log.ts"@@ -100,14 +100,14 @@ async function doFetch(const bodyJson = JSON.stringify(body)log.debug("posting to kimi", {- url: `${API_BASE_URL}/chat/completions`,+ url: `${apiBaseUrl()}/chat/completions`,model: body.model,messageCount: body.messages.length,toolCount: body.tools?.length ?? 0,requestBodyBytes: new TextEncoder().encode(bodyJson).length,})- return fetch(`${API_BASE_URL}/chat/completions`, {+ return fetch(`${apiBaseUrl()}/chat/completions`, {method: "POST",headers,body: bodyJson,diff --git a/src/providers/kimi/index.ts b/src/providers/kimi/index.tsindex 1112ee1..56ddbce 100644--- a/src/providers/kimi/index.ts+++ b/src/providers/kimi/index.ts@@ -14,8 +14,7 @@ import { KimiError, postKimi } from "./client.ts"import { runDeviceLogin } from "./auth/login.ts"import { persistInitialTokens } from "./auth/manager.ts"import { loadAuth, clearAuth, authPath } from "./auth/token-store.ts"--const VERBOSE = !!process.env.CCP_LOG_VERBOSE+import { logVerbose } from "../../config.ts"function jsonError(status: number, type: string, message: string): Response {return new Response(JSON.stringify({ type: "error", error: { type, message } }), {@@ -49,7 +48,7 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Promstream: wantStream,requestedMaxTokens: body.max_tokens,})- if (VERBOSE) log.debug("anthropic request body", { body })+ if (logVerbose()) log.debug("anthropic request body", { body })const resolvedModel = resolveModel(body.model)try {@@ -83,7 +82,7 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Promthinking: translated.thinking?.type,maxTokens: translated.max_tokens,})- if (VERBOSE) log.debug("translated request body", { body: translated })+ if (logVerbose()) log.debug("translated request body", { body: translated })let upstreamtry {diff --git a/src/providers/kimi/translate/reducer.ts b/src/providers/kimi/translate/reducer.tsindex 3d6eec8..841e2f9 100644--- a/src/providers/kimi/translate/reducer.ts+++ b/src/providers/kimi/translate/reducer.ts@@ -1,8 +1,6 @@import { parseSseStream } from "../../../sse.ts"import type { Logger } from "../../../log.ts"-const VERBOSE = !!process.env.CCP_LOG_VERBOSE-export class UpstreamStreamError extends Error {constructor(public kind: "rate_limit" | "failed",