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
Extending the Compression Pipeline (Dansk)
🌐 Languages: 🇺🇸 English · 🇪🇹 am · 🇸🇦 ar · 🇦🇿 az · 🇧🇬 bg · 🇧🇩 bn · 🇧🇦 bs · 🇨🇿 cs · 🇩🇪 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 · 🇸🇪 sv · 🇰🇪 sw · 🇮🇳 ta · 🇮🇳 te · 🇹🇭 th · 🇹🇷 tr · 🇺🇦 uk-UA · 🇵🇰 ur · 🇺🇿 uz · 🇻🇳 vi · 🇳🇬 yo · 🇨🇳 zh-CN · 🇹🇼 zh-TW
Kort fortalt: OmniRoutes komprimeringsmotor er udvidelig — du kan registrere brugerdefinerede motorer, levere sprogpakker til nye sprog og sammensætte stakkede pipelines. Denne vejledning viser hvordan.
Relaterede vejledninger:
- COMPRESSION_GUIDE.md — Fuld oversigt over pipelinen
- COMPRESSION_ENGINES.md — Motorregister og indbyggede motorer
- RTK_COMPRESSION.md — RTK-motor og brugerdefinerede filtre
- COMPRESSION_RULES_FORMAT.md — Reference til regelpakkens format
Oversigt
Komprimeringssystemet har 3 udvidelsespunkter:
| Udvidelsespunkt | Anvendelse | Sværhedsgrad |
|---|---|---|
| Brugerdefineret motor | Tilføj en helt ny komprimeringsalgoritme (f.eks. en domænespecifik opsummeringsfunktion) | Avanceret |
| Sprogpakke | Tilføj understøttelse af et nyt naturligt sprog (f.eks. hindi eller arabisk) | Middel |
| Stakket pipeline | Sammensæt eksisterende motorer i en brugerdefineret rækkefølge | Begynder |
┌─────────────────────────────────────────────────────────────┐
│ Komprimeringsstrategi │
│ │
│ Inputmeddelelser ──▶ getEffectiveMode() ──▶ tilstand │
│ │ │
│ ┌───────────────────────┼──────────┐ │
│ │ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │ │
│ "rtk" "lite" "standard" "stacked" │
│ │ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │ │
│ RTK Lite Caveman engines[] │
│ motor motor motor sammenkædet │
│ │ │ │ │ │ │
│ └─────────┴─────────┴─────────┘ │ │
│ │ │
│ ▼ │
│ Komprimeret output │
└─────────────────────────────────────────────────────────────┘
Strategivælgeren er TILSTANDSBASERET: Hver anmodning vælger ÉN tilstand
(rtk / lite / standard / aggressive / ultra / stacked / off).
Kun tilstanden "stacked" sammenkæder flere motorer sekventielt.
Standardtilstanden for automatisk aktivering er "lite" (ikke en prioriteringskæde med 3 niveauer).
Sådan skrives en brugerdefineret komprimeringsmotor
Motorgrænsefladen (open-sse/services/compression/engines/types.ts) er den kontrakt, som alle motorer skal opfylde. Den har 5 obligatoriske metoder.
Grænsefladen CompressionEngine
interface CompressionEngine {
id: string; // Unikt motor-id
name: string; // Vist navn
description: string; // Kort beskrivelse
icon: string; // Ikon (emoji eller URL)
targets: CompressionEngineTarget[]; // ["messages", "tool_results", "code_blocks"]
stackable: boolean; // Kan bruges i en stakket pipeline
stackPriority: number; // Rækkefølge i stakkede pipelines (lavere = tidligere)
metadata: CompressionEngineMetadata;
apply(body, options?): CompressionResult;
compress(body, config?): CompressionResult;
getConfigSchema(): EngineConfigField[];
validateConfig(config): EngineValidationResult;
}
Minimalt eksempel: Whitespace-motor
Den enklest mulige motor — fjern overflødige mellemrum fra meddelelser.
import type { CompressionEngine } from "omniroute/compression/engines/types";
import { registerCompressionEngine } from "omniroute/compression/engines/registry";
function preserveCodeBlocks(text: string): string {
// Opdel efter kodeblokmarkører, og bevar mellemrum i dem
const parts = text.split(/(```[\s\S]*?```)/);
return parts
.map((part) => {
if (part.startsWith("```")) {
return part; // Rediger ikke kodeblokke
}
return part.replace(/\n{3,}/g, "\n\n"); // Anvend kun på prosa
})
.join("");
}
const whitespaceEngine: CompressionEngine = {
id: "whitespace",
name: "Whitespace Stripper",
description: "Removes extra whitespace and blank lines",
icon: "📝",
targets: ["messages", "tool_results"],
stackable: true,
stackPriority: 100, // Kør EFTER caveman/rtk
metadata: {
id: "whitespace",
name: "Whitespace Stripper",
description: "Removes extra whitespace and blank lines",
inputScope: "messages",
targetLatencyMs: 5,
supportsPreview: true,
stable: true,
},
apply(body, options) {
return this.compress(body, options?.config);
},
compress(body, config = {}) {
let originalLength = 0;
let compressedLength = 0;
// Gennemløb beskedarrayet — håndter både streng- og multipart-indhold
const compressedBody = (body.messages || []).map((msg) => {
if (typeof msg.content === "string") {
originalLength += msg.content.length;
let compressed = msg.content
.replace(/[ \t]+/g, " ")
.replace(/\n{3,}/g, "\n\n")
.replace(/^\s+|\s+$/gm, "");
compressedLength += compressed.length;
return { ...msg, content: compressed };
}
// Multipart-indhold: gennemløb delene, og komprimer kun tekstdele
if (Array.isArray(msg.content)) {
const newParts = msg.content.map((part) => {
if (part.type === "text" && typeof part.text === "string") {
originalLength += part.text.length;
let compressed = part.text
.replace(/[ \t]+/g, " ")
.replace(/\n{3,}/g, "\n\n")
.replace(/^\s+|\s+$/gm, "");
compressedLength += compressed.length;
return { ...part, text: compressed };
}
return part; // Bevar image_url, tool_use osv.
});
return { ...msg, content: newParts };
}
return msg;
});
return {
body: { ...body, messages: compressedBody },
stats: {
originalTokens: Math.ceil(originalLength / 4),
compressedTokens: Math.ceil(compressedLength / 4),
savingsPercent: originalLength > 0 ? 100 * (1 - compressedLength / originalLength) : 0,
techniques: ["whitespace-collapse"],
engineId: "whitespace",
},
};
},
getConfigSchema() {
return [
{
key: "preserveCodeBlocks",
type: "boolean",
label: "Preserve code blocks",
defaultValue: true,
description: "Don't touch whitespace inside ```code``` blocks",
},
];
},
validateConfig(config) {
if (config.preserveCodeBlocks !== undefined && typeof config.preserveCodeBlocks !== "boolean") {
return { valid: false, errors: ["preserveCodeBlocks must be a boolean"] };
}
return { valid: true, errors: [] };
},
};
// Registrer globalt
registerCompressionEngine(whitespaceEngine);
Hvor brugerdefinerede engines skal placeres
~/.omniroute/compression/engines/my-engine.ts # Brugerniveau
<project>/compression-engines/my-engine.ts # Projektniveau (indlæses ved opstart)
Eller indlæs programmatisk fra et plugin:
// I dit plugin
import {
registerCompressionEngine,
unregisterCompressionEngine,
} from "@omniroute/open-sse/services/compression/engines/registry";
import { myEngine } from "./engines/my-engine";
export default definePlugin({
name: "my-compression-plugin",
// Plugin-SDK'et eksponerer onRequest-/onResponse-/onError-hooks. Registrer
// engine'en, når pluginmodulet indlæses (eller ved første onRequest); afregistrer den
// via din egen nedlukningsrutine.
onRequest: async (ctx) => {
registerCompressionEngine(myEngine);
},
});
// Ved nedlukning:
// unregisterCompressionEngine("my-engine");
Test af din engine
Registrer din engine i et plugin eller en opstartsfunktion. Når den er registreret, vil engine'en være tilgængelig
i strategivælgeren via dens id. Test integrationen ved at sammensætte den i en stablet pipeline:
Oprettelse af sprogpakker
Komprimering i hulemandsstil bruger sprogspecifikke regelpakker til at håndtere fyldord, forbehold og omstændelige formuleringer på hvert naturligt sprog. OmniRoute leveres med 6 sprogpakker: en, es, fr, de, ja, pt-BR.
Pakkestruktur
En sprogpakke er en mappe med JSON-filer under open-sse/services/compression/rules/<language>/:
open-sse/services/compression/rules/
├── en/
│ ├── filler.json # Høflighedsfraser, forbehold, høflighed
│ ├── context.json # Regler til reduktion af kontekst
│ ├── dedup.json # Regler for deduplikering
│ ├── structural.json # Tegnsætning, formatering
│ └── ultra.json # Aggressive komprimeringsregler
├── es/ (samme struktur)
├── fr/ (samme struktur)
├── de/ (samme struktur)
├── ja/ (samme struktur)
└── pt-BR/ (samme struktur)
Reglens opbygning
Hver regel har denne struktur (fra open-sse/services/compression/ruleLoader.ts):
interface FileRule {
name: string; // Menneskeligt læsbart navn (kebab-case)
pattern: string; // JavaScript-regexmønster
replacement?: string; // Det, som matchet skal erstattes med
replacementMap?: Record<string, string>; // ELLER et nøgle→erstatning-map
flags?: string; // Regex-flag (typisk "gi")
context?: "all" | "user" | "system" | "assistant";
category?: "filler" | "context" | "structural" | "dedup" | "terse" | "ultra";
minIntensity?: "lite" | "full" | "ultra"; // Spring over under denne intensitet
description?: string; // Dokumentation
}
Eksempel: Tilføjelse af hindi-regler for fyldord
{
"language": "hi",
"category": "filler",
"rules": [
{
"name": "polite_opener",
"pattern": "\\b(?:नमस्ते|नमस्कार|आदरणीय)\\b[,!\\s]*",
"replacement": "",
"context": "all",
"category": "filler",
"minIntensity": "lite",
"description": "Strip polite openers like 'नमस्ते'"
},
{
"name": "filler_actually",
"pattern": "\\b(?:असल में|वास्तव में|दरअसल)\\b\\s*",
"replacement": "",
"context": "all",
"category": "filler",
"minIntensity": "lite",
"description": "Strip 'actually' fillers"
},
{
"name": "verbose_plea",
"pattern": "\\b(?:कृपया|कृपया आप|अनुरोध है कि आप)\\b\\s*",
"replacement": "",
"context": "all",
"category": "filler",
"minIntensity": "full",
"description": "Strip 'please' in Hindi"
}
]
}
Validering
Regelpakker valideres mod _schema.json, når de indlæses. En pakke med en ugyldig struktur kan ikke indlæses og medfører, at der logges en fejl:
RULE_LOADER: pakken "hi/filler.json" kunne ikke valideres:
- rules.0.pattern: Ugyldigt regulært udtryk
- rules.1.context: skal være én af [all, user, system, assistant]
Valideringen kører automatisk, når en pakke indlæses (mod _schema.json); en
ugyldig pakke afvises, og ovenstående fejl logges. Der findes ikke et separat
npm run-script til validering af pakker — indlæs pakken (start f.eks. serveren,
eller kør komprimeringsforløbet), og hold øje med loggene.
Indlæsning af en brugerdefineret sprogpakke
import { loadRulePack } from "omniroute/compression/ruleLoader";
await loadRulePack("./my-custom-rules/hi/filler.json");
Eller placer den på en genkendt placering:
~/.omniroute/compression/rules/hi/filler.json # Brugerniveau
Bedste praksis for sprogpakker
- Start med
filler— disse regler har størst effekt - Brug
minIntensitytil at begrænse aggressive regler — det beskytter mod overkomprimering - Medtag testcases — tilføj et
tests[]-array i JSON-filen for at verificere adfærden - Rækkefølgen er vigtig — tidligere regler anvendes først; placer regler med stor effekt først
- Vær konservativ med
replacement— en tom streng er normalt korrekt; introducer aldrig nyt indhold
Oversættelsesstrategi
Når regelpakker lokaliseres til et nyt sprog:
- Oversæt regelnavnene — de vises i fejlfindingsoutputtet
- Tilpas regexmønstrene — direkte oversættelse fungerer ofte ikke (ordgrænser varierer)
- Test med virkelige samtaler — pakken skal være sikker at bruge på faktiske input
- Tilpas til kulturelle konventioner — japanske pakker har eksempelvis flere høflighedsrelaterede fyldord end engelske
Stablede pipelines
En stablet pipeline kører flere motorer sekventielt, hvor hver motors output sendes videre til den næste. Sådan fungerer mode: stacked internt.
Sådan fungerer stabling
Input (10.000 tokens)
│
▼
┌──────────┐
│ Motor │ prioritet 10
│ A │ ──▶ output: 6.000 tokens (-40 %)
└────┬─────┘
▼
┌──────────┐
│ Motor │ prioritet 50
│ B │ ──▶ output: 2.400 tokens (-60 %)
└────┬─────┘
▼
┌──────────┐
│ Motor │ prioritet 100
│ C │ ──▶ output: 1.200 tokens (-80 %)
└────┬─────┘
│
▼
Endeligt output (1.200 tokens, ~88 % samlet besparelse)
Når mode: "stacked" er valgt, udføres motorerne sekventielt i den rækkefølge, der er angivet i pipeline-arrayet.
Outputtet fra motor N bliver inputtet til motor N+1.
Komprimeringstilstande
OmniRoute vælger ÉN tilstand pr. anmodning baseret på konfiguration, tærskler for automatisk aktivering og kombinationstilsidesættelser.
De tilgængelige tilstande er defineret i open-sse/services/compression/types.ts (typen CompressionMode):
| Tilstand | Motorer | Anvendelse |
|---|---|---|
off |
Ingen | Deaktivér al komprimering |
rtk |
Kun RTK | Sessioner med meget kommandooutput (80 %+ besparelse) |
lite |
Kun Lite | Konservativ komprimering (hurtig og sikker) |
standard |
Caveman | Komprimering af prosa med sprogpakker |
aggressive |
Caveman + Aggressive | Aggressiv komprimering af prosa + aggressiv afsluttende behandling |
ultra |
Ultra | Maksimal komprimering (med tab, sidste udvej). Kan valgfrit sendes gennem LLMLingua-2 SLM-motoren, når ultra.modelPath er angivet (falder tilbage til den regelbaserede metode, når modellen ikke er tilgængelig). |
stacked |
Tilpasset pipeline | Kombiner motorer i vilkårlig rækkefølge (se nedenfor) |
Ud over ovenstående tilstandsmotorer indeholder registreringsdatabasen også specialiserede motorer, der kan stables — CCR, headroom, ionizer og session-dedup — som er dokumenteret i COMPRESSION_ENGINES.md.
Valget af tilstand bestemmes af getEffectiveMode() i open-sse/services/compression/strategySelector.ts:
- Hvis komprimering er deaktiveret:
"off" - Hvis der findes en kombinationstilsidesættelse: Brug tilsidesættelsen
- Hvis tærsklen for automatisk aktivering overskrides: Brug
autoTriggerMode(standard:"lite") - Ellers: Brug
defaultMode
Den stablede standardpipeline
Når mode: "stacked" er eksplicit konfigureret, kombinerer standardpipeline følgende:
- RTK — fjerner støj fra kommandooutput (~80 % besparelse på terminaloutput)
- Caveman — fjerner fyldord og gør prosaen mere kortfattet (~46 % af den resterende tekst)
- Lite — afsluttende behandling af mellemrum + fjernelse af dubletter
Denne kombination opnår 78-95 % besparelse i sessioner med omfattende brug af værktøjer.
Konfiguration af stablede pipelines
I kombinationskonfigurationen:
{
"compression": {
"mode": "stacked",
"pipeline": [
{ "engine": "rtk", "config": { "intensity": "aggressive" } },
{ "engine": "caveman", "config": { "intensity": "full" } },
{ "engine": "lite", "config": {} }
]
}
}
Du kan udelade motorer, tilføje tilpassede motorer eller ændre deres rækkefølge.
Videregivelse af tilstand
Motorer kan læse metadata fra anmodningskonteksten (i options):
compress(body, config) {
// Læs metadata fra tidligere motorer
const original = options?.compressionComboId; // "my-coding-combo"
// ...
}
Metadataene er skrivebeskyttede — motorerne kan ikke ændre anmodningskonteksten, kun deres eget body-output.
Faldgruber ved udførelsesrækkefølgen
| Motorrækkefølge | Effekt |
|---|---|
| RTK → Caveman → Lite | Anbefalet (fjerner først støj, derefter overflødigt sprog og til sidst mellemrum) |
| Lite → RTK → Caveman | Dårlig — Lite fjerner mellemrum fra råt output, så RTK's mønstermatching mislykkes |
| Caveman → RTK | Dårlig — Caveman kan omskrive tekst på måder, som RTK ikke genkender |
Vilkårlig rækkefølge med tool_results først |
Bedre — værktøjsoutput er det mest støjende indhold |
Hvornår du IKKE bør stable
Stabling er ikke altid bedre:
- Enkle beskeder (intet værktøjsoutput) — Caveman eller Lite alene er tilstrækkelig
- Omkostningsfølsomme scenarier — hver motor tilføjer ~5-50 ms latenstid
- Specifikke værktøjer — RTK alene er normalt tilstrækkelig til shell-output
Opbygning af en tilpasset pipeline
Der findes ikke noget register over navngivne pipelines. En stablet pipeline er blot et indlejret array
af trin, der overføres til applyStackedCompression() (eksporteret fra
@omniroute/open-sse/services/compression/strategySelector):
import { applyStackedCompression } from "@omniroute/open-sse/services/compression/strategySelector";
const result = applyStackedCompression(body, [
{ engine: "rtk", intensity: "aggressive" },
{ engine: "caveman", intensity: "full" },
]);
Når du ikke angiver en pipeline, bruges rtk(standard) → caveman(full) som standard.
For at styre den via konfiguration skal du indstille mode: "stacked" og angive arrayet af trin under
stackedPipeline (læses fra config.stackedPipeline):
{
"compression": {
"mode": "stacked",
"stackedPipeline": [
{ "engine": "rtk", "intensity": "aggressive" },
{ "engine": "caveman", "intensity": "full" }
]
}
}
Politik for synkronisering med upstream
OmniRoutes komprimeringsmotorer krediterer flere upstream-projekter i README ("inspireret af RTK, Caveman, LLMLingua-2, Troglodita"). Et almindeligt spørgsmål fra bidragydere er: Når upstream-RTK tilføjer et nyt værktøjsfilter, eller Caveman tilføjer en regelpakke, hvordan når det så frem til OmniRoute? Dette afsnit er det autoritative svar.
Leverandørkopier kontra uafhængige implementeringer
| Motor | Forhold til upstream | Placering |
|---|---|---|
| RTK | Uafhængig genimplementering (inspireret af, ikke en kopi) | open-sse/services/compression/engines/rtk/ |
| Caveman | Uafhængig genimplementering (inspireret af) | open-sse/services/compression/engines/cavemanAdapter.ts |
| Headroom | Primært intern; kun gcf/-codec'et er reelt leverandørkopieret fra gcf-typescript (MIT, SPDX-markeret, kun generisk profil) |
open-sse/services/compression/engines/headroom/gcf/ |
| LLMLingua-2 / Troglodita | Inspireret af (danner grundlag for motorerne llmlingua + session-dedup) |
open-sse/services/compression/engines/llmlingua/, session-dedup |
Vigtigt: RTK og Caveman er clean-room-TypeScript-implementeringer af
idéerne (filterregler, regelpakker), ikke leverandørkopierede kildetræer. Der
findes ingen upstream-kopi at køre git pull fra — hvilket netop er grunden til,
at README siger "inspireret af" i stedet for "inkluderet".
Sådan flettes upstream-forbedringer ind
Der er ingen automatisk sporing af upstream-udgivelser og ingen
compression-sync-etiket — helt bevidst. Fordi motorerne er
genimplementeringer, flettes et upstream-RTK-filter eller en Caveman-regelpakke
ikke ind som kode; det udtrykkes på ny som en ny regel eller et nyt filter i
OmniRoutes eget format (se
COMPRESSION_RULES_FORMAT.md) og indarbejdes ad
hoc via en almindelig PR. Udvidelsespunkterne ovenfor (brugerdefineret motor,
sprogpakke, RTK-filter) er den godkendte måde at bidrage med et sådant element på.
Nylige eksempler på netop dette forløb:
- RTK-filtre til build-output fra Gradle og
dotnet(v3.8.42) - RTK-filtre til kubectl / docker-build / composer / gh (#2824)
- Caveman-sprogpakke til indonesisk (#3975) samt pakker til tysk / fransk / japansk / kinesisk
Headroom (proxy til inputkomprimering)
Headroom er fuldt ud intern — et fastlåst leverandørkopieret snapshot af
gcf-codec'et plus OmniRoutes egne smartcrusher- / toon- / tabular-lag.
Der er ingen aktiv upstream at spore ud over leverandørkopien; opdateringer til
gcf opdateres manuelt, når codec'et ændres, og valideres igen i forhold til
kontrollen af komprimeringsbudgettet (check:compression-budget).
Forslag til en upstream-inspireret forbedring
- Opret ikke en leverandørkopi — udtryk upstream-reglen eller -filteret på ny i OmniRoutes format.
- Tilføj det via det tilsvarende udvidelsespunkt nedenfor (sprogpakke, RTK-filter eller brugerdefineret motor).
- Henvis til upstream-projektet i PR-beskrivelsen (kreditering) i stedet for at kopiere dets licensomfattede kildekode.
- Medtag tests, og bekræft, at kontrollen
check:compression-budgetstadig gennemføres.
Tilføjelse af en outputstil
Outputstile (se guidens katalogtabel)
er modsvarigheden på outputsiden til inputmotorerne: I stedet for at komprimere det, du
sender, instruerer de modellen i at producere billigere output. Registret er
OUTPUT_STYLE_CATALOG i open-sse/services/compression/outputStyles/catalog.ts, og
én katalogpost udgør hele funktionen: injektoren, indstillingspanelet i dashboardet,
persistens og telemetri gennemgår alle kataloget — der er ingen anden liste, der skal opdateres.
- Tilføj én post til
OUTPUT_STYLE_CATALOGmedid,label,descriptionog de tre engelskelevels(lite,full,ultra). Hvert niveau skal slutte med${SHARED_BOUNDARIES}, så kode, stier, kommandoer, fejl og URL'er forbliver ordrette. Instruktionsteksten skal være statisk og deterministisk for hver(id, level, language)—${SHARED_BOUNDARIES}er den eneste tilladte interpolation. - Oversæt den. Medtag som minimum en
pt-BR-blok underi18n;ponytailogi-have-adhd(en, pt-BR, es, de, fr, it, ru, zh, ja, id, vi) er referencestrukturen. En bevidst enkeltsproget stil angiver i stedetlocale(somterse-cjk→zh) og tilbydes derefter kun under den pågældende landestandard. - Opdater matrixkontrollen — føj stilens sprog til
BASELINE_LANGUAGESitests/unit/compression/output-styles-i18n-matrix.test.ts. Kontrollen afviser enhver ny stil, der ikke er begrænset af en landestandard, og som mangler de påkrævede oversættelser, medmindre den har en eksplicitKNOWN_ENGLISH_ONLY-post med en sporingsopgave. - Tilføj en test pr. stil baseret på
tests/unit/compression/i-have-adhd-catalog.test.ts: katalogstruktur, grænseklausul pr. niveau og en kontrol, der bekræfter, at hver oversættelse er skrevet på sit eget sprog frem for at være kopieret fra engelsk. - Kreditering: Hvis stilen er tilpasset fra et eksternt projekt, skal det krediteres i en
kildekommentar ved posten (f.eks.
i-have-adhd→ ayghri/i-have-adhd, MIT) — samme regel som i "Forslag til en upstream-inspireret forbedring" ovenfor.
Der er ikke behov for ændringer af brugergrænsefladen, skemaet eller telemetrien — disse flader gengives ud fra kataloget.
Bedste praksis
Udvikling af motorer
- Implementer altid
validateConfig— motorer uden validering medfører skjulte fejl - Angiv en realistisk
targetLatencyMs— bruges af strategivælgeren til at vælge motorer - Brug
getConfigSchematil dashboardet — skjul aldrig konfigurationen for brugerne - Understøt
stackable: true, hvis din motor er ren — motorer med bivirkninger bør ikke stables - Skriv indlejrede tests — motorer skal kunne verificeres på <1s
Udvikling af sprogpakker
- Start med intensiteten
lite— dine regler bør være sikre ved den laveste indstilling - Brug
contexttil at afgrænse regler — regler, der kun gælder foruser, kan ikke utilsigtet påvirke systemprompter - Undgå at matche JSON-nøgler —
\\bword\\bkan matche inde i JSON og ødelægge strukturerede data - Test med grænsetilfælde — tomt input, Unicode, RTL-tekst og emojis
- Brug eksisterende pakker som skabeloner —
en/filler.jsoner det mest veludviklede eksempel
Design af pipelines
- Profilér før optimering — mål først med
compression_stats - Foretræk komposition frem for genimplementering — udvid Caveman-regler, før du skriver en ny motor
- Dokumentér begrundelsen for rækkefølgen — kommentér, hvorfor motor A kommer før motor B
- Test ved alle 3 intensitetsniveauer —
liteer hurtig, men upræcis;ultraer langsom, men præcis
Reference: Indbyggede engines
| Engine-ID | Kan stables | Standard-stackPriority | Mål |
|---|---|---|---|
lite |
Ja | 5 | beskeder, værktøjsresultater |
rtk |
Ja | 10 | værktøjsresultater |
standard (caveman) |
Ja | 20 | beskeder, værktøjsresultater, kodeblokke |
aggressive |
Ja | 30 | beskeder |
ultra |
Ja | 40 | beskeder, kodeblokke |
Se også
- COMPRESSION_GUIDE.md — Oversigt over pipelinen
- COMPRESSION_ENGINES.md — Reference til engine-registret
- COMPRESSION_RULES_FORMAT.md — Specifikation af regelformatet
- COMPRESSION_LANGUAGE_PACKS.md — Detaljer om sprogpakker
- RTK_COMPRESSION.md — RTK-engine og brugerdefinerede filtre
- Kilde:
open-sse/services/compression/(117 filer, ~250 KB)