# 🗜️ Prompt Compression Guide — OmniRoute (മലയാളം)

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

---

> അനുയോജ്യമായ കോൺടെക്സ്റ്റിൽ സ്വയമേവ 15-95% ലാഭിക്കുക. പെട്ടെന്നുള്ള ഒരു അവലോകനത്തിനായി, [README കംപ്രഷൻ വിഭാഗം](../README.md#%EF%B8%8F-prompt-compression--save-15-95-eligible-tokens-automatically) കാണുക.

## അവലോകനം

അപ്സ്ട്രീം പ്രൊവൈഡർമാരിലേക്ക് അഭ്യർത്ഥനകൾ എത്തുന്നതിന് **മുൻകൂട്ടി** പ്രവർത്തിക്കുന്ന ഒരു മോഡുലാർ പ്രോംപ്റ്റ് കംപ്രഷൻ പൈപ്പ്ലൈൻ OmniRoute നടപ്പിലാക്കുന്നു. അതായത്, നിങ്ങളുടെ ടോക്കൺ ലാഭം സുതാര്യമായി സംഭവിക്കുന്നു — നിങ്ങളുടെ വർക്ക്ഫ്ലോയിൽ മാറ്റങ്ങളൊന്നും ആവശ്യമില്ല.

```
ക്ലയന്റ് അഭ്യർത്ഥന
  → കംപ്രഷൻ സ്ട്രാറ്റജി സെലക്ടർ
    → കോംബോ ഓവർറൈഡ്? → കോംബോ ക്രമീകരണം ഉപയോഗിക്കുക
    → ഓട്ടോ-ട്രിഗർ പരിധി? → ഓട്ടോ മോഡ് ഉപയോഗിക്കുക
    → ഡിഫോൾട്ട് മോഡ്? → ഗ്ലോബൽ ക്രമീകരണം ഉപയോഗിക്കുക
    → ഓഫ്? → കംപ്രഷൻ ഒഴിവാക്കുക
  → തിരഞ്ഞെടുത്ത കംപ്രഷൻ മോഡ്
    → ഓഫ്: കംപ്രഷൻ ഇല്ല
    → ലൈറ്റ്: സുരക്ഷിതമായ വൈറ്റ്സ്പേസ്/ഫോർമാറ്റിംഗ് വൃത്തിയാക്കൽ (~15%)
    → സ്റ്റാൻഡേർഡ്: ഗുഹാമനുഷ്യ ശൈലിയിൽ അനാവശ്യ പദങ്ങൾ നീക്കംചെയ്യൽ (~30%)
    → അഗ്രസീവ്: ഹിസ്റ്ററി ഏജിംഗ് + സംഗ്രഹിക്കൽ (~50%)
    → അൾട്രാ: ഹ്യൂറിസ്റ്റിക് പ്രൂണിംഗ് + കോഡ്-ബ്ലോക്ക് ലഘൂകരിക്കൽ (~75%)
    → RTK: കമാൻഡ്-അവബോധമുള്ള ടെർമിനൽ/ടൂൾ-ഔട്ട്പുട്ട് ഫിൽട്ടറിംഗ് (അപ്സ്ട്രീം പരിധി 60-90%)
    → സ്റ്റാക്ക്ഡ്: ക്രമീകരിച്ച മൾട്ടി-എഞ്ചിൻ പൈപ്പ്ലൈൻ, സാധാരണയായി RTK, തുടർന്ന് Caveman (അനുയോജ്യമായ പരിധി 78-95%)
  → കംപ്രസ് ചെയ്ത അഭ്യർത്ഥന → പ്രൊവൈഡർ
```

---

## കംപ്രഷൻ മോഡുകൾ

### ഓഫ്

കംപ്രഷൻ പ്രയോഗിക്കുന്നില്ല. എല്ലാ സന്ദേശങ്ങളും മാറ്റമില്ലാതെ കടന്നുപോകുന്നു.

### ലൈറ്റ് മോഡ് (~15% ലാഭം, <1ms ലേറ്റൻസി)

ഏറ്റവും സുരക്ഷിതമായ മോഡ് — അർത്ഥപരമായ മാറ്റമൊന്നുമില്ല, ഫോർമാറ്റിംഗ് വൃത്തിയാക്കൽ മാത്രം:

| സാങ്കേതികവിദ്യ           | വിവരണം                                                                     |
| ------------------------ | -------------------------------------------------------------------------- |
| `collapseWhitespace`     | തുടർച്ചയായ ശൂന്യവരികളും വരികളുടെ അവസാനത്തിലുള്ള സ്പേസുകളും ലയിപ്പിക്കുന്നു |
| `dedupSystemPrompt`      | ഡ്യൂപ്ലിക്കേറ്റ് സിസ്റ്റം സന്ദേശങ്ങൾ നീക്കംചെയ്യുന്നു                      |
| `compressToolResults`    | ദീർഘമായ ടൂൾ/ഫങ്ഷൻ ഔട്ട്പുട്ടുകൾ കംപ്രസ് ചെയ്യുന്നു                         |
| `removeRedundantContent` | ആവർത്തിച്ച നിർദ്ദേശങ്ങൾ നീക്കംചെയ്യുന്നു                                   |
| `replaceImageUrls`       | base64 ഇമേജ് ഡാറ്റ URI-കൾ ചുരുക്കുന്നു                                     |

**ഏറ്റവും അനുയോജ്യം:** എല്ലായ്പ്പോഴും പ്രവർത്തിക്കുന്ന ഉപയോഗം, സുരക്ഷാ-നിർണായക വർക്ക്ഫ്ലോകൾ.

### സ്റ്റാൻഡേർഡ് മോഡ് (~30% ലാഭം)

[Caveman](https://github.com/JuliusBrussee/caveman)-ൽ നിന്ന് പ്രചോദനം ഉൾക്കൊണ്ടത് — അർത്ഥം നിലനിർത്തിക്കൊണ്ട് അനാവശ്യ പദങ്ങളും ദീർഘമായ പ്രയോഗങ്ങളും നീക്കംചെയ്യുന്നു:

- അനാവശ്യ പദങ്ങൾ നീക്കംചെയ്യുന്നു ("please", "I think", "basically", "actually")
- ദീർഘമായ പ്രയോഗങ്ങൾ ചുരുക്കുന്നു ("in order to" → "to", "as a result of" → "because")
- വിനയപൂർവമായ മയപ്പെടുത്തൽ പ്രയോഗങ്ങൾ നീക്കംചെയ്യുന്നു ("Would you mind...", "If you could possibly...")
- കോഡിംഗ് പ്രോംപ്റ്റുകൾക്കായി ക്രമീകരിച്ച 30+ regex നിയമങ്ങൾ

**ഏറ്റവും അനുയോജ്യം:** ദൈനംദിന കോഡിംഗ് വർക്ക്ഫ്ലോകൾ, ചെലവ് പരിഗണിക്കുന്ന ടീമുകൾ.

### അഗ്രസീവ് മോഡ് (~50% ലാഭം)

ദൈർഘ്യമേറിയ സെഷനുകൾക്കായുള്ള സ്മാർട്ട് ഹിസ്റ്ററി മാനേജ്മെന്റ്:

- **സന്ദേശ ഏജിംഗ്** — പഴയ സന്ദേശങ്ങൾ ക്രമാനുഗതമായി കൂടുതൽ കംപ്രസ് ചെയ്യപ്പെടുന്നു
- **ടൂൾ റിസൾട്ട് കംപ്രഷൻ** — ദൈർഘ്യമേറിയ ടൂൾ ഔട്ട്പുട്ടുകൾ വെട്ടിച്ചുരുക്കുകയോ ഒഴിവാക്കുകയോ ചെയ്യുന്നു (ആദ്യ/അവസാന വരികൾ,
  പൊരുത്തപ്പെടുന്ന വരികളുടെ ഫിൽട്ടറിംഗ്, JSON കീ കംപാക്ഷൻ)
- **ഘടനാപരമായ സമഗ്രതാ സംരക്ഷണങ്ങൾ** — `tool_use` + `tool_result` ജോടികൾ സ്ഥിരതയോടെ തുടരുന്നുവെന്ന് ഉറപ്പാക്കുന്നു
- **കോൺടെക്സ്റ്റ് വിൻഡോ അവബോധം** — ഓരോ മോഡലിന്റെയും ടോക്കൺ പരിധികൾ മാനിക്കുന്നു

**ഏറ്റവും അനുയോജ്യം:** ദീർഘമായ ഡീബഗ്ഗിംഗ് സെഷനുകൾ, വലിയ കോഡ്ബേസുകൾ.

### അൾട്രാ മോഡ് (~75% ലാഭം)

ടോക്കൺ നിർണായകമായ സാഹചര്യങ്ങൾക്കുള്ള പരമാവധി കംപ്രഷൻ:

- **ഹ്യൂറിസ്റ്റിക് പ്രൂണിംഗ്** — ഗദ്യത്തിന്റെ സ്കോർ അടിസ്ഥാനത്തിലുള്ള ടോക്കൺ പ്രൂണിംഗ്
- **ഘടനാ സംരക്ഷണം** — ഫെൻസ് ചെയ്ത കോഡ് ബ്ലോക്കുകൾ, ഇൻലൈൻ കോഡ്, URL-കൾ, ഐഡന്റിഫയറുകൾ എന്നിവ
  ടൂംബ്സ്റ്റോൺ ചെയ്ത് അതേപടി വീണ്ടും ചേർക്കുന്നു; ഒരിക്കലും പ്രൂൺ ചെയ്യില്ല
- **ഓപ്ഷണൽ 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 സ്കീമ v1 ഫിൽട്ടറുകൾ ഇംപോർട്ട് ചെയ്യുന്നു; ഇൻലൈൻ-ടെസ്റ്റ്
  വാലിഡേഷനും പ്രോജക്റ്റ് ഫയലുകൾക്കായുള്ള ട്രസ്റ്റ്-ഗേറ്റിംഗും ഉൾപ്പെടെ
- ഇൻലൈൻ വെരിഫൈ സാമ്പിളുകളുള്ള 55 ബിൽറ്റ്-ഇൻ ഫിൽട്ടറുകൾ ഉൾക്കൊള്ളുന്നു
- ANSI കൺട്രോൾ സീക്വൻസുകൾ, പ്രോഗ്രസ് ബാറുകൾ, ആവർത്തിച്ച വരികൾ, നടപടിയെടുക്കാനാകാത്ത അനാവശ്യ ഉള്ളടക്കം എന്നിവ നീക്കംചെയ്യുന്നു
- പരാജയങ്ങൾ, പിശകുകൾ, മുന്നറിയിപ്പുകൾ, മാറിയ ഫയലുകൾ, സംഗ്രഹങ്ങൾ, ദൈർഘ്യമേറിയ ഔട്ട്പുട്ടിന്റെ അവസാനഭാഗം എന്നിവ സംരക്ഷിക്കുന്നു
- ട്രസ്റ്റ്-ഗേറ്റഡ് പ്രോജക്റ്റ് ഫിൽട്ടറുകൾ, ഗ്ലോബൽ ഫിൽട്ടറുകൾ, ഓപ്ഷണൽ റിഡാക്റ്റഡ് റോ-ഔട്ട്പുട്ട് വീണ്ടെടുക്കൽ എന്നിവ പിന്തുണയ്ക്കുന്നു

**ഏറ്റവും അനുയോജ്യം:** ഷെൽ, ബിൽഡ്, ടെസ്റ്റ്, git, grep, ഫയൽ-ഔട്ട്പുട്ട് ട്രാൻസ്ക്രിപ്റ്റുകൾ എന്നിവയുള്ള ഏജന്റ് സെഷനുകൾ.

### സ്റ്റാക്ക്ഡ് മോഡ് (അനുയോജ്യമായ പരിധി 78-95%)

സ്റ്റാക്ക്ഡ് മോഡ് ഒന്നിലധികം കംപ്രഷൻ എഞ്ചിനുകൾ നിർണായകമായ ഒരു ക്രമത്തിൽ പ്രവർത്തിപ്പിക്കുന്നു. ഡിഫോൾട്ട് പൈപ്പ്ലൈൻ:

```txt
RTK -> Caveman
```

ആ ക്രമം ആദ്യം ടെർമിനൽ/ടൂൾ ഔട്ട്പുട്ട് ചുരുക്കുന്നു, തുടർന്ന് ശേഷിക്കുന്ന സ്വാഭാവിക-ഭാഷാ പ്രോംപ്റ്റിൽ Caveman അർത്ഥപരമായ സംക്ഷിപ്തീകരണം പ്രയോഗിക്കുന്നു. സ്റ്റാക്ക്ഡ് പൈപ്പ്ലൈനുകൾ ഗ്ലോബലായോ റൂട്ടിംഗ് കോംബോകൾക്ക് നൽകിയിരിക്കുന്ന കംപ്രഷൻ കോംബോകൾ വഴിയോ കോൺഫിഗർ ചെയ്യാം.

**ഏറ്റവും അനുയോജ്യം:** വലിയ ടൂൾ ലോഗുകളും മനുഷ്യ നിർദ്ദേശങ്ങളോ അസിസ്റ്റന്റ് സംഗ്രഹങ്ങളോ ഉൾപ്പെടുന്ന സമ്മിശ്ര കോൺടെക്സ്റ്റ്.

---

## അപ്സ്ട്രീം ലാഭത്തിന്റെ കണക്ക്

OmniRoute രണ്ട് ഉറവിടങ്ങളിൽ നിന്നുള്ള കംപ്രഷൻ ലാഭം രേഖപ്പെടുത്തുന്നു: അപ്സ്ട്രീം പ്രോജക്റ്റ് ബെഞ്ച്മാർക്കുകളും
OmniRoute-ന്റെ സ്വന്തം എഞ്ചിൻ സംയോജനവും.

| ഉറവിടം  | ഇവിടെ ഉപയോഗിച്ചിരിക്കുന്ന അപ്സ്ട്രീം README സംഖ്യ                                                                                   |
| ------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| Caveman | `~75%` കുറവ് ഔട്ട്പുട്ട് ടോക്കണുകൾ, `65%` ബെഞ്ച്മാർക്ക് ശരാശരി ഔട്ട്പുട്ട് ലാഭം, `22-87%` പരിധി, കൂടാതെ `~46%` ഇൻപുട്ട് കംപ്രഷൻ ടൂൾ |
| RTK     | കമാൻഡ്-ഔട്ട്പുട്ടിൽ `60-90%` ലാഭം; സാമ്പിൾ സെഷനിൽ `~118,000 -> ~23,900` ടോക്കണുകൾ, അഥവാ `79.7%` ലാഭം (`~80%`)                       |

ഓവർലാപ്പ് ചെയ്യുന്ന ടൂൾ/കോൺടെക്സ്റ്റ് പേലോഡുകൾക്കായി, ഡിഫോൾട്ട് OmniRoute കോംബോ എഞ്ചിനുകളെ ഒന്നിനുപുറകെ ഒന്നായി പ്രയോഗിക്കുന്നു:

```txt
RTK -> Caveman
```

സംയോജിത ലാഭം അഡിറ്റീവ് അല്ല, മൾട്ടിപ്ലിക്കേറ്റീവ് ആണ്:

```txt
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%
```

RTK-യ്ക്കും Caveman-നും ഒരേ ഇൻപുട്ട്/കോൺടെക്സ്റ്റ് പേലോഡ് കുറയ്ക്കാൻ കഴിയുമ്പോഴാണ് ആ `78-95%` സംഖ്യ ബാധകമാകുന്നത്.
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` മാച്ച് ലിസ്റ്റ്,
ഹ്രസ്വമായ ഫയൽ റീഡ്, സാധാരണ സംഭാഷണ ടെക്സ്റ്റ്) അതേ പൈപ്പ്ലൈൻ പ്രവർത്തിപ്പിക്കുമ്പോൾ, ശരിയായി **പൂജ്യത്തോട് അടുത്ത ലാഭം** മാത്രമാണ് ലഭിക്കുന്നത്, കാരണം
നീക്കം ചെയ്യാൻ ആവർത്തനമുള്ള ഒന്നുമില്ല; കൂടാതെ കോഡ് ബ്ലോക്കുകൾ, URL-കൾ, തലക്കെട്ടുകൾ, പതിപ്പുകൾ, അല്ലെങ്കിൽ ALL-CAPS കോൺസ്റ്റന്റ് ഐഡന്റിഫയറുകൾ
ഒഴിവാക്കുകയോ മാറ്റുകയോ ചെയ്യുന്ന ഒരു റീറൈറ്റ് അയയ്ക്കാൻ `validateCompression()` (`validation.ts`) അനുവദിക്കില്ല.

ഇത് പ്രതീക്ഷിക്കാവുന്ന സുരക്ഷിതമായ പെരുമാറ്റമാണ്, ബഗ് അല്ല: കംപ്രഷൻ പൂർണ്ണമായി പ്രവർത്തനക്ഷമമാക്കിയിട്ടും, പ്രധാനമായും വൃത്തിയുള്ള ഫയലുകൾ
വായിക്കുകയോ 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% പരിധി)
```

---

## കോൺഫിഗറേഷൻ

### ഡാഷ്ബോർഡ്

`Dashboard → Context & Cache` എന്നതിലേക്ക് പോകുക:

- **Caveman** — മോഡ് തിരഞ്ഞെടുക്കൽ, ഭാഷാ പാക്കുകൾ, പ്രിവ്യൂ, ആഗോള ഡിഫോൾട്ടുകൾ
- **RTK** — കമാൻഡ്-ഫിൽട്ടർ പ്രിവ്യൂ, RTK സുരക്ഷാ ക്രമീകരണങ്ങൾ, ഫിൽട്ടർ കാറ്റലോഗ്
- **Compression Combos** — റൂട്ടിംഗ് കോംബോകൾക്ക് നിയോഗിച്ചിരിക്കുന്ന പേരിട്ട എൻജിൻ പൈപ്പ്ലൈനുകൾ
- **Auto-Trigger Threshold** — ടോക്കൺ എണ്ണം പരിധി കവിയുമ്പോൾ കംപ്രഷൻ സ്വയമേവ സജീവമാക്കുന്നു

### ഓരോ കോംബോയ്ക്കുമുള്ള ഓവർറൈഡ്

`Dashboard → Context & Cache → Compression Combos` എന്നതിൽ, ഒരു റൂട്ടിംഗ് കോംബോയ്ക്ക് ഒരു കംപ്രഷൻ കോംബോ നിയോഗിക്കുക:

```txt
Combo: "free-tier-fallback"
  Compression Combo: "coding-agent-stack"
  Pipeline: RTK -> Caveman
  Targets:
    1. if/kimi-k2.7-code
    2. if/qwen3.8-max-preview
```

പണമടച്ചുള്ള സബ്സ്ക്രിപ്ഷനുകളിൽ ലൈറ്റ് മോഡ് നിലനിർത്തിക്കൊണ്ട്, സൗജന്യ/കോഡിംഗ് പ്രൊവൈഡറുകളിൽ സ്റ്റാക്ക് ചെയ്ത കംപ്രഷൻ ഉപയോഗിക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു.

ഈ "Per-Combo Override" നിയോഗം **routing-combo compression mode** ഓവർറൈഡിൽനിന്ന് വ്യത്യസ്തമായ ഒരു നിയന്ത്രണമാണ് (Default/Off/Lite/Standard/Aggressive/Ultra/Codex Responses — ഈ ഫീൽഡിന്റെ സ്കീമ `rtk`, `stacked`, `omniglyph` എന്നിവയും സ്വീകരിക്കുന്നു) — ആ ഓവർറൈഡ് പേരിട്ട കംപ്രഷൻ-കോംബോ പൈപ്പ്ലൈൻ തിരഞ്ഞെടുക്കുന്നില്ല; `resolveCompressionPlan` പരിശോധിക്കുന്ന `compressionMode` ഫീൽഡ് മാത്രമാണ് അത് സജ്ജമാക്കുന്നത്. ഇത് കോംബോ കാർഡിൽ (`Dashboard → Combos`) സജ്ജമാക്കാം, അല്ലെങ്കിൽ #6760 മുതൽ, മുകളിൽ രേഖപ്പെടുത്തിയ പൈപ്പ്ലൈൻ-അസൈൻമെന്റ് ചെക്ക്ബോക്സിന് തൊട്ടടുത്തുള്ള `Dashboard → Context & Cache → Compression Combos` എന്നതിലെ "Assign to routing" പട്ടികയിൽ ഓരോ റൂട്ടിംഗ് കോംബോയ്ക്കും പ്രത്യേകം സജ്ജമാക്കാം. രണ്ട് ഇന്റർഫേസുകളിലെയും മാറ്റങ്ങൾ ഒരേ `PUT /api/combos/{id}` എൻഡ്പോയിന്റിലൂടെയാണ് നിലനിർത്തുന്നത്.

### ഓരോ അഭ്യർത്ഥനയ്ക്കുമുള്ള ഓവർറൈഡ്

ഒരൊറ്റ അഭ്യർത്ഥനയ്ക്കുള്ള കംപ്രഷൻ പ്ലാൻ ഓവർറൈഡ് ചെയ്യാൻ `x-omniroute-compression` അഭ്യർത്ഥന ഹെഡർ അയയ്ക്കുക. ഇതിന് ഏറ്റവും ഉയർന്ന മുൻഗണനയുണ്ട് — റൂട്ടിംഗ്-കോംബോ ഓവർറൈഡ്, സജീവ പ്രൊഫൈൽ, ഓട്ടോ-ട്രിഗർ, പാനലിലെ Default എന്നിവയെ ഇത് മറികടക്കും. തിരിച്ചറിയാത്ത മൂല്യങ്ങൾ അവഗണിക്കപ്പെടും (അഭ്യർത്ഥന ഒരിക്കലും നിരസിക്കപ്പെടില്ല), കൂടാതെ ആഗോള മാസ്റ്റർ സ്വിച്ച് ഇപ്പോഴും എല്ലാം നിയന്ത്രിക്കുന്നു: ആഗോളതലത്തിൽ കംപ്രഷൻ ഓഫായിരിക്കുമ്പോൾ, ഹെഡറിന് അത് ഓൺ ചെയ്യാനാകില്ല. മൂല്യങ്ങൾ:

| മൂല്യം        | ഫലം                                                                                                                  |
| ------------- | -------------------------------------------------------------------------------------------------------------------- |
| `off`         | ഈ അഭ്യർത്ഥനയ്ക്ക് കംപ്രഷൻ ഇല്ല.                                                                                      |
| `default`     | പാനലിൽനിന്ന് ലഭിക്കുന്ന 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

```bash
# കംപ്രഷൻ ക്രമീകരണങ്ങൾ നേടുക
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"}'
```

---

## സംരക്ഷിക്കപ്പെടുന്നവ

കംപ്രഷൻ എഞ്ചിൻ **എല്ലായ്പ്പോഴും സംരക്ഷിക്കുന്നത്:**

- ✅ കോഡ് ബ്ലോക്കുകൾ (ഫെൻസ്ഡ്, ഇൻലൈൻ)
- ✅ URL-കളും ഫയൽ പാത്തുകളും
- ✅ JSON ഘടനകളും ഘടനാബദ്ധമായ ഡാറ്റയും
- ✅ ഐഡന്റിഫയറുകളും സംരക്ഷിത സാങ്കേതിക ടോക്കണുകളും
- ✅ ഗണിത സമവാക്യങ്ങൾ
- ✅ ടൂൾ/ഫങ്ഷൻ കോൾ നിർവചനങ്ങൾ
- ✅ സിസ്റ്റം പ്രോംപ്റ്റുകൾ (lite മോഡിൽ)

എന്തെങ്കിലും പെർസിസ്റ്റ് ചെയ്യുന്നതിന് മുമ്പ്, RTK റോ-ഔട്ട്പുട്ട് റിക്കവറി സാധാരണ API കീകൾ, bearer ടോക്കണുകൾ, Slack ടോക്കണുകൾ, AWS ആക്സസ് കീകൾ,
പാസ്വേഡുകൾ, ടോക്കണുകൾ, രഹസ്യങ്ങൾ എന്നിവ മറയ്ക്കുന്നു.

---

## കംപ്രഷൻ സ്ഥിതിവിവരക്കണക്കുകൾ

കംപ്രസ് ചെയ്ത ഓരോ റിക്വസ്റ്റിന്റെയും സ്ഥിതിവിവരക്കണക്കുകൾ സെർവർ ലോഗുകളിൽ ഉൾപ്പെടുന്നു:

```json
{
  "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](https://github.com/JuliusBrussee)**-യുടെ **[Caveman](https://github.com/JuliusBrussee/caveman)** (⭐ 51K+)-ൽ നിന്ന് പ്രചോദനം ഉൾക്കൊണ്ടവയാണ് — വൈറലായ "കുറച്ച് ടോക്കണുകൾകൊണ്ട് കാര്യം നടക്കുമ്പോൾ എന്തിന് കൂടുതൽ ടോക്കണുകൾ ഉപയോഗിക്കണം" എന്ന പ്രോജക്റ്റ്. `~75%` കുറവ് ഔട്ട്പുട്ട് ടോക്കണുകളും, ബെഞ്ച്മാർക്കുകളിൽ ശരാശരി `65%` ഔട്ട്പുട്ട് ലാഭവും, `22-87%` ഔട്ട്പുട്ട് പരിധിയും, `~46%` ഇൻപുട്ട്-കംപ്രഷൻ ടൂളും Caveman റിപ്പോർട്ട് ചെയ്യുന്നു.

RTK മോഡ് **[RTK AI](https://github.com/rtk-ai)**-യുടെ **[RTK - Rust Token Killer](https://github.com/rtk-ai/rtk)**-ൽ നിന്ന് പ്രചോദനം ഉൾക്കൊണ്ടതാണ് — ടെർമിനൽ, ബിൽഡ്, ടെസ്റ്റ്, git, ടൂൾ-ഔട്ട്പുട്ട് ഫിൽട്ടറിംഗ് എന്നിവയ്ക്കായുള്ള ഉയർന്ന പ്രകടനമുള്ള കമാൻഡ്-ഔട്ട്പുട്ട് കംപ്രഷൻ പ്രോജക്റ്റ്. RTK `60-90%` ലാഭം റിപ്പോർട്ട് ചെയ്യുന്നു; അതിന്റെ README സാമ്പിൾ സെഷനിൽ `~80%` ലാഭിച്ചതായി കാണിക്കുന്നു.

---

## വിപുലമായ കംപ്രഷൻ സിസ്റ്റങ്ങൾ

മുകളിൽ വിവരിച്ച 7 മോഡുകൾക്കപ്പുറം (സോഴ്സ് `codex-responses`, `omniglyph`
മോഡുകളും സ്വീകരിക്കുന്നു, എന്നാൽ ഈ ഗൈഡ് അവ ഉൾക്കൊള്ളുന്നില്ല), താഴെയുള്ള വിഭാഗങ്ങൾ
ആ മോഡുകൾക്കുള്ളിലോ അവയ്ക്കൊപ്പമോ പ്രവർത്തിക്കുന്ന സവിശേഷതകൾ ഉൾക്കൊള്ളുന്നു: Tool Result Compression,
Progressive Aging എന്നിവ aggressive എഞ്ചിന്റെ 1, 2 ഘട്ടങ്ങളാണ് (Aggressive മോഡും
stacked pipeline-ന്റെ ഒരു `aggressive` ഘട്ടവും), Stacked മോഡ് പ്രവർത്തിക്കുന്നത് Stacked Pipeline
വഴിയാണ്, കംപ്രഷൻ ഓണായിരിക്കുമ്പോൾ Cache-Aware Compression കാഷിംഗ് പ്രൊവൈഡറുകൾക്കായി
`aggressive`, `ultra` എന്നിവയെ `standard`-ലേക്ക് ഡൗൺഗ്രേഡ് ചെയ്യുന്നു, കൂടാതെ Caveman Output Mode,
Output Styles എന്നിവ ഡിഫോൾട്ടായി ഓഫായിരിക്കുന്ന, ഓപ്റ്റ്-ഇൻ system-prompt നിർദ്ദേശങ്ങളാണ്;
റിക്വസ്റ്റ് കംപ്രസ് ചെയ്യുന്നതിന് പകരം അവ മോഡലിന്റെ ഔട്ട്പുട്ടിനെ രൂപപ്പെടുത്തുന്നു.

### Cache-Aware Compression

ചില പ്രൊവൈഡറുകൾ (prompt caching ഉള്ള Anthropic പോലുള്ളവ) **prompt caching**
പിന്തുണയ്ക്കുന്നു; ചെലവും ലേറ്റൻസിയും കുറയ്ക്കുന്നതിനായി prompt-ന്റെ ഭാഗങ്ങൾ കാഷ് ചെയ്യാൻ
ഇത് അവരെ അനുവദിക്കുന്നു. കാഷിംഗ് പ്രവർത്തനക്ഷമമാക്കിയിരിക്കുമ്പോൾ, aggressive compression
യഥാർത്ഥത്തിൽ പ്രകടനത്തെ **ദോഷകരമായി ബാധിച്ചേക്കാം**, കാരണം അത് കാഷ് ചെയ്ത ടോക്കണുകൾ
മാറ്റുകയും കാഷ് അസാധുവാക്കുകയും ചെയ്യുന്നു.

`cachingAware.ts` മൊഡ്യൂൾ **കാഷിംഗ് കോൺടെക്സ്റ്റ് കണ്ടെത്തുകയും**
അതനുസരിച്ച് **കംപ്രഷൻ സ്ട്രാറ്റജി ക്രമീകരിക്കുകയും** ചെയ്തുകൊണ്ട് ഇത് പരിഹരിക്കുന്നു.

#### ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു

1. **കാഷിംഗ് കോൺടെക്സ്റ്റ് കണ്ടെത്തുക** — `cache_control` മാർക്കറുകൾക്കായി റിക്വസ്റ്റ് ബോഡി സ്കാൻ ചെയ്യുന്നു
2. **കാഷിംഗ് പ്രൊവൈഡറുകളെ തിരിച്ചറിയുക** — ലക്ഷ്യ പ്രൊവൈഡർ കാഷിംഗ് പിന്തുണയ്ക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുന്നു
3. **സ്ട്രാറ്റജി ക്രമീകരിക്കുക** — കാഷിംഗ് പ്രൊവൈഡറുകൾക്കായി `aggressive`/`ultra` എന്നിവയെ `standard`-ലേക്ക് ഡൗൺഗ്രേഡ് ചെയ്യുന്നു
4. **system prompt ഒഴിവാക്കുക** — System prompt-കൾ സാധാരണയായി കാഷ് ചെയ്യപ്പെടുന്നതിനാൽ അവ കംപ്രസ് ചെയ്യരുത്

സ്ട്രാറ്റജി ഹെൽപ്പർ ഒരു `deterministicOnly` ഫ്ലാഗും നൽകുന്നു, എന്നാൽ പ്ലാൻ ബിൽഡർ
സ്ട്രാറ്റജി മാത്രമാണ് ഉപയോഗിക്കുന്നത് — നിലവിൽ downstream-ൽ ഒന്നും ആ ഫ്ലാഗ് വായിക്കുന്നില്ല.

#### കോഡ് ഉദാഹരണം

```ts
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 }
```

#### എപ്പോൾ ഉപയോഗിക്കണം

Cache-aware compression **എപ്പോഴും ഓണാണ്** — കോൺഫിഗറേഷൻ ആവശ്യമില്ല. കംപ്രഷൻ
ഓണായിരിക്കുകയും ലക്ഷ്യ പ്രൊവൈഡർ prompt caching പിന്തുണയ്ക്കുകയും ചെയ്യുമ്പോഴെല്ലാം
(Anthropic, OpenAI തുടങ്ങിയവ) ഇത് പ്രാബല്യത്തിൽ വരുന്നു; വ്യക്തമായ `cache_control`
മാർക്കറുകൾ ആവശ്യമില്ല — ഒരു കാഷിംഗ് പ്രൊവൈഡർ മാത്രം മതിയാകും ഡൗൺഗ്രേഡ് ട്രിഗർ ചെയ്യാൻ,
മാർക്കറുകൾ മാത്രം ഒരിക്കലും അത് ചെയ്യില്ല (മാർക്കർ കണ്ടെത്തൽ cache telemetry-ലേക്ക്
വിവരങ്ങൾ നൽകുന്നു, സ്ട്രാറ്റജി തീരുമാനത്തിലേക്കല്ല).

### Progressive Aging

ദീർഘമായ സംഭാഷണങ്ങളിൽ നിരവധി സന്ദേശ ടേണുകൾ ശേഖരിക്കപ്പെടുന്നു, എന്നാൽ പഴയ ടേണുകളുടെ
പ്രസക്തി ക്രമേണ കുറയുന്നു. `progressiveAging.ts` മൊഡ്യൂൾ **ടേൺ ദൂരത്തെ അടിസ്ഥാനമാക്കി
സന്ദേശങ്ങളുടെ വിശദാംശങ്ങൾ കുറയ്ക്കുന്നു** (സംഭാഷണത്തിന്റെ അവസാനം മുതൽ ദൂരം അളക്കുന്നു).
ഷിപ്പ് ചെയ്ത ഡിഫോൾട്ടുകൾ (`verbatim: 2, light: 2, moderate: 3`) ഉപയോഗിക്കുമ്പോൾ:

- **അവസാന 2 ടേണുകൾ (ദൂരം ≤ 2)**: അതേപടി നിലനിർത്തുന്നു
- **ദൂരം 3**: Caveman compression (അനാവശ്യ വാക്കുകൾ നീക്കംചെയ്യൽ)
- **ദൂരം 4+**: Assistant സന്ദേശങ്ങൾ സംഗ്രഹിക്കുന്നു; user സന്ദേശങ്ങൾ അവയുടെ ആദ്യ
  വരിയിലേക്ക് ചുരുക്കി 120 പ്രതീകമായി പരിമിതപ്പെടുത്തുന്നു; മറ്റ് റോളുകൾ മാറ്റമില്ലാതെ തുടരുന്നു. System prompt-കൾ,
  ഇതിനകം aging പ്രയോഗിച്ച സന്ദേശങ്ങൾ, ഏറ്റവും പുതിയ user സന്ദേശം എന്നിവ ദൂരം പരിഗണിക്കാതെ
  എല്ലായ്പ്പോഴും അതേപടി നിലനിർത്തുന്നു. ഒന്നും പൂർണ്ണമായി ഒഴിവാക്കുന്നില്ല, കൂടാതെ ഷിപ്പ് ചെയ്ത
  ഡിഫോൾട്ടുകളിൽ (`light` എന്നത് `verbatim`-ന് തുല്യമാണ്) `light`
  ബാൻഡിൽ എത്തിച്ചേരാനാവില്ല.

#### കോഡ് ഉദാഹരണം

```ts
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: lite compression
  moderate: 20, // ദൂരം <= 20: caveman compression
  fullSummary: 5, // type-ന് ആവശ്യമാണ്, banding code ഇത് വായിക്കുന്നില്ല
  // ദൂരം > 20: സംഗ്രഹിക്കുന്നു (assistant) / ആദ്യ വരി നിലനിർത്തുന്നു (user)
});

// saved = ലാഭിച്ച ടോക്കണുകളുടെ എണ്ണം
```

#### എപ്പോൾ ഉപയോഗിക്കണം

`aggressive` മോഡിൽ Progressive aging **എപ്പോഴും ഓണാണ്** — ഇത്
`compressAggressive()`-ന്റെ രണ്ടാം ഘട്ടമാണ്. Ultra മോഡ് ഇത് പ്രവർത്തിപ്പിക്കുന്നില്ല. ഇത്
പ്രത്യേകിച്ചും ഫലപ്രദമാകുന്ന സാഹചര്യങ്ങൾ:

- ദീർഘകാലം തുടരുന്ന കോഡിംഗ് സെഷനുകൾ
- ഒന്നിലധികം ദിവസങ്ങളിലായി നീളുന്ന സംഭാഷണങ്ങൾ
- നിരവധി tool call-കളുള്ള agentic workflow-കൾ

### Caveman Output Mode

Caveman output mode, മോഡലിനോട് തന്നെ സംക്ഷിപ്തമായ ഔട്ട്പുട്ട് ആവശ്യപ്പെടുന്ന
**system prompt നിർദ്ദേശങ്ങൾ** ചേർക്കുന്നു — `lite` ലെവൽ പൂർണ്ണ വാക്യങ്ങൾ നിലനിർത്തുന്ന
സംക്ഷിപ്ത ഉത്തരങ്ങൾ ആവശ്യപ്പെടുന്നു, `full` അതിനോട് "respond terse like smart caveman"
എന്ന് ആവശ്യപ്പെടുന്നു, `ultra` ടെലിഗ്രാഫിക് ഔട്ട്പുട്ട് ആവശ്യപ്പെടുന്നു; നിർദ്ദേശങ്ങൾ
അഭ്യർത്ഥിക്കുക മാത്രമാണ് ചെയ്യുന്നത്, അവയ്ക്ക് അത് ഉറപ്പുനൽകാനാവില്ല. റിക്വസ്റ്റുകൾക്ക് ഈ
നിർദ്ദേശങ്ങൾ `applyOutputStyles()` (`open-sse/services/compression/outputStyles/apply.ts`)
വഴി ലഭിക്കുന്നു: `open-sse/handlers/chatCore.ts` ആദ്യം back-compat shim
(`open-sse/services/compression/outputStyles/backCompat.ts`-ലെ
`resolveOutputStyleSelection()`) ഉപയോഗിച്ച് സെലക്ഷൻ പരിഹരിക്കുന്നു; `outputStyles`
ശൂന്യമായിരിക്കുമ്പോൾ, പ്രവർത്തനക്ഷമമാക്കിയ `cavemanOutputMode`-നെ
`cavemanOutputMode.intensity` തീവ്രതയിലുള്ള `terse-prose` output style-ലേക്ക് ഇത്
മാപ്പ് ചെയ്യുന്നു (താഴെയുള്ള Back-compat കാണുക); ശൂന്യമല്ലാത്ത `outputStyles`
സെലക്ഷൻ അതേപടി ഉപയോഗിക്കുന്നു, തുടർന്ന് `cavemanOutputMode.enabled`, `intensity`
എന്നിവയ്ക്ക് യാതൊരു പ്രഭാവവുമില്ല, എന്നാൽ അതിന്റെ `autoClarity` ടോഗിൾ തുടർന്നും
ബാധകമാണ്. `outputMode.ts`-ൽ നിർദ്ദേശങ്ങളുടെ ടെക്സ്റ്റുകൾ
(`CAVEMAN_INSTRUCTION_BY_LANGUAGE`), content bypass, injection ഉപയോഗിക്കുന്ന
placement helper എന്നിവ അടങ്ങിയിരിക്കുന്നു; അതിന്റെ സ്വന്തം `applyCavemanOutputMode()`
injector-ന് production caller ഇല്ല.

#### ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു

ഈ മോഡ് ഇൻപുട്ട് കംപ്രസ് ചെയ്യുന്നില്ല. ഇത് സിസ്റ്റം പ്രോംപ്റ്റിലേക്ക് ഒരു നിർദ്ദേശ ബ്ലോക്ക് ചേർക്കുന്നു
(താഴെയുള്ള ഇൻജക്ഷൻ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നത് കാണുക), കൂടാതെ അഭ്യർത്ഥനയ്ക്കായി തിരഞ്ഞെടുത്ത ഏതൊരു ഇൻപുട്ട് കംപ്രഷൻ മോഡും
അതിനുശേഷവും, ഇപ്പോൾ ബ്ലോക്ക് ഉൾക്കൊള്ളുന്ന ബോഡിയിൽ പ്രവർത്തിക്കുന്നു. ഓരോ ലെവലും അവസാനിക്കുന്ന പങ്കിട്ട
പരിധികളുടെ ക്ലോസിന് മുമ്പായി, ഇംഗ്ലീഷ് `full` ലെവൽ ഇങ്ങനെ പറയുന്നു:

> "ബുദ്ധിമാനായ ഗുഹാമനുഷ്യനെപ്പോലെ ചുരുക്കി മറുപടി നൽകുക. ആർട്ടിക്കിളുകൾ (a/an/the), അനാവശ്യ വാക്കുകൾ (just/really/basically/actually/simply), ഔപചാരിക മര്യാദകൾ, സന്ദേഹാത്മക ഭാഷ എന്നിവ ഒഴിവാക്കുക. വാക്യശകലങ്ങൾ അനുവദനീയമാണ്. ഹ്രസ്വമായ പര്യായങ്ങൾ ഉപയോഗിക്കുക (extensive എന്നതിന് പകരം big, implement എന്നതിന് പകരം fix). എല്ലാ സാങ്കേതിക ഉള്ളടക്കവും, കോഡും, പിശകുകളും, URLs-ഉം, ഐഡന്റിഫയറുകളും കൃത്യമായി നിലനിർത്തുക."

ഇത് പ്രത്യേകിച്ച് ഇനിപ്പറയുന്നവയ്ക്ക് നന്നായി പ്രവർത്തിക്കുന്നു:

- കോഡ് ജനറേഷൻ (കൂടുതൽ സംക്ഷിപ്തമായ ഔട്ട്പുട്ട് = കുറച്ച് ടോക്കണുകൾ)
- ദ്രുത ചോദ്യോത്തരങ്ങൾ (വിശദമായ വിശദീകരണങ്ങൾ ആവശ്യമില്ല)
- ബാച്ച് പ്രോസസ്സിംഗ് (ത്രൂപുട്ട് പരമാവധിയാക്കുക)

#### എപ്പോൾ ഉപയോഗിക്കണം

Caveman ഔട്ട്പുട്ട് മോഡ് **opt-in** ആണ്. കംപ്രഷൻ ഓണായിരിക്കുമ്പോൾ (`enabled: true`, Compression Settings പേജിലെ പ്രധാന ടോഗിൾ
ഓണായിരിക്കുമ്പോൾ), `cavemanOutputMode.enabled` ഉപയോഗിച്ച് അത് ഓണാക്കുക; `intensity`
`lite`, `full` അല്ലെങ്കിൽ `ultra` തിരഞ്ഞെടുക്കുന്നു:

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

ഒരു കംപ്രഷൻ കോംബോയുടെ **Output Mode** ടോഗിൾ (`outputMode`, `outputModeIntensity`-ൽ ലെവൽ)
ആ കോംബോ ബാധകമാകുന്ന അഭ്യർത്ഥനകൾക്കായി ഇതേ സ്വിച്ച് സജ്ജമാക്കുന്നു, കൂടാതെ
`omniroute_set_compression_engine` MCP ടൂൾ അതിന്റെ ബൂളിയൻ `outputMode`
ആർഗ്യുമെന്റ് വഴി ഇത് എഴുതുന്നു. ശൂന്യമല്ലാത്ത `outputStyles` തിരഞ്ഞെടുപ്പ് ഈ സ്വിച്ചിനേക്കാൾ മുൻഗണന നേടുന്നു.
ഡാഷ്ബോർഡിൽ, **Terse prose** ഔട്ട്പുട്ട് ശൈലി പ്രവർത്തനക്ഷമമാക്കുന്നത് ഇതേ ബ്ലോക്ക് ഇൻജക്റ്റ് ചെയ്യുന്നു (താഴെയുള്ള Output
Styles കാണുക).

### ഔട്ട്പുട്ട് ശൈലികൾ (കാറ്റലോഗ്)

മുകളിലെ 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 ശ്രേണി: പ്രവർത്തിക്കുന്ന ഏറ്റവും ചെറിയ മാറ്റം, ആവശ്യപ്പെടാത്ത അമൂർത്തീകരണങ്ങളില്ല.                                                                                                                                                                                                                  | en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi |
| പോണിടെയിൽ (അലസനായ സീനിയർ ഡെവലപ്പർ)             | `ponytail`      | "ഒരിക്കലും എഴുതാത്ത കോഡാണ് ഏറ്റവും മികച്ച കോഡ്": rewrite-നേക്കാൾ reuse, symptom-നേക്കാൾ root cause, പ്രവർത്തിക്കുന്ന ഏറ്റവും ഹ്രസ്വമായ diff.                                                                                                                                                              | en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi |
| എനിക്ക് ADHD ഉണ്ട് (പ്രവർത്തനം-ആദ്യം)          | `i-have-adhd`   | പ്രവർത്തനം ആദ്യം (ഗദ്യത്തിന് മുമ്പ് കമാൻഡ്/പാത്ത്/സ്നിപ്പെറ്റ്), അക്കമിട്ട പരിമിത ഘട്ടങ്ങൾ, ഒരൊറ്റ വ്യക്തമായ അടുത്ത ഘട്ടം, ആമുഖം/പുനരവലോകനം/സമാപനവാക്കുകൾ ഇല്ല. [ayghri/i-have-adhd](https://github.com/ayghri/i-have-adhd) (MIT)-ൽ നിന്ന് അനുരൂപമാക്കിയത്.                                               | en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi |
| Antislop UI ഫിൽട്ടർ                            | `antislop-ui`   | എല്ലാ ദൃശ്യ സാങ്കേതികതയും ഒരു ഉദ്ദേശ്യ പരിശോധന കടക്കണം (ശ്രേണീകരണം, വ്യക്തിത്വം, വായനാക്ഷമത); ഡിഫോൾട്ട് ഗ്രേഡിയന്റുകൾ/ഗ്ലാസ്/ഗ്ലോ ഇല്ല, പരിമിതമായ പാലറ്റ്, ടെംപ്ലേറ്റ് ലേഔട്ടുകൾ ഇല്ല. രണ്ട് antislop ശൈലികളും പ്രവർത്തനരഹിതമായ നിയന്ത്രണങ്ങളോ കെട്ടിച്ചമച്ച അവകാശവാദങ്ങളോ പാടില്ലെന്ന പരിധി ചേർക്കുന്നു. | en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi |
| Antislop പകർപ്പും മനുഷ്യ-കേന്ദ്രീകൃത ഫിൽട്ടറും | `antislop-copy` | വ്യക്തമായ പകർപ്പ് (em dash, പൊതുവായ CTAs, buzzwords, chatbot സമാപനവാക്കുകൾ, കെട്ടിച്ചമച്ച വസ്തുതകൾ എന്നിവ ഇല്ല), കൂടാതെ ആളുകൾക്കായുള്ള നിയമങ്ങൾ: WCAG AA കോൺട്രാസ്റ്റ്, ദൃശ്യമായ ഫോക്കസ്, കീബോർഡ് ആക്സസ്, ശൂന്യ/ലോഡിങ്/പിശക് നിലകൾ, മൊബൈൽ റീഫ്ലോ.                                                         | en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi |
| സംക്ഷിപ്ത CJK (文言)                           | `terse-cjk`     | `full`/`ultra` മറുപടി ക്ലാസിക്കൽ ചൈനീസിൽ (文言); `lite` ഫങ്ഷൻ വാക്കുകളോ ഔപചാരിക മര്യാദകളോ അലങ്കാരങ്ങളോ ഇല്ലാത്ത ഹ്രസ്വ മറുപടികൾ മാത്രം ആവശ്യപ്പെടുന്നു.                                                                                                                                                   | zh (ലൊക്കേൽ-ഗേറ്റഡ്, താഴെ കാണുക)              |

ഓരോ ശൈലിയിലും മൂന്ന് തീവ്രതാ ലെവലുകൾ ഉൾപ്പെടുന്നു — `lite`, `full`, `ultra` — കൂടാതെ ഓരോ ലെവലും
പങ്കിട്ട പരിധികളുടെ ക്ലോസിൽ (`outputMode.ts`-ലെ `SHARED_BOUNDARIES`) അവസാനിക്കുന്നു; ഇത്
കോഡ് ബ്ലോക്കുകൾ, ഫയൽ പാത്തുകൾ, കമാൻഡുകൾ, പിശകുകൾ, URLs എന്നിവ കൃത്യമായി നിലനിർത്തുന്നു. `terse-prose`,
`terse-cjk` ലെവൽ ടെക്സ്റ്റുകൾ ആ പട്ടികയിലേക്ക് ഐഡന്റിഫയറുകളും ചേർക്കുന്നു.

`terse-cjk` രണ്ട് ഇടങ്ങളിൽ `zh`-ലേക്ക് ലൊക്കേൽ-ഗേറ്റഡ് ആണ്. ഡാഷ്ബോർഡ് UI ഭാഷ ചൈനീസ് (`zh-CN` അല്ലെങ്കിൽ `zh-TW`) ആയിരിക്കുമ്പോൾ മാത്രം Compression Settings പേജ്
അതിന്റെ വരി കാണിക്കുന്നു, കൂടാതെ അഭ്യർത്ഥനയുടെ പരിഹരിച്ച ഭാഷ (താഴെയുള്ള ഭാഷാ
തിരഞ്ഞെടുപ്പ് കാണുക) `zh` ആയിരിക്കുമ്പോൾ മാത്രം `applyOutputStyles()` അത് ഇൻജക്റ്റ് ചെയ്യുന്നു. വരി മറയ്ക്കുന്നത് സേവ് ചെയ്ത `terse-cjk` തിരഞ്ഞെടുപ്പ് മായ്ക്കുന്നില്ല:
ക്രമീകരണ API ഏത് style id-യും സ്വീകരിക്കുന്നു, പേജിൽ മറ്റ് ശൈലികൾ സേവ് ചെയ്യുന്നത് അതിനെ നിലനിർത്തുന്നു. അഭ്യർത്ഥനാ
സമയത്ത്, `applyOutputStyles()`-ലെ ഭാഷാ പരിശോധന മാത്രമാണ് ഏക ലൊക്കേൽ ഗേറ്റ്.

#### ഇൻജക്ഷൻ എങ്ങനെ പ്രവർത്തിക്കുന്നു

`applyOutputStyles()` (`open-sse/services/compression/outputStyles/apply.ts`) തിരഞ്ഞെടുപ്പിനെ
കാറ്റലോഗുമായി പൊരുത്തപ്പെടുത്തി പരിഹരിക്കുന്നു (അജ്ഞാത id-കളും locale-മായി പൊരുത്തപ്പെടാത്ത ശൈലികളും
ഒഴിവാക്കപ്പെടും, ഒരിക്കലും പിശകാകില്ല; ഒരു ശൈലിയിലേക്കും പരിഹരിക്കപ്പെടാത്ത തിരഞ്ഞെടുപ്പ് body-യെ
മാറ്റമില്ലാതെ നിലനിർത്തുകയും `no_styles` ആയി ഒഴിവാക്കുകയും ചെയ്യും), തിരഞ്ഞെടുത്ത നിർദ്ദേശങ്ങളെ കാറ്റലോഗ്
ക്രമത്തിൽ സംയോജിപ്പിക്കുന്നു,
boundaries clause **ഒരിക്കൽ** ചേർക്കുന്നു (കൂടാതെ `less-code` അല്ലെങ്കിൽ `ponytail`
തിരഞ്ഞെടുക്കുമ്പോൾ safety clause, `SAFETY_BOUNDARIES` അല്ലെങ്കിൽ അതിന്റെ
പരിഭാഷയും), തുടർന്ന് ഒരൊറ്റ idempotency marker (`[OmniRoute Output Styles]`) ഉപയോഗിച്ച് block
ആരംഭിക്കുന്നു; അതിനാൽ വീണ്ടും പ്രയോഗിക്കുന്നത് ഒരു no-op ആണ്. പരിഹരിച്ച ഭാഷയ്ക്ക് (താഴെയുള്ള ഭാഷാ തിരഞ്ഞെടുപ്പ്
കാണുക) പരിഭാഷയുണ്ടെങ്കിൽ, ഇംഗ്ലീഷിന് പകരം പ്രാദേശികവൽക്കരിച്ച
നിർദ്ദേശം ചേർക്കപ്പെടും.

ശൂന്യമല്ലാത്ത `messages` array ഉള്ള body-യിൽ, content bypass-ന് മുമ്പാണ് idempotency check
പ്രവർത്തിക്കുന്നത്: `[OmniRoute Output Styles]` marker ഇതിനകം top-level
`system` field-ൽ (ഒരു string അല്ലെങ്കിൽ content-block array) അല്ലെങ്കിൽ string
content ഉള്ള system message-ൽ ഉണ്ടെങ്കിൽ, body `already_applied` ആയി മാറ്റമില്ലാതെ നിലനിർത്തുകയും
keyword check പ്രവർത്തിക്കാതിരിക്കുകയും ചെയ്യും.
അല്ലാത്തപക്ഷം, `open-sse/services/compression/outputMode.ts`-ലെ
content bypass (`shouldBypassCavemanOutputMode()`) അവസാനത്തെ മൂന്ന്
messages-ന്റെ role ഏതായാലും അവയുടെ text പരിശോധിക്കുകയും, ആ 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 ആയി on) on ആയിരിക്കുമ്പോൾ bypass പ്രവർത്തിക്കും;
toggle off ആക്കുന്നത് keyword check ഒഴിവാക്കും.

Bypass turn-നെ കടത്തിവിടുമ്പോൾ, പുതിയ `messages[0]` ഒരിക്കലും സൃഷ്ടിക്കാത്ത
`placeSystemInstruction()` (അതേ file), താഴെ പറയുന്നവയിൽ ആദ്യം കണ്ടെത്തുന്നതിൽ
block സ്ഥാപിക്കുന്നു:

1. തുടക്കത്തിലുള്ള, string content ഉള്ള system message: അതിന്റെ text-ന് ശേഷം block ചേർക്കപ്പെടും.
2. Top-level `system` field: string-ന്റെ text-ന് ശേഷം block ചേർക്കപ്പെടും, അല്ലെങ്കിൽ
   content-block array-യിലേക്ക് പുതിയ text block ആയി ചേർക്കപ്പെടും.
3. പിന്നീട് വരുന്ന, string content ഉള്ള ആദ്യത്തെ system message: അതിന്റെ
   text-ന് ശേഷം block ചേർക്കപ്പെടും.
4. മുകളിലുള്ളവയൊന്നുമില്ലെങ്കിൽ: `messages`-ന്റെ അവസാനം പുതിയ system message-ൽ block ചേർക്കപ്പെടും.

`messages` array ഇല്ലാത്ത (അല്ലെങ്കിൽ ശൂന്യമായ array ഉള്ള) body-യിൽ content bypass
പ്രവർത്തിക്കില്ല, top-level `system` field പരിഗണിക്കുകയുമില്ല. String
`instructions` field-ന്റെ text-ന് ശേഷം block ചേർക്കപ്പെടും; എന്നാൽ ആ field-ൽ ഇതിനകം
`[OmniRoute Output Styles]` marker ഉണ്ടെങ്കിൽ, body
`already_applied` ആയി മാറ്റമില്ലാതെ നിലനിർത്തപ്പെടും. Body-യിൽ string `instructions` field ഇല്ലെങ്കിലും
`input` (ഒരു string അല്ലെങ്കിൽ array) ഉണ്ടെങ്കിൽ, ആ field-ൽ ഉണ്ടായിരുന്ന string അല്ലാത്ത value
മാറ്റിസ്ഥാപിച്ച് block `instructions` ആയി മാറും. String `instructions` field-ഉം string അല്ലെങ്കിൽ array
`input`-ഉം ഇല്ലാത്ത body മാറ്റമില്ലാതെ നിലനിർത്തുകയും `no_messages` ആയി ഒഴിവാക്കുകയും ചെയ്യും.

#### എങ്ങനെ സജ്ജമാക്കാം

Dashboard-ൽ: **Compression Context → Compression Settings**
(`/dashboard/context/settings`), Output styles വിഭാഗത്തിൽ: ഓരോ style-നും on/off
toggle-ഉം level selector-ഉം ഉള്ള ഓരോ row. Compression തന്നെ on ആയിരിക്കുമ്പോൾ (page-ന്റെ
master toggle, `enabled`) styles ചേർക്കപ്പെടും. **Auto-Clarity Bypass** toggle **Caveman**
page-ലെ (`/dashboard/context/caveman`) **Output Mode** card-ലാണ്. Programmatically,
compression config തിരഞ്ഞെടുപ്പ് ഇങ്ങനെ നിലനിർത്തുന്നു:

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

Back-compat: `outputStyles` ശൂന്യമായിരിക്കുന്നിടത്തോളം, പഴയ `cavemanOutputMode.enabled`
setting `cavemanOutputMode.intensity`-ലെ `terse-prose`-ലേക്ക് map ചെയ്യപ്പെടുന്നു. തുടർന്ന് block
`[OmniRoute Output Styles]` marker ഉപയോഗിച്ച് ആരംഭിക്കും; പഴയ `applyCavemanOutputMode()`
injector എഴുതിയിരുന്നത് `[OmniRoute Caveman Output Mode]` ആയിരുന്നു. Marker-ന് താഴെ, en, pt-BR,
es, de, fr, it, ru, id, vi എന്നിവയിൽ text പഴയ injection-നോട് പൊരുത്തപ്പെടുന്നു; ja, zh എന്നിവയിൽ
boundaries clause-ന് മുമ്പ് ഒരു അധിക space ഉണ്ടാകും. `terse-prose` pt-BR, es, de,
fr, it, ru, zh, ja, id, vi എന്നിവയിലേക്ക് പരിഭാഷപ്പെടുന്നു; അതിനാൽ പരിഹരിച്ച ഭാഷ `hu` ആയ request-ന്
പഴയ injector അതിന്റെ Hungarian text ഉപയോഗിച്ചിരുന്നിടത്ത് English text ലഭിക്കും.

Output-style ഭാഷാ തിരഞ്ഞെടുപ്പ് (`outputStyles/apply.ts`-ലെ
`resolveOutputStyleLanguage()`): `languageConfig.enabled` on ആയിരിക്കുമ്പോൾ, `autoDetect`
request-ന്റെ `messages` array-യിൽ text ഉള്ള ഏറ്റവും പുതിയ user message (string content, അല്ലെങ്കിൽ
അതിന്റെ content parts-ലെ `text`) sample ചെയ്യുകയും അതിൽ Caveman engine-ന്റെ detector
(`detectCompressionLanguage()`) പ്രവർത്തിപ്പിക്കുകയും ചെയ്യും. Kana ഇല്ലാതെ Han
characters ഉള്ള text-ന് detector `zh` തിരികെ നൽകും; അല്ലാത്തപക്ഷം `it`, `pt-BR`, `es`, `de`,
`fr`, `ru`, `ja`, `hu`, `id` എന്നിവയിൽ ഏറ്റവും കൂടുതൽ hint matches ഉള്ളത് തിരികെ നൽകും,
ഒന്നും പൊരുത്തപ്പെടാത്തപ്പോൾ `en` തിരികെ നൽകും —
classify ചെയ്യാനാകാത്ത text-ന് `defaultLanguage` അല്ല, English ആണ് ലഭിക്കുക; കൂടാതെ styles-ൽ
`vi` text ഉൾപ്പെട്ടിട്ടുണ്ടെങ്കിലും `vi` ഒരിക്കലും detect ചെയ്യപ്പെടില്ല. Responses API body അതിന്റെ turns
`input`-ൽ സൂക്ഷിക്കുന്നു; അത് sample ചെയ്യപ്പെടാത്തതിനാൽ ആദ്യം `defaultLanguage`, തുടർന്ന് English
ലഭിക്കും. `messages`-ലെ ഒരു user message-ലും text ഇല്ലാത്തപ്പോഴോ `autoDetect` off ആയിരിക്കുമ്പോഴോ
`defaultLanguage`, തുടർന്ന് English പ്രയോഗിക്കും. `languageConfig.enabled` off ആയിരിക്കുമ്പോൾ
ഭാഷ English ആണ് — ഒരു compression combo request-ന് ബാധകമാകുന്നില്ലെങ്കിൽ മാത്രം (request-ന്റെ routing
combo-യ്ക്ക് നിയോഗിച്ച combo, അല്ലെങ്കിൽ built-in stacked pipeline-നായി chatCore fallback ചെയ്യുന്ന
default compression combo): combo പ്രയോഗിക്കുന്നത് ആ request-ന് `languageConfig.enabled` on
ആക്കുകയും combo-യുടെ language packs-ൽ നിന്ന് `defaultLanguage` സജ്ജമാക്കുകയും ചെയ്യും (saved value
combo-യുടെ packs-ലൊന്നാണെങ്കിൽ അത്, അല്ലെങ്കിൽ default ആയി `en` ഉള്ള combo-യുടെ ആദ്യ pack);
അതേസമയം saved `autoDetect` (default ആയി on) തുടർന്നും ബാധകമായിരിക്കും. Caveman input engine അതിന്റെ
rule-pack ഭാഷ വ്യത്യസ്തമായ രീതിയിൽ തിരഞ്ഞെടുക്കുന്നു — ഓരോ text part-നും പ്രത്യേകം; auto-detect off
ആയിരിക്കുമ്പോൾ `enabledPacks` അടിസ്ഥാനമാക്കി നിയന്ത്രിക്കുകയും ചെയ്യുന്നു.

ശൈലി × ഭാഷ മാട്രിക്സ്
`tests/unit/compression/output-styles-i18n-matrix.test.ts` ഉപയോഗിച്ച് പിൻ ചെയ്തിരിക്കുന്നു: ഓരോ കാറ്റലോഗ് ശൈലിക്കും ടെസ്റ്റിന്റെ `BASELINE_LANGUAGES`-ൽ ഒരു
എൻട്രി ആവശ്യമാണ്; ലൊക്കേൽ-ഗേറ്റ് ചെയ്തിട്ടില്ലാത്ത ഒരു ശൈലിക്ക്
pt-BR പരിഭാഷ ഉണ്ടായിരിക്കണം (ലൊക്കേൽ-ഗേറ്റ് ചെയ്ത `terse-cjk`-നെ ഈ നിയമത്തിൽനിന്ന് ഒഴിവാക്കിയിരിക്കുന്നു), അല്ലെങ്കിൽ അത്
`KNOWN_ENGLISH_ONLY`-ൽ ലിസ്റ്റ് ചെയ്തിരിക്കണം. പരിഭാഷകളൊന്നുമില്ലാത്ത ശൈലികൾ മാത്രമേ അതിൽ ഉൾപ്പെടുത്താവൂ —
ലിസ്റ്റ് ചെയ്ത ഒരു ശൈലിക്ക് ഏതെങ്കിലും പരിഭാഷയുണ്ടെങ്കിൽ ടെസ്റ്റ് പരാജയപ്പെടും; കൂടാതെ ഒരു ശൈലി അതിന്റെ
`BASELINE_LANGUAGES` എൻട്രിയിൽ ലിസ്റ്റ് ചെയ്തിട്ടുള്ള ഒരു ഭാഷ നഷ്ടപ്പെടുത്തുമ്പോഴും ടെസ്റ്റ് പരാജയപ്പെടും. ഒരു ശൈലി ചേർക്കാൻ,
[EXTENDING_COMPRESSION.md](./EXTENDING_COMPRESSION.md#adding-an-output-style) കാണുക.

### ടൂൾ ഫല കംപ്രഷൻ

`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>:` രൂപത്തിലുള്ള കുറഞ്ഞത് ഒരു വരിയെങ്കിലും ഉള്ള ഉള്ളടക്കം;
   ഇവിടെ ആദ്യ കോളണിന് മുമ്പുള്ള ടെക്സ്റ്റിൽ വൈറ്റ്സ്പേസ് ഉണ്ടാകരുത്. അത്തരം വരികൾ മാത്രം,
   പരമാവധി 30 എണ്ണം വരെ, നിലനിർത്തുകയും തുടർന്ന് ശേഷിക്കുന്ന പൊരുത്തങ്ങളുടെ എണ്ണവും പൊരുത്തപ്പെട്ട ഫയലുകളുടെ പട്ടികയും ചേർക്കുകയും ചെയ്യുന്നു;
   മറ്റെല്ലാ വരികളും ഒഴിവാക്കുന്നു. തന്ത്രം പ്രവർത്തനക്ഷമമാക്കാൻ അത്തരത്തിലുള്ള ഒരു വരി മതിയാകുന്നതിനാൽ,
   `12:30:45` പോലുള്ള ടൈംസ്റ്റാമ്പിൽ ആരംഭിക്കുന്ന ഒരു ലോഗ് വരിയും പൊരുത്തമായി കണക്കാക്കപ്പെടുന്നു.
3. **`shellOutput`**: ഒരു ANSI CSI സീക്വൻസ് (`ESC[`-ന് ശേഷം അക്കങ്ങളോ
   സെമിക്കോളണുകളോ, തുടർന്ന് കളർ കോഡുകളിലേതുപോലെ ഒരു അക്ഷരമോ) അല്ലെങ്കിൽ ടെക്സ്റ്റിലെ എവിടെയെങ്കിലും വൈറ്റ്സ്പേസ്
   പിന്തുടരുന്ന `$` അടങ്ങിയ ഔട്ട്പുട്ടിൽ നിന്ന് ആ സീക്വൻസുകൾ നീക്കംചെയ്യുന്നു (`ESC[?25l` അല്ലെങ്കിൽ ഒരു
   OSC വിൻഡോ-ടൈറ്റിൽ സീക്വൻസ് പോലുള്ള മറ്റ് എസ്കേപ്പുകൾ നിലനിർത്തുന്നു); തുടർച്ചയായി ആവർത്തിക്കുന്ന
   വരികൾ ഒരൊറ്റ വരിയാക്കി ചുരുക്കിക്കൊണ്ട് അവസാനത്തെ 50 വരികൾ നിലനിർത്തുന്നു. ഈ പരിശോധന `json`, `errorMessage`
   എന്നിവയ്ക്ക് മുമ്പ് പ്രവർത്തിക്കുന്നതിനാൽ, അത്തരത്തിലുള്ള `$` അടങ്ങുന്ന JSON അല്ലെങ്കിൽ പിശക് ഔട്ട്പുട്ട്
   `shellOutput` പ്രവർത്തനക്ഷമമായിരിക്കുമ്പോൾ അവയിലേക്ക് ഒരിക്കലും എത്തില്ല.
4. **`json`**: ഓപ്ഷണൽ വൈറ്റ്സ്പേസിന് ശേഷം `{` അല്ലെങ്കിൽ `[` ഉപയോഗിച്ച് ആരംഭിക്കുകയും
   പാർസ് ചെയ്യാൻ കഴിയുകയും ചെയ്യുന്ന 2,000-ൽ കൂടുതൽ അക്ഷരങ്ങളുള്ള JSON പേലോഡ് സംഗ്രഹിക്കുന്നു: 7-ൽ കൂടുതൽ ഇനങ്ങളുള്ള ഒരു അറേ
   അതിന്റെ ആദ്യത്തെ 5 ഇനങ്ങളും അവസാനത്തെ 2 ഇനങ്ങളും ആകെ എണ്ണവും നിലനിർത്തുന്നു; ഒരു ഒബ്ജക്റ്റ് അതിന്റെ ആദ്യത്തെ 20
   കീകൾ നിലനിർത്തുകയും, നെസ്റ്റഡ് ആയ ഓരോ ഒബ്ജക്റ്റ് അല്ലെങ്കിൽ അറേ മൂല്യവും ഒരു `{…N keys}` പ്ലേസ്ഹോൾഡർ ഉപയോഗിച്ച്
   മാറ്റിസ്ഥാപിക്കുകയും ചെയ്യുന്നു (ഒരു അറേയ്ക്ക് N അതിന്റെ നീളമാണ്), കൂടാതെ ആദ്യത്തെ 20-ന് ശേഷം
   ഒഴിവാക്കിയ കീകളെ എണ്ണുന്ന `_remaining_<N>_keys` മാർക്കറും ചേർക്കുന്നു. സ്കേലർ മൂല്യങ്ങൾ പൂർണ്ണമായി പകർത്തുന്നതിനാൽ,
   നെസ്റ്റഡ് മൂല്യങ്ങളൊന്നുമില്ലാത്ത 20 അല്ലെങ്കിൽ അതിൽ കുറവ് കീകളുള്ള ഒരു ഒബ്ജക്റ്റ് വീണ്ടും ഇൻഡന്റ് ചെയ്യുക മാത്രമാണ് ചെയ്യുന്നത് —
   മിനിഫൈ ചെയ്ത ഒന്നിന് കൂടുതൽ അക്ഷരങ്ങൾ ലഭിക്കുകയും അത് മാറ്റമില്ലാതെ തുടരുകയും ചെയ്യും.
5. **`errorMessage`**: എവിടെയെങ്കിലും, ഏത് ലെറ്റർ കേസിലായാലും, `error:`,
   `error ` (`no error found` എന്നതിലേതുപോലെ വാക്കിന് ശേഷം ഒരു സ്പേസ്), `[error]`,
   `exception:`, `exception `, `[exception]` അല്ലെങ്കിൽ `traceback` അടങ്ങിയ ഔട്ട്പുട്ട് അതിന്റെ ആദ്യ വരിയും,
   അടുത്ത 10 വരികളും അവസാനത്തെ 3 വരികളും നിലനിർത്തുന്നു; അവയ്ക്കിടയിലുള്ള വരികൾക്ക് പകരം
   `… [N frames elided] …` മാർക്കർ ഉപയോഗിക്കുന്നു. ആദ്യ വരിക്ക് ശേഷം 13-ൽ കൂടുതൽ വരികൾ ഉള്ളപ്പോൾ മാത്രമേ
   മാർക്കർ പ്രത്യക്ഷപ്പെടുകയുള്ളൂ; അതിനാൽ 14 വരികളോ അതിൽ കുറവോ ഉള്ള പിശക് ഔട്ട്പുട്ട് ചുരുക്കപ്പെടില്ല
   (12 അല്ലെങ്കിൽ 13 വരികളുള്ളപ്പോൾ അവസാനത്തെ 3 വരികൾ ഇതിനകം നിലനിർത്തിയ വരികൾ ആവർത്തിക്കുന്നു).

ഒരു തന്ത്രം പൊരുത്തപ്പെട്ടാൽ, അത് ഒന്നും ലാഭിക്കാത്തതാണെങ്കിലും പിന്നീടുള്ള തന്ത്രങ്ങൾ
പരീക്ഷിക്കില്ല. പൊരുത്തപ്പെട്ട തന്ത്രം കണക്കാക്കിയ ടോക്കണുകളൊന്നും ലാഭിക്കാത്തപ്പോൾ (നീളം ÷ 4, മുകളിലേക്കു റൗണ്ട് ചെയ്തത്) —
ഉദാഹരണത്തിന്, 25 വരികളോ അതിൽ കുറവോ ഉള്ള കോഡ് പോലെയുള്ള ഫയൽ, അല്ലെങ്കിൽ 7 ഇനങ്ങളോ അതിൽ കുറവോ ഉള്ള
2,000-ൽ കൂടുതൽ അക്ഷരങ്ങളുള്ള JSON അറേ — അഗ്രസീവ് എഞ്ചിൻ യഥാർത്ഥ ടൂൾ
ഫലം നിലനിർത്തുന്നു: രണ്ട് കോളറുകളും (`compressAggressive()`-ഉം `compressAnthropicToolResultBlock()`-ഉം)
`saved` 0 അല്ലെങ്കിൽ അതിൽ താഴെയായിരിക്കുമ്പോൾ യഥാർത്ഥ ഉള്ളടക്കം നിലനിർത്തുന്നു; എന്നാൽ `compressToolResult()` തന്നെ
ആ തന്ത്രത്തിന്റെ ഔട്ട്പുട്ട് ഇപ്പോഴും തിരികെ നൽകുന്നു. ടൂൾ-ഫല ഘട്ടം അന്തിമ തീരുമാനമല്ല:
8,192 അക്ഷരങ്ങളിൽ (`maxTokensPerMessage`, 2,048, ഗുണം 4) കൂടുതലുള്ള ഒരു `tool` അല്ലെങ്കിൽ `function`
സന്ദേശം എഞ്ചിന്റെ ഫാൾബാക്ക് സംഗ്രഹിക്കൽ സംവിധാനത്തിന് ഇനിയും ചുരുക്കാനാകും.

#### എപ്പോൾ ഉപയോഗിക്കണം

ടൂൾ ഫല കംപ്രഷൻ അഗ്രസീവ് എഞ്ചിന്റെ ഒന്നാം ഘട്ടമാണ് (`open-sse/services/compression/aggressive.ts`-ലെ
`compressAggressive()`); അതിനാൽ ഇത് Aggressive മോഡിലും സ്റ്റാക്ക് ചെയ്ത പൈപ്പ്ലൈനിലെ ഒരു
`aggressive` ഘട്ടത്തിലും പ്രവർത്തിക്കുന്നു. ഇത് OpenAI-രൂപത്തിലുള്ള `tool`, `function`
സന്ദേശങ്ങളും Anthropic `tool_result` ബ്ലോക്കുകൾക്കുള്ളിലെ ടെക്സ്റ്റും കംപ്രസ് ചെയ്യുന്നു. ഓരോ തന്ത്രത്തിനും
`aggressive.toolStrategies`-ന് കീഴിൽ അതിന്റേതായ സ്വിച്ച് ഉണ്ട്; അവയെല്ലാം ഡിഫോൾട്ടായി ഓണാണ്. ഡാഷ്ബോർഡിൽ,
കംപ്രഷൻ ഓണായിരിക്കുകയും ഡിഫോൾട്ട് മോഡ് Aggressive ആയിരിക്കുകയും ചെയ്യുമ്പോൾ Caveman പേജിന്റെ
**Advanced** കാഴ്ചയിലാണ് സ്വിച്ചുകൾ.

### സ്റ്റാക്ക് ചെയ്ത പൈപ്പ്ലൈൻ

സ്റ്റാക്ക് ചെയ്ത മോഡ് **ഒന്നിലധികം എഞ്ചിനുകൾ ക്രമത്തിൽ** പ്രവർത്തിപ്പിക്കുന്നു — സാധാരണയായി ആദ്യം RTK
(ടൂൾ ഔട്ട്പുട്ടിൽ 60-90% ലാഭം), തുടർന്ന് ശേഷിക്കുന്ന ടെക്സ്റ്റിൽ Caveman (~46% ഇൻപുട്ട്
ലാഭം). ഇവ സംയോജിപ്പിക്കുമ്പോൾ ലഭിക്കുന്നത് **78-95% യോഗ്യമായ പരിധിയാണ്** (മുകളിലെ Upstream Savings Math
കാണുക): `1 - (1 - 0.60..0.90) × (1 - 0.46)`-ന്റെ ശരാശരി ≈89%.

#### ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു

```
ഇൻപുട്ട് (1000 ടോക്കണുകൾ)
  → RTK (കമാൻഡ്-അവബോധമുള്ള ഫിൽട്ടർ) → 200 ടോക്കണുകൾ
    → Caveman (അനാവശ്യ ഉള്ളടക്കം നീക്കംചെയ്യൽ) → 108 ടോക്കണുകൾ
  → ഔട്ട്പുട്ട് (108 ടോക്കണുകൾ, ~89% ലാഭം)
```

#### എപ്പോൾ ഉപയോഗിക്കണം

ഇവയ്ക്കായി സ്റ്റാക്ക് ചെയ്ത മോഡ് ഉപയോഗിക്കുക:

- ടൂൾ-സാന്ദ്രമായ വർക്ക്ഫ്ലോകൾ (ഏജന്റിക് കോഡിങ്, ഗവേഷണം)
- ചെലവ് നിർണായകമായ ബാച്ച് പ്രോസസ്സിങ്
- പരമാവധി ടോക്കൺ ലാഭം ആവശ്യമായപ്പോൾ

സ്റ്റാക്ക് ചെയ്ത പൈപ്പ്ലൈനുകൾ ആഗോള `stackedPipeline` കംപ്രഷൻ
ക്രമീകരണത്തിലൂടെയോ, ഒരു റൂട്ടിങ് കോമ്പോയ്ക്ക് നിയോഗിച്ച പേരുള്ള കംപ്രഷൻ കോമ്പോയിലൂടെയോ ക്രമീകരിക്കുന്നു
(മുകളിലെ Per-Combo Override കാണുക) — ഒരു ഓട്ടോ-കോമ്പോ `modePack` വഴിയല്ല (ആ ഫീൽഡ്
ഓട്ടോ-കോമ്പോ മോഡൽ തിരഞ്ഞെടുപ്പിന്റെ ഭാരനിർണ്ണയം മാത്രം മാറ്റുന്നു; `stacked` സാധുവായ പാക്ക് നാമമല്ല).

---

## കോംപ്രഷൻ കോംബോ ഓവർറൈഡുകൾ

വ്യത്യസ്ത ഉപയോഗ സാഹചര്യങ്ങൾക്കായി പ്രവർത്തനം സൂക്ഷ്മമായി ക്രമീകരിക്കുന്നതിന് ഗ്ലോബൽ കോംപ്രഷൻ മോഡ് **ഓരോ കോംബോയ്ക്കും** ഓവർറൈഡ് ചെയ്യാം:

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

ഇത് ഇനിപ്പറയുന്നവയ്ക്ക് ഉപകാരപ്രദമാണ്:

- **കോഡിംഗ് കോംബോകൾ**: ദൈർഘ്യമേറിയ സെഷനുകൾക്കായി `aggressive` മോഡ് ഉപയോഗിക്കുക
- **ദ്രുത ചോദ്യോത്തര കോംബോകൾ**: വേഗത്തിലുള്ള പ്രതികരണങ്ങൾക്കായി `lite` മോഡ് ഉപയോഗിക്കുക
- **ടൂൾ-അധിഷ്ഠിത കോംബോകൾ**: പരമാവധി ലാഭത്തിനായി `stacked` മോഡ് ഉപയോഗിക്കുക
- **പ്രൊഡക്ഷൻ കോംബോകൾ**: കാഷിംഗ് പ്രൊവൈഡറുകൾക്കായി ഓവർറൈഡ് ഓഫാക്കി വെക്കുക — എല്ലായ്പ്പോഴും സജീവമായ
  കാഷ്-അവെയർ ക്രമീകരണം `aggressive`/`ultra` മോഡുകളെ സ്വയമേവ `standard` ആയി ഡൗൺഗ്രേഡ് ചെയ്യുന്നു
  (തിരഞ്ഞെടുക്കാവുന്ന `cache-aware` മോഡ് നിലവിലില്ല)

---

## ഇതും കാണുക

- [എൻവയോൺമെന്റ് കോൺഫിഗ്](../reference/ENVIRONMENT.md) — കോംപ്രഷൻ എൻവയോൺമെന്റ് വേരിയബിളുകൾ
- [ആർക്കിടെക്ചർ ഗൈഡ്](../architecture/ARCHITECTURE.md) — കോംപ്രഷൻ പൈപ്പ്ലൈനിന്റെ ആന്തരിക ഘടകങ്ങൾ
- [ഉപയോക്തൃ ഗൈഡ്](../guides/USER_GUIDE.md) — കോംപ്രഷൻ ഉപയോഗിച്ചു തുടങ്ങൽ
- [RTK കോംപ്രഷൻ](./RTK_COMPRESSION.md) — RTK ഫിൽട്ടറുകൾ, ട്രസ്റ്റ് മോഡൽ, വെരിഫൈ ഗേറ്റ്, റോ-ഔട്ട്പുട്ട് വീണ്ടെടുക്കൽ
- [കോംപ്രഷൻ എഞ്ചിനുകൾ](./COMPRESSION_ENGINES.md) — Caveman, RTK, stacked, APIs, MCP, ഡാഷ്ബോർഡ്
- [കോംപ്രഷൻ റൂൾസ് ഫോർമാറ്റ്](./COMPRESSION_RULES_FORMAT.md) — JSON റൂൾ-പാക്ക് ഫോർമാറ്റ്
- [കോംപ്രഷൻ ലാംഗ്വേജ് പാക്കുകൾ](./COMPRESSION_LANGUAGE_PACKS.md) — ഭാഷാ-നിർദ്ദിഷ്ട Caveman നിയമങ്ങൾ