Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
RTK Compression (Svenska)
🌐 Languages: 🇺🇸 English · 🇪🇹 am · 🇸🇦 ar · 🇦🇿 az · 🇧🇬 bg · 🇧🇩 bn · 🇧🇦 bs · 🇨🇿 cs · 🇩🇰 da · 🇩🇪 de · 🇬🇷 el · 🇪🇸 es · 🇪🇪 et · 🇮🇷 fa · 🇫🇮 fi · 🇫🇷 fr · 🇮🇪 ga · 🇮🇳 gu · 🇳🇬 ha · 🇮🇱 he · 🇮🇳 hi · 🇭🇷 hr · 🇭🇺 hu · 🇦🇲 hy · 🇮🇩 id · 🇳🇬 ig · 🇮🇹 it · 🇯🇵 ja · 🇬🇪 ka · 🇰🇭 km · 🇮🇳 kn · 🇰🇷 ko · 🇱🇹 lt · 🇱🇻 lv · 🇮🇳 ml · 🇮🇳 mr · 🇲🇾 ms · 🇲🇹 mt · 🇲🇲 my · 🇳🇵 ne · 🇳🇱 nl · 🇳🇴 no · 🇮🇳 or · 🇮🇳 pa · 🇵🇭 phi · 🇵🇱 pl · 🇵🇹 pt · 🇧🇷 pt-BR · 🇷🇴 ro · 🇷🇺 ru · 🇱🇰 si · 🇸🇰 sk · 🇸🇮 sl · 🇷🇸 sr · 🇰🇪 sw · 🇮🇳 ta · 🇮🇳 te · 🇹🇭 th · 🇹🇷 tr · 🇺🇦 uk-UA · 🇵🇰 ur · 🇺🇿 uz · 🇻🇳 vi · 🇳🇬 yo · 🇨🇳 zh-CN · 🇹🇼 zh-TW
RTK-komprimering är OmniRoutes kommandomedvetna komprimeringsmotor för terminal- och verktygsutdata. Den är utformad för sessioner med kodningsagenter där den största delen av kontexttillväxten kommer från testloggar, byggutdata, brus från pakethanterare, skalsessioner, Docker-utdata, git-utdata och stackspårningar.
RTK kan köras direkt med defaultMode: "rtk" eller som det första steget i en staplad pipeline, vanligtvis:
rtk -> caveman
Den ordningen komprimerar först brusig maskinutdata och låter sedan Caveman kondensera återstående prosa.
RTK:s uppströmsprojekt rapporterar besparingar på 60-90% för kommandoutdata. Exempelsessionen i dess README går från
~118,000 standardtoken till ~23,900 RTK-token, vilket innebär en besparing på 79.7% (~80%). OmniRoute använder
det uppströmsgenomsnittet för beräkningen av staplade besparingar med Caveman-indatakomprimering:
RTK-genomsnitt: 80% besparing
Caveman-indata: 46% besparing
Staplat: 1 - (1 - 0.80) * (1 - 0.46) = 89.2% besparing
Intervall: 1 - (1 - 0.60..0.90) * (1 - 0.46) = 78.4-94.6%
Vad som komprimeras
Den inbyggda katalogen innehåller för närvarande 49 filter inom dessa kategorier:
| Kategori | Exempel |
|---|---|
git |
git status, git branch, git diff, git log |
test |
Vitest, Jest, Pytest, Playwright, Go-tester, Cargo-tester |
build |
TypeScript, ESLint, Biome, Prettier, Vite, Webpack, Turbo, Nx |
package |
npm install, npm audit, pip, uv sync, Poetry, Bundler |
shell |
ls, find, grep, generiska skalloggar |
docker |
docker ps, Docker-loggar |
infra |
Terraform, OpenTofu, systemctl status |
generic |
JSON-utdata, stackspårningar, generell reservlösning för utdata |
Detektorn i open-sse/services/compression/engines/rtk/commandDetector.ts klassificerar utdata
innan filter väljs. Filter kan också matcha efter kommandomönster eller reguljära uttryck för utdata när en
kommandoklass inte är tillräcklig.
Filtermatchning
RTK läser in filter i följande ordning:
- Projektfilter från
.rtk/filters.tomloch.rtk/filters.json, endast när de är betrodda. - Globala filter från
DATA_DIR/rtk/filters.tomlochDATA_DIR/rtk/filters.json. - Inbyggda filter från
open-sse/services/compression/engines/rtk/filters/.
Inom samma omfång har RTK TOML schema v1-filter företräde framför OmniRoute JSON-filter. TOML-
match_command-uttryck kontrolleras före matchning av kommandotyp, så att ett importerat kommandospecifikt
filter kan åsidosätta ett bredare filter inom det omfånget. Projektomfånget har fortfarande företräde framför det globala
omfånget, oavsett filformat.
Projektfilter kräver avsiktligt förtroende eftersom regexfilter kan ändra hur verktygsutdata visas för agenter. En projektfilterfil godtas när något av följande gäller:
rtkConfig.trustProjectFiltersärtrue.OMNIROUTE_RTK_TRUST_PROJECT_FILTERS=1är inställd..rtk/trust.jsoninnehåller den matchande SHA-256-hashen för projektfilterfilen.
Exempel på förtroendefil:
{
"filtersSha256": "0123456789abcdef...",
"filtersTomlSha256": "fedcba9876543210..."
}
Hasharna är separata: filtersSha256 betror .rtk/filters.json, medan filtersTomlSha256
betror .rtk/filters.toml. Om någon av filerna redigeras ogiltigförklaras endast dess egen förtroendepost. Globala filer
installeras av administratörer och använder det befintliga förtroendebeteendet för globala filter.
Anpassade filter kan vara ett filterobjekt eller en array med filterobjekt. Ogiltiga anpassade filter
hoppas över och rapporteras av diagnostiken i /api/context/rtk/filters. Ogiltiga inbyggda filter orsakar omedelbart fel.
Kompatibilitet med RTK TOML-schema v1
OmniRoute kan tolka, validera, testa och installera deklarativa filterfiler som använder RTK TOML-schema v1.
De fält som stöds är description, match_command, strip_ansi, filter_stderr,
strip_lines_matching, keep_lines_matching, replace, match_output, truncate_lines_at,
head_lines, tail_lines, max_lines, on_empty och integrerade tester med [[tests.<filter>]].
Okända fält, ogiltiga eller osäkra reguljära uttryck, samtidiga regler för borttagning och bevarande, filer över
1 MiB samt referenser till okända filter avvisas. En fil vars integrerade tester misslyckas kan
valideras för inspektion men kan inte installeras eller läsas in. Fel vid inläsning av anpassade filer
fortsätter att vara fail-open: den ogiltiga filen hoppas över och de återstående filtren fortsätter att fungera.
OmniRoute tar emot verktygsutdata efter att klienten redan har samlat in dem, så filter_stderr = true
kan inte påverka processens insamling. Fältet accepteras utan någon effekt och valideringen returnerar en varning.
Detta beskrivs avsiktligt som kompatibilitet med RTK TOML-schema v1, inte fullständig kompatibilitet
med den körbara RTK-filen, shell-hookar, Rust-kommandoimplementationer eller dess trust store-layout.
Instrumentpanelens avancerade RTK-vy accepterar inklistrad eller uppladdad TOML. Valideringen är skrivskyddad.
Installationen skriver atomärt till DATA_DIR/rtk/filters.toml med restriktiva behörigheter och uppdaterar
den aktiva filterkatalogen utan omstart. För att ersätta en befintlig fil krävs en uttrycklig bekräftelse med overwrite,
och DATA_DIR/rtk/filters.toml.bak skapas först.
Filter-DSL
Filter använder JSON-schemat som beskrivs i Format för komprimeringsregler. Vid körning tillämpas dessa steg i följande ordning:
stripAnsi -> filterStderr -> replace -> matchOutput -> drop/include lines
-> truncateLineAt -> head/tail/maxLines -> onEmpty
Viktiga fält:
| Fält | Syfte |
|---|---|
rules.stripAnsi |
Ta bort terminalens färg-/kontrollsekvenser före matchning |
rules.filterStderr |
Normalisera vanliga stderr-prefix före matchning/filtrering |
rules.replace |
Tillämpa ordnade ersättningar med reguljära uttryck |
rules.matchOutput |
Returnera en kompakt sammanfattning när utdata matchar ett känt villkor |
rules.matchOutput[].unless |
Hoppa över genvägen när ett fel-/misslyckandemönster förekommer |
rules.dropPatterns |
Ta bort brusiga rader |
rules.includePatterns |
Prioritera åtgärdsbara rader |
rules.collapsePatterns |
Slå samman upprepade matchande rader |
rules.deduplicate |
Valfritt per filter: slå samman på varandra följande dubblettrader |
rules.truncateLineAt |
Unicode-säker trunkering per rad |
rules.onEmpty |
Reservmeddelande om alla rader filtreras bort |
tests[] |
Integrerade exempel som används av verifieringsspärren |
Inbyggda filter förväntas innehålla integrerade tests[]-exempel. Anpassade filter bör också innehålla
dem, särskilt när de delas mellan projekt.
Raddubblettborttagning (två lager)
RTK slår samman dubblettrader i två oberoende lager:
deduplicateper filter (valfritt, standardvärdefalse). Ett filter kan angerules.deduplicate: trueför att slå samman identiska efterföljande rader i filtrets matchade utdata, före trunkering. Detta körs ilineFilter.ts. För äldre filter aktiveras det automatiskt när filtret definierarcollapsePatterns. Schema:deduplicate: z.boolean().default(false)iopen-sse/services/compression/engines/rtk/filterSchema.ts.- Motoromfattande
deduplicateThreshold(standardvärde3). När alla filter har körts slår motorn samman alla sekvenser med>= deduplicateThresholdidentiska efterföljande rader i hela resultatet (deduplicateRepeatedLines, tillämpas iengines/rtk/index.ts). Värdet begränsas till 2–100 vid normalisering.
Passet per filter körs först (inuti filtret), och det motoromfattande passet körs sist (på den sammanfogade utdatan), så de kan kombineras utan dubbelräkning.
Radgruppering (enableGrouping)
När rtkConfig.enableGrouping är true (standardvärde false) kör RTK ytterligare ett groupSimilarLines-pass
på resultatet efter dubblettborttagningen, vilket slår samman sekvenser av nästan likvärdiga (inte byte-identiska)
efterföljande rader. rtkConfig.groupingThreshold (standardvärde 3) är den minsta sekvenslängd som utlöser
gruppering. Detta är den strukturella motsvarigheten till deduplicateThreshold: dubblettborttagning hanterar exakta upprepningar,
medan gruppering hanterar ”samma form med små skillnader”. Båda flaggorna ingår i rtkConfig-JSON-data
som lagras beständigt i tabellen key_value (se Konfiguration ovan), så inställningen finns kvar efter omstarter.
Borttagning av kodkommentarer (stripCodeComments / preserveDocstrings)
När rtkConfig.applyToCodeBlocks är aktiverat kan RTK även ta bort kommentarer från inhägnade kodblock:
stripCodeComments(standardvärdefalse) — valfritt. När värdet ärtruetar RTK bort kommentarer från inhägnade JavaScript- och TypeScript-block. Historiskt lästes flaggan men tillämpades aldrig, så standardvärdet förblir ”bevara” för att undvika en tyst ändring i produktionsmiljön.preserveDocstrings(standardvärdetrue) — när kommentarer tas bort bevaras JSDoc-//** … */-blockkommentarer (de innehåller API-dokumentation som är värd mer än de byte de kostar). Angefalseför att även ta bort dessa.
Kommentarborttagningen är implementerad i open-sse/services/compression/engines/rtk/codeStripper.ts. Den använder
TypeScript-parsern (inte ett reguljärt uttryck), så att sträng-, mall- och regexliteraler aldrig felaktigt tolkas
som kommentarer, och den avbryter helt när JSX identifieras (så kommentarer i JSX-uttrycksbehållare
aldrig skadas). Kommentarborttagning tillämpas för närvarande endast på JavaScript och TypeScript — andra
språk i stripparens CodeLanguage-uppsättning (Python, Rust, Go, Ruby, Java) får tomma rader och
blanksteg komprimerade, men kommentarer tas inte bort. Körningen för det bearbetade blocket märks med rtk:code-strip i
rulesApplied.
Obs! — GCF/tabellkodning är en separat motor. RTK innehåller inte den tabell-/kolumnbaserade JSON-kodaren ”GCF” (Graph Compact Format). Den kodaren — som ersatte en äldre
omni-tabular-kodare — finns i headroom-motorn (open-sse/services/compression/engines/headroom/, med den medföljande kodeken underheadroom/gcf/). Den är inte relaterad till RTK-filterpipelinen som dokumenteras här.
Konfiguration
Globala inställningar är tillgängliga via /api/settings/compression. RTK-specifika inställningar är också
tillgängliga via /api/context/rtk/config.
{
"defaultMode": "stacked",
"autoTriggerMode": "stacked",
"autoTriggerTokens": 32000,
"stackedPipeline": [
{ "engine": "rtk", "intensity": "standard" },
{ "engine": "caveman", "intensity": "full" }
],
"rtkConfig": {
"enabled": true,
"intensity": "standard",
"applyToToolResults": true,
"applyToCodeBlocks": false,
"applyToAssistantMessages": false,
"enabledFilters": [],
"disabledFilters": [],
"maxLinesPerResult": 120,
"maxCharsPerResult": 12000,
"deduplicateThreshold": 3,
"customFiltersEnabled": true,
"trustProjectFilters": false,
"rawOutputRetention": "never",
"rawOutputMaxBytes": 1048576,
"enableGrouping": false,
"groupingThreshold": 3,
"stripCodeComments": false,
"preserveDocstrings": true
}
}
enabledFilters och disabledFilters använder filter-ID:n, till exempel test-vitest eller git-diff.
Den fullständiga strukturen för rtkConfig definieras av RtkConfig / DEFAULT_RTK_CONFIG i
open-sse/services/compression/types.ts. Hela objektet lagras beständigt som ett enda JSON-värde i
SQLite-tabellen key_value under namespace = "compression", key = "rtkConfig"
(src/lib/db/compression.ts) och normaliseras vid läsning av normalizeRtkConfig. Därför går varje fält nedan
— inklusive enableGrouping, groupingThreshold, stripCodeComments och preserveDocstrings —
en tur och retur genom samma lagring och finns kvar efter en omstart.
| Nyckel | Standardvärde | Syfte |
|---|---|---|
deduplicateThreshold |
3 |
För hela motorn: minsta antal identiska rader i följd som komprimeras (2–100) |
enableGrouping |
false |
Valfritt: komprimera sekvenser av nästan likvärdiga rader i följd |
groupingThreshold |
3 |
Minsta antal liknande rader i följd som utlöser gruppering |
stripCodeComments |
false |
Valfritt: ta bort kommentarer från inhägnade kodblock (kräver applyToCodeBlocks) |
preserveDocstrings |
true |
Behåll JSDoc-//** … */-block när kommentarer tas bort |
API
| Rutt | Metod | Syfte |
|---|---|---|
/api/context/rtk/config |
GET | Läs RTK-konfiguration |
/api/context/rtk/config |
PUT | Uppdatera RTK-konfiguration |
/api/context/rtk/filters |
GET | Lista filterkatalog och laddningsdiagnostik |
/api/context/rtk/import |
POST | Validera eller installera RTK TOML-schemafiler av version 1 |
/api/context/rtk/test |
POST | Förhandsgranska RTK-komprimering för en textnyttolast |
/api/context/rtk/raw-output/[id] |
GET | Läs bevarad, redigerad råutdata |
/api/compression/preview |
POST | Förhandsgranska valfritt komprimeringsläge |
RTK-testnyttolast:
{
"command": "npm test",
"text": "FAIL tests/example.test.ts\nAssertionError: expected true\nTest Files 1 failed",
"config": {
"intensity": "standard"
}
}
Nyttolast för förhandsgranskning av komprimering:
{
"mode": "stacked",
"messages": [
{
"role": "tool",
"content": "FAIL tests/example.test.ts\nAssertionError: expected true\nTest Files 1 failed"
}
],
"config": {
"rtkConfig": {
"rawOutputRetention": "failures"
}
}
}
Hanteringsrutter kräver hanteringsautentisering för kontrollpanelen eller motsvarande API-nyckelpolicy.
Nyttolast för RTK TOML-validering:
{
"action": "validate",
"content": "schema_version = 1\n\n[filters.my-tool]\nmatch_command = \"^my-tool\\\\b\"\nmax_lines = 20\n"
}
Använd "action": "install" för att installera den validerade filen globalt. Lägg endast till "overwrite": true
efter att ha granskat och bekräftat ersättningen av en befintlig global fil.
Återställning av råutdata
RTK returnerar normalt endast komprimerad text. För felsökning kan rawOutputRetention behålla redigerad
råutdata:
| Värde | Beteende |
|---|---|
never |
Behåll inte råutdata |
failures |
Behåll endast utdata som sannolikt indikerar ett fel |
always |
Behåll all komprimerad råutdata från RTK, efter redigering |
Bevarade filer skrivs under:
DATA_DIR/rtk/raw-output/
Hemligheter redigeras innan beständig lagring, inklusive vanliga bearer-token, API-nycklar, Slack-token,
AWS-åtkomstnycklar och värden i tilldelningsformatet token=..., secret=..., password=.... Analysdata
lagrar endast pekar-id, storlek och hashmetadata.
Verifieringsgrind
Den fokuserade verifieringsgrinden kör inbyggda tester av inline-filter utan att anropa externa kommandon via skalet:
node --import tsx/esm --test tests/unit/compression/rtk-verify.test.ts
Den bredare RTK-grinden är:
node --import tsx/esm --test \
tests/unit/compression/rtk-*.test.ts \
tests/unit/compression/pipeline-integration.test.ts \
tests/unit/compression/context-compression-api.test.ts
Kör den breda komprimeringsgrinden före en release:
node --import tsx/esm --test \
tests/unit/compression/*.test.ts \
tests/golden-set/*.test.ts \
tests/integration/compression-pipeline.test.ts \
tests/unit/api/compression/compression-api.test.ts
Utöka RTK
- Lägg till eller uppdatera en JSON-fil för filter.
- Inkludera minst ett exempel i
tests[]som bevisar det viktiga beteendet. - Lägg till en fixtur under
tests/unit/compression/fixtures/rtk/för nya kommandofamiljer. - Lägg till täckning för kommandodetektering när du introducerar en ny utdataklass.
- Kör verifieringsgrinden och den breda RTK-grinden.
- Om filtret är projektspecifikt ska
.rtk/filters.jsoncheckas in och.rtk/trust.jsonuppdateras först efter granskning.
Intensitetsnivåer (v3.8.16+)
RTK stöder 3 intensitetsnivåer som balanserar komprimeringsaggressivitet mot säkerhet. Nivån anges via config.intensity i motorkonfigurationen.
De 3 nivåerna
| Nivå | Tröskel för trunkering | Tokenbesparing | Risk | Bäst för |
|---|---|---|---|---|
minimal |
24 rader per avsnitt | ~20-40% | Mycket låg | Produktion med kritisk kontext |
standard (standardvärde) |
24 rader per avsnitt | ~50-70% | Låg | Dagliga kodningssessioner |
aggressive |
16 rader per avsnitt | ~70-90% | Medelhög | Långa sessioner, maximala besparingar |
Var trunkeringen sker
Trunkeringströskeln påverkar lineFilter.ts:
// Från open-sse/services/compression/engines/rtk/index.ts:329-330
config.intensity === "aggressive" ? 16 : 24,
config.intensity === "aggressive" ? 16 : 24,
Både början och slutet av varje avsnitt bevaras; innehåll i mitten tas bort när trunkeringen aktiveras.
Vad som bevaras respektive tas bort
| Innehåll | minimal | standard | aggressive |
|---|---|---|---|
| Fel/stackspårningar | ✅ bevaras | ✅ bevaras | ✅ bevaras |
| Testfel | ✅ bevaras | ✅ bevaras | ✅ bevaras |
| Byggfel | ✅ bevaras | ✅ bevaras | ✅ bevaras |
| Godkända tester (utförliga) | ✅ bevaras | 🟡 komprimeras | 🟡 komprimeras |
| Rutinutdata (informationsloggar) | 🟡 komprimeras | 🟡 komprimeras | ❌ tas bort |
| Förloppsindikatorer | 🟡 komprimeras | ❌ tas bort | ❌ tas bort |
| Banderoll/ASCII-konst | 🟡 komprimeras | ❌ tas bort | ❌ tas bort |
Välja rätt intensitet
Är förlust av kontext katastrofal?
│
┌───────────┼───────────┐
│ │ │
JA NEJ OSÄKER
│ │ │
▼ │ │
minimal │ │
│ │ │
│ ▼ ▼
│ Hur kritisk är Prova `standard` först
│ genomströmningen? (fungerar i 80 % av
│ │ fallen)
│ ┌────┴────┐
│ │ │
│ LÅG HÖG
│ │ │
│ ▼ ▼
│ standard aggressive
│ │ │
└──────┴─────────┘
Konfigurera intensitet
Per kombination (i kombinationskonfigurationen):
{
"combo": "my-coding-combo",
"routing": {/* ... */},
"compression": {
"engine": "rtk",
"intensity": "aggressive"
}
}
Programmatiskt:
rtkEngine (@omniroute/open-sse/services/compression/engines/rtk) är en
CompressionEngine och har ingen updateConfig-metod. Uppdatera en motors konfiguration
via registerhjälpfunktionen i stället:
import { updateEngineConfig } from "@omniroute/open-sse/services/compression/engines/registry";
updateEngineConfig("rtk", { intensity: "aggressive" });
Verifiera effekten
Använd verifieringsgrinden (se nedan) för att bekräfta att filtret är säkert vid den valda intensiteten:
import { runRtkFilterTests } from "omniroute/compression/engines/rtk/verify";
const result = runRtkFilterTests({ intensity: "aggressive" });
if (!result.passed) {
console.error("Filtren misslyckades vid aggressiv intensitet");
}
Utveckling av anpassade filter (v3.8.16+)
Katalogen engines/rtk/filters/ innehåller över 49 inbyggda JSON-filterfiler. Du kan lägga till egna för att komprimera utdata från anpassade verktyg som inte omfattas av standardfiltren.
Filterschema (Zod)
{
"id": "string", // Obligatoriskt. Filteridentifierare (kebab-case, t.ex. "python-traceback")
"label": "string", // Obligatoriskt. Läsbart filternamn
"description": "string", // Valfritt (standard: ""). Kort beskrivning av vad filtret gör
"category": "git|test|build|shell|docker|package|infra|cloud|generic",
"priority": number, // Valfritt (0–100, standard: 50). Körningsordning (högre = först)
"match": {
"commands": ["string"], // Kommandonamn som ska matchas (t.ex. "python", "pytest")
"patterns": ["string"], // Reguljära uttryck som ska matcha utdata
"outputTypes": ["string"] // Identifierade utdataklasser (t.ex. "test-failure")
},
"rules": {
"stripAnsi": boolean, // Valfritt (standard: false). Ta bort ANSI-färgkoder
"replace": [ // Regler för sök och ersätt (standard: [])
{ "pattern": "regex", "replacement": "..." }
],
"matchOutput": [ // Avsluta direkt vid mönstermatchning (standard: [])
{
"pattern": "regex",
"message": "short summary",
"unless": "regex" // Hoppa över om detta mönster matchar
}
],
"includePatterns": ["string"], // Rader som ska behållas (reguljära uttryck, standard: [])
"dropPatterns": ["string"], // Rader som ska tas bort (reguljära uttryck, standard: [])
"collapsePatterns": ["string"], // Rader som ska slås ihop till en enda förekomst (standard: [])
"deduplicate": boolean, // Valfritt (standard: false). Ta bort duplicerade rader
"truncateLineAt": number, // Valfritt (standard: 0). Korta av rader till maximalt antal tecken
"maxLines": number, // Valfritt (standard: 0). Absolut gräns för totalt antal rader
"headLines": number, // Valfritt (standard: 20). Behåll de första N raderna av matchande utdata
"tailLines": number, // Valfritt (standard: 20). Behåll de sista N raderna av matchande utdata
"onEmpty": "string", // Valfritt (standard: ""). Reservmeddelande om alla rader filtreras bort
"filterStderr": boolean // Valfritt (standard: false). Filtrera även stderr-utdata
},
"preserve": {
"errorPatterns": ["string"], // Mönster som alltid måste bevaras (standard: [])
"summaryPatterns": ["string"] // Mönster för den avslutande sammanfattningsraden (standard: [])
},
"tests": [ // Infogade tester för verifiering (standard: [])
{
"name": "string", // Obligatoriskt. Testnamn
"input": "sample output", // Obligatoriskt. Exempel på indatatext
"expected": "expected output", // Obligatoriskt. Förväntad komprimerad utdata
"command": "optional command" // Valfritt. Kommandokontext
}
]
}
Exempel: filter för Python-spårning
{
"id": "python-traceback",
"label": "Python Traceback Filter",
"description": "Compresses Python tracebacks to essential file/line locations and error type",
"category": "test",
"priority": 60,
"match": {
"commands": ["python", "python3", "pytest", "uv", "poetry"],
"patterns": ["Traceback \\(most recent call last\\)", "Error", "Exception"],
"outputTypes": ["error-traceback"]
},
"rules": {
"stripAnsi": true,
"includePatterns": [
"Traceback \\(most recent call last\\)",
"^\\s*File \".+\", line \\d+",
"^\\s*[A-Z][a-zA-Z]+Error:",
"^\\s*[A-Z][a-zA-Z]+Exception"
],
"dropPatterns": ["site-packages/", "^\\s+[a-z_]+\\([^)]*\\)$"],
"headLines": 5,
"tailLines": 3,
"maxLines": 25,
"filterStderr": true
},
"preserve": {
"errorPatterns": ["Error:", "Exception:", "Traceback"],
"summaryPatterns": ["^[A-Z][a-zA-Z]+(?:Error|Exception):"]
},
"tests": [
{
"name": "preserves-error-type-and-location",
"input": "Traceback (most recent call last):\n File \"app.py\", line 42, in main\n do_thing()\n File \"lib/utils.py\", line 17, in helper\n return 1 / 0\nZeroDivisionError: division by zero",
"expected": "Traceback (most recent call last):\n File \"app.py\", line 42, in main\n File \"lib/utils.py\", line 17, in helper\nZeroDivisionError: division by zero",
"command": "python app.py"
}
]
}
Läsa in anpassade filter
Placera filen på en identifierad plats:
~/.omniroute/rtk/filters/my-filter.json # Användarnivå
<project>/.rtk/filters/my-filter.json # Projektnivå
Filter läses in automatiskt vid start via loadRtkFilters() i open-sse/services/compression/engines/rtk/filterLoader.ts. Inläsaren hittar filter från:
- Inbyggd katalog:
open-sse/services/compression/engines/rtk/filters/ - Användarkatalog:
~/.omniroute/rtk/filters/ - Projektkatalog:
<project>/.rtk/filters/
Så här läser du in filter programmatiskt:
import { loadRtkFilters } from "@omniroute/open-sse/services/compression/engines/rtk/filterLoader";
// Alternativ: customFiltersEnabled (läs in användar-/projektfilter, aktiverat som standard),
// trustProjectFilters, refresh.
const filters = loadRtkFilters({ customFiltersEnabled: true });
Validering
Filter valideras mot Zod-schemat när de läses in. Ett filter med felaktig struktur kan inte läsas in och ett fel loggas:
RTK_FILTER_LOADER: filter "my-filter" failed validation:
- rules.replace.0.pattern: Invalid regex
- match.commands: must not be empty
För att validera alla installerade filter anropar du runRtkFilterTests(), som exporteras från open-sse/services/compression/engines/rtk/verify.ts.
Bästa praxis
- Inkludera alltid
tests[]— de bevisar att ditt filter fungerar och förhindrar regressioner - Använd
matchOutputför tidiga avbrott — om en enda rad berättar hela historien, ersätt hela blocket - Föredra
keepframförstrip— uttryckliga regler för ”bevara alltid” är säkrare än ”ta alltid bort” - Testa på alla 3 intensitetsnivåer —
minimalbör inte göra någonting, ochaggressivebör fortfarande bevara fel - Använd fältet
unless— skydda tidiga avbrott med ”utlös inte om X finns”
Återställning av råutdata och verifieringsspärr
När RTK komprimerar utdata aggressivt kan du återställa originaltexten för felsökning, granskning eller återuppspelning.
Så fungerar återställning av råutdata
Ursprungliga utdata (10K token)
│
▼
RTK-komprimering (med rawOutput.enabled=true)
│
├─▶ Komprimerade utdata (2K token) ──▶ till LLM
│
└─▶ Ursprungliga utdata (10K token) ──▶ lagras i DB
(länkade via request_id)
Aktivera lagring av råutdata
Per begäran (i kombinationskonfigurationen):
{
"compression": {
"engine": "rtk",
"intensity": "aggressive",
"rawOutput": {
"enabled": true,
"maxBytes": 1048576 // Gräns på 1 MB
}
}
}
Standardvärde: rawOutput.enabled: false (sparar lagringsutrymme).
Lagringskostnad
| Per begäran | Gräns på 1 MB | Gräns på 10 MB |
|---|---|---|
| Genomsnittlig komprimerad utdata | ~5KB | ~5KB |
| Lagrade råutdata | ~50-500KB | ~500KB-5MB |
| Vid 1 000 begäranden/dag | 50-500MB/dag | 500MB-5GB/dag |
Rekommendation: Aktivera endast råutdata för felsökningssessioner eller stickprovsbaserad granskning, inte permanent.
Återställa originalet
import { readRtkRawOutput } from "omniroute/compression/engines/rtk/rawOutput";
const raw = readRtkRawOutput(pointerId); // pointerId från komprimeringsstatistiken
if (raw) {
console.log("Original output:", raw);
}
pointerId returneras i CompressionStats.rtkRawOutputPointers[] efter komprimeringen.
Se open-sse/services/compression/engines/rtk/rawOutput.ts:102 för funktionssignaturen.
Verifieringsspärren
RTK-filterverifieringen (open-sse/services/compression/engines/rtk/verify.ts) validerar alla filter mot deras tests[] och säkerställer att beteendet är korrekt på alla tre intensitetsnivåerna.
Anropa runRtkFilterTests() för att köra verifieringen:
import { runRtkFilterTests } from "open-sse/services/compression/engines/rtk/verify";
const result = runRtkFilterTests();
console.log(`Passed: ${result.outcomes.filter((o) => o.passed).length}`);
console.log(`Failed: ${result.outcomes.filter((o) => !o.passed).length}`);
if (!result.passed) {
console.error("Filters failed verification");
result.outcomes
.filter((o) => !o.passed)
.forEach((o) => {
console.error(
` - ${o.filterId} / ${o.testName}: expected "${o.expected}", got "${o.actual}"`
);
});
}
Detta valideras:
- Varje filter läses in och godkänns vid schemavalideringen
- Varje post i
tests[]producerar förväntade utdata - Intensiteten
minimalär en no-op (bevarar originalet och tillämpar endast strukturella filter) - Intensiteten
aggressivebevarar fel, testfel och stackspårningar - Komprimerade utdata är aldrig större än ursprungliga indata
Källa:
open-sse/services/compression/engines/rtk/(63 filer, ~70KB)Innan en filterändring slås samman — säkerställ alltid att testerna godkänns
Efter uppgradering av RTK-motorn — schemat kan ha ändrats
Regelbundet i övervakningen — skyddar mot avvikelser i testfixturer
När en ny verktygs-/kommandofamilj läggs till — bevisar att det nya filtret fungerar
Se även
- COMPRESSION_GUIDE.md — Fullständig översikt över komprimeringspipelines
- COMPRESSION_ENGINES.md — Motorregister och inbyggda motorer
- EXTENDING_COMPRESSION.md — Anpassade motorer, språkpaket och staplade pipelines
- Källa:
open-sse/services/compression/engines/rtk/(63 filer, ~70 kB)