Skip to content

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

Rust

add formatting hooks

Raine Virtaa5b92a6f6e14
diff --git a/.githooks/format-staged.ts b/.githooks/format-staged.ts
new file mode 100755
index 0000000..11f42ac
--- /dev/null
+++ b/.githooks/format-staged.ts
@@ -0,0 +1,149 @@
+#!/usr/bin/env bun
+
+import { mkdtempSync, copyFileSync, existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { spawnSync } from "node:child_process";
+
+const formatExtensions = new Set([
+ ".ts",
+ ".tsx",
+ ".js",
+ ".jsx",
+ ".mjs",
+ ".cjs",
+ ".mts",
+ ".cts",
+ ".json",
+ ".jsonc",
+]);
+
+function git(args: string[], options: { env?: NodeJS.ProcessEnv; input?: string | Buffer } = {}) {
+ const result = spawnSync("git", args, {
+ cwd: repoRoot,
+ env: { ...process.env, ...options.env },
+ input: options.input,
+ encoding: options.input instanceof Buffer ? "buffer" : "utf8",
+ stdio: options.input === undefined ? ["ignore", "pipe", "pipe"] : ["pipe", "pipe", "pipe"],
+ });
+
+ if (result.status !== 0) {
+ const stderr = result.stderr?.toString() ?? "";
+ throw new Error(`git ${args.join(" ")} failed${stderr ? `:\n${stderr}` : ""}`);
+ }
+
+ return result.stdout.toString();
+}
+
+function command(args: string[], options: { cwd: string; env?: NodeJS.ProcessEnv }) {
+ const result = spawnSync(args[0]!, args.slice(1), {
+ cwd: options.cwd,
+ env: { ...process.env, ...options.env },
+ stdio: "inherit",
+ });
+
+ if (result.status !== 0) {
+ process.exit(result.status ?? 1);
+ }
+}
+
+function parseNulList(output: string) {
+ return output.split("\0").filter(Boolean);
+}
+
+function hasFormatExtension(path: string) {
+ for (const extension of formatExtensions) {
+ if (path.endsWith(extension)) return true;
+ }
+ return false;
+}
+
+function hashFile(path: string) {
+ const result = spawnSync("git", ["hash-object", "--", path], {
+ cwd: repoRoot,
+ encoding: "utf8",
+ stdio: ["ignore", "pipe", "pipe"],
+ });
+
+ if (result.status !== 0) return null;
+ return result.stdout.trim();
+}
+
+const rootResult = spawnSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf8" });
+if (rootResult.status !== 0) {
+ process.stderr.write(rootResult.stderr);
+ process.exit(rootResult.status ?? 1);
+}
+
+const repoRoot = rootResult.stdout.trim();
+process.chdir(repoRoot);
+
+const stagedFiles = parseNulList(
+ git(["diff", "--cached", "--name-only", "-z", "--diff-filter=ACMR"]),
+);
+const targets = stagedFiles.filter(hasFormatExtension);
+
+if (targets.length === 0) {
+ process.exit(0);
+}
+
+const tempDir = mkdtempSync(join(tmpdir(), "format-staged-"));
+const tempTree = join(tempDir, "tree");
+const tempIndex = join(tempDir, "index");
+mkdirSync(tempTree);
+
+try {
+ const indexPath = git(["rev-parse", "--git-path", "index"]).trim();
+ copyFileSync(indexPath, tempIndex);
+
+ const tempGitEnv = { GIT_INDEX_FILE: tempIndex, GIT_WORK_TREE: tempTree };
+ const indexEntries = git(["ls-files", "-s", "--", ...targets]);
+ const entries = new Map<string, { mode: string; sha: string }>();
+
+ for (const line of indexEntries.trim().split("\n").filter(Boolean)) {
+ const match = /^(\d+) ([0-9a-f]+) \d\t(.+)$/.exec(line);
+ if (!match) throw new Error(`could not parse index entry: ${line}`);
+ entries.set(match[3]!, { mode: match[1]!, sha: match[2]! });
+ }
+
+ git(["checkout-index", "-z", "--stdin", "-f"], {
+ env: tempGitEnv,
+ input: Buffer.from(`${targets.join("\0")}\0`),
+ });
+
+ for (const configFile of [".gitignore", ".oxfmtrc.json", ".oxfmtrc.jsonc"]) {
+ const source = join(repoRoot, configFile);
+ if (existsSync(source)) copyFileSync(source, join(tempTree, configFile));
+ }
+
+ command(["bunx", "oxfmt", "--write", ...targets], { cwd: tempTree, env: { FORCE_COLOR: "1" } });
+
+ let changed = 0;
+ let kept = 0;
+
+ for (const path of targets) {
+ const entry = entries.get(path);
+ if (!entry) continue;
+
+ const tempPath = join(tempTree, path);
+ const newSha = git(["hash-object", "-w", "--path", path, tempPath]).trim();
+ if (newSha === entry.sha) continue;
+
+ git(["update-index", "--cacheinfo", `${entry.mode},${newSha},${path}`]);
+ changed++;
+
+ const workingTreeSha = hashFile(path);
+ if (workingTreeSha === entry.sha) {
+ git(["checkout", "--", path]);
+ } else {
+ kept++;
+ }
+ }
+
+ if (changed > 0) {
+ const suffix = kept > 0 ? ` (${kept} kept due to unstaged edits)` : "";
+ console.log(`[format-staged] formatted ${changed} staged file(s)${suffix}`);
+ }
+} finally {
+ rmSync(tempDir, { recursive: true, force: true });
+}
diff --git a/.githooks/pre-commit b/.githooks/pre-commit
new file mode 100755
index 0000000..6a01326
--- /dev/null
+++ b/.githooks/pre-commit
@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+repo_root=$(git rev-parse --show-toplevel)
+bun "$repo_root/.githooks/format-staged.ts"
+exec just check
diff --git a/.githooks/pre-push b/.githooks/pre-push
new file mode 100755
index 0000000..bb0d69f
--- /dev/null
+++ b/.githooks/pre-push
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+exec just check-push
diff --git a/bun.lock b/bun.lock
index 14ba968..e352aec 100644
--- a/bun.lock
+++ b/bun.lock
@@ -9,21 +9,123 @@
},
"devDependencies": {
"@types/bun": "latest",
+ "bun-types": "^1.3.14",
+ "oxfmt": "^0.49.0",
+ "oxlint": "^1.64.0",
+ "oxlint-tsgolint": "^0.22.1",
"typescript": "^5.6.0",
},
},
},
"packages": {
+ "@oxfmt/binding-android-arm-eabi": ["@oxfmt/[email protected]", "", { "os": "android", "cpu": "arm" }, "sha512-HbifJ84prIh9+55CTPAU35JdRQrwg47y16cGerCC+iejSKOuHXYo2WDql6l7cQlzrYVtc3f4UWY+dBj2lRmOeA=="],
+
+ "@oxfmt/binding-android-arm64": ["@oxfmt/[email protected]", "", { "os": "android", "cpu": "arm64" }, "sha512-Ef7SKJqAaH2d7E6eXZZa2OffIShbhFMxnGK0zd93p4qiyTJr75B0qf7lrPD+qQOwcf04BrjYJ0JUxq8d5+yZwg=="],
+
+ "@oxfmt/binding-darwin-arm64": ["@oxfmt/[email protected]", "", { "os": "darwin", "cpu": "arm64" }, "sha512-8x5DN9CsFfb432sHa9NyqX5XisGUdA53LPEGSdv/VniS+v4uEOR8Orv7A9QSB98Xxgp0t6r31DzQA/wpIobGqQ=="],
+
+ "@oxfmt/binding-darwin-x64": ["@oxfmt/[email protected]", "", { "os": "darwin", "cpu": "x64" }, "sha512-e0+DSVzk4ewhMVKNYDaRTmP81jNMBWR1X9al0cVKWS+hDM/dElNqD5zjTOCuLOZc4oOdp2Gx2ldrVL+yYo9TZQ=="],
+
+ "@oxfmt/binding-freebsd-x64": ["@oxfmt/[email protected]", "", { "os": "freebsd", "cpu": "x64" }, "sha512-W+mjtYtrQvFbXT/uNT+221OBhGRZ8UqNsLxjTWsjZ4GsQnRdvRC/N2NCK86BcamWr7lsTxwpwN3PULnr78sgcQ=="],
+
+ "@oxfmt/binding-linux-arm-gnueabihf": ["@oxfmt/[email protected]", "", { "os": "linux", "cpu": "arm" }, "sha512-Rtv6UevV7czDlLqil+NZUe4d8gs8jQo/zScSpumwyf7I+fSdLc+hc8AF3MQC7ymxSMMD9+vfiqQlsIf7wOAzXA=="],
+
+ "@oxfmt/binding-linux-arm-musleabihf": ["@oxfmt/[email protected]", "", { "os": "linux", "cpu": "arm" }, "sha512-sBi+8C/Q/MdKa5FL8ibAUCdhFBGFH7HFN/Qoyd5xQbZ/0ky3NMPpKfIBpaH0lhK2dXkGLczVQUoZ+xuNSerCdQ=="],
+
+ "@oxfmt/binding-linux-arm64-gnu": ["@oxfmt/[email protected]", "", { "os": "linux", "cpu": "arm64" }, "sha512-JIfWenFhlzx+O8YygyZhoHFzTsdgDhxhbDRnE2iJLnnM5pWKScFvPECO2vOlA7JqJ/9S1g3uzEKuRCkHFwTjvA=="],
+
+ "@oxfmt/binding-linux-arm64-musl": ["@oxfmt/[email protected]", "", { "os": "linux", "cpu": "arm64" }, "sha512-iNzkMPG18jPkwBOZ4/HEjwqfzAjq4RrUQ0CgId/fC1ENvYD5jLVAaU/gWgpiqP1ys07kxSsSggDd1fp3E7mQHw=="],
+
+ "@oxfmt/binding-linux-ppc64-gnu": ["@oxfmt/[email protected]", "", { "os": "linux", "cpu": "ppc64" }, "sha512-BPHA/NN3LvoIXiid+iz3BHt5V0Rzx0tXAqRUovwE1NsbDaLG9e8mtv7evDGRIkVQacqTDBv0XL25THHsxSJosQ=="],
+
+ "@oxfmt/binding-linux-riscv64-gnu": ["@oxfmt/[email protected]", "", { "os": "linux", "cpu": "none" }, "sha512-3Eroshe+s69htC9JIL0+zLGQczLtRKezkMhwqQC21VC5Z/fuLvzLfbAOLgJLUq601H8gDYjy7deYycfOBjCvWg=="],
+
+ "@oxfmt/binding-linux-riscv64-musl": ["@oxfmt/[email protected]", "", { "os": "linux", "cpu": "none" }, "sha512-fnaERGgsxGm0lKAmO72EYR4BA3qBnzBTJBTi6EtUMq1D4R7EexRBMU4voXnx4TXla3SEDl9x4uNp/18SbkPjGg=="],
+
+ "@oxfmt/binding-linux-s390x-gnu": ["@oxfmt/[email protected]", "", { "os": "linux", "cpu": "s390x" }, "sha512-rBwasMl1Uul1MCCeTGEFKnOTL7VUxHf+634jWStrQAbzpBJgd5Yz5m4F7exVCsoI8PHn57dNjssXagXLCLB5yA=="],
+
+ "@oxfmt/binding-linux-x64-gnu": ["@oxfmt/[email protected]", "", { "os": "linux", "cpu": "x64" }, "sha512-BoC/F9xHe2y/deuBGA5Aw7bes07OD2gcL2wlpzTrfImR92vPP7S/k3LBTyspQZCNIVNdagkELcqKELwMLGIfAg=="],
+
+ "@oxfmt/binding-linux-x64-musl": ["@oxfmt/[email protected]", "", { "os": "linux", "cpu": "x64" }, "sha512-umY6jFADAo/oztFKl8D/S6vSrG6oBpEskcentiRuz42kZVU2kfDXMWCYavxyZR2bwPjqkHpcHZ6EZFiH3Qj9ZA=="],
+
+ "@oxfmt/binding-openharmony-arm64": ["@oxfmt/[email protected]", "", { "os": "none", "cpu": "arm64" }, "sha512-J85zQMiw2pXiGPK+OusmDvSnJ/dgpgN7VgmB2zOBtgS8F+nsOUfSg9ZEBrwbQscjZ7tkPbm38CG4VF5f53MsiA=="],
+
+ "@oxfmt/binding-win32-arm64-msvc": ["@oxfmt/[email protected]", "", { "os": "win32", "cpu": "arm64" }, "sha512-38K67XR++CoFFORDd4sMFwUVAnD6msYBdGTei+qvKGrRPO6S2PbrYPNL/eQQ1RgnnxOegNba0YQwg6uRkNcw6A=="],
+
+ "@oxfmt/binding-win32-ia32-msvc": ["@oxfmt/[email protected]", "", { "os": "win32", "cpu": "ia32" }, "sha512-rXVe0HICwQF0dBgbQtBCoYf8x/SidPIdhyQl+iPuJlV7suV+qDv7yUEB3wQ4qC3nOeNxz287SwFXKzyr0kWgEg=="],
+
+ "@oxfmt/binding-win32-x64-msvc": ["@oxfmt/[email protected]", "", { "os": "win32", "cpu": "x64" }, "sha512-gwWLwSEmBBfIK/Wh7GGd658161o4RKAvHWRaRQbJm571iQXGKfyr7UKsI1vsWvDlNLc30CxJDc8mMmCvJ/kczQ=="],
+
+ "@oxlint-tsgolint/darwin-arm64": ["@oxlint-tsgolint/[email protected]", "", { "os": "darwin", "cpu": "arm64" }, "sha512-4150Lpgc1YM09GcjA6GSrra1JoPjC7aOpfywLjWEY4vW0Sd1qKzqHF1WRaiw0/qUZ40OATYdv3aRd7ipPkWQbw=="],
+
+ "@oxlint-tsgolint/darwin-x64": ["@oxlint-tsgolint/[email protected]", "", { "os": "darwin", "cpu": "x64" }, "sha512-vFWcPWYOgZs4HWcgS1EjUZg33NLcNfEYU49KGImmCfZWkflENrmBYV4HN/C0YeAPum6ZZ/goPSvQrB/cOD+NfA=="],
+
+ "@oxlint-tsgolint/linux-arm64": ["@oxlint-tsgolint/[email protected]", "", { "os": "linux", "cpu": "arm64" }, "sha512-6LiUpP0Zir3+29FvBm7Y28q/dBjSHqTZ5MhG1Ckw4fGhI4cAvbcwXaKvbjx1TP7rRmBNOoq/M5xdpHjTb+GAew=="],
+
+ "@oxlint-tsgolint/linux-x64": ["@oxlint-tsgolint/[email protected]", "", { "os": "linux", "cpu": "x64" }, "sha512-fuX1hEQfpHauUbXADsfqVhRzrUrGabzGXbj5wsp2vKhV5uk/Rze8Mba9GdjFGECzvXudMGqHqxB4r6jGRdhxVA=="],
+
+ "@oxlint-tsgolint/win32-arm64": ["@oxlint-tsgolint/[email protected]", "", { "os": "win32", "cpu": "arm64" }, "sha512-8SZidAj+jrbZf9ZjBEYW0tiNZ+KasqB2zgW26qdiPpQSF/DzURnPmXz651IeA9YsmbVdHGIooEHUmev6QJdquA=="],
+
+ "@oxlint-tsgolint/win32-x64": ["@oxlint-tsgolint/[email protected]", "", { "os": "win32", "cpu": "x64" }, "sha512-QweSk9H5lFh5Y+WUf2Kq/OAN88V6+62ZwGhP38gqdRotI90luXSMkruFTj7Q2rYrzH4ZVNaSqx7NY8JpSfIzqg=="],
+
+ "@oxlint/binding-android-arm-eabi": ["@oxlint/[email protected]", "", { "os": "android", "cpu": "arm" }, "sha512-2r6Nq3XXGLHEXKkSj8JtmJ6N4gDw431DPFOg0ZoJHlNjnG6HVMm/ksQ10m0HJ8WBvwgMe1L50UHPaYZutCRPCw=="],
+
+ "@oxlint/binding-android-arm64": ["@oxlint/[email protected]", "", { "os": "android", "cpu": "arm64" }, "sha512-ePJMpePgg7fBv+L/hVx1xXRU5/5gd5m0obLA6hPEfLXF3GjpR8idIDbY1dhQYhyz1ms2wdTccSboo6KEd2Oxtg=="],
+
+ "@oxlint/binding-darwin-arm64": ["@oxlint/[email protected]", "", { "os": "darwin", "cpu": "arm64" }, "sha512-U4DMLQd10gJLuoSTLSGbfv3bGjTlUNsScm9Dgb8wwBqmCzidf1pE1pXV4doGNxqwH3KtVng1AGTINA0NvkGLvQ=="],
+
+ "@oxlint/binding-darwin-x64": ["@oxlint/[email protected]", "", { "os": "darwin", "cpu": "x64" }, "sha512-GoRIL48QWm4/TAvjN8pB1nAG+1/uqc9EdnWT9zqHeb6wsmjZtywj8VRe5aGW47Fdb64YtLOsdLqVxOvQuz98Wg=="],
+
+ "@oxlint/binding-freebsd-x64": ["@oxlint/[email protected]", "", { "os": "freebsd", "cpu": "x64" }, "sha512-5dFkv4tkg7PxJJGS9/OjrJwjhuHczrd3OQOkRE0wHcLM+ncUnULtzEPWjqGOxTXxZnLWcB91bGiIznx89TVXyQ=="],
+
+ "@oxlint/binding-linux-arm-gnueabihf": ["@oxlint/[email protected]", "", { "os": "linux", "cpu": "arm" }, "sha512-jsBqMLl/uOL5+Kq/+BtK9FrmiNGUbx8SiyZXv+WlUxA45KuwcLu9BfiSIL3I3DBDgWM3yZizDITnTK9BcqNBQg=="],
+
+ "@oxlint/binding-linux-arm-musleabihf": ["@oxlint/[email protected]", "", { "os": "linux", "cpu": "arm" }, "sha512-1lrj8At/Uuc9GhjrVFBQo0NEjfBrTkzpmtHIGAhNnIXqn1CAyGL+qrztUsXb2GIluJrpl9Q7qRLJOb/NqydacQ=="],
+
+ "@oxlint/binding-linux-arm64-gnu": ["@oxlint/[email protected]", "", { "os": "linux", "cpu": "arm64" }, "sha512-HpSQbubwh03mMhAdy2BYtad/fsY8vDFHDAb6bUwuCYg2VD3xCQgn6ArKcO0oZyLCheacKTv4PrF3Mfu5hgoE2g=="],
+
+ "@oxlint/binding-linux-arm64-musl": ["@oxlint/[email protected]", "", { "os": "linux", "cpu": "arm64" }, "sha512-00QQ0h0Y7u0G69BgiH3+ky2aaq/QvkDL6DYok8htIuJHxybiux5aQ8jwmg8qIk9wha6UagUP2BAwAzbemcJbpg=="],
+
+ "@oxlint/binding-linux-ppc64-gnu": ["@oxlint/[email protected]", "", { "os": "linux", "cpu": "ppc64" }, "sha512-2GaimTV6EMW+s5HS0An3oGbQme3BgHswvfVdGk3EB57Xe9+/gyT+Qd7lNVzb3rtir52vbIPzXfaYArzs5b5zcw=="],
+
+ "@oxlint/binding-linux-riscv64-gnu": ["@oxlint/[email protected]", "", { "os": "linux", "cpu": "none" }, "sha512-H46AtFb9wypjoVwGdlxrm0DsD809NGmtiK9HiyPKTxkSte2YjhC4S+00rOIrwCaxcyPiGid3Y3OMXp5KMAkGZw=="],
+
+ "@oxlint/binding-linux-riscv64-musl": ["@oxlint/[email protected]", "", { "os": "linux", "cpu": "none" }, "sha512-HEgsidjjvvyzdg82icYkuFCf7REDV7B9JFwbIMbVwrKLBY0MrXX+bku3POn/hduZ2yW91IyVDUMq0Bf02KwXQw=="],
+
+ "@oxlint/binding-linux-s390x-gnu": ["@oxlint/[email protected]", "", { "os": "linux", "cpu": "s390x" }, "sha512-Axvm8qryotmKN00P5w4JapaSjvP2LOSbdbBJiX+2SuHd3QzhW7TUc8skqgw+ahQZ5DmzEYeHCqauvW8f32Ns6Q=="],
+
+ "@oxlint/binding-linux-x64-gnu": ["@oxlint/[email protected]", "", { "os": "linux", "cpu": "x64" }, "sha512-cR60vSd7+m+KRZ3GQGfDxWwahW5RMXg0qlGvAluZr0fTUYvw0H9N9AXAF/M/PMqgytyqvVNmBAkJG9l7U30Y1g=="],
+
+ "@oxlint/binding-linux-x64-musl": ["@oxlint/[email protected]", "", { "os": "linux", "cpu": "x64" }, "sha512-2u/aPZ9pEg7HnvZPDsHxUGNnrpr4qaHi+mCgLgpt+LYRzPrS4Px4wPfkIdRdr2GvKnaYyt+XSlto0Vm5sbStTg=="],
+
+ "@oxlint/binding-openharmony-arm64": ["@oxlint/[email protected]", "", { "os": "none", "cpu": "arm64" }, "sha512-kfhkGfCdoXLSxEkrhDlJrvBYajGmq+ma4EMc53dsOWTq+rIBOlI0vTBmpZNnM5oH2LY/K/w1HAK+UQEgjgpVUg=="],
+
+ "@oxlint/binding-win32-arm64-msvc": ["@oxlint/[email protected]", "", { "os": "win32", "cpu": "arm64" }, "sha512-r/cNKBFieONoVu2bb1KkVouq9W+edDUgHumXJGphCRRj+U0xaD4nanrw8ZOqo0IsutPkEM4vCcGBpak6x5aXMg=="],
+
+ "@oxlint/binding-win32-ia32-msvc": ["@oxlint/[email protected]", "", { "os": "win32", "cpu": "ia32" }, "sha512-tUw0xUUwEFVZbpJoeCblkv8SJA4Xz3CdXCJbAnBsiNLyxDrk2tLcxEAS6M73Q7hHHDg3OtwI8vZVK3t5RJt4Gw=="],
+
+ "@oxlint/binding-win32-x64-msvc": ["@oxlint/[email protected]", "", { "os": "win32", "cpu": "x64" }, "sha512-9CBR+LO0JVST87fNTzzNxS5I29jIUO5gxT9i9+M3SDHHALElj9sY1Prf12tad3vIRC6OD7Ehtvvh+sn13vSwHw=="],
+
"@types/bun": ["@types/[email protected]", "", { "dependencies": { "bun-types": "1.3.12" } }, "sha512-DBv81elK+/VSwXHDlnH3Qduw+KxkTIWi7TXkAeh24zpi5l0B2kUg9Ga3tb4nJaPcOFswflgi/yAvMVBPrxMB+A=="],
"@types/node": ["@types/[email protected]", "", { "dependencies": { "undici-types": "~7.19.0" } }, "sha512-+qIYRKdNYJwY3vRCZMdJbPLJAtGjQBudzZzdzwQYkEPQd+PJGixUL5QfvCLDaULoLv+RhT3LDkwEfKaAkgSmNQ=="],
- "bun-types": ["[email protected]", "", { "dependencies": { "@types/node": "*" } }, "sha512-HqOLj5PoFajAQciOMRiIZGNoKxDJSr6qigAttOX40vJuSp6DN/CxWp9s3C1Xwm4oH7ybueITwiaOcWXoYVoRkA=="],
+ "bun-types": ["[email protected]", "", { "dependencies": { "@types/node": "*" } }, "sha512-4N0ig0fEomHt5R0KCFWjovxow98rIoRwKolrYdCcknNwMekCXRnWEUvgu5soYV8QXtVsrUD8B95MBOZGPvr6KQ=="],
"gpt-tokenizer": ["[email protected]", "", {}, "sha512-YSpexBL/k4bfliAzMrRqn3M6+it02LutVyhVpDeMKrC/O9+pCe/5s8U2hYKa2vFLD5/vHhsKc8sOn/qGqII8Kg=="],
+ "oxfmt": ["[email protected]", "", { "dependencies": { "tinypool": "2.1.0" }, "optionalDependencies": { "@oxfmt/binding-android-arm-eabi": "0.49.0", "@oxfmt/binding-android-arm64": "0.49.0", "@oxfmt/binding-darwin-arm64": "0.49.0", "@oxfmt/binding-darwin-x64": "0.49.0", "@oxfmt/binding-freebsd-x64": "0.49.0", "@oxfmt/binding-linux-arm-gnueabihf": "0.49.0", "@oxfmt/binding-linux-arm-musleabihf": "0.49.0", "@oxfmt/binding-linux-arm64-gnu": "0.49.0", "@oxfmt/binding-linux-arm64-musl": "0.49.0", "@oxfmt/binding-linux-ppc64-gnu": "0.49.0", "@oxfmt/binding-linux-riscv64-gnu": "0.49.0", "@oxfmt/binding-linux-riscv64-musl": "0.49.0", "@oxfmt/binding-linux-s390x-gnu": "0.49.0", "@oxfmt/binding-linux-x64-gnu": "0.49.0", "@oxfmt/binding-linux-x64-musl": "0.49.0", "@oxfmt/binding-openharmony-arm64": "0.49.0", "@oxfmt/binding-win32-arm64-msvc": "0.49.0", "@oxfmt/binding-win32-ia32-msvc": "0.49.0", "@oxfmt/binding-win32-x64-msvc": "0.49.0" }, "peerDependencies": { "svelte": "^5.0.0" }, "optionalPeers": ["svelte"], "bin": { "oxfmt": "bin/oxfmt" } }, "sha512-IAHFMdlJSWe+oAr65dx22UvjCtV9DBMisAuLnKpDqMQrctzCkGnj3QRwNHm0d+uwSWPalsDF8ZYLz9rh6nH2IQ=="],
+
+ "oxlint": ["[email protected]", "", { "optionalDependencies": { "@oxlint/binding-android-arm-eabi": "1.64.0", "@oxlint/binding-android-arm64": "1.64.0", "@oxlint/binding-darwin-arm64": "1.64.0", "@oxlint/binding-darwin-x64": "1.64.0", "@oxlint/binding-freebsd-x64": "1.64.0", "@oxlint/binding-linux-arm-gnueabihf": "1.64.0", "@oxlint/binding-linux-arm-musleabihf": "1.64.0", "@oxlint/binding-linux-arm64-gnu": "1.64.0", "@oxlint/binding-linux-arm64-musl": "1.64.0", "@oxlint/binding-linux-ppc64-gnu": "1.64.0", "@oxlint/binding-linux-riscv64-gnu": "1.64.0", "@oxlint/binding-linux-riscv64-musl": "1.64.0", "@oxlint/binding-linux-s390x-gnu": "1.64.0", "@oxlint/binding-linux-x64-gnu": "1.64.0", "@oxlint/binding-linux-x64-musl": "1.64.0", "@oxlint/binding-openharmony-arm64": "1.64.0", "@oxlint/binding-win32-arm64-msvc": "1.64.0", "@oxlint/binding-win32-ia32-msvc": "1.64.0", "@oxlint/binding-win32-x64-msvc": "1.64.0" }, "peerDependencies": { "oxlint-tsgolint": ">=0.22.1" }, "optionalPeers": ["oxlint-tsgolint"], "bin": { "oxlint": "bin/oxlint" } }, "sha512-Star3SNpWPeWFPw7kRXIhXUSn6fdiAl25q15CQzH/9WaOtG6e9CWTc25vNZOCr4PE1yEP1GtKJKIKglhj3OmEQ=="],
+
+ "oxlint-tsgolint": ["[email protected]", "", { "optionalDependencies": { "@oxlint-tsgolint/darwin-arm64": "0.22.1", "@oxlint-tsgolint/darwin-x64": "0.22.1", "@oxlint-tsgolint/linux-arm64": "0.22.1", "@oxlint-tsgolint/linux-x64": "0.22.1", "@oxlint-tsgolint/win32-arm64": "0.22.1", "@oxlint-tsgolint/win32-x64": "0.22.1" }, "bin": { "tsgolint": "bin/tsgolint.js" } }, "sha512-YUSGSLUnoolsu8gxISEDio3q1rtsCozwfOzASUn3DT2mR2EeQ93uEEnen7s+6LpF+lyTQFln1pQfqwBh/fsVEg=="],
+
+ "tinypool": ["[email protected]", "", {}, "sha512-Pugqs6M0m7Lv1I7FtxN4aoyToKg1C4tu+/381vH35y8oENM/Ai7f7C4StcoK4/+BSw9ebcS8jRiVrORFKCALLw=="],
+
"typescript": ["[email protected]", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="],
"undici-types": ["[email protected]", "", {}, "sha512-qYVnV5OEm2AW8cJMCpdV20CDyaN3g0AjDlOGf1OW4iaDEx8MwdtChUp4zu4H0VP3nDRF/8RKWH+IPp9uW0YGZg=="],
+
+ "@types/bun/bun-types": ["[email protected]", "", { "dependencies": { "@types/node": "*" } }, "sha512-HqOLj5PoFajAQciOMRiIZGNoKxDJSr6qigAttOX40vJuSp6DN/CxWp9s3C1Xwm4oH7ybueITwiaOcWXoYVoRkA=="],
}
}
diff --git a/justfile b/justfile
new file mode 100644
index 0000000..5a92a0a
--- /dev/null
+++ b/justfile
@@ -0,0 +1,89 @@
+# Glob list shared by check-format and fix-format. Each pattern stays
+# single-quoted so the shell hands oxfmt the literal pattern.
+oxfmt_globs := "'**/*.ts' '**/*.tsx' '**/*.js' '**/*.jsx' '**/*.mjs' '**/*.cjs' '**/*.mts' '**/*.cts' '**/*.json' '**/*.jsonc'"
+
+# Point git at .githooks/ so the tracked hooks run. Idempotent.
+install-hooks:
+ git config core.hooksPath .githooks
+ @echo "git hooks installed (core.hooksPath=.githooks)"
+
+types:
+ bun run typecheck
+
+lint:
+ bunx oxlint --type-aware
+
+test:
+ bun test
+
+# Format check across JS/TS/JSON. Intentionally not part of `just check`.
+check-format:
+ bunx oxfmt --check {{oxfmt_globs}}
+
+# Auto-fix formatting across JS/TS/JSON.
+fix-format:
+ bunx oxfmt --write {{oxfmt_globs}}
+
+# Pre-push gate: format-check + the full check in parallel.
+[parallel]
+check-push: check-format check
+
+# Runs types, lint, and tests in parallel.
+# just check # quiet: one PASS/FAIL line per job
+# just check --verbose # stream all output prefixed with [job]
+check mode="":
+ #!/usr/bin/env bash
+ set -uo pipefail
+ case "{{mode}}" in
+ ""|--quiet) verbose=0 ;;
+ -v|--verbose) verbose=1 ;;
+ *) echo "usage: just check [--verbose|--quiet]" >&2; exit 2 ;;
+ esac
+ tmp=$(mktemp -d)
+ trap 'rm -rf "$tmp"' EXIT
+ if [ -t 1 ]; then export FORCE_COLOR=1; fi
+ if [ -t 1 ]; then
+ reset=$'\033[0m'
+ bold=$'\033[1m'
+ dim=$'\033[2m'
+ green=$'\033[32m'
+ red=$'\033[31m'
+ else
+ reset='' bold='' dim='' green='' red=''
+ fi
+ run() {
+ local label=$1 color=$2; shift 2
+ [ -z "$reset" ] && color=''
+ local prefix="${color}${bold}${label}${reset}${dim} |${reset} "
+ (
+ if [ "$verbose" = 1 ]; then
+ if "$@" 2>&1 | awk -v p="$prefix" '{print p $0}'; then
+ echo "${green}${bold}✔ PASS${reset} $label"
+ else
+ rc=${PIPESTATUS[0]}
+ echo "${red}${bold}✘ FAIL${reset} $label ${dim}(exit $rc)${reset}"
+ exit "$rc"
+ fi
+ else
+ if "$@" >"$tmp/$label.out" 2>&1; then
+ echo "${green}${bold}✔ PASS${reset} $label"
+ else
+ rc=$?
+ echo "${red}${bold}✘ FAIL${reset} $label ${dim}(exit $rc)${reset}"
+ grep -v $'\xe2\x9c\x93' "$tmp/$label.out" \
+ | awk -v p="$prefix" '{print p $0}'
+ exit "$rc"
+ fi
+ fi
+ ) &
+ pids+=("$!")
+ }
+ pids=()
+ run types $'\033[38;5;75m' bun run typecheck
+ run lint $'\033[38;5;213m' bunx oxlint --type-aware
+ run test $'\033[38;5;120m' bun test
+ fail=0
+ for pid in "${pids[@]}"; do
+ wait "$pid" || fail=1
+ done
+ exit "$fail"
diff --git a/package.json b/package.json
index abe9028..fab7a63 100644
--- a/package.json
+++ b/package.json
@@ -2,10 +2,10 @@
"name": "claude-code-proxy",
"version": "0.0.13",
"license": "MIT",
- "type": "module",
"bin": {
"claude-code-proxy": "./src/cli.ts"
},
+ "type": "module",
"scripts": {
"start": "bun run src/cli.ts serve",
"auth": "bun run src/cli.ts auth login",
@@ -16,6 +16,10 @@
},
"devDependencies": {
"@types/bun": "latest",
+ "bun-types": "^1.3.14",
+ "oxfmt": "^0.49.0",
+ "oxlint": "^1.64.0",
+ "oxlint-tsgolint": "^0.22.1",
"typescript": "^5.6.0"
}
}
diff --git a/src/anthropic/schema.ts b/src/anthropic/schema.ts
index ae58faf..8b98e48 100644
--- a/src/anthropic/schema.ts
+++ b/src/anthropic/schema.ts
@@ -1,34 +1,32 @@
export interface AnthropicTextBlock {
- type: "text"
- text: string
- cache_control?: { type: "ephemeral" }
+ type: "text";
+ text: string;
+ cache_control?: { type: "ephemeral" };
}
export interface AnthropicImageBlock {
- type: "image"
- source:
- | { type: "base64"; media_type: string; data: string }
- | { type: "url"; url: string }
+ type: "image";
+ source: { type: "base64"; media_type: string; data: string } | { type: "url"; url: string };
}
export interface AnthropicToolUseBlock {
- type: "tool_use"
- id: string
- name: string
- input: unknown
+ type: "tool_use";
+ id: string;
+ name: string;
+ input: unknown;
}
export interface AnthropicToolResultBlock {
- type: "tool_result"
- tool_use_id: string
- content: string | AnthropicToolResultContentBlock[]
- is_error?: boolean
+ type: "tool_result";
+ tool_use_id: string;
+ content: string | AnthropicToolResultContentBlock[];
+ is_error?: boolean;
}
export interface AnthropicThinkingBlock {
- type: "thinking"
- thinking: string
- signature?: string
+ type: "thinking";
+ thinking: string;
+ signature?: string;
}
export type AnthropicToolResultContentBlock =
@@ -37,41 +35,41 @@ export type AnthropicToolResultContentBlock =
| AnthropicToolUseBlock
| AnthropicToolResultBlock
| AnthropicThinkingBlock
- | (Record<string, unknown> & { type?: unknown })
+ | (Record<string, unknown> & { type?: unknown });
export type AnthropicContentBlock =
| AnthropicTextBlock
| AnthropicImageBlock
| AnthropicToolUseBlock
| AnthropicToolResultBlock
- | AnthropicThinkingBlock
+ | AnthropicThinkingBlock;
export interface AnthropicMessage {
- role: "user" | "assistant"
- content: string | AnthropicContentBlock[]
+ role: "user" | "assistant";
+ content: string | AnthropicContentBlock[];
}
export interface AnthropicTool {
- name: string
- description?: string
- input_schema: unknown
+ name: string;
+ description?: string;
+ input_schema: unknown;
}
export interface AnthropicRequest {
- model: string
- messages: AnthropicMessage[]
- system?: string | AnthropicTextBlock[]
- tools?: AnthropicTool[]
- tool_choice?: { type: "auto" | "any" | "tool" | "none"; name?: string }
- max_tokens?: number
- temperature?: number
- top_p?: number
- stream?: boolean
- thinking?: { type: string; [k: string]: unknown }
+ model: string;
+ messages: AnthropicMessage[];
+ system?: string | AnthropicTextBlock[];
+ tools?: AnthropicTool[];
+ tool_choice?: { type: "auto" | "any" | "tool" | "none"; name?: string };
+ max_tokens?: number;
+ temperature?: number;
+ top_p?: number;
+ stream?: boolean;
+ thinking?: { type: string; [k: string]: unknown };
output_config?: {
- effort?: "low" | "medium" | "high" | "max"
- format?: { type: "json_schema"; schema: unknown; name?: string; strict?: boolean }
- }
- context_management?: unknown
- metadata?: unknown
+ effort?: "low" | "medium" | "high" | "max";
+ format?: { type: "json_schema"; schema: unknown; name?: string; strict?: boolean };
+ };
+ context_management?: unknown;
+ metadata?: unknown;
}
diff --git a/src/cli.ts b/src/cli.ts
index e829324..05e93d9 100755
--- a/src/cli.ts
+++ b/src/cli.ts
@@ -1,95 +1,99 @@
#!/usr/bin/env bun
-import { startServer } from "./server.ts"
-import { createLogger, logFile } from "./log.ts"
-import { port as configPort, getConfig, aliasProvider as configAliasProvider } from "./config.ts"
-import { configDir } from "./paths.ts"
-import { existsSync } from "node:fs"
-import { join } from "node:path"
+import { startServer } from "./server.ts";
+import { createLogger, logFile } from "./log.ts";
+import { port as configPort, getConfig, aliasProvider as configAliasProvider } from "./config.ts";
+import { configDir } from "./paths.ts";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
import {
allProviders,
allSupportedModels,
getProvider,
listProviders,
-} from "./providers/registry.ts"
-import type { CliHandlers } from "./providers/types.ts"
+} 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"
+declare const BUILD_VERSION: string | undefined;
+const VERSION = typeof BUILD_VERSION === "string" ? BUILD_VERSION : "dev";
-const log = createLogger("cli")
+const log = createLogger("cli");
async function main() {
- const args = process.argv.slice(2)
- const [first, ...rest] = args
+ const args = process.argv.slice(2);
+ const [first, ...rest] = args;
if (first === "--version" || first === "-v" || first === "version") {
- console.log(`claude-code-proxy ${VERSION}`)
- return
+ console.log(`claude-code-proxy ${VERSION}`);
+ return;
}
if (!first || first === "serve") {
- const port = configPort()
- startServer({ port })
- console.log(`Proxy listening on http://localhost:${port}`)
- console.log(`Logs: ${logFile()}`)
- printConfigSummary()
- console.log()
- console.log("Providers are selected per-request by ANTHROPIC_MODEL:")
- printSupportedModels()
- console.log()
- console.log("Configure Claude Code (pick a model from above):")
- console.log(` export ANTHROPIC_BASE_URL="http://localhost:${port}"`)
- console.log(` export ANTHROPIC_AUTH_TOKEN="anything"`)
- console.log(` export ANTHROPIC_MODEL="kimi-for-coding[1m]" # or gpt-5.4[1m], etc.`)
- console.log(` export ANTHROPIC_SMALL_FAST_MODEL="kimi-for-coding[1m]" # background / title-gen`)
- console.log(` export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1"`)
- return
+ const port = configPort();
+ startServer({ port });
+ console.log(`Proxy listening on http://localhost:${port}`);
+ console.log(`Logs: ${logFile()}`);
+ printConfigSummary();
+ console.log();
+ console.log("Providers are selected per-request by ANTHROPIC_MODEL:");
+ printSupportedModels();
+ console.log();
+ console.log("Configure Claude Code (pick a model from above):");
+ console.log(` export ANTHROPIC_BASE_URL="http://localhost:${port}"`);
+ console.log(` export ANTHROPIC_AUTH_TOKEN="anything"`);
+ console.log(
+ ` export ANTHROPIC_MODEL="kimi-for-coding[1m]" # or gpt-5.4[1m], etc.`,
+ );
+ console.log(
+ ` export ANTHROPIC_SMALL_FAST_MODEL="kimi-for-coding[1m]" # background / title-gen`,
+ );
+ 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
+ const provider = getProvider(first);
+ await runProviderCommand(provider.name, provider.cli, rest);
+ return;
}
- usageAndExit()
+ usageAndExit();
}
async function runProviderCommand(name: string, cli: CliHandlers, args: string[]): Promise<void> {
- const [group, sub] = args
- if (group !== "auth") usageAndExit()
+ 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)
+ console.error(`${name}: browser login not supported`);
+ process.exit(2);
}
- await cli.login()
- process.exit(0)
+ await cli.login();
+ process.exit(0);
case "device":
if (!cli.device) {
- console.error(`${name}: device login not supported`)
- process.exit(2)
+ console.error(`${name}: device login not supported`);
+ process.exit(2);
}
- await cli.device()
- process.exit(0)
+ await cli.device();
+ process.exit(0);
case "status":
- await cli.status()
- return
+ await cli.status();
+ return;
case "logout":
- await cli.logout()
- return
+ await cli.logout();
+ return;
default:
- usageAndExit()
+ usageAndExit();
}
}
function usageAndExit(): never {
- const providers = listProviders().join("|")
+ const providers = listProviders().join("|");
const models = allSupportedModels()
.map((m) => `${m.model} (${m.provider})`)
- .join(", ")
+ .join(", ");
console.log(`Usage:
claude-code-proxy serve Run proxy (PORT env or config.json port, default 18765)
Upstream is chosen per-request from ANTHROPIC_MODEL.
@@ -101,80 +105,82 @@ function usageAndExit(): never {
Providers: ${providers}
Models: ${models}
-`)
- process.exit(2)
+`);
+ process.exit(2);
}
function printSupportedModels(): void {
- const groups = new Map<string, string[]>()
+ const groups = new Map<string, string[]>();
for (const { model, provider } of allSupportedModels()) {
- const models = groups.get(provider) ?? []
- models.push(model)
- groups.set(provider, models)
+ const models = groups.get(provider) ?? [];
+ models.push(model);
+ groups.set(provider, models);
}
for (const provider of listProviders()) {
- const models = groups.get(provider) ?? []
- console.log(` ${provider}: ${models.join(", ")}`)
+ const models = groups.get(provider) ?? [];
+ console.log(` ${provider}: ${models.join(", ")}`);
}
}
function printConfigSummary(): void {
- const cfg = getConfig()
- const fromFile = cfg.file
- const overrides: string[] = []
+ const cfg = getConfig();
+ const fromFile = cfg.file;
+ const overrides: string[] = [];
- const configPath = join(configDir(), "config.json")
+ const configPath = join(configDir(), "config.json");
if (existsSync(configPath)) {
- console.log(`Config: ${configPath}`)
+ console.log(`Config: ${configPath}`);
}
- if (cfg.env.CCP_CODEX_ORIGINATOR) overrides.push("CCP_CODEX_ORIGINATOR (env)")
- else if (fromFile.codex?.originator) overrides.push("codex.originator (config)")
+ if (cfg.env.CCP_CODEX_ORIGINATOR) overrides.push("CCP_CODEX_ORIGINATOR (env)");
+ else if (fromFile.codex?.originator) overrides.push("codex.originator (config)");
- if (cfg.env.CCP_CODEX_USER_AGENT) overrides.push("CCP_CODEX_USER_AGENT (env)")
- else if (cfg.env.CCP_USER_AGENT) overrides.push("CCP_USER_AGENT (env)")
- else if (fromFile.codex?.userAgent) overrides.push("codex.userAgent (config)")
+ if (cfg.env.CCP_CODEX_USER_AGENT) overrides.push("CCP_CODEX_USER_AGENT (env)");
+ else if (cfg.env.CCP_USER_AGENT) overrides.push("CCP_USER_AGENT (env)");
+ else if (fromFile.codex?.userAgent) overrides.push("codex.userAgent (config)");
- if (cfg.env.CCP_KIMI_USER_AGENT) overrides.push("CCP_KIMI_USER_AGENT (env)")
- else if (fromFile.kimi?.userAgent) overrides.push("kimi.userAgent (config)")
+ if (cfg.env.CCP_KIMI_USER_AGENT) overrides.push("CCP_KIMI_USER_AGENT (env)");
+ else if (fromFile.kimi?.userAgent) overrides.push("kimi.userAgent (config)");
- if (cfg.env.CCP_CODEX_MODEL) overrides.push("CCP_CODEX_MODEL (env)")
- else if (fromFile.codex?.model) overrides.push("codex.model (config)")
+ if (cfg.env.CCP_CODEX_MODEL) overrides.push("CCP_CODEX_MODEL (env)");
+ else if (fromFile.codex?.model) overrides.push("codex.model (config)");
- if (cfg.env.CCP_CODEX_EFFORT) overrides.push("CCP_CODEX_EFFORT (env)")
- else if (fromFile.codex?.effort) overrides.push("codex.effort (config)")
+ if (cfg.env.CCP_CODEX_EFFORT) overrides.push("CCP_CODEX_EFFORT (env)");
+ else if (fromFile.codex?.effort) overrides.push("codex.effort (config)");
- if (cfg.env.CCP_CODEX_SERVICE_TIER) overrides.push("CCP_CODEX_SERVICE_TIER (env)")
- else if (fromFile.codex?.serviceTier) overrides.push("codex.serviceTier (config)")
+ if (cfg.env.CCP_CODEX_SERVICE_TIER) overrides.push("CCP_CODEX_SERVICE_TIER (env)");
+ else if (fromFile.codex?.serviceTier) overrides.push("codex.serviceTier (config)");
- if (cfg.env.CCP_CODEX_BASE_URL) overrides.push("CCP_CODEX_BASE_URL (env)")
- else if (fromFile.codex?.baseUrl) overrides.push("codex.baseUrl (config)")
+ if (cfg.env.CCP_CODEX_BASE_URL) overrides.push("CCP_CODEX_BASE_URL (env)");
+ else if (fromFile.codex?.baseUrl) overrides.push("codex.baseUrl (config)");
- if (cfg.env.CCP_ALIAS_PROVIDER) overrides.push(`CCP_ALIAS_PROVIDER=${configAliasProvider()} (env)`)
- else if (fromFile.aliasProvider) overrides.push(`aliasProvider=${fromFile.aliasProvider} (config)`)
+ if (cfg.env.CCP_ALIAS_PROVIDER)
+ overrides.push(`CCP_ALIAS_PROVIDER=${configAliasProvider()} (env)`);
+ else if (fromFile.aliasProvider)
+ overrides.push(`aliasProvider=${fromFile.aliasProvider} (config)`);
- if (cfg.env.CCP_LOG_VERBOSE !== undefined) overrides.push("CCP_LOG_VERBOSE (env)")
- else if (fromFile.log?.verbose) overrides.push("log.verbose (config)")
+ if (cfg.env.CCP_LOG_VERBOSE !== undefined) overrides.push("CCP_LOG_VERBOSE (env)");
+ else if (fromFile.log?.verbose) overrides.push("log.verbose (config)");
- if (cfg.env.CCP_LOG_STDERR !== undefined) overrides.push("CCP_LOG_STDERR (env)")
- else if (fromFile.log?.stderr) overrides.push("log.stderr (config)")
+ if (cfg.env.CCP_LOG_STDERR !== undefined) overrides.push("CCP_LOG_STDERR (env)");
+ else if (fromFile.log?.stderr) overrides.push("log.stderr (config)");
- if (cfg.env.CCP_KIMI_OAUTH_HOST) overrides.push("CCP_KIMI_OAUTH_HOST (env)")
- else if (fromFile.kimi?.oauthHost) overrides.push("kimi.oauthHost (config)")
+ if (cfg.env.CCP_KIMI_OAUTH_HOST) overrides.push("CCP_KIMI_OAUTH_HOST (env)");
+ else if (fromFile.kimi?.oauthHost) overrides.push("kimi.oauthHost (config)");
- if (cfg.env.CCP_KIMI_BASE_URL) overrides.push("CCP_KIMI_BASE_URL (env)")
- else if (fromFile.kimi?.baseUrl) overrides.push("kimi.baseUrl (config)")
+ if (cfg.env.CCP_KIMI_BASE_URL) overrides.push("CCP_KIMI_BASE_URL (env)");
+ else if (fromFile.kimi?.baseUrl) overrides.push("kimi.baseUrl (config)");
if (overrides.length > 0) {
- console.log("Overrides:")
+ console.log("Overrides:");
for (const o of overrides) {
- console.log(` ${o}`)
+ console.log(` ${o}`);
}
}
}
main().catch((err) => {
- log.error("cli fatal", { err: String(err), stack: (err as Error)?.stack })
- console.error(err)
- process.exit(1)
-})
+ log.error("cli fatal", { err: String(err), stack: (err as Error)?.stack });
+ console.error(err);
+ process.exit(1);
+});
diff --git a/src/config.test.ts b/src/config.test.ts
index 7bcaec4..aa5e10b 100644
--- a/src/config.test.ts
+++ b/src/config.test.ts
@@ -1,7 +1,7 @@
-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 { 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,
@@ -17,67 +17,64 @@ import {
kimiBaseUrl,
logVerbose,
logStderr,
-} from "./config.ts"
+} from "./config.ts";
-let dir: string
-let configPath: string
+let dir: string;
+let configPath: string;
function setEnv(env: NodeJS.ProcessEnv) {
- loadConfig({ configPath, env, forceReload: true })
+ loadConfig({ configPath, env, forceReload: true });
}
beforeEach(() => {
- dir = mkdtempSync(join(tmpdir(), "ccp-config-"))
- configPath = join(dir, "config.json")
-})
+ dir = mkdtempSync(join(tmpdir(), "ccp-config-"));
+ configPath = join(dir, "config.json");
+});
afterEach(() => {
- rmSync(dir, { recursive: true, force: true })
+ 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 })
-})
+ 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(codexServiceTier()).toBeUndefined()
- expect(codexBaseUrl("default-codex-url")).toBe("default-codex-url")
- expect(aliasProvider()).toBe("codex")
- 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)
- })
-})
+ 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(codexServiceTier()).toBeUndefined();
+ expect(codexBaseUrl("default-codex-url")).toBe("default-codex-url");
+ expect(aliasProvider()).toBe("codex");
+ 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)
- })
+ 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")
- })
+ writeFileSync(configPath, JSON.stringify({ codex: { userAgent: "ccp/file" } }));
+ setEnv({});
+ expect(codexUserAgent("default")).toBe("ccp/file");
+ });
it("codex.serviceTier from config.json", () => {
- writeFileSync(configPath, JSON.stringify({ codex: { serviceTier: "fast" } }))
- setEnv({})
- expect(codexServiceTier()).toBe("fast")
- })
+ writeFileSync(configPath, JSON.stringify({ codex: { serviceTier: "fast" } }));
+ setEnv({});
+ expect(codexServiceTier()).toBe("fast");
+ });
it("codex.baseUrl from config.json", () => {
writeFileSync(
@@ -85,168 +82,154 @@ describe("file overrides default", () => {
JSON.stringify({
codex: { baseUrl: "http://127.0.0.1:2455/backend-api/codex/responses" },
}),
- )
- setEnv({})
- expect(codexBaseUrl("default")).toBe(
- "http://127.0.0.1:2455/backend-api/codex/responses",
- )
- })
+ );
+ setEnv({});
+ expect(codexBaseUrl("default")).toBe("http://127.0.0.1:2455/backend-api/codex/responses");
+ });
it("aliasProvider from config.json", () => {
- writeFileSync(configPath, JSON.stringify({ aliasProvider: "codex" }))
- setEnv({})
- expect(aliasProvider()).toBe("codex")
- })
+ writeFileSync(configPath, JSON.stringify({ aliasProvider: "codex" }));
+ setEnv({});
+ expect(aliasProvider()).toBe("codex");
+ });
it("kimi.oauthHost from config.json", () => {
- writeFileSync(
- configPath,
- JSON.stringify({ kimi: { oauthHost: "https://auth.example.com" } }),
- )
- setEnv({})
- expect(kimiOauthHost()).toBe("https://auth.example.com")
- })
+ 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)
- })
-})
+ 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)
- })
+ 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")
- })
+ writeFileSync(configPath, JSON.stringify({ codex: { userAgent: "from-file" } }));
+ setEnv({ CCP_CODEX_USER_AGENT: "from-env" });
+ expect(codexUserAgent("default")).toBe("from-env");
+ });
it("CCP_CODEX_SERVICE_TIER env wins over config", () => {
- writeFileSync(configPath, JSON.stringify({ codex: { serviceTier: "flex" } }))
- setEnv({ CCP_CODEX_SERVICE_TIER: "fast" })
- expect(codexServiceTier()).toBe("fast")
- })
+ writeFileSync(configPath, JSON.stringify({ codex: { serviceTier: "flex" } }));
+ setEnv({ CCP_CODEX_SERVICE_TIER: "fast" });
+ expect(codexServiceTier()).toBe("fast");
+ });
it("CCP_CODEX_BASE_URL env wins over config", () => {
- writeFileSync(
- configPath,
- JSON.stringify({ codex: { baseUrl: "http://127.0.0.1:2455/file" } }),
- )
- setEnv({ CCP_CODEX_BASE_URL: "http://127.0.0.1:2455/env" })
- expect(codexBaseUrl("default")).toBe("http://127.0.0.1:2455/env")
- })
+ writeFileSync(configPath, JSON.stringify({ codex: { baseUrl: "http://127.0.0.1:2455/file" } }));
+ setEnv({ CCP_CODEX_BASE_URL: "http://127.0.0.1:2455/env" });
+ expect(codexBaseUrl("default")).toBe("http://127.0.0.1:2455/env");
+ });
it("CCP_ALIAS_PROVIDER env wins over config", () => {
- writeFileSync(configPath, JSON.stringify({ aliasProvider: "kimi" }))
- setEnv({ CCP_ALIAS_PROVIDER: "codex" })
- expect(aliasProvider()).toBe("codex")
- })
+ writeFileSync(configPath, JSON.stringify({ aliasProvider: "kimi" }));
+ setEnv({ CCP_ALIAS_PROVIDER: "codex" });
+ expect(aliasProvider()).toBe("codex");
+ });
it("CCP_USER_AGENT env (generic fallback) is preferred over file", () => {
- writeFileSync(
- configPath,
- JSON.stringify({ codex: { userAgent: "from-file" } }),
- )
- setEnv({ CCP_USER_AGENT: "generic-env" })
- expect(codexUserAgent("default")).toBe("generic-env")
- expect(kimiUserAgent("default")).toBe("generic-env")
- })
+ 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)
- })
-})
+ 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")
- })
+ 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()
- })
+ setEnv({ CCP_CODEX_MODEL: "" });
+ expect(codexModel()).toBeUndefined();
+ });
it("empty CCP_CODEX_SERVICE_TIER env falls through to file value", () => {
- writeFileSync(configPath, JSON.stringify({ codex: { serviceTier: "flex" } }))
- setEnv({ CCP_CODEX_SERVICE_TIER: "" })
- expect(codexServiceTier()).toBe("flex")
- })
+ writeFileSync(configPath, JSON.stringify({ codex: { serviceTier: "flex" } }));
+ setEnv({ CCP_CODEX_SERVICE_TIER: "" });
+ expect(codexServiceTier()).toBe("flex");
+ });
it("empty CCP_ALIAS_PROVIDER env falls through to file value", () => {
- writeFileSync(configPath, JSON.stringify({ aliasProvider: "codex" }))
- setEnv({ CCP_ALIAS_PROVIDER: "" })
- expect(aliasProvider()).toBe("codex")
- })
+ writeFileSync(configPath, JSON.stringify({ aliasProvider: "codex" }));
+ setEnv({ CCP_ALIAS_PROVIDER: "" });
+ expect(aliasProvider()).toBe("codex");
+ });
it("invalid CCP_ALIAS_PROVIDER env falls through to file value", () => {
- writeFileSync(configPath, JSON.stringify({ aliasProvider: "codex" }))
- setEnv({ CCP_ALIAS_PROVIDER: "openai" })
- expect(aliasProvider()).toBe("codex")
- })
+ writeFileSync(configPath, JSON.stringify({ aliasProvider: "codex" }));
+ setEnv({ CCP_ALIAS_PROVIDER: "openai" });
+ expect(aliasProvider()).toBe("codex");
+ });
it("empty PORT env falls through to file value", () => {
- writeFileSync(configPath, JSON.stringify({ port: 33333 }))
- setEnv({ PORT: "" })
- expect(port()).toBe(33333)
- })
-})
+ 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("")
- })
+ setEnv({ CCP_CODEX_USER_AGENT: "" });
+ expect(codexUserAgent("default-ua")).toBe("");
+ });
it("empty CCP_KIMI_OAUTH_HOST env is a valid value (legacy ?? semantics)", () => {
- setEnv({ CCP_KIMI_OAUTH_HOST: "" })
- expect(kimiOauthHost()).toBe("")
- })
+ setEnv({ CCP_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)
- })
-})
+ 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)
- })
+ 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")
- })
+ );
+ setEnv({});
+ expect(port()).toBe(18765);
+ expect(codexUserAgent("default")).toBe("good");
+ });
it("ignores invalid aliasProvider values", () => {
- writeFileSync(configPath, JSON.stringify({ aliasProvider: "openai" }))
- setEnv({})
- expect(aliasProvider()).toBe("codex")
- })
+ writeFileSync(configPath, JSON.stringify({ aliasProvider: "openai" }));
+ setEnv({});
+ expect(aliasProvider()).toBe("codex");
+ });
it("returns defaults when file is missing entirely", () => {
- setEnv({})
- expect(port()).toBe(18765)
- })
-})
+ setEnv({});
+ expect(port()).toBe(18765);
+ });
+});
diff --git a/src/config.ts b/src/config.ts
index abaee4a..74ee139 100644
--- a/src/config.ts
+++ b/src/config.ts
@@ -1,6 +1,6 @@
-import { readFileSync } from "node:fs"
-import { join } from "node:path"
-import { configDir } from "./paths.ts"
+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
@@ -9,97 +9,97 @@ import { configDir } from "./paths.ts"
// from either env or the file are treated as "unset" so they fall through
// to the next layer (matches existing CCP_CODEX_MODEL behavior).
-export type AliasProvider = "codex" | "kimi"
+export type AliasProvider = "codex" | "kimi";
export interface FileConfig {
- port?: number
- aliasProvider?: AliasProvider
+ port?: number;
+ aliasProvider?: AliasProvider;
codex?: {
- originator?: string
- userAgent?: string
- model?: string
- effort?: string
- serviceTier?: string
- baseUrl?: string
- }
+ originator?: string;
+ userAgent?: string;
+ model?: string;
+ effort?: string;
+ serviceTier?: string;
+ baseUrl?: string;
+ };
kimi?: {
- userAgent?: string
- oauthHost?: string
- baseUrl?: string
- }
+ userAgent?: string;
+ oauthHost?: string;
+ baseUrl?: string;
+ };
log?: {
- stderr?: boolean
- verbose?: boolean
- }
+ stderr?: boolean;
+ verbose?: boolean;
+ };
}
interface LoadedConfig {
- file: FileConfig
- env: NodeJS.ProcessEnv
+ file: FileConfig;
+ env: NodeJS.ProcessEnv;
}
interface LoadOptions {
- configPath?: string
- env?: NodeJS.ProcessEnv
- forceReload?: boolean
+ configPath?: string;
+ env?: NodeJS.ProcessEnv;
+ forceReload?: boolean;
}
-let cached: LoadedConfig | undefined
+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
+ 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 parseAliasProvider(key: string, value: unknown): AliasProvider | undefined {
- if (value === undefined) return undefined
- if (value === "codex" || value === "kimi") return value
- warnInvalid(key, '"codex" or "kimi"', value)
- return undefined
+ if (value === undefined) return undefined;
+ if (value === "codex" || value === "kimi") return value;
+ warnInvalid(key, '"codex" or "kimi"', value);
+ return undefined;
}
function validate(raw: unknown): FileConfig {
- if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {}
- const r = raw as Record<string, unknown>
- const out: 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)
+ if (typeof r.port === "number" && Number.isFinite(r.port)) out.port = r.port;
+ else warnInvalid("port", "number", r.port);
}
- out.aliasProvider = parseAliasProvider("aliasProvider", r.aliasProvider)
+ out.aliasProvider = parseAliasProvider("aliasProvider", r.aliasProvider);
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 (r[key] === undefined) return undefined;
+ const sec = r[key];
if (!sec || typeof sec !== "object" || Array.isArray(sec)) {
- warnInvalid(key, "object", sec)
- return undefined
+ warnInvalid(key, "object", sec);
+ return undefined;
}
- const acc: Record<string, unknown> = {}
+ 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)
+ 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]>
- }
+ return acc as NonNullable<FileConfig[K]>;
+ };
const codex = validateStringSection(
"codex",
@@ -112,57 +112,57 @@ function validate(raw: unknown): FileConfig {
serviceTier: "string",
baseUrl: "string",
},
- )
- if (codex) out.codex = codex
+ );
+ if (codex) out.codex = codex;
const kimi = validateStringSection("kimi", ["userAgent", "oauthHost", "baseUrl"], {
userAgent: "string",
oauthHost: "string",
baseUrl: "string",
- })
- if (kimi) out.kimi = kimi
+ });
+ if (kimi) out.kimi = kimi;
const log = validateStringSection("log", ["stderr", "verbose"], {
stderr: "boolean",
verbose: "boolean",
- })
- if (log) out.log = log
+ });
+ if (log) out.log = log;
- return out
+ return out;
}
export function loadConfig(opts: LoadOptions = {}): LoadedConfig {
if (cached && !opts.forceReload && !opts.configPath && !opts.env) {
- return cached
+ return cached;
}
- const env = opts.env ?? process.env
- const path = opts.configPath ?? join(configDir(), "config.json")
- let file: FileConfig = {}
+ const env = opts.env ?? process.env;
+ const path = opts.configPath ?? join(configDir(), "config.json");
+ let file: FileConfig = {};
try {
- const raw = readFileSync(path, "utf8")
+ const raw = readFileSync(path, "utf8");
try {
- file = validate(JSON.parse(raw))
+ 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 }
+ 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
+ if (opts.forceReload || (!opts.configPath && !opts.env)) cached = result;
+ return result;
}
export function getConfig(): LoadedConfig {
- return cached ?? loadConfig()
+ return cached ?? loadConfig();
}
// Per-setting getters. Each encodes its precedence chain explicitly.
@@ -171,81 +171,76 @@ export function getConfig(): LoadedConfig {
// 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
+ const c = getConfig();
+ const envPort = c.env.PORT;
if (envPort !== undefined && envPort !== "") {
- const n = Number(envPort)
- if (Number.isFinite(n)) return n
+ const n = Number(envPort);
+ if (Number.isFinite(n)) return n;
}
- return c.file.port ?? 18765
+ return c.file.port ?? 18765;
}
export function codexOriginator(defaultValue: string): string {
- const c = getConfig()
+ const c = getConfig();
return (
- c.env.CCP_CODEX_ORIGINATOR ??
- c.env.CCP_ORIGINATOR ??
- c.file.codex?.originator ??
- defaultValue
- )
+ c.env.CCP_CODEX_ORIGINATOR ?? c.env.CCP_ORIGINATOR ?? c.file.codex?.originator ?? defaultValue
+ );
}
export function codexUserAgent(defaultValue: string): string {
- const c = getConfig()
+ const c = getConfig();
return (
- c.env.CCP_CODEX_USER_AGENT ??
- c.env.CCP_USER_AGENT ??
- c.file.codex?.userAgent ??
- defaultValue
- )
+ 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)
+ 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)
+ const c = getConfig();
+ return emptyOrUnset(c.env.CCP_CODEX_EFFORT) ?? emptyOrUnset(c.file.codex?.effort);
}
export function codexServiceTier(): string | undefined {
- const c = getConfig()
- return emptyOrUnset(c.env.CCP_CODEX_SERVICE_TIER) ?? emptyOrUnset(c.file.codex?.serviceTier)
+ const c = getConfig();
+ return emptyOrUnset(c.env.CCP_CODEX_SERVICE_TIER) ?? emptyOrUnset(c.file.codex?.serviceTier);
}
export function codexBaseUrl(defaultValue: string): string {
- const c = getConfig()
- return c.env.CCP_CODEX_BASE_URL ?? c.file.codex?.baseUrl ?? defaultValue
+ const c = getConfig();
+ return c.env.CCP_CODEX_BASE_URL ?? c.file.codex?.baseUrl ?? defaultValue;
}
export function aliasProvider(): AliasProvider {
- const c = getConfig()
- return parseAliasProvider("CCP_ALIAS_PROVIDER", emptyOrUnset(c.env.CCP_ALIAS_PROVIDER)) ?? c.file.aliasProvider ?? "codex"
+ const c = getConfig();
+ return (
+ parseAliasProvider("CCP_ALIAS_PROVIDER", emptyOrUnset(c.env.CCP_ALIAS_PROVIDER)) ??
+ c.file.aliasProvider ??
+ "codex"
+ );
}
export function kimiUserAgent(defaultValue: string): string {
- const c = getConfig()
+ const c = getConfig();
return (
- c.env.CCP_KIMI_USER_AGENT ??
- c.env.CCP_USER_AGENT ??
- c.file.kimi?.userAgent ??
- defaultValue
- )
+ 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.CCP_KIMI_OAUTH_HOST ?? c.file.kimi?.oauthHost ?? "https://auth.kimi.com"
+ const c = getConfig();
+ return c.env.CCP_KIMI_OAUTH_HOST ?? c.file.kimi?.oauthHost ?? "https://auth.kimi.com";
}
export function kimiBaseUrl(): string {
- const c = getConfig()
- return c.env.CCP_KIMI_BASE_URL ?? c.file.kimi?.baseUrl ?? "https://api.kimi.com/coding/v1"
+ const c = getConfig();
+ return c.env.CCP_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
@@ -253,13 +248,13 @@ export function kimiBaseUrl(): string {
// 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
+ 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
+ const c = getConfig();
+ if (c.env.CCP_LOG_VERBOSE !== undefined) return true;
+ return c.file.log?.verbose ?? false;
}
diff --git a/src/keychain.ts b/src/keychain.ts
index 5a318c5..2c3d44e 100644
--- a/src/keychain.ts
+++ b/src/keychain.ts
@@ -1,28 +1,48 @@
-import { dlopen, FFIType, ptr, toArrayBuffer, type Pointer } from "bun:ffi"
+import { dlopen, FFIType, ptr, toArrayBuffer, type Pointer } from "bun:ffi";
-const errSecSuccess = 0
-const errSecItemNotFound = -25300
-const errSecDuplicateItem = -25299
+const errSecSuccess = 0;
+const errSecItemNotFound = -25300;
+const errSecDuplicateItem = -25299;
function readPtr(buf: Uint8Array): Pointer {
- return Number(new DataView(buf.buffer, buf.byteOffset).getBigUint64(0, true)) as unknown as Pointer
+ return Number(
+ new DataView(buf.buffer, buf.byteOffset).getBigUint64(0, true),
+ ) as unknown as Pointer;
}
-let _sym: ReturnType<typeof loadLib>["symbols"] | undefined
+let _sym: ReturnType<typeof loadLib>["symbols"] | undefined;
function sym() {
- if (!_sym) _sym = loadLib().symbols
- return _sym
+ if (!_sym) _sym = loadLib().symbols;
+ return _sym;
}
function loadLib() {
return dlopen("/System/Library/Frameworks/Security.framework/Security", {
SecKeychainAddGenericPassword: {
- args: [FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr],
+ args: [
+ FFIType.ptr,
+ FFIType.u32,
+ FFIType.ptr,
+ FFIType.u32,
+ FFIType.ptr,
+ FFIType.u32,
+ FFIType.ptr,
+ FFIType.ptr,
+ ],
returns: FFIType.i32,
},
SecKeychainFindGenericPassword: {
- args: [FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr],
+ args: [
+ FFIType.ptr,
+ FFIType.u32,
+ FFIType.ptr,
+ FFIType.u32,
+ FFIType.ptr,
+ FFIType.ptr,
+ FFIType.ptr,
+ FFIType.ptr,
+ ],
returns: FFIType.i32,
},
SecKeychainItemModifyAttributesAndData: {
@@ -41,96 +61,113 @@ function loadLib() {
args: [FFIType.ptr],
returns: FFIType.void,
},
- } as const)
+ } as const);
}
export function keychainGet(service: string, account: string): string | undefined {
- const svc = Buffer.from(service)
- const acc = Buffer.from(account)
- const lenBuf = new Uint8Array(4)
- const dataBuf = new Uint8Array(8)
+ const svc = Buffer.from(service);
+ const acc = Buffer.from(account);
+ const lenBuf = new Uint8Array(4);
+ const dataBuf = new Uint8Array(8);
const s = sym().SecKeychainFindGenericPassword(
null,
- svc.byteLength, ptr(svc),
- acc.byteLength, ptr(acc),
- ptr(lenBuf), ptr(dataBuf),
+ svc.byteLength,
+ ptr(svc),
+ acc.byteLength,
+ ptr(acc),
+ ptr(lenBuf),
+ ptr(dataBuf),
null,
- ) as number
+ ) as number;
- if (s === errSecItemNotFound) return undefined
- if (s !== errSecSuccess) throw keychainError("read", s)
+ if (s === errSecItemNotFound) return undefined;
+ if (s !== errSecSuccess) throw keychainError("read", s);
- const dataPtr = readPtr(dataBuf)
- const dataLen = new DataView(lenBuf.buffer).getUint32(0, true)
- const result = Buffer.from(toArrayBuffer(dataPtr, 0, dataLen)).toString("utf8")
- sym().SecKeychainItemFreeContent(null, dataPtr)
- return result
+ const dataPtr = readPtr(dataBuf);
+ const dataLen = new DataView(lenBuf.buffer).getUint32(0, true);
+ const result = Buffer.from(toArrayBuffer(dataPtr, 0, dataLen)).toString("utf8");
+ sym().SecKeychainItemFreeContent(null, dataPtr);
+ return result;
}
export function keychainSet(service: string, account: string, password: string): void {
- const svc = Buffer.from(service)
- const acc = Buffer.from(account)
- const pwd = Buffer.from(password)
- const itemBuf = new Uint8Array(8)
+ const svc = Buffer.from(service);
+ const acc = Buffer.from(account);
+ const pwd = Buffer.from(password);
+ const itemBuf = new Uint8Array(8);
let s = sym().SecKeychainAddGenericPassword(
null,
- svc.byteLength, ptr(svc),
- acc.byteLength, ptr(acc),
- pwd.byteLength, ptr(pwd),
+ svc.byteLength,
+ ptr(svc),
+ acc.byteLength,
+ ptr(acc),
+ pwd.byteLength,
+ ptr(pwd),
ptr(itemBuf),
- ) as number
+ ) as number;
if (s === errSecSuccess) {
- const ref = readPtr(itemBuf)
- if (ref) sym().CFRelease(ref)
- return
+ const ref = readPtr(itemBuf);
+ if (ref) sym().CFRelease(ref);
+ return;
}
- if (s !== errSecDuplicateItem) throw keychainError("add", s)
+ if (s !== errSecDuplicateItem) throw keychainError("add", s);
// Item exists — find it and update in place
- const itemBuf2 = new Uint8Array(8)
+ const itemBuf2 = new Uint8Array(8);
s = sym().SecKeychainFindGenericPassword(
null,
- svc.byteLength, ptr(svc),
- acc.byteLength, ptr(acc),
- null, null,
+ svc.byteLength,
+ ptr(svc),
+ acc.byteLength,
+ ptr(acc),
+ null,
+ null,
ptr(itemBuf2),
- ) as number
- if (s !== errSecSuccess) throw keychainError("find for update", s)
+ ) as number;
+ if (s !== errSecSuccess) throw keychainError("find for update", s);
- const itemRef = readPtr(itemBuf2)
- s = sym().SecKeychainItemModifyAttributesAndData(itemRef, null, pwd.byteLength, ptr(pwd)) as number
- sym().CFRelease(itemRef)
- if (s !== errSecSuccess) throw keychainError("update", s)
+ const itemRef = readPtr(itemBuf2);
+ s = sym().SecKeychainItemModifyAttributesAndData(
+ itemRef,
+ null,
+ pwd.byteLength,
+ ptr(pwd),
+ ) as number;
+ sym().CFRelease(itemRef);
+ if (s !== errSecSuccess) throw keychainError("update", s);
}
export function keychainDelete(service: string, account: string): void {
- const svc = Buffer.from(service)
- const acc = Buffer.from(account)
- const itemBuf = new Uint8Array(8)
+ const svc = Buffer.from(service);
+ const acc = Buffer.from(account);
+ const itemBuf = new Uint8Array(8);
const s = sym().SecKeychainFindGenericPassword(
null,
- svc.byteLength, ptr(svc),
- acc.byteLength, ptr(acc),
- null, null,
+ svc.byteLength,
+ ptr(svc),
+ acc.byteLength,
+ ptr(acc),
+ null,
+ null,
ptr(itemBuf),
- ) as number
+ ) as number;
- if (s === errSecItemNotFound) return
- if (s !== errSecSuccess) throw keychainError("find for delete", s)
+ if (s === errSecItemNotFound) return;
+ if (s !== errSecSuccess) throw keychainError("find for delete", s);
- const itemRef = readPtr(itemBuf)
- const delStatus = sym().SecKeychainItemDelete(itemRef) as number
- sym().CFRelease(itemRef)
- if (delStatus !== errSecSuccess) throw keychainError("delete", delStatus)
+ const itemRef = readPtr(itemBuf);
+ const delStatus = sym().SecKeychainItemDelete(itemRef) as number;
+ sym().CFRelease(itemRef);
+ if (delStatus !== errSecSuccess) throw keychainError("delete", delStatus);
}
function keychainError(op: string, code: number): Error {
- const err = new Error(`Keychain ${op} failed: ${code}`) as Error & { code: number }
- err.code = code
- return err
+ const err = new Error(`Keychain ${op} failed: ${code}`) as Error & { code: number };
+ err.code = code;
+ return err;
}
diff --git a/src/log.ts b/src/log.ts
index 07c0e9f..9dee9ce 100644
--- a/src/log.ts
+++ b/src/log.ts
@@ -1,10 +1,10 @@
-import { mkdir, stat, rename } from "node:fs/promises"
-import { createWriteStream, type WriteStream } from "node:fs"
-import { dirname } from "node:path"
-import { logFile } from "./paths.ts"
-import { logStderr, logVerbose } from "./config.ts"
+import { mkdir, stat, rename } from "node:fs/promises";
+import { createWriteStream, type WriteStream } from "node:fs";
+import { dirname } from "node:path";
+import { logFile } from "./paths.ts";
+import { logStderr, logVerbose } from "./config.ts";
-const MAX_LOG_BYTES = 20 * 1024 * 1024 // 20 MiB
+const MAX_LOG_BYTES = 20 * 1024 * 1024; // 20 MiB
export const REDACT_KEYS = new Set([
"authorization",
"access",
@@ -16,108 +16,110 @@ export const REDACT_KEYS = new Set([
"code_verifier",
"chatgpt-account-id",
"x-api-key",
-])
+]);
-export { logFile }
+export { logFile };
export function logDir(): string {
- return dirname(logFile())
+ return dirname(logFile());
}
-let stream: WriteStream | undefined
-let rotating: Promise<void> | undefined
+let stream: WriteStream | undefined;
+let rotating: Promise<void> | undefined;
async function ensureStream(): Promise<WriteStream> {
- if (stream) return stream
- const file = logFile()
- await mkdir(dirname(file), { recursive: true })
- stream = createWriteStream(file, { flags: "a", mode: 0o600 })
- return stream
+ if (stream) return stream;
+ const file = logFile();
+ await mkdir(dirname(file), { recursive: true });
+ stream = createWriteStream(file, { flags: "a", mode: 0o600 });
+ return stream;
}
async function maybeRotate(): Promise<void> {
- if (rotating) return rotating
+ if (rotating) return rotating;
rotating = (async () => {
try {
- const file = logFile()
- const s = await stat(file).catch(() => undefined)
- if (!s || s.size < MAX_LOG_BYTES) return
- const rotated = `${file}.${Date.now()}`
- await rename(file, rotated)
+ const file = logFile();
+ const s = await stat(file).catch(() => undefined);
+ if (!s || s.size < MAX_LOG_BYTES) return;
+ const rotated = `${file}.${Date.now()}`;
+ await rename(file, rotated);
if (stream) {
- stream.end()
- stream = undefined
+ stream.end();
+ stream = undefined;
}
} catch {
// Never propagate rotation errors — logging must never crash the proxy.
} finally {
- rotating = undefined
+ rotating = undefined;
}
- })()
- return rotating
+ })();
+ return rotating;
}
function redact(value: unknown, depth = 0): unknown {
- if (depth > 6) return "[depth-limit]"
- if (value == null) return value
+ if (depth > 6) return "[depth-limit]";
+ if (value == null) return value;
if (typeof value === "string") {
- if (!logVerbose() && value.length > 4000) return value.slice(0, 4000) + `…[${value.length - 4000} more]`
- return value
+ if (!logVerbose() && value.length > 4000)
+ return value.slice(0, 4000) + `…[${value.length - 4000} more]`;
+ return value;
}
- if (typeof value !== "object") return value
- if (Array.isArray(value)) return value.map((v) => redact(v, depth + 1))
- const out: Record<string, unknown> = {}
+ if (typeof value !== "object") return value;
+ if (Array.isArray(value)) return value.map((v) => redact(v, depth + 1));
+ const out: Record<string, unknown> = {};
for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
if (REDACT_KEYS.has(k.toLowerCase())) {
- out[k] = typeof v === "string" ? `[redacted len=${v.length}]` : "[redacted]"
+ out[k] = typeof v === "string" ? `[redacted len=${v.length}]` : "[redacted]";
} else {
- out[k] = redact(v, depth + 1)
+ out[k] = redact(v, depth + 1);
}
}
- return out
+ return out;
}
-type Level = "debug" | "info" | "warn" | "error"
+type Level = "debug" | "info" | "warn" | "error";
-async function write(level: Level, service: string, msg: string, fields?: Record<string, unknown>): Promise<void> {
+async function write(
+ level: Level,
+ service: string,
+ msg: string,
+ fields?: Record<string, unknown>,
+): Promise<void> {
const line = JSON.stringify({
t: new Date().toISOString(),
level,
service,
msg,
...(fields ? { fields: redact(fields) as Record<string, unknown> } : {}),
- })
+ });
try {
- const s = await ensureStream()
- s.write(line + "\n")
- maybeRotate().catch(() => {})
+ const s = await ensureStream();
+ s.write(line + "\n");
+ maybeRotate().catch(() => {});
} catch {
// swallow; also print to stderr for visibility
}
if (level === "error" || level === "warn" || logStderr()) {
- process.stderr.write(line + "\n")
+ process.stderr.write(line + "\n");
}
}
export interface Logger {
- debug(msg: string, fields?: Record<string, unknown>): void
- info(msg: string, fields?: Record<string, unknown>): void
- warn(msg: string, fields?: Record<string, unknown>): void
- error(msg: string, fields?: Record<string, unknown>): void
- child(bindings: Record<string, unknown>): Logger
+ debug(msg: string, fields?: Record<string, unknown>): void;
+ info(msg: string, fields?: Record<string, unknown>): void;
+ warn(msg: string, fields?: Record<string, unknown>): void;
+ error(msg: string, fields?: Record<string, unknown>): void;
+ child(bindings: Record<string, unknown>): Logger;
}
-export function createLogger(
- service: string,
- baseFields: Record<string, unknown> = {},
-): Logger {
- const merge = (f?: Record<string, unknown>) =>
- f ? { ...baseFields, ...f } : baseFields
+export function createLogger(service: string, baseFields: Record<string, unknown> = {}): Logger {
+ const merge = (f?: Record<string, unknown>) => (f ? { ...baseFields, ...f } : baseFields);
return {
debug: (msg, fields) => void write("debug", service, msg, merge(fields)),
info: (msg, fields) => void write("info", service, msg, merge(fields)),
warn: (msg, fields) => void write("warn", service, msg, merge(fields)),
error: (msg, fields) => void write("error", service, msg, merge(fields)),
child: (bindings) => createLogger(service, { ...baseFields, ...bindings }),
- }
+ };
}
diff --git a/src/paths.test.ts b/src/paths.test.ts
index 682b90f..30ca864 100644
--- a/src/paths.test.ts
+++ b/src/paths.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it } from "bun:test"
+import { describe, expect, it } from "bun:test";
import {
codexAuthFile,
kimiAuthFile,
@@ -6,26 +6,26 @@ import {
legacyConfigDir,
resolveConfigDir,
resolveStateDir,
-} from "./paths.ts"
+} 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")
- })
+ ).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")
- })
+ ).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",
- )
- })
+ );
+ });
it("uses APPDATA on windows", () => {
expect(
@@ -34,34 +34,34 @@ describe("resolveConfigDir", () => {
env: { APPDATA: "C:\\Users\\u\\AppData\\Roaming" },
home: "C:\\Users\\u",
}),
- ).toBe("C:\\Users\\u\\AppData\\Roaming\\claude-code-proxy")
- })
+ ).toBe("C:\\Users\\u\\AppData\\Roaming\\claude-code-proxy");
+ });
it("falls back to $HOME/AppData/Roaming on windows without APPDATA", () => {
expect(resolveConfigDir({ platform: "win32", env: {}, home: "C:\\Users\\u" })).toBe(
"C:\\Users\\u\\AppData\\Roaming\\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")
- })
+ ).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")
- })
+ ).toBe("/x/claude-code-proxy");
+ });
it("uses LOCALAPPDATA on windows", () => {
expect(
@@ -70,8 +70,8 @@ describe("resolveStateDir", () => {
env: { LOCALAPPDATA: "C:\\Users\\u\\AppData\\Local" },
home: "C:\\Users\\u",
}),
- ).toBe("C:\\Users\\u\\AppData\\Local\\claude-code-proxy")
- })
+ ).toBe("C:\\Users\\u\\AppData\\Local\\claude-code-proxy");
+ });
it("falls back to $HOME/AppData/Local on windows without LOCALAPPDATA", () => {
expect(
@@ -80,9 +80,9 @@ describe("resolveStateDir", () => {
env: { APPDATA: "C:\\Users\\u\\AppData\\Roaming" },
home: "C:\\Users\\u",
}),
- ).toBe("C:\\Users\\u\\AppData\\Local\\claude-code-proxy")
- })
-})
+ ).toBe("C:\\Users\\u\\AppData\\Local\\claude-code-proxy");
+ });
+});
describe("provider paths", () => {
it("resolves provider files under the windows config directory", () => {
@@ -90,21 +90,21 @@ describe("provider paths", () => {
platform: "win32" as const,
env: { APPDATA: "C:\\Users\\u\\AppData\\Roaming" },
home: "C:\\Users\\u",
- }
+ };
expect(codexAuthFile(deps)).toBe(
"C:\\Users\\u\\AppData\\Roaming\\claude-code-proxy\\codex\\auth.json",
- )
+ );
expect(kimiAuthFile(deps)).toBe(
"C:\\Users\\u\\AppData\\Roaming\\claude-code-proxy\\kimi\\auth.json",
- )
+ );
expect(kimiDeviceIdFile(deps)).toBe(
"C:\\Users\\u\\AppData\\Roaming\\claude-code-proxy\\kimi\\device_id",
- )
- })
+ );
+ });
it("keeps the legacy config directory independent of platform", () => {
expect(legacyConfigDir({ platform: "win32", env: {}, home: "C:\\Users\\u" })).toBe(
"C:\\Users\\u\\.config\\claude-code-proxy",
- )
- })
-})
+ );
+ });
+});
diff --git a/src/paths.ts b/src/paths.ts
index 5d346d0..d06515d 100644
--- a/src/paths.ts
+++ b/src/paths.ts
@@ -1,52 +1,52 @@
-import { homedir } from "node:os"
-import { posix, win32 } from "node:path"
+import { homedir } from "node:os";
+import { posix, win32 } from "node:path";
export interface DirResolverEnv {
- platform: NodeJS.Platform
- env: NodeJS.ProcessEnv
- home: string
+ platform: NodeJS.Platform;
+ env: NodeJS.ProcessEnv;
+ home: string;
}
function defaults(): DirResolverEnv {
- return { platform: process.platform, env: process.env, home: homedir() }
+ return { platform: process.platform, env: process.env, home: homedir() };
}
function pathFor(platform: NodeJS.Platform) {
- return platform === "win32" ? win32 : posix
+ return platform === "win32" ? win32 : posix;
}
function windowsRoamingAppData(deps: DirResolverEnv): string {
- return deps.env.APPDATA || win32.join(deps.home, "AppData", "Roaming")
+ return deps.env.APPDATA || win32.join(deps.home, "AppData", "Roaming");
}
function windowsLocalAppData(deps: DirResolverEnv): string {
- return deps.env.LOCALAPPDATA || win32.join(deps.home, "AppData", "Local")
+ return deps.env.LOCALAPPDATA || win32.join(deps.home, "AppData", "Local");
}
// 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 {
- const path = pathFor(deps.platform)
+ const path = pathFor(deps.platform);
if (deps.platform === "win32") {
- return path.join(windowsRoamingAppData(deps), "claude-code-proxy")
+ return path.join(windowsRoamingAppData(deps), "claude-code-proxy");
}
if (deps.platform === "darwin") {
- return path.join(deps.home, ".config", "claude-code-proxy")
+ return path.join(deps.home, ".config", "claude-code-proxy");
}
- const base = deps.env.XDG_CONFIG_HOME || path.join(deps.home, ".config")
- return path.join(base, "claude-code-proxy")
+ const base = deps.env.XDG_CONFIG_HOME || path.join(deps.home, ".config");
+ return path.join(base, "claude-code-proxy");
}
// XDG_STATE_HOME is honored on macOS and Unix platforms — that's the
// pre-config.json behavior of log.ts and is documented in the README.
export function resolveStateDir(deps: DirResolverEnv): string {
- const path = pathFor(deps.platform)
+ const path = pathFor(deps.platform);
if (deps.platform === "win32") {
- return path.join(windowsLocalAppData(deps), "claude-code-proxy")
+ return path.join(windowsLocalAppData(deps), "claude-code-proxy");
}
- const base = deps.env.XDG_STATE_HOME || path.join(deps.home, ".local", "state")
- return path.join(base, "claude-code-proxy")
+ const base = deps.env.XDG_STATE_HOME || path.join(deps.home, ".local", "state");
+ return path.join(base, "claude-code-proxy");
}
// Legacy (pre-config.json) auth/device-id path. Always ~/.config regardless
@@ -54,29 +54,29 @@ export function resolveStateDir(deps: DirResolverEnv): string {
// configDir() existed. Used as a read-only fallback so existing logins keep
// working after upgrade.
export function legacyConfigDir(deps: DirResolverEnv = defaults()): string {
- return pathFor(deps.platform).join(deps.home, ".config", "claude-code-proxy")
+ return pathFor(deps.platform).join(deps.home, ".config", "claude-code-proxy");
}
export function codexAuthFile(deps: DirResolverEnv = defaults()): string {
- return pathFor(deps.platform).join(resolveConfigDir(deps), "codex", "auth.json")
+ return pathFor(deps.platform).join(resolveConfigDir(deps), "codex", "auth.json");
}
export function kimiAuthFile(deps: DirResolverEnv = defaults()): string {
- return pathFor(deps.platform).join(resolveConfigDir(deps), "kimi", "auth.json")
+ return pathFor(deps.platform).join(resolveConfigDir(deps), "kimi", "auth.json");
}
export function kimiDeviceIdFile(deps: DirResolverEnv = defaults()): string {
- return pathFor(deps.platform).join(resolveConfigDir(deps), "kimi", "device_id")
+ return pathFor(deps.platform).join(resolveConfigDir(deps), "kimi", "device_id");
}
export function logFile(deps: DirResolverEnv = defaults()): string {
- return pathFor(deps.platform).join(resolveStateDir(deps), "proxy.log")
+ return pathFor(deps.platform).join(resolveStateDir(deps), "proxy.log");
}
export function configDir(): string {
- return resolveConfigDir(defaults())
+ return resolveConfigDir(defaults());
}
export function stateDir(): string {
- return resolveStateDir(defaults())
+ return resolveStateDir(defaults());
}
diff --git a/src/providers/codex/auth/constants.ts b/src/providers/codex/auth/constants.ts
index eadfda2..bb19913 100644
--- a/src/providers/codex/auth/constants.ts
+++ b/src/providers/codex/auth/constants.ts
@@ -1,7 +1,7 @@
-export const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann"
-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-code-proxy"
-export const REFRESH_MARGIN_MS = 5 * 60 * 1000
+export const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+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-code-proxy";
+export const REFRESH_MARGIN_MS = 5 * 60 * 1000;
diff --git a/src/providers/codex/auth/device.ts b/src/providers/codex/auth/device.ts
index 21d815c..bf099b7 100644
--- a/src/providers/codex/auth/device.ts
+++ b/src/providers/codex/auth/device.ts
@@ -1,23 +1,23 @@
-import { CLIENT_ID, ISSUER } from "./constants.ts"
-import type { TokenResponse } from "./jwt.ts"
+import { CLIENT_ID, ISSUER } from "./constants.ts";
+import type { TokenResponse } from "./jwt.ts";
-const POLL_SAFETY_MARGIN_MS = 3000
+const POLL_SAFETY_MARGIN_MS = 3000;
export async function runDeviceLogin(): Promise<TokenResponse> {
const init = await fetch(`${ISSUER}/api/accounts/deviceauth/usercode`, {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ client_id: CLIENT_ID }),
- })
- if (!init.ok) throw new Error(`Device init failed: ${init.status}`)
+ });
+ if (!init.ok) throw new Error(`Device init failed: ${init.status}`);
const data = (await init.json()) as {
- device_auth_id: string
- user_code: string
- interval: string
- }
- const intervalMs = Math.max(parseInt(data.interval) || 5, 1) * 1000
+ device_auth_id: string;
+ user_code: string;
+ interval: string;
+ };
+ const intervalMs = Math.max(parseInt(data.interval) || 5, 1) * 1000;
- console.log(`\nVisit: ${ISSUER}/codex/device\nEnter code: ${data.user_code}\n`)
+ console.log(`\nVisit: ${ISSUER}/codex/device\nEnter code: ${data.user_code}\n`);
while (true) {
const resp = await fetch(`${ISSUER}/api/accounts/deviceauth/token`, {
@@ -27,9 +27,9 @@ export async function runDeviceLogin(): Promise<TokenResponse> {
device_auth_id: data.device_auth_id,
user_code: data.user_code,
}),
- })
+ });
if (resp.ok) {
- const body = (await resp.json()) as { authorization_code: string; code_verifier: string }
+ const body = (await resp.json()) as { authorization_code: string; code_verifier: string };
const tokenResp = await fetch(`${ISSUER}/oauth/token`, {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
@@ -40,13 +40,13 @@ export async function runDeviceLogin(): Promise<TokenResponse> {
client_id: CLIENT_ID,
code_verifier: body.code_verifier,
}).toString(),
- })
- if (!tokenResp.ok) throw new Error(`Token exchange failed: ${tokenResp.status}`)
- return (await tokenResp.json()) as TokenResponse
+ });
+ if (!tokenResp.ok) throw new Error(`Token exchange failed: ${tokenResp.status}`);
+ return (await tokenResp.json()) as TokenResponse;
}
if (resp.status !== 403 && resp.status !== 404) {
- throw new Error(`Device poll failed: ${resp.status}`)
+ throw new Error(`Device poll failed: ${resp.status}`);
}
- await new Promise((r) => setTimeout(r, intervalMs + POLL_SAFETY_MARGIN_MS))
+ await new Promise((r) => setTimeout(r, intervalMs + POLL_SAFETY_MARGIN_MS));
}
}
diff --git a/src/providers/codex/auth/jwt.ts b/src/providers/codex/auth/jwt.ts
index faf6cc3..851720e 100644
--- a/src/providers/codex/auth/jwt.ts
+++ b/src/providers/codex/auth/jwt.ts
@@ -1,20 +1,20 @@
export interface IdTokenClaims {
- chatgpt_account_id?: string
- organizations?: Array<{ id: string }>
- email?: string
+ chatgpt_account_id?: string;
+ organizations?: Array<{ id: string }>;
+ email?: string;
"https://api.openai.com/auth"?: {
- chatgpt_account_id?: string
- }
- "https://api.openai.com/auth.chatgpt_account_id"?: string
+ chatgpt_account_id?: string;
+ };
+ "https://api.openai.com/auth.chatgpt_account_id"?: string;
}
export function parseJwtClaims(token: string): IdTokenClaims | undefined {
- const parts = token.split(".")
- if (parts.length !== 3) return undefined
+ const parts = token.split(".");
+ if (parts.length !== 3) return undefined;
try {
- return JSON.parse(Buffer.from(parts[1]!, "base64url").toString())
+ return JSON.parse(Buffer.from(parts[1]!, "base64url").toString());
} catch {
- return undefined
+ return undefined;
}
}
@@ -24,25 +24,25 @@ export function extractAccountIdFromClaims(claims: IdTokenClaims): string | unde
claims["https://api.openai.com/auth"]?.chatgpt_account_id ||
claims["https://api.openai.com/auth.chatgpt_account_id"] ||
claims.organizations?.[0]?.id
- )
+ );
}
export interface TokenResponse {
- id_token?: string
- access_token: string
- refresh_token: string
- expires_in?: number
+ id_token?: string;
+ access_token: string;
+ refresh_token: string;
+ expires_in?: number;
}
export function extractAccountId(tokens: TokenResponse): string | undefined {
if (tokens.id_token) {
- const claims = parseJwtClaims(tokens.id_token)
- const accountId = claims && extractAccountIdFromClaims(claims)
- if (accountId) return accountId
+ const claims = parseJwtClaims(tokens.id_token);
+ const accountId = claims && extractAccountIdFromClaims(claims);
+ if (accountId) return accountId;
}
if (tokens.access_token) {
- const claims = parseJwtClaims(tokens.access_token)
- return claims ? extractAccountIdFromClaims(claims) : undefined
+ const claims = parseJwtClaims(tokens.access_token);
+ return claims ? extractAccountIdFromClaims(claims) : undefined;
}
- return undefined
+ return undefined;
}
diff --git a/src/providers/codex/auth/manager.ts b/src/providers/codex/auth/manager.ts
index 5325343..d45c19d 100644
--- a/src/providers/codex/auth/manager.ts
+++ b/src/providers/codex/auth/manager.ts
@@ -1,48 +1,51 @@
-import { CLIENT_ID, ISSUER, REFRESH_MARGIN_MS } from "./constants.ts"
-import { extractAccountId, type TokenResponse } from "./jwt.ts"
-import { loadAuth, saveAuth, type StoredAuth } from "./token-store.ts"
+import { CLIENT_ID, ISSUER, REFRESH_MARGIN_MS } from "./constants.ts";
+import { extractAccountId, type TokenResponse } from "./jwt.ts";
+import { loadAuth, saveAuth, type StoredAuth } from "./token-store.ts";
function validateTokenResponse(t: unknown): asserts t is TokenResponse {
- if (!t || typeof t !== "object") throw new Error("Invalid token response: not an object")
- const o = t as Record<string, unknown>
+ if (!t || typeof t !== "object") throw new Error("Invalid token response: not an object");
+ const o = t as Record<string, unknown>;
if (typeof o.access_token !== "string" || !o.access_token)
- throw new Error("Invalid token response: missing access_token")
+ throw new Error("Invalid token response: missing access_token");
if (typeof o.refresh_token !== "string" || !o.refresh_token)
- throw new Error("Invalid token response: missing refresh_token")
- if (o.expires_in !== undefined && (typeof o.expires_in !== "number" || !Number.isFinite(o.expires_in) || o.expires_in <= 0))
- throw new Error("Invalid token response: bad expires_in")
+ throw new Error("Invalid token response: missing refresh_token");
+ if (
+ o.expires_in !== undefined &&
+ (typeof o.expires_in !== "number" || !Number.isFinite(o.expires_in) || o.expires_in <= 0)
+ )
+ throw new Error("Invalid token response: bad expires_in");
}
-let cached: StoredAuth | undefined
-let inflight: Promise<StoredAuth> | undefined
+let cached: StoredAuth | undefined;
+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-code-proxy codex auth login")
- cached = stored
+ const stored = await loadAuth();
+ if (!stored) throw new Error("Not authenticated. Run: claude-code-proxy codex auth login");
+ cached = stored;
}
if (cached.expires - REFRESH_MARGIN_MS > Date.now()) {
- return cached
+ return cached;
}
- if (inflight) return inflight
+ if (inflight) return inflight;
inflight = refreshNow(cached).finally(() => {
- inflight = undefined
- })
- return inflight
+ inflight = undefined;
+ });
+ return inflight;
}
export async function forceRefresh(): Promise<StoredAuth> {
if (!cached) {
- const stored = await loadAuth()
- if (!stored) throw new Error("Not authenticated")
- cached = stored
+ const stored = await loadAuth();
+ if (!stored) throw new Error("Not authenticated");
+ cached = stored;
}
- if (inflight) return inflight
+ if (inflight) return inflight;
inflight = refreshNow(cached).finally(() => {
- inflight = undefined
- })
- return inflight
+ inflight = undefined;
+ });
+ return inflight;
}
async function refreshNow(current: StoredAuth): Promise<StoredAuth> {
@@ -54,35 +57,35 @@ async function refreshNow(current: StoredAuth): Promise<StoredAuth> {
refresh_token: current.refresh,
client_id: CLIENT_ID,
}).toString(),
- })
- if (!resp.ok) throw new Error(`Token refresh failed: ${resp.status}`)
- const tokens = await resp.json()
- validateTokenResponse(tokens)
- const accountId = extractAccountId(tokens) || current.accountId
+ });
+ if (!resp.ok) throw new Error(`Token refresh failed: ${resp.status}`);
+ const tokens = await resp.json();
+ validateTokenResponse(tokens);
+ const accountId = extractAccountId(tokens) || current.accountId;
const next: StoredAuth = {
access: tokens.access_token,
refresh: tokens.refresh_token || current.refresh,
expires: Date.now() + (tokens.expires_in ?? 3600) * 1000,
accountId,
- }
- await saveAuth(next)
- cached = next
- return next
+ };
+ await saveAuth(next);
+ cached = next;
+ return next;
}
export async function persistInitialTokens(tokens: TokenResponse): Promise<StoredAuth> {
- validateTokenResponse(tokens)
+ validateTokenResponse(tokens);
const auth: StoredAuth = {
access: tokens.access_token,
refresh: tokens.refresh_token,
expires: Date.now() + (tokens.expires_in ?? 3600) * 1000,
accountId: extractAccountId(tokens),
- }
- await saveAuth(auth)
- cached = auth
- return auth
+ };
+ await saveAuth(auth);
+ cached = auth;
+ return auth;
}
export function resetCache(): void {
- cached = undefined
+ cached = undefined;
}
diff --git a/src/providers/codex/auth/pkce.ts b/src/providers/codex/auth/pkce.ts
index c39991c..2ff5ed7 100644
--- a/src/providers/codex/auth/pkce.ts
+++ b/src/providers/codex/auth/pkce.ts
@@ -1,27 +1,27 @@
-import { createServer } from "node:http"
-import { CLIENT_ID, ISSUER, OAUTH_PORT, OAUTH_REDIRECT_URI, ORIGINATOR } from "./constants.ts"
-import type { TokenResponse } from "./jwt.ts"
+import { createServer } from "node:http";
+import { CLIENT_ID, ISSUER, OAUTH_PORT, OAUTH_REDIRECT_URI, ORIGINATOR } from "./constants.ts";
+import type { TokenResponse } from "./jwt.ts";
export interface PkceCodes {
- verifier: string
- challenge: string
+ verifier: string;
+ challenge: string;
}
export async function generatePKCE(): Promise<PkceCodes> {
- const verifier = base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)).buffer)
- const hash = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier))
- return { verifier, challenge: base64UrlEncode(hash) }
+ const verifier = base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)).buffer);
+ const hash = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+ return { verifier, challenge: base64UrlEncode(hash) };
}
function base64UrlEncode(buffer: ArrayBuffer): string {
- const bytes = new Uint8Array(buffer)
- let binary = ""
- for (const b of bytes) binary += String.fromCharCode(b)
- return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")
+ const bytes = new Uint8Array(buffer);
+ let binary = "";
+ for (const b of bytes) binary += String.fromCharCode(b);
+ return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
}
export function generateState(): string {
- return base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)).buffer)
+ return base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)).buffer);
}
export function buildAuthorizeUrl(pkce: PkceCodes, state: string): string {
@@ -36,8 +36,8 @@ export function buildAuthorizeUrl(pkce: PkceCodes, state: string): string {
codex_cli_simplified_flow: "true",
state,
originator: ORIGINATOR,
- })
- return `${ISSUER}/oauth/authorize?${params.toString()}`
+ });
+ return `${ISSUER}/oauth/authorize?${params.toString()}`;
}
export async function exchangeCodeForTokens(code: string, pkce: PkceCodes): Promise<TokenResponse> {
@@ -51,66 +51,67 @@ export async function exchangeCodeForTokens(code: string, pkce: PkceCodes): Prom
client_id: CLIENT_ID,
code_verifier: pkce.verifier,
}).toString(),
- })
- if (!response.ok) throw new Error(`Token exchange failed: ${response.status} ${await response.text()}`)
- return (await response.json()) as TokenResponse
+ });
+ if (!response.ok)
+ throw new Error(`Token exchange failed: ${response.status} ${await response.text()}`);
+ return (await response.json()) as TokenResponse;
}
export async function runBrowserLogin(): Promise<TokenResponse> {
- const pkce = await generatePKCE()
- const state = generateState()
- const authUrl = buildAuthorizeUrl(pkce, state)
+ const pkce = await generatePKCE();
+ const state = generateState();
+ const authUrl = buildAuthorizeUrl(pkce, state);
return new Promise<TokenResponse>((resolve, reject) => {
const cleanup = () => {
- clearTimeout(timeout)
- server.close()
- server.closeAllConnections?.()
- }
+ clearTimeout(timeout);
+ server.close();
+ server.closeAllConnections?.();
+ };
const server = createServer((req, res) => {
- const url = new URL(req.url || "/", `http://localhost:${OAUTH_PORT}`)
+ const url = new URL(req.url || "/", `http://localhost:${OAUTH_PORT}`);
if (url.pathname !== "/auth/callback") {
- res.writeHead(404)
- res.end("Not found")
- return
+ res.writeHead(404);
+ res.end("Not found");
+ return;
}
- const code = url.searchParams.get("code")
- const receivedState = url.searchParams.get("state")
- const error = url.searchParams.get("error")
+ const code = url.searchParams.get("code");
+ const receivedState = url.searchParams.get("state");
+ const error = url.searchParams.get("error");
if (error || !code || receivedState !== state) {
- const msg = error || "Invalid callback"
- res.writeHead(400, { "Content-Type": "text/plain" })
- res.end(`Auth failed: ${msg}`)
- cleanup()
- reject(new Error(msg))
- return
+ const msg = error || "Invalid callback";
+ res.writeHead(400, { "Content-Type": "text/plain" });
+ res.end(`Auth failed: ${msg}`);
+ cleanup();
+ reject(new Error(msg));
+ return;
}
exchangeCodeForTokens(code, pkce)
.then((tokens) => {
- res.writeHead(200, { "Content-Type": "text/html" })
+ res.writeHead(200, { "Content-Type": "text/html" });
res.end(
"<html><body><h1>Authorization Successful</h1><p>You can close this window.</p></body></html>",
- )
- cleanup()
- resolve(tokens)
+ );
+ cleanup();
+ resolve(tokens);
})
.catch((err) => {
- res.writeHead(500, { "Content-Type": "text/plain" })
- res.end(String(err))
- cleanup()
- reject(err)
- })
- })
+ res.writeHead(500, { "Content-Type": "text/plain" });
+ res.end(String(err));
+ cleanup();
+ reject(err);
+ });
+ });
server.listen(OAUTH_PORT, "127.0.0.1", () => {
- console.log(`Open this URL in your browser to authorize:\n\n ${authUrl}\n`)
- })
- server.on("error", reject)
+ console.log(`Open this URL in your browser to authorize:\n\n ${authUrl}\n`);
+ });
+ server.on("error", reject);
const timeout = setTimeout(
() => {
- cleanup()
- reject(new Error("OAuth timeout"))
+ cleanup();
+ reject(new Error("OAuth timeout"));
},
5 * 60 * 1000,
- )
- })
+ );
+ });
}
diff --git a/src/providers/codex/auth/token-store.ts b/src/providers/codex/auth/token-store.ts
index c28b570..71fa221 100644
--- a/src/providers/codex/auth/token-store.ts
+++ b/src/providers/codex/auth/token-store.ts
@@ -1,77 +1,77 @@
-import { mkdir, readFile, writeFile, unlink, rename } from "node:fs/promises"
-import { dirname, join } from "node:path"
-import { keychainGet, keychainSet, keychainDelete } from "../../../keychain.ts"
-import { codexAuthFile, legacyConfigDir } from "../../../paths.ts"
+import { mkdir, readFile, writeFile, unlink, rename } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { keychainGet, keychainSet, keychainDelete } from "../../../keychain.ts";
+import { codexAuthFile, legacyConfigDir } from "../../../paths.ts";
export interface StoredAuth {
- access: string
- refresh: string
- expires: number
- accountId?: string
+ access: string;
+ refresh: string;
+ expires: number;
+ accountId?: string;
}
function file(): string {
- return codexAuthFile()
+ return codexAuthFile();
}
function legacyFile(): string {
- return join(legacyConfigDir(), "codex", "auth.json")
+ return join(legacyConfigDir(), "codex", "auth.json");
}
-const KEYCHAIN_SERVICE = "claude-code-proxy.codex"
-const KEYCHAIN_ACCOUNT = "auth"
+const KEYCHAIN_SERVICE = "claude-code-proxy.codex";
+const KEYCHAIN_ACCOUNT = "auth";
export async function loadAuth(): Promise<StoredAuth | undefined> {
if (process.platform === "darwin") {
- const raw = keychainGet(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT)
- if (!raw) return undefined
- return JSON.parse(raw) as StoredAuth
+ const raw = keychainGet(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
+ if (!raw) return undefined;
+ return JSON.parse(raw) as StoredAuth;
}
- const primary = file()
+ const primary = file();
try {
- const raw = await readFile(primary, "utf8")
- return JSON.parse(raw) as StoredAuth
+ const raw = await readFile(primary, "utf8");
+ return JSON.parse(raw) as StoredAuth;
} catch (err: any) {
- if (err?.code !== "ENOENT") throw err
+ if (err?.code !== "ENOENT") throw err;
}
- const legacy = legacyFile()
- if (legacy === primary) return undefined
+ const legacy = legacyFile();
+ if (legacy === primary) return undefined;
try {
- const raw = await readFile(legacy, "utf8")
- return JSON.parse(raw) as StoredAuth
+ const raw = await readFile(legacy, "utf8");
+ return JSON.parse(raw) as StoredAuth;
} catch (err: any) {
- if (err?.code === "ENOENT") return undefined
- throw err
+ if (err?.code === "ENOENT") return undefined;
+ throw err;
}
}
export async function saveAuth(auth: StoredAuth): Promise<void> {
if (process.platform === "darwin") {
- keychainSet(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, JSON.stringify(auth))
- return
+ keychainSet(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, JSON.stringify(auth));
+ return;
}
- 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, path)
+ 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, path);
}
export async function clearAuth(): Promise<void> {
if (process.platform === "darwin") {
- keychainDelete(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT)
- return
+ keychainDelete(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
+ return;
}
for (const path of [file(), legacyFile()]) {
try {
- await unlink(path)
+ await unlink(path);
} catch (err: any) {
- if (err?.code !== "ENOENT") throw err
+ 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.ts
index 9d605f0..65425af 100644
--- a/src/providers/codex/client.ts
+++ b/src/providers/codex/client.ts
@@ -1,24 +1,24 @@
-import { CODEX_API_ENDPOINT, ORIGINATOR as ORIGINATOR_DEFAULT } from "./auth/constants.ts"
-import { codexBaseUrl, codexOriginator, codexUserAgent } from "../../config.ts"
-declare const BUILD_VERSION: string | undefined
-const PROXY_VERSION = typeof BUILD_VERSION === "string" ? BUILD_VERSION : "dev"
-import { forceRefresh, getAuth } from "./auth/manager.ts"
-import type { Logger } from "../../log.ts"
-import type { RequestContext } from "../types.ts"
-import type { ResponsesRequest } from "./translate/request.ts"
-import { retryOn429 } from "../retry.ts"
+import { CODEX_API_ENDPOINT, ORIGINATOR as ORIGINATOR_DEFAULT } from "./auth/constants.ts";
+import { codexBaseUrl, codexOriginator, codexUserAgent } from "../../config.ts";
+declare const BUILD_VERSION: string | undefined;
+const PROXY_VERSION = typeof BUILD_VERSION === "string" ? BUILD_VERSION : "dev";
+import { forceRefresh, getAuth } from "./auth/manager.ts";
+import type { Logger } from "../../log.ts";
+import type { RequestContext } from "../types.ts";
+import type { ResponsesRequest } from "./translate/request.ts";
+import { retryOn429 } from "../retry.ts";
export interface CodexResponse {
- body: ReadableStream<Uint8Array>
- status: number
- headers: Headers
+ body: ReadableStream<Uint8Array>;
+ status: number;
+ headers: Headers;
}
export async function postCodex(
body: ResponsesRequest,
ctx: RequestContext,
): Promise<CodexResponse> {
- const log = ctx.childLogger("codex.client")
+ const log = ctx.childLogger("codex.client");
return retryOn429(() => attemptPostCodex(body, ctx, log), {
log,
signal: ctx.signal,
@@ -26,7 +26,7 @@ export async function postCodex(
err instanceof CodexError && err.status === 429
? { retryAfter: err.meta?.retryAfter }
: undefined,
- })
+ });
}
async function attemptPostCodex(
@@ -34,39 +34,39 @@ async function attemptPostCodex(
ctx: RequestContext,
log: Logger,
): Promise<CodexResponse> {
- let auth = await getAuth()
- let resp = await doFetch(auth.access, auth.accountId, body, log, ctx.signal, ctx.sessionId)
+ let auth = await getAuth();
+ let resp = await doFetch(auth.access, auth.accountId, body, log, ctx.signal, ctx.sessionId);
if (resp.status === 401) {
- log.warn("got 401, refreshing token", {})
+ log.warn("got 401, refreshing token", {});
try {
- auth = await forceRefresh()
- resp = await doFetch(auth.access, auth.accountId, body, log, ctx.signal, ctx.sessionId)
+ auth = await forceRefresh();
+ resp = await doFetch(auth.access, auth.accountId, body, log, ctx.signal, ctx.sessionId);
} catch (err) {
- log.error("refresh after 401 failed", { err: String(err) })
+ log.error("refresh after 401 failed", { err: String(err) });
}
}
if (resp.status === 403) {
- const text = await safeText(resp)
- log.error("403 from upstream (non-refreshable)", { body: text })
- throw new CodexError(403, "Forbidden", text)
+ const text = await safeText(resp);
+ log.error("403 from upstream (non-refreshable)", { body: text });
+ throw new CodexError(403, "Forbidden", text);
}
if (resp.status === 429) {
- const retryAfter = resp.headers.get("retry-after") || undefined
- const text = await safeText(resp)
- throw new CodexError(429, "Rate limited", text, { retryAfter })
+ const retryAfter = resp.headers.get("retry-after") || undefined;
+ const text = await safeText(resp);
+ throw new CodexError(429, "Rate limited", text, { retryAfter });
}
if (!resp.ok) {
- const text = await safeText(resp)
- throw new CodexError(resp.status, "Upstream error", text)
+ const text = await safeText(resp);
+ throw new CodexError(resp.status, "Upstream error", text);
}
- if (!resp.body) throw new CodexError(500, "Upstream returned no body")
+ if (!resp.body) throw new CodexError(500, "Upstream returned no body");
- return { body: resp.body, status: resp.status, headers: resp.headers }
+ return { body: resp.body, status: resp.status, headers: resp.headers };
}
async function doFetch(
@@ -83,38 +83,38 @@ async function doFetch(
authorization: `Bearer ${accessToken}`,
originator: codexOriginator(ORIGINATOR_DEFAULT),
"openai-beta": "responses=experimental",
- })
- const userAgent = codexUserAgent(`claude-code-proxy/${PROXY_VERSION}`)
- if (userAgent) headers.set("User-Agent", userAgent)
- if (accountId) headers.set("ChatGPT-Account-Id", accountId)
+ });
+ 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) {
- headers.set("session_id", sessionId)
- headers.set("x-client-request-id", sessionId)
- headers.set("x-codex-window-id", `${sessionId}:0`)
+ headers.set("session_id", sessionId);
+ headers.set("x-client-request-id", sessionId);
+ headers.set("x-codex-window-id", `${sessionId}:0`);
}
- const codexUrl = codexBaseUrl(CODEX_API_ENDPOINT)
+ const codexUrl = codexBaseUrl(CODEX_API_ENDPOINT);
log.debug("posting to codex", {
url: codexUrl,
model: body.model,
inputCount: body.input.length,
toolCount: body.tools?.length ?? 0,
- })
+ });
return fetch(codexUrl, {
method: "POST",
headers,
body: JSON.stringify(body),
signal,
- })
+ });
}
async function safeText(resp: Response): Promise<string> {
try {
- return await resp.text()
+ return await resp.text();
} catch {
- return ""
+ return "";
}
}
@@ -125,7 +125,7 @@ export class CodexError extends Error {
public detail?: string,
public meta?: { retryAfter?: string },
) {
- super(message)
- this.name = "CodexError"
+ super(message);
+ this.name = "CodexError";
}
}
diff --git a/src/providers/codex/count-tokens.ts b/src/providers/codex/count-tokens.ts
index 6920069..374d38b 100644
--- a/src/providers/codex/count-tokens.ts
+++ b/src/providers/codex/count-tokens.ts
@@ -1,84 +1,84 @@
-import { encode } from "gpt-tokenizer/model/gpt-4o"
-import type { AnthropicRequest } from "../../anthropic/schema.ts"
-import type { ResponsesRequest } from "./translate/request.ts"
-import { buildInstructions, normalizeContent, toolResultToString } from "./translate/request.ts"
+import { encode } from "gpt-tokenizer/model/gpt-4o";
+import type { AnthropicRequest } from "../../anthropic/schema.ts";
+import type { ResponsesRequest } from "./translate/request.ts";
+import { buildInstructions, normalizeContent, toolResultToString } from "./translate/request.ts";
-const IMAGE_TOKEN_ESTIMATE = 2000
+const IMAGE_TOKEN_ESTIMATE = 2000;
export function countTokens(req: AnthropicRequest): number {
- let total = 0
- const instructions = buildInstructions(req.system)
- if (instructions) total += encode(instructions).length
+ let total = 0;
+ const instructions = buildInstructions(req.system);
+ if (instructions) total += encode(instructions).length;
for (const msg of req.messages) {
- const blocks = normalizeContent(msg.content)
+ const blocks = normalizeContent(msg.content);
for (const block of blocks) {
if (block.type === "text") {
- total += encode(block.text).length
+ total += encode(block.text).length;
} else if (block.type === "image") {
- total += IMAGE_TOKEN_ESTIMATE
+ total += IMAGE_TOKEN_ESTIMATE;
} else if (block.type === "tool_use") {
- total += encode(block.name).length
- total += encode(JSON.stringify(block.input ?? {})).length
+ total += encode(block.name).length;
+ total += encode(JSON.stringify(block.input ?? {})).length;
} else if (block.type === "tool_result") {
- total += encode(toolResultToString(block.content)).length
+ total += encode(toolResultToString(block.content)).length;
}
}
}
for (const tool of req.tools ?? []) {
- total += encode(tool.name).length
- if (tool.description) total += encode(tool.description).length
- total += encode(JSON.stringify(tool.input_schema ?? {})).length
+ total += encode(tool.name).length;
+ if (tool.description) total += encode(tool.description).length;
+ total += encode(JSON.stringify(tool.input_schema ?? {})).length;
}
- total += req.messages.length * 4
- return total
+ total += req.messages.length * 4;
+ return total;
}
export function countTranslatedTokens(
req: Pick<ResponsesRequest, "instructions" | "input" | "tools" | "text" | "tool_choice">,
): number {
- let total = 0
- if (req.instructions) total += encode(req.instructions).length
+ let total = 0;
+ if (req.instructions) total += encode(req.instructions).length;
for (const item of req.input) {
if (item.type === "message") {
for (const part of item.content) {
if (part.type === "input_text" || part.type === "output_text") {
- total += encode(part.text).length
+ total += encode(part.text).length;
} else if (part.type === "input_image") {
- total += IMAGE_TOKEN_ESTIMATE
+ total += IMAGE_TOKEN_ESTIMATE;
}
}
} else if (item.type === "function_call") {
- total += encode(item.call_id).length
- total += encode(item.name).length
- total += encode(item.arguments).length
+ total += encode(item.call_id).length;
+ total += encode(item.name).length;
+ total += encode(item.arguments).length;
} else if (item.type === "function_call_output") {
- total += encode(item.call_id).length
- total += encode(item.output).length
+ total += encode(item.call_id).length;
+ total += encode(item.output).length;
}
}
for (const tool of req.tools ?? []) {
- total += encode(tool.name).length
- if (tool.description) total += encode(tool.description).length
- total += encode(JSON.stringify(tool.parameters ?? {})).length
+ total += encode(tool.name).length;
+ if (tool.description) total += encode(tool.description).length;
+ total += encode(JSON.stringify(tool.parameters ?? {})).length;
}
if (req.text?.format?.type === "json_schema") {
- total += encode(req.text.format.name).length
- total += encode(JSON.stringify(req.text.format.schema)).length
+ total += encode(req.text.format.name).length;
+ total += encode(JSON.stringify(req.text.format.schema)).length;
}
if (typeof req.tool_choice === "string") {
- total += encode(req.tool_choice).length
+ total += encode(req.tool_choice).length;
} else if (req.tool_choice?.type === "function") {
- total += encode(req.tool_choice.type).length
- total += encode(req.tool_choice.name).length
+ total += encode(req.tool_choice.type).length;
+ total += encode(req.tool_choice.name).length;
}
- total += req.input.length * 4
- return total
+ total += req.input.length * 4;
+ return total;
}
diff --git a/src/providers/codex/index.test.ts b/src/providers/codex/index.test.ts
index d00a7d4..8fbfa0a 100644
--- a/src/providers/codex/index.test.ts
+++ b/src/providers/codex/index.test.ts
@@ -1,7 +1,7 @@
-import { afterEach, describe, expect, it } from "bun:test"
-import type { RequestContext } from "../types.ts"
-import { loadConfig } from "../../config.ts"
-import { codexProvider } from "./index.ts"
+import { afterEach, describe, expect, it } from "bun:test";
+import type { RequestContext } from "../types.ts";
+import { loadConfig } from "../../config.ts";
+import { codexProvider } from "./index.ts";
const ctx: RequestContext = {
reqId: "test-req",
@@ -12,49 +12,49 @@ const ctx: RequestContext = {
warn() {},
error() {},
child() {
- return this
+ return this;
},
}),
-}
+};
afterEach(() => {
- loadConfig({ forceReload: true })
-})
+ loadConfig({ forceReload: true });
+});
describe("codexProvider", () => {
it("returns 400 for invalid service tier config during token counting", async () => {
- loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "standard" }, forceReload: true })
+ loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "standard" }, forceReload: true });
const resp = await codexProvider.handleCountTokens(
{ model: "gpt-5.4", messages: [{ role: "user", content: "hello" }] },
ctx,
- )
+ );
- expect(resp.status).toBe(400)
+ expect(resp.status).toBe(400);
expect(await resp.json()).toEqual({
type: "error",
error: {
type: "invalid_request_error",
message: 'Invalid service tier override: "standard". Must be one of: fast, priority, flex',
},
- })
- })
+ });
+ });
it("returns 400 for invalid forced model during token counting", async () => {
- loadConfig({ env: { CCP_CODEX_MODEL: "gpt-4.1" }, forceReload: true })
+ loadConfig({ env: { CCP_CODEX_MODEL: "gpt-4.1" }, forceReload: true });
const resp = await codexProvider.handleCountTokens(
{ model: "gpt-5.4", messages: [{ role: "user", content: "hello" }] },
ctx,
- )
+ );
- expect(resp.status).toBe(400)
+ expect(resp.status).toBe(400);
expect(await resp.json()).toEqual({
type: "error",
error: {
type: "invalid_request_error",
message: 'Model "gpt-5.4" resolves to unsupported model "gpt-4.1"',
},
- })
- })
-})
+ });
+ });
+});
diff --git a/src/providers/codex/index.ts b/src/providers/codex/index.ts
index 3676c4d..7a6633f 100644
--- a/src/providers/codex/index.ts
+++ b/src/providers/codex/index.ts
@@ -1,117 +1,120 @@
-import type { AnthropicRequest } from "../../anthropic/schema.ts"
-import type { Provider, RequestContext, CliHandlers } from "../types.ts"
+import type { AnthropicRequest } from "../../anthropic/schema.ts";
+import type { Provider, RequestContext, CliHandlers } from "../types.ts";
import {
ALLOWED_MODELS,
assertAllowedModel,
FAST_MODEL_ALIASES,
ModelNotAllowedError,
resolveModelRequest,
-} from "./translate/model-allowlist.ts"
-import { InvalidServiceTierError, 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"
-import { logVerbose } from "../../config.ts"
+} from "./translate/model-allowlist.ts";
+import { InvalidServiceTierError, 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";
+import { logVerbose } from "../../config.ts";
interface SessionCountSnapshot {
- reqId: string
- model: string
- messageCount: number
- toolCount: number
- tokens: number
+ reqId: string;
+ model: string;
+ messageCount: number;
+ toolCount: number;
+ tokens: number;
}
interface SessionMessageSnapshot {
- reqId: string
- model: string
- messageCount: number
- toolCount: number
- localInputTokens?: number
- translatedInputTokens?: number
+ reqId: string;
+ model: string;
+ messageCount: number;
+ toolCount: number;
+ localInputTokens?: number;
+ translatedInputTokens?: number;
}
interface SessionTimelineState {
- lastCount?: SessionCountSnapshot
- lastMessage?: SessionMessageSnapshot
+ lastCount?: SessionCountSnapshot;
+ lastMessage?: SessionMessageSnapshot;
}
-const sessionTimeline = new Map<string, SessionTimelineState>()
+const sessionTimeline = new Map<string, SessionTimelineState>();
function sessionState(sessionId?: string): SessionTimelineState | undefined {
- if (!sessionId) return undefined
- let state = sessionTimeline.get(sessionId)
+ if (!sessionId) return undefined;
+ let state = sessionTimeline.get(sessionId);
if (!state) {
- state = {}
- sessionTimeline.set(sessionId, state)
+ state = {};
+ sessionTimeline.set(sessionId, state);
}
- return state
+ return state;
}
function usageWindowTokens(usage: {
- input_tokens: number
- output_tokens: number
- cache_creation_input_tokens: number
- cache_read_input_tokens: number
+ 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
+ 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" },
- })
+ });
}
function invalidServiceTierResponse(err: InvalidServiceTierError): Response {
- return jsonError(400, "invalid_request_error", err.message)
+ return jsonError(400, "invalid_request_error", err.message);
}
async function handleCountTokens(body: AnthropicRequest, ctx: RequestContext): Promise<Response> {
- const log = ctx.childLogger("provider.codex")
- const resolved = resolveModelRequest(body.model)
- const resolvedModel = resolved.model
- let translated
+ const log = ctx.childLogger("provider.codex");
+ const resolved = resolveModelRequest(body.model);
+ const resolvedModel = resolved.model;
+ let translated;
try {
- assertAllowedModel(resolvedModel)
- translated = translateRequest({ ...body, model: resolvedModel }, { serviceTier: resolved.serviceTier })
+ assertAllowedModel(resolvedModel);
+ translated = translateRequest(
+ { ...body, model: resolvedModel },
+ { serviceTier: resolved.serviceTier },
+ );
} catch (err) {
if (err instanceof ModelNotAllowedError) {
return jsonError(
400,
"invalid_request_error",
`Model "${body.model}" resolves to unsupported model "${err.model}"`,
- )
+ );
}
- if (err instanceof InvalidServiceTierError) return invalidServiceTierResponse(err)
- throw err
+ if (err instanceof InvalidServiceTierError) return invalidServiceTierResponse(err);
+ throw err;
}
- 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", { tokens })
+ 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", { tokens });
if (state) {
state.lastCount = {
reqId: ctx.reqId,
@@ -119,7 +122,7 @@ async function handleCountTokens(body: AnthropicRequest, ctx: RequestContext): P
messageCount,
toolCount,
tokens,
- }
+ };
}
if (logVerbose()) {
log.info("compaction telemetry", {
@@ -135,21 +138,21 @@ async function handleCountTokens(body: AnthropicRequest, ctx: RequestContext): P
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 log = ctx.childLogger("provider.codex")
- 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)
+ const log = ctx.childLogger("provider.codex");
+ 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", {
model: body.model,
@@ -159,32 +162,32 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
requestedMaxTokens: body.max_tokens,
hasContextManagement: contextManagement !== undefined,
hasJsonSchemaFormat: body.output_config?.format?.type === "json_schema",
- })
- if (logVerbose()) log.debug("anthropic request body", { body })
+ });
+ if (logVerbose()) log.debug("anthropic request body", { body });
- const resolved = resolveModelRequest(body.model)
- const resolvedModel = resolved.model
+ const resolved = resolveModelRequest(body.model);
+ const resolvedModel = resolved.model;
- let translated
+ let translated;
try {
- assertAllowedModel(resolvedModel)
+ assertAllowedModel(resolvedModel);
translated = translateRequest(
{ ...body, model: resolvedModel },
{ sessionId: ctx.sessionId, serviceTier: resolved.serviceTier },
- )
+ );
} catch (err) {
if (err instanceof ModelNotAllowedError) {
return jsonError(
400,
"invalid_request_error",
`Model "${body.model}" resolves to unsupported model "${err.model}"`,
- )
+ );
}
- if (err instanceof InvalidServiceTierError) return invalidServiceTierResponse(err)
- throw err
+ if (err instanceof InvalidServiceTierError) return invalidServiceTierResponse(err);
+ throw err;
}
- const localInputTokens = logVerbose() ? countTokens(body) : undefined
- const translatedInputTokens = logVerbose() ? countTranslatedTokens(translated) : undefined
+ const localInputTokens = logVerbose() ? countTokens(body) : undefined;
+ const translatedInputTokens = logVerbose() ? countTranslatedTokens(translated) : undefined;
if (state) {
state.lastMessage = {
reqId: ctx.reqId,
@@ -193,7 +196,7 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
toolCount,
localInputTokens,
translatedInputTokens,
- }
+ };
}
log.debug("translated request", {
requestedModel: body.model,
@@ -204,8 +207,8 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
requestedMaxTokens: body.max_tokens,
hasContextManagement: contextManagement !== undefined,
promptCacheKey: translated.prompt_cache_key,
- })
- if (logVerbose()) log.debug("translated request body", { body: translated })
+ });
+ if (logVerbose()) log.debug("translated request body", { body: translated });
if (logVerbose()) {
log.info("compaction telemetry", {
phase: "translated_request",
@@ -226,42 +229,41 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
previousCountTokens: state?.lastCount?.tokens,
previousCountMessageCount: state?.lastCount?.messageCount,
previousCountToolCount: state?.lastCount?.toolCount,
- })
+ });
}
- let upstream
+ let upstream;
try {
- upstream = await postCodex(translated, ctx)
+ upstream = await postCodex(translated, ctx);
} catch (err) {
if (err instanceof CodexError) {
- log.warn("codex error", { status: err.status, detail: err.detail })
+ log.warn("codex error", { 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
+ 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)
+ const type = err.status === 401 || err.status === 403 ? "authentication_error" : "api_error";
+ return jsonError(err.status, type, err.detail || err.message);
}
- throw err
+ throw err;
}
if (wantStream) {
- const { serverModel, serverReasoningIncluded } = upstreamHeaderSnapshot(upstream.headers)
+ const { serverModel, serverReasoningIncluded } = upstreamHeaderSnapshot(upstream.headers);
const stream = translateStream(upstream.body, {
messageId,
model: body.model,
log: ctx.childLogger("codex.stream"),
onFinish: logVerbose()
? (finish) => {
- const mappedUsage = finish.usage ? mapUsageToAnthropic(finish.usage) : undefined
+ const mappedUsage = finish.usage ? mapUsageToAnthropic(finish.usage) : undefined;
log.info("compaction telemetry", {
phase: "upstream_finish",
mode: "stream",
@@ -279,17 +281,16 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
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,
+ 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: {
@@ -297,13 +298,17 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
"cache-control": "no-cache",
connection: "keep-alive",
},
- })
+ });
}
try {
- const result = await accumulateResponse(upstream.body, { messageId, model: body.model, log: ctx.childLogger("codex.accumulate") })
+ const result = await accumulateResponse(upstream.body, {
+ messageId,
+ model: body.model,
+ log: ctx.childLogger("codex.accumulate"),
+ });
if (logVerbose()) {
- const { serverModel, serverReasoningIncluded } = upstreamHeaderSnapshot(upstream.headers)
+ const { serverModel, serverReasoningIncluded } = upstreamHeaderSnapshot(upstream.headers);
log.info("compaction telemetry", {
phase: "upstream_finish",
mode: "non_stream",
@@ -327,63 +332,63 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
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)", {
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)
+ 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)
+ return jsonError(502, "api_error", err.message);
}
- throw err
+ 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}`)
+ 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}`)
+ 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()
+ const auth = await loadAuth();
if (!auth) {
- console.log("Not authenticated")
- process.exit(1)
+ 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()}`)
+ 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")
+ await clearAuth();
+ console.log("Logged out");
},
-}
+};
export const codexProvider: Provider = {
name: "codex",
@@ -391,4 +396,4 @@ export const codexProvider: Provider = {
handleMessages,
handleCountTokens,
cli,
-}
+};
diff --git a/src/providers/codex/translate/accumulate.ts b/src/providers/codex/translate/accumulate.ts
index 712e606..480eeaa 100644
--- a/src/providers/codex/translate/accumulate.ts
+++ b/src/providers/codex/translate/accumulate.ts
@@ -1,31 +1,30 @@
-import { mapUsageToAnthropic, reduceUpstream } from "./reducer.ts"
-import type { CodexUsage } from "./reducer.ts"
-import type { Logger } from "../../../log.ts"
+import { mapUsageToAnthropic, reduceUpstream } from "./reducer.ts";
+import type { CodexUsage } from "./reducer.ts";
+import type { Logger } from "../../../log.ts";
-export { UpstreamStreamError } from "./reducer.ts"
+export { UpstreamStreamError } from "./reducer.ts";
export interface AnthropicNonStreamResponse {
- id: string
- type: "message"
- role: "assistant"
- model: string
+ id: string;
+ type: "message";
+ role: "assistant";
+ model: string;
content: Array<
- | { type: "text"; text: string }
- | { type: "tool_use"; id: string; name: string; input: unknown }
- >
- stop_reason: "end_turn" | "tool_use" | "max_tokens" | null
- stop_sequence: null
+ { type: "text"; text: string } | { type: "tool_use"; id: string; name: string; input: unknown }
+ >;
+ stop_reason: "end_turn" | "tool_use" | "max_tokens" | null;
+ stop_sequence: null;
usage: {
- input_tokens: number
- output_tokens: number
- cache_creation_input_tokens: number
- cache_read_input_tokens: number
- }
+ input_tokens: number;
+ output_tokens: number;
+ cache_creation_input_tokens: number;
+ cache_read_input_tokens: number;
+ };
}
export interface AccumulatedResponse {
- response: AnthropicNonStreamResponse
- rawUsage?: CodexUsage
+ response: AnthropicNonStreamResponse;
+ rawUsage?: CodexUsage;
}
/**
@@ -40,59 +39,59 @@ export async function accumulateResponse(
): Promise<AccumulatedResponse> {
type Block =
| { kind: "text"; text: string }
- | { kind: "tool"; id: string; name: string; args: string }
+ | { kind: "tool"; id: string; name: string; args: string };
- const ordered: number[] = []
- const blocks = new Map<number, Block>()
- let stopReason: AnthropicNonStreamResponse["stop_reason"] = null
- let usage: ReturnType<typeof mapUsageToAnthropic> | undefined
- let rawUsage: CodexUsage | undefined
+ const ordered: number[] = [];
+ const blocks = new Map<number, Block>();
+ let stopReason: AnthropicNonStreamResponse["stop_reason"] = null;
+ let usage: ReturnType<typeof mapUsageToAnthropic> | undefined;
+ let rawUsage: CodexUsage | undefined;
for await (const e of reduceUpstream(upstream, opts.log)) {
switch (e.kind) {
case "text-start":
- blocks.set(e.index, { kind: "text", text: "" })
- ordered.push(e.index)
- break
+ blocks.set(e.index, { kind: "text", text: "" });
+ ordered.push(e.index);
+ break;
case "text-delta": {
- const b = blocks.get(e.index)
- if (b?.kind === "text") b.text += e.text
- break
+ const b = blocks.get(e.index);
+ if (b?.kind === "text") b.text += e.text;
+ break;
}
case "tool-start":
- blocks.set(e.index, { kind: "tool", id: e.id, name: e.name, args: "" })
- ordered.push(e.index)
- break
+ blocks.set(e.index, { kind: "tool", id: e.id, name: e.name, args: "" });
+ ordered.push(e.index);
+ break;
case "tool-delta": {
- const b = blocks.get(e.index)
- if (b?.kind === "tool") b.args += e.partialJson
- break
+ const b = blocks.get(e.index);
+ if (b?.kind === "tool") b.args += e.partialJson;
+ break;
}
case "text-stop":
case "tool-stop":
- break
+ break;
case "finish":
- stopReason = e.stopReason
- rawUsage = e.usage
- usage = mapUsageToAnthropic(e.usage)
- break
+ stopReason = e.stopReason;
+ rawUsage = e.usage;
+ usage = mapUsageToAnthropic(e.usage);
+ break;
}
}
- const content: AnthropicNonStreamResponse["content"] = []
+ const content: AnthropicNonStreamResponse["content"] = [];
for (const i of ordered) {
- const b = blocks.get(i)
- if (!b) continue
+ const b = blocks.get(i);
+ if (!b) continue;
if (b.kind === "text") {
- if (b.text) content.push({ type: "text", text: b.text })
+ if (b.text) content.push({ type: "text", text: b.text });
} else {
- let input: unknown = {}
+ let input: unknown = {};
try {
- input = b.args ? JSON.parse(b.args) : {}
+ input = b.args ? JSON.parse(b.args) : {};
} catch {
- input = { _raw: b.args }
+ input = { _raw: b.args };
}
- content.push({ type: "tool_use", id: b.id, name: b.name, input })
+ content.push({ type: "tool_use", id: b.id, name: b.name, input });
}
}
@@ -113,5 +112,5 @@ export async function accumulateResponse(
cache_read_input_tokens: 0,
},
},
- }
+ };
}
diff --git a/src/providers/codex/translate/model-allowlist.test.ts b/src/providers/codex/translate/model-allowlist.test.ts
index 9ede655..3af24b7 100644
--- a/src/providers/codex/translate/model-allowlist.test.ts
+++ b/src/providers/codex/translate/model-allowlist.test.ts
@@ -1,95 +1,95 @@
-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 { 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 {
ALLOWED_MODELS,
MODEL_ALIASES,
resolveModel,
resolveModelRequest,
-} from "./model-allowlist.ts"
-import { loadConfig } from "../../../config.ts"
-import { ANTHROPIC_STYLE_ALIASES } from "../../registry.ts"
+} from "./model-allowlist.ts";
+import { loadConfig } from "../../../config.ts";
+import { ANTHROPIC_STYLE_ALIASES } from "../../registry.ts";
afterEach(() => {
- loadConfig({ forceReload: true })
-})
+ loadConfig({ forceReload: true });
+});
describe("resolveModel", () => {
it("returns alias when no override is set", () => {
- loadConfig({ env: {}, forceReload: true })
- expect(resolveModel("sonnet")).toBe("gpt-5.4")
- })
+ 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")
- })
+ 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" } }))
+ 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")
+ loadConfig({ configPath: path, env: {}, forceReload: true });
+ expect(resolveModel("sonnet")).toBe("gpt-5.5");
} finally {
- rmSync(dir, { recursive: true, force: true })
+ 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" } }))
+ 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")
+ expect(resolveModel("sonnet")).toBe("gpt-5.5");
} finally {
- rmSync(dir, { recursive: true, force: true })
+ 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")
- })
+ loadConfig({ env: { CCP_CODEX_MODEL: "" }, forceReload: true });
+ expect(resolveModel("sonnet")).toBe("gpt-5.4");
+ });
it("detects fast model aliases", () => {
- loadConfig({ env: {}, forceReload: true })
+ loadConfig({ env: {}, forceReload: true });
expect(resolveModelRequest("gpt-5.4-fast")).toEqual({
model: "gpt-5.4",
serviceTier: "priority",
- })
- })
+ });
+ });
it("model override preserves fast model alias service tier", () => {
- loadConfig({ env: { CCP_CODEX_MODEL: "gpt-5.5" }, forceReload: true })
+ loadConfig({ env: { CCP_CODEX_MODEL: "gpt-5.5" }, forceReload: true });
expect(resolveModelRequest("gpt-5.4-fast")).toEqual({
model: "gpt-5.5",
serviceTier: "priority",
- })
- })
+ });
+ });
it("does not strip unsupported fast-looking model names", () => {
- loadConfig({ env: {}, forceReload: true })
- expect(resolveModelRequest("gpt-4.1-fast")).toEqual({ model: "gpt-4.1-fast" })
- })
+ loadConfig({ env: {}, forceReload: true });
+ expect(resolveModelRequest("gpt-4.1-fast")).toEqual({ model: "gpt-4.1-fast" });
+ });
it("resolves every shared Anthropic-style alias to an allowed model", () => {
- loadConfig({ env: {}, forceReload: true })
+ loadConfig({ env: {}, forceReload: true });
for (const alias of ANTHROPIC_STYLE_ALIASES) {
- expect(ALLOWED_MODELS.has(resolveModel(alias))).toBe(true)
+ expect(ALLOWED_MODELS.has(resolveModel(alias))).toBe(true);
}
- })
+ });
it("keeps the shared alias routing set aligned with Codex model aliases", () => {
- expect([...ANTHROPIC_STYLE_ALIASES].sort()).toEqual([...MODEL_ALIASES.keys()].sort())
- })
-})
+ expect([...ANTHROPIC_STYLE_ALIASES].sort()).toEqual([...MODEL_ALIASES.keys()].sort());
+ });
+});
diff --git a/src/providers/codex/translate/model-allowlist.ts b/src/providers/codex/translate/model-allowlist.ts
index fd8c3e2..a8ba9c9 100644
--- a/src/providers/codex/translate/model-allowlist.ts
+++ b/src/providers/codex/translate/model-allowlist.ts
@@ -1,5 +1,5 @@
-import { codexModel } from "../../../config.ts"
-import type { ServiceTier } from "./request.ts"
+import { codexModel } from "../../../config.ts";
+import type { ServiceTier } from "./request.ts";
export const ALLOWED_MODELS = new Set([
"gpt-5.2",
@@ -8,11 +8,9 @@ export const ALLOWED_MODELS = new Set([
"gpt-5.4",
"gpt-5.4-mini",
"gpt-5.5",
-])
+]);
-export const FAST_MODEL_ALIASES = new Set(
- Array.from(ALLOWED_MODELS, (model) => `${model}-fast`),
-)
+export const FAST_MODEL_ALIASES = new Set(Array.from(ALLOWED_MODELS, (model) => `${model}-fast`));
export const MODEL_ALIASES = new Map<string, string>([
["haiku", "gpt-5.4-mini"],
@@ -22,15 +20,15 @@ export const MODEL_ALIASES = new Map<string, string>([
["claude-sonnet-4-6", "gpt-5.4"],
["opus", "gpt-5.5"],
["claude-opus-4-7", "gpt-5.5"],
-])
+]);
export interface ResolvedModel {
- model: string
- serviceTier?: ServiceTier
+ model: string;
+ serviceTier?: ServiceTier;
}
export function resolveModel(model: string): string {
- return resolveModelRequest(model).model
+ return resolveModelRequest(model).model;
}
export function resolveModelRequest(model: string): ResolvedModel {
@@ -38,26 +36,26 @@ export function resolveModelRequest(model: string): ResolvedModel {
// 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 alias = MODEL_ALIASES.get(model) ?? model
- const isFastAlias = FAST_MODEL_ALIASES.has(alias)
- const modelWithoutTier = isFastAlias ? alias.slice(0, -"-fast".length) : alias
- const override = codexModel()
+ const alias = MODEL_ALIASES.get(model) ?? model;
+ const isFastAlias = FAST_MODEL_ALIASES.has(alias);
+ const modelWithoutTier = isFastAlias ? alias.slice(0, -"-fast".length) : alias;
+ const override = codexModel();
return {
model: override ?? modelWithoutTier,
...(isFastAlias ? { serviceTier: "priority" } : {}),
- }
+ };
}
export function assertAllowedModel(model: string): void {
if (!ALLOWED_MODELS.has(model)) {
- throw new ModelNotAllowedError(model)
+ throw new ModelNotAllowedError(model);
}
}
export class ModelNotAllowedError extends Error {
constructor(public model: string) {
- super(`Model not allowed: ${model}`)
- this.name = "ModelNotAllowedError"
+ super(`Model not allowed: ${model}`);
+ this.name = "ModelNotAllowedError";
}
}
diff --git a/src/providers/codex/translate/reducer.ts b/src/providers/codex/translate/reducer.ts
index e151531..e2ebbb3 100644
--- a/src/providers/codex/translate/reducer.ts
+++ b/src/providers/codex/translate/reducer.ts
@@ -1,6 +1,6 @@
-import { parseSseStream } from "../../../sse.ts"
-import type { Logger } from "../../../log.ts"
-import { logVerbose } from "../../../config.ts"
+import { parseSseStream } from "../../../sse.ts";
+import type { Logger } from "../../../log.ts";
+import { logVerbose } from "../../../config.ts";
export class UpstreamStreamError extends Error {
constructor(
@@ -8,19 +8,19 @@ export class UpstreamStreamError extends Error {
message: string,
public retryAfterSeconds?: number,
) {
- super(message)
- this.name = "UpstreamStreamError"
+ super(message);
+ this.name = "UpstreamStreamError";
}
}
export interface CodexUsage {
- input_tokens?: number
- output_tokens?: number
- input_tokens_details?: { cached_tokens?: number }
- output_tokens_details?: { reasoning_tokens?: number }
+ input_tokens?: number;
+ output_tokens?: number;
+ input_tokens_details?: { cached_tokens?: number };
+ output_tokens_details?: { reasoning_tokens?: number };
}
-export type StopReason = "end_turn" | "tool_use" | "max_tokens"
+export type StopReason = "end_turn" | "tool_use" | "max_tokens";
export type ReducerEvent =
| { kind: "text-start"; index: number }
@@ -29,40 +29,40 @@ export type ReducerEvent =
| { kind: "tool-start"; index: number; id: string; name: string }
| { kind: "tool-delta"; index: number; partialJson: string }
| { kind: "tool-stop"; index: number }
- | { kind: "finish"; stopReason: StopReason; usage: CodexUsage | undefined }
+ | { kind: "finish"; stopReason: StopReason; usage: CodexUsage | undefined };
interface TextState {
- kind: "text"
- index: number
- textAccum: string
+ kind: "text";
+ index: number;
+ textAccum: string;
}
interface ToolState {
- kind: "tool"
- index: number
- callId: string
- name: string
- argsAccum: string
- hadDelta: boolean
- bufferUntilDone: boolean
- emittedArgs: boolean
+ kind: "tool";
+ index: number;
+ callId: string;
+ name: string;
+ argsAccum: string;
+ hadDelta: boolean;
+ bufferUntilDone: boolean;
+ emittedArgs: boolean;
}
-type BlockState = TextState | ToolState
+type BlockState = TextState | ToolState;
function shouldBufferToolArgs(name: string): boolean {
- return name === "Read"
+ return name === "Read";
}
function sanitizeToolArgs(name: string, args: string): string {
- if (name !== "Read" || !args) return args
+ if (name !== "Read" || !args) return args;
try {
- const parsed = JSON.parse(args)
- if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return args
- if (!("pages" in parsed) || parsed.pages !== "") return args
- const sanitized = { ...parsed }
- delete sanitized.pages
- return JSON.stringify(sanitized)
+ const parsed = JSON.parse(args);
+ if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return args;
+ if (!("pages" in parsed) || parsed.pages !== "") return args;
+ const sanitized = { ...parsed };
+ delete sanitized.pages;
+ return JSON.stringify(sanitized);
} catch {
- return args
+ return args;
}
}
@@ -79,25 +79,26 @@ export async function* reduceUpstream(
upstream: ReadableStream<Uint8Array>,
log: Logger,
): AsyncGenerator<ReducerEvent> {
- const blocksByOutputIndex = new Map<number, BlockState>()
- const itemIdToOutputIndex = new Map<string, number>()
- let anthropicIndex = 0
- let sawToolUse = false
- let finalUsage: CodexUsage | undefined
- let incomplete = false
+ const blocksByOutputIndex = new Map<number, BlockState>();
+ const itemIdToOutputIndex = new Map<string, number>();
+ let anthropicIndex = 0;
+ let sawToolUse = false;
+ let finalUsage: CodexUsage | undefined;
+ let incomplete = false;
for await (const evt of parseSseStream(upstream)) {
- if (!evt.data) continue
- let p: any
+ if (!evt.data) continue;
+ let p: any;
try {
- p = JSON.parse(evt.data)
+ p = JSON.parse(evt.data);
} catch (err) {
- log.warn("upstream sse: invalid json", { err: String(err), preview: evt.data.slice(0, 200) })
- continue
+ log.warn("upstream sse: invalid json", { err: String(err), preview: evt.data.slice(0, 200) });
+ continue;
}
- const t: string = p.type || evt.event || ""
+ const t: string = p.type || evt.event || "";
- if (logVerbose()) 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) {
@@ -105,30 +106,30 @@ export async function* reduceUpstream(
"rate_limit",
"rate limit reached",
p.rate_limits?.primary?.reset_after_seconds,
- )
+ );
}
- continue
+ continue;
}
if (t === "response.failed" || t === "response.error" || t === "error") {
- const message = p?.response?.error?.message || p?.error?.message || "Upstream error"
- throw new UpstreamStreamError("failed", message)
+ const message = p?.response?.error?.message || p?.error?.message || "Upstream error";
+ throw new UpstreamStreamError("failed", message);
}
if (t === "response.output_item.added") {
- const item = p.item
- const outputIndex: number = p.output_index
- if (!item) continue
- if (item.type === "reasoning") continue
+ const item = p.item;
+ const outputIndex: number = p.output_index;
+ if (!item) continue;
+ if (item.type === "reasoning") continue;
if (item.type === "message") {
- const idx = anthropicIndex++
- blocksByOutputIndex.set(outputIndex, { kind: "text", index: idx, textAccum: "" })
- if (item.id) itemIdToOutputIndex.set(item.id, outputIndex)
- yield { kind: "text-start", index: idx }
- continue
+ const idx = anthropicIndex++;
+ blocksByOutputIndex.set(outputIndex, { kind: "text", index: idx, textAccum: "" });
+ if (item.id) itemIdToOutputIndex.set(item.id, outputIndex);
+ yield { kind: "text-start", index: idx };
+ continue;
}
if (item.type === "function_call") {
- sawToolUse = true
- const idx = anthropicIndex++
+ sawToolUse = true;
+ const idx = anthropicIndex++;
blocksByOutputIndex.set(outputIndex, {
kind: "tool",
index: idx,
@@ -138,121 +139,121 @@ export async function* reduceUpstream(
hadDelta: false,
bufferUntilDone: shouldBufferToolArgs(item.name),
emittedArgs: false,
- })
- yield { kind: "tool-start", index: idx, id: item.call_id, name: item.name }
- continue
+ });
+ yield { kind: "tool-start", index: idx, id: item.call_id, name: item.name };
+ continue;
}
- continue
+ continue;
}
if (t === "response.output_text.delta") {
- const outputIndex: number | undefined = p.output_index
- const itemId: string | undefined = p.item_id
- let state: BlockState | undefined
- if (typeof outputIndex === "number") state = blocksByOutputIndex.get(outputIndex)
+ const outputIndex: number | undefined = p.output_index;
+ const itemId: string | undefined = p.item_id;
+ let state: BlockState | undefined;
+ if (typeof outputIndex === "number") state = blocksByOutputIndex.get(outputIndex);
if (!state && itemId) {
- const mapped = itemIdToOutputIndex.get(itemId)
- if (mapped !== undefined) state = blocksByOutputIndex.get(mapped)
+ const mapped = itemIdToOutputIndex.get(itemId);
+ if (mapped !== undefined) state = blocksByOutputIndex.get(mapped);
}
- if (!state || state.kind !== "text") continue
- const delta: string = p.delta ?? ""
- if (!delta) continue
- state.textAccum += delta
- yield { kind: "text-delta", index: state.index, text: delta }
- continue
+ if (!state || state.kind !== "text") continue;
+ const delta: string = p.delta ?? "";
+ if (!delta) continue;
+ state.textAccum += delta;
+ yield { kind: "text-delta", index: state.index, text: delta };
+ continue;
}
if (t === "response.function_call_arguments.delta") {
- const state = blocksByOutputIndex.get(p.output_index)
- if (!state || state.kind !== "tool") continue
- const delta: string = p.delta ?? ""
- if (!delta) continue
- state.argsAccum += delta
- state.hadDelta = true
+ const state = blocksByOutputIndex.get(p.output_index);
+ if (!state || state.kind !== "tool") continue;
+ const delta: string = p.delta ?? "";
+ if (!delta) continue;
+ state.argsAccum += delta;
+ state.hadDelta = true;
if (!state.bufferUntilDone) {
- state.emittedArgs = true
- yield { kind: "tool-delta", index: state.index, partialJson: delta }
+ state.emittedArgs = true;
+ yield { kind: "tool-delta", index: state.index, partialJson: delta };
}
- continue
+ continue;
}
if (t === "response.function_call_arguments.done") {
- const state = blocksByOutputIndex.get(p.output_index)
- if (!state || state.kind !== "tool") continue
+ const state = blocksByOutputIndex.get(p.output_index);
+ if (!state || state.kind !== "tool") continue;
if (typeof p.arguments === "string" && !state.argsAccum) {
- state.argsAccum = p.arguments
+ state.argsAccum = p.arguments;
}
- continue
+ continue;
}
if (t === "response.output_item.done") {
- const item = p.item
- const state = blocksByOutputIndex.get(p.output_index)
- if (!state) continue
+ const item = p.item;
+ const state = blocksByOutputIndex.get(p.output_index);
+ if (!state) continue;
if (!item) {
// defensive
- if (state.kind === "text") yield { kind: "text-stop", index: state.index }
- else yield { kind: "tool-stop", index: state.index }
- blocksByOutputIndex.delete(p.output_index)
- continue
+ if (state.kind === "text") yield { kind: "text-stop", index: state.index };
+ else yield { kind: "tool-stop", index: state.index };
+ blocksByOutputIndex.delete(p.output_index);
+ continue;
}
- if (item.type === "reasoning") continue
+ if (item.type === "reasoning") continue;
if (state.kind === "tool") {
const finalArgs =
(typeof item.arguments === "string" && item.arguments.length
? item.arguments
- : state.argsAccum) || ""
+ : state.argsAccum) || "";
if (finalArgs.length) {
- state.argsAccum = sanitizeToolArgs(state.name, finalArgs)
+ state.argsAccum = sanitizeToolArgs(state.name, finalArgs);
if (state.bufferUntilDone || !state.emittedArgs) {
- state.emittedArgs = true
- yield { kind: "tool-delta", index: state.index, partialJson: state.argsAccum }
+ state.emittedArgs = true;
+ yield { kind: "tool-delta", index: state.index, partialJson: state.argsAccum };
}
}
}
if (state.kind === "text") {
- log.debug("text block complete", { index: state.index, text: state.textAccum })
- yield { kind: "text-stop", index: state.index }
+ log.debug("text block complete", { index: state.index, text: state.textAccum });
+ yield { kind: "text-stop", index: state.index };
} else {
log.debug("tool block complete", {
index: state.index,
callId: state.callId,
name: state.name,
args: state.argsAccum,
- })
- yield { kind: "tool-stop", index: state.index }
+ });
+ yield { kind: "tool-stop", index: state.index };
}
- blocksByOutputIndex.delete(p.output_index)
- continue
+ blocksByOutputIndex.delete(p.output_index);
+ continue;
}
if (t === "response.completed" || t === "response.incomplete") {
- finalUsage = p.response?.usage
- const reason = p.response?.incomplete_details?.reason
+ finalUsage = p.response?.usage;
+ const reason = p.response?.incomplete_details?.reason;
if (
t === "response.incomplete" ||
reason === "max_output_tokens" ||
p.response?.status === "incomplete"
) {
- incomplete = true
+ incomplete = true;
}
- continue
+ continue;
}
}
- const stopReason: StopReason = incomplete ? "max_tokens" : sawToolUse ? "tool_use" : "end_turn"
- yield { kind: "finish", stopReason, usage: finalUsage }
+ const stopReason: StopReason = incomplete ? "max_tokens" : sawToolUse ? "tool_use" : "end_turn";
+ yield { kind: "finish", stopReason, usage: finalUsage };
}
export function mapUsageToAnthropic(u: CodexUsage | undefined): {
- input_tokens: number
- output_tokens: number
- cache_creation_input_tokens: number
- cache_read_input_tokens: number
+ input_tokens: number;
+ output_tokens: number;
+ cache_creation_input_tokens: number;
+ cache_read_input_tokens: number;
} {
- const cachedTokens = u?.input_tokens_details?.cached_tokens ?? 0
- const totalInputTokens = u?.input_tokens ?? 0
+ const cachedTokens = u?.input_tokens_details?.cached_tokens ?? 0;
+ const totalInputTokens = u?.input_tokens ?? 0;
return {
// OpenAI-style usage reports cached prompt tokens inside input_tokens.
// Anthropic-style usage reports cache reads separately, and Claude Code
@@ -263,5 +264,5 @@ export function mapUsageToAnthropic(u: CodexUsage | undefined): {
output_tokens: u?.output_tokens ?? 0,
cache_creation_input_tokens: 0,
cache_read_input_tokens: cachedTokens,
- }
+ };
}
diff --git a/src/providers/codex/translate/request.test.ts b/src/providers/codex/translate/request.test.ts
index fdf0b0f..80c9997 100644
--- a/src/providers/codex/translate/request.test.ts
+++ b/src/providers/codex/translate/request.test.ts
@@ -1,73 +1,75 @@
-import { afterEach, describe, expect, it } from "bun:test"
-import { loadConfig } from "../../../config.ts"
-import type { AnthropicRequest } from "../../../anthropic/schema.ts"
-import { countTokens } from "../count-tokens.ts"
-import { InvalidServiceTierError, toolResultToString, translateRequest } from "./request.ts"
+import { afterEach, describe, expect, it } from "bun:test";
+import { loadConfig } from "../../../config.ts";
+import type { AnthropicRequest } from "../../../anthropic/schema.ts";
+import { countTokens } from "../count-tokens.ts";
+import { InvalidServiceTierError, toolResultToString, translateRequest } from "./request.ts";
const baseRequest: AnthropicRequest = {
model: "claude-sonnet-4-6",
messages: [{ role: "user", content: "hello" }],
-}
+};
afterEach(() => {
- loadConfig({ forceReload: true })
-})
+ loadConfig({ forceReload: true });
+});
describe("translateRequest", () => {
it("omits reasoning include when reasoning is not enabled", () => {
- const translated = translateRequest(baseRequest)
+ const translated = translateRequest(baseRequest);
- expect(translated.reasoning).toBeUndefined()
- expect(translated.include).toBeUndefined()
- })
+ expect(translated.reasoning).toBeUndefined();
+ expect(translated.include).toBeUndefined();
+ });
it("includes encrypted reasoning content when reasoning is enabled", () => {
const translated = translateRequest({
...baseRequest,
output_config: { effort: "medium" },
- })
+ });
- expect(translated.reasoning).toEqual({ effort: "medium" })
- expect(translated.include).toEqual(["reasoning.encrypted_content"])
- })
+ expect(translated.reasoning).toEqual({ effort: "medium" });
+ expect(translated.include).toEqual(["reasoning.encrypted_content"]);
+ });
it("normalizes fast service tier to upstream priority", () => {
- loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "fast" }, forceReload: true })
+ loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "fast" }, forceReload: true });
- const translated = translateRequest(baseRequest)
+ const translated = translateRequest(baseRequest);
- expect(translated.service_tier).toBe("priority")
- })
+ expect(translated.service_tier).toBe("priority");
+ });
it("passes flex service tier through", () => {
- loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "flex" }, forceReload: true })
+ loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "flex" }, forceReload: true });
- const translated = translateRequest(baseRequest)
+ const translated = translateRequest(baseRequest);
- expect(translated.service_tier).toBe("flex")
- })
+ expect(translated.service_tier).toBe("flex");
+ });
it("uses model service tier when no override is set", () => {
- loadConfig({ env: {}, forceReload: true })
+ loadConfig({ env: {}, forceReload: true });
- const translated = translateRequest(baseRequest, { serviceTier: "priority" })
+ const translated = translateRequest(baseRequest, { serviceTier: "priority" });
- expect(translated.service_tier).toBe("priority")
- })
+ expect(translated.service_tier).toBe("priority");
+ });
it("service tier override takes precedence over model service tier", () => {
- loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "flex" }, forceReload: true })
+ loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "flex" }, forceReload: true });
- const translated = translateRequest(baseRequest, { serviceTier: "priority" })
+ const translated = translateRequest(baseRequest, { serviceTier: "priority" });
- expect(translated.service_tier).toBe("flex")
- })
+ expect(translated.service_tier).toBe("flex");
+ });
it("rejects invalid service tier overrides", () => {
- loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "standard" }, forceReload: true })
+ loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "standard" }, forceReload: true });
- expect(() => translateRequest(baseRequest)).toThrow(InvalidServiceTierError)
- expect(() => translateRequest(baseRequest)).toThrow('Invalid service tier override: "standard"')
- })
+ expect(() => translateRequest(baseRequest)).toThrow(InvalidServiceTierError);
+ expect(() => translateRequest(baseRequest)).toThrow(
+ 'Invalid service tier override: "standard"',
+ );
+ });
it("translates unsupported tool result content blocks without throwing", () => {
const translated = translateRequest({
@@ -87,7 +89,7 @@ describe("translateRequest", () => {
],
},
],
- })
+ });
expect(translated.input).toEqual([
{
@@ -95,8 +97,8 @@ describe("translateRequest", () => {
call_id: "toolu_1",
output: "visible output\n[unsupported content block omitted: thinking]",
},
- ])
- })
+ ]);
+ });
it("preserves text and image tool result stringification", () => {
expect(
@@ -108,8 +110,8 @@ describe("translateRequest", () => {
},
{ type: "image", source: { type: "url", url: "https://example.invalid/a.png" } },
]),
- ).toBe("caption\n[image omitted: image/png]\n[image omitted: url]")
- })
+ ).toBe("caption\n[image omitted: image/png]\n[image omitted: url]");
+ });
it("counts unsupported tool result content blocks without throwing", () => {
expect(
@@ -128,19 +130,14 @@ describe("translateRequest", () => {
},
],
}),
- ).toBeGreaterThan(0)
- })
+ ).toBeGreaterThan(0);
+ });
it("treats malformed tool result content blocks as unsupported", () => {
- expect(
- toolResultToString([
- { type: "text" },
- { type: "image" },
- ]),
- ).toBe(
+ expect(toolResultToString([{ type: "text" }, { type: "image" }])).toBe(
"[unsupported content block omitted: text]\n[unsupported content block omitted: image]",
- )
- })
+ );
+ });
it("returns only the expected top-level upstream request fields", () => {
const translated = translateRequest({
@@ -170,7 +167,7 @@ describe("translateRequest", () => {
},
},
},
- })
+ });
expect(Object.keys(translated).sort()).toEqual([
"include",
@@ -184,6 +181,6 @@ describe("translateRequest", () => {
"text",
"tool_choice",
"tools",
- ])
- })
-})
+ ]);
+ });
+});
diff --git a/src/providers/codex/translate/request.ts b/src/providers/codex/translate/request.ts
index 039becf..5b108fb 100644
--- a/src/providers/codex/translate/request.ts
+++ b/src/providers/codex/translate/request.ts
@@ -6,147 +6,146 @@ import type {
AnthropicTextBlock,
AnthropicTool,
AnthropicToolResultContentBlock,
-} from "../../../anthropic/schema.ts"
-import { codexEffort, codexServiceTier } from "../../../config.ts"
+} from "../../../anthropic/schema.ts";
+import { codexEffort, codexServiceTier } from "../../../config.ts";
-export type Effort = "none" | "low" | "medium" | "high" | "xhigh"
-export type ServiceTier = "priority" | "flex"
+export type Effort = "none" | "low" | "medium" | "high" | "xhigh";
+export type ServiceTier = "priority" | "flex";
export class InvalidServiceTierError extends Error {
constructor(public serviceTier: string) {
super(
`Invalid service tier override: "${serviceTier}". Must be one of: ${Array.from(VALID_SERVICE_TIERS).join(", ")}`,
- )
- this.name = "InvalidServiceTierError"
+ );
+ this.name = "InvalidServiceTierError";
}
}
// 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.
export interface ResponsesRequest {
- model: string
- instructions?: string
- input: ResponsesInputItem[]
- tools?: ResponsesTool[]
- tool_choice?:
- | "auto"
- | "none"
- | "required"
- | { type: "function"; name: string }
- parallel_tool_calls?: boolean
- reasoning?: { effort?: Effort; summary?: unknown }
- store: false
- stream: true
- include?: string[]
- service_tier?: ServiceTier
- prompt_cache_key?: string
+ model: string;
+ instructions?: string;
+ input: ResponsesInputItem[];
+ tools?: ResponsesTool[];
+ tool_choice?: "auto" | "none" | "required" | { type: "function"; name: string };
+ parallel_tool_calls?: boolean;
+ reasoning?: { effort?: Effort; summary?: unknown };
+ store: false;
+ stream: true;
+ include?: string[];
+ service_tier?: ServiceTier;
+ prompt_cache_key?: string;
text?: {
- verbosity?: "low" | "medium" | "high"
+ verbosity?: "low" | "medium" | "high";
format?:
| { type: "text" }
| { type: "json_object" }
- | { type: "json_schema"; name: string; schema: unknown; strict?: boolean }
- }
- client_metadata?: Record<string, string>
+ | { type: "json_schema"; name: string; schema: unknown; strict?: boolean };
+ };
+ client_metadata?: Record<string, string>;
}
export type ResponsesInputItem =
| {
- type: "message"
- role: "user" | "assistant" | "developer" | "system"
- content: ResponsesContentPart[]
+ type: "message";
+ role: "user" | "assistant" | "developer" | "system";
+ content: ResponsesContentPart[];
}
| {
- type: "function_call"
- call_id: string
- name: string
- arguments: string
+ type: "function_call";
+ call_id: string;
+ name: string;
+ arguments: string;
}
| {
- type: "function_call_output"
- call_id: string
- output: string
- }
+ type: "function_call_output";
+ call_id: string;
+ output: string;
+ };
export type ResponsesContentPart =
| { type: "input_text"; text: string }
| { type: "output_text"; text: string }
- | { type: "input_image"; image_url: string }
+ | { type: "input_image"; image_url: string };
export interface ResponsesTool {
- type: "function"
- name: string
- description?: string
- parameters: unknown
- strict?: boolean
+ type: "function";
+ name: string;
+ description?: string;
+ parameters: unknown;
+ strict?: boolean;
}
export interface TranslateOptions {
- sessionId?: string
- serviceTier?: ServiceTier
+ sessionId?: string;
+ serviceTier?: ServiceTier;
}
-const VALID_EFFORTS = new Set<Effort>(["none", "low", "medium", "high", "xhigh"])
+const VALID_EFFORTS = new Set<Effort>(["none", "low", "medium", "high", "xhigh"]);
-const ANTHROPIC_EFFORTS = new Set(["low", "medium", "high", "max"])
+const ANTHROPIC_EFFORTS = new Set(["low", "medium", "high", "max"]);
-const VALID_SERVICE_TIERS = new Set(["fast", "priority", "flex"])
+const VALID_SERVICE_TIERS = new Set(["fast", "priority", "flex"]);
function assertValidEffort(effort: unknown): void {
if (effort !== undefined && !ANTHROPIC_EFFORTS.has(effort as string)) {
throw new Error(
`Invalid output_config.effort: "${effort}". Must be one of: ${Array.from(ANTHROPIC_EFFORTS).join(", ")}`,
- )
+ );
}
}
function toCodexEffort(
effort: NonNullable<AnthropicRequest["output_config"]>["effort"],
): Effort | undefined {
- if (effort === "max") return "xhigh"
- return effort
+ if (effort === "max") return "xhigh";
+ return effort;
}
function resolveEffort(effort?: Effort): Effort | undefined {
- const override = codexEffort()
+ const override = codexEffort();
if (override === undefined) {
- return effort
+ return effort;
}
if (!VALID_EFFORTS.has(override as Effort)) {
throw new Error(
`Invalid effort override: "${override}". Must be one of: ${Array.from(VALID_EFFORTS).join(", ")}`,
- )
+ );
}
- return override as Effort
+ return override as Effort;
}
function normalizeServiceTier(tier: string): ServiceTier {
if (!VALID_SERVICE_TIERS.has(tier)) {
- throw new InvalidServiceTierError(tier)
+ throw new InvalidServiceTierError(tier);
}
- return tier === "flex" ? "flex" : "priority"
+ return tier === "flex" ? "flex" : "priority";
}
function resolveServiceTier(modelServiceTier?: ServiceTier): ServiceTier | undefined {
- const tier = codexServiceTier()
- if (tier === undefined) return modelServiceTier
- return normalizeServiceTier(tier)
+ const tier = codexServiceTier();
+ if (tier === undefined) return modelServiceTier;
+ return normalizeServiceTier(tier);
}
-export function translateRequest(req: AnthropicRequest, opts: TranslateOptions = {}): ResponsesRequest {
- const instructions = buildInstructions(req.system)
- const input = buildInput(req.messages)
- const tools = req.tools?.map(toResponsesTool)
+export function translateRequest(
+ req: AnthropicRequest,
+ opts: TranslateOptions = {},
+): ResponsesRequest {
+ const instructions = buildInstructions(req.system);
+ const input = buildInput(req.messages);
+ const tools = req.tools?.map(toResponsesTool);
- const text: ResponsesRequest["text"] = { verbosity: "low" }
- const fmt = req.output_config?.format
+ const text: ResponsesRequest["text"] = { verbosity: "low" };
+ const fmt = req.output_config?.format;
if (fmt?.type === "json_schema") {
text.format = {
type: "json_schema",
name: fmt.name ?? "response",
schema: fmt.schema,
strict: true,
- }
+ };
}
const out: ResponsesRequest = {
@@ -157,154 +156,150 @@ export function translateRequest(req: AnthropicRequest, opts: TranslateOptions =
parallel_tool_calls: true,
tool_choice: mapToolChoice(req.tool_choice),
text,
- }
- if (instructions) out.instructions = instructions
- if (tools && tools.length) out.tools = tools
- if (opts.sessionId) out.prompt_cache_key = opts.sessionId
- const serviceTier = resolveServiceTier(opts.serviceTier)
- if (serviceTier) out.service_tier = serviceTier
- assertValidEffort(req.output_config?.effort)
- const effort = resolveEffort(toCodexEffort(req.output_config?.effort))
+ };
+ if (instructions) out.instructions = instructions;
+ if (tools && tools.length) out.tools = tools;
+ if (opts.sessionId) out.prompt_cache_key = opts.sessionId;
+ const serviceTier = resolveServiceTier(opts.serviceTier);
+ if (serviceTier) out.service_tier = serviceTier;
+ assertValidEffort(req.output_config?.effort);
+ const effort = resolveEffort(toCodexEffort(req.output_config?.effort));
if (effort) {
- out.reasoning = { effort }
- out.include = ["reasoning.encrypted_content"]
+ out.reasoning = { effort };
+ out.include = ["reasoning.encrypted_content"];
}
- return out
+ return out;
}
-function mapToolChoice(
- choice: AnthropicRequest["tool_choice"],
-): ResponsesRequest["tool_choice"] {
- if (!choice) return "auto"
+function mapToolChoice(choice: AnthropicRequest["tool_choice"]): ResponsesRequest["tool_choice"] {
+ if (!choice) return "auto";
switch (choice.type) {
case "auto":
- return "auto"
+ return "auto";
case "none":
- return "none"
+ return "none";
case "any":
- return "required"
+ return "required";
case "tool":
- return choice.name ? { type: "function", name: choice.name } : "required"
+ return choice.name ? { type: "function", name: choice.name } : "required";
}
}
export function buildInstructions(system: AnthropicRequest["system"]): string | undefined {
- if (!system) return undefined
+ if (!system) return undefined;
const blocks: AnthropicTextBlock[] =
- typeof system === "string" ? [{ type: "text", text: system }] : system
+ typeof system === "string" ? [{ type: "text", text: system }] : system;
const texts = blocks
.filter((b) => b && b.type === "text" && typeof b.text === "string")
.map((b) => b.text)
- .filter((t) => !t.startsWith("x-anthropic-billing-header:"))
- if (!texts.length) return undefined
- return texts.join("\n\n")
+ .filter((t) => !t.startsWith("x-anthropic-billing-header:"));
+ if (!texts.length) return undefined;
+ return texts.join("\n\n");
}
function buildInput(messages: AnthropicMessage[]): ResponsesInputItem[] {
- const out: ResponsesInputItem[] = []
+ const out: ResponsesInputItem[] = [];
for (const msg of messages) {
- const blocks = normalizeContent(msg.content)
+ const blocks = normalizeContent(msg.content);
if (msg.role === "user") {
// Split into message parts vs function_call_output items
- const parts: ResponsesContentPart[] = []
+ const parts: ResponsesContentPart[] = [];
for (const block of blocks) {
if (block.type === "text") {
- parts.push({ type: "input_text", text: block.text })
+ parts.push({ type: "input_text", text: block.text });
} else if (block.type === "image") {
- parts.push({ type: "input_image", image_url: imageToUrl(block) })
+ parts.push({ type: "input_image", image_url: imageToUrl(block) });
} else if (block.type === "tool_result") {
if (parts.length) {
- out.push({ type: "message", role: "user", content: parts.splice(0) })
+ out.push({ type: "message", role: "user", content: parts.splice(0) });
}
- const body = toolResultToString(block.content)
+ const body = toolResultToString(block.content);
out.push({
type: "function_call_output",
call_id: block.tool_use_id,
output: block.is_error ? `[tool execution error]\n${body}` : body,
- })
+ });
}
}
- if (parts.length) out.push({ type: "message", role: "user", content: parts })
+ if (parts.length) out.push({ type: "message", role: "user", content: parts });
} else {
// assistant: preserve interleaved order of text vs tool_use
- const textParts: ResponsesContentPart[] = []
+ const textParts: ResponsesContentPart[] = [];
const flushText = () => {
if (textParts.length) {
- out.push({ type: "message", role: "assistant", content: textParts.splice(0) })
+ out.push({ type: "message", role: "assistant", content: textParts.splice(0) });
}
- }
+ };
for (const block of blocks) {
if (block.type === "text") {
- textParts.push({ type: "output_text", text: block.text })
+ textParts.push({ type: "output_text", text: block.text });
} else if (block.type === "tool_use") {
- flushText()
+ flushText();
out.push({
type: "function_call",
call_id: block.id,
name: block.name,
arguments: JSON.stringify(block.input ?? {}),
- })
+ });
}
}
- flushText()
+ flushText();
}
}
- return out
+ return out;
}
export function normalizeContent(content: AnthropicMessage["content"]): AnthropicContentBlock[] {
- if (typeof content === "string") return [{ type: "text", text: content }]
- return content
+ if (typeof content === "string") return [{ type: "text", text: content }];
+ return content;
}
function imageToUrl(block: Extract<AnthropicContentBlock, { type: "image" }>): string {
- if (block.source.type === "url") return block.source.url
- return `data:${block.source.media_type};base64,${block.source.data}`
+ if (block.source.type === "url") return block.source.url;
+ return `data:${block.source.media_type};base64,${block.source.data}`;
}
function unsupportedToolResultBlockToString(block: AnthropicToolResultContentBlock): string {
- const type = typeof block.type === "string" ? block.type : "unknown"
- return `[unsupported content block omitted: ${type}]`
+ const type = typeof block.type === "string" ? block.type : "unknown";
+ return `[unsupported content block omitted: ${type}]`;
}
function isToolResultTextBlock(
block: AnthropicToolResultContentBlock,
): block is AnthropicTextBlock {
- return block.type === "text" && typeof block.text === "string"
+ return block.type === "text" && typeof block.text === "string";
}
function isRecord(value: unknown): value is Record<string, unknown> {
- return !!value && typeof value === "object"
+ return !!value && typeof value === "object";
}
function isToolResultImageBlock(
block: AnthropicToolResultContentBlock,
): block is AnthropicImageBlock {
- if (block.type !== "image") return false
- const source = block.source
- if (!isRecord(source)) return false
- if (source.type === "url") return typeof source.url === "string"
+ if (block.type !== "image") return false;
+ const source = block.source;
+ if (!isRecord(source)) return false;
+ if (source.type === "url") return typeof source.url === "string";
return (
source.type === "base64" &&
typeof source.media_type === "string" &&
typeof source.data === "string"
- )
+ );
}
-export function toolResultToString(
- content: string | AnthropicToolResultContentBlock[],
-): string {
- if (typeof content === "string") return content
+export function toolResultToString(content: string | AnthropicToolResultContentBlock[]): string {
+ if (typeof content === "string") return content;
return content
.map((b) => {
- if (isToolResultTextBlock(b)) return b.text
+ if (isToolResultTextBlock(b)) return b.text;
if (isToolResultImageBlock(b)) {
- const mt = b.source.type === "base64" ? b.source.media_type : "url"
- return `[image omitted: ${mt}]`
+ const mt = b.source.type === "base64" ? b.source.media_type : "url";
+ return `[image omitted: ${mt}]`;
}
- return unsupportedToolResultBlockToString(b)
+ return unsupportedToolResultBlockToString(b);
})
- .join("\n")
+ .join("\n");
}
function toResponsesTool(tool: AnthropicTool): ResponsesTool {
@@ -313,5 +308,5 @@ function toResponsesTool(tool: AnthropicTool): ResponsesTool {
name: tool.name,
description: tool.description,
parameters: tool.input_schema,
- }
+ };
}
diff --git a/src/providers/codex/translate/stream.ts b/src/providers/codex/translate/stream.ts
index ba29961..8403f29 100644
--- a/src/providers/codex/translate/stream.ts
+++ b/src/providers/codex/translate/stream.ts
@@ -1,6 +1,6 @@
-import { encodeSseEvent } from "../../../sse.ts"
-import type { Logger } from "../../../log.ts"
-import { mapUsageToAnthropic, reduceUpstream, UpstreamStreamError } from "./reducer.ts"
+import { encodeSseEvent } from "../../../sse.ts";
+import type { Logger } from "../../../log.ts";
+import { mapUsageToAnthropic, reduceUpstream, UpstreamStreamError } from "./reducer.ts";
/**
* Translate a Codex Responses SSE stream into Anthropic SSE events.
@@ -13,23 +13,26 @@ import { mapUsageToAnthropic, reduceUpstream, UpstreamStreamError } from "./redu
export function translateStream(
upstream: ReadableStream<Uint8Array>,
opts: {
- messageId: string
- model: string
- log: Logger
- onFinish?: (finish: { stopReason: "end_turn" | "tool_use" | "max_tokens"; usage?: Parameters<typeof mapUsageToAnthropic>[0] }) => void
+ messageId: string;
+ model: string;
+ log: Logger;
+ onFinish?: (finish: {
+ stopReason: "end_turn" | "tool_use" | "max_tokens";
+ usage?: Parameters<typeof mapUsageToAnthropic>[0];
+ }) => void;
},
): ReadableStream<Uint8Array> {
- const encoder = new TextEncoder()
+ const encoder = new TextEncoder();
return new ReadableStream<Uint8Array>({
async start(controller) {
const emit = (event: string, data: unknown) => {
- controller.enqueue(encoder.encode(encodeSseEvent(event, data)))
- }
- const activeTools = new Map<number, { id: string; name: string }>()
- let messageStarted = false
+ controller.enqueue(encoder.encode(encodeSseEvent(event, data)));
+ };
+ const activeTools = new Map<number, { id: string; name: string }>();
+ let messageStarted = false;
const ensureMessageStart = () => {
- if (messageStarted) return
- messageStarted = true
+ if (messageStarted) return;
+ messageStarted = true;
emit("message_start", {
type: "message_start",
message: {
@@ -47,34 +50,34 @@ export function translateStream(
cache_read_input_tokens: 0,
},
},
- })
- emit("ping", { type: "ping" })
- }
+ });
+ emit("ping", { type: "ping" });
+ };
try {
for await (const e of reduceUpstream(upstream, opts.log)) {
switch (e.kind) {
case "text-start":
- ensureMessageStart()
+ ensureMessageStart();
emit("content_block_start", {
type: "content_block_start",
index: e.index,
content_block: { type: "text", text: "" },
- })
- break
+ });
+ break;
case "text-delta":
emit("content_block_delta", {
type: "content_block_delta",
index: e.index,
delta: { type: "text_delta", text: e.text },
- })
- break
+ });
+ break;
case "text-stop":
- emit("content_block_stop", { type: "content_block_stop", index: e.index })
- break
+ emit("content_block_stop", { type: "content_block_stop", index: e.index });
+ break;
case "tool-start":
- activeTools.set(e.index, { id: e.id, name: e.name })
- ensureMessageStart()
+ activeTools.set(e.index, { id: e.id, name: e.name });
+ ensureMessageStart();
emit("content_block_start", {
type: "content_block_start",
index: e.index,
@@ -84,64 +87,64 @@ export function translateStream(
name: e.name,
input: {},
},
- })
- break
+ });
+ break;
case "tool-delta":
emit("content_block_delta", {
type: "content_block_delta",
index: e.index,
delta: { type: "input_json_delta", partial_json: e.partialJson },
- })
- break
+ });
+ break;
case "tool-stop":
- activeTools.delete(e.index)
- emit("content_block_stop", { type: "content_block_stop", index: e.index })
- break
+ activeTools.delete(e.index);
+ emit("content_block_stop", { type: "content_block_stop", index: e.index });
+ break;
case "finish":
- ensureMessageStart()
- opts.onFinish?.({ stopReason: e.stopReason, usage: e.usage })
+ ensureMessageStart();
+ opts.onFinish?.({ stopReason: e.stopReason, usage: e.usage });
emit("message_delta", {
type: "message_delta",
delta: { stop_reason: e.stopReason, stop_sequence: null },
usage: mapUsageToAnthropic(e.usage),
- })
- emit("message_stop", { type: "message_stop" })
- break
+ });
+ emit("message_stop", { type: "message_stop" });
+ break;
}
}
} catch (err) {
- const activeToolNames = Array.from(activeTools.values(), (tool) => tool.name)
- const activeToolCalls = Array.from(activeTools.values())
+ const activeToolNames = Array.from(activeTools.values(), (tool) => tool.name);
+ const activeToolCalls = Array.from(activeTools.values());
if (err instanceof UpstreamStreamError) {
opts.log.warn("upstream stream error", {
kind: err.kind,
message: err.message,
activeToolNames,
activeToolCalls,
- })
- ensureMessageStart()
+ });
+ ensureMessageStart();
emit("error", {
type: "error",
error: {
type: err.kind === "rate_limit" ? "rate_limit_error" : "api_error",
message: err.message,
},
- })
+ });
} else {
opts.log.error("stream translation error", {
err: String(err),
activeToolNames,
activeToolCalls,
- })
- ensureMessageStart()
+ });
+ ensureMessageStart();
emit("error", {
type: "error",
error: { type: "api_error", message: String(err) },
- })
+ });
}
} finally {
- controller.close()
+ controller.close();
}
},
- })
+ });
}
diff --git a/src/providers/kimi/auth/constants.ts b/src/providers/kimi/auth/constants.ts
index 58fbf9a..aca0178 100644
--- a/src/providers/kimi/auth/constants.ts
+++ b/src/providers/kimi/auth/constants.ts
@@ -1,15 +1,15 @@
-import { kimiBaseUrl, kimiOauthHost } from "../../../config.ts"
+import { kimiBaseUrl, kimiOauthHost } from "../../../config.ts";
-export const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098"
+export const CLIENT_ID = "17e5f671-d194-4dfb-9706-5516cb48c098";
// Read lazily so config.json values apply. CCP_KIMI_OAUTH_HOST / CCP_KIMI_BASE_URL
// env vars still work (env wins over file in the getter).
export function oauthHost(): string {
- return kimiOauthHost()
+ return kimiOauthHost();
}
export function apiBaseUrl(): string {
- return kimiBaseUrl()
+ 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"
-export const REFRESH_MARGIN_MS = 5 * 60 * 1000
+export const KIMI_CLI_VERSION = "1.37.0";
+export const REFRESH_MARGIN_MS = 5 * 60 * 1000;
diff --git a/src/providers/kimi/auth/device-id.ts b/src/providers/kimi/auth/device-id.ts
index 5175042..032d7ee 100644
--- a/src/providers/kimi/auth/device-id.ts
+++ b/src/providers/kimi/auth/device-id.ts
@@ -1,30 +1,30 @@
-import { mkdir, readFile, writeFile, chmod } from "node:fs/promises"
-import { dirname, join } from "node:path"
-import { kimiDeviceIdFile, legacyConfigDir } from "../../../paths.ts"
+import { mkdir, readFile, writeFile, chmod } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { kimiDeviceIdFile, legacyConfigDir } from "../../../paths.ts";
function path(): string {
- return kimiDeviceIdFile()
+ return kimiDeviceIdFile();
}
function legacyPath(): string {
- return join(legacyConfigDir(), "kimi", "device_id")
+ return join(legacyConfigDir(), "kimi", "device_id");
}
export async function getDeviceId(): Promise<string> {
for (const candidate of [path(), legacyPath()]) {
try {
- const raw = await readFile(candidate, "utf8")
- const trimmed = raw.trim()
- if (trimmed) return trimmed
+ const raw = await readFile(candidate, "utf8");
+ const trimmed = raw.trim();
+ if (trimmed) return trimmed;
} catch (err: any) {
- if (err?.code !== "ENOENT") throw err
+ if (err?.code !== "ENOENT") throw err;
}
}
- const id = crypto.randomUUID().replace(/-/g, "")
- const target = path()
- await mkdir(dirname(target), { recursive: true })
- await writeFile(target, id, { encoding: "utf8", mode: 0o600 })
+ const id = crypto.randomUUID().replace(/-/g, "");
+ const target = path();
+ await mkdir(dirname(target), { recursive: true });
+ await writeFile(target, id, { encoding: "utf8", mode: 0o600 });
try {
- await chmod(target, 0o600)
+ await chmod(target, 0o600);
} catch {}
- return id
+ return id;
}
diff --git a/src/providers/kimi/auth/headers.ts b/src/providers/kimi/auth/headers.ts
index 21ecb53..2db97ee 100644
--- a/src/providers/kimi/auth/headers.ts
+++ b/src/providers/kimi/auth/headers.ts
@@ -1,24 +1,24 @@
-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"
+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()
- const p = platform()
- if (p === "darwin") return `macOS ${release()} ${a}`.trim()
- if (p === "win32") return `Windows ${release()} ${a}`.trim()
- return `${p} ${release()} ${a}`.trim()
+ const a = arch();
+ const p = platform();
+ if (p === "darwin") return `macOS ${release()} ${a}`.trim();
+ if (p === "win32") return `Windows ${release()} ${a}`.trim();
+ return `${p} ${release()} ${a}`.trim();
}
function asciiOnly(value: string, fallback = "unknown"): string {
// Strip non-ASCII, which would be rejected as an HTTP header value.
- const cleaned = value.replace(/[^\x20-\x7e]/g, "").trim()
- return cleaned || fallback
+ const cleaned = value.replace(/[^\x20-\x7e]/g, "").trim();
+ return cleaned || fallback;
}
export async function commonHeaders(): Promise<Record<string, string>> {
- const deviceId = await getDeviceId()
+ const deviceId = await getDeviceId();
return {
"X-Msh-Platform": "kimi_cli",
"X-Msh-Version": KIMI_CLI_VERSION,
@@ -27,5 +27,5 @@ export async function commonHeaders(): Promise<Record<string, string>> {
"X-Msh-Os-Version": asciiOnly(release()),
"X-Msh-Device-Id": deviceId,
"User-Agent": kimiUserAgent(`KimiCLI/${KIMI_CLI_VERSION}`),
- }
+ };
}
diff --git a/src/providers/kimi/auth/jwt.ts b/src/providers/kimi/auth/jwt.ts
index c606998..bf65acc 100644
--- a/src/providers/kimi/auth/jwt.ts
+++ b/src/providers/kimi/auth/jwt.ts
@@ -1,23 +1,23 @@
interface KimiClaims {
- user_id?: string
- device_id?: string
- scope?: string
- exp?: number
- iat?: number
+ user_id?: string;
+ device_id?: string;
+ scope?: string;
+ exp?: number;
+ iat?: number;
}
export function decodeClaims(jwt: string): KimiClaims | undefined {
- const parts = jwt.split(".")
- if (parts.length < 2) return undefined
+ const parts = jwt.split(".");
+ if (parts.length < 2) return undefined;
try {
- const payload = parts[1]!.replace(/-/g, "+").replace(/_/g, "/")
- const padded = payload + "=".repeat((4 - (payload.length % 4)) % 4)
- return JSON.parse(Buffer.from(padded, "base64").toString("utf8")) as KimiClaims
+ const payload = parts[1]!.replace(/-/g, "+").replace(/_/g, "/");
+ const padded = payload + "=".repeat((4 - (payload.length % 4)) % 4);
+ return JSON.parse(Buffer.from(padded, "base64").toString("utf8")) as KimiClaims;
} catch {
- return undefined
+ return undefined;
}
}
export function extractUserId(accessToken: string): string | undefined {
- return decodeClaims(accessToken)?.user_id
+ return decodeClaims(accessToken)?.user_id;
}
diff --git a/src/providers/kimi/auth/login.ts b/src/providers/kimi/auth/login.ts
index 43c018e..18054c1 100644
--- a/src/providers/kimi/auth/login.ts
+++ b/src/providers/kimi/auth/login.ts
@@ -1,42 +1,42 @@
-import { CLIENT_ID, oauthHost } from "./constants.ts"
-import { commonHeaders } from "./headers.ts"
+import { CLIENT_ID, oauthHost } from "./constants.ts";
+import { commonHeaders } from "./headers.ts";
export interface TokenResponse {
- access_token: string
- refresh_token: string
- expires_in: number
- scope: string
- token_type: string
+ access_token: string;
+ refresh_token: string;
+ expires_in: number;
+ scope: string;
+ token_type: string;
}
interface DeviceAuth {
- user_code: string
- device_code: string
- verification_uri?: string
- verification_uri_complete: string
- expires_in?: number
- interval: number
+ user_code: string;
+ device_code: string;
+ verification_uri?: string;
+ verification_uri_complete: string;
+ expires_in?: number;
+ interval: number;
}
-const GRANT_DEVICE_CODE = "urn:ietf:params:oauth:grant-type:device_code"
-const POLL_SAFETY_MARGIN_MS = 500
+const GRANT_DEVICE_CODE = "urn:ietf:params:oauth:grant-type:device_code";
+const POLL_SAFETY_MARGIN_MS = 500;
export async function runDeviceLogin(): Promise<TokenResponse> {
- const headers = await commonHeaders()
+ const headers = await commonHeaders();
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(),
- })
+ });
if (!initResp.ok) {
- throw new Error(`Device authorization failed: ${initResp.status} ${await initResp.text()}`)
+ throw new Error(`Device authorization failed: ${initResp.status} ${await initResp.text()}`);
}
- const auth = (await initResp.json()) as DeviceAuth
- const intervalMs = Math.max(auth.interval || 5, 1) * 1000
+ const auth = (await initResp.json()) as DeviceAuth;
+ const intervalMs = Math.max(auth.interval || 5, 1) * 1000;
- console.log(`\nVisit: ${auth.verification_uri_complete}`)
- console.log(`Code: ${auth.user_code}\n`)
+ console.log(`\nVisit: ${auth.verification_uri_complete}`);
+ console.log(`Code: ${auth.user_code}\n`);
while (true) {
const resp = await fetch(`${oauthHost()}/api/oauth/token`, {
@@ -47,29 +47,29 @@ export async function runDeviceLogin(): Promise<TokenResponse> {
device_code: auth.device_code,
grant_type: GRANT_DEVICE_CODE,
}).toString(),
- })
+ });
if (resp.status === 200) {
- return (await resp.json()) as TokenResponse
+ return (await resp.json()) as TokenResponse;
}
// Pending / slow_down / expired come back as non-200 with a JSON error payload.
const body = (await resp.json().catch(() => ({}))) as {
- error?: string
- error_description?: string
- }
- const error = body.error ?? `http_${resp.status}`
+ error?: string;
+ error_description?: string;
+ };
+ const error = body.error ?? `http_${resp.status}`;
if (error === "expired_token") {
- throw new Error("Device code expired. Run login again.")
+ throw new Error("Device code expired. Run login again.");
}
if (error !== "authorization_pending" && error !== "slow_down") {
throw new Error(
`Device token poll failed (${resp.status}): ${error}${
body.error_description ? ` — ${body.error_description}` : ""
}`,
- )
+ );
}
- await new Promise((r) => setTimeout(r, intervalMs + POLL_SAFETY_MARGIN_MS))
+ await new Promise((r) => setTimeout(r, intervalMs + POLL_SAFETY_MARGIN_MS));
}
}
diff --git a/src/providers/kimi/auth/manager.ts b/src/providers/kimi/auth/manager.ts
index dff90e4..d26ccd1 100644
--- a/src/providers/kimi/auth/manager.ts
+++ b/src/providers/kimi/auth/manager.ts
@@ -1,75 +1,78 @@
-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"
-import { clearAuth, loadAuth, saveAuth, type StoredAuth } from "./token-store.ts"
-import { createLogger } from "../../../log.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";
+import { clearAuth, loadAuth, saveAuth, type StoredAuth } from "./token-store.ts";
+import { createLogger } from "../../../log.ts";
-const log = createLogger("kimi.auth")
+const log = createLogger("kimi.auth");
-const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504])
-const MAX_REFRESH_ATTEMPTS = 3
+const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504]);
+const MAX_REFRESH_ATTEMPTS = 3;
function validateTokenResponse(t: unknown): asserts t is TokenResponse {
- if (!t || typeof t !== "object") throw new Error("Invalid token response: not an object")
- const o = t as Record<string, unknown>
+ if (!t || typeof t !== "object") throw new Error("Invalid token response: not an object");
+ const o = t as Record<string, unknown>;
if (typeof o.access_token !== "string" || !o.access_token)
- throw new Error("Invalid token response: missing access_token")
+ throw new Error("Invalid token response: missing access_token");
if (typeof o.refresh_token !== "string" || !o.refresh_token)
- throw new Error("Invalid token response: missing refresh_token")
- if (o.expires_in !== undefined && (typeof o.expires_in !== "number" || !Number.isFinite(o.expires_in) || o.expires_in <= 0))
- throw new Error("Invalid token response: bad expires_in")
+ throw new Error("Invalid token response: missing refresh_token");
+ if (
+ o.expires_in !== undefined &&
+ (typeof o.expires_in !== "number" || !Number.isFinite(o.expires_in) || o.expires_in <= 0)
+ )
+ throw new Error("Invalid token response: bad expires_in");
}
-let cached: StoredAuth | undefined
-let inflight: Promise<StoredAuth> | undefined
+let cached: StoredAuth | undefined;
+let inflight: Promise<StoredAuth> | undefined;
export class KimiAuthUnauthorizedError extends Error {
constructor(message: string) {
- super(message)
- this.name = "KimiAuthUnauthorizedError"
+ super(message);
+ this.name = "KimiAuthUnauthorizedError";
}
}
export async function getAuth(): Promise<StoredAuth> {
if (!cached) {
- const stored = await loadAuth()
- if (!stored) throw new Error("Not authenticated. Run: claude-code-proxy kimi auth login")
- cached = stored
+ const stored = await loadAuth();
+ if (!stored) throw new Error("Not authenticated. Run: claude-code-proxy kimi auth login");
+ cached = stored;
}
if (cached.expires - REFRESH_MARGIN_MS > Date.now()) {
- return cached
+ return cached;
}
- if (inflight) return inflight
+ if (inflight) return inflight;
inflight = refreshNow(cached).finally(() => {
- inflight = undefined
- })
- return inflight
+ inflight = undefined;
+ });
+ return inflight;
}
export async function forceRefresh(): Promise<StoredAuth> {
if (!cached) {
- const stored = await loadAuth()
- if (!stored) throw new Error("Not authenticated")
- cached = stored
+ const stored = await loadAuth();
+ if (!stored) throw new Error("Not authenticated");
+ cached = stored;
}
- if (inflight) return inflight
+ if (inflight) return inflight;
inflight = refreshNow(cached).finally(() => {
- inflight = undefined
- })
- return inflight
+ inflight = undefined;
+ });
+ return inflight;
}
export async function persistInitialTokens(tokens: TokenResponse): Promise<StoredAuth> {
- validateTokenResponse(tokens)
- const auth = tokensToStored(tokens)
- await saveAuth(auth)
- cached = auth
- return auth
+ validateTokenResponse(tokens);
+ const auth = tokensToStored(tokens);
+ await saveAuth(auth);
+ cached = auth;
+ return auth;
}
export function resetCache(): void {
- cached = undefined
+ cached = undefined;
}
function tokensToStored(tokens: TokenResponse): StoredAuth {
@@ -79,18 +82,18 @@ function tokensToStored(tokens: TokenResponse): StoredAuth {
expires: Date.now() + (tokens.expires_in ?? 900) * 1000,
scope: tokens.scope,
userId: extractUserId(tokens.access_token),
- }
+ };
}
async function refreshNow(current: StoredAuth): Promise<StoredAuth> {
if (!current.refresh) {
- throw new KimiAuthUnauthorizedError("No refresh token stored; re-authenticate")
+ throw new KimiAuthUnauthorizedError("No refresh token stored; re-authenticate");
}
- const headers = await commonHeaders()
+ const headers = await commonHeaders();
- let lastErr: unknown
+ let lastErr: unknown;
for (let attempt = 0; attempt < MAX_REFRESH_ATTEMPTS; attempt++) {
- let resp: Response
+ let resp: Response;
try {
resp = await fetch(`${oauthHost()}/api/oauth/token`, {
method: "POST",
@@ -100,49 +103,49 @@ async function refreshNow(current: StoredAuth): Promise<StoredAuth> {
grant_type: "refresh_token",
refresh_token: current.refresh,
}).toString(),
- })
+ });
} catch (err) {
- lastErr = err
- log.warn("refresh network error", { attempt, err: String(err) })
- await backoff(attempt)
- continue
+ lastErr = err;
+ log.warn("refresh network error", { attempt, err: String(err) });
+ await backoff(attempt);
+ continue;
}
if (resp.status === 200) {
- const tokens = await resp.json()
- validateTokenResponse(tokens)
+ const tokens = await resp.json();
+ validateTokenResponse(tokens);
const next: StoredAuth = {
...tokensToStored(tokens),
refresh: tokens.refresh_token || current.refresh,
userId: extractUserId(tokens.access_token) || current.userId,
- }
- await saveAuth(next)
- cached = next
- return next
+ };
+ await saveAuth(next);
+ cached = next;
+ return next;
}
if (resp.status === 401 || resp.status === 403) {
// Refresh token is dead; clear local state so the next login is clean.
- cached = undefined
- await clearAuth().catch(() => undefined)
- const body = (await resp.json().catch(() => ({}))) as { error_description?: string }
+ cached = undefined;
+ await clearAuth().catch(() => undefined);
+ const body = (await resp.json().catch(() => ({}))) as { error_description?: string };
throw new KimiAuthUnauthorizedError(
body.error_description || `Token refresh unauthorized (${resp.status})`,
- )
+ );
}
if (!RETRYABLE_STATUSES.has(resp.status)) {
- throw new Error(`Token refresh failed: ${resp.status}`)
+ throw new Error(`Token refresh failed: ${resp.status}`);
}
- lastErr = new Error(`Token refresh failed: ${resp.status}`)
- log.warn("refresh retryable error", { attempt, status: resp.status })
- await backoff(attempt)
+ lastErr = new Error(`Token refresh failed: ${resp.status}`);
+ log.warn("refresh retryable error", { attempt, status: resp.status });
+ await backoff(attempt);
}
- throw new Error(`Token refresh failed after ${MAX_REFRESH_ATTEMPTS} attempts`)
+ throw new Error(`Token refresh failed after ${MAX_REFRESH_ATTEMPTS} attempts`);
}
function backoff(attempt: number): Promise<void> {
- const ms = 2 ** attempt * 1000
- return new Promise((r) => setTimeout(r, ms))
+ const ms = 2 ** attempt * 1000;
+ return new Promise((r) => setTimeout(r, ms));
}
diff --git a/src/providers/kimi/auth/token-store.ts b/src/providers/kimi/auth/token-store.ts
index 032da16..c50b098 100644
--- a/src/providers/kimi/auth/token-store.ts
+++ b/src/providers/kimi/auth/token-store.ts
@@ -1,78 +1,78 @@
-import { mkdir, readFile, writeFile, unlink, rename } from "node:fs/promises"
-import { dirname, join } from "node:path"
-import { keychainGet, keychainSet, keychainDelete } from "../../../keychain.ts"
-import { kimiAuthFile, legacyConfigDir } from "../../../paths.ts"
+import { mkdir, readFile, writeFile, unlink, rename } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { keychainGet, keychainSet, keychainDelete } from "../../../keychain.ts";
+import { kimiAuthFile, legacyConfigDir } from "../../../paths.ts";
export interface StoredAuth {
- access: string
- refresh: string
- expires: number
- scope?: string
- userId?: string
+ access: string;
+ refresh: string;
+ expires: number;
+ scope?: string;
+ userId?: string;
}
function file(): string {
- return kimiAuthFile()
+ return kimiAuthFile();
}
function legacyFile(): string {
- return join(legacyConfigDir(), "kimi", "auth.json")
+ return join(legacyConfigDir(), "kimi", "auth.json");
}
-const KEYCHAIN_SERVICE = "claude-code-proxy.kimi"
-const KEYCHAIN_ACCOUNT = "auth"
+const KEYCHAIN_SERVICE = "claude-code-proxy.kimi";
+const KEYCHAIN_ACCOUNT = "auth";
export async function loadAuth(): Promise<StoredAuth | undefined> {
if (process.platform === "darwin") {
- const raw = keychainGet(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT)
- if (!raw) return undefined
- return JSON.parse(raw) as StoredAuth
+ const raw = keychainGet(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
+ if (!raw) return undefined;
+ return JSON.parse(raw) as StoredAuth;
}
- const primary = file()
+ const primary = file();
try {
- const raw = await readFile(primary, "utf8")
- return JSON.parse(raw) as StoredAuth
+ const raw = await readFile(primary, "utf8");
+ return JSON.parse(raw) as StoredAuth;
} catch (err: any) {
- if (err?.code !== "ENOENT") throw err
+ if (err?.code !== "ENOENT") throw err;
}
- const legacy = legacyFile()
- if (legacy === primary) return undefined
+ const legacy = legacyFile();
+ if (legacy === primary) return undefined;
try {
- const raw = await readFile(legacy, "utf8")
- return JSON.parse(raw) as StoredAuth
+ const raw = await readFile(legacy, "utf8");
+ return JSON.parse(raw) as StoredAuth;
} catch (err: any) {
- if (err?.code === "ENOENT") return undefined
- throw err
+ if (err?.code === "ENOENT") return undefined;
+ throw err;
}
}
export async function saveAuth(auth: StoredAuth): Promise<void> {
if (process.platform === "darwin") {
- keychainSet(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, JSON.stringify(auth))
- return
+ keychainSet(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, JSON.stringify(auth));
+ return;
}
- 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, path)
+ 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, path);
}
export async function clearAuth(): Promise<void> {
if (process.platform === "darwin") {
- keychainDelete(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT)
- return
+ keychainDelete(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
+ return;
}
for (const path of [file(), legacyFile()]) {
try {
- await unlink(path)
+ await unlink(path);
} catch (err: any) {
- if (err?.code !== "ENOENT") throw err
+ 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.ts
index ca1ff0a..541e59b 100644
--- a/src/providers/kimi/client.ts
+++ b/src/providers/kimi/client.ts
@@ -1,16 +1,16 @@
-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"
-import type { RequestContext } from "../types.ts"
-import type { KimiChatRequest } from "./translate/request.ts"
-import { retryOn429 } from "../retry.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";
+import type { RequestContext } from "../types.ts";
+import type { KimiChatRequest } from "./translate/request.ts";
+import { retryOn429 } from "../retry.ts";
export interface KimiResponse {
- body: ReadableStream<Uint8Array>
- status: number
- headers: Headers
- requestStartTime: number
+ body: ReadableStream<Uint8Array>;
+ status: number;
+ headers: Headers;
+ requestStartTime: number;
}
export class KimiError extends Error {
@@ -20,16 +20,13 @@ export class KimiError extends Error {
public detail?: string,
public meta?: { retryAfter?: string },
) {
- super(message)
- this.name = "KimiError"
+ super(message);
+ this.name = "KimiError";
}
}
-export async function postKimi(
- body: KimiChatRequest,
- ctx: RequestContext,
-): Promise<KimiResponse> {
- const log = ctx.childLogger("kimi.client")
+export async function postKimi(body: KimiChatRequest, ctx: RequestContext): Promise<KimiResponse> {
+ const log = ctx.childLogger("kimi.client");
return retryOn429(() => attemptPostKimi(body, ctx, log), {
log,
signal: ctx.signal,
@@ -37,7 +34,7 @@ export async function postKimi(
err instanceof KimiError && err.status === 429
? { retryAfter: err.meta?.retryAfter }
: undefined,
- })
+ });
}
async function attemptPostKimi(
@@ -45,43 +42,43 @@ async function attemptPostKimi(
ctx: RequestContext,
log: Logger,
): Promise<KimiResponse> {
- let auth = await getAuth()
- const requestStartTime = Date.now()
- let resp = await doFetch(auth.access, body, log, ctx.signal)
+ let auth = await getAuth();
+ const requestStartTime = Date.now();
+ let resp = await doFetch(auth.access, body, log, ctx.signal);
if (resp.status === 401) {
- log.warn("got 401, refreshing token", {})
+ log.warn("got 401, refreshing token", {});
try {
- auth = await forceRefresh()
- resp = await doFetch(auth.access, body, log, ctx.signal)
+ auth = await forceRefresh();
+ resp = await doFetch(auth.access, body, log, ctx.signal);
} catch (err) {
if (err instanceof KimiAuthUnauthorizedError) {
- throw new KimiError(401, "Unauthorized", err.message)
+ throw new KimiError(401, "Unauthorized", err.message);
}
- log.error("refresh after 401 failed", { err: String(err) })
+ log.error("refresh after 401 failed", { err: String(err) });
}
}
if (resp.status === 429) {
- const retryAfter = resp.headers.get("retry-after") || undefined
- const text = await safeText(resp)
- throw new KimiError(429, "Rate limited", text, { retryAfter })
+ const retryAfter = resp.headers.get("retry-after") || undefined;
+ const text = await safeText(resp);
+ throw new KimiError(429, "Rate limited", text, { retryAfter });
}
if (!resp.ok) {
- const text = await safeText(resp)
- const type = resp.status === 401 || resp.status === 403 ? "Unauthorized" : "Upstream error"
- throw new KimiError(resp.status, type, text)
+ const text = await safeText(resp);
+ const type = resp.status === 401 || resp.status === 403 ? "Unauthorized" : "Upstream error";
+ throw new KimiError(resp.status, type, text);
}
- if (!resp.body) throw new KimiError(500, "Upstream returned no body")
+ if (!resp.body) throw new KimiError(500, "Upstream returned no body");
log.debug("upstream response", {
status: resp.status,
timeToHeadersMs: Date.now() - requestStartTime,
- })
+ });
- return { body: resp.body, status: resp.status, headers: resp.headers, requestStartTime }
+ return { body: resp.body, status: resp.status, headers: resp.headers, requestStartTime };
}
async function doFetch(
@@ -90,35 +87,35 @@ async function doFetch(
log: Logger,
signal?: AbortSignal,
): Promise<Response> {
- const fp = await commonHeaders()
+ const fp = await commonHeaders();
const headers = new Headers({
"Content-Type": "application/json",
Accept: "application/json",
Authorization: `Bearer ${accessToken}`,
...fp,
- })
+ });
- const bodyJson = JSON.stringify(body)
+ const bodyJson = JSON.stringify(body);
log.debug("posting to kimi", {
url: `${apiBaseUrl()}/chat/completions`,
model: body.model,
messageCount: body.messages.length,
toolCount: body.tools?.length ?? 0,
requestBodyBytes: new TextEncoder().encode(bodyJson).length,
- })
+ });
return fetch(`${apiBaseUrl()}/chat/completions`, {
method: "POST",
headers,
body: bodyJson,
signal,
- })
+ });
}
async function safeText(resp: Response): Promise<string> {
try {
- return await resp.text()
+ return await resp.text();
} catch {
- return ""
+ return "";
}
}
diff --git a/src/providers/kimi/count-tokens.ts b/src/providers/kimi/count-tokens.ts
index 5698740..3a4d919 100644
--- a/src/providers/kimi/count-tokens.ts
+++ b/src/providers/kimi/count-tokens.ts
@@ -1,82 +1,82 @@
-import { encode } from "gpt-tokenizer/model/gpt-4o"
-import type { AnthropicRequest } from "../../anthropic/schema.ts"
-import type { KimiChatRequest } from "./translate/request.ts"
-import { buildSystemMessage, normalizeContent, toolResultToString } from "./translate/request.ts"
+import { encode } from "gpt-tokenizer/model/gpt-4o";
+import type { AnthropicRequest } from "../../anthropic/schema.ts";
+import type { KimiChatRequest } from "./translate/request.ts";
+import { buildSystemMessage, normalizeContent, toolResultToString } from "./translate/request.ts";
-const IMAGE_TOKEN_ESTIMATE = 2000
+const IMAGE_TOKEN_ESTIMATE = 2000;
// Approximate — Kimi's tokenizer isn't gpt-tokenizer, but Claude Code's
// compaction logic only needs a monotonic estimate, not an exact count.
export function countTokens(req: AnthropicRequest): number {
- let total = 0
- const system = buildSystemMessage(req.system)
- if (system) total += encode(system).length
+ let total = 0;
+ const system = buildSystemMessage(req.system);
+ if (system) total += encode(system).length;
for (const msg of req.messages) {
- const blocks = normalizeContent(msg.content)
+ const blocks = normalizeContent(msg.content);
for (const block of blocks) {
if (block.type === "text") {
- total += encode(block.text).length
+ total += encode(block.text).length;
} else if (block.type === "image") {
- total += IMAGE_TOKEN_ESTIMATE
+ total += IMAGE_TOKEN_ESTIMATE;
} else if (block.type === "tool_use") {
- total += encode(block.name).length
- total += encode(JSON.stringify(block.input ?? {})).length
+ total += encode(block.name).length;
+ total += encode(JSON.stringify(block.input ?? {})).length;
} else if (block.type === "tool_result") {
- total += encode(toolResultToString(block.content)).length
+ total += encode(toolResultToString(block.content)).length;
} else if (block.type === "thinking") {
- total += encode(block.thinking).length
+ total += encode(block.thinking).length;
}
}
}
for (const tool of req.tools ?? []) {
- total += encode(tool.name).length
- if (tool.description) total += encode(tool.description).length
- total += encode(JSON.stringify(tool.input_schema ?? {})).length
+ total += encode(tool.name).length;
+ if (tool.description) total += encode(tool.description).length;
+ total += encode(JSON.stringify(tool.input_schema ?? {})).length;
}
- total += req.messages.length * 4
- return total
+ total += req.messages.length * 4;
+ return total;
}
export function countTranslatedTokens(req: KimiChatRequest): number {
- let total = 0
+ let total = 0;
for (const m of req.messages) {
if (m.role === "system") {
- total += encode(m.content).length
+ total += encode(m.content).length;
} else if (m.role === "user") {
- if (typeof m.content === "string") total += encode(m.content).length
+ if (typeof m.content === "string") total += encode(m.content).length;
else {
for (const p of m.content) {
- if (p.type === "text") total += encode(p.text).length
- else total += IMAGE_TOKEN_ESTIMATE
+ if (p.type === "text") total += encode(p.text).length;
+ else total += IMAGE_TOKEN_ESTIMATE;
}
}
} else if (m.role === "assistant") {
- if (typeof m.content === "string") total += encode(m.content).length
- if (m.reasoning_content) total += encode(m.reasoning_content).length
+ if (typeof m.content === "string") total += encode(m.content).length;
+ if (m.reasoning_content) total += encode(m.reasoning_content).length;
for (const tc of m.tool_calls ?? []) {
- total += encode(tc.function.name).length
- total += encode(tc.function.arguments).length
+ total += encode(tc.function.name).length;
+ total += encode(tc.function.arguments).length;
}
} else if (m.role === "tool") {
- if (typeof m.content === "string") total += encode(m.content).length
+ if (typeof m.content === "string") total += encode(m.content).length;
else {
for (const p of m.content) {
- if (p.type === "text") total += encode(p.text).length
- else total += IMAGE_TOKEN_ESTIMATE
+ if (p.type === "text") total += encode(p.text).length;
+ else total += IMAGE_TOKEN_ESTIMATE;
}
}
}
}
for (const tool of req.tools ?? []) {
- total += encode(tool.function.name).length
- if (tool.function.description) total += encode(tool.function.description).length
- total += encode(JSON.stringify(tool.function.parameters ?? {})).length
+ total += encode(tool.function.name).length;
+ if (tool.function.description) total += encode(tool.function.description).length;
+ total += encode(JSON.stringify(tool.function.parameters ?? {})).length;
}
- total += req.messages.length * 4
- return total
+ total += req.messages.length * 4;
+ return total;
}
diff --git a/src/providers/kimi/index.ts b/src/providers/kimi/index.ts
index e54397a..1e34529 100644
--- a/src/providers/kimi/index.ts
+++ b/src/providers/kimi/index.ts
@@ -1,45 +1,45 @@
-import type { Provider, CliHandlers, RequestContext } from "../types.ts"
-import type { AnthropicRequest } from "../../anthropic/schema.ts"
+import type { Provider, CliHandlers, RequestContext } from "../types.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 { countTokens, countTranslatedTokens } from "./count-tokens.ts"
-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"
-import { logVerbose } from "../../config.ts"
+} 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 { countTokens, countTranslatedTokens } from "./count-tokens.ts";
+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";
+import { logVerbose } from "../../config.ts";
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 log = ctx.childLogger("provider.kimi")
- const resolvedModel = resolveModel(body.model)
- const translated = translateRequest({ ...body, model: resolvedModel })
- const tokens = countTranslatedTokens(translated)
- log.debug("count_tokens", { tokens })
+ const log = ctx.childLogger("provider.kimi");
+ const resolvedModel = resolveModel(body.model);
+ const translated = translateRequest({ ...body, model: resolvedModel });
+ const tokens = countTranslatedTokens(translated);
+ log.debug("count_tokens", { tokens });
return new Response(JSON.stringify({ input_tokens: tokens }), {
headers: { "content-type": "application/json" },
- })
+ });
}
async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Promise<Response> {
- const log = ctx.childLogger("provider.kimi")
- 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 log = ctx.childLogger("provider.kimi");
+ const messageId = `msg_${crypto.randomUUID().replace(/-/g, "")}`;
+ const wantStream = body.stream !== false;
+ const messageCount = body.messages?.length ?? 0;
+ const toolCount = body.tools?.length ?? 0;
log.debug("anthropic request", {
model: body.model,
@@ -47,29 +47,29 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
toolCount,
stream: wantStream,
requestedMaxTokens: body.max_tokens,
- })
- if (logVerbose()) log.debug("anthropic request body", { body })
+ });
+ if (logVerbose()) log.debug("anthropic request body", { body });
- const resolvedModel = resolveModel(body.model)
+ const resolvedModel = resolveModel(body.model);
try {
- assertAllowedModel(resolvedModel)
+ 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
+ throw err;
}
const translated = translateRequest(
{ ...body, model: resolvedModel },
{ sessionId: ctx.sessionId },
- )
- const localInputTokens = countTokens(body)
- const translatedInputTokens = countTranslatedTokens(translated)
+ );
+ const localInputTokens = countTokens(body);
+ const translatedInputTokens = countTranslatedTokens(translated);
log.debug("translated request", {
requestedModel: body.model,
resolvedModel,
@@ -81,31 +81,30 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
reasoningEffort: translated.reasoning_effort,
thinking: translated.thinking?.type,
maxTokens: translated.max_tokens,
- })
- if (logVerbose()) log.debug("translated request body", { body: translated })
+ });
+ if (logVerbose()) log.debug("translated request body", { body: translated });
- let upstream
+ let upstream;
try {
- upstream = await postKimi(translated, ctx)
+ upstream = await postKimi(translated, ctx);
} catch (err) {
if (err instanceof KimiError) {
- log.warn("kimi error", { status: err.status, detail: err.detail })
+ log.warn("kimi error", { 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
+ 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)
+ const type = err.status === 401 || err.status === 403 ? "authentication_error" : "api_error";
+ return jsonError(err.status, type, err.detail || err.message);
}
- throw err
+ throw err;
}
if (wantStream) {
@@ -115,23 +114,20 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
log: ctx.childLogger("kimi.stream"),
requestStartTime: upstream.requestStartTime,
onFinish: (finish) => {
- const mappedUsage = finish.usage ? mapUsageToAnthropic(finish.usage) : undefined
+ const mappedUsage = finish.usage ? mapUsageToAnthropic(finish.usage) : undefined;
log.debug("stream finish", {
stopReason: finish.stopReason,
upstreamInputTokens: finish.usage?.prompt_tokens ?? 0,
upstreamOutputTokens: finish.usage?.completion_tokens ?? 0,
upstreamCachedInputTokens:
- finish.usage?.prompt_tokens_details?.cached_tokens ??
- finish.usage?.cached_tokens ??
- 0,
- upstreamReasoningTokens:
- finish.usage?.completion_tokens_details?.reasoning_tokens ?? 0,
+ finish.usage?.prompt_tokens_details?.cached_tokens ?? finish.usage?.cached_tokens ?? 0,
+ upstreamReasoningTokens: finish.usage?.completion_tokens_details?.reasoning_tokens ?? 0,
mappedInputTokens: mappedUsage?.input_tokens ?? 0,
mappedOutputTokens: mappedUsage?.output_tokens ?? 0,
mappedCacheReadTokens: mappedUsage?.cache_read_input_tokens ?? 0,
- })
+ });
},
- })
+ });
return new Response(stream, {
status: 200,
headers: {
@@ -139,72 +135,72 @@ async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Prom
"cache-control": "no-cache",
connection: "keep-alive",
},
- })
+ });
}
try {
- const result = await accumulateResponse(upstream.body, { messageId, model: body.model, log: ctx.childLogger("kimi.accumulate") })
+ const result = await accumulateResponse(upstream.body, {
+ messageId,
+ model: body.model,
+ log: ctx.childLogger("kimi.accumulate"),
+ });
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)", {
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)
+ 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)
+ return jsonError(502, "api_error", err.message);
}
- throw err
+ throw err;
}
}
const cli: CliHandlers = {
async login() {
- const tokens = await runDeviceLogin()
- const saved = await persistInitialTokens(tokens)
- console.log(`Auth saved in ${authPath()}`)
- if (saved.userId) console.log(`User: ${saved.userId}`)
- const secs = Math.floor((saved.expires - Date.now()) / 1000)
- console.log(`Expires in ${secs}s`)
+ const tokens = await runDeviceLogin();
+ const saved = await persistInitialTokens(tokens);
+ console.log(`Auth saved in ${authPath()}`);
+ if (saved.userId) console.log(`User: ${saved.userId}`);
+ const secs = Math.floor((saved.expires - Date.now()) / 1000);
+ console.log(`Expires in ${secs}s`);
},
async status() {
- const auth = await loadAuth()
+ const auth = await loadAuth();
if (!auth) {
- console.log("Not authenticated")
- process.exit(1)
+ console.log("Not authenticated");
+ process.exit(1);
}
- const ms = auth.expires - Date.now()
- console.log(`User: ${auth.userId ?? "(none)"}`)
- console.log(`Expires: ${new Date(auth.expires).toISOString()} (in ${Math.floor(ms / 1000)}s)`)
- console.log(`Scope: ${auth.scope ?? "(none)"}`)
- console.log(`Storage: ${authPath()}`)
+ const ms = auth.expires - Date.now();
+ console.log(`User: ${auth.userId ?? "(none)"}`);
+ console.log(`Expires: ${new Date(auth.expires).toISOString()} (in ${Math.floor(ms / 1000)}s)`);
+ console.log(`Scope: ${auth.scope ?? "(none)"}`);
+ console.log(`Storage: ${authPath()}`);
},
async logout() {
- await clearAuth()
- console.log("Logged out")
+ await clearAuth();
+ console.log("Logged out");
},
-}
+};
export const kimiProvider: Provider = {
name: "kimi",
- supportedModels: new Set([
- "kimi-for-coding",
- "kimi-k2.6",
- "k2.6",
- ]),
+ supportedModels: new Set(["kimi-for-coding", "kimi-k2.6", "k2.6"]),
handleMessages,
handleCountTokens,
cli,
-}
+};
diff --git a/src/providers/kimi/translate/accumulate.ts b/src/providers/kimi/translate/accumulate.ts
index 3572043..6ed7981 100644
--- a/src/providers/kimi/translate/accumulate.ts
+++ b/src/providers/kimi/translate/accumulate.ts
@@ -1,34 +1,34 @@
-import { mapUsageToAnthropic, reduceUpstream, type KimiUsage } from "./reducer.ts"
-import { makeThinkingSignature } from "./signature.ts"
+import { mapUsageToAnthropic, reduceUpstream, type KimiUsage } from "./reducer.ts";
+import { makeThinkingSignature } from "./signature.ts";
-export { UpstreamStreamError } from "./reducer.ts"
+export { UpstreamStreamError } from "./reducer.ts";
export interface AnthropicNonStreamResponse {
- id: string
- type: "message"
- role: "assistant"
- model: string
+ id: string;
+ type: "message";
+ role: "assistant";
+ model: string;
content: Array<
| { type: "text"; text: string }
| { type: "thinking"; thinking: string; signature: string }
| { type: "tool_use"; id: string; name: string; input: unknown }
- >
- stop_reason: "end_turn" | "tool_use" | "max_tokens" | null
- stop_sequence: null
+ >;
+ stop_reason: "end_turn" | "tool_use" | "max_tokens" | null;
+ stop_sequence: null;
usage: {
- input_tokens: number
- output_tokens: number
- cache_creation_input_tokens: number
- cache_read_input_tokens: number
- }
+ input_tokens: number;
+ output_tokens: number;
+ cache_creation_input_tokens: number;
+ cache_read_input_tokens: number;
+ };
}
export interface AccumulatedResponse {
- response: AnthropicNonStreamResponse
- rawUsage?: KimiUsage
+ response: AnthropicNonStreamResponse;
+ rawUsage?: KimiUsage;
}
-import type { Logger } from "../../../log.ts"
+import type { Logger } from "../../../log.ts";
export async function accumulateResponse(
upstream: ReadableStream<Uint8Array>,
@@ -37,87 +37,87 @@ export async function accumulateResponse(
type Block =
| { kind: "thinking"; text: string }
| { kind: "text"; text: string }
- | { kind: "tool"; id: string; name: string; args: string }
+ | { kind: "tool"; id: string; name: string; args: string };
- const ordered: number[] = []
- const blocks = new Map<number, Block>()
- let stopReason: AnthropicNonStreamResponse["stop_reason"] = null
- let usage: ReturnType<typeof mapUsageToAnthropic> | undefined
- let rawUsage: KimiUsage | undefined
- let reasoningChars = 0
- let contentChars = 0
- let toolCount = 0
- const stats = { chunkCount: 0 }
+ const ordered: number[] = [];
+ const blocks = new Map<number, Block>();
+ let stopReason: AnthropicNonStreamResponse["stop_reason"] = null;
+ let usage: ReturnType<typeof mapUsageToAnthropic> | undefined;
+ let rawUsage: KimiUsage | undefined;
+ let reasoningChars = 0;
+ let contentChars = 0;
+ let toolCount = 0;
+ const stats = { chunkCount: 0 };
for await (const e of reduceUpstream(upstream, stats, opts.log)) {
switch (e.kind) {
case "thinking-start":
- blocks.set(e.index, { kind: "thinking", text: "" })
- ordered.push(e.index)
- break
+ blocks.set(e.index, { kind: "thinking", text: "" });
+ ordered.push(e.index);
+ break;
case "thinking-delta": {
- const b = blocks.get(e.index)
+ const b = blocks.get(e.index);
if (b?.kind === "thinking") {
- b.text += e.text
- reasoningChars += e.text.length
+ b.text += e.text;
+ reasoningChars += e.text.length;
}
- break
+ break;
}
case "text-start":
- blocks.set(e.index, { kind: "text", text: "" })
- ordered.push(e.index)
- break
+ blocks.set(e.index, { kind: "text", text: "" });
+ ordered.push(e.index);
+ break;
case "text-delta": {
- const b = blocks.get(e.index)
+ const b = blocks.get(e.index);
if (b?.kind === "text") {
- b.text += e.text
- contentChars += e.text.length
+ b.text += e.text;
+ contentChars += e.text.length;
}
- break
+ break;
}
case "tool-start":
- toolCount++
- blocks.set(e.index, { kind: "tool", id: e.id, name: e.name, args: "" })
- ordered.push(e.index)
- break
+ toolCount++;
+ blocks.set(e.index, { kind: "tool", id: e.id, name: e.name, args: "" });
+ ordered.push(e.index);
+ break;
case "tool-delta": {
- const b = blocks.get(e.index)
- if (b?.kind === "tool") b.args += e.partialJson
- break
+ const b = blocks.get(e.index);
+ if (b?.kind === "tool") b.args += e.partialJson;
+ break;
}
case "thinking-stop":
case "text-stop":
case "tool-stop":
- break
+ break;
case "finish":
- stopReason = e.stopReason
- rawUsage = e.usage
- usage = mapUsageToAnthropic(e.usage)
- break
+ stopReason = e.stopReason;
+ rawUsage = e.usage;
+ usage = mapUsageToAnthropic(e.usage);
+ break;
}
}
- const content: AnthropicNonStreamResponse["content"] = []
+ const content: AnthropicNonStreamResponse["content"] = [];
for (const i of ordered) {
- const b = blocks.get(i)
- if (!b) continue
+ const b = blocks.get(i);
+ if (!b) continue;
if (b.kind === "thinking") {
if (b.text)
content.push({
type: "thinking",
thinking: b.text,
signature: makeThinkingSignature(opts.messageId, i),
- })
+ });
} else if (b.kind === "text") {
- if (b.text) content.push({ type: "text", text: b.text })
+ if (b.text) content.push({ type: "text", text: b.text });
} else {
- let input: unknown = {}
+ let input: unknown = {};
try {
- input = b.args ? JSON.parse(b.args) : {}
+ input = b.args ? JSON.parse(b.args) : {};
} catch {
- input = { _raw: b.args }
+ input = { _raw: b.args };
}
- content.push({ type: "tool_use", id: b.id, name: b.name, input })
+ content.push({ type: "tool_use", id: b.id, name: b.name, input });
}
}
@@ -128,7 +128,7 @@ export async function accumulateResponse(
toolCount,
stopReason,
usage: rawUsage,
- })
+ });
return {
rawUsage,
@@ -147,5 +147,5 @@ export async function accumulateResponse(
cache_read_input_tokens: 0,
},
},
- }
+ };
}
diff --git a/src/providers/kimi/translate/model-allowlist.ts b/src/providers/kimi/translate/model-allowlist.ts
index 4ebf640..7b93c86 100644
--- a/src/providers/kimi/translate/model-allowlist.ts
+++ b/src/providers/kimi/translate/model-allowlist.ts
@@ -1,6 +1,6 @@
-export const KIMI_DEFAULT_MODEL = "kimi-for-coding"
+export const KIMI_DEFAULT_MODEL = "kimi-for-coding";
-export const ALLOWED_MODELS = new Set([KIMI_DEFAULT_MODEL])
+export const ALLOWED_MODELS = new Set([KIMI_DEFAULT_MODEL]);
// Every incoming model name collapses to kimi-for-coding — the only model
// Kimi Code exposes. Explicit aliases exist so `ANTHROPIC_MODEL=haiku` works
@@ -14,19 +14,19 @@ const ALIAS_TARGETS: Record<string, string> = {
opus: KIMI_DEFAULT_MODEL,
"claude-opus-4-7": KIMI_DEFAULT_MODEL,
"kimi-for-coding": KIMI_DEFAULT_MODEL,
-}
+};
export function resolveModel(model: string): string {
- return ALIAS_TARGETS[model] ?? KIMI_DEFAULT_MODEL
+ return ALIAS_TARGETS[model] ?? KIMI_DEFAULT_MODEL;
}
export function assertAllowedModel(model: string): void {
- if (!ALLOWED_MODELS.has(model)) throw new ModelNotAllowedError(model)
+ if (!ALLOWED_MODELS.has(model)) throw new ModelNotAllowedError(model);
}
export class ModelNotAllowedError extends Error {
constructor(public model: string) {
- super(`Model not allowed: ${model}`)
- this.name = "ModelNotAllowedError"
+ super(`Model not allowed: ${model}`);
+ this.name = "ModelNotAllowedError";
}
}
diff --git a/src/providers/kimi/translate/reducer.ts b/src/providers/kimi/translate/reducer.ts
index 841e2f9..511936a 100644
--- a/src/providers/kimi/translate/reducer.ts
+++ b/src/providers/kimi/translate/reducer.ts
@@ -1,5 +1,5 @@
-import { parseSseStream } from "../../../sse.ts"
-import type { Logger } from "../../../log.ts"
+import { parseSseStream } from "../../../sse.ts";
+import type { Logger } from "../../../log.ts";
export class UpstreamStreamError extends Error {
constructor(
@@ -7,21 +7,21 @@ export class UpstreamStreamError extends Error {
message: string,
public retryAfterSeconds?: number,
) {
- super(message)
- this.name = "UpstreamStreamError"
+ super(message);
+ this.name = "UpstreamStreamError";
}
}
export interface KimiUsage {
- prompt_tokens?: number
- completion_tokens?: number
- total_tokens?: number
- cached_tokens?: number
- prompt_tokens_details?: { cached_tokens?: number }
- completion_tokens_details?: { reasoning_tokens?: number }
+ prompt_tokens?: number;
+ completion_tokens?: number;
+ total_tokens?: number;
+ cached_tokens?: number;
+ prompt_tokens_details?: { cached_tokens?: number };
+ completion_tokens_details?: { reasoning_tokens?: number };
}
-export type StopReason = "end_turn" | "tool_use" | "max_tokens"
+export type StopReason = "end_turn" | "tool_use" | "max_tokens";
export type ReducerEvent =
| { kind: "thinking-start"; index: number }
@@ -33,31 +33,31 @@ export type ReducerEvent =
| { kind: "tool-start"; index: number; id: string; name: string }
| { kind: "tool-delta"; index: number; partialJson: string }
| { kind: "tool-stop"; index: number }
- | { kind: "finish"; stopReason: StopReason; usage: KimiUsage | undefined }
+ | { kind: "finish"; stopReason: StopReason; usage: KimiUsage | undefined };
interface StreamChunk {
choices?: Array<{
delta?: {
- role?: string
- content?: string | null
- reasoning_content?: string | null
+ role?: string;
+ content?: string | null;
+ reasoning_content?: string | null;
tool_calls?: Array<{
- index: number
- id?: string
- type?: string
- function?: { name?: string; arguments?: string }
- }>
- }
- finish_reason?: string | null
- }>
- usage?: KimiUsage
- error?: { message?: string; type?: string }
+ index: number;
+ id?: string;
+ type?: string;
+ function?: { name?: string; arguments?: string };
+ }>;
+ };
+ finish_reason?: string | null;
+ }>;
+ usage?: KimiUsage;
+ error?: { message?: string; type?: string };
}
interface ToolSlot {
- blockIndex: number
- id: string
- name: string
+ blockIndex: number;
+ id: string;
+ name: string;
}
/**
@@ -66,7 +66,7 @@ interface ToolSlot {
* streaming and non-streaming frontends.
*/
export interface ReducerStats {
- chunkCount: number
+ chunkCount: number;
}
export async function* reduceUpstream(
@@ -74,139 +74,139 @@ export async function* reduceUpstream(
stats?: ReducerStats,
log?: Logger,
): AsyncGenerator<ReducerEvent> {
- let nextBlockIndex = 0
- let thinkingIndex: number | undefined
- let textIndex: number | undefined
- const toolSlots = new Map<number, ToolSlot>() // keyed by upstream tool_calls[].index
+ let nextBlockIndex = 0;
+ let thinkingIndex: number | undefined;
+ let textIndex: number | undefined;
+ const toolSlots = new Map<number, ToolSlot>(); // keyed by upstream tool_calls[].index
- let sawToolCalls = false
- let finishReason: string | null | undefined
- let finalUsage: KimiUsage | undefined
+ let sawToolCalls = false;
+ let finishReason: string | null | undefined;
+ let finalUsage: KimiUsage | undefined;
const closeThinking = function* () {
if (thinkingIndex !== undefined) {
- const idx = thinkingIndex
- thinkingIndex = undefined
- yield { kind: "thinking-stop" as const, index: idx }
+ const idx = thinkingIndex;
+ thinkingIndex = undefined;
+ yield { kind: "thinking-stop" as const, index: idx };
}
- }
+ };
const closeText = function* () {
if (textIndex !== undefined) {
- const idx = textIndex
- textIndex = undefined
- yield { kind: "text-stop" as const, index: idx }
+ const idx = textIndex;
+ textIndex = undefined;
+ yield { kind: "text-stop" as const, index: idx };
}
- }
+ };
const closeAllTools = function* () {
for (const slot of toolSlots.values()) {
- yield { kind: "tool-stop" as const, index: slot.blockIndex }
+ yield { kind: "tool-stop" as const, index: slot.blockIndex };
}
- toolSlots.clear()
- }
+ toolSlots.clear();
+ };
for await (const evt of parseSseStream(upstream)) {
- if (!evt.data) continue
- const data = evt.data.trim()
- if (data === "[DONE]") continue
+ if (!evt.data) continue;
+ const data = evt.data.trim();
+ if (data === "[DONE]") continue;
- let chunk: StreamChunk
+ let chunk: StreamChunk;
try {
- chunk = JSON.parse(data) as StreamChunk
+ chunk = JSON.parse(data) as StreamChunk;
} catch (err) {
- log?.warn("upstream sse: invalid json", { err: String(err), preview: data.slice(0, 200) })
- continue
+ log?.warn("upstream sse: invalid json", { err: String(err), preview: data.slice(0, 200) });
+ continue;
}
- if (stats) stats.chunkCount++
+ if (stats) stats.chunkCount++;
if (chunk.error) {
- throw new UpstreamStreamError("failed", chunk.error.message || "Upstream error")
+ throw new UpstreamStreamError("failed", chunk.error.message || "Upstream error");
}
if (chunk.usage && !chunk.choices?.length) {
- finalUsage = chunk.usage
- continue
+ finalUsage = chunk.usage;
+ continue;
}
- const choice = chunk.choices?.[0]
- if (!choice) continue
- const delta = choice.delta ?? {}
+ const choice = chunk.choices?.[0];
+ if (!choice) continue;
+ const delta = choice.delta ?? {};
if (typeof delta.reasoning_content === "string" && delta.reasoning_content.length > 0) {
if (thinkingIndex === undefined) {
- thinkingIndex = nextBlockIndex++
- yield { kind: "thinking-start", index: thinkingIndex }
+ thinkingIndex = nextBlockIndex++;
+ yield { kind: "thinking-start", index: thinkingIndex };
}
- yield { kind: "thinking-delta", index: thinkingIndex, text: delta.reasoning_content }
+ yield { kind: "thinking-delta", index: thinkingIndex, text: delta.reasoning_content };
}
if (typeof delta.content === "string" && delta.content.length > 0) {
- yield* closeThinking()
+ yield* closeThinking();
if (textIndex === undefined) {
- textIndex = nextBlockIndex++
- yield { kind: "text-start", index: textIndex }
+ textIndex = nextBlockIndex++;
+ yield { kind: "text-start", index: textIndex };
}
- yield { kind: "text-delta", index: textIndex, text: delta.content }
+ yield { kind: "text-delta", index: textIndex, text: delta.content };
}
if (delta.tool_calls?.length) {
- yield* closeThinking()
- yield* closeText()
+ yield* closeThinking();
+ yield* closeText();
for (const tc of delta.tool_calls) {
- const upstreamIdx = tc.index
- let slot = toolSlots.get(upstreamIdx)
+ const upstreamIdx = tc.index;
+ let slot = toolSlots.get(upstreamIdx);
if (!slot) {
// First fragment of this tool call: must carry id + function.name.
- const id = tc.id ?? ""
- const name = tc.function?.name ?? ""
+ const id = tc.id ?? "";
+ const name = tc.function?.name ?? "";
if (!id || !name) {
// Defensive: out-of-order fragment before the initial one. Skip.
- continue
+ continue;
}
- sawToolCalls = true
- slot = { blockIndex: nextBlockIndex++, id, name }
- toolSlots.set(upstreamIdx, slot)
- yield { kind: "tool-start", index: slot.blockIndex, id, name }
+ sawToolCalls = true;
+ slot = { blockIndex: nextBlockIndex++, id, name };
+ toolSlots.set(upstreamIdx, slot);
+ yield { kind: "tool-start", index: slot.blockIndex, id, name };
}
- const argsDelta = tc.function?.arguments
+ const argsDelta = tc.function?.arguments;
if (typeof argsDelta === "string" && argsDelta.length > 0) {
- yield { kind: "tool-delta", index: slot.blockIndex, partialJson: argsDelta }
+ yield { kind: "tool-delta", index: slot.blockIndex, partialJson: argsDelta };
}
}
}
if (choice.finish_reason) {
- finishReason = choice.finish_reason
- if (chunk.usage) finalUsage = chunk.usage
+ finishReason = choice.finish_reason;
+ if (chunk.usage) finalUsage = chunk.usage;
}
}
- yield* closeThinking()
- yield* closeText()
- yield* closeAllTools()
+ yield* closeThinking();
+ yield* closeText();
+ yield* closeAllTools();
const stopReason: StopReason =
finishReason === "length"
? "max_tokens"
: finishReason === "tool_calls" || sawToolCalls
? "tool_use"
- : "end_turn"
+ : "end_turn";
- yield { kind: "finish", stopReason, usage: finalUsage }
+ yield { kind: "finish", stopReason, usage: finalUsage };
}
export function mapUsageToAnthropic(u: KimiUsage | undefined): {
- input_tokens: number
- output_tokens: number
- cache_creation_input_tokens: number
- cache_read_input_tokens: number
+ input_tokens: number;
+ output_tokens: number;
+ cache_creation_input_tokens: number;
+ cache_read_input_tokens: number;
} {
- const cached = u?.prompt_tokens_details?.cached_tokens ?? u?.cached_tokens ?? 0
- const totalPrompt = u?.prompt_tokens ?? 0
+ const cached = u?.prompt_tokens_details?.cached_tokens ?? u?.cached_tokens ?? 0;
+ const totalPrompt = u?.prompt_tokens ?? 0;
return {
input_tokens: Math.max(0, totalPrompt - cached),
output_tokens: u?.completion_tokens ?? 0,
cache_creation_input_tokens: 0,
cache_read_input_tokens: cached,
- }
+ };
}
diff --git a/src/providers/kimi/translate/request.test.ts b/src/providers/kimi/translate/request.test.ts
index 65cab82..3bfae85 100644
--- a/src/providers/kimi/translate/request.test.ts
+++ b/src/providers/kimi/translate/request.test.ts
@@ -1,7 +1,7 @@
-import { describe, expect, it } from "bun:test"
-import type { AnthropicRequest } from "../../../anthropic/schema.ts"
-import { countTokens } from "../count-tokens.ts"
-import { translateRequest } from "./request.ts"
+import { describe, expect, it } from "bun:test";
+import type { AnthropicRequest } from "../../../anthropic/schema.ts";
+import { countTokens } from "../count-tokens.ts";
+import { translateRequest } from "./request.ts";
describe("translateRequest", () => {
it("translates unsupported tool result content blocks as text parts", () => {
@@ -22,7 +22,7 @@ describe("translateRequest", () => {
],
},
],
- }
+ };
expect(translateRequest(req).messages).toEqual([
{
@@ -33,8 +33,8 @@ describe("translateRequest", () => {
{ type: "text", text: "[unsupported content block omitted: thinking]" },
],
},
- ])
- })
+ ]);
+ });
it("preserves image tool result content parts", () => {
const req: AnthropicRequest = {
@@ -57,7 +57,7 @@ describe("translateRequest", () => {
],
},
],
- }
+ };
expect(translateRequest(req).messages).toEqual([
{
@@ -68,8 +68,8 @@ describe("translateRequest", () => {
{ type: "image_url", image_url: { url: "data:image/png;base64,abc" } },
],
},
- ])
- })
+ ]);
+ });
it("counts unsupported tool result content blocks without throwing", () => {
const req: AnthropicRequest = {
@@ -86,8 +86,8 @@ describe("translateRequest", () => {
],
},
],
- }
+ };
- expect(countTokens(req)).toBeGreaterThan(0)
- })
-})
+ expect(countTokens(req)).toBeGreaterThan(0);
+ });
+});
diff --git a/src/providers/kimi/translate/request.ts b/src/providers/kimi/translate/request.ts
index 3545616..3ed7392 100644
--- a/src/providers/kimi/translate/request.ts
+++ b/src/providers/kimi/translate/request.ts
@@ -6,67 +6,67 @@ import type {
AnthropicTextBlock,
AnthropicTool,
AnthropicToolResultContentBlock,
-} from "../../../anthropic/schema.ts"
+} from "../../../anthropic/schema.ts";
// OpenAI-compatible chat-completions request shape used by Kimi.
// Only the fields kimi-cli is known to send are included; unknown
// fields are not forwarded.
export interface KimiChatRequest {
- model: string
- messages: KimiMessage[]
- tools?: KimiTool[]
- tool_choice?: KimiToolChoice
- stream: true
- stream_options: { include_usage: true }
- max_tokens: number
- reasoning_effort?: "low" | "medium" | "high"
- thinking?: { type: "enabled" }
- prompt_cache_key?: string
+ model: string;
+ messages: KimiMessage[];
+ tools?: KimiTool[];
+ tool_choice?: KimiToolChoice;
+ stream: true;
+ stream_options: { include_usage: true };
+ max_tokens: number;
+ reasoning_effort?: "low" | "medium" | "high";
+ thinking?: { type: "enabled" };
+ prompt_cache_key?: string;
}
export type KimiToolChoice =
| "auto"
| "none"
| "required"
- | { type: "function"; function: { name: string } }
+ | { type: "function"; function: { name: string } };
export type KimiAssistantMessage = {
- role: "assistant"
- content?: string | null
- reasoning_content?: string
- tool_calls?: KimiAssistantToolCall[]
-}
+ role: "assistant";
+ content?: string | null;
+ reasoning_content?: string;
+ tool_calls?: KimiAssistantToolCall[];
+};
export type KimiMessage =
| { role: "system"; content: string }
| { role: "user"; content: string | KimiUserContentPart[] }
| KimiAssistantMessage
- | { role: "tool"; tool_call_id: string; content: string | KimiToolResultPart[] }
+ | { role: "tool"; tool_call_id: string; content: string | KimiToolResultPart[] };
export type KimiUserContentPart =
| { type: "text"; text: string }
- | { type: "image_url"; image_url: { url: string } }
+ | { type: "image_url"; image_url: { url: string } };
export type KimiToolResultPart =
| { type: "text"; text: string }
- | { type: "image_url"; image_url: { url: string } }
+ | { type: "image_url"; image_url: { url: string } };
export interface KimiAssistantToolCall {
- id: string
- type: "function"
- function: { name: string; arguments: string }
+ id: string;
+ type: "function";
+ function: { name: string; arguments: string };
}
export interface KimiTool {
- type: "function"
- function: { name: string; description?: string; parameters: unknown }
+ type: "function";
+ function: { name: string; description?: string; parameters: unknown };
}
export interface TranslateOptions {
- sessionId?: string
+ sessionId?: string;
}
-const DEFAULT_MAX_TOKENS = 32000
+const DEFAULT_MAX_TOKENS = 32000;
// Kimi's `kimi-for-coding` is a reasoning model: it always produces
// reasoning_content and its server always enforces that prior assistant
@@ -78,10 +78,10 @@ export function translateRequest(
req: AnthropicRequest,
opts: TranslateOptions = {},
): KimiChatRequest {
- const messages = buildMessages(req)
- const tools = req.tools?.map(toKimiTool)
+ const messages = buildMessages(req);
+ const tools = req.tools?.map(toKimiTool);
- assertValidEffort(req.output_config?.effort)
+ assertValidEffort(req.output_config?.effort);
const out: KimiChatRequest = {
model: req.model,
messages,
@@ -90,26 +90,26 @@ export function translateRequest(
max_tokens: clampMaxTokens(req.max_tokens),
reasoning_effort: mapReasoningEffort(req.output_config?.effort),
thinking: { type: "enabled" },
- }
- if (tools && tools.length) out.tools = tools
- const tool_choice = mapToolChoice(req.tool_choice)
- if (tool_choice !== "auto") out.tool_choice = tool_choice
- if (opts.sessionId) out.prompt_cache_key = opts.sessionId
- return out
+ };
+ if (tools && tools.length) out.tools = tools;
+ const tool_choice = mapToolChoice(req.tool_choice);
+ if (tool_choice !== "auto") out.tool_choice = tool_choice;
+ if (opts.sessionId) out.prompt_cache_key = opts.sessionId;
+ return out;
}
function clampMaxTokens(requested: number | undefined): number {
- if (!requested || requested <= 0) return DEFAULT_MAX_TOKENS
- return Math.min(requested, DEFAULT_MAX_TOKENS)
+ if (!requested || requested <= 0) return DEFAULT_MAX_TOKENS;
+ return Math.min(requested, DEFAULT_MAX_TOKENS);
}
-const ANTHROPIC_EFFORTS = new Set(["low", "medium", "high", "max"])
+const ANTHROPIC_EFFORTS = new Set(["low", "medium", "high", "max"]);
function assertValidEffort(effort: unknown): void {
if (effort !== undefined && !ANTHROPIC_EFFORTS.has(effort as string)) {
throw new Error(
`Invalid output_config.effort: "${effort}". Must be one of: ${Array.from(ANTHROPIC_EFFORTS).join(", ")}`,
- )
+ );
}
}
@@ -119,52 +119,50 @@ function assertValidEffort(effort: unknown): void {
function mapReasoningEffort(
effort: NonNullable<AnthropicRequest["output_config"]>["effort"],
): "low" | "medium" | "high" {
- if (effort === "max") return "high"
- return effort ?? "medium"
+ if (effort === "max") return "high";
+ return effort ?? "medium";
}
function mapToolChoice(choice: AnthropicRequest["tool_choice"]): KimiToolChoice {
- if (!choice) return "auto"
+ if (!choice) return "auto";
switch (choice.type) {
case "auto":
- return "auto"
+ return "auto";
case "none":
- return "none"
+ return "none";
case "any":
- return "required"
+ return "required";
case "tool":
- return choice.name
- ? { type: "function", function: { name: choice.name } }
- : "required"
+ return choice.name ? { type: "function", function: { name: choice.name } } : "required";
}
}
export function buildSystemMessage(system: AnthropicRequest["system"]): string | undefined {
- if (!system) return undefined
+ if (!system) return undefined;
const blocks: AnthropicTextBlock[] =
- typeof system === "string" ? [{ type: "text", text: system }] : system
+ typeof system === "string" ? [{ type: "text", text: system }] : system;
const texts = blocks
.filter((b) => b && b.type === "text" && typeof b.text === "string")
.map((b) => b.text)
- .filter((t) => !t.startsWith("x-anthropic-billing-header:"))
- if (!texts.length) return undefined
- return texts.join("\n\n")
+ .filter((t) => !t.startsWith("x-anthropic-billing-header:"));
+ if (!texts.length) return undefined;
+ return texts.join("\n\n");
}
function buildMessages(req: AnthropicRequest): KimiMessage[] {
- const out: KimiMessage[] = []
- const system = buildSystemMessage(req.system)
- if (system) out.push({ role: "system", content: system })
+ const out: KimiMessage[] = [];
+ const system = buildSystemMessage(req.system);
+ if (system) out.push({ role: "system", content: system });
for (const msg of req.messages) {
- const blocks = normalizeContent(msg.content)
+ const blocks = normalizeContent(msg.content);
if (msg.role === "user") {
- pushUserMessages(out, blocks)
+ pushUserMessages(out, blocks);
} else {
- pushAssistantMessage(out, blocks)
+ pushAssistantMessage(out, blocks);
}
}
- return out
+ return out;
}
// In Anthropic-land a single user message can carry a mix of text, image,
@@ -172,49 +170,49 @@ function buildMessages(req: AnthropicRequest): KimiMessage[] {
// results to be their own role="tool" messages, so we split on tool_result
// boundaries, preserving order.
function pushUserMessages(out: KimiMessage[], blocks: AnthropicContentBlock[]): void {
- let buffer: KimiUserContentPart[] = []
+ let buffer: KimiUserContentPart[] = [];
const flushBuffer = () => {
- if (!buffer.length) return
+ if (!buffer.length) return;
// Collapse to a string when every part is text — matches what kimi-cli
// sends and keeps the wire payload compact.
- const allText = buffer.every((p) => p.type === "text")
+ const allText = buffer.every((p) => p.type === "text");
if (allText) {
out.push({
role: "user",
content: buffer.map((p) => (p as { type: "text"; text: string }).text).join(""),
- })
+ });
} else {
- out.push({ role: "user", content: buffer })
+ out.push({ role: "user", content: buffer });
}
- buffer = []
- }
+ buffer = [];
+ };
for (const block of blocks) {
if (block.type === "text") {
- buffer.push({ type: "text", text: block.text })
+ buffer.push({ type: "text", text: block.text });
} else if (block.type === "image") {
- buffer.push({ type: "image_url", image_url: { url: imageToUrl(block) } })
+ buffer.push({ type: "image_url", image_url: { url: imageToUrl(block) } });
} else if (block.type === "tool_result") {
- flushBuffer()
+ flushBuffer();
out.push({
role: "tool",
tool_call_id: block.tool_use_id,
content: toolResultContent(block.content, block.is_error),
- })
+ });
}
}
- flushBuffer()
+ flushBuffer();
}
function pushAssistantMessage(out: KimiMessage[], blocks: AnthropicContentBlock[]): void {
- const textParts: string[] = []
- const thinkingParts: string[] = []
- const toolCalls: KimiAssistantToolCall[] = []
+ const textParts: string[] = [];
+ const thinkingParts: string[] = [];
+ const toolCalls: KimiAssistantToolCall[] = [];
for (const block of blocks) {
if (block.type === "text") {
- if (block.text) textParts.push(block.text)
+ if (block.text) textParts.push(block.text);
} else if (block.type === "thinking") {
- if (block.thinking) thinkingParts.push(block.thinking)
+ if (block.thinking) thinkingParts.push(block.thinking);
} else if (block.type === "tool_use") {
toolCalls.push({
id: block.id,
@@ -223,100 +221,98 @@ function pushAssistantMessage(out: KimiMessage[], blocks: AnthropicContentBlock[
name: block.name,
arguments: JSON.stringify(block.input ?? {}),
},
- })
+ });
}
// image blocks from the assistant are dropped — Kimi's assistant
// schema does not express them.
}
- if (!textParts.length && !toolCalls.length && !thinkingParts.length) return
+ if (!textParts.length && !toolCalls.length && !thinkingParts.length) return;
- const msg: KimiAssistantMessage = { role: "assistant" }
- msg.content = textParts.length ? textParts.join("") : ""
+ const msg: KimiAssistantMessage = { role: "assistant" };
+ msg.content = textParts.length ? textParts.join("") : "";
// Kimi accepts one reasoning_content string per assistant turn. If a turn
// has multiple interleaved thinking blocks we concatenate in order —
// exact block/tool_use pairing can't be preserved over the wire.
- if (thinkingParts.length) msg.reasoning_content = thinkingParts.join("\n\n")
- if (toolCalls.length) msg.tool_calls = toolCalls
- out.push(msg)
+ if (thinkingParts.length) msg.reasoning_content = thinkingParts.join("\n\n");
+ if (toolCalls.length) msg.tool_calls = toolCalls;
+ out.push(msg);
}
export function normalizeContent(content: AnthropicMessage["content"]): AnthropicContentBlock[] {
- if (typeof content === "string") return [{ type: "text", text: content }]
- return content
+ if (typeof content === "string") return [{ type: "text", text: content }];
+ return content;
}
function imageToUrl(block: Extract<AnthropicContentBlock, { type: "image" }>): string {
- if (block.source.type === "url") return block.source.url
- return `data:${block.source.media_type};base64,${block.source.data}`
+ if (block.source.type === "url") return block.source.url;
+ return `data:${block.source.media_type};base64,${block.source.data}`;
}
function unsupportedToolResultBlockToString(block: AnthropicToolResultContentBlock): string {
- const type = typeof block.type === "string" ? block.type : "unknown"
- return `[unsupported content block omitted: ${type}]`
+ const type = typeof block.type === "string" ? block.type : "unknown";
+ return `[unsupported content block omitted: ${type}]`;
}
function isToolResultTextBlock(
block: AnthropicToolResultContentBlock,
): block is AnthropicTextBlock {
- return block.type === "text" && typeof block.text === "string"
+ return block.type === "text" && typeof block.text === "string";
}
function isRecord(value: unknown): value is Record<string, unknown> {
- return !!value && typeof value === "object"
+ return !!value && typeof value === "object";
}
function isToolResultImageBlock(
block: AnthropicToolResultContentBlock,
): block is AnthropicImageBlock {
- if (block.type !== "image") return false
- const source = block.source
- if (!isRecord(source)) return false
- if (source.type === "url") return typeof source.url === "string"
+ if (block.type !== "image") return false;
+ const source = block.source;
+ if (!isRecord(source)) return false;
+ if (source.type === "url") return typeof source.url === "string";
return (
source.type === "base64" &&
typeof source.media_type === "string" &&
typeof source.data === "string"
- )
+ );
}
export function toolResultContent(
content: string | AnthropicToolResultContentBlock[],
isError: boolean | undefined,
): string | KimiToolResultPart[] {
- const prefix = isError ? "[tool execution error]\n" : ""
- if (typeof content === "string") return prefix + content
+ const prefix = isError ? "[tool execution error]\n" : "";
+ if (typeof content === "string") return prefix + content;
- const parts: KimiToolResultPart[] = []
- if (prefix) parts.push({ type: "text", text: prefix })
+ const parts: KimiToolResultPart[] = [];
+ if (prefix) parts.push({ type: "text", text: prefix });
for (const b of content) {
if (isToolResultTextBlock(b)) {
- parts.push({ type: "text", text: b.text })
+ parts.push({ type: "text", text: b.text });
} else if (isToolResultImageBlock(b)) {
- parts.push({ type: "image_url", image_url: { url: imageToUrl(b) } })
+ parts.push({ type: "image_url", image_url: { url: imageToUrl(b) } });
} else {
- parts.push({ type: "text", text: unsupportedToolResultBlockToString(b) })
+ parts.push({ type: "text", text: unsupportedToolResultBlockToString(b) });
}
}
- if (parts.length === 1 && parts[0]!.type === "text") return parts[0]!.text
- return parts
+ if (parts.length === 1 && parts[0]!.type === "text") return parts[0]!.text;
+ return parts;
}
-export function toolResultToString(
- content: string | AnthropicToolResultContentBlock[],
-): string {
+export function toolResultToString(content: string | AnthropicToolResultContentBlock[]): string {
// Kept for the token counter, which wants a flat string.
- if (typeof content === "string") return content
+ if (typeof content === "string") return content;
return content
.map((b) => {
- if (isToolResultTextBlock(b)) return b.text
+ if (isToolResultTextBlock(b)) return b.text;
if (isToolResultImageBlock(b)) {
- const mt = b.source.type === "base64" ? b.source.media_type : "url"
- return `[image omitted: ${mt}]`
+ const mt = b.source.type === "base64" ? b.source.media_type : "url";
+ return `[image omitted: ${mt}]`;
}
- return unsupportedToolResultBlockToString(b)
+ return unsupportedToolResultBlockToString(b);
})
- .join("\n")
+ .join("\n");
}
function toKimiTool(tool: AnthropicTool): KimiTool {
@@ -327,5 +323,5 @@ function toKimiTool(tool: AnthropicTool): KimiTool {
description: tool.description,
parameters: tool.input_schema,
},
- }
+ };
}
diff --git a/src/providers/kimi/translate/signature.ts b/src/providers/kimi/translate/signature.ts
index 9475a9b..0547023 100644
--- a/src/providers/kimi/translate/signature.ts
+++ b/src/providers/kimi/translate/signature.ts
@@ -3,5 +3,5 @@
// stable per (messageId, blockIndex) and identical between the streaming
// and non-streaming paths.
export function makeThinkingSignature(messageId: string, index: number): string {
- return Buffer.from(`ccp:kimi:v1:${messageId}:${index}`).toString("base64url")
+ return Buffer.from(`ccp:kimi:v1:${messageId}:${index}`).toString("base64url");
}
diff --git a/src/providers/kimi/translate/stream.ts b/src/providers/kimi/translate/stream.ts
index b615329..16b1b2b 100644
--- a/src/providers/kimi/translate/stream.ts
+++ b/src/providers/kimi/translate/stream.ts
@@ -1,10 +1,15 @@
-import { encodeSseEvent } from "../../../sse.ts"
-import type { Logger } from "../../../log.ts"
-import { mapUsageToAnthropic, reduceUpstream, UpstreamStreamError, type KimiUsage } from "./reducer.ts"
-import { makeThinkingSignature } from "./signature.ts"
+import { encodeSseEvent } from "../../../sse.ts";
+import type { Logger } from "../../../log.ts";
+import {
+ mapUsageToAnthropic,
+ reduceUpstream,
+ UpstreamStreamError,
+ type KimiUsage,
+} from "./reducer.ts";
+import { makeThinkingSignature } from "./signature.ts";
function isAbortError(err: unknown): boolean {
- return err instanceof Error && err.name === "AbortError"
+ return err instanceof Error && err.name === "AbortError";
}
/**
@@ -16,27 +21,27 @@ function isAbortError(err: unknown): boolean {
export function translateStream(
upstream: ReadableStream<Uint8Array>,
opts: {
- messageId: string
- model: string
- log: Logger
- requestStartTime?: number
+ messageId: string;
+ model: string;
+ log: Logger;
+ requestStartTime?: number;
onFinish?: (finish: {
- stopReason: "end_turn" | "tool_use" | "max_tokens"
- usage?: Parameters<typeof mapUsageToAnthropic>[0]
- }) => void
+ stopReason: "end_turn" | "tool_use" | "max_tokens";
+ usage?: Parameters<typeof mapUsageToAnthropic>[0];
+ }) => void;
},
): ReadableStream<Uint8Array> {
- const encoder = new TextEncoder()
+ const encoder = new TextEncoder();
return new ReadableStream<Uint8Array>({
async start(controller) {
const emit = (event: string, data: unknown) => {
- controller.enqueue(encoder.encode(encodeSseEvent(event, data)))
- }
- const activeTools = new Map<number, { id: string; name: string }>()
- let messageStarted = false
+ controller.enqueue(encoder.encode(encodeSseEvent(event, data)));
+ };
+ const activeTools = new Map<number, { id: string; name: string }>();
+ let messageStarted = false;
const ensureMessageStart = () => {
- if (messageStarted) return
- messageStarted = true
+ if (messageStarted) return;
+ messageStarted = true;
emit("message_start", {
type: "message_start",
message: {
@@ -54,40 +59,40 @@ export function translateStream(
cache_read_input_tokens: 0,
},
},
- })
- emit("ping", { type: "ping" })
- }
+ });
+ emit("ping", { type: "ping" });
+ };
- const streamStart = Date.now()
- let firstChunkAt: number | undefined
- let reasoningChars = 0
- let contentChars = 0
- let toolCount = 0
- let finishUsage: KimiUsage | undefined
- let finishStopReason: string | undefined
- const stats = { chunkCount: 0 }
+ const streamStart = Date.now();
+ let firstChunkAt: number | undefined;
+ let reasoningChars = 0;
+ let contentChars = 0;
+ let toolCount = 0;
+ let finishUsage: KimiUsage | undefined;
+ let finishStopReason: string | undefined;
+ const stats = { chunkCount: 0 };
try {
for await (const e of reduceUpstream(upstream, stats, opts.log)) {
- if (firstChunkAt === undefined) firstChunkAt = Date.now()
+ if (firstChunkAt === undefined) firstChunkAt = Date.now();
switch (e.kind) {
case "thinking-start":
- ensureMessageStart()
+ ensureMessageStart();
emit("content_block_start", {
type: "content_block_start",
index: e.index,
content_block: { type: "thinking", thinking: "" },
- })
- break
+ });
+ break;
case "thinking-delta":
- reasoningChars += e.text.length
+ reasoningChars += e.text.length;
emit("content_block_delta", {
type: "content_block_delta",
index: e.index,
delta: { type: "thinking_delta", thinking: e.text },
- })
- break
+ });
+ break;
case "thinking-stop":
// Emit the signature as a separate signature_delta right
// before content_block_stop — matches Anthropic's native
@@ -100,32 +105,32 @@ export function translateStream(
type: "signature_delta",
signature: makeThinkingSignature(opts.messageId, e.index),
},
- })
- emit("content_block_stop", { type: "content_block_stop", index: e.index })
- break
+ });
+ emit("content_block_stop", { type: "content_block_stop", index: e.index });
+ break;
case "text-start":
- ensureMessageStart()
+ ensureMessageStart();
emit("content_block_start", {
type: "content_block_start",
index: e.index,
content_block: { type: "text", text: "" },
- })
- break
+ });
+ break;
case "text-delta":
- contentChars += e.text.length
+ contentChars += e.text.length;
emit("content_block_delta", {
type: "content_block_delta",
index: e.index,
delta: { type: "text_delta", text: e.text },
- })
- break
+ });
+ break;
case "text-stop":
- emit("content_block_stop", { type: "content_block_stop", index: e.index })
- break
+ emit("content_block_stop", { type: "content_block_stop", index: e.index });
+ break;
case "tool-start":
- toolCount++
- activeTools.set(e.index, { id: e.id, name: e.name })
- ensureMessageStart()
+ toolCount++;
+ activeTools.set(e.index, { id: e.id, name: e.name });
+ ensureMessageStart();
emit("content_block_start", {
type: "content_block_start",
index: e.index,
@@ -135,70 +140,69 @@ export function translateStream(
name: e.name,
input: {},
},
- })
- break
+ });
+ break;
case "tool-delta":
emit("content_block_delta", {
type: "content_block_delta",
index: e.index,
delta: { type: "input_json_delta", partial_json: e.partialJson },
- })
- break
+ });
+ break;
case "tool-stop":
- activeTools.delete(e.index)
- emit("content_block_stop", { type: "content_block_stop", index: e.index })
- break
+ activeTools.delete(e.index);
+ emit("content_block_stop", { type: "content_block_stop", index: e.index });
+ break;
case "finish":
- ensureMessageStart()
- finishUsage = e.usage
- finishStopReason = e.stopReason
- opts.onFinish?.({ stopReason: e.stopReason, usage: e.usage })
+ ensureMessageStart();
+ finishUsage = e.usage;
+ finishStopReason = e.stopReason;
+ opts.onFinish?.({ stopReason: e.stopReason, usage: e.usage });
emit("message_delta", {
type: "message_delta",
delta: { stop_reason: e.stopReason, stop_sequence: null },
usage: mapUsageToAnthropic(e.usage),
- })
- emit("message_stop", { type: "message_stop" })
- break
+ });
+ emit("message_stop", { type: "message_stop" });
+ break;
}
}
} catch (err) {
- const activeToolNames = Array.from(activeTools.values(), (t) => t.name)
- const activeToolCalls = Array.from(activeTools.values())
+ const activeToolNames = Array.from(activeTools.values(), (t) => t.name);
+ const activeToolCalls = Array.from(activeTools.values());
if (isAbortError(err)) {
- opts.log.info("client disconnected")
+ opts.log.info("client disconnected");
} else if (err instanceof UpstreamStreamError) {
opts.log.warn("upstream stream error", {
kind: err.kind,
message: err.message,
activeToolNames,
activeToolCalls,
- })
- ensureMessageStart()
+ });
+ ensureMessageStart();
emit("error", {
type: "error",
error: {
type: err.kind === "rate_limit" ? "rate_limit_error" : "api_error",
message: err.message,
},
- })
+ });
} else {
opts.log.error("stream translation error", {
err: String(err),
activeToolNames,
activeToolCalls,
- })
- ensureMessageStart()
+ });
+ ensureMessageStart();
emit("error", {
type: "error",
error: { type: "api_error", message: String(err) },
- })
+ });
}
} finally {
- const now = Date.now()
- const timeToFirstChunkMs = opts.requestStartTime && firstChunkAt
- ? firstChunkAt - opts.requestStartTime
- : undefined
+ const now = Date.now();
+ const timeToFirstChunkMs =
+ opts.requestStartTime && firstChunkAt ? firstChunkAt - opts.requestStartTime : undefined;
opts.log.debug("stream summary", {
chunkCount: stats.chunkCount,
timeToFirstChunkMs,
@@ -209,13 +213,13 @@ export function translateStream(
toolCount,
stopReason: finishStopReason,
usage: finishUsage,
- })
+ });
try {
- controller.close()
+ controller.close();
} catch {
// ignore if controller already errored or cancelled
}
}
},
- })
+ });
}
diff --git a/src/providers/registry.test.ts b/src/providers/registry.test.ts
index 76021cc..651aeba 100644
--- a/src/providers/registry.test.ts
+++ b/src/providers/registry.test.ts
@@ -1,97 +1,93 @@
-import { afterEach, describe, expect, it } from "bun:test"
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-import {
- allSupportedModels,
- ANTHROPIC_STYLE_ALIASES,
- providerForModel,
-} from "./registry.ts"
-import { loadConfig } from "../config.ts"
-import { normalizeIncomingModel } from "../server.ts"
+import { afterEach, describe, expect, it } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { allSupportedModels, ANTHROPIC_STYLE_ALIASES, providerForModel } from "./registry.ts";
+import { loadConfig } from "../config.ts";
+import { normalizeIncomingModel } from "../server.ts";
afterEach(() => {
- loadConfig({ forceReload: true })
-})
+ loadConfig({ forceReload: true });
+});
function providersFor(model: string): string[] {
return allSupportedModels()
.filter((entry) => entry.model === model)
- .map((entry) => entry.provider)
+ .map((entry) => entry.provider);
}
describe("provider routing", () => {
it("routes fast Codex model aliases after context suffix normalization", () => {
- const model = normalizeIncomingModel("gpt-5.4-fast[1m]")
+ const model = normalizeIncomingModel("gpt-5.4-fast[1m]");
- expect(model).toBe("gpt-5.4-fast")
- expect(providerForModel(model)?.name).toBe("codex")
- })
+ expect(model).toBe("gpt-5.4-fast");
+ expect(providerForModel(model)?.name).toBe("codex");
+ });
it("routes Anthropic-style aliases to Codex by default", () => {
- loadConfig({ env: {}, forceReload: true })
+ loadConfig({ env: {}, forceReload: true });
for (const alias of ANTHROPIC_STYLE_ALIASES) {
- expect(providerForModel(alias)?.name).toBe("codex")
+ expect(providerForModel(alias)?.name).toBe("codex");
}
- })
+ });
it("routes every Anthropic-style alias to Kimi when env selects Kimi", () => {
- loadConfig({ env: { CCP_ALIAS_PROVIDER: "kimi" }, forceReload: true })
+ loadConfig({ env: { CCP_ALIAS_PROVIDER: "kimi" }, forceReload: true });
for (const alias of ANTHROPIC_STYLE_ALIASES) {
- expect(providerForModel(alias)?.name).toBe("kimi")
+ expect(providerForModel(alias)?.name).toBe("kimi");
}
- })
+ });
it("lets session affinity override the global alias provider", () => {
- loadConfig({ env: {}, forceReload: true })
+ loadConfig({ env: {}, forceReload: true });
- expect(providerForModel("sonnet", "kimi")?.name).toBe("kimi")
- })
+ expect(providerForModel("sonnet", "kimi")?.name).toBe("kimi");
+ });
it("routes aliases to Codex when config file selects Codex", () => {
- const dir = mkdtempSync(join(tmpdir(), "ccp-alias-provider-"))
- const path = join(dir, "config.json")
- writeFileSync(path, JSON.stringify({ aliasProvider: "codex" }))
+ const dir = mkdtempSync(join(tmpdir(), "ccp-alias-provider-"));
+ const path = join(dir, "config.json");
+ writeFileSync(path, JSON.stringify({ aliasProvider: "codex" }));
try {
- loadConfig({ configPath: path, env: {}, forceReload: true })
- expect(providerForModel("claude-opus-4-7")?.name).toBe("codex")
+ loadConfig({ configPath: path, env: {}, forceReload: true });
+ expect(providerForModel("claude-opus-4-7")?.name).toBe("codex");
} finally {
- rmSync(dir, { recursive: true, force: true })
+ rmSync(dir, { recursive: true, force: true });
}
- })
+ });
it("lets env override config file alias provider", () => {
- const dir = mkdtempSync(join(tmpdir(), "ccp-alias-provider-"))
- const path = join(dir, "config.json")
- writeFileSync(path, JSON.stringify({ aliasProvider: "codex" }))
+ const dir = mkdtempSync(join(tmpdir(), "ccp-alias-provider-"));
+ const path = join(dir, "config.json");
+ writeFileSync(path, JSON.stringify({ aliasProvider: "codex" }));
try {
- loadConfig({ configPath: path, env: { CCP_ALIAS_PROVIDER: "kimi" }, forceReload: true })
- expect(providerForModel("haiku")?.name).toBe("kimi")
+ loadConfig({ configPath: path, env: { CCP_ALIAS_PROVIDER: "kimi" }, forceReload: true });
+ expect(providerForModel("haiku")?.name).toBe("kimi");
} finally {
- rmSync(dir, { recursive: true, force: true })
+ rmSync(dir, { recursive: true, force: true });
}
- })
+ });
it("lists aliases only under the active alias provider", () => {
- loadConfig({ env: { CCP_ALIAS_PROVIDER: "codex" }, forceReload: true })
+ loadConfig({ env: { CCP_ALIAS_PROVIDER: "codex" }, forceReload: true });
- expect(providersFor("sonnet")).toEqual(["codex"])
- })
+ expect(providersFor("sonnet")).toEqual(["codex"]);
+ });
it("does not duplicate supported model entries", () => {
for (const env of [{}, { CCP_ALIAS_PROVIDER: "codex" }]) {
- loadConfig({ env, forceReload: true })
- const models = allSupportedModels().map(({ model }) => model)
- expect(new Set(models).size).toBe(models.length)
+ loadConfig({ env, forceReload: true });
+ const models = allSupportedModels().map(({ model }) => model);
+ expect(new Set(models).size).toBe(models.length);
}
- })
+ });
it("keeps concrete model routing unchanged", () => {
- loadConfig({ env: { CCP_ALIAS_PROVIDER: "codex" }, forceReload: true })
+ loadConfig({ env: { CCP_ALIAS_PROVIDER: "codex" }, forceReload: true });
- expect(providerForModel("kimi-for-coding")?.name).toBe("kimi")
- expect(providerForModel("gpt-5.4-fast")?.name).toBe("codex")
- })
-})
+ expect(providerForModel("kimi-for-coding")?.name).toBe("kimi");
+ expect(providerForModel("gpt-5.4-fast")?.name).toBe("codex");
+ });
+});
diff --git a/src/providers/registry.ts b/src/providers/registry.ts
index 72df7fd..f3e4aef 100644
--- a/src/providers/registry.ts
+++ b/src/providers/registry.ts
@@ -1,7 +1,7 @@
-import { aliasProvider, type AliasProvider } from "../config.ts"
-import type { Provider } from "./types.ts"
-import { codexProvider } from "./codex/index.ts"
-import { kimiProvider } from "./kimi/index.ts"
+import { aliasProvider, type AliasProvider } from "../config.ts";
+import type { Provider } from "./types.ts";
+import { codexProvider } from "./codex/index.ts";
+import { kimiProvider } from "./kimi/index.ts";
export const ANTHROPIC_STYLE_ALIASES = new Set([
"haiku",
@@ -11,50 +11,49 @@ export const ANTHROPIC_STYLE_ALIASES = new Set([
"claude-sonnet-4-6",
"opus",
"claude-opus-4-7",
-])
+]);
const PROVIDERS: Record<string, Provider> = {
codex: codexProvider,
kimi: kimiProvider,
-}
+};
export function getProvider(name: string): Provider {
- const p = PROVIDERS[name]
+ const p = PROVIDERS[name];
if (!p) {
- throw new Error(
- `Unknown provider: ${name}. Available: ${Object.keys(PROVIDERS).join(", ")}`,
- )
+ throw new Error(`Unknown provider: ${name}. Available: ${Object.keys(PROVIDERS).join(", ")}`);
}
- return p
+ return p;
}
export function listProviders(): string[] {
- return Object.keys(PROVIDERS)
+ return Object.keys(PROVIDERS);
}
export function allProviders(): Provider[] {
- return Object.values(PROVIDERS)
+ return Object.values(PROVIDERS);
}
export function providerForModel(
model: string,
aliasProviderOverride?: AliasProvider,
): Provider | undefined {
- if (ANTHROPIC_STYLE_ALIASES.has(model)) return getProvider(aliasProviderOverride ?? aliasProvider())
+ if (ANTHROPIC_STYLE_ALIASES.has(model))
+ return getProvider(aliasProviderOverride ?? aliasProvider());
for (const p of allProviders()) {
- if (p.supportedModels.has(model)) return p
+ if (p.supportedModels.has(model)) return p;
}
- return undefined
+ return undefined;
}
export function allSupportedModels(): Array<{ model: string; provider: string }> {
- const out: Array<{ model: string; provider: string }> = []
- const activeAliasProvider = aliasProvider()
+ const out: Array<{ model: string; provider: string }> = [];
+ const activeAliasProvider = aliasProvider();
for (const p of allProviders()) {
- for (const m of p.supportedModels) out.push({ model: m, provider: p.name })
+ for (const m of p.supportedModels) out.push({ model: m, provider: p.name });
if (p.name === activeAliasProvider) {
- for (const m of ANTHROPIC_STYLE_ALIASES) out.push({ model: m, provider: p.name })
+ for (const m of ANTHROPIC_STYLE_ALIASES) out.push({ model: m, provider: p.name });
}
}
- return out
+ return out;
}
diff --git a/src/providers/retry.test.ts b/src/providers/retry.test.ts
index b7178da..b7db978 100644
--- a/src/providers/retry.test.ts
+++ b/src/providers/retry.test.ts
@@ -1,4 +1,4 @@
-import { describe, expect, it } from "bun:test"
+import { describe, expect, it } from "bun:test";
import {
computeBackoffDelay,
MAX_RATE_LIMIT_RETRIES,
@@ -6,7 +6,7 @@ import {
RETRY_MAX_DELAY_MS,
retryOn429,
sleep,
-} from "./retry.ts"
+} from "./retry.ts";
const silentLog = {
debug: () => {},
@@ -14,95 +14,95 @@ const silentLog = {
warn: () => {},
error: () => {},
child: () => silentLog,
-}
+};
describe("computeBackoffDelay", () => {
it("uses jittered exponential backoff without retry-after", () => {
// equal jitter: result is in [cap/2, cap]
for (const attempt of [0, 1, 2]) {
- const cap = RETRY_INITIAL_DELAY_MS * 2 ** attempt
- const { waitMs } = computeBackoffDelay(attempt)
- expect(waitMs).toBeGreaterThanOrEqual(cap / 2)
- expect(waitMs).toBeLessThanOrEqual(cap)
+ const cap = RETRY_INITIAL_DELAY_MS * 2 ** attempt;
+ const { waitMs } = computeBackoffDelay(attempt);
+ expect(waitMs).toBeGreaterThanOrEqual(cap / 2);
+ expect(waitMs).toBeLessThanOrEqual(cap);
}
- })
+ });
it("caps exponential backoff at max delay", () => {
- const { waitMs } = computeBackoffDelay(20)
- expect(waitMs).toBeGreaterThanOrEqual(RETRY_MAX_DELAY_MS / 2)
- expect(waitMs).toBeLessThanOrEqual(RETRY_MAX_DELAY_MS)
- })
+ const { waitMs } = computeBackoffDelay(20);
+ expect(waitMs).toBeGreaterThanOrEqual(RETRY_MAX_DELAY_MS / 2);
+ expect(waitMs).toBeLessThanOrEqual(RETRY_MAX_DELAY_MS);
+ });
it("respects numeric retry-after as seconds", () => {
- expect(computeBackoffDelay(0, "5").waitMs).toBe(5000)
- })
+ expect(computeBackoffDelay(0, "5").waitMs).toBe(5000);
+ });
it("flags retry-after that exceeds budget", () => {
- const out = computeBackoffDelay(0, "120")
- expect(out.waitMs).toBe(RETRY_MAX_DELAY_MS)
- expect(out.exceedsBudget).toBe(true)
- })
+ const out = computeBackoffDelay(0, "120");
+ expect(out.waitMs).toBe(RETRY_MAX_DELAY_MS);
+ expect(out.exceedsBudget).toBe(true);
+ });
it("rejects non-numeric retry-after garbage", () => {
- const { waitMs } = computeBackoffDelay(0, "1abc")
- expect(waitMs).toBeGreaterThanOrEqual(RETRY_INITIAL_DELAY_MS / 2)
- expect(waitMs).toBeLessThanOrEqual(RETRY_INITIAL_DELAY_MS)
- })
+ const { waitMs } = computeBackoffDelay(0, "1abc");
+ expect(waitMs).toBeGreaterThanOrEqual(RETRY_INITIAL_DELAY_MS / 2);
+ expect(waitMs).toBeLessThanOrEqual(RETRY_INITIAL_DELAY_MS);
+ });
it("parses HTTP-date retry-after", () => {
- const date = new Date(Date.now() + 5000).toUTCString()
- const out = computeBackoffDelay(0, date)
- expect(out.waitMs).toBeGreaterThan(3500)
- expect(out.waitMs).toBeLessThanOrEqual(5000)
- })
-})
+ const date = new Date(Date.now() + 5000).toUTCString();
+ const out = computeBackoffDelay(0, date);
+ expect(out.waitMs).toBeGreaterThan(3500);
+ expect(out.waitMs).toBeLessThanOrEqual(5000);
+ });
+});
describe("sleep", () => {
it("rejects if signal already aborted", async () => {
- const c = new AbortController()
- c.abort()
- await expect(sleep(1000, c.signal)).rejects.toThrow()
- })
+ const c = new AbortController();
+ c.abort();
+ await expect(sleep(1000, c.signal)).rejects.toThrow();
+ });
it("rejects when aborted mid-sleep", async () => {
- const c = new AbortController()
- const p = sleep(1000, c.signal)
- setTimeout(() => c.abort(), 10)
- await expect(p).rejects.toThrow()
- })
-})
+ const c = new AbortController();
+ const p = sleep(1000, c.signal);
+ setTimeout(() => c.abort(), 10);
+ await expect(p).rejects.toThrow();
+ });
+});
describe("retryOn429", () => {
class FakeRateLimit extends Error {
constructor(public retryAfter?: string) {
- super("rate limited")
+ super("rate limited");
}
}
it("returns successful result without retry", async () => {
- let calls = 0
+ let calls = 0;
const result = await retryOn429(
async () => {
- calls++
- return "ok"
+ calls++;
+ return "ok";
},
{
log: silentLog,
classify: () => undefined,
},
- )
- expect(result).toBe("ok")
- expect(calls).toBe(1)
- })
+ );
+ expect(result).toBe("ok");
+ expect(calls).toBe(1);
+ });
it("retries up to MAX_RATE_LIMIT_RETRIES then throws", async () => {
- let calls = 0
- const start = Date.now()
+ let calls = 0;
+ const start = Date.now();
await expect(
retryOn429(
async () => {
- calls++
- throw new FakeRateLimit("0")
+ calls++;
+ throw new FakeRateLimit("0");
},
{
log: silentLog,
@@ -110,18 +110,18 @@ describe("retryOn429", () => {
err instanceof FakeRateLimit ? { retryAfter: err.retryAfter } : undefined,
},
),
- ).rejects.toBeInstanceOf(FakeRateLimit)
- expect(calls).toBe(MAX_RATE_LIMIT_RETRIES + 1)
- expect(Date.now() - start).toBeLessThan(2000)
- })
+ ).rejects.toBeInstanceOf(FakeRateLimit);
+ expect(calls).toBe(MAX_RATE_LIMIT_RETRIES + 1);
+ expect(Date.now() - start).toBeLessThan(2000);
+ });
it("gives up immediately when retry-after exceeds budget", async () => {
- let calls = 0
+ let calls = 0;
await expect(
retryOn429(
async () => {
- calls++
- throw new FakeRateLimit("120")
+ calls++;
+ throw new FakeRateLimit("120");
},
{
log: silentLog,
@@ -129,42 +129,42 @@ describe("retryOn429", () => {
err instanceof FakeRateLimit ? { retryAfter: err.retryAfter } : undefined,
},
),
- ).rejects.toBeInstanceOf(FakeRateLimit)
- expect(calls).toBe(1)
- })
+ ).rejects.toBeInstanceOf(FakeRateLimit);
+ expect(calls).toBe(1);
+ });
it("does not retry non-rate-limit errors", async () => {
- let calls = 0
+ let calls = 0;
await expect(
retryOn429(
async () => {
- calls++
- throw new Error("other")
+ calls++;
+ throw new Error("other");
},
{
log: silentLog,
classify: () => undefined,
},
),
- ).rejects.toThrow("other")
- expect(calls).toBe(1)
- })
+ ).rejects.toThrow("other");
+ expect(calls).toBe(1);
+ });
it("succeeds after a transient 429", async () => {
- let calls = 0
+ let calls = 0;
const result = await retryOn429(
async () => {
- calls++
- if (calls === 1) throw new FakeRateLimit("0")
- return "recovered"
+ calls++;
+ if (calls === 1) throw new FakeRateLimit("0");
+ return "recovered";
},
{
log: silentLog,
classify: (err) =>
err instanceof FakeRateLimit ? { retryAfter: err.retryAfter } : undefined,
},
- )
- expect(result).toBe("recovered")
- expect(calls).toBe(2)
- })
-})
+ );
+ expect(result).toBe("recovered");
+ expect(calls).toBe(2);
+ });
+});
diff --git a/src/providers/retry.ts b/src/providers/retry.ts
index 99a9abe..d257270 100644
--- a/src/providers/retry.ts
+++ b/src/providers/retry.ts
@@ -1,89 +1,89 @@
-import type { Logger } from "../log.ts"
+import type { Logger } from "../log.ts";
-export const RETRY_INITIAL_DELAY_MS = 2000
-export const RETRY_BACKOFF_FACTOR = 2
-export const RETRY_MAX_DELAY_MS = 30_000
-export const MAX_RATE_LIMIT_RETRIES = 3
+export const RETRY_INITIAL_DELAY_MS = 2000;
+export const RETRY_BACKOFF_FACTOR = 2;
+export const RETRY_MAX_DELAY_MS = 30_000;
+export const MAX_RATE_LIMIT_RETRIES = 3;
-const STRICT_NUMERIC = /^\s*\d+(?:\.\d+)?\s*$/
+const STRICT_NUMERIC = /^\s*\d+(?:\.\d+)?\s*$/;
export interface BackoffOutcome {
- waitMs: number
- exceedsBudget: boolean
+ waitMs: number;
+ exceedsBudget: boolean;
}
export function computeBackoffDelay(attempt: number, retryAfter?: string): BackoffOutcome {
if (retryAfter) {
if (STRICT_NUMERIC.test(retryAfter)) {
- const ms = Math.ceil(Number.parseFloat(retryAfter) * 1000)
- return { waitMs: Math.min(ms, RETRY_MAX_DELAY_MS), exceedsBudget: ms > RETRY_MAX_DELAY_MS }
+ const ms = Math.ceil(Number.parseFloat(retryAfter) * 1000);
+ return { waitMs: Math.min(ms, RETRY_MAX_DELAY_MS), exceedsBudget: ms > RETRY_MAX_DELAY_MS };
}
- const dateMs = Date.parse(retryAfter) - Date.now()
+ const dateMs = Date.parse(retryAfter) - Date.now();
if (!Number.isNaN(dateMs) && dateMs > 0) {
return {
waitMs: Math.min(Math.ceil(dateMs), RETRY_MAX_DELAY_MS),
exceedsBudget: dateMs > RETRY_MAX_DELAY_MS,
- }
+ };
}
}
- const exp = RETRY_INITIAL_DELAY_MS * Math.pow(RETRY_BACKOFF_FACTOR, attempt)
- const capped = Math.min(exp, RETRY_MAX_DELAY_MS)
+ const exp = RETRY_INITIAL_DELAY_MS * Math.pow(RETRY_BACKOFF_FACTOR, attempt);
+ const capped = Math.min(exp, RETRY_MAX_DELAY_MS);
// Equal jitter on the exponential fallback to avoid synchronized retries
// across concurrent requests. Never jitter an explicit Retry-After.
- const jittered = capped / 2 + Math.random() * (capped / 2)
- return { waitMs: Math.round(jittered), exceedsBudget: false }
+ const jittered = capped / 2 + Math.random() * (capped / 2);
+ return { waitMs: Math.round(jittered), exceedsBudget: false };
}
export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
return new Promise((resolve, reject) => {
if (signal?.aborted) {
- reject(new DOMException("Aborted", "AbortError"))
- return
+ reject(new DOMException("Aborted", "AbortError"));
+ return;
}
const onAbort = () => {
- clearTimeout(timer)
- reject(new DOMException("Aborted", "AbortError"))
- }
+ clearTimeout(timer);
+ reject(new DOMException("Aborted", "AbortError"));
+ };
const timer = setTimeout(() => {
- signal?.removeEventListener("abort", onAbort)
- resolve()
- }, ms)
- signal?.addEventListener("abort", onAbort, { once: true })
- })
+ signal?.removeEventListener("abort", onAbort);
+ resolve();
+ }, ms);
+ signal?.addEventListener("abort", onAbort, { once: true });
+ });
}
export interface RateLimitInfo {
- retryAfter?: string
+ retryAfter?: string;
}
export interface RetryOptions {
- log: Logger
- signal?: AbortSignal
- classify: (err: unknown) => RateLimitInfo | undefined
+ log: Logger;
+ signal?: AbortSignal;
+ classify: (err: unknown) => RateLimitInfo | undefined;
}
export async function retryOn429<T>(run: () => Promise<T>, opts: RetryOptions): Promise<T> {
for (let attempt = 0; ; attempt++) {
try {
- return await run()
+ return await run();
} catch (err) {
- const info = opts.classify(err)
- if (!info || attempt >= MAX_RATE_LIMIT_RETRIES) throw err
- const { waitMs, exceedsBudget } = computeBackoffDelay(attempt, info.retryAfter)
+ const info = opts.classify(err);
+ if (!info || attempt >= MAX_RATE_LIMIT_RETRIES) throw err;
+ const { waitMs, exceedsBudget } = computeBackoffDelay(attempt, info.retryAfter);
if (exceedsBudget) {
opts.log.warn("upstream 429 retry-after exceeds budget; giving up", {
retryAfter: info.retryAfter,
maxDelayMs: RETRY_MAX_DELAY_MS,
- })
- throw err
+ });
+ throw err;
}
opts.log.warn("upstream 429, retrying after backoff", {
attempt: attempt + 1,
maxRetries: MAX_RATE_LIMIT_RETRIES,
waitMs,
retryAfter: info.retryAfter,
- })
- await sleep(waitMs, opts.signal)
+ });
+ await sleep(waitMs, opts.signal);
}
}
}
diff --git a/src/providers/types.ts b/src/providers/types.ts
index 1031f83..d2e86a6 100644
--- a/src/providers/types.ts
+++ b/src/providers/types.ts
@@ -1,28 +1,28 @@
-import type { AnthropicRequest } from "../anthropic/schema.ts"
+import type { AnthropicRequest } from "../anthropic/schema.ts";
-import type { Logger } from "../log.ts"
+import type { Logger } from "../log.ts";
export interface RequestContext {
- reqId: string
- sessionId?: string
- sessionSeq?: number
- signal: AbortSignal
- childLogger(service: string): Logger
+ reqId: string;
+ sessionId?: string;
+ sessionSeq?: number;
+ signal: AbortSignal;
+ childLogger(service: string): Logger;
}
export interface CliHandlers {
- login?: () => Promise<void>
- device?: () => Promise<void>
- status: () => Promise<void>
- logout: () => Promise<void>
+ login?: () => Promise<void>;
+ device?: () => Promise<void>;
+ status: () => Promise<void>;
+ logout: () => Promise<void>;
}
export interface Provider {
- name: string
+ name: string;
// Unambiguous model identifiers this provider claims. Cross-provider
// Anthropic-style aliases are resolved by registry-level alias routing.
- supportedModels: Set<string>
- handleMessages(body: AnthropicRequest, ctx: RequestContext): Promise<Response>
- handleCountTokens(body: AnthropicRequest, ctx: RequestContext): Promise<Response>
- cli: CliHandlers
+ supportedModels: Set<string>;
+ handleMessages(body: AnthropicRequest, ctx: RequestContext): Promise<Response>;
+ handleCountTokens(body: AnthropicRequest, ctx: RequestContext): Promise<Response>;
+ cli: CliHandlers;
}
diff --git a/src/server.test.ts b/src/server.test.ts
index e33b94b..8f99621 100644
--- a/src/server.test.ts
+++ b/src/server.test.ts
@@ -1,13 +1,13 @@
-import { afterEach, describe, expect, it } from "bun:test"
-import { loadConfig } from "./config.ts"
-import { startServer } from "./server.ts"
+import { afterEach, describe, expect, it } from "bun:test";
+import { loadConfig } from "./config.ts";
+import { startServer } from "./server.ts";
-const servers: Array<{ stop: () => void }> = []
+const servers: Array<{ stop: () => void }> = [];
afterEach(() => {
- for (const server of servers.splice(0)) server.stop()
- loadConfig({ forceReload: true })
-})
+ for (const server of servers.splice(0)) server.stop();
+ loadConfig({ forceReload: true });
+});
function countTokens(port: number, model: string, sessionId?: string): Promise<Response> {
return fetch(`http://127.0.0.1:${port}/v1/messages/count_tokens`, {
@@ -17,22 +17,22 @@ function countTokens(port: number, model: string, sessionId?: string): Promise<R
...(sessionId ? { "x-claude-code-session-id": sessionId } : {}),
},
body: JSON.stringify({ model, messages: [{ role: "user", content: "hello" }] }),
- })
+ });
}
describe("server session-aware alias routing", () => {
it("routes aliases to the concrete provider used earlier in the session", async () => {
- loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "standard" }, forceReload: true })
- const server = startServer({ port: 0 })
- servers.push(server)
+ loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "standard" }, forceReload: true });
+ const server = startServer({ port: 0 });
+ servers.push(server);
- const sessionId = crypto.randomUUID()
- const fallback = await countTokens(server.port, "sonnet")
- expect(fallback.status).toBe(400)
- const fallbackBody = (await fallback.json()) as { error: { message: string } }
- expect(fallbackBody.error.message).toContain("Invalid service tier override")
+ const sessionId = crypto.randomUUID();
+ const fallback = await countTokens(server.port, "sonnet");
+ expect(fallback.status).toBe(400);
+ const fallbackBody = (await fallback.json()) as { error: { message: string } };
+ expect(fallbackBody.error.message).toContain("Invalid service tier override");
- expect((await countTokens(server.port, "kimi-for-coding", sessionId)).status).toBe(200)
- expect((await countTokens(server.port, "sonnet", sessionId)).status).toBe(200)
- })
-})
+ expect((await countTokens(server.port, "kimi-for-coding", sessionId)).status).toBe(200);
+ expect((await countTokens(server.port, "sonnet", sessionId)).status).toBe(200);
+ });
+});
diff --git a/src/server.ts b/src/server.ts
index 6b971a1..6f2fa59 100644
--- a/src/server.ts
+++ b/src/server.ts
@@ -1,37 +1,40 @@
-import { createLogger, logDir, REDACT_KEYS } from "./log.ts"
+import { createLogger, logDir, REDACT_KEYS } from "./log.ts";
-import type { AnthropicRequest } from "./anthropic/schema.ts"
-import type { AliasProvider } from "./config.ts"
-import type { Provider, RequestContext } from "./providers/types.ts"
+import type { AnthropicRequest } from "./anthropic/schema.ts";
+import type { AliasProvider } from "./config.ts";
+import type { Provider, RequestContext } from "./providers/types.ts";
import {
allSupportedModels,
ANTHROPIC_STYLE_ALIASES,
providerForModel,
-} from "./providers/registry.ts"
+} from "./providers/registry.ts";
-const rootLog = createLogger("server")
+const rootLog = createLogger("server");
export interface ServeOptions {
- port: number
+ port: number;
}
interface SessionState {
- seq: number
- affinityProvider?: AliasProvider
- lastSeen: number
+ seq: number;
+ affinityProvider?: AliasProvider;
+ lastSeen: number;
}
-const SESSION_IDLE_TTL_MS = 30 * 60 * 1000
-const MAX_SESSIONS = 10_000
-const sessions = new Map<string, SessionState>()
+const SESSION_IDLE_TTL_MS = 30 * 60 * 1000;
+const MAX_SESSIONS = 10_000;
+const sessions = new Map<string, SessionState>();
-function existingSession(sessionId: string | undefined, now = Date.now()): SessionState | undefined {
- if (!sessionId) return undefined
- const state = sessions.get(sessionId)
- if (!state) return undefined
- if (now - state.lastSeen <= SESSION_IDLE_TTL_MS) return state
- sessions.delete(sessionId)
- return undefined
+function existingSession(
+ sessionId: string | undefined,
+ now = Date.now(),
+): SessionState | undefined {
+ if (!sessionId) return undefined;
+ const state = sessions.get(sessionId);
+ if (!state) return undefined;
+ if (now - state.lastSeen <= SESSION_IDLE_TTL_MS) return state;
+ sessions.delete(sessionId);
+ return undefined;
}
function recordSessionRequest(
@@ -41,29 +44,29 @@ function recordSessionRequest(
model: string,
now = Date.now(),
): SessionState | undefined {
- if (!sessionId) return undefined
- const state = session ?? { seq: 0, lastSeen: now }
- state.seq += 1
- state.lastSeen = now
- const affinityProvider = affinityProviderFor(providerName)
+ if (!sessionId) return undefined;
+ const state = session ?? { seq: 0, lastSeen: now };
+ state.seq += 1;
+ state.lastSeen = now;
+ const affinityProvider = affinityProviderFor(providerName);
if (affinityProvider && !ANTHROPIC_STYLE_ALIASES.has(model)) {
- state.affinityProvider = affinityProvider
+ state.affinityProvider = affinityProvider;
}
- sessions.set(sessionId, state)
- evictOldestSessions()
- return state
+ sessions.set(sessionId, state);
+ evictOldestSessions();
+ return state;
}
function affinityProviderFor(providerName: string): AliasProvider | undefined {
- if (providerName === "codex" || providerName === "kimi") return providerName
- return undefined
+ if (providerName === "codex" || providerName === "kimi") return providerName;
+ return undefined;
}
function evictOldestSessions(): void {
while (sessions.size > MAX_SESSIONS) {
- const oldestSessionId = sessions.keys().next().value
- if (!oldestSessionId) return
- sessions.delete(oldestSessionId)
+ const oldestSessionId = sessions.keys().next().value;
+ if (!oldestSessionId) return;
+ sessions.delete(oldestSessionId);
}
}
@@ -73,72 +76,72 @@ export function startServer(opts: ServeOptions): { stop: () => void; port: numbe
port: opts.port,
idleTimeout: 255,
async fetch(req) {
- const url = new URL(req.url)
- const start = Date.now()
- const reqId = crypto.randomUUID()
+ const url = new URL(req.url);
+ const start = Date.now();
+ const reqId = crypto.randomUUID();
rootLog.info("request", {
reqId,
method: req.method,
path: url.pathname,
...(url.search ? { query: redactedQuery(url) } : {}),
- })
+ });
try {
- const resp = await route(req, url, reqId)
- const ms = Date.now() - start
- rootLog.info("response", { reqId, status: resp.status, ms })
- if (!resp.body) return resp
- return wrapStreamResponse(resp, reqId, start, rootLog)
+ const resp = await route(req, url, reqId);
+ const ms = Date.now() - start;
+ rootLog.info("response", { reqId, status: resp.status, ms });
+ if (!resp.body) return resp;
+ return wrapStreamResponse(resp, reqId, start, rootLog);
} catch (err) {
if (isAbortError(err)) {
- rootLog.info("client disconnected", { reqId, ms: Date.now() - start })
- return new Response(null, { status: 499 })
+ rootLog.info("client disconnected", { reqId, ms: Date.now() - start });
+ return new Response(null, { status: 499 });
}
- rootLog.error("handler error", { reqId, err: String(err), stack: (err as Error)?.stack })
- return jsonError(500, "internal_error", String(err))
+ rootLog.error("handler error", { reqId, err: String(err), stack: (err as Error)?.stack });
+ return jsonError(500, "internal_error", String(err));
}
},
- })
- rootLog.info("server listening", { port: server.port, logDir: logDir() })
+ });
+ rootLog.info("server listening", { port: server.port, logDir: logDir() });
return {
port: Number(server.port),
stop: () => server.stop(),
- }
+ };
}
async function route(req: Request, url: URL, reqId: string): Promise<Response> {
if (url.pathname === "/healthz") {
return new Response(JSON.stringify({ ok: true }), {
headers: { "content-type": "application/json" },
- })
+ });
}
if (req.method === "POST" && url.pathname === "/v1/messages/count_tokens") {
- const body = await parseJsonBody(req)
- if (body instanceof Response) return body
- const sessionId = req.headers.get("x-claude-code-session-id") || undefined
- const session = existingSession(sessionId)
- const provider = routeProvider(body, reqId, session?.affinityProvider)
- if (provider instanceof Response) return provider
- const current = recordSessionRequest(sessionId, session, provider.name, body.model)
- const ctx = buildCtx(req, reqId, provider.name, sessionId, current)
- ctx.childLogger("server").info("dispatch", { model: body.model })
- return provider.handleCountTokens(body, ctx)
+ const body = await parseJsonBody(req);
+ if (body instanceof Response) return body;
+ const sessionId = req.headers.get("x-claude-code-session-id") || undefined;
+ const session = existingSession(sessionId);
+ const provider = routeProvider(body, reqId, session?.affinityProvider);
+ if (provider instanceof Response) return provider;
+ const current = recordSessionRequest(sessionId, session, provider.name, body.model);
+ const ctx = buildCtx(req, reqId, provider.name, sessionId, current);
+ ctx.childLogger("server").info("dispatch", { model: body.model });
+ return provider.handleCountTokens(body, ctx);
}
if (req.method === "POST" && url.pathname === "/v1/messages") {
- const body = await parseJsonBody(req)
- if (body instanceof Response) return body
- const sessionId = req.headers.get("x-claude-code-session-id") || undefined
- const session = existingSession(sessionId)
- const provider = routeProvider(body, reqId, session?.affinityProvider)
- if (provider instanceof Response) return provider
- const current = recordSessionRequest(sessionId, session, provider.name, body.model)
- const ctx = buildCtx(req, reqId, provider.name, sessionId, current)
- ctx.childLogger("server").info("dispatch", { model: body.model })
- return provider.handleMessages(body, ctx)
+ const body = await parseJsonBody(req);
+ if (body instanceof Response) return body;
+ const sessionId = req.headers.get("x-claude-code-session-id") || undefined;
+ const session = existingSession(sessionId);
+ const provider = routeProvider(body, reqId, session?.affinityProvider);
+ if (provider instanceof Response) return provider;
+ const current = recordSessionRequest(sessionId, session, provider.name, body.model);
+ const ctx = buildCtx(req, reqId, provider.name, sessionId, current);
+ ctx.childLogger("server").info("dispatch", { model: body.model });
+ return provider.handleMessages(body, ctx);
}
- return jsonError(404, "not_found", `No route for ${req.method} ${url.pathname}`)
+ return jsonError(404, "not_found", `No route for ${req.method} ${url.pathname}`);
}
function buildCtx(
@@ -148,15 +151,15 @@ function buildCtx(
sessionId: string | undefined,
session: SessionState | undefined,
): RequestContext {
- const sessionSeq = session?.seq
- const bindings = { reqId, sessionId, sessionSeq, provider: providerName }
+ const sessionSeq = session?.seq;
+ const bindings = { reqId, sessionId, sessionSeq, provider: providerName };
return {
reqId,
sessionId,
sessionSeq,
signal: req.signal,
childLogger: (service) => createLogger(service, bindings),
- }
+ };
}
// Claude Code uses a [1m] suffix convention (e.g. "gpt-5.4[1m]") to
@@ -165,7 +168,7 @@ function buildCtx(
// the API, but we strip it here too as defense-in-depth in case a
// future version or a different client includes it.
export function normalizeIncomingModel(model: string): string {
- return model.replace(/\[1m\]$/i, "")
+ return model.replace(/\[1m\]$/i, "");
}
function routeProvider(
@@ -178,45 +181,45 @@ function routeProvider(
400,
"invalid_request_error",
`Missing "model" in request body. ${knownModelsMessage()}`,
- )
+ );
}
- body.model = normalizeIncomingModel(body.model)
- const provider = providerForModel(body.model, sessionAliasProvider)
+ body.model = normalizeIncomingModel(body.model);
+ const provider = providerForModel(body.model, sessionAliasProvider);
if (!provider) {
- rootLog.warn("unknown model", { reqId, model: body.model })
+ rootLog.warn("unknown model", { reqId, model: body.model });
return jsonError(
400,
"invalid_request_error",
`Unknown model "${body.model}". ${knownModelsMessage()}`,
- )
+ );
}
- return provider
+ return provider;
}
function knownModelsMessage(): string {
- const groups = new Map<string, string[]>()
+ const groups = new Map<string, string[]>();
for (const { model, provider } of allSupportedModels()) {
- const list = groups.get(provider) ?? []
- list.push(model)
- groups.set(provider, list)
+ const list = groups.get(provider) ?? [];
+ list.push(model);
+ groups.set(provider, list);
}
- const parts: string[] = []
+ const parts: string[] = [];
for (const [provider, models] of groups) {
- parts.push(`${provider}: ${models.join(", ")}`)
+ parts.push(`${provider}: ${models.join(", ")}`);
}
- return `Supported: ${parts.join("; ")}.`
+ return `Supported: ${parts.join("; ")}.`;
}
async function parseJsonBody(req: Request): Promise<AnthropicRequest | Response> {
try {
- return (await req.json()) as AnthropicRequest
+ return (await req.json()) as AnthropicRequest;
} catch (err) {
- return jsonError(400, "invalid_request_error", `Invalid JSON: ${err}`)
+ return jsonError(400, "invalid_request_error", `Invalid JSON: ${err}`);
}
}
function isAbortError(err: unknown): boolean {
- return err instanceof Error && err.name === "AbortError"
+ return err instanceof Error && err.name === "AbortError";
}
function wrapStreamResponse(
@@ -225,53 +228,53 @@ function wrapStreamResponse(
start: number,
log: ReturnType<typeof createLogger>,
): Response {
- const body = resp.body!
- const reader = body.getReader()
+ const body = resp.body!;
+ const reader = body.getReader();
const stream = new ReadableStream<Uint8Array>({
async pull(controller) {
try {
- const { done, value } = await reader.read()
+ const { done, value } = await reader.read();
if (done) {
- log.info("request_completed", { reqId, status: resp.status, ms: Date.now() - start })
- controller.close()
- return
+ log.info("request_completed", { reqId, status: resp.status, ms: Date.now() - start });
+ controller.close();
+ return;
}
- controller.enqueue(value)
+ controller.enqueue(value);
} catch (err) {
if (isAbortError(err)) {
- log.info("client disconnected", { reqId, ms: Date.now() - start })
+ log.info("client disconnected", { reqId, ms: Date.now() - start });
} else {
- log.error("stream error", { reqId, err: String(err) })
+ log.error("stream error", { reqId, err: String(err) });
}
- controller.error(err)
+ controller.error(err);
}
},
cancel() {
- reader.cancel().catch(() => {})
+ reader.cancel().catch(() => {});
},
- })
- const headers = new Headers(resp.headers)
- headers.delete("content-encoding")
- headers.delete("content-length")
- headers.delete("transfer-encoding")
+ });
+ const headers = new Headers(resp.headers);
+ headers.delete("content-encoding");
+ headers.delete("content-length");
+ headers.delete("transfer-encoding");
return new Response(stream, {
status: resp.status,
statusText: resp.statusText,
headers,
- })
+ });
}
function redactedQuery(url: URL): Record<string, string> {
- const out: Record<string, string> = {}
+ const out: Record<string, string> = {};
for (const [k, v] of url.searchParams) {
- out[k] = REDACT_KEYS.has(k.toLowerCase()) ? `[redacted len=${v.length}]` : v
+ out[k] = REDACT_KEYS.has(k.toLowerCase()) ? `[redacted len=${v.length}]` : v;
}
- return out
+ return out;
}
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" },
- })
+ });
}
diff --git a/src/sse.ts b/src/sse.ts
index 5e92b47..8b2dc29 100644
--- a/src/sse.ts
+++ b/src/sse.ts
@@ -1,52 +1,52 @@
export interface SseEvent {
- event?: string
- data: string
+ event?: string;
+ data: string;
}
export function encodeSseEvent(event: string, data: unknown): string {
- return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`
+ return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
}
-const BOUNDARY = /\r\n\r\n|\n\n|\r\r/
+const BOUNDARY = /\r\n\r\n|\n\n|\r\r/;
export async function* parseSseStream(body: ReadableStream<Uint8Array>): AsyncGenerator<SseEvent> {
- const reader = body.getReader()
- const decoder = new TextDecoder()
- let buf = ""
+ const reader = body.getReader();
+ const decoder = new TextDecoder();
+ let buf = "";
try {
while (true) {
- const { value, done } = await reader.read()
- if (done) break
- buf += decoder.decode(value, { stream: true })
- let match: RegExpExecArray | null
+ const { value, done } = await reader.read();
+ if (done) break;
+ buf += decoder.decode(value, { stream: true });
+ let match: RegExpExecArray | null;
while ((match = BOUNDARY.exec(buf)) !== null) {
- const raw = buf.slice(0, match.index)
- buf = buf.slice(match.index + match[0].length)
- const evt = parseEventBlock(raw)
- if (evt) yield evt
+ const raw = buf.slice(0, match.index);
+ buf = buf.slice(match.index + match[0].length);
+ const evt = parseEventBlock(raw);
+ if (evt) yield evt;
}
}
if (buf.trim()) {
- const evt = parseEventBlock(buf)
- if (evt) yield evt
+ const evt = parseEventBlock(buf);
+ if (evt) yield evt;
}
} finally {
- reader.releaseLock()
+ reader.releaseLock();
}
}
function parseEventBlock(raw: string): SseEvent | undefined {
- let event: string | undefined
- const dataLines: string[] = []
+ let event: string | undefined;
+ const dataLines: string[] = [];
// Per SSE spec, lines are terminated by CR, LF, or CRLF.
for (const line of raw.split(/\r\n|\n|\r/)) {
- if (!line || line.startsWith(":")) continue
- const colon = line.indexOf(":")
- const field = colon === -1 ? line : line.slice(0, colon)
- const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "")
- if (field === "event") event = value
- else if (field === "data") dataLines.push(value)
+ if (!line || line.startsWith(":")) continue;
+ const colon = line.indexOf(":");
+ const field = colon === -1 ? line : line.slice(0, colon);
+ const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+ if (field === "event") event = value;
+ else if (field === "data") dataLines.push(value);
}
- if (!dataLines.length && !event) return undefined
- return { event, data: dataLines.join("\n") }
+ if (!dataLines.length && !event) return undefined;
+ return { event, data: dataLines.join("\n") };
}