# 🗜️ 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) · 🇰🇷 [ko](../../../ko/docs/compression/COMPRESSION_GUIDE.md) · 🇱🇹 [lt](../../../lt/docs/compression/COMPRESSION_GUIDE.md) · 🇱🇻 [lv](../../../lv/docs/compression/COMPRESSION_GUIDE.md) · 🇮🇳 [ml](../../../ml/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%)
    → ಸ್ಟ್ಯಾಂಡರ್ಡ್: Caveman-ಶೈಲಿಯ ಅನಗತ್ಯ ಪದಗಳ ತೆಗೆದುಹಾಕುವಿಕೆ (~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) ನಿಂದ ಪ್ರೇರಿತವಾಗಿದೆ — ಅರ್ಥವನ್ನು ಉಳಿಸಿಕೊಂಡೇ ಅನಗತ್ಯ ಪದಗಳು ಮತ್ತು ಸುದೀರ್ಘ ಪದಪ್ರಯೋಗಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ:

- ಅನಗತ್ಯ ಪದಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ("ದಯವಿಟ್ಟು", "ನನ್ನ ಅನಿಸಿಕೆಯಂತೆ", "ಮೂಲತಃ", "ವಾಸ್ತವವಾಗಿ")
- ಸುದೀರ್ಘ ಪದಗುಚ್ಛಗಳನ್ನು ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸುತ್ತದೆ ("ಮಾಡುವ ಸಲುವಾಗಿ" → "ಮಾಡಲು", "ಇದರ ಪರಿಣಾಮವಾಗಿ" → "ಏಕೆಂದರೆ")
- ವಿನಯಪೂರ್ವಕ ಹಿಂಜರಿಕೆಯ ನುಡಿಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ ("ನೀವು ದಯವಿಟ್ಟು...", "ನಿಮಗೆ ಸಾಧ್ಯವಾದರೆ...")
- ಕೋಡಿಂಗ್ ಪ್ರಾಂಪ್ಟ್ಗಳಿಗೆ ಸರಿಹೊಂದಿಸಲಾದ 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 schema 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 ಉಳಿತಾಯ) * (1 - Caveman ಇನ್ಪುಟ್ ಉಳಿತಾಯ)
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% ವ್ಯಾಪ್ತಿಯ ಉಳಿತಾಯ ದೊರೆಯುತ್ತದೆ. ಒಂದೇ ಸೆಷನ್ನ
ಕಡಿಮೆ ಒಟ್ಟು ಉಳಿತಾಯದ ಶೇಕಡಾವಾರನ್ನು ಕಂಪ್ರೆಷನ್ ತಪ್ಪಾಗಿ ಕಾನ್ಫಿಗರ್ ಆಗಿದೆ ಎಂಬುದಕ್ಕೆ ಪುರಾವೆಯಾಗಿ ಬಳಸಬೇಡಿ — ಮೊದಲು
ಆಧಾರವಾಗಿರುವ ಸಾಧನ ಔಟ್ಪುಟ್ ನಿಜವಾಗಿಯೂ ಪುನರಾವರ್ತಿತವಾಗಿತ್ತೇ ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸಿ.

---

## ಟೋಕನ್ ಉಳಿತಾಯದ ದೃಶ್ಯೀಕರಣ

```
ಕಂಪ್ರೆಷನ್ ಇಲ್ಲದೆ: 47K ಟೋಕನ್ಗಳನ್ನು LLMಗೆ ಕಳುಹಿಸಲಾಗಿದೆ
Lite ಜೊತೆಗೆ:      40K ಟೋಕನ್ಗಳನ್ನು ಕಳುಹಿಸಲಾಗಿದೆ     (15% ಉಳಿತಾಯ — ಸುರಕ್ಷಿತ, ಯಾವಾಗಲೂ ಸಕ್ರಿಯ)
Standard ಜೊತೆಗೆ:  33K ಟೋಕನ್ಗಳನ್ನು ಕಳುಹಿಸಲಾಗಿದೆ     (30% ಉಳಿತಾಯ — caveman-ಮಾತಿನ ನಿಯಮಗಳು)
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
```

ಪಾವತಿಸಿದ ಸಬ್ಸ್ಕ್ರಿಪ್ಶನ್ಗಳಲ್ಲಿ ಲೈಟ್ ಮೋಡ್ ಅನ್ನು ಉಳಿಸಿಕೊಂಡು, ಉಚಿತ/ಕೋಡಿಂಗ್ ಪೂರೈಕೆದಾರರಲ್ಲಿ ಸ್ಟ್ಯಾಕ್ ಮಾಡಿದ
ಕಂಪ್ರೆಷನ್ ಅನ್ನು ಬಳಸಲು ಇದು ನಿಮಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ.

ಈ "ಪ್ರತಿ-ಕಾಂಬೊ ಓವರ್ರೈಡ್" ನಿಯೋಜನೆಯು **ರೂಟಿಂಗ್-ಕಾಂಬೊ ಕಂಪ್ರೆಷನ್
ಮೋಡ್** ಓವರ್ರೈಡ್ಗಿಂತ (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 ರಚನೆಗಳು ಮತ್ತು ರಚನಾತ್ಮಕ ಡೇಟಾ
- ✅ ಐಡೆಂಟಿಫೈಯರ್ಗಳು ಮತ್ತು ಸಂರಕ್ಷಿತ ತಾಂತ್ರಿಕ ಟೋಕನ್ಗಳು
- ✅ ಗಣಿತೀಯ ಅಭಿವ್ಯಕ್ತಿಗಳು
- ✅ ಟೂಲ್/ಫಂಕ್ಷನ್ ಕರೆ ವ್ಯಾಖ್ಯಾನಗಳು
- ✅ ಸಿಸ್ಟಮ್ ಪ್ರಾಂಪ್ಟ್ಗಳು (ಲೈಟ್ ಮೋಡ್ನಲ್ಲಿ)

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  | ಆಫ್, ಲೈಟ್                                                                                                                                                      | ✅ ಬಿಡುಗಡೆ ಮಾಡಲಾಗಿದೆ |
| ಹಂತ 2  | ಸ್ಟ್ಯಾಂಡರ್ಡ್, ಅಗ್ರೆಸಿವ್, ಅಲ್ಟ್ರಾ                                                                                                                               | ✅ ಬಿಡುಗಡೆ ಮಾಡಲಾಗಿದೆ |
| ಹಂತ 3  | RTK, ಸ್ಟ್ಯಾಕ್ಡ್, ಸಂಕುಚನ ಸಂಯೋಜನೆಗಳು                                                                                                                             | ✅ ಬಿಡುಗಡೆ ಮಾಡಲಾಗಿದೆ |
| ಹಂತ 4  | ಔಟ್ಪುಟ್ ಶೈಲಿಗಳು, SLM-ಹಂತದ ಅಲ್ಟ್ರಾ, ಮೌಲ್ಯಮಾಪನ ವ್ಯವಸ್ಥೆ                                                                                                          | ✅ ಬಿಡುಗಡೆ ಮಾಡಲಾಗಿದೆ |
| ಹಂತ 4C | ಹೊಂದಾಣಿಕೆಯಾಗುವ ಕಾಂಟೆಕ್ಸ್ಟ್-ಬಜೆಟ್ ("ಡಯಲ್") — ಕಂಪ್ಯೂಟ್ ಎಂಜಿನ್ + API (`PUT /api/settings/compression` ನಲ್ಲಿ `contextBudget`) + ಡ್ಯಾಶ್ಬೋರ್ಡ್ ಮೋಡ್/ನೀತಿ ನಿಯಂತ್ರಣಗಳು | ✅ ಬಿಡುಗಡೆ ಮಾಡಲಾಗಿದೆ |

---

## ಕೃತಜ್ಞತೆಗಳು

ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಮೋಡ್ನ ಸಂಕುಚನ ನಿಯಮಗಳು **[JuliusBrussee](https://github.com/JuliusBrussee)** ಅವರ **[Caveman](https://github.com/JuliusBrussee/caveman)** (⭐ 51K+) — ವೈರಲ್ ಆದ "ಹೆಚ್ಚು ಟೋಕನ್ಗಳನ್ನು ಏಕೆ ಬಳಸಬೇಕು, ಕಡಿಮೆ ಟೋಕನ್ಗಳಿಂದ ಕೆಲಸವಾದಾಗ" ಯೋಜನೆಯಿಂದ ಪ್ರೇರಿತವಾಗಿವೆ. Caveman `~75%` ಕಡಿಮೆ ಔಟ್ಪುಟ್ ಟೋಕನ್ಗಳು, ಬೆಂಚ್ಮಾರ್ಕ್ನಲ್ಲಿ ಸರಾಸರಿ `65%` ಔಟ್ಪುಟ್ ಉಳಿತಾಯ, `22-87%` ಔಟ್ಪುಟ್ ವ್ಯಾಪ್ತಿ ಮತ್ತು `~46%` ಇನ್ಪುಟ್-ಸಂಕುಚನ ಟೂಲ್ ಅನ್ನು ವರದಿ ಮಾಡುತ್ತದೆ.

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
ಆಕ್ರಮಣಕಾರಿ ಎಂಜಿನ್ನ 1 ಮತ್ತು 2ನೇ ಹಂತಗಳಾಗಿವೆ (Aggressive ಮೋಡ್ ಮತ್ತು
ಸ್ಟ್ಯಾಕ್ ಮಾಡಿದ ಪೈಪ್ಲೈನ್ನ `aggressive` ಹಂತ), Stacked Pipeline ಎಂಬುದು Stacked ಮೋಡ್ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ವಿಧಾನವಾಗಿದೆ, Cache-Aware Compression
ಸಂಕೋಚನ ಸಕ್ರಿಯವಾಗಿರುವಾಗ ಕ್ಯಾಶಿಂಗ್ ಪೂರೈಕೆದಾರರಿಗಾಗಿ `aggressive` ಮತ್ತು `ultra` ಅನ್ನು `standard` ಗೆ
ತಗ್ಗಿಸುತ್ತದೆ, ಹಾಗೂ Caveman Output Mode ಮತ್ತು Output Styles ವಿನಂತಿಯನ್ನು ಸಂಕೋಚಿಸುವ ಬದಲು
ಮಾದರಿಯ ಔಟ್ಪುಟ್ ಅನ್ನು ರೂಪಿಸುವ, ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ನಿಷ್ಕ್ರಿಯವಾಗಿರುವ, ಆಯ್ಕೆಯ ಸಿಸ್ಟಮ್-ಪ್ರಾಂಪ್ಟ್ ಸೂಚನೆಗಳಾಗಿವೆ.

### ಕ್ಯಾಶ್-ಅವೇರ್ ಸಂಕೋಚನ

ಕೆಲವು ಪೂರೈಕೆದಾರರು (ಪ್ರಾಂಪ್ಟ್ ಕ್ಯಾಶಿಂಗ್ ಹೊಂದಿರುವ Anthropicನಂತಹವು) **ಪ್ರಾಂಪ್ಟ್ ಕ್ಯಾಶಿಂಗ್** ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತಾರೆ,
ಇದು ವೆಚ್ಚ ಮತ್ತು ವಿಳಂಬವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಪ್ರಾಂಪ್ಟ್ನ ಭಾಗಗಳನ್ನು ಕ್ಯಾಶ್ ಮಾಡಲು ಅವರಿಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ. ಕ್ಯಾಶಿಂಗ್
ಸಕ್ರಿಯವಾಗಿರುವಾಗ, ಆಕ್ರಮಣಕಾರಿ ಸಂಕೋಚನವು ವಾಸ್ತವವಾಗಿ ಕಾರ್ಯಕ್ಷಮತೆಗೆ **ಹಾನಿ** ಮಾಡಬಹುದು,
ಏಕೆಂದರೆ ಅದು ಕ್ಯಾಶ್ ಮಾಡಿದ ಟೋಕನ್ಗಳನ್ನು ಬದಲಾಯಿಸಿ, ಕ್ಯಾಶ್ ಅನ್ನು ಅಮಾನ್ಯಗೊಳಿಸುತ್ತದೆ.

`cachingAware.ts` ಮಾಡ್ಯೂಲ್ **ಕ್ಯಾಶಿಂಗ್ ಸಂದರ್ಭವನ್ನು ಪತ್ತೆಹಚ್ಚುವ** ಮತ್ತು
ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ **ಸಂಕೋಚನ ಕಾರ್ಯತಂತ್ರವನ್ನು ಸರಿಹೊಂದಿಸುವ** ಮೂಲಕ ಇದನ್ನು ಪರಿಹರಿಸುತ್ತದೆ.

#### ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ

1. **ಕ್ಯಾಶಿಂಗ್ ಸಂದರ್ಭವನ್ನು ಪತ್ತೆಹಚ್ಚುವುದು** — `cache_control` ಗುರುತುಗಳಿಗಾಗಿ ವಿನಂತಿಯ ಬಾಡಿಯನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುತ್ತದೆ
2. **ಕ್ಯಾಶಿಂಗ್ ಪೂರೈಕೆದಾರರನ್ನು ಗುರುತಿಸುವುದು** — ಗುರಿ ಪೂರೈಕೆದಾರರು ಕ್ಯಾಶಿಂಗ್ ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತಾರೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ
3. **ಕಾರ್ಯತಂತ್ರವನ್ನು ಸರಿಹೊಂದಿಸುವುದು** — ಕ್ಯಾಶಿಂಗ್ ಪೂರೈಕೆದಾರರಿಗಾಗಿ `aggressive`/`ultra` ಅನ್ನು `standard` ಗೆ ತಗ್ಗಿಸುತ್ತದೆ
4. **ಸಿಸ್ಟಮ್ ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಬಿಟ್ಟುಬಿಡುವುದು** — ಸಿಸ್ಟಮ್ ಪ್ರಾಂಪ್ಟ್ಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಕ್ಯಾಶ್ ಮಾಡಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಅವುಗಳನ್ನು ಸಂಕೋಚಿಸಬೇಡಿ

ಕಾರ್ಯತಂತ್ರದ ಸಹಾಯಕವು `deterministicOnly` ಫ್ಲ್ಯಾಗ್ ಅನ್ನೂ ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಆದರೆ ಪ್ಲಾನ್ ಬಿಲ್ಡರ್
ಕಾರ್ಯತಂತ್ರವನ್ನು ಮಾತ್ರ ಬಳಸುತ್ತದೆ — ಪ್ರಸ್ತುತ ನಂತರದ ಯಾವುದೇ ಘಟಕವು ಆ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಓದುವುದಿಲ್ಲ.

#### ಕೋಡ್ ಉದಾಹರಣೆ

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

#### ಯಾವಾಗ ಬಳಸಬೇಕು

ಕ್ಯಾಶ್-ಅವೇರ್ ಸಂಕೋಚನವು **ಯಾವಾಗಲೂ ಸಕ್ರಿಯವಾಗಿರುತ್ತದೆ** — ಯಾವುದೇ ಸಂರಚನೆ ಅಗತ್ಯವಿಲ್ಲ. ಸಂಕೋಚನ
ಸಕ್ರಿಯವಾಗಿದ್ದು, ಗುರಿ ಪೂರೈಕೆದಾರರು ಪ್ರಾಂಪ್ಟ್ ಕ್ಯಾಶಿಂಗ್ ಅನ್ನು ಬೆಂಬಲಿಸುವಾಗ (Anthropic, OpenAI,
ಇತ್ಯಾದಿ) ಇದು ಕಾರ್ಯಪ್ರವೃತ್ತವಾಗುತ್ತದೆ; ಸ್ಪಷ್ಟವಾದ `cache_control` ಗುರುತುಗಳು ಅಗತ್ಯವಿಲ್ಲ — ಕ್ಯಾಶಿಂಗ್ ಪೂರೈಕೆದಾರರು ಮಾತ್ರವೇ
ತಗ್ಗಿಸುವಿಕೆಯನ್ನು ಪ್ರಚೋದಿಸುತ್ತಾರೆ ಮತ್ತು ಗುರುತುಗಳು ಮಾತ್ರ ಎಂದಿಗೂ ಪ್ರಚೋದಿಸುವುದಿಲ್ಲ (ಗುರುತು ಪತ್ತೆಹಚ್ಚುವಿಕೆ ಕ್ಯಾಶ್
ಟೆಲಿಮೆಟ್ರಿಗೆ ಮಾಹಿತಿ ಒದಗಿಸುತ್ತದೆ, ಕಾರ್ಯತಂತ್ರದ ನಿರ್ಧಾರಕ್ಕಲ್ಲ).

### ಪ್ರಗತಿಶೀಲ ಏಜಿಂಗ್

ದೀರ್ಘ ಸಂಭಾಷಣೆಗಳಲ್ಲಿ ಅನೇಕ ಸಂದೇಶದ ಸರದಿಗಳು ಸಂಗ್ರಹವಾಗುತ್ತವೆ, ಆದರೆ ಹಳೆಯ ಸರದಿಗಳು ಕ್ರಮೇಣ ಕಡಿಮೆ
ಪ್ರಸ್ತುತವಾಗುತ್ತವೆ. `progressiveAging.ts` ಮಾಡ್ಯೂಲ್ **ಸರದಿಯ ಅಂತರದ ಆಧಾರದ ಮೇಲೆ ಸಂದೇಶಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ**
(ಸಂಭಾಷಣೆಯ ಕೊನೆಯಿಂದ ಅಂತರವನ್ನು ಅಳೆಯಲಾಗುತ್ತದೆ). ಒದಗಿಸಲಾದ ಪೂರ್ವನಿಯೋಜಿತ ಮೌಲ್ಯಗಳೊಂದಿಗೆ
(`verbatim: 2, light: 2, moderate: 3`):

- **ಕೊನೆಯ 2 ಸರದಿಗಳು (ಅಂತರ ≤ 2)**: ಯಥಾವತ್ತಾಗಿ ಉಳಿಸಲಾಗುತ್ತದೆ
- **ಅಂತರ 3**: Caveman ಸಂಕೋಚನ (ಅನಗತ್ಯ ಪದಗಳ ತೆಗೆದುಹಾಕುವಿಕೆ)
- **ಅಂತರ 4+**: ಸಹಾಯಕನ ಸಂದೇಶಗಳನ್ನು ಸಾರಾಂಶಗೊಳಿಸಲಾಗುತ್ತದೆ; ಬಳಕೆದಾರರ ಸಂದೇಶಗಳನ್ನು ಅವುಗಳ ಮೊದಲ
  ಸಾಲಿಗೆ ಇಳಿಸಿ, 120 ಅಕ್ಷರಗಳಿಗೆ ಮಿತಿಗೊಳಿಸಲಾಗುತ್ತದೆ; ಇತರ ಪಾತ್ರಗಳನ್ನು ಬದಲಾಯಿಸುವುದಿಲ್ಲ. ಸಿಸ್ಟಮ್ ಪ್ರಾಂಪ್ಟ್ಗಳು, ಈಗಾಗಲೇ ಏಜ್ ಮಾಡಲಾದ
  ಸಂದೇಶಗಳು ಮತ್ತು ಇತ್ತೀಚಿನ ಬಳಕೆದಾರರ ಸಂದೇಶವನ್ನು ಅಂತರವನ್ನು ಲೆಕ್ಕಿಸದೆ ಯಾವಾಗಲೂ ಯಥಾವತ್ತಾಗಿ ಉಳಿಸಲಾಗುತ್ತದೆ.
  ಯಾವುದನ್ನೂ ಸಂಪೂರ್ಣವಾಗಿ ಕೈಬಿಡುವುದಿಲ್ಲ, ಮತ್ತು ಒದಗಿಸಲಾದ ಪೂರ್ವನಿಯೋಜಿತ ಮೌಲ್ಯಗಳೊಂದಿಗೆ `light`
  ಬ್ಯಾಂಡ್ ಅನ್ನು ತಲುಪಲು ಸಾಧ್ಯವಿಲ್ಲ (`light` ಮತ್ತು `verbatim` ಸಮವಾಗಿವೆ).

#### ಕೋಡ್ ಉದಾಹರಣೆ

```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: ಲಘು ಸಂಕೋಚನ
  moderate: 20, // ಅಂತರ <= 20: caveman ಸಂಕೋಚನ
  fullSummary: 5, // ಪ್ರಕಾರಕ್ಕೆ ಅಗತ್ಯವಿದೆ, ಬ್ಯಾಂಡಿಂಗ್ ಕೋಡ್ ಇದನ್ನು ಓದುವುದಿಲ್ಲ
  // ಅಂತರ > 20: ಸಾರಾಂಶಗೊಳಿಸಲಾಗುತ್ತದೆ (ಸಹಾಯಕ) / ಮೊದಲ ಸಾಲನ್ನು ಉಳಿಸಲಾಗುತ್ತದೆ (ಬಳಕೆದಾರ)
});

// saved = ಉಳಿಸಲಾದ ಟೋಕನ್ಗಳ ಸಂಖ್ಯೆ
```

#### ಯಾವಾಗ ಬಳಸಬೇಕು

ಪ್ರಗತಿಶೀಲ ಏಜಿಂಗ್ `aggressive` ಮೋಡ್ಗಾಗಿ **ಯಾವಾಗಲೂ ಸಕ್ರಿಯವಾಗಿರುತ್ತದೆ** — ಇದು
`compressAggressive()` ನ 2ನೇ ಹಂತವಾಗಿದೆ. Ultra ಮೋಡ್ ಇದನ್ನು ಚಲಾಯಿಸುವುದಿಲ್ಲ. ಇದು
ವಿಶೇಷವಾಗಿ ಈ ಸಂದರ್ಭಗಳಲ್ಲಿ ಪರಿಣಾಮಕಾರಿಯಾಗಿದೆ:

- ದೀರ್ಘಕಾಲ ನಡೆಯುವ ಕೋಡಿಂಗ್ ಸೆಷನ್ಗಳು
- ಹಲವು ದಿನಗಳ ಸಂಭಾಷಣೆಗಳು
- ಅನೇಕ ಟೂಲ್ ಕರೆಗಳನ್ನು ಹೊಂದಿರುವ ಏಜೆಂಟಿಕ್ ಕಾರ್ಯಪ್ರವಾಹಗಳು

### Caveman ಔಟ್ಪುಟ್ ಮೋಡ್

Caveman ಔಟ್ಪುಟ್ ಮೋಡ್ ಸಂಕ್ಷಿಪ್ತ ಔಟ್ಪುಟ್ ನೀಡುವಂತೆ ಮಾದರಿಯನ್ನೇ ಕೇಳುವ **ಸಿಸ್ಟಮ್ ಪ್ರಾಂಪ್ಟ್ ಸೂಚನೆಗಳನ್ನು** ಸೇರಿಸುತ್ತದೆ —
`lite` ಹಂತವು ಪೂರ್ಣ ವಾಕ್ಯಗಳನ್ನು ಉಳಿಸಿಕೊಳ್ಳುವ ಸಂಕ್ಷಿಪ್ತ ಉತ್ತರಗಳನ್ನು ಕೇಳುತ್ತದೆ, `full`
ಅದನ್ನು "respond terse like smart caveman" ಎಂದು ಕೇಳುತ್ತದೆ ಮತ್ತು `ultra` ಟೆಲಿಗ್ರಾಫಿಕ್ ಔಟ್ಪುಟ್ ಅನ್ನು ಕೇಳುತ್ತದೆ;
ಸೂಚನೆಗಳು ಕೇವಲ ಕೇಳುತ್ತವೆ, ಅದನ್ನು ಖಾತರಿಪಡಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ವಿನಂತಿಗಳು ಅವುಗಳನ್ನು
`applyOutputStyles()` (`open-sse/services/compression/outputStyles/apply.ts`) ಮೂಲಕ ಸ್ವೀಕರಿಸುತ್ತವೆ:
`open-sse/handlers/chatCore.ts` ಮೊದಲು ಬ್ಯಾಕ್-ಕಾಂಪ್ಯಾಟ್ ಶಿಮ್ ಮೂಲಕ ಆಯ್ಕೆಯನ್ನು ಪರಿಹರಿಸುತ್ತದೆ
(`open-sse/services/compression/outputStyles/backCompat.ts` ನಲ್ಲಿನ `resolveOutputStyleSelection()`), ಇದು `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, ಗುರುತುಕಾರಕಗಳನ್ನು ಯಥಾವತ್ತಾಗಿ ಇರಿಸಿ."

ಇದು ವಿಶೇಷವಾಗಿ ಇವುಗಳಿಗೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ:

- ಕೋಡ್ ರಚನೆ (ಹೆಚ್ಚು ಸಂಕ್ಷಿಪ್ತ ಔಟ್ಪುಟ್ = ಕಡಿಮೆ ಟೋಕನ್ಗಳು)
- ತ್ವರಿತ ಪ್ರಶ್ನೋತ್ತರ (ವಿಸ್ತೃತ ವಿವರಣೆಗಳ ಅಗತ್ಯವಿಲ್ಲ)
- ಬ್ಯಾಚ್ ಪ್ರಕ್ರಿಯೆ (ಥ್ರೂಪುಟ್ ಅನ್ನು ಗರಿಷ್ಠಗೊಳಿಸಿ)

#### ಯಾವಾಗ ಬಳಸಬೇಕು

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 ನೋಡಿ).

### Output Styles (ಕ್ಯಾಟಲಾಗ್)

ಮೇಲಿನ Caveman ಔಟ್ಪುಟ್ ಮೋಡ್ **ಹಳೆಯ ಏಕ-ಶೈಲಿ ಮಾರ್ಗ**ವಾಗಿದೆ. ಹಂತ 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 (ಆಲಸಿ ಹಿರಿಯ ಡೆವಲಪರ್)    | `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](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, ಪ್ರಚಾರದ ಪದಗಳು, ಚಾಟ್ಬಾಟ್ ಮುಕ್ತಾಯಗಳು, ಕಲ್ಪಿತ ಸಂಗತಿಗಳಿಲ್ಲ) ಜೊತೆಗೆ ಜನಸ್ನೇಹಿ ನಿಯಮಗಳು: 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 ಯಾವುದೇ ಶೈಲಿ id ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಮತ್ತು ಪುಟದಲ್ಲಿ ಇತರ ಶೈಲಿಗಳನ್ನು ಉಳಿಸಿದಾಗ ಅದನ್ನು ಹಾಗೆಯೇ ಇರಿಸುತ್ತದೆ. ವಿನಂತಿಯ
ಸಮಯದಲ್ಲಿ, `applyOutputStyles()` ಭಾಷಾ ಪರಿಶೀಲನೆಯೇ ಏಕೈಕ ಲೊಕೇಲ್ ಗೇಟ್ ಆಗಿದೆ.

#### ಇಂಜೆಕ್ಷನ್ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ

`applyOutputStyles()` (`open-sse/services/compression/outputStyles/apply.ts`) ಆಯ್ಕೆಯನ್ನು
ಕ್ಯಾಟಲಾಗ್ನೊಂದಿಗೆ ಹೊಂದಿಸುತ್ತದೆ (ಅಪರಿಚಿತ idಗಳು ಮತ್ತು localeಗೆ ಹೊಂದಿಕೆಯಾಗದ ಶೈಲಿಗಳನ್ನು
ಕೈಬಿಡಲಾಗುತ್ತದೆ, ಎಂದಿಗೂ ದೋಷವಾಗುವುದಿಲ್ಲ; ಯಾವುದೇ ಶೈಲಿಗೆ ಹೊಂದಿಕೆಯಾಗದ ಆಯ್ಕೆಯು bodyಯನ್ನು
ಬದಲಾಯಿಸದೆ ಬಿಡುತ್ತದೆ, `no_styles` ಎಂದು ಬಿಟ್ಟುಬಿಡಲಾಗುತ್ತದೆ), ಆಯ್ಕೆಮಾಡಿದ ಸೂಚನೆಗಳನ್ನು ಕ್ಯಾಟಲಾಗ್
ಕ್ರಮದಲ್ಲಿ ಸಂಯೋಜಿಸುತ್ತದೆ,
boundaries ಷರತ್ತನ್ನು **ಒಮ್ಮೆ** ಸೇರಿಸುತ್ತದೆ (ಜೊತೆಗೆ, `less-code` ಅಥವಾ `ponytail`
ಆಯ್ಕೆಮಾಡಿದಾಗ safety ಷರತ್ತು, `SAFETY_BOUNDARIES` ಅಥವಾ ಅದರ ಅನುವಾದ), ಮತ್ತು ಬ್ಲಾಕ್ ಅನ್ನು
ಒಂದೇ idempotency ಗುರುತಿನಿಂದ (`[OmniRoute Output Styles]`) ಪ್ರಾರಂಭಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಅದನ್ನು
ಮರು-ಅನ್ವಯಿಸುವುದು ಯಾವುದೇ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ. ನಿರ್ಧರಿಸಲಾದ ಭಾಷೆಗೆ (ಕೆಳಗಿನ ಭಾಷೆ ಆಯ್ಕೆ
ನೋಡಿ) ಅನುವಾದವಿದ್ದಾಗ, ಇಂಗ್ಲಿಷ್ ಬದಲಿಗೆ ಸ್ಥಳೀಕೃತ ಸೂಚನೆಯನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ.

ಖಾಲಿಯಲ್ಲದ `messages` array ಹೊಂದಿರುವ bodyಯಲ್ಲಿ, content bypassಗಿಂತ ಮೊದಲು idempotency
ಪರಿಶೀಲನೆ ನಡೆಯುತ್ತದೆ: `[OmniRoute Output Styles]` ಗುರುತು ಈಗಾಗಲೇ ಮೇಲ್ಮಟ್ಟದ
`system` fieldನಲ್ಲಿ (string ಅಥವಾ content-block array) ಅಥವಾ string content ಹೊಂದಿರುವ
system messageನಲ್ಲಿ ಇದ್ದರೆ, bodyಯನ್ನು `already_applied` ಎಂದು ಬದಲಾಯಿಸದೆ ಬಿಡಲಾಗುತ್ತದೆ
ಮತ್ತು ಯಾವುದೇ keyword ಪರಿಶೀಲನೆ ನಡೆಯುವುದಿಲ್ಲ. ಇಲ್ಲದಿದ್ದರೆ content bypass
(`open-sse/services/compression/outputMode.ts`ನಲ್ಲಿರುವ `shouldBypassCavemanOutputMode()`)
ಕೊನೆಯ ಮೂರು messagesಗಳ text ಅನ್ನು, ಅವುಗಳ role ಏನೇ ಇದ್ದರೂ, ಪರಿಶೀಲಿಸುತ್ತದೆ ಮತ್ತು ಆ text
ಅದರ security, irreversible-action ಅಥವಾ clarification keywordsಗೆ ಹೊಂದಿಕೆಯಾದಾಗ, ಅಥವಾ
ಕ್ರಮ-ಸೂಕ್ಷ್ಮ ಅನುಕ್ರಮಕ್ಕೆ ಹೊಂದಿಕೆಯಾದಾಗ, ಸಂಪೂರ್ಣ turnಗಾಗಿ styles ಅನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ:
`first`, `then`, `after that`, `before`, `rollback` ಅಥವಾ `backup`, ಮತ್ತು ಅದರ ನಂತರ
240 characters ಒಳಗೆ `delete`, `drop`, `migrate`, `deploy` ಅಥವಾ `release`.
**Auto-Clarity Bypass** toggle (`cavemanOutputMode.autoClarity`, ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ on)
on ಆಗಿರುವಾಗ bypass ಚಲಿಸುತ್ತದೆ; toggle ಅನ್ನು off ಮಾಡಿದರೆ keyword ಪರಿಶೀಲನೆಯನ್ನು
ಬಿಟ್ಟುಬಿಡಲಾಗುತ್ತದೆ.

bypass turn ಅನ್ನು ಮುಂದುವರಿಯಲು ಅನುಮತಿಸಿದಾಗ, ಎಂದಿಗೂ ಹೊಸ `messages[0]` ಅನ್ನು ರಚಿಸದ
`placeSystemInstruction()` (ಅದೇ file), ತಾನು ಕಂಡುಕೊಳ್ಳುವ ಕೆಳಗಿನ ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ block
ಅನ್ನು ಇರಿಸುತ್ತದೆ:

1. string content ಹೊಂದಿರುವ ಆರಂಭಿಕ system message: ಅದರ text ನಂತರ block ಅನ್ನು
   ಸೇರಿಸಲಾಗುತ್ತದೆ.
2. ಮೇಲ್ಮಟ್ಟದ `system` field: stringನ text ನಂತರ block ಅನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ, ಅಥವಾ
   content-block arrayಗೆ ಹೊಸ text block ಆಗಿ ಸೇರಿಸಲಾಗುತ್ತದೆ.
3. ನಂತರ ಬರುವ, string content ಹೊಂದಿರುವ ಮೊದಲ system message: ಅದರ text ನಂತರ block ಅನ್ನು
   ಸೇರಿಸಲಾಗುತ್ತದೆ.
4. ಮೇಲಿನ ಯಾವುದೂ ಇಲ್ಲದಿದ್ದರೆ: `messages`ನ ಕೊನೆಯಲ್ಲಿ ಹೊಸ system message ಒಳಗೆ block
   ಹೋಗುತ್ತದೆ.

`messages` array ಇಲ್ಲದ bodyಯಲ್ಲಿ (ಅಥವಾ ಖಾಲಿ array ಹೊಂದಿರುವ bodyಯಲ್ಲಿ), ಯಾವುದೇ content
bypass ನಡೆಯುವುದಿಲ್ಲ ಮತ್ತು ಮೇಲ್ಮಟ್ಟದ `system` field ಅನ್ನು ಪರಿಗಣಿಸಲಾಗುವುದಿಲ್ಲ. string
`instructions` fieldನ text ನಂತರ block ಅನ್ನು ಸೇರಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ಆ field ಈಗಾಗಲೇ
`[OmniRoute Output Styles]` ಗುರುತನ್ನು ಹೊಂದಿದ್ದರೆ bodyಯನ್ನು `already_applied` ಎಂದು
ಬದಲಾಯಿಸದೆ ಬಿಡಲಾಗುತ್ತದೆ. bodyಯಲ್ಲಿ string `instructions` field ಇಲ್ಲದಿದ್ದರೂ `input`
(string ಅಥವಾ array) ಇದ್ದರೆ, ಆ fieldನಲ್ಲಿ ಇದ್ದ ಯಾವುದೇ non-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ನಲ್ಲಿ
ಇದೆ. ಪ್ರೋಗ್ರಾಮ್ ಮೂಲಕ, compression config ಆಯ್ಕೆಯನ್ನು ಹೀಗೆ ಉಳಿಸುತ್ತದೆ:

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

ಹಿಂದಿನ ಆವೃತ್ತಿಗಳೊಂದಿಗಿನ ಹೊಂದಾಣಿಕೆ: `outputStyles` ಖಾಲಿಯಾಗಿರುವವರೆಗೆ, ಹಳೆಯ
`cavemanOutputMode.enabled` setting ಅನ್ನು `cavemanOutputMode.intensity`ನಲ್ಲಿರುವ
`terse-prose`ಗೆ ಹೊಂದಿಸಲಾಗುತ್ತದೆ. ಆಗ block `[OmniRoute Output Styles]` ಗುರುತಿನಿಂದ
ಪ್ರಾರಂಭವಾಗುತ್ತದೆ; ಹಳೆಯ `applyCavemanOutputMode()` injector
`[OmniRoute Caveman Output Mode]` ಅನ್ನು ಸೇರಿಸುತ್ತಿತ್ತು. ಗುರುತಿನ ಕೆಳಗೆ, text en, pt-BR,
es, de, fr, it, ru, id ಮತ್ತು vi ಭಾಷೆಗಳಲ್ಲಿ ಹಳೆಯ injectionಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ; ja ಮತ್ತು
zhನಲ್ಲಿ boundaries ಷರತ್ತಿನ ಮೊದಲು ಒಂದು ಹೆಚ್ಚುವರಿ 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`) ಮಾದರಿಯಾಗಿ ತೆಗೆದುಕೊಂಡು ಅದರ ಮೇಲೆ Caveman
engineನ detector (`detectCompressionLanguage()`) ಅನ್ನು ಚಲಾಯಿಸುತ್ತದೆ. Han characters
ಇದ್ದು kana ಇಲ್ಲದ textಗೆ detector `zh` ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ; ಇಲ್ಲದಿದ್ದರೆ `it`,
`pt-BR`, `es`, `de`, `fr`, `ru`, `ja`, `hu` ಮತ್ತು `id`ಗಳಲ್ಲಿ ಅತಿ ಹೆಚ್ಚು hint
matches ಹೊಂದಿರುವುದನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಮತ್ತು ಯಾವುದೂ ಹೊಂದಿಕೆಯಾಗದಿದ್ದಾಗ `en` ಅನ್ನು
ಹಿಂದಿರುಗಿಸುತ್ತದೆ — ವರ್ಗೀಕರಿಸಲಾಗದ textಗೆ English ದೊರೆಯುತ್ತದೆ, ಎಂದಿಗೂ
`defaultLanguage` ಅಲ್ಲ, ಮತ್ತು styles `vi` text ಅನ್ನು ಒಳಗೊಂಡಿದ್ದರೂ `vi` ಅನ್ನು ಎಂದಿಗೂ
ಪತ್ತೆಹಚ್ಚಲಾಗುವುದಿಲ್ಲ. Responses API body ತನ್ನ turns ಅನ್ನು `input`ನಲ್ಲಿ ಇರಿಸುತ್ತದೆ;
ಅದನ್ನು ಮಾದರಿಯಾಗಿ ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಅದಕ್ಕೆ ಮೊದಲು `defaultLanguage`, ನಂತರ
English ದೊರೆಯುತ್ತದೆ. `messages`ನಲ್ಲಿ text ಹೊಂದಿರುವ user message ಇಲ್ಲದಿದ್ದಾಗ, ಅಥವಾ
`autoDetect` off ಆಗಿರುವಾಗ, `defaultLanguage` ಅನ್ವಯಿಸುತ್ತದೆ, ನಂತರ English.
`languageConfig.enabled` off ಆಗಿರುವಾಗ, ಭಾಷೆ English ಆಗಿರುತ್ತದೆ — requestಗೆ
compression combo ಅನ್ವಯಿಸದ ಹೊರತು (requestನ routing comboಗೆ ನಿಯೋಜಿಸಲಾದ combo, ಅಥವಾ
ಅಂತರ್ನಿರ್ಮಿತ stacked pipelineಗಾಗಿ chatCore fallback ಆಗಿ ಬಳಸುವ default compression
combo): combo ಅನ್ವಯಿಸುವುದರಿಂದ ಆ requestಗಾಗಿ `languageConfig.enabled` on ಆಗುತ್ತದೆ ಮತ್ತು
comboದ language packsನಿಂದ `defaultLanguage` ಅನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತದೆ (ಉಳಿಸಿದ value
comboದ packsಗಳಲ್ಲಿ ಒಂದಾಗಿದ್ದರೆ ಅದನ್ನೇ, ಇಲ್ಲದಿದ್ದರೆ comboದ ಮೊದಲ pack ಅನ್ನು; ಇದು
ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ `en` ಆಗಿರುತ್ತದೆ), ಹಾಗೆಯೇ ಉಳಿಸಿದ `autoDetect` (ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ on)
ಇನ್ನೂ ಅನ್ವಯಿಸುತ್ತದೆ. Caveman input engine ತನ್ನ rule-pack ಭಾಷೆಯನ್ನು ವಿಭಿನ್ನವಾಗಿ
ಆಯ್ಕೆಮಾಡುತ್ತದೆ — ಪ್ರತಿ text partಗೆ ಪ್ರತ್ಯೇಕವಾಗಿ ಮತ್ತು auto-detect off ಆಗಿರುವಾಗ,
`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](./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 ಅರೇ — ಆಕ್ರಮಣಕಾರಿ ಎಂಜಿನ್ ಮೂಲ ಟೂಲ್ ಫಲಿತಾಂಶವನ್ನೇ ಉಳಿಸಿಕೊಳ್ಳುತ್ತದೆ: `saved` 0 ಅಥವಾ ಅದಕ್ಕಿಂತ ಕಡಿಮೆಯಾಗಿದ್ದಾಗ ಎರಡೂ ಕಾಲರ್ಗಳು (`compressAggressive()` ಮತ್ತು `compressAnthropicToolResultBlock()`)
ಮೂಲವನ್ನೇ ಉಳಿಸಿಕೊಳ್ಳುತ್ತವೆ, ಆದರೆ `compressToolResult()` ಸ್ವತಃ ಇನ್ನೂ ಆ ಕಾರ್ಯತಂತ್ರದ ಔಟ್ಪುಟ್ ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ. ಟೂಲ್-ಫಲಿತಾಂಶದ ಹಂತವೇ ಅಂತಿಮ ನಿರ್ಧಾರವಲ್ಲ: ಎಂಜಿನ್ನ ಫಾಲ್ಬ್ಯಾಕ್ ಸಾರಾಂಶಕಾರವು 8,192 ಅಕ್ಷರಗಳಿಗಿಂತ ಉದ್ದದ `tool` ಅಥವಾ `function` ಸಂದೇಶವನ್ನು ಇನ್ನೂ ಚಿಕ್ಕದಾಗಿಸಬಹುದು (`maxTokensPerMessage`, 2,048, ಗುಣಿಸು 4).

#### ಯಾವಾಗ ಬಳಸಬೇಕು

ಟೂಲ್ ಫಲಿತಾಂಶ ಸಂಕುಚನವು ಆಕ್ರಮಣಕಾರಿ ಎಂಜಿನ್ನ ಹಂತ 1 ಆಗಿದೆ (`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 ನೋಡಿ) — auto-combo `modePack` ಮೂಲಕ ಅಲ್ಲ (ಆ ಫೀಲ್ಡ್ auto-combo ಮಾಡೆಲ್ ಆಯ್ಕೆಗೆ ಮಾತ್ರ ಮರು-ತೂಕ ನೀಡುತ್ತದೆ ಮತ್ತು `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, APIಗಳು, MCP, ಡ್ಯಾಶ್ಬೋರ್ಡ್
- [ಕಂಪ್ರೆಷನ್ ನಿಯಮಗಳ ಫಾರ್ಮ್ಯಾಟ್](./COMPRESSION_RULES_FORMAT.md) — JSON ರೂಲ್-ಪ್ಯಾಕ್ ಫಾರ್ಮ್ಯಾಟ್
- [ಕಂಪ್ರೆಷನ್ ಭಾಷಾ ಪ್ಯಾಕ್ಗಳು](./COMPRESSION_LANGUAGE_PACKS.md) — ಭಾಷೆ-ನಿರ್ದಿಷ್ಟ Caveman ನಿಯಮಗಳು