Skip to content

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

Rust

remove typescript reference source

Raine Virta50892072fa1e
diff --git a/reference/typescript/bun.lock b/reference/typescript/bun.lock
deleted file mode 100644
index b317169..0000000
--- a/reference/typescript/bun.lock
+++ /dev/null
@@ -1,137 +0,0 @@
-{
- "lockfileVersion": 1,
- "configVersion": 1,
- "workspaces": {
- "": {
- "name": "claude-openai-proxy",
- "dependencies": {
- "gpt-tokenizer": "^2.9.0",
- "ws": "^8.21.0",
- },
- "devDependencies": {
- "@types/bun": "latest",
- "@types/ws": "^8.18.1",
- "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=="],
-
- "@types/ws": ["@types/[email protected]", "", { "dependencies": { "@types/node": "*" } }, "sha512-ThVF6DCVhA8kUGy+aazFQ4kXQ7E1Ty7A3ypFOe0IcJV8O/M511G99AW24irKrW56Wt44yG9+ij8FaqoBGkuBXg=="],
-
- "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=="],
-
- "ws": ["[email protected]", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g=="],
-
- "@types/bun/bun-types": ["[email protected]", "", { "dependencies": { "@types/node": "*" } }, "sha512-HqOLj5PoFajAQciOMRiIZGNoKxDJSr6qigAttOX40vJuSp6DN/CxWp9s3C1Xwm4oH7ybueITwiaOcWXoYVoRkA=="],
- }
-}
diff --git a/reference/typescript/package.json b/reference/typescript/package.json
deleted file mode 100644
index a351b4e..0000000
--- a/reference/typescript/package.json
+++ /dev/null
@@ -1,27 +0,0 @@
-{
- "name": "claude-code-proxy",
- "version": "0.0.22",
- "license": "MIT",
- "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",
- "typecheck": "tsc --noEmit"
- },
- "dependencies": {
- "gpt-tokenizer": "^2.9.0",
- "ws": "^8.21.0"
- },
- "devDependencies": {
- "@types/bun": "latest",
- "@types/ws": "^8.18.1",
- "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/reference/typescript/scripts/publish b/reference/typescript/scripts/publish
deleted file mode 100755
index 4a1d6f6..0000000
--- a/reference/typescript/scripts/publish
+++ /dev/null
@@ -1,152 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-SKIP_CHANGELOG=false
-bump=""
-
-for arg in "$@"; do
- case "$arg" in
- --skip-changelog) SKIP_CHANGELOG=true ;;
- patch|minor|major|beta) bump="$arg" ;;
- *)
- echo "error: unknown argument: $arg" >&2
- echo "usage: scripts/publish <patch|minor|major|beta> [--skip-changelog]" >&2
- exit 1
- ;;
- esac
-done
-
-if [[ -z "$bump" ]]; then
- echo "usage: scripts/publish <patch|minor|major|beta> [--skip-changelog]" >&2
- exit 1
-fi
-
-BETA=false
-if [[ "$bump" == "beta" ]]; then
- BETA=true
-fi
-
-if ! git diff --quiet || ! git diff --cached --quiet; then
- echo "error: working tree has uncommitted changes" >&2
- exit 1
-fi
-
-if [[ "$BETA" == false ]]; then
- echo "Running checks..."
- bun run typecheck
-fi
-
-cleanup() {
- rc=$?
- if [ $rc -ne 0 ]; then
- echo "Failure detected, rolling back version changes..." >&2
- git restore package.json CHANGELOG.md 2>/dev/null || true
- fi
- exit $rc
-}
-trap cleanup EXIT
-
-if [[ "$BETA" == true ]]; then
- npm version prepatch --preid=beta --no-git-tag-version
-else
- npm version "$bump" --no-git-tag-version
-fi
-VERSION=$(node -p "require('./package.json').version")
-
-if [[ "$SKIP_CHANGELOG" == false ]]; then
- echo "Generating changelog entry for v${VERSION}..."
-
- # shellcheck disable=SC2016
- CHANGELOG_PROMPT=$(sed "s/__VERSION__/$VERSION/g" <<'PROMPT_EOF'
-# Changelog Updater (Pending Release)
-
-## Task
-
-Generate a user-focused changelog entry for the upcoming release `v__VERSION__` and insert it into CHANGELOG.md.
-
-## Steps
-
-1. **Find the previous tag**
-
- ```bash
- git describe --tags --abbrev=0
- ```
-
- If this fails (no previous tag exists), this is the first release—compare against the initial commit instead.
-
-2. **Get the commits since the last tag**
-
- ```bash
- git log --oneline PREVIOUS_TAG..HEAD
- ```
-
-3. **Review the actual changes** to understand context
-
- ```bash
- git diff PREVIOUS_TAG..HEAD --stat
- ```
-
- Read relevant changed files as needed to understand what the changes do.
-
-4. **Update CHANGELOG.md**
-
- - Insert the new entry at the top (after the `# Changelog` header), as the newest release
- - Use heading level `##` for version entries
- - Use today's date in YYYY-MM-DD format
- - Create CHANGELOG.md if it does not exist, with `# Changelog` as the first line
-
-## Writing Guidelines
-
-- Write from the user's perspective: what can they now do, what's fixed, what's improved?
-- Use plain language, avoid implementation details like function names, file paths, or internal refactors
-- Focus on behavior changes, new capabilities, and bug fixes users would notice
-- Skip purely internal changes (refactoring, test improvements, CI changes) unless they affect users
-- Keep entries concise—one line per change is usually enough
-- If there are no user-facing changes, still create a minimal entry noting the release
-
-## Linking Issues and Pull Requests
-
-- Determine the GitHub repository URL from the git remote (e.g., `git remote get-url origin`)
-- When commits reference GitHub issues or pull requests (e.g., `#70`, `fixes #70`, `closes #65`), link them at the end of the relevant changelog entry
-- Even when commits don't explicitly reference issues or PRs, check recent closed issues and merged pull requests (`gh issue list --state closed --limit 20`, `gh pr list --state merged --limit 20`) to find ones related to the changes, and link them
-- Format: `([#70](https://github.com/OWNER/REPO/issues/70))` for issues, `([#68](https://github.com/OWNER/REPO/pull/68))` for pull requests
-- If multiple entries relate to the same issue/PR, link it on each relevant entry
-
-## Entry Format
-
-```markdown
-## v__VERSION__ (YYYY-MM-DD)
-
-- Change description ([#70](https://github.com/OWNER/REPO/issues/70))
-- Another change description
-```
-PROMPT_EOF
-)
-
- claude --dangerously-skip-permissions --no-session-persistence -p "$CHANGELOG_PROMPT"
- prettier --write CHANGELOG.md 2>/dev/null || true
-
- ${EDITOR:-vim} CHANGELOG.md
-fi
-
-read -rp "Proceed with release v${VERSION}? [y/n] " response
-if [[ "$response" != "y" && "$response" != "yes" ]]; then
- echo "Aborting release."
- exit 1
-fi
-
-trap - EXIT
-
-CHANGELOG_FILE=""
-if [[ -f CHANGELOG.md ]]; then
- CHANGELOG_FILE="CHANGELOG.md"
-fi
-
-git add package.json $CHANGELOG_FILE
-git commit -m "$VERSION"
-git tag "v$VERSION"
-git push
-git push --tags
-
-echo ""
-echo "Pushed v${VERSION} — CI will build and publish."
diff --git a/reference/typescript/src/anthropic/response.test.ts b/reference/typescript/src/anthropic/response.test.ts
deleted file mode 100644
index a4abe8b..0000000
--- a/reference/typescript/src/anthropic/response.test.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
- anthropicErrorBody,
- expectSseHeaders,
- jsonError,
- jsonResponse,
- sseResponse,
- streamResponse,
-} from "./response.ts";
-
-describe("anthropicErrorBody", () => {
- it("returns Anthropic error payload shape", () => {
- expect(anthropicErrorBody("invalid_request_error", "Bad request")).toEqual({
- type: "error",
- error: { type: "invalid_request_error", message: "Bad request" },
- });
- });
-});
-
-describe("jsonResponse and jsonError", () => {
- it("normalizes JSON response shape and content type", async () => {
- const response = jsonError(400, "invalid_request_error", "Bad request");
- const body = (await response.json()) as { type: "error"; error: { type: string; message: string } };
-
- expect(response.status).toBe(400);
- expect(response.headers.get("content-type")).toBe("application/json");
- expect(body).toEqual({
- type: "error",
- error: { type: "invalid_request_error", message: "Bad request" },
- });
- });
-
- it("preserves custom headers when returning JSON errors", () => {
- const response = jsonError(429, "rate_limit_error", "Slow down", { "retry-after": "10" });
- expect(response.headers.get("retry-after")).toBe("10");
- expect(response.headers.get("content-type")).toBe("application/json");
- });
-
- it("preserves headers on generic JSON responses", async () => {
- const response = jsonResponse({ ok: true }, { headers: { "x-trace-id": "abc" } });
- expect(response.headers.get("content-type")).toBe("application/json");
- expect(response.headers.get("x-trace-id")).toBe("abc");
- expect(await response.json()).toEqual({ ok: true });
- });
-});
-
-describe("sseResponse", () => {
- it("adds SSE headers and preserves extra headers", () => {
- const response = sseResponse("data", {
- headers: {
- "x-upstream": "origin",
- "cache-control": "custom",
- connection: "close",
- },
- });
-
- expect(response.status).toBe(200);
- expectSseHeaders(response);
- expect(response.headers.get("x-upstream")).toBe("origin");
- });
-});
-
-describe("streamResponse", () => {
- it("strips hop-by-hop headers but preserves status, statusText and passthrough headers", async () => {
- const upstream = new Response("stream-data", {
- status: 203,
- statusText: "Accepted",
- headers: {
- "content-encoding": "gzip",
- "content-length": "10",
- "transfer-encoding": "chunked",
- "x-upstream": "provider",
- },
- });
- const response = streamResponse(upstream, upstream.body);
-
- expect(response.status).toBe(203);
- expect(response.statusText).toBe("Accepted");
- expect(response.headers.get("content-encoding")).toBeNull();
- expect(response.headers.get("content-length")).toBeNull();
- expect(response.headers.get("transfer-encoding")).toBeNull();
- expect(response.headers.get("x-upstream")).toBe("provider");
- expect(await response.text()).toBe("stream-data");
- });
-});
diff --git a/reference/typescript/src/anthropic/response.ts b/reference/typescript/src/anthropic/response.ts
deleted file mode 100644
index a481bda..0000000
--- a/reference/typescript/src/anthropic/response.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-import { expect } from "bun:test";
-
-type ResponseBody = ConstructorParameters<typeof Response>[0];
-type ResponseHeaders = ResponseInit["headers"];
-type HeadersConstructorInput = ConstructorParameters<typeof Headers>[0];
-
-export interface AnthropicErrorBody {
- type: "error";
- error: {
- type: string;
- message: string;
- };
-}
-
-export function anthropicErrorBody(type: string, message: string): AnthropicErrorBody {
- return { type: "error", error: { type, message } };
-}
-
-export function jsonError(status: number, type: string, message: string, headers?: ResponseHeaders): Response {
- return jsonResponse(anthropicErrorBody(type, message), { status, headers });
-}
-
-export function jsonResponse(body: unknown, init: ResponseInit = {}): Response {
- return new Response(JSON.stringify(body), {
- ...init,
- headers: jsonHeaders(init.headers),
- });
-}
-
-export function sseResponse(body: ResponseBody, init: ResponseInit = {}): Response {
- return new Response(body, {
- status: 200,
- ...init,
- headers: sseHeaders(init.headers),
- });
-}
-
-export function streamResponse(resp: Response, body: ResponseBody): Response {
- return new Response(body, {
- status: resp.status,
- statusText: resp.statusText,
- headers: streamResponseHeaders(resp.headers),
- });
-}
-
-export function streamResponseHeaders(headers: ResponseHeaders): Headers {
- const out = new Headers(headers as HeadersConstructorInput);
- out.delete("content-encoding");
- out.delete("content-length");
- out.delete("transfer-encoding");
- return out;
-}
-
-function jsonHeaders(headers: ResponseHeaders): Headers {
- const out = new Headers(headers as HeadersConstructorInput);
- out.set("content-type", "application/json");
- return out;
-}
-
-function sseHeaders(headers: ResponseHeaders): Headers {
- const out = new Headers(headers as HeadersConstructorInput);
- out.set("content-type", "text/event-stream");
- out.set("cache-control", "no-cache");
- out.set("connection", "keep-alive");
- return out;
-}
-
-export function expectSseHeaders(response: Response): void {
- expect(response.headers.get("content-type")).toBe("text/event-stream");
- expect(response.headers.get("cache-control")).toBe("no-cache");
- expect(response.headers.get("connection")).toBe("keep-alive");
-}
diff --git a/reference/typescript/src/anthropic/schema.ts b/reference/typescript/src/anthropic/schema.ts
deleted file mode 100644
index 054fc5c..0000000
--- a/reference/typescript/src/anthropic/schema.ts
+++ /dev/null
@@ -1,111 +0,0 @@
-export interface AnthropicTextBlock {
- 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 };
-}
-
-export interface AnthropicToolUseBlock {
- 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;
-}
-
-export interface AnthropicThinkingBlock {
- type: "thinking";
- thinking: string;
- signature?: string;
-}
-
-export interface AnthropicServerToolUseBlock {
- type: "server_tool_use";
- id: string;
- name: string;
- input: unknown;
-}
-
-export interface AnthropicWebSearchResultBlock {
- type: "web_search_result";
- url: string;
- title: string;
- encrypted_content?: string;
- page_age?: string | null;
-}
-
-export interface AnthropicWebSearchToolResultBlock {
- type: "web_search_tool_result";
- tool_use_id: string;
- content:
- | AnthropicWebSearchResultBlock[]
- | { type: "web_search_tool_result_error"; error_code: string };
-}
-
-export type AnthropicToolResultContentBlock =
- | AnthropicTextBlock
- | AnthropicImageBlock
- | AnthropicToolUseBlock
- | AnthropicToolResultBlock
- | AnthropicThinkingBlock
- | (Record<string, unknown> & { type?: unknown });
-
-export type AnthropicContentBlock =
- | AnthropicTextBlock
- | AnthropicImageBlock
- | AnthropicToolUseBlock
- | AnthropicToolResultBlock
- | AnthropicThinkingBlock
- | AnthropicServerToolUseBlock
- | AnthropicWebSearchToolResultBlock;
-
-export interface AnthropicMessage {
- role: "user" | "assistant" | "system";
- content: string | AnthropicContentBlock[];
-}
-
-export interface AnthropicFunctionTool {
- type?: "function" | "custom";
- name: string;
- description?: string;
- input_schema: unknown;
-}
-
-export interface AnthropicWebSearchTool {
- type: "web_search_20250305";
- name: string;
- allowed_domains?: string[];
- blocked_domains?: string[];
- max_uses?: number;
-}
-
-export type AnthropicTool = AnthropicFunctionTool | AnthropicWebSearchTool;
-
-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 };
- output_config?: {
- effort?: "low" | "medium" | "high" | "max";
- format?: { type: "json_schema"; schema: unknown; name?: string; strict?: boolean };
- };
- context_management?: unknown;
- metadata?: unknown;
-}
diff --git a/reference/typescript/src/anthropic/stream.test.ts b/reference/typescript/src/anthropic/stream.test.ts
deleted file mode 100644
index 2e519c2..0000000
--- a/reference/typescript/src/anthropic/stream.test.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { wantsDownstreamStream } from "./stream.ts";
-
-describe("wantsDownstreamStream", () => {
- it("uses Anthropic's non-streaming default", () => {
- expect(wantsDownstreamStream({})).toBe(false);
- });
-
- it("streams only when explicitly requested", () => {
- expect(wantsDownstreamStream({ stream: true })).toBe(true);
- expect(wantsDownstreamStream({ stream: false })).toBe(false);
- });
-});
diff --git a/reference/typescript/src/anthropic/stream.ts b/reference/typescript/src/anthropic/stream.ts
deleted file mode 100644
index 479939c..0000000
--- a/reference/typescript/src/anthropic/stream.ts
+++ /dev/null
@@ -1,5 +0,0 @@
-import type { AnthropicRequest } from "./schema.ts";
-
-export function wantsDownstreamStream(body: Pick<AnthropicRequest, "stream">): boolean {
- return body.stream === true;
-}
diff --git a/reference/typescript/src/cli.ts b/reference/typescript/src/cli.ts
deleted file mode 100755
index 9122cd7..0000000
--- a/reference/typescript/src/cli.ts
+++ /dev/null
@@ -1,183 +0,0 @@
-#!/usr/bin/env bun
-import { startServer } from "./server.ts";
-import { createLogger, logFile } from "./log.ts";
-import {
- port as configPort,
- configPath,
- configOverrideSummaryLines,
-} from "./config.ts";
-import { existsSync } from "node:fs";
-import {
- getProvider,
- groupSupportedModelsByProvider,
- listProviders,
-} from "./providers/registry.ts";
-import type { CliHandlers } from "./providers/types.ts";
-
-declare const BUILD_VERSION: string | undefined;
-const VERSION = typeof BUILD_VERSION === "string" ? BUILD_VERSION : "dev";
-
-const log = createLogger("cli");
-
-async function main() {
- const args = process.argv.slice(2);
- const [first, ...rest] = args;
-
- if (first === "--version" || first === "-v" || first === "version") {
- 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="gpt-5.5" # or kimi-for-coding[1m]`,
- );
- console.log(
- ` export ANTHROPIC_SMALL_FAST_MODEL="gpt-5.4-mini" # background / title-gen`,
- );
- console.log(` export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1"`);
- return;
- }
-
- if (first === "models") {
- printSupportedModels({ full: rest.includes("--full") });
- return;
- }
-
- if (listProviders().includes(first)) {
- const provider = getProvider(first);
- await runProviderCommand(provider.name, provider.cli, rest);
- return;
- }
-
- usageAndExit();
-}
-
-async function runProviderCommand(name: string, cli: CliHandlers, args: string[]): Promise<void> {
- const [group, sub] = args;
- if (group !== "auth") usageAndExit();
-
- switch (sub) {
- case "login":
- if (!cli.login) {
- console.error(`${name}: browser login not supported`);
- process.exit(2);
- }
- await cli.login();
- process.exit(0);
- case "device":
- if (!cli.device) {
- console.error(`${name}: device login not supported`);
- process.exit(2);
- }
- await cli.device();
- process.exit(0);
- case "status":
- await cli.status();
- return;
- case "logout":
- await cli.logout();
- return;
- default:
- usageAndExit();
- }
-}
-
-function usageAndExit(): never {
- const providers = listProviders().join("|");
- const models = compactSupportedModelsSummary();
- 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.
- claude-code-proxy models Show compact model list
- claude-code-proxy models --full Show every supported model alias
- claude-code-proxy <provider> auth login Browser OAuth
- claude-code-proxy <provider> auth device Device-code OAuth
- claude-code-proxy <provider> auth status Show current auth
- claude-code-proxy <provider> auth logout Clear stored auth
- claude-code-proxy --version Show version
-
-Providers: ${providers}
-Models:
-${models}
-`);
- process.exit(2);
-}
-
-function printSupportedModels(opts: { full?: boolean } = {}): void {
- const groups = groupSupportedModelsByProvider();
- for (const provider of listProviders()) {
- const models = groups.get(provider) ?? [];
- console.log(` ${provider}: ${formatProviderModels(provider, models, opts)}`);
- }
-}
-
-function compactSupportedModelsSummary(): string {
- const groups = groupSupportedModelsByProvider();
- return listProviders()
- .map((provider) => ` ${provider}: ${formatProviderModels(provider, groups.get(provider) ?? [])}`)
- .join("\n");
-}
-
-function formatProviderModels(provider: string, models: string[], opts: { full?: boolean } = {}): string {
- if (opts.full || provider !== "cursor") return models.join(", ");
- return formatCursorModels(models);
-}
-
-function formatCursorModels(models: string[]): string {
- const legacy = models.filter((model) => !model.includes(":"));
- const rawIds = new Set<string>();
- for (const model of models) {
- for (const prefix of ["cursor:", "cursor-plan:", "cursor-ask:"]) {
- if (model.startsWith(prefix)) rawIds.add(model.slice(prefix.length));
- }
- }
-
- const examples = [
- "cursor:gemini-3.1-pro",
- "cursor:gpt-5.5-high",
- "cursor-plan:gpt-5.5-high",
- "cursor-ask:gpt-5.5-high",
- ].filter((model) => models.includes(model));
-
- return [
- ...legacy,
- examples.length ? `examples: ${examples.join(", ")}` : undefined,
- `${rawIds.size} Cursor catalog models via cursor:<id>, cursor-plan:<id>, cursor-ask:<id>`,
- "run `claude-code-proxy models --full` for all aliases",
- ].filter(Boolean).join("; ");
-}
-
-function printConfigSummary(): void {
- const path = configPath();
- if (existsSync(path)) {
- console.log(`Config: ${path}`);
- }
-
- const overrides = configOverrideSummaryLines();
-
- if (overrides.length > 0) {
- console.log("Overrides:");
- for (const o of overrides) {
- console.log(` ${o}`);
- }
- }
-}
-
-main().catch((err) => {
- log.error("cli fatal", { err: String(err), stack: (err as Error)?.stack });
- console.error(err);
- process.exit(1);
-});
diff --git a/reference/typescript/src/config.test.ts b/reference/typescript/src/config.test.ts
deleted file mode 100644
index 03c5554..0000000
--- a/reference/typescript/src/config.test.ts
+++ /dev/null
@@ -1,482 +0,0 @@
-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,
- getConfig,
- configPath as resolveConfigPath,
- configOverrideSummaryLines,
- port,
- codexOriginator,
- codexUserAgent,
- codexModel,
- codexEffort,
- codexServiceTier,
- codexBaseUrl,
- codexTransport,
- codexPreviousResponseId,
- aliasProvider,
- kimiUserAgent,
- kimiOauthHost,
- kimiBaseUrl,
- cursorBaseUrl,
- cursorClientVersion,
- cursorAgentBundle,
- logVerbose,
- logStderr,
-} from "./config.ts";
-
-let dir: string;
-let configPath: string;
-
-function setEnv(env: NodeJS.ProcessEnv) {
- loadConfig({ configPath, env, forceReload: true });
-}
-
-function writeConfigSummaryFixture(overrides: { log?: { stderr?: boolean } } = {}) {
- writeFileSync(
- configPath,
- JSON.stringify({
- codex: {
- originator: "file-originator",
- userAgent: "file-codex-ua",
- model: "gpt-5.2",
- effort: "high",
- serviceTier: "flex",
- baseUrl: "https://codex-file.example.com",
- transport: "http",
- previousResponseId: false,
- },
- kimi: {
- userAgent: "file-kimi-ua",
- oauthHost: "https://kimi-auth-file.example.com",
- baseUrl: "https://kimi-file.example.com",
- },
- cursor: {
- baseUrl: "https://cursor-file.example.com",
- clientVersion: "cli-file",
- agentBundle: "/file/index.js",
- },
- aliasProvider: "kimi",
- log: {
- verbose: true,
- ...(overrides.log ? overrides.log : {}),
- },
- }),
- );
-}
-
-beforeEach(() => {
- dir = mkdtempSync(join(tmpdir(), "ccp-config-"));
- configPath = join(dir, "config.json");
-});
-
-afterEach(() => {
- rmSync(dir, { recursive: true, force: true });
- // Reset module-level cache to a clean process-env baseline so unrelated
- // tests that import config getters do not see leftover overrides.
- loadConfig({ forceReload: true });
-});
-
-describe("config defaults", () => {
- it("returns built-in defaults when no env and no file", () => {
- setEnv({});
- expect(port()).toBe(18765);
- expect(codexOriginator("default-orig")).toBe("default-orig");
- expect(codexUserAgent("default-ua")).toBe("default-ua");
- expect(codexModel()).toBeUndefined();
- expect(codexEffort()).toBeUndefined();
- expect(codexServiceTier()).toBeUndefined();
- expect(codexBaseUrl("default-codex-url")).toBe("default-codex-url");
- expect(codexTransport()).toBe("websocket");
- expect(codexPreviousResponseId()).toBe(false);
- 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(cursorBaseUrl()).toBe("https://api2.cursor.sh");
- expect(cursorClientVersion()).toBe("cli-2026.06.04-5fd875e");
- expect(cursorAgentBundle()).toBeUndefined();
- expect(logVerbose()).toBe(false);
- expect(logStderr()).toBe(false);
- });
-});
-
-describe("file overrides default", () => {
- it("port from config.json", () => {
- writeFileSync(configPath, JSON.stringify({ port: 11111 }));
- setEnv({});
- expect(port()).toBe(11111);
- });
-
- it("codex.userAgent from config.json", () => {
- writeFileSync(configPath, JSON.stringify({ codex: { userAgent: "ccp/file" } }));
- setEnv({});
- expect(codexUserAgent("default")).toBe("ccp/file");
- });
-
- it("codex.serviceTier from config.json", () => {
- writeFileSync(configPath, JSON.stringify({ codex: { serviceTier: "fast" } }));
- setEnv({});
- expect(codexServiceTier()).toBe("fast");
- });
-
- it("codex.baseUrl from config.json", () => {
- writeFileSync(
- configPath,
- 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");
- });
-
- it("codex transport and previous response id from config.json", () => {
- writeFileSync(
- configPath,
- JSON.stringify({ codex: { transport: "http", previousResponseId: true } }),
- );
- setEnv({});
- expect(codexTransport()).toBe("http");
- expect(codexPreviousResponseId()).toBe(true);
- });
-
- it("aliasProvider from config.json", () => {
- 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");
- });
-
- it("cursor config from config.json", () => {
- writeFileSync(
- configPath,
- JSON.stringify({
- cursor: {
- baseUrl: "https://cursor.example.com",
- clientVersion: "cli-test",
- agentBundle: "/tmp/cursor-agent/index.js",
- },
- }),
- );
- setEnv({});
- expect(cursorBaseUrl()).toBe("https://cursor.example.com");
- expect(cursorClientVersion()).toBe("cli-test");
- expect(cursorAgentBundle()).toBe("/tmp/cursor-agent/index.js");
- });
-
- it("log.verbose from config.json", () => {
- writeFileSync(configPath, JSON.stringify({ log: { verbose: true } }));
- setEnv({});
- expect(logVerbose()).toBe(true);
- });
-});
-
-describe("env overrides file", () => {
- it("PORT env wins over config port", () => {
- writeFileSync(configPath, JSON.stringify({ port: 11111 }));
- setEnv({ PORT: "22222" });
- expect(port()).toBe(22222);
- });
-
- it("CCP_CODEX_USER_AGENT env wins over config", () => {
- writeFileSync(configPath, JSON.stringify({ codex: { userAgent: "from-file" } }));
- setEnv({ CCP_CODEX_USER_AGENT: "from-env" });
- expect(codexUserAgent("default")).toBe("from-env");
- });
-
- it("CCP_CODEX_SERVICE_TIER env wins over config", () => {
- 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");
- });
-
- it("Codex transport env wins over config", () => {
- writeFileSync(
- configPath,
- JSON.stringify({ codex: { transport: "http", previousResponseId: false } }),
- );
- setEnv({ CCP_CODEX_TRANSPORT: "auto", CCP_CODEX_PREVIOUS_RESPONSE_ID: "true" });
- expect(codexTransport()).toBe("auto");
- expect(codexPreviousResponseId()).toBe(true);
- });
-
- it("CCP_ALIAS_PROVIDER env wins over config", () => {
- writeFileSync(configPath, JSON.stringify({ aliasProvider: "kimi" }));
- setEnv({ CCP_ALIAS_PROVIDER: "codex" });
- expect(aliasProvider()).toBe("codex");
- });
-
- it("CCP_USER_AGENT env (generic fallback) is preferred over file", () => {
- writeFileSync(configPath, 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("Cursor env vars win over config", () => {
- writeFileSync(
- configPath,
- JSON.stringify({
- cursor: {
- baseUrl: "https://cursor-file.example.com",
- clientVersion: "cli-file",
- agentBundle: "/file/index.js",
- },
- }),
- );
- setEnv({
- CCP_CURSOR_BASE_URL: "https://cursor-env.example.com",
- CCP_CURSOR_CLIENT_VERSION: "cli-env",
- CCP_CURSOR_AGENT_BUNDLE: "/env/index.js",
- });
- expect(cursorBaseUrl()).toBe("https://cursor-env.example.com");
- expect(cursorClientVersion()).toBe("cli-env");
- expect(cursorAgentBundle()).toBe("/env/index.js");
- });
-
- it("logStderr env-set forces true even when config sets false", () => {
- writeFileSync(configPath, JSON.stringify({ log: { stderr: false } }));
- setEnv({ CCP_LOG_STDERR: "1" });
- expect(logStderr()).toBe(true);
- });
-});
-
-describe("empty-string semantics", () => {
- it("empty CCP_CODEX_MODEL env falls through to file value", () => {
- writeFileSync(configPath, JSON.stringify({ codex: { model: "gpt-5.2" } }));
- setEnv({ CCP_CODEX_MODEL: "" });
- expect(codexModel()).toBe("gpt-5.2");
- });
-
- it("empty CCP_CODEX_MODEL env with no file value returns undefined", () => {
- setEnv({ CCP_CODEX_MODEL: "" });
- expect(codexModel()).toBeUndefined();
- });
-
- it("empty Codex transport env falls through to file value", () => {
- writeFileSync(
- configPath,
- JSON.stringify({ codex: { transport: "http", previousResponseId: true } }),
- );
- setEnv({ CCP_CODEX_TRANSPORT: "", CCP_CODEX_PREVIOUS_RESPONSE_ID: "" });
- expect(codexTransport()).toBe("http");
- expect(codexPreviousResponseId()).toBe(true);
- });
-
- 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");
- });
-
- it("empty CCP_ALIAS_PROVIDER env falls through to file value", () => {
- writeFileSync(configPath, JSON.stringify({ aliasProvider: "codex" }));
- setEnv({ CCP_ALIAS_PROVIDER: "" });
- expect(aliasProvider()).toBe("codex");
- });
-
- it("invalid CCP_ALIAS_PROVIDER env falls through to file value", () => {
- writeFileSync(configPath, JSON.stringify({ aliasProvider: "codex" }));
- setEnv({ CCP_ALIAS_PROVIDER: "openai" });
- expect(aliasProvider()).toBe("codex");
- });
-
- it("empty PORT env falls through to file value", () => {
- writeFileSync(configPath, JSON.stringify({ port: 33333 }));
- setEnv({ PORT: "" });
- expect(port()).toBe(33333);
- });
-});
-
-describe("empty env-string compatibility", () => {
- it("empty CCP_CODEX_USER_AGENT env is a valid value (legacy ?? semantics)", () => {
- setEnv({ CCP_CODEX_USER_AGENT: "" });
- expect(codexUserAgent("default-ua")).toBe("");
- });
-
- it("empty CCP_KIMI_OAUTH_HOST env is a valid value (legacy ?? semantics)", () => {
- 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);
- });
-});
-
-describe("malformed config", () => {
- it("returns defaults when JSON is invalid", () => {
- writeFileSync(configPath, "{not valid json");
- setEnv({});
- expect(port()).toBe(18765);
- });
-
- it("ignores wrong-typed values with a warning, keeps other valid ones", () => {
- writeFileSync(
- configPath,
- JSON.stringify({ port: "not-a-number", codex: { userAgent: "good" } }),
- );
- setEnv({});
- expect(port()).toBe(18765);
- expect(codexUserAgent("default")).toBe("good");
- });
-
- it("ignores invalid aliasProvider values", () => {
- writeFileSync(configPath, JSON.stringify({ aliasProvider: "openai" }));
- setEnv({});
- expect(aliasProvider()).toBe("codex");
- });
-
- it("ignores invalid Codex transport values", () => {
- writeFileSync(configPath, JSON.stringify({ codex: { transport: "websockets" } }));
- setEnv({});
- expect(codexTransport()).toBe("websocket");
- });
-
- it("returns defaults when file is missing entirely", () => {
- setEnv({});
- expect(port()).toBe(18765);
- });
-});
-
-describe("config summary", () => {
- it("resolves config.json under the configured directory", () => {
- expect(resolveConfigPath("/tmp/ccp-config")).toBe(join("/tmp/ccp-config", "config.json"));
- });
-
- it("returns no override lines for defaults", () => {
- setEnv({});
- expect(configOverrideSummaryLines(getConfig())).toEqual([]);
- });
-
- it("summarizes file override lines with existing labels", () => {
- writeConfigSummaryFixture({ log: { stderr: true } });
- setEnv({});
-
- expect(configOverrideSummaryLines(getConfig())).toEqual([
- "codex.originator (config)",
- "codex.userAgent (config)",
- "kimi.userAgent (config)",
- "codex.model (config)",
- "codex.effort (config)",
- "codex.serviceTier (config)",
- "codex.baseUrl (config)",
- "codex.transport=http (config)",
- "codex.previousResponseId=false (config)",
- "aliasProvider=kimi (config)",
- "log.verbose (config)",
- "log.stderr (config)",
- "kimi.oauthHost (config)",
- "kimi.baseUrl (config)",
- "cursor.baseUrl (config)",
- "cursor.clientVersion (config)",
- "cursor.agentBundle (config)",
- ]);
- });
-
- it("summarizes env override lines with current precedence and display values", () => {
- writeConfigSummaryFixture({ log: { stderr: false } });
- setEnv({
- CCP_CODEX_ORIGINATOR: "env-originator",
- CCP_CODEX_USER_AGENT: "env-codex-ua",
- CCP_KIMI_USER_AGENT: "env-kimi-ua",
- CCP_CODEX_MODEL: "gpt-5.5",
- CCP_CODEX_EFFORT: "medium",
- CCP_CODEX_SERVICE_TIER: "fast",
- CCP_CODEX_BASE_URL: "https://codex-env.example.com",
- CCP_CODEX_TRANSPORT: "auto",
- CCP_CODEX_PREVIOUS_RESPONSE_ID: "true",
- CCP_ALIAS_PROVIDER: "codex",
- CCP_LOG_VERBOSE: "0",
- CCP_LOG_STDERR: "",
- CCP_KIMI_OAUTH_HOST: "https://kimi-auth-env.example.com",
- CCP_KIMI_BASE_URL: "https://kimi-env.example.com",
- CCP_CURSOR_BASE_URL: "https://cursor-env.example.com",
- CCP_CURSOR_CLIENT_VERSION: "cli-env",
- CCP_CURSOR_AGENT_BUNDLE: "/env/index.js",
- });
-
- expect(configOverrideSummaryLines(getConfig())).toEqual([
- "CCP_CODEX_ORIGINATOR (env)",
- "CCP_CODEX_USER_AGENT (env)",
- "CCP_KIMI_USER_AGENT (env)",
- "CCP_CODEX_MODEL (env)",
- "CCP_CODEX_EFFORT (env)",
- "CCP_CODEX_SERVICE_TIER (env)",
- "CCP_CODEX_BASE_URL (env)",
- "CCP_CODEX_TRANSPORT=auto (env)",
- "CCP_CODEX_PREVIOUS_RESPONSE_ID=true (env)",
- "CCP_ALIAS_PROVIDER=codex (env)",
- "CCP_LOG_VERBOSE (env)",
- "CCP_LOG_STDERR (env)",
- "CCP_KIMI_OAUTH_HOST (env)",
- "CCP_KIMI_BASE_URL (env)",
- "CCP_CURSOR_BASE_URL=https://cursor-env.example.com (env)",
- "CCP_CURSOR_CLIENT_VERSION=cli-env (env)",
- "CCP_CURSOR_AGENT_BUNDLE (env)",
- ]);
- });
-
- it("preserves current empty-string display semantics", () => {
- writeFileSync(
- configPath,
- JSON.stringify({
- codex: { model: "gpt-5.2", transport: "http", previousResponseId: true },
- aliasProvider: "kimi",
- cursor: { baseUrl: "https://cursor-file.example.com" },
- }),
- );
- setEnv({
- CCP_CODEX_MODEL: "",
- CCP_CODEX_TRANSPORT: "",
- CCP_CODEX_PREVIOUS_RESPONSE_ID: "",
- CCP_ALIAS_PROVIDER: "",
- CCP_LOG_STDERR: "",
- CCP_CURSOR_BASE_URL: "",
- });
-
- expect(configOverrideSummaryLines(getConfig())).toEqual([
- "codex.model (config)",
- "codex.transport=http (config)",
- "CCP_CODEX_PREVIOUS_RESPONSE_ID=true (env)",
- "aliasProvider=kimi (config)",
- "CCP_LOG_STDERR (env)",
- "cursor.baseUrl (config)",
- ]);
- });
-
- it("summarizes generic CCP_USER_AGENT fallback once in the existing position", () => {
- setEnv({ CCP_USER_AGENT: "generic-env" });
-
- expect(configOverrideSummaryLines(getConfig())).toEqual(["CCP_USER_AGENT (env)"]);
- });
-
- it("uses the supplied loaded config instead of the module cache", () => {
- setEnv({ CCP_CODEX_TRANSPORT: "http", CCP_CURSOR_CLIENT_VERSION: "cached" });
-
- const supplied = loadConfig({
- configPath,
- env: { CCP_CODEX_TRANSPORT: "auto", CCP_CURSOR_CLIENT_VERSION: "supplied" },
- });
-
- expect(configOverrideSummaryLines(supplied)).toEqual([
- "CCP_CODEX_TRANSPORT=auto (env)",
- "CCP_CURSOR_CLIENT_VERSION=supplied (env)",
- ]);
- });
-});
diff --git a/reference/typescript/src/config.ts b/reference/typescript/src/config.ts
deleted file mode 100644
index 6293919..0000000
--- a/reference/typescript/src/config.ts
+++ /dev/null
@@ -1,429 +0,0 @@
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { configDir } from "./paths.ts";
-
-// Config precedence per setting:
-// provider-specific env > generic-fallback env (where one exists) > config.json > default
-//
-// The config file is parsed once on first access and cached. Empty strings
-// from either env or the file are treated as "unset" so they fall through
-// to the next layer (matches existing CCP_CODEX_MODEL behavior).
-
-export type AliasProvider = "codex" | "kimi";
-export type CodexTransport = "http" | "websocket" | "auto";
-
-export interface FileConfig {
- port?: number;
- aliasProvider?: AliasProvider;
- codex?: {
- originator?: string;
- userAgent?: string;
- model?: string;
- effort?: string;
- serviceTier?: string;
- baseUrl?: string;
- transport?: CodexTransport;
- previousResponseId?: boolean;
- };
- kimi?: {
- userAgent?: string;
- oauthHost?: string;
- baseUrl?: string;
- };
- cursor?: {
- baseUrl?: string;
- clientVersion?: string;
- agentBundle?: string;
- };
- log?: {
- stderr?: boolean;
- verbose?: boolean;
- };
-}
-
-export interface LoadedConfig {
- file: FileConfig;
- env: NodeJS.ProcessEnv;
-}
-
-interface LoadOptions {
- configPath?: string;
- env?: NodeJS.ProcessEnv;
- forceReload?: boolean;
-}
-
-let cached: LoadedConfig | undefined;
-
-export function configPath(configDirectory = configDir()): string {
- return join(configDirectory, "config.json");
-}
-
-// Most env-var consumers historically used `??` semantics — empty string is
-// a real value that wins. Only CCP_CODEX_MODEL and CCP_CODEX_EFFORT had
-// explicit empty-string-as-unset handling in the legacy code, so only those
-// getters use emptyOrUnset.
-function emptyOrUnset(v: string | undefined): string | undefined {
- return v === undefined || v === "" ? undefined : v;
-}
-
-function warnInvalid(key: string, expected: string, got: unknown): void {
- process.stderr.write(
- `claude-code-proxy: ignoring config.json key "${key}": expected ${expected}, got ${typeof got}\n`,
- );
-}
-
-function parseAliasProvider(key: string, value: unknown): AliasProvider | undefined {
- if (value === undefined) return undefined;
- if (value === "codex" || value === "kimi") return value;
- warnInvalid(key, '"codex" or "kimi"', value);
- return undefined;
-}
-
-function parseCodexTransport(key: string, value: unknown): CodexTransport | undefined {
- if (value === undefined) return undefined;
- if (value === "http" || value === "websocket" || value === "auto") return value;
- warnInvalid(key, '"http", "websocket", or "auto"', value);
- return undefined;
-}
-
-function parseBoolean(key: string, value: unknown): boolean | undefined {
- if (value === undefined) return undefined;
- if (typeof value === "boolean") return value;
- warnInvalid(key, "boolean", value);
- return undefined;
-}
-
-function parseBooleanEnv(value: string | undefined): boolean | undefined {
- const normalized = emptyOrUnset(value)?.toLowerCase();
- if (normalized === undefined) return undefined;
- return normalized === "1" || normalized === "true" || normalized === "yes";
-}
-
-function validate(raw: unknown): FileConfig {
- if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
- const r = raw as Record<string, unknown>;
- const out: FileConfig = {};
-
- if (r.port !== undefined) {
- if (typeof r.port === "number" && Number.isFinite(r.port)) out.port = r.port;
- else warnInvalid("port", "number", r.port);
- }
-
- out.aliasProvider = parseAliasProvider("aliasProvider", r.aliasProvider);
-
- const validateStringSection = <K extends "codex" | "kimi" | "cursor" | "log">(
- key: K,
- keys: ReadonlyArray<keyof NonNullable<FileConfig[K]>>,
- types: Record<string, "string" | "boolean">,
- ): NonNullable<FileConfig[K]> | undefined => {
- if (r[key] === undefined) return undefined;
- const sec = r[key];
- if (!sec || typeof sec !== "object" || Array.isArray(sec)) {
- warnInvalid(key, "object", sec);
- return undefined;
- }
- const acc: Record<string, unknown> = {};
- for (const k of keys) {
- const v = (sec as Record<string, unknown>)[k as string];
- if (v === undefined) continue;
- const expected = types[k as string];
- if (expected && typeof v === expected) acc[k as string] = v;
- else warnInvalid(`${key}.${String(k)}`, expected ?? "unknown", v);
- }
- return acc as NonNullable<FileConfig[K]>;
- };
-
- const codex = validateStringSection(
- "codex",
- [
- "originator",
- "userAgent",
- "model",
- "effort",
- "serviceTier",
- "baseUrl",
- "transport",
- "previousResponseId",
- ],
- {
- originator: "string",
- userAgent: "string",
- model: "string",
- effort: "string",
- serviceTier: "string",
- baseUrl: "string",
- transport: "string",
- previousResponseId: "boolean",
- },
- );
- if (codex) {
- codex.transport = parseCodexTransport("codex.transport", codex.transport);
- codex.previousResponseId = parseBoolean("codex.previousResponseId", codex.previousResponseId);
- out.codex = codex;
- }
-
- const kimi = validateStringSection("kimi", ["userAgent", "oauthHost", "baseUrl"], {
- userAgent: "string",
- oauthHost: "string",
- baseUrl: "string",
- });
- if (kimi) out.kimi = kimi;
-
- const cursor = validateStringSection("cursor", ["baseUrl", "clientVersion", "agentBundle"], {
- baseUrl: "string",
- clientVersion: "string",
- agentBundle: "string",
- });
- if (cursor) out.cursor = cursor;
-
- const log = validateStringSection("log", ["stderr", "verbose"], {
- stderr: "boolean",
- verbose: "boolean",
- });
- if (log) out.log = log;
-
- return out;
-}
-
-export function loadConfig(opts: LoadOptions = {}): LoadedConfig {
- if (cached && !opts.forceReload && !opts.configPath && !opts.env) {
- return cached;
- }
- const env = opts.env ?? process.env;
- const path = opts.configPath ?? configPath();
- let file: FileConfig = {};
- try {
- const raw = readFileSync(path, "utf8");
- try {
- file = validate(JSON.parse(raw));
- } catch (err) {
- process.stderr.write(
- `claude-code-proxy: failed to parse ${path} (${(err as Error).message}); using defaults\n`,
- );
- }
- } catch (err: unknown) {
- if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
- process.stderr.write(
- `claude-code-proxy: failed to read ${path} (${(err as Error).message}); using defaults\n`,
- );
- }
- }
- const result: LoadedConfig = { file, env };
- // Always update the cache when forceReload is requested (lets tests
- // install a custom env+path under the same singleton other modules read).
- if (opts.forceReload || (!opts.configPath && !opts.env)) cached = result;
- return result;
-}
-
-export function getConfig(): LoadedConfig {
- return cached ?? loadConfig();
-}
-
-// Per-setting getters. Each encodes its precedence chain explicitly.
-
-// Preserves legacy `Number(process.env.PORT ?? 18765)` semantics: an env-set
-// PORT of empty string parsed to NaN under the old code (effectively broken),
-// so we treat it as unset rather than returning NaN.
-export function port(): number {
- const c = getConfig();
- const envPort = c.env.PORT;
- if (envPort !== undefined && envPort !== "") {
- const n = Number(envPort);
- if (Number.isFinite(n)) return n;
- }
- return c.file.port ?? 18765;
-}
-
-export function codexOriginator(defaultValue: string): string {
- const c = getConfig();
- return (
- c.env.CCP_CODEX_ORIGINATOR ?? c.env.CCP_ORIGINATOR ?? c.file.codex?.originator ?? defaultValue
- );
-}
-
-export function codexUserAgent(defaultValue: string): string {
- const c = getConfig();
- return (
- c.env.CCP_CODEX_USER_AGENT ?? c.env.CCP_USER_AGENT ?? c.file.codex?.userAgent ?? defaultValue
- );
-}
-
-// Returns undefined when neither env nor file specifies a value. Empty
-// string in env is intentionally treated as "unset" (preserves the
-// long-standing CCP_CODEX_MODEL escape hatch).
-export function codexModel(): string | undefined {
- const c = getConfig();
- return emptyOrUnset(c.env.CCP_CODEX_MODEL) ?? emptyOrUnset(c.file.codex?.model);
-}
-
-export function codexEffort(): string | undefined {
- const c = getConfig();
- return emptyOrUnset(c.env.CCP_CODEX_EFFORT) ?? emptyOrUnset(c.file.codex?.effort);
-}
-
-export function codexServiceTier(): string | undefined {
- 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;
-}
-
-export function codexTransport(): CodexTransport {
- return resolvedCodexTransport(getConfig());
-}
-
-export function codexPreviousResponseId(): boolean {
- return resolvedCodexPreviousResponseId(getConfig());
-}
-
-export function aliasProvider(): AliasProvider {
- return resolvedAliasProvider(getConfig());
-}
-
-export function kimiUserAgent(defaultValue: string): string {
- const c = getConfig();
- return (
- c.env.CCP_KIMI_USER_AGENT ?? c.env.CCP_USER_AGENT ?? c.file.kimi?.userAgent ?? defaultValue
- );
-}
-
-export function kimiOauthHost(): string {
- const c = getConfig();
- return c.env.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";
-}
-
-export function cursorBaseUrl(): string {
- const c = getConfig();
- return c.env.CCP_CURSOR_BASE_URL ?? c.file.cursor?.baseUrl ?? "https://api2.cursor.sh";
-}
-
-export function cursorClientVersion(): string {
- const c = getConfig();
- return c.env.CCP_CURSOR_CLIENT_VERSION ?? c.file.cursor?.clientVersion ?? "cli-2026.06.04-5fd875e";
-}
-
-function resolvedCodexTransport(c: LoadedConfig): CodexTransport {
- return (
- parseCodexTransport("CCP_CODEX_TRANSPORT", emptyOrUnset(c.env.CCP_CODEX_TRANSPORT)) ??
- c.file.codex?.transport ??
- "websocket"
- );
-}
-
-function resolvedCodexPreviousResponseId(c: LoadedConfig): boolean {
- return (
- parseBooleanEnv(c.env.CCP_CODEX_PREVIOUS_RESPONSE_ID) ??
- c.file.codex?.previousResponseId ??
- false
- );
-}
-
-function resolvedAliasProvider(c: LoadedConfig): AliasProvider {
- return (
- parseAliasProvider("CCP_ALIAS_PROVIDER", emptyOrUnset(c.env.CCP_ALIAS_PROVIDER)) ??
- c.file.aliasProvider ??
- "codex"
- );
-}
-
-function resolvedCursorBaseUrl(c: LoadedConfig): string {
- return c.env.CCP_CURSOR_BASE_URL ?? c.file.cursor?.baseUrl ?? "https://api2.cursor.sh";
-}
-
-function resolvedCursorClientVersion(c: LoadedConfig): string {
- return c.env.CCP_CURSOR_CLIENT_VERSION ?? c.file.cursor?.clientVersion ?? "cli-2026.06.04-5fd875e";
-}
-
-export function configOverrideSummaryLines(cfg: LoadedConfig = getConfig()): string[] {
- const fromFile = cfg.file;
- const overrides: string[] = [];
-
- 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_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_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_BASE_URL) overrides.push("CCP_CODEX_BASE_URL (env)");
- else if (fromFile.codex?.baseUrl) overrides.push("codex.baseUrl (config)");
-
- if (cfg.env.CCP_CODEX_TRANSPORT)
- overrides.push(`CCP_CODEX_TRANSPORT=${resolvedCodexTransport(cfg)} (env)`);
- else if (fromFile.codex?.transport)
- overrides.push(`codex.transport=${fromFile.codex.transport} (config)`);
-
- if (cfg.env.CCP_CODEX_PREVIOUS_RESPONSE_ID !== undefined)
- overrides.push(`CCP_CODEX_PREVIOUS_RESPONSE_ID=${resolvedCodexPreviousResponseId(cfg)} (env)`);
- else if (fromFile.codex?.previousResponseId !== undefined)
- overrides.push(`codex.previousResponseId=${fromFile.codex.previousResponseId} (config)`);
-
- if (cfg.env.CCP_ALIAS_PROVIDER) overrides.push(`CCP_ALIAS_PROVIDER=${resolvedAliasProvider(cfg)} (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_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_BASE_URL) overrides.push("CCP_KIMI_BASE_URL (env)");
- else if (fromFile.kimi?.baseUrl) overrides.push("kimi.baseUrl (config)");
-
- if (cfg.env.CCP_CURSOR_BASE_URL)
- overrides.push(`CCP_CURSOR_BASE_URL=${resolvedCursorBaseUrl(cfg)} (env)`);
- else if (fromFile.cursor?.baseUrl) overrides.push("cursor.baseUrl (config)");
-
- if (cfg.env.CCP_CURSOR_CLIENT_VERSION)
- overrides.push(`CCP_CURSOR_CLIENT_VERSION=${resolvedCursorClientVersion(cfg)} (env)`);
- else if (fromFile.cursor?.clientVersion) overrides.push("cursor.clientVersion (config)");
-
- if (cfg.env.CCP_CURSOR_AGENT_BUNDLE) overrides.push("CCP_CURSOR_AGENT_BUNDLE (env)");
- else if (fromFile.cursor?.agentBundle) overrides.push("cursor.agentBundle (config)");
-
- return overrides;
-}
-
-export function cursorAgentBundle(): string | undefined {
- const c = getConfig();
- return emptyOrUnset(c.env.CCP_CURSOR_AGENT_BUNDLE) ?? emptyOrUnset(c.file.cursor?.agentBundle);
-}
-
-// Additive: error/warn always go to stderr in log.ts; this getter only
-// controls whether *all* levels are also mirrored to stderr. Matches the
-// pre-existing `!!process.env.CCP_LOG_STDERR` semantics where any value
-// (including the empty string) enables it.
-export function logStderr(): boolean {
- const c = getConfig();
- if (c.env.CCP_LOG_STDERR !== undefined) return true;
- return c.file.log?.stderr ?? false;
-}
-
-export function logVerbose(): boolean {
- const c = getConfig();
- if (c.env.CCP_LOG_VERBOSE !== undefined) return true;
- return c.file.log?.verbose ?? false;
-}
diff --git a/reference/typescript/src/keychain.ts b/reference/typescript/src/keychain.ts
deleted file mode 100644
index 2c3d44e..0000000
--- a/reference/typescript/src/keychain.ts
+++ /dev/null
@@ -1,173 +0,0 @@
-import { dlopen, FFIType, ptr, toArrayBuffer, type Pointer } from "bun:ffi";
-
-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;
-}
-
-let _sym: ReturnType<typeof loadLib>["symbols"] | undefined;
-
-function 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,
- ],
- returns: FFIType.i32,
- },
- SecKeychainFindGenericPassword: {
- args: [
- FFIType.ptr,
- FFIType.u32,
- FFIType.ptr,
- FFIType.u32,
- FFIType.ptr,
- FFIType.ptr,
- FFIType.ptr,
- FFIType.ptr,
- ],
- returns: FFIType.i32,
- },
- SecKeychainItemModifyAttributesAndData: {
- args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr],
- returns: FFIType.i32,
- },
- SecKeychainItemFreeContent: {
- args: [FFIType.ptr, FFIType.ptr],
- returns: FFIType.i32,
- },
- SecKeychainItemDelete: {
- args: [FFIType.ptr],
- returns: FFIType.i32,
- },
- CFRelease: {
- args: [FFIType.ptr],
- returns: FFIType.void,
- },
- } 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 s = sym().SecKeychainFindGenericPassword(
- null,
- svc.byteLength,
- ptr(svc),
- acc.byteLength,
- ptr(acc),
- ptr(lenBuf),
- ptr(dataBuf),
- null,
- ) as number;
-
- 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;
-}
-
-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);
-
- let s = sym().SecKeychainAddGenericPassword(
- null,
- svc.byteLength,
- ptr(svc),
- acc.byteLength,
- ptr(acc),
- pwd.byteLength,
- ptr(pwd),
- ptr(itemBuf),
- ) as number;
-
- if (s === errSecSuccess) {
- const ref = readPtr(itemBuf);
- if (ref) sym().CFRelease(ref);
- return;
- }
-
- if (s !== errSecDuplicateItem) throw keychainError("add", s);
-
- // Item exists — find it and update in place
- const itemBuf2 = new Uint8Array(8);
- s = sym().SecKeychainFindGenericPassword(
- null,
- svc.byteLength,
- ptr(svc),
- acc.byteLength,
- ptr(acc),
- null,
- null,
- ptr(itemBuf2),
- ) 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);
-}
-
-export function keychainDelete(service: string, account: string): void {
- 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,
- ptr(itemBuf),
- ) as number;
-
- 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);
-}
-
-function keychainError(op: string, code: number): Error {
- const err = new Error(`Keychain ${op} failed: ${code}`) as Error & { code: number };
- err.code = code;
- return err;
-}
diff --git a/reference/typescript/src/log.ts b/reference/typescript/src/log.ts
deleted file mode 100644
index cc5b060..0000000
--- a/reference/typescript/src/log.ts
+++ /dev/null
@@ -1,127 +0,0 @@
-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
-export const REDACT_KEYS = new Set([
- "authorization",
- "access",
- "access_token",
- "refresh",
- "refresh_token",
- "id_token",
- "code",
- "code_verifier",
- "chatgpt-account-id",
- "cookie",
- "set-cookie",
- "x-api-key",
-]);
-
-export { logFile };
-
-export function logDir(): string {
- return dirname(logFile());
-}
-
-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;
-}
-
-async function maybeRotate(): Promise<void> {
- 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);
- if (stream) {
- stream.end();
- stream = undefined;
- }
- } catch {
- // Never propagate rotation errors — logging must never crash the proxy.
- } finally {
- rotating = undefined;
- }
- })();
- return rotating;
-}
-
-function redact(value: unknown, depth = 0): unknown {
- 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 (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]";
- } else {
- out[k] = redact(v, depth + 1);
- }
- }
- return out;
-}
-
-type Level = "debug" | "info" | "warn" | "error";
-
-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(() => {});
- } catch {
- // swallow; also print to stderr for visibility
- }
- if (level === "error" || level === "warn" || logStderr()) {
- 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;
-}
-
-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/reference/typescript/src/paths.test.ts b/reference/typescript/src/paths.test.ts
deleted file mode 100644
index 52fcc63..0000000
--- a/reference/typescript/src/paths.test.ts
+++ /dev/null
@@ -1,120 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
- codexAuthFile,
- cursorAuthFile,
- kimiAuthFile,
- kimiDeviceIdFile,
- legacyConfigDir,
- resolveConfigDir,
- resolveStateDir,
-} from "./paths.ts";
-
-describe("resolveConfigDir", () => {
- it("uses CCP_CONFIG_DIR when set", () => {
- expect(
- resolveConfigDir({ platform: "darwin", env: { CCP_CONFIG_DIR: "/tmp/ccp-a" }, home: "/home/u" }),
- ).toBe("/tmp/ccp-a");
- });
-
- it("uses ~/.config on darwin even when XDG_CONFIG_HOME is set", () => {
- expect(
- resolveConfigDir({ platform: "darwin", env: { XDG_CONFIG_HOME: "/x" }, home: "/home/u" }),
- ).toBe("/home/u/.config/claude-code-proxy");
- });
-
- it("honors XDG_CONFIG_HOME on linux", () => {
- expect(
- resolveConfigDir({ platform: "linux", env: { XDG_CONFIG_HOME: "/x" }, home: "/home/u" }),
- ).toBe("/x/claude-code-proxy");
- });
-
- it("falls back to $HOME/.config on linux without XDG_CONFIG_HOME", () => {
- expect(resolveConfigDir({ platform: "linux", env: {}, home: "/home/u" })).toBe(
- "/home/u/.config/claude-code-proxy",
- );
- });
-
- it("uses APPDATA on windows", () => {
- expect(
- resolveConfigDir({
- platform: "win32",
- env: { APPDATA: "C:\\Users\\u\\AppData\\Roaming" },
- home: "C:\\Users\\u",
- }),
- ).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");
- });
-
- 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");
- });
-
- it("uses LOCALAPPDATA on windows", () => {
- expect(
- resolveStateDir({
- platform: "win32",
- env: { LOCALAPPDATA: "C:\\Users\\u\\AppData\\Local" },
- home: "C:\\Users\\u",
- }),
- ).toBe("C:\\Users\\u\\AppData\\Local\\claude-code-proxy");
- });
-
- it("falls back to $HOME/AppData/Local on windows without LOCALAPPDATA", () => {
- expect(
- resolveStateDir({
- platform: "win32",
- env: { APPDATA: "C:\\Users\\u\\AppData\\Roaming" },
- home: "C:\\Users\\u",
- }),
- ).toBe("C:\\Users\\u\\AppData\\Local\\claude-code-proxy");
- });
-});
-
-describe("provider paths", () => {
- it("resolves provider files under the windows config directory", () => {
- const deps = {
- 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(cursorAuthFile(deps)).toBe(
- "C:\\Users\\u\\AppData\\Roaming\\claude-code-proxy\\cursor\\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/reference/typescript/src/paths.ts b/reference/typescript/src/paths.ts
deleted file mode 100644
index 89fdf7b..0000000
--- a/reference/typescript/src/paths.ts
+++ /dev/null
@@ -1,93 +0,0 @@
-import { homedir } from "node:os";
-import { posix, win32 } from "node:path";
-
-export interface DirResolverEnv {
- platform: NodeJS.Platform;
- env: NodeJS.ProcessEnv;
- home: string;
-}
-
-function explicitConfigDir(deps: DirResolverEnv): string | undefined {
- return deps.env.CCP_CONFIG_DIR;
-}
-
-function defaults(): DirResolverEnv {
- return { platform: process.platform, env: process.env, home: homedir() };
-}
-
-function pathFor(platform: NodeJS.Platform) {
- return platform === "win32" ? win32 : posix;
-}
-
-function windowsRoamingAppData(deps: DirResolverEnv): string {
- 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");
-}
-
-// 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 override = explicitConfigDir(deps);
- if (override) return override;
-
- const path = pathFor(deps.platform);
- if (deps.platform === "win32") {
- return path.join(windowsRoamingAppData(deps), "claude-code-proxy");
- }
- if (deps.platform === "darwin") {
- 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");
-}
-
-// 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);
- if (deps.platform === "win32") {
- 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");
-}
-
-// Legacy (pre-config.json) auth/device-id path. Always ~/.config regardless
-// of XDG_CONFIG_HOME — this is the directory token stores hardcoded before
-// configDir() existed. Used as a read-only fallback so existing logins keep
-// working after upgrade.
-export function legacyConfigDir(deps: DirResolverEnv = defaults()): string {
- return 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");
-}
-
-export function kimiAuthFile(deps: DirResolverEnv = defaults()): string {
- return pathFor(deps.platform).join(resolveConfigDir(deps), "kimi", "auth.json");
-}
-
-export function cursorAuthFile(deps: DirResolverEnv = defaults()): string {
- return pathFor(deps.platform).join(resolveConfigDir(deps), "cursor", "auth.json");
-}
-
-export function kimiDeviceIdFile(deps: DirResolverEnv = defaults()): string {
- 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");
-}
-
-export function configDir(): string {
- return resolveConfigDir(defaults());
-}
-
-export function stateDir(): string {
- return resolveStateDir(defaults());
-}
diff --git a/reference/typescript/src/providers/codex/auth/constants.ts b/reference/typescript/src/providers/codex/auth/constants.ts
deleted file mode 100644
index bb19913..0000000
--- a/reference/typescript/src/providers/codex/auth/constants.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-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/reference/typescript/src/providers/codex/auth/device.ts b/reference/typescript/src/providers/codex/auth/device.ts
deleted file mode 100644
index bf099b7..0000000
--- a/reference/typescript/src/providers/codex/auth/device.ts
+++ /dev/null
@@ -1,52 +0,0 @@
-import { CLIENT_ID, ISSUER } from "./constants.ts";
-import type { TokenResponse } from "./jwt.ts";
-
-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}`);
- 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;
-
- console.log(`\nVisit: ${ISSUER}/codex/device\nEnter code: ${data.user_code}\n`);
-
- while (true) {
- const resp = await fetch(`${ISSUER}/api/accounts/deviceauth/token`, {
- method: "POST",
- headers: { "Content-Type": "application/json" },
- body: JSON.stringify({
- 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 tokenResp = await fetch(`${ISSUER}/oauth/token`, {
- method: "POST",
- headers: { "Content-Type": "application/x-www-form-urlencoded" },
- body: new URLSearchParams({
- grant_type: "authorization_code",
- code: body.authorization_code,
- redirect_uri: `${ISSUER}/deviceauth/callback`,
- 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 (resp.status !== 403 && resp.status !== 404) {
- throw new Error(`Device poll failed: ${resp.status}`);
- }
- await new Promise((r) => setTimeout(r, intervalMs + POLL_SAFETY_MARGIN_MS));
- }
-}
diff --git a/reference/typescript/src/providers/codex/auth/jwt.ts b/reference/typescript/src/providers/codex/auth/jwt.ts
deleted file mode 100644
index 851720e..0000000
--- a/reference/typescript/src/providers/codex/auth/jwt.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-export interface IdTokenClaims {
- 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;
-}
-
-export function parseJwtClaims(token: string): IdTokenClaims | undefined {
- const parts = token.split(".");
- if (parts.length !== 3) return undefined;
- try {
- return JSON.parse(Buffer.from(parts[1]!, "base64url").toString());
- } catch {
- return undefined;
- }
-}
-
-export function extractAccountIdFromClaims(claims: IdTokenClaims): string | undefined {
- return (
- claims.chatgpt_account_id ||
- 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;
-}
-
-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;
- }
- if (tokens.access_token) {
- const claims = parseJwtClaims(tokens.access_token);
- return claims ? extractAccountIdFromClaims(claims) : undefined;
- }
- return undefined;
-}
diff --git a/reference/typescript/src/providers/codex/auth/manager.ts b/reference/typescript/src/providers/codex/auth/manager.ts
deleted file mode 100644
index 82c7b0f..0000000
--- a/reference/typescript/src/providers/codex/auth/manager.ts
+++ /dev/null
@@ -1,54 +0,0 @@
-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 { createAuthLifecycle, validateTokenResponse } from "../../shared/auth/manager.ts";
-
-const lifecycle = createAuthLifecycle<StoredAuth>({
- loadAuth,
- loginRequiredMessage: "Not authenticated. Run: claude-code-proxy codex auth login",
- forceRefreshUnauthenticatedMessage: "Not authenticated",
- refreshMarginMs: REFRESH_MARGIN_MS,
- refreshNow,
-});
-
-export const getAuth = lifecycle.getAuth;
-export const forceRefresh = lifecycle.forceRefresh;
-export const resetCache = lifecycle.resetCache;
-
-async function refreshNow(current: StoredAuth): Promise<StoredAuth> {
- const resp = await fetch(`${ISSUER}/oauth/token`, {
- method: "POST",
- headers: { "Content-Type": "application/x-www-form-urlencoded" },
- body: new URLSearchParams({
- grant_type: "refresh_token",
- 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;
- 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);
- lifecycle.setCached(next);
- return next;
-}
-
-export async function persistInitialTokens(tokens: TokenResponse): Promise<StoredAuth> {
- 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);
- lifecycle.setCached(auth);
- return auth;
-}
diff --git a/reference/typescript/src/providers/codex/auth/pkce.ts b/reference/typescript/src/providers/codex/auth/pkce.ts
deleted file mode 100644
index 2ff5ed7..0000000
--- a/reference/typescript/src/providers/codex/auth/pkce.ts
+++ /dev/null
@@ -1,117 +0,0 @@
-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;
-}
-
-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) };
-}
-
-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(/=+$/, "");
-}
-
-export function generateState(): string {
- return base64UrlEncode(crypto.getRandomValues(new Uint8Array(32)).buffer);
-}
-
-export function buildAuthorizeUrl(pkce: PkceCodes, state: string): string {
- const params = new URLSearchParams({
- response_type: "code",
- client_id: CLIENT_ID,
- redirect_uri: OAUTH_REDIRECT_URI,
- scope: "openid profile email offline_access",
- code_challenge: pkce.challenge,
- code_challenge_method: "S256",
- id_token_add_organizations: "true",
- codex_cli_simplified_flow: "true",
- state,
- originator: ORIGINATOR,
- });
- return `${ISSUER}/oauth/authorize?${params.toString()}`;
-}
-
-export async function exchangeCodeForTokens(code: string, pkce: PkceCodes): Promise<TokenResponse> {
- const response = await fetch(`${ISSUER}/oauth/token`, {
- method: "POST",
- headers: { "Content-Type": "application/x-www-form-urlencoded" },
- body: new URLSearchParams({
- grant_type: "authorization_code",
- code,
- redirect_uri: OAUTH_REDIRECT_URI,
- 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;
-}
-
-export async function runBrowserLogin(): Promise<TokenResponse> {
- 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?.();
- };
- const server = createServer((req, res) => {
- const url = new URL(req.url || "/", `http://localhost:${OAUTH_PORT}`);
- if (url.pathname !== "/auth/callback") {
- 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");
- 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;
- }
- exchangeCodeForTokens(code, pkce)
- .then((tokens) => {
- 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);
- })
- .catch((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);
- const timeout = setTimeout(
- () => {
- cleanup();
- reject(new Error("OAuth timeout"));
- },
- 5 * 60 * 1000,
- );
- });
-}
diff --git a/reference/typescript/src/providers/codex/auth/token-store.ts b/reference/typescript/src/providers/codex/auth/token-store.ts
deleted file mode 100644
index 07beb26..0000000
--- a/reference/typescript/src/providers/codex/auth/token-store.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-import { join } from "node:path";
-import { codexAuthFile, legacyConfigDir } from "../../../paths.ts";
-import { createAuthStore } from "../../shared/auth/token-store.ts";
-
-export interface StoredAuth {
- access: string;
- refresh: string;
- expires: number;
- accountId?: string;
-}
-
-const store = createAuthStore<StoredAuth>({
- file: codexAuthFile,
- legacyFile: () => join(legacyConfigDir(), "codex", "auth.json"),
- keychainService: "claude-code-proxy.codex",
-});
-
-export const loadAuth = store.loadAuth;
-export const saveAuth = store.saveAuth;
-export const clearAuth = store.clearAuth;
-export const authPath = store.authPath;
diff --git a/reference/typescript/src/providers/codex/cli.ts b/reference/typescript/src/providers/codex/cli.ts
deleted file mode 100644
index 5107c6d..0000000
--- a/reference/typescript/src/providers/codex/cli.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-import type { CliHandlers } from "../types.ts";
-import { runDeviceLogin } from "./auth/device.ts";
-import { persistInitialTokens } from "./auth/manager.ts";
-import { runBrowserLogin } from "./auth/pkce.ts";
-import { authPath, clearAuth, loadAuth } from "./auth/token-store.ts";
-import { printAuthStatus } from "../shared/cli-status.ts";
-
-export const codexCli: CliHandlers = {
- async login() {
- const tokens = await runBrowserLogin();
- const saved = await persistInitialTokens(tokens);
- console.log(`Auth saved in ${authPath()}`);
- if (saved.accountId) console.log(`Account: ${saved.accountId}`);
- },
- async device() {
- const tokens = await runDeviceLogin();
- const saved = await persistInitialTokens(tokens);
- console.log(`Auth saved in ${authPath()}`);
- if (saved.accountId) console.log(`Account: ${saved.accountId}`);
- },
- async status() {
- await printAuthStatus({
- loadAuth,
- authPath,
- formatIdentityLine: (auth) => `Account: ${auth.accountId ?? "(none)"}`,
- });
- },
- async logout() {
- await clearAuth();
- console.log("Logged out");
- },
-};
diff --git a/reference/typescript/src/providers/codex/client.test.ts b/reference/typescript/src/providers/codex/client.test.ts
deleted file mode 100644
index ce789e3..0000000
--- a/reference/typescript/src/providers/codex/client.test.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import {
- CodexHeaderTimeoutError,
- CodexTransportError,
- isRetryableCodexTransportError,
- setCodexHeaderTimeoutForTests,
-} from "./client.ts";
-
-const originalFetch = globalThis.fetch;
-
-afterEach(() => {
- globalThis.fetch = originalFetch;
- setCodexHeaderTimeoutForTests(60_000, 1);
-});
-
-describe("CodexHeaderTimeoutError", () => {
- it("identifies header wait timeouts", () => {
- const err = new CodexHeaderTimeoutError(123);
-
- expect(err.name).toBe("CodexHeaderTimeoutError");
- expect(err.message).toContain("123ms");
- });
-});
-
-describe("CodexTransportError", () => {
- it("classifies Bun socket-close fetch failures as retryable transport errors", () => {
- const err = new TypeError(
- "The socket connection was closed unexpectedly. For more information, pass `verbose: true` in the second argument to fetch()",
- );
-
- expect(isRetryableCodexTransportError(err)).toBe(true);
- expect(new CodexTransportError(err).message).toContain(
- "socket connection was closed unexpectedly",
- );
- });
-
- it("classifies Codex API operation timeouts as retryable transport errors", () => {
- const err = new TypeError("API Error: The operation timed out.");
-
- expect(isRetryableCodexTransportError(err)).toBe(true);
- expect(new CodexTransportError(err).message).toContain("operation timed out");
- });
-
- it("does not retry abort errors as transport failures", () => {
- expect(isRetryableCodexTransportError(new DOMException("Aborted", "AbortError"))).toBe(false);
- });
-});
diff --git a/reference/typescript/src/providers/codex/client.ts b/reference/typescript/src/providers/codex/client.ts
deleted file mode 100644
index c14de2e..0000000
--- a/reference/typescript/src/providers/codex/client.ts
+++ /dev/null
@@ -1,506 +0,0 @@
-import { CODEX_API_ENDPOINT, ORIGINATOR as ORIGINATOR_DEFAULT } from "./auth/constants.ts";
-import {
- codexBaseUrl,
- codexOriginator,
- codexPreviousResponseId,
- codexTransport,
- 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 { toWebSocketRequest, type ResponsesRequest } from "./translate/request.ts";
-import { computeBackoffDelay, retryOn429, sleep } from "../retry.ts";
-import { headersToRecord } from "../../traffic.ts";
-import { summarizeCodexRequestSize } from "./request-summary.ts";
-import {
- CodexWebSocketSetupError,
- codexWebSocketHeaders,
- codexWebSocketRequest,
- invalidateCodexWebSocketPoolKey,
- isPreviousResponseMissingError,
-} from "./websocket.ts";
-import { clearContinuation, type ContinuationCandidate } from "./continuation.ts";
-
-const FETCH_WATCHDOG_INTERVAL_MS = 30_000;
-const MAX_TRANSPORT_RETRIES = 10;
-let fetchHeaderTimeoutMs = 60_000;
-let fetchHeaderTimeoutRetries = 1;
-
-export function setCodexHeaderTimeoutForTests(timeoutMs: number, retries: number): void {
- fetchHeaderTimeoutMs = timeoutMs;
- fetchHeaderTimeoutRetries = retries;
-}
-
-export interface CodexResponse {
- body: ReadableStream<Uint8Array>;
- status: number;
- headers: Headers;
-}
-
-export interface PostCodexOptions {
- continuation?: ContinuationCandidate;
- poolKey?: string;
-}
-
-export async function postCodex(
- body: ResponsesRequest,
- ctx: RequestContext,
- opts: PostCodexOptions = {},
-): Promise<CodexResponse> {
- const log = ctx.childLogger("codex.client");
- return retryTransientPostFailures(
- () =>
- retryOn429(() => attemptPostCodex(body, ctx, log, opts), {
- log,
- signal: ctx.signal,
- classify: (err) =>
- err instanceof CodexError && err.status === 429
- ? { retryAfter: err.meta?.retryAfter }
- : undefined,
- }),
- log,
- ctx.signal,
- body,
- );
-}
-
-async function retryTransientPostFailures(
- run: () => Promise<CodexResponse>,
- log: Logger,
- signal: AbortSignal | undefined,
- body: ResponsesRequest,
-): Promise<CodexResponse> {
- for (let attempt = 0; ; attempt++) {
- try {
- return await run();
- } catch (err) {
- const retryInfo = codexPostRetryInfo(err);
- if (!retryInfo || attempt >= retryInfo.maxRetries) throw err;
- const waitMs =
- err instanceof CodexHeaderTimeoutError
- ? fetchHeaderTimeoutMs <= 10
- ? 0
- : 500 + Math.round(Math.random() * 1000)
- : computeBackoffDelay(attempt).waitMs;
- log.warn(retryInfo.message, {
- reason: retryInfo.reason,
- attempt: attempt + 1,
- maxRetries: retryInfo.maxRetries,
- waitMs,
- err: describeError(err),
- timeoutMs: err instanceof CodexHeaderTimeoutError ? fetchHeaderTimeoutMs : undefined,
- model: body.model,
- inputCount: body.input.length,
- toolCount: body.tools?.length ?? 0,
- requestSize: summarizeCodexRequestSize(body),
- });
- await sleep(waitMs, signal);
- }
- }
-}
-
-function codexPostRetryInfo(
- err: unknown,
-): { reason: "header_timeout" | "transport"; maxRetries: number; message: string } | undefined {
- if (err instanceof CodexHeaderTimeoutError) {
- return {
- reason: "header_timeout",
- maxRetries: fetchHeaderTimeoutRetries,
- message: "codex response headers timed out, retrying",
- };
- }
- if (err instanceof CodexTransportError) {
- return {
- reason: "transport",
- maxRetries: MAX_TRANSPORT_RETRIES,
- message: "codex transport error before response, retrying",
- };
- }
- return undefined;
-}
-
-async function attemptPostCodex(
- body: ResponsesRequest,
- ctx: RequestContext,
- log: Logger,
- opts: PostCodexOptions,
-): Promise<CodexResponse> {
- let auth = await getAuth();
- let resp: Response;
- try {
- resp = await doFetch(auth.access, auth.accountId, body, ctx, log, opts);
- } catch (err) {
- if (!(err instanceof CodexWebSocketSetupError)) throw err;
- if (err.status === 429) {
- throw new CodexError(429, "Rate limited", err.message, { retryAfter: err.retryAfter });
- }
- if (err.requestSent) throw err;
- if (err.status !== 401 && err.status !== 403) throw err;
- log.warn("codex websocket auth failed, refreshing token", { status: err.status });
- auth = await forceRefresh();
- resp = await doFetch(auth.access, auth.accountId, body, ctx, log, opts);
- }
-
- if (resp.status === 401) {
- log.warn("got 401, refreshing token", {});
- try {
- auth = await forceRefresh();
- resp = await doFetch(auth.access, auth.accountId, body, ctx, log, opts);
- } catch (err) {
- log.error("refresh after 401 failed", { err: String(err) });
- }
- }
-
- if (resp.status === 403) {
- const text = await safeText(resp);
- ctx.traffic?.writeText("031-upstream-error-body", text);
- 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);
- ctx.traffic?.writeText("031-upstream-error-body", text);
- throw new CodexError(429, "Rate limited", text, { retryAfter });
- }
-
- if (!resp.ok) {
- const text = await safeText(resp);
- ctx.traffic?.writeText("031-upstream-error-body", text);
- throw new CodexError(resp.status, "Upstream error", text);
- }
-
- if (!resp.body) throw new CodexError(500, "Upstream returned no body");
-
- return { body: resp.body, status: resp.status, headers: resp.headers };
-}
-
-async function doFetch(
- accessToken: string,
- accountId: string | undefined,
- body: ResponsesRequest,
- ctx: RequestContext,
- log: Logger,
- opts: PostCodexOptions,
-): Promise<Response> {
- const mode = codexTransport();
- const continuationEnabled = codexPreviousResponseId();
- const poolKey = continuationEnabled ? ctx.sessionId : undefined;
- if (shouldResetWebSocketPool(opts.continuation)) invalidateCodexWebSocketPoolKey(poolKey);
- const websocketOpts = {
- ...opts,
- poolKey,
- };
- if (mode === "websocket") {
- return doFetchWebSocket(accessToken, accountId, body, ctx, log, websocketOpts);
- }
- if (mode === "auto") {
- try {
- return await doFetchWebSocket(accessToken, accountId, body, ctx, log, websocketOpts);
- } catch (err) {
- if (err instanceof CodexWebSocketSetupError && err.requestSent) throw err;
- log.warn("codex websocket failed before response, falling back to http", {
- err: String(err),
- });
- }
- }
- return doFetchHttp(accessToken, accountId, body, ctx, log);
-}
-
-function codexHeaders(
- accessToken: string,
- accountId: string | undefined,
- ctx: RequestContext,
-): Headers {
- const headers = new Headers({
- "Content-Type": "application/json",
- accept: "text/event-stream",
- 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);
- if (ctx.sessionId) {
- headers.set("session_id", ctx.sessionId);
- headers.set("x-client-request-id", ctx.sessionId);
- headers.set("x-codex-window-id", `${ctx.sessionId}:0`);
- }
- return headers;
-}
-
-async function doFetchWebSocket(
- accessToken: string,
- accountId: string | undefined,
- body: ResponsesRequest,
- ctx: RequestContext,
- log: Logger,
- opts: PostCodexOptions,
-): Promise<Response> {
- const headers = codexHeaders(accessToken, accountId, ctx);
- const requestHeaders = codexWebSocketHeaders(headers);
- const codexUrl = codexBaseUrl(CODEX_API_ENDPOINT);
- const continuation = opts.continuation;
- const wsBody = toWebSocketRequest(body, {
- previousResponseId: continuation?.previousResponseId,
- input: continuation?.inputDelta,
- });
- const bodyJson = JSON.stringify(wsBody);
- const size = summarizeCodexRequestSize(wsBody, bodyJson);
- ctx.traffic?.writeJson("020-upstream-request", wsBody);
- ctx.traffic?.writeJson("021-upstream-request-metadata", {
- provider: "codex",
- transport: "websocket",
- url: codexUrl,
- method: "GET",
- headers: requestHeaders,
- size,
- continuation: {
- previousResponseId: continuation?.previousResponseId,
- inputDeltaCount: continuation?.inputDeltaCount ?? body.input.length,
- disabledReason: continuation?.disabledReason,
- },
- });
- log.debug("posting to codex websocket", {
- url: codexUrl,
- model: body.model,
- inputCount: wsBody.input.length,
- toolCount: body.tools?.length ?? 0,
- serviceTier: body.service_tier,
- reasoningEffort: body.reasoning?.effort,
- promptCacheKey: body.prompt_cache_key,
- continuation: {
- previousResponseId: continuation?.previousResponseId,
- inputDeltaCount: continuation?.inputDeltaCount,
- disabledReason: continuation?.disabledReason,
- },
- size,
- });
- const startedAt = Date.now();
- let stream: ReadableStream<Uint8Array>;
- try {
- stream = await codexWebSocketRequest({
- url: codexUrl,
- headers,
- body: wsBody,
- ctx,
- connectTimeoutMs: 15_000,
- idleTimeoutMs: 300_000,
- poolKey: opts.poolKey,
- });
- } catch (err) {
- if (!isSafeFullWebSocketRetry(err, continuation)) throw err;
- clearContinuation(ctx.sessionId);
- invalidateCodexWebSocketPoolKey(opts.poolKey);
- log.warn("codex previous response missing, retrying full websocket request", {
- previousResponseId: continuation?.previousResponseId,
- });
- stream = await codexWebSocketRequest({
- url: codexUrl,
- headers,
- body: toWebSocketRequest(body),
- ctx,
- connectTimeoutMs: 15_000,
- idleTimeoutMs: 300_000,
- poolKey: opts.poolKey,
- });
- }
- const elapsedMs = Date.now() - startedAt;
- const responseHeaders = new Headers({ "content-type": "text/event-stream" });
- ctx.traffic?.writeJson("030-upstream-response-headers", {
- status: 200,
- statusText: "OK",
- elapsedMs,
- headers: headersToRecord(responseHeaders),
- });
- return new Response(stream, { status: 200, headers: responseHeaders });
-}
-
-async function doFetchHttp(
- accessToken: string,
- accountId: string | undefined,
- body: ResponsesRequest,
- ctx: RequestContext,
- log: Logger,
-): Promise<Response> {
- const headers = codexHeaders(accessToken, accountId, ctx);
- const codexUrl = codexBaseUrl(CODEX_API_ENDPOINT);
-
- const bodyJson = JSON.stringify(body);
- const size = summarizeCodexRequestSize(body, bodyJson);
- ctx.traffic?.writeJson("020-upstream-request", body);
- ctx.traffic?.writeJson("021-upstream-request-metadata", {
- provider: "codex",
- transport: "http",
- url: codexUrl,
- method: "POST",
- headers: headersToRecord(headers),
- size,
- });
-
- log.debug("posting to codex", {
- url: codexUrl,
- model: body.model,
- inputCount: body.input.length,
- toolCount: body.tools?.length ?? 0,
- serviceTier: body.service_tier,
- reasoningEffort: body.reasoning?.effort,
- promptCacheKey: body.prompt_cache_key,
- size,
- });
-
- const startedAt = Date.now();
- const watchdog = setInterval(() => {
- log.info("waiting for codex response headers", {
- elapsedMs: Date.now() - startedAt,
- model: body.model,
- inputCount: body.input.length,
- toolCount: body.tools?.length ?? 0,
- });
- }, FETCH_WATCHDOG_INTERVAL_MS);
- const headerTimeout = new AbortController();
- const timeout = setTimeout(() => {
- headerTimeout.abort(new CodexHeaderTimeoutError(fetchHeaderTimeoutMs));
- }, fetchHeaderTimeoutMs);
- const onAbort = () => headerTimeout.abort(ctx.signal.reason);
- ctx.signal.addEventListener("abort", onAbort, { once: true });
- try {
- const resp = await fetch(codexUrl, {
- method: "POST",
- headers,
- body: bodyJson,
- signal: headerTimeout.signal,
- });
- const elapsedMs = Date.now() - startedAt;
- ctx.traffic?.writeJson("030-upstream-response-headers", {
- status: resp.status,
- statusText: resp.statusText,
- elapsedMs,
- headers: headersToRecord(resp.headers),
- });
- log.debug("received codex response headers", {
- status: resp.status,
- elapsedMs,
- });
- return resp;
- } catch (err) {
- if (headerTimeout.signal.reason instanceof CodexHeaderTimeoutError) {
- throw headerTimeout.signal.reason;
- }
- if (!ctx.signal.aborted && isRetryableCodexTransportError(err)) {
- throw new CodexTransportError(err);
- }
- throw err;
- } finally {
- ctx.signal.removeEventListener("abort", onAbort);
- clearTimeout(timeout);
- clearInterval(watchdog);
- }
-}
-
-async function safeText(resp: Response): Promise<string> {
- try {
- return await resp.text();
- } catch {
- return "";
- }
-}
-
-function isSafeFullWebSocketRetry(
- err: unknown,
- continuation: ContinuationCandidate | undefined,
-): boolean {
- if (!continuation?.previousResponseId) return false;
- return isPreviousResponseMissingError(err);
-}
-
-function shouldResetWebSocketPool(continuation: ContinuationCandidate | undefined): boolean {
- if (!continuation?.disabledReason) return false;
- return (
- continuation.disabledReason !== "missing_state" && continuation.disabledReason !== "disabled"
- );
-}
-
-export class CodexHeaderTimeoutError extends Error {
- constructor(public timeoutMs: number) {
- super(`Timed out waiting ${timeoutMs}ms for Codex response headers`);
- this.name = "CodexHeaderTimeoutError";
- }
-}
-
-export class CodexTransportError extends Error {
- constructor(public originalError: unknown) {
- super(errorMessage(originalError));
- this.name = "CodexTransportError";
- }
-}
-
-export class CodexError extends Error {
- constructor(
- public status: number,
- message: string,
- public detail?: string,
- public meta?: { retryAfter?: string },
- ) {
- super(message);
- this.name = "CodexError";
- }
-}
-
-export function isRetryableCodexTransportError(err: unknown): boolean {
- if (isAbortError(err)) return false;
- const text = errorSearchText(err);
- return (
- text.includes("socket connection was closed unexpectedly") ||
- text.includes("connection closed unexpectedly") ||
- text.includes("connection reset") ||
- text.includes("operation timed out") ||
- text.includes("econnreset") ||
- text.includes("epipe") ||
- text.includes("etimedout") ||
- text.includes("und_err_socket") ||
- text.includes("fetch failed")
- );
-}
-
-function isAbortError(err: unknown): boolean {
- return err instanceof Error && err.name === "AbortError";
-}
-
-function errorMessage(err: unknown): string {
- return err instanceof Error ? err.message : String(err);
-}
-
-function errorSearchText(err: unknown): string {
- const parts: string[] = [];
- let current: unknown = err;
- for (let depth = 0; current && depth < 4; depth++) {
- if (current instanceof Error) {
- parts.push(current.name, current.message);
- const code = (current as Error & { code?: unknown }).code;
- if (code !== undefined) parts.push(String(code));
- current = (current as Error & { cause?: unknown }).cause;
- } else {
- parts.push(String(current));
- break;
- }
- }
- return parts.join(" ").toLowerCase();
-}
-
-function describeError(err: unknown): Record<string, unknown> {
- if (!(err instanceof Error)) return { message: String(err) };
- const code = (err as Error & { code?: unknown }).code;
- return {
- name: err.name,
- message: err.message,
- code,
- cause:
- err.cause instanceof Error ? { name: err.cause.name, message: err.cause.message } : err.cause,
- };
-}
diff --git a/reference/typescript/src/providers/codex/continuation.test.ts b/reference/typescript/src/providers/codex/continuation.test.ts
deleted file mode 100644
index 0610bde..0000000
--- a/reference/typescript/src/providers/codex/continuation.test.ts
+++ /dev/null
@@ -1,176 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import {
- clearAllContinuationsForTests,
- continuationCandidate,
- hasContinuationForTests,
- recordContinuation,
-} from "./continuation.ts";
-import type { ResponsesInputItem, ResponsesRequest } from "./translate/request.ts";
-
-function requestWithInput(
- input: ResponsesInputItem[],
- extra: Partial<ResponsesRequest> = {},
-): ResponsesRequest {
- return {
- model: "gpt-5.5",
- input,
- store: false,
- stream: true,
- text: { verbosity: "low" },
- ...extra,
- };
-}
-
-afterEach(() => {
- clearAllContinuationsForTests();
-});
-
-describe("continuationCandidate", () => {
- it("is disabled unless the feature is enabled", () => {
- const req = requestWithInput([
- { type: "message", role: "user", content: [{ type: "input_text", text: "one" }] },
- ]);
-
- expect(continuationCandidate("s1", req, false)).toEqual({
- inputDeltaCount: 1,
- disabledReason: "disabled",
- });
- });
-
- it("uses previous response id for append-only input", () => {
- const first = requestWithInput([
- { type: "message", role: "user", content: [{ type: "input_text", text: "one" }] },
- ]);
- recordContinuation("s1", first, "resp_1", [
- { type: "message", role: "assistant", content: [{ type: "output_text", text: "two" }] },
- ]);
-
- const second = requestWithInput([
- { type: "message", role: "user", content: [{ type: "input_text", text: "one" }] },
- { type: "message", role: "assistant", content: [{ type: "output_text", text: "two" }] },
- { type: "message", role: "user", content: [{ type: "input_text", text: "three" }] },
- ]);
-
- const result = continuationCandidate("s1", second, true);
-
- expect(result.previousResponseId).toBe("resp_1");
- expect(result.inputDeltaCount).toBe(1);
- expect(result.inputDelta).toEqual([
- { type: "message", role: "user", content: [{ type: "input_text", text: "three" }] },
- ]);
- });
-
- it("clears state when the prompt signature changes", () => {
- const first = requestWithInput([
- { type: "message", role: "user", content: [{ type: "input_text", text: "one" }] },
- ]);
- recordContinuation("s1", first, "resp_1", []);
-
- const second = requestWithInput(first.input, { tool_choice: "none" });
-
- expect(continuationCandidate("s1", second, true).disabledReason).toBe("prompt_changed");
- expect(hasContinuationForTests("s1")).toBe(false);
- });
-
- it("preserves state when an exact repeat has no input delta", () => {
- const first = requestWithInput([
- { type: "message", role: "user", content: [{ type: "input_text", text: "one" }] },
- ]);
- recordContinuation("s1", first, "resp_1", []);
-
- expect(continuationCandidate("s1", first, true).disabledReason).toBe("empty_delta");
- expect(
- continuationCandidate(
- "s1",
- requestWithInput([
- ...first.input,
- { type: "message", role: "user", content: [{ type: "input_text", text: "two" }] },
- ]),
- true,
- ).previousResponseId,
- ).toBe("resp_1");
- });
-
- it("clears state when the transcript is not a strict prefix", () => {
- const first = requestWithInput([
- { type: "message", role: "user", content: [{ type: "input_text", text: "one" }] },
- ]);
- recordContinuation("s1", first, "resp_1", []);
-
- const second = requestWithInput([
- { type: "message", role: "user", content: [{ type: "input_text", text: "changed" }] },
- { type: "message", role: "user", content: [{ type: "input_text", text: "three" }] },
- ]);
-
- expect(continuationCandidate("s1", second, true).disabledReason).toBe("not_append_only");
- expect(hasContinuationForTests("s1")).toBe(false);
- });
-
- it("handles previous function call output as visible transcript", () => {
- const first = requestWithInput([
- { type: "message", role: "user", content: [{ type: "input_text", text: "read" }] },
- ]);
- recordContinuation("s1", first, "resp_1", [
- {
- type: "function_call",
- call_id: "call_1",
- name: "Read",
- arguments: '{"file_path":"/tmp/a"}',
- },
- ]);
-
- const second = requestWithInput([
- { type: "message", role: "user", content: [{ type: "input_text", text: "read" }] },
- {
- type: "function_call",
- call_id: "call_1",
- name: "Read",
- arguments: '{"file_path":"/tmp/a"}',
- },
- { type: "function_call_output", call_id: "call_1", output: "contents" },
- { type: "message", role: "user", content: [{ type: "input_text", text: "summarize" }] },
- ]);
-
- const result = continuationCandidate("s1", second, true);
-
- expect(result.previousResponseId).toBe("resp_1");
- expect(result.inputDelta).toEqual([
- { type: "function_call_output", call_id: "call_1", output: "contents" },
- { type: "message", role: "user", content: [{ type: "input_text", text: "summarize" }] },
- ]);
- });
-
- it("expires stale state", () => {
- const first = requestWithInput([
- { type: "message", role: "user", content: [{ type: "input_text", text: "one" }] },
- ]);
- recordContinuation("s1", first, "resp_1", [], 1_000);
-
- expect(continuationCandidate("s1", first, true, 31 * 60 * 1_000).disabledReason).toBe(
- "missing_state",
- );
- expect(hasContinuationForTests("s1")).toBe(false);
- });
-
- it("clears state when the response id is missing", () => {
- const first = requestWithInput([
- { type: "message", role: "user", content: [{ type: "input_text", text: "one" }] },
- ]);
- recordContinuation("s1", first, "resp_1", []);
-
- recordContinuation("s1", first, undefined, []);
-
- expect(hasContinuationForTests("s1")).toBe(false);
- });
-
- it("does not store oversized session transcripts", () => {
- const largeText = "x".repeat(2_000_001);
- const first = requestWithInput([
- { type: "message", role: "user", content: [{ type: "input_text", text: largeText }] },
- ]);
-
- recordContinuation("s1", first, "resp_1", []);
-
- expect(continuationCandidate("s1", first, true).disabledReason).toBe("missing_state");
- });
-});
diff --git a/reference/typescript/src/providers/codex/continuation.ts b/reference/typescript/src/providers/codex/continuation.ts
deleted file mode 100644
index 0d53a9e..0000000
--- a/reference/typescript/src/providers/codex/continuation.ts
+++ /dev/null
@@ -1,139 +0,0 @@
-import type { ResponsesInputItem, ResponsesRequest } from "./translate/request.ts";
-
-interface ContinuationState {
- responseId: string;
- promptSignature: string;
- transcript: ResponsesInputItem[];
- transcriptBytes: number;
- updatedAt: number;
-}
-
-const states = new Map<string, ContinuationState>();
-const TTL_MS = 30 * 60 * 1000;
-const MAX_STATES = 10_000;
-const MAX_SESSION_TRANSCRIPT_BYTES = 2_000_000;
-const MAX_TOTAL_TRANSCRIPT_BYTES = 20_000_000;
-let totalTranscriptBytes = 0;
-
-export interface ContinuationCandidate {
- previousResponseId?: string;
- inputDelta?: ResponsesInputItem[];
- inputDeltaCount: number;
- disabledReason?: string;
-}
-
-export function continuationCandidate(
- sessionId: string | undefined,
- body: ResponsesRequest,
- enabled: boolean,
- now = Date.now(),
-): ContinuationCandidate {
- if (!enabled) return { inputDeltaCount: body.input.length, disabledReason: "disabled" };
- if (!sessionId) return { inputDeltaCount: body.input.length, disabledReason: "missing_session" };
- const state = states.get(sessionId);
- if (!state || now - state.updatedAt > TTL_MS) {
- clearContinuation(sessionId);
- return { inputDeltaCount: body.input.length, disabledReason: "missing_state" };
- }
- const signature = promptSignature(body);
- if (signature !== state.promptSignature) {
- clearContinuation(sessionId);
- return { inputDeltaCount: body.input.length, disabledReason: "prompt_changed" };
- }
- const suffix = inputSuffixAfterPrefix(body.input, state.transcript);
- if (!suffix) {
- clearContinuation(sessionId);
- return { inputDeltaCount: body.input.length, disabledReason: "not_append_only" };
- }
- if (suffix.length === 0) {
- return { inputDeltaCount: 0, disabledReason: "empty_delta" };
- }
- return {
- previousResponseId: state.responseId,
- inputDelta: suffix,
- inputDeltaCount: suffix.length,
- };
-}
-
-export function recordContinuation(
- sessionId: string | undefined,
- requestBody: ResponsesRequest,
- responseId: string | undefined,
- outputItems: ResponsesInputItem[],
- now = Date.now(),
-): void {
- if (!sessionId) return;
- if (!responseId) {
- clearContinuation(sessionId);
- return;
- }
- const transcript = [...requestBody.input, ...outputItems];
- const transcriptBytes = byteLength(JSON.stringify(transcript));
- if (transcriptBytes > MAX_SESSION_TRANSCRIPT_BYTES) {
- clearContinuation(sessionId);
- return;
- }
- clearContinuation(sessionId);
- states.set(sessionId, {
- responseId,
- promptSignature: promptSignature(requestBody),
- transcript,
- transcriptBytes,
- updatedAt: now,
- });
- totalTranscriptBytes += transcriptBytes;
- evictOldest();
-}
-
-export function clearContinuation(sessionId: string | undefined): void {
- if (!sessionId) return;
- const existing = states.get(sessionId);
- if (existing) totalTranscriptBytes -= existing.transcriptBytes;
- states.delete(sessionId);
-}
-
-export function hasContinuationForTests(sessionId: string): boolean {
- return states.has(sessionId);
-}
-
-export function clearAllContinuationsForTests(): void {
- states.clear();
- totalTranscriptBytes = 0;
-}
-
-function inputSuffixAfterPrefix(
- input: ResponsesInputItem[],
- prefix: ResponsesInputItem[],
-): ResponsesInputItem[] | undefined {
- if (prefix.length > input.length) return undefined;
- for (let i = 0; i < prefix.length; i++) {
- if (JSON.stringify(input[i]) !== JSON.stringify(prefix[i])) return undefined;
- }
- return input.slice(prefix.length);
-}
-
-function promptSignature(body: ResponsesRequest): string {
- const { input: _input, ...signature } = body;
- return stableJson(signature);
-}
-
-function stableJson(value: unknown): string {
- if (value === null || typeof value !== "object") return JSON.stringify(value);
- if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
- const entries = Object.entries(value as Record<string, unknown>)
- .filter(([, child]) => child !== undefined)
- .sort(([a], [b]) => a.localeCompare(b));
- return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${stableJson(child)}`).join(",")}}`;
-}
-
-function evictOldest(): void {
- while (states.size > MAX_STATES || totalTranscriptBytes > MAX_TOTAL_TRANSCRIPT_BYTES) {
- const key = states.keys().next().value;
- if (!key) return;
- clearContinuation(key);
- }
-}
-
-function byteLength(value: string): number {
- return new TextEncoder().encode(value).byteLength;
-}
diff --git a/reference/typescript/src/providers/codex/count-tokens.ts b/reference/typescript/src/providers/codex/count-tokens.ts
deleted file mode 100644
index 5a25969..0000000
--- a/reference/typescript/src/providers/codex/count-tokens.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import { encode } from "gpt-tokenizer/model/gpt-4o";
-import type { AnthropicRequest } from "../../anthropic/schema.ts";
-import type { ResponsesRequest } from "./translate/request.ts";
-import { countAnthropicTokens, IMAGE_TOKEN_ESTIMATE } from "../shared/count-tokens.ts";
-import { countToolSchemaTokens } from "../shared/tool-schema.ts";
-
-export function countTokens(req: AnthropicRequest): number {
- return countAnthropicTokens(req, (value) => encode(value).length);
-}
-
-export function countTranslatedTokens(
- req: Pick<ResponsesRequest, "instructions" | "input" | "tools" | "text" | "tool_choice">,
-): number {
- 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;
- } else if (part.type === "input_image") {
- 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;
- } else if (item.type === "function_call_output") {
- total += encode(item.call_id).length;
- total += encode(item.output).length;
- }
- }
-
- total += countToolSchemaTokens(
- req.tools,
- (tool) => ("name" in tool ? tool.name : tool.type),
- (tool) => ("description" in tool ? tool.description : undefined),
- (tool) => ("parameters" in tool ? tool.parameters : undefined),
- );
-
- if (req.text?.format?.type === "json_schema") {
- 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;
- } else if (req.tool_choice) {
- total += encode(req.tool_choice.type).length;
- if ("name" in req.tool_choice) total += encode(req.tool_choice.name).length;
- }
-
- total += req.input.length * 4;
- return total;
-}
diff --git a/reference/typescript/src/providers/codex/index.test.ts b/reference/typescript/src/providers/codex/index.test.ts
deleted file mode 100644
index 8b4291b..0000000
--- a/reference/typescript/src/providers/codex/index.test.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import type { AnthropicRequest } from "../../anthropic/schema.ts";
-import type { RequestContext } from "../types.ts";
-import { loadConfig } from "../../config.ts";
-import { codexProvider } from "./index.ts";
-
-const ctx: RequestContext = {
- reqId: "test-req",
- signal: new AbortController().signal,
- childLogger: () => ({
- debug() {},
- info() {},
- warn() {},
- error() {},
- child() {
- return this;
- },
- }),
-};
-
-const countTokensRequest: AnthropicRequest = {
- model: "gpt-5.4",
- messages: [{ role: "user", content: "hello" }],
-};
-
-const expectInvalidCountTokens = async (env: Record<string, string>, message: string) => {
- loadConfig({ env, forceReload: true });
- const resp = await codexProvider.handleCountTokens(countTokensRequest, ctx);
-
- expect(resp.status).toBe(400);
- expect(resp.headers.get("content-type")).toBe("application/json");
- expect(await resp.json()).toEqual({
- type: "error",
- error: {
- type: "invalid_request_error",
- message,
- },
- });
-};
-
-afterEach(() => {
- loadConfig({ forceReload: true });
-});
-
-describe("codexProvider", () => {
- it("returns 400 for invalid service tier config during token counting", async () => {
- await expectInvalidCountTokens(
- { CCP_CODEX_SERVICE_TIER: "standard" },
- 'Invalid service tier override: "standard". Must be one of: fast, priority, flex',
- );
- });
-
- it("returns 400 for invalid forced model during token counting", async () => {
- await expectInvalidCountTokens(
- { CCP_CODEX_MODEL: "gpt-4.1" },
- 'Model "gpt-5.4" resolves to unsupported model "gpt-4.1"',
- );
- });
-});
diff --git a/reference/typescript/src/providers/codex/index.ts b/reference/typescript/src/providers/codex/index.ts
deleted file mode 100644
index 6569e48..0000000
--- a/reference/typescript/src/providers/codex/index.ts
+++ /dev/null
@@ -1,436 +0,0 @@
-import type { AnthropicRequest } from "../../anthropic/schema.ts";
-import { wantsDownstreamStream } from "../../anthropic/stream.ts";
-import type { Provider, RequestContext } from "../types.ts";
-import { jsonError, jsonResponse, sseResponse } from "../../anthropic/response.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 { summarizeCodexRequestSize, type CodexRequestSizeSummary } from "./request-summary.ts";
-import { codexPreviousResponseId, logVerbose } from "../../config.ts";
-import { clearContinuation, continuationCandidate, recordContinuation } from "./continuation.ts";
-import { codexCli } from "./cli.ts";
-import {
- mapUpstreamHttpErrorToResponse,
- mapUpstreamStreamErrorToResponse,
-} from "../shared/upstream-errors.ts";
-
-interface SessionCountSnapshot {
- reqId: string;
- model: string;
- messageCount: number;
- toolCount: number;
- tokens: number;
-}
-
-interface SessionMessageSnapshot {
- reqId: string;
- model: string;
- messageCount: number;
- toolCount: number;
- localInputTokens?: number;
- translatedInputTokens?: number;
-}
-
-interface SessionTimelineState {
- lastCount?: SessionCountSnapshot;
- lastMessage?: SessionMessageSnapshot;
-}
-
-const sessionTimeline = new Map<string, SessionTimelineState>();
-
-function sessionState(sessionId?: string): SessionTimelineState | undefined {
- if (!sessionId) return undefined;
- let state = sessionTimeline.get(sessionId);
- if (!state) {
- state = {};
- sessionTimeline.set(sessionId, state);
- }
- return state;
-}
-
-function readToolSchemaSummary(
- tools: { type?: string; name?: string; parameters?: unknown; strict?: boolean }[] | undefined,
-) {
- const read = tools?.find((tool) => tool.name === "Read");
- if (!read) return undefined;
- const parameters = read.parameters;
- const properties =
- parameters && typeof parameters === "object" && !Array.isArray(parameters)
- ? (parameters as { properties?: unknown }).properties
- : undefined;
- return {
- strict: read.strict,
- schema: summarizeSchema(parameters),
- properties: summarizeSchema(properties),
- };
-}
-
-function summarizeSchema(value: unknown): Record<string, unknown> {
- const json = JSON.stringify(value ?? null);
- if (!value || typeof value !== "object" || Array.isArray(value)) {
- return { type: typeof value, jsonLength: json.length, preview: json.slice(0, 500) };
- }
- const record = value as Record<string, unknown>;
- return {
- jsonLength: json.length,
- keys: Object.keys(record),
- type: record.type,
- required: record.required,
- additionalProperties: record.additionalProperties,
- preview: json.slice(0, 500),
- };
-}
-
-function usageWindowTokens(usage: {
- input_tokens: number;
- output_tokens: number;
- cache_creation_input_tokens: number;
- cache_read_input_tokens: number;
-}): number {
- return (
- usage.input_tokens +
- usage.output_tokens +
- usage.cache_creation_input_tokens +
- usage.cache_read_input_tokens
- );
-}
-
-function upstreamHeaderSnapshot(headers: Headers): {
- serverModel?: string;
- serverReasoningIncluded: boolean;
-} {
- return {
- serverModel: headers.get("OpenAI-Model") || undefined,
- serverReasoningIncluded: headers.has("X-Reasoning-Included"),
- };
-}
-
-function warnForHeavyImages(
- log: ReturnType<RequestContext["childLogger"]>,
- requestSize: CodexRequestSizeSummary,
-): void {
- if (requestSize.inputImageDataUrlBytes < 1_000_000) return;
- log.warn("large inline images in codex request", {
- inputImagePartCount: requestSize.inputImagePartCount,
- inputImageDataUrlBytes: requestSize.inputImageDataUrlBytes,
- bodyJsonBytes: requestSize.bodyJsonBytes,
- inputJsonBytes: requestSize.inputJsonBytes,
- largestInputImages: requestSize.largestInputImages,
- });
-}
-
-function invalidServiceTierResponse(err: InvalidServiceTierError): Response {
- return jsonError(400, "invalid_request_error", err.message);
-}
-
-type PrepareCodexRequestResult =
- | {
- ok: true;
- translated: ReturnType<typeof translateRequest>;
- resolvedModel: string;
- resolvedServiceTier: ReturnType<typeof resolveModelRequest>["serviceTier"];
- }
- | { ok: false; response: Response };
-
-function prepareCodexRequest(
- body: AnthropicRequest,
- options: { sessionId?: string } = {},
-): PrepareCodexRequestResult {
- const resolved = resolveModelRequest(body.model);
- try {
- assertAllowedModel(resolved.model);
- const translated = translateRequest(
- { ...body, model: resolved.model },
- { sessionId: options.sessionId, serviceTier: resolved.serviceTier },
- );
- return {
- ok: true,
- translated,
- resolvedModel: resolved.model,
- resolvedServiceTier: resolved.serviceTier,
- };
- } catch (err) {
- if (err instanceof ModelNotAllowedError) {
- return {
- ok: false,
- response: jsonError(
- 400,
- "invalid_request_error",
- `Model "${body.model}" resolves to unsupported model "${err.model}"`,
- ),
- };
- }
- if (err instanceof InvalidServiceTierError) {
- return {
- ok: false,
- response: invalidServiceTierResponse(err),
- };
- }
- throw err;
- }
-}
-
-async function handleCountTokens(body: AnthropicRequest, ctx: RequestContext): Promise<Response> {
- const log = ctx.childLogger("provider.codex");
- const prepared = prepareCodexRequest(body);
- if (!prepared.ok) return prepared.response;
- const translated = prepared.translated;
- const resolvedModel = prepared.resolvedModel;
- const tokens = countTranslatedTokens(translated);
- const messageCount = body.messages?.length ?? 0;
- const toolCount = body.tools?.length ?? 0;
- const state = sessionState(ctx.sessionId);
- log.debug("count_tokens", { tokens });
- if (state) {
- state.lastCount = {
- reqId: ctx.reqId,
- model: body.model,
- messageCount,
- toolCount,
- tokens,
- };
- }
- if (logVerbose()) {
- log.info("compaction telemetry", {
- phase: "count_tokens",
- model: body.model,
- resolvedModel,
- tokens,
- messageCount,
- toolCount,
- previousMessageReqId: state?.lastMessage?.reqId,
- previousMessageModel: state?.lastMessage?.model,
- previousMessageCount: state?.lastMessage?.messageCount,
- previousMessageToolCount: state?.lastMessage?.toolCount,
- previousMessageLocalInputTokens: state?.lastMessage?.localInputTokens,
- previousMessageTranslatedInputTokens: state?.lastMessage?.translatedInputTokens,
- });
- }
- return jsonResponse({ input_tokens: tokens });
-}
-
-async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Promise<Response> {
- const log = ctx.childLogger("provider.codex");
- const messageId = `msg_${crypto.randomUUID().replace(/-/g, "")}`;
- const wantStream = wantsDownstreamStream(body);
- 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,
- messageCount,
- toolCount,
- stream: wantStream,
- requestedMaxTokens: body.max_tokens,
- hasContextManagement: contextManagement !== undefined,
- hasJsonSchemaFormat: body.output_config?.format?.type === "json_schema",
- });
- if (logVerbose()) log.debug("anthropic request body", { body });
-
- const prepared = prepareCodexRequest(body, { sessionId: ctx.sessionId });
- if (!prepared.ok) return prepared.response;
- const translated = prepared.translated;
- const resolvedModel = prepared.resolvedModel;
- const requestSize = summarizeCodexRequestSize(translated);
- warnForHeavyImages(log, requestSize);
- const localInputTokens = logVerbose() ? countTokens(body) : undefined;
- const translatedInputTokens = logVerbose() ? countTranslatedTokens(translated) : undefined;
- if (state) {
- state.lastMessage = {
- reqId: ctx.reqId,
- model: body.model,
- messageCount,
- toolCount,
- localInputTokens,
- translatedInputTokens,
- };
- }
- log.debug("translated request", {
- requestedModel: body.model,
- resolvedModel,
- inputItems: translated.input.length,
- tools: translated.tools?.length ?? 0,
- readToolSchema: readToolSchemaSummary(translated.tools),
- hasInstructions: !!translated.instructions,
- requestedMaxTokens: body.max_tokens,
- hasContextManagement: contextManagement !== undefined,
- promptCacheKey: translated.prompt_cache_key,
- requestSize,
- });
- if (logVerbose()) log.debug("translated request body", { body: translated });
- if (logVerbose()) {
- log.info("compaction telemetry", {
- phase: "translated_request",
- requestedModel: body.model,
- resolvedModel,
- messageCount,
- toolCount,
- localInputTokens,
- translatedInputTokens,
- inputItems: translated.input.length,
- translatedToolCount: translated.tools?.length ?? 0,
- readToolSchema: readToolSchemaSummary(translated.tools),
- hasInstructions: !!translated.instructions,
- requestedMaxTokens: body.max_tokens,
- hasContextManagement: contextManagement !== undefined,
- contextManagement,
- requestSize,
- previousCountReqId: state?.lastCount?.reqId,
- previousCountModel: state?.lastCount?.model,
- previousCountTokens: state?.lastCount?.tokens,
- previousCountMessageCount: state?.lastCount?.messageCount,
- previousCountToolCount: state?.lastCount?.toolCount,
- });
- }
-
- const previousResponseIdEnabled = codexPreviousResponseId();
- const continuation = continuationCandidate(ctx.sessionId, translated, previousResponseIdEnabled);
- log.debug("codex continuation", {
- enabled: previousResponseIdEnabled,
- previousResponseId: continuation.previousResponseId,
- inputDeltaCount: continuation.inputDeltaCount,
- disabledReason: continuation.disabledReason,
- });
-
- let upstream;
- try {
- upstream = await postCodex(translated, ctx, { continuation });
- } catch (err) {
- clearContinuation(ctx.sessionId);
- if (err instanceof CodexError) {
- log.warn("codex error", { status: err.status, detail: err.detail });
- return mapUpstreamHttpErrorToResponse(err);
- }
- throw err;
- }
-
- if (wantStream) {
- const { serverModel, serverReasoningIncluded } = upstreamHeaderSnapshot(upstream.headers);
- const stream = translateStream(upstream.body, {
- messageId,
- model: body.model,
- log: ctx.childLogger("codex.stream"),
- reqId: ctx.reqId,
- signal: ctx.signal,
- upstreamHeaders: upstream.headers,
- traffic: ctx.traffic,
- requestSize,
- retryUpstream: async () => {
- const retry = await postCodex(translated, ctx, { continuation });
- return {
- body: retry.body,
- headers: retry.headers,
- requestSize,
- };
- },
- onFinish: (finish) => {
- if (finish.continuationEligible) {
- recordContinuation(ctx.sessionId, translated, finish.responseId, finish.outputItems);
- } else {
- clearContinuation(ctx.sessionId);
- }
- if (logVerbose()) {
- const mappedUsage = finish.usage ? mapUsageToAnthropic(finish.usage) : undefined;
- log.info("compaction telemetry", {
- phase: "upstream_finish",
- mode: "stream",
- requestedModel: body.model,
- resolvedModel,
- serverModel,
- serverReasoningIncluded,
- messageCount,
- toolCount,
- localInputTokens,
- translatedInputTokens,
- requestedMaxTokens: body.max_tokens,
- hasContextManagement: contextManagement !== undefined,
- contextManagement,
- upstreamInputTokens: finish.usage?.input_tokens ?? 0,
- upstreamOutputTokens: finish.usage?.output_tokens ?? 0,
- upstreamCachedInputTokens: finish.usage?.input_tokens_details?.cached_tokens ?? 0,
- upstreamReasoningTokens: finish.usage?.output_tokens_details?.reasoning_tokens ?? 0,
- mappedInputTokens: mappedUsage?.input_tokens ?? 0,
- mappedOutputTokens: mappedUsage?.output_tokens ?? 0,
- mappedCachedInputTokens: mappedUsage?.cache_read_input_tokens ?? 0,
- mappedContextWindowTokens: mappedUsage ? usageWindowTokens(mappedUsage) : 0,
- stopReason: finish.stopReason,
- });
- }
- },
- onInvalidateContinuation: () => clearContinuation(ctx.sessionId),
- });
- return sseResponse(stream);
- }
-
- try {
- const result = await accumulateResponse(upstream.body, {
- messageId,
- model: body.model,
- log: ctx.childLogger("codex.accumulate"),
- traffic: ctx.traffic,
- });
- if (result.continuationEligible) {
- recordContinuation(ctx.sessionId, translated, result.responseId, result.outputItems);
- } else {
- clearContinuation(ctx.sessionId);
- }
- if (logVerbose()) {
- const { serverModel, serverReasoningIncluded } = upstreamHeaderSnapshot(upstream.headers);
- log.info("compaction telemetry", {
- phase: "upstream_finish",
- mode: "non_stream",
- requestedModel: body.model,
- resolvedModel,
- serverModel,
- serverReasoningIncluded,
- messageCount,
- toolCount,
- localInputTokens,
- translatedInputTokens,
- requestedMaxTokens: body.max_tokens,
- hasContextManagement: contextManagement !== undefined,
- contextManagement,
- upstreamInputTokens: result.rawUsage?.input_tokens ?? 0,
- upstreamOutputTokens: result.rawUsage?.output_tokens ?? 0,
- upstreamCachedInputTokens: result.rawUsage?.input_tokens_details?.cached_tokens ?? 0,
- upstreamReasoningTokens: result.rawUsage?.output_tokens_details?.reasoning_tokens ?? 0,
- mappedInputTokens: result.response.usage.input_tokens,
- mappedOutputTokens: result.response.usage.output_tokens,
- mappedCachedInputTokens: result.response.usage.cache_read_input_tokens,
- mappedContextWindowTokens: usageWindowTokens(result.response.usage),
- stopReason: result.response.stop_reason,
- });
- }
- return jsonResponse(result.response);
- } catch (err) {
- clearContinuation(ctx.sessionId);
- if (err instanceof UpstreamStreamError) {
- log.warn("upstream stream error (non-streaming)", {
- kind: err.kind,
- message: err.message,
- });
- return mapUpstreamStreamErrorToResponse(err);
- }
- throw err;
- }
-}
-
-export const codexProvider: Provider = {
- name: "codex",
- supportedModels: new Set([...ALLOWED_MODELS, ...FAST_MODEL_ALIASES]),
- handleMessages,
- handleCountTokens,
- cli: codexCli,
-};
diff --git a/reference/typescript/src/providers/codex/request-summary.test.ts b/reference/typescript/src/providers/codex/request-summary.test.ts
deleted file mode 100644
index d1cb5c1..0000000
--- a/reference/typescript/src/providers/codex/request-summary.test.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { summarizeCodexRequestSize } from "./request-summary.ts";
-import type { ResponsesRequest } from "./translate/request.ts";
-
-describe("summarizeCodexRequestSize", () => {
- it("reports inline image byte weight separately", () => {
- const req: ResponsesRequest = {
- model: "gpt-5.5",
- input: [
- {
- type: "message",
- role: "user",
- content: [
- { type: "input_text", text: "look" },
- { type: "input_image", image_url: `data:image/png;base64,${"a".repeat(20)}` },
- ],
- },
- {
- type: "message",
- role: "user",
- content: [
- { type: "input_image", image_url: "https://example.invalid/image.png" },
- { type: "input_image", image_url: `data:image/png;base64,${"b".repeat(40)}` },
- ],
- },
- ],
- store: false,
- stream: true,
- };
-
- const summary = summarizeCodexRequestSize(req);
-
- expect(summary.inputImagePartCount).toBe(3);
- expect(summary.inputImageDataUrlBytes).toBe("data:image/png;base64,".length * 2 + 20 + 40);
- expect(summary.largestInputImages).toEqual([
- expect.objectContaining({ itemIndex: 1, partIndex: 1, dataUrl: true }),
- expect.objectContaining({ itemIndex: 0, partIndex: 1, dataUrl: true }),
- expect.objectContaining({ itemIndex: 1, partIndex: 0, dataUrl: false }),
- ]);
- });
-});
diff --git a/reference/typescript/src/providers/codex/request-summary.ts b/reference/typescript/src/providers/codex/request-summary.ts
deleted file mode 100644
index e1d97bb..0000000
--- a/reference/typescript/src/providers/codex/request-summary.ts
+++ /dev/null
@@ -1,126 +0,0 @@
-import type { ResponsesInputItem, ResponsesRequest } from "./translate/request.ts";
-
-const encoder = new TextEncoder();
-
-export interface CodexRequestSizeSummary {
- bodyJsonBytes: number;
- instructionsBytes: number;
- inputJsonBytes: number;
- toolsJsonBytes: number;
- textJsonBytes: number;
- reasoningJsonBytes: number;
- includeJsonBytes: number;
- clientMetadataJsonBytes: number;
- inputItemCount: number;
- toolCount: number;
- inputImagePartCount: number;
- inputImageDataUrlBytes: number;
- inputTypeCounts: Record<string, number>;
- roleCounts: Record<string, number>;
- largestInputItems: Array<{ index: number; type: string; role?: string; jsonBytes: number }>;
- largestInputImages: Array<{
- itemIndex: number;
- partIndex: number;
- jsonBytes: number;
- imageUrlBytes: number;
- dataUrl: boolean;
- }>;
- largestTools: Array<{ index: number; name: string; jsonBytes: number }>;
-}
-
-export function summarizeCodexRequestSize(
- body: ResponsesRequest,
- bodyJson = JSON.stringify(body),
-): CodexRequestSizeSummary {
- const imageParts = inputImageParts(body.input);
- return {
- bodyJsonBytes: byteLength(bodyJson),
- instructionsBytes: stringBytes(body.instructions),
- inputJsonBytes: jsonBytes(body.input),
- toolsJsonBytes: jsonBytes(body.tools),
- textJsonBytes: jsonBytes(body.text),
- reasoningJsonBytes: jsonBytes(body.reasoning),
- includeJsonBytes: jsonBytes(body.include),
- clientMetadataJsonBytes: jsonBytes(body.client_metadata),
- inputItemCount: body.input.length,
- toolCount: body.tools?.length ?? 0,
- inputImagePartCount: imageParts.length,
- inputImageDataUrlBytes: imageParts
- .filter((part) => part.image_url.startsWith("data:"))
- .reduce((sum, part) => sum + byteLength(part.image_url), 0),
- inputTypeCounts: countBy(body.input, (item) => item.type),
- roleCounts: countBy(body.input, (item) => ("role" in item ? item.role : undefined)),
- largestInputItems: largestInputItems(body.input),
- largestInputImages: largestInputImages(imageParts),
- largestTools: largestTools(body.tools),
- };
-}
-
-function largestInputItems(input: ResponsesInputItem[]) {
- return input
- .map((item, index) => ({
- index,
- type: item.type,
- role: "role" in item ? item.role : undefined,
- jsonBytes: jsonBytes(item),
- }))
- .sort((a, b) => b.jsonBytes - a.jsonBytes)
- .slice(0, 5);
-}
-
-function largestInputImages(imageParts: ReturnType<typeof inputImageParts>) {
- return imageParts
- .map(({ itemIndex, partIndex, image_url }) => ({
- itemIndex,
- partIndex,
- jsonBytes: jsonBytes({ type: "input_image", image_url }),
- imageUrlBytes: byteLength(image_url),
- dataUrl: image_url.startsWith("data:"),
- }))
- .sort((a, b) => b.imageUrlBytes - a.imageUrlBytes)
- .slice(0, 5);
-}
-
-function inputImageParts(input: ResponsesInputItem[]) {
- return input.flatMap((item, itemIndex) => {
- if (item.type !== "message") return [];
- return item.content.flatMap((part, partIndex) =>
- part.type === "input_image" ? [{ itemIndex, partIndex, image_url: part.image_url }] : [],
- );
- });
-}
-
-function largestTools(tools: ResponsesRequest["tools"]) {
- return (tools ?? [])
- .map((tool, index) => ({
- index,
- name: "name" in tool ? tool.name : tool.type,
- jsonBytes: jsonBytes(tool),
- }))
- .sort((a, b) => b.jsonBytes - a.jsonBytes)
- .slice(0, 5);
-}
-
-function countBy<T>(items: T[], keyFor: (item: T) => string | undefined): Record<string, number> {
- const counts: Record<string, number> = {};
- for (const item of items) {
- const key = keyFor(item);
- if (!key) continue;
- counts[key] = (counts[key] ?? 0) + 1;
- }
- return counts;
-}
-
-function jsonBytes(value: unknown): number {
- if (value === undefined) return 0;
- return byteLength(JSON.stringify(value));
-}
-
-function stringBytes(value: string | undefined): number {
- if (!value) return 0;
- return byteLength(value);
-}
-
-function byteLength(value: string): number {
- return encoder.encode(value).byteLength;
-}
diff --git a/reference/typescript/src/providers/codex/translate/accumulate.test.ts b/reference/typescript/src/providers/codex/translate/accumulate.test.ts
deleted file mode 100644
index c5433c6..0000000
--- a/reference/typescript/src/providers/codex/translate/accumulate.test.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { accumulateResponse } from "./accumulate.ts";
-import { sse, silentLog, upstreamFromChunks } from "./test-helpers.ts";
-
-describe("accumulateResponse", () => {
- it("returns Anthropic web search blocks and usage for Codex hosted web search", async () => {
- const result = await accumulateResponse(
- upstreamFromChunks([
- sse("response.output_item.added", {
- output_index: 0,
- item: { type: "web_search_call", id: "ws_1", status: "in_progress" },
- }),
- sse("response.web_search_call.in_progress", { output_index: 0, item_id: "ws_1" }),
- sse("response.web_search_call.searching", { output_index: 0, item_id: "ws_1" }),
- sse("response.web_search_call.completed", { output_index: 0, item_id: "ws_1" }),
- sse("response.output_item.done", {
- output_index: 0,
- item: {
- type: "web_search_call",
- id: "ws_1",
- status: "completed",
- action: {
- type: "search",
- query: "claude-code-proxy github",
- queries: ["claude-code-proxy github"],
- },
- },
- }),
- sse("response.output_item.added", {
- output_index: 1,
- item: { type: "message", id: "msg_upstream" },
- }),
- sse("response.output_text.delta", {
- output_index: 1,
- delta:
- "1. **TechRadar security article** - warns about malware.\n https://www.techradar.com/pro/security/example",
- }),
- sse("response.output_item.done", {
- output_index: 1,
- item: { type: "message", id: "msg_upstream" },
- }),
- sse("response.completed", { response: { id: "resp_1", usage: { input_tokens: 10 } } }),
- ]),
- { messageId: "msg_1", model: "gpt-5.5", log: silentLog },
- );
-
- expect(result.response.content).toEqual([
- {
- type: "server_tool_use",
- id: "srvtoolu_ws_1",
- name: "web_search",
- input: { query: "claude-code-proxy github" },
- },
- {
- type: "web_search_tool_result",
- tool_use_id: "srvtoolu_ws_1",
- content: [
- {
- type: "web_search_result",
- title: "TechRadar security article",
- url: "https://www.techradar.com/pro/security/example",
- },
- ],
- },
- {
- type: "text",
- text: "1. **TechRadar security article** - warns about malware.\n https://www.techradar.com/pro/security/example",
- },
- ]);
- expect(result.response.usage.server_tool_use).toEqual({ web_search_requests: 1 });
- });
-});
diff --git a/reference/typescript/src/providers/codex/translate/accumulate.ts b/reference/typescript/src/providers/codex/translate/accumulate.ts
deleted file mode 100644
index 7f30648..0000000
--- a/reference/typescript/src/providers/codex/translate/accumulate.ts
+++ /dev/null
@@ -1,126 +0,0 @@
-import { mapUsageToAnthropic, reduceUpstream } from "./reducer.ts";
-import type { CodexUsage, ReducerEvent } from "./reducer.ts";
-import type { Logger } from "../../../log.ts";
-import type { TrafficCapture } from "../../types.ts";
-import { attachTrafficCapture, createUpstreamStreamDiagnostics } from "./reducer.ts";
-import {
- AnthropicNonStreamResponse,
- type AnthropicNonStreamContent,
- createBlockAccumulator,
- defaultAnthropicNonStreamUsage,
- parseToolInputJsonOrRaw,
-} from "../../translate/accumulate.ts";
-import { buildWebSearchCompatBlocks } from "./web-search-compat.ts";
-
-export { UpstreamStreamError } from "./reducer.ts";
-
-type FinishEvent = Extract<ReducerEvent, { kind: "finish" }>;
-
-export interface AccumulatedResponse {
- response: AnthropicNonStreamResponse;
- rawUsage?: CodexUsage;
- terminalType?: FinishEvent["terminalType"];
- continuationEligible: boolean;
- responseId?: string;
- outputItems: FinishEvent["outputItems"];
-}
-
-/**
- * Drive the Codex SSE stream to completion through the shared reducer
- * and fold the ReducerEvents into a single Anthropic non-streaming
- * response object. Throws UpstreamStreamError on rate_limit or failed
- * upstream; server translates to a proper HTTP status.
- */
-export async function accumulateResponse(
- upstream: ReadableStream<Uint8Array>,
- opts: { messageId: string; model: string; log: Logger; traffic?: TrafficCapture },
-): Promise<AccumulatedResponse> {
- const blockAccumulator = createBlockAccumulator();
- let stopReason: AnthropicNonStreamResponse["stop_reason"] = null;
- let usage: ReturnType<typeof mapUsageToAnthropic> | undefined;
- let rawUsage: CodexUsage | undefined;
- let terminalType: FinishEvent["terminalType"] | undefined;
- let continuationEligible = false;
- let responseId: string | undefined;
- let outputItems: FinishEvent["outputItems"] = [];
- const webSearchEvents: Array<Extract<ReducerEvent, { kind: "web-search" }>> = [];
-
- const diagnostics = attachTrafficCapture(createUpstreamStreamDiagnostics(), opts.traffic);
-
- for await (const e of reduceUpstream(upstream, opts.log, diagnostics)) {
- switch (e.kind) {
- case "text-start":
- blockAccumulator.onTextStart(e.index);
- break;
- case "text-delta": {
- blockAccumulator.onTextDelta(e.index, e.text);
- break;
- }
- case "tool-start":
- blockAccumulator.onToolStart(e.index, e.id, e.name);
- break;
- case "tool-delta": {
- blockAccumulator.onToolDelta(e.index, e.partialJson);
- break;
- }
- case "web-search":
- webSearchEvents.push(e);
- break;
- case "text-stop":
- case "tool-stop":
- break;
- case "finish":
- stopReason = e.stopReason;
- rawUsage = e.usage;
- usage = mapUsageToAnthropic(e.usage, { webSearchRequests: e.webSearchRequests });
- terminalType = e.terminalType;
- continuationEligible = e.continuationEligible;
- responseId = e.responseId;
- outputItems = e.outputItems;
- break;
- }
- }
-
- const accumulatedBlocks = blockAccumulator.orderedBlocks();
- const text = accumulatedBlocks
- .flatMap((block) => (block.kind === "text" ? [block.text] : []))
- .join("");
- const indexedContent: Array<{ index: number; content: AnthropicNonStreamContent }> = [
- ...buildWebSearchCompatBlocks(webSearchEvents, text),
- ];
- for (const block of accumulatedBlocks) {
- if (block.kind === "text") {
- if (block.text)
- indexedContent.push({ index: block.index, content: { type: "text", text: block.text } });
- } else if (block.kind === "tool") {
- indexedContent.push({
- index: block.index,
- content: {
- type: "tool_use",
- id: block.id,
- name: block.name,
- input: parseToolInputJsonOrRaw(block.args),
- },
- });
- }
- }
- const content = indexedContent.sort((a, b) => a.index - b.index).map((item) => item.content);
-
- return {
- rawUsage,
- terminalType,
- continuationEligible,
- responseId,
- outputItems,
- response: {
- id: opts.messageId,
- type: "message",
- role: "assistant",
- model: opts.model,
- content,
- stop_reason: stopReason,
- stop_sequence: null,
- usage: usage ?? defaultAnthropicNonStreamUsage(),
- },
- };
-}
diff --git a/reference/typescript/src/providers/codex/translate/model-allowlist.test.ts b/reference/typescript/src/providers/codex/translate/model-allowlist.test.ts
deleted file mode 100644
index 416b473..0000000
--- a/reference/typescript/src/providers/codex/translate/model-allowlist.test.ts
+++ /dev/null
@@ -1,102 +0,0 @@
-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";
-
-afterEach(() => {
- loadConfig({ forceReload: true });
-});
-
-function withTempCodexConfig(
- env: Record<string, string> | undefined,
- callback: () => void,
-) {
- 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: env ?? {}, forceReload: true });
- callback();
- } finally {
- rmSync(dir, { recursive: true, force: true });
- }
-}
-
-describe("resolveModel", () => {
- it("returns alias when no override is set", () => {
- loadConfig({ env: {}, forceReload: true });
- expect(resolveModel("sonnet")).toBe("gpt-5.4");
- });
-
- it("env CCP_CODEX_MODEL takes precedence", () => {
- loadConfig({ env: { CCP_CODEX_MODEL: "gpt-5.2" }, forceReload: true });
- expect(resolveModel("sonnet")).toBe("gpt-5.2");
- });
-
- it("config.json codex.model overrides aliases", () => {
- withTempCodexConfig({}, () => {
- expect(resolveModel("sonnet")).toBe("gpt-5.5");
- });
- });
-
- it("empty CCP_CODEX_MODEL env is treated as unset (no regression)", () => {
- withTempCodexConfig({ CCP_CODEX_MODEL: "" }, () => {
- // Empty env should fall through to file value
- expect(resolveModel("sonnet")).toBe("gpt-5.5");
- });
- });
-
- 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");
- });
-
- it("detects fast model aliases", () => {
- 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 });
- expect(resolveModelRequest("gpt-5.4-fast")).toEqual({
- model: "gpt-5.5",
- serviceTier: "priority",
- });
- });
-
- it("model override accepts fast model aliases", () => {
- loadConfig({ env: { CCP_CODEX_MODEL: "gpt-5.5-fast" }, forceReload: true });
- expect(resolveModelRequest("gpt-5.4")).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" });
- });
-
- it("resolves every shared Anthropic-style alias to an allowed model", () => {
- loadConfig({ env: {}, forceReload: true });
-
- for (const alias of ANTHROPIC_STYLE_ALIASES) {
- expect(ALLOWED_MODELS.has(resolveModel(alias))).toBe(true);
- }
- });
-
- it("keeps the shared alias routing set aligned with Codex model aliases", () => {
- expect([...ANTHROPIC_STYLE_ALIASES].sort()).toEqual([...MODEL_ALIASES.keys()].sort());
- });
-});
diff --git a/reference/typescript/src/providers/codex/translate/model-allowlist.ts b/reference/typescript/src/providers/codex/translate/model-allowlist.ts
deleted file mode 100644
index 87c29c7..0000000
--- a/reference/typescript/src/providers/codex/translate/model-allowlist.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-import { codexModel } from "../../../config.ts";
-import type { ServiceTier } from "./request.ts";
-
-export const ALLOWED_MODELS = new Set([
- "gpt-5.2",
- "gpt-5.3-codex",
- "gpt-5.3-codex-spark",
- "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 MODEL_ALIASES = new Map<string, string>([
- ["haiku", "gpt-5.4-mini"],
- ["claude-haiku-4-5", "gpt-5.4-mini"],
- ["claude-haiku-4-5-20251001", "gpt-5.4-mini"],
- ["sonnet", "gpt-5.4"],
- ["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;
-}
-
-export function resolveModel(model: string): string {
- return resolveModelRequest(model).model;
-}
-
-export function resolveModelRequest(model: string): ResolvedModel {
- // CCP_CODEX_MODEL (env) or codex.model (config.json) overrides the model
- // so that regardless of whatever model is requested by the harness, the
- // provided model is always used. Empty values fall through to alias
- // resolution.
- const alias = MODEL_ALIASES.get(model) ?? model;
- const requested = resolveFastModelAlias(alias);
- const override = codexModel();
- const resolved = override === undefined ? requested : resolveFastModelAlias(override);
-
- return {
- model: resolved.model,
- ...(requested.serviceTier === "priority" || resolved.serviceTier === "priority"
- ? { serviceTier: "priority" }
- : {}),
- };
-}
-
-function resolveFastModelAlias(model: string): ResolvedModel {
- if (!FAST_MODEL_ALIASES.has(model)) return { model };
-
- return {
- model: model.slice(0, -"-fast".length),
- serviceTier: "priority",
- };
-}
-
-export function assertAllowedModel(model: string): void {
- 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";
- }
-}
diff --git a/reference/typescript/src/providers/codex/translate/reducer.test.ts b/reference/typescript/src/providers/codex/translate/reducer.test.ts
deleted file mode 100644
index 894e451..0000000
--- a/reference/typescript/src/providers/codex/translate/reducer.test.ts
+++ /dev/null
@@ -1,269 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { reduceUpstream } from "./reducer.ts";
-import {
- sse,
- silentLog,
- upstreamFromChunks,
- upstreamThatErrorsAfterChunks,
-} from "./test-helpers.ts";
-
-async function events(chunks: string[]) {
- return collectEvents(upstreamFromChunks(chunks));
-}
-
-async function collectEvents(upstream: ReadableStream<Uint8Array>) {
- const out = [];
- for await (const event of reduceUpstream(upstream, silentLog)) out.push(event);
- return out;
-}
-
-describe("reduceUpstream finish metadata", () => {
- it("captures completed response id and assistant text output items", async () => {
- const out = await events([
- sse("response.output_item.added", {
- output_index: 0,
- item: { type: "message", id: "msg_upstream" },
- }),
- sse("response.output_text.delta", { output_index: 0, delta: "hello" }),
- sse("response.output_item.done", {
- output_index: 0,
- item: { type: "message", id: "msg_upstream" },
- }),
- sse("response.completed", { response: { id: "resp_1", usage: { input_tokens: 3 } } }),
- ]);
-
- expect(out.at(-1)).toEqual({
- kind: "finish",
- stopReason: "end_turn",
- terminalType: "response.completed",
- continuationEligible: true,
- usage: { input_tokens: 3 },
- webSearchRequests: 0,
- responseId: "resp_1",
- outputItems: [
- { type: "message", role: "assistant", content: [{ type: "output_text", text: "hello" }] },
- ],
- });
- });
-
- it("captures sanitized Read function call arguments", async () => {
- const out = await events([
- sse("response.output_item.added", {
- output_index: 0,
- item: { type: "function_call", call_id: "call_1", name: "Read" },
- }),
- sse("response.function_call_arguments.done", {
- output_index: 0,
- arguments: '{"file_path":"/tmp/a","pages":""}',
- }),
- sse("response.output_item.done", {
- output_index: 0,
- item: {
- type: "function_call",
- call_id: "call_1",
- name: "Read",
- arguments: '{"file_path":"/tmp/a","pages":""}',
- },
- }),
- sse("response.completed", { response: { id: "resp_1", usage: {} } }),
- ]);
-
- expect(out.at(-1)).toMatchObject({
- kind: "finish",
- stopReason: "tool_use",
- terminalType: "response.completed",
- continuationEligible: true,
- webSearchRequests: 0,
- responseId: "resp_1",
- outputItems: [
- {
- type: "function_call",
- call_id: "call_1",
- name: "Read",
- arguments: '{"file_path":"/tmp/a"}',
- },
- ],
- });
- });
-
- it("repairs whitespace-stalled Read function call arguments", async () => {
- const out = await events([
- sse("response.output_item.added", {
- output_index: 0,
- item: { type: "function_call", call_id: "call_1", name: "Read" },
- }),
- sse("response.function_call_arguments.delta", {
- output_index: 0,
- delta: '{"file_path":"/tmp/a","limit":2200',
- }),
- sse("response.function_call_arguments.delta", {
- output_index: 0,
- delta: " ".repeat(1024),
- }),
- ]);
-
- expect(out).toContainEqual({
- kind: "tool-delta",
- index: 0,
- partialJson: '{"file_path":"/tmp/a","limit":2200}',
- });
- expect(out).toContainEqual({ kind: "tool-stop", index: 0 });
- expect(out.at(-1)).toEqual({
- kind: "finish",
- stopReason: "tool_use",
- terminalType: "response.incomplete",
- continuationEligible: false,
- usage: undefined,
- webSearchRequests: 0,
- responseId: undefined,
- outputItems: [
- {
- type: "function_call",
- call_id: "call_1",
- name: "Read",
- arguments: '{"file_path":"/tmp/a","limit":2200}',
- },
- ],
- });
- });
-
- it("treats hosted web search response events as progress", async () => {
- const out = await events([
- sse("response.output_item.added", {
- output_index: 0,
- item: { type: "web_search_call", id: "ws_1", status: "in_progress" },
- }),
- sse("response.web_search_call.in_progress", { output_index: 0, item_id: "ws_1" }),
- sse("response.web_search_call.searching", { output_index: 0, item_id: "ws_1" }),
- sse("response.web_search_call.completed", { output_index: 0, item_id: "ws_1" }),
- sse("response.output_item.done", {
- output_index: 0,
- item: { type: "web_search_call", id: "ws_1", status: "completed" },
- }),
- sse("response.output_item.added", {
- output_index: 1,
- item: { type: "message", id: "msg_upstream" },
- }),
- sse("response.output_text.delta", { output_index: 1, delta: "result text" }),
- sse("response.output_item.done", {
- output_index: 1,
- item: { type: "message", id: "msg_upstream" },
- }),
- sse("response.completed", { response: { id: "resp_1", usage: { input_tokens: 3 } } }),
- ]);
-
- expect(out.filter((event) => event.kind === "progress").length).toBeGreaterThanOrEqual(3);
- expect(out).toContainEqual({
- kind: "web-search",
- index: 0,
- resultIndex: 1,
- id: "srvtoolu_ws_1",
- query: "",
- });
- expect(out.at(-1)).toEqual({
- kind: "finish",
- stopReason: "end_turn",
- terminalType: "response.completed",
- continuationEligible: true,
- usage: { input_tokens: 3 },
- webSearchRequests: 1,
- responseId: "resp_1",
- outputItems: [
- {
- type: "message",
- role: "assistant",
- content: [{ type: "output_text", text: "result text" }],
- },
- ],
- });
- });
-
- it("finishes completed tool calls when the Codex WebSocket closes before a terminal event", async () => {
- const out = await collectEvents(
- upstreamThatErrorsAfterChunks(
- [
- sse("response.output_item.added", {
- output_index: 0,
- item: { type: "function_call", call_id: "call_1", name: "WebSearch" },
- }),
- sse("response.function_call_arguments.done", {
- output_index: 0,
- arguments: '{"query":"claude-code-proxy github"}',
- }),
- sse("response.output_item.done", {
- output_index: 0,
- item: {
- type: "function_call",
- call_id: "call_1",
- name: "WebSearch",
- arguments: '{"query":"claude-code-proxy github"}',
- },
- }),
- ],
- new Error("Codex WebSocket connection closed"),
- ),
- );
-
- expect(out.at(-1)).toEqual({
- kind: "finish",
- stopReason: "tool_use",
- terminalType: "response.incomplete",
- continuationEligible: false,
- usage: undefined,
- webSearchRequests: 0,
- responseId: undefined,
- outputItems: [
- {
- type: "function_call",
- call_id: "call_1",
- name: "WebSearch",
- arguments: '{"query":"claude-code-proxy github"}',
- },
- ],
- });
- });
-
- it("marks response.done as continuation eligible when complete", async () => {
- const out = await events([
- sse("response.done", {
- response: {
- id: "resp_1",
- usage: {},
- },
- }),
- ]);
-
- expect(out.at(-1)).toMatchObject({
- kind: "finish",
- stopReason: "end_turn",
- terminalType: "response.done",
- continuationEligible: true,
- webSearchRequests: 0,
- responseId: "resp_1",
- outputItems: [],
- });
- });
-
- it("marks incomplete terminals as max tokens and preserves terminal type", async () => {
- const out = await events([
- sse("response.incomplete", {
- response: {
- id: "resp_1",
- status: "incomplete",
- incomplete_details: { reason: "max_output_tokens" },
- usage: {},
- },
- }),
- ]);
-
- expect(out.at(-1)).toMatchObject({
- kind: "finish",
- stopReason: "max_tokens",
- terminalType: "response.incomplete",
- continuationEligible: false,
- webSearchRequests: 0,
- responseId: "resp_1",
- outputItems: [],
- });
- });
-});
diff --git a/reference/typescript/src/providers/codex/translate/reducer.ts b/reference/typescript/src/providers/codex/translate/reducer.ts
deleted file mode 100644
index 0b374bf..0000000
--- a/reference/typescript/src/providers/codex/translate/reducer.ts
+++ /dev/null
@@ -1,775 +0,0 @@
-import { createSseStreamStats, parseSseStream, type SseStreamStats } from "../../../sse.ts";
-import type { Logger } from "../../../log.ts";
-import { logVerbose } from "../../../config.ts";
-import type { TrafficCapture } from "../../types.ts";
-import type { TextToolReducerEvent } from "../../translate/accumulate.ts";
-import { mapCachedInputUsageToAnthropicUsage } from "../../translate/accumulate.ts";
-import type { ResponsesInputItem } from "./request.ts";
-import { serverToolUseIdFromCodexWebSearchId } from "./web-search-compat.ts";
-
-export class UpstreamStreamError extends Error {
- constructor(
- public kind: "rate_limit" | "overloaded" | "transient" | "failed",
- message: string,
- public retryAfterSeconds?: number,
- ) {
- 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 };
-}
-
-export type StopReason = "end_turn" | "tool_use" | "max_tokens";
-export type TerminalType = "response.completed" | "response.incomplete" | "response.done";
-
-export type ReducerEvent =
- | TextToolReducerEvent
- | { kind: "tool-progress"; index: number }
- | { kind: "progress" }
- | {
- kind: "web-search";
- index: number;
- resultIndex: number;
- id: string;
- query: string;
- }
- | {
- kind: "finish";
- stopReason: StopReason;
- terminalType: TerminalType;
- continuationEligible: boolean;
- usage: CodexUsage | undefined;
- webSearchRequests: number;
- responseId?: string;
- outputItems: ResponsesInputItem[];
- };
-
-interface TextState {
- kind: "text";
- index: number;
- textAccum: string;
-}
-interface ToolState {
- kind: "tool";
- index: number;
- outputIndex: number;
- callId: string;
- name: string;
- argsAccum: string;
- deltaCount: number;
- startedAt: number;
- lastProgressLogAt: number;
- largeArgsLogged: boolean;
- hadDelta: boolean;
- bufferUntilDone: boolean;
- emittedArgs: boolean;
-}
-type BlockState = TextState | ToolState;
-
-const BUFFERED_TOOL_PROGRESS_LOG_INTERVAL_MS = 30_000;
-const BUFFERED_TOOL_LARGE_ARGS_BYTES = 1_000_000;
-const BUFFERED_TOOL_MAX_ARGS_BYTES = 5_000_000;
-const BUFFERED_TOOL_MAX_DURATION_MS = 120_000;
-const BUFFERED_READ_REPAIR_TRAILING_WHITESPACE_BYTES = 1_024;
-
-function shouldBufferToolArgs(name: string): boolean {
- return name === "Read";
-}
-
-function sanitizeToolArgs(name: string, args: string): string {
- 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);
- } catch {
- return args;
- }
-}
-
-function toolArgSummary(args: string): Record<string, unknown> {
- const trimmed = args.trimEnd();
- return {
- length: args.length,
- trimmedLength: trimmed.length,
- trailingWhitespace: args.length - trimmed.length,
- prefix: args.slice(0, 120),
- suffix: args.slice(-120),
- };
-}
-
-function toolArgJsonState(args: string): Record<string, unknown> {
- const trimmed = args.trimEnd();
- try {
- const parsed = JSON.parse(trimmed);
- return {
- parseOk: true,
- parsedKeys:
- parsed && typeof parsed === "object" && !Array.isArray(parsed)
- ? Object.keys(parsed)
- : undefined,
- trimmedLength: trimmed.length,
- trailingWhitespace: args.length - trimmed.length,
- };
- } catch (err) {
- return {
- parseOk: false,
- parseError: err instanceof Error ? err.message : String(err),
- trimmedLength: trimmed.length,
- trailingWhitespace: args.length - trimmed.length,
- };
- }
-}
-
-function parseReadArgsCandidate(args: string): string | undefined {
- let parsed: unknown;
- try {
- parsed = JSON.parse(args);
- } catch {
- return undefined;
- }
- if (!isValidReadArgs(parsed)) return undefined;
- return sanitizeToolArgs("Read", JSON.stringify(parsed));
-}
-
-function isValidReadArgs(value: unknown): value is Record<string, unknown> {
- if (!value || typeof value !== "object" || Array.isArray(value)) return false;
- const allowed = new Set(["file_path", "offset", "limit", "pages"]);
- for (const key of Object.keys(value)) {
- if (!allowed.has(key)) return false;
- }
- const args = value as Record<string, unknown>;
- if (typeof args.file_path !== "string" || !args.file_path) return false;
- if (
- args.offset !== undefined &&
- (!Number.isSafeInteger(args.offset) || (args.offset as number) < 0)
- )
- return false;
- if (
- args.limit !== undefined &&
- (!Number.isSafeInteger(args.limit) || (args.limit as number) <= 0)
- )
- return false;
- if (args.pages !== undefined && typeof args.pages !== "string") return false;
- return true;
-}
-
-function repairWhitespaceStalledReadArgs(log: Logger, state: ToolState): string | undefined {
- if (!state.bufferUntilDone || state.name !== "Read") return undefined;
- const trimmed = state.argsAccum.trimEnd();
- const trailingWhitespace = state.argsAccum.length - trimmed.length;
- if (trailingWhitespace < BUFFERED_READ_REPAIR_TRAILING_WHITESPACE_BYTES) return undefined;
-
- const repaired = parseReadArgsCandidate(trimmed) ?? parseReadArgsCandidate(`${trimmed}}`);
- if (!repaired) return undefined;
-
- log.warn("repairing whitespace-stalled Read tool arguments", {
- outputIndex: state.outputIndex,
- index: state.index,
- callId: state.callId,
- name: state.name,
- deltaCount: state.deltaCount,
- elapsedMs: Date.now() - state.startedAt,
- args: toolArgSummary(state.argsAccum),
- repaired: toolArgJsonState(repaired),
- });
- return repaired;
-}
-
-function logBufferedToolProgress(log: Logger, state: ToolState, force = false): void {
- if (!state.bufferUntilDone) return;
- const now = Date.now();
- const large = state.argsAccum.length >= BUFFERED_TOOL_LARGE_ARGS_BYTES && !state.largeArgsLogged;
- const stale = now - state.lastProgressLogAt >= BUFFERED_TOOL_PROGRESS_LOG_INTERVAL_MS;
- if (!force && !large && !stale) return;
- if (large) state.largeArgsLogged = true;
- state.lastProgressLogAt = now;
- log.info("buffered tool arguments progress", {
- outputIndex: state.outputIndex,
- index: state.index,
- callId: state.callId,
- name: state.name,
- deltaCount: state.deltaCount,
- elapsedMs: now - state.startedAt,
- args: toolArgSummary(state.argsAccum),
- });
-}
-
-function throwIfBufferedToolExceeded(log: Logger, state: ToolState): void {
- if (!state.bufferUntilDone) return;
- const elapsedMs = Date.now() - state.startedAt;
- if (
- state.argsAccum.length <= BUFFERED_TOOL_MAX_ARGS_BYTES &&
- elapsedMs <= BUFFERED_TOOL_MAX_DURATION_MS
- )
- return;
- log.warn("buffered tool arguments exceeded safe limits", {
- outputIndex: state.outputIndex,
- index: state.index,
- callId: state.callId,
- name: state.name,
- deltaCount: state.deltaCount,
- elapsedMs,
- args: toolArgSummary(state.argsAccum),
- json: toolArgJsonState(state.argsAccum),
- });
- throw new UpstreamStreamError(
- "failed",
- `Buffered ${state.name} tool arguments exceeded safe limits`,
- );
-}
-
-function describeOpenBlock(outputIndex: number, state: BlockState): Record<string, unknown> {
- if (state.kind === "text") {
- return {
- outputIndex,
- index: state.index,
- kind: state.kind,
- textLength: state.textAccum.length,
- };
- }
- return {
- outputIndex,
- index: state.index,
- kind: state.kind,
- callId: state.callId,
- name: state.name,
- deltaCount: state.deltaCount,
- elapsedMs: Date.now() - state.startedAt,
- bufferUntilDone: state.bufferUntilDone,
- emittedArgs: state.emittedArgs,
- args: toolArgSummary(state.argsAccum),
- json: toolArgJsonState(state.argsAccum),
- };
-}
-
-/**
- * Single source of truth for translating Codex Responses SSE into a
- * stream of typed, downstream-agnostic ReducerEvents. Both the streaming
- * and non-streaming frontends consume this generator.
- *
- * Throws UpstreamStreamError on codex.rate_limits.limit_reached or
- * response.failed/response.error. Any usage that arrived before the
- * failure is discarded.
- */
-export interface UpstreamStreamDiagnostics {
- stats: SseStreamStats;
- lastEventType?: string;
- sawTerminalEvent: boolean;
- traffic?: TrafficCapture;
-}
-
-export function createUpstreamStreamDiagnostics(): UpstreamStreamDiagnostics {
- return {
- stats: createSseStreamStats(),
- sawTerminalEvent: false,
- };
-}
-
-export function attachTrafficCapture(
- diagnostics: UpstreamStreamDiagnostics,
- traffic: TrafficCapture | undefined,
-): UpstreamStreamDiagnostics {
- diagnostics.traffic = traffic;
- return diagnostics;
-}
-
-export async function* reduceUpstream(
- upstream: ReadableStream<Uint8Array>,
- log: Logger,
- diagnostics = createUpstreamStreamDiagnostics(),
-): AsyncGenerator<ReducerEvent> {
- const blocksByOutputIndex = new Map<number, BlockState>();
- const outputItemsByIndex = new Map<number, ResponsesInputItem>();
- const itemIdToOutputIndex = new Map<string, number>();
- let anthropicIndex = 0;
- let sawToolUse = false;
- let finalUsage: CodexUsage | undefined;
- let responseId: string | undefined;
- let terminalType: TerminalType | undefined;
- let continuationEligible = false;
- let incomplete = false;
- let webSearchRequests = 0;
-
- function canFinishAfterClosedCompletedToolCall(err: unknown): boolean {
- return (
- sawToolUse &&
- outputItemsByIndex.size > 0 &&
- blocksByOutputIndex.size === 0 &&
- isCodexWebSocketCloseError(err)
- );
- }
-
- function captureOutputItem(outputIndex: number, state: BlockState): void {
- if (state.kind === "text") {
- if (!state.textAccum) return;
- outputItemsByIndex.set(outputIndex, {
- type: "message",
- role: "assistant",
- content: [{ type: "output_text", text: state.textAccum }],
- });
- return;
- }
- outputItemsByIndex.set(outputIndex, {
- type: "function_call",
- call_id: state.callId,
- name: state.name,
- arguments: state.argsAccum,
- });
- }
-
- const events = parseSseStream(upstream, diagnostics.stats);
- while (true) {
- let next: Awaited<ReturnType<typeof events.next>>;
- try {
- next = await events.next();
- } catch (err) {
- if (canFinishAfterClosedCompletedToolCall(err)) {
- diagnostics.sawTerminalEvent = true;
- terminalType = "response.incomplete";
- incomplete = false;
- continuationEligible = false;
- log.warn("upstream websocket closed after completed tool call", {
- err: err instanceof Error ? err.message : String(err),
- lastEventType: diagnostics.lastEventType,
- stats: diagnostics.stats,
- });
- break;
- }
- throw upstreamReadError(err);
- }
- if (next.done) break;
- const evt = next.value;
- if (!evt.data) continue;
- let p: any;
- try {
- p = JSON.parse(evt.data);
- } catch (err) {
- log.warn("upstream sse: invalid json", { err: String(err), preview: evt.data.slice(0, 200) });
- continue;
- }
- const t: string = p.type || evt.event || "";
- diagnostics.lastEventType = t;
- diagnostics.traffic?.writeJsonEvent("040-upstream-event", p);
-
- 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) {
- throw new UpstreamStreamError(
- "rate_limit",
- "rate limit reached",
- p.rate_limits?.primary?.reset_after_seconds,
- );
- }
- yield { kind: "progress" };
- continue;
- }
- if (t === "keepalive") {
- yield { kind: "progress" };
- continue;
- }
- if (
- t === "response.web_search_call.in_progress" ||
- t === "response.web_search_call.searching" ||
- t === "response.web_search_call.completed"
- ) {
- yield { kind: "progress" };
- continue;
- }
- if (t === "response.failed" || t === "response.error" || t === "error") {
- const message = p?.response?.error?.message || p?.error?.message || "Upstream error";
- throw new UpstreamStreamError(
- upstreamFailureKind(p, message),
- message,
- retryAfterSecondsFromPayload(p),
- );
- }
-
- if (t === "response.output_item.added") {
- const item = p.item;
- const outputIndex: number = p.output_index;
- if (!item) continue;
- if (item.type === "reasoning") continue;
- if (item.type === "web_search_call") {
- yield { kind: "progress" };
- 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;
- }
- if (item.type === "function_call") {
- sawToolUse = true;
- const idx = anthropicIndex++;
- const bufferUntilDone = shouldBufferToolArgs(item.name);
- blocksByOutputIndex.set(outputIndex, {
- kind: "tool",
- index: idx,
- outputIndex,
- callId: item.call_id,
- name: item.name,
- argsAccum: "",
- deltaCount: 0,
- startedAt: Date.now(),
- lastProgressLogAt: Date.now(),
- largeArgsLogged: false,
- hadDelta: false,
- bufferUntilDone,
- emittedArgs: false,
- });
- log.info("tool block started", {
- outputIndex,
- index: idx,
- callId: item.call_id,
- name: item.name,
- bufferUntilDone,
- });
- yield { kind: "tool-start", index: idx, id: item.call_id, name: item.name };
- 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);
- if (!state && itemId) {
- 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 (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.deltaCount += 1;
- state.hadDelta = true;
- logBufferedToolProgress(log, state);
- const repairedArgs = repairWhitespaceStalledReadArgs(log, state);
- if (repairedArgs) {
- state.argsAccum = repairedArgs;
- state.emittedArgs = true;
- captureOutputItem(p.output_index, state);
- yield { kind: "tool-delta", index: state.index, partialJson: state.argsAccum };
- yield { kind: "tool-stop", index: state.index };
- blocksByOutputIndex.delete(p.output_index);
- const outputItems = Array.from(outputItemsByIndex.entries())
- .sort(([a], [b]) => a - b)
- .map(([, item]) => item);
- yield {
- kind: "finish",
- stopReason: "tool_use",
- terminalType: "response.incomplete",
- continuationEligible: false,
- usage: undefined,
- webSearchRequests,
- responseId: undefined,
- outputItems,
- };
- await events.return?.(undefined);
- return;
- }
- throwIfBufferedToolExceeded(log, state);
- if (!state.bufferUntilDone) {
- state.emittedArgs = true;
- yield { kind: "tool-delta", index: state.index, partialJson: delta };
- } else {
- yield { kind: "tool-progress", index: state.index };
- }
- continue;
- }
-
- if (t === "response.function_call_arguments.done") {
- const state = blocksByOutputIndex.get(p.output_index);
- if (!state || state.kind !== "tool") continue;
- if (typeof p.arguments === "string" && !state.argsAccum) {
- state.argsAccum = p.arguments;
- }
- log.info("tool arguments done", {
- outputIndex: p.output_index,
- index: state.index,
- callId: state.callId,
- name: state.name,
- deltaCount: state.deltaCount,
- elapsedMs: Date.now() - state.startedAt,
- args: toolArgSummary(state.argsAccum),
- });
- continue;
- }
-
- if (t === "response.output_item.done") {
- const item = p.item;
- if (item?.type === "web_search_call") {
- const idx = anthropicIndex++;
- const resultIndex = anthropicIndex++;
- webSearchRequests += 1;
- yield {
- kind: "web-search",
- index: idx,
- resultIndex,
- id: serverToolUseIdFromCodexWebSearchId(item.id),
- query: webSearchQuery(item),
- };
- continue;
- }
- const state = blocksByOutputIndex.get(p.output_index);
- if (!state) continue;
- if (!item) {
- log.warn("output item done without item", {
- outputIndex: p.output_index,
- stateKind: state.kind,
- });
- 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 (state.kind === "tool") {
- const finalArgs =
- (typeof item.arguments === "string" && item.arguments.length
- ? item.arguments
- : state.argsAccum) || "";
- log.info("tool output item done", {
- outputIndex: p.output_index,
- index: state.index,
- callId: state.callId,
- name: state.name,
- itemType: item.type,
- deltaCount: state.deltaCount,
- elapsedMs: Date.now() - state.startedAt,
- finalArgs: toolArgSummary(finalArgs),
- });
- if (finalArgs.length) {
- state.argsAccum = sanitizeToolArgs(state.name, finalArgs);
- if (state.bufferUntilDone || !state.emittedArgs) {
- state.emittedArgs = true;
- yield { kind: "tool-delta", index: state.index, partialJson: state.argsAccum };
- }
- }
- }
- captureOutputItem(p.output_index, state);
- if (state.kind === "text") {
- 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: toolArgSummary(state.argsAccum),
- });
- yield { kind: "tool-stop", index: state.index };
- }
- blocksByOutputIndex.delete(p.output_index);
- continue;
- }
-
- if (t === "response.completed" || t === "response.incomplete" || t === "response.done") {
- diagnostics.sawTerminalEvent = true;
- terminalType = t;
- responseId = p.response?.id;
- finalUsage = p.response?.usage;
- const reason = p.response?.incomplete_details?.reason;
- if (
- t === "response.incomplete" ||
- reason !== undefined ||
- p.response?.status === "incomplete"
- ) {
- incomplete = true;
- }
- continuationEligible = (t === "response.completed" || t === "response.done") && !incomplete;
- continue;
- }
- }
-
- const openBlocks = Array.from(blocksByOutputIndex, ([outputIndex, state]) =>
- describeOpenBlock(outputIndex, state),
- );
- if (!diagnostics.sawTerminalEvent || openBlocks.length) {
- log.warn("upstream stream ended without complete response", {
- sawTerminalEvent: diagnostics.sawTerminalEvent,
- lastEventType: diagnostics.lastEventType,
- openBlocks,
- stats: diagnostics.stats,
- });
- throw new UpstreamStreamError(
- "failed",
- diagnostics.sawTerminalEvent
- ? "Upstream stream ended with open output blocks"
- : "Upstream stream ended without a terminal response event",
- );
- }
-
- const stopReason: StopReason = incomplete ? "max_tokens" : sawToolUse ? "tool_use" : "end_turn";
- const outputItems = Array.from(outputItemsByIndex.entries())
- .sort(([a], [b]) => a - b)
- .map(([, item]) => item);
- yield {
- kind: "finish",
- stopReason,
- terminalType: terminalType ?? "response.incomplete",
- continuationEligible,
- usage: finalUsage,
- webSearchRequests,
- responseId,
- outputItems,
- };
-}
-
-function webSearchQuery(item: unknown): string {
- if (!item || typeof item !== "object") return "";
- const action = (item as { action?: unknown }).action;
- if (!action || typeof action !== "object") return "";
- const query = (action as { query?: unknown }).query;
- if (typeof query === "string") return query;
- const queries = (action as { queries?: unknown }).queries;
- if (Array.isArray(queries)) {
- const first = queries.find((value): value is string => typeof value === "string");
- return first ?? "";
- }
- return "";
-}
-
-function upstreamFailureKind(
- payload: {
- status?: unknown;
- status_code?: unknown;
- response?: { error?: { code?: unknown; type?: unknown } };
- error?: { code?: unknown; type?: unknown };
- },
- message: string,
-): "overloaded" | "transient" | "failed" {
- const status = payload.status ?? payload.status_code;
- const code = payload.response?.error?.code ?? payload.error?.code;
- const type = payload.response?.error?.type ?? payload.error?.type;
- const lowerMessage = message.toLowerCase();
- if (
- status === 529 ||
- status === "529" ||
- code === "overloaded_error" ||
- type === "overloaded_error" ||
- lowerMessage.includes("overloaded")
- ) {
- return "overloaded";
- }
- if (
- is5xxStatus(status) ||
- code === "server_error" ||
- code === "internal_server_error" ||
- code === "internal_error" ||
- type === "server_error" ||
- type === "internal_server_error" ||
- type === "internal_error" ||
- isRetryableTransportOrServerMessage(lowerMessage)
- ) {
- return "transient";
- }
- return "failed";
-}
-
-function is5xxStatus(status: unknown): boolean {
- const value =
- typeof status === "number" ? status : typeof status === "string" ? Number(status) : NaN;
- return Number.isInteger(value) && value >= 500 && value < 600;
-}
-
-function retryAfterSecondsFromPayload(payload: {
- retry_after_seconds?: unknown;
- headers?: Record<string, unknown>;
- response?: { error?: { retry_after_seconds?: unknown } };
- error?: { retry_after_seconds?: unknown };
-}): number | undefined {
- const raw =
- payload.response?.error?.retry_after_seconds ??
- payload.error?.retry_after_seconds ??
- payload.retry_after_seconds ??
- payload.headers?.["retry-after"] ??
- payload.headers?.["Retry-After"];
- const value = typeof raw === "number" ? raw : typeof raw === "string" ? Number(raw) : NaN;
- return Number.isFinite(value) && value >= 0 ? value : undefined;
-}
-
-function isCodexWebSocketCloseError(err: unknown): boolean {
- const message = err instanceof Error ? err.message : String(err);
- return (
- message.includes("Codex WebSocket connection closed") ||
- message.includes("Codex WebSocket closed before terminal event")
- );
-}
-
-function upstreamReadError(err: unknown): Error {
- if (err instanceof UpstreamStreamError) return err;
- const message = err instanceof Error ? err.message : String(err);
- return new UpstreamStreamError(
- isRetryableTransportOrServerMessage(message.toLowerCase()) ? "transient" : "failed",
- `Upstream stream read failed: ${message}`,
- );
-}
-
-function isRetryableTransportOrServerMessage(lowerMessage: string): boolean {
- return (
- lowerMessage.includes("you can retry your request") ||
- lowerMessage.includes("socket connection was closed unexpectedly") ||
- lowerMessage.includes("connection closed unexpectedly") ||
- lowerMessage.includes("connection reset") ||
- lowerMessage.includes("operation timed out") ||
- lowerMessage.includes("econnreset") ||
- lowerMessage.includes("epipe") ||
- lowerMessage.includes("etimedout") ||
- lowerMessage.includes("und_err_socket") ||
- lowerMessage.includes("fetch failed")
- );
-}
-
-export function mapUsageToAnthropic(
- u: CodexUsage | undefined,
- opts: { webSearchRequests?: number } = {},
-): {
- input_tokens: number;
- output_tokens: number;
- cache_creation_input_tokens: number;
- cache_read_input_tokens: number;
- server_tool_use?: { web_search_requests?: number };
-} {
- // OpenAI-style usage reports cached prompt tokens inside input_tokens.
- // Anthropic-style usage reports cache reads separately, and Claude Code
- // sums input_tokens + cache_read_input_tokens when deciding context size.
- // Subtract cached reads here so the downstream total matches the real
- // prompt window instead of double-counting cached context.
- const usage = mapCachedInputUsageToAnthropicUsage({
- inputTokens: u?.input_tokens,
- outputTokens: u?.output_tokens,
- cachedInputTokens: u?.input_tokens_details?.cached_tokens,
- });
- if (opts.webSearchRequests && opts.webSearchRequests > 0) {
- usage.server_tool_use = { web_search_requests: opts.webSearchRequests };
- }
- return usage;
-}
diff --git a/reference/typescript/src/providers/codex/translate/request.test.ts b/reference/typescript/src/providers/codex/translate/request.test.ts
deleted file mode 100644
index e4f964c..0000000
--- a/reference/typescript/src/providers/codex/translate/request.test.ts
+++ /dev/null
@@ -1,337 +0,0 @@
-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,
- toWebSocketRequest,
- toolResultToString,
- translateRequest,
-} from "./request.ts";
-const baseRequest: AnthropicRequest = {
- model: "claude-sonnet-4-6",
- messages: [{ role: "user", content: "hello" }],
-};
-
-afterEach(() => {
- loadConfig({ forceReload: true });
-});
-
-describe("translateRequest", () => {
- it("omits reasoning include when reasoning is not enabled", () => {
- const translated = translateRequest(baseRequest);
-
- 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"]);
- });
-
- it("translates Anthropic web search to the Codex hosted web_search tool", () => {
- const translated = translateRequest({
- ...baseRequest,
- tools: [
- {
- type: "web_search_20250305",
- name: "web_search",
- allowed_domains: [],
- blocked_domains: [],
- max_uses: 8,
- },
- ],
- });
-
- expect(translated.tools).toEqual([
- {
- type: "web_search",
- external_web_access: false,
- search_content_types: ["text", "image"],
- },
- ]);
- });
-
- it("maps forced Anthropic web search choice to Codex hosted search choice", () => {
- const translated = translateRequest({
- ...baseRequest,
- tools: [
- {
- type: "web_search_20250305",
- name: "web_search",
- },
- ],
- tool_choice: { type: "tool", name: "web_search" },
- });
-
- expect(translated.tools).toEqual([
- {
- type: "web_search",
- external_web_access: false,
- search_content_types: ["text", "image"],
- },
- ]);
- expect(translated.tool_choice).toEqual({ type: "web_search" });
- });
-
- it("preserves non-empty Anthropic web search domain filters", () => {
- const translated = translateRequest({
- ...baseRequest,
- tools: [
- {
- type: "web_search_20250305",
- name: "web_search",
- allowed_domains: ["github.com"],
- blocked_domains: ["example.com"],
- },
- ],
- });
-
- expect(translated.tools).toEqual([
- {
- type: "web_search",
- external_web_access: false,
- search_content_types: ["text", "image"],
- filters: {
- allowed_domains: ["github.com"],
- blocked_domains: ["example.com"],
- },
- },
- ]);
- });
-
- it("normalizes fast service tier to upstream priority", () => {
- loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "fast" }, forceReload: true });
-
- const translated = translateRequest(baseRequest);
-
- expect(translated.service_tier).toBe("priority");
- });
-
- it("passes flex service tier through", () => {
- loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "flex" }, forceReload: true });
-
- const translated = translateRequest(baseRequest);
-
- expect(translated.service_tier).toBe("flex");
- });
-
- it("uses model service tier when no override is set", () => {
- loadConfig({ env: {}, forceReload: true });
-
- const translated = translateRequest(baseRequest, { serviceTier: "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 });
-
- const translated = translateRequest(baseRequest, { serviceTier: "priority" });
-
- expect(translated.service_tier).toBe("flex");
- });
-
- it("rejects invalid service tier overrides", () => {
- loadConfig({ env: { CCP_CODEX_SERVICE_TIER: "standard" }, forceReload: true });
-
- expect(() => translateRequest(baseRequest)).toThrow(InvalidServiceTierError);
- expect(() => translateRequest(baseRequest)).toThrow(
- 'Invalid service tier override: "standard"',
- );
- });
-
- it("translates mid-conversation system messages as developer input", () => {
- const translated = translateRequest({
- ...baseRequest,
- messages: [
- { role: "user", content: "hello" },
- { role: "system", content: "remember this runtime constraint" },
- ],
- });
-
- expect(translated.input).toEqual([
- {
- type: "message",
- role: "user",
- content: [{ type: "input_text", text: "hello" }],
- },
- {
- type: "message",
- role: "developer",
- content: [{ type: "input_text", text: "remember this runtime constraint" }],
- },
- ]);
- });
-
- it("translates unsupported tool result content blocks without throwing", () => {
- const translated = translateRequest({
- ...baseRequest,
- messages: [
- {
- role: "user",
- content: [
- {
- type: "tool_result",
- tool_use_id: "toolu_1",
- content: [
- { type: "text", text: "visible output" },
- { type: "thinking", thinking: "hidden thought" },
- ],
- },
- ],
- },
- ],
- });
-
- expect(translated.input).toEqual([
- {
- type: "function_call_output",
- call_id: "toolu_1",
- output: "visible output\n[unsupported content block omitted: thinking]",
- },
- ]);
- });
-
- it("preserves text and image tool result stringification", () => {
- expect(
- toolResultToString([
- { type: "text", text: "caption" },
- {
- type: "image",
- source: { type: "base64", media_type: "image/png", data: "abc" },
- },
- { type: "image", source: { type: "url", url: "https://example.invalid/a.png" } },
- ]),
- ).toBe("caption\n[image omitted: image/png]\n[image omitted: url]");
- });
-
- it("counts unsupported tool result content blocks without throwing", () => {
- expect(
- countTokens({
- ...baseRequest,
- messages: [
- {
- role: "user",
- content: [
- {
- type: "tool_result",
- tool_use_id: "toolu_1",
- content: [{ type: "thinking", thinking: "hidden thought" }],
- },
- ],
- },
- ],
- }),
- ).toBeGreaterThan(0);
- });
-
- it("treats malformed tool result content blocks as unsupported", () => {
- expect(toolResultToString([{ type: "text" }, { type: "image" }])).toBe(
- "[unsupported content block omitted: text]\n[unsupported content block omitted: image]",
- );
- });
-
- it("requires every JSON schema property for strict responses", () => {
- const translated = translateRequest({
- ...baseRequest,
- output_config: {
- format: {
- type: "json_schema",
- schema: {
- type: "object",
- properties: {
- ok: { type: "boolean" },
- reason: { type: "string" },
- impossible: { type: "boolean" },
- },
- required: ["ok", "reason"],
- additionalProperties: false,
- },
- },
- },
- });
-
- expect(translated.text?.format).toMatchObject({
- type: "json_schema",
- schema: {
- required: ["ok", "reason", "impossible"],
- },
- strict: true,
- });
- });
-
- it("builds a websocket request without mutating the HTTP request", () => {
- const translated = translateRequest(baseRequest);
- const delta = [
- {
- type: "message" as const,
- role: "user" as const,
- content: [{ type: "input_text" as const, text: "next" }],
- },
- ];
-
- const ws = toWebSocketRequest(translated, {
- previousResponseId: "resp_1",
- input: delta,
- generate: false,
- });
-
- expect(ws.previous_response_id).toBe("resp_1");
- expect(ws.generate).toBe(false);
- expect(ws.input).toEqual(delta);
- expect(translated.input).not.toEqual(delta);
- expect("previous_response_id" in translated).toBe(false);
- });
-
- it("returns only the expected top-level upstream request fields", () => {
- const translated = translateRequest({
- ...baseRequest,
- system: "follow instructions",
- tools: [
- {
- name: "lookup_weather",
- description: "Look up the weather",
- input_schema: {
- type: "object",
- properties: { city: { type: "string" } },
- required: ["city"],
- },
- },
- ],
- tool_choice: { type: "tool", name: "lookup_weather" },
- output_config: {
- effort: "high",
- format: {
- type: "json_schema",
- name: "weather_response",
- schema: {
- type: "object",
- properties: { forecast: { type: "string" } },
- required: ["forecast"],
- },
- },
- },
- });
-
- expect(Object.keys(translated).sort()).toEqual([
- "include",
- "input",
- "instructions",
- "model",
- "parallel_tool_calls",
- "reasoning",
- "store",
- "stream",
- "text",
- "tool_choice",
- "tools",
- ]);
- });
-});
diff --git a/reference/typescript/src/providers/codex/translate/request.ts b/reference/typescript/src/providers/codex/translate/request.ts
deleted file mode 100644
index 5e28d3f..0000000
--- a/reference/typescript/src/providers/codex/translate/request.ts
+++ /dev/null
@@ -1,322 +0,0 @@
-import type {
- AnthropicContentBlock,
- AnthropicMessage,
- AnthropicRequest,
- AnthropicTool,
-} from "../../../anthropic/schema.ts";
-import { codexEffort, codexServiceTier } from "../../../config.ts";
-import {
- assertValidEffort,
- mapToolChoice as mapAnthropicToolChoice,
- flattenSystemText,
- imageBlockToUrl,
- normalizeContent,
- toolResultToString,
-} from "../../translate/anthropic-content.ts";
-
-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";
- }
-}
-
-// 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 }
- | { type: "web_search" };
- 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";
- format?:
- | { type: "text" }
- | { type: "json_object" }
- | { type: "json_schema"; name: string; schema: unknown; strict?: boolean };
- };
- client_metadata?: Record<string, string>;
-}
-
-export interface ResponsesWebSocketRequest extends ResponsesRequest {
- previous_response_id?: string;
- generate?: boolean;
-}
-
-export function toWebSocketRequest(
- body: ResponsesRequest,
- opts: { previousResponseId?: string; input?: ResponsesInputItem[]; generate?: boolean } = {},
-): ResponsesWebSocketRequest {
- return {
- ...body,
- ...(opts.input ? { input: opts.input } : {}),
- ...(opts.previousResponseId ? { previous_response_id: opts.previousResponseId } : {}),
- ...(opts.generate !== undefined ? { generate: opts.generate } : {}),
- };
-}
-
-export type ResponsesInputItem =
- | {
- type: "message";
- role: "user" | "assistant" | "developer" | "system";
- content: ResponsesContentPart[];
- }
- | {
- type: "function_call";
- call_id: string;
- name: string;
- arguments: 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; detail?: "auto" | "low" | "high" };
-
-export type ResponsesTool = ResponsesFunctionTool | ResponsesWebSearchTool;
-
-export interface ResponsesFunctionTool {
- type: "function";
- name: string;
- description?: string;
- parameters: unknown;
- strict?: boolean;
-}
-
-export interface ResponsesWebSearchTool {
- type: "web_search";
- external_web_access: boolean;
- search_content_types: Array<"text" | "image">;
- filters?: {
- allowed_domains?: string[];
- blocked_domains?: string[];
- };
-}
-
-export interface TranslateOptions {
- sessionId?: string;
- serviceTier?: ServiceTier;
-}
-
-const VALID_EFFORTS = new Set<Effort>(["none", "low", "medium", "high", "xhigh"]);
-
-const VALID_SERVICE_TIERS = new Set(["fast", "priority", "flex"]);
-
-function toCodexEffort(
- effort: NonNullable<AnthropicRequest["output_config"]>["effort"],
-): Effort | undefined {
- if (effort === "max") return "xhigh";
- return effort;
-}
-
-function resolveEffort(effort?: Effort): Effort | undefined {
- const override = codexEffort();
- if (override === undefined) {
- 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;
-}
-
-function normalizeServiceTier(tier: string): ServiceTier {
- if (!VALID_SERVICE_TIERS.has(tier)) {
- throw new InvalidServiceTierError(tier);
- }
- return tier === "flex" ? "flex" : "priority";
-}
-
-function resolveServiceTier(modelServiceTier?: ServiceTier): ServiceTier | undefined {
- const tier = codexServiceTier();
- if (tier === undefined) return modelServiceTier;
- return normalizeServiceTier(tier);
-}
-
-export function normalizeStrictJsonSchema(schema: unknown): unknown {
- if (Array.isArray(schema)) return schema.map(normalizeStrictJsonSchema);
- if (!isRecord(schema)) return schema;
-
- const out: Record<string, unknown> = {};
- for (const [key, value] of Object.entries(schema)) {
- out[key] = normalizeStrictJsonSchema(value);
- }
-
- if (isRecord(out.properties)) {
- out.required = Object.keys(out.properties);
- }
-
- return out;
-}
-
-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;
- if (fmt?.type === "json_schema") {
- text.format = {
- type: "json_schema",
- name: fmt.name ?? "response",
- schema: normalizeStrictJsonSchema(fmt.schema),
- strict: true,
- };
- }
-
- const out: ResponsesRequest = {
- model: req.model,
- input,
- store: false,
- stream: true,
- parallel_tool_calls: true,
- tool_choice: mapToolChoice(req.tool_choice, req.tools),
- 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 (effort) {
- out.reasoning = { effort };
- out.include = ["reasoning.encrypted_content"];
- }
- return out;
-}
-
-function mapToolChoice(
- choice: AnthropicRequest["tool_choice"],
- tools: AnthropicRequest["tools"],
-): ResponsesRequest["tool_choice"] {
- const mapped = mapAnthropicToolChoice(choice);
- if (mapped === "auto" || mapped === "none" || mapped === "required") return mapped;
- if (isForcedHostedWebSearchChoice(choice, tools)) return { type: "web_search" };
- return { type: "function", name: mapped.name };
-}
-
-export const buildInstructions = flattenSystemText;
-
-export { normalizeContent, toolResultToString };
-
-function buildInput(messages: AnthropicMessage[]): ResponsesInputItem[] {
- const out: ResponsesInputItem[] = [];
- for (const msg of messages) {
- const blocks = normalizeContent(msg.content);
- if (msg.role === "user") {
- // Split into message parts vs function_call_output items
- const parts: ResponsesContentPart[] = [];
- for (const block of blocks) {
- if (block.type === "text") {
- parts.push({ type: "input_text", text: block.text });
- } else if (block.type === "image") {
- parts.push({ type: "input_image", image_url: imageBlockToUrl(block) });
- } else if (block.type === "tool_result") {
- if (parts.length) {
- out.push({ type: "message", role: "user", content: parts.splice(0) });
- }
- 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 });
- } else if (msg.role === "system") {
- const parts = blocks
- .filter((block): block is AnthropicContentBlock & { type: "text" } => block.type === "text")
- .map((block) => ({ type: "input_text" as const, text: block.text }));
- if (parts.length) out.push({ type: "message", role: "developer", content: parts });
- } else {
- // assistant: preserve interleaved order of text vs tool_use
- const textParts: ResponsesContentPart[] = [];
- const flushText = () => {
- if (textParts.length) {
- 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 });
- } else if (block.type === "tool_use") {
- flushText();
- out.push({
- type: "function_call",
- call_id: block.id,
- name: block.name,
- arguments: JSON.stringify(block.input ?? {}),
- });
- }
- }
- flushText();
- }
- }
- return out;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
- return !!value && typeof value === "object";
-}
-
-function isForcedHostedWebSearchChoice(
- choice: AnthropicRequest["tool_choice"],
- tools: AnthropicRequest["tools"],
-): boolean {
- if (choice?.type !== "tool" || !choice.name) return false;
- return (
- tools?.some((tool) => tool.type === "web_search_20250305" && tool.name === choice.name) ?? false
- );
-}
-
-function toResponsesTool(tool: AnthropicTool): ResponsesTool {
- if (tool.type === "web_search_20250305") {
- const filters: ResponsesWebSearchTool["filters"] = {};
- if (tool.allowed_domains?.length) filters.allowed_domains = tool.allowed_domains;
- if (tool.blocked_domains?.length) filters.blocked_domains = tool.blocked_domains;
- return {
- type: "web_search",
- external_web_access: false,
- search_content_types: ["text", "image"],
- ...(Object.keys(filters).length ? { filters } : {}),
- };
- }
- return {
- type: "function",
- name: tool.name,
- description: tool.description,
- parameters: tool.input_schema,
- };
-}
diff --git a/reference/typescript/src/providers/codex/translate/stream.test.ts b/reference/typescript/src/providers/codex/translate/stream.test.ts
deleted file mode 100644
index 9509e6b..0000000
--- a/reference/typescript/src/providers/codex/translate/stream.test.ts
+++ /dev/null
@@ -1,475 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { translateStream } from "./stream.ts";
-import {
- abortingUpstream,
- collect,
- sse,
- silentLog,
- upstreamFromChunks,
- upstreamThatErrorsAfterChunks,
-} from "./test-helpers.ts";
-
-let now = 0;
-const realNow = Date.now;
-
-async function withMockNow<T>(run: () => Promise<T>): Promise<T> {
- Date.now = () => now;
- try {
- return await run();
- } finally {
- Date.now = realNow;
- now = 0;
- }
-}
-
-function readChunks(deltas: string[], includeDone = true): string[] {
- return [
- sse("response.output_item.added", {
- output_index: 0,
- item: { type: "function_call", call_id: "call_read", name: "Read" },
- }),
- ...deltas.map((delta) =>
- sse("response.function_call_arguments.delta", { output_index: 0, delta }),
- ),
- ...(includeDone
- ? [
- sse("response.output_item.done", {
- output_index: 0,
- item: { type: "function_call", arguments: '{"file_path":"/tmp/a"}' },
- }),
- ]
- : []),
- ];
-}
-
-function collectFromChunks(
- chunks: string[],
- options?: {
- advance?: () => void;
- log?: typeof silentLog;
- signal?: AbortSignal;
- },
-): Promise<string> {
- const upstream = options?.advance
- ? upstreamFromChunks(chunks, options.advance)
- : upstreamFromChunks(chunks);
- return collect(
- translateStream(upstream, {
- messageId: "msg_1",
- model: "gpt-5.5",
- log: options?.log ?? silentLog,
- ...(options?.signal ? { signal: options.signal } : {}),
- }),
- );
-}
-
-function collectWithTime(chunks: string[]): Promise<string> {
- return withMockNow(() =>
- collectFromChunks(chunks, {
- advance: () => {
- now += 16_000;
- },
- }),
- );
-}
-
-function webSearchChunks(): string[] {
- return [
- sse("response.output_item.added", {
- output_index: 0,
- item: { type: "web_search_call", id: "ws_1", status: "in_progress" },
- }),
- sse("response.web_search_call.in_progress", { output_index: 0, item_id: "ws_1" }),
- sse("response.web_search_call.searching", { output_index: 0, item_id: "ws_1" }),
- sse("response.web_search_call.completed", { output_index: 0, item_id: "ws_1" }),
- sse("response.output_item.done", {
- output_index: 0,
- item: {
- type: "web_search_call",
- id: "ws_1",
- status: "completed",
- action: {
- type: "search",
- query: "claude-code-proxy github",
- queries: ["claude-code-proxy github"],
- },
- },
- }),
- sse("response.output_item.added", {
- output_index: 1,
- item: { type: "message", id: "msg_upstream" },
- }),
- sse("response.output_text.delta", {
- output_index: 1,
- delta:
- "1. **TechRadar security article** - warns about malware.\n https://www.techradar.com/pro/security/example\n",
- }),
- sse("response.output_text.delta", {
- output_index: 1,
- delta:
- "2. **The Verge GitHub Claude/Codex agents article** - covers agents.\n https://www.theverge.com/news/873665/github-claude-codex-ai-agents",
- }),
- sse("response.output_item.done", {
- output_index: 1,
- item: { type: "message", id: "msg_upstream" },
- }),
- sse("response.completed", { response: { usage: { input_tokens: 10, output_tokens: 5 } } }),
- ];
-}
-
-function textChunks(text: string): string[] {
- return [
- sse("response.output_item.added", {
- output_index: 0,
- item: { type: "message", id: "msg_upstream" },
- }),
- sse("response.output_text.delta", {
- output_index: 0,
- delta: text,
- }),
- sse("response.output_item.done", {
- output_index: 0,
- item: { type: "message", id: "msg_upstream" },
- }),
- sse("response.completed", { response: { usage: { input_tokens: 10, output_tokens: 5 } } }),
- ];
-}
-
-function overloadChunk(): string {
- return sse("error", {
- status: 529,
- error: {
- type: "overloaded_error",
- message: "Our servers are currently overloaded. Please try again later.",
- },
- });
-}
-
-function retryableServerErrorChunk(): string {
- return sse("error", {
- error: {
- type: "server_error",
- message:
- "An error occurred while processing your request. You can retry your request, or contact us through our help center at help.openai.com if the error persists. Please include the request ID 3f6288fe-aea9-4dcc-b7c9-a354cc765bf2 in your message.",
- },
- });
-}
-
-describe("translateStream", () => {
- it("retries overloaded stream errors before downstream output starts", async () => {
- let retryCalls = 0;
- const logs: Array<{ msg: string; fields: unknown }> = [];
- const log = {
- ...silentLog,
- warn: (msg: string, fields: unknown) => logs.push({ msg, fields }),
- };
-
- const output = await collect(
- translateStream(upstreamFromChunks([overloadChunk()]), {
- messageId: "msg_1",
- model: "gpt-5.5",
- log,
- retryUpstream: async () => {
- retryCalls++;
- return { body: upstreamFromChunks(textChunks("Recovered")) };
- },
- computeRetryDelay: () => ({ waitMs: 0, exceedsBudget: false }),
- }),
- );
-
- expect(retryCalls).toBe(1);
- expect(output).toContain("Recovered");
- expect(output).toContain("event: message_stop");
- expect(output).not.toContain("event: error");
- expect(
- logs.some(
- (entry) => entry.msg === "upstream stream error before downstream output, retrying",
- ),
- ).toBe(true);
- });
-
- it("retries generic retryable server errors before downstream output starts", async () => {
- let retryCalls = 0;
-
- const output = await collect(
- translateStream(upstreamFromChunks([retryableServerErrorChunk()]), {
- messageId: "msg_1",
- model: "gpt-5.5",
- log: silentLog,
- retryUpstream: async () => {
- retryCalls++;
- return { body: upstreamFromChunks(textChunks("Recovered")) };
- },
- computeRetryDelay: () => ({ waitMs: 0, exceedsBudget: false }),
- }),
- );
-
- expect(retryCalls).toBe(1);
- expect(output).toContain("Recovered");
- expect(output).toContain("event: message_stop");
- expect(output).not.toContain("event: error");
- });
-
- it("retries upstream socket read failures before downstream output starts", async () => {
- let retryCalls = 0;
- const err = new TypeError(
- "The socket connection was closed unexpectedly. For more information, pass `verbose: true` in the second argument to fetch()",
- );
-
- const output = await collect(
- translateStream(upstreamThatErrorsAfterChunks([], err), {
- messageId: "msg_1",
- model: "gpt-5.5",
- log: silentLog,
- retryUpstream: async () => {
- retryCalls++;
- return { body: upstreamFromChunks(textChunks("Recovered")) };
- },
- computeRetryDelay: () => ({ waitMs: 0, exceedsBudget: false }),
- }),
- );
-
- expect(retryCalls).toBe(1);
- expect(output).toContain("Recovered");
- expect(output).toContain("event: message_stop");
- expect(output).not.toContain("event: error");
- });
-
- it("retries upstream operation timeouts before downstream output starts", async () => {
- let retryCalls = 0;
- const err = new TypeError("API Error: The operation timed out.");
-
- const output = await collect(
- translateStream(upstreamThatErrorsAfterChunks([], err), {
- messageId: "msg_1",
- model: "gpt-5.5",
- log: silentLog,
- retryUpstream: async () => {
- retryCalls++;
- return { body: upstreamFromChunks(textChunks("Recovered")) };
- },
- computeRetryDelay: () => ({ waitMs: 0, exceedsBudget: false }),
- }),
- );
-
- expect(retryCalls).toBe(1);
- expect(output).toContain("Recovered");
- expect(output).toContain("event: message_stop");
- expect(output).not.toContain("event: error");
- });
-
- it("does not retry overloaded stream errors after downstream output starts", async () => {
- let retryCalls = 0;
-
- const output = await collect(
- translateStream(upstreamFromChunks([...textChunks("Partial").slice(0, 2), overloadChunk()]), {
- messageId: "msg_1",
- model: "gpt-5.5",
- log: silentLog,
- retryUpstream: async () => {
- retryCalls++;
- return { body: upstreamFromChunks(textChunks("Recovered")) };
- },
- computeRetryDelay: () => ({ waitMs: 0, exceedsBudget: false }),
- }),
- );
-
- expect(retryCalls).toBe(0);
- expect(output).toContain("Partial");
- expect(output).toContain("event: content_block_stop");
- expect(output).toContain("event: error");
- expect(output).toContain('"type":"overloaded_error"');
- });
-
- it("emits keepalive pings while Read arguments are buffered", async () => {
- const chunks = [
- ...readChunks(['{"file_path"', '":"/tmp/a"}']),
- sse("response.completed", { response: { usage: {} } }),
- ];
-
- const output = await collectWithTime(chunks);
-
- expect(output).toContain("event: content_block_start");
- expect(output).toContain("event: content_block_delta");
- expect(output.match(/event: ping/g)?.length).toBeGreaterThanOrEqual(2);
- expect(output).toContain("event: message_stop");
- });
-
- it("short-circuits whitespace-stalled Read arguments as a tool use", async () => {
- const chunks = [
- sse("response.output_item.added", {
- output_index: 0,
- item: { type: "function_call", call_id: "call_read", name: "Read" },
- }),
- sse("response.function_call_arguments.delta", {
- output_index: 0,
- delta: '{"file_path":"/tmp/a","limit":2200',
- }),
- sse("response.function_call_arguments.delta", {
- output_index: 0,
- delta: " ".repeat(1024),
- }),
- ];
-
- const output = await collectFromChunks(chunks);
-
- expect(output).toContain("event: content_block_start");
- expect(output).toContain('"partial_json":"{\\"file_path\\":\\"/tmp/a\\",\\"limit\\":2200}"');
- expect(output).toContain('"stop_reason":"tool_use"');
- expect(output).toContain("event: message_stop");
- expect(output).not.toContain("event: error");
- });
-
- it("emits keepalive pings for upstream keepalive events", async () => {
- const chunks = [
- sse("response.output_item.added", {
- output_index: 0,
- item: { type: "message", id: "msg_upstream" },
- }),
- sse("keepalive", {}),
- sse("keepalive", {}),
- sse("response.output_item.done", {
- output_index: 0,
- item: { type: "message", id: "msg_upstream" },
- }),
- sse("response.completed", { response: { usage: {} } }),
- ];
-
- const output = await collectWithTime(chunks);
-
- expect(output.match(/event: ping/g)?.length).toBeGreaterThanOrEqual(2);
- expect(output).toContain("event: message_stop");
- });
-
- it("emits an error instead of message_stop when upstream ends with an open Read block", async () => {
- const chunks = readChunks(['{"file_path"', ':"/tmp/a"'], false);
-
- const output = await collectFromChunks(chunks);
-
- expect(output).toContain("event: content_block_start");
- expect(output).toContain("event: content_block_stop");
- expect(output).toContain("event: error");
- expect(output).toContain("Upstream stream ended without a terminal response event");
- expect(output).not.toContain("input_json_delta");
- expect(output).not.toContain("event: message_stop");
- });
-
- it("reports upstream read failures as upstream stream errors", async () => {
- const chunks = readChunks(['{"file_path"'], false);
- const err = new DOMException("The connection was closed.", "AbortError");
- const logs: Array<{ msg: string; fields: unknown }> = [];
- const log = {
- ...silentLog,
- warn: (msg: string, fields: unknown) => logs.push({ msg, fields }),
- };
-
- const output = await collect(
- translateStream(upstreamThatErrorsAfterChunks(chunks, err), {
- messageId: "msg_1",
- model: "gpt-5.5",
- log,
- }),
- );
-
- expect(output.indexOf("event: content_block_stop")).toBeLessThan(
- output.indexOf("event: error"),
- );
- expect(output).toContain("event: error");
- expect(output).toContain("Upstream stream read failed: The connection was closed.");
- expect(output).not.toContain("input_json_delta");
- expect(logs.some((entry) => entry.msg === "upstream stream error")).toBe(true);
- });
-
- it("emits tool_use stop when Codex closes after a completed tool call", async () => {
- const chunks = [
- sse("response.output_item.added", {
- output_index: 0,
- item: { type: "function_call", call_id: "call_search", name: "WebSearch" },
- }),
- sse("response.function_call_arguments.done", {
- output_index: 0,
- arguments: '{"query":"claude-code-proxy github"}',
- }),
- sse("response.output_item.done", {
- output_index: 0,
- item: {
- type: "function_call",
- call_id: "call_search",
- name: "WebSearch",
- arguments: '{"query":"claude-code-proxy github"}',
- },
- }),
- ];
-
- const output = await collect(
- translateStream(
- upstreamThatErrorsAfterChunks(chunks, new Error("Codex WebSocket connection closed")),
- {
- messageId: "msg_1",
- model: "gpt-5.5",
- log: silentLog,
- },
- ),
- );
-
- expect(output).toContain("event: content_block_start");
- expect(output).toContain("input_json_delta");
- expect(output).toContain('"stop_reason":"tool_use"');
- expect(output).toContain("event: message_stop");
- expect(output).not.toContain("event: error");
- });
-
- it("emits Anthropic web search blocks and usage for Codex hosted web search", async () => {
- const output = await collectFromChunks(webSearchChunks());
-
- expect(output).toContain('"type":"server_tool_use"');
- expect(output).toContain('"id":"srvtoolu_ws_1"');
- expect(output).toContain('"name":"web_search"');
- expect(output).toContain('"partial_json":"{\\"query\\":\\"claude-code-proxy github\\"}"');
- expect(output).toContain('"type":"web_search_tool_result"');
- expect(output).toContain('"tool_use_id":"srvtoolu_ws_1"');
- expect(output).toContain('"title":"TechRadar security article"');
- expect(output).toContain('"url":"https://www.techradar.com/pro/security/example"');
- expect(output).toContain('"web_search_requests":1');
- expect(output).toContain("event: message_stop");
- expect(output).not.toContain("event: error");
- expect(output.indexOf('"type":"web_search_tool_result"')).toBeLessThan(
- output.indexOf('"type":"text_delta"'),
- );
- });
-
- it("fails buffered Read arguments that exceed the safe duration", async () => {
- const chunks = readChunks(['{"file_path"', ':"/tmp/a"'], false);
-
- const output = await withMockNow(() =>
- collectFromChunks(chunks, {
- advance: () => {
- now += 121_000;
- },
- }),
- );
-
- expect(output).toContain("Buffered Read tool arguments exceeded safe limits");
- expect(output).toContain("event: content_block_stop");
- expect(output).toContain("event: error");
- expect(output).not.toContain("input_json_delta");
- expect(output).not.toContain("event: message_stop");
- });
-
- it("treats aborted upstream reads as cancellation", async () => {
- const abort = new AbortController();
- abort.abort();
- const err = new DOMException("The connection was closed.", "AbortError");
-
- const output = await collect(
- translateStream(abortingUpstream(err), {
- messageId: "msg_1",
- model: "gpt-5.5",
- log: silentLog,
- signal: abort.signal,
- }),
- );
-
- expect(output).not.toContain("event: error");
- });
-});
diff --git a/reference/typescript/src/providers/codex/translate/stream.ts b/reference/typescript/src/providers/codex/translate/stream.ts
deleted file mode 100644
index f7c042c..0000000
--- a/reference/typescript/src/providers/codex/translate/stream.ts
+++ /dev/null
@@ -1,536 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { stateDir } from "../../../paths.ts";
-import { encodeSseEvent } from "../../../sse.ts";
-import type { Logger } from "../../../log.ts";
-import type { TrafficCapture } from "../../types.ts";
-import type { CodexRequestSizeSummary } from "../request-summary.ts";
-import {
- attachTrafficCapture,
- createUpstreamStreamDiagnostics,
- mapUsageToAnthropic,
- reduceUpstream,
- UpstreamStreamError,
- type ReducerEvent,
-} from "./reducer.ts";
-import { emitMessageStart } from "../../shared/anthropic-sse.ts";
-import { buildWebSearchCompatBlocks } from "./web-search-compat.ts";
-import { computeBackoffDelay, sleep, type BackoffOutcome } from "../../retry.ts";
-
-/**
- * Translate a Codex Responses SSE stream into Anthropic SSE events.
- * Returns a ReadableStream<Uint8Array> ready to pipe to the client.
- *
- * The HTTP status has already been flushed (200) before the first
- * upstream event is consumed, so rate-limit and upstream-failed cases
- * surface as SSE error events rather than non-200 statuses.
- */
-const KEEPALIVE_INTERVAL_MS = 15_000;
-const STREAM_WATCHDOG_INTERVAL_MS = 30_000;
-const MAX_RETRYABLE_STREAM_RETRIES = 10;
-
-interface RetryableUpstream {
- body: ReadableStream<Uint8Array>;
- headers?: Headers;
- requestSize?: CodexRequestSizeSummary;
-}
-
-export function translateStream(
- upstream: ReadableStream<Uint8Array>,
- opts: {
- messageId: string;
- model: string;
- log: Logger;
- reqId?: string;
- signal?: AbortSignal;
- upstreamHeaders?: Headers;
- traffic?: TrafficCapture;
- requestSize?: CodexRequestSizeSummary;
- onFinish?: (finish: Extract<ReducerEvent, { kind: "finish" }>) => void;
- onInvalidateContinuation?: () => void;
- retryUpstream?: () => Promise<RetryableUpstream>;
- maxRetryableStreamRetries?: number;
- computeRetryDelay?: (attempt: number, retryAfter?: string) => BackoffOutcome;
- },
-): ReadableStream<Uint8Array> {
- const encoder = new TextEncoder();
- return new ReadableStream<Uint8Array>({
- async start(controller) {
- const openBlocks = new Map<number, { type: "text" | "tool"; id?: string; name?: string }>();
- let diagnostics = attachTrafficCapture(createUpstreamStreamDiagnostics(), opts.traffic);
- let closed = false;
- let messageStarted = false;
- let lastEmitAt = 0;
- let lastEmitEvent: string | undefined;
- let lastReducerEvent: string | undefined;
- const webSearchEvents: Array<Extract<ReducerEvent, { kind: "web-search" }>> = [];
- const deferredContentEvents: ReducerEvent[] = [];
- const startedAt = Date.now();
- const safeClose = () => {
- if (closed) return;
- closed = true;
- try {
- controller.close();
- } catch {
- // The stream can be closed by cancellation before the producer observes it.
- }
- };
- const emit = (event: string, data: unknown) => {
- if (closed || opts.signal?.aborted || controller.desiredSize === null) return false;
- try {
- opts.traffic?.writeJsonEvent("050-downstream-event", { event, data });
- controller.enqueue(encoder.encode(encodeSseEvent(event, data)));
- lastEmitAt = Date.now();
- lastEmitEvent = event;
- return true;
- } catch (err) {
- if (opts.signal?.aborted || isClosedControllerError(err)) {
- closed = true;
- return false;
- }
- throw err;
- }
- };
- const emitPingIfStale = () => {
- if (!messageStarted || Date.now() - lastEmitAt < KEEPALIVE_INTERVAL_MS) return;
- emit("ping", { type: "ping" });
- };
- const activeToolCalls = () =>
- Array.from(openBlocks.values()).filter(
- (block): block is { type: "tool"; id: string; name: string } =>
- block.type === "tool" && typeof block.id === "string" && typeof block.name === "string",
- );
- const closeOpenBlocks = () => {
- for (const [index] of openBlocks) {
- emit("content_block_stop", { type: "content_block_stop", index });
- }
- openBlocks.clear();
- };
- const resetBeforeRetry = () => {
- openBlocks.clear();
- webSearchEvents.length = 0;
- deferredContentEvents.length = 0;
- lastReducerEvent = undefined;
- };
- const logWatchdog = () => {
- const tools = activeToolCalls();
- opts.log.info("codex stream watchdog", {
- elapsedMs: Date.now() - startedAt,
- activeToolNames: tools.map((tool) => tool.name),
- activeToolCalls: tools,
- openBlocks: Array.from(openBlocks.entries(), ([index, block]) => ({ index, ...block })),
- messageStarted,
- lastReducerEvent,
- lastEmitEvent,
- msSinceLastEmit: lastEmitAt ? Date.now() - lastEmitAt : undefined,
- diagnostics: describeDiagnostics(diagnostics),
- });
- };
- const watchdog = setInterval(logWatchdog, STREAM_WATCHDOG_INTERVAL_MS);
- const ensureMessageStart = () => {
- if (messageStarted) return;
- messageStarted = true;
- emitMessageStart(emit, { messageId: opts.messageId, model: opts.model });
- };
- const textFromDeferredContent = () =>
- deferredContentEvents
- .flatMap((event) => (event.kind === "text-delta" ? [event.text] : []))
- .join("");
- const emitWebSearchCompatBlocks = () => {
- if (!webSearchEvents.length) return;
- ensureMessageStart();
- for (const block of buildWebSearchCompatBlocks(
- webSearchEvents,
- textFromDeferredContent(),
- )) {
- if (block.content.type === "server_tool_use") {
- emit("content_block_start", {
- type: "content_block_start",
- index: block.index,
- content_block: {
- type: "server_tool_use",
- id: block.content.id,
- name: block.content.name,
- input: {},
- },
- });
- emit("content_block_delta", {
- type: "content_block_delta",
- index: block.index,
- delta: {
- type: "input_json_delta",
- partial_json: JSON.stringify(block.content.input),
- },
- });
- emit("content_block_stop", { type: "content_block_stop", index: block.index });
- continue;
- }
- emit("content_block_start", {
- type: "content_block_start",
- index: block.index,
- content_block: block.content,
- });
- emit("content_block_stop", { type: "content_block_stop", index: block.index });
- }
- };
- const isContentEvent = (event: ReducerEvent): boolean =>
- event.kind === "text-start" ||
- event.kind === "text-delta" ||
- event.kind === "text-stop" ||
- event.kind === "tool-start" ||
- event.kind === "tool-delta" ||
- event.kind === "tool-stop";
- const emitContentEvent = (e: ReducerEvent) => {
- switch (e.kind) {
- case "text-start":
- openBlocks.set(e.index, { type: "text" });
- ensureMessageStart();
- emit("content_block_start", {
- type: "content_block_start",
- index: e.index,
- content_block: { type: "text", text: "" },
- });
- break;
- case "text-delta":
- emit("content_block_delta", {
- type: "content_block_delta",
- index: e.index,
- delta: { type: "text_delta", text: e.text },
- });
- break;
- case "text-stop":
- openBlocks.delete(e.index);
- emit("content_block_stop", { type: "content_block_stop", index: e.index });
- break;
- case "tool-start":
- openBlocks.set(e.index, { type: "tool", id: e.id, name: e.name });
- ensureMessageStart();
- emit("content_block_start", {
- type: "content_block_start",
- index: e.index,
- content_block: {
- type: "tool_use",
- id: e.id,
- name: e.name,
- input: {},
- },
- });
- 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;
- case "tool-stop":
- openBlocks.delete(e.index);
- emit("content_block_stop", { type: "content_block_stop", index: e.index });
- break;
- }
- };
-
- let currentUpstream = upstream;
- let currentUpstreamHeaders = opts.upstreamHeaders;
- let currentRequestSize = opts.requestSize;
- let retryAttempt = 0;
- let terminalError: unknown;
- try {
- for (;;) {
- diagnostics = attachTrafficCapture(createUpstreamStreamDiagnostics(), opts.traffic);
- try {
- for await (const e of reduceUpstream(currentUpstream, opts.log, diagnostics)) {
- lastReducerEvent = e.kind;
- if (e.kind === "web-search") {
- webSearchEvents.push(e);
- continue;
- }
- if (webSearchEvents.length && isContentEvent(e)) {
- deferredContentEvents.push(e);
- continue;
- }
- switch (e.kind) {
- case "text-start":
- case "text-delta":
- case "text-stop":
- case "tool-start":
- case "tool-delta":
- case "tool-stop":
- emitContentEvent(e);
- break;
- case "tool-progress":
- case "progress":
- emitPingIfStale();
- break;
- case "finish":
- if (openBlocks.size) {
- throw new UpstreamStreamError(
- "failed",
- "Stream finished with open content blocks",
- );
- }
- emitWebSearchCompatBlocks();
- for (const event of deferredContentEvents) {
- emitContentEvent(event);
- }
- if (openBlocks.size) {
- throw new UpstreamStreamError(
- "failed",
- "Stream finished with open content blocks",
- );
- }
- ensureMessageStart();
- opts.onFinish?.(e);
- emit("message_delta", {
- type: "message_delta",
- delta: { stop_reason: e.stopReason, stop_sequence: null },
- usage: mapUsageToAnthropic(e.usage, {
- webSearchRequests: e.webSearchRequests,
- }),
- });
- emit("message_stop", { type: "message_stop" });
- break;
- }
- }
- break;
- } catch (err) {
- if (!(await retryPreMessageStreamError(err))) {
- terminalError ??= err;
- break;
- }
- }
- }
- if (terminalError) throw terminalError;
- } catch (err) {
- const activeToolCalls = Array.from(openBlocks.values()).filter(
- (block): block is { type: "tool"; id: string; name: string } =>
- block.type === "tool" && typeof block.id === "string" && typeof block.name === "string",
- );
- const activeToolNames = activeToolCalls.map((tool) => tool.name);
- const openBlockDetails = Array.from(openBlocks.entries(), ([index, block]) => ({
- index,
- ...block,
- }));
- opts.onInvalidateContinuation?.();
- if (opts.signal?.aborted) {
- opts.log.info("stream cancelled", {
- err: describeError(err),
- activeToolNames,
- activeToolCalls,
- openBlocks: openBlockDetails,
- diagnostics: describeDiagnostics(diagnostics),
- });
- return;
- }
- if (err instanceof UpstreamStreamError) {
- const detail = {
- kind: err.kind,
- message: err.message,
- activeToolNames,
- activeToolCalls,
- openBlocks: openBlockDetails,
- clientAborted: opts.signal?.aborted ?? false,
- diagnostics: describeDiagnostics(diagnostics),
- upstreamHeaders: describeHeaders(currentUpstreamHeaders),
- requestSize: currentRequestSize,
- };
- const diagnosticFile = await writeDiagnosticFile(
- opts.reqId,
- "upstream-stream-error",
- detail,
- );
- opts.log.warn("upstream stream error", { ...detail, diagnosticFile });
- ensureMessageStart();
- closeOpenBlocks();
- emit("error", {
- type: "error",
- error: {
- type: anthropicStreamErrorType(err),
- message: err.message,
- },
- });
- } else {
- const detail = {
- err: describeError(err),
- activeToolNames,
- activeToolCalls,
- openBlocks: openBlockDetails,
- clientAborted: opts.signal?.aborted ?? false,
- diagnostics: describeDiagnostics(diagnostics),
- upstreamHeaders: describeHeaders(currentUpstreamHeaders),
- requestSize: currentRequestSize,
- };
- const diagnosticFile = await writeDiagnosticFile(
- opts.reqId,
- "stream-translation-error",
- detail,
- );
- opts.log.error("stream translation error", { ...detail, diagnosticFile });
- ensureMessageStart();
- closeOpenBlocks();
- emit("error", {
- type: "error",
- error: { type: "api_error", message: String(err) },
- });
- }
- } finally {
- clearInterval(watchdog);
- safeClose();
- }
-
- async function retryPreMessageStreamError(err: unknown): Promise<boolean> {
- const retryInfo = retryableStreamErrorInfo(err);
- const maxRetries = opts.maxRetryableStreamRetries ?? MAX_RETRYABLE_STREAM_RETRIES;
- if (
- !retryInfo ||
- !opts.retryUpstream ||
- messageStarted ||
- retryAttempt >= maxRetries ||
- opts.signal?.aborted
- ) {
- return false;
- }
- const retryDelay = opts.computeRetryDelay ?? computeBackoffDelay;
- const { waitMs, exceedsBudget } = retryDelay(retryAttempt, retryInfo.retryAfter);
- if (exceedsBudget) {
- opts.log.warn("upstream stream retry-after exceeds budget; giving up", {
- kind: retryInfo.kind,
- retryAfter: retryInfo.retryAfter,
- maxDelayMs: waitMs,
- });
- return false;
- }
- const nextAttempt = retryAttempt + 1;
- opts.log.warn("upstream stream error before downstream output, retrying", {
- kind: retryInfo.kind,
- attempt: nextAttempt,
- maxRetries,
- waitMs,
- retryAfter: retryInfo.retryAfter,
- message: retryInfo.message,
- diagnostics: describeDiagnostics(diagnostics),
- requestSize: currentRequestSize,
- });
- resetBeforeRetry();
- retryAttempt = nextAttempt;
- try {
- await sleep(waitMs, opts.signal);
- const retry = await opts.retryUpstream();
- currentUpstream = retry.body;
- currentUpstreamHeaders = retry.headers ?? currentUpstreamHeaders;
- currentRequestSize = retry.requestSize ?? currentRequestSize;
- return true;
- } catch (retryErr) {
- terminalError = retryErr;
- return false;
- }
- }
- },
- });
-}
-
-function retryableStreamErrorInfo(err: unknown):
- | {
- kind: "rate_limit" | "overloaded" | "transient";
- retryAfter?: string;
- message: string;
- }
- | undefined {
- if (!(err instanceof UpstreamStreamError)) return undefined;
- if (err.kind !== "rate_limit" && err.kind !== "overloaded" && err.kind !== "transient")
- return undefined;
- return {
- kind: err.kind,
- retryAfter: err.retryAfterSeconds !== undefined ? String(err.retryAfterSeconds) : undefined,
- message: err.message,
- };
-}
-
-function anthropicStreamErrorType(err: UpstreamStreamError): string {
- if (err.kind === "rate_limit") return "rate_limit_error";
- if (err.kind === "overloaded") return "overloaded_error";
- return "api_error";
-}
-
-function isClosedControllerError(err: unknown): boolean {
- return err instanceof TypeError && err.message.includes("Controller is already closed");
-}
-
-function describeDiagnostics(diagnostics: ReturnType<typeof createUpstreamStreamDiagnostics>) {
- const now = Date.now();
- return {
- bytesRead: diagnostics.stats.bytesRead,
- chunkCount: diagnostics.stats.chunkCount,
- eventCount: diagnostics.stats.eventCount,
- durationMs: now - diagnostics.stats.startedAt,
- msSinceLastChunk: diagnostics.stats.lastChunkAt
- ? now - diagnostics.stats.lastChunkAt
- : undefined,
- msSinceLastEvent: diagnostics.stats.lastEventAt
- ? now - diagnostics.stats.lastEventAt
- : undefined,
- lastEventType: diagnostics.lastEventType,
- sawTerminalEvent: diagnostics.sawTerminalEvent,
- };
-}
-
-function describeHeaders(headers: Headers | undefined): Record<string, string> | undefined {
- if (!headers) return undefined;
- const out: Record<string, string> = {};
- for (const [key, value] of headers) {
- out[key] = value;
- }
- return out;
-}
-
-async function writeDiagnosticFile(
- reqId: string | undefined,
- kind: string,
- detail: Record<string, unknown>,
-): Promise<string | undefined> {
- try {
- const dir = join(stateDir(), "diagnostics");
- await mkdir(dir, { recursive: true });
- const safeReqId = reqId?.replace(/[^a-zA-Z0-9._-]/g, "_") || "unknown";
- const file = join(
- dir,
- `${new Date().toISOString().replace(/[:.]/g, "-")}-${safeReqId}-${kind}.json`,
- );
- await writeFile(
- file,
- JSON.stringify({ t: new Date().toISOString(), kind, reqId, ...detail }, null, 2),
- );
- return file;
- } catch {
- return undefined;
- }
-}
-
-function describeError(err: unknown) {
- if (!(err instanceof Error)) return { message: String(err) };
- const detail = err as Error & {
- code?: unknown;
- errno?: unknown;
- cause?: unknown;
- };
- return {
- name: err.name,
- message: err.message,
- code: detail.code,
- errno: detail.errno,
- cause: describeCause(detail.cause),
- stack: err.stack,
- };
-}
-
-function describeCause(cause: unknown): unknown {
- if (!(cause instanceof Error)) return cause;
- const detail = cause as Error & { code?: unknown; errno?: unknown };
- return {
- name: cause.name,
- message: cause.message,
- code: detail.code,
- errno: detail.errno,
- stack: cause.stack,
- };
-}
diff --git a/reference/typescript/src/providers/codex/translate/test-helpers.ts b/reference/typescript/src/providers/codex/translate/test-helpers.ts
deleted file mode 100644
index 171d2ff..0000000
--- a/reference/typescript/src/providers/codex/translate/test-helpers.ts
+++ /dev/null
@@ -1,70 +0,0 @@
-import type { Logger } from "../../../log.ts";
-
-export const silentLog: Logger = (() => {
- const log: Logger = {
- debug: () => {},
- info: () => {},
- warn: () => {},
- error: () => {},
- child: () => log,
- };
- return log;
-})();
-
-export function sse(type: string, payload: Record<string, unknown>): string {
- return `data: ${JSON.stringify({ type, ...payload })}\n\n`;
-}
-
-export function upstreamFromChunks(
- chunks: string[],
- onChunk?: () => void,
-): ReadableStream<Uint8Array> {
- const encoder = new TextEncoder();
- let index = 0;
- return new ReadableStream<Uint8Array>({
- pull(controller) {
- if (index >= chunks.length) {
- controller.close();
- return;
- }
- onChunk?.();
- controller.enqueue(encoder.encode(chunks[index++]));
- },
- });
-}
-
-export function abortingUpstream(err: Error): ReadableStream<Uint8Array> {
- return new ReadableStream<Uint8Array>({
- pull(controller) {
- controller.error(err);
- },
- });
-}
-
-export function upstreamThatErrorsAfterChunks(
- chunks: string[],
- err: Error,
-): ReadableStream<Uint8Array> {
- const encoder = new TextEncoder();
- let index = 0;
- return new ReadableStream<Uint8Array>({
- pull(controller) {
- if (index >= chunks.length) {
- controller.error(err);
- return;
- }
- controller.enqueue(encoder.encode(chunks[index++]));
- },
- });
-}
-
-export async function collect(stream: ReadableStream<Uint8Array>): Promise<string> {
- const reader = stream.getReader();
- const decoder = new TextDecoder();
- let out = "";
- while (true) {
- const { done, value } = await reader.read();
- if (done) return out;
- out += decoder.decode(value, { stream: true });
- }
-}
diff --git a/reference/typescript/src/providers/codex/translate/web-search-compat.ts b/reference/typescript/src/providers/codex/translate/web-search-compat.ts
deleted file mode 100644
index 02bd2b4..0000000
--- a/reference/typescript/src/providers/codex/translate/web-search-compat.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-export interface AnthropicWebSearchResult {
- type: "web_search_result";
- title: string;
- url: string;
- page_age?: string | null;
-}
-
-export interface AnthropicServerToolUseContent {
- type: "server_tool_use";
- id: string;
- name: "web_search";
- input: { query: string };
-}
-
-export interface AnthropicWebSearchToolResultContent {
- type: "web_search_tool_result";
- tool_use_id: string;
- content: AnthropicWebSearchResult[];
-}
-
-export interface WebSearchCompatBlock {
- index: number;
- content: AnthropicServerToolUseContent | AnthropicWebSearchToolResultContent;
-}
-
-export function serverToolUseIdFromCodexWebSearchId(id: string | undefined): string {
- const suffix = (id || crypto.randomUUID()).replace(/[^A-Za-z0-9_]/g, "_");
- return `srvtoolu_${suffix}`;
-}
-
-export function extractWebSearchResultsFromText(text: string): AnthropicWebSearchResult[] {
- const results = new Map<string, AnthropicWebSearchResult>();
- for (const match of text.matchAll(/\[([^\]\n]+)\]\((https?:\/\/[^)\s]+)\)/g)) {
- const title = cleanTitle(match[1] ?? "");
- const url = cleanUrl(match[2] ?? "");
- if (!url || results.has(url)) continue;
- results.set(url, { type: "web_search_result", title: title || fallbackTitle(url), url });
- }
-
- for (const match of text.matchAll(/\bhttps?:\/\/[^\s<>"')\]]+/g)) {
- const rawUrl = match[0] ?? "";
- const url = cleanUrl(rawUrl);
- if (!url || results.has(url)) continue;
- const title = titleNearUrl(text, match.index ?? 0, url);
- results.set(url, { type: "web_search_result", title: title || fallbackTitle(url), url });
- }
-
- return Array.from(results.values());
-}
-
-export function buildWebSearchCompatBlocks(
- searches: Array<{ index: number; resultIndex: number; id: string; query: string }>,
- text: string,
-): WebSearchCompatBlock[] {
- const results = extractWebSearchResultsFromText(text);
- return searches.flatMap((search) => [
- {
- index: search.index,
- content: {
- type: "server_tool_use" as const,
- id: search.id,
- name: "web_search" as const,
- input: { query: search.query },
- },
- },
- {
- index: search.resultIndex,
- content: {
- type: "web_search_tool_result" as const,
- tool_use_id: search.id,
- content: results,
- },
- },
- ]);
-}
-
-function cleanUrl(value: string): string {
- let out = value.trim();
- while (/[.,;:!?]$/.test(out)) out = out.slice(0, -1);
- try {
- return new URL(out).toString();
- } catch {
- return "";
- }
-}
-
-function titleNearUrl(text: string, urlStart: number, url: string): string {
- const before = text
- .slice(0, urlStart)
- .split(/\r?\n/)
- .map((line) => line.trim())
- .filter(Boolean)
- .filter((line) => !line.includes("http"))
- .slice(-3)
- .reverse();
- for (const line of before) {
- const title = cleanTitle(line);
- if (title) return title;
- }
- return fallbackTitle(url);
-}
-
-function cleanTitle(value: string): string {
- const noListMarker = value
- .replace(/^\s*(?:[-*+]|\d+[.)])\s+/, "")
- .replace(/\*\*/g, "")
- .replace(/`/g, "")
- .trim();
- const [prefix] = noListMarker.split(/\s(?:-|\u2013|\u2014)\s/);
- return (prefix ?? noListMarker).trim();
-}
-
-function fallbackTitle(url: string): string {
- try {
- return new URL(url).hostname;
- } catch {
- return url;
- }
-}
diff --git a/reference/typescript/src/providers/codex/websocket.test.ts b/reference/typescript/src/providers/codex/websocket.test.ts
deleted file mode 100644
index f7a0b51..0000000
--- a/reference/typescript/src/providers/codex/websocket.test.ts
+++ /dev/null
@@ -1,264 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import { createServer } from "node:http";
-import WebSocket, { WebSocketServer } from "ws";
-import type { RequestContext } from "../types.ts";
-import {
- CodexWebSocketSetupError,
- clearCodexWebSocketPoolForTests,
- codexWebSocketHeaders,
- codexWebSocketRequest,
- toWebSocketUrl,
- WEBSOCKET_PROTOCOL_HEADER,
-} from "./websocket.ts";
-import { collect, silentLog } from "./translate/test-helpers.ts";
-import type { ResponsesWebSocketRequest } from "./translate/request.ts";
-
-const websocketTimeoutMs = {
- connect: 1_000,
- idle: 1_000,
-};
-
-function ctx(): RequestContext {
- return {
- reqId: "req_1",
- signal: new AbortController().signal,
- childLogger: () => silentLog,
- };
-}
-
-afterEach(() => {
- clearCodexWebSocketPoolForTests();
-});
-
-function body(): ResponsesWebSocketRequest {
- return {
- model: "gpt-5.5",
- input: [{ type: "message", role: "user", content: [{ type: "input_text", text: "hello" }] }],
- store: false,
- stream: true,
- };
-}
-
-function webSocketRequest(
- url: string,
- options: { poolKey?: string } = {},
-): ReturnType<typeof codexWebSocketRequest> {
- return codexWebSocketRequest({
- url,
- headers: new Headers(),
- body: body(),
- ctx: ctx(),
- connectTimeoutMs: websocketTimeoutMs.connect,
- idleTimeoutMs: websocketTimeoutMs.idle,
- ...options,
- });
-}
-
-async function withServer(
- handler: (socket: WebSocket, requestBody: Promise<unknown>, request: import("node:http").IncomingMessage) => void,
-): Promise<{ url: string; close: () => Promise<void> }> {
- const server = createServer();
- const wss = new WebSocketServer({ server });
- wss.on("connection", (socket, request) => {
- const messages: unknown[] = [];
- const waiters: ((value: unknown) => void)[] = [];
- const nextBody = () =>
- new Promise<unknown>((resolve) => {
- const message = messages.shift();
- if (message !== undefined) resolve(message);
- else waiters.push(resolve);
- });
- socket.on("message", (data) => {
- const message = JSON.parse(data.toString());
- const waiter = waiters.shift();
- if (waiter) waiter(message);
- else messages.push(message);
- });
- handler(socket, nextBody(), request);
- });
- await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
- const address = server.address();
- if (!address || typeof address === "string") throw new Error("missing server address");
- return {
- url: `http://127.0.0.1:${address.port}/backend-api/codex/responses`,
- close: () =>
- new Promise<void>((resolve, reject) => {
- wss.close((err) => {
- if (err) reject(err);
- else server.close((closeErr) => (closeErr ? reject(closeErr) : resolve()));
- });
- }),
- };
-}
-
-async function withCompletionServer(
- onConnection: (socket: WebSocket, socketIndex: number) => void,
-): Promise<{ url: string; close: () => Promise<void>; sockets: () => number }> {
- let sockets = 0;
- const server = await withServer((socket, requestBody, request) => {
- const socketIndex = ++sockets;
- onConnection(socket, socketIndex);
- });
- return {
- url: server.url,
- close: server.close,
- sockets: () => sockets,
- };
-}
-
-async function withAutoCompletionServer(): Promise<{
- url: string;
- close: () => Promise<void>;
- sockets: () => number;
-}> {
- return withCompletionServer((socket, socketIndex) => {
- socket.on("message", () => {
- socket.send(
- JSON.stringify({ type: "response.completed", response: { id: `resp_${socketIndex}` } }),
- );
- });
- });
-}
-
-describe("Codex WebSocket helpers", () => {
- it("converts HTTP URLs to WebSocket URLs", () => {
- expect(toWebSocketUrl("https://chatgpt.com/backend-api/codex/responses")).toBe(
- "wss://chatgpt.com/backend-api/codex/responses",
- );
- expect(toWebSocketUrl("http://127.0.0.1:1234/backend-api/codex/responses")).toBe(
- "ws://127.0.0.1:1234/backend-api/codex/responses",
- );
- });
-
- it("rejects unsupported URL schemes", () => {
- expect(() => toWebSocketUrl("file:///tmp/responses")).toThrow(
- "Unsupported Codex WebSocket URL scheme",
- );
- });
-
- it("sets the WebSocket beta header and removes content length", () => {
- const headers = new Headers({
- "openai-beta": "responses=experimental",
- "content-length": "123",
- authorization: "Bearer token",
- });
-
- expect(codexWebSocketHeaders(headers)).toEqual({
- authorization: "Bearer token",
- "openai-beta": WEBSOCKET_PROTOCOL_HEADER,
- });
- });
-
- it("carries upgrade failure status for auth refresh", () => {
- const err = new CodexWebSocketSetupError("upgrade failed", 401);
-
- expect(err.name).toBe("CodexWebSocketSetupError");
- expect(err.status).toBe(401);
- });
-
- it("converts websocket events to SSE and sends response.create without stream", async () => {
- const server = await withServer(async (socket, requestBody) => {
- const req = await requestBody;
- expect(req).toEqual({
- type: "response.create",
- model: "gpt-5.5",
- input: [
- { type: "message", role: "user", content: [{ type: "input_text", text: "hello" }] },
- ],
- store: false,
- });
- socket.send(JSON.stringify({ type: "response.completed", response: { id: "resp_1" } }));
- });
- try {
- const stream = await webSocketRequest(server.url);
-
- await expect(collect(stream)).resolves.toBe(
- 'data: {"type":"response.completed","response":{"id":"resp_1"}}\n\n',
- );
- } finally {
- await server.close();
- }
- });
-
- it("rejects setup errors before exposing a stream", async () => {
- const server = await withServer((socket) => {
- socket.send(
- JSON.stringify({
- type: "error",
- status: 429,
- error: { code: "rate_limit", message: "slow down" },
- headers: { "retry-after": "3" },
- }),
- );
- });
- try {
- let caught: unknown;
- try {
- await webSocketRequest(server.url);
- } catch (err) {
- caught = err;
- }
- expect(caught).toBeInstanceOf(CodexWebSocketSetupError);
- const err = caught as CodexWebSocketSetupError;
- expect(err.status).toBe(429);
- expect(err.code).toBe("rate_limit");
- expect(err.retryAfter).toBe("3");
- expect(err.requestSent).toBe(false);
- } finally {
- await server.close();
- }
- });
-
- it("exposes response errors as SSE events", async () => {
- const server = await withServer(async (socket, requestBody) => {
- await requestBody;
- socket.send(
- JSON.stringify({
- type: "error",
- error: { code: "invalid_request", message: "bad request" },
- }),
- );
- });
- try {
- const stream = await webSocketRequest(server.url);
-
- await expect(collect(stream)).resolves.toBe(
- 'data: {"type":"error","error":{"code":"invalid_request","message":"bad request"}}\n\n',
- );
- } finally {
- await server.close();
- }
- });
-
- it("reuses a pooled websocket", async () => {
- const server = await withAutoCompletionServer();
- try {
- const request = () =>
- webSocketRequest(server.url, {
- poolKey: "session-1",
- });
-
- await collect(await request());
- await collect(await request());
-
- expect(server.sockets()).toBe(1);
- } finally {
- clearCodexWebSocketPoolForTests();
- await server.close();
- }
- });
-
- it("does not pool websocket requests without a pool key", async () => {
- const server = await withAutoCompletionServer();
- try {
- const makeRequest = () => webSocketRequest(server.url).then(collect);
-
- await makeRequest();
- await makeRequest();
- expect(server.sockets()).toBe(2);
- } finally {
- await server.close();
- }
- });
-
-});
diff --git a/reference/typescript/src/providers/codex/websocket.ts b/reference/typescript/src/providers/codex/websocket.ts
deleted file mode 100644
index bc7e76e..0000000
--- a/reference/typescript/src/providers/codex/websocket.ts
+++ /dev/null
@@ -1,544 +0,0 @@
-import WebSocket from "ws";
-import { headersToRecord } from "../../traffic.ts";
-import type { RequestContext } from "../types.ts";
-import type { ResponsesWebSocketRequest } from "./translate/request.ts";
-
-export const WEBSOCKET_PROTOCOL_HEADER = "responses_websockets=2026-02-06";
-
-export class CodexWebSocketSetupError extends Error {
- constructor(
- message: string,
- public status?: number,
- public code?: string,
- public retryAfter?: string,
- public requestSent = false,
- ) {
- super(message);
- this.name = "CodexWebSocketSetupError";
- }
-}
-
-export interface CodexWebSocketOptions {
- url: string;
- headers: Headers;
- body: ResponsesWebSocketRequest;
- ctx: RequestContext;
- connectTimeoutMs: number;
- idleTimeoutMs: number;
- poolKey?: string;
-}
-
-export type CodexWebSocketInvalidateReason = "cancel" | "error" | "close";
-
-interface ActiveRequest {
- controller?: ReadableStreamDefaultController<Uint8Array>;
- pendingChunks: Uint8Array[];
- resolve: (stream: ReadableStream<Uint8Array>) => void;
- reject: (err: Error) => void;
- settled: boolean;
- done: boolean;
- requestSent: boolean;
- chunksExposed: boolean;
- idleTimer?: ReturnType<typeof setTimeout>;
- stream: ReadableStream<Uint8Array>;
- ctx: RequestContext;
- releaseQueue: () => void;
-}
-
-interface PoolEntry {
- connection: CodexWebSocketConnection;
- lastUsed: number;
-}
-
-class CodexWebSocketConnection {
- private socket?: WebSocket;
- private active?: ActiveRequest;
- private activeAbort?: () => void;
- private connectPromise?: Promise<void>;
- private connectTimer?: ReturnType<typeof setTimeout>;
- private closed = false;
- private requestHeaders: Record<string, string>;
- private queue: Promise<void> = Promise.resolve();
-
- constructor(
- private readonly wsUrl: string,
- headers: Headers,
- private readonly connectTimeoutMs: number,
- private readonly idleTimeoutMs: number,
- private readonly keepAlive: boolean,
- private readonly onInvalidate?: (reason: CodexWebSocketInvalidateReason) => void,
- ) {
- this.requestHeaders = codexWebSocketHeaders(headers);
- }
-
- updateHeaders(headers: Headers): void {
- this.requestHeaders = codexWebSocketHeaders(headers);
- }
-
- isClosed(): boolean {
- return this.closed || !this.socket || this.socket.readyState === WebSocket.CLOSED;
- }
-
- hasActiveRequest(): boolean {
- return !!this.active;
- }
-
- dispose(): void {
- this.closed = true;
- this.clearConnectTimer();
- this.failActive(new Error("Codex WebSocket connection closed"));
- this.socket?.on("error", () => {});
- this.socket?.terminate();
- }
-
- async request(opts: CodexWebSocketOptions): Promise<ReadableStream<Uint8Array>> {
- const previous = this.queue.catch(() => {});
- let releaseQueue: () => void = () => {};
- const queued = new Promise<void>((resolve) => {
- releaseQueue = resolve;
- });
- this.queue = previous.then(() => queued);
- await previous;
- if (this.closed) {
- releaseQueue();
- throw new Error("Codex WebSocket connection closed");
- }
- if (opts.ctx.signal.aborted) {
- releaseQueue();
- throw new DOMException("Aborted", "AbortError");
- }
- try {
- return await this.runRequest(opts, releaseQueue);
- } catch (err) {
- releaseQueue();
- throw err;
- }
- }
-
- private async runRequest(
- opts: CodexWebSocketOptions,
- releaseQueue: () => void,
- ): Promise<ReadableStream<Uint8Array>> {
- this.updateHeaders(opts.headers);
- return new Promise((resolve, reject) => {
- const pendingChunks: Uint8Array[] = [];
- let controller: ReadableStreamDefaultController<Uint8Array> | undefined;
- let active: ActiveRequest;
- const stream = new ReadableStream<Uint8Array>({
- start: (next) => {
- controller = next;
- for (const chunk of pendingChunks.splice(0)) {
- if (chunk.byteLength === 0) next.close();
- else next.enqueue(chunk);
- }
- },
- cancel: () => {
- active.done = true;
- this.clearIdle(active);
- opts.ctx.signal.removeEventListener("abort", onAbort);
- this.activeAbort = undefined;
- this.active = undefined;
- this.closed = true;
- this.socket?.on("error", () => {});
- this.socket?.terminate();
- this.onInvalidate?.("cancel");
- active.releaseQueue();
- },
- });
- active = {
- controller,
- pendingChunks,
- resolve,
- reject,
- settled: false,
- done: false,
- requestSent: false,
- chunksExposed: false,
- ctx: opts.ctx,
- releaseQueue,
- stream,
- };
- const onAbort = () => this.failActive(new DOMException("Aborted", "AbortError"));
- opts.ctx.signal.addEventListener("abort", onAbort, { once: true });
- this.active = active;
- this.activeAbort = onAbort;
- this.connect(opts.ctx)
- .then(() => {
- if (active.done) return;
- this.resetIdle(active);
- const { stream: _stream, ...payload } = opts.body;
- if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
- throw new Error("Codex WebSocket is not open");
- }
- active.requestSent = true;
- this.socket.send(JSON.stringify({ type: "response.create", ...payload }), (err) => {
- if (err) this.failActive(err instanceof Error ? err : new Error(String(err)));
- });
- })
- .catch((err) => this.failActive(err instanceof Error ? err : new Error(String(err))));
- });
- }
-
- private connect(ctx: RequestContext): Promise<void> {
- if (this.socket?.readyState === WebSocket.OPEN) return Promise.resolve();
- if (this.connectPromise) return this.connectPromise;
- this.closed = false;
- this.connectPromise = new Promise((resolve, reject) => {
- const socket = new WebSocket(this.wsUrl, { headers: this.requestHeaders });
- this.socket = socket;
- const cleanup = () => {
- this.clearConnectTimer();
- ctx.signal.removeEventListener("abort", onAbort);
- this.connectPromise = undefined;
- };
- const failConnect = (err: Error) => {
- this.closed = true;
- cleanup();
- socket.on("error", () => {});
- socket.terminate();
- reject(err);
- };
- const onAbort = () => failConnect(new DOMException("Aborted", "AbortError"));
- this.connectTimer = setTimeout(
- () => failConnect(new Error("Timed out connecting to Codex WebSocket")),
- this.connectTimeoutMs,
- );
- ctx.signal.addEventListener("abort", onAbort, { once: true });
- socket.on("open", () => {
- cleanup();
- resolve();
- });
- socket.on("message", (data, isBinary) => {
- this.onMessage(data, isBinary);
- });
- socket.on("error", (err) => {
- if (this.connectPromise) failConnect(err instanceof Error ? err : new Error(String(err)));
- else this.failActive(err instanceof Error ? err : new Error(String(err)));
- });
- socket.on("close", (code, reason) => {
- this.closed = true;
- this.onInvalidate?.("close");
- if (this.connectPromise) {
- failConnect(new Error(`Codex WebSocket closed during setup: ${code} ${reason}`));
- return;
- }
- if (this.active) {
- this.failActive(
- new CodexWebSocketSetupError(
- `Codex WebSocket closed before terminal event: ${code} ${reason}`,
- undefined,
- undefined,
- undefined,
- this.active.requestSent,
- ),
- );
- }
- });
- });
- return this.connectPromise;
- }
-
- private onMessage(data: WebSocket.RawData, isBinary: boolean): void {
- const active = this.active;
- if (!active) return;
- if (isBinary) {
- this.failActive(new Error("Unexpected binary Codex WebSocket frame"));
- return;
- }
- this.resetIdle(active);
- const text = data.toString();
- let event: {
- type?: string;
- status?: number;
- status_code?: number;
- error?: { code?: string; message?: string };
- headers?: Record<string, string>;
- };
- try {
- event = JSON.parse(text);
- } catch (err) {
- this.failActive(err instanceof Error ? err : new Error(String(err)));
- return;
- }
- if (!active.settled && event.type === "error" && isSetupErrorEvent(event)) {
- this.failActive(setupErrorFromEvent(event, active.requestSent));
- return;
- }
- if (isPreviousResponseMissingEvent(event)) {
- this.failActive(setupErrorFromEvent(event, active.requestSent));
- return;
- }
- this.enqueue(active, new TextEncoder().encode(encodeSse(text)));
- if (!active.settled && shouldExposeStream(event)) {
- active.settled = true;
- active.chunksExposed = true;
- active.resolve(active.stream);
- }
- if (isTerminalEvent(event.type)) {
- if (!active.settled) {
- active.settled = true;
- active.chunksExposed = true;
- active.resolve(active.stream);
- }
- this.finishActive();
- }
- }
-
- private resetIdle(active: ActiveRequest): void {
- this.clearIdle(active);
- active.idleTimer = setTimeout(
- () => this.failActive(new Error("Timed out waiting for Codex WebSocket event")),
- this.idleTimeoutMs,
- );
- }
-
- private clearIdle(active: ActiveRequest): void {
- if (active.idleTimer) clearTimeout(active.idleTimer);
- active.idleTimer = undefined;
- }
-
- private clearConnectTimer(): void {
- if (this.connectTimer) clearTimeout(this.connectTimer);
- this.connectTimer = undefined;
- }
-
- private enqueue(active: ActiveRequest, chunk: Uint8Array): void {
- if (active.controller) active.controller.enqueue(chunk);
- else active.pendingChunks.push(chunk);
- }
-
- private tearDownActive(active: ActiveRequest | undefined): ActiveRequest | undefined {
- if (!active || active.done) return;
- active.done = true;
- this.clearIdle(active);
- if (this.activeAbort) active.ctx.signal.removeEventListener("abort", this.activeAbort);
- this.activeAbort = undefined;
- this.active = undefined;
- active.releaseQueue();
- return active;
- }
-
- private finishActive(): void {
- const active = this.tearDownActive(this.active);
- if (!active) return;
- if (!this.keepAlive) this.socket?.close();
- if (active.controller) active.controller.close();
- else active.pendingChunks.push(new Uint8Array());
- }
-
- private failActive(err: Error): void {
- const active = this.tearDownActive(this.active);
- if (!active) return;
- if (err instanceof CodexWebSocketSetupError) err.requestSent = active.requestSent;
- else if (active.requestSent) err = new CodexWebSocketSetupError(err.message, undefined, undefined, undefined, true);
- if (active.requestSent) {
- this.closed = true;
- this.socket?.on("error", () => {});
- this.socket?.terminate();
- this.onInvalidate?.("error");
- }
- if (!active.settled) active.reject(err);
- else active.controller?.error(err);
- }
-
-}
-
-const POOL_IDLE_TTL_MS = 30 * 60 * 1000;
-const MAX_POOL_ENTRIES = 10_000;
-const pool = new Map<string, PoolEntry>();
-
-export function clearCodexWebSocketPoolForTests(): void {
- for (const entry of pool.values()) entry.connection.dispose();
- pool.clear();
-}
-
-export function invalidateCodexWebSocketPoolKey(poolKey: string | undefined): void {
- if (!poolKey) return;
- const entry = pool.get(poolKey);
- if (!entry) return;
- entry.connection.dispose();
- pool.delete(poolKey);
-}
-
-function evictIdlePoolEntries(now = Date.now()): void {
- for (const [key, entry] of pool) {
- if (
- (entry.connection.hasActiveRequest() || now - entry.lastUsed <= POOL_IDLE_TTL_MS) &&
- !entry.connection.isClosed()
- ) {
- continue;
- }
- entry.connection.dispose();
- pool.delete(key);
- }
- while (pool.size > MAX_POOL_ENTRIES) {
- const key = pool.keys().next().value;
- if (!key) return;
- invalidateCodexWebSocketPoolKey(key);
- }
-}
-
-export function toWebSocketUrl(url: string): string {
- const parsed = new URL(url);
- if (parsed.protocol === "http:") {
- parsed.protocol = "ws:";
- return parsed.toString();
- }
- if (parsed.protocol === "https:") {
- parsed.protocol = "wss:";
- return parsed.toString();
- }
- throw new Error(`Unsupported Codex WebSocket URL scheme: ${parsed.protocol}`);
-}
-
-export function codexWebSocketHeaders(headers: Headers): Record<string, string> {
- const requestHeaders = headersToRecord(headers);
- requestHeaders["openai-beta"] = WEBSOCKET_PROTOCOL_HEADER;
- delete requestHeaders["content-length"];
- return requestHeaders;
-}
-
-export async function codexWebSocketRequest(
- opts: CodexWebSocketOptions,
-): Promise<ReadableStream<Uint8Array>> {
- const wsUrl = toWebSocketUrl(opts.url);
- const requestHeaders = codexWebSocketHeaders(opts.headers);
-
- opts.ctx.traffic?.writeJson("022-upstream-websocket-metadata", {
- provider: "codex",
- url: wsUrl,
- headers: requestHeaders,
- poolKey: opts.poolKey,
- });
-
- if (!opts.poolKey) {
- const connection = new CodexWebSocketConnection(
- wsUrl,
- opts.headers,
- opts.connectTimeoutMs,
- opts.idleTimeoutMs,
- false,
- );
- try {
- return await connection.request(opts);
- } catch (err) {
- connection.dispose();
- throw err;
- }
- }
-
- evictIdlePoolEntries();
- const existing = pool.get(opts.poolKey);
- if (existing && !existing.connection.isClosed()) {
- existing.lastUsed = Date.now();
- existing.connection.updateHeaders(opts.headers);
- try {
- return await existing.connection.request(opts);
- } catch (err) {
- if (err instanceof CodexWebSocketSetupError || isConnectionInvalidatingError(err)) {
- invalidateCodexWebSocketPoolKey(opts.poolKey);
- }
- throw err;
- }
- }
-
- if (existing) invalidateCodexWebSocketPoolKey(opts.poolKey);
- const connection = new CodexWebSocketConnection(
- wsUrl,
- opts.headers,
- opts.connectTimeoutMs,
- opts.idleTimeoutMs,
- true,
- () => pool.delete(opts.poolKey!),
- );
- pool.set(opts.poolKey, { connection, lastUsed: Date.now() });
- try {
- return await connection.request(opts);
- } catch (err) {
- if (err instanceof CodexWebSocketSetupError || isConnectionInvalidatingError(err)) {
- invalidateCodexWebSocketPoolKey(opts.poolKey);
- }
- throw err;
- }
-}
-
-export function isPreviousResponseMissingError(err: unknown): boolean {
- if (!(err instanceof CodexWebSocketSetupError)) return false;
- return isPreviousResponseMissingMessage(err.message) || err.code === "previous_response_not_found";
-}
-
-function shouldExposeStream(event: { type?: string }): boolean {
- const type = event.type;
- return (
- type === "response.output_text.delta" ||
- type === "response.function_call_arguments.delta" ||
- type === "response.completed" ||
- type === "response.incomplete" ||
- type === "response.done" ||
- type === "error"
- );
-}
-
-function isSetupErrorEvent(event: {
- status?: number;
- status_code?: number;
- error?: { code?: string; message?: string };
-}): boolean {
- const status = event.status ?? event.status_code;
- return status === 401 || status === 403 || status === 429;
-}
-
-function isPreviousResponseMissingEvent(event: {
- error?: { code?: string; message?: string };
-}): boolean {
- return (
- event.error?.code === "previous_response_not_found" ||
- isPreviousResponseMissingMessage(event.error?.message)
- );
-}
-
-function isPreviousResponseMissingMessage(message: string | undefined): boolean {
- if (!message) return false;
- const lower = message.toLowerCase();
- return lower.includes("previous response") && lower.includes("not found");
-}
-
-function setupErrorFromEvent(
- event: {
- status?: number;
- status_code?: number;
- error?: { code?: string; message?: string };
- headers?: Record<string, string>;
- },
- requestSent: boolean,
-): CodexWebSocketSetupError {
- return new CodexWebSocketSetupError(
- event.error?.message ?? event.error?.code ?? "Codex WebSocket setup error",
- event.status ?? event.status_code,
- event.error?.code,
- event.headers?.["retry-after"],
- requestSent,
- );
-}
-
-function isConnectionInvalidatingError(err: unknown): boolean {
- if (!(err instanceof Error)) return false;
- return err.message.includes("closed") || err.message.includes("Timed out");
-}
-
-function isTerminalEvent(type: string | undefined): boolean {
- return (
- type === "response.completed" ||
- type === "response.failed" ||
- type === "response.incomplete" ||
- type === "response.done" ||
- type === "error"
- );
-}
-
-function encodeSse(text: string): string {
- return `${text
- .split(/\r?\n/)
- .map((line) => `data: ${line}`)
- .join("\n")}\n\n`;
-}
diff --git a/reference/typescript/src/providers/cursor/auth/jwt.ts b/reference/typescript/src/providers/cursor/auth/jwt.ts
deleted file mode 100644
index 8e94b26..0000000
--- a/reference/typescript/src/providers/cursor/auth/jwt.ts
+++ /dev/null
@@ -1,21 +0,0 @@
-export interface CursorTokenClaims {
- exp?: number;
- sub?: string;
- email?: string;
- [key: string]: unknown;
-}
-
-export function parseJwtClaims(token: string): CursorTokenClaims | undefined {
- const parts = token.split(".");
- if (parts.length !== 3) return undefined;
- try {
- return JSON.parse(Buffer.from(parts[1]!, "base64url").toString()) as CursorTokenClaims;
- } catch {
- return undefined;
- }
-}
-
-export function tokenExpiryMs(token: string): number | undefined {
- const exp = parseJwtClaims(token)?.exp;
- return typeof exp === "number" ? exp * 1000 : undefined;
-}
diff --git a/reference/typescript/src/providers/cursor/auth/login.ts b/reference/typescript/src/providers/cursor/auth/login.ts
deleted file mode 100644
index f1e2eda..0000000
--- a/reference/typescript/src/providers/cursor/auth/login.ts
+++ /dev/null
@@ -1,109 +0,0 @@
-import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { execFile } from "node:child_process";
-import { platform } from "node:os";
-import { promisify } from "node:util";
-import { cursorBaseUrl } from "../../../config.ts";
-import { saveCursorAuth, type CursorAuth } from "./token-store.ts";
-import { parseCursorAuthTokens } from "./token-parser.ts";
-
-const execFileAsync = promisify(execFile);
-const CURSOR_WEBSITE_URL = "https://cursor.com";
-
-interface LoginMetadata {
- uuid: string;
- verifier: string;
-}
-
-interface CursorLoginResult {
- accessToken: string;
- refreshToken: string;
-}
-
-function base64Url(bytes: Buffer): string {
- return bytes.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-}
-
-function sleep(ms: number): Promise<void> {
- return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-export function createCursorLogin(): { loginUrl: string; metadata: LoginMetadata } {
- const verifier = base64Url(randomBytes(32));
- const challenge = base64Url(createHash("sha256").update(verifier).digest());
- const uuid = randomUUID();
- const loginUrl = `${CURSOR_WEBSITE_URL}/loginDeepControl?challenge=${challenge}&uuid=${uuid}&mode=login&redirectTarget=cli`;
- return { loginUrl, metadata: { uuid, verifier } };
-}
-
-export async function openCursorLoginUrl(url: string): Promise<void> {
- if (platform() === "darwin") {
- await execFileAsync("open", [url]);
- return;
- }
- if (platform() === "win32") {
- await execFileAsync("cmd", ["/c", "start", "", url]);
- return;
- }
- await execFileAsync("xdg-open", [url]);
-}
-
-export async function waitForCursorLogin(
- metadata: LoginMetadata,
- opts: { maxAttempts?: number; onProgress?: (attempt: number) => void } = {},
-): Promise<CursorLoginResult | undefined> {
- const maxAttempts = opts.maxAttempts ?? 150;
- let consecutiveErrors = 0;
- for (let attempt = 0; attempt < maxAttempts; attempt++) {
- const delay = Math.min(1000 * Math.pow(1.2, attempt), 10_000);
- try {
- const base = cursorBaseUrl().replace(/\/$/, "");
- const resp = await fetch(`${base}/auth/poll?uuid=${metadata.uuid}&verifier=${metadata.verifier}`, {
- headers: { "content-type": "application/json" },
- });
- if (resp.status === 404) {
- consecutiveErrors = 0;
- opts.onProgress?.(attempt);
- await sleep(delay);
- continue;
- }
- if (!resp.ok) {
- consecutiveErrors += 1;
- if (consecutiveErrors >= 3) return undefined;
- await sleep(delay);
- continue;
- }
- const parsed = await resp.json();
- const parsedTokens = parseCursorAuthTokens(parsed);
- if (!parsedTokens) return undefined;
- return parsedTokens;
- } catch {
- consecutiveErrors += 1;
- if (consecutiveErrors >= 3) return undefined;
- await sleep(delay);
- }
- }
- return undefined;
-}
-
-export async function runCursorLogin(): Promise<CursorAuth | undefined> {
- const login = createCursorLogin();
- console.log("Open this URL to authenticate with Cursor:");
- console.log(login.loginUrl);
- console.log();
- try {
- await openCursorLoginUrl(login.loginUrl);
- } catch (err) {
- console.log(`Could not open browser automatically: ${String(err)}`);
- }
- console.log("Waiting for Cursor login...");
- const result = await waitForCursorLogin(login.metadata, {
- onProgress(attempt) {
- if (attempt > 0 && attempt % 10 === 0) process.stdout.write(".");
- },
- });
- if (!result) return undefined;
- return saveCursorAuth({
- accessToken: result.accessToken,
- refreshToken: result.refreshToken,
- });
-}
diff --git a/reference/typescript/src/providers/cursor/auth/token-parser.ts b/reference/typescript/src/providers/cursor/auth/token-parser.ts
deleted file mode 100644
index 8eee99a..0000000
--- a/reference/typescript/src/providers/cursor/auth/token-parser.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-type ParsedCursorAuthTokens = {
- accessToken: string;
- refreshToken: string;
-};
-
-export function parseCursorAuthTokens(parsed: unknown): ParsedCursorAuthTokens | undefined {
- if (!parsed || typeof parsed !== "object") return undefined;
- const obj = parsed as Partial<Record<string, unknown>>;
- if (typeof obj.accessToken === "string" && typeof obj.refreshToken === "string") {
- return { accessToken: obj.accessToken, refreshToken: obj.refreshToken };
- }
- return undefined;
-}
diff --git a/reference/typescript/src/providers/cursor/auth/token-store.test.ts b/reference/typescript/src/providers/cursor/auth/token-store.test.ts
deleted file mode 100644
index 53e01a1..0000000
--- a/reference/typescript/src/providers/cursor/auth/token-store.test.ts
+++ /dev/null
@@ -1,66 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { clearCursorAuth, cursorAuthLocation, loadCursorAuth, saveCursorAuth } from "./token-store.ts";
-import { parseJwtClaims, tokenExpiryMs } from "./jwt.ts";
-import { jwt } from "../cursor-test-helpers.ts";
-
-describe("Cursor auth token discovery", () => {
- const originalConfigDir = process.env.CCP_CONFIG_DIR;
- const tempDirs: string[] = [];
-
- afterEach(() => {
- restoreEnv("CCP_CONFIG_DIR", originalConfigDir);
- for (const dir of tempDirs.splice(0)) rmSync(dir, { recursive: true, force: true });
- });
-
- it("loads CCP_CURSOR_AUTH_TOKEN without reading Cursor storage", async () => {
- const token = jwt({ sub: "user_1", email: "[email protected]", exp: 2_000_000_000 });
-
- const auth = await loadCursorAuth({ CCP_CURSOR_AUTH_TOKEN: token });
-
- expect(auth?.accessToken).toBe(token);
- expect(auth?.source).toBe("environment");
- expect(auth?.userId).toBe("user_1");
- expect(auth?.email).toBe("[email protected]");
- expect(auth?.expires).toBe(2_000_000_000_000);
- });
-
- it("parses JWT claims and expiration", () => {
- const token = jwt({ sub: "user_2", exp: 123 });
-
- expect(parseJwtClaims(token)?.sub).toBe("user_2");
- expect(tokenExpiryMs(token)).toBe(123_000);
- });
-
- it("uses CCP_CONFIG_DIR for Cursor auth storage", async () => {
- const dir = tempConfigDir(tempDirs);
- process.env.CCP_CONFIG_DIR = dir;
- const token = jwt({ sub: "user_3", email: "[email protected]", exp: 2_000_000_000 });
-
- const saved = await saveCursorAuth({ accessToken: token, refreshToken: "refresh-token" });
- const raw = await readFile(join(dir, "cursor", "auth.json"), "utf8");
- const loaded = await loadCursorAuth({});
- await clearCursorAuth();
-
- expect(saved.source).toBe(join(dir, "cursor", "auth.json"));
- expect(JSON.parse(raw)).toEqual({ accessToken: token, refreshToken: "refresh-token" });
- expect(loaded?.accessToken).toBe(token);
- expect(loaded?.source).toBe(join(dir, "cursor", "auth.json"));
- expect(cursorAuthLocation()).toBe(join(dir, "cursor", "auth.json"));
- await expect(readFile(join(dir, "cursor", "auth.json"), "utf8")).rejects.toThrow();
- });
-});
-
-function restoreEnv(key: string, value: string | undefined): void {
- if (value === undefined) delete process.env[key];
- else process.env[key] = value;
-}
-
-function tempConfigDir(tempDirs: string[]): string {
- const dir = mkdtempSync(join(tmpdir(), "ccp-cursor-auth-"));
- tempDirs.push(dir);
- return dir;
-}
diff --git a/reference/typescript/src/providers/cursor/auth/token-store.ts b/reference/typescript/src/providers/cursor/auth/token-store.ts
deleted file mode 100644
index 3823423..0000000
--- a/reference/typescript/src/providers/cursor/auth/token-store.ts
+++ /dev/null
@@ -1,158 +0,0 @@
-import { readFile, unlink } from "node:fs/promises";
-import { join } from "node:path";
-import { cursorBaseUrl } from "../../../config.ts";
-import { keychainDelete, keychainGet, keychainSet } from "../../../keychain.ts";
-import { cursorAuthFile, legacyConfigDir } from "../../../paths.ts";
-import { writeAtomicJson } from "../../shared/auth/atomic-write.ts";
-import { parseCursorAuthTokens } from "./token-parser.ts";
-import { parseJwtClaims, tokenExpiryMs } from "./jwt.ts";
-
-export interface CursorAuth {
- accessToken: string;
- refreshToken?: string;
- apiKey?: string;
- expires?: number;
- userId?: string;
- email?: string;
- source: string;
-}
-
-interface CursorAuthFile {
- accessToken?: string;
- refreshToken?: string;
- apiKey?: string;
-}
-
-const KEYCHAIN_SERVICE = "claude-code-proxy.cursor";
-const KEYCHAIN_ACCOUNT = "auth";
-const REFRESH_EXPIRY_SKEW_MS = 60_000;
-
-type CursorAuthStorage = "file" | "keychain";
-
-export async function loadCursorAuth(env: NodeJS.ProcessEnv = process.env): Promise<CursorAuth | undefined> {
- const envToken = env.CCP_CURSOR_AUTH_TOKEN || env.CURSOR_AUTH_TOKEN;
- if (envToken) return authFromToken(envToken, "environment");
-
- if (cursorAuthStorage() === "keychain") {
- const raw = keychainGet(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
- if (!raw) return undefined;
- const parsed = JSON.parse(raw) as CursorAuthFile;
- if (!parsed.accessToken) return undefined;
- return refreshIfNeeded(enrich({ ...parsed, accessToken: parsed.accessToken, source: cursorAuthLocation() }));
- }
-
- for (const path of authFileCandidates()) {
- try {
- const raw = await readFile(path, "utf8");
- const parsed = JSON.parse(raw) as CursorAuthFile;
- if (parsed.accessToken) return refreshIfNeeded(enrich({ ...parsed, accessToken: parsed.accessToken, source: path }));
- } catch (err: any) {
- if (err?.code !== "ENOENT") throw err;
- }
- }
-
- return undefined;
-}
-
-export async function clearCursorAuth(): Promise<void> {
- if (cursorAuthStorage() === "keychain") {
- keychainDelete(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT);
- return;
- }
-
- for (const path of authFileCandidates()) {
- try {
- await unlink(path);
- } catch (err: any) {
- if (err?.code !== "ENOENT") throw err;
- }
- }
-}
-
-export async function saveCursorAuth(auth: CursorAuthFile): Promise<CursorAuth> {
- if (!auth.accessToken) throw new Error("Cursor auth accessToken is required");
- if (cursorAuthStorage() === "keychain") {
- keychainSet(KEYCHAIN_SERVICE, KEYCHAIN_ACCOUNT, JSON.stringify(auth));
- return enrich({ ...auth, accessToken: auth.accessToken, source: cursorAuthLocation() });
- }
-
- const path = cursorAuthFile();
- await writeAtomicJson(path, auth);
- return enrich({ ...auth, accessToken: auth.accessToken, source: path });
-}
-
-export function cursorAuthLocation(): string {
- return cursorAuthStorage() === "keychain" ? "macOS Keychain (claude-code-proxy.cursor)" : cursorAuthFile();
-}
-
-export function missingAuthMessage(): string {
- return [
- "Cursor authentication was not found.",
- "Run `claude-code-proxy cursor auth login`, or set CCP_CURSOR_AUTH_TOKEN/CURSOR_AUTH_TOKEN.",
- "The proxy stores Cursor credentials in its own claude-code-proxy.cursor storage, not Cursor Agent's Keychain/auth.json.",
- ].join(" ");
-}
-
-export function expiredAuthMessage(auth: CursorAuth): string {
- const expires = auth.expires ? new Date(auth.expires).toISOString() : "unknown";
- return `Cursor access token from ${auth.source} is expired or near expiry (${expires}). Run \`claude-code-proxy cursor auth login\` again or set CCP_CURSOR_AUTH_TOKEN.`;
-}
-
-function authFromToken(accessToken: string, source: string): CursorAuth {
- return enrich({ accessToken, source });
-}
-
-function enrich(auth: Omit<CursorAuth, "expires" | "userId" | "email"> & Partial<CursorAuth>): CursorAuth {
- const claims = parseJwtClaims(auth.accessToken);
- return {
- ...auth,
- expires: tokenExpiryMs(auth.accessToken),
- userId: typeof claims?.sub === "string" ? claims.sub : auth.userId,
- email: typeof claims?.email === "string" ? claims.email : auth.email,
- };
-}
-
-async function refreshIfNeeded(auth: CursorAuth): Promise<CursorAuth> {
- if (!auth.refreshToken || !auth.expires || auth.expires > Date.now() + REFRESH_EXPIRY_SKEW_MS) {
- return auth;
- }
- const refreshed = await refreshCursorAuth(auth.refreshToken);
- if (!refreshed) return auth;
- return saveCursorAuth({
- accessToken: refreshed.accessToken,
- refreshToken: refreshed.refreshToken,
- apiKey: auth.apiKey,
- });
-}
-
-async function refreshCursorAuth(refreshToken: string): Promise<{ accessToken: string; refreshToken: string } | undefined> {
- const resp = await fetch(`${cursorBaseUrl().replace(/\/$/, "")}/auth/refresh`, {
- method: "POST",
- headers: {
- "content-type": "application/json",
- authorization: `Bearer ${refreshToken}`,
- },
- body: JSON.stringify({}),
- });
- if (!resp.ok) return undefined;
- const parsed = await resp.json();
- return parseCursorAuthTokens(parsed);
-}
-
-function authFileCandidates(): string[] {
- const primary = cursorAuthFile();
- if (hasConfigDirOverride()) return [primary];
- const legacy = join(legacyConfigDir(), "cursor", "auth.json");
- return legacy === primary ? [primary] : [primary, legacy];
-}
-
-function cursorAuthStorage(): CursorAuthStorage {
- if (process.platform === "darwin" && !hasConfigDirOverride()) {
- return "keychain";
- }
- return "file";
-}
-
-function hasConfigDirOverride(): boolean {
- return !!process.env.CCP_CONFIG_DIR;
-}
diff --git a/reference/typescript/src/providers/cursor/cli.ts b/reference/typescript/src/providers/cursor/cli.ts
deleted file mode 100644
index 06ec5ed..0000000
--- a/reference/typescript/src/providers/cursor/cli.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import type { CliHandlers } from "../types.ts";
-import { runCursorLogin } from "./auth/login.ts";
-import {
- type CursorAuth,
- clearCursorAuth,
- cursorAuthLocation,
- loadCursorAuth,
- missingAuthMessage,
-} from "./auth/token-store.ts";
-
-function printCursorAuth(auth: CursorAuth, mode: "login" | "status"): void {
- const storageLabel = mode === "login" ? "Logged in. Storage:" : "Storage:";
- console.log(`${storageLabel} ${auth.source}`);
- if (auth.email) console.log(`Email: ${auth.email}`);
- if (auth.userId) console.log(`User: ${auth.userId}`);
- if (mode === "login") {
- if (auth.expires) console.log(`Expires: ${new Date(auth.expires).toISOString()}`);
- return;
- }
- if (auth.expires) {
- const ms = auth.expires - Date.now();
- console.log(`Expires: ${new Date(auth.expires).toISOString()} (in ${Math.floor(ms / 1000)}s)`);
- } else {
- console.log("Expires: unknown");
- }
-}
-
-export const cursorCli: CliHandlers = {
- async login() {
- const auth = await runCursorLogin();
- if (!auth) {
- console.error("Cursor login did not complete.");
- process.exit(1);
- }
- console.log();
- printCursorAuth(auth, "login");
- },
- async status() {
- const auth = await loadCursorAuth();
- if (!auth) {
- console.log("Not authenticated");
- console.log(missingAuthMessage());
- process.exit(1);
- }
- printCursorAuth(auth, "status");
- },
- async logout() {
- await clearCursorAuth();
- console.log(`Cleared Cursor auth from ${cursorAuthLocation()}`);
- },
-};
diff --git a/reference/typescript/src/providers/cursor/client.test.ts b/reference/typescript/src/providers/cursor/client.test.ts
deleted file mode 100644
index 5a409ba..0000000
--- a/reference/typescript/src/providers/cursor/client.test.ts
+++ /dev/null
@@ -1,468 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { mkdtemp, readFile, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
- CursorError,
- decodeCursorStream,
- encodeConnectFrame,
- isRetryableCursorNetworkResourceError,
- runCursorAgent,
-} from "./client.ts";
-import {
- decodeFrameJson,
- fakeProtoMerged as fakeProto,
- fakeCursorCtx,
- frame,
- jsonBytes,
- streamFromChunks,
-} from "./cursor-test-helpers.ts";
-
-type CursorRunOptions = Omit<Parameters<typeof runCursorAgent>[0], "ctx" | "proto" | "openRunStream">;
-type CursorClientMessage = Record<string, any>;
-
-function buildRunOptions(overrides: Partial<CursorRunOptions> = {}): CursorRunOptions {
- return {
- prompt: "hello",
- mode: "AGENT_MODE_AGENT",
- conversationId: "conversation",
- model: { modelId: "composer-2.5" },
- auth: { accessToken: "token", source: "test" },
- ...overrides,
- };
-}
-
-function buildServerExecFrame(
- id: number,
- execId: string | undefined,
- message: { case: string; value: Record<string, any> },
-): Uint8Array {
- const serverMessage = {
- id,
- ...(execId === undefined ? {} : { execId }),
- message,
- };
-
- return frame({
- message: {
- case: "execServerMessage",
- value: serverMessage,
- },
- });
-}
-
-function buildServerKvFrame(
- id: number,
- message: { case: string; value: Record<string, any> },
-): Uint8Array {
- return frame({
- message: {
- case: "kvServerMessage",
- value: {
- id,
- message,
- },
- },
- });
-}
-
-function buildServerInteractionQueryFrame(
- id: number,
- query: { case: string; value: Record<string, any> },
-): Uint8Array {
- return frame({
- message: {
- case: "interactionQuery",
- value: {
- id,
- query,
- },
- },
- });
-}
-
-function buildServerStreamCloseFrame(): Uint8Array {
- return encodeConnectFrame(jsonBytes({}), 2);
-}
-
-function assertHeartbeatMessage(messages: CursorClientMessage[], index: number) {
- expect(messages[index]).toEqual({ execClientControlMessage: { heartbeat: {} } });
-}
-
-function assertStreamCloseMessage(messages: CursorClientMessage[], index: number, id?: number) {
- expect(messages[index]).toEqual({
- execClientControlMessage: {
- streamClose: id === undefined ? {} : { id },
- },
- });
-}
-
-describe("CursorError retry classification", () => {
- it("retries resource_exhausted network errors", () => {
- expect(
- isRetryableCursorNetworkResourceError(
- new CursorError(429, "Cursor Run failed: resource_exhausted: Network Error"),
- ),
- ).toBe(true);
- });
-
- it("does not retry quota resource_exhausted errors", () => {
- expect(
- isRetryableCursorNetworkResourceError(
- new CursorError(429, "Cursor Run failed: resource_exhausted: You've hit your free requests limit."),
- ),
- ).toBe(false);
- });
-});
-
-async function runCursorAgentWithFrames(
- serverFrames: Uint8Array[],
- runOptions: Partial<CursorRunOptions> = {},
-): Promise<{ upstream: ReadableStream<Uint8Array>; sentFrames: Uint8Array[] }> {
- const sentFrames: Uint8Array[] = [];
-
- const upstream = await runCursorAgent({
- ...buildRunOptions(runOptions),
- ctx: fakeCursorCtx(),
- proto: fakeProto,
- openRunStream: async () => ({
- readable: streamFromChunks(serverFrames),
- status: Promise.resolve({ status: 200 }),
- async write(frame) {
- sentFrames.push(frame);
- },
- close() {},
- }),
- });
-
- return { upstream, sentFrames };
-}
-
-function decodeSentFrames(sentFrames: Uint8Array[]): CursorClientMessage[] {
- return sentFrames.map((frameBytes) => decodeFrameJson(frameBytes) as CursorClientMessage);
-}
-
-async function runAndDrainCursorAgentWithFrames(
- serverFrames: Uint8Array[],
- runOptions: Partial<CursorRunOptions> = {},
-): Promise<CursorClientMessage[]> {
- const { upstream, sentFrames } = await runCursorAgentWithFrames(serverFrames, runOptions);
- await drain(upstream);
- return decodeSentFrames(sentFrames);
-}
-
-describe("Cursor protocol client", () => {
- it("acks exec setup and KV messages on the HTTP/2 Run stream", async () => {
- const { upstream, sentFrames } = await runCursorAgentWithFrames([
- buildServerExecFrame(0, undefined, { case: "requestContextArgs", value: {} }),
- buildServerKvFrame(0, { case: "setBlobArgs", value: {} }),
- buildServerKvFrame(2, { case: "getBlobArgs", value: {} }),
- buildServerStreamCloseFrame(),
- ]);
- await drain(upstream);
-
- const clientMessages = decodeSentFrames(sentFrames);
- expect(clientMessages[0]?.runRequest.conversationId).toBe("conversation");
- expect(clientMessages[0]?.runRequest.clientSupportsInlineImages).toBe(true);
- assertHeartbeatMessage(clientMessages, 1);
- expect(clientMessages[2]?.execClientMessage.requestContextResult.success.requestContext).toBeDefined();
- expect(clientMessages[2]?.execClientMessage.requestContextResult.success.requestContext.webSearchEnabled).toBe(true);
- expect(clientMessages[2]?.execClientMessage.requestContextResult.success.requestContext.webFetchEnabled).toBe(true);
- assertStreamCloseMessage(clientMessages, 3);
- expect(clientMessages[4]).toEqual({ kvClientMessage: { setBlobResult: {} } });
- expect(clientMessages[5]).toEqual({ kvClientMessage: { getBlobResult: {}, id: 2 } });
- });
-
- it("answers repeated Cursor requestContextArgs messages", async () => {
- const clientMessages = await runAndDrainCursorAgentWithFrames([
- buildServerExecFrame(0, undefined, { case: "requestContextArgs", value: {} }),
- buildServerExecFrame(7, "exec-context", { case: "requestContextArgs", value: {} }),
- buildServerStreamCloseFrame(),
- ]);
-
- assertHeartbeatMessage(clientMessages, 1);
- expect(clientMessages[2]?.execClientMessage.requestContextResult.success.requestContext).toBeDefined();
- assertStreamCloseMessage(clientMessages, 3);
- expect(clientMessages[4]).toMatchObject({
- execClientMessage: {
- id: 7,
- execId: "exec-context",
- requestContextResult: {
- success: {
- requestContext: expect.any(Object),
- },
- },
- },
- });
- assertStreamCloseMessage(clientMessages, 5, 7);
- });
-
- it("sends selected images in the Cursor run request", async () => {
- const { upstream, sentFrames } = await runCursorAgentWithFrames(
- [buildServerStreamCloseFrame()],
- {
- prompt: "describe image",
- selectedImages: [
- {
- data: "aGVsbG8=",
- uuid: "image-id",
- path: "claude-image-1.png",
- mimeType: "image/png",
- },
- ],
- },
- );
- await drain(upstream);
-
- const clientMessages = decodeSentFrames(sentFrames);
- expect(clientMessages[0]?.runRequest.action.userMessageAction.userMessage.selectedContext).toEqual({
- selectedImages: [
- {
- data: "aGVsbG8=",
- uuid: "image-id",
- path: "claude-image-1.png",
- mimeType: "image/png",
- },
- ],
- });
- expect(clientMessages[0]?.runRequest.clientSupportsInlineImages).toBe(true);
- });
-
- it("approves Cursor web search and web fetch interaction queries", async () => {
- const { upstream, sentFrames } = await runCursorAgentWithFrames(
- [
- buildServerInteractionQueryFrame(11, {
- case: "webSearchRequestQuery",
- value: { args: { searchTerm: "cursor" } },
- }),
- buildServerInteractionQueryFrame(12, {
- case: "webFetchRequestQuery",
- value: { args: { url: "https://example.com" } },
- }),
- buildServerInteractionQueryFrame(13, { case: "generateImageRequestQuery", value: {} }),
- buildServerStreamCloseFrame(),
- ],
- { prompt: "search the web" },
- );
- await drain(upstream);
-
- const clientMessages = decodeSentFrames(sentFrames);
- expect(clientMessages).toContainEqual({
- interactionResponse: { id: 11, webSearchRequestResponse: { approved: {} } },
- });
- expect(clientMessages).toContainEqual({
- interactionResponse: { id: 12, webFetchRequestResponse: { approved: {} } },
- });
- expect(clientMessages.some((message) => message.interactionResponse?.id === 13)).toBe(false);
- });
-
- it("answers Cursor readArgs with file content and closes the exec stream", async () => {
- const dir = await mkdtemp(join(tmpdir(), "cursor-read-"));
- const file = join(dir, "SKILL.md");
- await writeFile(file, "hello\nworld\n", "utf8");
-
- const clientMessages = await runAndDrainCursorAgentWithFrames([
- buildServerExecFrame(7, "exec-read", {
- case: "readArgs",
- value: { path: file },
- }),
- buildServerStreamCloseFrame(),
- ]);
- assertHeartbeatMessage(clientMessages, 1);
- expect(clientMessages[2]).toEqual({
- execClientMessage: {
- id: 7,
- execId: "exec-read",
- readResult: {
- success: {
- path: file,
- content: "hello\nworld\n",
- totalLines: 3,
- fileSize: "12",
- },
- },
- },
- });
- assertStreamCloseMessage(clientMessages, 3, 7);
- });
-
- it("answers Cursor writeArgs by writing the file and closing the exec stream", async () => {
- const dir = await mkdtemp(join(tmpdir(), "cursor-write-"));
- const file = join(dir, "history", "findings.md");
-
- const clientMessages = await runAndDrainCursorAgentWithFrames([
- buildServerExecFrame(10, "exec-write", {
- case: "writeArgs",
- value: {
- path: file,
- fileText: "finding one\nfinding two\n",
- returnFileContentAfterWrite: true,
- },
- }),
- buildServerStreamCloseFrame(),
- ]);
- expect(await readFile(file, "utf8")).toBe("finding one\nfinding two\n");
- assertHeartbeatMessage(clientMessages, 1);
- expect(clientMessages[2]).toEqual({
- execClientMessage: {
- id: 10,
- execId: "exec-write",
- writeResult: {
- success: {
- path: file,
- linesCreated: 3,
- fileSize: 24,
- fileContentAfterWrite: "finding one\nfinding two\n",
- },
- },
- },
- });
- assertStreamCloseMessage(clientMessages, 3, 10);
- });
-
- it("answers Cursor grepArgs with glob file matches and closes the exec stream", async () => {
- const dir = await mkdtemp(join(tmpdir(), "cursor-grep-"));
- await writeFile(join(dir, "README.md"), "hello\n", "utf8");
- await writeFile(join(dir, "notes.txt"), "hello\n", "utf8");
-
- const clientMessages = await runAndDrainCursorAgentWithFrames([
- buildServerExecFrame(8, "exec-grep", {
- case: "grepArgs",
- value: {
- pattern: "",
- path: dir,
- glob: "**/README*",
- outputMode: "files_with_matches",
- },
- }),
- buildServerStreamCloseFrame(),
- ]);
- assertHeartbeatMessage(clientMessages, 1);
- expect(clientMessages[2]).toEqual({
- execClientMessage: {
- id: 8,
- execId: "exec-grep",
- grepResult: {
- success: {
- pattern: "**/README*",
- path: dir,
- outputMode: "files_with_matches",
- workspaceResults: {
- [dir]: {
- files: {
- files: ["README.md"],
- totalFiles: 1,
- },
- },
- },
- },
- },
- },
- });
- assertStreamCloseMessage(clientMessages, 3, 8);
- });
-
- it("answers Cursor shellStreamArgs with stream events and closes the exec stream", async () => {
- const { upstream, sentFrames } = await runCursorAgentWithFrames([
- buildServerExecFrame(9, "exec-shell", {
- case: "shellStreamArgs",
- value: {
- command: "printf stdout; printf stderr >&2",
- workingDirectory: process.cwd(),
- timeout: 5000,
- },
- }),
- buildServerStreamCloseFrame(),
- ]);
- let trace = "";
- for await (const event of decodeCursorStream(upstream, fakeProto)) {
- if (event.type === "text_delta") trace += event.text;
- }
-
- const clientMessages = decodeSentFrames(sentFrames);
- assertHeartbeatMessage(clientMessages, 1);
- expect(clientMessages.some((message) => message.execClientMessage?.shellStream?.start)).toBe(true);
- expect(clientMessages.some((message) => message.execClientMessage?.shellStream?.stdout?.data === "stdout")).toBe(true);
- expect(clientMessages.some((message) => message.execClientMessage?.shellStream?.stderr?.data === "stderr")).toBe(true);
- expect(clientMessages.some((message) => message.execClientMessage?.shellStream?.exit?.code === 0)).toBe(true);
- assertStreamCloseMessage(clientMessages, clientMessages.length - 1, 9);
- expect(trace).toContain("Bash(printf stdout; printf stderr >&2)");
- expect(trace).toContain("stdout");
- expect(trace).toContain("stderr");
- });
-
- it("closes the Cursor run stream when the downstream consumer cancels", async () => {
- let closeCalls = 0;
- const upstream = await runCursorAgent({
- ...buildRunOptions(),
- ctx: fakeCursorCtx(),
- proto: fakeProto,
- openRunStream: async () => ({
- readable: new ReadableStream<Uint8Array>(),
- status: Promise.resolve({ status: 200 }),
- async write() {},
- close() {
- closeCalls += 1;
- },
- }),
- });
-
- await upstream.cancel("done");
-
- expect(closeCalls).toBe(1);
- });
-
- it("stops Cursor heartbeats when the Run stream closes", async () => {
- const originalSetInterval = globalThis.setInterval;
- const originalClearInterval = globalThis.clearInterval;
- const fakeTimer = Symbol("heartbeat-timer");
- let heartbeatCleared = false;
- let resolveClosed!: () => void;
- const closed = new Promise<void>((resolve) => {
- resolveClosed = resolve;
- });
- let closeCalls = 0;
-
- globalThis.setInterval = (() => fakeTimer) as unknown as typeof setInterval;
- globalThis.clearInterval = ((timer: unknown) => {
- if (timer === fakeTimer) heartbeatCleared = true;
- }) as typeof clearInterval;
-
- try {
- await runCursorAgent({
- ...buildRunOptions(),
- ctx: fakeCursorCtx(),
- proto: fakeProto,
- openRunStream: async () => ({
- readable: new ReadableStream<Uint8Array>(),
- status: Promise.resolve({ status: 200 }),
- closed,
- async write() {},
- close() {
- closeCalls += 1;
- },
- }),
- });
-
- resolveClosed();
- await Promise.resolve();
-
- expect(heartbeatCleared).toBe(true);
- expect(closeCalls).toBe(1);
- } finally {
- globalThis.setInterval = originalSetInterval;
- globalThis.clearInterval = originalClearInterval;
- }
- });
-});
-
-async function drain(stream: ReadableStream<Uint8Array>): Promise<void> {
- const reader = stream.getReader();
- try {
- while (!(await reader.read()).done) {
- // Drain.
- }
- } finally {
- reader.releaseLock();
- }
-}
diff --git a/reference/typescript/src/providers/cursor/client.ts b/reference/typescript/src/providers/cursor/client.ts
deleted file mode 100644
index 99eea29..0000000
--- a/reference/typescript/src/providers/cursor/client.ts
+++ /dev/null
@@ -1,1290 +0,0 @@
-import { gunzipSync } from "node:zlib";
-import http2 from "node:http2";
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join } from "node:path";
-import { cursorBaseUrl, cursorClientVersion } from "../../config.ts";
-import type { RequestContext, TrafficCapture } from "../types.ts";
-import type { Logger } from "../../log.ts";
-import type { CursorProto } from "./proto-loader.ts";
-import { loadCursorProto } from "./proto-loader.ts";
-import type { CursorAuth } from "./auth/token-store.ts";
-import type { CursorSelectedImage } from "./translate/request.ts";
-
-export interface CursorRunOptions {
- prompt: string;
- mode: CursorAgentMode;
- conversationId: string;
- model: CursorModelRequest;
- selectedImages?: CursorSelectedImage[];
- auth: CursorAuth;
- ctx: RequestContext;
- proto?: CursorProto;
- openRunStream?: CursorRunStreamFactory;
- readHandler?: CursorReadHandler;
- shellStreamHandler?: CursorShellStreamHandler;
- writeHandler?: CursorWriteHandler;
-}
-
-export type CursorRunStreamFactory = (opts: {
- requestId: string;
- accessToken: string;
- ctx: RequestContext;
-}) => Promise<CursorRunStream>;
-
-export interface CursorRunStream {
- readable: ReadableStream<Uint8Array>;
- status: Promise<{ status: number; detail?: string }>;
- closed?: Promise<void>;
- write(frame: Uint8Array): Promise<void>;
- close(): void;
-}
-
-export interface CursorShellStreamExec {
- id?: number;
- execId?: string;
- message?: { case?: string; value?: unknown };
-}
-
-export interface CursorShellStreamResult {
- stdout?: string;
- stderr?: string;
- exitCode: number;
- cwd?: string;
- aborted?: boolean;
- abortReason?: string;
- localExecutionTimeMs?: number;
-}
-
-export type CursorAppendMessage = (messageJson: unknown) => Promise<void>;
-
-export interface CursorReadExec {
- id?: number;
- execId?: string;
- message?: { case?: string; value?: unknown };
-}
-
-export interface CursorReadToolResult {
- success: boolean;
- error?: string;
-}
-
-export type CursorReadHandler = (
- exec: CursorReadExec,
- append: CursorAppendMessage,
-) => Promise<void>;
-
-export type CursorShellStreamHandler = (
- exec: CursorShellStreamExec,
- append: CursorAppendMessage,
-) => Promise<void>;
-
-export interface CursorWriteExec {
- id?: number;
- execId?: string;
- message?: { case?: string; value?: unknown };
-}
-
-export interface CursorWriteResult {
- success: boolean;
- error?: string;
-}
-
-export type CursorWriteHandler = (
- exec: CursorWriteExec,
- append: CursorAppendMessage,
-) => Promise<void>;
-
-export type CursorAgentMode = "AGENT_MODE_AGENT" | "AGENT_MODE_PLAN" | "AGENT_MODE_ASK";
-
-export interface CursorModelRequest {
- modelId: string;
- parameters?: Array<{ id: string; value: string }>;
-}
-
-export interface CursorUsage {
- inputTokens: string;
- outputTokens: string;
- cacheReadTokens?: string;
- cacheWriteTokens?: string;
-}
-
-export type CursorStreamEvent =
- | { type: "session"; sessionId: string }
- | { type: "thinking_delta"; text: string }
- | { type: "text_delta"; text: string }
- | { type: "usage"; usage: CursorUsage }
- | { type: "end" };
-
-export class CursorError extends Error {
- constructor(
- public status: number,
- message: string,
- public detail?: string,
- ) {
- super(message);
- this.name = "CursorError";
- }
-}
-
-export function isRetryableCursorNetworkResourceError(err: unknown): boolean {
- if (!(err instanceof CursorError) || err.status !== 429) return false;
- const text = `${err.message} ${err.detail ?? ""}`.toLowerCase();
- return text.includes("resource_exhausted") && text.includes("network error");
-}
-
-const HEARTBEAT_INTERVAL_MS = 5_000;
-export const CURSOR_OUTPUT_IDLE_TIMEOUT_MS = 30_000;
-
-export async function runCursorAgent(opts: CursorRunOptions): Promise<ReadableStream<Uint8Array>> {
- const proto = opts.proto ?? loadCursorProto();
- const requestId = crypto.randomUUID();
- const openRunStream = opts.openRunStream ?? openHttp2RunStream;
- const runUrl = `${cursorBaseUrl().replace(/\/$/, "")}/agent.v1.AgentService/Run`;
-
- opts.ctx.traffic?.writeJson("020-cursor-run-request", {
- url: runUrl,
- requestId,
- conversationId: opts.conversationId,
- mode: opts.mode,
- model: opts.model,
- });
-
- const runStream = await openRunStream({
- requestId,
- accessToken: opts.auth.accessToken,
- ctx: opts.ctx,
- });
-
- let appendQueue = Promise.resolve();
- const append = async (messageJson: unknown) => {
- appendQueue = appendQueue.then(async () => {
- const messageBytes = proto.AgentClientMessage.fromJson(messageJson).toBinary();
- const frame = encodeConnectFrame(messageBytes);
- opts.ctx.traffic?.writeBytes("021-cursor-run-frame", frame);
- await runStream.write(frame);
- });
- await appendQueue;
- };
-
- await append({
- runRequest: {
- conversationState: {},
- action: {
- userMessageAction: {
- userMessage: {
- text: opts.prompt,
- messageId: crypto.randomUUID(),
- selectedContext: selectedContext(opts.selectedImages),
- mode: opts.mode,
- },
- },
- },
- mcpTools: {},
- conversationId: opts.conversationId,
- requestedModel: opts.model,
- excludeWorkspaceContext: false,
- selectedSubagentModels: selectedSubagentModels(opts.model),
- conversationGroupId: opts.conversationId,
- clientSupportsInlineImages: true,
- },
- });
-
- const heartbeat = setInterval(() => {
- append({ clientHeartbeat: {} }).catch((err) => {
- opts.ctx.childLogger("cursor.client").warn("cursor heartbeat failed", {
- err: String(err),
- });
- });
- }, HEARTBEAT_INTERVAL_MS);
-
- let cleanedUp = false;
- const cleanup = () => {
- if (cleanedUp) return;
- cleanedUp = true;
- clearInterval(heartbeat);
- opts.ctx.signal.removeEventListener("abort", cleanup);
- runStream.close();
- };
- opts.ctx.signal.addEventListener("abort", cleanup, { once: true });
- void runStream.closed?.then(cleanup, cleanup);
-
- const response = await runStream.status;
- if (response.status < 200 || response.status >= 300) {
- cleanup();
- throw new CursorError(response.status, `Cursor AgentService/Run failed with HTTP ${response.status}`, response.detail);
- }
-
- const transformed = runStream.readable.pipeThrough(
- new TransformStream<Uint8Array, Uint8Array>({
- async transform(chunk, controller) {
- opts.ctx.traffic?.writeBytes("030-cursor-run-response-chunk", chunk);
- controller.enqueue(chunk);
- await processServerControlFrames(
- chunk,
- proto,
- append,
- opts.ctx,
- opts.readHandler,
- opts.shellStreamHandler,
- opts.writeHandler,
- (text) => {
- if (!text || controller.desiredSize === null) return;
- try {
- opts.ctx.traffic?.writeJsonEvent("038-cursor-tool-trace", { text });
- const messageBytes = proto.AgentServerMessage.fromJson({
- interactionUpdate: { textDelta: { text } },
- }).toBinary();
- controller.enqueue(encodeConnectFrame(messageBytes));
- } catch {
- // Downstream cancellation can close the transformed stream while a Cursor exec is still finishing.
- }
- },
- );
- },
- flush() {
- cleanup();
- },
- }),
- );
- return readableWithCleanup(transformed, cleanup);
-}
-
-function readableWithCleanup(stream: ReadableStream<Uint8Array>, cleanup: () => void): ReadableStream<Uint8Array> {
- const reader = stream.getReader();
- return new ReadableStream<Uint8Array>({
- async pull(controller) {
- const { done, value } = await reader.read();
- if (done) {
- cleanup();
- controller.close();
- return;
- }
- if (value) controller.enqueue(value);
- },
- async cancel(reason) {
- cleanup();
- await reader.cancel(reason);
- },
- });
-}
-
-export async function openHttp2RunStream(opts: {
- requestId: string;
- accessToken: string;
- ctx: RequestContext;
-}): Promise<CursorRunStream> {
- const base = new URL(cursorBaseUrl());
- const session = http2.connect(base.origin);
- await new Promise<void>((resolve, reject) => {
- const cleanup = () => {
- session.off("connect", onConnect);
- session.off("error", onError);
- };
- const onConnect = () => {
- cleanup();
- resolve();
- };
- const onError = (err: Error) => {
- cleanup();
- reject(err);
- };
- session.once("connect", onConnect);
- session.once("error", onError);
- });
-
- let closed = false;
- let responseStatus = 0;
- let errorDetail = "";
- let statusSettled = false;
- let resolveClosed!: () => void;
- let resolveStatus!: (value: { status: number; detail?: string }) => void;
- let rejectStatus!: (err: Error) => void;
- const closedSignal = new Promise<void>((resolve) => {
- resolveClosed = resolve;
- });
- const status = new Promise<{ status: number; detail?: string }>((resolve, reject) => {
- resolveStatus = resolve;
- rejectStatus = reject;
- });
- const settleStatus = (value: { status: number; detail?: string }) => {
- if (statusSettled) return;
- statusSettled = true;
- resolveStatus(value);
- };
- const failStatus = (err: unknown) => {
- if (statusSettled) return;
- statusSettled = true;
- rejectStatus(err instanceof Error ? err : new Error(String(err)));
- };
-
- const stream = session.request({
- ":method": "POST",
- ":path": `${base.pathname.replace(/\/$/, "")}/agent.v1.AgentService/Run`,
- "authorization": `Bearer ${opts.accessToken}`,
- "content-type": "application/connect+proto",
- "connect-protocol-version": "1",
- "connect-accept-encoding": "gzip,br",
- "user-agent": "connect-es/1.6.1",
- "x-cursor-client-type": "cli",
- "x-cursor-client-version": cursorClientVersion(),
- "x-ghost-mode": "true",
- "x-request-id": opts.requestId,
- "x-original-request-id": opts.requestId,
- "x-cursor-streaming": "true",
- "te": "trailers",
- });
-
- stream.once("response", (headers) => {
- responseStatus = Number(headers[":status"] ?? 0);
- if (responseStatus >= 200 && responseStatus < 300) {
- settleStatus({ status: responseStatus });
- }
- });
-
- const readable = new ReadableStream<Uint8Array>({
- start(controller) {
- let readableClosed = false;
- const markClosed = () => {
- closed = true;
- resolveClosed();
- };
- const safeCloseReadable = () => {
- if (readableClosed) return;
- readableClosed = true;
- try {
- controller.close();
- } catch {
- // The downstream consumer may have canceled the ReadableStream first.
- }
- };
- const safeErrorReadable = (err: unknown) => {
- if (readableClosed) return;
- readableClosed = true;
- try {
- controller.error(err);
- } catch {
- // The downstream consumer may have canceled the ReadableStream first.
- }
- };
- stream.on("data", (chunk: Buffer) => {
- if (responseStatus >= 400) {
- errorDetail += chunk.toString("utf8");
- return;
- }
- if (readableClosed) return;
- controller.enqueue(new Uint8Array(chunk));
- });
- stream.once("end", () => {
- if (responseStatus >= 400) {
- settleStatus({ status: responseStatus, detail: errorDetail || undefined });
- }
- safeCloseReadable();
- markClosed();
- session.close();
- });
- stream.once("error", (err) => {
- failStatus(err);
- safeErrorReadable(err);
- markClosed();
- session.destroy();
- });
- stream.once("close", () => {
- if (responseStatus === 0) failStatus(new Error("Cursor HTTP/2 Run stream closed before response headers"));
- safeCloseReadable();
- markClosed();
- session.close();
- });
- session.once("error", (err) => {
- failStatus(err);
- safeErrorReadable(err);
- markClosed();
- });
- session.once("close", markClosed);
- },
- cancel() {
- close();
- },
- });
-
- const close = () => {
- if (closed) return;
- closed = true;
- resolveClosed();
- stream.close();
- session.close();
- };
-
- return {
- readable,
- status,
- closed: closedSignal,
- write(frame: Uint8Array) {
- if (closed || stream.destroyed) {
- return Promise.reject(new Error("Cursor HTTP/2 Run stream is closed"));
- }
- return new Promise<void>((resolve, reject) => {
- stream.write(Buffer.from(frame), (err) => {
- if (err) reject(err);
- else resolve();
- });
- });
- },
- close,
- };
-}
-
-async function processServerControlFrames(
- chunk: Uint8Array,
- proto: CursorProto,
- append: (messageJson: unknown) => Promise<void>,
- ctx?: RequestContext,
- readHandler?: CursorReadHandler,
- shellStreamHandler?: CursorShellStreamHandler,
- writeHandler?: CursorWriteHandler,
- emitTrace?: (text: string) => void,
-): Promise<void> {
- const state = controlFrameState.get(append) ?? {
- buffer: Buffer.alloc(0),
- execHeartbeatSent: false,
- };
- controlFrameState.set(append, state);
- state.buffer = Buffer.concat([state.buffer, Buffer.from(chunk)]);
- while (state.buffer.byteLength >= 5) {
- const flags = state.buffer[0]!;
- const len = state.buffer.readUInt32BE(1);
- if (state.buffer.byteLength < 5 + len) break;
- let payload = state.buffer.subarray(5, 5 + len);
- state.buffer = state.buffer.subarray(5 + len);
- if (flags & 1) payload = gunzipSync(payload);
- if (flags & 2) continue;
- const message = proto.AgentServerMessage.fromBinary(payload) as unknown as CursorOneofMessage;
- const summary = summarizeCursorOneofMessage(message);
- ctx?.traffic?.writeJsonEvent("035-cursor-server-message", summary);
- ctx?.childLogger("cursor.client").debug("cursor server message", summary);
- const oneof = message.message;
- if (oneof?.case === "execServerMessage") {
- if (!state.execHeartbeatSent) {
- state.execHeartbeatSent = true;
- await append({ execClientControlMessage: { heartbeat: {} } });
- }
- if (oneof.value?.message?.case === "requestContextArgs") {
- await append({ execClientMessage: buildRequestContextResult(oneof.value) });
- await append({ execClientControlMessage: { streamClose: streamCloseForExec(oneof.value) } });
- } else if (oneof.value?.message?.case === "readArgs") {
- if (readHandler) {
- await readHandler(oneof.value, append);
- } else {
- await append({ execClientMessage: await buildReadResult(oneof.value) });
- await append({ execClientControlMessage: { streamClose: { id: oneof.value.id } } });
- }
- } else if (oneof.value?.message?.case === "writeArgs") {
- if (writeHandler) {
- await writeHandler(oneof.value, append);
- } else {
- await append({ execClientMessage: await buildWriteResult(oneof.value) });
- await append({ execClientControlMessage: { streamClose: { id: oneof.value.id } } });
- }
- } else if (oneof.value?.message?.case === "grepArgs") {
- await append({ execClientMessage: await buildGrepResult(oneof.value) });
- await append({ execClientControlMessage: { streamClose: { id: oneof.value.id } } });
- } else if (oneof.value?.message?.case === "shellStreamArgs") {
- if (shellStreamHandler) {
- await shellStreamHandler(oneof.value, append);
- } else {
- await runShellStream(oneof.value, append, emitTrace);
- }
- }
- } else if (oneof?.case === "kvServerMessage") {
- const kv = oneof.value;
- if (kv?.message?.case === "setBlobArgs") {
- const msg: Record<string, unknown> = { setBlobResult: {} };
- if (typeof kv.id === "number" && kv.id !== 0) msg.id = kv.id;
- await append({ kvClientMessage: msg });
- } else if (kv?.message?.case === "getBlobArgs") {
- const msg: Record<string, unknown> = { getBlobResult: {} };
- if (typeof kv.id === "number" && kv.id !== 0) msg.id = kv.id;
- await append({ kvClientMessage: msg });
- }
- } else if (oneof?.case === "interactionQuery") {
- const response = buildInteractionResponse(oneof.value);
- if (response) await append({ interactionResponse: response });
- }
- }
-}
-
-export function cursorShellStreamArgs(exec: CursorShellStreamExec): {
- command: string;
- workingDirectory: string;
- timeoutMs: number;
-} {
- const args = asRecord(exec.message?.value);
- const command = typeof args?.command === "string" ? args.command : "";
- const workingDirectory = typeof args?.workingDirectory === "string" && args.workingDirectory
- ? args.workingDirectory
- : process.cwd();
- const timeoutMs = typeof args?.timeout === "number" && args.timeout > 0 ? args.timeout : 30_000;
- return { command, workingDirectory, timeoutMs };
-}
-
-export function cursorReadArgs(exec: CursorReadExec): {
- path: string;
-} {
- const args = asRecord(exec.message?.value);
- const path = typeof args?.path === "string" ? args.path : "";
- return { path };
-}
-
-export function cursorWriteArgs(exec: CursorWriteExec): {
- path: string;
- content: string;
- returnFileContentAfterWrite: boolean;
-} {
- const args = asRecord(exec.message?.value);
- const path = typeof args?.path === "string" ? args.path : "";
- const rawContent = writeContentFromArgs(args);
- const content = typeof rawContent === "string" ? rawContent : rawContent.toString("utf8");
- const returnFileContentAfterWrite = Boolean(args?.returnFileContentAfterWrite);
- return { path, content, returnFileContentAfterWrite };
-}
-
-async function buildReadResult(exec: {
- id?: number;
- execId?: string;
- message?: { case?: string; value?: unknown };
-}): Promise<Record<string, unknown>> {
- const args = asRecord(exec.message?.value);
- const requestedPath = typeof args?.path === "string" ? args.path : "";
- let content = "";
- let fileSize = "0";
- let totalLines = 0;
- try {
- content = await readFile(requestedPath, "utf8");
- const fileStat = await stat(requestedPath);
- fileSize = String(fileStat.size);
- totalLines = content.length === 0 ? 0 : content.split("\n").length;
- } catch (err) {
- content = `Error reading ${requestedPath}: ${err instanceof Error ? err.message : String(err)}`;
- fileSize = String(Buffer.byteLength(content, "utf8"));
- totalLines = 1;
- }
- return withExecIds(exec, {
- readResult: {
- success: {
- path: requestedPath,
- content,
- totalLines,
- fileSize,
- },
- },
- });
-}
-
-async function buildWriteResult(exec: {
- id?: number;
- execId?: string;
- message?: { case?: string; value?: unknown };
-}): Promise<Record<string, unknown>> {
- const args = asRecord(exec.message?.value);
- const requestedPath = typeof args?.path === "string" ? args.path : "";
- const returnContent = Boolean(args?.returnFileContentAfterWrite);
- try {
- if (!requestedPath) throw new Error("write path is required");
- const content = writeContentFromArgs(args);
- await mkdir(dirname(requestedPath), { recursive: true });
- await writeFile(requestedPath, content);
- const textContent = typeof content === "string" ? content : content.toString("utf8");
- const success: Record<string, unknown> = {
- path: requestedPath,
- linesCreated: lineCount(textContent),
- fileSize: Buffer.byteLength(content),
- };
- if (returnContent) success.fileContentAfterWrite = await readFile(requestedPath, "utf8");
- return withExecIds(exec, {
- writeResult: { success },
- });
- } catch (err) {
- return withExecIds(exec, {
- writeResult: {
- error: {
- path: requestedPath,
- error: err instanceof Error ? err.message : String(err),
- },
- },
- });
- }
-}
-
-function writeContentFromArgs(args: Record<string, unknown> | undefined): string | Buffer {
- if (typeof args?.fileText === "string") return args.fileText;
- if (typeof args?.file_text === "string") return args.file_text;
- if (typeof args?.fileBytes === "string") return Buffer.from(args.fileBytes, "base64");
- if (typeof args?.file_bytes === "string") return Buffer.from(args.file_bytes, "base64");
- if (args?.fileBytes instanceof Uint8Array) return Buffer.from(args.fileBytes);
- if (args?.file_bytes instanceof Uint8Array) return Buffer.from(args.file_bytes);
- return "";
-}
-
-interface CursorNativeExec {
- id?: number;
- execId?: string;
-}
-
-function withExecIds(
- exec: CursorNativeExec,
- payload: Record<string, unknown>,
-): Record<string, unknown> {
- return {
- ...(typeof exec.id === "number" ? { id: exec.id } : {}),
- ...(typeof exec.execId === "string" ? { execId: exec.execId } : {}),
- ...payload,
- };
-}
-
-function lineCount(content: string): number {
- return content.length === 0 ? 0 : content.split("\n").length;
-}
-
-export interface CursorNativeToolResult {
- content: string;
- isError: boolean;
-}
-
-export function buildCursorReadResultFromNativeToolResult(
- result: CursorNativeToolResult,
-): CursorReadToolResult {
- return {
- success: !result.isError,
- error: result.isError ? result.content : undefined,
- };
-}
-
-export function buildCursorWriteResultFromNativeToolResult(
- result: CursorNativeToolResult,
-): CursorWriteResult {
- if (!result.isError) return { success: true };
- return {
- success: false,
- error: result.content || "Write tool failed",
- };
-}
-
-export function buildCursorShellStreamResultFromNativeToolResult(
- result: CursorNativeToolResult,
- startedAt: number,
- cwd: string,
-): CursorShellStreamResult {
- return {
- stdout: result.isError ? undefined : result.content,
- stderr: result.isError ? result.content : undefined,
- exitCode: result.isError ? 1 : 0,
- cwd,
- localExecutionTimeMs: Date.now() - startedAt,
- };
-}
-
-export async function appendCursorReadResult(
- exec: CursorReadExec,
- result: CursorReadToolResult,
- append: CursorAppendMessage,
-): Promise<void> {
- await append({ execClientMessage: await buildReadResultFromTool(exec, result) });
- await append({ execClientControlMessage: { streamClose: { id: exec.id } } });
-}
-
-async function buildReadResultFromTool(
- exec: CursorReadExec,
- result: CursorReadToolResult,
-): Promise<Record<string, unknown>> {
- if (result.success) return buildReadResult(exec);
-
- const { path } = cursorReadArgs(exec);
- const content = result.error || `Error reading ${path}`;
- return withExecIds(exec, {
- readResult: {
- success: {
- path,
- content,
- totalLines: lineCount(content),
- fileSize: String(Buffer.byteLength(content, "utf8")),
- },
- },
- });
-}
-
-export async function appendCursorWriteResult(
- exec: CursorWriteExec,
- result: CursorWriteResult,
- append: CursorAppendMessage,
-): Promise<void> {
- await append({ execClientMessage: await buildWriteResultFromTool(exec, result) });
- await append({ execClientControlMessage: { streamClose: { id: exec.id } } });
-}
-
-async function buildWriteResultFromTool(
- exec: CursorWriteExec,
- result: CursorWriteResult,
-): Promise<Record<string, unknown>> {
- const { path, returnFileContentAfterWrite } = cursorWriteArgs(exec);
- if (!result.success) {
- return withExecIds(exec, {
- writeResult: {
- error: {
- path,
- error: result.error || "Write tool failed",
- },
- },
- });
- }
-
- const content = await readFile(path, "utf8");
- const success: Record<string, unknown> = {
- path,
- linesCreated: lineCount(content),
- fileSize: Buffer.byteLength(content),
- };
- if (returnFileContentAfterWrite) success.fileContentAfterWrite = content;
- return withExecIds(exec, {
- writeResult: { success },
- });
-}
-
-async function runShellStream(
- exec: {
- id?: number;
- execId?: string;
- message?: { case?: string; value?: unknown };
- },
- append: (messageJson: unknown) => Promise<void>,
- emitTrace?: (text: string) => void,
-): Promise<void> {
- const { command, workingDirectory, timeoutMs } = cursorShellStreamArgs(exec);
- const started = Date.now();
- let outputStarted = false;
- const emitOutputTrace = (data: string) => {
- if (!emitTrace || !data) return;
- if (!outputStarted) {
- outputStarted = true;
- emitTrace("\n \u23bf ");
- }
- emitTrace(data);
- };
- if (emitTrace && command) {
- emitTrace(`\n\n\u23fa Bash(${command})\n`);
- }
- await append({ execClientMessage: buildShellStream(exec, { start: {} }) });
-
- let timedOut = false;
- const proc = Bun.spawn(["/bin/sh", "-lc", command], {
- cwd: workingDirectory,
- stdout: "pipe",
- stderr: "pipe",
- });
- const timeout = setTimeout(() => {
- timedOut = true;
- proc.kill("SIGTERM");
- }, timeoutMs);
- try {
- const [exitCode] = await Promise.all([
- proc.exited,
- appendShellOutput(exec, proc.stdout, "stdout", append, emitOutputTrace),
- appendShellOutput(exec, proc.stderr, "stderr", append, emitOutputTrace),
- ]);
- await append({
- execClientMessage: buildShellStream(exec, {
- exit: {
- code: exitCode,
- cwd: workingDirectory,
- aborted: timedOut,
- ...(timedOut ? { abortReason: "ABORT_REASON_TIMEOUT" } : {}),
- localExecutionTimeMs: Date.now() - started,
- },
- }),
- });
- } catch (err) {
- await append({
- execClientMessage: buildShellStream(exec, {
- stderr: {
- data: `Shell execution failed: ${err instanceof Error ? err.message : String(err)}`,
- },
- }),
- });
- emitOutputTrace(`Shell execution failed: ${err instanceof Error ? err.message : String(err)}`);
- await append({
- execClientMessage: buildShellStream(exec, {
- exit: {
- code: 1,
- cwd: workingDirectory,
- localExecutionTimeMs: Date.now() - started,
- },
- }),
- });
- } finally {
- clearTimeout(timeout);
- await append({ execClientControlMessage: { streamClose: { id: exec.id } } });
- }
-}
-
-export async function appendCursorShellStreamResult(
- exec: CursorShellStreamExec,
- result: CursorShellStreamResult,
- append: CursorAppendMessage,
-): Promise<void> {
- const cwd = result.cwd || cursorShellStreamArgs(exec).workingDirectory;
- await append({ execClientMessage: buildShellStream(exec, { start: {} }) });
- if (result.stdout) {
- await append({ execClientMessage: buildShellStream(exec, { stdout: { data: result.stdout } }) });
- }
- if (result.stderr) {
- await append({ execClientMessage: buildShellStream(exec, { stderr: { data: result.stderr } }) });
- }
- await append({
- execClientMessage: buildShellStream(exec, {
- exit: {
- code: result.exitCode,
- cwd,
- aborted: Boolean(result.aborted),
- ...(result.abortReason ? { abortReason: result.abortReason } : {}),
- localExecutionTimeMs: result.localExecutionTimeMs ?? 0,
- },
- }),
- });
- await append({ execClientControlMessage: { streamClose: { id: exec.id } } });
-}
-
-async function appendShellOutput(
- exec: { id?: number; execId?: string },
- stream: ReadableStream<Uint8Array> | null,
- streamName: "stdout" | "stderr",
- append: (messageJson: unknown) => Promise<void>,
- emitTrace?: (data: string) => void,
-): Promise<void> {
- if (!stream) return;
- const reader = stream.getReader();
- const decoder = new TextDecoder();
- try {
- while (true) {
- const { value, done } = await reader.read();
- if (done) break;
- if (!value?.byteLength) continue;
- const data = decoder.decode(value, { stream: true });
- emitTrace?.(data);
- if (data) await append({ execClientMessage: buildShellStream(exec, { [streamName]: { data } }) });
- }
- const rest = decoder.decode();
- emitTrace?.(rest);
- if (rest) await append({ execClientMessage: buildShellStream(exec, { [streamName]: { data: rest } }) });
- } finally {
- reader.releaseLock();
- }
-}
-
-function buildShellStream(
- exec: { id?: number; execId?: string },
- shellStream: Record<string, unknown>,
-): Record<string, unknown> {
- return withExecIds(exec, {
- shellStream,
- });
-}
-
-async function buildGrepResult(exec: {
- id?: number;
- execId?: string;
- message?: { case?: string; value?: unknown };
-}): Promise<Record<string, unknown>> {
- const args = asRecord(exec.message?.value);
- const path = typeof args?.path === "string" && args.path ? args.path : process.cwd();
- const pattern = typeof args?.pattern === "string" ? args.pattern : "";
- const glob = typeof args?.glob === "string" ? args.glob : "";
- const outputMode = typeof args?.outputMode === "string" && args.outputMode ? args.outputMode : "files_with_matches";
- const resultPattern = pattern || glob;
- let files: string[] = [];
- try {
- if (glob) {
- const globber = new Bun.Glob(glob);
- files = Array.from(globber.scanSync(path)).sort();
- } else if (pattern) {
- files = await grepFilesWithRg(pattern, path);
- }
- } catch (err) {
- return withExecIds(exec, {
- grepResult: {
- error: {
- error: err instanceof Error ? err.message : String(err),
- },
- },
- });
- }
- return withExecIds(exec, {
- grepResult: {
- success: {
- pattern: resultPattern,
- path,
- outputMode,
- workspaceResults: {
- [path]: {
- files: {
- files,
- totalFiles: files.length,
- },
- },
- },
- },
- },
- });
-}
-
-async function grepFilesWithRg(pattern: string, path: string): Promise<string[]> {
- const proc = Bun.spawn(["rg", "-l", pattern, path], {
- stdout: "pipe",
- stderr: "ignore",
- });
- const stdout = await new Response(proc.stdout).text();
- const code = await proc.exited;
- if (code !== 0 && code !== 1) {
- throw new Error(`rg exited with status ${code}`);
- }
- return stdout
- .split("\n")
- .map((file) => (isAbsolute(file) ? file : join(path, file)))
- .filter((file) => file.length > 0)
- .sort();
-}
-
-function buildRequestContextResult(exec: {
- id?: number;
- execId?: string;
- message?: { case?: string; value?: unknown };
-}): Record<string, unknown> {
- return withExecIds(exec, {
- requestContextResult: {
- success: {
- requestContext: {
- env: {
- osVersion: `${process.platform} ${process.arch}`,
- workspacePaths: [process.cwd()],
- shell: process.env.SHELL || "",
- sandboxEnabled: false,
- projectFolder: process.cwd(),
- processWorkingDirectory: process.cwd(),
- },
- webSearchEnabled: true,
- webFetchEnabled: true,
- repositoryInfoComplete: true,
- rulesInfoComplete: true,
- envInfoComplete: true,
- customSubagentsInfoComplete: true,
- mcpFileSystemInfoComplete: true,
- mcpInfoComplete: true,
- gitStatusInfoComplete: true,
- agentSkillsInfoComplete: true,
- },
- },
- },
- });
-}
-
-function buildInteractionResponse(query: {
- id?: number;
- query?: { case?: string; value?: unknown };
-} | undefined): Record<string, unknown> | undefined {
- if (!query || typeof query.id !== "number") return undefined;
- switch (query.query?.case) {
- case "webSearchRequestQuery":
- return { id: query.id, webSearchRequestResponse: { approved: {} } };
- case "webFetchRequestQuery":
- return { id: query.id, webFetchRequestResponse: { approved: {} } };
- default:
- return undefined;
- }
-}
-
-const controlFrameState = new WeakMap<
- (messageJson: unknown) => Promise<void>,
- { buffer: Buffer; execHeartbeatSent: boolean }
->();
-
-function streamCloseForExec(exec: { id?: number }): Record<string, unknown> {
- return typeof exec.id === "number" && exec.id !== 0 ? { id: exec.id } : {};
-}
-
-interface CursorOneofMessage {
- message?: {
- case?: string;
- value?: {
- id?: number;
- execId?: string;
- message?: { case?: string; value?: unknown };
- query?: { case?: string; value?: unknown };
- };
- };
-}
-
-function summarizeCursorOneofMessage(message: CursorOneofMessage): Record<string, unknown> {
- const oneof = message.message;
- const value = oneof?.value;
- return {
- case: oneof?.case ?? "unknown",
- innerCase: value?.message?.case,
- queryCase: value?.query?.case,
- id: value?.id,
- execId: value?.execId,
- };
-}
-
-function summarizeCursorServerJson(json: unknown): Record<string, unknown> {
- if (!isRecord(json)) return { type: typeof json };
- const interaction = asRecord(json.interactionUpdate);
- const exec = asRecord(json.execServerMessage);
- const kv = asRecord(json.kvServerMessage);
- return {
- keys: Object.keys(json),
- interactionKeys: interaction ? Object.keys(interaction) : undefined,
- execKeys: exec ? Object.keys(exec) : undefined,
- kvKeys: kv ? Object.keys(kv) : undefined,
- };
-}
-
-export async function* decodeCursorStream(
- body: ReadableStream<Uint8Array>,
- proto: CursorProto = loadCursorProto(),
- opts: DecodeCursorStreamOptions = {},
-): AsyncGenerator<CursorStreamEvent> {
- let buffer = Buffer.alloc(0);
- const reader = body.getReader();
- let outputSeen = false;
- try {
- while (true) {
- const idleMs = opts.outputIdleTimeoutMs ?? CURSOR_OUTPUT_IDLE_TIMEOUT_MS;
- const read = await readWithOutputIdleTimeout(reader, outputSeen ? idleMs : undefined);
- if (read === "idle") {
- opts.log?.warn("cursor stream idle after output", { idleMs });
- opts.traffic?.writeJsonEvent("040-cursor-event", {
- type: "end",
- reason: "output_idle_timeout",
- idleMs,
- });
- yield { type: "end" };
- await reader.cancel("Cursor output idle timeout");
- return;
- }
- const { value, done } = read;
- if (done) break;
- if (!value?.byteLength) continue;
- buffer = Buffer.concat([buffer, Buffer.from(value)]);
- while (buffer.byteLength >= 5) {
- const flags = buffer[0]!;
- const len = buffer.readUInt32BE(1);
- if (buffer.byteLength < 5 + len) break;
- let payload = buffer.subarray(5, 5 + len);
- buffer = buffer.subarray(5 + len);
- if (flags & 1) payload = gunzipSync(payload);
- if (flags & 2) {
- const connectError = cursorConnectEndError(payload);
- if (connectError) {
- opts.log?.warn("cursor connect end error", {
- status: connectError.status,
- message: connectError.message,
- });
- opts.traffic?.writeJsonEvent("040-cursor-event", {
- type: "error",
- status: connectError.status,
- message: connectError.message,
- detail: connectError.detail,
- });
- throw connectError;
- }
- yield { type: "end" };
- await reader.cancel("Cursor Connect end frame");
- return;
- }
- const decoded = safeToJson(proto.AgentServerMessage.fromBinary(payload));
- if (!decoded) continue;
- opts.traffic?.writeJsonEvent("039-cursor-server-message", summarizeCursorServerJson(decoded));
- for (const event of eventsFromServerMessage(decoded)) {
- if (event.type === "thinking_delta" || event.type === "text_delta" || event.type === "usage") {
- outputSeen = true;
- }
- yield event;
- if (event.type === "end") {
- await reader.cancel("Cursor turnEnded frame");
- return;
- }
- }
- }
- }
- } finally {
- reader.releaseLock();
- }
-}
-
-export interface DecodeCursorStreamOptions {
- outputIdleTimeoutMs?: number;
- traffic?: TrafficCapture;
- log?: Logger;
-}
-
-async function readWithOutputIdleTimeout(
- reader: { read(): Promise<CursorReadResult> },
- idleMs: number | undefined,
-): Promise<CursorReadResult | "idle"> {
- if (!idleMs || idleMs <= 0) return reader.read();
- let timeout: ReturnType<typeof setTimeout> | undefined;
- try {
- return await Promise.race([
- reader.read(),
- new Promise<"idle">((resolve) => {
- timeout = setTimeout(() => resolve("idle"), idleMs);
- }),
- ]);
- } finally {
- if (timeout) clearTimeout(timeout);
- }
-}
-
-type CursorReadResult = { done: false; value: Uint8Array } | { done: true; value?: Uint8Array };
-
-function cursorConnectEndError(payload: Buffer): CursorError | undefined {
- if (payload.byteLength === 0) return undefined;
- let parsed: unknown;
- try {
- parsed = JSON.parse(payload.toString("utf8"));
- } catch {
- return undefined;
- }
- const error = asRecord(asRecord(parsed)?.error);
- if (!error) return undefined;
- const code = typeof error.code === "string" ? error.code : "unknown";
- const message = typeof error.message === "string" ? error.message : "Cursor Connect error";
- const details = Array.isArray(error.details) ? error.details : [];
- const debugDetails = details
- .map((detail) => asRecord(asRecord(detail)?.debug))
- .map((debug) => asRecord(debug?.details))
- .find((detail) => detail);
- const additionalInfo = asRecord(debugDetails?.additionalInfo);
- const friendly = stringValue(additionalInfo?.chatMessage) ||
- stringValue(debugDetails?.title) ||
- stringValue(debugDetails?.detail) ||
- message;
- const status = code === "resource_exhausted" ? 429 : 502;
- return new CursorError(status, `Cursor Run failed: ${code}: ${friendly}`, JSON.stringify(parsed));
-}
-
-function* eventsFromServerMessage(json: unknown): Generator<CursorStreamEvent> {
- if (!isRecord(json)) return;
- const exec = asRecord(json.execServerMessage);
- const requestContextArgs = asRecord(exec?.requestContextArgs);
- const notesSessionId = requestContextArgs?.notesSessionId;
- if (typeof notesSessionId === "string" && notesSessionId) {
- yield { type: "session", sessionId: notesSessionId };
- }
-
- const interaction = asRecord(json.interactionUpdate);
- const thinkingDelta = asRecord(interaction?.thinkingDelta)?.text;
- if (typeof thinkingDelta === "string" && thinkingDelta) {
- yield { type: "thinking_delta", text: thinkingDelta };
- }
- const textDelta = asRecord(interaction?.textDelta)?.text;
- if (typeof textDelta === "string" && textDelta) {
- yield { type: "text_delta", text: textDelta };
- }
- const turnEnded = asRecord(interaction?.turnEnded);
- if (turnEnded) {
- yield {
- type: "usage",
- usage: {
- inputTokens: stringToken(turnEnded.inputTokens),
- outputTokens: stringToken(turnEnded.outputTokens),
- cacheReadTokens: stringToken(turnEnded.cacheReadTokens),
- cacheWriteTokens: stringToken(turnEnded.cacheWriteTokens),
- },
- };
- yield { type: "end" };
- }
-}
-
-export function encodeConnectFrame(payload: Uint8Array, flags = 0): Uint8Array {
- const out = new Uint8Array(5 + payload.byteLength);
- const view = new DataView(out.buffer);
- view.setUint8(0, flags);
- view.setUint32(1, payload.byteLength, false);
- out.set(payload, 5);
- return out;
-}
-
-function selectedContext(images: CursorSelectedImage[] | undefined): Record<string, unknown> {
- if (!images?.length) return {};
- return {
- selectedImages: images.map((image) => ({
- data: image.data,
- uuid: image.uuid,
- path: image.path,
- mimeType: image.mimeType,
- })),
- };
-}
-
-function selectedSubagentModels(model: CursorModelRequest): CursorModelRequest[] {
- return [
- { modelId: "default" },
- model,
- {
- modelId: "claude-opus-4-8",
- parameters: [
- { id: "thinking", value: "true" },
- { id: "context", value: "300k" },
- { id: "effort", value: "high" },
- { id: "fast", value: "false" },
- ],
- },
- {
- modelId: "gpt-5.5",
- parameters: [
- { id: "context", value: "272k" },
- { id: "reasoning", value: "extra-high" },
- { id: "fast", value: "false" },
- ],
- },
- {
- modelId: "claude-sonnet-4-6",
- parameters: [
- { id: "thinking", value: "true" },
- { id: "context", value: "200k" },
- { id: "effort", value: "medium" },
- ],
- },
- {
- modelId: "gpt-5.3-codex",
- parameters: [
- { id: "reasoning", value: "medium" },
- { id: "fast", value: "false" },
- ],
- },
- ];
-}
-
-function safeToJson(message: { toJson(options?: unknown): unknown }): unknown | undefined {
- try {
- return message.toJson({ emitDefaultValues: false });
- } catch {
- return undefined;
- }
-}
-
-function stringToken(value: unknown): string {
- if (typeof value === "string") return value;
- if (typeof value === "number") return String(value);
- return "0";
-}
-
-function stringValue(value: unknown): string | undefined {
- return typeof value === "string" && value ? value : undefined;
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
- return !!value && typeof value === "object" && !Array.isArray(value);
-}
-
-function asRecord(value: unknown): Record<string, unknown> | undefined {
- return isRecord(value) ? value : undefined;
-}
diff --git a/reference/typescript/src/providers/cursor/count-tokens.ts b/reference/typescript/src/providers/cursor/count-tokens.ts
deleted file mode 100644
index 94c9cca..0000000
--- a/reference/typescript/src/providers/cursor/count-tokens.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import { encode } from "gpt-tokenizer/model/gpt-4o";
-import type { AnthropicRequest } from "../../anthropic/schema.ts";
-import { renderCursorPrompt } from "./translate/request.ts";
-import { countToolSchemaTokens } from "../shared/tool-schema.ts";
-
-export function countCursorTokens(req: AnthropicRequest): number {
- let total = encode(renderCursorPrompt(req)).length;
- total += countToolSchemaTokens(
- req.tools,
- (tool) => tool.name,
- (tool) => ("description" in tool ? tool.description : undefined),
- (tool) => ("input_schema" in tool ? tool.input_schema : {}),
- );
- return total;
-}
diff --git a/reference/typescript/src/providers/cursor/cursor-test-helpers.ts b/reference/typescript/src/providers/cursor/cursor-test-helpers.ts
deleted file mode 100644
index 30dd86f..0000000
--- a/reference/typescript/src/providers/cursor/cursor-test-helpers.ts
+++ /dev/null
@@ -1,154 +0,0 @@
-import { encodeConnectFrame } from "./client.ts";
-import type { CursorProto, ProtoClass, ProtoMessage } from "./proto-loader.ts";
-import type { RequestContext } from "../types.ts";
-import { parseSseStream } from "../../sse.ts";
-
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-
-export type JsonProtoClassOptions = {
- mergeFields?: boolean;
-};
-
-export function jsonProtoClass(options: JsonProtoClassOptions = {}): ProtoClass {
- const { mergeFields = false } = options;
- return {
- fromBinary(bytes: Uint8Array): ProtoMessage {
- return messageFromJson(JSON.parse(decoder.decode(bytes)), options);
- },
- fromJson(json: unknown): ProtoMessage {
- return messageFromJson(json, options);
- },
- };
-}
-
-export function messageFromJson(
- json: unknown,
- options: JsonProtoClassOptions = {},
-): ProtoMessage {
- const { mergeFields = false } = options;
- const message: ProtoMessage = {
- toBinary(): Uint8Array {
- return jsonBytes(json);
- },
- toJson(): unknown {
- return json;
- },
- };
- if (!mergeFields) return message;
- return Object.assign(
- message,
- json && typeof json === "object" && !Array.isArray(json) ? json : {},
- );
-}
-
-export function createFakeProto(options: JsonProtoClassOptions = {}): CursorProto {
- const protoClass = jsonProtoClass(options);
- return {
- AgentServerMessage: protoClass,
- AgentClientMessage: protoClass,
- };
-}
-
-export const fakeProtoMerged = createFakeProto({ mergeFields: true });
-export const fakeProto = createFakeProto();
-
-export function frame(json: unknown): Uint8Array {
- return encodeConnectFrame(jsonBytes(json));
-}
-
-export function jsonBytes(json: unknown): Uint8Array {
- return encoder.encode(JSON.stringify(json));
-}
-
-export function decodeFrameJson(frameBytes: Uint8Array): unknown {
- const buf = Buffer.from(frameBytes);
- const len = buf.readUInt32BE(1);
- return JSON.parse(decoder.decode(buf.subarray(5, 5 + len)));
-}
-
-export function streamFromChunks(chunks: Uint8Array[]): ReadableStream<Uint8Array> {
- return new ReadableStream<Uint8Array>({
- start(controller) {
- for (const chunk of chunks) controller.enqueue(chunk);
- controller.close();
- },
- });
-}
-
-export type FakeCursorCtxOptions = {
- sessionId?: string;
- reqId?: string;
-};
-
-export function fakeCursorCtx(options: FakeCursorCtxOptions = {}): RequestContext {
- const { sessionId, reqId = "req" } = options;
- return {
- reqId,
- ...(sessionId === undefined ? {} : { sessionId }),
- signal: new AbortController().signal,
- childLogger: () => ({
- debug() {},
- info() {},
- warn() {},
- error() {},
- child() {
- return this;
- },
- }),
- };
-}
-
-export async function collectCursorSse(
- response: Response | ReadableStream<Uint8Array>,
-): Promise<Array<{ event: string; data: any }>> {
- const events = [];
- const body = response instanceof ReadableStream ? response : response.body!;
- for await (const event of parseSseStream(body)) {
- events.push({ event: event.event ?? "message", data: JSON.parse(event.data) });
- }
- return events;
-}
-
-export function jwt(payload: Record<string, unknown>): string {
- return [
- Buffer.from(JSON.stringify({ alg: "none", typ: "JWT" })).toString("base64url"),
- Buffer.from(JSON.stringify(payload)).toString("base64url"),
- "signature",
- ].join(".");
-}
-
-export function resourceExhaustedFrame(): Uint8Array {
- return encodeConnectFrame(
- jsonBytes({
- error: {
- code: "resource_exhausted",
- message: "Error",
- details: [
- {
- debug: {
- details: {
- additionalInfo: {
- chatMessage: "You've hit your free requests limit.",
- },
- },
- },
- },
- ],
- },
- }),
- 2,
- );
-}
-
-export function resourceExhaustedNetworkFrame(): Uint8Array {
- return encodeConnectFrame(
- jsonBytes({
- error: {
- code: "resource_exhausted",
- message: "Network Error",
- },
- }),
- 2,
- );
-}
diff --git a/reference/typescript/src/providers/cursor/index.test.ts b/reference/typescript/src/providers/cursor/index.test.ts
deleted file mode 100644
index 9131952..0000000
--- a/reference/typescript/src/providers/cursor/index.test.ts
+++ /dev/null
@@ -1,849 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import { cursorProvider, createCursorProvider } from "./index.ts";
-import { encodeConnectFrame, runCursorAgent, type CursorRunOptions } from "./client.ts";
-import {
- collectCursorSse,
- decodeFrameJson,
- fakeCursorCtx,
- fakeProtoMerged as fakeProto,
- frame,
- jsonBytes,
- jwt,
- resourceExhaustedFrame,
- resourceExhaustedNetworkFrame,
- streamFromChunks,
-} from "./cursor-test-helpers.ts";
-import { mkdir, mkdtemp, stat, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { expectSseHeaders } from "../../anthropic/response.ts";
-
-const originalToken = process.env.CCP_CURSOR_AUTH_TOKEN;
-
-afterEach(() => {
- if (originalToken === undefined) delete process.env.CCP_CURSOR_AUTH_TOKEN;
- else process.env.CCP_CURSOR_AUTH_TOKEN = originalToken;
-});
-
-type CursorSseEvent = (Awaited<ReturnType<typeof collectCursorSse>>)[number];
-type CursorProviderOptions = NonNullable<Parameters<typeof createCursorProvider>[0]>;
-type CursorRunAgent = CursorProviderOptions["runAgent"];
-
-function createCursorTestProvider(
- runAgent: CursorRunAgent,
- overrides: Partial<CursorProviderOptions> = {},
-) {
- return createCursorProvider({
- loadAuth: async () => ({ accessToken: "token", source: "test" }),
- runAgent,
- proto: fakeProto,
- ...overrides,
- });
-}
-
-function createRunStreamHarness(
- initialServerMessage: Record<string, any> | Array<Record<string, any>>,
- onWrite: (
- message: Record<string, any>,
- serverController: ReadableStreamDefaultController<Uint8Array>,
- ) => Promise<void> | void,
-) {
- const initialServerMessages = Array.isArray(initialServerMessage)
- ? initialServerMessage
- : [initialServerMessage];
- const sentFrames: Array<Record<string, any>> = [];
- let serverController!: ReadableStreamDefaultController<Uint8Array>;
- const serverReadable = new ReadableStream<Uint8Array>({
- start(controller) {
- serverController = controller;
- queueMicrotask(() => {
- for (const message of initialServerMessages) controller.enqueue(frame(message));
- });
- },
- });
- return {
- sentFrames,
- runAgent: async (opts: CursorRunOptions) =>
- runCursorAgent({
- ...opts,
- proto: fakeProto,
- openRunStream: async () => ({
- readable: serverReadable,
- status: Promise.resolve({ status: 200 }),
- async write(frameBytes) {
- const message = decodeFrameJson(frameBytes) as Record<string, any>;
- sentFrames.push(message);
- await onWrite(message, serverController);
- },
- close() {},
- }),
- }),
- };
-}
-
-function findCursorSseEvent(
- events: readonly CursorSseEvent[],
- eventName: string,
- predicate: (event: CursorSseEvent) => boolean = () => true,
-) {
- return events.find((event) => event.event === eventName && predicate(event));
-}
-
-function getToolUseStartEvent(events: readonly CursorSseEvent[]) {
- return findCursorSseEvent(
- events,
- "content_block_start",
- (event) => event.data.content_block?.type === "tool_use",
- );
-}
-
-function getInputJsonDeltaEvent(events: readonly CursorSseEvent[]) {
- return findCursorSseEvent(
- events,
- "content_block_delta",
- (event) => event.data.delta?.type === "input_json_delta",
- );
-}
-
-function getTextDeltaEvent(events: readonly CursorSseEvent[]) {
- return findCursorSseEvent(events, "content_block_delta");
-}
-
-function expectMessageStopReason(events: readonly CursorSseEvent[], reason: string) {
- expect(findCursorSseEvent(events, "message_delta")?.data.delta.stop_reason).toBe(reason);
-}
-
-function expectMessageStop(events: readonly CursorSseEvent[]) {
- expect(events.at(-1)?.event).toBe("message_stop");
-}
-
-function enqueueFinalAssistantResponse(
- serverController: ReadableStreamDefaultController<Uint8Array>,
- text: string,
- inputTokens: string,
- outputTokens: string,
-) {
- serverController.enqueue(frame({
- interactionUpdate: { textDelta: { text } },
- }));
- serverController.enqueue(frame({
- interactionUpdate: { turnEnded: { inputTokens, outputTokens } },
- }));
- serverController.close();
-}
-
-describe("Cursor provider auth errors", () => {
- it("surfaces expired auth before calling Cursor", async () => {
- process.env.CCP_CURSOR_AUTH_TOKEN = jwt({ exp: 1 });
-
- const response = await cursorProvider.handleMessages(
- {
- model: "cursor",
- messages: [{ role: "user", content: "hello" }],
- },
- fakeCursorCtx({ sessionId: "session" }),
- );
- const body = (await response.json()) as {
- error: { type: string; message: string };
- };
-
- expect(response.status).toBe(401);
- expect(response.headers.get("content-type")).toBe("application/json");
- expect(body.error.type).toBe("authentication_error");
- expect(body.error.message).toContain("expired or near expiry");
- });
-});
-
-describe("Cursor provider messages", () => {
- it("returns assistant text for non-streaming requests", async () => {
- const provider = createCursorTestProvider(async () => {
- return streamFromChunks([
- frame({ interactionUpdate: { textDelta: { text: "hello" } } }),
- frame({ interactionUpdate: { turnEnded: { inputTokens: "4", outputTokens: "1" } } }),
- encodeConnectFrame(jsonBytes({}), 2),
- ]);
- });
-
- const response = await provider.handleMessages(
- {
- model: "cursor",
- messages: [{ role: "user", content: "hello" }],
- },
- fakeCursorCtx({ sessionId: "session" }),
- );
- const body = (await response.json()) as { content: Array<{ type: string; text?: string }> };
-
- expect(response.status).toBe(200);
- expect(response.headers.get("content-type")).toBe("application/json");
- expect(body.content).toEqual([{ type: "text", text: "hello" }]);
- });
-
- it("retries Cursor resource_exhausted network errors for non-streaming requests", async () => {
- let attempts = 0;
- const provider = createCursorTestProvider(
- async () => {
- attempts++;
- if (attempts === 1) return streamFromChunks([resourceExhaustedNetworkFrame()]);
- return streamFromChunks([
- frame({ interactionUpdate: { textDelta: { text: "recovered" } } }),
- frame({ interactionUpdate: { turnEnded: { inputTokens: "4", outputTokens: "1" } } }),
- encodeConnectFrame(jsonBytes({}), 2),
- ]);
- },
- { computeRetryDelay: () => ({ waitMs: 0, exceedsBudget: false }) },
- );
-
- const response = await provider.handleMessages(
- {
- model: "cursor",
- messages: [{ role: "user", content: "hello" }],
- },
- fakeCursorCtx({ sessionId: "session" }),
- );
- const body = (await response.json()) as { content: Array<{ type: string; text?: string }> };
-
- expect(attempts).toBe(2);
- expect(response.status).toBe(200);
- expect(body.content).toEqual([{ type: "text", text: "recovered" }]);
- });
-
- it("returns valid Anthropic SSE for streaming requests", async () => {
- const provider = createCursorTestProvider(async () => {
- return streamFromChunks([
- frame({ interactionUpdate: { textDelta: { text: "streamed" } } }),
- frame({ interactionUpdate: { turnEnded: { inputTokens: "4", outputTokens: "2" } } }),
- encodeConnectFrame(jsonBytes({}), 2),
- ]);
- });
-
- const response = await provider.handleMessages(
- {
- model: "cursor",
- stream: true,
- messages: [{ role: "user", content: "hello" }],
- },
- fakeCursorCtx({ sessionId: "session" }),
- );
- const events = await collectCursorSse(response);
-
- expectSseHeaders(response);
- expect(events.map((event) => event.event)).toContain("message_start");
- expect(getTextDeltaEvent(events)?.data.delta.text).toBe("streamed");
- expectMessageStop(events);
- });
-
- it("retries Cursor resource_exhausted network errors for bridged streaming requests", async () => {
- let attempts = 0;
- const provider = createCursorTestProvider(
- async () => {
- attempts++;
- if (attempts === 1) return streamFromChunks([resourceExhaustedNetworkFrame()]);
- return streamFromChunks([
- frame({ interactionUpdate: { textDelta: { text: "bridge recovered" } } }),
- frame({ interactionUpdate: { turnEnded: { inputTokens: "4", outputTokens: "1" } } }),
- ]);
- },
- { computeRetryDelay: () => ({ waitMs: 0, exceedsBudget: false }) },
- );
-
- const response = await provider.handleMessages(
- {
- model: "cursor",
- stream: true,
- tools: [{ name: "Read", input_schema: { type: "object" } }],
- messages: [{ role: "user", content: "hello" }],
- },
- fakeCursorCtx({ sessionId: "session" }),
- );
- const events = await collectCursorSse(response);
-
- expect(attempts).toBe(2);
- expect(events.some((event) => event.event === "error")).toBe(false);
- expect(getTextDeltaEvent(events)?.data.delta.text).toBe("bridge recovered");
- expectMessageStop(events);
- });
-
- it("preserves Cursor Connect end error status for non-streaming requests", async () => {
- const provider = createCursorTestProvider(async () => {
- return streamFromChunks([
- resourceExhaustedFrame(),
- ]);
- });
-
- const response = await provider.handleMessages(
- {
- model: "cursor",
- messages: [{ role: "user", content: "hello" }],
- },
- fakeCursorCtx({ sessionId: "session" }),
- );
- const body = (await response.json()) as { error: { message: string } };
-
- expect(response.status).toBe(429);
- expect(body.error.message).toContain("resource_exhausted");
- expect(body.error.message).toContain("free requests limit");
- });
-
- it("bridges Cursor shellStreamArgs through Claude Bash tool_use and resumes from tool_result", async () => {
- let finalResponseSent = false;
- const workingDirectory = "/tmp/cursor bridge cwd";
- const { sentFrames, runAgent } = createRunStreamHarness(
- {
- message: {
- case: "execServerMessage",
- value: {
- id: 11,
- execId: "exec-shell",
- message: {
- case: "shellStreamArgs",
- value: {
- command: "printf should-not-run",
- workingDirectory,
- timeout: 5000,
- },
- },
- },
- },
- },
- (message, serverController) => {
- if (message.execClientMessage?.shellStream?.exit && !finalResponseSent) {
- finalResponseSent = true;
- enqueueFinalAssistantResponse(serverController, "resumed after native shell", "4", "3");
- }
- },
- );
- const provider = createCursorTestProvider(runAgent);
-
- const initial = await provider.handleMessages(
- {
- model: "cursor",
- stream: true,
- tools: [{ name: "Bash", input_schema: { type: "object" } }],
- messages: [{ role: "user", content: "run shell" }],
- },
- fakeCursorCtx({ sessionId: "session" }),
- );
- const initialEvents = await collectCursorSse(initial);
- const toolStart = getToolUseStartEvent(initialEvents);
- const initialStop = findCursorSseEvent(initialEvents, "message_delta");
-
- expect(toolStart?.data.content_block.name).toBe("Bash");
- expect(toolStart?.data.content_block.id).toStartWith("call_cursor_");
- expect(initialStop?.data.usage.input_tokens).toBeGreaterThan(0);
- expect(initialStop?.data.usage.cache_read_input_tokens).toBe(0);
- const toolInputDelta = getInputJsonDeltaEvent(initialEvents);
- expect(JSON.parse(toolInputDelta?.data.delta.partial_json).command).toBe(
- "cd '/tmp/cursor bridge cwd' && printf should-not-run",
- );
- expectMessageStopReason(initialEvents, "tool_use");
- expect(sentFrames.some((message) => message.execClientMessage?.shellStream?.stdout)).toBe(false);
-
- const resume = await provider.handleMessages(
- {
- model: "cursor",
- stream: true,
- messages: [
- {
- role: "assistant",
- content: [{
- type: "tool_use",
- id: toolStart!.data.content_block.id,
- name: "Bash",
- input: { command: "printf should-not-run" },
- }],
- },
- {
- role: "user",
- content: [{
- type: "tool_result",
- tool_use_id: toolStart!.data.content_block.id,
- content: "native shell output",
- is_error: false,
- }],
- },
- ],
- },
- fakeCursorCtx({ sessionId: "session" }),
- );
- const resumeEvents = await collectCursorSse(resume);
-
- expect(sentFrames.some((message) =>
- message.execClientMessage?.shellStream?.stdout?.data === "native shell output"
- )).toBe(true);
- expect(sentFrames.some((message) =>
- message.execClientMessage?.shellStream?.stdout?.data === "should-not-run"
- )).toBe(false);
- expect(getTextDeltaEvent(resumeEvents)?.data.delta.text).toBe("resumed after native shell");
- expectMessageStopReason(resumeEvents, "end_turn");
- expectMessageStop(resumeEvents);
- });
-
- it("keeps native shell bridge state while a long Claude Bash result is pending", async () => {
- let finalResponseSent = false;
- const { sentFrames, runAgent } = createRunStreamHarness(
- [
- { interactionUpdate: { textDelta: { text: "preparing consult" } } },
- {
- message: {
- case: "execServerMessage",
- value: {
- id: 31,
- execId: "exec-long-shell",
- message: {
- case: "shellStreamArgs",
- value: {
- command: "consult-llm --task review",
- workingDirectory: "/tmp",
- timeout: 300000,
- },
- },
- },
- },
- },
- ],
- (message, serverController) => {
- if (message.execClientMessage?.shellStream?.exit && !finalResponseSent) {
- finalResponseSent = true;
- enqueueFinalAssistantResponse(serverController, "review results consumed", "12", "4");
- }
- },
- );
- const provider = createCursorTestProvider(runAgent, { bridgeOutputIdleTimeoutMs: 5 });
-
- const initial = await provider.handleMessages(
- {
- model: "cursor",
- stream: true,
- tools: [{ name: "Bash", input_schema: { type: "object" } }],
- messages: [{ role: "user", content: "review change" }],
- },
- fakeCursorCtx({ sessionId: "session-long-shell" }),
- );
- const initialEvents = await collectCursorSse(initial);
- const toolStart = getToolUseStartEvent(initialEvents);
-
- expect(getTextDeltaEvent(initialEvents)?.data.delta.text).toBe("preparing consult");
- expect(toolStart?.data.content_block.name).toBe("Bash");
- expectMessageStopReason(initialEvents, "tool_use");
-
- await new Promise((resolve) => setTimeout(resolve, 25));
-
- const resume = await provider.handleMessages(
- {
- model: "cursor",
- stream: true,
- messages: [
- {
- role: "assistant",
- content: [{
- type: "tool_use",
- id: toolStart!.data.content_block.id,
- name: "Bash",
- input: { command: "consult-llm --task review" },
- }],
- },
- {
- role: "user",
- content: [{
- type: "tool_result",
- tool_use_id: toolStart!.data.content_block.id,
- content: "consult findings",
- is_error: false,
- }],
- },
- ],
- },
- fakeCursorCtx({ sessionId: "session-long-shell" }),
- );
- const resumeEvents = await collectCursorSse(resume);
-
- expect(sentFrames.some((message) =>
- message.execClientMessage?.shellStream?.stdout?.data === "consult findings"
- )).toBe(true);
- expect(getTextDeltaEvent(resumeEvents)?.data.delta.text).toBe("review results consumed");
- expectMessageStopReason(resumeEvents, "end_turn");
- expectMessageStop(resumeEvents);
- });
-
- it("recovers XML tool_use text while the native Cursor bridge is active", async () => {
- const provider = createCursorTestProvider(async () => {
- return streamFromChunks([
- frame({
- interactionUpdate: {
- textDelta: {
- text:
- "Continuing validation: checking the diff.\n\n<tool_use id=\"old_read_id\" name=\"Bash\">\n" +
- "{\"command\":\"git diff --check && git diff src/operations.rs\",\"description\":\"Check diff whitespace\"}\n" +
- "</tool_use>\n<tool_use id=\"old_read_id_2\" name=\"Bash\">\n",
- },
- },
- }),
- frame({
- interactionUpdate: {
- textDelta: {
- text:
- "{\"command\":\"just check\",\"description\":\"Run project check suite\",\"block_until_ms\":300000}\n</tool_use>\n</tool_use>",
- },
- },
- }),
- frame({ interactionUpdate: { turnEnded: { inputTokens: "20", outputTokens: "10" } } }),
- encodeConnectFrame(jsonBytes({}), 2),
- ]);
- });
-
- const response = await provider.handleMessages(
- {
- model: "cursor",
- stream: true,
- tools: [{ name: "Bash", input_schema: { type: "object" } }],
- messages: [{ role: "user", content: "continue" }],
- },
- fakeCursorCtx({ sessionId: "session" }),
- );
- const events = await collectCursorSse(response);
- const text = events
- .filter((event) => event.event === "content_block_delta" && event.data.delta?.type === "text_delta")
- .map((event) => event.data.delta.text)
- .join("");
- const toolStarts = events.filter((event) =>
- event.event === "content_block_start" && event.data.content_block?.type === "tool_use"
- );
- const inputs = events
- .filter((event) => event.event === "content_block_delta" && event.data.delta?.type === "input_json_delta")
- .map((event) => JSON.parse(event.data.delta.partial_json));
-
- expect(text).toBe("Continuing validation: checking the diff.\n\n");
- expect(text).not.toContain("<tool_use");
- expect(toolStarts).toHaveLength(2);
- expect(toolStarts.map((event) => event.data.content_block.name)).toEqual(["Bash", "Bash"]);
- expect(toolStarts[0]?.data.content_block.id).toStartWith("call_cursor_");
- expect(toolStarts[0]?.data.content_block.id).not.toBe("old_read_id");
- expect(toolStarts[1]?.data.content_block.id).toStartWith("call_cursor_");
- expect(toolStarts[1]?.data.content_block.id).not.toBe("old_read_id_2");
- expect(inputs.map((input) => input.command)).toEqual([
- "git diff --check && git diff src/operations.rs",
- "just check",
- ]);
- expect(inputs[1]?.block_until_ms).toBe(300000);
- expectMessageStopReason(events, "tool_use");
- expectMessageStop(events);
- });
-
- it("denies Cursor shellStreamArgs instead of executing internally when Claude did not advertise Bash", async () => {
- let finalResponseSent = false;
- const dir = await mkdtemp(join(tmpdir(), "cursor-denied-shell-"));
- const file = join(dir, "hidden-edit.txt");
- const { sentFrames, runAgent } = createRunStreamHarness(
- {
- message: {
- case: "execServerMessage",
- value: {
- id: 13,
- execId: "exec-shell-denied",
- message: {
- case: "shellStreamArgs",
- value: {
- command: `printf hidden > ${JSON.stringify(file)}`,
- workingDirectory: dir,
- timeout: 5000,
- },
- },
- },
- },
- },
- (message, serverController) => {
- if (message.execClientMessage?.shellStream?.exit && !finalResponseSent) {
- finalResponseSent = true;
- enqueueFinalAssistantResponse(serverController, "shell was denied", "4", "3");
- }
- },
- );
- const provider = createCursorTestProvider(runAgent);
-
- const response = await provider.handleMessages(
- {
- model: "cursor",
- stream: true,
- tools: [{ name: "Read", input_schema: { type: "object" } }],
- messages: [{ role: "user", content: "try hidden shell edit" }],
- },
- fakeCursorCtx({ sessionId: "session" }),
- );
- const events = await collectCursorSse(response);
-
- expect(events.some((event) =>
- event.event === "content_block_start" && event.data.content_block?.name === "Bash"
- )).toBe(false);
- expect(sentFrames.some((message) =>
- String(message.execClientMessage?.shellStream?.stderr?.data ?? "").includes("did not advertise the Bash tool")
- )).toBe(true);
- expect(sentFrames.find((message) => message.execClientMessage?.shellStream?.exit)
- ?.execClientMessage.shellStream.exit.code).toBe(1);
- expect(await exists(file)).toBe(false);
- expect(getTextDeltaEvent(events)?.data.delta.text).toBe("shell was denied");
- expectMessageStopReason(events, "end_turn");
- });
-
- it("bridges Cursor writeArgs through Claude Write tool_use and resumes from tool_result", async () => {
- let finalResponseSent = false;
- const dir = await mkdtemp(join(tmpdir(), "cursor-write-bridge-"));
- const file = join(dir, "history", "findings.md");
- const fileContent = "finding one\nfinding two\n";
- const { sentFrames, runAgent } = createRunStreamHarness(
- {
- message: {
- case: "execServerMessage",
- value: {
- id: 12,
- execId: "exec-write",
- message: {
- case: "writeArgs",
- value: {
- path: file,
- fileText: fileContent,
- returnFileContentAfterWrite: true,
- },
- },
- },
- },
- },
- (message, serverController) => {
- if (message.execClientMessage?.writeResult?.success && !finalResponseSent) {
- finalResponseSent = true;
- enqueueFinalAssistantResponse(serverController, "resumed after native write", "5", "4");
- }
- },
- );
- const provider = createCursorTestProvider(runAgent);
-
- const initial = await provider.handleMessages(
- {
- model: "cursor",
- stream: true,
- tools: [{ name: "Write", input_schema: { type: "object" } }],
- messages: [{ role: "user", content: "write file" }],
- },
- fakeCursorCtx({ sessionId: "session" }),
- );
- const initialEvents = await collectCursorSse(initial);
- const toolStart = getToolUseStartEvent(initialEvents);
- const toolInputDelta = getInputJsonDeltaEvent(initialEvents);
-
- expect(toolStart?.data.content_block.name).toBe("Write");
- expect(toolStart?.data.content_block.id).toStartWith("call_cursor_");
- expect(JSON.parse(toolInputDelta?.data.delta.partial_json)).toEqual({
- file_path: file,
- content: fileContent,
- });
- expectMessageStopReason(initialEvents, "tool_use");
- expect(sentFrames.some((message) => message.execClientMessage?.writeResult)).toBe(false);
-
- await mkdir(join(dir, "history"), { recursive: true });
- await writeFile(file, fileContent, "utf8");
- const resume = await provider.handleMessages(
- {
- model: "cursor",
- stream: true,
- messages: [
- {
- role: "assistant",
- content: [{
- type: "tool_use",
- id: toolStart!.data.content_block.id,
- name: "Write",
- input: { file_path: file, content: fileContent },
- }],
- },
- {
- role: "user",
- content: [{
- type: "tool_result",
- tool_use_id: toolStart!.data.content_block.id,
- content: `Wrote 3 lines to ${file}`,
- is_error: false,
- }],
- },
- ],
- },
- fakeCursorCtx({ sessionId: "session" }),
- );
- const resumeEvents = await collectCursorSse(resume);
- const writeResult = sentFrames.find((message) => message.execClientMessage?.writeResult)
- ?.execClientMessage.writeResult.success;
-
- expect(writeResult).toEqual({
- path: file,
- linesCreated: 3,
- fileSize: 24,
- fileContentAfterWrite: fileContent,
- });
- expect(sentFrames.at(-1)).toEqual({ execClientControlMessage: { streamClose: { id: 12 } } });
- expect(getTextDeltaEvent(resumeEvents)?.data.delta.text).toBe("resumed after native write");
- expectMessageStopReason(resumeEvents, "end_turn");
- expectMessageStop(resumeEvents);
- });
-
- it("bridges Cursor readArgs before writeArgs so Claude Write can edit existing files", async () => {
- let writeRequested = false;
- let finalResponseSent = false;
- const dir = await mkdtemp(join(tmpdir(), "cursor-read-write-bridge-"));
- const file = join(dir, "README.md");
- const originalContent = "# Demo\n\nOld detail.\n";
- const updatedContent = "# Demo\n\nUpdated detail.\n";
- await writeFile(file, originalContent, "utf8");
- const { sentFrames, runAgent } = createRunStreamHarness(
- {
- message: {
- case: "execServerMessage",
- value: {
- id: 21,
- execId: "exec-read",
- message: { case: "readArgs", value: { path: file } },
- },
- },
- },
- (message, serverController) => {
- if (message.execClientMessage?.readResult?.success && !writeRequested) {
- writeRequested = true;
- serverController.enqueue(frame({
- message: {
- case: "execServerMessage",
- value: {
- id: 22,
- execId: "exec-write",
- message: {
- case: "writeArgs",
- value: {
- path: file,
- fileText: updatedContent,
- returnFileContentAfterWrite: true,
- },
- },
- },
- },
- }));
- }
- if (message.execClientMessage?.writeResult?.success && !finalResponseSent) {
- finalResponseSent = true;
- enqueueFinalAssistantResponse(serverController, "edited existing file", "8", "5");
- }
- },
- );
- const provider = createCursorTestProvider(runAgent);
-
- const initial = await provider.handleMessages(
- {
- model: "cursor",
- stream: true,
- tools: [
- { name: "Read", input_schema: { type: "object" } },
- { name: "Write", input_schema: { type: "object" } },
- ],
- messages: [{ role: "user", content: "edit readme" }],
- },
- fakeCursorCtx({ sessionId: "session" }),
- );
- const initialEvents = await collectCursorSse(initial);
- const readToolStart = getToolUseStartEvent(initialEvents);
- const readToolInput = getInputJsonDeltaEvent(initialEvents);
-
- expect(readToolStart?.data.content_block.name).toBe("Read");
- expect(JSON.parse(readToolInput?.data.delta.partial_json)).toEqual({ file_path: file });
- expect(sentFrames.some((message) => message.execClientMessage?.readResult)).toBe(false);
-
- const afterRead = await provider.handleMessages(
- {
- model: "cursor",
- stream: true,
- messages: [
- {
- role: "assistant",
- content: [{
- type: "tool_use",
- id: readToolStart!.data.content_block.id,
- name: "Read",
- input: { file_path: file },
- }],
- },
- {
- role: "user",
- content: [{
- type: "tool_result",
- tool_use_id: readToolStart!.data.content_block.id,
- content: originalContent,
- is_error: false,
- }],
- },
- ],
- },
- fakeCursorCtx({ sessionId: "session" }),
- );
- const afterReadEvents = await collectCursorSse(afterRead);
- const readResult = sentFrames.find((message) => message.execClientMessage?.readResult)
- ?.execClientMessage.readResult.success;
- const writeToolStart = getToolUseStartEvent(afterReadEvents);
- const writeToolInput = getInputJsonDeltaEvent(afterReadEvents);
-
- expect(readResult).toEqual({
- path: file,
- content: originalContent,
- totalLines: 4,
- fileSize: "20",
- });
- expect(writeToolStart?.data.content_block.name).toBe("Write");
- expect(JSON.parse(writeToolInput?.data.delta.partial_json)).toEqual({
- file_path: file,
- content: updatedContent,
- });
-
- await writeFile(file, updatedContent, "utf8");
- const afterWrite = await provider.handleMessages(
- {
- model: "cursor",
- stream: true,
- messages: [
- {
- role: "assistant",
- content: [{
- type: "tool_use",
- id: writeToolStart!.data.content_block.id,
- name: "Write",
- input: { file_path: file, content: updatedContent },
- }],
- },
- {
- role: "user",
- content: [{
- type: "tool_result",
- tool_use_id: writeToolStart!.data.content_block.id,
- content: `Wrote 3 lines to ${file}`,
- is_error: false,
- }],
- },
- ],
- },
- fakeCursorCtx({ sessionId: "session" }),
- );
- const afterWriteEvents = await collectCursorSse(afterWrite);
- const writeResult = sentFrames.find((message) => message.execClientMessage?.writeResult)
- ?.execClientMessage.writeResult.success;
-
- expect(writeResult).toEqual({
- path: file,
- linesCreated: 4,
- fileSize: 24,
- fileContentAfterWrite: updatedContent,
- });
- expect(getTextDeltaEvent(afterWriteEvents)?.data.delta.text).toBe("edited existing file");
- expectMessageStopReason(afterWriteEvents, "end_turn");
- });
-});
-
-async function exists(path: string): Promise<boolean> {
- try {
- await stat(path);
- return true;
- } catch {
- return false;
- }
-}
diff --git a/reference/typescript/src/providers/cursor/index.ts b/reference/typescript/src/providers/cursor/index.ts
deleted file mode 100644
index e407730..0000000
--- a/reference/typescript/src/providers/cursor/index.ts
+++ /dev/null
@@ -1,274 +0,0 @@
-import type { AnthropicRequest } from "../../anthropic/schema.ts";
-import { wantsDownstreamStream } from "../../anthropic/stream.ts";
-import { jsonError, jsonResponse, sseResponse } from "../../anthropic/response.ts";
-import { logVerbose } from "../../config.ts";
-import type { Logger } from "../../log.ts";
-import { computeBackoffDelay, MAX_RATE_LIMIT_RETRIES, sleep, type BackoffOutcome } from "../retry.ts";
-import type { Provider, RequestContext } from "../types.ts";
-import {
- CursorError,
- isRetryableCursorNetworkResourceError,
- runCursorAgent,
- type CursorRunOptions,
-} from "./client.ts";
-import { countCursorTokens } from "./count-tokens.ts";
-import {
- cursorAuthLocation,
- expiredAuthMessage,
- loadCursorAuth,
- missingAuthMessage,
-} from "./auth/token-store.ts";
-import { cursorSelectedImages, renderCursorPrompt } from "./translate/request.ts";
-import { CURSOR_SUPPORTED_MODELS, resolveCursorModel } from "./translate/model.ts";
-import {
- accumulateCursorResponse,
- translateCursorStream,
-} from "./translate/response.ts";
-import {
- cursorConversationForRequest,
- recordCursorConversation,
-} from "./session.ts";
-import {
- canBridgeCursorBashTool,
- canBridgeCursorNativeTools,
- canBridgeCursorReadTool,
- canBridgeCursorWriteTool,
- createCursorShellToolBridge,
- denyCursorBashTool,
- denyCursorReadTool,
- denyCursorWriteTool,
- resumeCursorShellToolBridge,
-} from "./tool-bridge.ts";
-import type { CursorAuth } from "./auth/token-store.ts";
-import type { CursorProto } from "./proto-loader.ts";
-import { cursorCli } from "./cli.ts";
-
-const AUTH_EXPIRY_SKEW_MS = 60_000;
-
-export interface CursorProviderDeps {
- loadAuth: () => Promise<CursorAuth | undefined>;
- runAgent: (opts: CursorRunOptions) => Promise<ReadableStream<Uint8Array>>;
- proto?: CursorProto;
- bridgeOutputIdleTimeoutMs?: number;
- computeRetryDelay?: (attempt: number) => BackoffOutcome;
-}
-
-const defaultDeps: CursorProviderDeps = {
- loadAuth: () => loadCursorAuth(),
- runAgent: runCursorAgent,
-};
-
-async function handleCountTokens(body: AnthropicRequest, ctx: RequestContext): Promise<Response> {
- const tokens = countCursorTokens(body);
- ctx.childLogger("provider.cursor").debug("count_tokens", { tokens });
- return jsonResponse({ input_tokens: tokens });
-}
-
-async function handleMessages(
- body: AnthropicRequest,
- ctx: RequestContext,
- deps: CursorProviderDeps,
-): Promise<Response> {
- const log = ctx.childLogger("provider.cursor");
- const messageId = `msg_${crypto.randomUUID().replace(/-/g, "")}`;
- const resumed = resumeCursorShellToolBridge(body, ctx, messageId);
- if (resumed) return resumed;
-
- const selection = resolveCursorModel(body);
- const prompt = renderCursorPrompt(body);
- const inputTokens = countCursorTokens(body);
- const selectedImages = cursorSelectedImages(body);
- const wantStream = wantsDownstreamStream(body);
- const conversationId = cursorConversationForRequest(body, ctx.sessionId);
- const allowedToolNames = new Set((body.tools ?? []).map((tool) => tool.name));
-
- log.debug("cursor request", {
- requestedModel: body.model,
- resolvedModel: selection.requestedModel,
- mode: selection.mode,
- conversationId,
- stream: wantStream,
- messageCount: body.messages.length,
- promptChars: prompt.length,
- selectedImageCount: selectedImages.length,
- });
- if (logVerbose()) log.debug("cursor prompt", { prompt });
-
- const auth = await deps.loadAuth();
- if (!auth) return jsonError(401, "authentication_error", missingAuthMessage());
- if (auth.expires && auth.expires <= Date.now() + AUTH_EXPIRY_SKEW_MS) {
- return jsonError(401, "authentication_error", expiredAuthMessage(auth));
- }
-
- const onSession = (cursorSessionId: string) => {
- recordCursorConversation(ctx.sessionId, cursorSessionId);
- log.debug("cursor session observed", { cursorSessionId });
- };
- const nativeToolBridge = wantStream && ctx.sessionId && canBridgeCursorNativeTools(body, ctx)
- ? createCursorShellToolBridge({
- sessionId: ctx.sessionId,
- messageId,
- model: body.model,
- inputTokens,
- log: ctx.childLogger("cursor.bridge"),
- traffic: ctx.traffic,
- proto: deps.proto,
- onSession,
- allowedToolNames,
- outputIdleTimeoutMs: deps.bridgeOutputIdleTimeoutMs,
- })
- : undefined;
- const bridgeRead = canBridgeCursorReadTool(body);
- const bridgeBash = canBridgeCursorBashTool(body);
- const bridgeWrite = canBridgeCursorWriteTool(body);
- const denyUnadvertisedNativeTools = Boolean(wantStream && ctx.sessionId);
-
- const runOptions: CursorRunOptions = {
- prompt,
- mode: selection.mode,
- conversationId,
- model: selection.requestedModel,
- selectedImages,
- auth,
- ctx,
- readHandler: bridgeRead
- ? nativeToolBridge?.readHandler
- : denyUnadvertisedNativeTools
- ? denyCursorReadTool
- : undefined,
- shellStreamHandler: bridgeBash
- ? nativeToolBridge?.shellStreamHandler
- : denyUnadvertisedNativeTools
- ? denyCursorBashTool
- : undefined,
- writeHandler: bridgeWrite
- ? nativeToolBridge?.writeHandler
- : denyUnadvertisedNativeTools
- ? denyCursorWriteTool
- : undefined,
- };
- const runAgent = () => deps.runAgent(runOptions);
- const retryRunAgent = () =>
- retryCursorNetworkResourceError(runAgent, {
- log,
- signal: ctx.signal,
- computeRetryDelay: deps.computeRetryDelay,
- });
-
- let upstream: ReadableStream<Uint8Array>;
- try {
- upstream = await retryRunAgent();
- } catch (err) {
- if (err instanceof CursorError) {
- log.warn("cursor upstream error", {
- status: err.status,
- message: err.message,
- detail: err.detail,
- });
- const type = err.status === 401 || err.status === 403 ? "authentication_error" : "api_error";
- return jsonError(err.status, type, err.detail || err.message);
- }
- throw err;
- }
-
- if (wantStream) {
- const stream = nativeToolBridge?.stream(upstream, ctx.signal, {
- retryUpstream: retryRunAgent,
- computeRetryDelay: deps.computeRetryDelay,
- }) ?? translateCursorStream(upstream, {
- messageId,
- model: body.model,
- log: ctx.childLogger("cursor.stream"),
- signal: ctx.signal,
- traffic: ctx.traffic,
- proto: deps.proto,
- onSession,
- allowedToolNames,
- inputTokens,
- retryUpstream: retryRunAgent,
- computeRetryDelay: deps.computeRetryDelay,
- });
- return sseResponse(stream);
- }
-
- try {
- const accumulateLog = ctx.childLogger("cursor.accumulate");
- let nextUpstream: ReadableStream<Uint8Array> | undefined = upstream;
- const result = await retryCursorNetworkResourceError(
- async () => {
- const currentUpstream = nextUpstream ?? await runAgent();
- nextUpstream = undefined;
- return accumulateCursorResponse(currentUpstream, {
- messageId,
- model: body.model,
- log: accumulateLog,
- traffic: ctx.traffic,
- proto: deps.proto,
- onSession,
- allowedToolNames,
- inputTokens,
- });
- },
- {
- log: accumulateLog,
- signal: ctx.signal,
- computeRetryDelay: deps.computeRetryDelay,
- },
- );
- return jsonResponse(result.response);
- } catch (err) {
- log.warn("cursor accumulate error", { err: String(err) });
- if (err instanceof CursorError) {
- const type = err.status === 401 || err.status === 403 ? "authentication_error" : "api_error";
- return jsonError(err.status, type, err.detail || err.message);
- }
- return jsonError(502, "api_error", String(err));
- }
-}
-
-export function createCursorProvider(deps: CursorProviderDeps = defaultDeps): Provider {
- return {
- name: "cursor",
- supportedModels: CURSOR_SUPPORTED_MODELS,
- handleMessages: (body, ctx) => handleMessages(body, ctx, deps),
- handleCountTokens,
- cli: cursorCli,
- };
-}
-
-export const cursorProvider: Provider = createCursorProvider();
-
-async function retryCursorNetworkResourceError<T>(
- run: () => Promise<T>,
- opts: {
- log: Logger;
- signal?: AbortSignal;
- computeRetryDelay?: (attempt: number) => BackoffOutcome;
- },
-): Promise<T> {
- const retryDelay = opts.computeRetryDelay ?? computeBackoffDelay;
- for (let attempt = 0; ; attempt++) {
- try {
- return await run();
- } catch (err) {
- if (!isRetryableCursorNetworkResourceError(err) || attempt >= MAX_RATE_LIMIT_RETRIES) {
- throw err;
- }
- const { waitMs, exceedsBudget } = retryDelay(attempt);
- if (exceedsBudget) {
- opts.log.warn("cursor resource_exhausted network retry delay exceeds budget; giving up", {
- maxDelayMs: waitMs,
- err: String(err),
- });
- throw err;
- }
- opts.log.warn("cursor resource_exhausted network error, retrying", {
- attempt: attempt + 1,
- maxRetries: MAX_RATE_LIMIT_RETRIES,
- waitMs,
- err: String(err),
- });
- await sleep(waitMs, opts.signal);
- }
- }
-}
diff --git a/reference/typescript/src/providers/cursor/proto-loader.ts b/reference/typescript/src/providers/cursor/proto-loader.ts
deleted file mode 100644
index e9ea18e..0000000
--- a/reference/typescript/src/providers/cursor/proto-loader.ts
+++ /dev/null
@@ -1,122 +0,0 @@
-import { existsSync, readFileSync, realpathSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { execFileSync } from "node:child_process";
-import vm from "node:vm";
-import { createRequire } from "node:module";
-import { cursorAgentBundle } from "../../config.ts";
-
-export interface CursorProto {
- AgentClientMessage: ProtoClass;
- AgentServerMessage: ProtoClass;
-}
-
-export interface ProtoClass {
- typeName?: string;
- fromBinary(bytes: Uint8Array): ProtoMessage;
- fromJson(json: unknown): ProtoMessage;
-}
-
-export interface ProtoMessage {
- toBinary(): Uint8Array;
- toJson(options?: unknown): unknown;
-}
-
-let cached: CursorProto | undefined;
-
-export function loadCursorProto(): CursorProto {
- if (cached) return cached;
- const bundle = resolveCursorBundle();
- const code = patchBundleMain(readFileSync(bundle, "utf8"));
- const req = createRequire(bundle);
- const ctx: Record<string, unknown> = {
- require: req,
- console,
- process,
- Buffer,
- TextDecoder,
- TextEncoder,
- crypto,
- performance,
- URL,
- Headers,
- setTimeout,
- clearTimeout,
- __filename: bundle,
- __dirname: dirname(bundle),
- };
- ctx.globalThis = ctx;
- ctx.global = ctx;
- vm.runInNewContext(code, ctx, { filename: bundle });
- const webpackRequire = ctx.__wr as ((id: string) => Record<string, unknown>) | undefined;
- if (!webpackRequire) {
- throw new Error(`Cursor Agent protobuf loader failed: webpack require was not exposed from ${bundle}`);
- }
-
- const agent = webpackRequire("../proto/dist/generated/agent/v1/agent_service_pb.js");
- cached = {
- AgentClientMessage: requireProtoClass(agent.KS, "agent.v1.AgentClientMessage"),
- AgentServerMessage: requireProtoClass(agent.Oy, "agent.v1.AgentServerMessage"),
- };
- return cached;
-}
-
-export function resolveCursorBundle(): string {
- const configured = cursorAgentBundle();
- if (configured) return normalizeBundlePath(configured);
-
- const found = findOnPath("cursor-agent");
- if (found) return normalizeBundlePath(found);
-
- throw new Error(
- "Cursor Agent bundle not found. Install cursor-agent or set CCP_CURSOR_AGENT_BUNDLE to its index.js path.",
- );
-}
-
-function normalizeBundlePath(path: string): string {
- const real = realpathSync(path);
- if (real.endsWith("index.js")) return real;
- const siblingIndex = join(dirname(real), "index.js");
- if (existsSync(siblingIndex)) return siblingIndex;
- throw new Error(`Cursor Agent bundle path does not point to index.js or a launcher beside index.js: ${path}`);
-}
-
-function findOnPath(bin: string): string | undefined {
- try {
- const out = execFileSync("which", [bin], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
- return out.trim() || undefined;
- } catch {
- return undefined;
- }
-}
-
-function patchBundleMain(code: string): string {
- const exact = 'var __webpack_exports__=__webpack_require__("./src/main.tsx")})();';
- if (code.includes(exact)) {
- return code.replace(
- exact,
- "globalThis.__wr=__webpack_require__; globalThis.__wm=__webpack_modules__;})();",
- );
- }
- const fallback = new RegExp(
- String.raw`var __webpack_exports__=__webpack_require__\(["']\./src/main\.tsx["']\)\}\)\(\);?\s*$`,
- );
- const patched = code.replace(
- fallback,
- "globalThis.__wr=__webpack_require__; globalThis.__wm=__webpack_modules__;})();",
- );
- if (patched !== code) return patched;
- throw new Error("Cursor Agent bundle main entry pattern was not recognized");
-}
-
-function requireProtoClass(value: unknown, typeName: string): ProtoClass {
- const candidate = value as Record<string, unknown> | undefined;
- if (
- candidate &&
- typeof value === "function" &&
- typeof candidate.fromBinary === "function" &&
- typeof candidate.fromJson === "function"
- ) {
- return value as unknown as ProtoClass;
- }
- throw new Error(`Cursor protobuf class missing: ${typeName}`);
-}
diff --git a/reference/typescript/src/providers/cursor/session.test.ts b/reference/typescript/src/providers/cursor/session.test.ts
deleted file mode 100644
index 6956ad1..0000000
--- a/reference/typescript/src/providers/cursor/session.test.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import {
- clearCursorSessionsForTests,
- cursorConversationForRequest,
- recordCursorConversation,
-} from "./session.ts";
-
-afterEach(() => {
- clearCursorSessionsForTests();
-});
-
-describe("Cursor session mapping", () => {
- it("reuses a Cursor conversation for the same Claude session", () => {
- const first = cursorConversationForRequest({ metadata: undefined }, "claude-session", 1000);
- const second = cursorConversationForRequest({ metadata: undefined }, "claude-session", 2000);
-
- expect(second).toBe(first);
- });
-
- it("uses explicit resume metadata and records it for continuation", () => {
- const explicit = cursorConversationForRequest(
- { metadata: { cursor_chat_id: "cursor-chat-1" } },
- "claude-session",
- 1000,
- );
- const continued = cursorConversationForRequest({ metadata: undefined }, "claude-session", 2000);
-
- expect(explicit).toBe("cursor-chat-1");
- expect(continued).toBe("cursor-chat-1");
- });
-
- it("records observed server session ids", () => {
- recordCursorConversation("claude-session", "observed-cursor-session", 1000);
-
- expect(cursorConversationForRequest({ metadata: undefined }, "claude-session", 2000)).toBe(
- "observed-cursor-session",
- );
- });
-});
diff --git a/reference/typescript/src/providers/cursor/session.ts b/reference/typescript/src/providers/cursor/session.ts
deleted file mode 100644
index 20889ab..0000000
--- a/reference/typescript/src/providers/cursor/session.ts
+++ /dev/null
@@ -1,74 +0,0 @@
-import type { AnthropicRequest } from "../../anthropic/schema.ts";
-
-interface CursorSessionState {
- conversationId: string;
- lastSeen: number;
-}
-
-const SESSION_IDLE_TTL_MS = 30 * 60 * 1000;
-const MAX_SESSIONS = 10_000;
-const sessions = new Map<string, CursorSessionState>();
-
-export function cursorConversationForRequest(
- req: Pick<AnthropicRequest, "metadata">,
- sessionId: string | undefined,
- now = Date.now(),
-): string {
- const explicit = explicitConversationId(req.metadata);
- if (explicit) {
- if (sessionId) recordCursorConversation(sessionId, explicit, now);
- return explicit;
- }
-
- if (!sessionId) return crypto.randomUUID();
-
- const existing = sessions.get(sessionId);
- if (existing && now - existing.lastSeen <= SESSION_IDLE_TTL_MS) {
- existing.lastSeen = now;
- return existing.conversationId;
- }
-
- const conversationId = crypto.randomUUID();
- recordCursorConversation(sessionId, conversationId, now);
- return conversationId;
-}
-
-export function recordCursorConversation(
- sessionId: string | undefined,
- conversationId: string | undefined,
- now = Date.now(),
-): void {
- if (!sessionId || !conversationId) return;
- sessions.set(sessionId, { conversationId, lastSeen: now });
- evictOldestSessions();
-}
-
-export function clearCursorSessionsForTests(): void {
- sessions.clear();
-}
-
-function explicitConversationId(metadata: unknown): string | undefined {
- if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) return undefined;
- const record = metadata as Record<string, unknown>;
- for (const key of ["cursor_chat_id", "cursorChatId", "cursor_resume", "cursorResume"]) {
- const value = record[key];
- if (typeof value === "string" && value) return value;
- }
- const cursor = record.cursor;
- if (cursor && typeof cursor === "object" && !Array.isArray(cursor)) {
- const nested = cursor as Record<string, unknown>;
- for (const key of ["chat_id", "chatId", "resume", "resumeId"]) {
- const value = nested[key];
- if (typeof value === "string" && value) return value;
- }
- }
- return undefined;
-}
-
-function evictOldestSessions(): void {
- while (sessions.size > MAX_SESSIONS) {
- const oldest = sessions.keys().next().value;
- if (!oldest) return;
- sessions.delete(oldest);
- }
-}
diff --git a/reference/typescript/src/providers/cursor/sse-framing.ts b/reference/typescript/src/providers/cursor/sse-framing.ts
deleted file mode 100644
index f5792c6..0000000
--- a/reference/typescript/src/providers/cursor/sse-framing.ts
+++ /dev/null
@@ -1,148 +0,0 @@
-import type { CursorUsage } from "./client.ts";
-import { emitMessageStart } from "../shared/anthropic-sse.ts";
-
-type CursorSseStopReason = "end_turn" | "tool_use";
-
-interface CursorSseFramingOptions {
- messageId: string;
- model: string;
- emit: (event: string, data: unknown) => boolean;
- mapUsage: (usage?: CursorUsage) => unknown;
- initialUsage?: {
- input_tokens: number;
- output_tokens: number;
- cache_creation_input_tokens: number;
- cache_read_input_tokens: number;
- };
-}
-
-export interface CursorSseFramer {
- emitThinkingDelta(text: string): void;
- emitTextDelta(text: string): void;
- recordUsage(usage: CursorUsage): void;
- emitFinalMessage(stopReason: CursorSseStopReason): void;
- emitError(error: unknown): void;
- emitToolPauseMessage(emitToolUse: (index: number) => void): void;
- closeOpenBlocks(): void;
- ensureStart(): void;
- nextContentBlockIndex(): number;
-}
-
-export function createCursorSseFramer(opts: CursorSseFramingOptions): CursorSseFramer {
- let started = false;
- let thinkingOpen = false;
- let textOpen = false;
- let nextIndex = 0;
- let thinkingIndex = -1;
- let textIndex = -1;
- let finalUsage: CursorUsage | undefined;
-
- const emit = (event: string, data: unknown) => {
- opts.emit(event, data);
- };
-
- const nextContentBlockIndex = () => nextIndex++;
-
- const ensureStart = () => {
- if (started) return;
- started = true;
- emitMessageStart(emit, {
- messageId: opts.messageId,
- model: opts.model,
- usage: opts.initialUsage,
- });
- };
-
- const openThinking = () => {
- if (thinkingOpen) return;
- ensureStart();
- thinkingOpen = true;
- thinkingIndex = nextIndex++;
- emit("content_block_start", {
- type: "content_block_start",
- index: thinkingIndex,
- content_block: { type: "thinking", thinking: "", signature: "" },
- });
- };
-
- const openText = () => {
- if (textOpen) return;
- ensureStart();
- textOpen = true;
- textIndex = nextIndex++;
- emit("content_block_start", {
- type: "content_block_start",
- index: textIndex,
- content_block: { type: "text", text: "" },
- });
- };
-
- const closeOpenBlocks = () => {
- if (thinkingOpen) {
- emit("content_block_stop", { type: "content_block_stop", index: thinkingIndex });
- thinkingOpen = false;
- }
- if (textOpen) {
- emit("content_block_stop", { type: "content_block_stop", index: textIndex });
- textOpen = false;
- }
- };
-
- const emitFinalMessage = (stopReason: CursorSseStopReason) => {
- ensureStart();
- closeOpenBlocks();
- emit("message_delta", {
- type: "message_delta",
- delta: { stop_reason: stopReason, stop_sequence: null },
- usage: opts.mapUsage(finalUsage),
- });
- emit("message_stop", { type: "message_stop" });
- };
-
- return {
- emitThinkingDelta(text) {
- openThinking();
- emit("content_block_delta", {
- type: "content_block_delta",
- index: thinkingIndex,
- delta: { type: "thinking_delta", thinking: text },
- });
- },
- emitTextDelta(text) {
- if (thinkingOpen) {
- emit("content_block_stop", { type: "content_block_stop", index: thinkingIndex });
- thinkingOpen = false;
- }
- openText();
- emit("content_block_delta", {
- type: "content_block_delta",
- index: textIndex,
- delta: { type: "text_delta", text },
- });
- },
- recordUsage(usage) {
- finalUsage = usage;
- },
- emitFinalMessage,
- emitError(error) {
- ensureStart();
- closeOpenBlocks();
- emit("error", {
- type: "error",
- error: { type: "api_error", message: String(error) },
- });
- },
- emitToolPauseMessage(emitToolUse) {
- closeOpenBlocks();
- ensureStart();
- const index = nextContentBlockIndex();
- emitToolUse(index);
- emitFinalMessage("tool_use");
- },
- closeOpenBlocks,
- ensureStart,
- nextContentBlockIndex() {
- return nextContentBlockIndex();
- },
- };
-}
diff --git a/reference/typescript/src/providers/cursor/tool-bridge.ts b/reference/typescript/src/providers/cursor/tool-bridge.ts
deleted file mode 100644
index 04b78d6..0000000
--- a/reference/typescript/src/providers/cursor/tool-bridge.ts
+++ /dev/null
@@ -1,618 +0,0 @@
-import { encodeSseEvent } from "../../sse.ts";
-import type { AnthropicRequest, AnthropicToolResultBlock } from "../../anthropic/schema.ts";
-import type { Logger } from "../../log.ts";
-import { computeBackoffDelay, MAX_RATE_LIMIT_RETRIES, sleep, type BackoffOutcome } from "../retry.ts";
-import type { RequestContext } from "../types.ts";
-import { countCursorTokens } from "./count-tokens.ts";
-import {
- appendCursorReadResult,
- appendCursorShellStreamResult,
- appendCursorWriteResult,
- buildCursorReadResultFromNativeToolResult,
- buildCursorShellStreamResultFromNativeToolResult,
- buildCursorWriteResultFromNativeToolResult,
- CURSOR_OUTPUT_IDLE_TIMEOUT_MS,
- cursorReadArgs,
- cursorShellStreamArgs,
- cursorWriteArgs,
- type CursorNativeToolResult,
- decodeCursorStream,
- isRetryableCursorNetworkResourceError,
- type CursorAppendMessage,
- type CursorReadExec,
- type CursorShellStreamExec,
- type CursorStreamEvent,
- type CursorWriteExec,
-} from "./client.ts";
-import type { CursorProto } from "./proto-loader.ts";
-import { cursorUsageToAnthropic } from "./translate/response.ts";
-import { createCursorSseFramer } from "./sse-framing.ts";
-import {
- CursorToolUseXmlParser,
- type RecoveredCursorTextEvent,
- type RecoveredCursorToolUse,
-} from "./tool-use-xml.ts";
-
-interface PendingToolBase {
- toolUseId: string;
- startedAt: number;
- append: CursorAppendMessage;
- resolve(result: CursorNativeToolResult): void;
- result: Promise<CursorNativeToolResult>;
-}
-
-interface PendingReadTool extends PendingToolBase {
- kind: "Read";
- exec: CursorReadExec;
- path: string;
-}
-
-interface PendingShellTool extends PendingToolBase {
- kind: "Bash";
- exec: CursorShellStreamExec;
- command: string;
- workingDirectory: string;
- timeoutMs: number;
-}
-
-interface PendingWriteTool extends PendingToolBase {
- kind: "Write";
- exec: CursorWriteExec;
- path: string;
- content: string;
-}
-
-type PendingNativeTool = PendingReadTool | PendingShellTool | PendingWriteTool;
-
-interface CursorBridgeState {
- sessionId: string;
- messageId: string;
- model: string;
- inputTokens?: number;
- iterator: AsyncGenerator<CursorStreamEvent>;
- pendingNext?: Promise<IteratorResult<CursorStreamEvent>>;
- pendingTool?: PendingNativeTool;
- waiters: Array<(tool: PendingNativeTool) => void>;
- log: Logger;
- traffic?: RequestContext["traffic"];
- proto?: CursorProto;
- onSession?: (sessionId: string) => void;
- allowedToolNames?: ReadonlySet<string>;
- outputSeen: boolean;
- downstreamStarted: boolean;
- outputIdleTimeoutMs: number;
- retryUpstream?: () => Promise<ReadableStream<Uint8Array>>;
- computeRetryDelay?: (attempt: number) => BackoffOutcome;
-}
-
-const bridgeStates = new Map<string, CursorBridgeState>();
-
-export function canBridgeCursorNativeTools(body: AnthropicRequest, ctx: RequestContext): boolean {
- return Boolean(
- ctx.sessionId && body.stream && body.tools?.some((tool) =>
- tool.name === "Read" || tool.name === "Bash" || tool.name === "Write"
- ),
- );
-}
-
-export function canBridgeCursorReadTool(body: AnthropicRequest): boolean {
- return Boolean(body.tools?.some((tool) => tool.name === "Read"));
-}
-
-export function canBridgeCursorBashTool(body: AnthropicRequest): boolean {
- return Boolean(body.tools?.some((tool) => tool.name === "Bash"));
-}
-
-export function canBridgeCursorWriteTool(body: AnthropicRequest): boolean {
- return Boolean(body.tools?.some((tool) => tool.name === "Write"));
-}
-
-export async function denyCursorReadTool(exec: CursorReadExec, append: CursorAppendMessage): Promise<void> {
- await appendCursorReadResult(
- exec,
- {
- success: false,
- error: "Cursor requested Read, but Claude did not advertise the Read tool",
- },
- append,
- );
-}
-
-export async function denyCursorBashTool(exec: CursorShellStreamExec, append: CursorAppendMessage): Promise<void> {
- await appendCursorShellStreamResult(
- exec,
- {
- stderr: "Cursor requested Bash, but Claude did not advertise the Bash tool",
- exitCode: 1,
- cwd: cursorShellStreamArgs(exec).workingDirectory,
- localExecutionTimeMs: 0,
- },
- append,
- );
-}
-
-export async function denyCursorWriteTool(exec: CursorWriteExec, append: CursorAppendMessage): Promise<void> {
- await appendCursorWriteResult(
- exec,
- {
- success: false,
- error: "Cursor requested Write, but Claude did not advertise the Write tool",
- },
- append,
- );
-}
-
-export function createCursorShellToolBridge(opts: {
- sessionId: string;
- messageId: string;
- model: string;
- inputTokens?: number;
- log: Logger;
- traffic?: RequestContext["traffic"];
- proto?: CursorProto;
- onSession?: (sessionId: string) => void;
- allowedToolNames?: ReadonlySet<string>;
- outputIdleTimeoutMs?: number;
-}): {
- readHandler: (exec: CursorReadExec, append: CursorAppendMessage) => Promise<void>;
- shellStreamHandler: (exec: CursorShellStreamExec, append: CursorAppendMessage) => Promise<void>;
- writeHandler: (exec: CursorWriteExec, append: CursorAppendMessage) => Promise<void>;
- stream: (
- upstream: ReadableStream<Uint8Array>,
- signal?: AbortSignal,
- retryOpts?: {
- retryUpstream?: () => Promise<ReadableStream<Uint8Array>>;
- computeRetryDelay?: (attempt: number) => BackoffOutcome;
- },
- ) => ReadableStream<Uint8Array>;
-} {
- const state: CursorBridgeState = {
- sessionId: opts.sessionId,
- messageId: opts.messageId,
- model: opts.model,
- inputTokens: opts.inputTokens,
- iterator: undefined as unknown as AsyncGenerator<CursorStreamEvent>,
- waiters: [],
- log: opts.log,
- traffic: opts.traffic,
- proto: opts.proto,
- onSession: opts.onSession,
- allowedToolNames: opts.allowedToolNames,
- outputSeen: false,
- downstreamStarted: false,
- outputIdleTimeoutMs: opts.outputIdleTimeoutMs ?? CURSOR_OUTPUT_IDLE_TIMEOUT_MS,
- };
-
- const notifyTool = (tool: PendingNativeTool) => {
- state.pendingTool = tool;
- for (const waiter of state.waiters.splice(0)) waiter(tool);
- };
-
- const createPendingTool = <T extends PendingNativeTool>(
- append: CursorAppendMessage,
- build: (base: {
- toolUseId: string;
- startedAt: number;
- append: CursorAppendMessage;
- resolve(result: CursorNativeToolResult): void;
- result: Promise<CursorNativeToolResult>;
- }) => T,
- ): T => {
- const toolUseId = `call_cursor_${crypto.randomUUID().replace(/-/g, "")}`;
- let resolve!: (result: CursorNativeToolResult) => void;
- const result = new Promise<CursorNativeToolResult>((r) => {
- resolve = r;
- });
- return build({
- toolUseId,
- startedAt: Date.now(),
- append,
- resolve,
- result,
- });
- };
-
- return {
- async readHandler(exec, append) {
- const { path } = cursorReadArgs(exec);
- const tool = createPendingTool<PendingReadTool>(append, (base) => ({
- kind: "Read",
- exec,
- path,
- ...base,
- }));
- opts.traffic?.writeJsonEvent("038-cursor-tool-bridge-pause", {
- kind: tool.kind,
- toolUseId: tool.toolUseId,
- path,
- });
- notifyTool(tool);
- const readResult = await tool.result;
- await appendCursorReadResult(
- exec,
- buildCursorReadResultFromNativeToolResult(readResult),
- append,
- );
- opts.traffic?.writeJsonEvent("038-cursor-tool-bridge-resume", {
- kind: tool.kind,
- toolUseId: tool.toolUseId,
- isError: readResult.isError,
- contentChars: readResult.content.length,
- });
- },
- async shellStreamHandler(exec, append) {
- const { command, workingDirectory, timeoutMs } = cursorShellStreamArgs(exec);
- const tool = createPendingTool<PendingShellTool>(append, (base) => ({
- kind: "Bash",
- exec,
- command,
- workingDirectory,
- timeoutMs,
- ...base,
- }));
- opts.traffic?.writeJsonEvent("038-cursor-tool-bridge-pause", {
- kind: tool.kind,
- toolUseId: tool.toolUseId,
- command,
- workingDirectory,
- timeoutMs,
- });
- notifyTool(tool);
- const shellResult = await tool.result;
- await appendCursorShellStreamResult(
- exec,
- buildCursorShellStreamResultFromNativeToolResult(
- shellResult,
- tool.startedAt,
- workingDirectory,
- ),
- append,
- );
- opts.traffic?.writeJsonEvent("038-cursor-tool-bridge-resume", {
- kind: tool.kind,
- toolUseId: tool.toolUseId,
- isError: shellResult.isError,
- contentChars: shellResult.content.length,
- });
- },
- async writeHandler(exec, append) {
- const { path, content } = cursorWriteArgs(exec);
- const tool = createPendingTool<PendingWriteTool>(append, (base) => ({
- kind: "Write",
- exec,
- path,
- content,
- ...base,
- }));
- opts.traffic?.writeJsonEvent("038-cursor-tool-bridge-pause", {
- kind: tool.kind,
- toolUseId: tool.toolUseId,
- path,
- contentChars: content.length,
- });
- notifyTool(tool);
- const writeResult = await tool.result;
- await appendCursorWriteResult(exec, buildCursorWriteResultFromNativeToolResult(writeResult), append);
- opts.traffic?.writeJsonEvent("038-cursor-tool-bridge-resume", {
- kind: tool.kind,
- toolUseId: tool.toolUseId,
- isError: writeResult.isError,
- contentChars: writeResult.content.length,
- });
- },
- stream(upstream, signal, retryOpts) {
- state.iterator = decodeCursorStream(upstream, opts.proto, {
- traffic: opts.traffic,
- log: opts.log,
- outputIdleTimeoutMs: 0,
- });
- state.pendingNext = undefined;
- state.outputSeen = false;
- state.downstreamStarted = false;
- state.retryUpstream = retryOpts?.retryUpstream;
- state.computeRetryDelay = retryOpts?.computeRetryDelay;
- bridgeStates.set(opts.sessionId, state);
- return streamBridgeUntilToolOrEnd(state, signal);
- },
- };
-}
-
-export function resumeCursorShellToolBridge(
- body: AnthropicRequest,
- ctx: RequestContext,
- messageId: string,
-): Response | undefined {
- const sessionId = ctx.sessionId;
- if (!sessionId) return undefined;
- const state = bridgeStates.get(sessionId);
- const tool = state?.pendingTool;
- if (!state || !tool) return undefined;
- const result = findToolResult(body, tool.toolUseId);
- if (!result) return undefined;
-
- state.pendingTool = undefined;
- state.messageId = messageId;
- state.model = body.model;
- state.inputTokens = countCursorTokens(body);
- tool.resolve({
- content: renderToolResultContent(result.content),
- isError: Boolean(result.is_error),
- });
-
- const stream = streamBridgeUntilToolOrEnd(state, ctx.signal);
- return new Response(stream, {
- headers: {
- "content-type": "text/event-stream",
- "cache-control": "no-cache",
- "connection": "keep-alive",
- },
- });
-}
-
-function streamBridgeUntilToolOrEnd(
- state: CursorBridgeState,
- signal?: AbortSignal,
-): ReadableStream<Uint8Array> {
- const encoder = new TextEncoder();
- return new ReadableStream<Uint8Array>({
- async start(controller) {
- let closed = false;
- let retryAttempt = 0;
-
- const emit = (event: string, data: unknown) => {
- if (closed || signal?.aborted || controller.desiredSize === null) return false;
- state.traffic?.writeJsonEvent("050-downstream-event", { event, data });
- controller.enqueue(encoder.encode(encodeSseEvent(event, data)));
- state.downstreamStarted = true;
- return true;
- };
-
- try {
- while (true) {
- const framing = createCursorSseFramer({
- messageId: state.messageId,
- model: state.model,
- emit,
- mapUsage: (usage) => cursorUsageToAnthropic(usage, { inputTokens: state.inputTokens }),
- initialUsage: cursorUsageToAnthropic(undefined, { inputTokens: state.inputTokens }),
- });
- const toolUseXml = new CursorToolUseXmlParser({ allowedToolNames: state.allowedToolNames });
-
- const emitToolUseAndPause = (tool: PendingNativeTool) => {
- framing.emitToolPauseMessage((index) => {
- const input = toolUseInput(tool);
- emit("content_block_start", {
- type: "content_block_start",
- index,
- content_block: {
- type: "tool_use",
- id: tool.toolUseId,
- name: tool.kind,
- input: {},
- },
- });
- emit("content_block_delta", {
- type: "content_block_delta",
- index,
- delta: { type: "input_json_delta", partial_json: input },
- });
- emit("content_block_stop", { type: "content_block_stop", index });
- });
- };
-
- const emitRecoveredToolUse = (tool: RecoveredCursorToolUse) => {
- state.traffic?.writeJsonEvent("041-cursor-xml-tool-use", {
- id: tool.id,
- originalId: tool.originalId,
- name: tool.name,
- inputChars: JSON.stringify(tool.input).length,
- });
- framing.closeOpenBlocks();
- framing.ensureStart();
- const index = framing.nextContentBlockIndex();
- emit("content_block_start", {
- type: "content_block_start",
- index,
- content_block: {
- type: "tool_use",
- id: tool.id,
- name: tool.name,
- input: {},
- },
- });
- emit("content_block_delta", {
- type: "content_block_delta",
- index,
- delta: { type: "input_json_delta", partial_json: JSON.stringify(tool.input) },
- });
- emit("content_block_stop", { type: "content_block_stop", index });
- };
-
- const applyRecoveredEvent = (event: RecoveredCursorTextEvent) => {
- if (event.type === "text") {
- framing.emitTextDelta(event.text);
- return;
- }
- emitRecoveredToolUse(event);
- };
-
- try {
- while (!signal?.aborted) {
- const next = state.pendingNext ?? state.iterator.next();
- state.pendingNext = next;
- let idleTimer: ReturnType<typeof setTimeout> | undefined;
- const race: Array<Promise<
- | { type: "event"; value: IteratorResult<CursorStreamEvent> }
- | { type: "tool"; tool: PendingNativeTool }
- | { type: "idle" }
- >> = [
- next.then((value) => ({ type: "event" as const, value })),
- waitForPendingTool(state).then((tool) => ({ type: "tool" as const, tool })),
- ];
- if (state.outputSeen && state.outputIdleTimeoutMs > 0) {
- race.push(new Promise<{ type: "idle" }>((resolve) => {
- idleTimer = setTimeout(() => resolve({ type: "idle" }), state.outputIdleTimeoutMs);
- }));
- }
- const result = await Promise.race(race).finally(() => {
- if (idleTimer) clearTimeout(idleTimer);
- });
-
- if (result.type === "tool") {
- emitToolUseAndPause(result.tool);
- return;
- }
-
- if (result.type === "idle") {
- state.log.warn("cursor bridge stream idle after output", {
- idleMs: state.outputIdleTimeoutMs,
- });
- state.traffic?.writeJsonEvent("040-cursor-event", {
- type: "end",
- reason: "output_idle_timeout",
- idleMs: state.outputIdleTimeoutMs,
- });
- state.pendingNext = undefined;
- await state.iterator.return?.(undefined);
- break;
- }
-
- state.pendingNext = undefined;
- if (result.value.done) break;
- const event = result.value.value;
- state.traffic?.writeJsonEvent("040-cursor-event", event);
- if (event.type === "thinking_delta" || event.type === "text_delta" || event.type === "usage") {
- state.outputSeen = true;
- }
- switch (event.type) {
- case "session":
- state.onSession?.(event.sessionId);
- break;
- case "thinking_delta":
- framing.emitThinkingDelta(event.text);
- break;
- case "text_delta":
- for (const recovered of toolUseXml.push(event.text)) applyRecoveredEvent(recovered);
- break;
- case "usage":
- framing.recordUsage(event.usage);
- break;
- case "end":
- break;
- }
- }
- for (const recovered of toolUseXml.flush()) applyRecoveredEvent(recovered);
-
- framing.emitFinalMessage(toolUseXml.sawToolUse ? "tool_use" : "end_turn");
- bridgeStates.delete(state.sessionId);
- return;
- } catch (caught) {
- let err: unknown = caught;
- if (!state.downstreamStarted && state.retryUpstream && isRetryableCursorNetworkResourceError(err)) {
- if (retryAttempt < MAX_RATE_LIMIT_RETRIES && !signal?.aborted) {
- const retryDelay = state.computeRetryDelay ?? computeBackoffDelay;
- const { waitMs, exceedsBudget } = retryDelay(retryAttempt);
- if (exceedsBudget) {
- state.log.warn("cursor bridge retry delay exceeds budget; giving up", {
- maxDelayMs: waitMs,
- err: String(err),
- });
- } else {
- const nextAttempt = retryAttempt + 1;
- state.log.warn("cursor bridge stream error before downstream output, retrying", {
- attempt: nextAttempt,
- maxRetries: MAX_RATE_LIMIT_RETRIES,
- waitMs,
- err: String(err),
- });
- retryAttempt = nextAttempt;
- try {
- await sleep(waitMs, signal);
- const retryUpstream = await state.retryUpstream();
- state.iterator = decodeCursorStream(retryUpstream, state.proto, {
- traffic: state.traffic,
- log: state.log,
- outputIdleTimeoutMs: 0,
- });
- state.pendingNext = undefined;
- state.outputSeen = false;
- continue;
- } catch (retryErr) {
- err = retryErr;
- }
- }
- }
- }
- state.log.warn("cursor bridge stream error", { err: String(err) });
- framing.emitError(err);
- bridgeStates.delete(state.sessionId);
- return;
- }
- }
- } finally {
- closed = true;
- try {
- controller.close();
- } catch {}
- }
- },
- });
-}
-
-function waitForPendingTool(state: CursorBridgeState): Promise<PendingNativeTool> {
- if (state.pendingTool) return Promise.resolve(state.pendingTool);
- return new Promise((resolve) => state.waiters.push(resolve));
-}
-
-function findToolResult(body: AnthropicRequest, toolUseId: string): AnthropicToolResultBlock | undefined {
- for (let i = body.messages.length - 1; i >= 0; i--) {
- const message = body.messages[i];
- if (!message || message.role !== "user" || typeof message.content === "string") continue;
- for (const block of message.content) {
- if (block.type === "tool_result" && block.tool_use_id === toolUseId) return block;
- }
- }
- return undefined;
-}
-
-function renderToolResultContent(content: AnthropicToolResultBlock["content"]): string {
- if (typeof content === "string") return content;
- return content
- .map((block) => {
- if (block.type === "text") return block.text;
- if (block.type === "image") return "[image result omitted]";
- if (block.type === "thinking") return block.thinking;
- return JSON.stringify(block);
- })
- .join("\n");
-}
-
-function toolUseInput(tool: PendingNativeTool): string {
- if (tool.kind === "Read") {
- return JSON.stringify({
- file_path: tool.path,
- });
- }
- if (tool.kind === "Write") {
- return JSON.stringify({
- file_path: tool.path,
- content: tool.content,
- });
- }
- return JSON.stringify({
- command: claudeBashCommand(tool),
- timeout: tool.timeoutMs,
- description: "Run Cursor-requested shell command",
- run_in_background: false,
- dangerouslyDisableSandbox: false,
- });
-}
-
-function claudeBashCommand(tool: PendingShellTool): string {
- if (!tool.workingDirectory || tool.workingDirectory === process.cwd()) return tool.command;
- return `cd ${shellQuote(tool.workingDirectory)} && ${tool.command}`;
-}
-
-function shellQuote(value: string): string {
- return `'${value.replaceAll("'", "'\\''")}'`;
-}
diff --git a/reference/typescript/src/providers/cursor/tool-use-xml.ts b/reference/typescript/src/providers/cursor/tool-use-xml.ts
deleted file mode 100644
index 81a664a..0000000
--- a/reference/typescript/src/providers/cursor/tool-use-xml.ts
+++ /dev/null
@@ -1,160 +0,0 @@
-export interface RecoveredCursorToolUse {
- type: "tool_use";
- id: string;
- originalId?: string;
- name: string;
- input: Record<string, unknown>;
-}
-
-export type RecoveredCursorTextEvent =
- | { type: "text"; text: string }
- | RecoveredCursorToolUse;
-
-export class CursorToolUseXmlParser {
- private buffer = "";
- private recoveredToolUse = false;
- private readonly allowedToolNames?: ReadonlySet<string>;
- private readonly idFactory: () => string;
-
- constructor(opts: {
- allowedToolNames?: ReadonlySet<string>;
- idFactory?: () => string;
- } = {}) {
- this.allowedToolNames = opts.allowedToolNames;
- this.idFactory = opts.idFactory ?? newCursorToolUseId;
- }
-
- get sawToolUse(): boolean {
- return this.recoveredToolUse;
- }
-
- push(text: string): RecoveredCursorTextEvent[] {
- this.buffer += text;
- return this.drain(false);
- }
-
- flush(): RecoveredCursorTextEvent[] {
- return this.drain(true);
- }
-
- private drain(flush: boolean): RecoveredCursorTextEvent[] {
- const events: RecoveredCursorTextEvent[] = [];
-
- while (this.buffer) {
- if (this.dropRedundantCloseTag()) continue;
-
- const start = this.buffer.search(/<tool_use\b/);
- if (start === -1) {
- const hold = flush ? 0 : toolUsePrefixSuffixLength(this.buffer);
- const end = this.buffer.length - hold;
- this.pushText(events, this.buffer.slice(0, end));
- this.buffer = this.buffer.slice(end);
- break;
- }
-
- if (start > 0) {
- this.pushText(events, this.buffer.slice(0, start));
- this.buffer = this.buffer.slice(start);
- continue;
- }
-
- const closeStart = this.buffer.indexOf("</tool_use>");
- if (closeStart === -1) {
- if (flush) {
- this.pushText(events, this.buffer);
- this.buffer = "";
- }
- break;
- }
-
- const closeEnd = closeStart + "</tool_use>".length;
- const raw = this.buffer.slice(0, closeEnd);
- const parsed = this.parseToolUse(raw);
- if (parsed) {
- this.recoveredToolUse = true;
- events.push(parsed);
- } else {
- this.pushText(events, raw);
- }
- this.buffer = this.buffer.slice(closeEnd);
- }
-
- return events;
- }
-
- private parseToolUse(raw: string): RecoveredCursorToolUse | undefined {
- const match = raw.match(/^<tool_use\b([^>]*)>([\s\S]*?)<\/tool_use>$/);
- if (!match) return undefined;
- const attrs = parseXmlAttributes(match[1] ?? "");
- const name = attrs.name;
- if (!name) return undefined;
- if (this.allowedToolNames && !this.allowedToolNames.has(name)) return undefined;
-
- let input: unknown;
- try {
- input = JSON.parse((match[2] ?? "").trim() || "{}");
- } catch {
- return undefined;
- }
- if (!isJsonObject(input)) return undefined;
-
- return {
- type: "tool_use",
- id: this.idFactory(),
- originalId: attrs.id,
- name,
- input,
- };
- }
-
- private pushText(events: RecoveredCursorTextEvent[], text: string): void {
- if (!text) return;
- if (this.recoveredToolUse && text.trim() === "") return;
- events.push({ type: "text", text });
- }
-
- private dropRedundantCloseTag(): boolean {
- if (!this.recoveredToolUse) return false;
- const match = this.buffer.match(/^\s*<\/tool_use>\s*/);
- if (!match?.[0]) return false;
- this.buffer = this.buffer.slice(match[0].length);
- return true;
- }
-}
-
-function parseXmlAttributes(source: string): Record<string, string> {
- const attrs: Record<string, string> = {};
- const attrPattern = /([A-Za-z_][\w:.-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
- for (const match of source.matchAll(attrPattern)) {
- const key = match[1];
- const value = match[2] ?? match[3] ?? "";
- if (key) attrs[key] = decodeXmlAttribute(value);
- }
- return attrs;
-}
-
-function decodeXmlAttribute(value: string): string {
- return value
- .replaceAll("&quot;", '"')
- .replaceAll("&apos;", "'")
- .replaceAll("&lt;", "<")
- .replaceAll("&gt;", ">")
- .replaceAll("&amp;", "&");
-}
-
-function isJsonObject(value: unknown): value is Record<string, unknown> {
- return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-
-function toolUsePrefixSuffixLength(value: string): number {
- const marker = "<tool_use";
- const max = Math.min(marker.length - 1, value.length);
- for (let len = max; len > 0; len--) {
- if (value.endsWith(marker.slice(0, len))) return len;
- }
- return 0;
-}
-
-function newCursorToolUseId(): string {
- return `call_cursor_${crypto.randomUUID().replaceAll("-", "")}`;
-}
diff --git a/reference/typescript/src/providers/cursor/translate/catalog.ts b/reference/typescript/src/providers/cursor/translate/catalog.ts
deleted file mode 100644
index 8e9ec9b..0000000
--- a/reference/typescript/src/providers/cursor/translate/catalog.ts
+++ /dev/null
@@ -1,136 +0,0 @@
-// Generated from `cursor-agent --list-models` on 2026-06-07.
-// Cursor models are account-gated and change over time; the resolver also
-// accepts cursor:<raw-model> for ids that are not in this snapshot.
-export const CURSOR_AGENT_MODEL_IDS = [
- "auto",
- "gpt-5.3-codex-low",
- "gpt-5.3-codex-low-fast",
- "gpt-5.3-codex",
- "gpt-5.3-codex-fast",
- "gpt-5.3-codex-high",
- "gpt-5.3-codex-high-fast",
- "gpt-5.3-codex-xhigh",
- "gpt-5.3-codex-xhigh-fast",
- "gpt-5.2",
- "gpt-5.2-codex-low",
- "gpt-5.2-codex-low-fast",
- "gpt-5.2-codex",
- "gpt-5.2-codex-fast",
- "gpt-5.2-codex-high",
- "gpt-5.2-codex-high-fast",
- "gpt-5.2-codex-xhigh",
- "gpt-5.2-codex-xhigh-fast",
- "gpt-5.1-codex-max-low",
- "gpt-5.1-codex-max-low-fast",
- "gpt-5.1-codex-max-medium",
- "gpt-5.1-codex-max-medium-fast",
- "gpt-5.1-codex-max-high",
- "gpt-5.1-codex-max-high-fast",
- "gpt-5.1-codex-max-xhigh",
- "gpt-5.1-codex-max-xhigh-fast",
- "composer-2.5",
- "claude-opus-4-8-thinking-high",
- "claude-opus-4-8-thinking-high-fast",
- "gpt-5.5-high",
- "gpt-5.5-high-fast",
- "claude-opus-4-7-thinking-high",
- "claude-opus-4-7-thinking-high-fast",
- "gpt-5.4-high",
- "gpt-5.4-high-fast",
- "claude-4.6-opus-high-thinking",
- "composer-2.5-fast",
- "claude-opus-4-8-low",
- "claude-opus-4-8-low-fast",
- "claude-opus-4-8-medium",
- "claude-opus-4-8-medium-fast",
- "claude-opus-4-8-high",
- "claude-opus-4-8-high-fast",
- "claude-opus-4-8-xhigh",
- "claude-opus-4-8-xhigh-fast",
- "claude-opus-4-8-max",
- "claude-opus-4-8-max-fast",
- "claude-opus-4-8-thinking-low",
- "claude-opus-4-8-thinking-low-fast",
- "claude-opus-4-8-thinking-medium",
- "claude-opus-4-8-thinking-medium-fast",
- "claude-opus-4-8-thinking-xhigh",
- "claude-opus-4-8-thinking-xhigh-fast",
- "claude-opus-4-8-thinking-max",
- "claude-opus-4-8-thinking-max-fast",
- "gpt-5.5-none",
- "gpt-5.5-none-fast",
- "gpt-5.5-low",
- "gpt-5.5-low-fast",
- "gpt-5.5-medium",
- "gpt-5.5-medium-fast",
- "gpt-5.5-extra-high",
- "gpt-5.5-extra-high-fast",
- "claude-4.6-sonnet-medium",
- "claude-4.6-sonnet-medium-thinking",
- "claude-opus-4-7-low",
- "claude-opus-4-7-low-fast",
- "claude-opus-4-7-medium",
- "claude-opus-4-7-medium-fast",
- "claude-opus-4-7-high",
- "claude-opus-4-7-high-fast",
- "claude-opus-4-7-xhigh",
- "claude-opus-4-7-xhigh-fast",
- "claude-opus-4-7-max",
- "claude-opus-4-7-max-fast",
- "claude-opus-4-7-thinking-low",
- "claude-opus-4-7-thinking-low-fast",
- "claude-opus-4-7-thinking-medium",
- "claude-opus-4-7-thinking-medium-fast",
- "claude-opus-4-7-thinking-xhigh",
- "claude-opus-4-7-thinking-xhigh-fast",
- "claude-opus-4-7-thinking-max",
- "claude-opus-4-7-thinking-max-fast",
- "grok-build-0.1",
- "gpt-5.4-low",
- "gpt-5.4-medium",
- "gpt-5.4-medium-fast",
- "gpt-5.4-xhigh",
- "gpt-5.4-xhigh-fast",
- "claude-4.6-opus-high",
- "claude-4.6-opus-max",
- "claude-4.6-opus-high-thinking-fast",
- "claude-4.6-opus-max-thinking",
- "claude-4.6-opus-max-thinking-fast",
- "claude-4.5-opus-high",
- "claude-4.5-opus-high-thinking",
- "gpt-5.2-low",
- "gpt-5.2-low-fast",
- "gpt-5.2-fast",
- "gpt-5.2-high",
- "gpt-5.2-high-fast",
- "gpt-5.2-xhigh",
- "gpt-5.2-xhigh-fast",
- "gemini-3.1-pro",
- "gpt-5.4-mini-none",
- "gpt-5.4-mini-low",
- "gpt-5.4-mini-medium",
- "gpt-5.4-mini-high",
- "gpt-5.4-mini-xhigh",
- "gpt-5.4-nano-none",
- "gpt-5.4-nano-low",
- "gpt-5.4-nano-medium",
- "gpt-5.4-nano-high",
- "gpt-5.4-nano-xhigh",
- "grok-4.3",
- "claude-4.5-sonnet",
- "claude-4.5-sonnet-thinking",
- "gpt-5.1-low",
- "gpt-5.1",
- "gpt-5.1-high",
- "gemini-3-flash",
- "gemini-3.5-flash",
- "gpt-5.1-codex-mini-low",
- "gpt-5.1-codex-mini",
- "gpt-5.1-codex-mini-high",
- "claude-4-sonnet",
- "claude-4-sonnet-thinking",
- "gpt-5-mini",
- "kimi-k2.5",
-] as const;
-
-export const CURSOR_AGENT_MODEL_ID_SET = new Set<string>(CURSOR_AGENT_MODEL_IDS);
diff --git a/reference/typescript/src/providers/cursor/translate/model.test.ts b/reference/typescript/src/providers/cursor/translate/model.test.ts
deleted file mode 100644
index 3cabee3..0000000
--- a/reference/typescript/src/providers/cursor/translate/model.test.ts
+++ /dev/null
@@ -1,166 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { CURSOR_AGENT_MODEL_IDS } from "./catalog.ts";
-import { CURSOR_SUPPORTED_MODELS, isCursorModel, resolveCursorModel } from "./model.ts";
-
-describe("Cursor model selection", () => {
- it("maps cursor aliases to Cursor default", () => {
- expect(resolveCursorModel({ model: "cursor", metadata: undefined })).toEqual({
- mode: "AGENT_MODE_AGENT",
- requestedModel: { modelId: "default" },
- });
- expect(resolveCursorModel({ model: "cursor-agent", metadata: undefined })).toEqual({
- mode: "AGENT_MODE_AGENT",
- requestedModel: { modelId: "default" },
- });
- });
-
- it("maps composer aliases explicitly", () => {
- expect(resolveCursorModel({ model: "cursor-composer", metadata: undefined })).toEqual({
- mode: "AGENT_MODE_AGENT",
- requestedModel: {
- modelId: "composer-2.5",
- parameters: [{ id: "fast", value: "false" }],
- },
- });
- expect(resolveCursorModel({ model: "cursor-composer-fast", metadata: undefined })).toEqual({
- mode: "AGENT_MODE_AGENT",
- requestedModel: {
- modelId: "composer-2.5",
- parameters: [{ id: "fast", value: "true" }],
- },
- });
- });
-
- it("selects plan and ask modes from aliases", () => {
- expect(resolveCursorModel({ model: "cursor-plan", metadata: undefined })).toEqual({
- mode: "AGENT_MODE_PLAN",
- requestedModel: { modelId: "default" },
- });
- expect(resolveCursorModel({ model: "cursor-ask", metadata: undefined })).toEqual({
- mode: "AGENT_MODE_ASK",
- requestedModel: { modelId: "default" },
- });
- });
-
- it("supports raw cursor model prefix", () => {
- const selected = resolveCursorModel({
- model: "cursor:claude-sonnet-4-6-fast",
- metadata: { cursor_mode: "plan" },
- });
-
- expect(selected.mode).toBe("AGENT_MODE_PLAN");
- expect(selected.requestedModel).toEqual({
- modelId: "claude-sonnet-4-6",
- parameters: [{ id: "fast", value: "true" }],
- });
-
- expect(resolveCursorModel({
- model: "cursor:composer-2.5",
- metadata: undefined,
- }).requestedModel).toEqual({
- modelId: "composer-2.5",
- parameters: [{ id: "fast", value: "false" }],
- });
- });
-
- it("preserves exact Cursor catalog ids", () => {
- const selected = resolveCursorModel({
- model: "cursor:gpt-5.5-high-fast",
- metadata: undefined,
- });
-
- expect(selected.mode).toBe("AGENT_MODE_AGENT");
- expect(selected.requestedModel).toEqual({ modelId: "gpt-5.5-high-fast" });
- });
-
- it("maps Claude effort onto Cursor catalog effort variants", () => {
- expect(resolveCursorModel({
- model: "cursor:gpt-5.5",
- metadata: undefined,
- output_config: { effort: "low" },
- }).requestedModel).toEqual({ modelId: "gpt-5.5-low" });
- expect(resolveCursorModel({
- model: "cursor:gpt-5.5",
- metadata: undefined,
- output_config: { effort: "medium" },
- }).requestedModel).toEqual({ modelId: "gpt-5.5-medium" });
- expect(resolveCursorModel({
- model: "cursor:gpt-5.5",
- metadata: undefined,
- output_config: { effort: "high" },
- }).requestedModel).toEqual({ modelId: "gpt-5.5-high" });
- expect(resolveCursorModel({
- model: "cursor:gpt-5.5",
- metadata: undefined,
- output_config: { effort: "max" },
- }).requestedModel).toEqual({ modelId: "gpt-5.5-extra-high" });
- });
-
- it("preserves fast mode when applying Cursor effort variants", () => {
- expect(resolveCursorModel({
- model: "cursor:gpt-5.5-fast",
- metadata: undefined,
- output_config: { effort: "high" },
- }).requestedModel).toEqual({ modelId: "gpt-5.5-high-fast" });
- });
-
- it("maps max effort to Cursor xhigh when max is unavailable", () => {
- expect(resolveCursorModel({
- model: "cursor:gpt-5.2",
- metadata: undefined,
- output_config: { effort: "max" },
- }).requestedModel).toEqual({ modelId: "gpt-5.2-xhigh" });
- });
-
- it("applies effort independently of Cursor mode prefixes", () => {
- expect(resolveCursorModel({
- model: "cursor-plan:claude-opus-4-8",
- metadata: undefined,
- output_config: { effort: "max" },
- })).toEqual({
- mode: "AGENT_MODE_PLAN",
- requestedModel: { modelId: "claude-opus-4-8-max" },
- });
- expect(resolveCursorModel({
- model: "cursor-ask:claude-opus-4-8-thinking",
- metadata: undefined,
- output_config: { effort: "high" },
- })).toEqual({
- mode: "AGENT_MODE_ASK",
- requestedModel: { modelId: "claude-opus-4-8-thinking-high" },
- });
- });
-
- it("does not override explicit Cursor effort ids or models without effort variants", () => {
- expect(resolveCursorModel({
- model: "cursor:gpt-5.5-low",
- metadata: undefined,
- output_config: { effort: "max" },
- }).requestedModel).toEqual({ modelId: "gpt-5.5-low" });
- expect(resolveCursorModel({
- model: "cursor:gemini-3.1-pro",
- metadata: undefined,
- output_config: { effort: "high" },
- }).requestedModel).toEqual({ modelId: "gemini-3.1-pro" });
- });
-
- it("supports prefixed plan and ask variants for catalog ids", () => {
- expect(resolveCursorModel({ model: "cursor-plan:gpt-5.5-high", metadata: undefined })).toEqual({
- mode: "AGENT_MODE_PLAN",
- requestedModel: { modelId: "gpt-5.5-high" },
- });
- expect(resolveCursorModel({ model: "cursor-ask:claude-opus-4-8-thinking-high", metadata: undefined })).toEqual({
- mode: "AGENT_MODE_ASK",
- requestedModel: { modelId: "claude-opus-4-8-thinking-high" },
- });
- });
-
- it("advertises current Cursor Agent models with unambiguous prefixes", () => {
- expect(CURSOR_AGENT_MODEL_IDS.length).toBeGreaterThan(100);
- expect(CURSOR_SUPPORTED_MODELS.has("cursor:gpt-5.5-high")).toBe(true);
- expect(CURSOR_SUPPORTED_MODELS.has("cursor-plan:gpt-5.5-high")).toBe(true);
- expect(CURSOR_SUPPORTED_MODELS.has("cursor-ask:gpt-5.5-high")).toBe(true);
- expect(isCursorModel("cursor:kimi-k2.5")).toBe(true);
- expect(isCursorModel("gpt-5.2")).toBe(false);
- });
-});
diff --git a/reference/typescript/src/providers/cursor/translate/model.ts b/reference/typescript/src/providers/cursor/translate/model.ts
deleted file mode 100644
index 968cd27..0000000
--- a/reference/typescript/src/providers/cursor/translate/model.ts
+++ /dev/null
@@ -1,163 +0,0 @@
-import type { CursorAgentMode, CursorModelRequest } from "../client.ts";
-import type { AnthropicRequest } from "../../../anthropic/schema.ts";
-import { CURSOR_AGENT_MODEL_IDS, CURSOR_AGENT_MODEL_ID_SET } from "./catalog.ts";
-
-export interface CursorModelSelection {
- requestedModel: CursorModelRequest;
- mode: CursorAgentMode;
-}
-
-type AnthropicEffort = NonNullable<AnthropicRequest["output_config"]>["effort"];
-
-const COMPOSER_2_5_MODEL: CursorModelRequest = {
- modelId: "composer-2.5",
- parameters: [{ id: "fast", value: "false" }],
-};
-
-const LEGACY_CURSOR_MODELS = [
- "cursor",
- "cursor-agent",
- "cursor-composer",
- "cursor-composer-fast",
- "cursor-plan",
- "cursor-ask",
- "composer-2.5",
- "composer-2.5-fast",
-] as const;
-
-export const CURSOR_SUPPORTED_MODELS = new Set<string>([
- ...LEGACY_CURSOR_MODELS,
- ...CURSOR_AGENT_MODEL_IDS.map((id) => `cursor:${id}`),
- ...CURSOR_AGENT_MODEL_IDS.map((id) => `cursor-plan:${id}`),
- ...CURSOR_AGENT_MODEL_IDS.map((id) => `cursor-ask:${id}`),
-]);
-
-const CURSOR_MODEL_PREFIXES = [
- { prefix: "cursor-plan:", mode: "AGENT_MODE_PLAN" as const },
- { prefix: "cursor-ask:", mode: "AGENT_MODE_ASK" as const },
- { prefix: "cursor-agent:", mode: "AGENT_MODE_AGENT" as const },
- { prefix: "cursor:", mode: undefined },
-];
-
-export function isCursorModel(model: string): boolean {
- return CURSOR_SUPPORTED_MODELS.has(model) || CURSOR_MODEL_PREFIXES.some((p) => model.startsWith(p.prefix));
-}
-
-export function resolveCursorModel(req: Pick<AnthropicRequest, "model" | "metadata" | "output_config">): CursorModelSelection {
- let mode = modeFromMetadata(req.metadata);
- const effort = req.output_config?.effort;
- const prefixed = splitCursorModelPrefix(req.model);
- if (prefixed) {
- return {
- requestedModel: parseRawCursorModel(applyCursorEffort(prefixed.raw, effort)),
- mode: prefixed.mode ?? mode ?? "AGENT_MODE_AGENT",
- };
- }
-
- if (req.model === "cursor-plan") mode = "AGENT_MODE_PLAN";
- else if (req.model === "cursor-ask") mode = "AGENT_MODE_ASK";
- else mode ??= "AGENT_MODE_AGENT";
-
- switch (req.model) {
- case "cursor":
- case "cursor-agent":
- case "cursor-plan":
- case "cursor-ask":
- return { requestedModel: { modelId: "default" }, mode };
- case "cursor-composer":
- case "composer-2.5":
- return { requestedModel: COMPOSER_2_5_MODEL, mode };
- case "cursor-composer-fast":
- case "composer-2.5-fast":
- return {
- requestedModel: { modelId: "composer-2.5", parameters: [{ id: "fast", value: "true" }] },
- mode,
- };
- default:
- return { requestedModel: { modelId: req.model }, mode };
- }
-}
-
-function parseRawCursorModel(raw: string): CursorModelRequest {
- if (raw === "composer-2.5") return COMPOSER_2_5_MODEL;
- if (CURSOR_AGENT_MODEL_ID_SET.has(raw)) return { modelId: raw };
- if (raw.endsWith("-fast")) {
- return {
- modelId: raw.slice(0, -"-fast".length),
- parameters: [{ id: "fast", value: "true" }],
- };
- }
- return { modelId: raw };
-}
-
-const EFFORT_SUFFIXES = [
- "extra-high",
- "medium",
- "xhigh",
- "high",
- "low",
- "max",
- "none",
-] as const;
-
-function applyCursorEffort(raw: string, effort: AnthropicEffort | undefined): string {
- if (!effort) return raw;
- const { modelId, fast } = splitFastSuffix(raw);
- if (hasEffortSuffix(modelId)) return raw;
-
- const targetBase = findCursorEffortVariant(modelId, effort);
- if (!targetBase) return raw;
- if (!fast) return targetBase;
-
- const fastTarget = `${targetBase}-fast`;
- return CURSOR_AGENT_MODEL_ID_SET.has(fastTarget) ? fastTarget : `${targetBase}-fast`;
-}
-
-function findCursorEffortVariant(modelId: string, effort: AnthropicEffort): string | undefined {
- for (const suffix of cursorEffortSuffixCandidates(effort)) {
- const candidate = `${modelId}-${suffix}`;
- if (CURSOR_AGENT_MODEL_ID_SET.has(candidate)) return candidate;
- }
- return undefined;
-}
-
-function cursorEffortSuffixCandidates(effort: AnthropicEffort): readonly string[] {
- switch (effort) {
- case "low":
- return ["low"];
- case "medium":
- return ["medium"];
- case "high":
- return ["high", "extra-high", "xhigh"];
- case "max":
- return ["max", "xhigh", "extra-high", "high"];
- default:
- return [];
- }
-}
-
-function hasEffortSuffix(modelId: string): boolean {
- return EFFORT_SUFFIXES.some((suffix) => modelId.endsWith(`-${suffix}`));
-}
-
-function splitFastSuffix(raw: string): { modelId: string; fast: boolean } {
- return raw.endsWith("-fast")
- ? { modelId: raw.slice(0, -"-fast".length), fast: true }
- : { modelId: raw, fast: false };
-}
-
-function splitCursorModelPrefix(model: string): { raw: string; mode?: CursorAgentMode } | undefined {
- for (const p of CURSOR_MODEL_PREFIXES) {
- if (model.startsWith(p.prefix)) return { raw: model.slice(p.prefix.length), mode: p.mode };
- }
- return undefined;
-}
-
-function modeFromMetadata(metadata: unknown): CursorAgentMode | undefined {
- if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) return undefined;
- const value = (metadata as Record<string, unknown>).cursor_mode ?? (metadata as Record<string, unknown>).cursorMode;
- if (value === "plan" || value === "AGENT_MODE_PLAN") return "AGENT_MODE_PLAN";
- if (value === "ask" || value === "AGENT_MODE_ASK") return "AGENT_MODE_ASK";
- if (value === "agent" || value === "AGENT_MODE_AGENT") return "AGENT_MODE_AGENT";
- return undefined;
-}
diff --git a/reference/typescript/src/providers/cursor/translate/request.test.ts b/reference/typescript/src/providers/cursor/translate/request.test.ts
deleted file mode 100644
index 8615299..0000000
--- a/reference/typescript/src/providers/cursor/translate/request.test.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { cursorSelectedImages, renderCursorPrompt } from "./request.ts";
-import type { AnthropicRequest } from "../../../anthropic/schema.ts";
-
-describe("Cursor prompt rendering", () => {
- it("renders system, messages, tools, and tool results deterministically", () => {
- const req: AnthropicRequest = {
- model: "cursor",
- system: "Follow instructions.",
- messages: [
- { role: "user", content: "Question" },
- {
- role: "assistant",
- content: [
- { type: "text", text: "Calling tool" },
- { type: "tool_use", id: "toolu_1", name: "Read", input: { file: "package.json" } },
- ],
- },
- {
- role: "user",
- content: [
- {
- type: "tool_result",
- tool_use_id: "toolu_1",
- content: [{ type: "text", text: "package content" }],
- },
- ],
- },
- ],
- tools: [{ name: "Read", input_schema: { type: "object" } }],
- };
-
- const prompt = renderCursorPrompt(req);
-
- expect(prompt).toContain("<system>\nFollow instructions.\n</system>");
- expect(prompt).toContain("<user>\nQuestion\n</user>");
- expect(prompt).toContain('<tool_use id="toolu_1" name="Read">');
- expect(prompt).toContain('<tool_result tool_use_id="toolu_1">');
- expect(prompt).toContain('"name":"Read"');
- });
-
- it("extracts base64 image blocks for Cursor selected context", () => {
- const req: AnthropicRequest = {
- model: "cursor",
- messages: [
- {
- role: "user",
- content: [
- { type: "text", text: "Describe this" },
- { type: "image", source: { type: "base64", media_type: "image/png", data: "aGVsbG8=" } },
- { type: "image", source: { type: "url", url: "https://example.invalid/image.png" } },
- ],
- },
- ],
- };
-
- const images = cursorSelectedImages(req);
-
- expect(images).toHaveLength(1);
- expect(images[0]?.data).toBe("aGVsbG8=");
- expect(images[0]?.mimeType).toBe("image/png");
- expect(images[0]?.path).toBe("claude-image-1.png");
- expect(typeof images[0]?.uuid).toBe("string");
- });
-});
diff --git a/reference/typescript/src/providers/cursor/translate/request.ts b/reference/typescript/src/providers/cursor/translate/request.ts
deleted file mode 100644
index d29c27e..0000000
--- a/reference/typescript/src/providers/cursor/translate/request.ts
+++ /dev/null
@@ -1,161 +0,0 @@
-import type {
- AnthropicContentBlock,
- AnthropicImageBlock,
- AnthropicMessage,
- AnthropicRequest,
- AnthropicTextBlock,
- AnthropicToolResultContentBlock,
-} from "../../../anthropic/schema.ts";
-
-export interface CursorSelectedImage {
- data: string;
- uuid: string;
- path: string;
- mimeType: string;
-}
-
-export function renderCursorPrompt(req: AnthropicRequest): string {
- const sections: string[] = [];
- const system = renderSystem(req.system);
- if (system) sections.push(`<system>\n${system}\n</system>`);
-
- for (const message of req.messages) {
- const content = renderContent(message);
- if (content) sections.push(`<${message.role}>\n${content}\n</${message.role}>`);
- }
-
- if (req.tools?.length) {
- sections.push(
- `<tools>\n${req.tools
- .map((tool) =>
- JSON.stringify({
- name: tool.name,
- description: "description" in tool ? tool.description : undefined,
- input_schema: "input_schema" in tool ? tool.input_schema : {},
- }),
- )
- .join("\n")}\n</tools>`,
- );
- }
-
- return sections.join("\n\n");
-}
-
-export function cursorSelectedImages(req: AnthropicRequest): CursorSelectedImage[] {
- const images: CursorSelectedImage[] = [];
- let index = 0;
- for (const message of req.messages) {
- for (const block of messageBlocks(message)) {
- collectImageBlocks(block, (image) => {
- if (image.source.type !== "base64") return;
- const uuid = crypto.randomUUID();
- const extension = imageExtension(image.source.media_type);
- images.push({
- data: image.source.data,
- uuid,
- path: `claude-image-${++index}.${extension}`,
- mimeType: image.source.media_type,
- });
- });
- }
- }
- return images;
-}
-
-function renderSystem(system: AnthropicRequest["system"]): string | undefined {
- if (!system) return undefined;
- const blocks: AnthropicTextBlock[] =
- typeof system === "string" ? [{ type: "text", text: system }] : system;
- const text = blocks
- .filter((block) => block.type === "text" && typeof block.text === "string")
- .map((block) => block.text)
- .filter((line) => !line.startsWith("x-anthropic-billing-header:"))
- .join("\n\n");
- return text || undefined;
-}
-
-function renderContent(message: AnthropicMessage): string {
- return messageBlocks(message).map(renderBlock).filter(Boolean).join("\n\n");
-}
-
-function renderBlock(block: AnthropicContentBlock): string {
- switch (block.type) {
- case "text":
- return block.text;
- case "thinking":
- return `<thinking>\n${block.thinking}\n</thinking>`;
- case "image":
- if (block.source.type === "url") return `[image: ${block.source.url}]`;
- return `[image: ${block.source.media_type}, ${block.source.data.length} base64 chars]`;
- case "tool_use":
- return `<tool_use id="${block.id}" name="${block.name}">\n${JSON.stringify(block.input ?? {})}\n</tool_use>`;
- case "tool_result":
- return `<tool_result tool_use_id="${block.tool_use_id}"${block.is_error ? ' is_error="true"' : ""}>\n${renderToolResult(block.content)}\n</tool_result>`;
- case "server_tool_use":
- return `<server_tool_use id="${block.id}" name="${block.name}">\n${JSON.stringify(block.input ?? {})}\n</server_tool_use>`;
- case "web_search_tool_result":
- return `<web_search_tool_result tool_use_id="${block.tool_use_id}">\n${JSON.stringify(block.content)}\n</web_search_tool_result>`;
- }
-}
-
-function renderToolResult(content: AnthropicToolResultContentBlock[] | string): string {
- if (typeof content === "string") return content;
- return content.map(renderToolResultBlock).filter(Boolean).join("\n\n");
-}
-
-function renderToolResultBlock(block: AnthropicToolResultContentBlock): string {
- if (
- block.type === "text" ||
- block.type === "image" ||
- block.type === "tool_use" ||
- block.type === "tool_result" ||
- block.type === "thinking"
- ) {
- return renderBlock(block as AnthropicContentBlock);
- }
- const type = typeof block.type === "string" ? block.type : "unknown";
- return `[unsupported tool result block: ${type}]`;
-}
-
-function messageBlocks(message: AnthropicMessage): AnthropicContentBlock[] {
- return typeof message.content === "string"
- ? [{ type: "text", text: message.content }]
- : message.content;
-}
-
-function collectImageBlocks(
- block: AnthropicContentBlock,
- visit: (block: AnthropicImageBlock) => void,
-): void {
- if (block.type === "image") {
- visit(block);
- return;
- }
- if (block.type !== "tool_result" || typeof block.content === "string") return;
- for (const child of block.content) {
- if (
- child.type === "text" ||
- child.type === "image" ||
- child.type === "tool_use" ||
- child.type === "tool_result" ||
- child.type === "thinking"
- ) {
- collectImageBlocks(child as AnthropicContentBlock, visit);
- }
- }
-}
-
-function imageExtension(mediaType: string): string {
- switch (mediaType) {
- case "image/jpeg":
- return "jpg";
- case "image/png":
- return "png";
- case "image/gif":
- return "gif";
- case "image/webp":
- return "webp";
- default:
- return "img";
- }
-}
diff --git a/reference/typescript/src/providers/cursor/translate/response.test.ts b/reference/typescript/src/providers/cursor/translate/response.test.ts
deleted file mode 100644
index 9f0c390..0000000
--- a/reference/typescript/src/providers/cursor/translate/response.test.ts
+++ /dev/null
@@ -1,397 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { gzipSync } from "node:zlib";
-import { decodeCursorStream, encodeConnectFrame } from "../client.ts";
-import type { CursorStreamEvent } from "../client.ts";
-import {
- collectCursorSse,
- fakeProto,
- frame,
- jsonBytes,
- resourceExhaustedNetworkFrame,
- streamFromChunks,
-} from "../cursor-test-helpers.ts";
-import {
- accumulateCursorResponse,
- cursorUsageToAnthropic,
- translateCursorStream,
-} from "./response.ts";
-import { createLogger } from "../../../log.ts";
-
-/** Wraps decodeCursorStream with cancellation tracking. */
-async function collectDecodedCursorEvents(
- ...chunks: Uint8Array[]
-): Promise<{ events: CursorStreamEvent[]; cancelled: boolean }> {
- let cancelled = false;
- const stream = new ReadableStream<Uint8Array>({
- start(controller) {
- for (const chunk of chunks) controller.enqueue(chunk);
- },
- cancel() {
- cancelled = true;
- },
- });
-
- const events: CursorStreamEvent[] = [];
- for await (const event of decodeCursorStream(stream, fakeProto)) events.push(event);
- return { events, cancelled };
-}
-
-async function translateCursorSse(
- frames: Uint8Array[],
- messageId: string,
- allowedToolNames?: ReadonlySet<string>,
- inputTokens?: number,
-): Promise<Array<{ event: string; data: any }>> {
- const downstream = translateCursorStream(
- streamFromChunks(frames),
- {
- messageId,
- model: "cursor-plan",
- log: createLogger("cursor.response.test"),
- proto: fakeProto,
- allowedToolNames,
- inputTokens,
- },
- );
- return collectCursorSse(downstream);
-}
-
-describe("Cursor response translation", () => {
- it("does not expose Cursor aggregate cache counters as Anthropic context cache", () => {
- expect(
- cursorUsageToAnthropic({
- inputTokens: "100",
- outputTokens: "7",
- cacheReadTokens: "4490752",
- cacheWriteTokens: "3000",
- }),
- ).toEqual({
- input_tokens: 100,
- output_tokens: 7,
- cache_creation_input_tokens: 0,
- cache_read_input_tokens: 0,
- });
- });
-
- it("uses request-side input estimates instead of Cursor aggregate input counters", () => {
- expect(
- cursorUsageToAnthropic(
- {
- inputTokens: "2116658",
- outputTokens: "5576",
- cacheReadTokens: "1976832",
- cacheWriteTokens: "0",
- },
- { inputTokens: 135246 },
- ),
- ).toEqual({
- input_tokens: 135246,
- output_tokens: 5576,
- cache_creation_input_tokens: 0,
- cache_read_input_tokens: 0,
- });
- });
-
- it("decodes Connect-framed Cursor messages including gzip and end frames", async () => {
- const stream = streamFromChunks([
- frame({ interactionUpdate: { textDelta: { text: "hi" } } }),
- encodeConnectFrame(gzipSync(jsonBytes({ interactionUpdate: { textDelta: { text: "!" } } })), 1),
- encodeConnectFrame(jsonBytes({}), 2),
- ]);
-
- const events = [];
- for await (const event of decodeCursorStream(stream, fakeProto)) events.push(event);
-
- expect(events).toEqual([
- { type: "text_delta", text: "hi" },
- { type: "text_delta", text: "!" },
- { type: "end" },
- ]);
- });
-
- it("terminates on Connect end even if the HTTP/2 stream stays open", async () => {
- const { events, cancelled } = await collectDecodedCursorEvents(
- frame({ interactionUpdate: { textDelta: { text: "hi" } } }),
- encodeConnectFrame(jsonBytes({}), 2),
- );
-
- expect(events).toEqual([{ type: "text_delta", text: "hi" }, { type: "end" }]);
- expect(cancelled).toBe(true);
- });
-
- it("throws on Cursor Connect end errors", async () => {
- const stream = streamFromChunks([
- encodeConnectFrame(
- gzipSync(
- jsonBytes({
- error: {
- code: "resource_exhausted",
- message: "Error",
- details: [
- {
- debug: {
- details: {
- title: "You've hit your usage limit",
- additionalInfo: {
- chatMessage: "You've hit your free requests limit.",
- },
- },
- },
- },
- ],
- },
- }),
- ),
- 3,
- ),
- ]);
-
- let err: unknown;
- try {
- for await (const _event of decodeCursorStream(stream, fakeProto)) {
- // Drain.
- }
- } catch (caught) {
- err = caught;
- }
-
- expect(String(err)).toContain("resource_exhausted");
- expect(String(err)).toContain("free requests limit");
- });
-
- it("terminates on turnEnded even if the HTTP/2 stream stays open", async () => {
- const { events, cancelled } = await collectDecodedCursorEvents(
- frame({ interactionUpdate: { textDelta: { text: "hi" } } }),
- frame({ interactionUpdate: { turnEnded: { inputTokens: "4", outputTokens: "1" } } }),
- );
-
- expect(events).toEqual([
- { type: "text_delta", text: "hi" },
- {
- type: "usage",
- usage: {
- inputTokens: "4",
- outputTokens: "1",
- cacheReadTokens: "0",
- cacheWriteTokens: "0",
- },
- },
- { type: "end" },
- ]);
- expect(cancelled).toBe(true);
- });
-
- it("terminates after output goes idle without a Cursor terminator", async () => {
- let cancelled = false;
- const stream = new ReadableStream<Uint8Array>({
- start(controller) {
- controller.enqueue(frame({ interactionUpdate: { textDelta: { text: "hi" } } }));
- },
- cancel() {
- cancelled = true;
- },
- });
-
- const events = [];
- for await (const event of decodeCursorStream(stream, fakeProto, { outputIdleTimeoutMs: 1 })) {
- events.push(event);
- }
-
- expect(events).toEqual([{ type: "text_delta", text: "hi" }, { type: "end" }]);
- expect(cancelled).toBe(true);
- });
-
- it("accumulates non-streaming thinking, text, usage, and session id", async () => {
- let observedSession: string | undefined;
- const result = await accumulateCursorResponse(
- streamFromChunks([
- frame({ execServerMessage: { requestContextArgs: { notesSessionId: "cursor-session" } } }),
- frame({ interactionUpdate: { thinkingDelta: { text: "think" } } }),
- frame({ interactionUpdate: { textDelta: { text: "hello" } } }),
- frame({ interactionUpdate: { turnEnded: { inputTokens: "10", outputTokens: "2" } } }),
- encodeConnectFrame(jsonBytes({}), 2),
- ]),
- {
- messageId: "msg_1",
- model: "cursor-plan",
- log: createLogger("cursor.response.test"),
- proto: fakeProto,
- onSession: (session) => {
- observedSession = session;
- },
- },
- );
-
- expect(observedSession).toBe("cursor-session");
- expect(result.response.content).toEqual([
- { type: "thinking", thinking: "think", signature: "" },
- { type: "text", text: "hello" },
- ]);
- expect(result.response.usage.output_tokens).toBe(2);
- });
-
- it("emits valid Anthropic SSE for thinking and text deltas", async () => {
- const events = await translateCursorSse(
- [
- frame({ interactionUpdate: { thinkingDelta: { text: "plan" } } }),
- frame({ interactionUpdate: { textDelta: { text: "done" } } }),
- frame({ interactionUpdate: { turnEnded: { inputTokens: "8", outputTokens: "3" } } }),
- encodeConnectFrame(jsonBytes({}), 2),
- ],
- "msg_2",
- );
-
- expect(events.map((event) => event.event)).toEqual([
- "message_start",
- "ping",
- "content_block_start",
- "content_block_delta",
- "content_block_stop",
- "content_block_start",
- "content_block_delta",
- "content_block_stop",
- "message_delta",
- "message_stop",
- ]);
- expect(events[2]?.data.content_block.type).toBe("thinking");
- expect(events[3]?.data.delta).toEqual({ type: "thinking_delta", thinking: "plan" });
- expect(events[6]?.data.delta).toEqual({ type: "text_delta", text: "done" });
- expect(events[8]?.data.usage.output_tokens).toBe(3);
- });
-
- it("emits estimated input usage at stream start and finish", async () => {
- const events = await translateCursorSse(
- [
- frame({ interactionUpdate: { textDelta: { text: "done" } } }),
- frame({
- interactionUpdate: {
- turnEnded: {
- inputTokens: "2116658",
- outputTokens: "5576",
- cacheReadTokens: "1976832",
- },
- },
- }),
- encodeConnectFrame(jsonBytes({}), 2),
- ],
- "msg_estimated_usage",
- undefined,
- 135246,
- );
-
- expect(events[0]?.data.message.usage).toMatchObject({
- input_tokens: 135246,
- output_tokens: 0,
- cache_creation_input_tokens: 0,
- cache_read_input_tokens: 0,
- });
- expect(events.find((event) => event.event === "message_delta")?.data.usage).toEqual({
- input_tokens: 135246,
- output_tokens: 5576,
- cache_creation_input_tokens: 0,
- cache_read_input_tokens: 0,
- });
- });
-
- it("recovers XML tool_use text deltas as Anthropic tool calls", async () => {
- const events = await translateCursorSse(
- [
- frame({ interactionUpdate: { textDelta: { text: "Continuing validation.\n\n<tool_" } } }),
- frame({
- interactionUpdate: {
- textDelta: {
- text:
- "use id=\"old_history_id\" name=\"Bash\">\n{\"command\":\"git diff --check\",\"description\":\"Check diff\"}\n</tool_use>\n</tool_use>",
- },
- },
- }),
- frame({ interactionUpdate: { turnEnded: { inputTokens: "8", outputTokens: "3" } } }),
- encodeConnectFrame(jsonBytes({}), 2),
- ],
- "msg_xml_tool",
- new Set(["Bash"]),
- );
-
- const textDeltas = events
- .filter((event) => event.event === "content_block_delta" && event.data.delta?.type === "text_delta")
- .map((event) => event.data.delta.text)
- .join("");
- const toolStart = events.find((event) =>
- event.event === "content_block_start" && event.data.content_block?.type === "tool_use"
- );
- const inputDelta = events.find((event) =>
- event.event === "content_block_delta" && event.data.delta?.type === "input_json_delta"
- );
- const stopReason = events.find((event) => event.event === "message_delta")?.data.delta.stop_reason;
-
- expect(textDeltas).toBe("Continuing validation.\n\n");
- expect(textDeltas).not.toContain("<tool_use");
- expect(toolStart?.data.content_block.name).toBe("Bash");
- expect(toolStart?.data.content_block.id).toStartWith("call_cursor_");
- expect(toolStart?.data.content_block.id).not.toBe("old_history_id");
- expect(JSON.parse(inputDelta?.data.delta.partial_json)).toEqual({
- command: "git diff --check",
- description: "Check diff",
- });
- expect(stopReason).toBe("tool_use");
- });
-
- it("emits an Anthropic SSE error for Cursor Connect end errors", async () => {
- const events = await translateCursorSse(
- [
- encodeConnectFrame(
- jsonBytes({
- error: {
- code: "resource_exhausted",
- message: "Error",
- details: [
- {
- debug: {
- details: {
- additionalInfo: {
- chatMessage: "You've hit your free requests limit.",
- },
- },
- },
- },
- ],
- },
- }),
- 2,
- ),
- ],
- "msg_error",
- );
-
- expect(events.map((event) => event.event)).toEqual(["message_start", "ping", "error"]);
- expect(events[2]?.data.error.message).toContain("resource_exhausted");
- expect(events[2]?.data.error.message).toContain("free requests limit");
- });
-
- it("retries Cursor resource_exhausted network errors before downstream output starts", async () => {
- let retryCalls = 0;
- const downstream = translateCursorStream(
- streamFromChunks([resourceExhaustedNetworkFrame()]),
- {
- messageId: "msg_retry",
- model: "cursor-plan",
- log: createLogger("cursor.response.test"),
- proto: fakeProto,
- retryUpstream: async () => {
- retryCalls++;
- return streamFromChunks([
- frame({ interactionUpdate: { textDelta: { text: "recovered" } } }),
- frame({ interactionUpdate: { turnEnded: { inputTokens: "4", outputTokens: "1" } } }),
- ]);
- },
- computeRetryDelay: () => ({ waitMs: 0, exceedsBudget: false }),
- },
- );
- const events = await collectCursorSse(downstream);
-
- expect(retryCalls).toBe(1);
- expect(events.map((event) => event.event)).toContain("message_stop");
- expect(events.some((event) => event.event === "error")).toBe(false);
- expect(events.some((event) => event.data.delta?.text === "recovered")).toBe(true);
- });
-});
diff --git a/reference/typescript/src/providers/cursor/translate/response.ts b/reference/typescript/src/providers/cursor/translate/response.ts
deleted file mode 100644
index 4e8516b..0000000
--- a/reference/typescript/src/providers/cursor/translate/response.ts
+++ /dev/null
@@ -1,320 +0,0 @@
-import { encodeSseEvent } from "../../../sse.ts";
-import type { Logger } from "../../../log.ts";
-import { computeBackoffDelay, MAX_RATE_LIMIT_RETRIES, sleep, type BackoffOutcome } from "../../retry.ts";
-import type { TrafficCapture } from "../../types.ts";
-import {
- decodeCursorStream,
- isRetryableCursorNetworkResourceError,
- type CursorStreamEvent,
- type CursorUsage,
-} from "../client.ts";
-import type { CursorProto } from "../proto-loader.ts";
-import { createCursorSseFramer } from "../sse-framing.ts";
-import {
- CursorToolUseXmlParser,
- type RecoveredCursorTextEvent,
- type RecoveredCursorToolUse,
-} from "../tool-use-xml.ts";
-
-export interface AnthropicCursorResponse {
- id: string;
- type: "message";
- role: "assistant";
- model: string;
- content: Array<
- | { type: "thinking"; thinking: string; signature: string }
- | { type: "text"; text: string }
- | { type: "tool_use"; id: string; name: string; input: Record<string, unknown> }
- >;
- stop_reason: "end_turn" | "tool_use" | null;
- stop_sequence: null;
- usage: AnthropicUsage;
-}
-
-export interface AnthropicUsage {
- input_tokens: number;
- output_tokens: number;
- cache_creation_input_tokens: number;
- cache_read_input_tokens: number;
-}
-
-export function cursorUsageToAnthropic(
- usage?: CursorUsage,
- opts: { inputTokens?: number } = {},
-): AnthropicUsage {
- const input = opts.inputTokens ?? toNumber(usage?.inputTokens);
- const output = toNumber(usage?.outputTokens);
- // Cursor's turnEnded token counters are aggregate agent-run/billing counters,
- // not Anthropic-style current prompt-window counters. Claude Code uses these
- // fields for active context/autocompact, so prefer our request-side input
- // estimate and suppress Cursor cache counters.
- return {
- input_tokens: input,
- output_tokens: output,
- cache_creation_input_tokens: 0,
- cache_read_input_tokens: 0,
- };
-}
-
-export async function accumulateCursorResponse(
- upstream: ReadableStream<Uint8Array>,
- opts: {
- messageId: string;
- model: string;
- log: Logger;
- traffic?: TrafficCapture;
- proto?: CursorProto;
- onSession?: (sessionId: string) => void;
- allowedToolNames?: ReadonlySet<string>;
- inputTokens?: number;
- },
-): Promise<{ response: AnthropicCursorResponse; cursorSessionId?: string }> {
- let thinking = "";
- let usage: CursorUsage | undefined;
- let cursorSessionId: string | undefined;
- const content: AnthropicCursorResponse["content"] = [];
- const toolUseXml = new CursorToolUseXmlParser({ allowedToolNames: opts.allowedToolNames });
-
- const flushThinking = () => {
- if (!thinking) return;
- content.push({ type: "thinking", thinking, signature: "" });
- thinking = "";
- };
-
- const appendText = (text: string) => {
- if (!text) return;
- const previous = content.at(-1);
- if (previous?.type === "text") {
- previous.text += text;
- } else {
- content.push({ type: "text", text });
- }
- };
-
- const applyRecoveredEvent = (event: RecoveredCursorTextEvent) => {
- flushThinking();
- if (event.type === "text") {
- appendText(event.text);
- return;
- }
- content.push({
- type: "tool_use",
- id: event.id,
- name: event.name,
- input: event.input,
- });
- opts.traffic?.writeJsonEvent("041-cursor-xml-tool-use", {
- id: event.id,
- originalId: event.originalId,
- name: event.name,
- inputChars: JSON.stringify(event.input).length,
- });
- };
-
- for await (const event of decodeCursorStream(upstream, opts.proto, { traffic: opts.traffic, log: opts.log })) {
- opts.traffic?.writeJsonEvent("040-cursor-event", event);
- switch (event.type) {
- case "session":
- cursorSessionId = event.sessionId;
- opts.onSession?.(event.sessionId);
- break;
- case "thinking_delta":
- thinking += event.text;
- break;
- case "text_delta":
- for (const recovered of toolUseXml.push(event.text)) applyRecoveredEvent(recovered);
- break;
- case "usage":
- usage = event.usage;
- break;
- case "end":
- break;
- }
- }
- for (const recovered of toolUseXml.flush()) applyRecoveredEvent(recovered);
- flushThinking();
-
- opts.log.debug("cursor accumulate finish", {
- contentBlocks: content.length,
- sawRecoveredToolUse: toolUseXml.sawToolUse,
- cursorSessionId,
- usage,
- });
-
- return {
- cursorSessionId,
- response: {
- id: opts.messageId,
- type: "message",
- role: "assistant",
- model: opts.model,
- content,
- stop_reason: toolUseXml.sawToolUse ? "tool_use" : "end_turn",
- stop_sequence: null,
- usage: cursorUsageToAnthropic(usage, { inputTokens: opts.inputTokens }),
- },
- };
-}
-
-export function translateCursorStream(
- upstream: ReadableStream<Uint8Array>,
- opts: {
- messageId: string;
- model: string;
- log: Logger;
- signal?: AbortSignal;
- traffic?: TrafficCapture;
- proto?: CursorProto;
- onSession?: (sessionId: string) => void;
- allowedToolNames?: ReadonlySet<string>;
- inputTokens?: number;
- retryUpstream?: () => Promise<ReadableStream<Uint8Array>>;
- computeRetryDelay?: (attempt: number) => BackoffOutcome;
- maxRetryableStreamRetries?: number;
- },
-): ReadableStream<Uint8Array> {
- const encoder = new TextEncoder();
- return new ReadableStream<Uint8Array>({
- async start(controller) {
- let closed = false;
- let currentUpstream = upstream;
- let downstreamStarted = false;
- let retryAttempt = 0;
-
- const emit = (event: string, data: unknown) => {
- if (closed || opts.signal?.aborted || controller.desiredSize === null) return false;
- opts.traffic?.writeJsonEvent("050-downstream-event", { event, data });
- controller.enqueue(encoder.encode(encodeSseEvent(event, data)));
- downstreamStarted = true;
- return true;
- };
-
- try {
- while (true) {
- const framing = createCursorSseFramer({
- messageId: opts.messageId,
- model: opts.model,
- emit,
- mapUsage: (usage) => cursorUsageToAnthropic(usage, { inputTokens: opts.inputTokens }),
- initialUsage: cursorUsageToAnthropic(undefined, { inputTokens: opts.inputTokens }),
- });
- const toolUseXml = new CursorToolUseXmlParser({ allowedToolNames: opts.allowedToolNames });
-
- const emitRecoveredToolUse = (tool: RecoveredCursorToolUse) => {
- opts.traffic?.writeJsonEvent("041-cursor-xml-tool-use", {
- id: tool.id,
- originalId: tool.originalId,
- name: tool.name,
- inputChars: JSON.stringify(tool.input).length,
- });
- framing.closeOpenBlocks();
- framing.ensureStart();
- const index = framing.nextContentBlockIndex();
- emit("content_block_start", {
- type: "content_block_start",
- index,
- content_block: {
- type: "tool_use",
- id: tool.id,
- name: tool.name,
- input: {},
- },
- });
- emit("content_block_delta", {
- type: "content_block_delta",
- index,
- delta: { type: "input_json_delta", partial_json: JSON.stringify(tool.input) },
- });
- emit("content_block_stop", { type: "content_block_stop", index });
- };
-
- const applyRecoveredEvent = (event: RecoveredCursorTextEvent) => {
- if (event.type === "text") {
- framing.emitTextDelta(event.text);
- return;
- }
- emitRecoveredToolUse(event);
- };
-
- try {
- for await (
- const event of decodeCursorStream(currentUpstream, opts.proto, {
- traffic: opts.traffic,
- log: opts.log,
- })
- ) {
- opts.traffic?.writeJsonEvent("040-cursor-event", event);
- if (opts.signal?.aborted) return;
- switch (event.type) {
- case "session":
- opts.onSession?.(event.sessionId);
- break;
- case "thinking_delta":
- framing.emitThinkingDelta(event.text);
- break;
- case "text_delta":
- for (const recovered of toolUseXml.push(event.text)) applyRecoveredEvent(recovered);
- break;
- case "usage":
- framing.recordUsage(event.usage);
- break;
- case "end":
- break;
- }
- }
- for (const recovered of toolUseXml.flush()) applyRecoveredEvent(recovered);
- framing.emitFinalMessage(toolUseXml.sawToolUse ? "tool_use" : "end_turn");
- return;
- } catch (caught) {
- let err: unknown = caught;
- if (!downstreamStarted && opts.retryUpstream && isRetryableCursorNetworkResourceError(err)) {
- const maxRetries = opts.maxRetryableStreamRetries ?? MAX_RATE_LIMIT_RETRIES;
- if (retryAttempt < maxRetries && !opts.signal?.aborted) {
- const retryDelay = opts.computeRetryDelay ?? computeBackoffDelay;
- const { waitMs, exceedsBudget } = retryDelay(retryAttempt);
- if (exceedsBudget) {
- opts.log.warn("cursor stream retry delay exceeds budget; giving up", {
- maxDelayMs: waitMs,
- err: String(err),
- });
- } else {
- const nextAttempt = retryAttempt + 1;
- opts.log.warn("cursor stream error before downstream output, retrying", {
- attempt: nextAttempt,
- maxRetries,
- waitMs,
- err: String(err),
- });
- retryAttempt = nextAttempt;
- try {
- await sleep(waitMs, opts.signal);
- currentUpstream = await opts.retryUpstream();
- continue;
- } catch (retryErr) {
- err = retryErr;
- }
- }
- }
- }
- opts.log.warn("cursor stream error", { err: String(err) });
- framing.emitError(err);
- return;
- }
- }
- } finally {
- closed = true;
- try {
- controller.close();
- } catch {
- // Consumer cancellation can close the controller first.
- }
- }
- },
- });
-}
-
-function toNumber(value: string | undefined): number {
- if (!value) return 0;
- const parsed = Number(value);
- return Number.isFinite(parsed) ? parsed : 0;
-}
diff --git a/reference/typescript/src/providers/kimi/auth/constants.ts b/reference/typescript/src/providers/kimi/auth/constants.ts
deleted file mode 100644
index aca0178..0000000
--- a/reference/typescript/src/providers/kimi/auth/constants.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import { kimiBaseUrl, kimiOauthHost } from "../../../config.ts";
-
-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();
-}
-export function apiBaseUrl(): string {
- return kimiBaseUrl();
-}
-// Masquerade as kimi-cli so the server accepts us. Bumping this in lockstep
-// with kimi-cli releases may become necessary.
-export const KIMI_CLI_VERSION = "1.37.0";
-export const REFRESH_MARGIN_MS = 5 * 60 * 1000;
diff --git a/reference/typescript/src/providers/kimi/auth/device-id.ts b/reference/typescript/src/providers/kimi/auth/device-id.ts
deleted file mode 100644
index 032d7ee..0000000
--- a/reference/typescript/src/providers/kimi/auth/device-id.ts
+++ /dev/null
@@ -1,30 +0,0 @@
-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();
-}
-function legacyPath(): string {
- 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;
- } catch (err: any) {
- 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 });
- try {
- await chmod(target, 0o600);
- } catch {}
- return id;
-}
diff --git a/reference/typescript/src/providers/kimi/auth/headers.ts b/reference/typescript/src/providers/kimi/auth/headers.ts
deleted file mode 100644
index 2db97ee..0000000
--- a/reference/typescript/src/providers/kimi/auth/headers.ts
+++ /dev/null
@@ -1,31 +0,0 @@
-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();
-}
-
-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;
-}
-
-export async function commonHeaders(): Promise<Record<string, string>> {
- const deviceId = await getDeviceId();
- return {
- "X-Msh-Platform": "kimi_cli",
- "X-Msh-Version": KIMI_CLI_VERSION,
- "X-Msh-Device-Name": asciiOnly(hostname()),
- "X-Msh-Device-Model": asciiOnly(deviceModel()),
- "X-Msh-Os-Version": asciiOnly(release()),
- "X-Msh-Device-Id": deviceId,
- "User-Agent": kimiUserAgent(`KimiCLI/${KIMI_CLI_VERSION}`),
- };
-}
diff --git a/reference/typescript/src/providers/kimi/auth/jwt.ts b/reference/typescript/src/providers/kimi/auth/jwt.ts
deleted file mode 100644
index bf65acc..0000000
--- a/reference/typescript/src/providers/kimi/auth/jwt.ts
+++ /dev/null
@@ -1,23 +0,0 @@
-interface KimiClaims {
- 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;
- 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;
- } catch {
- return undefined;
- }
-}
-
-export function extractUserId(accessToken: string): string | undefined {
- return decodeClaims(accessToken)?.user_id;
-}
diff --git a/reference/typescript/src/providers/kimi/auth/login.ts b/reference/typescript/src/providers/kimi/auth/login.ts
deleted file mode 100644
index 18054c1..0000000
--- a/reference/typescript/src/providers/kimi/auth/login.ts
+++ /dev/null
@@ -1,75 +0,0 @@
-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;
-}
-
-interface DeviceAuth {
- 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;
-
-export async function runDeviceLogin(): Promise<TokenResponse> {
- 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()}`);
- }
- 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`);
-
- while (true) {
- const resp = await fetch(`${oauthHost()}/api/oauth/token`, {
- method: "POST",
- headers: { ...headers, "Content-Type": "application/x-www-form-urlencoded" },
- body: new URLSearchParams({
- client_id: CLIENT_ID,
- device_code: auth.device_code,
- grant_type: GRANT_DEVICE_CODE,
- }).toString(),
- });
-
- if (resp.status === 200) {
- 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}`;
-
- if (error === "expired_token") {
- 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));
- }
-}
diff --git a/reference/typescript/src/providers/kimi/auth/manager.ts b/reference/typescript/src/providers/kimi/auth/manager.ts
deleted file mode 100644
index 811962f..0000000
--- a/reference/typescript/src/providers/kimi/auth/manager.ts
+++ /dev/null
@@ -1,110 +0,0 @@
-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 { createAuthLifecycle, validateTokenResponse } from "../../shared/auth/manager.ts";
-import { createLogger } from "../../../log.ts";
-
-const log = createLogger("kimi.auth");
-
-const RETRYABLE_STATUSES = new Set([429, 500, 502, 503, 504]);
-const MAX_REFRESH_ATTEMPTS = 3;
-
-const lifecycle = createAuthLifecycle<StoredAuth>({
- loadAuth,
- loginRequiredMessage: "Not authenticated. Run: claude-code-proxy kimi auth login",
- forceRefreshUnauthenticatedMessage: "Not authenticated",
- refreshMarginMs: REFRESH_MARGIN_MS,
- refreshNow,
-});
-
-export const getAuth = lifecycle.getAuth;
-export const forceRefresh = lifecycle.forceRefresh;
-export const resetCache = lifecycle.resetCache;
-
-export class KimiAuthUnauthorizedError extends Error {
- constructor(message: string) {
- super(message);
- this.name = "KimiAuthUnauthorizedError";
- }
-}
-
-export async function persistInitialTokens(tokens: TokenResponse): Promise<StoredAuth> {
- validateTokenResponse(tokens);
- const auth = tokensToStored(tokens);
- await saveAuth(auth);
- lifecycle.setCached(auth);
- return auth;
-}
-
-function tokensToStored(tokens: TokenResponse): StoredAuth {
- return {
- access: tokens.access_token,
- refresh: tokens.refresh_token,
- 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");
- }
- const headers = await commonHeaders();
-
- for (let attempt = 0; attempt < MAX_REFRESH_ATTEMPTS; attempt++) {
- let resp: Response;
- try {
- resp = await fetch(`${oauthHost()}/api/oauth/token`, {
- method: "POST",
- headers: { ...headers, "Content-Type": "application/x-www-form-urlencoded" },
- body: new URLSearchParams({
- client_id: CLIENT_ID,
- grant_type: "refresh_token",
- refresh_token: current.refresh,
- }).toString(),
- });
- } catch (err) {
- log.warn("refresh network error", { attempt, err: String(err) });
- await backoff(attempt);
- continue;
- }
-
- if (resp.status === 200) {
- const tokens: unknown = await resp.json();
- validateTokenResponse<TokenResponse>(tokens);
- const next: StoredAuth = {
- ...tokensToStored(tokens),
- refresh: tokens.refresh_token || current.refresh,
- userId: extractUserId(tokens.access_token) || current.userId,
- };
- await saveAuth(next);
- lifecycle.setCached(next);
- return next;
- }
-
- if (resp.status === 401 || resp.status === 403) {
- lifecycle.setCached(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}`);
- }
-
- log.warn("refresh retryable error", { attempt, status: resp.status });
- await backoff(attempt);
- }
- 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));
-}
diff --git a/reference/typescript/src/providers/kimi/auth/token-store.ts b/reference/typescript/src/providers/kimi/auth/token-store.ts
deleted file mode 100644
index 5a41fa0..0000000
--- a/reference/typescript/src/providers/kimi/auth/token-store.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-import { join } from "node:path";
-import { kimiAuthFile, legacyConfigDir } from "../../../paths.ts";
-import { createAuthStore } from "../../shared/auth/token-store.ts";
-
-export interface StoredAuth {
- access: string;
- refresh: string;
- expires: number;
- scope?: string;
- userId?: string;
-}
-
-const store = createAuthStore<StoredAuth>({
- file: kimiAuthFile,
- legacyFile: () => join(legacyConfigDir(), "kimi", "auth.json"),
- keychainService: "claude-code-proxy.kimi",
-});
-
-export const loadAuth = store.loadAuth;
-export const saveAuth = store.saveAuth;
-export const clearAuth = store.clearAuth;
-export const authPath = store.authPath;
diff --git a/reference/typescript/src/providers/kimi/cli.ts b/reference/typescript/src/providers/kimi/cli.ts
deleted file mode 100644
index 6cc17ba..0000000
--- a/reference/typescript/src/providers/kimi/cli.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import type { CliHandlers } from "../types.ts";
-import { runDeviceLogin } from "./auth/login.ts";
-import { persistInitialTokens } from "./auth/manager.ts";
-import { authPath, clearAuth, loadAuth } from "./auth/token-store.ts";
-import { printAuthStatus } from "../shared/cli-status.ts";
-
-export const kimiCli: 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`);
- },
- async status() {
- await printAuthStatus({
- loadAuth,
- authPath,
- formatIdentityLine: (auth) => `User: ${auth.userId ?? "(none)"}`,
- extraLines: (auth) => [`Scope: ${auth.scope ?? "(none)"}`],
- });
- },
- async logout() {
- await clearAuth();
- console.log("Logged out");
- },
-};
diff --git a/reference/typescript/src/providers/kimi/client.ts b/reference/typescript/src/providers/kimi/client.ts
deleted file mode 100644
index 3bf9c2c..0000000
--- a/reference/typescript/src/providers/kimi/client.ts
+++ /dev/null
@@ -1,141 +0,0 @@
-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 { headersToRecord } from "../../traffic.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;
-}
-
-export class KimiError extends Error {
- constructor(
- public status: number,
- message: string,
- public detail?: string,
- public meta?: { retryAfter?: string },
- ) {
- super(message);
- this.name = "KimiError";
- }
-}
-
-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,
- classify: (err) =>
- err instanceof KimiError && err.status === 429
- ? { retryAfter: err.meta?.retryAfter }
- : undefined,
- });
-}
-
-async function attemptPostKimi(
- body: KimiChatRequest,
- ctx: RequestContext,
- log: Logger,
-): Promise<KimiResponse> {
- let auth = await getAuth();
- const requestStartTime = Date.now();
- let resp = await doFetch(auth.access, body, ctx, log);
-
- if (resp.status === 401) {
- log.warn("got 401, refreshing token", {});
- try {
- auth = await forceRefresh();
- resp = await doFetch(auth.access, body, ctx, log);
- } catch (err) {
- if (err instanceof KimiAuthUnauthorizedError) {
- throw new KimiError(401, "Unauthorized", err.message);
- }
- 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);
- ctx.traffic?.writeText("031-upstream-error-body", text);
- throw new KimiError(429, "Rate limited", text, { retryAfter });
- }
-
- if (!resp.ok) {
- const text = await safeText(resp);
- ctx.traffic?.writeText("031-upstream-error-body", text);
- 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");
-
- const timeToHeadersMs = Date.now() - requestStartTime;
- ctx.traffic?.writeJson("030-upstream-response-headers", {
- status: resp.status,
- statusText: resp.statusText,
- timeToHeadersMs,
- headers: headersToRecord(resp.headers),
- });
- log.debug("upstream response", {
- status: resp.status,
- timeToHeadersMs,
- });
-
- return { body: resp.body, status: resp.status, headers: resp.headers, requestStartTime };
-}
-
-async function doFetch(
- accessToken: string,
- body: KimiChatRequest,
- ctx: RequestContext,
- log: Logger,
-): Promise<Response> {
- const fp = await commonHeaders();
- const headers = new Headers({
- "Content-Type": "application/json",
- Accept: "application/json",
- Authorization: `Bearer ${accessToken}`,
- ...fp,
- });
-
- const url = `${apiBaseUrl()}/chat/completions`;
- const bodyJson = JSON.stringify(body);
- const requestBodyBytes = new TextEncoder().encode(bodyJson).length;
- ctx.traffic?.writeJson("020-upstream-request", body);
- ctx.traffic?.writeJson("021-upstream-request-metadata", {
- provider: "kimi",
- url,
- method: "POST",
- headers: headersToRecord(headers),
- requestBodyBytes,
- });
- log.debug("posting to kimi", {
- url,
- model: body.model,
- messageCount: body.messages.length,
- toolCount: body.tools?.length ?? 0,
- requestBodyBytes,
- });
-
- return fetch(url, {
- method: "POST",
- headers,
- body: bodyJson,
- signal: ctx.signal,
- });
-}
-
-async function safeText(resp: Response): Promise<string> {
- try {
- return await resp.text();
- } catch {
- return "";
- }
-}
diff --git a/reference/typescript/src/providers/kimi/count-tokens.ts b/reference/typescript/src/providers/kimi/count-tokens.ts
deleted file mode 100644
index c511921..0000000
--- a/reference/typescript/src/providers/kimi/count-tokens.ts
+++ /dev/null
@@ -1,45 +0,0 @@
-import { encode } from "gpt-tokenizer/model/gpt-4o";
-import type { AnthropicRequest } from "../../anthropic/schema.ts";
-import type { KimiChatRequest } from "./translate/request.ts";
-import {
- countAnthropicTokens,
- IMAGE_TOKEN_ESTIMATE,
- countContentParts,
-} from "../shared/count-tokens.ts";
-import { countToolSchemaTokens } from "../shared/tool-schema.ts";
-
-// 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 {
- return countAnthropicTokens(req, (value) => encode(value).length, true);
-}
-
-export function countTranslatedTokens(req: KimiChatRequest): number {
- let total = 0;
- for (const m of req.messages) {
- if (m.role === "system") {
- total += encode(m.content).length;
- } else if (m.role === "user") {
- total += countContentParts(m.content, (v) => encode(v).length);
- } 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;
- for (const tc of m.tool_calls ?? []) {
- total += encode(tc.function.name).length;
- total += encode(tc.function.arguments).length;
- }
- } else if (m.role === "tool") {
- total += countContentParts(m.content, (v) => encode(v).length);
- }
- }
-
- total += countToolSchemaTokens(
- req.tools,
- (tool) => tool.function.name,
- (tool) => tool.function.description,
- (tool) => tool.function.parameters,
- );
-
- total += req.messages.length * 4;
- return total;
-}
diff --git a/reference/typescript/src/providers/kimi/index.test.ts b/reference/typescript/src/providers/kimi/index.test.ts
deleted file mode 100644
index 9422d3e..0000000
--- a/reference/typescript/src/providers/kimi/index.test.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import type { RequestContext } from "../types.ts";
-import { loadConfig } from "../../config.ts";
-import { kimiProvider } from "./index.ts";
-
-afterEach(() => {
- loadConfig({ forceReload: true });
-});
-
-describe("kimiProvider", () => {
- it("returns token count JSON responses", async () => {
- const response = await kimiProvider.handleCountTokens(
- { model: "kimi-for-coding", messages: [{ role: "user", content: "hello" }] },
- fakeCtx(),
- );
- const body = (await response.json()) as { input_tokens: number };
-
- expect(response.status).toBe(200);
- expect(response.headers.get("content-type")).toBe("application/json");
- expect(body.input_tokens).toBeGreaterThan(0);
- });
-});
-
-function fakeCtx(): RequestContext {
- return {
- reqId: "kimi-req",
- signal: new AbortController().signal,
- childLogger: () => ({
- debug() {},
- info() {},
- warn() {},
- error() {},
- child() {
- return this;
- },
- }),
- };
-}
diff --git a/reference/typescript/src/providers/kimi/index.ts b/reference/typescript/src/providers/kimi/index.ts
deleted file mode 100644
index 1d3fb72..0000000
--- a/reference/typescript/src/providers/kimi/index.ts
+++ /dev/null
@@ -1,141 +0,0 @@
-import type { Provider, RequestContext } from "../types.ts";
-import type { AnthropicRequest } from "../../anthropic/schema.ts";
-import { wantsDownstreamStream } from "../../anthropic/stream.ts";
-import { jsonError, jsonResponse, sseResponse } from "../../anthropic/response.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 { logVerbose } from "../../config.ts";
-import { kimiCli } from "./cli.ts";
-import { mapUpstreamHttpErrorToResponse, mapUpstreamStreamErrorToResponse } from "../shared/upstream-errors.ts";
-
-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 });
- return jsonResponse({ input_tokens: tokens });
-}
-
-async function handleMessages(body: AnthropicRequest, ctx: RequestContext): Promise<Response> {
- const log = ctx.childLogger("provider.kimi");
- const messageId = `msg_${crypto.randomUUID().replace(/-/g, "")}`;
- const wantStream = wantsDownstreamStream(body);
- const messageCount = body.messages?.length ?? 0;
- const toolCount = body.tools?.length ?? 0;
-
- log.debug("anthropic request", {
- model: body.model,
- messageCount,
- toolCount,
- stream: wantStream,
- requestedMaxTokens: body.max_tokens,
- });
- if (logVerbose()) log.debug("anthropic request body", { body });
-
- const resolvedModel = resolveModel(body.model);
- try {
- assertAllowedModel(resolvedModel);
- } catch (err) {
- if (err instanceof ModelNotAllowedError) {
- return jsonError(
- 400,
- "invalid_request_error",
- `Model "${body.model}" resolves to unsupported model "${err.model}"`,
- );
- }
- throw err;
- }
-
- const translated = translateRequest(
- { ...body, model: resolvedModel },
- { sessionId: ctx.sessionId },
- );
- const localInputTokens = countTokens(body);
- const translatedInputTokens = countTranslatedTokens(translated);
- log.debug("translated request", {
- requestedModel: body.model,
- resolvedModel,
- messageCount: translated.messages.length,
- toolCount: translated.tools?.length ?? 0,
- localInputTokens,
- translatedInputTokens,
- promptCacheKey: translated.prompt_cache_key,
- reasoningEffort: translated.reasoning_effort,
- thinking: translated.thinking?.type,
- maxTokens: translated.max_tokens,
- });
- if (logVerbose()) log.debug("translated request body", { body: translated });
-
- let upstream;
- try {
- upstream = await postKimi(translated, ctx);
- } catch (err) {
- if (err instanceof KimiError) {
- log.warn("kimi error", { status: err.status, detail: err.detail });
- return mapUpstreamHttpErrorToResponse(err);
- }
- throw err;
- }
-
- if (wantStream) {
- const stream = translateStream(upstream.body, {
- messageId,
- model: body.model,
- log: ctx.childLogger("kimi.stream"),
- requestStartTime: upstream.requestStartTime,
- traffic: ctx.traffic,
- onFinish: (finish) => {
- 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,
- mappedInputTokens: mappedUsage?.input_tokens ?? 0,
- mappedOutputTokens: mappedUsage?.output_tokens ?? 0,
- mappedCacheReadTokens: mappedUsage?.cache_read_input_tokens ?? 0,
- });
- },
- });
- return sseResponse(stream);
- }
-
- try {
- const result = await accumulateResponse(upstream.body, {
- messageId,
- model: body.model,
- log: ctx.childLogger("kimi.accumulate"),
- traffic: ctx.traffic,
- });
- return jsonResponse(result.response);
- } catch (err) {
- if (err instanceof UpstreamStreamError) {
- log.warn("upstream stream error (non-streaming)", {
- kind: err.kind,
- message: err.message,
- });
- return mapUpstreamStreamErrorToResponse(err);
- }
- throw err;
- }
-}
-
-export const kimiProvider: Provider = {
- name: "kimi",
- supportedModels: new Set(["kimi-for-coding", "kimi-k2.6", "k2.6"]),
- handleMessages,
- handleCountTokens,
- cli: kimiCli,
-};
diff --git a/reference/typescript/src/providers/kimi/translate/accumulate.ts b/reference/typescript/src/providers/kimi/translate/accumulate.ts
deleted file mode 100644
index 436675f..0000000
--- a/reference/typescript/src/providers/kimi/translate/accumulate.ts
+++ /dev/null
@@ -1,117 +0,0 @@
-import { mapUsageToAnthropic, reduceUpstream, type KimiUsage } from "./reducer.ts";
-import { makeThinkingSignature } from "./signature.ts";
-import type { TrafficCapture } from "../../types.ts";
-import {
- collectAnthropicContentFromAccumulatedBlocks,
- AnthropicNonStreamResponse,
- createBlockAccumulator,
- defaultAnthropicNonStreamUsage,
- parseToolInputJsonOrRaw,
-} from "../../translate/accumulate.ts";
-
-export { UpstreamStreamError } from "./reducer.ts";
-
-export interface AccumulatedResponse {
- response: AnthropicNonStreamResponse;
- rawUsage?: KimiUsage;
-}
-
-import type { Logger } from "../../../log.ts";
-
-export async function accumulateResponse(
- upstream: ReadableStream<Uint8Array>,
- opts: { messageId: string; model: string; log: Logger; traffic?: TrafficCapture },
-): Promise<AccumulatedResponse> {
- const blockAccumulator = createBlockAccumulator({ includeThinking: true });
- 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, traffic: opts.traffic };
-
- for await (const e of reduceUpstream(upstream, stats, opts.log)) {
- switch (e.kind) {
- case "thinking-start":
- blockAccumulator.onThinkingStart(e.index);
- break;
- case "thinking-delta": {
- if (blockAccumulator.onThinkingDelta(e.index, e.text)) {
- reasoningChars += e.text.length;
- }
- break;
- }
- case "text-start":
- blockAccumulator.onTextStart(e.index);
- break;
- case "text-delta": {
- if (blockAccumulator.onTextDelta(e.index, e.text)) {
- contentChars += e.text.length;
- }
- break;
- }
- case "tool-start":
- toolCount++;
- blockAccumulator.onToolStart(e.index, e.id, e.name);
- break;
- case "tool-delta": {
- blockAccumulator.onToolDelta(e.index, e.partialJson);
- break;
- }
- case "thinking-stop":
- case "text-stop":
- case "tool-stop":
- break;
- case "finish":
- stopReason = e.stopReason;
- rawUsage = e.usage;
- usage = mapUsageToAnthropic(e.usage);
- break;
- }
- }
-
- const content = collectAnthropicContentFromAccumulatedBlocks<AnthropicNonStreamResponse["content"][number]>(
- blockAccumulator.orderedBlocks(),
- {
- onThinking: (index, text) =>
- text
- ? {
- type: "thinking",
- thinking: text,
- signature: makeThinkingSignature(opts.messageId, index),
- }
- : undefined,
- onText: (_index, text) => (text ? { type: "text", text } : undefined),
- onTool: (_index, id, name, args) => ({
- type: "tool_use",
- id,
- name,
- input: parseToolInputJsonOrRaw(args),
- }),
- },
- );
-
- opts.log.debug("accumulate summary", {
- chunkCount: stats.chunkCount,
- reasoningChars,
- contentChars,
- toolCount,
- stopReason,
- usage: rawUsage,
- });
-
- return {
- rawUsage,
- response: {
- id: opts.messageId,
- type: "message",
- role: "assistant",
- model: opts.model,
- content,
- stop_reason: stopReason,
- stop_sequence: null,
- usage: usage ?? defaultAnthropicNonStreamUsage(),
- },
- };
-}
diff --git a/reference/typescript/src/providers/kimi/translate/model-allowlist.ts b/reference/typescript/src/providers/kimi/translate/model-allowlist.ts
deleted file mode 100644
index 7b93c86..0000000
--- a/reference/typescript/src/providers/kimi/translate/model-allowlist.ts
+++ /dev/null
@@ -1,32 +0,0 @@
-export const KIMI_DEFAULT_MODEL = "kimi-for-coding";
-
-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
-// for portability with the codex provider's aliasing.
-const ALIAS_TARGETS: Record<string, string> = {
- haiku: KIMI_DEFAULT_MODEL,
- "claude-haiku-4-5": KIMI_DEFAULT_MODEL,
- "claude-haiku-4-5-20251001": KIMI_DEFAULT_MODEL,
- sonnet: KIMI_DEFAULT_MODEL,
- "claude-sonnet-4-6": KIMI_DEFAULT_MODEL,
- 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;
-}
-
-export function assertAllowedModel(model: string): void {
- 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";
- }
-}
diff --git a/reference/typescript/src/providers/kimi/translate/reducer.ts b/reference/typescript/src/providers/kimi/translate/reducer.ts
deleted file mode 100644
index 07121df..0000000
--- a/reference/typescript/src/providers/kimi/translate/reducer.ts
+++ /dev/null
@@ -1,213 +0,0 @@
-import { parseSseStream } from "../../../sse.ts";
-import type { Logger } from "../../../log.ts";
-import type { TrafficCapture } from "../../types.ts";
-import type { TextToolReducerEvent } from "../../translate/accumulate.ts";
-import { mapCachedInputUsageToAnthropicUsage } from "../../translate/accumulate.ts";
-
-export class UpstreamStreamError extends Error {
- constructor(
- public kind: "rate_limit" | "failed",
- message: string,
- public retryAfterSeconds?: number,
- ) {
- 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 };
-}
-
-export type StopReason = "end_turn" | "tool_use" | "max_tokens";
-
-export type ReducerEvent =
- | { kind: "thinking-start"; index: number }
- | { kind: "thinking-delta"; index: number; text: string }
- | { kind: "thinking-stop"; index: number }
- | TextToolReducerEvent
- | { kind: "finish"; stopReason: StopReason; usage: KimiUsage | undefined };
-
-interface StreamChunk {
- choices?: Array<{
- delta?: {
- 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 };
-}
-
-interface ToolSlot {
- blockIndex: number;
- id: string;
- name: string;
-}
-
-/**
- * Translate a Kimi/OpenAI-style chat-completions SSE stream into a stream
- * of typed, downstream-agnostic ReducerEvents consumed by both the
- * streaming and non-streaming frontends.
- */
-export interface ReducerStats {
- chunkCount: number;
- traffic?: TrafficCapture;
-}
-
-export async function* reduceUpstream(
- upstream: ReadableStream<Uint8Array>,
- 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 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 closeText = function* () {
- if (textIndex !== undefined) {
- 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 };
- }
- toolSlots.clear();
- };
-
- for await (const evt of parseSseStream(upstream)) {
- if (!evt.data) continue;
- const data = evt.data.trim();
- if (data === "[DONE]") continue;
-
- let chunk: StreamChunk;
- try {
- chunk = JSON.parse(data) as StreamChunk;
- } catch (err) {
- log?.warn("upstream sse: invalid json", { err: String(err), preview: data.slice(0, 200) });
- continue;
- }
-
- if (stats) {
- stats.chunkCount++;
- stats.traffic?.writeJsonEvent("040-upstream-event", chunk);
- }
-
- if (chunk.error) {
- throw new UpstreamStreamError("failed", chunk.error.message || "Upstream error");
- }
-
- if (chunk.usage && !chunk.choices?.length) {
- finalUsage = chunk.usage;
- continue;
- }
-
- 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 };
- }
- yield { kind: "thinking-delta", index: thinkingIndex, text: delta.reasoning_content };
- }
-
- if (typeof delta.content === "string" && delta.content.length > 0) {
- yield* closeThinking();
- if (textIndex === undefined) {
- textIndex = nextBlockIndex++;
- yield { kind: "text-start", index: textIndex };
- }
- yield { kind: "text-delta", index: textIndex, text: delta.content };
- }
-
- if (delta.tool_calls?.length) {
- yield* closeThinking();
- yield* closeText();
- for (const tc of delta.tool_calls) {
- 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 ?? "";
- if (!id || !name) {
- // Defensive: out-of-order fragment before the initial one. Skip.
- continue;
- }
- 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;
- if (typeof argsDelta === "string" && argsDelta.length > 0) {
- yield { kind: "tool-delta", index: slot.blockIndex, partialJson: argsDelta };
- }
- }
- }
-
- if (choice.finish_reason) {
- finishReason = choice.finish_reason;
- if (chunk.usage) finalUsage = chunk.usage;
- }
- }
-
- yield* closeThinking();
- yield* closeText();
- yield* closeAllTools();
-
- const stopReason: StopReason =
- finishReason === "length"
- ? "max_tokens"
- : finishReason === "tool_calls" || sawToolCalls
- ? "tool_use"
- : "end_turn";
-
- 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;
-} {
- const cached = u?.prompt_tokens_details?.cached_tokens ?? u?.cached_tokens ?? 0;
- const totalPrompt = u?.prompt_tokens ?? 0;
- return mapCachedInputUsageToAnthropicUsage({
- inputTokens: totalPrompt,
- outputTokens: u?.completion_tokens,
- cachedInputTokens: cached,
- });
-}
diff --git a/reference/typescript/src/providers/kimi/translate/request.test.ts b/reference/typescript/src/providers/kimi/translate/request.test.ts
deleted file mode 100644
index 3bfae85..0000000
--- a/reference/typescript/src/providers/kimi/translate/request.test.ts
+++ /dev/null
@@ -1,93 +0,0 @@
-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", () => {
- const req: AnthropicRequest = {
- model: "kimi-k2",
- messages: [
- {
- role: "user",
- content: [
- {
- type: "tool_result",
- tool_use_id: "toolu_1",
- content: [
- { type: "text", text: "visible output" },
- { type: "thinking", thinking: "hidden thought" },
- ],
- },
- ],
- },
- ],
- };
-
- expect(translateRequest(req).messages).toEqual([
- {
- role: "tool",
- tool_call_id: "toolu_1",
- content: [
- { type: "text", text: "visible output" },
- { type: "text", text: "[unsupported content block omitted: thinking]" },
- ],
- },
- ]);
- });
-
- it("preserves image tool result content parts", () => {
- const req: AnthropicRequest = {
- model: "kimi-k2",
- messages: [
- {
- role: "user",
- content: [
- {
- type: "tool_result",
- tool_use_id: "toolu_1",
- content: [
- { type: "text", text: "caption" },
- {
- type: "image",
- source: { type: "base64", media_type: "image/png", data: "abc" },
- },
- ],
- },
- ],
- },
- ],
- };
-
- expect(translateRequest(req).messages).toEqual([
- {
- role: "tool",
- tool_call_id: "toolu_1",
- content: [
- { type: "text", text: "caption" },
- { type: "image_url", image_url: { url: "data:image/png;base64,abc" } },
- ],
- },
- ]);
- });
-
- it("counts unsupported tool result content blocks without throwing", () => {
- const req: AnthropicRequest = {
- model: "kimi-k2",
- messages: [
- {
- role: "user",
- content: [
- {
- type: "tool_result",
- tool_use_id: "toolu_1",
- content: [{ type: "thinking", thinking: "hidden thought" }],
- },
- ],
- },
- ],
- };
-
- expect(countTokens(req)).toBeGreaterThan(0);
- });
-});
diff --git a/reference/typescript/src/providers/kimi/translate/request.ts b/reference/typescript/src/providers/kimi/translate/request.ts
deleted file mode 100644
index 8f46b25..0000000
--- a/reference/typescript/src/providers/kimi/translate/request.ts
+++ /dev/null
@@ -1,255 +0,0 @@
-import type {
- AnthropicContentBlock,
- AnthropicRequest,
- AnthropicTool,
- AnthropicToolResultContentBlock,
-} from "../../../anthropic/schema.ts";
-import {
- assertValidEffort,
- mapToolChoice as mapAnthropicToolChoice,
- flattenSystemText,
- imageBlockToUrl,
- isToolResultImageBlock,
- isToolResultTextBlock,
- normalizeContent,
- toolResultToString,
- unsupportedToolResultBlockToString,
-} from "../../translate/anthropic-content.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;
-}
-
-export type KimiToolChoice =
- | "auto"
- | "none"
- | "required"
- | { type: "function"; function: { name: string } };
-
-export type KimiAssistantMessage = {
- 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[] };
-
-export type KimiUserContentPart =
- | { type: "text"; text: string }
- | { type: "image_url"; image_url: { url: string } };
-
-export type KimiToolResultPart =
- | { type: "text"; text: string }
- | { type: "image_url"; image_url: { url: string } };
-
-export interface KimiAssistantToolCall {
- id: string;
- type: "function";
- function: { name: string; arguments: string };
-}
-
-export interface KimiTool {
- type: "function";
- function: { name: string; description?: string; parameters: unknown };
-}
-
-export interface TranslateOptions {
- sessionId?: string;
-}
-
-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
-// tool_call messages carry reasoning_content back. The `thinking` /
-// `reasoning_effort` flags on the request don't gate that contract.
-// They're a model-level property. So we always enable thinking on the
-// outbound Kimi request and always forward/replay reasoning end-to-end.
-export function translateRequest(
- req: AnthropicRequest,
- opts: TranslateOptions = {},
-): KimiChatRequest {
- const messages = buildMessages(req);
- const tools = req.tools?.map(toKimiTool);
-
- assertValidEffort(req.output_config?.effort);
- const out: KimiChatRequest = {
- model: req.model,
- messages,
- stream: true,
- stream_options: { include_usage: true },
- 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;
-}
-
-function clampMaxTokens(requested: number | undefined): number {
- if (!requested || requested <= 0) return DEFAULT_MAX_TOKENS;
- return Math.min(requested, DEFAULT_MAX_TOKENS);
-}
-
-// Kimi's reasoning_effort is capped at "high"; collapse the proxy's "max"
-// to "high" since Kimi has no stronger tier, and default to "medium" when no
-// effort is requested.
-function mapReasoningEffort(
- effort: NonNullable<AnthropicRequest["output_config"]>["effort"],
-): "low" | "medium" | "high" {
- if (effort === "max") return "high";
- return effort ?? "medium";
-}
-
-function mapToolChoice(choice: AnthropicRequest["tool_choice"]): KimiToolChoice {
- const mapped = mapAnthropicToolChoice(choice);
- if (mapped === "auto" || mapped === "none" || mapped === "required") return mapped;
- return { type: "function", function: { name: mapped.name } };
-}
-
-export const buildSystemMessage = flattenSystemText;
-
-export { normalizeContent, toolResultToString };
-
-function buildMessages(req: AnthropicRequest): KimiMessage[] {
- 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);
- if (msg.role === "user") {
- pushUserMessages(out, blocks);
- } else {
- pushAssistantMessage(out, blocks);
- }
- }
- return out;
-}
-
-// In Anthropic-land a single user message can carry a mix of text, image,
-// and tool_result blocks. OpenAI-style chat-completions requires tool
-// 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[] = [];
- const flushBuffer = () => {
- if (!buffer.length) return;
- // Collapse to a string when every part is text. This matches what kimi-cli
- // sends and keeps the wire payload compact.
- 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 });
- }
- buffer = [];
- };
-
- for (const block of blocks) {
- if (block.type === "text") {
- buffer.push({ type: "text", text: block.text });
- } else if (block.type === "image") {
- buffer.push({ type: "image_url", image_url: { url: imageBlockToUrl(block) } });
- } else if (block.type === "tool_result") {
- flushBuffer();
- out.push({
- role: "tool",
- tool_call_id: block.tool_use_id,
- content: toolResultContent(block.content, block.is_error),
- });
- }
- }
- flushBuffer();
-}
-
-function pushAssistantMessage(out: KimiMessage[], blocks: AnthropicContentBlock[]): void {
- 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);
- } else if (block.type === "thinking") {
- if (block.thinking) thinkingParts.push(block.thinking);
- } else if (block.type === "tool_use") {
- toolCalls.push({
- id: block.id,
- type: "function",
- function: {
- name: block.name,
- arguments: JSON.stringify(block.input ?? {}),
- },
- });
- }
- // image blocks from the assistant are dropped because Kimi's assistant
- // schema does not express them.
- }
-
- if (!textParts.length && !toolCalls.length && !thinkingParts.length) return;
-
- 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);
-}
-
-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 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 });
- } else if (isToolResultImageBlock(b)) {
- parts.push({ type: "image_url", image_url: { url: imageBlockToUrl(b) } });
- } else {
- parts.push({ type: "text", text: unsupportedToolResultBlockToString(b) });
- }
- }
- if (parts.length === 1 && parts[0]!.type === "text") return parts[0]!.text;
- return parts;
-}
-
-function toKimiTool(tool: AnthropicTool): KimiTool {
- return {
- type: "function",
- function: {
- name: tool.name,
- description: "description" in tool ? tool.description : undefined,
- parameters: "input_schema" in tool ? tool.input_schema : {},
- },
- };
-}
diff --git a/reference/typescript/src/providers/kimi/translate/signature.ts b/reference/typescript/src/providers/kimi/translate/signature.ts
deleted file mode 100644
index 0547023..0000000
--- a/reference/typescript/src/providers/kimi/translate/signature.ts
+++ /dev/null
@@ -1,7 +0,0 @@
-// Opaque per-block signature for Anthropic thinking blocks. Claude Code
-// treats this as a passthrough string, so the only requirements are:
-// 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");
-}
diff --git a/reference/typescript/src/providers/kimi/translate/stream.ts b/reference/typescript/src/providers/kimi/translate/stream.ts
deleted file mode 100644
index 05d6ac3..0000000
--- a/reference/typescript/src/providers/kimi/translate/stream.ts
+++ /dev/null
@@ -1,211 +0,0 @@
-import { encodeSseEvent } from "../../../sse.ts";
-import type { Logger } from "../../../log.ts";
-import type { TrafficCapture } from "../../types.ts";
-import {
- mapUsageToAnthropic,
- reduceUpstream,
- UpstreamStreamError,
- type KimiUsage,
-} from "./reducer.ts";
-import { makeThinkingSignature } from "./signature.ts";
-import { emitMessageStart } from "../../shared/anthropic-sse.ts";
-
-function isAbortError(err: unknown): boolean {
- return err instanceof Error && err.name === "AbortError";
-}
-
-/**
- * Translate a Kimi chat-completions SSE stream into Anthropic SSE events.
- * HTTP status 200 is already committed before the first upstream event is
- * read, so rate-limit and upstream-failed conditions surface here as SSE
- * `error` events instead of non-200 statuses.
- */
-export function translateStream(
- upstream: ReadableStream<Uint8Array>,
- opts: {
- messageId: string;
- model: string;
- log: Logger;
- requestStartTime?: number;
- traffic?: TrafficCapture;
- onFinish?: (finish: {
- stopReason: "end_turn" | "tool_use" | "max_tokens";
- usage?: Parameters<typeof mapUsageToAnthropic>[0];
- }) => void;
- },
-): ReadableStream<Uint8Array> {
- const encoder = new TextEncoder();
- return new ReadableStream<Uint8Array>({
- async start(controller) {
- const emit = (event: string, data: unknown) => {
- opts.traffic?.writeJsonEvent("050-downstream-event", { event, data });
- 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;
- emitMessageStart(emit, { messageId: opts.messageId, model: opts.model });
- };
-
- 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, traffic: opts.traffic };
-
- try {
- for await (const e of reduceUpstream(upstream, stats, opts.log)) {
- if (firstChunkAt === undefined) firstChunkAt = Date.now();
-
- switch (e.kind) {
- case "thinking-start":
- ensureMessageStart();
- emit("content_block_start", {
- type: "content_block_start",
- index: e.index,
- content_block: { type: "thinking", thinking: "" },
- });
- break;
- case "thinking-delta":
- reasoningChars += e.text.length;
- emit("content_block_delta", {
- type: "content_block_delta",
- index: e.index,
- delta: { type: "thinking_delta", thinking: e.text },
- });
- break;
- case "thinking-stop":
- // Emit the signature as a separate signature_delta right
- // before content_block_stop — matches Anthropic's native
- // wire format and keeps Claude Code's thinking-block parser
- // happy on round-trip.
- emit("content_block_delta", {
- type: "content_block_delta",
- index: e.index,
- delta: {
- type: "signature_delta",
- signature: makeThinkingSignature(opts.messageId, e.index),
- },
- });
- emit("content_block_stop", { type: "content_block_stop", index: e.index });
- break;
- case "text-start":
- ensureMessageStart();
- emit("content_block_start", {
- type: "content_block_start",
- index: e.index,
- content_block: { type: "text", text: "" },
- });
- break;
- case "text-delta":
- contentChars += e.text.length;
- emit("content_block_delta", {
- type: "content_block_delta",
- index: e.index,
- delta: { type: "text_delta", text: e.text },
- });
- break;
- case "text-stop":
- 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();
- emit("content_block_start", {
- type: "content_block_start",
- index: e.index,
- content_block: {
- type: "tool_use",
- id: e.id,
- name: e.name,
- input: {},
- },
- });
- 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;
- case "tool-stop":
- 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 });
- 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;
- }
- }
- } catch (err) {
- const activeToolNames = Array.from(activeTools.values(), (t) => t.name);
- const activeToolCalls = Array.from(activeTools.values());
- if (isAbortError(err)) {
- 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();
- 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();
- 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;
- opts.log.debug("stream summary", {
- chunkCount: stats.chunkCount,
- timeToFirstChunkMs,
- streamDurationMs: firstChunkAt ? now - firstChunkAt : undefined,
- totalMs: opts.requestStartTime ? now - opts.requestStartTime : now - streamStart,
- reasoningChars,
- contentChars,
- toolCount,
- stopReason: finishStopReason,
- usage: finishUsage,
- });
- try {
- controller.close();
- } catch {
- // ignore if controller already errored or cancelled
- }
- }
- },
- });
-}
diff --git a/reference/typescript/src/providers/registry.test.ts b/reference/typescript/src/providers/registry.test.ts
deleted file mode 100644
index 278ed5a..0000000
--- a/reference/typescript/src/providers/registry.test.ts
+++ /dev/null
@@ -1,151 +0,0 @@
-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,
- getProvider,
- groupSupportedModelsByProvider,
- normalizeIncomingModel,
- providerForModel,
-} from "./registry.ts";
-import { loadConfig } from "../config.ts";
-
-afterEach(() => {
- loadConfig({ forceReload: true });
-});
-
-function providersFor(model: string): string[] {
- return allSupportedModels()
- .filter((entry) => entry.model === model)
- .map((entry) => entry.provider);
-}
-
-function withAliasConfig<T>(aliasProvider: string, test: (configPath: string) => T): T {
- const dir = mkdtempSync(join(tmpdir(), "ccp-alias-provider-"));
- const configPath = join(dir, "config.json");
- writeFileSync(configPath, JSON.stringify({ aliasProvider }));
- try {
- return test(configPath);
- } finally {
- rmSync(dir, { recursive: true, force: true });
- }
-}
-
-describe("provider routing", () => {
- it("routes fast Codex model aliases after context suffix normalization", () => {
- expect(normalizeIncomingModel("gpt-5.4-fast[1m]")).toBe("gpt-5.4-fast");
- expect(providerForModel("gpt-5.4-fast[1m]")?.name).toBe("codex");
- });
-
- it("routes Anthropic-style aliases to Codex by default", () => {
- loadConfig({ env: {}, forceReload: true });
-
- for (const alias of ANTHROPIC_STYLE_ALIASES) {
- 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 });
-
- for (const alias of ANTHROPIC_STYLE_ALIASES) {
- expect(providerForModel(alias)?.name).toBe("kimi");
- }
- });
-
- it("lets session affinity override the global alias provider", () => {
- loadConfig({ env: {}, forceReload: true });
-
- expect(providerForModel("sonnet", "kimi")?.name).toBe("kimi");
- });
-
- it("routes aliases to Codex when config file selects Codex", () => {
- withAliasConfig("codex", (path) => {
- loadConfig({ configPath: path, env: {}, forceReload: true });
- expect(providerForModel("claude-opus-4-7")?.name).toBe("codex");
- });
- });
-
- it("lets env override config file alias provider", () => {
- withAliasConfig("codex", (path) => {
- loadConfig({ configPath: path, env: { CCP_ALIAS_PROVIDER: "kimi" }, forceReload: true });
- expect(providerForModel("haiku")?.name).toBe("kimi");
- });
- });
-
- it("lists aliases only under the active alias provider", () => {
- loadConfig({ env: { CCP_ALIAS_PROVIDER: "codex" }, forceReload: true });
-
- expect(providersFor("sonnet")).toEqual(["codex"]);
- });
-
- it("groups supported models without changing provider or model order", () => {
- loadConfig({ env: { CCP_ALIAS_PROVIDER: "kimi" }, forceReload: true });
-
- const grouped = groupSupportedModelsByProvider();
- const expected = new Map<string, string[]>();
- for (const { model, provider } of allSupportedModels()) {
- const models = expected.get(provider) ?? [];
- models.push(model);
- expected.set(provider, models);
- }
-
- expect([...grouped.keys()]).toEqual([...expected.keys()]);
- expect([...grouped.entries()]).toEqual([...expected.entries()]);
- expect(grouped.get("kimi")).toEqual(expect.arrayContaining([...ANTHROPIC_STYLE_ALIASES]));
- expect(grouped.get("codex") ?? []).not.toEqual(expect.arrayContaining(["sonnet"]));
- });
-
- it("does not duplicate supported model entries", () => {
- for (const env of [{}, { CCP_ALIAS_PROVIDER: "codex" }]) {
- loadConfig({ env, forceReload: true });
- const models = allSupportedModels().map(({ model }) => model);
- expect(new Set(models).size).toBe(models.length);
- }
- });
-
- it("keeps concrete model routing unchanged", () => {
- loadConfig({ env: { CCP_ALIAS_PROVIDER: "codex" }, forceReload: true });
-
- expect(providerForModel("kimi-for-coding")?.name).toBe("kimi");
- expect(providerForModel("gpt-5.4-fast")?.name).toBe("codex");
- expect(providerForModel("cursor")?.name).toBe("cursor");
- expect(providerForModel("cursor-plan")?.name).toBe("cursor");
- expect(providerForModel("cursor:claude-sonnet-4-6")?.name).toBe("cursor");
- });
-
- it("lists Cursor aliases in supported models", () => {
- const cursorModels = allSupportedModels()
- .filter((entry) => entry.provider === "cursor")
- .map((entry) => entry.model);
-
- expect(cursorModels).toContain("cursor");
- expect(cursorModels).toContain("cursor-plan");
- expect(cursorModels).toContain("composer-2.5-fast");
- });
-
- it("keeps auth CLI commands available through the registry", () => {
- const codex = getProvider("codex").cli;
- expect(Object.keys(codex).sort()).toEqual(["device", "login", "logout", "status"]);
- expect(typeof codex.login).toBe("function");
- expect(typeof codex.device).toBe("function");
- expect(typeof codex.status).toBe("function");
- expect(typeof codex.logout).toBe("function");
-
- const kimi = getProvider("kimi").cli;
- expect(Object.keys(kimi).sort()).toEqual(["login", "logout", "status"]);
- expect(typeof kimi.login).toBe("function");
- expect(kimi.device).toBeUndefined();
- expect(typeof kimi.status).toBe("function");
- expect(typeof kimi.logout).toBe("function");
-
- const cursor = getProvider("cursor").cli;
- expect(Object.keys(cursor).sort()).toEqual(["login", "logout", "status"]);
- expect(typeof cursor.login).toBe("function");
- expect(cursor.device).toBeUndefined();
- expect(typeof cursor.status).toBe("function");
- expect(typeof cursor.logout).toBe("function");
- });
-});
diff --git a/reference/typescript/src/providers/registry.ts b/reference/typescript/src/providers/registry.ts
deleted file mode 100644
index ca35a73..0000000
--- a/reference/typescript/src/providers/registry.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-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 { cursorProvider } from "./cursor/index.ts";
-import { isCursorModel } from "./cursor/translate/model.ts";
-
-export const ANTHROPIC_STYLE_ALIASES = new Set([
- "haiku",
- "claude-haiku-4-5",
- "claude-haiku-4-5-20251001",
- "sonnet",
- "claude-sonnet-4-6",
- "opus",
- "claude-opus-4-7",
-]);
-
-const PROVIDERS: Record<string, Provider> = {
- codex: codexProvider,
- kimi: kimiProvider,
- cursor: cursorProvider,
-};
-
-export function getProvider(name: string): Provider {
- const p = PROVIDERS[name];
- if (!p) {
- throw new Error(`Unknown provider: ${name}. Available: ${Object.keys(PROVIDERS).join(", ")}`);
- }
- return p;
-}
-
-export function listProviders(): string[] {
- return Object.keys(PROVIDERS);
-}
-
-export function allProviders(): Provider[] {
- return Object.values(PROVIDERS);
-}
-
-export function normalizeIncomingModel(model: string): string {
- return model.replace(/\[1m\]$/i, "");
-}
-
-export function providerForModel(
- model: string,
- aliasProviderOverride?: AliasProvider,
-): Provider | undefined {
- const normalizedModel = normalizeIncomingModel(model);
- if (ANTHROPIC_STYLE_ALIASES.has(normalizedModel))
- return getProvider(aliasProviderOverride ?? aliasProvider());
- if (isCursorModel(normalizedModel)) return cursorProvider;
- for (const p of allProviders()) {
- if (p.supportedModels.has(normalizedModel)) return p;
- }
- return undefined;
-}
-
-export function groupSupportedModelsByProvider(): 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);
- }
- return groups;
-}
-
-export function allSupportedModels(): Array<{ model: string; provider: string }> {
- const out: Array<{ model: string; provider: string }> = [];
- const activeAliasProvider = aliasProvider();
- for (const p of allProviders()) {
- for (const m of p.supportedModels) out.push({ model: m, provider: p.name });
- if (p.name === activeAliasProvider) {
- for (const m of ANTHROPIC_STYLE_ALIASES) out.push({ model: m, provider: p.name });
- }
- }
- return out;
-}
diff --git a/reference/typescript/src/providers/retry.test.ts b/reference/typescript/src/providers/retry.test.ts
deleted file mode 100644
index 5eb8484..0000000
--- a/reference/typescript/src/providers/retry.test.ts
+++ /dev/null
@@ -1,192 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
- computeBackoffDelay,
- MAX_RATE_LIMIT_RETRIES,
- RETRY_INITIAL_DELAY_MS,
- RETRY_MAX_DELAY_MS,
- retryOn429,
- sleep,
-} from "./retry.ts";
-
-const silentLog = {
- debug: () => {},
- info: () => {},
- warn: () => {},
- error: () => {},
- child: () => silentLog,
-};
-
-async function expectRejects(promise: Promise<unknown>, check: (err: unknown) => void) {
- try {
- await promise;
- } catch (err) {
- check(err);
- return;
- }
- throw new Error("Expected promise to reject");
-}
-
-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);
- }
- });
-
- 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);
- });
-
- it("respects numeric retry-after as seconds", () => {
- 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);
- });
-
- 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);
- });
-
- 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);
- });
-});
-
-describe("sleep", () => {
- it("rejects if signal already aborted", async () => {
- const c = new AbortController();
- c.abort();
- await expectRejects(sleep(1000, c.signal), (err) => expect(err).toBeInstanceOf(Error));
- });
-
- it("rejects when aborted mid-sleep", async () => {
- const c = new AbortController();
- const p = sleep(1000, c.signal);
- setTimeout(() => c.abort(), 10);
- await expectRejects(p, (err) => expect(err).toBeInstanceOf(Error));
- });
-});
-
-describe("retryOn429", () => {
- class FakeRateLimit extends Error {
- constructor(public retryAfter?: string) {
- super("rate limited");
- }
- }
-
- const retryWithFakeRateLimit = (retryAfter: string, onAttempt: () => void) =>
- retryOn429(
- async () => {
- onAttempt();
- throw new FakeRateLimit(retryAfter);
- },
- {
- log: silentLog,
- classify: (err) =>
- err instanceof FakeRateLimit ? { retryAfter: err.retryAfter } : undefined,
- },
- );
-
- it("returns successful result without retry", async () => {
- let calls = 0;
- const result = await retryOn429(
- async () => {
- calls++;
- return "ok";
- },
- {
- log: silentLog,
- classify: () => undefined,
- },
- );
- expect(result).toBe("ok");
- expect(calls).toBe(1);
- });
-
- const retryLimitCases: Array<{
- name: string;
- retryAfter: string;
- expectedCalls: number;
- maxDurationMs?: number;
- }> = [
- {
- name: "retries up to MAX_RATE_LIMIT_RETRIES then throws",
- retryAfter: "0",
- expectedCalls: MAX_RATE_LIMIT_RETRIES + 1,
- maxDurationMs: 2000,
- },
- {
- name: "gives up immediately when retry-after exceeds budget",
- retryAfter: "120",
- expectedCalls: 1,
- },
- ] as const;
-
- for (const tc of retryLimitCases) {
- it(tc.name, async () => {
- let calls = 0;
- const start = Date.now();
- await expectRejects(
- retryWithFakeRateLimit(tc.retryAfter, () => {
- calls++;
- }),
- (err) => expect(err).toBeInstanceOf(FakeRateLimit),
- );
- expect(calls).toBe(tc.expectedCalls);
- if (tc.maxDurationMs !== undefined) {
- expect(Date.now() - start).toBeLessThan(tc.maxDurationMs);
- }
- });
- }
-
- it("does not retry non-rate-limit errors", async () => {
- let calls = 0;
- await expectRejects(
- retryOn429(
- async () => {
- calls++;
- throw new Error("other");
- },
- {
- log: silentLog,
- classify: () => undefined,
- },
- ),
- (err) => expect(err).toEqual(new Error("other")),
- );
- expect(calls).toBe(1);
- });
-
- it("succeeds after a transient 429", async () => {
- let calls = 0;
- const result = await retryOn429(
- async () => {
- 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);
- });
-});
diff --git a/reference/typescript/src/providers/retry.ts b/reference/typescript/src/providers/retry.ts
deleted file mode 100644
index d257270..0000000
--- a/reference/typescript/src/providers/retry.ts
+++ /dev/null
@@ -1,89 +0,0 @@
-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;
-
-const STRICT_NUMERIC = /^\s*\d+(?:\.\d+)?\s*$/;
-
-export interface BackoffOutcome {
- 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 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);
- // 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 };
-}
-
-export function sleep(ms: number, signal?: AbortSignal): Promise<void> {
- return new Promise((resolve, reject) => {
- if (signal?.aborted) {
- reject(new DOMException("Aborted", "AbortError"));
- return;
- }
- const onAbort = () => {
- clearTimeout(timer);
- reject(new DOMException("Aborted", "AbortError"));
- };
- const timer = setTimeout(() => {
- signal?.removeEventListener("abort", onAbort);
- resolve();
- }, ms);
- signal?.addEventListener("abort", onAbort, { once: true });
- });
-}
-
-export interface RateLimitInfo {
- retryAfter?: string;
-}
-
-export interface RetryOptions {
- 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();
- } catch (err) {
- 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;
- }
- 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);
- }
- }
-}
diff --git a/reference/typescript/src/providers/shared/anthropic-sse.ts b/reference/typescript/src/providers/shared/anthropic-sse.ts
deleted file mode 100644
index 574c21c..0000000
--- a/reference/typescript/src/providers/shared/anthropic-sse.ts
+++ /dev/null
@@ -1,41 +0,0 @@
-/**
- * Emit the Anthropic `message_start` event followed by a `ping`.
- *
- * Every provider stream translator needs this exact sequence before any
- * content blocks, error events, or message_delta can be sent. The caller
- * owns stream-level state (whether start has already been emitted) and the
- * emit function.
- */
-export function emitMessageStart(
- emit: (event: string, data: unknown) => void,
- opts: {
- messageId: string;
- model: string;
- usage?: {
- input_tokens: number;
- output_tokens: number;
- cache_creation_input_tokens: number;
- cache_read_input_tokens: number;
- };
- },
-): void {
- emit("message_start", {
- type: "message_start",
- message: {
- id: opts.messageId,
- type: "message",
- role: "assistant",
- model: opts.model,
- content: [],
- stop_reason: null,
- stop_sequence: null,
- usage: opts.usage ?? {
- input_tokens: 0,
- output_tokens: 0,
- cache_creation_input_tokens: 0,
- cache_read_input_tokens: 0,
- },
- },
- });
- emit("ping", { type: "ping" });
-}
diff --git a/reference/typescript/src/providers/shared/auth/atomic-write.ts b/reference/typescript/src/providers/shared/auth/atomic-write.ts
deleted file mode 100644
index df7b6b7..0000000
--- a/reference/typescript/src/providers/shared/auth/atomic-write.ts
+++ /dev/null
@@ -1,9 +0,0 @@
-import { mkdir, writeFile, rename } from "node:fs/promises";
-import { dirname } from "node:path";
-
-export async function writeAtomicJson(path: string, data: unknown): Promise<void> {
- await mkdir(dirname(path), { recursive: true, mode: 0o700 });
- const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
- await writeFile(tmp, JSON.stringify(data, null, 2), { encoding: "utf8", mode: 0o600 });
- await rename(tmp, path);
-}
diff --git a/reference/typescript/src/providers/shared/auth/manager.ts b/reference/typescript/src/providers/shared/auth/manager.ts
deleted file mode 100644
index 8f97cd8..0000000
--- a/reference/typescript/src/providers/shared/auth/manager.ts
+++ /dev/null
@@ -1,76 +0,0 @@
-export interface TokenResponse {
- access_token: string;
- refresh_token: string;
- expires_in?: number;
-}
-
-export function validateTokenResponse<T extends TokenResponse>(t: unknown): asserts t is T {
- 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");
- 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");
-}
-
-export interface AuthLifecycle<T extends { expires: number }> {
- getAuth(): Promise<T>;
- forceRefresh(): Promise<T>;
- resetCache(): void;
- setCached(auth: T | undefined): void;
-}
-
-export function createAuthLifecycle<T extends { expires: number }>(deps: {
- loadAuth: () => Promise<T | undefined>;
- loginRequiredMessage: string;
- forceRefreshUnauthenticatedMessage: string;
- refreshMarginMs: number;
- refreshNow: (current: T) => Promise<T>;
-}): AuthLifecycle<T> {
- let cached: T | undefined;
- let inflight: Promise<T> | undefined;
-
- async function getAuth(): Promise<T> {
- if (!cached) {
- const stored = await deps.loadAuth();
- if (!stored) throw new Error(deps.loginRequiredMessage);
- cached = stored;
- }
- if (cached.expires - deps.refreshMarginMs > Date.now()) {
- return cached;
- }
- if (inflight) return inflight;
- inflight = deps.refreshNow(cached).finally(() => {
- inflight = undefined;
- });
- return inflight;
- }
-
- async function forceRefresh(): Promise<T> {
- if (!cached) {
- const stored = await deps.loadAuth();
- if (!stored) throw new Error(deps.forceRefreshUnauthenticatedMessage);
- cached = stored;
- }
- if (inflight) return inflight;
- inflight = deps.refreshNow(cached).finally(() => {
- inflight = undefined;
- });
- return inflight;
- }
-
- function resetCache(): void {
- cached = undefined;
- }
-
- function setCached(auth: T | undefined): void {
- cached = auth;
- }
-
- return { getAuth, forceRefresh, resetCache, setCached };
-}
diff --git a/reference/typescript/src/providers/shared/auth/token-store.ts b/reference/typescript/src/providers/shared/auth/token-store.ts
deleted file mode 100644
index 835922b..0000000
--- a/reference/typescript/src/providers/shared/auth/token-store.ts
+++ /dev/null
@@ -1,77 +0,0 @@
-import { readFile, unlink } from "node:fs/promises";
-import { keychainGet, keychainSet, keychainDelete } from "../../../keychain.ts";
-import { writeAtomicJson } from "./atomic-write.ts";
-
-const KEYCHAIN_ACCOUNT = "auth";
-
-export interface AuthStoreOptions {
- file: () => string;
- legacyFile: () => string;
- keychainService: string;
-}
-
-export interface AuthStore<T> {
- loadAuth(): Promise<T | undefined>;
- saveAuth(auth: T): Promise<void>;
- clearAuth(): Promise<void>;
- authPath(): string;
-}
-
-export function createAuthStore<T>(options: AuthStoreOptions): AuthStore<T> {
- const { file, legacyFile, keychainService } = options;
-
- return {
- async loadAuth(): Promise<T | undefined> {
- if (process.platform === "darwin") {
- const raw = keychainGet(keychainService, KEYCHAIN_ACCOUNT);
- if (!raw) return undefined;
- return JSON.parse(raw) as T;
- }
-
- const primary = file();
- try {
- const raw = await readFile(primary, "utf8");
- return JSON.parse(raw) as T;
- } catch (err: any) {
- if (err?.code !== "ENOENT") throw err;
- }
- const legacy = legacyFile();
- if (legacy === primary) return undefined;
- try {
- const raw = await readFile(legacy, "utf8");
- return JSON.parse(raw) as T;
- } catch (err: any) {
- if (err?.code === "ENOENT") return undefined;
- throw err;
- }
- },
-
- async saveAuth(auth: T): Promise<void> {
- if (process.platform === "darwin") {
- keychainSet(keychainService, KEYCHAIN_ACCOUNT, JSON.stringify(auth));
- return;
- }
-
- await writeAtomicJson(file(), auth);
- },
-
- async clearAuth(): Promise<void> {
- if (process.platform === "darwin") {
- keychainDelete(keychainService, KEYCHAIN_ACCOUNT);
- return;
- }
-
- for (const path of [file(), legacyFile()]) {
- try {
- await unlink(path);
- } catch (err: any) {
- if (err?.code !== "ENOENT") throw err;
- }
- }
- },
-
- authPath(): string {
- return process.platform === "darwin" ? "macOS Keychain" : file();
- },
- };
-}
diff --git a/reference/typescript/src/providers/shared/cli-status.ts b/reference/typescript/src/providers/shared/cli-status.ts
deleted file mode 100644
index 9f988a8..0000000
--- a/reference/typescript/src/providers/shared/cli-status.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-export interface AuthStatus {
- expires: number;
-}
-
-export interface AuthStatusPrinter<TAuth extends AuthStatus> {
- loadAuth: () => Promise<TAuth | undefined>;
- authPath: () => string;
- formatIdentityLine: (auth: TAuth) => string;
- extraLines?: (auth: TAuth) => string[];
-}
-
-export async function printAuthStatus<TAuth extends AuthStatus>(
- options: AuthStatusPrinter<TAuth>,
-): Promise<void> {
- const auth = await options.loadAuth();
- if (!auth) {
- console.log("Not authenticated");
- process.exit(1);
- }
- const ms = auth.expires - Date.now();
- console.log(options.formatIdentityLine(auth));
- console.log(`Expires: ${new Date(auth.expires).toISOString()} (in ${Math.floor(ms / 1000)}s)`);
- for (const line of options.extraLines?.(auth) ?? []) {
- console.log(line);
- }
- console.log(`Storage: ${options.authPath()}`);
-}
diff --git a/reference/typescript/src/providers/shared/count-tokens.ts b/reference/typescript/src/providers/shared/count-tokens.ts
deleted file mode 100644
index 8800004..0000000
--- a/reference/typescript/src/providers/shared/count-tokens.ts
+++ /dev/null
@@ -1,126 +0,0 @@
-import { countToolSchemaTokens } from "./tool-schema.ts";
-import {
- flattenSystemText,
- normalizeContent,
- toolResultToString,
-} from "../translate/anthropic-content.ts";
-import type { AnthropicRequest, AnthropicTool } from "../../anthropic/schema.ts";
-
-export const IMAGE_TOKEN_ESTIMATE = 2000;
-
-export function countContentParts(
- content: string | { type: string; text?: string }[],
- countToken: (text: string) => number,
-): number {
- if (typeof content === "string") return countToken(content);
- let total = 0;
- for (const p of content) {
- if (p.type === "text") total += countToken(p.text ?? "");
- else total += IMAGE_TOKEN_ESTIMATE;
- }
- return total;
-}
-
-export type AnthropicRequestTokenCounter = (text: string) => number;
-
-export function countAnthropicTokens(
- req: AnthropicRequest,
- countToken: AnthropicRequestTokenCounter,
- includeThinking = false,
-): number {
- const base = {
- req,
- countToken,
- tools: req.tools,
- readToolName: (tool: AnthropicTool) => tool.name,
- readToolDescription: (tool: AnthropicTool) =>
- "description" in tool ? tool.description : undefined,
- readToolSchema: (tool: AnthropicTool) => ("input_schema" in tool ? tool.input_schema : {}),
- };
- if (includeThinking) {
- return countAnthropicRequestTokensWithSystem({ ...base, includeThinking: true });
- }
- return countAnthropicRequestTokensWithSystem({ ...base, includeThinking: false });
-}
-
-type AnthropicToolReaders<TTool> = {
- readToolName: (tool: TTool) => string;
- readToolDescription: (tool: TTool) => string | undefined;
- readToolSchema: (tool: TTool) => unknown;
-};
-
-type CountAnthropicRequestTokenOptions<TTool> = {
- req: AnthropicRequest;
- countToken: AnthropicRequestTokenCounter;
- tools?: TTool[];
-} & AnthropicToolReaders<TTool>;
-
-export function countAnthropicRequestTokens<TTool>(
- options: CountAnthropicRequestTokenOptions<TTool> & {
- includeThinking?: false;
- },
-): number;
-
-export function countAnthropicRequestTokens<TTool>(
- options: CountAnthropicRequestTokenOptions<TTool> & {
- includeThinking: true;
- },
-): number;
-
-export function countAnthropicRequestTokens<TTool>({
- req,
- countToken,
- tools,
- readToolName,
- readToolDescription,
- readToolSchema,
- includeThinking = false,
-}: CountAnthropicRequestTokenOptions<TTool> & { includeThinking?: boolean }): number {
- let total = 0;
- for (const msg of req.messages) {
- const blocks = normalizeContent(msg.content);
- for (const block of blocks) {
- if (block.type === "text") {
- total += countToken(block.text);
- } else if (block.type === "image") {
- total += IMAGE_TOKEN_ESTIMATE;
- } else if (block.type === "tool_use") {
- total += countToken(block.name);
- total += countToken(JSON.stringify(block.input ?? {}));
- } else if (block.type === "tool_result") {
- total += countToken(toolResultToString(block.content));
- } else if (includeThinking && block.type === "thinking") {
- total += countToken(block.thinking);
- }
- }
- }
-
- total += countToolSchemaTokens(tools, readToolName, readToolDescription, readToolSchema);
-
- total += req.messages.length * 4;
- return total;
-}
-
-export function countAnthropicRequestTokensWithSystem<TTool>(
- options: CountAnthropicRequestTokenOptions<TTool> & {
- includeThinking?: false;
- },
-): number;
-
-export function countAnthropicRequestTokensWithSystem<TTool>(
- options: CountAnthropicRequestTokenOptions<TTool> & {
- includeThinking: true;
- },
-): number;
-
-export function countAnthropicRequestTokensWithSystem<TTool>(
- options: CountAnthropicRequestTokenOptions<TTool> & { includeThinking?: boolean },
-): number {
- let total = 0;
- const system = flattenSystemText(options.req.system);
- if (system) total += options.countToken(system);
- total += options.includeThinking
- ? countAnthropicRequestTokens({ ...options, includeThinking: true })
- : countAnthropicRequestTokens({ ...options, includeThinking: false });
- return total;
-}
diff --git a/reference/typescript/src/providers/shared/tool-schema.ts b/reference/typescript/src/providers/shared/tool-schema.ts
deleted file mode 100644
index 10be422..0000000
--- a/reference/typescript/src/providers/shared/tool-schema.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { encode } from "gpt-tokenizer/model/gpt-4o";
-
-export function countToolSchemaTokens<T>(
- tools: Array<T> | undefined,
- readName: (tool: T) => string,
- readDescription: (tool: T) => string | undefined,
- readSchema: (tool: T) => unknown,
-): number {
- let total = 0;
- for (const tool of tools ?? []) {
- total += encode(readName(tool)).length;
- const description = readDescription(tool);
- if (description) total += encode(description).length;
- total += encode(JSON.stringify(readSchema(tool) ?? {})).length;
- }
- return total;
-}
diff --git a/reference/typescript/src/providers/shared/upstream-errors.ts b/reference/typescript/src/providers/shared/upstream-errors.ts
deleted file mode 100644
index 175dd41..0000000
--- a/reference/typescript/src/providers/shared/upstream-errors.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-import { anthropicErrorBody, jsonError, jsonResponse } from "../../anthropic/response.ts";
-
-export interface UpstreamHttpError {
- status: number;
- detail?: string;
- message: string;
- meta?: {
- retryAfter?: string;
- };
-}
-
-export interface UpstreamStreamErrorLike {
- kind: string;
- retryAfterSeconds?: number;
- message: string;
-}
-
-export function mapUpstreamHttpErrorToResponse(err: UpstreamHttpError): Response {
- if (err.status === 429) {
- const headers: Record<string, string> = {};
- if (err.meta?.retryAfter) headers["retry-after"] = err.meta.retryAfter;
- return jsonResponse(anthropicErrorBody("rate_limit_error", 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);
-}
-
-export function mapUpstreamStreamErrorToResponse(err: UpstreamStreamErrorLike): Response {
- if (err.kind === "rate_limit") {
- const headers: Record<string, string> = {};
- if (err.retryAfterSeconds) headers["retry-after"] = String(err.retryAfterSeconds);
- return jsonResponse(anthropicErrorBody("rate_limit_error", err.message), {
- status: 429,
- headers,
- });
- }
- if (err.kind === "overloaded") {
- const headers: Record<string, string> = {};
- if (err.retryAfterSeconds) headers["retry-after"] = String(err.retryAfterSeconds);
- return jsonResponse(anthropicErrorBody("overloaded_error", err.message), {
- status: 529,
- headers,
- });
- }
- return jsonError(502, "api_error", err.message);
-}
diff --git a/reference/typescript/src/providers/translate/accumulate.ts b/reference/typescript/src/providers/translate/accumulate.ts
deleted file mode 100644
index 30d5e66..0000000
--- a/reference/typescript/src/providers/translate/accumulate.ts
+++ /dev/null
@@ -1,211 +0,0 @@
-export type AccumulatedTextBlock = {
- kind: "text";
- index: number;
- text: string;
-};
-
-export type AccumulatedThinkingBlock = {
- kind: "thinking";
- index: number;
- text: string;
-};
-
-export type AccumulatedToolBlock = {
- kind: "tool";
- index: number;
- id: string;
- name: string;
- args: string;
-};
-
-export type AccumulatedBlock =
- | AccumulatedTextBlock
- | AccumulatedThinkingBlock
- | AccumulatedToolBlock;
-
-export interface BlockAccumulator {
- onTextStart(index: number): void;
- onTextDelta(index: number, text: string): boolean;
- onThinkingStart(index: number): void;
- onThinkingDelta(index: number, text: string): boolean;
- onToolStart(index: number, id: string, name: string): void;
- onToolDelta(index: number, partialJson: string): boolean;
- orderedBlocks(): readonly AccumulatedBlock[];
-}
-
-export interface AnthropicNonStreamUsage {
- input_tokens: number;
- output_tokens: number;
- cache_creation_input_tokens: number;
- cache_read_input_tokens: number;
- server_tool_use?: {
- web_search_requests?: number;
- };
-}
-
-export type AnthropicTextContent = { type: "text"; text: string };
-export type AnthropicThinkingContent = { type: "thinking"; thinking: string; signature: string };
-export type AnthropicToolUseContent = {
- type: "tool_use";
- id: string;
- name: string;
- input: unknown;
-};
-export type AnthropicServerToolUseContent = {
- type: "server_tool_use";
- id: string;
- name: "web_search";
- input: { query: string };
-};
-export type AnthropicWebSearchResultContent = {
- type: "web_search_result";
- title: string;
- url: string;
- page_age?: string | null;
-};
-export type AnthropicWebSearchToolResultContent = {
- type: "web_search_tool_result";
- tool_use_id: string;
- content: AnthropicWebSearchResultContent[];
-};
-
-export type AnthropicNonStreamContent =
- | AnthropicTextContent
- | AnthropicThinkingContent
- | AnthropicToolUseContent
- | AnthropicServerToolUseContent
- | AnthropicWebSearchToolResultContent;
-
-export interface AnthropicNonStreamResponse<ContentType = AnthropicNonStreamContent> {
- id: string;
- type: "message";
- role: "assistant";
- model: string;
- content: Array<ContentType>;
- stop_reason: "end_turn" | "tool_use" | "max_tokens" | null;
- stop_sequence: null;
- usage: AnthropicNonStreamUsage;
-}
-
-export interface CachedInputUsage {
- inputTokens?: number;
- outputTokens?: number;
- cachedInputTokens?: number;
-}
-
-export type TextToolReducerEvent =
- | { kind: "text-start"; index: number }
- | { kind: "text-delta"; index: number; text: string }
- | { kind: "text-stop"; index: number }
- | { kind: "tool-start"; index: number; id: string; name: string }
- | { kind: "tool-delta"; index: number; partialJson: string }
- | { kind: "tool-stop"; index: number };
-
-export function defaultAnthropicNonStreamUsage(): AnthropicNonStreamUsage {
- return {
- input_tokens: 0,
- output_tokens: 0,
- cache_creation_input_tokens: 0,
- cache_read_input_tokens: 0,
- };
-}
-
-export function mapCachedInputUsageToAnthropicUsage(
- usage: CachedInputUsage = {},
-): AnthropicNonStreamUsage {
- const inputTokens = usage.inputTokens ?? 0;
- const outputTokens = usage.outputTokens ?? 0;
- const cachedTokens = Math.max(0, usage.cachedInputTokens ?? 0);
- return {
- input_tokens: Math.max(0, inputTokens - cachedTokens),
- output_tokens: outputTokens,
- cache_creation_input_tokens: 0,
- cache_read_input_tokens: cachedTokens,
- };
-}
-
-export function collectAnthropicContentFromAccumulatedBlocks<TContent>(
- blocks: readonly AccumulatedBlock[],
- handlers: {
- onThinking?: (index: number, text: string) => TContent | undefined;
- onText: (index: number, text: string) => TContent | undefined;
- onTool: (index: number, id: string, name: string, args: string) => TContent | undefined;
- },
-): TContent[] {
- const content: TContent[] = [];
- for (const block of blocks) {
- if (block.kind === "thinking") {
- const item = handlers.onThinking?.(block.index, block.text);
- if (item !== undefined) content.push(item);
- continue;
- }
- if (block.kind === "text") {
- const item = handlers.onText(block.index, block.text);
- if (item !== undefined) content.push(item);
- continue;
- }
- const item = handlers.onTool(block.index, block.id, block.name, block.args);
- if (item !== undefined) content.push(item);
- }
- return content;
-}
-
-export function createBlockAccumulator(options?: { includeThinking?: boolean }): BlockAccumulator {
- const ordered: number[] = [];
- const blocks = new Map<number, AccumulatedBlock>();
- const includeThinking = options?.includeThinking === true;
-
- return {
- onTextStart(index: number): void {
- blocks.set(index, { kind: "text", index, text: "" });
- ordered.push(index);
- },
- onTextDelta(index: number, text: string): boolean {
- const block = blocks.get(index);
- if (block?.kind === "text") {
- block.text += text;
- return true;
- }
- return false;
- },
- onThinkingStart(index: number): void {
- if (!includeThinking) return;
- blocks.set(index, { kind: "thinking", index, text: "" });
- ordered.push(index);
- },
- onThinkingDelta(index: number, text: string): boolean {
- const block = blocks.get(index);
- if (block?.kind === "thinking") {
- block.text += text;
- return true;
- }
- return false;
- },
- onToolStart(index: number, id: string, name: string): void {
- blocks.set(index, { kind: "tool", index, id, name, args: "" });
- ordered.push(index);
- },
- onToolDelta(index: number, partialJson: string): boolean {
- const block = blocks.get(index);
- if (block?.kind === "tool") {
- block.args += partialJson;
- return true;
- }
- return false;
- },
- orderedBlocks(): readonly AccumulatedBlock[] {
- return ordered.flatMap((index) => {
- const block = blocks.get(index);
- return block ? [block] : [];
- });
- },
- };
-}
-
-export function parseToolInputJsonOrRaw(args: string): unknown {
- try {
- return args ? JSON.parse(args) : {};
- } catch {
- return { _raw: args };
- }
-}
diff --git a/reference/typescript/src/providers/translate/anthropic-content.ts b/reference/typescript/src/providers/translate/anthropic-content.ts
deleted file mode 100644
index 3f31d7c..0000000
--- a/reference/typescript/src/providers/translate/anthropic-content.ts
+++ /dev/null
@@ -1,103 +0,0 @@
-import type {
- AnthropicContentBlock,
- AnthropicImageBlock,
- AnthropicMessage,
- AnthropicRequest,
- AnthropicTextBlock,
- AnthropicToolResultContentBlock,
-} from "../../anthropic/schema.ts";
-
-const ANTHROPIC_EFFORTS = new Set(["low", "medium", "high", "max"]);
-
-export function assertValidEffort(effort: unknown): void {
- if (effort !== undefined && !ANTHROPIC_EFFORTS.has(effort as string)) {
- throw new Error(
- `Invalid output_config.effort: ${JSON.stringify(effort)}. Must be one of: ${Array.from(ANTHROPIC_EFFORTS).join(", ")}`,
- );
- }
-}
-
-export type AnthropicToolChoice = "auto" | "none" | "required" | { type: "function"; name: string };
-
-export function mapToolChoice(
- choice?: AnthropicRequest["tool_choice"],
-): AnthropicToolChoice {
- if (!choice) return "auto";
- switch (choice.type) {
- case "auto":
- return "auto";
- case "none":
- return "none";
- case "any":
- return "required";
- case "tool":
- return choice.name ? { type: "function", name: choice.name } : "required";
- }
-}
-
-export function flattenSystemText(system: AnthropicRequest["system"]): string | undefined {
- if (!system) return undefined;
- const blocks: AnthropicTextBlock[] =
- 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");
-}
-
-export function normalizeContent(content: AnthropicMessage["content"]): AnthropicContentBlock[] {
- if (typeof content === "string") return [{ type: "text", text: content }];
- return content;
-}
-
-export function imageBlockToUrl(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}`;
-}
-
-export function unsupportedToolResultBlockToString(
- block: AnthropicToolResultContentBlock,
-): string {
- const type = typeof block.type === "string" ? block.type : "unknown";
- return `[unsupported content block omitted: ${type}]`;
-}
-
-export function isToolResultTextBlock(
- block: AnthropicToolResultContentBlock,
-): block is AnthropicTextBlock {
- return block.type === "text" && typeof block.text === "string";
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
- return !!value && typeof value === "object";
-}
-
-export 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";
- 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;
- return content
- .map((b) => {
- if (isToolResultTextBlock(b)) return b.text;
- if (isToolResultImageBlock(b)) {
- const mt = b.source.type === "base64" ? b.source.media_type : "url";
- return `[image omitted: ${mt}]`;
- }
- return unsupportedToolResultBlockToString(b);
- })
- .join("\n");
-}
diff --git a/reference/typescript/src/providers/types.ts b/reference/typescript/src/providers/types.ts
deleted file mode 100644
index 479a7c8..0000000
--- a/reference/typescript/src/providers/types.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import type { AnthropicRequest } from "../anthropic/schema.ts";
-
-import type { Logger } from "../log.ts";
-
-export interface TrafficCapture {
- writeJson(name: string, value: unknown): void;
- writeText(name: string, value: string): void;
- writeBytes(name: string, value: Uint8Array): void;
- writeJsonEvent(name: string, value: unknown): void;
-}
-
-export interface RequestContext {
- reqId: string;
- sessionId?: string;
- sessionSeq?: number;
- signal: AbortSignal;
- traffic?: TrafficCapture;
- childLogger(service: string): Logger;
-}
-
-export interface CliHandlers {
- login?: () => Promise<void>;
- device?: () => Promise<void>;
- status: () => Promise<void>;
- logout: () => Promise<void>;
-}
-
-export interface Provider {
- 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;
-}
diff --git a/reference/typescript/src/server.test.ts b/reference/typescript/src/server.test.ts
deleted file mode 100644
index b3e0e39..0000000
--- a/reference/typescript/src/server.test.ts
+++ /dev/null
@@ -1,162 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import { loadConfig } from "./config.ts";
-import type { createLogger } from "./log.ts";
-import { startServer, normalizeIncomingModel, wrapStreamResponse } from "./server.ts";
-import { groupSupportedModelsByProvider } from "./providers/registry.ts";
-import { startTestServer } from "./test/server.ts";
-import { resetSessionsForTest } from "./server/session-affinity.ts";
-
-const servers: Array<{ stop: () => void }> = [];
-
-afterEach(() => {
- for (const server of servers.splice(0)) server.stop();
- loadConfig({ forceReload: true });
- resetSessionsForTest();
-});
-
-function countTokens(port: number, model: string, sessionId?: string): Promise<Response> {
- return fetch(`http://127.0.0.1:${port}/v1/messages/count_tokens`, {
- method: "POST",
- headers: {
- "content-type": "application/json",
- ...(sessionId ? { "x-claude-code-session-id": sessionId } : {}),
- },
- body: JSON.stringify({ model, messages: [{ role: "user", content: "hello" }] }),
- });
-}
-
-describe("normalizeIncomingModel", () => {
- it("removes Claude Code local context hints without changing the model id otherwise", () => {
- expect(normalizeIncomingModel("gpt-5.5[1m]")).toBe("gpt-5.5");
- expect(normalizeIncomingModel("gpt-5.4-fast[1m]")).toBe("gpt-5.4-fast");
- expect(normalizeIncomingModel("kimi-for-coding")).toBe("kimi-for-coding");
- });
-});
-
-describe("server error responses", () => {
- it("returns JSON for health checks", async () => {
- const server = startTestServer(startServer);
- servers.push(server);
-
- const resp = await fetch(`http://127.0.0.1:${server.port}/healthz`);
- const body = (await resp.json()) as { ok: boolean };
-
- expect(resp.status).toBe(200);
- expect(resp.headers.get("content-type")).toBe("application/json");
- expect(body).toEqual({ ok: true });
- });
-
- it("returns JSON for unknown routes", async () => {
- const server = startTestServer(startServer);
- servers.push(server);
-
- const resp = await fetch(`http://127.0.0.1:${server.port}/not-a-route`);
- const body = (await resp.json()) as { type: string; error: { type: string; message: string } };
-
- expect(resp.status).toBe(404);
- expect(resp.headers.get("content-type")).toBe("application/json");
- expect(body).toEqual({
- type: "error",
- error: {
- type: "not_found",
- message: "No route for GET /not-a-route",
- },
- });
- });
-
- it("keeps invalid JSON request parsing failures as JSON", async () => {
- const server = startTestServer(startServer);
- servers.push(server);
-
- const resp = await fetch(`http://127.0.0.1:${server.port}/v1/messages`, {
- method: "POST",
- headers: { "content-type": "application/json" },
- body: "{",
- });
- const body = (await resp.json()) as { error: { type: string; message: string } };
-
- expect(resp.status).toBe(400);
- expect(resp.headers.get("content-type")).toBe("application/json");
- expect(body.error.type).toBe("invalid_request_error");
- });
-
- it("uses active alias-provider grouping in unknown-model errors", async () => {
- loadConfig({ env: { CCP_ALIAS_PROVIDER: "kimi" }, forceReload: true });
- const server = startTestServer(startServer);
- servers.push(server);
-
- const resp = await fetch(`http://127.0.0.1:${server.port}/v1/messages`, {
- method: "POST",
- headers: { "content-type": "application/json" },
- body: JSON.stringify({
- model: "not-a-real-model",
- messages: [{ role: "user", content: "hello" }],
- }),
- });
- const body = (await resp.json()) as { error: { message: string } };
-
- const parts: string[] = [];
- for (const [provider, models] of groupSupportedModelsByProvider()) {
- parts.push(`${provider}: ${models.join(", ")}`);
- }
-
- expect(resp.status).toBe(400);
- expect(body.error.message).toBe(
- `Unknown model "not-a-real-model". Supported: ${parts.join("; ")}.`,
- );
- expect([...groupSupportedModelsByProvider().keys()]).toEqual(["codex", "kimi", "cursor"]);
- expect(groupSupportedModelsByProvider().get("kimi")).toEqual(
- expect.arrayContaining(["haiku", "sonnet", "opus"]),
- );
- });
-});
-
-describe("stream wrapper", () => {
- it("strips hop-by-hop headers when wrapping upstream streams", async () => {
- const upstream = new Response("hello", {
- status: 207,
- statusText: "Multi-Status",
- headers: {
- "content-encoding": "gzip",
- "content-length": "5",
- "transfer-encoding": "chunked",
- "x-upstream": "ok",
- },
- });
-
- const wrapped = wrapStreamResponse(upstream, "test", 0, {
- info() {},
- error() {},
- warn() {},
- debug() {},
- child() {
- return this;
- },
- } as ReturnType<typeof createLogger>);
-
- expect(wrapped.status).toBe(207);
- expect(wrapped.statusText).toBe("Multi-Status");
- expect(wrapped.headers.get("content-encoding")).toBeNull();
- expect(wrapped.headers.get("content-length")).toBeNull();
- expect(wrapped.headers.get("transfer-encoding")).toBeNull();
- expect(wrapped.headers.get("x-upstream")).toBe("ok");
- expect(await wrapped.text()).toBe("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 = startTestServer(startServer);
- 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");
-
- 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/reference/typescript/src/server.ts b/reference/typescript/src/server.ts
deleted file mode 100644
index f547fe8..0000000
--- a/reference/typescript/src/server.ts
+++ /dev/null
@@ -1,262 +0,0 @@
-import { createLogger, logDir, REDACT_KEYS } from "./log.ts";
-import { createTrafficCapture, headersToRecord } from "./traffic.ts";
-import { jsonError, jsonResponse, streamResponse } from "./anthropic/response.ts";
-
-import type { AnthropicRequest } from "./anthropic/schema.ts";
-import type { AliasProvider } from "./config.ts";
-import type { Provider, RequestContext } from "./providers/types.ts";
-import {
- groupSupportedModelsByProvider,
- normalizeIncomingModel,
- providerForModel,
-} from "./providers/registry.ts";
-import {
- existingSession,
- recordSessionRequest,
- type SessionState,
-} from "./server/session-affinity.ts";
-
-export { normalizeIncomingModel };
-
-const rootLog = createLogger("server");
-
-export interface ServeOptions {
- port: number;
-}
-
-export function startServer(opts: ServeOptions): { stop: () => void; port: number } {
- const server = Bun.serve({
- hostname: "127.0.0.1",
- port: opts.port,
- idleTimeout: 255,
- async fetch(req) {
- 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);
- } catch (err) {
- if (isAbortError(err)) {
- 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.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 jsonResponse({ ok: true });
- }
-
- if (req.method === "POST" && url.pathname === "/v1/messages/count_tokens") {
- return routeAnthropicPost(req, url, reqId, "count_tokens");
- }
-
- if (req.method === "POST" && url.pathname === "/v1/messages") {
- return routeAnthropicPost(req, url, reqId, "messages");
- }
-
- return jsonError(404, "not_found", `No route for ${req.method} ${url.pathname}`);
-}
-
-async function routeAnthropicPost(
- req: Request,
- url: URL,
- reqId: string,
- kind: "messages" | "count_tokens",
-): Promise<Response> {
- 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);
- captureInboundTraffic(ctx, req, url, body, kind, provider.name);
- ctx.childLogger("server").info("dispatch", { model: body.model });
- return kind === "messages"
- ? provider.handleMessages(body, ctx)
- : provider.handleCountTokens(body, ctx);
-}
-
-function buildCtx(
- req: Request,
- reqId: string,
- providerName: string,
- sessionId: string | undefined,
- session: SessionState | undefined,
-): RequestContext {
- const sessionSeq = session?.seq;
- const bindings = { reqId, sessionId, sessionSeq, provider: providerName };
- return {
- reqId,
- sessionId,
- sessionSeq,
- signal: req.signal,
- traffic: createTrafficCapture({ reqId, sessionId, sessionSeq, provider: providerName }),
- childLogger: (service) => createLogger(service, bindings),
- };
-}
-
-function captureInboundTraffic(
- ctx: RequestContext,
- req: Request,
- url: URL,
- body: AnthropicRequest,
- kind: "messages" | "count_tokens",
- provider: string,
-): void {
- if (!ctx.traffic) return;
- ctx.traffic.writeJson("000-metadata", {
- reqId: ctx.reqId,
- sessionId: ctx.sessionId,
- sessionSeq: ctx.sessionSeq,
- kind,
- provider,
- model: body.model,
- method: req.method,
- path: url.pathname,
- query: redactedQuery(url),
- headers: headersToRecord(req.headers),
- });
- ctx.traffic.writeJson("010-anthropic-request", body);
-}
-
-function routeProvider(
- body: AnthropicRequest,
- reqId: string,
- sessionAliasProvider?: AliasProvider,
-): Provider | Response {
- if (!body.model) {
- return jsonError(
- 400,
- "invalid_request_error",
- `Missing "model" in request body. ${knownModelsMessage()}`,
- );
- }
- body.model = normalizeIncomingModel(body.model);
- const provider = providerForModel(body.model, sessionAliasProvider);
- if (!provider) {
- rootLog.warn("unknown model", { reqId, model: body.model });
- return jsonError(
- 400,
- "invalid_request_error",
- `Unknown model "${body.model}". ${knownModelsMessage()}`,
- );
- }
- return provider;
-}
-
-function knownModelsMessage(): string {
- const parts: string[] = [];
- for (const [provider, models] of groupSupportedModelsByProvider()) {
- parts.push(`${provider}: ${models.join(", ")}`);
- }
- return `Supported: ${parts.join("; ")}.`;
-}
-
-async function parseJsonBody(req: Request): Promise<AnthropicRequest | Response> {
- try {
- return (await req.json()) as AnthropicRequest;
- } catch (err) {
- return jsonError(400, "invalid_request_error", `Invalid JSON: ${String(err)}`);
- }
-}
-
-function isAbortError(err: unknown): boolean {
- return err instanceof Error && err.name === "AbortError";
-}
-
-function isClosedControllerError(err: unknown): boolean {
- return err instanceof TypeError && err.message.includes("Controller is already closed");
-}
-
-export function wrapStreamResponse(
- resp: Response,
- reqId: string,
- start: number,
- log: ReturnType<typeof createLogger>,
-): Response {
- const body = resp.body!;
- const reader = body.getReader();
- let closed = false;
- const stream = new ReadableStream<Uint8Array>({
- async pull(controller) {
- if (closed) return;
- const safeClose = () => {
- if (closed) return;
- closed = true;
- try {
- controller.close();
- } catch {}
- };
- const safeError = (err: unknown) => {
- if (closed) return;
- closed = true;
- try {
- controller.error(err);
- } catch {}
- };
- try {
- const { done, value } = await reader.read();
- if (closed) return;
- if (done) {
- log.info("request_completed", { reqId, status: resp.status, ms: Date.now() - start });
- safeClose();
- return;
- }
- try {
- controller.enqueue(value);
- } catch (err) {
- if (!isClosedControllerError(err)) {
- log.error("stream error", { reqId, err: String(err) });
- reader.cancel().catch(() => {});
- safeError(err);
- } else {
- closed = true;
- }
- }
- } catch (err) {
- if (isAbortError(err) || isClosedControllerError(err)) {
- log.info("client disconnected", { reqId, ms: Date.now() - start });
- } else {
- log.error("stream error", { reqId, err: String(err) });
- }
- safeError(err);
- }
- },
- cancel() {
- closed = true;
- reader.cancel().catch(() => {});
- },
- });
- return streamResponse(resp, stream);
-}
-
-function redactedQuery(url: URL): 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;
- }
- return out;
-}
diff --git a/reference/typescript/src/server/session-affinity.test.ts b/reference/typescript/src/server/session-affinity.test.ts
deleted file mode 100644
index 0e2a0fd..0000000
--- a/reference/typescript/src/server/session-affinity.test.ts
+++ /dev/null
@@ -1,68 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import {
- MAX_SESSIONS,
- SESSION_IDLE_TTL_MS,
- existingSession,
- recordSessionRequest,
- resetSessionsForTest,
-} from "./session-affinity.ts";
-
-describe("server session affinity", () => {
- it("records concrete codex and kimi affinity for later aliases", () => {
- resetSessionsForTest();
- const codex = recordSessionRequest("codex-session", undefined, "codex", "gpt-5.4", 1);
- const kimi = recordSessionRequest("kimi-session", undefined, "kimi", "kimi-for-coding", 1);
-
- expect(codex?.affinityProvider).toBe("codex");
- expect(kimi?.affinityProvider).toBe("kimi");
- expect(existingSession("codex-session", 2)?.affinityProvider).toBe("codex");
- expect(existingSession("kimi-session", 2)?.affinityProvider).toBe("kimi");
- });
-
- it("does not overwrite affinity for aliases or cursor requests", () => {
- resetSessionsForTest();
- const first = recordSessionRequest("session", undefined, "codex", "gpt-5.4", 1);
- const alias = recordSessionRequest("session", first, "kimi", "sonnet", 2);
- const cursor = recordSessionRequest("session", alias, "cursor", "cursor-agent", 3);
-
- expect(alias?.affinityProvider).toBe("codex");
- expect(cursor?.affinityProvider).toBe("codex");
- expect(cursor?.seq).toBe(3);
- });
-
- it("expires idle sessions with the current TTL boundary", () => {
- resetSessionsForTest();
- const state = recordSessionRequest("session", undefined, "kimi", "kimi-for-coding", 100);
-
- expect(existingSession("session", 100 + SESSION_IDLE_TTL_MS)).toBe(state);
- expect(existingSession("session", 100 + SESSION_IDLE_TTL_MS + 1)).toBeUndefined();
- });
-
- it("evicts oldest sessions when the maximum is exceeded", () => {
- resetSessionsForTest();
- for (let i = 0; i <= MAX_SESSIONS; i += 1) {
- recordSessionRequest(`session-${i}`, undefined, "codex", "gpt-5.4", i);
- }
-
- expect(existingSession("session-0", MAX_SESSIONS + 1)).toBeUndefined();
- expect(existingSession("session-1", MAX_SESSIONS + 1)).toBeDefined();
- expect(existingSession(`session-${MAX_SESSIONS}`, MAX_SESSIONS + 1)).toBeDefined();
- });
-
- it("evicts by oldest map key rather than most recent lastSeen", () => {
- resetSessionsForTest();
- recordSessionRequest("session-0", undefined, "codex", "gpt-5.4", 0);
-
- for (let i = 1; i < MAX_SESSIONS; i += 1) {
- recordSessionRequest(`session-${i}`, undefined, "codex", "gpt-5.4", i);
- }
-
- const existing = existingSession("session-0", MAX_SESSIONS);
- recordSessionRequest("session-0", existing, "codex", "gpt-5.4", MAX_SESSIONS);
- recordSessionRequest("overflow", undefined, "codex", "gpt-5.4", MAX_SESSIONS + 1);
-
- expect(existingSession("session-0", MAX_SESSIONS + 2)).toBeUndefined();
- expect(existingSession("session-1", MAX_SESSIONS + 2)).toBeDefined();
- });
-});
-
diff --git a/reference/typescript/src/server/session-affinity.ts b/reference/typescript/src/server/session-affinity.ts
deleted file mode 100644
index ea79f28..0000000
--- a/reference/typescript/src/server/session-affinity.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import type { AliasProvider } from "../config.ts";
-import { ANTHROPIC_STYLE_ALIASES } from "../providers/registry.ts";
-
-export interface SessionState {
- seq: number;
- affinityProvider?: AliasProvider;
- lastSeen: number;
-}
-
-export const SESSION_IDLE_TTL_MS = 30 * 60 * 1000;
-export const MAX_SESSIONS = 10_000;
-
-const sessions = new Map<string, SessionState>();
-
-export 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;
-}
-
-export function recordSessionRequest(
- sessionId: string | undefined,
- session: SessionState | undefined,
- providerName: string,
- 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 (affinityProvider && !ANTHROPIC_STYLE_ALIASES.has(model)) {
- state.affinityProvider = affinityProvider;
- }
- sessions.set(sessionId, state);
- evictOldestSessions();
- return state;
-}
-
-export function resetSessionsForTest(): void {
- sessions.clear();
-}
-
-function affinityProviderFor(providerName: string): AliasProvider | 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);
- }
-}
-
diff --git a/reference/typescript/src/sse.ts b/reference/typescript/src/sse.ts
deleted file mode 100644
index 92c4cb6..0000000
--- a/reference/typescript/src/sse.ts
+++ /dev/null
@@ -1,90 +0,0 @@
-export interface SseEvent {
- event?: string;
- data: string;
-}
-
-export interface SseStreamStats {
- bytesRead: number;
- chunkCount: number;
- eventCount: number;
- startedAt: number;
- lastChunkAt?: number;
- lastEventAt?: number;
-}
-
-export function createSseStreamStats(now = Date.now()): SseStreamStats {
- return {
- bytesRead: 0,
- chunkCount: 0,
- eventCount: 0,
- startedAt: now,
- };
-}
-
-export function encodeSseEvent(event: string, data: unknown): string {
- return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
-}
-
-const BOUNDARY = /\r\n\r\n|\n\n|\r\r/;
-
-export async function* parseSseStream(
- body: ReadableStream<Uint8Array>,
- stats = createSseStreamStats(),
-): AsyncGenerator<SseEvent> {
- const reader = body.getReader();
- const decoder = new TextDecoder();
- let buf = "";
- let completed = false;
- try {
- while (true) {
- const { value, done } = await reader.read();
- if (done) {
- completed = true;
- break;
- }
- stats.bytesRead += value.byteLength;
- stats.chunkCount += 1;
- stats.lastChunkAt = Date.now();
- 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) {
- stats.eventCount += 1;
- stats.lastEventAt = Date.now();
- yield evt;
- }
- }
- }
- if (buf.trim()) {
- const evt = parseEventBlock(buf);
- if (evt) {
- stats.eventCount += 1;
- stats.lastEventAt = Date.now();
- yield evt;
- }
- }
- completed = true;
- } finally {
- if (!completed) await reader.cancel("SSE parser closed before stream end").catch(() => {});
- reader.releaseLock();
- }
-}
-
-function parseEventBlock(raw: string): SseEvent | undefined {
- 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 (!dataLines.length && !event) return undefined;
- return { event, data: dataLines.join("\n") };
-}
diff --git a/reference/typescript/src/test/server.test.ts b/reference/typescript/src/test/server.test.ts
deleted file mode 100644
index 3f99cfd..0000000
--- a/reference/typescript/src/test/server.test.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { startTestServer } from "./server.ts";
-
-function bindError(): Error & { code: string } {
- const err = new Error("address already in use") as Error & { code: string };
- err.code = "EADDRINUSE";
- return err;
-}
-
-describe("startTestServer", () => {
- it("uses explicit non-zero ports and retries bind failures", () => {
- const seen: number[] = [];
- const server = startTestServer(({ port }) => {
- seen.push(port);
- if (seen.length === 1) throw bindError();
- return { port, stop() {} };
- }, [41000, 41001]);
-
- expect(server.port).toBe(41001);
- expect(seen).toEqual([41000, 41001]);
- });
-
- it("rejects port 0 candidates", () => {
- expect(() => startTestServer(({ port }) => ({ port, stop() {} }), [0])).toThrow(
- "Invalid test server port: 0",
- );
- });
-
- it("rethrows non-bind failures", () => {
- expect(() =>
- startTestServer(() => {
- throw new Error("boom");
- }, [41000]),
- ).toThrow("boom");
- });
-});
diff --git a/reference/typescript/src/test/server.ts b/reference/typescript/src/test/server.ts
deleted file mode 100644
index f87ef6c..0000000
--- a/reference/typescript/src/test/server.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-export interface TestServer {
- stop: () => void;
- port: number;
-}
-
-type StartServer = (opts: { port: number }) => TestServer;
-
-const ATTEMPTS = 50;
-const MIN_PORT = 40_000;
-const PORT_SPAN = 20_000;
-
-export function startTestServer(
- startServer: StartServer,
- portCandidates: Iterable<number> = defaultPortCandidates(),
-): TestServer {
- let lastError: unknown;
- let attempts = 0;
-
- for (const port of portCandidates) {
- attempts += 1;
- if (!Number.isInteger(port) || port < 1 || port > 65535) {
- throw new Error(`Invalid test server port: ${port}`);
- }
-
- try {
- return startServer({ port });
- } catch (err) {
- if (!isPortUnavailableError(err)) throw err;
- lastError = err;
- }
- }
-
- throw new Error(`Unable to start test server after ${attempts} explicit port attempts`, {
- cause: lastError,
- });
-}
-
-function defaultPortCandidates(): number[] {
- const start = Math.abs(process.pid) % PORT_SPAN;
- return Array.from({ length: ATTEMPTS }, (_, i) => MIN_PORT + ((start + i) % PORT_SPAN));
-}
-
-function isPortUnavailableError(err: unknown): boolean {
- if (!(err instanceof Error)) return false;
- const code = (err as Error & { code?: unknown }).code;
- if (code === "EADDRINUSE") return true;
- return /EADDRINUSE|address already in use/i.test(err.message);
-}
diff --git a/reference/typescript/src/traffic.ts b/reference/typescript/src/traffic.ts
deleted file mode 100644
index 979c652..0000000
--- a/reference/typescript/src/traffic.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { stateDir } from "./paths.ts";
-import { REDACT_KEYS } from "./log.ts";
-import type { TrafficCapture } from "./providers/types.ts";
-
-const encoder = new TextEncoder();
-
-export function trafficCaptureEnabled(env = process.env): boolean {
- const value = env.CCP_TRAFFIC_LOG;
- return value === "1" || value === "true" || value === "yes";
-}
-
-export function createTrafficCapture(opts: {
- reqId: string;
- sessionId?: string;
- sessionSeq?: number;
- provider?: string;
-}): TrafficCapture | undefined {
- if (!trafficCaptureEnabled()) return undefined;
- const sessionPart = sanitizePathPart(opts.sessionId || "no-session");
- const seqPart = String(opts.sessionSeq ?? 0).padStart(6, "0");
- const providerPart = sanitizePathPart(opts.provider || "unknown-provider");
- const reqPart = sanitizePathPart(opts.reqId);
- const dir = join(stateDir(), "traffic", sessionPart, `${seqPart}-${providerPart}-${reqPart}`);
- let artifactCounter = 0;
- let eventCounter = 0;
-
- const artifactPath = (name: string) => {
- artifactCounter += 1;
- return join(dir, `${String(artifactCounter).padStart(3, "0")}-${sanitizePathPart(name)}`);
- };
- const eventPath = (name: string) => {
- eventCounter += 1;
- return join(
- dir,
- "events",
- `${String(eventCounter).padStart(6, "0")}-${sanitizePathPart(name)}`,
- );
- };
-
- return {
- writeJson(name, value) {
- const path = artifactPath(ensureExtension(name, ".json"));
- void writeCaptureFile(path, JSON.stringify(redactTraffic(value), null, 2));
- },
- writeText(name, value) {
- const path = artifactPath(ensureExtension(name, ".txt"));
- void writeCaptureFile(path, value);
- },
- writeBytes(name, value) {
- const path = artifactPath(name);
- void writeCaptureFile(path, value);
- },
- writeJsonEvent(name, value) {
- const path = eventPath(ensureExtension(name, ".json"));
- void writeCaptureFile(path, JSON.stringify(redactTraffic(value), null, 2));
- },
- };
-}
-
-export function headersToRecord(headers: Headers): Record<string, string> {
- const out: Record<string, string> = {};
- for (const [key, value] of headers) out[key] = value;
- return out;
-}
-
-function redactTraffic(value: unknown, depth = 0): unknown {
- if (depth > 100) return "[depth-limit]";
- if (value == null) return value;
- if (typeof value !== "object") return value;
- if (Array.isArray(value)) return value.map((item) => redactTraffic(item, depth + 1));
- const out: Record<string, unknown> = {};
- for (const [key, child] of Object.entries(value as Record<string, unknown>)) {
- out[key] = REDACT_KEYS.has(key.toLowerCase())
- ? redactValue(child)
- : redactTraffic(child, depth + 1);
- }
- return out;
-}
-
-function redactValue(value: unknown): string {
- if (typeof value === "string") return `[redacted len=${value.length}]`;
- return "[redacted]";
-}
-
-async function writeCaptureFile(path: string, value: string | Uint8Array): Promise<void> {
- try {
- await mkdir(dirname(path), { recursive: true });
- await writeFile(path, typeof value === "string" ? encoder.encode(value) : value, {
- mode: 0o600,
- });
- } catch {
- // Traffic capture must not affect request handling.
- }
-}
-
-function sanitizePathPart(value: string): string {
- const sanitized = value.replace(/[^a-zA-Z0-9._-]/g, "_");
- return sanitized.slice(0, 160) || "unknown";
-}
-
-function ensureExtension(name: string, extension: string): string {
- return name.endsWith(extension) ? name : `${name}${extension}`;
-}
diff --git a/reference/typescript/tsconfig.json b/reference/typescript/tsconfig.json
deleted file mode 100644
index d44a4ba..0000000
--- a/reference/typescript/tsconfig.json
+++ /dev/null
@@ -1,18 +0,0 @@
-{
- "compilerOptions": {
- "target": "ESNext",
- "module": "ESNext",
- "moduleResolution": "bundler",
- "lib": ["ESNext"],
- "types": ["bun-types"],
- "strict": true,
- "noUncheckedIndexedAccess": true,
- "esModuleInterop": true,
- "skipLibCheck": true,
- "resolveJsonModule": true,
- "allowImportingTsExtensions": true,
- "noEmit": true,
- "verbatimModuleSyntax": false
- },
- "include": ["src/**/*.ts"]
-}
diff --git a/src/providers/cursor/model.rs b/src/providers/cursor/model.rs
index 7f165ea..69fe9b8 100644
--- a/src/providers/cursor/model.rs
+++ b/src/providers/cursor/model.rs
@@ -1,6 +1,6 @@
/// Cursor model catalog -- resolves incoming model names to Cursor model IDs.
///
-/// Resolution rules mirror the TypeScript reference:
+/// Resolution rules:
/// - `cursor:`, `cursor-plan:`, `cursor-ask:` prefixes are stripped and mapped
/// to the corresponding agent mode.
/// - Legacy names like `cursor`, `cursor-agent`, `cursor-composer`,
diff --git a/src/providers/cursor/request.rs b/src/providers/cursor/request.rs
index 27c6d6f..a83207e 100644
--- a/src/providers/cursor/request.rs
+++ b/src/providers/cursor/request.rs
@@ -11,9 +11,6 @@ pub struct CursorSelectedImage {
/// Render the full Cursor prompt from an Anthropic MessagesRequest.
///
-/// Mirrors the TypeScript `renderCursorPrompt` in
-/// `reference/typescript/src/providers/cursor/translate/request.ts`.
-///
/// Includes:
/// - System message (with billing-header filtering)
/// - Conversation messages with content blocks
diff --git a/src/providers/cursor/tool_bridge.rs b/src/providers/cursor/tool_bridge.rs
index 6b0ff7e..1082434 100644
--- a/src/providers/cursor/tool_bridge.rs
+++ b/src/providers/cursor/tool_bridge.rs
@@ -299,8 +299,6 @@ pub fn find_tool_result<'a>(
}
/// Render the content of a `tool_result` block into a string.
-///
-/// Mirrors the TypeScript `renderToolResultContent` function.
pub fn render_tool_result_content(result: &serde_json::Value) -> String {
let content = match result.get("content") {
Some(serde_json::Value::String(s)) => return s.clone(),