Something went wrong. Try again.
sloproxy
Something went wrong. Try again.
356 kB · 8889 lines
Go
at main
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873487448754876487748784879488048814882488348844885488648874888488948904891489248934894489548964897489848994900490149024903490449054906490749084909491049114912491349144915491649174918491949204921492249234924492549264927492849294930493149324933493449354936493749384939494049414942494349444945494649474948494949504951495249534954495549564957495849594960496149624963496449654966496749684969497049714972497349744975497649774978497949804981498249834984498549864987498849894990499149924993499449954996499749984999500050015002500350045005500650075008500950105011501250135014501550165017501850195020502150225023502450255026502750285029503050315032503350345035503650375038503950405041504250435044504550465047504850495050505150525053505450555056505750585059506050615062506350645065506650675068506950705071507250735074507550765077507850795080508150825083508450855086508750885089509050915092509350945095509650975098509951005101510251035104510551065107510851095110511151125113511451155116511751185119512051215122512351245125512651275128512951305131513251335134513551365137513851395140514151425143514451455146514751485149515051515152515351545155515651575158515951605161516251635164516551665167516851695170517151725173517451755176517751785179518051815182518351845185518651875188518951905191519251935194519551965197519851995200520152025203520452055206520752085209521052115212521352145215521652175218521952205221522252235224522552265227522852295230523152325233523452355236523752385239524052415242524352445245524652475248524952505251525252535254525552565257525852595260526152625263526452655266526752685269527052715272527352745275527652775278527952805281528252835284528552865287528852895290529152925293529452955296529752985299530053015302530353045305530653075308530953105311531253135314531553165317531853195320532153225323532453255326532753285329533053315332533353345335533653375338533953405341534253435344534553465347534853495350535153525353535453555356535753585359536053615362536353645365536653675368536953705371537253735374537553765377537853795380538153825383538453855386538753885389539053915392539353945395539653975398539954005401540254035404540554065407540854095410541154125413541454155416541754185419542054215422542354245425542654275428542954305431543254335434543554365437543854395440544154425443544454455446544754485449545054515452545354545455545654575458545954605461546254635464546554665467546854695470547154725473547454755476547754785479548054815482548354845485548654875488548954905491549254935494549554965497549854995500550155025503550455055506550755085509551055115512551355145515551655175518551955205521552255235524552555265527552855295530553155325533553455355536553755385539554055415542554355445545554655475548554955505551555255535554555555565557555855595560556155625563556455655566556755685569557055715572557355745575557655775578557955805581558255835584558555865587558855895590559155925593559455955596559755985599560056015602560356045605560656075608560956105611561256135614561556165617561856195620562156225623562456255626562756285629563056315632563356345635563656375638563956405641564256435644564556465647564856495650565156525653565456555656565756585659566056615662566356645665566656675668566956705671567256735674567556765677567856795680568156825683568456855686568756885689569056915692569356945695569656975698569957005701570257035704570557065707570857095710571157125713571457155716571757185719572057215722572357245725572657275728572957305731573257335734573557365737573857395740574157425743574457455746574757485749575057515752575357545755575657575758575957605761576257635764576557665767576857695770577157725773577457755776577757785779578057815782578357845785578657875788578957905791579257935794579557965797579857995800580158025803580458055806580758085809581058115812581358145815581658175818581958205821582258235824582558265827582858295830583158325833583458355836583758385839584058415842584358445845584658475848584958505851585258535854585558565857585858595860586158625863586458655866586758685869587058715872587358745875587658775878587958805881588258835884588558865887588858895890589158925893589458955896589758985899590059015902590359045905590659075908590959105911591259135914591559165917591859195920592159225923592459255926592759285929593059315932593359345935593659375938593959405941594259435944594559465947594859495950595159525953595459555956595759585959596059615962596359645965596659675968596959705971597259735974597559765977597859795980598159825983598459855986598759885989599059915992599359945995599659975998599960006001600260036004600560066007600860096010601160126013601460156016601760186019602060216022602360246025602660276028602960306031603260336034603560366037603860396040604160426043604460456046604760486049605060516052605360546055605660576058605960606061606260636064606560666067606860696070607160726073607460756076607760786079608060816082608360846085608660876088608960906091609260936094609560966097609860996100610161026103610461056106610761086109611061116112611361146115611661176118611961206121612261236124612561266127612861296130613161326133613461356136613761386139614061416142614361446145614661476148614961506151615261536154615561566157615861596160616161626163616461656166616761686169617061716172617361746175617661776178617961806181618261836184618561866187618861896190619161926193619461956196619761986199620062016202620362046205620662076208620962106211621262136214621562166217621862196220622162226223622462256226622762286229623062316232623362346235623662376238623962406241624262436244624562466247624862496250625162526253625462556256625762586259626062616262626362646265626662676268626962706271627262736274627562766277627862796280628162826283628462856286628762886289629062916292629362946295629662976298629963006301630263036304630563066307630863096310631163126313631463156316631763186319632063216322632363246325632663276328632963306331633263336334633563366337633863396340634163426343634463456346634763486349635063516352635363546355635663576358635963606361636263636364636563666367636863696370637163726373637463756376637763786379638063816382638363846385638663876388638963906391639263936394639563966397639863996400640164026403640464056406640764086409641064116412641364146415641664176418641964206421642264236424642564266427642864296430643164326433643464356436643764386439644064416442644364446445644664476448644964506451645264536454645564566457645864596460646164626463646464656466646764686469647064716472647364746475647664776478647964806481648264836484648564866487648864896490649164926493649464956496649764986499650065016502650365046505650665076508650965106511651265136514651565166517651865196520652165226523652465256526652765286529653065316532653365346535653665376538653965406541654265436544654565466547654865496550655165526553655465556556655765586559656065616562656365646565656665676568656965706571657265736574657565766577657865796580658165826583658465856586658765886589659065916592659365946595659665976598659966006601660266036604660566066607660866096610661166126613661466156616661766186619662066216622662366246625662666276628662966306631663266336634663566366637663866396640664166426643664466456646664766486649665066516652665366546655665666576658665966606661666266636664666566666667666866696670667166726673667466756676667766786679668066816682668366846685668666876688668966906691669266936694669566966697669866996700670167026703670467056706670767086709671067116712671367146715671667176718671967206721672267236724672567266727672867296730673167326733673467356736673767386739674067416742674367446745674667476748674967506751675267536754675567566757675867596760676167626763676467656766676767686769677067716772677367746775677667776778677967806781678267836784678567866787678867896790679167926793679467956796679767986799680068016802680368046805680668076808680968106811681268136814681568166817681868196820682168226823682468256826682768286829683068316832683368346835683668376838683968406841684268436844684568466847684868496850685168526853685468556856685768586859686068616862686368646865686668676868686968706871687268736874687568766877687868796880688168826883688468856886688768886889689068916892689368946895689668976898689969006901690269036904690569066907690869096910691169126913691469156916691769186919692069216922692369246925692669276928692969306931693269336934693569366937693869396940694169426943694469456946694769486949695069516952695369546955695669576958695969606961696269636964696569666967696869696970697169726973697469756976697769786979698069816982698369846985698669876988698969906991699269936994699569966997699869997000700170027003700470057006700770087009701070117012701370147015701670177018701970207021702270237024702570267027702870297030703170327033703470357036703770387039704070417042704370447045704670477048704970507051705270537054705570567057705870597060706170627063706470657066706770687069707070717072707370747075707670777078707970807081708270837084708570867087708870897090709170927093709470957096709770987099710071017102710371047105710671077108710971107111711271137114711571167117711871197120712171227123712471257126712771287129713071317132713371347135713671377138713971407141714271437144714571467147714871497150715171527153715471557156715771587159716071617162716371647165716671677168716971707171717271737174717571767177717871797180718171827183718471857186718771887189719071917192719371947195719671977198719972007201720272037204720572067207720872097210721172127213721472157216721772187219722072217222722372247225722672277228722972307231723272337234723572367237723872397240724172427243724472457246724772487249725072517252725372547255725672577258725972607261726272637264726572667267726872697270727172727273727472757276727772787279728072817282728372847285728672877288728972907291729272937294729572967297729872997300730173027303730473057306730773087309731073117312731373147315731673177318731973207321732273237324732573267327732873297330733173327333733473357336733773387339734073417342734373447345734673477348734973507351735273537354735573567357735873597360736173627363736473657366736773687369737073717372737373747375737673777378737973807381738273837384738573867387738873897390739173927393739473957396739773987399740074017402740374047405740674077408740974107411741274137414741574167417741874197420742174227423742474257426742774287429743074317432743374347435743674377438743974407441744274437444744574467447744874497450745174527453745474557456745774587459746074617462746374647465746674677468746974707471747274737474747574767477747874797480748174827483748474857486748774887489749074917492749374947495749674977498749975007501750275037504750575067507750875097510751175127513751475157516751775187519752075217522752375247525752675277528752975307531753275337534753575367537753875397540754175427543754475457546754775487549755075517552755375547555755675577558755975607561756275637564756575667567756875697570757175727573757475757576757775787579758075817582758375847585758675877588758975907591759275937594759575967597759875997600760176027603760476057606760776087609761076117612761376147615761676177618761976207621762276237624762576267627762876297630763176327633763476357636763776387639764076417642764376447645764676477648764976507651765276537654765576567657765876597660766176627663766476657666766776687669767076717672767376747675767676777678767976807681768276837684768576867687768876897690769176927693769476957696769776987699770077017702770377047705770677077708770977107711771277137714771577167717771877197720772177227723772477257726772777287729773077317732773377347735773677377738773977407741774277437744774577467747774877497750775177527753775477557756775777587759776077617762776377647765776677677768776977707771777277737774777577767777777877797780778177827783778477857786778777887789779077917792779377947795779677977798779978007801780278037804780578067807780878097810781178127813781478157816781778187819782078217822782378247825782678277828782978307831783278337834783578367837783878397840784178427843784478457846784778487849785078517852785378547855785678577858785978607861786278637864786578667867786878697870787178727873787478757876787778787879788078817882788378847885788678877888788978907891789278937894789578967897789878997900790179027903790479057906790779087909791079117912791379147915791679177918791979207921792279237924792579267927792879297930793179327933793479357936793779387939794079417942794379447945794679477948794979507951795279537954795579567957795879597960796179627963796479657966796779687969797079717972797379747975797679777978797979807981798279837984798579867987798879897990799179927993799479957996799779987999800080018002800380048005800680078008800980108011801280138014801580168017801880198020802180228023802480258026802780288029803080318032803380348035803680378038803980408041804280438044804580468047804880498050805180528053805480558056805780588059806080618062806380648065806680678068806980708071807280738074807580768077807880798080808180828083808480858086808780888089809080918092809380948095809680978098809981008101810281038104810581068107810881098110811181128113811481158116811781188119812081218122812381248125812681278128812981308131813281338134813581368137813881398140814181428143814481458146814781488149815081518152815381548155815681578158815981608161816281638164816581668167816881698170817181728173817481758176817781788179818081818182818381848185818681878188818981908191819281938194819581968197819881998200820182028203820482058206820782088209821082118212821382148215821682178218821982208221822282238224822582268227822882298230823182328233823482358236823782388239824082418242824382448245824682478248824982508251825282538254825582568257825882598260826182628263826482658266826782688269827082718272827382748275827682778278827982808281828282838284828582868287828882898290829182928293829482958296829782988299830083018302830383048305830683078308830983108311831283138314831583168317831883198320832183228323832483258326832783288329833083318332833383348335833683378338833983408341834283438344834583468347834883498350835183528353835483558356835783588359836083618362836383648365836683678368836983708371837283738374837583768377837883798380838183828383838483858386838783888389839083918392839383948395839683978398839984008401840284038404840584068407840884098410841184128413841484158416841784188419842084218422842384248425842684278428842984308431843284338434843584368437843884398440844184428443844484458446844784488449845084518452845384548455845684578458845984608461846284638464846584668467846884698470847184728473847484758476847784788479848084818482848384848485848684878488848984908491849284938494849584968497849884998500850185028503850485058506850785088509851085118512851385148515851685178518851985208521852285238524852585268527852885298530853185328533853485358536853785388539854085418542854385448545854685478548854985508551855285538554855585568557855885598560856185628563856485658566856785688569857085718572857385748575857685778578857985808581858285838584858585868587858885898590859185928593859485958596859785988599860086018602860386048605860686078608860986108611861286138614861586168617861886198620862186228623862486258626862786288629863086318632863386348635863686378638863986408641864286438644864586468647864886498650865186528653865486558656865786588659866086618662866386648665866686678668866986708671867286738674867586768677867886798680868186828683868486858686868786888689869086918692869386948695869686978698869987008701870287038704870587068707870887098710871187128713871487158716871787188719872087218722872387248725872687278728872987308731873287338734873587368737873887398740874187428743874487458746874787488749875087518752875387548755875687578758875987608761876287638764876587668767876887698770877187728773877487758776877787788779878087818782878387848785878687878788878987908791879287938794879587968797879887998800880188028803880488058806880788088809881088118812881388148815881688178818881988208821882288238824882588268827882888298830883188328833883488358836883788388839884088418842884388448845884688478848884988508851885288538854885588568857885888598860886188628863886488658866886788688869887088718872887388748875887688778878887988808881888288838884888588868887888888898890package executor
import ( "bytes" "compress/gzip" "context" "encoding/base64" "encoding/json" "errors" "fmt" "io" "net/http" "net/http/httptest" "strings" "sync" "testing" "time"
"github.com/andybalholm/brotli" "github.com/gin-gonic/gin" "github.com/klauspost/compress/zstd" claudeauth "github.com/router-for-me/CLIProxyAPI/v7/internal/auth/claude" "github.com/router-for-me/CLIProxyAPI/v7/internal/config" "github.com/router-for-me/CLIProxyAPI/v7/internal/registry" "github.com/router-for-me/CLIProxyAPI/v7/internal/runtime/executor/helps" cliproxyauth "github.com/router-for-me/CLIProxyAPI/v7/sdk/cliproxy/auth" cliproxyexecutor "github.com/router-for-me/CLIProxyAPI/v7/sdk/cliproxy/executor" sdktranslator "github.com/router-for-me/CLIProxyAPI/v7/sdk/translator" "github.com/tidwall/gjson" "github.com/tidwall/sjson")
func resetClaudeDeviceProfileCache() { helps.ResetClaudeDeviceProfileCache()}
func claudeOAuthTestMetadata() map[string]any { return map[string]any{ "account_uuid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", claudeauth.ClaudeDeviceIDsMetadataKey: []string{ "0000000000000000000000000000000000000000000000000000000000000000", }, }}
func malformedClaudeTreeSignatureForClaudeExecutorTest() string { return base64.StdEncoding.EncodeToString([]byte{0x12, 0xFF, 0xFE, 0xFD})}
func newClaudeHeaderTestRequest(t *testing.T, incoming http.Header) *http.Request { t.Helper()
gin.SetMode(gin.TestMode) recorder := httptest.NewRecorder() ginCtx, _ := gin.CreateTestContext(recorder) ginReq := httptest.NewRequest(http.MethodPost, "http://localhost/v1/messages", nil) ginReq.Header = incoming.Clone() ginCtx.Request = ginReq
req := httptest.NewRequest(http.MethodPost, "https://api.anthropic.com/v1/messages", nil) return req.WithContext(context.WithValue(req.Context(), "gin", ginCtx))}
func assertClaudeFingerprint(t *testing.T, headers http.Header, userAgent, pkgVersion, runtimeVersion, osName, arch string) { t.Helper()
if got := headers.Get("User-Agent"); got != userAgent { t.Fatalf("User-Agent = %q, want %q", got, userAgent) } if got := headers.Get("X-Stainless-Package-Version"); got != pkgVersion { t.Fatalf("X-Stainless-Package-Version = %q, want %q", got, pkgVersion) } if got := headers.Get("X-Stainless-Runtime-Version"); got != runtimeVersion { t.Fatalf("X-Stainless-Runtime-Version = %q, want %q", got, runtimeVersion) } if got := headers.Get("X-Stainless-Os"); got != osName { t.Fatalf("X-Stainless-Os = %q, want %q", got, osName) } if got := headers.Get("X-Stainless-Arch"); got != arch { t.Fatalf("X-Stainless-Arch = %q, want %q", got, arch) }}
func TestApplyClaudeHeaders_FastModeBetaIsConditional(t *testing.T) { baseline := claudeCodeCLIBetas([]byte(`{"model":"claude-opus-5"}`), nil, false) betasWithoutFastMode := baseline betasWithFastMode := baseline + "," + claudeFastModeBeta
tests := []struct { name string body string want string }{ { name: "omitted speed excludes fast mode beta", body: `{"model":"claude-opus-5"}`, want: betasWithoutFastMode, }, { name: "fast speed appends fast mode beta", body: `{"model":"claude-opus-5","speed":"fast"}`, want: betasWithFastMode, }, { name: "explicit body beta appends fast mode beta", body: `{"model":"claude-opus-5","betas":["fast-mode-2026-02-01"]}`, want: betasWithFastMode, }, }
auth := &cliproxyauth.Auth{Attributes: map[string]string{"api_key": "key-fast-mode-beta", "cloak_mode": "always"}} for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { extraBetas, body := extractAndRemoveBetas([]byte(tt.body)) req := newClaudeHeaderTestRequest(t, nil) if errApply := applyClaudeHeaders(req, auth, "key-fast-mode-beta", false, extraBetas, body, nil, nil, false); errApply != nil { t.Fatalf("applyClaudeHeaders() error = %v", errApply) } if got := req.Header.Get("Anthropic-Beta"); got != tt.want { t.Fatalf("Anthropic-Beta = %q, want %q", got, tt.want) } }) }}
func assertClaudeCredentialIdentity(t *testing.T, body []byte, headers http.Header, deviceIDs []string, accountUUID string) { t.Helper() userID := gjson.GetBytes(body, "metadata.user_id").String() deviceID := gjson.Get(userID, "device_id").String() inPool := false for _, candidate := range deviceIDs { if deviceID == candidate { inPool = true break } } if !inPool { t.Fatalf("device_id = %q, want selected credential device pool entry", deviceID) } if got := gjson.Get(userID, "account_uuid").String(); got != accountUUID { t.Fatalf("account_uuid = %q, want selected credential account %q", got, accountUUID) } sessionID := gjson.Get(userID, "session_id").String() if sessionID == "" || sessionID != headers.Get("X-Claude-Code-Session-Id") { t.Fatalf("metadata session_id = %q, header session ID = %q", sessionID, headers.Get("X-Claude-Code-Session-Id")) } resigned, errResign := finalizeAnthropicMessagesBodyCCH(body, "") if errResign != nil { t.Fatalf("re-finalize Claude CCH: %v", errResign) } if !bytes.Equal(resigned, body) { t.Fatal("Claude CCH was calculated before final credential metadata rewrite") }}
// assertClaudeCountTokensIdentity pins the count_tokens shape captured from real// Claude Code 2.1.220: the endpoint carries no metadata whatsoever. Anthropic// rejects the field there with "metadata: Extra inputs are not permitted", so the// credential identity travels only on the header and on the Messages endpoint.func assertClaudeCountTokensIdentity(t *testing.T, body []byte, headers http.Header) { t.Helper() if got := gjson.GetBytes(body, "metadata"); got.Exists() { t.Fatalf("count_tokens metadata = %s, want it absent", got.Raw) } if got := headers.Get("X-Claude-Code-Session-Id"); got == "" { t.Fatal("count_tokens is missing X-Claude-Code-Session-Id") } resigned, errResign := finalizeAnthropicMessagesBodyCCH(body, "") if errResign != nil { t.Fatalf("re-finalize Claude CCH: %v", errResign) } if !bytes.Equal(resigned, body) { t.Fatal("count_tokens CCH was calculated before the final body rewrite") }}
func TestApplyClaudeHeaders_UsesConfiguredBaselineFingerprint(t *testing.T) { resetClaudeDeviceProfileCache() stabilize := true
cfg := &config.Config{ ClaudeHeaderDefaults: config.ClaudeHeaderDefaults{ UserAgent: "claude-cli/2.1.70 (external, cli)", PackageVersion: "0.80.0", RuntimeVersion: "v24.5.0", OS: "MacOS", Arch: "arm64", Timeout: "900", StabilizeDeviceProfile: &stabilize, }, } auth := &cliproxyauth.Auth{ ID: "auth-baseline", Attributes: map[string]string{ "api_key": "key-baseline", "cloak_mode": "always", "header:User-Agent": "evil-client/9.9", "header:X-Stainless-Os": "Linux", "header:X-Stainless-Arch": "x64", "header:X-Stainless-Package-Version": "9.9.9", }, } incoming := http.Header{ "User-Agent": []string{"curl/8.7.1"}, "X-Stainless-Package-Version": []string{"0.10.0"}, "X-Stainless-Runtime-Version": []string{"v18.0.0"}, "X-Stainless-Os": []string{"Linux"}, "X-Stainless-Arch": []string{"x64"}, }
req := newClaudeHeaderTestRequest(t, incoming) applyClaudeHeaders(req, auth, "key-baseline", false, nil, nil, cfg, nil, false)
assertClaudeFingerprint(t, req.Header, "evil-client/9.9", "9.9.9", "v24.5.0", "Linux", "x64") if got := req.Header.Get("X-Stainless-Timeout"); got != "900" { t.Fatalf("X-Stainless-Timeout = %q, want %q", got, "900") }}
func TestApplyClaudeHeaders_RejectsUnmeasuredClaudeCLIFingerprints(t *testing.T) { resetClaudeDeviceProfileCache() stabilize := true
cfg := &config.Config{ ClaudeHeaderDefaults: config.ClaudeHeaderDefaults{ UserAgent: "claude-cli/2.1.60 (external, cli)", PackageVersion: "0.70.0", RuntimeVersion: "v22.0.0", OS: "MacOS", Arch: "arm64", StabilizeDeviceProfile: &stabilize, }, } auth := &cliproxyauth.Auth{ ID: "auth-upgrade", Attributes: map[string]string{ "api_key": "key-upgrade", "cloak_mode": "always", }, }
firstReq := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"claude-cli/2.1.62 (external, cli)"}, "X-Stainless-Package-Version": []string{"0.74.0"}, "X-Stainless-Runtime-Version": []string{"v24.3.0"}, "X-Stainless-Os": []string{"Linux"}, "X-Stainless-Arch": []string{"x64"}, }) applyClaudeHeaders(firstReq, auth, "key-upgrade", false, nil, nil, cfg, nil, true) assertClaudeFingerprint(t, firstReq.Header, "claude-cli/2.1.60 (external, cli)", "0.70.0", "v22.0.0", "MacOS", "arm64")
thirdPartyReq := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"lobe-chat/1.0"}, "X-Stainless-Package-Version": []string{"0.10.0"}, "X-Stainless-Runtime-Version": []string{"v18.0.0"}, "X-Stainless-Os": []string{"Windows"}, "X-Stainless-Arch": []string{"x64"}, }) applyClaudeHeaders(thirdPartyReq, auth, "key-upgrade", false, nil, nil, cfg, nil, false) assertClaudeFingerprint(t, thirdPartyReq.Header, "claude-cli/2.1.60 (external, cli)", "0.70.0", "v22.0.0", "MacOS", "arm64")
higherReq := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"claude-cli/2.1.63 (external, cli)"}, "X-Stainless-Package-Version": []string{"0.75.0"}, "X-Stainless-Runtime-Version": []string{"v24.4.0"}, "X-Stainless-Os": []string{"MacOS"}, "X-Stainless-Arch": []string{"arm64"}, }) applyClaudeHeaders(higherReq, auth, "key-upgrade", false, nil, nil, cfg, nil, true) assertClaudeFingerprint(t, higherReq.Header, "claude-cli/2.1.60 (external, cli)", "0.70.0", "v22.0.0", "MacOS", "arm64")
lowerReq := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"claude-cli/2.1.61 (external, cli)"}, "X-Stainless-Package-Version": []string{"0.73.0"}, "X-Stainless-Runtime-Version": []string{"v24.2.0"}, "X-Stainless-Os": []string{"Windows"}, "X-Stainless-Arch": []string{"x64"}, }) applyClaudeHeaders(lowerReq, auth, "key-upgrade", false, nil, nil, cfg, nil, true) assertClaudeFingerprint(t, lowerReq.Header, "claude-cli/2.1.60 (external, cli)", "0.70.0", "v22.0.0", "MacOS", "arm64")}
func TestApplyClaudeHeaders_DoesNotDowngradeConfiguredBaselineOnFirstClaudeClient(t *testing.T) { resetClaudeDeviceProfileCache() stabilize := true
cfg := &config.Config{ ClaudeHeaderDefaults: config.ClaudeHeaderDefaults{ UserAgent: "claude-cli/2.1.70 (external, cli)", PackageVersion: "0.80.0", RuntimeVersion: "v24.5.0", OS: "MacOS", Arch: "arm64", StabilizeDeviceProfile: &stabilize, }, } auth := &cliproxyauth.Auth{ ID: "auth-baseline-floor", Attributes: map[string]string{ "api_key": "key-baseline-floor", }, }
olderClaudeReq := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"claude-cli/2.1.62 (external, cli)"}, "X-Stainless-Package-Version": []string{"0.74.0"}, "X-Stainless-Runtime-Version": []string{"v24.3.0"}, "X-Stainless-Os": []string{"Linux"}, "X-Stainless-Arch": []string{"x64"}, }) applyClaudeHeaders(olderClaudeReq, auth, "key-baseline-floor", false, nil, nil, cfg, nil, true) assertClaudeFingerprint(t, olderClaudeReq.Header, "claude-cli/2.1.70 (external, cli)", "0.80.0", "v24.5.0", "MacOS", "arm64")
newerClaudeReq := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"claude-cli/2.1.71 (external, cli)"}, "X-Stainless-Package-Version": []string{"0.81.0"}, "X-Stainless-Runtime-Version": []string{"v24.6.0"}, "X-Stainless-Os": []string{"Linux"}, "X-Stainless-Arch": []string{"x64"}, }) applyClaudeHeaders(newerClaudeReq, auth, "key-baseline-floor", false, nil, nil, cfg, nil, true) assertClaudeFingerprint(t, newerClaudeReq.Header, "claude-cli/2.1.70 (external, cli)", "0.80.0", "v24.5.0", "MacOS", "arm64")}
func TestApplyClaudeHeaders_UpgradesCachedSoftwareFingerprintWhenBaselineAdvances(t *testing.T) { resetClaudeDeviceProfileCache() stabilize := true
oldCfg := &config.Config{ ClaudeHeaderDefaults: config.ClaudeHeaderDefaults{ UserAgent: "claude-cli/2.1.70 (external, cli)", PackageVersion: "0.80.0", RuntimeVersion: "v24.5.0", OS: "MacOS", Arch: "arm64", StabilizeDeviceProfile: &stabilize, }, } newCfg := &config.Config{ ClaudeHeaderDefaults: config.ClaudeHeaderDefaults{ UserAgent: "claude-cli/2.1.77 (external, cli)", PackageVersion: "0.87.0", RuntimeVersion: "v24.8.0", OS: "MacOS", Arch: "arm64", StabilizeDeviceProfile: &stabilize, }, } auth := &cliproxyauth.Auth{ ID: "auth-baseline-reload", Attributes: map[string]string{ "api_key": "key-baseline-reload", "cloak_mode": "always", }, }
officialReq := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"claude-cli/2.1.71 (external, cli)"}, "X-Stainless-Package-Version": []string{"0.81.0"}, "X-Stainless-Runtime-Version": []string{"v24.6.0"}, "X-Stainless-Os": []string{"Linux"}, "X-Stainless-Arch": []string{"x64"}, }) applyClaudeHeaders(officialReq, auth, "key-baseline-reload", false, nil, nil, oldCfg, nil, true) assertClaudeFingerprint(t, officialReq.Header, "claude-cli/2.1.70 (external, cli)", "0.80.0", "v24.5.0", "MacOS", "arm64")
thirdPartyReq := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"curl/8.7.1"}, "X-Stainless-Package-Version": []string{"0.10.0"}, "X-Stainless-Runtime-Version": []string{"v18.0.0"}, "X-Stainless-Os": []string{"Linux"}, "X-Stainless-Arch": []string{"x64"}, }) applyClaudeHeaders(thirdPartyReq, auth, "key-baseline-reload", false, nil, nil, newCfg, nil, false) assertClaudeFingerprint(t, thirdPartyReq.Header, "claude-cli/2.1.77 (external, cli)", "0.87.0", "v24.8.0", "MacOS", "arm64")}
func TestApplyClaudeHeaders_LearnsOfficialFingerprintAfterCustomBaselineFallback(t *testing.T) { resetClaudeDeviceProfileCache() stabilize := true
cfg := &config.Config{ ClaudeHeaderDefaults: config.ClaudeHeaderDefaults{ UserAgent: "my-gateway/1.0", PackageVersion: "custom-pkg", RuntimeVersion: "custom-runtime", OS: "MacOS", Arch: "arm64", StabilizeDeviceProfile: &stabilize, }, } auth := &cliproxyauth.Auth{ ID: "auth-custom-baseline-learning", Attributes: map[string]string{ "api_key": "key-custom-baseline-learning", "cloak_mode": "always", }, }
thirdPartyReq := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"curl/8.7.1"}, "X-Stainless-Package-Version": []string{"0.10.0"}, "X-Stainless-Runtime-Version": []string{"v18.0.0"}, "X-Stainless-Os": []string{"Linux"}, "X-Stainless-Arch": []string{"x64"}, }) applyClaudeHeaders(thirdPartyReq, auth, "key-custom-baseline-learning", false, nil, nil, cfg, nil, false) assertClaudeFingerprint(t, thirdPartyReq.Header, "my-gateway/1.0", "custom-pkg", "custom-runtime", "MacOS", "arm64")
officialReq := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"claude-cli/2.1.77 (external, cli)"}, "X-Stainless-Package-Version": []string{"0.87.0"}, "X-Stainless-Runtime-Version": []string{"v24.8.0"}, "X-Stainless-Os": []string{"Linux"}, "X-Stainless-Arch": []string{"x64"}, }) applyClaudeHeaders(officialReq, auth, "key-custom-baseline-learning", false, nil, nil, cfg, nil, true) assertClaudeFingerprint(t, officialReq.Header, "my-gateway/1.0", "custom-pkg", "custom-runtime", "MacOS", "arm64")
postLearningThirdPartyReq := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"curl/8.7.1"}, "X-Stainless-Package-Version": []string{"0.10.0"}, "X-Stainless-Runtime-Version": []string{"v18.0.0"}, "X-Stainless-Os": []string{"Linux"}, "X-Stainless-Arch": []string{"x64"}, }) applyClaudeHeaders(postLearningThirdPartyReq, auth, "key-custom-baseline-learning", false, nil, nil, cfg, nil, false) assertClaudeFingerprint(t, postLearningThirdPartyReq.Header, "my-gateway/1.0", "custom-pkg", "custom-runtime", "MacOS", "arm64")}
func TestResolveClaudeDeviceProfile_RechecksCacheBeforeStoringCandidate(t *testing.T) { resetClaudeDeviceProfileCache() stabilize := true
cfg := &config.Config{ ClaudeHeaderDefaults: config.ClaudeHeaderDefaults{ UserAgent: "claude-cli/2.1.60 (external, cli)", PackageVersion: "0.70.0", RuntimeVersion: "v22.0.0", OS: "MacOS", Arch: "arm64", StabilizeDeviceProfile: &stabilize, }, } auth := &cliproxyauth.Auth{ ID: "auth-racy-upgrade", Attributes: map[string]string{ "api_key": "key-racy-upgrade", }, }
lowPaused := make(chan struct{}) releaseLow := make(chan struct{}) var pauseOnce sync.Once var releaseOnce sync.Once
helps.ClaudeDeviceProfileBeforeCandidateStore = func(candidate helps.ClaudeDeviceProfile) { if candidate.UserAgent != "claude-cli/2.1.60 (external, cli)" { return } pause := false pauseOnce.Do(func() { pause = true close(lowPaused) }) if pause { <-releaseLow } } t.Cleanup(func() { helps.ClaudeDeviceProfileBeforeCandidateStore = nil releaseOnce.Do(func() { close(releaseLow) }) })
lowResultCh := make(chan helps.ClaudeDeviceProfile, 1) go func() { lowResultCh <- helps.ResolveClaudeDeviceProfile(auth, "key-racy-upgrade", http.Header{ "User-Agent": []string{"claude-cli/2.1.60 (external, cli)"}, "X-Stainless-Package-Version": []string{"0.70.0"}, "X-Stainless-Runtime-Version": []string{"v22.0.0"}, "X-Stainless-Os": []string{"Linux"}, "X-Stainless-Arch": []string{"x64"}, }, cfg) }()
select { case <-lowPaused: case <-time.After(2 * time.Second): t.Fatal("timed out waiting for lower candidate to pause before storing") }
highResult := helps.ResolveClaudeDeviceProfile(auth, "key-racy-upgrade", http.Header{ "User-Agent": []string{"claude-cli/2.1.60 (external, cli)"}, "X-Stainless-Package-Version": []string{"0.70.0"}, "X-Stainless-Runtime-Version": []string{"v22.0.0"}, "X-Stainless-Os": []string{"MacOS"}, "X-Stainless-Arch": []string{"arm64"}, }, cfg) releaseOnce.Do(func() { close(releaseLow) })
select { case lowResult := <-lowResultCh: if lowResult.UserAgent != "claude-cli/2.1.60 (external, cli)" { t.Fatalf("lowResult.UserAgent = %q, want %q", lowResult.UserAgent, "claude-cli/2.1.60 (external, cli)") } if lowResult.PackageVersion != "0.70.0" { t.Fatalf("lowResult.PackageVersion = %q, want %q", lowResult.PackageVersion, "0.70.0") } if lowResult.OS != "MacOS" || lowResult.Arch != "arm64" { t.Fatalf("lowResult platform = %s/%s, want %s/%s", lowResult.OS, lowResult.Arch, "MacOS", "arm64") } case <-time.After(2 * time.Second): t.Fatal("timed out waiting for lower candidate result") }
if highResult.UserAgent != "claude-cli/2.1.60 (external, cli)" { t.Fatalf("highResult.UserAgent = %q, want %q", highResult.UserAgent, "claude-cli/2.1.60 (external, cli)") } if highResult.OS != "MacOS" || highResult.Arch != "arm64" { t.Fatalf("highResult platform = %s/%s, want %s/%s", highResult.OS, highResult.Arch, "MacOS", "arm64") }
cached := helps.ResolveClaudeDeviceProfile(auth, "key-racy-upgrade", http.Header{ "User-Agent": []string{"curl/8.7.1"}, }, cfg) if cached.UserAgent != "claude-cli/2.1.60 (external, cli)" { t.Fatalf("cached.UserAgent = %q, want %q", cached.UserAgent, "claude-cli/2.1.60 (external, cli)") } if cached.PackageVersion != "0.70.0" { t.Fatalf("cached.PackageVersion = %q, want %q", cached.PackageVersion, "0.70.0") } if cached.OS != "MacOS" || cached.Arch != "arm64" { t.Fatalf("cached platform = %s/%s, want %s/%s", cached.OS, cached.Arch, "MacOS", "arm64") }}
func TestApplyClaudeHeaders_ThirdPartyBaselineThenOfficialUpgradeKeepsPinnedPlatform(t *testing.T) { resetClaudeDeviceProfileCache() stabilize := true
cfg := &config.Config{ ClaudeHeaderDefaults: config.ClaudeHeaderDefaults{ UserAgent: "claude-cli/2.1.70 (external, cli)", PackageVersion: "0.80.0", RuntimeVersion: "v24.5.0", OS: "MacOS", Arch: "arm64", StabilizeDeviceProfile: &stabilize, }, } auth := &cliproxyauth.Auth{ ID: "auth-third-party-then-official", Attributes: map[string]string{ "api_key": "key-third-party-then-official", "cloak_mode": "always", }, }
thirdPartyReq := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"curl/8.7.1"}, "X-Stainless-Package-Version": []string{"0.10.0"}, "X-Stainless-Runtime-Version": []string{"v18.0.0"}, "X-Stainless-Os": []string{"Linux"}, "X-Stainless-Arch": []string{"x64"}, }) applyClaudeHeaders(thirdPartyReq, auth, "key-third-party-then-official", false, nil, nil, cfg, nil, false) assertClaudeFingerprint(t, thirdPartyReq.Header, "claude-cli/2.1.70 (external, cli)", "0.80.0", "v24.5.0", "MacOS", "arm64")
officialReq := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"claude-cli/2.1.77 (external, cli)"}, "X-Stainless-Package-Version": []string{"0.87.0"}, "X-Stainless-Runtime-Version": []string{"v24.8.0"}, "X-Stainless-Os": []string{"Linux"}, "X-Stainless-Arch": []string{"x64"}, }) applyClaudeHeaders(officialReq, auth, "key-third-party-then-official", false, nil, nil, cfg, nil, true) assertClaudeFingerprint(t, officialReq.Header, "claude-cli/2.1.70 (external, cli)", "0.80.0", "v24.5.0", "MacOS", "arm64")}
func TestApplyClaudeHeaders_DisableDeviceProfileStabilization(t *testing.T) { resetClaudeDeviceProfileCache()
stabilize := false cfg := &config.Config{ ClaudeHeaderDefaults: config.ClaudeHeaderDefaults{ UserAgent: "claude-cli/2.1.60 (external, cli)", PackageVersion: "0.70.0", RuntimeVersion: "v22.0.0", OS: "MacOS", Arch: "arm64", StabilizeDeviceProfile: &stabilize, }, } auth := &cliproxyauth.Auth{ ID: "auth-disable-stability", Attributes: map[string]string{ "api_key": "key-disable-stability", "cloak_mode": "always", }, }
firstReq := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"claude-cli/2.1.62 (external, cli)"}, "X-Stainless-Package-Version": []string{"0.74.0"}, "X-Stainless-Runtime-Version": []string{"v24.3.0"}, "X-Stainless-Os": []string{"Linux"}, "X-Stainless-Arch": []string{"x64"}, }) applyClaudeHeaders(firstReq, auth, "key-disable-stability", false, nil, nil, cfg, nil, true) assertClaudeFingerprint(t, firstReq.Header, "claude-cli/2.1.60 (external, cli)", "0.70.0", "v22.0.0", "MacOS", "arm64")
thirdPartyReq := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"lobe-chat/1.0"}, "X-Stainless-Package-Version": []string{"0.10.0"}, "X-Stainless-Runtime-Version": []string{"v18.0.0"}, "X-Stainless-Os": []string{"Windows"}, "X-Stainless-Arch": []string{"x64"}, }) applyClaudeHeaders(thirdPartyReq, auth, "key-disable-stability", false, nil, nil, cfg, nil, false) assertClaudeFingerprint(t, thirdPartyReq.Header, "claude-cli/2.1.60 (external, cli)", "0.70.0", "v22.0.0", "MacOS", "arm64")
lowerReq := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"claude-cli/2.1.61 (external, cli)"}, "X-Stainless-Package-Version": []string{"0.73.0"}, "X-Stainless-Runtime-Version": []string{"v24.2.0"}, "X-Stainless-Os": []string{"Windows"}, "X-Stainless-Arch": []string{"x64"}, }) applyClaudeHeaders(lowerReq, auth, "key-disable-stability", false, nil, nil, cfg, nil, true) assertClaudeFingerprint(t, lowerReq.Header, "claude-cli/2.1.60 (external, cli)", "0.70.0", "v22.0.0", "MacOS", "arm64")}
func TestApplyClaudeHeaders_LegacyModePreservesConfiguredUserAgentOverrideForClaudeClients(t *testing.T) { resetClaudeDeviceProfileCache()
stabilize := false cfg := &config.Config{ ClaudeHeaderDefaults: config.ClaudeHeaderDefaults{ UserAgent: "claude-cli/2.1.60 (external, cli)", PackageVersion: "0.70.0", RuntimeVersion: "v22.0.0", StabilizeDeviceProfile: &stabilize, }, } auth := &cliproxyauth.Auth{ ID: "auth-legacy-ua-override", Attributes: map[string]string{ "api_key": "key-legacy-ua-override", "header:User-Agent": "config-ua/1.0", }, }
req := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"claude-cli/2.1.62 (external, cli)"}, "X-Stainless-Package-Version": []string{"0.74.0"}, "X-Stainless-Runtime-Version": []string{"v24.3.0"}, "X-Stainless-Os": []string{"Linux"}, "X-Stainless-Arch": []string{"x64"}, }) applyClaudeHeaders(req, auth, "key-legacy-ua-override", false, nil, nil, cfg, nil, true)
assertClaudeFingerprint(t, req.Header, "config-ua/1.0", "0.70.0", "v22.0.0", "MacOS", "arm64")}
func TestApplyClaudeHeaders_LegacyThirdPartyUsesStableConfiguredOSArch(t *testing.T) { resetClaudeDeviceProfileCache()
stabilize := false cfg := &config.Config{ ClaudeHeaderDefaults: config.ClaudeHeaderDefaults{ UserAgent: "claude-cli/2.1.60 (external, cli)", PackageVersion: "0.70.0", RuntimeVersion: "v22.0.0", OS: "Windows", Arch: "x64", StabilizeDeviceProfile: &stabilize, }, } auth := &cliproxyauth.Auth{ ID: "auth-legacy-runtime-os-arch", Attributes: map[string]string{ "api_key": "key-legacy-runtime-os-arch", "cloak_mode": "always", }, }
req := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"curl/8.7.1"}, }) applyClaudeHeaders(req, auth, "key-legacy-runtime-os-arch", false, nil, nil, cfg, nil, false)
assertClaudeFingerprint(t, req.Header, "claude-cli/2.1.60 (external, cli)", "0.70.0", "v22.0.0", "Windows", "x64")}
func TestApplyClaudeHeaders_UnsetStabilizationUsesStableConfiguredOSArch(t *testing.T) { resetClaudeDeviceProfileCache()
cfg := &config.Config{ ClaudeHeaderDefaults: config.ClaudeHeaderDefaults{ UserAgent: "claude-cli/2.1.60 (external, cli)", PackageVersion: "0.70.0", RuntimeVersion: "v22.0.0", OS: "Linux", Arch: "x64", }, } auth := &cliproxyauth.Auth{ ID: "auth-unset-runtime-os-arch", Attributes: map[string]string{ "api_key": "key-unset-runtime-os-arch", "cloak_mode": "always", }, }
req := newClaudeHeaderTestRequest(t, http.Header{ "User-Agent": []string{"curl/8.7.1"}, }) applyClaudeHeaders(req, auth, "key-unset-runtime-os-arch", false, nil, nil, cfg, nil, false)
assertClaudeFingerprint(t, req.Header, "claude-cli/2.1.60 (external, cli)", "0.70.0", "v22.0.0", "Linux", "x64")}
func TestApplyClaudeHeaders_UsesOAuthAuthorizationAndBrowserFingerprint(t *testing.T) { auth := &cliproxyauth.Auth{Attributes: map[string]string{"api_key": "sk-ant-oat-header-test"}} req := newClaudeHeaderTestRequest(t, nil) if errHeaders := applyClaudeHeaders(req, auth, "sk-ant-oat-header-test", false, nil, nil, &config.Config{}, nil, false, "11111111-2222-4333-8444-555555555555"); errHeaders != nil { t.Fatalf("applyClaudeHeaders() error = %v", errHeaders) } if got := req.Header.Get("Authorization"); got != "Bearer sk-ant-oat-header-test" { t.Fatalf("Authorization = %q, want OAuth bearer", got) } if got := req.Header.Get("x-api-key"); got != "" { t.Fatalf("x-api-key = %q, want empty for OAuth", got) } if got := req.Header.Get("Anthropic-Dangerous-Direct-Browser-Access"); got != "true" { t.Fatalf("Anthropic-Dangerous-Direct-Browser-Access = %q, want true", got) } if got := req.Header.Get("Anthropic-Beta"); !strings.Contains(got, "oauth-2025-04-20") { t.Fatalf("Anthropic-Beta = %q, want OAuth beta", got) }}
func TestApplyClaudeHeaders_EmptyAPIKey_OmitsAuthHeaders(t *testing.T) { auth := &cliproxyauth.Auth{ Provider: "claude", Attributes: map[string]string{ "auth_kind": "apikey", "base_url": "https://custom-claude.example.com", "header:Custom-Token": "custom-secret", }, } req, err := http.NewRequest(http.MethodPost, "https://custom-claude.example.com/v1/messages", nil) if err != nil { t.Fatalf("NewRequest() error = %v", err) } // Preset preexisting client headers to ensure they get stripped for empty API key req.Header.Set("Authorization", "Bearer preexisting-bearer") req.Header.Set("x-api-key", "preexisting-key")
if errHeaders := applyClaudeHeaders(req, auth, "", false, nil, nil, &config.Config{}, nil, false); errHeaders != nil { t.Fatalf("applyClaudeHeaders() error = %v", errHeaders) } if got := req.Header.Get("Authorization"); got != "" { t.Fatalf("Authorization = %q, want empty for empty API key", got) } if got := req.Header.Get("x-api-key"); got != "" { t.Fatalf("x-api-key = %q, want empty for empty API key", got) } if got := req.Header.Get("Custom-Token"); got != "custom-secret" { t.Fatalf("Custom-Token = %q, want custom-secret", got) }
// Also verify PrepareRequest req2, _ := http.NewRequest(http.MethodPost, "https://custom-claude.example.com/v1/messages", nil) req2.Header.Set("Authorization", "Bearer preexisting-bearer") req2.Header.Set("x-api-key", "preexisting-key") exec := &ClaudeExecutor{} if errPrep := exec.PrepareRequest(req2, auth); errPrep != nil { t.Fatalf("PrepareRequest() error = %v", errPrep) } if got := req2.Header.Get("Authorization"); got != "" { t.Fatalf("PrepareRequest Authorization = %q, want empty", got) } if got := req2.Header.Get("x-api-key"); got != "" { t.Fatalf("PrepareRequest x-api-key = %q, want empty", got) } if got := req2.Header.Get("Custom-Token"); got != "custom-secret" { t.Fatalf("PrepareRequest Custom-Token = %q, want custom-secret", got) }}
func TestClaudeExecutor_NonClaudeRequestUsesClaudeCode220CLIFingerprint(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-opus-4-6","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-sdk-fingerprint", "base_url": server.URL, "cloak_mode": "always", }} payload := []byte(`{"model":"claude-opus-4-6","messages":[{"role":"user","content":[{"type":"text","text":"x"}]}]}`)
_, errExecute := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-opus-4-6", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if errExecute != nil { t.Fatalf("Execute() error = %v", errExecute) }
assertClaudeFingerprint(t, seenHeaders, "claude-cli/2.1.258 (external, cli)", "0.112.1", "v26.3.0", "MacOS", "arm64") if got := seenHeaders.Get("X-App"); got != "cli" { t.Fatalf("X-App = %q, want cli", got) } if want := claudeCodeCLIBetas(payload, nil, false); seenHeaders.Get("Anthropic-Beta") != want { t.Fatalf("Anthropic-Beta = %q, want %q", seenHeaders.Get("Anthropic-Beta"), want) }
system := gjson.GetBytes(seenBody, "system").Array() if len(system) != 2 { t.Fatalf("system block count = %d, want 2: %s", len(system), seenBody) } if got := system[0].Get("text").String(); got != "x-anthropic-billing-header: cc_version=2.1.258.1e2; cc_entrypoint=cli;" { t.Fatalf("billing header = %q, want 2.1.258 CLI fingerprint", got) } if got := system[1].Get("text").String(); got != claudeCodeCLIIdentity { t.Fatalf("system[1].text = %q, want official CLI identity", got) } if got := system[1].Get("cache_control.type").String(); got != "ephemeral" { t.Fatalf("system[1].cache_control.type = %q, want ephemeral", got) } // This credential is an API key, and native only selects the 1h cache pool for // OAuth. The body ttl therefore has to stay absent, matching the fact that // claudeCodeCLIBetas does not emit extended-cache-ttl-2025-04-11 here either. if system[1].Get("cache_control.ttl").Exists() { t.Fatalf("API-key request must not carry a 1h body ttl: %s", system[1].Raw) } if betas := seenHeaders.Get("Anthropic-Beta"); strings.Contains(betas, claudeExtendedCacheTTLBeta) { t.Fatalf("API-key request must not declare extended-cache-ttl: %s", betas) } content := gjson.GetBytes(seenBody, "messages.0.content").Array() if len(content) != 2 { t.Fatalf("messages[0].content has %d blocks, want currentDate and user text", len(content)) } assertClaudeCodeCurrentDateBlock(t, content[0]) assertEphemeralUserTextBlock(t, content[1], "x", "")
userID := gjson.GetBytes(seenBody, "metadata.user_id").String() if !helps.IsValidUserID(userID) { t.Fatalf("metadata.user_id = %q, want Claude Code JSON shape", userID) } if got, want := gjson.Get(userID, "session_id").String(), seenHeaders.Get("X-Claude-Code-Session-Id"); got != want { t.Fatalf("metadata session_id = %q, header session ID = %q", got, want) }}
func TestClaudeExecutor_ConfirmedClaudeCodeRequestPreservesInteractiveIdentity(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-opus-4-6","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
const sessionID = "11111111-2222-4333-8444-555555555555" const userID = `{"device_id":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","account_uuid":"","session_id":"11111111-2222-4333-8444-555555555555"}` payload := []byte(`{"model":"claude-opus-4-6","system":[{"type":"text","text":"interactive-system","cache_control":{"type":"ephemeral"}}],"messages":[{"role":"user","content":"x"}],"metadata":{"user_id":` + fmt.Sprintf("%q", userID) + `}}`) incoming := http.Header{ "User-Agent": {"claude-cli/2.1.258 (external, cli)"}, "X-App": {"cli"}, "Anthropic-Beta": {"claude-code-20250219,interleaved-thinking-2025-05-14,redact-thinking-2026-02-12,thinking-token-count-2026-05-13,context-management-2025-06-27,prompt-caching-scope-2026-01-05,effort-2025-11-24"}, "X-Claude-Code-Session-Id": {sessionID}, "X-Stainless-Package-Version": {"0.112.1"}, "X-Stainless-Runtime-Version": {"v26.3.0"}, "X-Stainless-Os": {"MacOS"}, "X-Stainless-Arch": {"arm64"}, } executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-confirmed-client", "base_url": server.URL, }}
_, errExecute := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-opus-4-6", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, OriginalRequest: payload, Headers: incoming, }) if errExecute != nil { t.Fatalf("Execute() error = %v", errExecute) }
assertClaudeFingerprint(t, seenHeaders, "claude-cli/2.1.258 (external, cli)", "0.112.1", "v26.3.0", "MacOS", "arm64") if got := gjson.GetBytes(seenBody, "system.0.text").String(); got != "interactive-system" { t.Fatalf("system.0.text = %q, want confirmed client system preserved", got) } if got := gjson.GetBytes(seenBody, "system.#").Int(); got != 1 { t.Fatalf("system block count = %d, want 1", got) } if got := gjson.GetBytes(seenBody, "metadata.user_id").String(); got != userID { t.Fatalf("metadata.user_id = %q, want preserved %q", got, userID) } if got := seenHeaders.Get("Anthropic-Beta"); got != incoming.Get("Anthropic-Beta") { t.Fatalf("Anthropic-Beta = %q, want preserved %q", got, incoming.Get("Anthropic-Beta")) }}
func TestClaudeExecutor_ConfirmedClaudeCodeWithoutCacheControlPreservesContent(t *testing.T) { tests := []struct { name string stream bool }{ {name: "non-stream"}, {name: "stream", stream: true}, }
for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) if tt.stream { w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte("event: message_stop\n" + `data: {"type":"message_stop"}` + "\n\n")) return } w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-opus-4-6","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
const sessionID = "11111111-2222-4333-8444-555555555555" const userID = `{"device_id":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","account_uuid":"","session_id":"11111111-2222-4333-8444-555555555555"}` payload := []byte(`{"model":"claude-opus-4-6","messages":[{"role":"user","content":"x"}],"metadata":{"user_id":` + fmt.Sprintf("%q", userID) + `}}`) incoming := http.Header{ "User-Agent": {"claude-cli/2.1.258 (external, cli)"}, "X-App": {"cli"}, "Anthropic-Beta": {"claude-code-20250219"}, "X-Claude-Code-Session-Id": {sessionID}, } executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-confirmed-markerless", "base_url": server.URL, }} req := cliproxyexecutor.Request{Model: "claude-opus-4-6", Payload: payload} opts := cliproxyexecutor.Options{ Stream: tt.stream, SourceFormat: sdktranslator.FormatClaude, OriginalRequest: payload, Headers: incoming, }
if tt.stream { result, errStream := executor.ExecuteStream(context.Background(), auth, req, opts) if errStream != nil { t.Fatalf("ExecuteStream() error = %v", errStream) } for chunk := range result.Chunks { if chunk.Err != nil { t.Fatalf("stream chunk error = %v", chunk.Err) } } } else if _, errExecute := executor.Execute(context.Background(), auth, req, opts); errExecute != nil { t.Fatalf("Execute() error = %v", errExecute) }
content := gjson.GetBytes(seenBody, "messages.0.content") if content.Type != gjson.String || content.String() != "x" { t.Fatalf("messages.0.content = %s, want native string content preserved; body=%s", content.Raw, seenBody) } if gjson.GetBytes(seenBody, "messages.0.content.0.cache_control").Exists() { t.Fatalf("confirmed markerless native request received synthetic cache_control: %s", seenBody) } }) }}
func TestClaudeExecutor_ConfirmedVSCodeAgentSDKRequestPreservesIdentity(t *testing.T) { helps.ResetClaudeDeviceProfileCache() var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-opus-4-6","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
const sessionID = "22222222-3333-4444-8555-666666666666" const userID = `{"device_id":"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb","account_uuid":"","session_id":"22222222-3333-4444-8555-666666666666"}` const vscodeUA = "claude-cli/2.1.258 (external, claude-vscode, agent-sdk/0.3.220)" const billingHeader = "x-anthropic-billing-header: cc_version=2.1.258.9cb; cc_entrypoint=claude-vscode;" payload := []byte(`{"model":"claude-opus-4-6","system":[{"type":"text","text":` + fmt.Sprintf("%q", billingHeader) + `},{"type":"text","text":"You are a Claude agent, built on Anthropic's Claude Agent SDK.","cache_control":{"type":"ephemeral","ttl":"1h"}},{"type":"text","text":"vscode-agent-system"}],"messages":[{"role":"user","content":"x"}],"metadata":{"user_id":` + fmt.Sprintf("%q", userID) + `}}`) incoming := http.Header{ "User-Agent": {vscodeUA}, "X-App": {"cli"}, "Anthropic-Beta": {"claude-code-20250219,interleaved-thinking-2025-05-14"}, "Anthropic-Dangerous-Direct-Browser-Access": {"true"}, "X-Claude-Code-Session-Id": {sessionID}, "X-Stainless-Package-Version": {"0.112.1"}, "X-Stainless-Runtime-Version": {"v26.3.0"}, "X-Stainless-Os": {"MacOS"}, "X-Stainless-Arch": {"arm64"}, } stabilize := true executor := NewClaudeExecutor(&config.Config{ClaudeHeaderDefaults: config.ClaudeHeaderDefaults{StabilizeDeviceProfile: &stabilize}}) auth := &cliproxyauth.Auth{ID: "auth-vscode-agent-sdk", Attributes: map[string]string{ "api_key": "key-vscode-agent-sdk", "base_url": server.URL, }}
_, errExecute := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-opus-4-6", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, OriginalRequest: payload, Headers: incoming, }) if errExecute != nil { t.Fatalf("Execute() error = %v", errExecute) }
assertClaudeFingerprint(t, seenHeaders, vscodeUA, "0.112.1", "v26.3.0", "MacOS", "arm64") if got := seenHeaders.Get("Anthropic-Dangerous-Direct-Browser-Access"); got != "true" { t.Fatalf("Anthropic-Dangerous-Direct-Browser-Access = %q, want preserved true", got) } if got := seenHeaders.Get("X-Claude-Code-Session-Id"); got != sessionID { t.Fatalf("X-Claude-Code-Session-Id = %q, want preserved %q", got, sessionID) } if got := gjson.GetBytes(seenBody, "system.0.text").String(); got != billingHeader { t.Fatalf("system.0.text = %q, want VSCode attribution preserved", got) } if got := gjson.GetBytes(seenBody, "system.1.text").String(); got != "You are a Claude agent, built on Anthropic's Claude Agent SDK." { t.Fatalf("system.1.text = %q, want VSCode Agent SDK identity preserved", got) } if got := gjson.GetBytes(seenBody, "system.1.cache_control.ttl").String(); got != "1h" { t.Fatalf("system.1.cache_control.ttl = %q, want preserved 1h", got) } if got := gjson.GetBytes(seenBody, "system.2.text").String(); got != "vscode-agent-system" { t.Fatalf("system.2.text = %q, want VSCode Agent SDK system preserved", got) } if got := gjson.GetBytes(seenBody, "system.#").Int(); got != 3 { t.Fatalf("system block count = %d, want 3", got) } if got := gjson.GetBytes(seenBody, "metadata.user_id").String(); got != userID { t.Fatalf("metadata.user_id = %q, want preserved %q", got, userID) }}
func TestClaudeExecutor_CopiedVSCodeAgentSDKHeadersWithoutMetadataAreCloaked(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-opus-4-6","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
payload := []byte(`{"model":"claude-opus-5","system":"spoofed-system","messages":[{"role":"user","content":"x"}]}`) executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-spoofed-client", "base_url": server.URL, "cloak_mode": "always", }} _, errExecute := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-opus-5", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, OriginalRequest: payload, Headers: http.Header{ "User-Agent": {"claude-cli/2.1.258 (external, claude-vscode, agent-sdk/0.3.220)"}, "X-App": {"cli"}, "Anthropic-Beta": {"claude-code-20250219"}, }, }) if errExecute != nil { t.Fatalf("Execute() error = %v", errExecute) }
if got := seenHeaders.Get("User-Agent"); got != "claude-cli/2.1.258 (external, cli)" { t.Fatalf("User-Agent = %q, want CLI cloak", got) } if got := gjson.GetBytes(seenBody, "system.#").Int(); got != 3 { t.Fatalf("system block count = %d, want billing, CLI identity and caller", got) } content := gjson.GetBytes(seenBody, "messages.0.content").Array() if len(content) != 2 { t.Fatalf("messages[0].content has %d blocks, want currentDate and user text", len(content)) } assertClaudeCodeCurrentDateBlock(t, content[0]) assertEphemeralUserTextBlock(t, content[1], "x", "") assertClaudeTopLevelCallerSystem(t, seenBody, 1, "spoofed-system", "")}
func TestClaudeExecutor_AgentSDKEntrypointWithStrongSignalsUsesCLICloak(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-opus-4-6","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
payload := []byte(`{"model":"claude-opus-4-6","system":"agent-sdk-system","messages":[{"role":"user","content":"x"}],"metadata":{"user_id":"agent-sdk-user"}}`) executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-agent-sdk-client", "base_url": server.URL, "cloak_mode": "always", }} _, errExecute := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-opus-4-6", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, OriginalRequest: payload, Headers: http.Header{ "User-Agent": {"claude-cli/2.1.258 (external, sdk-ts, agent-sdk/0.3.220)"}, "X-App": {"cli"}, "Anthropic-Beta": {"claude-code-20250219"}, }, }) if errExecute != nil { t.Fatalf("Execute() error = %v", errExecute) }
if got := seenHeaders.Get("User-Agent"); got != "claude-cli/2.1.258 (external, cli)" { t.Fatalf("User-Agent = %q, want CLI cloak", got) } if got := gjson.GetBytes(seenBody, "system.0.text").String(); !strings.Contains(got, "cc_entrypoint=cli;") { t.Fatalf("billing attribution = %q, want cli", got) } if got := gjson.GetBytes(seenBody, "system.1.text").String(); got != claudeCodeCLIIdentity { t.Fatalf("system.1.text = %q, want official CLI identity", got) }}
func TestClaudeExecutor_ConfirmedVSCodeOAuthPreservesToolNames(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-opus-4-6","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
const userID = `{"device_id":"cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc","account_uuid":"","session_id":"33333333-4444-4555-8666-777777777777"}` payload := []byte(`{"model":"claude-opus-4-6","system":[{"type":"text","text":"x-anthropic-billing-header: cc_version=2.1.258.9cb; cc_entrypoint=claude-vscode; cch=00000;"}],"tools":[{"name":"bash","description":"known native name must pass through","input_schema":{"type":"object"}},{"name":"search_web","description":"unknown native name must pass through","input_schema":{"type":"object"}}],"messages":[{"role":"user","content":"x"}],"metadata":{"user_id":` + fmt.Sprintf("%q", userID) + `}}`) deviceIDs := []string{ "0000000000000000000000000000000000000000000000000000000000000000", } executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ Attributes: map[string]string{ "api_key": "sk-ant-oat-native-vscode", "base_url": server.URL, }, Metadata: map[string]any{ "account_uuid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", "claude_device_ids": deviceIDs, "cloak_mode": "always", }, } _, errExecute := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-opus-4-6", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, OriginalRequest: payload, Headers: http.Header{ "User-Agent": {"claude-cli/2.1.258 (external, claude-vscode, agent-sdk/0.3.220)"}, "X-App": {"cli"}, "Anthropic-Beta": {"claude-code-20250219"}, "X-Stainless-Package-Version": {"0.112.1"}, "X-Stainless-Runtime-Version": {"v26.3.0"}, }, }) if errExecute != nil { t.Fatalf("Execute() error = %v", errExecute) }
if got := gjson.GetBytes(seenBody, "tools.0.name").String(); got != "bash" { t.Fatalf("tools.0.name = %q, want confirmed native known name preserved", got) } if got := gjson.GetBytes(seenBody, "tools.1.name").String(); got != "search_web" { t.Fatalf("tools.1.name = %q, want confirmed native unknown name preserved", got) } assertClaudeCredentialIdentity(t, seenBody, seenHeaders, deviceIDs, "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa") upstreamUserID := gjson.GetBytes(seenBody, "metadata.user_id").String() if upstreamDeviceID := gjson.Get(upstreamUserID, "device_id").String(); upstreamDeviceID == strings.Repeat("c", 64) { t.Fatalf("device_id = %q, want native device replaced by credential pool", upstreamDeviceID) } if got := gjson.Get(upstreamUserID, "session_id").String(); got != "33333333-4444-4555-8666-777777777777" { t.Fatalf("session_id = %q, want downstream agent session", got) } if got := seenHeaders.Get("X-Claude-Code-Session-Id"); got != "33333333-4444-4555-8666-777777777777" { t.Fatalf("X-Claude-Code-Session-Id = %q, want downstream agent session", got) }}
func TestClaudeDeviceProfileStabilizationEnabled_DefaultFalse(t *testing.T) { if helps.ClaudeDeviceProfileStabilizationEnabled(nil) { t.Fatal("expected nil config to default to disabled stabilization") } if helps.ClaudeDeviceProfileStabilizationEnabled(&config.Config{}) { t.Fatal("expected unset stabilize-device-profile to default to disabled stabilization") }}
func TestApplyClaudeToolPrefix(t *testing.T) { input := []byte(`{"tools":[{"name":"alpha"},{"name":"proxy_bravo"}],"tool_choice":{"type":"tool","name":"charlie"},"messages":[{"role":"assistant","content":[{"type":"tool_use","name":"delta","id":"t1","input":{}}]}]}`) out := applyClaudeToolPrefix(input, "proxy_")
if got := gjson.GetBytes(out, "tools.0.name").String(); got != "proxy_alpha" { t.Fatalf("tools.0.name = %q, want %q", got, "proxy_alpha") } if got := gjson.GetBytes(out, "tools.1.name").String(); got != "proxy_bravo" { t.Fatalf("tools.1.name = %q, want %q", got, "proxy_bravo") } if got := gjson.GetBytes(out, "tool_choice.name").String(); got != "proxy_charlie" { t.Fatalf("tool_choice.name = %q, want %q", got, "proxy_charlie") } if got := gjson.GetBytes(out, "messages.0.content.0.name").String(); got != "proxy_delta" { t.Fatalf("messages.0.content.0.name = %q, want %q", got, "proxy_delta") }}
func TestApplyClaudeToolPrefix_WithToolReference(t *testing.T) { input := []byte(`{"tools":[{"name":"alpha"}],"messages":[{"role":"user","content":[{"type":"tool_reference","tool_name":"beta"},{"type":"tool_reference","tool_name":"proxy_gamma"}]}]}`) out := applyClaudeToolPrefix(input, "proxy_")
if got := gjson.GetBytes(out, "messages.0.content.0.tool_name").String(); got != "proxy_beta" { t.Fatalf("messages.0.content.0.tool_name = %q, want %q", got, "proxy_beta") } if got := gjson.GetBytes(out, "messages.0.content.1.tool_name").String(); got != "proxy_gamma" { t.Fatalf("messages.0.content.1.tool_name = %q, want %q", got, "proxy_gamma") }}
func TestSanitizeClaudeWebSearchDomains(t *testing.T) { // Mirrors the litellm payload from issue #2681: a non-empty allowed_domains // alongside an empty blocked_domains, which Anthropic rejects as ambiguous. input := []byte(`{"tools":[{"type":"web_search_20250305","name":"web_search","allowed_domains":["anthropic.com"],"blocked_domains":[],"max_uses":8}]}`) out := sanitizeClaudeWebSearchDomains(input)
if gjson.GetBytes(out, "tools.0.blocked_domains").Exists() { t.Fatalf("empty blocked_domains should be removed: %s", string(out)) } if got := gjson.GetBytes(out, "tools.0.allowed_domains").Array(); len(got) != 1 || got[0].String() != "anthropic.com" { t.Fatalf("non-empty allowed_domains should be preserved: %s", string(out)) } if got := gjson.GetBytes(out, "tools.0.max_uses").Int(); got != 8 { t.Fatalf("max_uses should be preserved: got %d", got) }}
func TestSanitizeClaudeWebSearchDomains_LeavesNonBuiltinAndNonEmpty(t *testing.T) { // Empty arrays on non-web_search tools must be left untouched. input := []byte(`{"tools":[{"type":"custom","name":"x","blocked_domains":[]},{"type":"web_search_20250305","name":"web_search","blocked_domains":["evil.com"]}]}`) out := sanitizeClaudeWebSearchDomains(input)
if !gjson.GetBytes(out, "tools.0.blocked_domains").Exists() { t.Fatalf("non-web_search tool fields should be untouched: %s", string(out)) } if got := gjson.GetBytes(out, "tools.1.blocked_domains").Array(); len(got) != 1 || got[0].String() != "evil.com" { t.Fatalf("non-empty blocked_domains should be preserved: %s", string(out)) }}
func TestApplyClaudeToolPrefix_SkipsBuiltinTools(t *testing.T) { input := []byte(`{"tools":[{"type":"web_search_20250305","name":"web_search"},{"name":"my_custom_tool","input_schema":{"type":"object"}}]}`) out := applyClaudeToolPrefix(input, "proxy_")
if got := gjson.GetBytes(out, "tools.0.name").String(); got != "web_search" { t.Fatalf("built-in tool name should not be prefixed: tools.0.name = %q, want %q", got, "web_search") } if got := gjson.GetBytes(out, "tools.1.name").String(); got != "proxy_my_custom_tool" { t.Fatalf("custom tool should be prefixed: tools.1.name = %q, want %q", got, "proxy_my_custom_tool") }}
func TestApplyClaudeToolPrefix_BuiltinToolSkipped(t *testing.T) { body := []byte(`{ "tools": [ {"type": "web_search_20250305", "name": "web_search", "max_uses": 5}, {"name": "Read"} ], "messages": [ {"role": "user", "content": [ {"type": "tool_use", "name": "web_search", "id": "ws1", "input": {}}, {"type": "tool_use", "name": "Read", "id": "r1", "input": {}} ]} ] }`) out := applyClaudeToolPrefix(body, "proxy_")
if got := gjson.GetBytes(out, "tools.0.name").String(); got != "web_search" { t.Fatalf("tools.0.name = %q, want %q", got, "web_search") } if got := gjson.GetBytes(out, "messages.0.content.0.name").String(); got != "web_search" { t.Fatalf("messages.0.content.0.name = %q, want %q", got, "web_search") } if got := gjson.GetBytes(out, "tools.1.name").String(); got != "proxy_Read" { t.Fatalf("tools.1.name = %q, want %q", got, "proxy_Read") } if got := gjson.GetBytes(out, "messages.0.content.1.name").String(); got != "proxy_Read" { t.Fatalf("messages.0.content.1.name = %q, want %q", got, "proxy_Read") }}
func TestApplyClaudeToolPrefix_KnownBuiltinInHistoryOnly(t *testing.T) { body := []byte(`{ "tools": [ {"name": "Read"} ], "messages": [ {"role": "user", "content": [ {"type": "tool_use", "name": "web_search", "id": "ws1", "input": {}} ]} ] }`) out := applyClaudeToolPrefix(body, "proxy_")
if got := gjson.GetBytes(out, "messages.0.content.0.name").String(); got != "web_search" { t.Fatalf("messages.0.content.0.name = %q, want %q", got, "web_search") } if got := gjson.GetBytes(out, "tools.0.name").String(); got != "proxy_Read" { t.Fatalf("tools.0.name = %q, want %q", got, "proxy_Read") }}
func TestApplyClaudeToolPrefix_CustomToolsPrefixed(t *testing.T) { body := []byte(`{ "tools": [{"name": "Read"}, {"name": "Write"}], "messages": [ {"role": "user", "content": [ {"type": "tool_use", "name": "Read", "id": "r1", "input": {}}, {"type": "tool_use", "name": "Write", "id": "w1", "input": {}} ]} ] }`) out := applyClaudeToolPrefix(body, "proxy_")
if got := gjson.GetBytes(out, "tools.0.name").String(); got != "proxy_Read" { t.Fatalf("tools.0.name = %q, want %q", got, "proxy_Read") } if got := gjson.GetBytes(out, "tools.1.name").String(); got != "proxy_Write" { t.Fatalf("tools.1.name = %q, want %q", got, "proxy_Write") } if got := gjson.GetBytes(out, "messages.0.content.0.name").String(); got != "proxy_Read" { t.Fatalf("messages.0.content.0.name = %q, want %q", got, "proxy_Read") } if got := gjson.GetBytes(out, "messages.0.content.1.name").String(); got != "proxy_Write" { t.Fatalf("messages.0.content.1.name = %q, want %q", got, "proxy_Write") }}
func TestApplyClaudeToolPrefix_ToolChoiceBuiltin(t *testing.T) { body := []byte(`{ "tools": [ {"type": "web_search_20250305", "name": "web_search"}, {"name": "Read"} ], "tool_choice": {"type": "tool", "name": "web_search"} }`) out := applyClaudeToolPrefix(body, "proxy_")
if got := gjson.GetBytes(out, "tool_choice.name").String(); got != "web_search" { t.Fatalf("tool_choice.name = %q, want %q", got, "web_search") }}
func TestApplyClaudeToolPrefix_KnownFallbackBuiltinsRemainUnprefixed(t *testing.T) { for _, builtin := range []string{"web_search", "code_execution", "text_editor", "computer"} { t.Run(builtin, func(t *testing.T) { input := []byte(fmt.Sprintf(`{ "tools":[{"name":"Read"}], "tool_choice":{"type":"tool","name":%q}, "messages":[{"role":"assistant","content":[{"type":"tool_use","name":%q,"id":"toolu_1","input":{}},{"type":"tool_reference","tool_name":%q},{"type":"tool_result","tool_use_id":"toolu_1","content":[{"type":"tool_reference","tool_name":%q}]}]}] }`, builtin, builtin, builtin, builtin)) out := applyClaudeToolPrefix(input, "proxy_")
if got := gjson.GetBytes(out, "tool_choice.name").String(); got != builtin { t.Fatalf("tool_choice.name = %q, want %q", got, builtin) } if got := gjson.GetBytes(out, "messages.0.content.0.name").String(); got != builtin { t.Fatalf("messages.0.content.0.name = %q, want %q", got, builtin) } if got := gjson.GetBytes(out, "messages.0.content.1.tool_name").String(); got != builtin { t.Fatalf("messages.0.content.1.tool_name = %q, want %q", got, builtin) } if got := gjson.GetBytes(out, "messages.0.content.2.content.0.tool_name").String(); got != builtin { t.Fatalf("messages.0.content.2.content.0.tool_name = %q, want %q", got, builtin) } if got := gjson.GetBytes(out, "tools.0.name").String(); got != "proxy_Read" { t.Fatalf("tools.0.name = %q, want %q", got, "proxy_Read") } }) }}
func TestStripClaudeToolPrefixFromResponse(t *testing.T) { input := []byte(`{"content":[{"type":"tool_use","name":"proxy_alpha","id":"t1","input":{}},{"type":"tool_use","name":"bravo","id":"t2","input":{}}]}`) out := stripClaudeToolPrefixFromResponse(input, "proxy_")
if got := gjson.GetBytes(out, "content.0.name").String(); got != "alpha" { t.Fatalf("content.0.name = %q, want %q", got, "alpha") } if got := gjson.GetBytes(out, "content.1.name").String(); got != "bravo" { t.Fatalf("content.1.name = %q, want %q", got, "bravo") }}
func TestStripClaudeToolPrefixFromResponse_WithToolReference(t *testing.T) { input := []byte(`{"content":[{"type":"tool_reference","tool_name":"proxy_alpha"},{"type":"tool_reference","tool_name":"bravo"}]}`) out := stripClaudeToolPrefixFromResponse(input, "proxy_")
if got := gjson.GetBytes(out, "content.0.tool_name").String(); got != "alpha" { t.Fatalf("content.0.tool_name = %q, want %q", got, "alpha") } if got := gjson.GetBytes(out, "content.1.tool_name").String(); got != "bravo" { t.Fatalf("content.1.tool_name = %q, want %q", got, "bravo") }}
func TestStripClaudeToolPrefixFromStreamLine(t *testing.T) { line := []byte(`data: {"type":"content_block_start","content_block":{"type":"tool_use","name":"proxy_alpha","id":"t1"},"index":0}`) out := stripClaudeToolPrefixFromStreamLine(line, "proxy_")
payload := bytes.TrimSpace(out) if bytes.HasPrefix(payload, []byte("data:")) { payload = bytes.TrimSpace(payload[len("data:"):]) } if got := gjson.GetBytes(payload, "content_block.name").String(); got != "alpha" { t.Fatalf("content_block.name = %q, want %q", got, "alpha") }}
func TestStripClaudeToolPrefixFromStreamLine_WithToolReference(t *testing.T) { line := []byte(`data: {"type":"content_block_start","content_block":{"type":"tool_reference","tool_name":"proxy_beta"},"index":0}`) out := stripClaudeToolPrefixFromStreamLine(line, "proxy_")
payload := bytes.TrimSpace(out) if bytes.HasPrefix(payload, []byte("data:")) { payload = bytes.TrimSpace(payload[len("data:"):]) } if got := gjson.GetBytes(payload, "content_block.tool_name").String(); got != "beta" { t.Fatalf("content_block.tool_name = %q, want %q", got, "beta") }}
func TestApplyClaudeToolPrefix_PreservesNestedMCPToolReference(t *testing.T) { input := []byte(`{"messages":[{"role":"user","content":[{"type":"tool_result","tool_use_id":"toolu_123","content":[{"type":"tool_reference","tool_name":"mcp__nia__manage_resource"}]}]}]}`) out := applyClaudeToolPrefix(input, "proxy_") got := gjson.GetBytes(out, "messages.0.content.0.content.0.tool_name").String() if got != "mcp__nia__manage_resource" { t.Fatalf("nested tool_reference tool_name = %q, want MCP name preserved", got) }}
func TestClaudeExecutor_ExecuteStripsOpenAIEncryptedThinkingBeforeUpstream(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) seenBody = bytes.Clone(body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-3-5-sonnet","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{ "messages": [ {"role":"assistant","content":[ {"type":"thinking","thinking":"codex reasoning","signature":"gAAAAABopenai-encrypted-content"}, {"type":"text","text":"Answer"} ]}, {"role":"user","content":[{"type":"text","text":"next"}]} ] }`)
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) if err != nil { t.Fatalf("Execute() error = %v", err) } if len(seenBody) == 0 { t.Fatal("expected request body to be captured") } if strings.Contains(string(seenBody), "gAAAAABopenai-encrypted-content") || strings.Contains(string(seenBody), "codex reasoning") { t.Fatalf("invalid thinking block was forwarded: %s", string(seenBody)) } content := gjson.GetBytes(seenBody, "messages.0.content").Array() if len(content) != 1 { t.Fatalf("messages.0.content length = %d, want 1: %s", len(content), string(seenBody)) } if got := content[0].Get("text").String(); got != "Answer" { t.Fatalf("remaining content text = %q, want Answer", got) }}
func TestClaudeExecutor_ExecuteStripsForeignToolUseSignaturesBeforeUpstream(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) seenBody = bytes.Clone(body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-3-5-sonnet","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{ "messages": [ {"role":"assistant","content":[ { "type":"tool_use", "id":"toolu_1", "name":"lookup", "input":{"q":"x"}, "signature":"skip_thought_signature_validator", "thought_signature":"skip_thought_signature_validator", "extra_content":{"google":{"thought_signature":"skip_thought_signature_validator"}} } ]}, {"role":"user","content":[{"type":"tool_result","tool_use_id":"toolu_1","content":"ok"}]} ] }`)
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) if err != nil { t.Fatalf("Execute() error = %v", err) } if len(seenBody) == 0 { t.Fatal("expected request body to be captured") } toolUse := gjson.GetBytes(seenBody, "messages.0.content.0") if !toolUse.Get("type").Exists() || toolUse.Get("type").String() != "tool_use" { t.Fatalf("tool_use block was not preserved: %s", string(seenBody)) } for _, path := range []string{"signature", "thought_signature", "extra_content"} { if toolUse.Get(path).Exists() { t.Fatalf("foreign tool_use signature field %s was forwarded: %s", path, string(seenBody)) } }}
func TestShouldSanitizeClaudeMessagesForUpstream_OnlyClaudeFamily(t *testing.T) { cases := []struct { model string want bool }{ {model: "claude-sonnet-4-5", want: true}, {model: "claude-3-5-sonnet-20241022", want: true}, {model: "kimi-k2.5", want: false}, {model: "mimo-v2", want: false}, {model: "gemini-3.5-flash", want: false}, } for _, tc := range cases { t.Run(tc.model, func(t *testing.T) { got := shouldSanitizeClaudeMessagesForUpstream(tc.model) if got != tc.want { t.Errorf("shouldSanitizeClaudeMessagesForUpstream(%q) = %v, want %v", tc.model, got, tc.want) } }) }}
func TestSanitizeClaudeMessagesForClaudeUpstream_BypassesUnknownModelSignatureMatrix(t *testing.T) { rawSignature := "skip_thought_signature_validator" body := []byte(`{ "model": "kimi-k2.5", "messages": [ { "role": "assistant", "content": [ {"type": "thinking", "thinking": "keep", "signature": "` + rawSignature + `"}, {"type": "text", "text": "hello"}, {"type": "tool_use", "id": "call_123", "name": "get_weather", "input": {}, "signature": "` + rawSignature + `"} ] } ] }`)
output := sanitizeClaudeMessagesForClaudeUpstreamWithDebug(context.Background(), body, "kimi-k2.5") parts := gjson.GetBytes(output, "messages.0.content").Array() if len(parts) != 3 { t.Fatalf("content length = %d, want 3 when sanitizer is bypassed: %s", len(parts), output) } if got := parts[0].Get("signature").String(); got != rawSignature { t.Fatalf("thinking signature = %q, want preserved %q", got, rawSignature) } if got := parts[2].Get("signature").String(); got != rawSignature { t.Fatalf("tool_use signature = %q, want preserved %q", got, rawSignature) }}
func TestClaudeExecutor_ExecuteBypassesSignatureSanitizerForUnknownModel(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) seenBody = bytes.Clone(body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"mimo-v2","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{ "messages": [ {"role":"assistant","content":[ {"type":"thinking","thinking":"keep reasoning","signature":""}, {"type":"text","text":"Answer"} ]}, {"role":"user","content":[{"type":"text","text":"next"}]} ] }`)
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "mimo-v2", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) if err != nil { t.Fatalf("Execute() error = %v", err) } if len(seenBody) == 0 { t.Fatal("expected request body to be captured") } if !strings.Contains(string(seenBody), "keep reasoning") { t.Fatalf("unknown-model thinking block should bypass Claude sanitizer: %s", string(seenBody)) }}
func TestClaudeExecutor_ExecuteStripsMalformedEPrefixThinkingBeforeUpstream(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) seenBody = bytes.Clone(body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-3-5-sonnet","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} malformedSignature := malformedClaudeTreeSignatureForClaudeExecutorTest() payload := []byte(`{ "messages": [ {"role":"assistant","content":[ {"type":"thinking","thinking":"bad reasoning","signature":"` + malformedSignature + `"}, {"type":"text","text":"Answer"} ]}, {"role":"user","content":[{"type":"text","text":"next"}]} ] }`)
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) if err != nil { t.Fatalf("Execute() error = %v", err) } if len(seenBody) == 0 { t.Fatal("expected request body to be captured") } if strings.Contains(string(seenBody), malformedSignature) || strings.Contains(string(seenBody), "bad reasoning") { t.Fatalf("malformed E-prefix thinking block was forwarded: %s", string(seenBody)) } content := gjson.GetBytes(seenBody, "messages.0.content").Array() if len(content) != 1 { t.Fatalf("messages.0.content length = %d, want 1: %s", len(content), string(seenBody)) } if got := content[0].Get("text").String(); got != "Answer" { t.Fatalf("remaining content text = %q, want Answer", got) }}
func TestClaudeExecutor_ExecuteStripsInvalidBase64ThinkingBeforeUpstream(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) seenBody = bytes.Clone(body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-3-5-sonnet","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{ "messages": [ {"role":"assistant","content":[ {"type":"thinking","thinking":"bad reasoning","signature":"E!!!invalid!!!"}, {"type":"text","text":"Answer"} ]}, {"role":"user","content":[{"type":"text","text":"next"}]} ] }`)
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) if err != nil { t.Fatalf("Execute() error = %v", err) } if len(seenBody) == 0 { t.Fatal("expected request body to be captured") } if strings.Contains(string(seenBody), "E!!!invalid!!!") || strings.Contains(string(seenBody), "bad reasoning") { t.Fatalf("invalid-base64 thinking block was forwarded: %s", string(seenBody)) } content := gjson.GetBytes(seenBody, "messages.0.content").Array() if len(content) != 1 { t.Fatalf("messages.0.content length = %d, want 1: %s", len(content), string(seenBody)) }}
func TestClaudeExecutor_ExecuteStripsEmptySignatureEmptyTextThinking(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) seenBody = bytes.Clone(body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-3-5-sonnet","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{ "messages": [ {"role":"assistant","content":[ {"type":"thinking","text":"","signature":""}, {"type":"text","text":"Answer"} ]}, {"role":"user","content":[{"type":"text","text":"next"}]} ] }`)
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) if err != nil { t.Fatalf("Execute() error = %v", err) } if len(seenBody) == 0 { t.Fatal("expected request body to be captured") } content := gjson.GetBytes(seenBody, "messages.0.content").Array() if len(content) != 1 { t.Fatalf("messages.0.content length = %d, want 1: %s", len(content), string(seenBody)) } if got := content[0].Get("type").String(); got != "text" { t.Fatalf("remaining content type = %q, want text: %s", got, string(seenBody)) } if got := content[0].Get("text").String(); got != "Answer" { t.Fatalf("remaining content text = %q, want Answer: %s", got, string(seenBody)) }}
func TestClaudeExecutor_ExecuteStreamStripsOpenAIEncryptedThinkingBeforeUpstream(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) seenBody = bytes.Clone(body) w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte("data: {\"type\":\"message_stop\"}\n\n")) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{ "messages": [ {"role":"assistant","content":[ {"type":"thinking","thinking":"codex reasoning","signature":"gAAAAABopenai-encrypted-content"}, {"type":"text","text":"Answer"} ]}, {"role":"user","content":[{"type":"text","text":"next"}]} ] }`)
result, err := executor.ExecuteStream(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) if err != nil { t.Fatalf("ExecuteStream() error = %v", err) } for chunk := range result.Chunks { if chunk.Err != nil { t.Fatalf("unexpected chunk error: %v", chunk.Err) } } if len(seenBody) == 0 { t.Fatal("expected request body to be captured") } if strings.Contains(string(seenBody), "gAAAAABopenai-encrypted-content") || strings.Contains(string(seenBody), "codex reasoning") { t.Fatalf("invalid thinking block was forwarded: %s", string(seenBody)) }}
func claudeOAuthCancellationTestMetadata() map[string]any { return map[string]any{ "account_uuid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", claudeauth.ClaudeDeviceIDsMetadataKey: []string{ "0000000000000000000000000000000000000000000000000000000000000000", }, }}
func TestClaudeExecutor_ExecuteStreamOAuthStartupCancellationIsRequestScoped(t *testing.T) { started := make(chan struct{}) release := make(chan struct{}) server := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) { close(started) <-release })) defer server.Close() defer close(release)
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ ID: "oauth-stream-startup-cancellation", Attributes: map[string]string{ "api_key": "sk-ant-oat-stream-startup-cancellation", "base_url": server.URL, }, Metadata: claudeOAuthCancellationTestMetadata(), } ctx, cancel := context.WithCancel(context.Background()) errCh := make(chan error, 1) go func() { _, errStream := executor.ExecuteStream(ctx, auth, cliproxyexecutor.Request{ Model: "claude-opus-5", Payload: []byte(`{"model":"claude-opus-5","messages":[{"role":"user","content":"hello"}],"stream":true}`), }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) errCh <- errStream }() <-started cancel()
select { case errStream := <-errCh: if !errors.Is(errStream, context.Canceled) { t.Fatalf("ExecuteStream() error = %v, want context.Canceled", errStream) } var requestErr cliproxyexecutor.RequestScopedError if !errors.As(errStream, &requestErr) || requestErr == nil || !requestErr.IsRequestScoped() { t.Fatalf("ExecuteStream() error = %T %v, want request-scoped cancellation", errStream, errStream) } case <-time.After(2 * time.Second): t.Fatal("timed out waiting for startup cancellation") }}
func TestClaudeExecutor_ExecuteStreamOAuthCancellationIsRequestScoped(t *testing.T) { started := make(chan struct{}) server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") w.WriteHeader(http.StatusOK) _, _ = w.Write([]byte("data")) if flusher, ok := w.(http.Flusher); ok { flusher.Flush() } close(started) <-r.Context().Done() })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ ID: "oauth-stream-cancellation", Attributes: map[string]string{ "api_key": "sk-ant-oat-stream-cancellation", "base_url": server.URL, }, Metadata: claudeOAuthCancellationTestMetadata(), } payload := []byte(`{"model":"claude-opus-5","system":"system prompt","messages":[{"role":"user","content":"hello"}],"stream":true}`) ctx, cancel := context.WithCancel(context.Background()) result, errStream := executor.ExecuteStream(ctx, auth, cliproxyexecutor.Request{ Model: "claude-opus-5", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if errStream != nil { cancel() t.Fatalf("ExecuteStream() error = %v", errStream) } <-started cancel()
var cancellationErr error deadline := time.After(2 * time.Second) for cancellationErr == nil { select { case chunk, ok := <-result.Chunks: if !ok { t.Fatal("stream closed without a cancellation result") } cancellationErr = chunk.Err case <-deadline: t.Fatal("timed out waiting for cancellation result") } } if !errors.Is(cancellationErr, context.Canceled) { t.Fatalf("stream error = %v, want context.Canceled", cancellationErr) } var requestErr cliproxyexecutor.RequestScopedError if !errors.As(cancellationErr, &requestErr) || requestErr == nil || !requestErr.IsRequestScoped() { t.Fatalf("stream error = %T %v, want request-scoped cancellation", cancellationErr, cancellationErr) } var statusErr interface{ StatusCode() int } if errors.As(cancellationErr, &statusErr) { t.Fatalf("stream cancellation unexpectedly exposes HTTP status %d", statusErr.StatusCode()) } for range result.Chunks { }}
func TestClaudeExecutor_ExecuteStreamDirectPassthroughEmitsCompleteSSEEvents(t *testing.T) { firstData := `{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"hi"}}` secondData := `{"type":"message_stop"}` upstreamStream := "event: content_block_delta\n" + "data: " + firstData + "\n" + "\n" + "event: message_stop\n" + "data: " + secondData + "\n" + "\n"
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte(upstreamStream)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{"messages":[{"role":"user","content":[{"type":"text","text":"hi"}]}]}`)
result, err := executor.ExecuteStream(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) if err != nil { t.Fatalf("ExecuteStream() error = %v", err) }
var payloads []string for chunk := range result.Chunks { if chunk.Err != nil { t.Fatalf("unexpected chunk error: %v", chunk.Err) } payloads = append(payloads, string(chunk.Payload)) }
want := []string{ "event: content_block_delta\n" + "data: " + firstData + "\n\n", "event: message_stop\n" + "data: " + secondData + "\n\n", } if len(payloads) != len(want) { t.Fatalf("payload count = %d, want %d: %#v", len(payloads), len(want), payloads) } for i := range want { if payloads[i] != want[i] { t.Fatalf("payload[%d] = %q, want %q", i, payloads[i], want[i]) } }}
// TestClaudeExecutor_ExecuteStreamDecodesCompressedSSE guards the dependency that// lets CPA advertise the real client's Accept-Encoding on streaming requests:// once compression is offered the upstream may compress the SSE body, so the// streaming success path must decode it and still emit event boundaries intact.func TestClaudeExecutor_ExecuteStreamDecodesCompressedSSE(t *testing.T) { firstData := `{"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"hi"}}` secondData := `{"type":"message_stop"}` upstreamStream := "event: content_block_delta\n" + "data: " + firstData + "\n" + "\n" + "event: message_stop\n" + "data: " + secondData + "\n" + "\n"
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") w.Header().Set("Content-Encoding", "gzip") gzipWriter := gzip.NewWriter(w) if _, errWrite := gzipWriter.Write([]byte(upstreamStream)); errWrite != nil { t.Errorf("gzip write: %v", errWrite) } if errClose := gzipWriter.Close(); errClose != nil { t.Errorf("gzip close: %v", errClose) } })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{"messages":[{"role":"user","content":[{"type":"text","text":"hi"}]}]}`)
result, err := executor.ExecuteStream(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) if err != nil { t.Fatalf("ExecuteStream() error = %v", err) }
var payloads []string for chunk := range result.Chunks { if chunk.Err != nil { t.Fatalf("unexpected chunk error: %v", chunk.Err) } payloads = append(payloads, string(chunk.Payload)) }
want := []string{ "event: content_block_delta\n" + "data: " + firstData + "\n\n", "event: message_stop\n" + "data: " + secondData + "\n\n", } if len(payloads) != len(want) { t.Fatalf("payload count = %d, want %d: %#v", len(payloads), len(want), payloads) } for i := range want { if payloads[i] != want[i] { t.Fatalf("payload[%d] = %q, want %q", i, payloads[i], want[i]) } }}
func TestClaudeExecutor_CountTokensExcludesInvalidOpenAIThinking(t *testing.T) { executor := NewClaudeExecutor(&config.Config{}) countTokens := func(payload []byte) int64 { t.Helper() resp, err := executor.CountTokens(context.Background(), nil, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) if err != nil { t.Fatalf("CountTokens() error = %v", err) } return gjson.GetBytes(resp.Payload, "input_tokens").Int() }
withInvalidThinking := []byte(`{ "messages": [ {"role":"assistant","content":[ {"type":"thinking","thinking":"codex reasoning","signature":"gAAAAABopenai-encrypted-content"}, {"type":"text","text":"Answer"} ]}, {"role":"user","content":[{"type":"text","text":"next"}]} ] }`) withoutInvalidThinking := []byte(`{ "messages": [ {"role":"assistant","content":[{"type":"text","text":"Answer"}]}, {"role":"user","content":[{"type":"text","text":"next"}]} ] }`)
if got, want := countTokens(withInvalidThinking), countTokens(withoutInvalidThinking); got != want { t.Fatalf("count with invalid thinking = %d, want sanitized count %d", got, want) }}
func TestClaudeCountTokensBetasForCredentialMatchesNativeOAuth220(t *testing.T) { want := "claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,context-management-2025-06-27,token-counting-2024-11-01" if got := claudeCountTokensBetasForCredential(true); got != want { t.Fatalf("OAuth count_tokens betas = %q, want %q", got, want) } wantAPIKey := "claude-code-20250219,interleaved-thinking-2025-05-14,context-management-2025-06-27,token-counting-2024-11-01" if got := claudeCountTokensBetasForCredential(false); got != wantAPIKey { t.Fatalf("API-key count_tokens betas = %q, want %q", got, wantAPIKey) } if got := withClaudeCountTokensOAuthBeta(wantAPIKey); got != want { t.Fatalf("confirmed-client count_tokens betas = %q, want %q", got, want) }}
func TestShouldUseClaudeUpstreamTokenCount(t *testing.T) { tests := []struct { name string apiKey string baseURL string want bool }{ {name: "official OAuth", apiKey: "sk-ant-oat-official", baseURL: "https://api.anthropic.com", want: true}, {name: "official API key", apiKey: "key-official", baseURL: "https://api.anthropic.com:443", want: true}, {name: "custom OAuth", apiKey: "sk-ant-oat-custom", baseURL: "https://gateway.example"}, {name: "custom API key", apiKey: "key-custom", baseURL: "https://gateway.example"}, {name: "lookalike host", apiKey: "sk-ant-oat-lookalike", baseURL: "https://api.anthropic.com.example"}, {name: "insecure official host", apiKey: "sk-ant-oat-http", baseURL: "http://api.anthropic.com"}, {name: "missing credential", baseURL: "https://api.anthropic.com"}, }
for _, test := range tests { t.Run(test.name, func(t *testing.T) { if got := shouldUseClaudeUpstreamTokenCount(test.apiKey, test.baseURL); got != test.want { t.Fatalf("shouldUseClaudeUpstreamTokenCount() = %v, want %v", got, test.want) } }) }}
func TestClaudeExecutor_LegacySystemPreservedAcrossMessagesAndStream(t *testing.T) { var mu sync.Mutex captured := make(map[string][]byte) server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) if strings.Contains(r.URL.Path, "count_tokens") { t.Errorf("custom OAuth count_tokens unexpectedly reached upstream: %s", r.URL.Path) w.WriteHeader(http.StatusInternalServerError) return } kind := "messages" if gjson.GetBytes(body, "stream").Bool() { kind = "stream" } mu.Lock() captured[kind] = bytes.Clone(body) mu.Unlock() switch kind { case "stream": w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte("event: message_stop\ndata: {\"type\":\"message_stop\"}\n\n")) default: w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_legacy","type":"message","model":"claude-opus-4-6","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) } })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ ID: "oauth-legacy-reminder-paths", Attributes: map[string]string{ "api_key": "sk-ant-oat-legacy-reminder-paths", "base_url": server.URL, }, Metadata: map[string]any{ "account_uuid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", claudeauth.ClaudeDeviceIDsMetadataKey: []string{ "0000000000000000000000000000000000000000000000000000000000000000", }, }, } makePayload := func(userText string, stream bool) []byte { streamField := "" if stream { streamField = `,"stream":true` } return []byte(`{"model":"claude-opus-4-6","system":"legacy-system-prompt","messages":[{"role":"user","content":` + fmt.Sprintf("%q", userText) + `}]` + streamField + `}`) }
if _, errExecute := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-opus-4-6", Payload: makePayload("messages-user", false), }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}); errExecute != nil { t.Fatalf("Execute() error = %v", errExecute) } countResp, errCount := executor.CountTokens(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-opus-4-6", Payload: makePayload("count-user", false), }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if errCount != nil { t.Fatalf("CountTokens() error = %v", errCount) } if got := gjson.GetBytes(countResp.Payload, "input_tokens").Int(); got <= 0 { t.Fatalf("local count_tokens input_tokens = %d, want positive estimate", got) } streamResult, errStream := executor.ExecuteStream(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-opus-4-6", Payload: makePayload("stream-user", true), }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if errStream != nil { t.Fatalf("ExecuteStream() error = %v", errStream) } for chunk := range streamResult.Chunks { if chunk.Err != nil { t.Fatalf("stream chunk error = %v", chunk.Err) } }
mu.Lock() bodies := map[string][]byte{ "messages": bytes.Clone(captured["messages"]), "stream": bytes.Clone(captured["stream"]), } mu.Unlock() for kind, wantUser := range map[string]string{"messages": "messages-user", "stream": "stream-user"} { body := bodies[kind] if len(body) == 0 { t.Fatalf("missing %s upstream capture", kind) } assertClaudePreservedSystemLayout(t, body, "legacy-system-prompt", wantUser, "1h") if _, ok := claudeBillingCCHDigitsOffset(body); !ok { t.Fatalf("%s body is missing final CCH", kind) } }}
func TestClaudeExecutor_CountTokensUpstreamCloakNeverPreservesCustomTool(t *testing.T) { var upstreamBody []byte var upstreamHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { upstreamBody, _ = io.ReadAll(r.Body) upstreamHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"input_tokens":7}`)) })) defer server.Close()
deviceIDs := []string{ "0000000000000000000000000000000000000000000000000000000000000000", } auth := &cliproxyauth.Auth{ ID: "oauth-never-count-tokens", Attributes: map[string]string{ "api_key": "sk-ant-oat-never-count-tokens", "base_url": server.URL, }, Metadata: map[string]any{ "account_uuid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", claudeauth.ClaudeDeviceIDsMetadataKey: deviceIDs, "cloak_mode": "never", }, } payload := []byte(`{"model":"claude-opus-4-6","messages":[{"role":"user","content":"search"}],"tools":[{"name":"search_web","input_schema":{"type":"object"}}]}`) executor := NewClaudeExecutor(&config.Config{}) _, errCount := executor.countTokensUpstream(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-opus-4-6", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, Metadata: map[string]any{ cliproxyexecutor.ExecutionSessionMetadataKey: "count-never-agent-conversation", }, }) if errCount != nil { t.Fatalf("countTokensUpstream() error = %v", errCount) } if got := gjson.GetBytes(upstreamBody, "tools.0.name").String(); got != "search_web" { t.Fatalf("count_tokens tool name = %q, want cloak=never passthrough", got) } assertClaudeCountTokensIdentity(t, upstreamBody, upstreamHeaders)}
func TestClaudeExecutor_CountTokensUpstreamConfirmedVSCodePreservesCustomTool(t *testing.T) { var upstreamName string server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) upstreamName = gjson.GetBytes(body, "tools.0.name").String() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"input_tokens":7}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ ID: "oauth-mcp-native-count-tokens", Attributes: map[string]string{ "api_key": "sk-ant-oat-mcp-native-count-tokens", "base_url": server.URL, }, Metadata: map[string]any{ "cloak_mode": "always", }, } payload := []byte(`{"model":"claude-opus-4-6","messages":[{"role":"user","content":"search"}],"tools":[{"name":"search_web","input_schema":{"type":"object"}}]}`) _, errCount := executor.countTokensUpstream(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-opus-4-6", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, Headers: http.Header{ "User-Agent": {"claude-cli/2.1.258 (external, claude-vscode, agent-sdk/0.3.220)"}, "X-App": {"cli"}, "Anthropic-Beta": {"claude-code-20250219"}, }, }) if errCount != nil { t.Fatalf("countTokensUpstream() error = %v", errCount) } if upstreamName != "search_web" { t.Fatalf("confirmed VSCode count_tokens tool name = %q, want unchanged", upstreamName) }}
func TestClaudeExecutor_CountTokensCloakMatchesMeasuredDirectAnthropicShape(t *testing.T) { var upstreamBody []byte transport := roundTripperFunc(func(req *http.Request) (*http.Response, error) { var errRead error upstreamBody, errRead = io.ReadAll(req.Body) if errRead != nil { t.Fatal(errRead) } return &http.Response{StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: io.NopCloser(strings.NewReader(`{"input_tokens":34}`)), Request: req}, nil }) ctx := context.WithValue(context.Background(), "cliproxy.roundtripper", http.RoundTripper(transport)) auth := &cliproxyauth.Auth{Attributes: map[string]string{"api_key": "sk-ant-oat-cloaked-count-shape"}} payload := []byte(`{"model":"claude-opus-5","messages":[{"role":"user","content":[{"type":"text","text":"x"}]}],"tools":[{"name":"search_web","input_schema":{"type":"object"}}],"metadata":{"user_id":"remove"},"context_management":{"edits":[]},"diagnostics":{"previous_message_id":"remove"}}`) _, errCount := NewClaudeExecutor(&config.Config{}).countTokensUpstream(ctx, auth, cliproxyexecutor.Request{Model: "claude-opus-5", Payload: payload}, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if errCount != nil { t.Fatalf("countTokensUpstream() error = %v", errCount) } if got := gjson.GetBytes(upstreamBody, "system"); got.Exists() { t.Fatalf("cloaked direct count system = %s, want absent", got.Raw) } for _, field := range []string{"metadata", "context_management", "diagnostics", "betas"} { if got := gjson.GetBytes(upstreamBody, field); got.Exists() { t.Fatalf("cloaked direct count %s = %s, want absent", field, got.Raw) } } if got := gjson.GetBytes(upstreamBody, "tools.0.name").String(); !helps.IsClaudeMCPToolName(got) { t.Fatalf("cloaked direct count tool = %q, want OAuth MCP alias", got) }}
// Count-token cloaking preserves the caller system slot and sensitive-word policy.func TestClaudeExecutor_CountTokensCloakPreservesCallerSystemAndObfuscates(t *testing.T) { const callerSystem = "third party ACMECORP orchestrator rules" const sensitiveWord = "ACMECORP"
testCases := []struct { name string model string }{ {name: "opus 5", model: "claude-opus-5"}, {name: "legacy sonnet", model: "claude-sonnet-4-5"}, }
for _, testCase := range testCases { t.Run(testCase.name, func(t *testing.T) { var upstreamBody []byte transport := roundTripperFunc(func(req *http.Request) (*http.Response, error) { var errRead error upstreamBody, errRead = io.ReadAll(req.Body) if errRead != nil { t.Fatal(errRead) } return &http.Response{ StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: io.NopCloser(strings.NewReader(`{"input_tokens":34}`)), Request: req, }, nil }) ctx := context.WithValue(context.Background(), "cliproxy.roundtripper", http.RoundTripper(transport)) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "sk-ant-oat-count-relocate", "cloak_sensitive_words": sensitiveWord, }} payload := []byte(`{"model":"` + testCase.model + `","system":[{"type":"text","text":"` + callerSystem + `"}],` + `"messages":[{"role":"user","content":[{"type":"text","text":"hello"}]}],"tools":[]}`)
_, errCount := NewClaudeExecutor(&config.Config{}).countTokensUpstream(ctx, auth, cliproxyexecutor.Request{Model: testCase.model, Payload: payload}, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if errCount != nil { t.Fatalf("countTokensUpstream() error = %v", errCount) }
joinedTexts := gjson.GetBytes(upstreamBody, "system.0.text").String() if !strings.Contains(joinedTexts, "orchestrator rules") { t.Fatalf("caller system prompt missing from top-level system: %s", upstreamBody) } if got := gjson.GetBytes(upstreamBody, "messages").Raw; got != gjson.GetBytes(payload, "messages").Raw { t.Fatalf("count_tokens modified conversation messages: %s", upstreamBody) } // Sensitive words must not reach Anthropic verbatim on this endpoint either. if strings.Contains(joinedTexts, sensitiveWord) { t.Fatalf("sensitive word %q leaked to count_tokens: %s", sensitiveWord, upstreamBody) } }) }}
// TestClaudeExecutor_CountTokensCloakStrictModeDropsCallerSystem mirrors the// Messages path: strict mode keeps only Claude Code identity, so a caller's// system prompt must not be reintroduced into the counted body.func TestClaudeExecutor_CountTokensCloakStrictModeDropsCallerSystem(t *testing.T) { var upstreamBody []byte transport := roundTripperFunc(func(req *http.Request) (*http.Response, error) { var errRead error upstreamBody, errRead = io.ReadAll(req.Body) if errRead != nil { t.Fatal(errRead) } return &http.Response{ StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: io.NopCloser(strings.NewReader(`{"input_tokens":34}`)), Request: req, }, nil }) ctx := context.WithValue(context.Background(), "cliproxy.roundtripper", http.RoundTripper(transport)) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "sk-ant-oat-count-strict", "cloak_strict_mode": "true", }} payload := []byte(`{"model":"claude-opus-5","system":[{"type":"text","text":"caller only secret directive"}],` + `"messages":[{"role":"user","content":[{"type":"text","text":"hello"}]}],"tools":[]}`)
_, errCount := NewClaudeExecutor(&config.Config{}).countTokensUpstream(ctx, auth, cliproxyexecutor.Request{Model: "claude-opus-5", Payload: payload}, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if errCount != nil { t.Fatalf("countTokensUpstream() error = %v", errCount) } if got := gjson.GetBytes(upstreamBody, "system"); got.Exists() { t.Fatalf("strict cloaked count system = %s, want absent", got.Raw) } if strings.Contains(string(upstreamBody), "secret directive") { t.Fatalf("strict mode must not forward the caller system prompt: %s", upstreamBody) }}
func TestClaudeExecutor_CountTokensConfirmedNativePreservesMeasuredOAuthBody(t *testing.T) { var upstreamBody []byte var upstreamHeaders http.Header transport := roundTripperFunc(func(req *http.Request) (*http.Response, error) { var errRead error upstreamBody, errRead = io.ReadAll(req.Body) if errRead != nil { t.Fatal(errRead) } upstreamHeaders = req.Header.Clone() return &http.Response{ StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: io.NopCloser(strings.NewReader(`{"input_tokens":34}`)), Request: req, }, nil }) ctx := context.WithValue(context.Background(), "cliproxy.roundtripper", http.RoundTripper(transport)) executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{"api_key": "sk-ant-oat-native-count-shape"}} payload := []byte(`{"model":"claude-opus-5","messages":[{"role":"user","content":[{"type":"text","text":"x"}]}],"tools":[]}`) incomingBetas := "claude-code-20250219,interleaved-thinking-2025-05-14,context-management-2025-06-27,token-counting-2024-11-01" wantBetas := "claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,context-management-2025-06-27,token-counting-2024-11-01" _, errCount := executor.countTokensUpstream(ctx, auth, cliproxyexecutor.Request{Model: "claude-opus-5", Payload: payload}, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, Headers: http.Header{ "User-Agent": {"claude-cli/2.1.258 (external, cli)"}, "X-App": {"cli"}, "Anthropic-Beta": {incomingBetas}, }, }) if errCount != nil { t.Fatalf("countTokensUpstream() error = %v", errCount) } if !bytes.Equal(upstreamBody, payload) { t.Fatalf("confirmed native count body changed\n got: %s\nwant: %s", upstreamBody, payload) } for _, field := range []string{"system", "metadata", "context_management", "betas"} { if got := gjson.GetBytes(upstreamBody, field); got.Exists() { t.Fatalf("confirmed native count body %s = %s, want absent", field, got.Raw) } } if got := strings.Join(upstreamHeaders["anthropic-beta"], ","); got != wantBetas { t.Fatalf("confirmed native count beta = %q, want %q", got, wantBetas) } if got := upstreamHeaders.Get("X-Stainless-Timeout"); got != "" { t.Fatalf("confirmed native count timeout = %q, want absent", got) }}
func TestClaudeExecutor_CountTokensCountsLocallyWithoutUpstreamRequest(t *testing.T) { payload := []byte(`{ "system":"client system instructions", "messages":[{"role":"user","content":[{"type":"text","text":"hello"}]}] }`) const expectedCount int64 = 7
testCases := []struct { name string apiKey string }{ {name: "custom API key", apiKey: "key-123"}, {name: "custom OAuth", apiKey: "sk-ant-oat-custom"}, }
for _, testCase := range testCases { t.Run(testCase.name, func(t *testing.T) { server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { t.Errorf("unexpected upstream count_tokens request: %s", r.URL.Path) w.WriteHeader(http.StatusInternalServerError) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": testCase.apiKey, "base_url": server.URL, }} resp, errCount := executor.CountTokens(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-4-5", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) if errCount != nil { t.Fatalf("CountTokens() error = %v", errCount) } if got := gjson.GetBytes(resp.Payload, "input_tokens").Int(); got != expectedCount { t.Fatalf("input_tokens = %d, want %d; payload = %s", got, expectedCount, resp.Payload) } }) }
executor := NewClaudeExecutor(&config.Config{}) resp, err := executor.CountTokens(context.Background(), nil, cliproxyexecutor.Request{ Model: "claude-sonnet-4-5", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, ResponseFormat: sdktranslator.FormatGemini, }) if err != nil { t.Fatalf("CountTokens() Gemini response error = %v", err) } if got := gjson.GetBytes(resp.Payload, "totalTokens").Int(); got != expectedCount { t.Fatalf("Gemini totalTokens = %d, want %d; payload = %s", got, expectedCount, resp.Payload) } if got := gjson.GetBytes(resp.Payload, "promptTokensDetails.0.tokenCount").Int(); got != expectedCount { t.Fatalf("Gemini prompt token detail = %d, want %d; payload = %s", got, expectedCount, resp.Payload) }}
func TestClaudeExecutor_CountTokensRejectsInvalidRequests(t *testing.T) { testCases := []struct { name string payload string }{ {name: "invalid JSON", payload: `not-json`}, {name: "non-object", payload: `[]`}, {name: "missing messages", payload: `{}`}, {name: "empty messages", payload: `{"messages":[]}`}, {name: "non-array messages", payload: `{"messages":"invalid"}`}, {name: "invalid role", payload: `{"messages":[{"role":"system","content":"hello"}]}`}, {name: "invalid content", payload: `{"messages":[{"role":"user","content":42}]}`}, {name: "non-object content block", payload: `{"messages":[{"role":"user","content":[42]}]}`}, {name: "untyped content block", payload: `{"messages":[{"role":"user","content":[{"text":"hello"}]}]}`}, }
executor := NewClaudeExecutor(&config.Config{}) for _, testCase := range testCases { t.Run(testCase.name, func(t *testing.T) { _, err := executor.CountTokens(context.Background(), nil, cliproxyexecutor.Request{ Model: "claude-sonnet-4-5", Payload: []byte(testCase.payload), }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) assertStatusErr(t, err, http.StatusBadRequest) requestErr, ok := err.(cliproxyexecutor.RequestScopedError) if !ok || !requestErr.IsRequestScoped() { t.Fatalf("error %T is not request-scoped", err) } }) }}
func TestClaudeExecutor_CountTokensRebuildsMidSystemMessagesBeforeValidation(t *testing.T) { executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "rebuild_mid_system_message": "true", }} payload := []byte(`{ "system":"Top rule", "messages":[ {"role":"user","content":"hello"}, {"role":"system","content":"Mid rule"}, {"role":"assistant","content":"answer"} ] }`)
resp, err := executor.CountTokens(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-4-5", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("CountTokens() error = %v", err) } if got := gjson.GetBytes(resp.Payload, "input_tokens").Int(); got <= 0 { t.Fatalf("input_tokens = %d, want positive count; payload = %s", got, resp.Payload) }}
func TestClaudeExecutor_ReusesUserIDAcrossModelsWhenCacheEnabled(t *testing.T) { var userIDs []string var requestModels []string server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) userID := gjson.GetBytes(body, "metadata.user_id").String() model := gjson.GetBytes(body, "model").String() userIDs = append(userIDs, userID) requestModels = append(requestModels, model) t.Logf("HTTP Server received request: model=%s, user_id=%s, url=%s", model, userID, r.URL.String()) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-3-5-sonnet","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
t.Logf("End-to-end test: Fake HTTP server started at %s", server.URL)
cacheEnabled := true executor := NewClaudeExecutor(&config.Config{ ClaudeKey: []config.ClaudeKey{ { APIKey: "key-123", BaseURL: server.URL, Cloak: &config.CloakConfig{ CacheUserID: &cacheEnabled, }, }, }, }) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }}
payload := []byte(`{"messages":[{"role":"user","content":[{"type":"text","text":"hi"}]}]}`) models := []string{"claude-3-5-sonnet", "claude-3-5-haiku"} for _, model := range models { t.Logf("Sending request for model: %s", model) modelPayload, _ := sjson.SetBytes(payload, "model", model) if _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: model, Payload: modelPayload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("claude"), }); err != nil { t.Fatalf("Execute(%s) error: %v", model, err) } }
if len(userIDs) != 2 { t.Fatalf("expected 2 requests, got %d", len(userIDs)) } if userIDs[0] == "" || userIDs[1] == "" { t.Fatal("expected user_id to be populated") } t.Logf("user_id[0] (model=%s): %s", requestModels[0], userIDs[0]) t.Logf("user_id[1] (model=%s): %s", requestModels[1], userIDs[1]) if userIDs[0] != userIDs[1] { t.Fatalf("expected user_id to be reused across models, got %q and %q", userIDs[0], userIDs[1]) } if !helps.IsValidUserID(userIDs[0]) { t.Fatalf("user_id %q is not valid", userIDs[0]) } t.Logf("✓ End-to-end test passed: Same user_id (%s) was used for both models", userIDs[0])}
func TestClaudeExecutor_DefaultDoesNotInjectUserID(t *testing.T) { var userIDs []string server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) userIDs = append(userIDs, gjson.GetBytes(body, "metadata.user_id").String()) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-3-5-sonnet","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }}
payload := []byte(`{"messages":[{"role":"user","content":[{"type":"text","text":"hi"}]}]}`)
for i := 0; i < 2; i++ { if _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("claude"), }); err != nil { t.Fatalf("Execute call %d error: %v", i, err) } }
if len(userIDs) != 2 { t.Fatalf("expected 2 requests, got %d", len(userIDs)) } if userIDs[0] != "" || userIDs[1] != "" { t.Fatalf("default API-key requests must preserve caller metadata without injecting user_id, got %q and %q", userIDs[0], userIDs[1]) }}
func TestClaudeExecutor_ExecuteOpenAINonStreamRejectsEmptyClaudeStream(t *testing.T) { _, err := executeOpenAIChatCompletionThroughClaude(t, "") if err == nil { t.Fatal("Execute error = nil, want empty stream error") } assertStatusErr(t, err, http.StatusBadGateway) if !strings.Contains(err.Error(), "empty stream response") { t.Fatalf("Execute error = %q, want empty stream response", err.Error()) }}
func TestClaudeExecutor_ExecuteOpenAINonStreamRejectsClaudeErrorEvent(t *testing.T) { body := `data: {"type":"error","error":{"type":"overloaded_error","message":"upstream overloaded"}}` + "\n" _, err := executeOpenAIChatCompletionThroughClaude(t, body) if err == nil { t.Fatal("Execute error = nil, want upstream error event") } assertStatusErr(t, err, http.StatusBadGateway) if !strings.Contains(err.Error(), "upstream overloaded") { t.Fatalf("Execute error = %q, want upstream overloaded", err.Error()) }}
func TestClaudeExecutor_ExecuteOpenAINonStreamRejectsIncompleteClaudeStream(t *testing.T) { body := strings.Join([]string{ `data: {"type":"message_start","message":{"id":"msg_123","model":"claude-3-5-sonnet-20241022"}}`, `data: {"type":"message_stop"}`, ``, }, "\n")
_, err := executeOpenAIChatCompletionThroughClaude(t, body) if err == nil { t.Fatal("Execute error = nil, want incomplete stream error") } assertStatusErr(t, err, http.StatusBadGateway) if !strings.Contains(err.Error(), "ended before message completion") { t.Fatalf("Execute error = %q, want incomplete stream error", err.Error()) }}
func TestClaudeExecutor_ExecuteOpenAINonStreamConvertsValidClaudeStream(t *testing.T) { body := strings.Join([]string{ `event: message_start`, `data: {"type":"message_start","message":{"id":"msg_123","model":"claude-3-5-sonnet-20241022"}}`, `event: content_block_delta`, `data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ok"}}`, `event: message_delta`, `data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input_tokens":2,"output_tokens":1}}`, `event: message_stop`, `data: {"type":"message_stop"}`, ``, }, "\n")
resp, err := executeOpenAIChatCompletionThroughClaude(t, body) if err != nil { t.Fatalf("Execute error: %v", err) } if got := gjson.GetBytes(resp.Payload, "id").String(); got != "msg_123" { t.Fatalf("response id = %q, want msg_123; payload=%s", got, string(resp.Payload)) } if got := gjson.GetBytes(resp.Payload, "model").String(); got != "claude-3-5-sonnet-20241022" { t.Fatalf("response model = %q, want claude-3-5-sonnet-20241022", got) } if got := gjson.GetBytes(resp.Payload, "choices.0.message.content").String(); got != "ok" { t.Fatalf("response content = %q, want ok", got) } if got := gjson.GetBytes(resp.Payload, "usage.total_tokens").Int(); got != 3 { t.Fatalf("usage.total_tokens = %d, want 3", got) }}
func TestClaudeExecutor_ExecuteTransportMatchesResponseFormat(t *testing.T) { const model = "claude-3-5-sonnet-20241022" streamResponse := strings.Join([]string{ `event: message_start`, `data: {"type":"message_start","message":{"id":"msg_123","model":"claude-3-5-sonnet-20241022"}}`, `event: content_block_delta`, `data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"ok"}}`, `event: message_delta`, `data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"input_tokens":2,"output_tokens":1}}`, `event: message_stop`, `data: {"type":"message_stop"}`, ``, }, "\n") jsonResponse := `{"id":"msg_123","type":"message","role":"assistant","model":"claude-3-5-sonnet-20241022","content":[{"type":"text","text":"ok"}],"stop_reason":"end_turn","stop_sequence":null,"usage":{"input_tokens":2,"output_tokens":1}}`
tests := []struct { name string sourceFormat sdktranslator.Format responseFormat sdktranslator.Format wantStream bool }{ {name: "OpenAI to OpenAI uses SSE", sourceFormat: sdktranslator.FormatOpenAI, responseFormat: sdktranslator.FormatOpenAI, wantStream: true}, {name: "OpenAI to Claude uses JSON", sourceFormat: sdktranslator.FormatOpenAI, responseFormat: sdktranslator.FormatClaude, wantStream: false}, {name: "Claude to OpenAI uses SSE", sourceFormat: sdktranslator.FormatClaude, responseFormat: sdktranslator.FormatOpenAI, wantStream: true}, {name: "Claude to Claude uses JSON", sourceFormat: sdktranslator.FormatClaude, responseFormat: sdktranslator.FormatClaude, wantStream: false}, }
for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() if tt.wantStream { w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte(streamResponse)) return } w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(jsonResponse)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{ Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: model, Protocol: "claude"}}, Params: map[string]any{"stream": !tt.wantStream}, }}, }, }) attributes := map[string]string{ "api_key": "key-123", "base_url": server.URL, } if tt.wantStream { attributes["header:Accept"] = "application/json" attributes["header:Accept-Encoding"] = "gzip, deflate, br, zstd" } auth := &cliproxyauth.Auth{Attributes: attributes} payload := []byte(`{"model":"claude-3-5-sonnet-20241022","stream":false,"messages":[{"role":"user","content":"hi"}]}`)
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: model, Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: tt.sourceFormat, ResponseFormat: tt.responseFormat, Headers: http.Header{ "Anthropic-Beta": []string{"client-beta"}, }, }) if err != nil { t.Fatalf("Execute error: %v", err) } stream := gjson.GetBytes(seenBody, "stream") if !stream.Exists() || stream.Bool() != tt.wantStream { t.Fatalf("upstream stream = %s, want %t; body=%s", stream.Raw, tt.wantStream, string(seenBody)) } wantAccept := "application/json" wantEncoding := "gzip, deflate, br, zstd" if tt.wantStream { wantAccept = "text/event-stream" wantEncoding = "identity" } if got := seenHeaders.Get("Accept"); got != wantAccept { t.Fatalf("Accept = %q, want %q", got, wantAccept) } if got := seenHeaders.Get("Accept-Encoding"); got != wantEncoding { t.Fatalf("Accept-Encoding = %q, want %q", got, wantEncoding) } if got := seenHeaders.Get("Anthropic-Beta"); !strings.Contains(got, "client-beta") { t.Fatalf("Anthropic-Beta = %q, want client beta preserved", got) } }) }}
func executeOpenAIChatCompletionThroughClaude(t *testing.T, upstreamBody string) (cliproxyexecutor.Response, error) { t.Helper()
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte(upstreamBody)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{"model":"claude-3-5-sonnet-20241022","messages":[{"role":"user","content":"hi"}]}`)
return executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("openai"), })}
func assertStatusErr(t *testing.T, err error, want int) { t.Helper()
status, ok := err.(interface{ StatusCode() int }) if !ok { t.Fatalf("error %T does not expose StatusCode", err) } if got := status.StatusCode(); got != want { t.Fatalf("StatusCode() = %d, want %d", got, want) }}
func TestStripClaudeToolPrefixFromResponse_NestedToolReference(t *testing.T) { input := []byte(`{"content":[{"type":"tool_result","tool_use_id":"toolu_123","content":[{"type":"tool_reference","tool_name":"proxy_mcp__nia__manage_resource"}]}]}`) out := stripClaudeToolPrefixFromResponse(input, "proxy_") got := gjson.GetBytes(out, "content.0.content.0.tool_name").String() if got != "mcp__nia__manage_resource" { t.Fatalf("nested tool_reference tool_name = %q, want %q", got, "mcp__nia__manage_resource") }}
func TestApplyClaudeToolPrefix_NestedToolReferenceWithStringContent(t *testing.T) { // tool_result.content can be a string - should not be processed input := []byte(`{"messages":[{"role":"user","content":[{"type":"tool_result","tool_use_id":"toolu_123","content":"plain string result"}]}]}`) out := applyClaudeToolPrefix(input, "proxy_") got := gjson.GetBytes(out, "messages.0.content.0.content").String() if got != "plain string result" { t.Fatalf("string content should remain unchanged = %q", got) }}
func TestApplyClaudeToolPrefix_SkipsBuiltinToolReference(t *testing.T) { input := []byte(`{"tools":[{"type":"web_search_20250305","name":"web_search"}],"messages":[{"role":"user","content":[{"type":"tool_result","tool_use_id":"t1","content":[{"type":"tool_reference","tool_name":"web_search"}]}]}]}`) out := applyClaudeToolPrefix(input, "proxy_") got := gjson.GetBytes(out, "messages.0.content.0.content.0.tool_name").String() if got != "web_search" { t.Fatalf("built-in tool_reference should not be prefixed, got %q", got) }}
func TestNormalizeCacheControlTTL_DowngradesLaterOneHourBlocks(t *testing.T) { payload := []byte(`{ "tools": [{"name":"t1","cache_control":{"type":"ephemeral","ttl":"1h"}}], "system": [{"type":"text","text":"s1","cache_control":{"type":"ephemeral"}}], "messages": [{"role":"user","content":[{"type":"text","text":"u1","cache_control":{"type":"ephemeral","ttl":"1h"}}]}] }`)
out := normalizeCacheControlTTL(payload)
if got := gjson.GetBytes(out, "tools.0.cache_control.ttl").String(); got != "1h" { t.Fatalf("tools.0.cache_control.ttl = %q, want %q", got, "1h") } if gjson.GetBytes(out, "messages.0.content.0.cache_control.ttl").Exists() { t.Fatalf("messages.0.content.0.cache_control.ttl should be removed after a default-5m block") }}
func TestNormalizeCacheControlTTL_PreservesOriginalBytesWhenNoChange(t *testing.T) { // Payload where no TTL normalization is needed (all blocks use 1h with no // preceding 5m block). The text intentionally contains HTML chars (<, >, &) // that json.Marshal would escape to \u003c etc., altering byte identity. payload := []byte(`{"tools":[{"name":"t1","cache_control":{"type":"ephemeral","ttl":"1h"}}],"system":[{"type":"text","text":"<system-reminder>foo & bar</system-reminder>","cache_control":{"type":"ephemeral","ttl":"1h"}}],"messages":[{"role":"user","content":[{"type":"text","text":"hello"}]}]}`)
out := normalizeCacheControlTTL(payload)
if !bytes.Equal(out, payload) { t.Fatalf("normalizeCacheControlTTL altered bytes when no change was needed.\noriginal: %s\ngot: %s", payload, out) }}
func TestNormalizeCacheControlTTL_PreservesKeyOrderWhenModified(t *testing.T) { payload := []byte(`{"model":"m","messages":[{"role":"user","content":[{"type":"text","text":"u1","cache_control":{"type":"ephemeral","ttl":"1h"}}]}],"tools":[{"name":"t1","cache_control":{"type":"ephemeral"}}],"system":[{"type":"text","text":"s1","cache_control":{"type":"ephemeral"}}]}`)
out := normalizeCacheControlTTL(payload)
if gjson.GetBytes(out, "messages.0.content.0.cache_control.ttl").Exists() { t.Fatalf("messages.0.content.0.cache_control.ttl should be removed after a default-5m block") }
outStr := string(out) idxModel := strings.Index(outStr, `"model"`) idxMessages := strings.Index(outStr, `"messages"`) idxTools := strings.Index(outStr, `"tools"`) idxSystem := strings.Index(outStr, `"system"`) if idxModel == -1 || idxMessages == -1 || idxTools == -1 || idxSystem == -1 { t.Fatalf("failed to locate top-level keys in output: %s", outStr) } if !(idxModel < idxMessages && idxMessages < idxTools && idxTools < idxSystem) { t.Fatalf("top-level key order changed:\noriginal: %s\ngot: %s", payload, out) }}
func TestEnforceCacheControlLimit_StripsNonLastToolBeforeMessages(t *testing.T) { payload := []byte(`{ "tools": [ {"name":"t1","cache_control":{"type":"ephemeral"}}, {"name":"t2","cache_control":{"type":"ephemeral"}} ], "system": [{"type":"text","text":"s1","cache_control":{"type":"ephemeral"}}], "messages": [ {"role":"user","content":[{"type":"text","text":"u1","cache_control":{"type":"ephemeral"}}]}, {"role":"user","content":[{"type":"text","text":"u2","cache_control":{"type":"ephemeral"}}]} ] }`)
out := enforceCacheControlLimit(payload, 4)
if got := countCacheControls(out); got != 4 { t.Fatalf("cache_control count = %d, want 4", got) } if gjson.GetBytes(out, "tools.0.cache_control").Exists() { t.Fatalf("tools.0.cache_control should be removed first (non-last tool)") } if !gjson.GetBytes(out, "tools.1.cache_control").Exists() { t.Fatalf("tools.1.cache_control (last tool) should be preserved") } if !gjson.GetBytes(out, "messages.0.content.0.cache_control").Exists() || !gjson.GetBytes(out, "messages.1.content.0.cache_control").Exists() { t.Fatalf("message cache_control blocks should be preserved when non-last tool removal is enough") }}
func TestEnforceCacheControlLimit_PreservesKeyOrderWhenModified(t *testing.T) { payload := []byte(`{"model":"m","messages":[{"role":"user","content":[{"type":"text","text":"u1","cache_control":{"type":"ephemeral"}},{"type":"text","text":"u2","cache_control":{"type":"ephemeral"}}]}],"tools":[{"name":"t1","cache_control":{"type":"ephemeral"}},{"name":"t2","cache_control":{"type":"ephemeral"}}],"system":[{"type":"text","text":"s1","cache_control":{"type":"ephemeral"}}]}`)
out := enforceCacheControlLimit(payload, 4)
if got := countCacheControls(out); got != 4 { t.Fatalf("cache_control count = %d, want 4", got) } if gjson.GetBytes(out, "tools.0.cache_control").Exists() { t.Fatalf("tools.0.cache_control should be removed first (non-last tool)") }
outStr := string(out) idxModel := strings.Index(outStr, `"model"`) idxMessages := strings.Index(outStr, `"messages"`) idxTools := strings.Index(outStr, `"tools"`) idxSystem := strings.Index(outStr, `"system"`) if idxModel == -1 || idxMessages == -1 || idxTools == -1 || idxSystem == -1 { t.Fatalf("failed to locate top-level keys in output: %s", outStr) } if !(idxModel < idxMessages && idxMessages < idxTools && idxTools < idxSystem) { t.Fatalf("top-level key order changed:\noriginal: %s\ngot: %s", payload, out) }}
func TestEnforceCacheControlLimit_ToolOnlyPayloadStillRespectsLimit(t *testing.T) { payload := []byte(`{ "tools": [ {"name":"t1","cache_control":{"type":"ephemeral"}}, {"name":"t2","cache_control":{"type":"ephemeral"}}, {"name":"t3","cache_control":{"type":"ephemeral"}}, {"name":"t4","cache_control":{"type":"ephemeral"}}, {"name":"t5","cache_control":{"type":"ephemeral"}} ] }`)
out := enforceCacheControlLimit(payload, 4)
if got := countCacheControls(out); got != 4 { t.Fatalf("cache_control count = %d, want 4", got) } if gjson.GetBytes(out, "tools.0.cache_control").Exists() { t.Fatalf("tools.0.cache_control should be removed to satisfy max=4") } if !gjson.GetBytes(out, "tools.4.cache_control").Exists() { t.Fatalf("last tool cache_control should be preserved when possible") }}
func TestClaudeExecutor_ExecuteSanitizesSignaturesBeforeUpstream(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) seenBody = bytes.Clone(body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-sonnet-4-5","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }}
payload := []byte(`{ "model": "claude-sonnet-4-5", "max_tokens": 16, "messages": [ {"role":"assistant","content":[ {"type":"thinking","thinking":"drop this","signature":""}, {"type":"text","text":"I will run git status."}, {"type":"tool_use","id":"Bash-1","name":"Bash","input":{"command":"git status"},"signature":"bad","thoughtSignature":"bad2","model":"claude-opus-4-1"} ]}, {"role":"user","content":[{"type":"tool_result","tool_use_id":"Bash-1","content":"ok"}]} ] }`)
if _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-4-5", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("claude"), Stream: false, }); err != nil { t.Fatalf("Execute error: %v", err) }
parts := gjson.GetBytes(seenBody, "messages.0.content").Array() if len(parts) != 2 { t.Fatalf("messages.0.content length = %d, want 2; body=%s", len(parts), seenBody) } if parts[0].Get("type").String() != "text" { t.Fatalf("first remaining part = %s, want text", parts[0].Raw) } toolUse := parts[1] if toolUse.Get("type").String() != "tool_use" { t.Fatalf("second remaining part = %s, want tool_use", toolUse.Raw) } for _, path := range []string{"signature", "thoughtSignature", "model"} { if toolUse.Get(path).Exists() { t.Fatalf("tool_use.%s should be removed before upstream: %s", path, seenBody) } }}
func TestClaudeExecutor_Execute_InvalidGzipErrorBodyReturnsDecodeMessage(t *testing.T) { testClaudeExecutorInvalidCompressedErrorBody(t, func(executor *ClaudeExecutor, auth *cliproxyauth.Auth, payload []byte) error { _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) return err })}
func TestClaudeExecutor_ExecuteStream_InvalidGzipErrorBodyReturnsDecodeMessage(t *testing.T) { testClaudeExecutorInvalidCompressedErrorBody(t, func(executor *ClaudeExecutor, auth *cliproxyauth.Auth, payload []byte) error { _, err := executor.ExecuteStream(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) return err })}
func testClaudeExecutorInvalidCompressedErrorBody( t *testing.T, invoke func(executor *ClaudeExecutor, auth *cliproxyauth.Auth, payload []byte) error,) { t.Helper()
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") w.Header().Set("Content-Encoding", "gzip") w.WriteHeader(http.StatusBadRequest) _, _ = w.Write([]byte("not-a-valid-gzip-stream")) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{"messages":[{"role":"user","content":[{"type":"text","text":"hi"}]}]}`)
err := invoke(executor, auth, payload) if err == nil { t.Fatal("expected error, got nil") } if !strings.Contains(err.Error(), "failed to decode error response body") { t.Fatalf("expected decode failure message, got: %v", err) } if statusProvider, ok := err.(interface{ StatusCode() int }); !ok || statusProvider.StatusCode() != http.StatusBadRequest { t.Fatalf("expected status code 400, got: %v", err) }}
func TestEnsureModelMaxTokens_UsesRegisteredMaxCompletionTokens(t *testing.T) { reg := registry.GetGlobalRegistry() clientID := "test-claude-max-completion-tokens-client" modelID := "test-claude-max-completion-tokens-model" reg.RegisterClient(clientID, "claude", []*registry.ModelInfo{{ ID: modelID, Type: "claude", OwnedBy: "anthropic", Object: "model", Created: time.Now().Unix(), MaxCompletionTokens: 4096, UserDefined: true, }}) defer reg.UnregisterClient(clientID)
input := []byte(`{"model":"test-claude-max-completion-tokens-model","messages":[{"role":"user","content":"hi"}]}`) out := ensureModelMaxTokens(input, modelID)
if got := gjson.GetBytes(out, "max_tokens").Int(); got != 4096 { t.Fatalf("max_tokens = %d, want %d", got, 4096) }}
func TestEnsureModelMaxTokens_DefaultsMissingValue(t *testing.T) { reg := registry.GetGlobalRegistry() clientID := "test-claude-default-max-tokens-client" modelID := "test-claude-default-max-tokens-model" reg.RegisterClient(clientID, "claude", []*registry.ModelInfo{{ ID: modelID, Type: "claude", OwnedBy: "anthropic", Object: "model", Created: time.Now().Unix(), UserDefined: true, }}) defer reg.UnregisterClient(clientID)
input := []byte(`{"model":"test-claude-default-max-tokens-model","messages":[{"role":"user","content":"hi"}]}`) out := ensureModelMaxTokens(input, modelID)
if got := gjson.GetBytes(out, "max_tokens").Int(); got != defaultModelMaxTokens { t.Fatalf("max_tokens = %d, want %d", got, defaultModelMaxTokens) }}
func TestEnsureModelMaxTokens_PreservesExplicitValue(t *testing.T) { reg := registry.GetGlobalRegistry() clientID := "test-claude-preserve-max-tokens-client" modelID := "test-claude-preserve-max-tokens-model" reg.RegisterClient(clientID, "claude", []*registry.ModelInfo{{ ID: modelID, Type: "claude", OwnedBy: "anthropic", Object: "model", Created: time.Now().Unix(), MaxCompletionTokens: 4096, UserDefined: true, }}) defer reg.UnregisterClient(clientID)
input := []byte(`{"model":"test-claude-preserve-max-tokens-model","max_tokens":2048,"messages":[{"role":"user","content":"hi"}]}`) out := ensureModelMaxTokens(input, modelID)
if got := gjson.GetBytes(out, "max_tokens").Int(); got != 2048 { t.Fatalf("max_tokens = %d, want %d", got, 2048) }}
func TestEnsureModelMaxTokens_SkipsUnregisteredModel(t *testing.T) { input := []byte(`{"model":"test-claude-unregistered-model","messages":[{"role":"user","content":"hi"}]}`) out := ensureModelMaxTokens(input, "test-claude-unregistered-model")
if gjson.GetBytes(out, "max_tokens").Exists() { t.Fatalf("max_tokens should remain unset, got %s", gjson.GetBytes(out, "max_tokens").Raw) }}
// TestClaudeExecutor_ExecuteStream_SetsIdentityAcceptEncoding verifies that streaming// requests use Accept-Encoding: identity so the upstream cannot respond with a// compressed SSE body that would silently break the line scanner.func TestClaudeExecutor_ExecuteStream_SetsIdentityAcceptEncoding(t *testing.T) { var gotEncoding, gotAccept string server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { gotEncoding = r.Header.Get("Accept-Encoding") gotAccept = r.Header.Get("Accept") w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte("data: {\"type\":\"message_stop\"}\n\n")) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{"messages":[{"role":"user","content":[{"type":"text","text":"hi"}]}]}`)
result, err := executor.ExecuteStream(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("claude"), }) if err != nil { t.Fatalf("ExecuteStream error: %v", err) } for chunk := range result.Chunks { if chunk.Err != nil { t.Fatalf("unexpected chunk error: %v", chunk.Err) } }
if gotEncoding != "identity" { t.Errorf("Accept-Encoding = %q, want %q", gotEncoding, "identity") } if gotAccept != "text/event-stream" { t.Errorf("Accept = %q, want %q", gotAccept, "text/event-stream") }}
// TestClaudeExecutor_Execute_SetsCompressedAcceptEncoding verifies that non-streaming// requests keep the full accept-encoding to allow response compression (which// decodeResponseBody handles correctly).func TestClaudeExecutor_Execute_SetsCompressedAcceptEncoding(t *testing.T) { var gotEncoding, gotAccept string server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { gotEncoding = r.Header.Get("Accept-Encoding") gotAccept = r.Header.Get("Accept") w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-3-5-sonnet-20241022","role":"assistant","content":[{"type":"text","text":"hi"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{"messages":[{"role":"user","content":[{"type":"text","text":"hi"}]}]}`)
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("claude"), }) if err != nil { t.Fatalf("Execute error: %v", err) }
if gotEncoding != "gzip, deflate, br, zstd" { t.Errorf("Accept-Encoding = %q, want %q", gotEncoding, "gzip, deflate, br, zstd") } if gotAccept != "application/json" { t.Errorf("Accept = %q, want %q", gotAccept, "application/json") }}
// TestClaudeExecutor_ExecuteStream_GzipSuccessBodyDecoded verifies that a streaming// HTTP 200 response with Content-Encoding: gzip is correctly decompressed before// the line scanner runs, so SSE chunks are not silently dropped.func TestClaudeExecutor_ExecuteStream_GzipSuccessBodyDecoded(t *testing.T) { var buf bytes.Buffer gz := gzip.NewWriter(&buf) _, _ = gz.Write([]byte("data: {\"type\":\"message_stop\"}\n")) _ = gz.Close() compressedBody := buf.Bytes()
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") w.Header().Set("Content-Encoding", "gzip") _, _ = w.Write(compressedBody) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{"messages":[{"role":"user","content":[{"type":"text","text":"hi"}]}]}`)
result, err := executor.ExecuteStream(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("claude"), }) if err != nil { t.Fatalf("ExecuteStream error: %v", err) }
var combined strings.Builder for chunk := range result.Chunks { if chunk.Err != nil { t.Fatalf("chunk error: %v", chunk.Err) } combined.Write(chunk.Payload) }
if combined.Len() == 0 { t.Fatal("expected at least one chunk from gzip-encoded SSE body, got none (body was not decompressed)") } if !strings.Contains(combined.String(), "message_stop") { t.Errorf("expected SSE content in chunks, got: %q", combined.String()) }}
func TestDecodeResponseBodyStackedRepeatedHeaders(t *testing.T) { payload := []byte("stacked Claude response") var gzipOutput bytes.Buffer gzipWriter := gzip.NewWriter(&gzipOutput) if _, errWrite := gzipWriter.Write(payload); errWrite != nil { t.Fatal(errWrite) } if errClose := gzipWriter.Close(); errClose != nil { t.Fatal(errClose) } var brotliOutput bytes.Buffer brotliWriter := brotli.NewWriter(&brotliOutput) if _, errWrite := brotliWriter.Write(gzipOutput.Bytes()); errWrite != nil { t.Fatal(errWrite) } if errClose := brotliWriter.Close(); errClose != nil { t.Fatal(errClose) }
header := make(http.Header) header.Add("Content-Encoding", "gzip") header.Add("Content-Encoding", "br") decoded, errDecode := decodeResponseBody(io.NopCloser(bytes.NewReader(brotliOutput.Bytes())), claudeResponseContentEncoding(header)) if errDecode != nil { t.Fatal(errDecode) } defer decoded.Close() got, errRead := io.ReadAll(decoded) if errRead != nil { t.Fatal(errRead) } if !bytes.Equal(got, payload) { t.Fatalf("decoded body = %q, want %q", got, payload) }}
// TestDecodeResponseBody_MagicByteGzipNoHeader verifies that decodeResponseBody// detects gzip-compressed content via magic bytes even when Content-Encoding is absent.func TestDecodeResponseBody_MagicByteGzipNoHeader(t *testing.T) { const plaintext = "data: {\"type\":\"message_stop\"}\n"
var buf bytes.Buffer gz := gzip.NewWriter(&buf) _, _ = gz.Write([]byte(plaintext)) _ = gz.Close()
rc := io.NopCloser(&buf) decoded, err := decodeResponseBody(rc, "") if err != nil { t.Fatalf("decodeResponseBody error: %v", err) } defer decoded.Close()
got, err := io.ReadAll(decoded) if err != nil { t.Fatalf("ReadAll error: %v", err) } if string(got) != plaintext { t.Errorf("decoded = %q, want %q", got, plaintext) }}
// TestDecodeResponseBody_MagicByteZstdNoHeader verifies that decodeResponseBody// detects zstd-compressed content via magic bytes even when Content-Encoding is absent.func TestDecodeResponseBody_MagicByteZstdNoHeader(t *testing.T) { const plaintext = "data: {\"type\":\"message_stop\"}\n"
var buf bytes.Buffer enc, err := zstd.NewWriter(&buf) if err != nil { t.Fatalf("zstd.NewWriter: %v", err) } _, _ = enc.Write([]byte(plaintext)) _ = enc.Close()
rc := io.NopCloser(&buf) decoded, err := decodeResponseBody(rc, "") if err != nil { t.Fatalf("decodeResponseBody error: %v", err) } defer decoded.Close()
got, err := io.ReadAll(decoded) if err != nil { t.Fatalf("ReadAll error: %v", err) } if string(got) != plaintext { t.Errorf("decoded = %q, want %q", got, plaintext) }}
// TestDecodeResponseBody_PlainTextNoHeader verifies that decodeResponseBody returns// plain text untouched when Content-Encoding is absent and no magic bytes match.func TestDecodeResponseBody_PlainTextNoHeader(t *testing.T) { const plaintext = "data: {\"type\":\"message_stop\"}\n" rc := io.NopCloser(strings.NewReader(plaintext)) decoded, err := decodeResponseBody(rc, "") if err != nil { t.Fatalf("decodeResponseBody error: %v", err) } defer decoded.Close()
got, err := io.ReadAll(decoded) if err != nil { t.Fatalf("ReadAll error: %v", err) } if string(got) != plaintext { t.Errorf("decoded = %q, want %q", got, plaintext) }}
// TestClaudeExecutor_ExecuteStream_GzipNoContentEncodingHeader verifies the full// pipeline: when the upstream returns a gzip-compressed SSE body WITHOUT setting// Content-Encoding (a misbehaving upstream), the magic-byte sniff in// decodeResponseBody still decompresses it, so chunks reach the caller.func TestClaudeExecutor_ExecuteStream_GzipNoContentEncodingHeader(t *testing.T) { var buf bytes.Buffer gz := gzip.NewWriter(&buf) _, _ = gz.Write([]byte("data: {\"type\":\"message_stop\"}\n")) _ = gz.Close() compressedBody := buf.Bytes()
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") // Intentionally omit Content-Encoding to simulate misbehaving upstream. _, _ = w.Write(compressedBody) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{"messages":[{"role":"user","content":[{"type":"text","text":"hi"}]}]}`)
result, err := executor.ExecuteStream(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("claude"), }) if err != nil { t.Fatalf("ExecuteStream error: %v", err) }
var combined strings.Builder for chunk := range result.Chunks { if chunk.Err != nil { t.Fatalf("chunk error: %v", chunk.Err) } combined.Write(chunk.Payload) }
if combined.Len() == 0 { t.Fatal("expected chunks from gzip body without Content-Encoding header, got none (magic-byte sniff failed)") } if !strings.Contains(combined.String(), "message_stop") { t.Errorf("unexpected chunk content: %q", combined.String()) }}
// TestClaudeExecutor_Execute_GzipErrorBodyNoContentEncodingHeader verifies that the// error path (4xx) correctly decompresses a gzip body even when the upstream omits// the Content-Encoding header. This closes the gap left by PR #1771, which only// fixed header-declared compression on the error path.func TestClaudeExecutor_Execute_GzipErrorBodyNoContentEncodingHeader(t *testing.T) { const errJSON = `{"type":"error","error":{"type":"invalid_request_error","message":"test error"}}`
var buf bytes.Buffer gz := gzip.NewWriter(&buf) _, _ = gz.Write([]byte(errJSON)) _ = gz.Close() compressedBody := buf.Bytes()
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") // Intentionally omit Content-Encoding to simulate misbehaving upstream. w.WriteHeader(http.StatusBadRequest) _, _ = w.Write(compressedBody) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{"messages":[{"role":"user","content":[{"type":"text","text":"hi"}]}]}`)
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("claude"), }) if err == nil { t.Fatal("expected an error for 400 response, got nil") } if !strings.Contains(err.Error(), "test error") { t.Errorf("error message should contain decompressed JSON, got: %q", err.Error()) }}
// TestClaudeExecutor_ExecuteStream_GzipErrorBodyNoContentEncodingHeader verifies// the same for the streaming executor: 4xx gzip body without Content-Encoding is// decoded and the error message is readable.func TestClaudeExecutor_ExecuteStream_GzipErrorBodyNoContentEncodingHeader(t *testing.T) { const errJSON = `{"type":"error","error":{"type":"invalid_request_error","message":"stream test error"}}`
var buf bytes.Buffer gz := gzip.NewWriter(&buf) _, _ = gz.Write([]byte(errJSON)) _ = gz.Close() compressedBody := buf.Bytes()
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") // Intentionally omit Content-Encoding to simulate misbehaving upstream. w.WriteHeader(http.StatusBadRequest) _, _ = w.Write(compressedBody) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{"messages":[{"role":"user","content":[{"type":"text","text":"hi"}]}]}`)
_, err := executor.ExecuteStream(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("claude"), }) if err == nil { t.Fatal("expected an error for 400 response, got nil") } if !strings.Contains(err.Error(), "stream test error") { t.Errorf("error message should contain decompressed JSON, got: %q", err.Error()) }}
// TestClaudeExecutor_ExecuteStream_AcceptEncodingOverrideCannotBypassIdentity verifies that the// streaming executor enforces Accept-Encoding: identity regardless of auth.Attributes override.func TestClaudeExecutor_ExecuteStream_AcceptEncodingOverrideCannotBypassIdentity(t *testing.T) { var gotEncoding string server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { gotEncoding = r.Header.Get("Accept-Encoding") w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte("data: {\"type\":\"message_stop\"}\n\n")) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, "header:Accept-Encoding": "gzip, deflate, br, zstd", }} payload := []byte(`{"messages":[{"role":"user","content":[{"type":"text","text":"hi"}]}]}`)
result, err := executor.ExecuteStream(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("claude"), }) if err != nil { t.Fatalf("ExecuteStream error: %v", err) } for chunk := range result.Chunks { if chunk.Err != nil { t.Fatalf("unexpected chunk error: %v", chunk.Err) } }
if gotEncoding != "identity" { t.Errorf("Accept-Encoding = %q; stream path must enforce identity regardless of auth.Attributes override", gotEncoding) }}
// assertClaudeTopLevelCallerSystem checks a forwarded caller system prompt.// wantTTL is "" for the native default marker and "1h" once// upgradeClaudeCacheControlTTL has run, which only happens for OAuth credentials.func assertClaudeTopLevelCallerSystem(t *testing.T, body []byte, callerIndex int, wantText, wantTTL string) { t.Helper() path := fmt.Sprintf("system.%d", callerIndex+1) block := gjson.GetBytes(body, path) if got := block.Get("text").String(); got != wantText { t.Fatalf("%s.text lost caller prompt: got len %d, want len %d", path, len(got), len(wantText)) } if wantTTL != "" && block.Get("cache_control.ttl").String() != wantTTL { t.Fatalf("%s.cache_control.ttl = %q, want %q", path, block.Get("cache_control.ttl").String(), wantTTL) } if gjson.GetBytes(body, `messages.#(role=="system")`).Exists() { t.Fatal("cloaking inserted a system turn into messages") }}
func assertClaudePreservedSystemLayout(t *testing.T, body []byte, wantSystem, wantUser, wantTTL string) { t.Helper() if got := gjson.GetBytes(body, "system.#").Int(); got != 3 { t.Fatalf("top-level system block count = %d, want billing, identity and caller", got) } if got := gjson.GetBytes(body, "messages.#").Int(); got != 1 { t.Fatalf("message count = %d, want one user turn", got) } content := gjson.GetBytes(body, "messages.0.content").Array() if len(content) != 2 { t.Fatalf("user content has %d blocks, want currentDate and user text", len(content)) } assertClaudeCodeCurrentDateBlock(t, content[0]) assertEphemeralUserTextBlock(t, content[1], wantUser, wantTTL) assertClaudeTopLevelCallerSystem(t, body, 1, wantSystem, wantTTL)}
func assertClaudeCodeCurrentDateBlock(t *testing.T, block gjson.Result) { t.Helper() assertClaudeCodeCurrentDateBlockAt(t, block, time.Now())}
func assertClaudeCodeCurrentDateBlockAt(t *testing.T, block gjson.Result, now time.Time) { t.Helper() if got := block.Get("type").String(); got != "text" { t.Fatalf("currentDate block type = %q, want text", got) } if got, want := block.Get("text").String(), claudeCodeCurrentDateReminder(now); got != want { t.Fatalf("currentDate reminder = %q, want %q", got, want) } if block.Get("cache_control").Exists() { t.Fatalf("currentDate block must not contain cache_control: %s", block.Raw) }}
// assertEphemeralUserTextBlock checks the cloaked first-user block. wantTTL is ""// for the native default marker and "1h" once upgradeClaudeCacheControlTTL has run,// which only happens for OAuth credentials.func assertEphemeralUserTextBlock(t *testing.T, block gjson.Result, wantText, wantTTL string) { t.Helper() if got := block.Get("type").String(); got != "text" { t.Fatalf("user block type = %q, want text", got) } if got := block.Get("text").String(); got != wantText { t.Fatalf("user block text = %q, want %q", got, wantText) } if got := block.Get("cache_control.type").String(); got != "ephemeral" { t.Fatalf("user block cache_control.type = %q, want ephemeral", got) } if got := block.Get("cache_control.ttl").String(); got != wantTTL { t.Fatalf("user block cache_control.ttl = %q, want %q: %s", got, wantTTL, block.Raw) }}
func TestClaudeBillingFingerprintUsesLatestUserText(t *testing.T) { const prompt = "CPA_OFFICIAL_BASEURL_CLI_SYSTEM_EMPTY_b82d4e" payload := []byte(`{"system":"must not seed the build hash","messages":[{"role":"user","content":"old"},{"role":"assistant","content":"answer"},{"role":"user","content":[{"type":"text","text":"<system-reminder>date</system-reminder>"},{"type":"text","text":"` + prompt + `"}]}]}`) if got := claudeBillingFingerprintMessageText(payload); got != prompt { t.Fatalf("claudeBillingFingerprintMessageText() = %q, want %q", got, prompt) } if got := computeFingerprint(prompt, "2.1.258"); got != "1f4" { t.Fatalf("computeFingerprint() = %q, want official 2.1.258 capture suffix 1f4", got) }}
func TestClaudeCodeLocalDateMatchesNativeLocalCalendarAlgorithm(t *testing.T) { instant := time.Date(2026, time.July, 31, 15, 30, 0, 0, time.UTC) kiritimati := time.FixedZone("Kiritimati", 14*60*60) minusTwelve := time.FixedZone("Etc/GMT+12", -12*60*60)
if got := claudeCodeLocalDate(instant.In(kiritimati)); got != "2026-08-01" { t.Fatalf("Kiritimati local date = %q, want 2026-08-01", got) } if got := claudeCodeLocalDate(instant.In(minusTwelve)); got != "2026-07-31" { t.Fatalf("GMT-12 local date = %q, want 2026-07-31", got) } wantReminder := "<system-reminder>\nAs you answer the user's questions, you can use the following context:\n# currentDate\nToday's date is 2026-08-01.\n\n IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task.\n</system-reminder>\n\n" if got := claudeCodeCurrentDateReminder(instant.In(kiritimati)); got != wantReminder { t.Fatalf("currentDate reminder = %q, want exact native text %q", got, wantReminder) }}
func TestClaudeCodeTimezoneUsesCredentialThenConfiguredProfile(t *testing.T) { instant := time.Date(2026, time.August, 2, 1, 30, 0, 0, time.UTC) cfg := &config.Config{ClaudeHeaderDefaults: config.ClaudeHeaderDefaults{Timezone: "Asia/Tokyo"}} auth := &cliproxyauth.Auth{Metadata: map[string]any{"timezone": "Pacific/Honolulu"}} if got := claudeCodeLocalDate(instant.In(claudeCodeTimezone(cfg, auth))); got != "2026-08-01" { t.Fatalf("credential currentDate = %q, want 2026-08-01", got) } if got := claudeCodeLocalDate(instant.In(claudeCodeTimezone(cfg, nil))); got != "2026-08-02" { t.Fatalf("configured currentDate = %q, want 2026-08-02", got) } invalidAuth := &cliproxyauth.Auth{Metadata: map[string]any{"timezone": "not/a-timezone"}} if got := claudeCodeTimezone(cfg, invalidAuth).String(); got != "Asia/Tokyo" { t.Fatalf("invalid credential timezone = %q, want config fallback", got) } invalid := &config.Config{ClaudeHeaderDefaults: config.ClaudeHeaderDefaults{Timezone: "not/a-timezone"}} if got := claudeCodeTimezone(invalid, nil); got != time.Local { t.Fatalf("invalid timezone location = %v, want time.Local", got) }}
func TestInjectClaudeCodeCurrentDateIsIdempotentAndAlignsFirstUserCache(t *testing.T) { fixed := time.Date(2026, time.August, 1, 9, 0, 0, 0, time.FixedZone("UTC+8", 8*60*60)) payload := []byte(`{"messages":[{"role":"user","content":[{"type":"text","text":"hello","cache_control":{"type":"ephemeral","ttl":"1h"}}]}]}`)
first := injectClaudeCodeCurrentDate(payload, fixed) if !bytes.Contains(first, []byte(`<system-reminder>`)) || bytes.Contains(first, []byte(`\u003csystem-reminder`)) { t.Fatalf("currentDate angle brackets must match JSON.stringify bytes: %s", first) } second := injectClaudeCodeCurrentDate(first, fixed) if !bytes.Equal(first, second) { t.Fatalf("currentDate injection is not idempotent:\nfirst: %s\nsecond: %s", first, second) } content := gjson.GetBytes(first, "messages.0.content").Array() if len(content) != 2 { t.Fatalf("first user content has %d blocks, want 2: %s", len(content), first) } if got := content[0].Get("text").String(); got != claudeCodeCurrentDateReminder(fixed) { t.Fatalf("currentDate text = %q, want exact native reminder", got) } if content[0].Get("cache_control").Exists() { t.Fatalf("currentDate block must not contain cache_control: %s", content[0].Raw) } assertEphemeralUserTextBlock(t, content[1], "hello", "")}
func TestInjectClaudeCodeCurrentDateMovesExistingCopyToFirstBlock(t *testing.T) { fixed := time.Date(2026, time.August, 1, 9, 0, 0, 0, time.FixedZone("UTC+8", 8*60*60)) dateBlock := buildTextBlock(claudeCodeCurrentDateReminder(fixed), nil) payload := []byte(`{"messages":[{"role":"user","content":[` + `{"type":"text","text":"hello"},` + dateBlock + `]}]}`)
out := injectClaudeCodeCurrentDate(payload, fixed) content := gjson.GetBytes(out, "messages.0.content").Array() if len(content) != 2 { t.Fatalf("content has %d blocks, want one currentDate and user text: %s", len(content), out) } assertClaudeCodeCurrentDateBlockAt(t, content[0], fixed) assertEphemeralUserTextBlock(t, content[1], "hello", "")}
func TestInjectClaudeCodeCurrentDatePrecedesExistingReminder(t *testing.T) { fixed := time.Date(2026, time.August, 1, 9, 0, 0, 0, time.FixedZone("UTC+8", 8*60*60)) reminder := "<system-reminder>\ncaller instructions\n</system-reminder>" payload := []byte(`{"messages":[{"role":"user","content":[` + buildTextBlock(reminder, nil) + `,` + `{"type":"text","text":"continue","cache_control":{"type":"ephemeral","ttl":"1h"}}]}]}`)
out := injectClaudeCodeCurrentDate(payload, fixed) content := gjson.GetBytes(out, "messages.0.content").Array() if len(content) != 3 { t.Fatalf("content has %d blocks, want currentDate, reminder, and user text: %s", len(content), out) } assertClaudeCodeCurrentDateBlockAt(t, content[0], fixed) if got := content[1].Get("text").String(); got != reminder { t.Fatalf("content[1].text = %q, want standalone reminder", got) } assertEphemeralUserTextBlock(t, content[2], "continue", "")}
func TestInjectClaudeCodeCurrentDateFollowsLeadingToolResults(t *testing.T) { fixed := time.Date(2026, time.August, 1, 9, 0, 0, 0, time.FixedZone("UTC+8", 8*60*60)) payload := []byte(`{"messages":[` + `{"role":"assistant","content":[{"type":"tool_use","id":"toolu_1","name":"Read","input":{}}]},` + `{"role":"user","content":[` + `{"type":"tool_result","tool_use_id":"toolu_1","content":"ok"},` + `{"type":"text","text":"continue"}]}]}`)
first := injectClaudeCodeCurrentDate(payload, fixed) second := injectClaudeCodeCurrentDate(first, fixed) if !bytes.Equal(first, second) { t.Fatalf("currentDate injection is not idempotent:\nfirst: %s\nsecond: %s", first, second) }
content := gjson.GetBytes(first, "messages.1.content").Array() if len(content) != 3 { t.Fatalf("content has %d blocks, want tool_result, currentDate, and user text: %s", len(content), first) } if got := content[0].Get("type").String(); got != "tool_result" { t.Fatalf("content[0].type = %q, want tool_result to stay first: %s", got, first) } if got := content[0].Get("tool_use_id").String(); got != "toolu_1" { t.Fatalf("content[0].tool_use_id = %q, want toolu_1", got) } assertClaudeCodeCurrentDateBlockAt(t, content[1], fixed) assertEphemeralUserTextBlock(t, content[2], "continue", "")}
func TestInjectClaudeCodeCurrentDateFollowsAllLeadingToolResults(t *testing.T) { fixed := time.Date(2026, time.August, 1, 9, 0, 0, 0, time.FixedZone("UTC+8", 8*60*60)) payload := []byte(`{"messages":[` + `{"role":"assistant","content":[` + `{"type":"tool_use","id":"toolu_1","name":"Read","input":{}},` + `{"type":"tool_use","id":"toolu_2","name":"Read","input":{}}]},` + `{"role":"user","content":[` + `{"type":"tool_result","tool_use_id":"toolu_1","content":"ok"},` + `{"type":"tool_result","tool_use_id":"toolu_2","content":"ok"}]}]}`)
out := injectClaudeCodeCurrentDate(payload, fixed) content := gjson.GetBytes(out, "messages.1.content").Array() if len(content) != 3 { t.Fatalf("content has %d blocks, want two tool_results and currentDate: %s", len(content), out) } for idx, wantID := range []string{"toolu_1", "toolu_2"} { if got := content[idx].Get("type").String(); got != "tool_result" { t.Fatalf("content[%d].type = %q, want tool_result: %s", idx, got, out) } if got := content[idx].Get("tool_use_id").String(); got != wantID { t.Fatalf("content[%d].tool_use_id = %q, want %q", idx, got, wantID) } } assertClaudeCodeCurrentDateBlockAt(t, content[2], fixed)}
// String caller instructions stay top-level alongside CLI attribution.func TestCheckSystemInstructionsWithMode_StringSystemPreserved(t *testing.T) { payload := []byte(`{"model":"claude-opus-5","system":"You are a helpful assistant.","messages":[{"role":"user","content":"hi"}]}`)
out := checkSystemInstructionsWithMode(payload, false)
system := gjson.GetBytes(out, "system") if !system.IsArray() { t.Fatalf("system should be an array, got %s", system.Type) } blocks := system.Array() if len(blocks) != 3 { t.Fatalf("expected billing, identity and caller blocks, got %d", len(blocks)) } if got := blocks[0].Get("text").String(); !strings.Contains(got, "cc_entrypoint=cli;") { t.Fatalf("blocks[0] should use CLI billing attribution, got %q", got) } if blocks[1].Get("text").String() != claudeCodeCLIIdentity { t.Fatalf("blocks[1] should be official CLI identity, got %q", blocks[1].Get("text").String()) } if got := blocks[1].Get("cache_control.type").String(); got != "ephemeral" { t.Fatalf("blocks[1] cache_control.type = %q, want ephemeral", got) } if blocks[1].Get("cache_control.ttl").Exists() { t.Fatalf("blocks[1] cache_control must not carry a default ttl: %s", blocks[1].Raw) } content := gjson.GetBytes(out, "messages.0.content").Array() if len(content) != 2 { t.Fatalf("messages[0].content has %d blocks, want currentDate and user text: %s", len(content), out) } assertClaudeCodeCurrentDateBlock(t, content[0]) assertEphemeralUserTextBlock(t, content[1], "hi", "") assertClaudeTopLevelCallerSystem(t, out, 1, "You are a helpful assistant.", "")}
func TestClaudeUsesLegacySystemReminder(t *testing.T) { tests := map[string]bool{ "claude-opus-4-6": true, "claude-opus-4-7": true, "claude-sonnet-5": false, "prefix/claude-sonnet-4-6": true, "claude-3-5-haiku-latest": true, "claude-opus-5": false, "prefix/claude-opus-4-8": false, "claude-fable-5": false, "claude-future-6": false, "": false, } for model, want := range tests { t.Run(model, func(t *testing.T) { payload := []byte(`{"model":` + fmt.Sprintf("%q", model) + `}`) if got := claudeUsesLegacySystemReminder(payload); got != want { t.Fatalf("claudeUsesLegacySystemReminder(%q) = %v, want %v", model, got, want) } }) }}
// Test case 2: Strict mode keeps only the injected Claude Code system blocks.func TestCheckSystemInstructionsWithMode_StringSystemStrict(t *testing.T) { payload := []byte(`{"system":"You are a helpful assistant.","messages":[{"role":"user","content":"hi"}]}`)
out := checkSystemInstructionsWithMode(payload, true)
blocks := gjson.GetBytes(out, "system").Array() if len(blocks) != 2 { t.Fatalf("strict mode should produce 2 injected blocks, got %d", len(blocks)) } content := gjson.GetBytes(out, "messages.0.content").Array() if len(content) != 2 { t.Fatalf("strict mode content has %d blocks, want currentDate and user text", len(content)) } assertClaudeCodeCurrentDateBlock(t, content[0]) assertEphemeralUserTextBlock(t, content[1], "hi", "")}
// Test case 3: Empty string system prompt adds only currentDate before user text.func TestCheckSystemInstructionsWithMode_EmptyStringSystemIgnored(t *testing.T) { payload := []byte(`{"system":"","messages":[{"role":"user","content":"hi"}]}`)
out := checkSystemInstructionsWithMode(payload, false)
blocks := gjson.GetBytes(out, "system").Array() if len(blocks) != 2 { t.Fatalf("empty string system should still produce 2 injected blocks, got %d", len(blocks)) } content := gjson.GetBytes(out, "messages.0.content").Array() if len(content) != 2 { t.Fatalf("empty system content has %d blocks, want 2", len(content)) } assertClaudeCodeCurrentDateBlock(t, content[0]) assertEphemeralUserTextBlock(t, content[1], "hi", "")}
// Array caller instructions stay top-level.func TestCheckSystemInstructionsWithMode_ArraySystemStillWorks(t *testing.T) { payload := []byte(`{"model":"claude-opus-5","system":[{"type":"text","text":"Be concise."}],"messages":[{"role":"user","content":"hi"}]}`)
out := checkSystemInstructionsWithMode(payload, false)
blocks := gjson.GetBytes(out, "system").Array() if len(blocks) != 3 { t.Fatalf("expected 3 top-level system blocks, got %d", len(blocks)) } content := gjson.GetBytes(out, "messages.0.content").Array() if len(content) != 2 { t.Fatalf("messages[0].content has %d blocks, want currentDate and user text", len(content)) } assertClaudeCodeCurrentDateBlock(t, content[0]) assertEphemeralUserTextBlock(t, content[1], "hi", "") assertClaudeTopLevelCallerSystem(t, out, 1, "Be concise.", "")}
func TestPrepareClaudeSystemPromptForCountTokensKeepsBlocksSeparate(t *testing.T) { for _, model := range []string{"claude-opus-5", "claude-opus-4-6", "claude-future-6"} { t.Run(model, func(t *testing.T) { payload := []byte(`{"model":"` + model + `","system":[{"type":"text","text":"first guidance"},{"type":"text","text":"second guidance"}],"messages":[{"role":"user","content":"hi"}]}`) out := prepareClaudeSystemPromptForCountTokens(payload, false) if !bytes.Equal(payload, out) { t.Fatalf("count_tokens changed caller system or messages: %s", out) } }) }}
func TestCheckSystemInstructionsWithMode_AdvisorToolResultPreservesTopLevelSystemAndKeepsMessagesIntact(t *testing.T) { payload := []byte(`{ "model": "claude-opus-5", "system": [ {"type": "text", "text": "first guidance"}, {"type": "text", "text": "second guidance"} ], "messages": [ {"role": "user", "content": "hello"}, { "role": "assistant", "content": [ {"type": "server_tool_use", "id": "srvtoolu_adv1", "name": "advisor", "input": {}} ] }, { "role": "user", "content": [ { "type": "advisor_tool_result", "tool_use_id": "srvtoolu_adv1", "content": { "type": "advisor_redacted_result", "encrypted_content": "ciphertext123" } } ] }, {"role": "assistant", "content": "advice acknowledged"} ] }`)
out := checkSystemInstructionsWithMode(payload, false)
// Messages must NOT have mid-conversation role=system turns inserted, // so the message count stays at 4 and roles remain intact. if got := gjson.GetBytes(out, "messages.#").Int(); got != 4 { t.Fatalf("messages count = %d, want 4 (no mid-conversation system splice): %s", got, out) } roles := gjson.GetBytes(out, "messages.#.role").Array() wantRoles := []string{"user", "assistant", "user", "assistant"} for idx, wantRole := range wantRoles { if got := roles[idx].String(); got != wantRole { t.Fatalf("messages[%d].role = %q, want %q", idx, got, wantRole) } }
// Top-level system must retain caller system blocks in addition to Claude Code identity blocks. systemBlocks := gjson.GetBytes(out, "system").Array() if len(systemBlocks) != 4 { t.Fatalf("system blocks count = %d, want 4 (2 identity + 2 caller blocks): %s", len(systemBlocks), out) } if got := systemBlocks[2].Get("text").String(); got != "first guidance" { t.Fatalf("system[2].text = %q, want first guidance", got) } if got := systemBlocks[3].Get("text").String(); got != "second guidance" { t.Fatalf("system[3].text = %q, want second guidance", got) }}
func TestRelocateClaudeSystemPromptForCountTokens_AdvisorToolResultLeavesMessagesUntouched(t *testing.T) { payload := []byte(`{ "model": "claude-opus-5", "system": [ {"type": "text", "text": "first guidance"}, {"type": "text", "text": "second guidance"} ], "messages": [ {"role": "user", "content": "hello"}, { "role": "assistant", "content": [ {"type": "server_tool_use", "id": "srvtoolu_adv1", "name": "advisor", "input": {}} ] }, { "role": "user", "content": [ { "type": "advisor_tool_result", "tool_use_id": "srvtoolu_adv1", "content": [ { "type": "advisor_redacted_result", "encrypted_content": "ciphertext123" } ] } ] } ] }`)
out := prepareClaudeSystemPromptForCountTokens(payload, false)
// Caller system blocks must be retained in top-level system so that // their tokens are counted, without splicing them into messages[]. systemBlocks := gjson.GetBytes(out, "system").Array() if len(systemBlocks) != 2 { t.Fatalf("count_tokens system blocks count = %d, want 2: %s", len(systemBlocks), out) } if got := systemBlocks[0].Get("text").String(); got != "first guidance" { t.Fatalf("system[0].text = %q, want first guidance", got) } if got := systemBlocks[1].Get("text").String(); got != "second guidance" { t.Fatalf("system[1].text = %q, want second guidance", got) }
if got := gjson.GetBytes(out, "messages.#").Int(); got != 3 { t.Fatalf("count_tokens messages count = %d, want 3 (no mid-conversation system splice): %s", got, out) } roles := gjson.GetBytes(out, "messages.#.role").Array() wantRoles := []string{"user", "assistant", "user"} for idx, wantRole := range wantRoles { if got := roles[idx].String(); got != wantRole { t.Fatalf("messages[%d].role = %q, want %q", idx, got, wantRole) } }}
func TestCheckSystemInstructionsWithMode_UnicodeEscapedAdvisor(t *testing.T) { // JSON with unicode-escaped "advisor" name: \u0061dvisor payload := []byte(`{ "model": "claude-opus-5", "system": [ {"type": "text", "text": "guidance"} ], "messages": [ {"role": "user", "content": "hello"}, { "role": "assistant", "content": [ {"type": "server_tool_use", "id": "srvtoolu_adv1", "name": "\u0061dvisor", "input": {}} ] } ] }`)
out := checkSystemInstructionsWithMode(payload, false)
if got := gjson.GetBytes(out, "messages.#").Int(); got != 2 { t.Fatalf("messages count = %d, want 2 (no mid-conversation splice): %s", got, out) } systemBlocks := gjson.GetBytes(out, "system").Array() if len(systemBlocks) != 3 { t.Fatalf("system blocks count = %d, want 3: %s", len(systemBlocks), out) } if got := systemBlocks[2].Get("text").String(); got != "guidance" { t.Fatalf("system[2].text = %q, want guidance", got) }}
func TestCheckSystemInstructionsWithMode_StandaloneAdvisorCallWithoutResult(t *testing.T) { // Assistant made an advisor call, but no result has arrived yet payload := []byte(`{ "model": "claude-opus-5", "system": [ {"type": "text", "text": "guidance"} ], "messages": [ {"role": "user", "content": "hello"}, { "role": "assistant", "content": [ {"type": "server_tool_use", "id": "srvtoolu_adv1", "name": "advisor", "input": {}} ] } ] }`)
out := checkSystemInstructionsWithMode(payload, false)
if got := gjson.GetBytes(out, "messages.#").Int(); got != 2 { t.Fatalf("messages count = %d, want 2 (no mid-conversation splice): %s", got, out) } roles := gjson.GetBytes(out, "messages.#.role").Array() wantRoles := []string{"user", "assistant"} for idx, wantRole := range wantRoles { if got := roles[idx].String(); got != wantRole { t.Fatalf("messages[%d].role = %q, want %q", idx, got, wantRole) } } systemBlocks := gjson.GetBytes(out, "system").Array() if len(systemBlocks) != 3 { t.Fatalf("system blocks count = %d, want 3: %s", len(systemBlocks), out) } if got := systemBlocks[2].Get("text").String(); got != "guidance" { t.Fatalf("system[2].text = %q, want guidance", got) }}
func TestCheckSystemInstructionsWithMode_StandaloneAdvisorResultWithoutCall(t *testing.T) { // User message has advisor_tool_result without preceding server_tool_use in the window payload := []byte(`{ "model": "claude-opus-5", "system": [ {"type": "text", "text": "guidance"} ], "messages": [ {"role": "user", "content": "hello"}, { "role": "user", "content": [ { "type": "advisor_tool_result", "tool_use_id": "srvtoolu_adv1", "content": [ { "type": "advisor_redacted_result", "encrypted_content": "ciphertext123" } ] } ] } ] }`)
out := checkSystemInstructionsWithMode(payload, false)
if got := gjson.GetBytes(out, "messages.#").Int(); got != 2 { t.Fatalf("messages count = %d, want 2 (no mid-conversation splice): %s", got, out) } roles := gjson.GetBytes(out, "messages.#.role").Array() wantRoles := []string{"user", "user"} for idx, wantRole := range wantRoles { if got := roles[idx].String(); got != wantRole { t.Fatalf("messages[%d].role = %q, want %q", idx, got, wantRole) } } systemBlocks := gjson.GetBytes(out, "system").Array() if len(systemBlocks) != 3 { t.Fatalf("system blocks count = %d, want 3: %s", len(systemBlocks), out) } if got := systemBlocks[2].Get("text").String(); got != "guidance" { t.Fatalf("system[2].text = %q, want guidance", got) }}
func TestCheckSystemInstructionsWithMode_NormalTextWithAdvisorWordKeepsSystemTopLevel(t *testing.T) { payload := []byte(`{ "model": "claude-opus-5", "system": [ {"type": "text", "text": "first guidance"}, {"type": "text", "text": "second guidance"} ], "messages": [ {"role": "user", "content": "I need an advisor on financial planning."} ] }`)
out := checkSystemInstructionsWithMode(payload, false)
// Caller instructions stay top-level regardless of advisor content. if got := gjson.GetBytes(out, "messages.#").Int(); got != 1 { t.Fatalf("messages count = %d, want 1 user message: %s", got, out) } assertClaudeTopLevelCallerSystem(t, out, 1, "first guidance", "") assertClaudeTopLevelCallerSystem(t, out, 2, "second guidance", "")}
func TestCheckSystemInstructionsWithMode_AdvisorToolResultArrayContent(t *testing.T) { payload := []byte(`{ "model": "claude-opus-5", "system": [ {"type": "text", "text": "guidance"} ], "messages": [ {"role": "user", "content": "hello"}, { "role": "assistant", "content": [ {"type": "server_tool_use", "id": "srvtoolu_adv1", "name": "advisor", "input": {}} ] }, { "role": "user", "content": [ { "type": "advisor_tool_result", "tool_use_id": "srvtoolu_adv1", "content": [ { "type": "advisor_redacted_result", "encrypted_content": "ciphertext123" } ] } ] } ] }`)
out := checkSystemInstructionsWithMode(payload, false)
if got := gjson.GetBytes(out, "messages.#").Int(); got != 3 { t.Fatalf("messages count = %d, want 3: %s", got, out) } roles := gjson.GetBytes(out, "messages.#.role").Array() wantRoles := []string{"user", "assistant", "user"} for idx, wantRole := range wantRoles { if got := roles[idx].String(); got != wantRole { t.Fatalf("messages[%d].role = %q, want %q", idx, got, wantRole) } } systemBlocks := gjson.GetBytes(out, "system").Array() if len(systemBlocks) != 3 { t.Fatalf("system blocks count = %d, want 3: %s", len(systemBlocks), out) } if got := systemBlocks[2].Get("text").String(); got != "guidance" { t.Fatalf("system[2].text = %q, want guidance", got) }}
func TestCheckSystemInstructionsWithMode_ToolResultWithAdvisorRedactedResult(t *testing.T) { payload := []byte(`{ "model": "claude-opus-5", "system": [ {"type": "text", "text": "guidance"} ], "messages": [ {"role": "user", "content": "hello"}, { "role": "assistant", "content": [ {"type": "tool_use", "id": "toolu_adv1", "name": "advisor", "input": {}} ] }, { "role": "user", "content": [ { "type": "tool_result", "tool_use_id": "toolu_adv1", "content": [ { "type": "advisor_redacted_result", "encrypted_content": "ciphertext123" } ] } ] } ] }`)
out := checkSystemInstructionsWithMode(payload, false)
if got := gjson.GetBytes(out, "messages.#").Int(); got != 3 { t.Fatalf("messages count = %d, want 3: %s", got, out) } roles := gjson.GetBytes(out, "messages.#.role").Array() wantRoles := []string{"user", "assistant", "user"} for idx, wantRole := range wantRoles { if got := roles[idx].String(); got != wantRole { t.Fatalf("messages[%d].role = %q, want %q", idx, got, wantRole) } } systemBlocks := gjson.GetBytes(out, "system").Array() if len(systemBlocks) != 3 { t.Fatalf("system blocks count = %d, want 3: %s", len(systemBlocks), out) } if got := systemBlocks[2].Get("text").String(); got != "guidance" { t.Fatalf("system[2].text = %q, want guidance", got) }}
// Special characters survive top-level system preservation.func TestCheckSystemInstructionsWithMode_StringWithSpecialChars(t *testing.T) { payload := []byte(`{"model":"claude-opus-5","system":"Use <xml> tags & \"quotes\" in output.","messages":[{"role":"user","content":"hi"}]}`)
out := checkSystemInstructionsWithMode(payload, false)
wantSystem := `Use <xml> tags & "quotes" in output.` if got := gjson.GetBytes(out, "system.#").Int(); got != 3 { t.Fatalf("top-level system block count = %d, want 3", got) } content := gjson.GetBytes(out, "messages.0.content").Array() if len(content) != 2 { t.Fatalf("messages[0].content has %d blocks, want 2", len(content)) } assertClaudeCodeCurrentDateBlock(t, content[0]) assertEphemeralUserTextBlock(t, content[1], "hi", "") assertClaudeTopLevelCallerSystem(t, out, 1, wantSystem, "")}
func TestCheckSystemInstructionsWithSigningMode_LongPromptIsExactAndIdempotent(t *testing.T) { wantSystem := "\nPI_SYSTEM_BEGIN\nEmbedded reference: # currentDate\nToday's date is caller-owned text.\n" + strings.Repeat("Preserve tools, policies, and caller semantics exactly.\n", 560) + "PI_SYSTEM_END \n" payloadMap := map[string]any{ "model": "claude-opus-5", "system": wantSystem, "messages": []any{map[string]any{ "role": "user", "content": "hello", }}, } payload, errMarshal := json.Marshal(payloadMap) if errMarshal != nil { t.Fatalf("marshal payload: %v", errMarshal) }
first := checkSystemInstructionsWithSigningMode(payload, false, true, "2.1.258", "cli", "") second := checkSystemInstructionsWithSigningMode(first, false, true, "2.1.258", "cli", "") if !bytes.Equal(first, second) { t.Fatalf("complete cloak layout is not byte-idempotent:\nfirst: %s\nsecond: %s", first, second) } if got := gjson.GetBytes(first, "system.#").Int(); got != 3 { t.Fatalf("top-level system block count = %d, want 3", got) } if got := gjson.GetBytes(first, "messages.#").Int(); got != 1 { t.Fatalf("message count = %d, want only the user turn", got) } content := gjson.GetBytes(first, "messages.0.content").Array() if len(content) != 2 { t.Fatalf("user content has %d blocks, want currentDate and user text", len(content)) } assertClaudeCodeCurrentDateBlock(t, content[0]) assertEphemeralUserTextBlock(t, content[1], "hello", "") assertClaudeTopLevelCallerSystem(t, first, 1, wantSystem, "") if strings.Contains(content[0].Get("text").String(), "PI_SYSTEM_BEGIN") || strings.Contains(content[1].Get("text").String(), "PI_SYSTEM_BEGIN") { t.Fatal("caller system prompt leaked into the user content blocks") } if !bytes.Contains(first, []byte(`<system-reminder>`)) || bytes.Contains(first, []byte(`\u003csystem-reminder`)) { t.Fatalf("currentDate reminder angle brackets must remain literal JSON bytes") }
signed, errSign := finalizeAnthropicMessagesBodyCCH(first, "") if errSign != nil { t.Fatalf("finalize Claude CCH: %v", errSign) } resigned, errResign := finalizeAnthropicMessagesBodyCCH(signed, "") if errResign != nil { t.Fatalf("re-finalize Claude CCH: %v", errResign) } if !bytes.Equal(signed, resigned) { t.Fatal("CCH finalization is not byte-idempotent after long prompt preservation") }}
func TestClaudeExecutor_CustomBaseURLPreservesBodyByDefault(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) seenBody = bytes.Clone(body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-3-5-sonnet","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{"messages":[{"role":"user","content":[{"type":"text","text":"hi"}]}]}`)
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) if err != nil { t.Fatalf("Execute() error = %v", err) } if len(seenBody) == 0 { t.Fatal("expected request body to be captured") }
if strings.Contains(string(seenBody), "x-anthropic-billing-header:") || strings.Contains(string(seenBody), "cch=") { t.Fatalf("default custom BaseURL request must not inject billing/CCH: %s", seenBody) }}
func TestClaudeExecutor_CustomBaseURLAPIKeyDoesNotEnableCCHSigning(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) seenBody = bytes.Clone(body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-3-5-sonnet","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "key-123", BaseURL: server.URL, ExperimentalCCHSigning: true, }}, }) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} const messageText = "please keep literal cch=00000 in this message" payload := []byte(`{"messages":[{"role":"user","content":[{"type":"text","text":"please keep literal cch=00000 in this message"}]}]}`)
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) if err != nil { t.Fatalf("Execute() error = %v", err) } if len(seenBody) == 0 { t.Fatal("expected request body to be captured") } if got := gjson.GetBytes(seenBody, "messages.0.content.0.text").String(); got != messageText { t.Fatalf("message text = %q, want %q", got, messageText) } if strings.Contains(string(seenBody), "x-anthropic-billing-header:") { t.Fatalf("default custom BaseURL request must not inject a billing header: %s", seenBody) }}
func TestClaudeExecutor_CustomBaseURLOAuthGeneratesMissingCCH(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) seenBody = bytes.Clone(body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-opus-4-6","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ Attributes: map[string]string{ "api_key": "sk-ant-oat-custom-cch", "base_url": server.URL, "cloak_mode": "never", }, Metadata: claudeOAuthTestMetadata(), } payload := []byte(`{"model":"claude-opus-4-6","system":"keep original system","messages":[{"role":"user","content":"hello"}],"max_tokens":64}`)
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-opus-4-6", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute() error = %v", err) } if _, ok := claudeBillingCCHDigitsOffset(seenBody); !ok { t.Fatalf("Claude OAuth custom BaseURL body is missing generated CCH: %s", seenBody) } if got := gjson.GetBytes(seenBody, "system.1.text").String(); got != "keep original system" { t.Fatalf("system.1.text = %q, want preserved system text", got) }}
func TestClaudeExecutor_RebuildMidSystemMessageDisabledByDefault(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) seenBody = bytes.Clone(body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-3-5-sonnet","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "key-123", BaseURL: server.URL, }}, }) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{"system":[{"type":"text","text":"Top rule","cache_control":{"type":"ephemeral"}}],"messages":[{"role":"user","content":[{"type":"text","text":"hi"}]},{"role":"system","content":"Mid rule"},{"role":"user","content":[{"type":"text","text":"continue"}]}],"metadata":{"user_id":"{\"device_id\":\"0000000000000000000000000000000000000000000000000000000000000000\",\"account_uuid\":\"\",\"session_id\":\"11111111-2222-4333-8444-555555555555\"}"}}`) ctx := contextWithGinHeaders(map[string]string{ "User-Agent": "claude-cli/2.1.258 (external, cli)", "X-App": "cli", "Anthropic-Beta": "claude-code-20250219", })
_, errExecute := executor.Execute(ctx, auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) if errExecute != nil { t.Fatalf("Execute() error = %v", errExecute) } if len(seenBody) == 0 { t.Fatal("expected request body to be captured") } if got := gjson.GetBytes(seenBody, "system.0.text").String(); got != "Top rule" { t.Fatalf("system.0.text = %q, want top-level system preserved", got) } if got := gjson.GetBytes(seenBody, `messages.#(role=="system").content`).String(); got != "Mid rule" { t.Fatalf("mid system message = %q, want original message preserved", got) }}
func TestClaudeExecutor_RebuildMidSystemMessageOptInMovesSystemMessages(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) seenBody = bytes.Clone(body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-3-5-sonnet","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "key-123", BaseURL: server.URL, RebuildMidSystemMessage: true, }}, }) auth := &cliproxyauth.Auth{Attributes: map[string]string{ "api_key": "key-123", "base_url": server.URL, }} payload := []byte(`{"system":"Top rule","messages":[{"role":"user","content":[{"type":"text","text":"hi"}]},{"role":"system","content":"Mid string rule"},{"role":"assistant","content":[{"type":"text","text":"ok"}]},{"role":"system","content":[{"type":"text","text":"Mid array rule","cache_control":{"type":"ephemeral"}}]},{"role":"user","content":[{"type":"text","text":"continue"}]}],"metadata":{"user_id":"{\"device_id\":\"0000000000000000000000000000000000000000000000000000000000000000\",\"account_uuid\":\"\",\"session_id\":\"11111111-2222-4333-8444-555555555555\"}"}}`) ctx := contextWithGinHeaders(map[string]string{ "User-Agent": "claude-cli/2.1.258 (external, cli)", "X-App": "cli", "Anthropic-Beta": "claude-code-20250219", })
_, errExecute := executor.Execute(ctx, auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FromString("claude")}) if errExecute != nil { t.Fatalf("Execute() error = %v", errExecute) } if len(seenBody) == 0 { t.Fatal("expected request body to be captured") }
system := gjson.GetBytes(seenBody, "system").Array() if len(system) != 3 { t.Fatalf("system has %d items, want 3: %s", len(system), gjson.GetBytes(seenBody, "system").Raw) } wantTexts := []string{"Top rule", "Mid string rule", "Mid array rule"} for i, want := range wantTexts { if got := system[i].Get("text").String(); got != want { t.Fatalf("system[%d].text = %q, want %q", i, got, want) } } if got := gjson.GetBytes(seenBody, "system.2.cache_control.type").String(); got != "ephemeral" { t.Fatalf("system.2.cache_control.type = %q, want ephemeral", got) } if gjson.GetBytes(seenBody, `messages.#(role=="system")`).Exists() { t.Fatalf("messages should not contain system role after rebuild: %s", gjson.GetBytes(seenBody, "messages").Raw) } if got := gjson.GetBytes(seenBody, "messages.#").Int(); got != 3 { t.Fatalf("messages count = %d, want 3", got) }}
func TestResolveClaudeWirePolicy(t *testing.T) { tests := []struct { name string confirmed bool mode string wantCloak bool }{ {name: "unknown auto", mode: "auto", wantCloak: true}, {name: "unknown always", mode: "always", wantCloak: true}, {name: "unknown never", mode: "never", wantCloak: false}, {name: "confirmed auto", confirmed: true, mode: "auto", wantCloak: false}, {name: "confirmed always", confirmed: true, mode: "always", wantCloak: false}, {name: "confirmed never", confirmed: true, mode: "never", wantCloak: false}, } for _, test := range tests { t.Run(test.name, func(t *testing.T) { auth := &cliproxyauth.Auth{Metadata: map[string]any{"cloak_mode": test.mode}} policy, _ := resolveClaudeWirePolicy(&config.Config{}, auth, "sk-ant-oat-test", test.confirmed) if !policy.OAuth { t.Fatal("resolveClaudeWirePolicy() OAuth = false, want true") } if policy.ConfirmedClaudeCode != test.confirmed { t.Fatalf("ConfirmedClaudeCode = %v, want %v", policy.ConfirmedClaudeCode, test.confirmed) } if policy.Cloak != test.wantCloak { t.Fatalf("Cloak = %v, want %v", policy.Cloak, test.wantCloak) } }) }}
func TestApplyCloaking_PreservesConfiguredStrictModeAndSensitiveWordsWhenModeOmitted(t *testing.T) { cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "key-123", Cloak: &config.CloakConfig{ StrictMode: true, SensitiveWords: []string{"proxy"}, }, }}, } auth := &cliproxyauth.Auth{Attributes: map[string]string{"api_key": "key-123"}} payload := []byte(`{"system":"proxy rules","messages":[{"role":"user","content":[{"type":"text","text":"proxy access"}]}]}`)
out, cloaked, errCloaking := applyCloaking( context.Background(), cfg, auth, payload, "key-123", false, false, ) if errCloaking != nil { t.Fatalf("applyCloaking() error = %v", errCloaking) }
if !cloaked { t.Fatal("applyCloaking() cloaked = false, want true") } blocks := gjson.GetBytes(out, "system").Array() if len(blocks) != 2 { t.Fatalf("expected strict mode to keep the 2 injected Claude CLI system blocks, got %d", len(blocks)) } content := gjson.GetBytes(out, "messages.0.content").Array() if len(content) != 2 { t.Fatalf("strict mode should add only currentDate before user text, got %d content blocks", len(content)) } assertClaudeCodeCurrentDateBlock(t, content[0]) if got := content[1].Get("text").String(); !strings.Contains(got, "\u200B") { t.Fatalf("expected configured sensitive word obfuscation to apply, got %q", got) }}
func TestApplyCloaking_FableInjectsFallbacksAndDisplayUpdates(t *testing.T) { cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-fable-test", Cloak: &config.CloakConfig{}, }}, } auth := &cliproxyauth.Auth{Attributes: map[string]string{"api_key": "sk-ant-oat-fable-test"}} payload := []byte(`{"model":"claude-fable-5-1","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`)
out, cloaked, err := applyCloaking( context.Background(), cfg, auth, payload, "sk-ant-oat-fable-test", false, true, ) if err != nil { t.Fatalf("applyCloaking() error = %v", err) } if !cloaked { t.Fatal("applyCloaking() cloaked = false, want true") }
fallbacks := gjson.GetBytes(out, "fallbacks").Array() if len(fallbacks) != 1 || fallbacks[0].Get("model").String() != "claude-opus-5" { t.Fatalf("expected fallbacks=[{\"model\":\"claude-opus-5\"}], got: %s", gjson.GetBytes(out, "fallbacks").Raw) }
systemBlocks := gjson.GetBytes(out, "system").Array() if len(systemBlocks) != 3 { t.Fatalf("expected 3 system blocks for Fable cloaking (billing, identity, reporting outcomes), got %d", len(systemBlocks)) } if !strings.Contains(systemBlocks[2].Get("text").String(), "Reporting outcomes") { t.Fatalf("expected system block 2 to contain Reporting outcomes, got: %s", systemBlocks[2].Get("text").String()) } if systemBlocks[2].Get("cache_control").Exists() { t.Fatalf("system block 2 for Reporting outcomes should have no cache_control, got: %s", systemBlocks[2].Get("cache_control").Raw) }
display := gjson.GetBytes(out, "thinking.display").String() if display != "updates" { t.Fatalf("expected thinking.display=updates, got: %q", display) }
betas := claudeCodeCLIBetas(out, nil, true) if !strings.Contains(betas, "server-side-fallback-2026-06-01") { t.Fatalf("expected server-side-fallback beta in betas, got: %s", betas) } if !strings.Contains(betas, "thinking-display-updates-2026-08-18") { t.Fatalf("expected thinking-display-updates beta in betas, got: %s", betas) } if strings.Contains(betas, "redact-thinking-2026-02-12") { t.Fatalf("expected redact-thinking beta to be dropped when display=updates, got: %s", betas) }}
func TestApplyCloaking_SonnetOmitsReportingOutcomes(t *testing.T) { cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-sonnet-test", Cloak: &config.CloakConfig{}, }}, } auth := &cliproxyauth.Auth{Attributes: map[string]string{"api_key": "sk-ant-oat-sonnet-test"}} payload := []byte(`{"model":"claude-sonnet-5","messages":[{"role":"user","content":"test"}]}`)
out, cloaked, err := applyCloaking( context.Background(), cfg, auth, payload, "sk-ant-oat-sonnet-test", false, true, ) if err != nil { t.Fatalf("applyCloaking() error = %v", err) } if !cloaked { t.Fatal("applyCloaking() cloaked = false, want true") }
systemBlocks := gjson.GetBytes(out, "system").Array() if len(systemBlocks) != 2 { t.Fatalf("expected 2 system blocks for Sonnet (billing, identity only), got %d", len(systemBlocks)) } for i, b := range systemBlocks { if strings.Contains(b.Get("text").String(), "Reporting outcomes") { t.Fatalf("system block %d should not contain Reporting outcomes on non-Fable model, got: %s", i, b.Get("text").String()) } }}
func TestApplyCloaking_DisabledByConfigLeavesFableUntouched(t *testing.T) { cfg := &config.Config{ DisableClaudeCloakMode: true, } auth := &cliproxyauth.Auth{Attributes: map[string]string{"api_key": "sk-ant-oat-fable-test"}} originalSystem := "You are a custom assistant for my company." payload := []byte(`{"model":"claude-fable-5-1","system":"` + originalSystem + `","messages":[{"role":"user","content":"test"}]}`)
out, cloaked, err := applyCloaking( context.Background(), cfg, auth, payload, "sk-ant-oat-fable-test", false, true, ) if err != nil { t.Fatalf("applyCloaking() error = %v", err) } if cloaked { t.Fatal("applyCloaking() cloaked = true, want false when DisableClaudeCloakMode is true") } if got := gjson.GetBytes(out, "system").String(); got != originalSystem { t.Fatalf("expected system to be preserved unchanged, got: %s", got) } if gjson.GetBytes(out, "fallbacks").Exists() { t.Fatalf("expected no fallbacks injected when cloaking is disabled, got: %s", gjson.GetBytes(out, "fallbacks").Raw) }}
func TestApplyCloaking_NativeClaudeCodeLeavesFableUntouched(t *testing.T) { cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-fable-test", Cloak: &config.CloakConfig{}, }}, } auth := &cliproxyauth.Auth{Attributes: map[string]string{"api_key": "sk-ant-oat-fable-test"}} originalSystem := "You are a native claude code agent." payload := []byte(`{"model":"claude-fable-5-1","system":"` + originalSystem + `","messages":[{"role":"user","content":"test"}]}`)
out, cloaked, err := applyCloaking( context.Background(), cfg, auth, payload, "sk-ant-oat-fable-test", true, // confirmedClaudeCode = true true, ) if err != nil { t.Fatalf("applyCloaking() error = %v", err) } if cloaked { t.Fatal("applyCloaking() cloaked = true, want false for confirmed native Claude Code") } if got := gjson.GetBytes(out, "system").String(); got != originalSystem { t.Fatalf("expected system to be preserved unchanged for native client, got: %s", got) }}
func TestApplyCloaking_Fable5OmitsFallbacksAndReportingOutcomes(t *testing.T) { cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-fable5-test", Cloak: &config.CloakConfig{}, }}, } auth := &cliproxyauth.Auth{Attributes: map[string]string{"api_key": "sk-ant-oat-fable5-test"}} payload := []byte(`{"model":"claude-fable-5","messages":[{"role":"user","content":"test"}]}`)
out, cloaked, err := applyCloaking( context.Background(), cfg, auth, payload, "sk-ant-oat-fable5-test", false, true, ) if err != nil { t.Fatalf("applyCloaking() error = %v", err) } if !cloaked { t.Fatal("applyCloaking() cloaked = false, want true") }
if gjson.GetBytes(out, "fallbacks").Exists() { t.Fatalf("claude-fable-5 should not have fallbacks injected, got: %s", gjson.GetBytes(out, "fallbacks").Raw) }
systemBlocks := gjson.GetBytes(out, "system").Array() if len(systemBlocks) != 2 { t.Fatalf("expected 2 system blocks for claude-fable-5, got %d", len(systemBlocks)) } for _, b := range systemBlocks { if strings.Contains(b.Get("text").String(), "Reporting outcomes") { t.Fatalf("claude-fable-5 should not contain Reporting outcomes, got: %s", b.Get("text").String()) } }}
func TestClaudeExecutor_TitleHelperWithSystemPromptIsolated(t *testing.T) { helps.ResetClaudeDiagnosticsForTest() defer helps.ResetClaudeDiagnosticsForTest()
var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") w.Header().Set("request-id", "req_helper123") _, _ = w.Write([]byte(`{"id":"msg_helper123","type":"message","model":"claude-sonnet-5","role":"assistant","content":[{"type":"text","text":"Title"}]}`)) })) defer server.Close()
payload := []byte(`{"model":"claude-sonnet-5","system":"Return a short title summarizing this conversation","messages":[{"role":"user","content":"test"}]}`) cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-title-test", Cloak: &config.CloakConfig{}, }}, } auth := &cliproxyauth.Auth{ ID: "auth-title-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-title-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) ctx := helps.WithClaudeSessionID(context.Background(), "session-title-1") _, err := executor.Execute(ctx, auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, }) if err != nil { t.Fatalf("Execute error: %v", err) }
// Title helper must NOT carry diagnostics if gjson.GetBytes(seenBody, "diagnostics").Exists() { t.Fatalf("expected title helper to omit diagnostics, got: %s", gjson.GetBytes(seenBody, "diagnostics").Raw) }
// Title helper must NOT advance session continuity state credID := claudeDiagnosticsCredentialIdentity(auth) _, _, prevMsg := helps.BeginClaudeDiagnostics(credID, "session-title-1") if prevMsg != "" { t.Fatalf("expected title helper to leave prevMsg empty, got: %q", prevMsg) }}
func TestClaudeExecutor_SubagentAndProbeOmit1hCacheTTLAndBeta(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_sub1","type":"message","model":"claude-sonnet-5","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-subagent-cache-test", Cloak: &config.CloakConfig{}, }}, } auth := &cliproxyauth.Auth{ ID: "auth-subagent-cache-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-subagent-cache-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg)
// 1. Subagent request: carries X-Claude-Code-Agent-Id header subagentPayload := []byte(`{"model":"claude-sonnet-5","messages":[{"role":"user","content":"do task"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: subagentPayload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, Headers: http.Header{ "X-Claude-Code-Agent-Id": {"subagent-123"}, }, }) if err != nil { t.Fatalf("Execute(subagent) error = %v", err) } if strings.Contains(seenHeaders.Get("Anthropic-Beta"), "extended-cache-ttl-2025-04-11") { t.Fatalf("subagent must not carry extended-cache-ttl beta, got: %s", seenHeaders.Get("Anthropic-Beta")) } for _, blk := range gjson.GetBytes(seenBody, "system").Array() { if blk.Get("cache_control.ttl").String() == "1h" { t.Fatalf("subagent system block must not carry ttl: 1h, got: %s", blk.Raw) } }
// 2. Probe request: max_tokens: 1 probePayload := []byte(`{"model":"claude-sonnet-5","max_tokens":1,"messages":[{"role":"user","content":"probe"}]}`) _, err = executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: probePayload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, }) if err != nil { t.Fatalf("Execute(probe) error = %v", err) } if strings.Contains(seenHeaders.Get("Anthropic-Beta"), "extended-cache-ttl-2025-04-11") { t.Fatalf("probe must not carry extended-cache-ttl beta, got: %s", seenHeaders.Get("Anthropic-Beta")) } for _, blk := range gjson.GetBytes(seenBody, "system").Array() { if blk.Get("cache_control.ttl").String() == "1h" { t.Fatalf("probe system block must not carry ttl: 1h, got: %s", blk.Raw) } }
// 3. Normal interactive main-thread request: MUST carry 1h cache and beta mainPayload := []byte(`{"model":"claude-sonnet-5","messages":[{"role":"user","content":"hello"}]}`) _, err = executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: mainPayload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, }) if err != nil { t.Fatalf("Execute(main) error = %v", err) } if !strings.Contains(seenHeaders.Get("Anthropic-Beta"), "extended-cache-ttl-2025-04-11") { t.Fatalf("main thread request must carry extended-cache-ttl beta, got: %s", seenHeaders.Get("Anthropic-Beta")) } has1h := false for _, blk := range gjson.GetBytes(seenBody, "system").Array() { if blk.Get("cache_control.ttl").String() == "1h" { has1h = true break } } if !has1h { t.Fatalf("main thread request system block must carry ttl: 1h, got: %s", gjson.GetBytes(seenBody, "system").Raw) }
// 4. Confirmed native Claude Code subagent: must NOT have extended-cache-ttl restored confirmedSubagentPayload := []byte(`{"model":"claude-sonnet-5","messages":[{"role":"user","content":"task"}]}`) _, err = executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: confirmedSubagentPayload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, Headers: http.Header{ "User-Agent": {"claude-cli/2.1.258 (external, cli)"}, "X-Claude-Code-Agent-Id": {"subagent-confirmed-456"}, "Anthropic-Beta": {"claude-code-20250219,oauth-2025-04-20,effort-2025-11-24"}, }, }) if err != nil { t.Fatalf("Execute(confirmed subagent) error = %v", err) } if strings.Contains(seenHeaders.Get("Anthropic-Beta"), "extended-cache-ttl-2025-04-11") { t.Fatalf("confirmed subagent must not carry extended-cache-ttl beta, got: %s", seenHeaders.Get("Anthropic-Beta")) }}
func TestClaudeExecutor_PayloadOverrideFableModelReconciled(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-sonnet-5","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-payload-fable-test", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-fable-5-1"}}, Params: map[string]any{ "model": "claude-sonnet-5", }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-payload-fable-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-payload-fable-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-fable-5-1","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-fable-5-1", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Model was rewritten to claude-sonnet-5 if got := gjson.GetBytes(seenBody, "model").String(); got != "claude-sonnet-5" { t.Fatalf("model = %q, want claude-sonnet-5", got) }
// Because model is now claude-sonnet-5, Fable additions must NOT be present: if gjson.GetBytes(seenBody, "fallbacks").Exists() { t.Fatalf("fallbacks must be omitted when rewritten to non-Fable, got: %s", gjson.GetBytes(seenBody, "fallbacks").Raw) } if strings.Contains(seenHeaders.Get("Anthropic-Beta"), "server-side-fallback") { t.Fatalf("server-side-fallback beta must be omitted when rewritten to non-Fable, got: %s", seenHeaders.Get("Anthropic-Beta")) } for _, blk := range gjson.GetBytes(seenBody, "system").Array() { if strings.Contains(blk.Get("text").String(), "Reporting outcomes") { t.Fatalf("system must not contain Reporting outcomes when rewritten to non-Fable, got: %s", blk.Raw) } }}
func TestClaudeExecutor_PayloadOverrideNonFableToFableReconciled(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-fable-5-1","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-payload-fable-test-2", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-sonnet-5"}}, Params: map[string]any{ "model": "claude-fable-5-1", }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-payload-fable-test-2", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-payload-fable-test-2", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-sonnet-5","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Model was rewritten to claude-fable-5-1 if got := gjson.GetBytes(seenBody, "model").String(); got != "claude-fable-5-1" { t.Fatalf("model = %q, want claude-fable-5-1", got) }
// Fable additions must now be attached: fallbacks := gjson.GetBytes(seenBody, "fallbacks").Array() if len(fallbacks) != 1 || fallbacks[0].Get("model").String() != "claude-opus-5" { t.Fatalf("fallbacks must be injected for Fable 5.1, got: %s", gjson.GetBytes(seenBody, "fallbacks").Raw) } if !strings.Contains(seenHeaders.Get("Anthropic-Beta"), "server-side-fallback") { t.Fatalf("server-side-fallback beta must be present, got: %s", seenHeaders.Get("Anthropic-Beta")) } hasReporting := false for _, blk := range gjson.GetBytes(seenBody, "system").Array() { if strings.Contains(blk.Get("text").String(), "Reporting outcomes") { hasReporting = true break } } if !hasReporting { t.Fatalf("system must contain Reporting outcomes for Fable 5.1, got: %s", gjson.GetBytes(seenBody, "system").Raw) }}
func TestClaudeExecutor_PayloadOverridePreservesExplicitFallbacks(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-sonnet-5","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-payload-fable-test-3", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-fable-5-1"}}, Params: map[string]any{ "model": "claude-sonnet-5", "fallbacks": []any{map[string]any{"model": "claude-opus-5"}}, }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-payload-fable-test-3", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-payload-fable-test-3", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-fable-5-1","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-fable-5-1", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Explicit payload fallback override must be preserved! fallbacks := gjson.GetBytes(seenBody, "fallbacks").Array() if len(fallbacks) != 1 || fallbacks[0].Get("model").String() != "claude-opus-5" { t.Fatalf("explicit payload fallback override must be preserved, got: %s", gjson.GetBytes(seenBody, "fallbacks").Raw) } if !strings.Contains(seenHeaders.Get("Anthropic-Beta"), "server-side-fallback") { t.Fatalf("server-side-fallback beta must be present for explicit fallback, got: %s", seenHeaders.Get("Anthropic-Beta")) }}
func TestClaudeExecutor_PayloadOverrideUnrelatedModelRuleDoesNotPreserveFableFallbacks(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-sonnet-5","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-payload-fable-test-4", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{ // Rule 1: Unrelated rule for gpt-4 has fallbacks { Models: []config.PayloadModelRule{{Name: "gpt-4"}}, Params: map[string]any{ "fallbacks": []any{map[string]any{"model": "claude-opus-5"}}, }, }, // Rule 2: Rewrites Fable 5.1 to Sonnet 5 WITHOUT fallbacks { Models: []config.PayloadModelRule{{Name: "claude-fable-5-1"}}, Params: map[string]any{ "model": "claude-sonnet-5", }, }, }, }, } auth := &cliproxyauth.Auth{ ID: "auth-payload-fable-test-4", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-payload-fable-test-4", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-fable-5-1","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-fable-5-1", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Unrelated rule must NOT preserve fallback on Sonnet 5 if gjson.GetBytes(seenBody, "fallbacks").Exists() { t.Fatalf("unrelated rule for gpt-4 must not cause fallbacks to be preserved on sonnet-5, got: %s", gjson.GetBytes(seenBody, "fallbacks").Raw) } if strings.Contains(seenHeaders.Get("Anthropic-Beta"), "server-side-fallback") { t.Fatalf("server-side-fallback beta must be omitted, got: %s", seenHeaders.Get("Anthropic-Beta")) }}
func TestClaudeExecutor_PayloadOverrideMaxTokensTo1ReclassifiesAsProbe(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_probe1","type":"message","model":"claude-sonnet-5","role":"assistant","content":[{"type":"text","text":"."}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-payload-probe-test", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-sonnet-5"}}, Params: map[string]any{ "max_tokens": 1, }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-payload-probe-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-payload-probe-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-sonnet-5","max_tokens":1000,"messages":[{"role":"user","content":"."}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Payload rule made it max_tokens: 1 if got := gjson.GetBytes(seenBody, "max_tokens").Int(); got != 1 { t.Fatalf("max_tokens = %d, want 1", got) }
// Probe must NOT carry 1h cache control and must NOT carry extended-cache-ttl beta if strings.Contains(seenHeaders.Get("Anthropic-Beta"), "extended-cache-ttl-2025-04-11") { t.Fatalf("reclassified probe must not carry extended-cache-ttl beta, got: %s", seenHeaders.Get("Anthropic-Beta")) } for _, blk := range gjson.GetBytes(seenBody, "system").Array() { if blk.Get("cache_control.ttl").String() == "1h" { t.Fatalf("reclassified probe system block must not carry ttl: 1h, got: %s", blk.Raw) } }
// Probe must NOT carry diagnostics if gjson.GetBytes(seenBody, "diagnostics").Exists() { t.Fatalf("reclassified probe must omit diagnostics, got: %s", gjson.GetBytes(seenBody, "diagnostics").Raw) }
// Probe must NOT carry cc_prev_req or cc_prompt_id in billing header billingText := gjson.GetBytes(seenBody, "system.0.text").String() if strings.Contains(billingText, "cc_prev_req=") { t.Fatalf("reclassified probe must omit cc_prev_req, got: %s", billingText) } if strings.Contains(billingText, "cc_prompt_id=") { t.Fatalf("reclassified probe must omit cc_prompt_id, got: %s", billingText) }}
func TestClaudeExecutor_PayloadOverrideFableToProbeStripsFableAdditions(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-fable-5-1","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-payload-fable-probe-strip-test", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-fable-5-1"}}, Params: map[string]any{ "max_tokens": 1, }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-payload-fable-probe-strip-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-payload-fable-probe-strip-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) // Initially non-probe (max_tokens: 1000, content: ".") payload := []byte(`{"model":"claude-fable-5-1","thinking":{"type":"adaptive"},"max_tokens":1000,"messages":[{"role":"user","content":"."}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-fable-5-1", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Because payload rule reclassified request as probe (max_tokens: 1): // 1. fallbacks must be stripped if gjson.GetBytes(seenBody, "fallbacks").Exists() { t.Fatalf("probe must not carry fallbacks, got: %s", gjson.GetBytes(seenBody, "fallbacks").Raw) } // 2. thinking.display must be stripped if gjson.GetBytes(seenBody, "thinking.display").Exists() { t.Fatalf("probe must not carry thinking.display, got: %s", gjson.GetBytes(seenBody, "thinking.display").Raw) } // 3. Reporting outcomes block must be stripped for _, blk := range gjson.GetBytes(seenBody, "system").Array() { if strings.Contains(blk.Get("text").String(), "Reporting outcomes") { t.Fatalf("probe must not carry Reporting outcomes block, got: %s", blk.Raw) } } // 4. Beta headers must omit server-side-fallback, thinking-display-updates, and extended-cache-ttl betas := seenHeaders.Get("Anthropic-Beta") if strings.Contains(betas, "server-side-fallback") { t.Fatalf("probe must omit server-side-fallback beta, got: %s", betas) } if strings.Contains(betas, "thinking-display-updates") { t.Fatalf("probe must omit thinking-display-updates beta, got: %s", betas) } if strings.Contains(betas, "extended-cache-ttl") { t.Fatalf("probe must omit extended-cache-ttl beta, got: %s", betas) }}
func TestClaudeExecutor_PayloadOverrideProbeToNormalReinitializes(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-fable-5-1","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-payload-declassify-probe-test", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-fable-5-1"}}, Params: map[string]any{ "max_tokens": 1000, }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-payload-declassify-probe-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-payload-declassify-probe-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) // Initially a probe (max_tokens: 1, content: ".") payload := []byte(`{"model":"claude-fable-5-1","thinking":{"type":"adaptive"},"max_tokens":1,"messages":[{"role":"user","content":"."}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-fable-5-1", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Declassified probe is now a normal request: // 1. Must carry 1h cache TTL and extended-cache-ttl beta has1h := false for _, blk := range gjson.GetBytes(seenBody, "system").Array() { if blk.Get("cache_control.ttl").String() == "1h" { has1h = true break } } if !has1h { t.Fatalf("declassified normal request must carry 1h cache, got: %s", gjson.GetBytes(seenBody, "system").Raw) } betas := seenHeaders.Get("Anthropic-Beta") if !strings.Contains(betas, "extended-cache-ttl-2025-04-11") { t.Fatalf("declassified normal request must carry extended-cache-ttl beta, got: %s", betas) } // 2. Must carry Fable additions (fallbacks, display, reporting block) if !gjson.GetBytes(seenBody, "fallbacks").Exists() { t.Fatalf("declassified Fable request must carry fallbacks") }
// 3. Must carry cc_prompt_id in billing header billingText := gjson.GetBytes(seenBody, "system.0.text").String() if !strings.Contains(billingText, "cc_prompt_id=") { t.Fatalf("declassified normal request must carry cc_prompt_id, got: %s", billingText) }}
func TestClaudeExecutor_CallerOwnedDiagnosticsPreservedOnProbe(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-haiku-4-5-20251001","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-api-caller-diagnostics-test", Cloak: &config.CloakConfig{Mode: "never"}, }}, } auth := &cliproxyauth.Auth{ ID: "auth-caller-diagnostics-test", Attributes: map[string]string{ "api_key": "sk-ant-api-caller-diagnostics-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) // Caller sends max_tokens: 1 probe with their own explicit diagnostics object payload := []byte(`{"model":"claude-haiku-4-5-20251001","max_tokens":1,"diagnostics":{"caller_custom_key":"val123"},"messages":[{"role":"user","content":"quota"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-haiku-4-5-20251001", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Caller-owned diagnostics must be preserved! if got := gjson.GetBytes(seenBody, "diagnostics.caller_custom_key").String(); got != "val123" { t.Fatalf("caller diagnostics must be preserved, got: %s", gjson.GetBytes(seenBody, "diagnostics").Raw) }}
func TestClaudeExecutor_PayloadOverrideParentThinkingPreventsDisplayUpdates(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-fable-5-1","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-payload-parent-thinking-test", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-fable-5-1"}}, Params: map[string]any{ "thinking": map[string]any{ "type": "adaptive", }, }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-payload-parent-thinking-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-payload-parent-thinking-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-fable-5-1","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-fable-5-1", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Payload rule replaced parent "thinking" without "display", so "display" must NOT be re-added! if gjson.GetBytes(seenBody, "thinking.display").Exists() { t.Fatalf("thinking.display must not be injected when parent thinking was overridden, got: %s", gjson.GetBytes(seenBody, "thinking").Raw) }}
func TestClaudeExecutor_PayloadSystemTTLOverrideStillRemovesInjectedFableReportingBlock(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-sonnet-5","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-payload-system-ttl-fable-test", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-fable-5-1"}}, Params: map[string]any{ "model": "claude-sonnet-5", "system.0.cache_control.ttl": "1h", }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-payload-system-ttl-fable-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-payload-system-ttl-fable-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-fable-5-1","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-fable-5-1", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Model was rewritten from Fable 5.1 to Sonnet 5, so injected Reporting outcomes block // MUST be removed even though payload rule touched system.0.cache_control.ttl! for _, blk := range gjson.GetBytes(seenBody, "system").Array() { if strings.Contains(blk.Get("text").String(), "Reporting outcomes") { t.Fatalf("Reporting outcomes block must be removed on rewritten Sonnet model, got: %s", blk.Raw) } }}
func TestClaudeExecutor_PayloadSonnetToFableWithSystemTTLEditsAddsReportingBlock(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-fable-5-1","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-payload-sonnet-to-fable-test", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-sonnet-5"}}, Params: map[string]any{ "model": "claude-fable-5-1", "system.1.cache_control.ttl": "1h", }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-payload-sonnet-to-fable-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-payload-sonnet-to-fable-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-sonnet-5","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Model was rewritten from Sonnet 5 to Fable 5.1, so Reporting outcomes block // MUST be added even though payload rule touched system.1.cache_control.ttl! hasReporting := false for _, blk := range gjson.GetBytes(seenBody, "system").Array() { if strings.Contains(blk.Get("text").String(), "Reporting outcomes") { hasReporting = true break } } if !hasReporting { t.Fatalf("Reporting outcomes block must be attached on rewritten Fable model, got: %s", gjson.GetBytes(seenBody, "system").Raw) }}
func TestClaudeExecutor_PayloadOverrideProbeWithExplicitDiagnosticsPreserved(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-haiku-4-5-20251001","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-probe-explicit-diag-test", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-haiku-4-5-20251001"}}, Params: map[string]any{ "max_tokens": 1, "diagnostics": map[string]any{ "operator_custom": "custom_value_123", }, }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-probe-explicit-diag-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-probe-explicit-diag-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) // Initially non-probe so CPA injects diagnostics, then payload rule overrides to probe AND sets custom diagnostics payload := []byte(`{"model":"claude-haiku-4-5-20251001","max_tokens":1000,"messages":[{"role":"user","content":"quota"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-haiku-4-5-20251001", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// The operator-provided diagnostics object must be preserved! if got := gjson.GetBytes(seenBody, "diagnostics.operator_custom").String(); got != "custom_value_123" { t.Fatalf("operator custom diagnostics must be preserved, got: %s", gjson.GetBytes(seenBody, "diagnostics").Raw) }}
func TestClaudeExecutor_PayloadStringSystemFableAddsReportingBlock(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-fable-5-1","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-string-system-fable-test", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-sonnet-5"}}, Params: map[string]any{ "model": "claude-fable-5-1", "system": "You are a helpful coding assistant.", }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-string-system-fable-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-string-system-fable-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-sonnet-5","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Payload rule set string system and rewrote to Fable 5.1: // System must become an array containing the reporting outcomes block! hasReporting := false for _, blk := range gjson.GetBytes(seenBody, "system").Array() { if strings.Contains(blk.Get("text").String(), "Reporting outcomes") { hasReporting = true break } } if !hasReporting { t.Fatalf("Reporting outcomes block must be attached for string system Fable request, got: %s", gjson.GetBytes(seenBody, "system").Raw) }}
func TestClaudeExecutor_PayloadStringSystemMentioningReportingOutcomesStillInjectsFableReportingBlock(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-fable-5-1","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-string-system-mention-test", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-sonnet-5"}}, Params: map[string]any{ "model": "claude-fable-5-1", "system": "Please follow best practices when reporting outcomes to the user.", }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-string-system-mention-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-string-system-mention-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-sonnet-5","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Payload rule had a system string that merely mentioned "reporting outcomes". // The exact `# Reporting outcomes` block MUST be injected! hasExactReporting := false for _, blk := range gjson.GetBytes(seenBody, "system").Array() { if blk.Get("text").String() == claudeCodeFableReportingOutcomes { hasExactReporting = true break } } if !hasExactReporting { t.Fatalf("exact `# Reporting outcomes` block must be injected even when string mentions reporting outcomes, got: %s", gjson.GetBytes(seenBody, "system").Raw) }}
func TestClaudeExecutor_PayloadStringSystemWithExactReportingPromptDoesNotDuplicate(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-fable-5-1","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-string-system-exact-test", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-sonnet-5"}}, Params: map[string]any{ "model": "claude-fable-5-1", "system": claudeCodeFableReportingOutcomes, }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-string-system-exact-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-string-system-exact-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-sonnet-5","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
reportingCount := 0 for _, blk := range gjson.GetBytes(seenBody, "system").Array() { if blk.Get("text").String() == claudeCodeFableReportingOutcomes { reportingCount++ } } if reportingCount != 1 { t.Fatalf("expected exactly 1 reporting block, got %d in: %s", reportingCount, gjson.GetBytes(seenBody, "system").Raw) }}
func TestClaudeExecutor_PayloadFableThinkingAdaptiveToDisabledDropsInjectedDisplay(t *testing.T) { var seenHeaders http.Header var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-fable-5-1","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-fable-disabled-thinking-test", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-fable-5-1"}}, Params: map[string]any{ "thinking.type": "disabled", }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-fable-disabled-thinking-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-fable-disabled-thinking-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) // Starts with adaptive thinking so CPA cloaking injects thinking.display=updates, // then payload rule overrides thinking.type to disabled: payload := []byte(`{"model":"claude-fable-5-1","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-fable-5-1", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Injected thinking.display must be dropped if gjson.GetBytes(seenBody, "thinking.display").Exists() { t.Fatalf("thinking.display must be dropped when thinking.type is disabled, got: %s", gjson.GetBytes(seenBody, "thinking").Raw) } // thinking-display-updates beta header must NOT be present betas := seenHeaders.Get("anthropic-beta") if strings.Contains(betas, "thinking-display-updates") { t.Fatalf("thinking-display-updates beta header must NOT be present on disabled thinking, got: %s", betas) }}
func TestClaudeExecutor_UncloakedProbePreservesCallerBillingTags(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-haiku-4-5-20251001","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-api03-uncloaked-test", // No CloakConfig, uncloaked request }}, } auth := &cliproxyauth.Auth{ ID: "auth-uncloaked-probe-test", Attributes: map[string]string{ "api_key": "sk-ant-api03-uncloaked-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) // Caller provides their own billing header with prompt ID on probe callerBilling := "x-anthropic-billing-header: cc_version=2.1.258; cc_entrypoint=cli; cch=abc12; cc_prompt_id=00000000-0000-4000-8000-000000000001;" payload := []byte(fmt.Sprintf(`{"model":"claude-haiku-4-5-20251001","max_tokens":1,"system":[{"type":"text","text":%q}],"messages":[{"role":"user","content":"quota"}]}`, callerBilling))
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-haiku-4-5-20251001", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Because cloaking was disabled, the caller-owned billing header must be preserved exactly! gotSystem := gjson.GetBytes(seenBody, "system.0.text").String() if !strings.Contains(gotSystem, "cc_prompt_id=00000000-0000-4000-8000-000000000001") { t.Fatalf("uncloaked request must preserve caller billing tags on probe, got: %s", gotSystem) }}
func TestClaudeExecutor_FableWithSensitiveWordsHasSingleObfuscatedReportingBlock(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-fable-5-1","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-fable-sensitive-test", Cloak: &config.CloakConfig{ SensitiveWords: []string{"Reporting"}, }, }}, } auth := &cliproxyauth.Auth{ ID: "auth-fable-sensitive-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-fable-sensitive-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-fable-5-1","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-fable-5-1", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
reportingCount := 0 for _, blk := range gjson.GetBytes(seenBody, "system").Array() { raw := blk.Get("text").String() cleaned := strings.ReplaceAll(raw, "\u200B", "") if cleaned == claudeCodeFableReportingOutcomes { reportingCount++ if !strings.Contains(raw, "\u200B") { t.Fatalf("Reporting block must be obfuscated with zero-width space, got: %q", raw) } if strings.Contains(raw, "Reporting") { t.Fatalf("Reporting block must not contain cleartext sensitive word 'Reporting', got: %q", raw) } } } if reportingCount != 1 { t.Fatalf("expected exactly 1 reporting block, got %d; system = %s", reportingCount, gjson.GetBytes(seenBody, "system").Raw) }}
func TestClaudeExecutor_PayloadSonnetToFableWithSensitiveWordsObfuscatesInjectedReportingBlock(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-fable-5-1","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-sonnet-to-fable-sensitive-test", Cloak: &config.CloakConfig{ SensitiveWords: []string{"Reporting"}, }, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-sonnet-5"}}, Params: map[string]any{ "model": "claude-fable-5-1", }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-sonnet-to-fable-sensitive-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-sonnet-to-fable-sensitive-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-sonnet-5","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
reportingCount := 0 for _, blk := range gjson.GetBytes(seenBody, "system").Array() { raw := blk.Get("text").String() cleaned := strings.ReplaceAll(raw, "\u200B", "") if cleaned == claudeCodeFableReportingOutcomes { reportingCount++ if !strings.Contains(raw, "\u200B") { t.Fatalf("Reporting block must be obfuscated with zero-width space, got: %q", raw) } if strings.Contains(raw, "Reporting") { t.Fatalf("Reporting block must not contain cleartext sensitive word 'Reporting', got: %q", raw) } } } if reportingCount != 1 { t.Fatalf("expected exactly 1 reporting block, got %d; system = %s", reportingCount, gjson.GetBytes(seenBody, "system").Raw) }}
func TestClaudeExecutor_PayloadFableToSonnetWithSensitiveWordsRemovesReportingBlock(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-sonnet-5","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-fable-to-sonnet-sensitive-test", Cloak: &config.CloakConfig{ SensitiveWords: []string{"Reporting"}, }, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-fable-5-1"}}, Params: map[string]any{ "model": "claude-sonnet-5", }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-fable-to-sonnet-sensitive-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-fable-to-sonnet-sensitive-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-fable-5-1","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-fable-5-1", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
for _, blk := range gjson.GetBytes(seenBody, "system").Array() { raw := blk.Get("text").String() cleaned := strings.ReplaceAll(raw, "\u200B", "") if cleaned == claudeCodeFableReportingOutcomes { t.Fatalf("reporting block should be removed when rewritten to Sonnet 5, got: %s", raw) } }}
func TestClaudeExecutor_SensitiveWordsDoNotCorruptBillingHeaderTags(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-fable-5-1","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-billing-corrupt-test", Cloak: &config.CloakConfig{ SensitiveWords: []string{"cli", "version", "entrypoint", "prompt", "anthropic"}, }, }}, } auth := &cliproxyauth.Auth{ ID: "auth-billing-corrupt-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-billing-corrupt-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-fable-5-1","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-fable-5-1", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// system[0] billing header must NOT contain zero-width spaces in its tags billingText := gjson.GetBytes(seenBody, "system.0.text").String() if !strings.HasPrefix(billingText, "x-anthropic-billing-header: cc_version=") { t.Fatalf("billing header must start cleanly without obfuscation, got: %q", billingText) } if strings.Contains(billingText, "\u200B") { t.Fatalf("billing header must not contain zero-width space characters, got: %q", billingText) } if !strings.Contains(billingText, "cc_entrypoint=cli;") { t.Fatalf("billing header must preserve cc_entrypoint=cli;, got: %q", billingText) }}
func TestClaudeExecutor_DisabledCloakingSkipsSensitiveWordObfuscation(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-sonnet-5","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ DisableClaudeCloakMode: true, ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-skip-obfuscate-test", Cloak: &config.CloakConfig{ SensitiveWords: []string{"confidential", "secret"}, }, }}, } auth := &cliproxyauth.Auth{ ID: "auth-skip-obfuscate-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-skip-obfuscate-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-sonnet-5","system":[{"type":"text","text":"this is confidential"}],"messages":[{"role":"user","content":"keep this secret"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
rawBody := string(seenBody) if strings.Contains(rawBody, "\u200B") { t.Fatalf("disabled cloaking must not insert zero-width spaces into Execute body, got: %s", rawBody) } if !strings.Contains(rawBody, "confidential") || !strings.Contains(rawBody, "secret") { t.Fatalf("expected cleartext preserved in Execute, got: %s", rawBody) }}
func TestClaudeExecutor_DisabledCloakingStreamSkipsSensitiveWordObfuscation(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "text/event-stream") _, _ = w.Write([]byte("event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_1\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-sonnet-5\",\"content\":[]}}\n\n")) _, _ = w.Write([]byte("event: message_stop\ndata: {\"type\":\"message_stop\"}\n\n")) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-skip-obfuscate-stream-test", Cloak: &config.CloakConfig{ Mode: "never", SensitiveWords: []string{"confidential", "secret"}, }, }}, } auth := &cliproxyauth.Auth{ ID: "auth-skip-obfuscate-stream-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-skip-obfuscate-stream-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-sonnet-5","stream":true,"system":[{"type":"text","text":"this is confidential"}],"messages":[{"role":"user","content":"keep this secret"}]}`) streamResult, err := executor.ExecuteStream(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("ExecuteStream error = %v", err) } for range streamResult.Chunks { }
rawBody := string(seenBody) if strings.Contains(rawBody, "\u200B") { t.Fatalf("disabled cloaking must not insert zero-width spaces into ExecuteStream body, got: %s", rawBody) } if !strings.Contains(rawBody, "confidential") || !strings.Contains(rawBody, "secret") { t.Fatalf("expected cleartext preserved in ExecuteStream, got: %s", rawBody) }}
func TestClaudeExecutor_PayloadReplacesSystemOnOriginalFableReaddsReportingBlock(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-fable-5-1","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-fable-replace-sys-test", }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-fable-5-1"}}, Params: map[string]any{ "system": "Custom replaced system prompt", }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-fable-replace-sys-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-fable-replace-sys-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-fable-5-1","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-fable-5-1", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
hasReplacedSystem := false hasReporting := false for _, blk := range gjson.GetBytes(seenBody, "system").Array() { text := blk.Get("text").String() if text == "Custom replaced system prompt" { hasReplacedSystem = true } if text == claudeCodeFableReportingOutcomes { hasReporting = true } } if !hasReplacedSystem { t.Fatalf("expected custom replaced system prompt in system, got: %s", gjson.GetBytes(seenBody, "system").Raw) } if !hasReporting { t.Fatalf("expected Fable reporting outcomes block re-added in system, got: %s", gjson.GetBytes(seenBody, "system").Raw) }}
func TestClaudeExecutor_UserTitlePromptWithoutSchemaTreatedAsNormalTurn(t *testing.T) { var seenHeaders http.Header var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-sonnet-5","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-user-title-prompt-test", Cloak: &config.CloakConfig{}, }}, } auth := &cliproxyauth.Auth{ ID: "auth-user-title-prompt-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-user-title-prompt-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) // Normal user query with text "Return a short title for this blog post", but NO structured output schema payload := []byte(`{"model":"claude-sonnet-5","messages":[{"role":"user","content":"Return a short title for this blog post"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Must NOT be treated as a title helper: // 1. Must carry 1h cache TTL and extended-cache-ttl beta has1h := false for _, blk := range gjson.GetBytes(seenBody, "system").Array() { if blk.Get("cache_control.ttl").String() == "1h" { has1h = true break } } if !has1h { t.Fatalf("user title query must carry 1h cache, got: %s", gjson.GetBytes(seenBody, "system").Raw) } if !strings.Contains(seenHeaders.Get("Anthropic-Beta"), "extended-cache-ttl-2025-04-11") { t.Fatalf("user title query must carry extended-cache-ttl beta, got: %s", seenHeaders.Get("Anthropic-Beta")) } // 2. Billing header must carry cc_prompt_id billingText := gjson.GetBytes(seenBody, "system.0.text").String() if !strings.Contains(billingText, "cc_prompt_id=") { t.Fatalf("user title query must carry cc_prompt_id, got: %s", billingText) }}
func TestClaudeExecutor_PayloadOverrideRawPreservesExplicitFallbacks(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-sonnet-5","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-payload-fable-test-5", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ OverrideRaw: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-fable-5-1"}}, Params: map[string]any{ "model": `"claude-sonnet-5"`, "fallbacks": `[{"model":"claude-opus-5"}]`, }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-payload-fable-test-5", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-payload-fable-test-5", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-fable-5-1","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-fable-5-1", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// Raw payload override setting fallbacks must be preserved! fallbacks := gjson.GetBytes(seenBody, "fallbacks").Array() if len(fallbacks) != 1 || fallbacks[0].Get("model").String() != "claude-opus-5" { t.Fatalf("explicit raw payload fallback override must be preserved, got: %s", gjson.GetBytes(seenBody, "fallbacks").Raw) } if !strings.Contains(seenHeaders.Get("Anthropic-Beta"), "server-side-fallback") { t.Fatalf("server-side-fallback beta must be present for explicit raw fallback, got: %s", seenHeaders.Get("Anthropic-Beta")) }}
func TestClaudeExecutor_PayloadFilterFallbacksPreservesRemovalOnFable(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-fable-5-1","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-payload-fable-filter-test", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Filter: []config.PayloadFilterRule{{ Models: []config.PayloadModelRule{{Name: "claude-fable-5-1"}}, Params: []string{"fallbacks"}, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-payload-fable-filter-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-payload-fable-filter-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-fable-5-1","thinking":{"type":"adaptive"},"messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-fable-5-1", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
// fallbacks was filtered out by operator rule, must NOT be recreated! if gjson.GetBytes(seenBody, "fallbacks").Exists() { t.Fatalf("fallbacks must remain deleted after payload filter, got: %s", gjson.GetBytes(seenBody, "fallbacks").Raw) } if strings.Contains(seenHeaders.Get("Anthropic-Beta"), "server-side-fallback") { t.Fatalf("server-side-fallback beta must be absent when fallbacks is filtered, got: %s", seenHeaders.Get("Anthropic-Beta")) }}
func TestClaudeExecutor_PayloadCustomReportingOutcomesPreservedOnRewrite(t *testing.T) { var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-sonnet-5","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-payload-fable-custom-reporting-test", Cloak: &config.CloakConfig{}, }}, Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: []config.PayloadModelRule{{Name: "claude-fable-5-1"}}, Params: map[string]any{ "model": "claude-sonnet-5", "system": []map[string]any{ {"type": "text", "text": "Custom user prompt containing Reporting outcomes heading in discussion."}, }, }, }}, }, } auth := &cliproxyauth.Auth{ ID: "auth-payload-fable-custom-reporting-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-payload-fable-custom-reporting-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{"model":"claude-fable-5-1","messages":[{"role":"user","content":"test"}]}`) _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-fable-5-1", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if err != nil { t.Fatalf("Execute error = %v", err) }
system := gjson.GetBytes(seenBody, "system").Array() hasCustom := false for _, blk := range system { if strings.Contains(blk.Get("text").String(), "Custom user prompt") { hasCustom = true } } if !hasCustom { t.Fatalf("custom user system prompt must NOT be deleted, got: %s", gjson.GetBytes(seenBody, "system").Raw) }}
func TestNormalizeClaudeSamplingForUpstream_RemovesTemperature(t *testing.T) { payload := []byte(`{"temperature":0,"thinking":{"type":"adaptive"},"output_config":{"effort":"max"}}`) out := normalizeClaudeSamplingForUpstream(payload, false)
if gjson.GetBytes(out, "temperature").Exists() { t.Fatalf("temperature should be removed") }}
func TestNormalizeClaudeSamplingForUpstream_RemovesTemperatureWithThinkingEnabled(t *testing.T) { payload := []byte(`{"temperature":0.2,"thinking":{"type":"enabled","budget_tokens":2048}}`) out := normalizeClaudeSamplingForUpstream(payload, false)
if gjson.GetBytes(out, "temperature").Exists() { t.Fatalf("temperature should be removed") }}
func TestNormalizeClaudeSamplingForUpstream_RemovesTopPAndTopKForThinking(t *testing.T) { payload := []byte(`{"temperature":0.2,"top_p":0.9,"top_k":40,"thinking":{"type":"adaptive"}}`) out := normalizeClaudeSamplingForUpstream(payload, false)
if gjson.GetBytes(out, "temperature").Exists() { t.Fatalf("temperature should be removed") } if gjson.GetBytes(out, "top_p").Exists() { t.Fatalf("top_p should be removed when thinking is active") } if gjson.GetBytes(out, "top_k").Exists() { t.Fatalf("top_k should be removed when thinking is active") }}
func TestNormalizeClaudeSamplingForUpstream_NoThinkingRemovesTemperatureAndTopP(t *testing.T) { payload := []byte(`{"temperature":0,"top_p":0.9,"top_k":40,"messages":[{"role":"user","content":"hi"}]}`) out := normalizeClaudeSamplingForUpstream(payload, false)
if gjson.GetBytes(out, "temperature").Exists() { t.Fatalf("temperature should be removed") } if gjson.GetBytes(out, "top_p").Exists() { t.Fatalf("top_p should be removed") } if got := gjson.GetBytes(out, "top_k").Int(); got != 40 { t.Fatalf("top_k = %v, want 40", got) }}
func TestNormalizeClaudeSamplingForUpstream_AfterForcedToolChoiceRemovesTemperature(t *testing.T) { payload := []byte(`{"temperature":0,"thinking":{"type":"adaptive"},"output_config":{"effort":"max"},"tool_choice":{"type":"any"}}`) out := disableThinkingIfToolChoiceForced(payload) out = normalizeClaudeSamplingForUpstream(out, false)
if gjson.GetBytes(out, "thinking").Exists() { t.Fatalf("thinking should be removed when tool_choice forces tool use") } if gjson.GetBytes(out, "temperature").Exists() { t.Fatalf("temperature should be removed") }}
// The measured structured Haiku helper sends "temperature":1, and// claudeCodeHelperShapeStructured keys on exactly that value. Stripping it would// make CPA emit a shape no native client produces, so a confirmed native caller// must keep it.func TestNormalizeClaudeSamplingForUpstreamNativeKeepsMeasuredHelperTemperature(t *testing.T) { // Top-level key order and values mirror the measured structured helper. payload := []byte(`{"model":"claude-haiku-4-5-20251001","messages":[{"role":"user","content":[{"type":"text","text":"helper probe"}]}],"system":[{"type":"text","text":"Return a short title."}],"tools":[],"metadata":{"user_id":"u"},"max_tokens":32000,"thinking":{"type":"disabled"},"temperature":1,"output_config":{"format":{"type":"json_schema"}},"stream":true}`) if got := gjson.GetBytes(payload, "temperature"); !got.Exists() || got.Num != 1 { t.Fatalf("measured helper fixture should carry temperature=1, got %q", got.Raw) }
out := normalizeClaudeSamplingForUpstream(payload, true)
if got := gjson.GetBytes(out, "temperature"); !got.Exists() || got.Num != 1 { t.Fatalf("confirmed native must preserve the measured temperature, got %q", got.Raw) }}
// Anthropic's real constraints, verified against the live API: with thinking// active temperature must be 1, top_p must be >= 0.95 and top_k must be unset;// otherwise temperature and top_p cannot both be specified. Preserving the// native wire must never forward a combination that would 400.func TestNormalizeClaudeSamplingForUpstreamNativeDropsOnlyRejectedCombinations(t *testing.T) { tests := []struct { name string payload string keep map[string]float64 dropped []string }{ { name: "thinking off keeps every accepted knob", payload: `{"temperature":0.5,"top_k":40}`, keep: map[string]float64{"temperature": 0.5, "top_k": 40}, }, { name: "thinking off drops top_p when temperature is also set", payload: `{"temperature":0.5,"top_p":0.9}`, keep: map[string]float64{"temperature": 0.5}, dropped: []string{"top_p"}, }, { name: "thinking off keeps a lone top_p", payload: `{"top_p":0.9}`, keep: map[string]float64{"top_p": 0.9}, }, { name: "thinking disabled is not thinking", payload: `{"temperature":1,"thinking":{"type":"disabled"}}`, keep: map[string]float64{"temperature": 1}, }, { name: "thinking enabled keeps temperature 1", payload: `{"temperature":1,"thinking":{"type":"enabled","budget_tokens":1024}}`, keep: map[string]float64{"temperature": 1}, }, { name: "thinking enabled drops temperature that is not 1", payload: `{"temperature":0.5,"thinking":{"type":"enabled","budget_tokens":1024}}`, dropped: []string{"temperature"}, }, { name: "thinking enabled keeps top_p at or above 0.95", payload: `{"top_p":0.99,"thinking":{"type":"enabled","budget_tokens":1024}}`, keep: map[string]float64{"top_p": 0.99}, }, { name: "thinking enabled drops top_p below 0.95", payload: `{"top_p":0.9,"thinking":{"type":"enabled","budget_tokens":1024}}`, dropped: []string{"top_p"}, }, { name: "thinking enabled always drops top_k", payload: `{"top_k":40,"thinking":{"type":"enabled","budget_tokens":1024}}`, dropped: []string{"top_k"}, }, }
for _, tc := range tests { t.Run(tc.name, func(t *testing.T) { out := normalizeClaudeSamplingForUpstream([]byte(tc.payload), true)
for field, want := range tc.keep { got := gjson.GetBytes(out, field) if !got.Exists() || got.Num != want { t.Fatalf("%s = %q, want %v preserved", field, got.Raw, want) } } for _, field := range tc.dropped { if got := gjson.GetBytes(out, field); got.Exists() { t.Fatalf("%s = %q, want dropped because Anthropic rejects it", field, got.Raw) } } }) }}
func TestRemapOAuthToolNames_AllClientNamesUseMCPAliases(t *testing.T) { for _, original := range []string{"Bash", "bash", "Glob", "glob"} { t.Run(original, func(t *testing.T) { body := []byte(`{"tools":[{"name":` + fmt.Sprintf("%q", original) + `,"description":"Run a client tool","input_schema":{"type":"object"}}]}`) out, reverseMap := remapOAuthToolNames(body) alias := gjson.GetBytes(out, "tools.0.name").String() if !helps.IsClaudeMCPToolName(alias) { t.Fatalf("tools.0.name = %q, want MCP alias", alias) } if reverseMap[alias] != original { t.Fatalf("reverseMap = %v, want %q -> %q", reverseMap, alias, original) } resp := []byte(`{"content":[{"type":"tool_use","id":"toolu_01","name":` + fmt.Sprintf("%q", alias) + `,"input":{}}]}`) reversed, errReverse := reverseRemapOAuthToolNames(resp, reverseMap) if errReverse != nil { t.Fatalf("reverseRemapOAuthToolNames() error = %v", errReverse) } if got := gjson.GetBytes(reversed, "content.0.name").String(); got != original { t.Fatalf("content.0.name = %q, want %q", got, original) } }) }}
func TestRemapOAuthToolNames_AllClientToolsAsMCP(t *testing.T) { body := []byte(`{ "tools":[ {"type":"web_search_20250305","name":"web_search","max_uses":2}, {"name":"bash","description":"client shell tool","input_schema":{"type":"object"}}, {"name":"Read","description":"client read tool","input_schema":{"type":"object"}}, {"name":"mcp__context7__query-docs","description":"existing MCP tool","input_schema":{"type":"object"}}, {"name":"search_web","description":"unknown one","input_schema":{"type":"object","properties":{"q":{"type":"string"}},"required":["q"]}}, {"name":"Search_Web","description":"case-distinct unknown","input_schema":{"type":"object"}}, {"name":"search_web","description":"repeated declaration","input_schema":{"type":"object"}} ], "tool_choice":{"type":"tool","name":"search_web"}, "messages":[ {"role":"assistant","content":[ {"type":"tool_use","id":"toolu_unknown","name":"search_web","input":{"q":"go"}}, {"type":"tool_reference","tool_name":"Search_Web"} ]}, {"role":"user","content":[ {"type":"tool_result","tool_use_id":"toolu_unknown","content":[{"type":"tool_reference","tool_name":"search_web"}]} ]} ] }`)
out, reverseMap := remapOAuthToolNamesWithOptions(body, claudeMCPAliasOptions{secret: "credential-secret"})
if got := gjson.GetBytes(out, "tools.0.name").String(); got != "web_search" { t.Fatalf("typed builtin = %q, want unchanged", got) } bashAlias := gjson.GetBytes(out, "tools.1.name").String() readAlias := gjson.GetBytes(out, "tools.2.name").String() if !helps.IsClaudeMCPToolName(bashAlias) || !helps.IsClaudeMCPToolName(readAlias) { t.Fatalf("former vetted names did not receive MCP aliases: bash=%q Read=%q", bashAlias, readAlias) } if got := gjson.GetBytes(out, "tools.1.description").String(); got != "client shell tool" { t.Fatalf("bash description = %q, want preserved", got) } if got := gjson.GetBytes(out, "tools.1.input_schema.type").String(); got != "object" { t.Fatalf("bash schema changed: %s", out) } if got := gjson.GetBytes(out, "tools.3.name").String(); got != "mcp__context7__query-docs" { t.Fatalf("existing MCP tool = %q, want unchanged", got) }
searchAlias := gjson.GetBytes(out, "tools.4.name").String() caseAlias := gjson.GetBytes(out, "tools.5.name").String() if !helps.IsClaudeMCPToolName(searchAlias) || !helps.IsClaudeMCPToolName(caseAlias) { t.Fatalf("generated aliases are invalid: %q, %q", searchAlias, caseAlias) } if searchAlias == caseAlias { t.Fatalf("case-distinct names share alias %q", searchAlias) } if got := gjson.GetBytes(out, "tools.6.name").String(); got != searchAlias { t.Fatalf("repeated declaration alias = %q, want %q", got, searchAlias) } if !strings.HasSuffix(searchAlias, "_search_web") || !strings.HasSuffix(caseAlias, "_Search_Web") { t.Fatalf("generated aliases lost semantic suffixes: %q, %q", searchAlias, caseAlias) } if len(searchAlias) > 64 || len(caseAlias) > 64 { t.Fatalf("generated aliases exceed 64 characters: %q, %q", searchAlias, caseAlias) } if got := gjson.GetBytes(out, "tools.4.description").String(); got != "unknown one" { t.Fatalf("description = %q, want preserved", got) } if got := gjson.GetBytes(out, "tools.4.input_schema.required.0").String(); got != "q" { t.Fatalf("input schema was not preserved: %s", out) } if got := gjson.GetBytes(out, "tool_choice.name").String(); got != searchAlias { t.Fatalf("tool_choice.name = %q, want %q", got, searchAlias) } if got := gjson.GetBytes(out, "messages.0.content.0.name").String(); got != searchAlias { t.Fatalf("historical tool_use.name = %q, want %q", got, searchAlias) } if got := gjson.GetBytes(out, "messages.0.content.0.id").String(); got != "toolu_unknown" { t.Fatalf("tool_use.id = %q, want unchanged", got) } if got := gjson.GetBytes(out, "messages.0.content.1.tool_name").String(); got != caseAlias { t.Fatalf("tool_reference.tool_name = %q, want %q", got, caseAlias) } if got := gjson.GetBytes(out, "messages.1.content.0.content.0.tool_name").String(); got != searchAlias { t.Fatalf("nested tool_reference.tool_name = %q, want %q", got, searchAlias) } if reverseMap[searchAlias] != "search_web" || reverseMap[caseAlias] != "Search_Web" || reverseMap[bashAlias] != "bash" || reverseMap[readAlias] != "Read" { t.Fatalf("reverseMap = %v, want exact client names", reverseMap) }
response := []byte(fmt.Sprintf(`{"content":[ {"type":"tool_use","id":"toolu_unknown","name":%q,"input":{}}, {"type":"tool_reference","tool_name":%q}, {"type":"tool_result","tool_use_id":"toolu_unknown","content":[{"type":"tool_reference","tool_name":%q}]} ]}`, searchAlias, caseAlias, searchAlias)) restored, errReverse := reverseRemapOAuthToolNames(response, reverseMap) if errReverse != nil { t.Fatalf("reverseRemapOAuthToolNames() error = %v", errReverse) } if got := gjson.GetBytes(restored, "content.0.name").String(); got != "search_web" { t.Fatalf("restored tool_use.name = %q, want search_web", got) } if got := gjson.GetBytes(restored, "content.1.tool_name").String(); got != "Search_Web" { t.Fatalf("restored tool_reference.tool_name = %q, want Search_Web", got) } if got := gjson.GetBytes(restored, "content.2.content.0.tool_name").String(); got != "search_web" { t.Fatalf("restored nested tool_reference = %q, want search_web", got) }
streamLine := []byte(fmt.Sprintf(`data: {"type":"content_block_start","index":0,"content_block":{"type":"tool_use","id":"toolu_unknown","name":%q,"input":{}}}`, searchAlias)) restoredLine, errReverse := reverseRemapOAuthToolNamesFromStreamLine(streamLine, reverseMap) if errReverse != nil { t.Fatalf("reverseRemapOAuthToolNamesFromStreamLine() error = %v", errReverse) } if got := gjson.GetBytes(helps.JSONPayload(restoredLine), "content_block.name").String(); got != "search_web" { t.Fatalf("restored stream name = %q, want search_web: %s", got, restoredLine) }}
func TestRemapOAuthToolNames_TypedCustomUsesMCPAlias(t *testing.T) { body := []byte(`{ "tools":[ {"type":"custom","name":"client_custom","description":"keep","input_schema":{"type":"object","properties":{"value":{"type":"string"}}}}, {"type":"web_search_20250305","name":"web_search","max_uses":2}, {"type":"client_extension_v1","name":"client_extension","description":"extension","input_schema":{"type":"object"}} ], "tool_choice":{"type":"tool","name":"client_custom"}, "messages":[{"role":"assistant","content":[{"type":"tool_use","id":"toolu_custom","name":"client_custom","input":{}}]}] }`) out, reverseMap := remapOAuthToolNamesWithOptions(body, claudeMCPAliasOptions{secret: "caller-secret"})
alias := gjson.GetBytes(out, "tools.0.name").String() if !helps.IsClaudeMCPToolName(alias) { t.Fatalf("typed custom alias = %q, want MCP name", alias) } if gjson.GetBytes(out, "tools.0.type").Exists() { t.Fatalf("typed custom type was not normalized away: %s", out) } if got := gjson.GetBytes(out, "tools.0.description").String(); got != "keep" { t.Fatalf("typed custom description = %q, want preserved", got) } if got := gjson.GetBytes(out, "tools.1.name").String(); got != "web_search" { t.Fatalf("server builtin name = %q, want unchanged", got) } extensionAlias := gjson.GetBytes(out, "tools.2.name").String() if !helps.IsClaudeMCPToolName(extensionAlias) || gjson.GetBytes(out, "tools.2.type").Exists() { t.Fatalf("unknown typed client tool was not normalized: %s", out) } if got := gjson.GetBytes(out, "tool_choice.name").String(); got != alias { t.Fatalf("tool_choice.name = %q, want %q", got, alias) } if got := gjson.GetBytes(out, "messages.0.content.0.name").String(); got != alias { t.Fatalf("historical tool_use.name = %q, want %q", got, alias) } if reverseMap[alias] != "client_custom" || reverseMap[extensionAlias] != "client_extension" { t.Fatalf("reverseMap = %v, want exact typed client names", reverseMap) }}
func TestRemapOAuthToolNames_MCPAliasAvoidsClientCollision(t *testing.T) { const secret = "credential-secret" initialCandidate := helps.ClaudeMCPToolAlias(secret, "fetch_url", 0) body := []byte(fmt.Sprintf(`{"tools":[ {"name":%q,"input_schema":{"type":"object"}}, {"name":"fetch_url","input_schema":{"type":"object"}} ]}`, initialCandidate))
out, reverseMap := remapOAuthToolNamesWithOptions(body, claudeMCPAliasOptions{secret: secret}) if got := gjson.GetBytes(out, "tools.0.name").String(); got != initialCandidate { t.Fatalf("existing MCP tool = %q, want %q", got, initialCandidate) } alias := gjson.GetBytes(out, "tools.1.name").String() if alias == initialCandidate { t.Fatalf("generated alias collided with client MCP name %q", alias) } if reverseMap[alias] != "fetch_url" { t.Fatalf("reverseMap = %v, want %q -> fetch_url", reverseMap, alias) }}
func TestRemapOAuthToolNames_MCPAliasIsMandatory(t *testing.T) { body := []byte(`{"tools":[{"name":"search_web","input_schema":{"type":"object"}}]}`) out, reverseMap := remapOAuthToolNames(body) alias := gjson.GetBytes(out, "tools.0.name").String() if !helps.IsClaudeMCPToolName(alias) { t.Fatalf("tools.0.name = %q, want mandatory MCP alias", alias) } if reverseMap[alias] != "search_web" { t.Fatalf("reverseMap = %v, want alias -> search_web", reverseMap) }}
func TestRemapOAuthToolNames_SemanticAliasRestoresLongOriginal(t *testing.T) { original := "Read.file/with a very long semantic name and Unicode 网页内容 that exceeds the wire limit" body := []byte(`{"tools":[{"name":` + fmt.Sprintf("%q", original) + `,"input_schema":{"type":"object"}}]}`) options := claudeMCPAliasOptions{secret: "stable-caller"}
out, reverseMap := remapOAuthToolNamesWithOptions(body, options) alias := gjson.GetBytes(out, "tools.0.name").String() if !helps.IsClaudeMCPToolName(alias) || len(alias) > 64 { t.Fatalf("semantic alias is invalid or too long: len=%d name=%q", len(alias), alias) } if !strings.Contains(alias, "_Read_file_with_a_very_long") { t.Fatalf("semantic alias %q does not expose the truncated original meaning", alias) } if reverseMap[alias] != original { t.Fatalf("reverseMap lost exact original: got %q, want %q", reverseMap[alias], original) }
second, _ := remapOAuthToolNamesWithOptions(body, options) if got := gjson.GetBytes(second, "tools.0.name").String(); got != alias { t.Fatalf("semantic alias is not stable across requests: %q != %q", got, alias) } response := []byte(`{"content":[{"type":"tool_use","id":"toolu_1","name":` + fmt.Sprintf("%q", alias) + `,"input":{}}]}`) restored, errReverse := reverseRemapOAuthToolNames(response, reverseMap) if errReverse != nil { t.Fatalf("reverseRemapOAuthToolNames() error = %v", errReverse) } if got := gjson.GetBytes(restored, "content.0.name").String(); got != original { t.Fatalf("restored tool name = %q, want exact original %q", got, original) }}
func TestPrepareClaudeOAuthToolNamesForUpstream_PreservesMCPConvention(t *testing.T) { body := []byte(`{"tools":[ {"name":"search_web","input_schema":{"type":"object"}}, {"name":"mcp__context7__query-docs","input_schema":{"type":"object"}}, {"name":"bash","input_schema":{"type":"object"}} ],"tool_choice":{"type":"tool","name":"search_web"}}`) out, reverseMap := prepareClaudeOAuthToolNamesForUpstream(body, claudeMCPAliasOptions{secret: "credential-secret"})
alias := gjson.GetBytes(out, "tools.0.name").String() if !helps.IsClaudeMCPToolName(alias) || strings.HasPrefix(alias, "proxy_") { t.Fatalf("unknown alias = %q, want bare mcp__ name", alias) } if got := gjson.GetBytes(out, "tools.1.name").String(); got != "mcp__context7__query-docs" { t.Fatalf("existing MCP name = %q, want unchanged", got) } bashAlias := gjson.GetBytes(out, "tools.2.name").String() if !helps.IsClaudeMCPToolName(bashAlias) || strings.HasPrefix(bashAlias, "proxy_") { t.Fatalf("former vetted tool = %q, want bare MCP alias", bashAlias) } if got := gjson.GetBytes(out, "tool_choice.name").String(); got != alias { t.Fatalf("tool_choice.name = %q, want %q", got, alias) } if reverseMap[alias] != "search_web" || reverseMap[bashAlias] != "bash" { t.Fatalf("reverseMap = %v, want exact alias restoration", reverseMap) }}
func TestResolveClaudeMCPAliasOptions(t *testing.T) { if options := resolveClaudeMCPAliasOptions(context.Background()); options.secret == "" { t.Fatal("default caller alias secret is empty") }
gin.SetMode(gin.TestMode) ginCtx, _ := gin.CreateTestContext(httptest.NewRecorder()) ginCtx.Set("userApiKey", "downstream-caller-one") callerCtx := context.WithValue(context.Background(), "gin", ginCtx) firstSecret := resolveClaudeMCPAliasOptions(callerCtx).secret secondSecret := resolveClaudeMCPAliasOptions(callerCtx).secret if firstSecret == "" || secondSecret != firstSecret { t.Fatalf("caller alias secret is unstable: %q != %q", firstSecret, secondSecret) } otherGinCtx, _ := gin.CreateTestContext(httptest.NewRecorder()) otherGinCtx.Set("userApiKey", "downstream-caller-two") otherCtx := context.WithValue(context.Background(), "gin", otherGinCtx) if otherSecret := resolveClaudeMCPAliasOptions(otherCtx).secret; otherSecret == firstSecret { t.Fatalf("different downstream callers shared alias secret %q", firstSecret) }}
func TestRemapOAuthToolNames_MixedCaseNamesRemainDistinct(t *testing.T) { body := []byte(`{"tools":[` + `{"name":"Bash","input_schema":{"type":"object"}},` + `{"name":"bash","input_schema":{"type":"object"}}` + `]}`) out, reverseMap := remapOAuthToolNames(body) upperAlias := gjson.GetBytes(out, "tools.0.name").String() lowerAlias := gjson.GetBytes(out, "tools.1.name").String() if !helps.IsClaudeMCPToolName(upperAlias) || !helps.IsClaudeMCPToolName(lowerAlias) || upperAlias == lowerAlias { t.Fatalf("mixed-case aliases = %q, %q, want distinct MCP names", upperAlias, lowerAlias) } if reverseMap[upperAlias] != "Bash" || reverseMap[lowerAlias] != "bash" { t.Fatalf("reverseMap = %v, want exact mixed-case names", reverseMap) }}
// TestReverseRemapOAuthToolNamesFromStreamLine_HonorsPerRequestMap guards the// SSE streaming code path against the same mixed-case bug.func TestReverseRemapOAuthToolNamesFromStreamLine_HonorsPerRequestMap(t *testing.T) { reverseMap := map[string]string{"Glob": "glob"}
// Bash block was never renamed, must pass through as-is. bashLine := []byte(`data: {"type":"content_block_start","index":0,"content_block":{"type":"tool_use","id":"toolu_01","name":"Bash","input":{}}}`) out, errReverse := reverseRemapOAuthToolNamesFromStreamLine(bashLine, reverseMap) if errReverse != nil { t.Fatalf("reverseRemapOAuthToolNamesFromStreamLine() error = %v", errReverse) } if !bytes.Contains(out, []byte(`"name":"Bash"`)) { t.Fatalf("Bash should be preserved, got: %s", string(out)) } if bytes.Contains(out, []byte(`"name":"bash"`)) { t.Fatalf("Bash must not be lowercased, got: %s", string(out)) }
// Glob block IS in the reverseMap, must be restored to `glob`. globLine := []byte(`data: {"type":"content_block_start","index":0,"content_block":{"type":"tool_use","id":"toolu_02","name":"Glob","input":{}}}`) out, errReverse = reverseRemapOAuthToolNamesFromStreamLine(globLine, reverseMap) if errReverse != nil { t.Fatalf("reverseRemapOAuthToolNamesFromStreamLine() error = %v", errReverse) } if !bytes.Contains(out, []byte(`"name":"glob"`)) { t.Fatalf("Glob should be restored to glob, got: %s", string(out)) }}
func TestPrepareClaudeOAuthToolNamesForUpstream_AllCustomToolsWithHistory(t *testing.T) { body := []byte(`{"tools":[` + `{"name":"Bash","input_schema":{"type":"object","properties":{"cmd":{"type":"string"}}}},` + `{"name":"glob","input_schema":{"type":"object","properties":{"filePattern":{"type":"string"}}}}` + `],"messages":[{"role":"assistant","content":[` + `{"type":"tool_use","id":"toolu_01","name":"Bash","input":{}},` + `{"type":"tool_use","id":"toolu_02","name":"glob","input":{}}` + `]}]}`)
out, reverseMap := prepareClaudeOAuthToolNamesForUpstream(body, claudeMCPAliasOptions{secret: "mixed-case-caller"}) bashAlias := gjson.GetBytes(out, "tools.0.name").String() globAlias := gjson.GetBytes(out, "tools.1.name").String() if !helps.IsClaudeMCPToolName(bashAlias) || !helps.IsClaudeMCPToolName(globAlias) || bashAlias == globAlias { t.Fatalf("tool aliases = %q, %q, want distinct bare MCP names", bashAlias, globAlias) } if got := gjson.GetBytes(out, "messages.0.content.0.name").String(); got != bashAlias { t.Fatalf("messages.0.content.0.name = %q, want %q", got, bashAlias) } if got := gjson.GetBytes(out, "messages.0.content.1.name").String(); got != globAlias { t.Fatalf("messages.0.content.1.name = %q, want %q", got, globAlias) } if reverseMap[bashAlias] != "Bash" || reverseMap[globAlias] != "glob" { t.Fatalf("reverseMap = %v, want exact client names", reverseMap) }}
func TestClaudeExecutor_ExecuteOpenAINonStreamRestoresOAuthToolNames(t *testing.T) { upstreamBody := strings.Join([]string{ `event: message_start`, `data: {"type":"message_start","message":{"id":"msg_123","model":"claude-3-5-sonnet-20241022","usage":{"input_tokens":10,"output_tokens":1}}}`, `event: content_block_start`, `data: {"type":"content_block_start","index":0,"content_block":{"type":"tool_use","id":"toolu_01","name":"Bash","input":{}}}`, `event: content_block_delta`, `data: {"type":"content_block_delta","index":0,"delta":{"type":"input_json_delta","partial_json":"{\"command\": \"echo hi\"}"}}`, `event: content_block_stop`, `data: {"type":"content_block_stop","index":0}`, `event: message_delta`, `data: {"type":"message_delta","delta":{"stop_reason":"tool_use"},"usage":{"output_tokens":30}}`, `event: message_stop`, `data: {"type":"message_stop"}`, ``, }, "\n")
type upstreamRequest struct { toolName string stream bool } upstreamRequests := make(chan upstreamRequest, 1) server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, errRead := io.ReadAll(r.Body) if errRead != nil { http.Error(w, errRead.Error(), http.StatusBadRequest) return } toolName := gjson.GetBytes(body, "tools.0.name").String() upstreamRequests <- upstreamRequest{ toolName: toolName, stream: gjson.GetBytes(body, "stream").Bool(), } w.Header().Set("Content-Type", "text/event-stream") responseBody := strings.Replace(upstreamBody, `"name":"Bash"`, `"name":`+fmt.Sprintf("%q", toolName), 1) _, _ = w.Write([]byte(responseBody)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ Attributes: map[string]string{ "api_key": "sk-ant-oat01-test", "base_url": server.URL, }, Metadata: claudeOAuthTestMetadata(), } payload := []byte(`{"model":"claude-3-5-sonnet-20241022","messages":[{"role":"user","content":"run echo hi"}],` + `"tools":[{"type":"function","function":{"name":"bash","description":"run shell",` + `"parameters":{"type":"object","properties":{"command":{"type":"string"}},"required":["command"]}}}]}`)
resp, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-3-5-sonnet-20241022", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FromString("openai"), }) if err != nil { t.Fatalf("Execute error: %v", err) }
upstream := <-upstreamRequests if !upstream.stream { t.Fatal("upstream stream = false, want true") } if !helps.IsClaudeMCPToolName(upstream.toolName) || !strings.HasSuffix(upstream.toolName, "_bash") { t.Fatalf("upstream tools.0.name = %q, want semantic MCP alias", upstream.toolName) } if got := gjson.GetBytes(resp.Payload, "choices.0.message.tool_calls.0.function.name").String(); got != "bash" { t.Fatalf("tool_calls.0.function.name = %q, want %q; payload=%s", got, "bash", string(resp.Payload)) }}
func TestClaudeExecutor_ExecuteOAuthCustomToolMCPAliasRoundTrip(t *testing.T) { var upstreamAlias string var upstreamBody []byte var upstreamHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) upstreamBody = bytes.Clone(body) upstreamHeaders = r.Header.Clone() upstreamAlias = gjson.GetBytes(body, "tools.0.name").String() w.Header().Set("Content-Type", "application/json") _, _ = fmt.Fprintf(w, `{"id":"msg_1","type":"message","role":"assistant","model":"claude-opus-4-6","content":[{"type":"tool_use","id":"toolu_1","name":%q,"input":{"query":"go"}}],"stop_reason":"tool_use","usage":{"input_tokens":1,"output_tokens":1}}`, upstreamAlias) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ ID: "oauth-mcp-round-trip", Attributes: map[string]string{ "api_key": "sk-ant-oat-mcp-round-trip", "base_url": server.URL, }, Metadata: claudeOAuthTestMetadata(), } payload := []byte(`{"model":"claude-opus-5","system":"messages-system-prompt","messages":[{"role":"user","content":"search"}],"tools":[{"name":"search_web","description":"search","input_schema":{"type":"object","properties":{"query":{"type":"string"}},"required":["query"]}}]}`) resp, errExecute := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-opus-5", Payload: payload, }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if errExecute != nil { t.Fatalf("Execute() error = %v", errExecute) } if !helps.IsClaudeMCPToolName(upstreamAlias) || strings.HasPrefix(upstreamAlias, "proxy_") || !strings.HasSuffix(upstreamAlias, "_search_web") { t.Fatalf("upstream tool name = %q, want semantic mcp__ alias", upstreamAlias) } if got := gjson.GetBytes(resp.Payload, "content.0.name").String(); got != "search_web" { t.Fatalf("client response tool name = %q, want search_web; payload=%s", got, resp.Payload) } if _, ok := claudeBillingCCHDigitsOffset(upstreamBody); !ok { t.Fatalf("Claude OAuth custom BaseURL body is missing CCH: %s", upstreamBody) } if got := upstreamHeaders.Get("User-Agent"); got != "claude-cli/2.1.258 (external, cli)" { t.Fatalf("Messages User-Agent = %q, want CLI identity", got) } wantBetas := claudeCodeCLIBetas(payload, nil, true) if got := upstreamHeaders.Get("Anthropic-Beta"); got != wantBetas { t.Fatalf("Messages Anthropic-Beta = %q, want %q", got, wantBetas) } if got := gjson.GetBytes(upstreamBody, "system.1.text").String(); got != claudeCodeCLIIdentity { t.Fatalf("Messages system.1.text = %q, want official CLI identity", got) } if got := gjson.GetBytes(upstreamBody, "system.#").Int(); got != 3 { t.Fatalf("Messages top-level system block count = %d, want 3", got) } content := gjson.GetBytes(upstreamBody, "messages.0.content").Array() if len(content) != 2 { t.Fatalf("Messages first user content has %d blocks, want currentDate and user text", len(content)) } assertClaudeCodeCurrentDateBlock(t, content[0]) assertEphemeralUserTextBlock(t, content[1], "search", "1h") assertClaudeTopLevelCallerSystem(t, upstreamBody, 1, "messages-system-prompt", "1h")}
func TestClaudeExecutor_ExecuteStreamOAuthCustomToolMCPAliasRoundTrip(t *testing.T) { var upstreamAlias string var upstreamBody []byte var upstreamHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) upstreamBody = bytes.Clone(body) upstreamHeaders = r.Header.Clone() upstreamAlias = gjson.GetBytes(body, "tools.0.name").String() w.Header().Set("Content-Type", "text/event-stream") _, _ = fmt.Fprintf(w, "event: content_block_start\ndata: {\"type\":\"content_block_start\",\"index\":0,\"content_block\":{\"type\":\"tool_use\",\"id\":\"toolu_1\",\"name\":%q,\"input\":{}}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n", upstreamAlias) })) defer server.Close()
deviceIDs := []string{ "0000000000000000000000000000000000000000000000000000000000000000", } executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ ID: "oauth-mcp-stream-round-trip", Attributes: map[string]string{ "api_key": "sk-ant-oat-mcp-stream-round-trip", "base_url": server.URL, }, Metadata: map[string]any{ "account_uuid": "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa", claudeauth.ClaudeDeviceIDsMetadataKey: deviceIDs, }, } payload := []byte(`{"model":"claude-opus-5","system":"stream-system-prompt","messages":[{"role":"user","content":"fetch"}],"tools":[{"name":"fetch_url","description":"fetch","input_schema":{"type":"object"}}],"stream":true}`) result, errStream := executor.ExecuteStream(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-opus-5", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, Metadata: map[string]any{ cliproxyexecutor.ExecutionSessionMetadataKey: "stream-agent-conversation", }, }) if errStream != nil { t.Fatalf("ExecuteStream() error = %v", errStream) } var downstream bytes.Buffer for chunk := range result.Chunks { if chunk.Err != nil { t.Fatalf("stream chunk error = %v", chunk.Err) } downstream.Write(chunk.Payload) } if !helps.IsClaudeMCPToolName(upstreamAlias) || !strings.HasSuffix(upstreamAlias, "_fetch_url") { t.Fatalf("upstream tool name = %q, want semantic mcp__ alias", upstreamAlias) } if _, ok := claudeBillingCCHDigitsOffset(upstreamBody); !ok { t.Fatalf("streaming Claude OAuth custom BaseURL body is missing CCH: %s", upstreamBody) } if got := upstreamHeaders.Get("User-Agent"); got != "claude-cli/2.1.258 (external, cli)" { t.Fatalf("streaming User-Agent = %q, want CLI identity", got) } wantBetas := claudeCodeCLIBetas(payload, nil, true) if got := upstreamHeaders.Get("Anthropic-Beta"); got != wantBetas { t.Fatalf("streaming Anthropic-Beta = %q, want %q", got, wantBetas) } if got := gjson.GetBytes(upstreamBody, "system.1.text").String(); got != claudeCodeCLIIdentity { t.Fatalf("streaming system.1.text = %q, want official CLI identity", got) } if got := gjson.GetBytes(upstreamBody, "system.#").Int(); got != 3 { t.Fatalf("streaming top-level system block count = %d, want 3", got) } content := gjson.GetBytes(upstreamBody, "messages.0.content").Array() if len(content) != 2 { t.Fatalf("streaming first user content has %d blocks, want currentDate and user text", len(content)) } assertClaudeCodeCurrentDateBlock(t, content[0]) assertEphemeralUserTextBlock(t, content[1], "fetch", "1h") assertClaudeTopLevelCallerSystem(t, upstreamBody, 1, "stream-system-prompt", "1h") assertClaudeCredentialIdentity(t, upstreamBody, upstreamHeaders, deviceIDs, "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa") if !strings.Contains(downstream.String(), `"name":"fetch_url"`) { t.Fatalf("downstream stream did not restore fetch_url: %s", downstream.String()) } if strings.Contains(downstream.String(), upstreamAlias) { t.Fatalf("downstream leaked upstream alias %q: %s", upstreamAlias, downstream.String()) }}
// TestClaudeCodeCLIBetas_MatchesObservedClientMatrix pins the Anthropic-Beta// baseline to Claude Code 2.1.220 behavior captured against api.anthropic.com.// The OAuth profile was reverified on 2026-08-03 with two distinct accounts.func TestClaudeCodeCLIBetas_MatchesObservedClientMatrix(t *testing.T) { const constants = "claude-code-20250219,interleaved-thinking-2025-05-14,redact-thinking-2026-02-12,thinking-token-count-2026-05-13,context-management-2025-06-27,prompt-caching-scope-2026-01-05"
tests := []struct { name string body string requested map[string]bool oauth bool want string }{ { name: "legacy model without tools omits both conditional betas", body: `{"model":"claude-opus-4-6"}`, want: constants + ",effort-2025-11-24", }, { name: "context 1m sits right after claude-code, not at the end", body: `{"model":"claude-opus-4-6"}`, requested: map[string]bool{claudeContext1MBeta: true}, want: "claude-code-20250219,context-1m-2025-08-07," + "interleaved-thinking-2025-05-14,redact-thinking-2026-02-12," + "thinking-token-count-2026-05-13,context-management-2025-06-27," + "prompt-caching-scope-2026-01-05,effort-2025-11-24", }, { name: "opus-5 1m variant reproduces the full observed order", body: `{"model":"claude-opus-5","tools":[{"name":"Read"}]}`, requested: map[string]bool{ claudeContext1MBeta: true, claudeServerSideFallbackBeta: true, claudeFallbackCreditBeta: true, }, want: "claude-code-20250219,context-1m-2025-08-07," + "interleaved-thinking-2025-05-14,redact-thinking-2026-02-12," + "thinking-token-count-2026-05-13,context-management-2025-06-27," + "prompt-caching-scope-2026-01-05,mid-conversation-system-2026-04-07," + "advanced-tool-use-2025-11-20,effort-2025-11-24," + "server-side-fallback-2026-06-01,fallback-credit-2026-06-01", }, { name: "structured outputs trails effort", body: `{"model":"claude-opus-4-6"}`, requested: map[string]bool{claudeStructuredOutputsBeta: true}, want: constants + ",effort-2025-11-24,structured-outputs-2025-12-15", }, { name: "unknown caller beta is not smuggled into the baseline", body: `{"model":"claude-opus-4-6"}`, requested: map[string]bool{"totally-made-up-2030-01-01": true}, want: constants + ",effort-2025-11-24", }, { name: "claude-sonnet-5 accepts role=system", body: `{"model":"claude-sonnet-5"}`, want: constants + ",mid-conversation-system-2026-04-07,effort-2025-11-24", }, { name: "claude-opus-4-8 accepts role=system", body: `{"model":"claude-opus-4-8"}`, want: constants + ",mid-conversation-system-2026-04-07,effort-2025-11-24", }, { name: "claude-fable-5 accepts role=system", body: `{"model":"claude-fable-5"}`, want: constants + ",mid-conversation-system-2026-04-07,effort-2025-11-24", }, { name: "claude-opus-4-7 stays on the reminder path", body: `{"model":"claude-opus-4-7"}`, want: constants + ",effort-2025-11-24", }, { name: "oauth uses advanced tools and the current cache TTL trailer", body: `{"model":"claude-opus-4-6","tools":[{"name":"Read"}]}`, oauth: true, want: "claude-code-20250219,oauth-2025-04-20," + "interleaved-thinking-2025-05-14,redact-thinking-2026-02-12," + "thinking-token-count-2026-05-13,context-management-2025-06-27," + "prompt-caching-scope-2026-01-05,advanced-tool-use-2025-11-20," + "effort-2025-11-24,fallback-credit-2026-06-01," + "extended-cache-ttl-2025-04-11", }, { name: "oauth precedes context-1m", body: `{"model":"claude-opus-5","tools":[{"name":"Read"}]}`, oauth: true, requested: map[string]bool{ claudeContext1MBeta: true, claudeServerSideFallbackBeta: true, claudeFallbackCreditBeta: true, }, want: "claude-code-20250219,oauth-2025-04-20,context-1m-2025-08-07," + "interleaved-thinking-2025-05-14,redact-thinking-2026-02-12," + "thinking-token-count-2026-05-13,context-management-2025-06-27," + "prompt-caching-scope-2026-01-05,mid-conversation-system-2026-04-07," + "advanced-tool-use-2025-11-20,effort-2025-11-24," + "server-side-fallback-2026-06-01,fallback-credit-2026-06-01," + "extended-cache-ttl-2025-04-11", }, { name: "api key path sends neither oauth beta", body: `{"model":"claude-opus-4-6"}`, want: constants + ",effort-2025-11-24", }, { name: "claude-haiku-4-5-20251001 stays on the reminder path and omits effort", body: `{"model":"claude-haiku-4-5-20251001"}`, want: constants, }, { name: "legacy model with tools adds advanced tool use only", body: `{"model":"claude-sonnet-4-6","tools":[{"name":"Read"}]}`, want: constants + ",advanced-tool-use-2025-11-20,effort-2025-11-24", }, { name: "role=system model without tools adds mid conversation system only", body: `{"model":"claude-opus-5"}`, want: constants + ",mid-conversation-system-2026-04-07,effort-2025-11-24", }, { name: "role=system model with tools adds both in wire order", body: `{"model":"claude-opus-5","tools":[{"name":"Read"}]}`, want: constants + ",mid-conversation-system-2026-04-07,advanced-tool-use-2025-11-20,effort-2025-11-24", }, { name: "empty tools array does not add advanced tool use", body: `{"model":"claude-opus-4-6","tools":[]}`, want: constants + ",effort-2025-11-24", }, { name: "unknown future model keeps the optimistic role=system default", body: `{"model":"claude-future-9"}`, want: constants + ",mid-conversation-system-2026-04-07,effort-2025-11-24", }, { name: "thinking display summarized drops redact-thinking", body: `{"model":"claude-opus-5","thinking":{"type":"adaptive","display":"summarized"}}`, want: "claude-code-20250219,interleaved-thinking-2025-05-14," + "thinking-token-count-2026-05-13,context-management-2025-06-27," + "prompt-caching-scope-2026-01-05,mid-conversation-system-2026-04-07," + "effort-2025-11-24", }, { name: "thinking display omitted drops redact-thinking as well", body: `{"model":"claude-opus-4-6","thinking":{"type":"enabled","budget_tokens":2048,"display":"omitted"}}`, want: "claude-code-20250219,interleaved-thinking-2025-05-14," + "thinking-token-count-2026-05-13,context-management-2025-06-27," + "prompt-caching-scope-2026-01-05,effort-2025-11-24", }, { name: "thinking without display keeps redact-thinking", body: `{"model":"claude-opus-4-6","thinking":{"type":"adaptive"}}`, want: constants + ",effort-2025-11-24", }, { name: "blank display value keeps redact-thinking", body: `{"model":"claude-opus-4-6","thinking":{"type":"adaptive","display":" "}}`, want: constants + ",effort-2025-11-24", }, { name: "advisor tool beta requested placed before advanced-tool-use", body: `{"model":"claude-opus-5","tools":[{"name":"Read"}]}`, requested: map[string]bool{"advisor-tool-2026-03-01": true}, want: constants + ",mid-conversation-system-2026-04-07,advisor-tool-2026-03-01,advanced-tool-use-2025-11-20,effort-2025-11-24", }, { name: "body with advisor server tool automatically adds advisor-tool beta", body: `{"model":"claude-opus-5","tools":[{"type":"advisor_20260301","name":"advisor"}]}`, want: constants + ",mid-conversation-system-2026-04-07,advisor-tool-2026-03-01,advanced-tool-use-2025-11-20,effort-2025-11-24", }, { name: "thinking display updates emits thinking-display-updates beta and drops redact-thinking", body: `{"model":"claude-fable-5-1","thinking":{"type":"adaptive","display":"updates"}}`, want: "claude-code-20250219,interleaved-thinking-2025-05-14," + "thinking-token-count-2026-05-13,context-management-2025-06-27," + "prompt-caching-scope-2026-01-05,mid-conversation-system-2026-04-07," + "effort-2025-11-24,thinking-display-updates-2026-08-18", }, { name: "body with fallbacks automatically adds server-side-fallback beta", body: `{"model":"claude-fable-5-1","fallbacks":[{"model":"claude-opus-5"}]}`, want: constants + ",mid-conversation-system-2026-04-07,effort-2025-11-24,server-side-fallback-2026-06-01", }, { name: "subagent request omits extended-cache-ttl beta", body: `{"model":"claude-sonnet-5","system":[{"type":"text","text":"x-anthropic-billing-header: cc_version=2.1.258.0ab; cc_is_subagent=true;"}]}`, oauth: true, want: "claude-code-20250219,oauth-2025-04-20," + "interleaved-thinking-2025-05-14,redact-thinking-2026-02-12," + "thinking-token-count-2026-05-13,context-management-2025-06-27," + "prompt-caching-scope-2026-01-05,mid-conversation-system-2026-04-07," + "effort-2025-11-24,fallback-credit-2026-06-01", }, { name: "probe request max_tokens=1 omits effort and extended-cache-ttl betas", body: `{"model":"claude-sonnet-5","max_tokens":1}`, oauth: true, want: "claude-code-20250219,oauth-2025-04-20," + "interleaved-thinking-2025-05-14,redact-thinking-2026-02-12," + "thinking-token-count-2026-05-13,context-management-2025-06-27," + "prompt-caching-scope-2026-01-05,mid-conversation-system-2026-04-07," + "fallback-credit-2026-06-01", }, { name: "haiku model omits effort beta even if requested", body: `{"model":"claude-haiku-4-5-20251001"}`, requested: map[string]bool{"effort-2025-11-24": true}, oauth: true, want: "claude-code-20250219,oauth-2025-04-20," + "interleaved-thinking-2025-05-14,redact-thinking-2026-02-12," + "thinking-token-count-2026-05-13,context-management-2025-06-27," + "prompt-caching-scope-2026-01-05," + "fallback-credit-2026-06-01,extended-cache-ttl-2025-04-11", }, { name: "disabled thinking omits effort beta even if requested", body: `{"model":"claude-sonnet-5","thinking":{"type":"disabled"}}`, requested: map[string]bool{"effort-2025-11-24": true}, oauth: true, want: "claude-code-20250219,oauth-2025-04-20," + "interleaved-thinking-2025-05-14,redact-thinking-2026-02-12," + "thinking-token-count-2026-05-13,context-management-2025-06-27," + "prompt-caching-scope-2026-01-05,mid-conversation-system-2026-04-07," + "fallback-credit-2026-06-01,extended-cache-ttl-2025-04-11", }, }
for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { if got := claudeCodeCLIBetas([]byte(tt.body), tt.requested, tt.oauth); got != tt.want { t.Fatalf("claudeCodeCLIBetas() = %q, want %q", got, tt.want) } }) }}
// TestApplyClaudeHeaders_StreamTransportNegotiation pins the observed 2.1.220// behaviour: a streaming request to api.anthropic.com negotiates exactly like a// non-streaming one, because Anthropic selects SSE from the body. Other// Anthropic-compatible upstreams keep the conservative SSE contract.func TestApplyClaudeHeaders_StreamTransportNegotiation(t *testing.T) { auth := &cliproxyauth.Auth{Attributes: map[string]string{"api_key": "key-stream-accept"}} body := []byte(`{"model":"claude-opus-4-6","stream":true}`)
directReq := newClaudeHeaderTestRequest(t, http.Header{}) if errApply := applyClaudeHeaders(directReq, auth, "key-stream-accept", true, nil, body, nil, http.Header{}, false); errApply != nil { t.Fatalf("applyClaudeHeaders() error = %v", errApply) } if got, want := directReq.Header.Get("Accept"), "application/json"; got != want { t.Fatalf("streaming Accept = %q, want %q to match the real client", got, want) } if got, want := directReq.Header.Get("Accept-Encoding"), "gzip, deflate, br, zstd"; got != want { t.Fatalf("streaming Accept-Encoding = %q, want %q to match the real client", got, want) }
gatewayReq := httptest.NewRequest(http.MethodPost, "https://api.kimi.com/coding/v1/messages", nil) gatewayReq = gatewayReq.WithContext(directReq.Context()) if errApply := applyClaudeHeaders(gatewayReq, auth, "key-stream-accept", true, nil, body, nil, http.Header{}, false); errApply != nil { t.Fatalf("applyClaudeHeaders() error = %v", errApply) } if got, want := gatewayReq.Header.Get("Accept"), "text/event-stream"; got != want { t.Fatalf("gateway streaming Accept = %q, want %q", got, want) } if got, want := gatewayReq.Header.Get("Accept-Encoding"), "identity"; got != want { t.Fatalf("gateway streaming Accept-Encoding = %q, want %q", got, want) }}
func TestApplyClaudeHeaders_DefaultPreservesCallerBetas(t *testing.T) { incoming := http.Header{"Anthropic-Beta": []string{"caller-only-beta"}} auth := &cliproxyauth.Auth{Attributes: map[string]string{"api_key": "key-caller-betas"}} body := []byte(`{"model":"claude-opus-4-6"}`)
// Default API-key mode preserves caller betas on direct Anthropic. directReq := newClaudeHeaderTestRequest(t, incoming) if errApply := applyClaudeHeaders(directReq, auth, "key-caller-betas", false, nil, body, nil, incoming, false); errApply != nil { t.Fatalf("applyClaudeHeaders() error = %v", errApply) } if got := directReq.Header.Get("Anthropic-Beta"); got != "caller-only-beta" { t.Fatalf("Anthropic-Beta = %q, want caller beta on api.anthropic.com", got) }
// Other Anthropic-compatible upstreams keep caller betas functional. gatewayReq := httptest.NewRequest(http.MethodPost, "https://api.kimi.com/coding/v1/messages", nil) gatewayReq = gatewayReq.WithContext(directReq.Context()) if errApply := applyClaudeHeaders(gatewayReq, auth, "key-caller-betas", false, nil, body, nil, incoming, false); errApply != nil { t.Fatalf("applyClaudeHeaders() error = %v", errApply) } if got := gatewayReq.Header.Get("Anthropic-Beta"); !strings.Contains(got, "caller-only-beta") { t.Fatalf("Anthropic-Beta = %q, want caller beta preserved on non-Anthropic upstream", got) }}
// TestInjectClaudeCodeContextManagement pins the captured 2.1.220 object and// the thinking and caller-ownership rules that control automatic injection.func TestInjectClaudeCodeContextManagement(t *testing.T) { const captured = `{"edits":[{"type":"clear_thinking_20251015","keep":"all"}]}`
for _, test := range []struct { name string payload string }{ {name: "enabled thinking", payload: `{"model":"claude-opus-5","thinking":{"type":"enabled"}}`}, {name: "adaptive thinking", payload: `{"model":"claude-opus-5","thinking":{"type":"adaptive"}}`}, } { t.Run(test.name, func(t *testing.T) { got, automaticallyInjected := injectClaudeCodeContextManagement([]byte(test.payload)) if !automaticallyInjected { t.Fatal("automatic context_management injection was not reported") } if diff := gjson.GetBytes(got, "context_management").Raw; diff != captured { t.Fatalf("context_management = %s, want the captured object %s", diff, captured) } }) }
callerOwned := []byte(`{"model":"claude-opus-4-6","context_management":{"edits":[]}}`) callerOwnedGot, automaticallyInjected := injectClaudeCodeContextManagement(callerOwned) if automaticallyInjected { t.Error("caller context_management was reported as automatically injected") } if !bytes.Equal(callerOwnedGot, callerOwned) { t.Fatalf("caller context_management was modified: %s", callerOwnedGot) }
// Anthropic rejects clear_thinking_20251015 unless thinking is enabled or // adaptive, so an omitted thinking field is as ineligible as an explicit // disabled one. for _, test := range []struct { name string payload string }{ {name: "disabled thinking", payload: `{"model":"claude-opus-5","thinking":{"type":"disabled"}}`}, {name: "omitted thinking", payload: `{"model":"claude-opus-4-6"}`}, {name: "unknown thinking", payload: `{"model":"claude-opus-5","thinking":{"type":"unexpected"}}`}, } { t.Run(test.name, func(t *testing.T) { ineligible := []byte(test.payload) got, automaticallyInjected := injectClaudeCodeContextManagement(ineligible) if automaticallyInjected { t.Error("ineligible thinking context_management was reported as automatically injected") } if !bytes.Equal(got, ineligible) { t.Errorf("ineligible payload was modified: %s", got) } if cm := gjson.GetBytes(got, "context_management"); cm.Exists() { t.Errorf("context_management = %s, want absent", cm.Raw) } }) }}
// Anthropic rejects a request carrying the clear_thinking_20251015 strategy// without enabled/adaptive thinking://// `clear_thinking_20251015` strategy requires `thinking` to be enabled or adaptive//// This walks the real execute.go ordering, where disableThinkingIfToolChoiceForced// deletes the thinking field between injection and reconciliation.func TestClaudeCodeContextManagementNeverOutlivesEligibleThinking(t *testing.T) { for _, test := range []struct { name string payload string wantCM bool }{ { name: "thinking omitted from the start", payload: `{"model":"claude-opus-5","messages":[]}`, }, { name: "forced tool_choice strips thinking after injection", payload: `{"model":"claude-opus-5","thinking":{"type":"enabled","budget_tokens":1024},"tool_choice":{"type":"any"},"messages":[]}`, }, { name: "thinking survives without forced tool_choice", payload: `{"model":"claude-opus-5","thinking":{"type":"enabled","budget_tokens":1024},"messages":[]}`, wantCM: true, }, } { t.Run(test.name, func(t *testing.T) { body, injected := injectClaudeCodeContextManagement([]byte(test.payload)) state := claudeCodeContextManagementState{eligible: true, automaticallyInjected: injected} body = disableThinkingIfToolChoiceForced(body) body = reconcileClaudeCodeContextManagement(body, state)
thinkingEligible := gjson.GetBytes(body, "thinking.type").String() == "enabled" || gjson.GetBytes(body, "thinking.type").String() == "adaptive" cm := gjson.GetBytes(body, "context_management") if cm.Exists() && !thinkingEligible { t.Fatalf("context_management = %s survived ineligible thinking; Anthropic would reject this: %s", cm.Raw, body) } if cm.Exists() != test.wantCM { t.Fatalf("context_management present = %v, want %v; body=%s", cm.Exists(), test.wantCM, body) } }) }}
func TestReconcileClaudeCodeContextManagement(t *testing.T) { withAutomatic := func(thinkingType string) string { return `{"thinking":{"type":"` + thinkingType + `"},"context_management":` + claudeCodeContextManagement + `}` }
for _, test := range []struct { name string payload string state claudeCodeContextManagementState wantRaw string }{ { name: "removes unchanged automatic object when disabled", payload: withAutomatic("disabled"), state: claudeCodeContextManagementState{eligible: true, automaticallyInjected: true}, }, { name: "preserves rule owned automatic object when disabled", payload: withAutomatic("disabled"), state: claudeCodeContextManagementState{eligible: true, automaticallyInjected: true, payloadRuleTouched: true}, wantRaw: claudeCodeContextManagement, }, { name: "preserves changed automatic object when disabled", payload: `{"thinking":{"type":"disabled"},"context_management":{"edits":[{"type":"custom"}]}}`, state: claudeCodeContextManagementState{eligible: true, automaticallyInjected: true}, wantRaw: `{"edits":[{"type":"custom"}]}`, }, { name: "adds automatic object when enabled", payload: `{"thinking":{"type":"enabled"}}`, state: claudeCodeContextManagementState{eligible: true}, wantRaw: claudeCodeContextManagement, }, { name: "adds automatic object when adaptive", payload: `{"thinking":{"type":"adaptive"}}`, state: claudeCodeContextManagementState{eligible: true}, wantRaw: claudeCodeContextManagement, }, { name: "caller ownership prevents addition", payload: `{"thinking":{"type":"enabled"}}`, state: claudeCodeContextManagementState{eligible: true, callerOwned: true}, }, { name: "payload rule ownership prevents addition", payload: `{"thinking":{"type":"enabled"}}`, state: claudeCodeContextManagementState{eligible: true, payloadRuleTouched: true}, }, { name: "ineligible request prevents addition", payload: `{"thinking":{"type":"enabled"}}`, }, { name: "omitted thinking prevents addition", payload: `{}`, state: claudeCodeContextManagementState{eligible: true}, }, { name: "removes automatic object when thinking was stripped entirely", payload: `{"context_management":` + claudeCodeContextManagement + `}`, state: claudeCodeContextManagementState{eligible: true, automaticallyInjected: true}, }, { name: "keeps caller object when thinking was stripped entirely", payload: `{"context_management":` + claudeCodeContextManagement + `}`, state: claudeCodeContextManagementState{eligible: true, callerOwned: true}, wantRaw: claudeCodeContextManagement, }, { name: "unknown thinking prevents addition", payload: `{"thinking":{"type":"unexpected"}}`, state: claudeCodeContextManagementState{eligible: true}, }, { name: "invalid thinking prevents addition", payload: `{"thinking":{"type":123}}`, state: claudeCodeContextManagementState{eligible: true}, }, } { t.Run(test.name, func(t *testing.T) { got := reconcileClaudeCodeContextManagement([]byte(test.payload), test.state) if raw := gjson.GetBytes(got, "context_management").Raw; raw != test.wantRaw { t.Fatalf("context_management = %s, want %s; body=%s", raw, test.wantRaw, got) } }) }}
func TestClaudeExecutorPayloadOverrideDisabledThinking(t *testing.T) { const model = "claude-opus-5" modelRules := []config.PayloadModelRule{{Name: model, Protocol: "claude"}} basePayload := []byte(`{"model":"claude-opus-5","max_tokens":16,"messages":[{"role":"user","content":"hi"}]}`)
for _, test := range []struct { name string stream bool }{ {name: "execute"}, {name: "execute stream", stream: true}, } { t.Run(test.name, func(t *testing.T) { cfg := &config.Config{Payload: config.PayloadConfig{Override: []config.PayloadRule{{ Models: modelRules, Params: map[string]any{"thinking.type": "disabled"}, }}}} upstreamBody := executeClaudeContextManagementRequest(t, cfg, basePayload, test.stream) if got := gjson.GetBytes(upstreamBody, "thinking.type").String(); got != "disabled" { t.Fatalf("final upstream thinking.type = %q, want disabled; body=%s", got, upstreamBody) } if got := gjson.GetBytes(upstreamBody, "context_management"); got.Exists() { t.Errorf("final upstream context_management = %s with disabled thinking, want absent", got.Raw) } }) }
t.Run("caller context management is preserved", func(t *testing.T) { cfg := &config.Config{Payload: config.PayloadConfig{Override: []config.PayloadRule{{ Models: modelRules, Params: map[string]any{"thinking.type": "disabled"}, }}}} payload := []byte(`{"model":"claude-opus-5","max_tokens":16,"messages":[{"role":"user","content":"hi"}],"context_management":{"edits":[{"type":"caller_owned"}]}}`) upstreamBody := executeClaudeContextManagementRequest(t, cfg, payload, false) if got := gjson.GetBytes(upstreamBody, "context_management.edits.0.type").String(); got != "caller_owned" { t.Fatalf("caller context_management type = %q, want caller_owned; body=%s", got, upstreamBody) } })
t.Run("payload override replacement is preserved", func(t *testing.T) { cfg := &config.Config{Payload: config.PayloadConfig{Override: []config.PayloadRule{{ Models: modelRules, Params: map[string]any{ "thinking.type": "disabled", "context_management": map[string]any{"edits": []any{map[string]any{"type": "payload_rule"}}}, }, }}}} upstreamBody := executeClaudeContextManagementRequest(t, cfg, basePayload, false) if got := gjson.GetBytes(upstreamBody, "context_management.edits.0.type").String(); got != "payload_rule" { t.Fatalf("payload-rule context_management type = %q, want payload_rule; body=%s", got, upstreamBody) } })
t.Run("exact automatic value remains payload rule owned", func(t *testing.T) { ownershipConfigs := []struct { name string cfg *config.Config }{ { name: "default", cfg: &config.Config{Payload: config.PayloadConfig{ Default: []config.PayloadRule{{ Models: modelRules, Params: map[string]any{"context_management": json.RawMessage(claudeCodeContextManagement)}, }}, Override: []config.PayloadRule{{ Models: modelRules, Params: map[string]any{"thinking.type": "disabled"}, }}, }}, }, { name: "raw default", cfg: &config.Config{Payload: config.PayloadConfig{ DefaultRaw: []config.PayloadRule{{ Models: modelRules, Params: map[string]any{"context_management": claudeCodeContextManagement}, }}, Override: []config.PayloadRule{{ Models: modelRules, Params: map[string]any{"thinking.type": "disabled"}, }}, }}, }, { name: "override", cfg: &config.Config{Payload: config.PayloadConfig{Override: []config.PayloadRule{{ Models: modelRules, Params: map[string]any{ "thinking.type": "disabled", "context_management": json.RawMessage(claudeCodeContextManagement), }, }}}}, }, { name: "raw override", cfg: &config.Config{Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: modelRules, Params: map[string]any{"thinking.type": "disabled"}, }}, OverrideRaw: []config.PayloadRule{{ Models: modelRules, Params: map[string]any{"context_management": claudeCodeContextManagement}, }}, }}, }, } for _, ownership := range ownershipConfigs { for _, stream := range []bool{false, true} { name := ownership.name + " execute" if stream { name += " stream" } t.Run(name, func(t *testing.T) { upstreamBody := executeClaudeContextManagementRequest(t, ownership.cfg, basePayload, stream) if got := gjson.GetBytes(upstreamBody, "thinking.type").String(); got != "disabled" { t.Fatalf("final upstream thinking.type = %q, want disabled; body=%s", got, upstreamBody) } if got := gjson.GetBytes(upstreamBody, "context_management").Raw; got != claudeCodeContextManagement { t.Fatalf("%s context_management = %s, want payload-rule-owned %s; body=%s", ownership.name, got, claudeCodeContextManagement, upstreamBody) } }) } } })
t.Run("payload filter remains effective", func(t *testing.T) { cfg := &config.Config{Payload: config.PayloadConfig{Filter: []config.PayloadFilterRule{{ Models: modelRules, Params: []string{"context_management"}, }}}} upstreamBody := executeClaudeContextManagementRequest(t, cfg, basePayload, false) if got := gjson.GetBytes(upstreamBody, "context_management"); got.Exists() { t.Fatalf("filtered context_management = %s, want absent", got.Raw) } })
for _, stream := range []bool{false, true} { // Anthropic rejects the automatic strategy once forced tool choice has // stripped thinking: // // `clear_thinking_20251015` strategy requires `thinking` to be enabled or adaptive name := "forced tool choice drops automatic context management execute" if stream { name += " stream" } t.Run(name, func(t *testing.T) { payload := []byte(`{"model":"claude-opus-5","max_tokens":16,"messages":[{"role":"user","content":"hi"}],"thinking":{"type":"adaptive"},"tool_choice":{"type":"any"}}`) upstreamBody := executeClaudeContextManagementRequest(t, &config.Config{}, payload, stream) if got := gjson.GetBytes(upstreamBody, "thinking"); got.Exists() { t.Fatalf("forced tool choice thinking = %s, want absent", got.Raw) } if got := gjson.GetBytes(upstreamBody, "context_management"); got.Exists() { t.Fatalf("forced tool choice context_management = %s, want absent because Anthropic rejects it without thinking", got.Raw) } if got := gjson.GetBytes(upstreamBody, "tool_choice.type").String(); got != "any" { t.Fatalf("forced tool_choice.type = %q, want any", got) } }) }}
func TestClaudeExecutorPayloadOverrideReenablesThinking(t *testing.T) { const model = "claude-opus-5" modelRules := []config.PayloadModelRule{{Name: model, Protocol: "claude"}} basePayload := []byte(`{"model":"claude-opus-5","max_tokens":16,"messages":[{"role":"user","content":"hi"}],"thinking":{"type":"disabled"}}`)
for _, test := range []struct { name string thinkingType string stream bool }{ {name: "execute enabled", thinkingType: "enabled"}, {name: "execute adaptive", thinkingType: "adaptive"}, {name: "execute stream enabled", thinkingType: "enabled", stream: true}, {name: "execute stream adaptive", thinkingType: "adaptive", stream: true}, } { t.Run(test.name, func(t *testing.T) { cfg := &config.Config{Payload: config.PayloadConfig{Override: []config.PayloadRule{{ Models: modelRules, Params: map[string]any{"thinking.type": test.thinkingType}, }}}} upstreamBody := executeClaudeContextManagementRequest(t, cfg, basePayload, test.stream) if got := gjson.GetBytes(upstreamBody, "thinking.type").String(); got != test.thinkingType { t.Fatalf("final upstream thinking.type = %q, want %q; body=%s", got, test.thinkingType, upstreamBody) } if got := gjson.GetBytes(upstreamBody, "context_management").Raw; got != claudeCodeContextManagement { t.Fatalf("final upstream context_management = %s, want %s after payload override to %s; body=%s", got, claudeCodeContextManagement, test.thinkingType, upstreamBody) } }) }
for _, stream := range []bool{false, true} { nameSuffix := "execute" if stream { nameSuffix = "execute stream" }
t.Run("caller context management is preserved after re-enabling "+nameSuffix, func(t *testing.T) { cfg := &config.Config{Payload: config.PayloadConfig{Override: []config.PayloadRule{{ Models: modelRules, Params: map[string]any{"thinking.type": "enabled"}, }}}} payload := []byte(`{"model":"claude-opus-5","max_tokens":16,"messages":[{"role":"user","content":"hi"}],"thinking":{"type":"disabled"},"context_management":{"edits":[{"type":"caller_owned"}]}}`) upstreamBody := executeClaudeContextManagementRequest(t, cfg, payload, stream) if got := gjson.GetBytes(upstreamBody, "context_management.edits.0.type").String(); got != "caller_owned" { t.Fatalf("caller context_management type = %q, want caller_owned; body=%s", got, upstreamBody) } })
t.Run("custom payload rule object is preserved after re-enabling "+nameSuffix, func(t *testing.T) { cfg := &config.Config{Payload: config.PayloadConfig{Override: []config.PayloadRule{{ Models: modelRules, Params: map[string]any{ "thinking.type": "adaptive", "context_management": map[string]any{"edits": []any{map[string]any{"type": "payload_rule"}}}, }, }}}} upstreamBody := executeClaudeContextManagementRequest(t, cfg, basePayload, stream) if got := gjson.GetBytes(upstreamBody, "context_management.edits.0.type").String(); got != "payload_rule" { t.Fatalf("payload-rule context_management type = %q, want payload_rule; body=%s", got, upstreamBody) } })
t.Run("context management filter remains authoritative after re-enabling "+nameSuffix, func(t *testing.T) { cfg := &config.Config{Payload: config.PayloadConfig{ Override: []config.PayloadRule{{ Models: modelRules, Params: map[string]any{"thinking.type": "enabled"}, }}, Filter: []config.PayloadFilterRule{{ Models: modelRules, Params: []string{"context_management"}, }}, }} upstreamBody := executeClaudeContextManagementRequest(t, cfg, basePayload, stream) if got := gjson.GetBytes(upstreamBody, "thinking.type").String(); got != "enabled" { t.Fatalf("final upstream thinking.type = %q, want enabled; body=%s", got, upstreamBody) } if got := gjson.GetBytes(upstreamBody, "context_management"); got.Exists() { t.Fatalf("filtered context_management = %s after re-enabling, want absent; body=%s", got.Raw, upstreamBody) } }) }}
func executeClaudeContextManagementRequest(t *testing.T, cfg *config.Config, payload []byte, stream bool) []byte { t.Helper()
var upstreamBody []byte transport := roundTripperFunc(func(req *http.Request) (*http.Response, error) { var errRead error upstreamBody, errRead = io.ReadAll(req.Body) if errRead != nil { t.Fatal(errRead) } contentType := "application/json" responseBody := `{"id":"msg_test","type":"message","role":"assistant","model":"claude-opus-5","content":[{"type":"text","text":"ok"}],"stop_reason":"end_turn","usage":{"input_tokens":1,"output_tokens":1}}` if stream { contentType = "text/event-stream" responseBody = "event: message_start\ndata: {\"type\":\"message_start\",\"message\":{\"id\":\"msg_test\",\"type\":\"message\",\"role\":\"assistant\",\"model\":\"claude-opus-5\",\"content\":[],\"stop_reason\":null,\"usage\":{\"input_tokens\":1,\"output_tokens\":0}}}\n\nevent: message_stop\ndata: {\"type\":\"message_stop\"}\n\n" } return &http.Response{ StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{contentType}}, Body: io.NopCloser(strings.NewReader(responseBody)), Request: req, }, nil }) ctx := context.WithValue(context.Background(), "cliproxy.roundtripper", http.RoundTripper(transport)) executor := NewClaudeExecutor(cfg) auth := &cliproxyauth.Auth{Attributes: map[string]string{"api_key": "key-payload-rule", "cloak_mode": "always"}} request := cliproxyexecutor.Request{Model: "claude-opus-5", Payload: payload} options := cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}
if stream { result, errStream := executor.ExecuteStream(ctx, auth, request, options) if errStream != nil { t.Fatalf("ExecuteStream() error = %v", errStream) } for chunk := range result.Chunks { if chunk.Err != nil { t.Fatalf("stream chunk error = %v", chunk.Err) } } return upstreamBody } if _, errExecute := executor.Execute(ctx, auth, request, options); errExecute != nil { t.Fatalf("Execute() error = %v", errExecute) } return upstreamBody}
func TestValidateClaudeCallerSystemBlocksAcceptsTextOnly(t *testing.T) { tests := []struct { name string system string }{ {name: "string", system: `"S1"`}, {name: "text blocks", system: `[{"type":"text","text":"S1"},{"type":"text","text":"S2"}]`}, {name: "absent", system: ``}, } for _, test := range tests { t.Run(test.name, func(t *testing.T) { payload := `{"model":"claude-opus-5"}` if test.system != "" { payload = `{"model":"claude-opus-5","system":` + test.system + `}` } if err := validateClaudeCallerSystemBlocks(gjson.Get(payload, "system")); err != nil { t.Fatalf("validateClaudeCallerSystemBlocks() error = %v, want nil", err) } }) }}
// Anthropic rejects every non-text block in both system slots, verified live on// 2026-08-03: the top-level field answers "system.<i>.type: Input should be// 'text'" and a role=system message answers "role 'system' supports text,// tool_addition, and tool_removal blocks only". Cloaking has no third slot, so// the request has to fail here instead of losing the caller's instructions.func TestValidateClaudeCallerSystemBlocksRejectsNonTextBlock(t *testing.T) { tests := []struct { name string system string wantIndex string wantType string }{ { name: "image", system: `[{"type":"text","text":"S1"},{"type":"image","source":{"type":"base64","media_type":"image/png","data":"AAAA"}}]`, wantIndex: "system.1.type", wantType: `"image"`, }, { name: "responses marker", system: `[{"type":"input_file"}]`, wantIndex: "system.0.type", wantType: `"input_file"`, }, { name: "missing type", system: `[{"text":"S1"}]`, wantIndex: "system.0.type", wantType: `"unknown"`, }, } for _, test := range tests { t.Run(test.name, func(t *testing.T) { err := validateClaudeCallerSystemBlocks(gjson.Parse(test.system)) if err == nil { t.Fatal("validateClaudeCallerSystemBlocks() error = nil, want rejection") } var statusCoder interface{ StatusCode() int } if !errors.As(err, &statusCoder) || statusCoder.StatusCode() != http.StatusBadRequest { t.Fatalf("error status = %v, want 400", err) } var scoped interface{ IsRequestScoped() bool } if !errors.As(err, &scoped) || !scoped.IsRequestScoped() { t.Fatalf("error %v must be request scoped so no other credential is tried", err) } if got := err.Error(); !strings.Contains(got, test.wantIndex) || !strings.Contains(got, test.wantType) { t.Fatalf("error = %q, want it to name %s and %s", got, test.wantIndex, test.wantType) } }) }}
func TestApplyCloakingRejectsNonTextCallerSystemBlock(t *testing.T) { cfg := &config.Config{} auth := &cliproxyauth.Auth{Attributes: map[string]string{"api_key": "key-123", "cloak_mode": "always"}} payload := []byte(`{"model":"claude-opus-5","system":[{"type":"text","text":"S1"},{"type":"input_image"}],"messages":[{"role":"user","content":[{"type":"text","text":"U1"}]}]}`)
out, cloaked, errCloaking := applyCloaking(context.Background(), cfg, auth, payload, "key-123", false, true) if errCloaking == nil { t.Fatal("applyCloaking() error = nil, want rejection") } if out != nil { t.Fatalf("applyCloaking() payload = %s, want nil", out) } if cloaked { t.Fatal("applyCloaking() cloaked = true, want false") }}
// Strict mode never forwards caller system prompts, so an unusable block cannot// lose information and must not fail the request.func TestApplyCloakingStrictModeIgnoresNonTextCallerSystemBlock(t *testing.T) { cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "key-123", Cloak: &config.CloakConfig{StrictMode: true}, }}, } auth := &cliproxyauth.Auth{Attributes: map[string]string{"api_key": "key-123"}} payload := []byte(`{"model":"claude-opus-5","system":[{"type":"input_image"}],"messages":[{"role":"user","content":[{"type":"text","text":"U1"}]}]}`)
out, cloaked, errCloaking := applyCloaking(context.Background(), cfg, auth, payload, "key-123", false, true) if errCloaking != nil { t.Fatalf("applyCloaking() error = %v, want nil", errCloaking) } if !cloaked { t.Fatal("applyCloaking() cloaked = false, want true") } if got := len(gjson.GetBytes(out, "system").Array()); got != 2 { t.Fatalf("system blocks = %d, want the 2 Claude Code blocks", got) }}
// Count-token requests reject non-text system blocks before any upstream call.func TestClaudeExecutor_CountTokensRejectsNonTextCallerSystemBlock(t *testing.T) { upstreamCalled := false transport := roundTripperFunc(func(req *http.Request) (*http.Response, error) { upstreamCalled = true return &http.Response{StatusCode: http.StatusOK, Header: http.Header{"Content-Type": []string{"application/json"}}, Body: io.NopCloser(strings.NewReader(`{"input_tokens":1}`)), Request: req}, nil }) ctx := context.WithValue(context.Background(), "cliproxy.roundtripper", http.RoundTripper(transport)) auth := &cliproxyauth.Auth{Attributes: map[string]string{"api_key": "sk-ant-oat-count-system-block"}} payload := []byte(`{"model":"claude-opus-5","system":[{"type":"text","text":"S1"},{"type":"input_image"}],"messages":[{"role":"user","content":[{"type":"text","text":"x"}]}]}`)
_, errCount := NewClaudeExecutor(&config.Config{}).countTokensUpstream(ctx, auth, cliproxyexecutor.Request{Model: "claude-opus-5", Payload: payload}, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if errCount == nil { t.Fatal("countTokensUpstream() error = nil, want rejection") } var statusCoder interface{ StatusCode() int } if !errors.As(errCount, &statusCoder) || statusCoder.StatusCode() != http.StatusBadRequest { t.Fatalf("countTokensUpstream() error = %v, want 400", errCount) } if upstreamCalled { t.Fatal("countTokensUpstream() called upstream, want local rejection") }}
// The native gate selects the 1h cache pool only for OAuth credentials and pushes// extended-cache-ttl-2025-04-11 exactly when that selection produced a 1h body ttl.// Body ttl and the beta must therefore always travel together.func TestClaudeExecutor_CacheTTLIsPairedWithExtendedCacheTTLBeta(t *testing.T) { tests := []struct { name string apiKey string wantTTL string wantBeta bool }{ { name: "oauth credential selects the 1h pool", apiKey: "sk-ant-oat-cache-ttl-pairing", wantTTL: "1h", wantBeta: true, }, { name: "api key credential keeps the default pool", apiKey: "key-cache-ttl-pairing", wantTTL: "", wantBeta: false, }, } for _, test := range tests { t.Run(test.name, func(t *testing.T) { var seenBody []byte var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenBody, _ = io.ReadAll(r.Body) seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-opus-4-6","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ ID: "cache-ttl-pairing", Attributes: map[string]string{ "api_key": test.apiKey, "base_url": server.URL, "cloak_mode": "always", }, Metadata: claudeOAuthTestMetadata(), } _, errExecute := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-opus-4-6", Payload: []byte(`{"model":"claude-opus-4-6","messages":[{"role":"user","content":[{"type":"text","text":"x"}]}]}`), }, cliproxyexecutor.Options{SourceFormat: sdktranslator.FormatClaude}) if errExecute != nil { t.Fatalf("Execute() error = %v", errExecute) }
gotTTL := gjson.GetBytes(seenBody, "system.1.cache_control.ttl").String() if gotTTL != test.wantTTL { t.Fatalf("system[1].cache_control.ttl = %q, want %q: %s", gotTTL, test.wantTTL, seenBody) } if got := gjson.GetBytes(seenBody, "system.1.cache_control.type").String(); got != "ephemeral" { t.Fatalf("system[1].cache_control.type = %q, want ephemeral: %s", got, seenBody) } gotBeta := strings.Contains(seenHeaders.Get("Anthropic-Beta"), claudeExtendedCacheTTLBeta) if gotBeta != test.wantBeta { t.Fatalf("extended-cache-ttl declared = %v, want %v: %s", gotBeta, test.wantBeta, seenHeaders.Get("Anthropic-Beta")) } // The pairing invariant itself: a 1h body ttl without the beta, or the beta // without a 1h body ttl, is a combination native never produces. if (gotTTL == "1h") != gotBeta { t.Fatalf("body ttl %q and extended-cache-ttl beta %v disagree", gotTTL, gotBeta) } }) }}
func TestClaudeExecutor_PreservesNativeAgentAndEnvironmentHeaders(t *testing.T) { tests := []struct { name string incomingHeaders http.Header wantHeaders map[string]string wantAbsent []string }{ { name: "preserves canonical agent and parent agent headers", incomingHeaders: http.Header{ "X-Claude-Code-Agent-Id": {"subagent-001"}, "X-Claude-Code-Parent-Agent-Id": {"parent-agent-root"}, }, wantHeaders: map[string]string{ "X-Claude-Code-Agent-Id": "subagent-001", "X-Claude-Code-Parent-Agent-Id": "parent-agent-root", }, }, { name: "preserves lowercased agent and environment headers", incomingHeaders: http.Header{ "x-claude-code-agent-id": {"agent-xyz"}, "x-claude-remote-container-id": {"container-123"}, "x-claude-remote-session-id": {"remote-sess-456"}, "x-client-app": {"custom-sdk"}, "x-anthropic-additional-protection": {"true"}, }, wantHeaders: map[string]string{ "X-Claude-Code-Agent-Id": "agent-xyz", "X-Claude-Remote-Container-Id": "container-123", "X-Claude-Remote-Session-Id": "remote-sess-456", "X-Client-App": "custom-sdk", "X-Anthropic-Additional-Protection": "true", }, }, { name: "does not fabricate agent header when absent", incomingHeaders: http.Header{ "User-Agent": {"test-client"}, }, wantAbsent: []string{ "X-Claude-Code-Agent-Id", "X-Claude-Code-Parent-Agent-Id", "X-Claude-Remote-Container-Id", "X-Claude-Remote-Session-Id", "X-Client-App", "X-Anthropic-Additional-Protection", }, }, }
for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_agent","type":"message","model":"claude-opus-4-6","role":"assistant","content":[{"type":"text","text":"ok"}],"usage":{"input_tokens":1,"output_tokens":1}}`)) })) defer server.Close()
executor := NewClaudeExecutor(&config.Config{}) auth := &cliproxyauth.Auth{ ID: "agent-header-test", Attributes: map[string]string{ "api_key": "sk-ant-test-key", "base_url": server.URL, "cloak_mode": "always", }, Metadata: claudeOAuthTestMetadata(), }
_, errExecute := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-opus-4-6", Payload: []byte(`{"model":"claude-opus-4-6","messages":[{"role":"user","content":[{"type":"text","text":"hi"}]}]}`), }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, Headers: tt.incomingHeaders, }) if errExecute != nil { t.Fatalf("Execute() error = %v", errExecute) }
for wantKey, wantVal := range tt.wantHeaders { if got := seenHeaders.Get(wantKey); got != wantVal { t.Errorf("header %s = %q, want %q", wantKey, got, wantVal) } } for _, absentKey := range tt.wantAbsent { if got := seenHeaders.Get(absentKey); got != "" { t.Errorf("header %s = %q, want absent", absentKey, got) } } }) }}
func TestIsClaudeFable51Model_DigitBoundary(t *testing.T) { valid := []string{ "claude-fable-5-1", "claude-fable-5.1", "claude-fable-5-1-20260901", "claude-mythos-5-1", "claude-mythos-5.1", "claude-mythos-5-1-preview", } for _, m := range valid { if !isClaudeFable51Model(m) { t.Errorf("expected %q to be recognized as Fable 5.1", m) } }
invalid := []string{ "claude-fable-5-10", "claude-fable-5.10", "claude-mythos-5-10", "claude-sonnet-5", "claude-opus-5", "claude-haiku-4-5", } for _, m := range invalid { if isClaudeFable51Model(m) { t.Errorf("expected %q NOT to be recognized as Fable 5.1", m) } }}
func TestClaudeExecutor_ProbeStripsCaller1hTTLAndBetas(t *testing.T) { var seenHeaders http.Header var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenHeaders = r.Header.Clone() seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-sonnet-5","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-probe-ttl-test", }}, } auth := &cliproxyauth.Auth{ ID: "auth-probe-ttl-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-probe-ttl-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) // Probe request with caller-supplied 1h TTL and forbidden betas payload := []byte(`{ "model": "claude-sonnet-5", "max_tokens": 1, "messages": [{ "role": "user", "content": [ {"type": "text", "text": "quota", "cache_control": {"type": "ephemeral", "ttl": "1h"}} ] }] }`) incomingHeaders := http.Header{} incomingHeaders.Set("Anthropic-Beta", "extended-cache-ttl-2025-04-11,server-side-fallback-2026-06-01,thinking-display-updates-2026-08-18,effort-2025-11-24")
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, Headers: incomingHeaders, }) if err != nil { t.Fatalf("Execute error = %v", err) }
// 1. Verify body cache_control does not have ttl: "1h" rawBody := string(seenBody) if strings.Contains(rawBody, `"ttl":"1h"`) || strings.Contains(rawBody, `"ttl": "1h"`) { t.Fatalf("probe body must have ttl stripped, got: %s", rawBody) }
// 2. Verify forbidden betas are stripped from header betas := seenHeaders.Get("Anthropic-Beta") for _, forbidden := range []string{ "extended-cache-ttl-2025-04-11", "server-side-fallback-2026-06-01", "thinking-display-updates-2026-08-18", "effort-2025-11-24", } { if strings.Contains(betas, forbidden) { t.Errorf("probe Anthropic-Beta must not contain %s, got: %s", forbidden, betas) } }}
func TestClaudeExecutor_SubagentStripsCaller1hTTLAndExtendedCacheBeta(t *testing.T) { var seenHeaders http.Header var seenBody []byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenHeaders = r.Header.Clone() seenBody, _ = io.ReadAll(r.Body) w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-sonnet-5","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-subagent-ttl-test", }}, } auth := &cliproxyauth.Auth{ ID: "auth-subagent-ttl-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-subagent-ttl-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{ "model": "claude-sonnet-5", "messages": [{ "role": "user", "content": [ {"type": "text", "text": "subagent work", "cache_control": {"type": "ephemeral", "ttl": "1h"}} ] }] }`) incomingHeaders := http.Header{} incomingHeaders.Set("X-Claude-Code-Agent-Id", "agent-sub-123") incomingHeaders.Set("Anthropic-Beta", "extended-cache-ttl-2025-04-11")
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, Headers: incomingHeaders, }) if err != nil { t.Fatalf("Execute error = %v", err) }
// 1. Verify body cache_control does not have ttl: "1h" rawBody := string(seenBody) if strings.Contains(rawBody, `"ttl":"1h"`) || strings.Contains(rawBody, `"ttl": "1h"`) { t.Fatalf("subagent body must have ttl stripped, got: %s", rawBody) }
// 2. Verify extended-cache-ttl beta is stripped from header betas := seenHeaders.Get("Anthropic-Beta") if strings.Contains(betas, "extended-cache-ttl-2025-04-11") { t.Errorf("subagent Anthropic-Beta must not contain extended-cache-ttl, got: %s", betas) }}
func TestClaudeExecutor_DisabledThinkingStripsDisplayBeta(t *testing.T) { var seenHeaders http.Header server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { seenHeaders = r.Header.Clone() w.Header().Set("Content-Type", "application/json") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-sonnet-5","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-disabled-thinking-beta-test", }}, } auth := &cliproxyauth.Auth{ ID: "auth-disabled-thinking-beta-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-disabled-thinking-beta-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) payload := []byte(`{ "model": "claude-sonnet-5", "thinking": {"type": "disabled"}, "messages": [{ "role": "user", "content": "hello" }] }`) incomingHeaders := http.Header{} incomingHeaders.Set("Anthropic-Beta", "thinking-display-updates-2026-08-18,effort-2025-11-24")
_, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: payload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, Headers: incomingHeaders, }) if err != nil { t.Fatalf("Execute error = %v", err) }
betas := seenHeaders.Get("Anthropic-Beta") if strings.Contains(betas, "thinking-display-updates-2026-08-18") { t.Errorf("disabled thinking must not send thinking-display-updates beta, got: %s", betas) } if strings.Contains(betas, "effort-2025-11-24") { t.Errorf("disabled thinking must not send effort beta, got: %s", betas) }}
func TestClaudeExecutor_CloakModePrefersStoredPrevReqOverCallerFake(t *testing.T) { var seenBodies [][]byte server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { body, _ := io.ReadAll(r.Body) seenBodies = append(seenBodies, body) w.Header().Set("Content-Type", "application/json") w.Header().Set("request-id", "req_real_upstream_001") _, _ = w.Write([]byte(`{"id":"msg_1","type":"message","model":"claude-sonnet-5","role":"assistant","content":[{"type":"text","text":"ok"}]}`)) })) defer server.Close()
cfg := &config.Config{ ClaudeKey: []config.ClaudeKey{{ APIKey: "sk-ant-oat-cloak-prev-req-test", Cloak: &config.CloakConfig{}, }}, } auth := &cliproxyauth.Auth{ ID: "auth-cloak-prev-req-test", Metadata: claudeOAuthTestMetadata(), Attributes: map[string]string{ "api_key": "sk-ant-oat-cloak-prev-req-test", "base_url": server.URL, }, }
executor := NewClaudeExecutor(cfg) headers := http.Header{"Session-Id": []string{"sess-test-001"}}
// Turn 1: normal turn, establishes real upstream request-id req_real_upstream_001 _, err := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: []byte(`{"model":"claude-sonnet-5","messages":[{"role":"user","content":"turn 1"}]}`), }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, Headers: headers, }) if err != nil { t.Fatalf("Turn 1 Execute error = %v", err) }
// Turn 2: a non-native caller in cloak mode sends a fake cc_prev_req in system fakeCallerPayload := []byte(`{ "model": "claude-sonnet-5", "system": [ {"type": "text", "text": "x-anthropic-billing-header: cc_version=2.1.258.000; cc_entrypoint=cli; cch=00000; cc_prev_req=req_fake_caller_999; cc_prompt_id=aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee;"}, {"type": "text", "text": "custom instructions"} ], "messages": [ {"role":"user","content":"turn 1"}, {"role":"assistant","content":"ok"}, {"role":"user","content":"turn 2"} ] }`)
_, err2 := executor.Execute(context.Background(), auth, cliproxyexecutor.Request{ Model: "claude-sonnet-5", Payload: fakeCallerPayload, }, cliproxyexecutor.Options{ SourceFormat: sdktranslator.FormatClaude, Headers: headers, }) if err2 != nil { t.Fatalf("Turn 2 Execute error = %v", err2) }
if len(seenBodies) < 2 { t.Fatalf("expected at least 2 requests, got %d", len(seenBodies)) } turn2System := gjson.GetBytes(seenBodies[1], "system.0.text").String() if !strings.Contains(turn2System, "cc_prev_req=req_real_upstream_001") { t.Fatalf("CPA in cloak mode must use real storedPrevReq req_real_upstream_001, got: %s", turn2System) } if strings.Contains(turn2System, "req_fake_caller_999") { t.Fatalf("CPA must not use fake caller cc_prev_req, got: %s", turn2System) }}