Skip to content

Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors

83.0 KB
Raw Blame

🗜️ Prompt Compression Guide — OmniRoute (ગુજરાતી)

🌐 Languages: 🇺🇸 English · 🇪🇹 am · 🇸🇦 ar · 🇦🇿 az · 🇧🇬 bg · 🇧🇩 bn · 🇧🇦 bs · 🇨🇿 cs · 🇩🇰 da · 🇩🇪 de · 🇬🇷 el · 🇪🇸 es · 🇪🇪 et · 🇮🇷 fa · 🇫🇮 fi · 🇫🇷 fr · 🇮🇪 ga · 🇳🇬 ha · 🇮🇱 he · 🇮🇳 hi · 🇭🇷 hr · 🇭🇺 hu · 🇦🇲 hy · 🇮🇩 id · 🇳🇬 ig · 🇮🇹 it · 🇯🇵 ja · 🇬🇪 ka · 🇰🇭 km · 🇮🇳 kn · 🇰🇷 ko · 🇱🇹 lt · 🇱🇻 lv · 🇮🇳 ml · 🇮🇳 mr · 🇲🇾 ms · 🇲🇹 mt · 🇲🇲 my · 🇳🇵 ne · 🇳🇱 nl · 🇳🇴 no · 🇮🇳 or · 🇮🇳 pa · 🇵🇭 phi · 🇵🇱 pl · 🇵🇹 pt · 🇧🇷 pt-BR · 🇷🇴 ro · 🇷🇺 ru · 🇱🇰 si · 🇸🇰 sk · 🇸🇮 sl · 🇷🇸 sr · 🇸🇪 sv · 🇰🇪 sw · 🇮🇳 ta · 🇮🇳 te · 🇹🇭 th · 🇹🇷 tr · 🇺🇦 uk-UA · 🇵🇰 ur · 🇺🇿 uz · 🇻🇳 vi · 🇳🇬 yo · 🇨🇳 zh-CN · 🇹🇼 zh-TW


પાત્ર સંદર્ભ પર આપમેળે 15-95% બચાવો. ઝડપી અવલોકન માટે, README Compression વિભાગ જુઓ.

અવલોકન

OmniRoute એક મોડ્યુલર પ્રોમ્પ્ટ કમ્પ્રેશન પાઇપલાઇન અમલમાં મૂકે છે, જે વિનંતીઓ અપસ્ટ્રીમ પ્રદાતાઓ સુધી પહોંચે તે પહેલાં સક્રિય રીતે ચાલે છે. આનો અર્થ એ છે કે તમારી ટોકન બચત પારદર્શક રીતે થાય છે — તમારા વર્કફ્લોમાં કોઈ ફેરફાર કરવાની જરૂર નથી.

ક્લાયન્ટ વિનંતી
  → કમ્પ્રેશન વ્યૂહરચના પસંદગીકાર
    → કૉમ્બો ઓવરરાઇડ? → કૉમ્બો સેટિંગનો ઉપયોગ કરો
    → સ્વચાલિત-ટ્રિગર થ્રેશોલ્ડ? → સ્વચાલિત મોડનો ઉપયોગ કરો
    → ડિફૉલ્ટ મોડ? → વૈશ્વિક સેટિંગનો ઉપયોગ કરો
    → બંધ? → કમ્પ્રેશન છોડો
  → પસંદ કરેલો કમ્પ્રેશન મોડ
    → બંધ: કોઈ કમ્પ્રેશન નહીં
    → લાઇટ: સુરક્ષિત વ્હાઇટસ્પેસ/ફોર્મેટિંગ સફાઈ (~15%)
    → સ્ટાન્ડર્ડ: Caveman-શૈલીમાં વધારાના શબ્દો દૂર કરવા (~30%)
    → એગ્રેસિવ: ઇતિહાસ એજિંગ + સારાંશીકરણ (~50%)
    → અલ્ટ્રા: હ્યુરિસ્ટિક પ્રૂનિંગ + કોડ-બ્લૉક પાતળા કરવા (~75%)
    → RTK: કમાન્ડ-અવેર ટર્મિનલ/ટૂલ-આઉટપુટ ફિલ્ટરિંગ (60-90% અપસ્ટ્રીમ રેન્જ)
    → સ્ટૅક્ડ: ક્રમબદ્ધ મલ્ટિ-એન્જિન પાઇપલાઇન, સામાન્ય રીતે પહેલાં RTK અને પછી Caveman (78-95% પાત્ર રેન્જ)
  → કમ્પ્રેસ કરેલી વિનંતી → પ્રદાતા

કમ્પ્રેશન મોડ્સ

બંધ

કોઈ કમ્પ્રેશન લાગુ કરવામાં આવતું નથી. બધા સંદેશા કોઈ ફેરફાર વિના પસાર થાય છે.

લાઇટ મોડ (~15% બચત, <1ms લેટન્સી)

સૌથી સુરક્ષિત મોડ — અર્થમાં શૂન્ય ફેરફાર, માત્ર ફોર્મેટિંગની સફાઈ:

તકનીક વર્ણન
collapseWhitespace લગાતાર ખાલી લાઇનો અને લાઇનના અંતેની સ્પેસને મર્જ કરે છે
dedupSystemPrompt ડુપ્લિકેટ સિસ્ટમ સંદેશા દૂર કરે છે
compressToolResults વિસ્તૃત ટૂલ/ફંક્શન આઉટપુટને કમ્પ્રેસ કરે છે
removeRedundantContent પુનરાવર્તિત સૂચનાઓ દૂર કરે છે
replaceImageUrls base64 ઇમેજ ડેટા URIને ટૂંકા કરે છે

આ માટે શ્રેષ્ઠ: હંમેશાં ચાલુ રાખીને ઉપયોગ કરવા અને સુરક્ષા-નિર્ણાયક વર્કફ્લો માટે.

સ્ટાન્ડર્ડ મોડ (~30% બચત)

Cavemanથી પ્રેરિત — અર્થ જાળવી રાખીને વધારાના શબ્દો અને વિસ્તૃત શબ્દપ્રયોગ દૂર કરે છે:

  • વધારાના શબ્દો દૂર કરે છે ("કૃપા કરીને", "મને લાગે છે", "મૂળભૂત રીતે", "ખરેખર")
  • વિસ્તૃત શબ્દસમૂહોને સંક્ષિપ્ત કરે છે ("ના હેતુથી" → "માટે", "ના પરિણામે" → "કારણ કે")
  • વિનમ્ર સંકોચભર્યા શબ્દપ્રયોગ દૂર કરે છે ("શું તમને વાંધો હશે...", "જો તમે કદાચ કરી શકો તો...")
  • કોડિંગ પ્રોમ્પ્ટ માટે અનુકૂલિત 30+ regex નિયમો

આ માટે શ્રેષ્ઠ: દૈનિક કોડિંગ વર્કફ્લો અને ખર્ચ પ્રત્યે સચેત ટીમો માટે.

એગ્રેસિવ મોડ (~50% બચત)

લાંબા સત્રો માટે સ્માર્ટ ઇતિહાસ વ્યવસ્થાપન:

  • સંદેશ એજિંગ — જૂના સંદેશા ક્રમશઃ વધુ કમ્પ્રેસ થાય છે
  • ટૂલ પરિણામ કમ્પ્રેશન — લાંબા ટૂલ આઉટપુટને કાપવામાં કે છોડી દેવામાં આવે છે (પ્રથમ/છેલ્લી લાઇનો, મેળ ખાતી લાઇનનું ફિલ્ટરિંગ, JSON કીનું સંકોચન)
  • માળખાકીય અખંડિતતા સુરક્ષાઓ — ખાતરી કરે છે કે tool_use + tool_result જોડીઓ સુસંગત રહે
  • કોન્ટેક્સ્ટ વિન્ડો જાગૃતિ — દરેક મોડલની ટોકન મર્યાદાનું પાલન કરે છે

આ માટે શ્રેષ્ઠ: વિસ્તૃત ડિબગિંગ સત્રો અને મોટા કોડબેઝ માટે.

અલ્ટ્રા મોડ (~75% બચત)

ટોકન-નિર્ણાયક પરિસ્થિતિઓ માટે મહત્તમ કમ્પ્રેશન:

  • હ્યુરિસ્ટિક પ્રૂનિંગ — ગદ્યનું સ્કોર-આધારિત ટોકન પ્રૂનિંગ
  • માળખું જાળવણી — ફેન્સ્ડ કોડ બ્લૉક્સ, ઇનલાઇન કોડ, URLs અને આઇડેન્ટિફાયર્સને ટોમ્બસ્ટોન કરીને મૂળરૂપે ફરી જોડવામાં આવે છે, તેમને ક્યારેય પ્રૂન કરવામાં આવતા નથી
  • વૈકલ્પિક SLM સ્તર — કૉન્ફિગર કરેલું હોય ત્યારે નાનું સ્થાનિક મોડલ પ્રૂનને વધુ ચોક્કસ બનાવી શકે છે
  • એગ્રેસિવ મોડથી સ્વતંત્ર: તે સંદેશ એજિંગ, ટૂલ-પરિણામ કમ્પ્રેશન અથવા ફૉલબૅક સારાંશક ચલાવતું નથી (માત્ર SLM-સ્તરની નિષ્ફળતા જ ફૉલબૅક પાસને એગ્રેસિવ મારફતે રૂટ કરી શકે છે)

આ માટે શ્રેષ્ઠ: જ્યારે તમે વારંવાર કોન્ટેક્સ્ટ મર્યાદા સુધી પહોંચી રહ્યા હોવ.

RTK મોડ (60-90% અપસ્ટ્રીમ રેન્જ)

RTK મોડ કોડિંગ-એજન્ટ સત્રોમાં દેખાતા વિસ્તૃત ટૂલ આઉટપુટ માટે ઑપ્ટિમાઇઝ કરેલો છે:

  • git status, git diff, git log, ટેસ્ટ રનર્સ, TypeScript/Vite/Webpack બિલ્ડ્સ, ESLint/Biome/Prettier, npm ઑડિટ/ઇન્સ્ટોલ્સ, Docker લૉગ્સ, ઇન્ફ્રા આઉટપુટ અને સામાન્ય શેલ આઉટપુટ જેવા કમાન્ડ/આઉટપુટ વર્ગો શોધે છે
  • open-sse/services/compression/engines/rtk/filters/માંથી JSON ફિલ્ટર પૅક્સ લાગુ કરે છે
  • પ્રોજેક્ટ અથવા વૈશ્વિક filters.toml ફાઇલોમાંથી RTK TOML schema v1 ફિલ્ટર્સ ઇમ્પોર્ટ કરે છે, જેમાં ઇનલાઇન-ટેસ્ટ માન્યતા અને પ્રોજેક્ટ ફાઇલો માટે ટ્રસ્ટ-ગેટિંગ સામેલ છે
  • ઇનલાઇન ચકાસણી નમૂનાઓ સાથે 55 બિલ્ટ-ઇન ફિલ્ટર્સ પૂરા પાડે છે
  • ANSI નિયંત્રણ સિક્વન્સ, પ્રોગ્રેસ બાર, પુનરાવર્તિત લાઇનો અને કાર્યવાહી ન કરી શકાય તેવો ઘોંઘાટ દૂર કરે છે
  • નિષ્ફળતાઓ, ભૂલો, ચેતવણીઓ, બદલાયેલી ફાઇલો, સારાંશો અને લાંબા આઉટપુટનો છેલ્લો ભાગ જાળવે છે
  • ટ્રસ્ટ-ગેટેડ પ્રોજેક્ટ ફિલ્ટર્સ, વૈશ્વિક ફિલ્ટર્સ અને વૈકલ્પિક રીતે સંપાદિત કાચા આઉટપુટની પુનઃપ્રાપ્તિને સપોર્ટ કરે છે

આ માટે શ્રેષ્ઠ: શેલ, બિલ્ડ, ટેસ્ટ, git, grep અને ફાઇલ-આઉટપુટ ટ્રાન્સક્રિપ્ટ ધરાવતા એજન્ટ સત્રો માટે.

સ્ટૅક્ડ મોડ (78-95% પાત્ર રેન્જ)

સ્ટૅક્ડ મોડ એક નિર્ધારિત ક્રમમાં અનેક કમ્પ્રેશન એન્જિન ચલાવે છે. ડિફૉલ્ટ પાઇપલાઇન આ છે:

RTK -> Caveman

આ ક્રમ પહેલાં ટર્મિનલ/ટૂલ આઉટપુટને સંક્ષિપ્ત રાખે છે, ત્યારબાદ બાકી રહેલા કુદરતી-ભાષાના પ્રોમ્પ્ટ પર Caveman અર્થલક્ષી સંક્ષેપ લાગુ કરે છે. સ્ટૅક્ડ પાઇપલાઇન્સને વૈશ્વિક રીતે અથવા રૂટિંગ કૉમ્બોને સોંપાયેલા કમ્પ્રેશન કૉમ્બો દ્વારા કૉન્ફિગર કરી શકાય છે.

આ માટે શ્રેષ્ઠ: મોટા ટૂલ લૉગ્સ ઉપરાંત માનવીય સૂચનાઓ અથવા સહાયક સારાંશો ધરાવતા મિશ્ર કોન્ટેક્સ્ટ માટે.


અપસ્ટ્રીમ બચતનું ગણિત

OmniRoute બે સ્રોતોમાંથી કમ્પ્રેશનની બચતનું દસ્તાવેજીકરણ કરે છે: અપસ્ટ્રીમ પ્રોજેક્ટ બેન્ચમાર્ક્સ અને OmniRouteનું પોતાનું એન્જિન સંયોજન.

સ્રોત અહીં ઉપયોગમાં લેવાયેલ અપસ્ટ્રીમ READMEનો આંકડો
Caveman ~75% ઓછા આઉટપુટ ટોકન્સ, બેન્ચમાર્કમાં સરેરાશ 65% આઉટપુટ બચત, 22-87%ની શ્રેણી અને ~46% ઇનપુટ કમ્પ્રેશન ટૂલ
RTK કમાન્ડ-આઉટપુટમાં 60-90% બચત; નમૂના સત્રમાં ~118,000 -> ~23,900 ટોકન્સ, અથવા 79.7% બચત (~80%)

ઓવરલેપ થતા ટૂલ/કોન્ટેક્સ્ટ પેલોડ્સ માટે, ડિફૉલ્ટ OmniRoute કોમ્બો એન્જિનોને આ ક્રમમાં સ્ટૅક કરે છે:

RTK -> Caveman

સંયુક્ત બચત ગુણાકાર આધારિત છે, સરવાળા આધારિત નહીં:

combined = 1 - (1 - RTK savings) * (1 - Caveman input savings)
average  = 1 - (1 - 0.80) * (1 - 0.46) = 89.2%
range    = 1 - (1 - 0.60..0.90) * (1 - 0.46) = 78.4-94.6%

આ 78-95%નો આંકડો ત્યારે લાગુ પડે છે જ્યારે RTK અને Caveman બંને સમાન ઇનપુટ/કોન્ટેક્સ્ટ પેલોડને ઘટાડી શકે. Cavemanનો રિસ્પોન્સ આઉટપુટ મોડ અલગ છે: જ્યારે તે સક્ષમ હોય, ત્યારે Cavemanની પોતાની આઉટપુટ બચતનો ઉપયોગ કરો (સરેરાશ 65%, મુખ્ય આંકડો ~75%, શ્રેણી 22-87%). કુલ બિલિંગ બચત તમારા પ્રોમ્પ્ટ/આઉટપુટના મિશ્રણ પર આધારિત છે.

"પાત્ર"નો ખરેખર અર્થ શું છે

15-95%ની મુખ્ય શ્રેણી વાસ્તવિક છે, પરંતુ તે ફક્ત પુનરાવર્તિત અથવા અતિવિસ્તૃત સામગ્રી પર જ લાગુ પડે છે — વારંવાર આવતી એરર લાઇનો, એક જ ચેતવણી વારંવાર બતાવતો બિલ્ડ લૉગ, અથવા જરૂર કરતાં મોટો grep/ફાઇલ-રીડ ડમ્પ. તેનો અર્થ એ નથી કે દરેક રિક્વેસ્ટમાં એટલી બચત થાય છે.

પ્રાયોગિક રીતે ચકાસાયેલ (tests/unit/compression/stacked-compression-tool-result-savings.test.ts): 300 સમાન એરર લાઇનો ધરાવતા Anthropic-આકારના tool_result બ્લૉક સામે stacked (RTK + Caveman) રન કરવાથી 95.93% ટોકન બચત / 96.26% અક્ષર બચત મળી — જે જાહેર કરેલી શ્રેણીમાં ચોક્કસપણે આવે છે. પરંતુ સામાન્ય, બિન-પુનરાવર્તિત ટૂલ આઉટપુટ (સ્વચ્છ grep મેચ સૂચિ, ટૂંકું ફાઇલ રીડ, સામાન્ય વાર્તાલાપી ટેક્સ્ટ) સામે એ જ પાઇપલાઇન ચલાવવાથી યોગ્ય રીતે લગભગ શૂન્ય બચત થાય છે, કારણ કે દૂર કરવા માટે કંઈપણ પુનરાવર્તિત નથી અને validateCompression() (validation.ts) એવા પુનર્લેખનને મોકલવાનો ઇનકાર કરે છે જે કોડ બ્લૉક્સ, URLs, હેડિંગ્સ, વર્ઝન્સ અથવા ALL-CAPS કૉન્સ્ટન્ટ આઇડેન્ટિફાયર્સને કાઢી નાખે કે બદલે.

આ અપેક્ષિત અને સુરક્ષિત વર્તન છે, બગ નહીં: જે કોડિંગ સત્રમાં મોટાભાગે સ્વચ્છ ફાઇલો વાંચવામાં/grep કરવામાં આવે છે તેમાં કમ્પ્રેશન સંપૂર્ણપણે સક્ષમ હોવા છતાં કુલ બચત મર્યાદિત જોવા મળશે, જ્યારે નિષ્ફળ થતી લૂપ અથવા ખૂબ વધુ આઉટપુટ આપતા લિન્ટરનો સામનો કરતું સત્ર તે ટ્રાફિક પર સંપૂર્ણ 78-95% શ્રેણી જોશે. કોઈ એક સત્રની નીચી એકંદર બચત ટકાવારીને કમ્પ્રેશન ખોટી રીતે કૉન્ફિગર થયું હોવાના પુરાવા તરીકે ઉપયોગ કરશો નહીં — પહેલાં તપાસો કે અંતર્ગત ટૂલ આઉટપુટ ખરેખર પુનરાવર્તિત હતું કે નહીં.


ટોકન બચતનું વિઝ્યુઅલાઇઝેશન

કમ્પ્રેશન વિના:             LLMને 47K ટોકન્સ મોકલાયા
Lite સાથે:                  40K ટોકન્સ મોકલાયા          (15% બચત — સુરક્ષિત, હંમેશાં ચાલુ)
Standard સાથે:              33K ટોકન્સ મોકલાયા          (30% બચત — caveman-speak નિયમો)
Aggressive સાથે:            24K ટોકન્સ મોકલાયા          (50% બચત — એજિંગ + સારાંશીકરણ)
Ultra સાથે:                 12K ટોકન્સ મોકલાયા          (75% બચત — હ્યુરિસ્ટિક પ્રૂનિંગ)
RTK સાથે:                   19K-5K ટોકન્સ મોકલાયા       (કમાન્ડ/ટૂલ આઉટપુટ પર 60-90% બચત)
Stacked સાથે:               10K-2.5K ટોકન્સ મોકલાયા     (પાત્ર RTK+Caveman શ્રેણીમાં 78-95% બચત)

રૂપરેખાંકન

ડેશબોર્ડ

ડેશબોર્ડ → કોન્ટેક્સ્ટ અને કૅશ પર જાઓ:

  • Caveman — મોડની પસંદગી, ભાષા પૅક્સ, પૂર્વાવલોકન અને વૈશ્વિક ડિફૉલ્ટ્સ
  • RTK — કમાન્ડ-ફિલ્ટર પૂર્વાવલોકન, RTK સુરક્ષા સેટિંગ્સ અને ફિલ્ટર કૅટલૉગ
  • કમ્પ્રેશન કોમ્બોઝ — રૂટિંગ કોમ્બોઝને સોંપેલી નામવાળી એન્જિન પાઇપલાઇન્સ
  • ઑટો-ટ્રિગર થ્રેશોલ્ડ — ટોકનની સંખ્યા થ્રેશોલ્ડ કરતાં વધી જાય ત્યારે કમ્પ્રેશન આપમેળે સક્રિય કરે છે

પ્રતિ-કોમ્બો ઓવરરાઇડ

ડેશબોર્ડ → કોન્ટેક્સ્ટ અને કૅશ → કમ્પ્રેશન કોમ્બોઝમાં, રૂટિંગ કોમ્બોને કમ્પ્રેશન કોમ્બો સોંપો:

કોમ્બો: "free-tier-fallback"
  કમ્પ્રેશન કોમ્બો: "coding-agent-stack"
  પાઇપલાઇન: RTK -> Caveman
  લક્ષ્યો:
    1. if/kimi-k2.7-code
    2. if/qwen3.8-max-preview

આ તમને પેઇડ સબ્સ્ક્રિપ્શન્સ પર લાઇટ મોડ જાળવી રાખીને મફત/કોડિંગ પ્રદાતાઓ પર સ્ટૅક્ડ કમ્પ્રેશનનો ઉપયોગ કરવાની મંજૂરી આપે છે.

આ "પ્રતિ-કોમ્બો ઓવરરાઇડ" સોંપણી રૂટિંગ-કોમ્બો કમ્પ્રેશન મોડ ઓવરરાઇડ (ડિફૉલ્ટ/બંધ/લાઇટ/સ્ટાન્ડર્ડ/આક્રમક/અલ્ટ્રા/Codex Responses — આ ફીલ્ડનું સ્કીમા rtk, stacked અને omniglyph પણ સ્વીકારે છે) કરતાં અલગ નિયંત્રણ છે — તે ઓવરરાઇડ નામવાળી કમ્પ્રેશન-કોમ્બો પાઇપલાઇન પસંદ કરતું નથી; તે માત્ર resolveCompressionPlan દ્વારા ઉપયોગમાં લેવાતું compressionMode ફીલ્ડ સેટ કરે છે. તેને કોમ્બો કાર્ડ (ડેશબોર્ડ → કોમ્બોઝ) પર અથવા, #6760થી, ઉપર દસ્તાવેજીકૃત પાઇપલાઇન-સોંપણી ચેકબૉક્સની બાજુમાં ડેશબોર્ડ → કોન્ટેક્સ્ટ અને કૅશ → કમ્પ્રેશન કોમ્બોઝ પરની "રૂટિંગને સોંપો" સૂચિમાં પ્રતિ રૂટિંગ કોમ્બો સેટ કરી શકાય છે. બંને સપાટીઓ સમાન PUT /api/combos/{id} એન્ડપોઇન્ટ દ્વારા સંગ્રહિત થાય છે.

પ્રતિ-વિનંતી ઓવરરાઇડ

એક વિનંતી માટે કમ્પ્રેશન પ્લાનને ઓવરરાઇડ કરવા x-omniroute-compression વિનંતી હેડર મોકલો. તેની પ્રાથમિકતા સૌથી ઊંચી છે — તે રૂટિંગ-કોમ્બો ઓવરરાઇડ, સક્રિય પ્રોફાઇલ, ઑટો-ટ્રિગર અને પેનલ ડિફૉલ્ટ કરતાં અગ્રતા ધરાવે છે. અજ્ઞાત મૂલ્યો અવગણવામાં આવે છે (વિનંતી ક્યારેય નકારવામાં આવતી નથી) અને વૈશ્વિક માસ્ટર સ્વિચ હજુ પણ બધું નિયંત્રિત કરે છે: જ્યારે કમ્પ્રેશન વૈશ્વિક સ્તરે બંધ હોય, ત્યારે હેડર તેને ચાલુ કરી શકતું નથી. મૂલ્યો:

મૂલ્ય અસર
off આ વિનંતી માટે કોઈ કમ્પ્રેશન નહીં.
default પેનલમાંથી મેળવેલી ડિફૉલ્ટ પ્રોફાઇલ (સક્રિય પ્રોફાઇલને અવગણે છે). લૉસી એન્જિનો બંધ રાખવામાં આવે છે.
safe હેડર ન આપ્યું હોય તેવું જ: ફક્ત ડિડુપ અને વ્હાઇટસ્પેસ ફોલ્ડિંગ.
allow-lossy સારાંશો, પ્રાસંગિકતા ફિલ્ટર્સ અને શૈલી પુનર્લેખન સહિત આ વિનંતીનો ઑપરેટર પ્લાન જાળવે છે.
engine:<id> સક્રિય હોય ત્યારે એક એન્જિન, દા.ત. engine:rtk. આ તે એન્જિન માટેનું પ્રતિ-વિનંતી ઑપ્ટ-ઇન છે.
<combo> એક નામવાળો કોમ્બો, જે પહેલાં નામથી (કેસ-ઇન્સેન્સિટિવ રીતે) અને પછી id દ્વારા મેળ ખાય છે.

allow-lossy, engine:<id> અથવા કોઈ નામવાળા કોમ્બો વિના, લૉસી એન્જિનો લાગુ કરવામાં આવતા નથી. કમ્પ્રેશન ચાલુ હોય ત્યારે પણ વિનંતી પર સેશન ડિડુપ અને વ્હાઇટસ્પેસ ફોલ્ડિંગ લાગુ થાય છે.

લાગુ કરાયેલ પ્લાનને X-OmniRoute-Compression: <mode>; source=<source> પ્રતિસાદ હેડરમાં પાછો દર્શાવવામાં આવે છે, જ્યાં <source> એ request-header, routing-override, active-profile, auto-trigger, default અથવા offમાંથી એક હોય છે.

API

# કમ્પ્રેશન સેટિંગ્સ મેળવો
curl http://localhost:20128/api/settings/compression

# કમ્પ્રેશન સેટિંગ્સ અપડેટ કરો
curl -X PUT http://localhost:20128/api/settings/compression \
  -H "Content-Type: application/json" \
  -d '{"defaultMode":"stacked","autoTriggerMode":"stacked","autoTriggerTokens":32000}'

# ચોક્કસ RTK/stacked પેલોડનું પૂર્વાવલોકન કરો
curl -X POST http://localhost:20128/api/compression/preview \
  -H "Content-Type: application/json" \
  -d '{"mode":"rtk","messages":[{"role":"tool","content":"npm test output here"}]}'

# RTK ફિલ્ટર પૅક્સની સૂચિ મેળવો
curl http://localhost:20128/api/context/rtk/filters

# વૈકલ્પિક કમાન્ડ મેટાડેટા સાથે RTKનું સીધું પરીક્ષણ કરો
curl -X POST http://localhost:20128/api/context/rtk/test \
  -H "Content-Type: application/json" \
  -d '{"command":"npm test","text":"FAIL tests/example.test.ts\nError: boom"}'

શું સુરક્ષિત રાખવામાં આવે છે

કમ્પ્રેશન એન્જિન હંમેશાં આને જાળવી રાખે છે:

  • ✅ કોડ બ્લૉક્સ (ફેન્સ્ડ અને ઇનલાઇન)
  • ✅ URLs અને ફાઇલ પાથ્સ
  • ✅ JSON સ્ટ્રક્ચર્સ અને સંરચિત ડેટા
  • ✅ આઇડેન્ટિફાયર્સ અને સુરક્ષિત ટેક્નિકલ ટોકન્સ
  • ✅ ગાણિતિક અભિવ્યક્તિઓ
  • ✅ ટૂલ/ફંક્શન કૉલ વ્યાખ્યાઓ
  • ✅ સિસ્ટમ પ્રૉમ્પ્ટ્સ (lite મોડમાં)

RTK રૉ-આઉટપુટ રિકવરી કંઈપણ સંગ્રહિત થાય તે પહેલાં સામાન્ય API કીઝ, બેરર ટોકન્સ, Slack ટોકન્સ, AWS ઍક્સેસ કીઝ, પાસવર્ડ્સ, ટોકન્સ અને સિક્રેટ્સને રિડેક્ટ કરે છે.


કમ્પ્રેશનના આંકડા

દરેક કમ્પ્રેસ કરેલી વિનંતીમાં સર્વર લૉગ્સમાં આંકડા સામેલ હોય છે:

{
  "originalTokens": 47200,
  "compressedTokens": 40120,
  "savingsPercent": 15.0,
  "techniquesUsed": ["collapseWhitespace", "dedupSystemPrompt"],
  "mode": "lite",
  "engine": "caveman",
  "compressionComboId": "coding-agent-stack",
  "durationMs": 0.8,
  "rtkRawOutputPointers": []
}

તબક્કાવાર રોડમૅપ

તબક્કો મોડ્સ સ્થિતિ
તબક્કો 1 Off, Lite ✅ રિલીઝ થઈ ગયું
તબક્કો 2 Standard, Aggressive, Ultra ✅ રિલીઝ થઈ ગયું
તબક્કો 3 RTK, Stacked, Compression Combos ✅ રિલીઝ થઈ ગયું
તબક્કો 4 Output Styles, SLM-tier Ultra, eval harness ✅ રિલીઝ થઈ ગયું
તબક્કો 4C અનુકૂલનશીલ કોન્ટેક્સ્ટ-બજેટ ("dial") — કમ્પ્યુટ એન્જિન + API (PUT /api/settings/compression પર contextBudget) + ડૅશબોર્ડ મોડ/પૉલિસી નિયંત્રણો ✅ રિલીઝ થઈ ગયું

આભારવિધિ

Standard મોડના કમ્પ્રેશન નિયમો JuliusBrussee (⭐ 51K+) દ્વારા બનાવાયેલા **Caveman**થી પ્રેરિત છે — વાયરલ "જ્યારે થોડા ટોકનથી કામ થઈ જાય ત્યારે ઘણા ટોકન શા માટે વાપરવા" પ્રોજેક્ટ. Caveman ~75% ઓછા આઉટપુટ ટોકન્સ, બેન્ચમાર્કમાં સરેરાશ 65% આઉટપુટ બચત, 22-87%ની આઉટપુટ રેન્જ અને ~46%નું ઇનપુટ-કમ્પ્રેશન ટૂલ દર્શાવે છે.

RTK મોડ RTK AI દ્વારા બનાવાયેલા **RTK - Rust Token Killer**થી પ્રેરિત છે — ટર્મિનલ, બિલ્ડ, ટેસ્ટ, git અને ટૂલ-આઉટપુટ ફિલ્ટરિંગ માટેનો ઉચ્ચ-પ્રદર્શન ધરાવતો કમાન્ડ-આઉટપુટ કમ્પ્રેશન પ્રોજેક્ટ. RTK 60-90% બચત દર્શાવે છે, જ્યારે તેના READMEના નમૂના સેશનમાં ~80% બચત બતાવવામાં આવી છે.


અદ્યતન કમ્પ્રેશન સિસ્ટમ્સ

ઉપર વર્ણવેલી 7 મોડ્સ ઉપરાંત (સોર્સ codex-responses અને omniglyph મોડ્સ પણ સ્વીકારે છે, જેને આ માર્ગદર્શિકા આવરી લેતી નથી), નીચેના વિભાગો એવી સુવિધાઓને આવરી લે છે જે આ મોડ્સની અંદર અથવા તેમની સાથે કાર્ય કરે છે: Tool Result Compression અને Progressive Aging એ aggressive એન્જિનનાં પગલાં 1 અને 2 છે (Aggressive મોડ અને સ્ટૅક્ડ પાઇપલાઇનનું aggressive પગલું), Stacked Pipeline એ Stacked મોડ કેવી રીતે ચાલે છે તે છે, Cache-Aware Compression કૅશિંગ પ્રોવાઇડર્સ માટે aggressive અને ultra ને standard પર ડાઉનગ્રેડ કરે છે જ્યારે કમ્પ્રેશન ચાલુ હોય, અને Caveman Output Mode તથા Output Styles એ વૈકલ્પિક સિસ્ટમ-પ્રોમ્પ્ટ સૂચનાઓ છે, જે ડિફૉલ્ટ રૂપે બંધ હોય છે અને વિનંતીને કમ્પ્રેસ કરવાને બદલે મોડલના આઉટપુટને આકાર આપે છે.

કૅશ-અવેર કમ્પ્રેશન

કેટલાક પ્રોવાઇડર્સ (જેમ કે પ્રોમ્પ્ટ કૅશિંગ સાથે Anthropic) પ્રોમ્પ્ટ કૅશિંગને સપોર્ટ કરે છે, જે તેમને ખર્ચ અને વિલંબ ઘટાડવા માટે પ્રોમ્પ્ટના ભાગોને કૅશ કરવાની મંજૂરી આપે છે. જ્યારે કૅશિંગ સક્ષમ હોય, ત્યારે aggressive કમ્પ્રેશન વાસ્તવમાં કામગીરીને નુકસાન પહોંચાડી શકે છે કારણ કે તે કૅશ કરેલા ટોકન્સને બદલે છે, જેનાથી કૅશ અમાન્ય થઈ જાય છે.

cachingAware.ts મોડ્યુલ કૅશિંગ સંદર્ભ શોધીને અને તે અનુસાર કમ્પ્રેશન વ્યૂહરચના સમાયોજિત કરીને આ સમસ્યાનું નિરાકરણ લાવે છે.

તે કેવી રીતે કાર્ય કરે છે

  1. કૅશિંગ સંદર્ભ શોધો — cache_control માર્કર્સ માટે વિનંતી બૉડીને સ્કૅન કરે છે
  2. કૅશિંગ પ્રોવાઇડર્સ ઓળખો — લક્ષ્ય પ્રોવાઇડર કૅશિંગને સપોર્ટ કરે છે કે નહીં તે તપાસે છે
  3. વ્યૂહરચના સમાયોજિત કરો — કૅશિંગ પ્રોવાઇડર્સ માટે aggressive/ultra ને standard પર ડાઉનગ્રેડ કરે છે
  4. સિસ્ટમ પ્રોમ્પ્ટ છોડો — સિસ્ટમ પ્રોમ્પ્ટ્સ સામાન્ય રીતે કૅશ કરેલા હોય છે, તેથી તેમને કમ્પ્રેસ કરશો નહીં

વ્યૂહરચના સહાયક એક deterministicOnly ફ્લૅગ પણ પરત કરે છે, પરંતુ પ્લાન બિલ્ડર ફક્ત વ્યૂહરચનાનો ઉપયોગ કરે છે — હાલમાં ડાઉનસ્ટ્રીમમાં કંઈપણ આ ફ્લૅગને વાંચતું નથી.

કોડ ઉદાહરણ

import {
  detectCachingContext,
  getCacheAwareStrategy,
} from "@omniroute/open-sse/services/compression/cachingAware";

const body = {
  model: "anthropic/claude-sonnet-4.5",
  messages: [{ role: "user", content: "Hello" }],
  cache_control: { type: "ephemeral" }, // ← કૅશ માર્કર
};

const ctx = detectCachingContext(body, { provider: "anthropic" });
// → { hasCacheControl: true, provider: "anthropic", targetFormat: null, isCachingProvider: true }

const strategy = getCacheAwareStrategy("aggressive", ctx);
// → { strategy: "standard", skipSystemPrompt: true, deterministicOnly: true }

ક્યારે ઉપયોગ કરવો

કૅશ-અવેર કમ્પ્રેશન હંમેશાં ચાલુ હોય છે — કોઈ કન્ફિગરેશનની જરૂર નથી. જ્યારે પણ કમ્પ્રેશન ચાલુ હોય અને લક્ષ્ય પ્રોવાઇડર પ્રોમ્પ્ટ કૅશિંગ (Anthropic, OpenAI, વગેરે)ને સપોર્ટ કરતું હોય ત્યારે તે સક્રિય થાય છે; સ્પષ્ટ cache_control માર્કર્સ જરૂરી નથી — માત્ર કૅશિંગ પ્રોવાઇડર હોવું જ ડાઉનગ્રેડને ટ્રિગર કરે છે, અને માત્ર માર્કર્સ ક્યારેય એવું કરતા નથી (માર્કર ડિટેક્શન કૅશ ટેલિમેટ્રીને ઇનપુટ આપે છે, વ્યૂહરચનાના નિર્ણયને નહીં).

પ્રોગ્રેસિવ એજિંગ

લાંબી વાતચીતોમાં અનેક મેસેજ ટર્ન્સ એકઠા થાય છે, પરંતુ જૂના ટર્ન્સ ધીમે ધીમે ઓછા સંબંધિત બને છે. progressiveAging.ts મોડ્યુલ ટર્નના અંતરના આધારે મેસેજની વિગતો ઘટાડે છે (અંતર વાતચીતના અંતથી માપવામાં આવે છે). પ્રદાન કરેલા ડિફૉલ્ટ્સ (verbatim: 2, light: 2, moderate: 3) સાથે:

  • છેલ્લા 2 ટર્ન્સ (અંતર ≤ 2): શબ્દશઃ જાળવી રાખવામાં આવે છે
  • અંતર 3: Caveman કમ્પ્રેશન (બિનજરૂરી શબ્દો દૂર કરવા)
  • અંતર 4+: Assistant મેસેજનો સારાંશ બનાવવામાં આવે છે; user મેસેજને તેમની પ્રથમ લાઇન સુધી ઘટાડવામાં આવે છે, જેની મર્યાદા 120 અક્ષરો છે; અન્ય roles અસ્પર્શિત રહે છે. સિસ્ટમ પ્રોમ્પ્ટ્સ, અગાઉથી એજ કરેલા મેસેજ અને સૌથી તાજેતરનો user મેસેજ અંતરને ધ્યાનમાં લીધા વગર હંમેશાં શબ્દશઃ જાળવવામાં આવે છે. કંઈપણ સંપૂર્ણપણે કાઢી નાખવામાં આવતું નથી, અને પ્રદાન કરેલા ડિફૉલ્ટ્સ સાથે light બૅન્ડ સુધી પહોંચી શકાતું નથી (light, verbatim જેટલું છે).

કોડ ઉદાહરણ

import { applyAging } from "@omniroute/open-sse/services/compression/progressiveAging";

const messages = [
  { role: "system", content: "You are a helpful assistant" },
  { role: "user", content: "What is 2+2?" },
  { role: "assistant", content: "4" },
  // ... વધુ 50 ટર્ન્સ ...
];

const { messages: aged, saved } = applyAging(messages, {
  verbatim: 3, // છેલ્લા 3 ટર્ન્સ: શબ્દશઃ
  light: 8, // અંતર <= 8: હળવું કમ્પ્રેશન
  moderate: 20, // અંતર <= 20: caveman કમ્પ્રેશન
  fullSummary: 5, // પ્રકાર માટે જરૂરી, બૅન્ડિંગ કોડ દ્વારા વાંચવામાં આવતું નથી
  // અંતર > 20: સારાંશ બનાવવામાં આવે છે (assistant) / પ્રથમ લાઇન જાળવવામાં આવે છે (user)
});

// saved = બચાવવામાં આવેલા ટોકન્સની સંખ્યા

ક્યારે ઉપયોગ કરવો

aggressive મોડ માટે પ્રોગ્રેસિવ એજિંગ હંમેશાં ચાલુ હોય છે — તે compressAggressive()નું પગલું 2 છે. Ultra મોડ તેને ચલાવતો નથી. તે ખાસ કરીને આ માટે અસરકારક છે:

  • લાંબા સમય સુધી ચાલતા કોડિંગ સત્રો
  • ઘણા દિવસો સુધી ચાલતી વાતચીતો
  • ઘણા ટૂલ કૉલ્સ ધરાવતા એજન્ટિક વર્કફ્લોઝ

કેવમેન આઉટપુટ મોડ

Caveman આઉટપુટ મોડ એવી સિસ્ટમ પ્રોમ્પ્ટ સૂચનાઓ ઉમેરે છે જે મોડલને જ સંક્ષિપ્ત આઉટપુટ આપવા કહે છે — lite સ્તર સંપૂર્ણ વાક્યો જાળવતા સંક્ષિપ્ત જવાબો માંગે છે, full તેને "હોશિયાર ગુફામાનવની જેમ ટૂંકમાં જવાબ આપવા" કહે છે અને ultra ટેલિગ્રાફિક આઉટપુટ માંગે છે; સૂચનાઓ ફક્ત વિનંતી કરી શકે છે, તેની ખાતરી આપી શકતી નથી. વિનંતીઓને આ સૂચનાઓ applyOutputStyles() (open-sse/services/compression/outputStyles/apply.ts) મારફતે મળે છે: open-sse/handlers/chatCore.ts પહેલાં બૅકવર્ડ-કમ્પેટિબિલિટી શિમ વડે પસંદગી નક્કી કરે છે (resolveOutputStyleSelection() જે open-sse/services/compression/outputStyles/backCompat.tsમાં છે), જે outputStyles ખાલી હોય ત્યારે સક્ષમ cavemanOutputModeને cavemanOutputMode.intensity પર terse-prose આઉટપુટ સ્ટાઇલ સાથે મૅપ કરે છે (નીચે બૅકવર્ડ કમ્પેટિબિલિટી જુઓ); ખાલી ન હોય તેવી outputStyles પસંદગી જેવી છે તેવી જ વપરાય છે અને પછી cavemanOutputMode.enabled તથા intensityની કોઈ અસર થતી નથી, જ્યારે તેનું autoClarity ટૉગલ હજી પણ લાગુ પડે છે. outputMode.tsમાં સૂચનાના ટેક્સ્ટ્સ (CAVEMAN_INSTRUCTION_BY_LANGUAGE), કન્ટેન્ટ બાયપાસ અને ઇન્જેક્શન દ્વારા વપરાતું પ્લેસમેન્ટ સહાયક છે; તેના પોતાના applyCavemanOutputMode() ઇન્જેક્ટરનો કોઈ પ્રોડક્શન કૉલર નથી.

તે કેવી રીતે કાર્ય કરે છે

આ મોડ ઇનપુટને સંકુચિત કરતું નથી. તે સિસ્ટમ પ્રોમ્પ્ટમાં સૂચના બ્લોક ઉમેરે છે (નીચે ઇન્જેક્શન કેવી રીતે કાર્ય કરે છે તે જુઓ), અને વિનંતી માટે પસંદ કરેલો કોઈપણ ઇનપુટ સંકોચન મોડ પછી પણ, હવે બ્લોક ધરાવતી બોડી પર ચાલે છે. દરેક સ્તરના અંતે આવતી સહિયારી સીમાઓની કલમ પહેલાં, અંગ્રેજી full સ્તર આ પ્રમાણે છે:

"હોશિયાર આદિમાનવની જેમ સંક્ષિપ્ત જવાબ આપો. આર્ટિકલ્સ (a/an/the), બિનજરૂરી શબ્દો (just/really/basically/actually/simply), ઔપચારિક સૌજન્ય, અનિશ્ચિત ભાષા કાઢી નાખો. અધૂરાં વાક્યો ચાલે. ટૂંકા સમાનાર્થી શબ્દો વાપરો (extensive નહીં, big; implement નહીં, fix). તમામ તકનીકી માહિતી, કોડ, ભૂલો, URLs, identifiers ચોક્કસ રાખો."

આ ખાસ કરીને આ માટે સારી રીતે કાર્ય કરે છે:

  • કોડ જનરેશન (વધુ સંક્ષિપ્ત આઉટપુટ = ઓછા ટોકન્સ)
  • ઝડપી પ્રશ્નોત્તરી (વિસ્તૃત સમજૂતીની જરૂર નથી)
  • બૅચ પ્રોસેસિંગ (મહત્તમ થ્રૂપુટ)

ક્યારે ઉપયોગ કરવો

Caveman આઉટપુટ મોડ opt-in છે. સંકોચન ચાલુ હોય ત્યારે (enabled: true, Compression Settings પેજ પરનું મુખ્ય ટૉગલ ચાલુ), તેને cavemanOutputMode.enabled વડે ચાલુ કરો; intensity lite, full અથવા ultra પસંદ કરે છે:

{
  "enabled": true,
  "cavemanOutputMode": {
    "enabled": true,
    "intensity": "full"
  }
}

સંકોચન કૉમ્બોનું આઉટપુટ મોડ ટૉગલ (outputMode, outputModeIntensityમાં સ્તર) તે કૉમ્બો લાગુ પડતી વિનંતીઓ માટે એ જ સ્વિચ સેટ કરે છે, અને omniroute_set_compression_engine MCP ટૂલ તેના બુલિયન outputMode આર્ગ્યુમેન્ટ દ્વારા તેને લખે છે. ખાલી ન હોય તેવી outputStyles પસંદગી આ સ્વિચ કરતાં પ્રાધાન્ય ધરાવે છે. ડૅશબોર્ડમાં, સંક્ષિપ્ત ગદ્ય આઉટપુટ શૈલી સક્ષમ કરવાથી એ જ બ્લોક ઇન્જેક્ટ થાય છે (નીચે આઉટપુટ શૈલીઓ જુઓ).

આઉટપુટ શૈલીઓ (કૅટલૉગ)

ઉપરનો Caveman આઉટપુટ મોડ જૂનો એકલ-શૈલી પાથ છે. Phase 4એ તેને સંયોજિત કરી શકાય તેવી આઉટપુટ શૈલીઓના કૅટલૉગમાં સામાન્યકૃત કર્યો: open-sse/services/compression/outputStyles/catalog.tsમાં OUTPUT_STYLE_CATALOG. દરેક શૈલી એક સિસ્ટમ-પ્રોમ્પ્ટ સૂચના છે, જે મોડલને જ ઓછો ખર્ચાળ આઉટપુટ આપવા કહે છે; શૈલીઓને એકસાથે સક્ષમ કરી શકાય છે અને તે કૅટલૉગના ક્રમમાં ઇન્જેક્ટ થાય છે.

શૈલી id તે શું કરે છે સૂચનાની ભાષાઓ
સંક્ષિપ્ત ગદ્ય terse-prose બિનજરૂરી શબ્દો/આર્ટિકલ્સ/અનિશ્ચિત ભાષા કાઢી નાખે; તકનીકી માહિતી ચોક્કસ રાખે. જૂના Caveman આઉટપુટ મોડ જેવું જ લખાણ (ફરી લખેલું નહીં, સંદર્ભિત). en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi
ઓછો કોડ less-code YAGNI ક્રમ: કાર્યરત સૌથી નાનો ફેરફાર, વિનંતી ન કરેલા abstraction નહીં. en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi
પોનીટેલ (આળસુ વરિષ્ઠ ડેવલપર) ponytail "શ્રેષ્ઠ કોડ એ છે જે ક્યારેય લખાયો જ નથી": ફરી લખવા કરતાં પુનઃઉપયોગ, લક્ષણ કરતાં મૂળ કારણ, કાર્યરત સૌથી ટૂંકો diff. en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi
મને ADHD છે (ક્રિયા-પ્રથમ) i-have-adhd ક્રિયા પ્રથમ (ગદ્ય પહેલાં command/path/snippet), ક્રમાંકિત મર્યાદિત પગલાં, એક નક્કર આગલું પગલું, કોઈ પ્રસ્તાવના/પુનરાવર્તન/સમાપન નહીં. ayghri/i-have-adhd (MIT) પરથી અનુકૂલિત. en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi
Antislop UI ફિલ્ટર antislop-ui દરેક દૃશ્ય તકનીકે હેતુની કસોટી પાર કરવી આવશ્યક છે (શ્રેણીક્રમ, ઓળખ, વાંચનક્ષમતા); ડિફૉલ્ટ gradients/glass/glow નહીં, મર્યાદિત palette, template layouts નહીં. બંને antislop શૈલીઓ બિનકાર્યરત controls નહીં / બનાવટી દાવા નહીંની સીમા ઉમેરે છે. en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi
Antislop કૉપી અને માનવીય ફિલ્ટર antislop-copy ચોક્કસ કૉપી (em dash, સામાન્ય CTAs, buzzwords, chatbot સમાપન, ઉપજાવેલી હકીકતો નહીં) ઉપરાંત લોકો માટેના નિયમો: WCAG AA contrast, દૃશ્યમાન focus, keyboard reach, empty/loading/error સ્થિતિઓ, mobile reflow. en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi
સંક્ષિપ્ત CJK (文言) terse-cjk full/ultra જવાબ Classical Chinese (文言)માં; lite માત્ર function words, સૌજન્યપૂર્ણ શબ્દો અથવા અલંકાર વગરના સંક્ષિપ્ત જવાબો માંગે છે. zh (locale-gated, નીચે જુઓ)

દરેક શૈલીમાં ત્રણ તીવ્રતા સ્તરો હોય છે — lite, full, ultra — અને દરેક સ્તર સહિયારી સીમાઓની કલમ (outputMode.tsમાં SHARED_BOUNDARIES) સાથે સમાપ્ત થાય છે, જે કોડ બ્લોક્સ, file paths, commands, errors અને URLsને ચોક્કસ રાખે છે. terse-prose અને terse-cjk સ્તરના લખાણો તે સૂચિમાં identifiers ઉમેરે છે.

terse-cjk બે જગ્યાએ zh માટે locale-gated છે. Compression Settings પેજ તેની પંક્તિ માત્ર ત્યારે સૂચિબદ્ધ કરે છે જ્યારે ડૅશબોર્ડ UI ભાષા Chinese (zh-CN અથવા zh-TW) હોય, અને applyOutputStyles() તેને માત્ર ત્યારે ઇન્જેક્ટ કરે છે જ્યારે વિનંતીની નિર્ધારિત ભાષા (નીચે ભાષા પસંદગી જુઓ) zh હોય. પંક્તિ છુપાવવાથી સાચવેલી terse-cjk પસંદગી સાફ થતી નથી: settings API કોઈપણ style id સ્વીકારે છે, અને પેજ પર અન્ય શૈલીઓ સાચવવાથી તે જળવાઈ રહે છે. વિનંતી સમયે, applyOutputStyles()ની ભાષા તપાસ જ એકમાત્ર locale gate છે.

ઇન્જેક્શન કેવી રીતે કાર્ય કરે છે

applyOutputStyles() (open-sse/services/compression/outputStyles/apply.ts) પસંદગીને કૅટલૉગ સામે ઉકેલે છે (અજ્ઞાત ids અને locale સાથે મેળ ન ખાતી styles કાઢી નાખવામાં આવે છે, તેને ક્યારેય error ગણવામાં આવતી નથી; કોઈ styleમાં ન ઉકેલાતી પસંદગી bodyને યથાવત્ રાખે છે અને no_styles તરીકે છોડી દેવામાં આવે છે), પસંદ કરેલી instructionsને કૅટલૉગના ક્રમમાં જોડે છે, boundaries clauseને એક વખત ઉમેરે છે (ઉપરાંત, less-code અથવા ponytail પસંદ કરેલું હોય ત્યારે safety clause, SAFETY_BOUNDARIES અથવા તેનો અનુવાદ), અને blockને એક જ idempotency marker ([OmniRoute Output Styles]) વડે શરૂ કરે છે, તેથી ફરીથી લાગુ કરવાથી કોઈ ફેરફાર થતો નથી. જ્યારે ઉકેલાયેલી ભાષા (નીચે Language selection જુઓ) માટે અનુવાદ ઉપલબ્ધ હોય, ત્યારે English instructionના બદલે localized instruction દાખલ કરવામાં આવે છે.

ખાલી ન હોય તેવા messages array ધરાવતા body પર, idempotency check content bypass પહેલાં ચાલે છે: જ્યારે [OmniRoute Output Styles] marker top-level system fieldમાં (string અથવા content-block array) અથવા string content ધરાવતા system messageમાં પહેલેથી હાજર હોય, ત્યારે bodyને already_applied તરીકે યથાવત્ રાખવામાં આવે છે અને કોઈ keyword check ચાલતું નથી. નહીં તો content bypass (shouldBypassCavemanOutputMode() જે open-sse/services/compression/outputMode.tsમાં છે) છેલ્લા ત્રણ messagesની text તપાસે છે, તેમની role કોઈ પણ હોય, અને જ્યારે તે text security, irreversible-action અથવા clarification keywords સાથે મેળ ખાય, અથવા આ ક્રમ-સંવેદનશીલ sequence સાથે મેળ ખાય ત્યારે આખા turn માટે stylesને છોડી દે છે: first, then, after that, before, rollback અથવા backup, અને તેના પછી 240 charactersની અંદર delete, drop, migrate, deploy અથવા release. Auto-Clarity Bypass toggle (cavemanOutputMode.autoClarity, default રીતે ચાલુ) ચાલુ હોય ત્યારે bypass ચાલે છે; toggle બંધ કરવાથી keyword check છોડી દેવામાં આવે છે.

જ્યારે bypass turnને આગળ જવા દે છે, ત્યારે placeSystemInstruction() (એ જ file), જે ક્યારેય નવું messages[0] બનાવતું નથી, તે blockને નીચે આપેલામાંથી સૌપ્રથમ મળતા સ્થાને મૂકે છે:

  1. string content ધરાવતો શરૂઆતનો system message: block તેની text પછી ઉમેરવામાં આવે છે.
  2. top-level system field: block stringની text પછી ઉમેરવામાં આવે છે, અથવા content-block arrayમાં નવા text block તરીકે ઉમેરવામાં આવે છે.
  3. પછી આવતો, string content ધરાવતો પ્રથમ system message: block તેની text પછી ઉમેરવામાં આવે છે.
  4. ઉપરના પૈકી કોઈ નહીં: block messagesના અંતે નવા system messageમાં મૂકવામાં આવે છે.

messages array વિનાના body પર (અથવા ખાલી array ધરાવતા body પર), કોઈ content bypass ચાલતું નથી અને top-level system fieldને ધ્યાનમાં લેવામાં આવતું નથી. blockને string instructions fieldની text પછી ઉમેરવામાં આવે છે, સિવાય કે તે fieldમાં [OmniRoute Output Styles] marker પહેલેથી હોય; એ સ્થિતિમાં bodyને already_applied તરીકે યથાવત્ રાખવામાં આવે છે. જ્યારે bodyમાં string instructions field ન હોય પરંતુ input (string અથવા array) હોય, ત્યારે block instructions બને છે અને તે fieldમાં રહેલી કોઈ પણ non-string valueને બદલે છે. string instructions field કે string અથવા array input, બંનેમાંથી કશું ન ધરાવતા bodyને યથાવત્ રાખવામાં આવે છે અને no_messages તરીકે છોડી દેવામાં આવે છે.

કેવી રીતે સક્ષમ કરવું

dashboardમાં: Compression Context → Compression Settings (/dashboard/context/settings), Output styles section: દરેક style માટે on/off toggle અને level selector સાથે એક row. compression પોતે ચાલુ હોય ત્યારે styles દાખલ થાય છે (pageનું master toggle, enabled). Auto-Clarity Bypass toggle Caveman page (/dashboard/context/caveman) પર તેના Output Mode cardમાં છે. Programmatically, compression config પસંદગીને આ રીતે સાચવે છે:

{
  "outputStyles": [
    { "id": "i-have-adhd", "level": "full" },
    { "id": "less-code", "level": "lite" }
  ]
}

Back-compat: outputStyles ખાલી હોય ત્યાં સુધી legacy cavemanOutputMode.enabled setting, cavemanOutputMode.intensity પર terse-prose સાથે map થાય છે. ત્યારબાદ block [OmniRoute Output Styles] markerથી શરૂ થાય છે, જ્યારે legacy applyCavemanOutputMode() injector [OmniRoute Caveman Output Mode] લખતું હતું. markerની નીચે text en, pt-BR, es, de, fr, it, ru, id અને viમાં legacy injection સાથે મેળ ખાય છે; ja અને zhમાં તેમાં boundaries clause પહેલાં એક વધારાનો space હોય છે. terse-proseનો અનુવાદ pt-BR, es, de, fr, it, ru, zh, ja, id અને viમાં થાય છે, તેથી જે requestની resolved language hu હોય તેને English text મળે છે, જ્યારે legacy injector તેના Hungarian textનો ઉપયોગ કરતું હતું.

Output-style language selection (resolveOutputStyleLanguage() જે outputStyles/apply.tsમાં છે): languageConfig.enabled ચાલુ હોય ત્યારે, autoDetect requestના messages arrayમાં text ધરાવતા સૌથી તાજેતરના user messageનો sample લે છે (string content, અથવા તેના content partsનું text) અને તેના પર Caveman engineનું detector (detectCompressionLanguage()) ચલાવે છે. Han characters ધરાવતી પરંતુ kana વિનાની text માટે detector zh પરત કરે છે; અન્યથા it, pt-BR, es, de, fr, ru, ja, hu અને idમાંથી જેમાં સૌથી વધુ hint matches હોય તે પરત કરે છે, અને કોઈ match ન થાય ત્યારે en પરત કરે છે — જે textને તે classify ન કરી શકે તેને English મળે છે, ક્યારેય defaultLanguage નહીં, અને styles સાથે vi text આપવામાં આવ્યું હોવા છતાં vi ક્યારેય detect થતું નથી. Responses API body તેના turns inputમાં રાખે છે, જેનો sample લેવામાં આવતો નથી, તેથી તેને defaultLanguage, અને પછી English મળે છે. જ્યારે messagesમાં કોઈ user message પાસે text ન હોય, અથવા autoDetect બંધ હોય, ત્યારે defaultLanguage લાગુ પડે છે અને પછી English. languageConfig.enabled બંધ હોય ત્યારે ભાષા English રહે છે — સિવાય કે request પર compression combo લાગુ પડતું હોય (requestના routing comboને assign કરેલું combo, અથવા built-in stacked pipeline માટે chatCore જે default compression combo પર પાછું જાય છે): combo લાગુ કરવાથી તે request માટે languageConfig.enabled ચાલુ થાય છે અને comboના language packsમાંથી defaultLanguage સેટ થાય છે (જો saved value comboના packsમાંથી એક હોય તો તે, અન્યથા comboનો પ્રથમ pack, જે default રીતે en હોય છે), જ્યારે saved autoDetect (default રીતે ચાલુ) હજી પણ લાગુ પડે છે. Caveman input engine તેની rule-pack languageને અલગ રીતે પસંદ કરે છે — દરેક text part દીઠ અને, auto-detect બંધ હોય ત્યારે, enabledPacksના આધારે નિયંત્રિત કરીને.

શૈલી × ભાષા મેટ્રિક્સને tests/unit/compression/output-styles-i18n-matrix.test.ts દ્વારા નિશ્ચિત કરવામાં આવે છે: દરેક કૅટલૉગ શૈલી માટે પરીક્ષણના BASELINE_LANGUAGESમાં એક એન્ટ્રી હોવી જરૂરી છે; જે શૈલી locale-gated નથી તેની સાથે pt-BR અનુવાદ આવવો જરૂરી છે (locale-gated terse-cjkને આ નિયમમાંથી મુક્તિ છે), સિવાય કે તે KNOWN_ENGLISH_ONLYમાં સૂચિબદ્ધ હોય, જેમાં ફક્ત એવી શૈલીઓ હોઈ શકે છે જેના કોઈ અનુવાદ જ નથી — સૂચિબદ્ધ શૈલીનો કોઈપણ અનુવાદ હોય તો પરીક્ષણ નિષ્ફળ જાય છે; અને જો કોઈ શૈલી તેની BASELINE_LANGUAGES એન્ટ્રીમાં સૂચિબદ્ધ ભાષા ગુમાવે તો તે પરીક્ષણમાં નિષ્ફળ જાય છે. શૈલી ઉમેરવા માટે, EXTENDING_COMPRESSION.md જુઓ.

ટૂલ પરિણામ સંકોચન

open-sse/services/compression/toolResultCompressor.tsમાં રહેલું compressToolResult() ટૂલ-પરિણામના ટેક્સ્ટને 5 વ્યૂહરચનાઓ વડે સંકોચે છે. તે તેમને આ ક્રમમાં અજમાવે છે, અને જેની તપાસ સામગ્રી સાથે મેળ ખાતી હોય એવી પ્રથમ સક્ષમ વ્યૂહરચના પરિણામ નક્કી કરે છે:

  1. fileContent: 3 અથવા વધુ લાઇનો ધરાવતી સામગ્રી, જેમાં ઓછામાં ઓછી એક લાઇન, શરૂઆતનું ઇન્ડેન્ટેશન અવગણીને, import , export , function , class , const , let , var અથવા return થી (કીવર્ડ પછી સ્પેસ સાથે), અથવા if, for કે while પછી ( અથવા ( સાથે શરૂ થાય છે, તેની પ્રથમ 20 અને છેલ્લી 5 લાઇનો રાખે છે અને દૂર કરાયેલ મધ્ય ભાગને ચિહ્નિત કરે છે.
  2. grepSearch: <path>:<digits>: સ્વરૂપની ઓછામાં ઓછી એક લાઇન ધરાવતી સામગ્રી, જેમાં પ્રથમ કોલન પહેલાંના ટેક્સ્ટમાં કોઈ whitespace ન હોય, ફક્ત એવી લાઇનો રાખે છે, વધુમાં વધુ 30, અને ત્યારબાદ બાકીના મેળોની સંખ્યા તથા મેળ ખાતી ફાઇલોની સૂચિ ઉમેરે છે; બીજી બધી લાઇનો કાઢી નાખવામાં આવે છે. વ્યૂહરચના ટ્રિગર કરવા માટે આવી એક જ લાઇન પૂરતી છે, તેથી 12:30:45 જેવા timestampથી શરૂ થતી લૉગ લાઇન પણ ગણાય છે.
  3. shellOutput: એવું આઉટપુટ જેમાં ANSI CSI sequence (ESC[ પછી અંકો અથવા semicolons અને પછી કોઈ અક્ષર, જેમ કે color codesમાં) હોય અથવા ટેક્સ્ટમાં ક્યાંય whitespace પછી $ હોય, તે sequences ગુમાવે છે (અન્ય escapes, જેમ કે ESC[?25l અથવા OSC window-title sequence, જાળવી રાખવામાં આવે છે) અને તેની છેલ્લી 50 લાઇનો રાખે છે, જ્યારે સળંગ પુનરાવર્તિત લાઇનોને એકમાં સમેટી દેવામાં આવે છે. આ તપાસ json અને errorMessage પહેલાં ચાલતી હોવાથી, આવું $ ધરાવતું JSON અથવા error output shellOutput ચાલુ હોય ત્યારે ક્યારેય તેમના સુધી પહોંચતું નથી.
  4. json: 2,000 કરતાં વધુ અક્ષરો ધરાવતો JSON payload, જે વૈકલ્પિક whitespace પછી { અથવા [થી શરૂ થાય અને સફળતાપૂર્વક parse થાય, તેનો સારાંશ બનાવવામાં આવે છે: 7 કરતાં વધુ items ધરાવતી array તેના પ્રથમ 5 અને છેલ્લા 2 items તથા કુલ સંખ્યા રાખે છે, અને object તેની પ્રથમ 20 keys રાખે છે; તેમાં દરેક nested object અથવા array valueને {…N keys} placeholderથી બદલવામાં આવે છે (array માટે, N તેની length છે) અને પ્રથમ 20 પછી કાઢી નાખવામાં આવેલી keysની ગણતરી દર્શાવતો _remaining_<N>_keys marker ઉમેરવામાં આવે છે. Scalar values સંપૂર્ણપણે copy થાય છે, તેથી 20 કે તેથી ઓછી keys અને કોઈ nested values ન ધરાવતું object ફક્ત ફરીથી indent થાય છે — minified objectમાં અક્ષરો વધી જાય છે અને તે યથાવત્ રહે છે.
  5. errorMessage: એવું આઉટપુટ જેમાં ક્યાંય અને કોઈપણ letter caseમાં error:, error (શબ્દ પછી space, જેમ કે no error foundમાં), [error], exception:, exception , [exception] અથવા traceback હોય, તે તેની પ્રથમ લાઇન, પછીની 10 લાઇનો અને છેલ્લી 3 લાઇનો રાખે છે, અને તેમની વચ્ચેની લાઇનોના સ્થાને … [N frames elided] … marker મૂકે છે. પ્રથમ લાઇન પછી 13 કરતાં વધુ લાઇનો હોય ત્યારે જ marker દેખાય છે, તેથી 14 કે તેથી ઓછી લાઇનો ધરાવતું error output ટૂંકું થતું નથી (12 અથવા 13 લાઇનોમાં છેલ્લી 3 લાઇનો પહેલેથી જ રાખવામાં આવેલી લાઇનોનું પુનરાવર્તન કરે છે).

કોઈ વ્યૂહરચના મેળ ખાય પછી, ભલે તે કશું બચાવતી ન હોય, પછીની વ્યૂહરચનાઓ અજમાવવામાં આવતી નથી. જ્યારે મેળ ખાતી વ્યૂહરચના કોઈ અંદાજિત tokens બચાવતી નથી (લંબાઈ ÷ 4, ઉપરના પૂર્ણાંક સુધી round કરેલી) — ઉદાહરણ તરીકે 25 કે તેથી ઓછી લાઇનોવાળી code-like file, અથવા 2,000 કરતાં વધુ અક્ષરો ધરાવતી અને 7 કે તેથી ઓછા itemsવાળી JSON array — ત્યારે aggressive engine મૂળ tool result જાળવી રાખે છે: saved 0 અથવા તેનાથી ઓછું હોય ત્યારે બંને callers (compressAggressive() અને compressAnthropicToolResultBlock()) મૂળ પરિણામ જાળવે છે, જ્યારે compressToolResult() પોતે હજુ પણ તે વ્યૂહરચનાનું output પરત કરે છે. tool-result પગલું અંતિમ નિર્ણય નથી: engineનું fallback summarizer હજુ પણ 8,192 અક્ષરોથી લાંબા tool અથવા function messageને ટૂંકા કરી શકે છે (maxTokensPerMessage, 2,048, ગુણ્યા 4).

ક્યારે ઉપયોગ કરવો

Tool result compression aggressive engineનું પગલું 1 છે (open-sse/services/compression/aggressive.tsમાં compressAggressive()), તેથી તે Aggressive modeમાં અને stacked pipelineના aggressive પગલામાં ચાલે છે. તે OpenAI-shape tool અને function messages તથા Anthropic tool_result blocksની અંદરના ટેક્સ્ટને સંકોચે છે. દરેક વ્યૂહરચનાનું aggressive.toolStrategies હેઠળ પોતાનું switch છે, અને બધા મૂળભૂત રીતે ચાલુ હોય છે. dashboardમાં, compression ચાલુ હોય અને default mode Aggressive હોય ત્યારે switches Caveman pageના Advanced viewમાં હોય છે.

સ્ટૅક્ડ પાઇપલાઇન

stacked mode એક પછી એક અનેક engines ચલાવે છે — સામાન્ય રીતે પહેલાં RTK (tool output પર 60-90% બચત), પછી બાકી રહેલા ટેક્સ્ટ પર Caveman (~46% input બચત). સંયુક્ત રીતે, આ 78-95% પાત્ર શ્રેણી બને છે (ઉપરનું Upstream Savings Math જુઓ): 1 - (1 - 0.60..0.90) × (1 - 0.46)ની સરેરાશ ≈89% થાય છે.

તે કેવી રીતે કાર્ય કરે છે

ઇનપુટ (1000 tokens)
  → RTK (command-aware filter) → 200 tokens
    → Caveman (filler removal) → 108 tokens
  → આઉટપુટ (108 tokens, ~89% બચત)

ક્યારે ઉપયોગ કરવો

stacked modeનો ઉપયોગ આ માટે કરો:

  • Tool-heavy workflows (agentic coding, research)
  • ખર્ચ-સંવેદનશીલ batch processing
  • જ્યારે તમને મહત્તમ token બચતની જરૂર હોય

Stacked pipelinesને global stackedPipeline compression setting દ્વારા, અથવા routing comboને સોંપાયેલા named compression combo દ્વારા configure કરવામાં આવે છે (ઉપરનું Per-Combo Override જુઓ) — auto-combo modePack દ્વારા નહીં (તે field ફક્ત auto-combo model selectionના weights ફરીથી ગોઠવે છે, અને stacked માન્ય pack name નથી).


કોમ્પ્રેશન કોમ્બો ઓવરરાઇડ્સ

વિવિધ ઉપયોગના કિસ્સાઓ માટે વર્તનને વધુ ચોકસાઈથી ગોઠવવા તમે વૈશ્વિક કોમ્પ્રેશન મોડને દરેક કોમ્બો માટે ઓવરરાઇડ કરી શકો છો:

{
  "id": "coding-combo",
  "strategy": "priority",
  "config": {
    "weights": { "taskFit": 0.5 },
    "modePack": "quality-first"
  },
  "compressionOverride": "aggressive"
}

આ નીચેના માટે ઉપયોગી છે:

  • કોડિંગ કોમ્બો: લાંબા સત્રો માટે aggressive મોડનો ઉપયોગ કરો
  • ઝડપી પ્રશ્નોત્તરી કોમ્બો: ઝડપી પ્રતિસાદો માટે lite મોડનો ઉપયોગ કરો
  • ટૂલ-હેવી કોમ્બો: મહત્તમ બચત માટે stacked મોડનો ઉપયોગ કરો
  • પ્રોડક્શન કોમ્બો: કૅશિંગ પ્રદાતાઓ માટે ઓવરરાઇડ બંધ રાખો — હંમેશાં સક્રિય કૅશ-અવેર સમાયોજન aggressive/ultraને આપમેળે standardમાં ડાઉનગ્રેડ કરે છે (પસંદ કરી શકાય એવો કોઈ cache-aware મોડ નથી)

આ પણ જુઓ