Skip to content

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

Rust

rename to claude-code-proxy and restructure for multi-provider support

Raine Virtac5de572e4d79
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index dd503b5..adb780f 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -8,7 +8,7 @@ permissions:
contents: write
env:
- BIN_NAME: claude-codex-proxy
+ BIN_NAME: claude-code-proxy
jobs:
build:
@@ -80,7 +80,7 @@ jobs:
merge-multiple: true
- uses: actions/checkout@v5
with:
- repository: raine/homebrew-claude-codex-proxy
+ repository: raine/homebrew-claude-code-proxy
token: ${{ secrets.RELEASE_TOKEN }}
path: tap
- name: Generate formula and push to tap
@@ -88,54 +88,54 @@ jobs:
VERSION: ${{ github.ref_name }}
run: |
VERSION="${VERSION#v}"
- SHA_ARM=$(awk '{print $1}' claude-codex-proxy-darwin-arm64.sha256)
- SHA_INTEL=$(awk '{print $1}' claude-codex-proxy-darwin-amd64.sha256)
- SHA_LINUX_AMD=$(awk '{print $1}' claude-codex-proxy-linux-amd64.sha256)
- SHA_LINUX_ARM=$(awk '{print $1}' claude-codex-proxy-linux-arm64.sha256)
+ SHA_ARM=$(awk '{print $1}' claude-code-proxy-darwin-arm64.sha256)
+ SHA_INTEL=$(awk '{print $1}' claude-code-proxy-darwin-amd64.sha256)
+ SHA_LINUX_AMD=$(awk '{print $1}' claude-code-proxy-linux-amd64.sha256)
+ SHA_LINUX_ARM=$(awk '{print $1}' claude-code-proxy-linux-arm64.sha256)
mkdir -p tap/Formula
- cat > tap/Formula/claude-codex-proxy.rb << EOF
- class ClaudeCodexProxy < Formula
+ cat > tap/Formula/claude-code-proxy.rb << EOF
+ class ClaudeCodeProxy < Formula
desc "Local proxy: Claude Code to ChatGPT subscription via Codex Responses API"
- homepage "https://github.com/raine/claude-codex-proxy"
+ homepage "https://github.com/raine/claude-code-proxy"
version "${VERSION}"
license "MIT"
on_macos do
if Hardware::CPU.arm?
- url "https://github.com/raine/claude-codex-proxy/releases/download/v${VERSION}/claude-codex-proxy-darwin-arm64.tar.gz"
+ url "https://github.com/raine/claude-code-proxy/releases/download/v${VERSION}/claude-code-proxy-darwin-arm64.tar.gz"
sha256 "${SHA_ARM}"
else
- url "https://github.com/raine/claude-codex-proxy/releases/download/v${VERSION}/claude-codex-proxy-darwin-amd64.tar.gz"
+ url "https://github.com/raine/claude-code-proxy/releases/download/v${VERSION}/claude-code-proxy-darwin-amd64.tar.gz"
sha256 "${SHA_INTEL}"
end
end
on_linux do
if Hardware::CPU.arm?
- url "https://github.com/raine/claude-codex-proxy/releases/download/v${VERSION}/claude-codex-proxy-linux-arm64.tar.gz"
+ url "https://github.com/raine/claude-code-proxy/releases/download/v${VERSION}/claude-code-proxy-linux-arm64.tar.gz"
sha256 "${SHA_LINUX_ARM}"
else
- url "https://github.com/raine/claude-codex-proxy/releases/download/v${VERSION}/claude-codex-proxy-linux-amd64.tar.gz"
+ url "https://github.com/raine/claude-code-proxy/releases/download/v${VERSION}/claude-code-proxy-linux-amd64.tar.gz"
sha256 "${SHA_LINUX_AMD}"
end
end
def install
- bin.install "claude-codex-proxy"
+ bin.install "claude-code-proxy"
end
test do
- assert_match version.to_s, shell_output("\#{bin}/claude-codex-proxy --version")
+ assert_match version.to_s, shell_output("\#{bin}/claude-code-proxy --version")
end
end
EOF
- sed -i 's/^ //' tap/Formula/claude-codex-proxy.rb
+ sed -i 's/^ //' tap/Formula/claude-code-proxy.rb
cd tap
git config user.name "github-actions[bot]"
git config user.email "github-actions[bot]@users.noreply.github.com"
- git add Formula/claude-codex-proxy.rb
- git commit -m "claude-codex-proxy ${VERSION}"
+ git add Formula/claude-code-proxy.rb
+ git commit -m "claude-code-proxy ${VERSION}"
git pull --rebase
git push
diff --git a/README.md b/README.md
index 4ff0388..62ea70f 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
-# claude-codex-proxy
+# claude-code-proxy
-`claude-codex-proxy` lets you use
+`claude-code-proxy` lets you use
[Claude Code](https://www.anthropic.com/claude-code) with your ChatGPT Plus or
Pro subscription.
-<img src="meta/claude-code-screenshot.webp" alt="Claude Code running through claude-codex-proxy" width="630" />
+<img src="meta/claude-code-screenshot.webp" alt="Claude Code running through claude-code-proxy" width="630" />
[Quick start](#quick-start) · [How it works](#how-it-works) ·
[Configuration](#configuration) · [Limitations](#limitations)
@@ -27,30 +27,30 @@ ended up forking it and applying some patches, but would much rather not do it.
**Homebrew** (macOS and Linux):
```sh
-brew install raine/claude-codex-proxy/claude-codex-proxy
+brew install raine/claude-code-proxy/claude-code-proxy
```
**Install script** (macOS and Linux):
```sh
-curl -fsSL https://raw.githubusercontent.com/raine/claude-codex-proxy/main/scripts/install.sh | bash
+curl -fsSL https://raw.githubusercontent.com/raine/claude-code-proxy/main/scripts/install.sh | bash
```
**Manual:** download a prebuilt binary for your platform from the
-[releases page](https://github.com/raine/claude-codex-proxy/releases).
+[releases page](https://github.com/raine/claude-code-proxy/releases).
### 2. Authenticate with ChatGPT
Open a browser (PKCE flow):
```sh
-claude-codex-proxy auth login
+claude-code-proxy codex auth login
```
Or, on a headless machine (device code flow):
```sh
-claude-codex-proxy auth device
+claude-code-proxy codex auth device
```
Either command prints a URL. Sign in with your **ChatGPT Plus/Pro account**. On
@@ -60,17 +60,17 @@ locally for reuse by the proxy.
Verify it stuck:
```sh
-claude-codex-proxy auth status
+claude-code-proxy codex auth status
```
### 3. Start the proxy
```sh
-claude-codex-proxy serve
+claude-code-proxy serve
```
Defaults to `http://127.0.0.1:18765` (loopback only). Override with
-`PORT=11435 claude-codex-proxy serve`.
+`PORT=11435 claude-code-proxy serve`.
### 4. Point Claude Code at it
@@ -178,7 +178,7 @@ and the proxy will send `gpt-5.4-mini` upstream.
sequenceDiagram
autonumber
participant CC as Claude Code
- participant P as claude-codex-proxy
+ participant P as claude-code-proxy
participant AUTH as auth.openai.com
participant CGX as chatgpt.com/<br/>backend-api/codex
@@ -192,7 +192,7 @@ sequenceDiagram
end
P->>P: translate request<br/>• strip max_tokens / temperature / cache_control<br/>• system blocks → top-level "instructions"<br/>• tool_use.id = call_id (identity)<br/>• prompt_cache_key = session id
- P->>CGX: POST /responses<br/>Bearer + ChatGPT-Account-Id + originator=claude-codex-proxy
+ P->>CGX: POST /responses<br/>Bearer + ChatGPT-Account-Id + originator=claude-code-proxy
CGX-->>P: Responses API SSE<br/>(output_item.*, output_text.delta, function_call_arguments.*, codex.rate_limits, response.completed)
P->>P: reducer: typed events<br/>(text/tool start/delta/stop, finish)
P-->>CC: Anthropic SSE<br/>(message_start, content_block_*, message_delta, message_stop)
@@ -200,35 +200,37 @@ sequenceDiagram
## Commands
-| Command | Description |
-| ----------------------------- | ----------------------------------------- |
-| [`serve`](#serve) | Start the proxy on `PORT` (default 18765) |
-| [`auth login`](#auth-login) | Browser OAuth (PKCE) |
-| [`auth device`](#auth-device) | Device-code OAuth (headless) |
-| [`auth status`](#auth-status) | Show account ID and token expiry |
-| [`auth logout`](#auth-logout) | Delete stored auth credentials |
+| Command | Description |
+| ----------------------------------- | ----------------------------------------- |
+| [`serve`](#serve) | Start the proxy on `PORT` (default 18765) |
+| [`codex auth login`](#auth-login) | Browser OAuth (PKCE) |
+| [`codex auth device`](#auth-device) | Device-code OAuth (headless) |
+| [`codex auth status`](#auth-status) | Show account ID and token expiry |
+| [`codex auth logout`](#auth-logout) | Delete stored auth credentials |
---
### `serve`
Starts the HTTP proxy and blocks. Binds to `127.0.0.1` only. Logs to
-`$XDG_STATE_HOME/claude-codex-proxy/proxy.log` (rotated at 20 MiB). Set
+`$XDG_STATE_HOME/claude-code-proxy/proxy.log` (rotated at 20 MiB). Set
`CCP_LOG_STDERR=1` to mirror log lines to stderr while running.
```sh
-claude-codex-proxy serve
-PORT=11435 claude-codex-proxy serve
-CCP_LOG_STDERR=1 claude-codex-proxy serve
+claude-code-proxy serve
+PORT=11435 claude-code-proxy serve
+CCP_LOG_STDERR=1 claude-code-proxy serve
```
Prints the exact `ANTHROPIC_BASE_URL` / `ANTHROPIC_MODEL` env vars to export on
-startup. Refuses to start traffic until `auth login` (or `auth device`) has
-stored a token.
+startup. Refuses to start traffic until `codex auth login` (or `codex auth
+device`) has stored a token.
+
+Selects a provider with `CCP_PROVIDER` (default `codex`).
---
-### `auth login`
+### `codex auth login`
Runs the PKCE browser flow against `auth.openai.com` using the Codex CLI's
client ID. Prints a URL, opens a local callback listener on port 1455, waits for
@@ -237,7 +239,7 @@ in Keychain on macOS or locally on other platforms. The process exits
automatically once the tokens are saved.
```sh
-claude-codex-proxy auth login
+claude-code-proxy codex auth login
```
Sign in with your **ChatGPT Plus/Pro account**, not an OpenAI API account. The
@@ -246,27 +248,27 @@ token file includes the extracted `chatgpt_account_id` so the proxy can set the
---
-### `auth device`
+### `codex auth device`
Same OAuth flow, but for headless machines. Prints a short user code and a URL;
you enter the code from any browser on any other device, and the CLI polls
`auth.openai.com` until you authorize, then stores the token.
```sh
-claude-codex-proxy auth device
+claude-code-proxy codex auth device
```
Useful over SSH, inside a container, or on any host that can't open a browser.
---
-### `auth status`
+### `codex auth status`
Shows whether credentials are stored, the account ID, and how long until the
access token expires. Non-zero exit if no auth is present.
```sh
-claude-codex-proxy auth status
+claude-code-proxy codex auth status
```
Example output:
@@ -283,16 +285,16 @@ calls.
---
-### `auth logout`
+### `codex auth logout`
Removes stored auth credentials. On macOS this deletes the Keychain entry. No
server call is needed; the refresh token just becomes dead.
```sh
-claude-codex-proxy auth logout
+claude-code-proxy codex auth logout
```
-Run `auth login` again to re-authenticate.
+Run `codex auth login` again to re-authenticate.
---
@@ -313,13 +315,14 @@ Settings are environment variables on the proxy process, not a config file.
| Variable | Default | Purpose |
| ----------------- | ---------------- | -------------------------------------------------- |
| `PORT` | `18765` | Proxy listen port |
+| `CCP_PROVIDER` | `codex` | Upstream provider (`codex`) |
| `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 |
### Files
-- `$XDG_STATE_HOME/claude-codex-proxy/proxy.log`: JSON-lines log, rotated at 20
+- `$XDG_STATE_HOME/claude-code-proxy/proxy.log`: JSON-lines log, rotated at 20
MiB. Secrets (`authorization`, `access`, `refresh`, `id_token`,
`ChatGPT-Account-Id`, …) are redacted before write.
@@ -348,7 +351,7 @@ Settings are environment variables on the proxy process, not a config file.
```sh
bunx tsc --noEmit # typecheck
bun src/cli.ts serve # run locally
-tail -f ~/.local/state/claude-codex-proxy/proxy.log | jq .
+tail -f ~/.local/state/claude-code-proxy/proxy.log | jq .
```
**Install a compiled dev build globally:** compile the current working tree to a
@@ -356,7 +359,7 @@ binary and place it on your `PATH` without linking:
```sh
mkdir -p ~/.local/bin
-bun build ./src/cli.ts --compile --outfile ~/.local/bin/claude-codex-proxy
+bun build ./src/cli.ts --compile --outfile ~/.local/bin/claude-code-proxy
```
## Related projects
diff --git a/package.json b/package.json
index 5506814..fe5f8fd 100644
--- a/package.json
+++ b/package.json
@@ -1,10 +1,10 @@
{
- "name": "claude-codex-proxy",
+ "name": "claude-code-proxy",
"version": "0.0.2",
"license": "MIT",
"type": "module",
"bin": {
- "claude-codex-proxy": "./src/cli.ts"
+ "claude-code-proxy": "./src/cli.ts"
},
"scripts": {
"start": "bun run src/cli.ts serve",
diff --git a/scripts/install.sh b/scripts/install.sh
index c9e731f..2aede83 100755
--- a/scripts/install.sh
+++ b/scripts/install.sh
@@ -1,21 +1,21 @@
#!/usr/bin/env bash
#
-# claude-codex-proxy installation script
-# Usage: curl -fsSL https://raw.githubusercontent.com/raine/claude-codex-proxy/main/scripts/install.sh | bash
+# claude-code-proxy installation script
+# Usage: curl -fsSL https://raw.githubusercontent.com/raine/claude-code-proxy/main/scripts/install.sh | bash
#
# Environment variables:
-# CLAUDE_CODEX_PROXY_VERSION - Pin a specific version (e.g., v0.1.0)
-# CLAUDE_CODEX_PROXY_INSTALL_DIR - Override install directory (default: /usr/local/bin or ~/.local/bin)
+# CLAUDE_CODE_PROXY_VERSION - Pin a specific version (e.g., v0.1.0)
+# CLAUDE_CODE_PROXY_INSTALL_DIR - Override install directory (default: /usr/local/bin or ~/.local/bin)
#
# Examples:
-# CLAUDE_CODEX_PROXY_VERSION=v0.1.0 bash install.sh
-# CLAUDE_CODEX_PROXY_INSTALL_DIR=/opt/bin bash install.sh
+# CLAUDE_CODE_PROXY_VERSION=v0.1.0 bash install.sh
+# CLAUDE_CODE_PROXY_INSTALL_DIR=/opt/bin bash install.sh
#
set -e
-BIN_NAME="claude-codex-proxy"
-REPO="raine/claude-codex-proxy"
+BIN_NAME="claude-code-proxy"
+REPO="raine/claude-code-proxy"
RED='\033[0;31m'
GREEN='\033[0;32m'
@@ -70,7 +70,7 @@ install_from_release() {
tmp_dir=$(mktemp -d)
trap 'rm -rf "$tmp_dir"' EXIT
- local version="${CLAUDE_CODEX_PROXY_VERSION:-}"
+ local version="${CLAUDE_CODE_PROXY_VERSION:-}"
if [ -z "$version" ]; then
log_info "Fetching latest release..."
@@ -93,7 +93,7 @@ install_from_release() {
echo ""
echo "This might be due to network issues or GitHub API rate limits."
echo "You can specify a version manually:"
- echo " CLAUDE_CODEX_PROXY_VERSION=v0.1.0 bash install.sh"
+ echo " CLAUDE_CODE_PROXY_VERSION=v0.1.0 bash install.sh"
echo ""
exit 1
fi
@@ -166,7 +166,7 @@ install_from_release() {
exit 1
fi
- local install_dir="${CLAUDE_CODEX_PROXY_INSTALL_DIR:-}"
+ local install_dir="${CLAUDE_CODE_PROXY_INSTALL_DIR:-}"
if [ -z "$install_dir" ]; then
if [[ -w /usr/local/bin ]]; then
install_dir="/usr/local/bin"
@@ -243,7 +243,7 @@ verify_installation() {
echo ""
echo "Get started:"
- echo " ${BIN_NAME} auth login # authenticate with your ChatGPT account"
+ echo " ${BIN_NAME} codex auth login # authenticate with your ChatGPT account"
echo " ${BIN_NAME} serve # start the proxy"
echo ""
echo "Documentation: https://github.com/${REPO}"
diff --git a/src/cli.ts b/src/cli.ts
index 1e0775f..6b62788 100755
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -1,10 +1,8 @@
#!/usr/bin/env bun
-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"
import { startServer } from "./server.ts"
import { createLogger, logDir } from "./log.ts"
+import { getProvider, listProviders } from "./providers/registry.ts"
+import type { CliHandlers } from "./providers/types.ts"
declare const BUILD_VERSION: string | undefined
const VERSION = typeof BUILD_VERSION === "string" ? BUILD_VERSION : "dev"
@@ -12,74 +10,89 @@ const VERSION = typeof BUILD_VERSION === "string" ? BUILD_VERSION : "dev"
const log = createLogger("cli")
async function main() {
- const [, , cmd, sub] = process.argv
- if (cmd === "--version" || cmd === "-v" || cmd === "version") {
- console.log(`claude-codex-proxy ${VERSION}`)
+ const args = process.argv.slice(2)
+ const [first, ...rest] = args
+
+ if (first === "--version" || first === "-v" || first === "version") {
+ console.log(`claude-code-proxy ${VERSION}`)
return
}
- switch (cmd) {
- case "serve":
- case undefined: {
- const port = Number(process.env.PORT ?? 18765)
- 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(` export ANTHROPIC_BASE_URL="http://localhost:${port}"`)
- console.log(` export ANTHROPIC_AUTH_TOKEN="anything"`)
+
+ 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})`)
+ console.log(`Logs: ${logDir()}/proxy.log`)
+ console.log()
+ console.log("Configure Claude Code:")
+ 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"`)
- console.log(` export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1"`)
- return
}
- case "auth": {
- if (sub === "login") {
- const tokens = await runBrowserLogin()
- const saved = await persistInitialTokens(tokens)
- console.log(`Auth saved in ${authPath()}`)
- if (saved.accountId) console.log(`Account: ${saved.accountId}`)
- process.exit(0)
- }
- if (sub === "device") {
- const tokens = await runDeviceLogin()
- const saved = await persistInitialTokens(tokens)
- console.log(`Auth saved in ${authPath()}`)
- if (saved.accountId) console.log(`Account: ${saved.accountId}`)
- process.exit(0)
- }
- if (sub === "status") {
- const auth = await loadAuth()
- if (!auth) {
- console.log("Not authenticated")
- process.exit(1)
- }
- const ms = auth.expires - Date.now()
- console.log(`Account: ${auth.accountId ?? "(none)"}`)
- console.log(`Expires: ${new Date(auth.expires).toISOString()} (in ${Math.floor(ms / 1000)}s)`)
- console.log(`Storage: ${authPath()}`)
- return
+ console.log(` export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1"`)
+ return
+ }
+
+ if (listProviders().includes(first)) {
+ const provider = getProvider(first)
+ await runProviderCommand(provider.name, provider.cli, rest)
+ return
+ }
+
+ usageAndExit()
+}
+
+async function runProviderCommand(name: string, cli: CliHandlers, args: string[]): Promise<void> {
+ const [group, sub] = args
+ if (group !== "auth") usageAndExit()
+
+ switch (sub) {
+ case "login":
+ if (!cli.login) {
+ console.error(`${name}: browser login not supported`)
+ process.exit(2)
}
- if (sub === "logout") {
- await clearAuth()
- console.log("Logged out")
- return
+ await cli.login()
+ process.exit(0)
+ case "device":
+ if (!cli.device) {
+ console.error(`${name}: device login not supported`)
+ process.exit(2)
}
- usageAndExit()
+ await cli.device()
+ process.exit(0)
+ case "status":
+ await cli.status()
+ return
+ case "logout":
+ await cli.logout()
return
- }
default:
usageAndExit()
}
}
+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("|")
console.log(`Usage:
- claude-codex-proxy serve Run proxy (PORT env, default 18765)
- claude-codex-proxy auth login Browser OAuth (PKCE)
- claude-codex-proxy auth device Device-code OAuth
- claude-codex-proxy auth status Show current auth
- claude-codex-proxy auth logout Clear stored auth
- claude-codex-proxy --version Show version
+ 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
+
+Providers: ${providers}
+Default provider: ${process.env.CCP_PROVIDER ?? "codex"} (override with CCP_PROVIDER or --provider)
`)
process.exit(2)
}
diff --git a/src/log.ts b/src/log.ts
index 2510bfd..8da9a8e 100644
--- a/src/log.ts
+++ b/src/log.ts
@@ -21,7 +21,7 @@ const REDACT_KEYS = new Set([
function stateDir(): string {
const base = process.env.XDG_STATE_HOME || join(homedir(), ".local", "state")
- return join(base, "claude-codex-proxy")
+ return join(base, "claude-code-proxy")
}
export function logDir(): string {
diff --git a/src/auth/constants.ts b/src/providers/codex/auth/constants.ts
similarity index 88%
rename from src/auth/constants.ts
rename to src/providers/codex/auth/constants.ts
index ed8557f..eadfda2 100644
--- a/src/auth/constants.ts
+++ b/src/providers/codex/auth/constants.ts
@@ -3,5 +3,5 @@ export const ISSUER = "https://auth.openai.com"
export const CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses"
export const OAUTH_PORT = 1455
export const OAUTH_REDIRECT_URI = `http://localhost:${OAUTH_PORT}/auth/callback`
-export const ORIGINATOR = "claude-codex-proxy"
+export const ORIGINATOR = "claude-code-proxy"
export const REFRESH_MARGIN_MS = 5 * 60 * 1000
diff --git a/src/auth/device.ts b/src/providers/codex/auth/device.ts
similarity index 100%
rename from src/auth/device.ts
rename to src/providers/codex/auth/device.ts
diff --git a/src/auth/jwt.ts b/src/providers/codex/auth/jwt.ts
similarity index 100%
rename from src/auth/jwt.ts
rename to src/providers/codex/auth/jwt.ts
diff --git a/src/auth/manager.ts b/src/providers/codex/auth/manager.ts
similarity index 98%
rename from src/auth/manager.ts
rename to src/providers/codex/auth/manager.ts
index 2ed98df..f157a67 100644
--- a/src/auth/manager.ts
+++ b/src/providers/codex/auth/manager.ts
@@ -8,7 +8,7 @@ let inflight: Promise<StoredAuth> | undefined
export async function getAuth(): Promise<StoredAuth> {
if (!cached) {
const stored = await loadAuth()
- if (!stored) throw new Error("Not authenticated. Run: claude-codex-proxy auth login")
+ if (!stored) throw new Error("Not authenticated. Run: claude-code-proxy codex auth login")
cached = stored
}
if (cached.expires - REFRESH_MARGIN_MS > Date.now()) {
diff --git a/src/auth/pkce.ts b/src/providers/codex/auth/pkce.ts
similarity index 100%
rename from src/auth/pkce.ts
rename to src/providers/codex/auth/pkce.ts
diff --git a/src/auth/token-store.ts b/src/providers/codex/auth/token-store.ts
similarity index 95%
rename from src/auth/token-store.ts
rename to src/providers/codex/auth/token-store.ts
index b3b6ed7..ae85d48 100644
--- a/src/auth/token-store.ts
+++ b/src/providers/codex/auth/token-store.ts
@@ -9,9 +9,9 @@ export interface StoredAuth {
accountId?: string
}
-const DIR = join(homedir(), ".config", "claude-codex-proxy")
+const DIR = join(homedir(), ".config", "claude-code-proxy", "codex")
const FILE = join(DIR, "auth.json")
-const KEYCHAIN_SERVICE = "claude-codex-proxy"
+const KEYCHAIN_SERVICE = "claude-code-proxy.codex"
const KEYCHAIN_ACCOUNT = "auth"
export async function loadAuth(): Promise<StoredAuth | undefined> {
diff --git a/src/codex/client.ts b/src/providers/codex/client.ts
similarity index 92%
rename from src/codex/client.ts
rename to src/providers/codex/client.ts
index 9046a67..b02d6b7 100644
--- a/src/codex/client.ts
+++ b/src/providers/codex/client.ts
@@ -1,7 +1,7 @@
-import { CODEX_API_ENDPOINT, ORIGINATOR } from "../auth/constants.ts"
-import { forceRefresh, getAuth } from "../auth/manager.ts"
-import { createLogger } from "../log.ts"
-import type { ResponsesRequest } from "../translate/request.ts"
+import { CODEX_API_ENDPOINT, ORIGINATOR } from "./auth/constants.ts"
+import { forceRefresh, getAuth } from "./auth/manager.ts"
+import { createLogger } from "../../log.ts"
+import type { ResponsesRequest } from "./translate/request.ts"
const log = createLogger("codex.client")
diff --git a/src/count-tokens.ts b/src/providers/codex/count-tokens.ts
similarity index 97%
rename from src/count-tokens.ts
rename to src/providers/codex/count-tokens.ts
index db0c5d0..6920069 100644
--- a/src/count-tokens.ts
+++ b/src/providers/codex/count-tokens.ts
@@ -1,5 +1,5 @@
import { encode } from "gpt-tokenizer/model/gpt-4o"
-import type { AnthropicRequest } from "./anthropic/schema.ts"
+import type { AnthropicRequest } from "../../anthropic/schema.ts"
import type { ResponsesRequest } from "./translate/request.ts"
import { buildInstructions, normalizeContent, toolResultToString } from "./translate/request.ts"
diff --git a/src/providers/codex/index.ts b/src/providers/codex/index.ts
new file mode 100644
index 0000000..3a16720
--- /dev/null
+++ b/src/providers/codex/index.ts
@@ -0,0 +1,385 @@
+import type { AnthropicRequest } from "../../anthropic/schema.ts"
+import type { Provider, RequestContext, CliHandlers } from "../types.ts"
+import { createLogger } from "../../log.ts"
+import {
+ assertAllowedModel,
+ ModelNotAllowedError,
+ resolveModel,
+} from "./translate/model-allowlist.ts"
+import { translateRequest } from "./translate/request.ts"
+import { translateStream } from "./translate/stream.ts"
+import { accumulateResponse, UpstreamStreamError } from "./translate/accumulate.ts"
+import { mapUsageToAnthropic } from "./translate/reducer.ts"
+import { CodexError, postCodex } from "./client.ts"
+import { countTokens, countTranslatedTokens } from "./count-tokens.ts"
+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 log = createLogger("provider.codex")
+const VERBOSE = !!process.env.CCP_LOG_VERBOSE
+
+interface SessionCountSnapshot {
+ reqId: string
+ model: string
+ messageCount: number
+ toolCount: number
+ tokens: number
+}
+
+interface SessionMessageSnapshot {
+ reqId: string
+ model: string
+ messageCount: number
+ toolCount: number
+ localInputTokens?: number
+ translatedInputTokens?: number
+}
+
+interface SessionTimelineState {
+ lastCount?: SessionCountSnapshot
+ lastMessage?: SessionMessageSnapshot
+}
+
+const sessionTimeline = new Map<string, SessionTimelineState>()
+
+function sessionState(sessionId?: string): SessionTimelineState | undefined {
+ if (!sessionId) return undefined
+ let state = sessionTimeline.get(sessionId)
+ if (!state) {
+ state = {}
+ sessionTimeline.set(sessionId, state)
+ }
+ return state
+}
+
+function usageWindowTokens(usage: {
+ input_tokens: number
+ output_tokens: number
+ cache_creation_input_tokens: number
+ cache_read_input_tokens: number
+}): number {
+ return (
+ usage.input_tokens +
+ usage.output_tokens +
+ usage.cache_creation_input_tokens +
+ usage.cache_read_input_tokens
+ )
+}
+
+function upstreamHeaderSnapshot(headers: Headers): {
+ serverModel?: string
+ serverReasoningIncluded: boolean
+} {
+ return {
+ serverModel: headers.get("OpenAI-Model") || undefined,
+ serverReasoningIncluded: headers.has("X-Reasoning-Included"),
+ }
+}
+
+function jsonError(status: number, type: string, message: string): Response {
+ return new Response(JSON.stringify({ type: "error", error: { type, message } }), {
+ status,
+ headers: { "content-type": "application/json" },
+ })
+}
+
+async function handleCountTokens(body: AnthropicRequest, ctx: RequestContext): Promise<Response> {
+ const resolvedModel = resolveModel(body.model)
+ const translated = translateRequest({ ...body, model: resolvedModel })
+ const tokens = countTranslatedTokens(translated)
+ const messageCount = body.messages?.length ?? 0
+ const toolCount = body.tools?.length ?? 0
+ const state = sessionState(ctx.sessionId)
+ log.debug("count_tokens", { reqId: ctx.reqId, tokens })
+ if (state) {
+ state.lastCount = {
+ reqId: ctx.reqId,
+ model: body.model,
+ messageCount,
+ toolCount,
+ tokens,
+ }
+ }
+ if (VERBOSE) {
+ log.info("compaction telemetry", {
+ reqId: ctx.reqId,
+ phase: "count_tokens",
+ sessionId: ctx.sessionId,
+ sessionSeq: ctx.sessionSeq,
+ model: body.model,
+ resolvedModel,
+ tokens,
+ messageCount,
+ toolCount,
+ previousMessageReqId: state?.lastMessage?.reqId,
+ previousMessageModel: state?.lastMessage?.model,
+ previousMessageCount: state?.lastMessage?.messageCount,
+ previousMessageToolCount: state?.lastMessage?.toolCount,
+ previousMessageLocalInputTokens: state?.lastMessage?.localInputTokens,
+ previousMessageTranslatedInputTokens: state?.lastMessage?.translatedInputTokens,
+ })
+ }
+ return new Response(JSON.stringify({ input_tokens: tokens }), {
+ headers: { "content-type": "application/json" },
+ })
+}
+
+async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Promise<Response> {
+ const messageId = `msg_${crypto.randomUUID().replace(/-/g, "")}`
+ const wantStream = body.stream !== false
+ const messageCount = body.messages?.length ?? 0
+ const toolCount = body.tools?.length ?? 0
+ const contextManagement = body.context_management
+ const state = sessionState(ctx.sessionId)
+
+ log.debug("anthropic request", {
+ reqId: ctx.reqId,
+ model: body.model,
+ messageCount,
+ toolCount,
+ stream: wantStream,
+ sessionId: ctx.sessionId,
+ requestedMaxTokens: body.max_tokens,
+ hasContextManagement: contextManagement !== undefined,
+ hasJsonSchemaFormat: body.output_config?.format?.type === "json_schema",
+ })
+ if (VERBOSE) log.debug("anthropic request body", { reqId: ctx.reqId, body })
+
+ const resolvedModel = resolveModel(body.model)
+
+ try {
+ assertAllowedModel(resolvedModel)
+ } catch (err) {
+ if (err instanceof ModelNotAllowedError) {
+ return jsonError(
+ 400,
+ "invalid_request_error",
+ `Model "${body.model}" resolves to unsupported model "${err.model}"`,
+ )
+ }
+ throw err
+ }
+
+ const translated = translateRequest({ ...body, model: resolvedModel }, { sessionId: ctx.sessionId })
+ const localInputTokens = VERBOSE ? countTokens(body) : undefined
+ const translatedInputTokens = VERBOSE ? countTranslatedTokens(translated) : undefined
+ if (state) {
+ state.lastMessage = {
+ reqId: ctx.reqId,
+ model: body.model,
+ messageCount,
+ toolCount,
+ localInputTokens,
+ translatedInputTokens,
+ }
+ }
+ log.debug("translated request", {
+ reqId: ctx.reqId,
+ requestedModel: body.model,
+ resolvedModel,
+ inputItems: translated.input.length,
+ tools: translated.tools?.length ?? 0,
+ hasInstructions: !!translated.instructions,
+ requestedMaxTokens: body.max_tokens,
+ hasContextManagement: contextManagement !== undefined,
+ promptCacheKey: translated.prompt_cache_key,
+ })
+ if (VERBOSE) log.debug("translated request body", { reqId: ctx.reqId, body: translated })
+ if (VERBOSE) {
+ log.info("compaction telemetry", {
+ reqId: ctx.reqId,
+ phase: "translated_request",
+ sessionId: ctx.sessionId,
+ sessionSeq: ctx.sessionSeq,
+ requestedModel: body.model,
+ resolvedModel,
+ messageCount,
+ toolCount,
+ localInputTokens,
+ translatedInputTokens,
+ inputItems: translated.input.length,
+ translatedToolCount: translated.tools?.length ?? 0,
+ hasInstructions: !!translated.instructions,
+ requestedMaxTokens: body.max_tokens,
+ hasContextManagement: contextManagement !== undefined,
+ contextManagement,
+ previousCountReqId: state?.lastCount?.reqId,
+ previousCountModel: state?.lastCount?.model,
+ previousCountTokens: state?.lastCount?.tokens,
+ previousCountMessageCount: state?.lastCount?.messageCount,
+ previousCountToolCount: state?.lastCount?.toolCount,
+ })
+ }
+
+ let upstream
+ try {
+ upstream = await postCodex(translated, { sessionId: ctx.sessionId, signal: ctx.signal })
+ } catch (err) {
+ if (err instanceof CodexError) {
+ log.warn("codex error", { reqId: ctx.reqId, status: err.status, detail: err.detail })
+ if (err.status === 429) {
+ const headers: Record<string, string> = { "content-type": "application/json" }
+ if (err.meta?.retryAfter) headers["retry-after"] = err.meta.retryAfter
+ return new Response(
+ JSON.stringify({
+ type: "error",
+ error: { type: "rate_limit_error", message: err.detail || err.message },
+ }),
+ { status: 429, headers },
+ )
+ }
+ const type =
+ err.status === 401 || err.status === 403 ? "authentication_error" : "api_error"
+ return jsonError(err.status, type, err.detail || err.message)
+ }
+ throw err
+ }
+
+ if (wantStream) {
+ const { serverModel, serverReasoningIncluded } = upstreamHeaderSnapshot(upstream.headers)
+ const stream = translateStream(upstream.body, {
+ messageId,
+ model: body.model,
+ reqId: ctx.reqId,
+ sessionId: ctx.sessionId,
+ onFinish: VERBOSE
+ ? (finish) => {
+ const mappedUsage = finish.usage ? mapUsageToAnthropic(finish.usage) : undefined
+ log.info("compaction telemetry", {
+ reqId: ctx.reqId,
+ phase: "upstream_finish",
+ mode: "stream",
+ sessionId: ctx.sessionId,
+ sessionSeq: ctx.sessionSeq,
+ requestedModel: body.model,
+ resolvedModel,
+ serverModel,
+ serverReasoningIncluded,
+ messageCount,
+ toolCount,
+ localInputTokens,
+ translatedInputTokens,
+ requestedMaxTokens: body.max_tokens,
+ hasContextManagement: contextManagement !== undefined,
+ contextManagement,
+ upstreamInputTokens: finish.usage?.input_tokens ?? 0,
+ upstreamOutputTokens: finish.usage?.output_tokens ?? 0,
+ upstreamCachedInputTokens: finish.usage?.input_tokens_details?.cached_tokens ?? 0,
+ upstreamReasoningTokens:
+ finish.usage?.output_tokens_details?.reasoning_tokens ?? 0,
+ mappedInputTokens: mappedUsage?.input_tokens ?? 0,
+ mappedOutputTokens: mappedUsage?.output_tokens ?? 0,
+ mappedCachedInputTokens: mappedUsage?.cache_read_input_tokens ?? 0,
+ mappedContextWindowTokens: mappedUsage ? usageWindowTokens(mappedUsage) : 0,
+ stopReason: finish.stopReason,
+ })
+ }
+ : undefined,
+ })
+ return new Response(stream, {
+ status: 200,
+ headers: {
+ "content-type": "text/event-stream",
+ "cache-control": "no-cache",
+ connection: "keep-alive",
+ },
+ })
+ }
+
+ try {
+ const result = await accumulateResponse(upstream.body, { messageId, model: body.model })
+ if (VERBOSE) {
+ const { serverModel, serverReasoningIncluded } = upstreamHeaderSnapshot(upstream.headers)
+ log.info("compaction telemetry", {
+ reqId: ctx.reqId,
+ phase: "upstream_finish",
+ mode: "non_stream",
+ sessionId: ctx.sessionId,
+ sessionSeq: ctx.sessionSeq,
+ requestedModel: body.model,
+ resolvedModel,
+ serverModel,
+ serverReasoningIncluded,
+ messageCount,
+ toolCount,
+ localInputTokens,
+ translatedInputTokens,
+ requestedMaxTokens: body.max_tokens,
+ hasContextManagement: contextManagement !== undefined,
+ contextManagement,
+ upstreamInputTokens: result.rawUsage?.input_tokens ?? 0,
+ upstreamOutputTokens: result.rawUsage?.output_tokens ?? 0,
+ upstreamCachedInputTokens: result.rawUsage?.input_tokens_details?.cached_tokens ?? 0,
+ upstreamReasoningTokens: result.rawUsage?.output_tokens_details?.reasoning_tokens ?? 0,
+ mappedInputTokens: result.response.usage.input_tokens,
+ mappedOutputTokens: result.response.usage.output_tokens,
+ mappedCachedInputTokens: result.response.usage.cache_read_input_tokens,
+ mappedContextWindowTokens: usageWindowTokens(result.response.usage),
+ stopReason: result.response.stop_reason,
+ })
+ }
+ return new Response(JSON.stringify(result.response), {
+ headers: { "content-type": "application/json" },
+ })
+ } catch (err) {
+ if (err instanceof UpstreamStreamError) {
+ log.warn("upstream stream error (non-streaming)", {
+ reqId: ctx.reqId,
+ kind: err.kind,
+ message: err.message,
+ })
+ if (err.kind === "rate_limit") {
+ const headers: Record<string, string> = { "content-type": "application/json" }
+ if (err.retryAfterSeconds) headers["retry-after"] = String(err.retryAfterSeconds)
+ return new Response(
+ JSON.stringify({
+ type: "error",
+ error: { type: "rate_limit_error", message: err.message },
+ }),
+ { status: 429, headers },
+ )
+ }
+ return jsonError(502, "api_error", err.message)
+ }
+ throw err
+ }
+}
+
+const cli: CliHandlers = {
+ async login() {
+ const tokens = await runBrowserLogin()
+ const saved = await persistInitialTokens(tokens)
+ console.log(`Auth saved in ${authPath()}`)
+ if (saved.accountId) console.log(`Account: ${saved.accountId}`)
+ },
+ async device() {
+ const tokens = await runDeviceLogin()
+ const saved = await persistInitialTokens(tokens)
+ console.log(`Auth saved in ${authPath()}`)
+ if (saved.accountId) console.log(`Account: ${saved.accountId}`)
+ },
+ async status() {
+ const auth = await loadAuth()
+ if (!auth) {
+ console.log("Not authenticated")
+ process.exit(1)
+ }
+ const ms = auth.expires - Date.now()
+ console.log(`Account: ${auth.accountId ?? "(none)"}`)
+ console.log(`Expires: ${new Date(auth.expires).toISOString()} (in ${Math.floor(ms / 1000)}s)`)
+ console.log(`Storage: ${authPath()}`)
+ },
+ async logout() {
+ await clearAuth()
+ console.log("Logged out")
+ },
+}
+
+export const codexProvider: Provider = {
+ name: "codex",
+ handleMessages,
+ handleCountTokens,
+ cli,
+}
diff --git a/src/translate/accumulate.ts b/src/providers/codex/translate/accumulate.ts
similarity index 100%
rename from src/translate/accumulate.ts
rename to src/providers/codex/translate/accumulate.ts
diff --git a/src/translate/model-allowlist.ts b/src/providers/codex/translate/model-allowlist.ts
similarity index 100%
rename from src/translate/model-allowlist.ts
rename to src/providers/codex/translate/model-allowlist.ts
diff --git a/src/translate/reducer.ts b/src/providers/codex/translate/reducer.ts
similarity index 98%
rename from src/translate/reducer.ts
rename to src/providers/codex/translate/reducer.ts
index 071b47c..34ce0dd 100644
--- a/src/translate/reducer.ts
+++ b/src/providers/codex/translate/reducer.ts
@@ -1,5 +1,5 @@
-import { parseSseStream } from "./sse.ts"
-import { createLogger } from "../log.ts"
+import { parseSseStream } from "../../../sse.ts"
+import { createLogger } from "../../../log.ts"
const log = createLogger("translate.reducer")
const VERBOSE = !!process.env.CCP_LOG_VERBOSE
diff --git a/src/translate/request.test.ts b/src/providers/codex/translate/request.test.ts
similarity index 96%
rename from src/translate/request.test.ts
rename to src/providers/codex/translate/request.test.ts
index 43af7af..7362234 100644
--- a/src/translate/request.test.ts
+++ b/src/providers/codex/translate/request.test.ts
@@ -1,5 +1,5 @@
import { describe, expect, it } from "bun:test"
-import type { AnthropicRequest } from "../anthropic/schema.ts"
+import type { AnthropicRequest } from "../../../anthropic/schema.ts"
import { translateRequest } from "./request.ts"
const baseRequest: AnthropicRequest = {
diff --git a/src/translate/request.ts b/src/providers/codex/translate/request.ts
similarity index 99%
rename from src/translate/request.ts
rename to src/providers/codex/translate/request.ts
index cbd1498..ac0f115 100644
--- a/src/translate/request.ts
+++ b/src/providers/codex/translate/request.ts
@@ -5,7 +5,7 @@ import type {
AnthropicRequest,
AnthropicTextBlock,
AnthropicTool,
-} from "../anthropic/schema.ts"
+} from "../../../anthropic/schema.ts"
// Keep this aligned to the upstream Codex ResponsesApiRequest field set.
// Do not add plausible-looking top-level fields without source support or a confirmed live test.
diff --git a/src/translate/stream.ts b/src/providers/codex/translate/stream.ts
similarity index 98%
rename from src/translate/stream.ts
rename to src/providers/codex/translate/stream.ts
index fe78c4f..a9dd438 100644
--- a/src/translate/stream.ts
+++ b/src/providers/codex/translate/stream.ts
@@ -1,5 +1,5 @@
-import { encodeSseEvent } from "./sse.ts"
-import { createLogger } from "../log.ts"
+import { encodeSseEvent } from "../../../sse.ts"
+import { createLogger } from "../../../log.ts"
import { mapUsageToAnthropic, reduceUpstream, UpstreamStreamError } from "./reducer.ts"
const log = createLogger("translate.stream")
diff --git a/src/providers/registry.ts b/src/providers/registry.ts
new file mode 100644
index 0000000..bbcb39b
--- /dev/null
+++ b/src/providers/registry.ts
@@ -0,0 +1,21 @@
+import type { Provider } from "./types.ts"
+import { codexProvider } from "./codex/index.ts"
+
+const PROVIDERS: Record<string, Provider> = {
+ codex: codexProvider,
+}
+
+export function getProvider(name?: string): Provider {
+ const key = name ?? process.env.CCP_PROVIDER ?? "codex"
+ const p = PROVIDERS[key]
+ if (!p) {
+ throw new Error(
+ `Unknown provider: ${key}. Available: ${Object.keys(PROVIDERS).join(", ")}`,
+ )
+ }
+ return p
+}
+
+export function listProviders(): string[] {
+ return Object.keys(PROVIDERS)
+}
diff --git a/src/providers/types.ts b/src/providers/types.ts
new file mode 100644
index 0000000..390fb05
--- /dev/null
+++ b/src/providers/types.ts
@@ -0,0 +1,22 @@
+import type { AnthropicRequest } from "../anthropic/schema.ts"
+
+export interface RequestContext {
+ reqId: string
+ sessionId?: string
+ sessionSeq?: number
+ signal: AbortSignal
+}
+
+export interface CliHandlers {
+ login?: () => Promise<void>
+ device?: () => Promise<void>
+ status: () => Promise<void>
+ logout: () => Promise<void>
+}
+
+export interface Provider {
+ name: 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 c5f7c83..66fb0fd 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -1,84 +1,25 @@
import { createLogger, logDir } from "./log.ts"
import type { AnthropicRequest } from "./anthropic/schema.ts"
-import { assertAllowedModel, ModelNotAllowedError, resolveModel } from "./translate/model-allowlist.ts"
-import { translateRequest } from "./translate/request.ts"
-import { translateStream } from "./translate/stream.ts"
-import { accumulateResponse, UpstreamStreamError } from "./translate/accumulate.ts"
-import { mapUsageToAnthropic } from "./translate/reducer.ts"
-import { CodexError, postCodex } from "./codex/client.ts"
-import { countTokens, countTranslatedTokens } from "./count-tokens.ts"
+import type { Provider, RequestContext } from "./providers/types.ts"
const log = createLogger("server")
-const VERBOSE = !!process.env.CCP_LOG_VERBOSE
export interface ServeOptions {
port: number
+ provider: Provider
}
-interface SessionCountSnapshot {
- reqId: string
- model: string
- messageCount: number
- toolCount: number
- tokens: number
-}
-
-interface SessionMessageSnapshot {
- reqId: string
- model: string
- messageCount: number
- toolCount: number
- localInputTokens?: number
- translatedInputTokens?: number
-}
-
-function usageWindowTokens(usage: {
- input_tokens: number
- output_tokens: number
- cache_creation_input_tokens: number
- cache_read_input_tokens: number
-}): number {
- return (
- usage.input_tokens +
- usage.output_tokens +
- usage.cache_creation_input_tokens +
- usage.cache_read_input_tokens
- )
-}
+const sessionSeqs = new Map<string, number>()
-function upstreamHeaderSnapshot(headers: Headers): {
- serverModel?: string
- serverReasoningIncluded: boolean
-} {
- return {
- serverModel: headers.get("OpenAI-Model") || undefined,
- serverReasoningIncluded: headers.has("X-Reasoning-Included"),
- }
-}
-
-interface SessionTimelineState {
- seq: number
- lastCount?: SessionCountSnapshot
- lastMessage?: SessionMessageSnapshot
-}
-
-const sessionTimeline = new Map<string, SessionTimelineState>()
-
-function nextSessionTimeline(sessionId?: string): {
- state?: SessionTimelineState
- sessionSeq?: number
-} {
- if (!sessionId) return {}
- let state = sessionTimeline.get(sessionId)
- if (!state) {
- state = { seq: 0 }
- sessionTimeline.set(sessionId, state)
- }
- state.seq += 1
- return { state, sessionSeq: state.seq }
+function nextSessionSeq(sessionId?: string): number | undefined {
+ if (!sessionId) return undefined
+ const seq = (sessionSeqs.get(sessionId) ?? 0) + 1
+ sessionSeqs.set(sessionId, seq)
+ return seq
}
export function startServer(opts: ServeOptions): { stop: () => void; port: number } {
+ const { provider } = opts
const server = Bun.serve({
hostname: "127.0.0.1",
port: opts.port,
@@ -87,9 +28,15 @@ export function startServer(opts: ServeOptions): { stop: () => void; port: numbe
const url = new URL(req.url)
const start = Date.now()
const reqId = crypto.randomUUID()
- log.info("request", { reqId, method: req.method, path: url.pathname, query: url.search })
+ log.info("request", {
+ reqId,
+ method: req.method,
+ path: url.pathname,
+ query: url.search,
+ provider: provider.name,
+ })
try {
- const resp = await route(req, url, reqId)
+ const resp = await route(req, url, reqId, provider)
log.info("response", { reqId, status: resp.status, ms: Date.now() - start })
return resp
} catch (err) {
@@ -98,297 +45,54 @@ export function startServer(opts: ServeOptions): { stop: () => void; port: numbe
}
},
})
- log.info("server listening", { port: server.port, logDir: logDir() })
+ log.info("server listening", { port: server.port, provider: provider.name, logDir: logDir() })
return {
port: Number(server.port),
stop: () => server.stop(),
}
}
-async function route(req: Request, url: URL, reqId: string): Promise<Response> {
+async function route(req: Request, url: URL, reqId: string, provider: Provider): Promise<Response> {
if (url.pathname === "/healthz") {
- return new Response(JSON.stringify({ ok: true }), {
+ return new Response(JSON.stringify({ ok: true, provider: provider.name }), {
headers: { "content-type": "application/json" },
})
}
if (req.method === "POST" && url.pathname === "/v1/messages/count_tokens") {
- const body = (await req.json()) as AnthropicRequest
- const resolvedModel = resolveModel(body.model)
- const translated = translateRequest({ ...body, model: resolvedModel })
- const tokens = countTranslatedTokens(translated)
+ const body = await parseJsonBody(req)
+ if (body instanceof Response) return body
const sessionId = req.headers.get("x-claude-code-session-id") || undefined
- const { state, sessionSeq } = nextSessionTimeline(sessionId)
- const messageCount = body.messages?.length ?? 0
- const toolCount = body.tools?.length ?? 0
- log.debug("count_tokens", { reqId, tokens })
- if (state) {
- state.lastCount = {
- reqId,
- model: body.model,
- messageCount,
- toolCount,
- tokens,
- }
- }
- if (VERBOSE) {
- log.info("compaction telemetry", {
- reqId,
- phase: "count_tokens",
- path: url.pathname,
- sessionId,
- sessionSeq,
- model: body.model,
- resolvedModel,
- tokens,
- messageCount,
- toolCount,
- previousMessageReqId: state?.lastMessage?.reqId,
- previousMessageModel: state?.lastMessage?.model,
- previousMessageCount: state?.lastMessage?.messageCount,
- previousMessageToolCount: state?.lastMessage?.toolCount,
- previousMessageLocalInputTokens: state?.lastMessage?.localInputTokens,
- previousMessageTranslatedInputTokens: state?.lastMessage?.translatedInputTokens,
- })
+ const ctx: RequestContext = {
+ reqId,
+ sessionId,
+ sessionSeq: nextSessionSeq(sessionId),
+ signal: req.signal,
}
- return new Response(JSON.stringify({ input_tokens: tokens }), {
- headers: { "content-type": "application/json" },
- })
+ return provider.handleCountTokens(body, ctx)
}
if (req.method === "POST" && url.pathname === "/v1/messages") {
- return handleMessages(req, reqId)
- }
-
- return jsonError(404, "not_found", `No route for ${req.method} ${url.pathname}`)
-}
-
-async function handleMessages(req: Request, reqId: string): Promise<Response> {
- let body: AnthropicRequest
- try {
- body = (await req.json()) as AnthropicRequest
- } catch (err) {
- return jsonError(400, "invalid_request_error", `Invalid JSON: ${err}`)
- }
-
- const sessionId = req.headers.get("x-claude-code-session-id") || undefined
- const { state, sessionSeq } = nextSessionTimeline(sessionId)
- const messageId = `msg_${crypto.randomUUID().replace(/-/g, "")}`
- const wantStream = body.stream !== false
- const messageCount = body.messages?.length ?? 0
- const toolCount = body.tools?.length ?? 0
- const contextManagement = body.context_management
-
- log.debug("anthropic request", {
- reqId,
- model: body.model,
- messageCount,
- toolCount,
- stream: wantStream,
- sessionId,
- requestedMaxTokens: body.max_tokens,
- hasContextManagement: contextManagement !== undefined,
- hasJsonSchemaFormat: body.output_config?.format?.type === "json_schema",
- })
- if (VERBOSE) log.debug("anthropic request body", { reqId, body })
-
- const resolvedModel = resolveModel(body.model)
-
- try {
- assertAllowedModel(resolvedModel)
- } catch (err) {
- if (err instanceof ModelNotAllowedError) {
- return jsonError(
- 400,
- "invalid_request_error",
- `Model "${body.model}" resolves to unsupported model "${err.model}"`,
- )
- }
- throw err
- }
-
- const translated = translateRequest({ ...body, model: resolvedModel }, { sessionId })
- const localInputTokens = VERBOSE ? countTokens(body) : undefined
- const translatedInputTokens = VERBOSE ? countTranslatedTokens(translated) : undefined
- if (state) {
- state.lastMessage = {
- reqId,
- model: body.model,
- messageCount,
- toolCount,
- localInputTokens,
- translatedInputTokens,
- }
- }
- log.debug("translated request", {
- reqId,
- requestedModel: body.model,
- resolvedModel,
- inputItems: translated.input.length,
- tools: translated.tools?.length ?? 0,
- hasInstructions: !!translated.instructions,
- requestedMaxTokens: body.max_tokens,
- hasContextManagement: contextManagement !== undefined,
- promptCacheKey: translated.prompt_cache_key,
- })
- if (VERBOSE) log.debug("translated request body", { reqId, body: translated })
- if (VERBOSE) {
- log.info("compaction telemetry", {
+ 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,
- phase: "translated_request",
sessionId,
- sessionSeq,
- requestedModel: body.model,
- resolvedModel,
- messageCount,
- toolCount,
- localInputTokens,
- translatedInputTokens,
- inputItems: translated.input.length,
- translatedToolCount: translated.tools?.length ?? 0,
- hasInstructions: !!translated.instructions,
- requestedMaxTokens: body.max_tokens,
- hasContextManagement: contextManagement !== undefined,
- contextManagement,
- previousCountReqId: state?.lastCount?.reqId,
- previousCountModel: state?.lastCount?.model,
- previousCountTokens: state?.lastCount?.tokens,
- previousCountMessageCount: state?.lastCount?.messageCount,
- previousCountToolCount: state?.lastCount?.toolCount,
- })
- }
-
- let upstream
- try {
- upstream = await postCodex(translated, { sessionId, signal: req.signal })
- } catch (err) {
- if (err instanceof CodexError) {
- log.warn("codex error", { reqId, status: err.status, detail: err.detail })
- if (err.status === 429) {
- const headers: Record<string, string> = { "content-type": "application/json" }
- if (err.meta?.retryAfter) headers["retry-after"] = err.meta.retryAfter
- return new Response(
- JSON.stringify({
- type: "error",
- error: { type: "rate_limit_error", message: err.detail || err.message },
- }),
- { status: 429, headers },
- )
- }
- const type =
- err.status === 401 || err.status === 403 ? "authentication_error" : "api_error"
- return jsonError(err.status, type, err.detail || err.message)
+ sessionSeq: nextSessionSeq(sessionId),
+ signal: req.signal,
}
- throw err
+ return provider.handleMessages(body, ctx)
}
- if (wantStream) {
- const { serverModel, serverReasoningIncluded } = upstreamHeaderSnapshot(upstream.headers)
- const stream = translateStream(upstream.body, {
- messageId,
- model: body.model,
- reqId,
- sessionId,
- onFinish: VERBOSE
- ? (finish) => {
- const mappedUsage = finish.usage ? mapUsageToAnthropic(finish.usage) : undefined
- log.info("compaction telemetry", {
- reqId,
- phase: "upstream_finish",
- mode: "stream",
- sessionId,
- sessionSeq,
- requestedModel: body.model,
- resolvedModel,
- serverModel,
- serverReasoningIncluded,
- messageCount,
- toolCount,
- localInputTokens,
- translatedInputTokens,
- requestedMaxTokens: body.max_tokens,
- hasContextManagement: contextManagement !== undefined,
- contextManagement,
- upstreamInputTokens: finish.usage?.input_tokens ?? 0,
- upstreamOutputTokens: finish.usage?.output_tokens ?? 0,
- upstreamCachedInputTokens: finish.usage?.input_tokens_details?.cached_tokens ?? 0,
- upstreamReasoningTokens:
- finish.usage?.output_tokens_details?.reasoning_tokens ?? 0,
- mappedInputTokens: mappedUsage?.input_tokens ?? 0,
- mappedOutputTokens: mappedUsage?.output_tokens ?? 0,
- mappedCachedInputTokens: mappedUsage?.cache_read_input_tokens ?? 0,
- mappedContextWindowTokens: mappedUsage ? usageWindowTokens(mappedUsage) : 0,
- stopReason: finish.stopReason,
- })
- }
- : undefined,
- })
- return new Response(stream, {
- status: 200,
- headers: {
- "content-type": "text/event-stream",
- "cache-control": "no-cache",
- connection: "keep-alive",
- },
- })
- }
+ return jsonError(404, "not_found", `No route for ${req.method} ${url.pathname}`)
+}
+async function parseJsonBody(req: Request): Promise<AnthropicRequest | Response> {
try {
- const result = await accumulateResponse(upstream.body, { messageId, model: body.model })
- if (VERBOSE) {
- const { serverModel, serverReasoningIncluded } = upstreamHeaderSnapshot(upstream.headers)
- log.info("compaction telemetry", {
- reqId,
- phase: "upstream_finish",
- mode: "non_stream",
- sessionId,
- sessionSeq,
- requestedModel: body.model,
- resolvedModel,
- serverModel,
- serverReasoningIncluded,
- messageCount,
- toolCount,
- localInputTokens,
- translatedInputTokens,
- requestedMaxTokens: body.max_tokens,
- hasContextManagement: contextManagement !== undefined,
- contextManagement,
- upstreamInputTokens: result.rawUsage?.input_tokens ?? 0,
- upstreamOutputTokens: result.rawUsage?.output_tokens ?? 0,
- upstreamCachedInputTokens: result.rawUsage?.input_tokens_details?.cached_tokens ?? 0,
- upstreamReasoningTokens: result.rawUsage?.output_tokens_details?.reasoning_tokens ?? 0,
- mappedInputTokens: result.response.usage.input_tokens,
- mappedOutputTokens: result.response.usage.output_tokens,
- mappedCachedInputTokens: result.response.usage.cache_read_input_tokens,
- mappedContextWindowTokens: usageWindowTokens(result.response.usage),
- stopReason: result.response.stop_reason,
- })
- }
- return new Response(JSON.stringify(result.response), {
- headers: { "content-type": "application/json" },
- })
+ return (await req.json()) as AnthropicRequest
} catch (err) {
- if (err instanceof UpstreamStreamError) {
- log.warn("upstream stream error (non-streaming)", {
- reqId,
- kind: err.kind,
- message: err.message,
- })
- if (err.kind === "rate_limit") {
- const headers: Record<string, string> = { "content-type": "application/json" }
- if (err.retryAfterSeconds) headers["retry-after"] = String(err.retryAfterSeconds)
- return new Response(
- JSON.stringify({
- type: "error",
- error: { type: "rate_limit_error", message: err.message },
- }),
- { status: 429, headers },
- )
- }
- return jsonError(502, "api_error", err.message)
- }
- throw err
+ return jsonError(400, "invalid_request_error", `Invalid JSON: ${err}`)
}
}
diff --git a/src/translate/sse.ts b/src/sse.ts
similarity index 100%
rename from src/translate/sse.ts
rename to src/sse.ts